claude-flow-novice 2.2.3 → 2.2.5

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/platform/contextkey/common/contextkeys.js

@@ -0,0 +1,18 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { isIOS, isLinux, isMacintosh, isMobile, isWeb, isWindows } from '../../../base/common/platform.js';
+import { localize } from '../../../nls.js';
+import { RawContextKey } from './contextkey.js';
+export const IsMacContext = new RawContextKey('isMac', isMacintosh, localize('isMac', "Whether the operating system is macOS"));
+export const IsLinuxContext = new RawContextKey('isLinux', isLinux, localize('isLinux', "Whether the operating system is Linux"));
+export const IsWindowsContext = new RawContextKey('isWindows', isWindows, localize('isWindows', "Whether the operating system is Windows"));
+export const IsWebContext = new RawContextKey('isWeb', isWeb, localize('isWeb', "Whether the platform is a web browser"));
+export const IsMacNativeContext = new RawContextKey('isMacNative', isMacintosh && !isWeb, localize('isMacNative', "Whether the operating system is macOS on a non-browser platform"));
+export const IsIOSContext = new RawContextKey('isIOS', isIOS, localize('isIOS', "Whether the operating system is iOS"));
+export const IsMobileContext = new RawContextKey('isMobile', isMobile, localize('isMobile', "Whether the platform is a mobile web browser"));
+export const IsDevelopmentContext = new RawContextKey('isDevelopment', false, true);
+export const ProductQualityContext = new RawContextKey('productQualityType', '', localize('productQualityType', "Quality type of VS Code"));
+export const InputFocusedContextKey = 'inputFocus';
+export const InputFocusedContext = new RawContextKey(InputFocusedContextKey, false, localize('inputFocus', "Whether keyboard focus is inside an input box"));

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/platform/contextview/browser/contextMenuHandler.js

@@ -0,0 +1,124 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { $, addDisposableListener, EventType, getActiveElement, getWindow, isAncestor } from '../../../base/browser/dom.js';
+import { StandardMouseEvent } from '../../../base/browser/mouseEvent.js';
+import { Menu } from '../../../base/browser/ui/menu/menu.js';
+import { ActionRunner } from '../../../base/common/actions.js';
+import { isCancellationError } from '../../../base/common/errors.js';
+import { combinedDisposable, DisposableStore } from '../../../base/common/lifecycle.js';
+import { defaultMenuStyles } from '../../theme/browser/defaultStyles.js';
+export class ContextMenuHandler {
+    constructor(contextViewService, telemetryService, notificationService, keybindingService) {
+        this.contextViewService = contextViewService;
+        this.telemetryService = telemetryService;
+        this.notificationService = notificationService;
+        this.keybindingService = keybindingService;
+        this.focusToReturn = null;
+        this.lastContainer = null;
+        this.block = null;
+        this.blockDisposable = null;
+        this.options = { blockMouse: true };
+    }
+    configure(options) {
+        this.options = options;
+    }
+    showContextMenu(delegate) {
+        const actions = delegate.getActions();
+        if (!actions.length) {
+            return; // Don't render an empty context menu
+        }
+        this.focusToReturn = getActiveElement();
+        let menu;
+        const shadowRootElement = delegate.domForShadowRoot instanceof HTMLElement ? delegate.domForShadowRoot : undefined;
+        this.contextViewService.showContextView({
+            getAnchor: () => delegate.getAnchor(),
+            canRelayout: false,
+            anchorAlignment: delegate.anchorAlignment,
+            anchorAxisAlignment: delegate.anchorAxisAlignment,
+            render: (container) => {
+                var _a;
+                this.lastContainer = container;
+                const className = delegate.getMenuClassName ? delegate.getMenuClassName() : '';
+                if (className) {
+                    container.className += ' ' + className;
+                }
+                // Render invisible div to block mouse interaction in the rest of the UI
+                if (this.options.blockMouse) {
+                    this.block = container.appendChild($('.context-view-block'));
+                    this.block.style.position = 'fixed';
+                    this.block.style.cursor = 'initial';
+                    this.block.style.left = '0';
+                    this.block.style.top = '0';
+                    this.block.style.width = '100%';
+                    this.block.style.height = '100%';
+                    this.block.style.zIndex = '-1';
+                    (_a = this.blockDisposable) === null || _a === void 0 ? void 0 : _a.dispose();
+                    this.blockDisposable = addDisposableListener(this.block, EventType.MOUSE_DOWN, e => e.stopPropagation());
+                }
+                const menuDisposables = new DisposableStore();
+                const actionRunner = delegate.actionRunner || new ActionRunner();
+                actionRunner.onWillRun(evt => this.onActionRun(evt, !delegate.skipTelemetry), this, menuDisposables);
+                actionRunner.onDidRun(this.onDidActionRun, this, menuDisposables);
+                menu = new Menu(container, actions, {
+                    actionViewItemProvider: delegate.getActionViewItem,
+                    context: delegate.getActionsContext ? delegate.getActionsContext() : null,
+                    actionRunner,
+                    getKeyBinding: delegate.getKeyBinding ? delegate.getKeyBinding : action => this.keybindingService.lookupKeybinding(action.id)
+                }, defaultMenuStyles);
+                menu.onDidCancel(() => this.contextViewService.hideContextView(true), null, menuDisposables);
+                menu.onDidBlur(() => this.contextViewService.hideContextView(true), null, menuDisposables);
+                const targetWindow = getWindow(container);
+                menuDisposables.add(addDisposableListener(targetWindow, EventType.BLUR, () => this.contextViewService.hideContextView(true)));
+                menuDisposables.add(addDisposableListener(targetWindow, EventType.MOUSE_DOWN, (e) => {
+                    if (e.defaultPrevented) {
+                        return;
+                    }
+                    const event = new StandardMouseEvent(targetWindow, e);
+                    let element = event.target;
+                    // Don't do anything as we are likely creating a context menu
+                    if (event.rightButton) {
+                        return;
+                    }
+                    while (element) {
+                        if (element === container) {
+                            return;
+                        }
+                        element = element.parentElement;
+                    }
+                    this.contextViewService.hideContextView(true);
+                }));
+                return combinedDisposable(menuDisposables, menu);
+            },
+            focus: () => {
+                menu === null || menu === void 0 ? void 0 : menu.focus(!!delegate.autoSelectFirstItem);
+            },
+            onHide: (didCancel) => {
+                var _a, _b, _c;
+                (_a = delegate.onHide) === null || _a === void 0 ? void 0 : _a.call(delegate, !!didCancel);
+                if (this.block) {
+                    this.block.remove();
+                    this.block = null;
+                }
+                (_b = this.blockDisposable) === null || _b === void 0 ? void 0 : _b.dispose();
+                this.blockDisposable = null;
+                if (!!this.lastContainer && (getActiveElement() === this.lastContainer || isAncestor(getActiveElement(), this.lastContainer))) {
+                    (_c = this.focusToReturn) === null || _c === void 0 ? void 0 : _c.focus();
+                }
+                this.lastContainer = null;
+            }
+        }, shadowRootElement, !!shadowRootElement);
+    }
+    onActionRun(e, logTelemetry) {
+        if (logTelemetry) {
+            this.telemetryService.publicLog2('workbenchActionExecuted', { id: e.action.id, from: 'contextMenu' });
+        }
+        this.contextViewService.hideContextView(false);
+    }
+    onDidActionRun(e) {
+        if (e.error && !isCancellationError(e.error)) {
+            this.notificationService.error(e.error);
+        }
+    }
+}

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/platform/contextview/browser/contextMenuService.js

@@ -0,0 +1,101 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { ModifierKeyEmitter } from '../../../base/browser/dom.js';
+import { Separator } from '../../../base/common/actions.js';
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { createAndFillInContextMenuActions } from '../../actions/browser/menuEntryActionViewItem.js';
+import { IMenuService, MenuId } from '../../actions/common/actions.js';
+import { IContextKeyService } from '../../contextkey/common/contextkey.js';
+import { IKeybindingService } from '../../keybinding/common/keybinding.js';
+import { INotificationService } from '../../notification/common/notification.js';
+import { ITelemetryService } from '../../telemetry/common/telemetry.js';
+import { ContextMenuHandler } from './contextMenuHandler.js';
+import { IContextViewService } from './contextView.js';
+let ContextMenuService = class ContextMenuService extends Disposable {
+    get contextMenuHandler() {
+        if (!this._contextMenuHandler) {
+            this._contextMenuHandler = new ContextMenuHandler(this.contextViewService, this.telemetryService, this.notificationService, this.keybindingService);
+        }
+        return this._contextMenuHandler;
+    }
+    constructor(telemetryService, notificationService, contextViewService, keybindingService, menuService, contextKeyService) {
+        super();
+        this.telemetryService = telemetryService;
+        this.notificationService = notificationService;
+        this.contextViewService = contextViewService;
+        this.keybindingService = keybindingService;
+        this.menuService = menuService;
+        this.contextKeyService = contextKeyService;
+        this._contextMenuHandler = undefined;
+        this._onDidShowContextMenu = this._store.add(new Emitter());
+        this._onDidHideContextMenu = this._store.add(new Emitter());
+    }
+    configure(options) {
+        this.contextMenuHandler.configure(options);
+    }
+    // ContextMenu
+    showContextMenu(delegate) {
+        delegate = ContextMenuMenuDelegate.transform(delegate, this.menuService, this.contextKeyService);
+        this.contextMenuHandler.showContextMenu({
+            ...delegate,
+            onHide: (didCancel) => {
+                var _a;
+                (_a = delegate.onHide) === null || _a === void 0 ? void 0 : _a.call(delegate, didCancel);
+                this._onDidHideContextMenu.fire();
+            }
+        });
+        ModifierKeyEmitter.getInstance().resetKeyStatus();
+        this._onDidShowContextMenu.fire();
+    }
+};
+ContextMenuService = __decorate([
+    __param(0, ITelemetryService),
+    __param(1, INotificationService),
+    __param(2, IContextViewService),
+    __param(3, IKeybindingService),
+    __param(4, IMenuService),
+    __param(5, IContextKeyService)
+], ContextMenuService);
+export { ContextMenuService };
+export var ContextMenuMenuDelegate;
+(function (ContextMenuMenuDelegate) {
+    function is(thing) {
+        return thing && thing.menuId instanceof MenuId;
+    }
+    function transform(delegate, menuService, globalContextKeyService) {
+        if (!is(delegate)) {
+            return delegate;
+        }
+        const { menuId, menuActionOptions, contextKeyService } = delegate;
+        return {
+            ...delegate,
+            getActions: () => {
+                const target = [];
+                if (menuId) {
+                    const menu = menuService.createMenu(menuId, contextKeyService !== null && contextKeyService !== void 0 ? contextKeyService : globalContextKeyService);
+                    createAndFillInContextMenuActions(menu, menuActionOptions, target);
+                    menu.dispose();
+                }
+                if (!delegate.getActions) {
+                    return target;
+                }
+                else {
+                    return Separator.join(delegate.getActions(), target);
+                }
+            }
+        };
+    }
+    ContextMenuMenuDelegate.transform = transform;
+})(ContextMenuMenuDelegate || (ContextMenuMenuDelegate = {}));

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/platform/contextview/browser/contextView.js

@@ -0,0 +1,7 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+export const IContextViewService = createDecorator('contextViewService');
+export const IContextMenuService = createDecorator('contextMenuService');

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/platform/contextview/browser/contextViewService.js

@@ -0,0 +1,72 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { ContextView } from '../../../base/browser/ui/contextview/contextview.js';
+import { Disposable, toDisposable } from '../../../base/common/lifecycle.js';
+import { ILayoutService } from '../../layout/browser/layoutService.js';
+import { getWindow } from '../../../base/browser/dom.js';
+let ContextViewService = class ContextViewService extends Disposable {
+    constructor(layoutService) {
+        super();
+        this.layoutService = layoutService;
+        this.currentViewDisposable = Disposable.None;
+        this.contextView = this._register(new ContextView(this.layoutService.mainContainer, 1 /* ContextViewDOMPosition.ABSOLUTE */));
+        this.layout();
+        this._register(layoutService.onDidLayoutContainer(() => this.layout()));
+    }
+    // ContextView
+    showContextView(delegate, container, shadowRoot) {
+        let domPosition;
+        if (container) {
+            if (container === this.layoutService.getContainer(getWindow(container))) {
+                domPosition = 1 /* ContextViewDOMPosition.ABSOLUTE */;
+            }
+            else if (shadowRoot) {
+                domPosition = 3 /* ContextViewDOMPosition.FIXED_SHADOW */;
+            }
+            else {
+                domPosition = 2 /* ContextViewDOMPosition.FIXED */;
+            }
+        }
+        else {
+            domPosition = 1 /* ContextViewDOMPosition.ABSOLUTE */;
+        }
+        this.contextView.setContainer(container !== null && container !== void 0 ? container : this.layoutService.activeContainer, domPosition);
+        this.contextView.show(delegate);
+        const disposable = toDisposable(() => {
+            if (this.currentViewDisposable === disposable) {
+                this.hideContextView();
+            }
+        });
+        this.currentViewDisposable = disposable;
+        return disposable;
+    }
+    getContextViewElement() {
+        return this.contextView.getViewElement();
+    }
+    layout() {
+        this.contextView.layout();
+    }
+    hideContextView(data) {
+        this.contextView.hide(data);
+    }
+    dispose() {
+        super.dispose();
+        this.currentViewDisposable.dispose();
+        this.currentViewDisposable = Disposable.None;
+    }
+};
+ContextViewService = __decorate([
+    __param(0, ILayoutService)
+], ContextViewService);
+export { ContextViewService };

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/platform/dialogs/common/dialogs.js

@@ -0,0 +1,2 @@
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+export const IDialogService = createDecorator('dialogService');

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/platform/dnd/browser/dnd.js

@@ -0,0 +1,36 @@
+import { Registry } from '../../registry/common/platform.js';
+//#region Editor / Resources DND
+export const CodeDataTransfers = {
+    EDITORS: 'CodeEditors',
+    FILES: 'CodeFiles'
+};
+class DragAndDropContributionRegistry {
+}
+export const Extensions = {
+    DragAndDropContribution: 'workbench.contributions.dragAndDrop'
+};
+Registry.add(Extensions.DragAndDropContribution, new DragAndDropContributionRegistry());
+//#endregion
+//#region DND Utilities
+/**
+ * A singleton to store transfer data during drag & drop operations that are only valid within the application.
+ */
+export class LocalSelectionTransfer {
+    constructor() {
+        // protect against external instantiation
+    }
+    static getInstance() {
+        return LocalSelectionTransfer.INSTANCE;
+    }
+    hasData(proto) {
+        return proto && proto === this.proto;
+    }
+    getData(proto) {
+        if (this.hasData(proto)) {
+            return this.data;
+        }
+        return undefined;
+    }
+}
+LocalSelectionTransfer.INSTANCE = new LocalSelectionTransfer();
+//#endregion

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/platform/editor/common/editor.js

@@ -0,0 +1,17 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+export var EditorOpenSource;
+(function (EditorOpenSource) {
+    /**
+     * Default: the editor is opening via a programmatic call
+     * to the editor service API.
+     */
+    EditorOpenSource[EditorOpenSource["API"] = 0] = "API";
+    /**
+     * Indicates that a user action triggered the opening, e.g.
+     * via mouse or keyboard use.
+     */
+    EditorOpenSource[EditorOpenSource["USER"] = 1] = "USER";
+})(EditorOpenSource || (EditorOpenSource = {}));

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/platform/environment/common/environment.js

@@ -0,0 +1,2 @@
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+export const IEnvironmentService = createDecorator('environmentService');

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/platform/extensions/common/extensions.js

@@ -0,0 +1,47 @@
+/**
+ * **!Do not construct directly!**
+ *
+ * **!Only static methods because it gets serialized!**
+ *
+ * This represents the "canonical" version for an extension identifier. Extension ids
+ * have to be case-insensitive (due to the marketplace), but we must ensure case
+ * preservation because the extension API is already public at this time.
+ *
+ * For example, given an extension with the publisher `"Hello"` and the name `"World"`,
+ * its canonical extension identifier is `"Hello.World"`. This extension could be
+ * referenced in some other extension's dependencies using the string `"hello.world"`.
+ *
+ * To make matters more complicated, an extension can optionally have an UUID. When two
+ * extensions have the same UUID, they are considered equal even if their identifier is different.
+ */
+export class ExtensionIdentifier {
+    constructor(value) {
+        this.value = value;
+        this._lower = value.toLowerCase();
+    }
+    /**
+     * Gives the value by which to index (for equality).
+     */
+    static toKey(id) {
+        if (typeof id === 'string') {
+            return id.toLowerCase();
+        }
+        return id._lower;
+    }
+}
+export class ExtensionIdentifierSet {
+    constructor(iterable) {
+        this._set = new Set();
+        if (iterable) {
+            for (const value of iterable) {
+                this.add(value);
+            }
+        }
+    }
+    add(id) {
+        this._set.add(ExtensionIdentifier.toKey(id));
+    }
+    has(id) {
+        return this._set.has(ExtensionIdentifier.toKey(id));
+    }
+}

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/platform/files/common/files.js

@@ -0,0 +1,9 @@
+//#endregion
+//#region Utilities
+export var FileKind;
+(function (FileKind) {
+    FileKind[FileKind["FILE"] = 0] = "FILE";
+    FileKind[FileKind["FOLDER"] = 1] = "FOLDER";
+    FileKind[FileKind["ROOT_FOLDER"] = 2] = "ROOT_FOLDER";
+})(FileKind || (FileKind = {}));
+//#endregion

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/platform/history/browser/contextScopedHistoryWidget.js

@@ -0,0 +1,105 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { FindInput } from '../../../base/browser/ui/findinput/findInput.js';
+import { ReplaceInput } from '../../../base/browser/ui/findinput/replaceInput.js';
+import { ContextKeyExpr, IContextKeyService, RawContextKey } from '../../contextkey/common/contextkey.js';
+import { KeybindingsRegistry } from '../../keybinding/common/keybindingsRegistry.js';
+import { localize } from '../../../nls.js';
+import { DisposableStore, toDisposable } from '../../../base/common/lifecycle.js';
+import { isActiveElement } from '../../../base/browser/dom.js';
+export const historyNavigationVisible = new RawContextKey('suggestWidgetVisible', false, localize('suggestWidgetVisible', "Whether suggestion are visible"));
+const HistoryNavigationWidgetFocusContext = 'historyNavigationWidgetFocus';
+const HistoryNavigationForwardsEnablementContext = 'historyNavigationForwardsEnabled';
+const HistoryNavigationBackwardsEnablementContext = 'historyNavigationBackwardsEnabled';
+let lastFocusedWidget = undefined;
+const widgets = [];
+export function registerAndCreateHistoryNavigationContext(scopedContextKeyService, widget) {
+    if (widgets.includes(widget)) {
+        throw new Error('Cannot register the same widget multiple times');
+    }
+    widgets.push(widget);
+    const disposableStore = new DisposableStore();
+    const historyNavigationWidgetFocus = new RawContextKey(HistoryNavigationWidgetFocusContext, false).bindTo(scopedContextKeyService);
+    const historyNavigationForwardsEnablement = new RawContextKey(HistoryNavigationForwardsEnablementContext, true).bindTo(scopedContextKeyService);
+    const historyNavigationBackwardsEnablement = new RawContextKey(HistoryNavigationBackwardsEnablementContext, true).bindTo(scopedContextKeyService);
+    const onDidFocus = () => {
+        historyNavigationWidgetFocus.set(true);
+        lastFocusedWidget = widget;
+    };
+    const onDidBlur = () => {
+        historyNavigationWidgetFocus.set(false);
+        if (lastFocusedWidget === widget) {
+            lastFocusedWidget = undefined;
+        }
+    };
+    // Check for currently being focused
+    if (isActiveElement(widget.element)) {
+        onDidFocus();
+    }
+    disposableStore.add(widget.onDidFocus(() => onDidFocus()));
+    disposableStore.add(widget.onDidBlur(() => onDidBlur()));
+    disposableStore.add(toDisposable(() => {
+        widgets.splice(widgets.indexOf(widget), 1);
+        onDidBlur();
+    }));
+    return {
+        historyNavigationForwardsEnablement,
+        historyNavigationBackwardsEnablement,
+        dispose() {
+            disposableStore.dispose();
+        }
+    };
+}
+let ContextScopedFindInput = class ContextScopedFindInput extends FindInput {
+    constructor(container, contextViewProvider, options, contextKeyService) {
+        super(container, contextViewProvider, options);
+        const scopedContextKeyService = this._register(contextKeyService.createScoped(this.inputBox.element));
+        this._register(registerAndCreateHistoryNavigationContext(scopedContextKeyService, this.inputBox));
+    }
+};
+ContextScopedFindInput = __decorate([
+    __param(3, IContextKeyService)
+], ContextScopedFindInput);
+export { ContextScopedFindInput };
+let ContextScopedReplaceInput = class ContextScopedReplaceInput extends ReplaceInput {
+    constructor(container, contextViewProvider, options, contextKeyService, showReplaceOptions = false) {
+        super(container, contextViewProvider, showReplaceOptions, options);
+        const scopedContextKeyService = this._register(contextKeyService.createScoped(this.inputBox.element));
+        this._register(registerAndCreateHistoryNavigationContext(scopedContextKeyService, this.inputBox));
+    }
+};
+ContextScopedReplaceInput = __decorate([
+    __param(3, IContextKeyService)
+], ContextScopedReplaceInput);
+export { ContextScopedReplaceInput };
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'history.showPrevious',
+    weight: 200 /* KeybindingWeight.WorkbenchContrib */,
+    when: ContextKeyExpr.and(ContextKeyExpr.has(HistoryNavigationWidgetFocusContext), ContextKeyExpr.equals(HistoryNavigationBackwardsEnablementContext, true), ContextKeyExpr.not('isComposing'), historyNavigationVisible.isEqualTo(false)),
+    primary: 16 /* KeyCode.UpArrow */,
+    secondary: [512 /* KeyMod.Alt */ | 16 /* KeyCode.UpArrow */],
+    handler: (accessor) => {
+        lastFocusedWidget === null || lastFocusedWidget === void 0 ? void 0 : lastFocusedWidget.showPreviousValue();
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'history.showNext',
+    weight: 200 /* KeybindingWeight.WorkbenchContrib */,
+    when: ContextKeyExpr.and(ContextKeyExpr.has(HistoryNavigationWidgetFocusContext), ContextKeyExpr.equals(HistoryNavigationForwardsEnablementContext, true), ContextKeyExpr.not('isComposing'), historyNavigationVisible.isEqualTo(false)),
+    primary: 18 /* KeyCode.DownArrow */,
+    secondary: [512 /* KeyMod.Alt */ | 18 /* KeyCode.DownArrow */],
+    handler: (accessor) => {
+        lastFocusedWidget === null || lastFocusedWidget === void 0 ? void 0 : lastFocusedWidget.showNextValue();
+    }
+});

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/platform/instantiation/common/descriptors.js

@@ -0,0 +1,11 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+export class SyncDescriptor {
+    constructor(ctor, staticArguments = [], supportsDelayedInstantiation = false) {
+        this.ctor = ctor;
+        this.staticArguments = staticArguments;
+        this.supportsDelayedInstantiation = supportsDelayedInstantiation;
+    }
+}

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/platform/instantiation/common/extensions.js

@@ -0,0 +1,15 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { SyncDescriptor } from './descriptors.js';
+const _registry = [];
+export function registerSingleton(id, ctorOrDescriptor, supportsDelayedInstantiation) {
+    if (!(ctorOrDescriptor instanceof SyncDescriptor)) {
+        ctorOrDescriptor = new SyncDescriptor(ctorOrDescriptor, [], Boolean(supportsDelayedInstantiation));
+    }
+    _registry.push([id, ctorOrDescriptor]);
+}
+export function getSingletonServiceDescriptors() {
+    return _registry;
+}