claude-flow-novice 2.0.4 → 2.0.5

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

@@ -1,18 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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

@@ -1,124 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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

@@ -1,101 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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

@@ -1,7 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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

@@ -1,72 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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

@@ -1,2 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,17 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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

@@ -1,2 +0,0 @@
-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

@@ -1,47 +0,0 @@
-/**
- * **!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

@@ -1,9 +0,0 @@
-//#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

@@ -1,105 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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

@@ -1,11 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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

@@ -1,15 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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;
-}