{"version":3,"file":"static/js/9174_bd9912a0c0dd02c4e018.js","mappings":"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","sources":["file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/platform/environment/common/environment.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/platform/extensions/common/extensions.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/platform/files/common/files.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/platform/history/browser/contextScopedHistoryWidget.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/platform/history/browser/historyWidgetKeybindingHint.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/platform/hover/browser/hover.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/platform/instantiation/common/descriptors.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/platform/instantiation/common/extensions.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/platform/instantiation/common/instantiation.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/platform/instantiation/common/graph.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/platform/instantiation/common/instantiationService.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/platform/instantiation/common/serviceCollection.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/platform/keybinding/common/abstractKeybindingService.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/platform/keybinding/common/keybinding.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/platform/keybinding/common/keybindingResolver.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/platform/keybinding/common/keybindingsRegistry.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/platform/keybinding/common/resolvedKeybindingItem.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/platform/keybinding/common/baseResolvedKeybinding.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/platform/keybinding/common/usLayoutResolvedKeybinding.js"],"sourcesContent":["import { createDecorator } from '../../instantiation/common/instantiation.js';\nexport const IEnvironmentService = createDecorator('environmentService');\n","/**\n * **!Do not construct directly!**\n *\n * **!Only static methods because it gets serialized!**\n *\n * This represents the \"canonical\" version for an extension identifier. Extension ids\n * have to be case-insensitive (due to the marketplace), but we must ensure case\n * preservation because the extension API is already public at this time.\n *\n * For example, given an extension with the publisher `\"Hello\"` and the name `\"World\"`,\n * its canonical extension identifier is `\"Hello.World\"`. This extension could be\n * referenced in some other extension's dependencies using the string `\"hello.world\"`.\n *\n * To make matters more complicated, an extension can optionally have an UUID. When two\n * extensions have the same UUID, they are considered equal even if their identifier is different.\n */\nexport class ExtensionIdentifier {\n    constructor(value) {\n        this.value = value;\n        this._lower = value.toLowerCase();\n    }\n    /**\n     * Gives the value by which to index (for equality).\n     */\n    static toKey(id) {\n        if (typeof id === 'string') {\n            return id.toLowerCase();\n        }\n        return id._lower;\n    }\n}\nexport class ExtensionIdentifierSet {\n    constructor(iterable) {\n        this._set = new Set();\n        if (iterable) {\n            for (const value of iterable) {\n                this.add(value);\n            }\n        }\n    }\n    add(id) {\n        this._set.add(ExtensionIdentifier.toKey(id));\n    }\n    has(id) {\n        return this._set.has(ExtensionIdentifier.toKey(id));\n    }\n}\n","//#endregion\n//#region Utilities\nexport var FileKind;\n(function (FileKind) {\n    FileKind[FileKind[\"FILE\"] = 0] = \"FILE\";\n    FileKind[FileKind[\"FOLDER\"] = 1] = \"FOLDER\";\n    FileKind[FileKind[\"ROOT_FOLDER\"] = 2] = \"ROOT_FOLDER\";\n})(FileKind || (FileKind = {}));\n//#endregion\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    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;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\n    return function (target, key) { decorator(target, key, paramIndex); }\n};\nimport { FindInput } from '../../../base/browser/ui/findinput/findInput.js';\nimport { ReplaceInput } from '../../../base/browser/ui/findinput/replaceInput.js';\nimport { ContextKeyExpr, IContextKeyService, RawContextKey } from '../../contextkey/common/contextkey.js';\nimport { KeybindingsRegistry } from '../../keybinding/common/keybindingsRegistry.js';\nimport { localize } from '../../../nls.js';\nimport { DisposableStore, toDisposable } from '../../../base/common/lifecycle.js';\nimport { isActiveElement } from '../../../base/browser/dom.js';\nexport const historyNavigationVisible = new RawContextKey('suggestWidgetVisible', false, localize('suggestWidgetVisible', \"Whether suggestion are visible\"));\nconst HistoryNavigationWidgetFocusContext = 'historyNavigationWidgetFocus';\nconst HistoryNavigationForwardsEnablementContext = 'historyNavigationForwardsEnabled';\nconst HistoryNavigationBackwardsEnablementContext = 'historyNavigationBackwardsEnabled';\nlet lastFocusedWidget = undefined;\nconst widgets = [];\nexport function registerAndCreateHistoryNavigationContext(scopedContextKeyService, widget) {\n    if (widgets.includes(widget)) {\n        throw new Error('Cannot register the same widget multiple times');\n    }\n    widgets.push(widget);\n    const disposableStore = new DisposableStore();\n    const historyNavigationWidgetFocus = new RawContextKey(HistoryNavigationWidgetFocusContext, false).bindTo(scopedContextKeyService);\n    const historyNavigationForwardsEnablement = new RawContextKey(HistoryNavigationForwardsEnablementContext, true).bindTo(scopedContextKeyService);\n    const historyNavigationBackwardsEnablement = new RawContextKey(HistoryNavigationBackwardsEnablementContext, true).bindTo(scopedContextKeyService);\n    const onDidFocus = () => {\n        historyNavigationWidgetFocus.set(true);\n        lastFocusedWidget = widget;\n    };\n    const onDidBlur = () => {\n        historyNavigationWidgetFocus.set(false);\n        if (lastFocusedWidget === widget) {\n            lastFocusedWidget = undefined;\n        }\n    };\n    // Check for currently being focused\n    if (isActiveElement(widget.element)) {\n        onDidFocus();\n    }\n    disposableStore.add(widget.onDidFocus(() => onDidFocus()));\n    disposableStore.add(widget.onDidBlur(() => onDidBlur()));\n    disposableStore.add(toDisposable(() => {\n        widgets.splice(widgets.indexOf(widget), 1);\n        onDidBlur();\n    }));\n    return {\n        historyNavigationForwardsEnablement,\n        historyNavigationBackwardsEnablement,\n        dispose() {\n            disposableStore.dispose();\n        }\n    };\n}\nlet ContextScopedFindInput = class ContextScopedFindInput extends FindInput {\n    constructor(container, contextViewProvider, options, contextKeyService) {\n        super(container, contextViewProvider, options);\n        const scopedContextKeyService = this._register(contextKeyService.createScoped(this.inputBox.element));\n        this._register(registerAndCreateHistoryNavigationContext(scopedContextKeyService, this.inputBox));\n    }\n};\nContextScopedFindInput = __decorate([\n    __param(3, IContextKeyService)\n], ContextScopedFindInput);\nexport { ContextScopedFindInput };\nlet ContextScopedReplaceInput = class ContextScopedReplaceInput extends ReplaceInput {\n    constructor(container, contextViewProvider, options, contextKeyService, showReplaceOptions = false) {\n        super(container, contextViewProvider, showReplaceOptions, options);\n        const scopedContextKeyService = this._register(contextKeyService.createScoped(this.inputBox.element));\n        this._register(registerAndCreateHistoryNavigationContext(scopedContextKeyService, this.inputBox));\n    }\n};\nContextScopedReplaceInput = __decorate([\n    __param(3, IContextKeyService)\n], ContextScopedReplaceInput);\nexport { ContextScopedReplaceInput };\nKeybindingsRegistry.registerCommandAndKeybindingRule({\n    id: 'history.showPrevious',\n    weight: 200 /* KeybindingWeight.WorkbenchContrib */,\n    when: ContextKeyExpr.and(ContextKeyExpr.has(HistoryNavigationWidgetFocusContext), ContextKeyExpr.equals(HistoryNavigationBackwardsEnablementContext, true), ContextKeyExpr.not('isComposing'), historyNavigationVisible.isEqualTo(false)),\n    primary: 16 /* KeyCode.UpArrow */,\n    secondary: [512 /* KeyMod.Alt */ | 16 /* KeyCode.UpArrow */],\n    handler: (accessor) => {\n        lastFocusedWidget === null || lastFocusedWidget === void 0 ? void 0 : lastFocusedWidget.showPreviousValue();\n    }\n});\nKeybindingsRegistry.registerCommandAndKeybindingRule({\n    id: 'history.showNext',\n    weight: 200 /* KeybindingWeight.WorkbenchContrib */,\n    when: ContextKeyExpr.and(ContextKeyExpr.has(HistoryNavigationWidgetFocusContext), ContextKeyExpr.equals(HistoryNavigationForwardsEnablementContext, true), ContextKeyExpr.not('isComposing'), historyNavigationVisible.isEqualTo(false)),\n    primary: 18 /* KeyCode.DownArrow */,\n    secondary: [512 /* KeyMod.Alt */ | 18 /* KeyCode.DownArrow */],\n    handler: (accessor) => {\n        lastFocusedWidget === null || lastFocusedWidget === void 0 ? void 0 : lastFocusedWidget.showNextValue();\n    }\n});\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport function showHistoryKeybindingHint(keybindingService) {\n    var _a, _b;\n    return ((_a = keybindingService.lookupKeybinding('history.showPrevious')) === null || _a === void 0 ? void 0 : _a.getElectronAccelerator()) === 'Up' && ((_b = keybindingService.lookupKeybinding('history.showNext')) === null || _b === void 0 ? void 0 : _b.getElectronAccelerator()) === 'Down';\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    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;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\n    return function (target, key) { decorator(target, key, paramIndex); }\n};\nimport { createDecorator } from '../../instantiation/common/instantiation.js';\nimport { Disposable, DisposableStore } from '../../../base/common/lifecycle.js';\nimport { IConfigurationService } from '../../configuration/common/configuration.js';\nimport { addStandardDisposableListener, isHTMLElement } from '../../../base/browser/dom.js';\nexport const IHoverService = createDecorator('hoverService');\nlet WorkbenchHoverDelegate = class WorkbenchHoverDelegate extends Disposable {\n    get delay() {\n        if (this.isInstantlyHovering()) {\n            return 0; // show instantly when a hover was recently shown\n        }\n        return this._delay;\n    }\n    constructor(placement, instantHover, overrideOptions = {}, configurationService, hoverService) {\n        super();\n        this.placement = placement;\n        this.instantHover = instantHover;\n        this.overrideOptions = overrideOptions;\n        this.configurationService = configurationService;\n        this.hoverService = hoverService;\n        this.lastHoverHideTime = 0;\n        this.timeLimit = 200;\n        this.hoverDisposables = this._register(new DisposableStore());\n        this._delay = this.configurationService.getValue('workbench.hover.delay');\n        this._register(this.configurationService.onDidChangeConfiguration(e => {\n            if (e.affectsConfiguration('workbench.hover.delay')) {\n                this._delay = this.configurationService.getValue('workbench.hover.delay');\n            }\n        }));\n    }\n    showHover(options, focus) {\n        const overrideOptions = typeof this.overrideOptions === 'function' ? this.overrideOptions(options, focus) : this.overrideOptions;\n        // close hover on escape\n        this.hoverDisposables.clear();\n        const targets = isHTMLElement(options.target) ? [options.target] : options.target.targetElements;\n        for (const target of targets) {\n            this.hoverDisposables.add(addStandardDisposableListener(target, 'keydown', (e) => {\n                if (e.equals(9 /* KeyCode.Escape */)) {\n                    this.hoverService.hideHover();\n                }\n            }));\n        }\n        const id = isHTMLElement(options.content) ? undefined : options.content.toString();\n        return this.hoverService.showHover({\n            ...options,\n            ...overrideOptions,\n            persistence: {\n                hideOnKeyDown: true,\n                ...overrideOptions.persistence\n            },\n            id,\n            appearance: {\n                ...options.appearance,\n                compact: true,\n                skipFadeInAnimation: this.isInstantlyHovering(),\n                ...overrideOptions.appearance\n            }\n        }, focus);\n    }\n    isInstantlyHovering() {\n        return this.instantHover && Date.now() - this.lastHoverHideTime < this.timeLimit;\n    }\n    onDidHideHover() {\n        this.hoverDisposables.clear();\n        if (this.instantHover) {\n            this.lastHoverHideTime = Date.now();\n        }\n    }\n};\nWorkbenchHoverDelegate = __decorate([\n    __param(3, IConfigurationService),\n    __param(4, IHoverService)\n], WorkbenchHoverDelegate);\nexport { WorkbenchHoverDelegate };\n// TODO@benibenj remove this, only temp fix for contextviews\nexport const nativeHoverDelegate = {\n    showHover: function () {\n        throw new Error('Native hover function not implemented.');\n    },\n    delay: 0,\n    showNativeHover: true\n};\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport class SyncDescriptor {\n    constructor(ctor, staticArguments = [], supportsDelayedInstantiation = false) {\n        this.ctor = ctor;\n        this.staticArguments = staticArguments;\n        this.supportsDelayedInstantiation = supportsDelayedInstantiation;\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { SyncDescriptor } from './descriptors.js';\nconst _registry = [];\nexport function registerSingleton(id, ctorOrDescriptor, supportsDelayedInstantiation) {\n    if (!(ctorOrDescriptor instanceof SyncDescriptor)) {\n        ctorOrDescriptor = new SyncDescriptor(ctorOrDescriptor, [], Boolean(supportsDelayedInstantiation));\n    }\n    _registry.push([id, ctorOrDescriptor]);\n}\nexport function getSingletonServiceDescriptors() {\n    return _registry;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n// ------ internal util\nexport var _util;\n(function (_util) {\n    _util.serviceIds = new Map();\n    _util.DI_TARGET = '$di$target';\n    _util.DI_DEPENDENCIES = '$di$dependencies';\n    function getServiceDependencies(ctor) {\n        return ctor[_util.DI_DEPENDENCIES] || [];\n    }\n    _util.getServiceDependencies = getServiceDependencies;\n})(_util || (_util = {}));\nexport const IInstantiationService = createDecorator('instantiationService');\nfunction storeServiceDependency(id, target, index) {\n    if (target[_util.DI_TARGET] === target) {\n        target[_util.DI_DEPENDENCIES].push({ id, index });\n    }\n    else {\n        target[_util.DI_DEPENDENCIES] = [{ id, index }];\n        target[_util.DI_TARGET] = target;\n    }\n}\n/**\n * The *only* valid way to create a {{ServiceIdentifier}}.\n */\nexport function createDecorator(serviceId) {\n    if (_util.serviceIds.has(serviceId)) {\n        return _util.serviceIds.get(serviceId);\n    }\n    const id = function (target, key, index) {\n        if (arguments.length !== 3) {\n            throw new Error('@IServiceName-decorator can only be used to decorate a parameter');\n        }\n        storeServiceDependency(id, target, index);\n    };\n    id.toString = () => serviceId;\n    _util.serviceIds.set(serviceId, id);\n    return id;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport class Node {\n    constructor(key, data) {\n        this.key = key;\n        this.data = data;\n        this.incoming = new Map();\n        this.outgoing = new Map();\n    }\n}\nexport class Graph {\n    constructor(_hashFn) {\n        this._hashFn = _hashFn;\n        this._nodes = new Map();\n        // empty\n    }\n    roots() {\n        const ret = [];\n        for (const node of this._nodes.values()) {\n            if (node.outgoing.size === 0) {\n                ret.push(node);\n            }\n        }\n        return ret;\n    }\n    insertEdge(from, to) {\n        const fromNode = this.lookupOrInsertNode(from);\n        const toNode = this.lookupOrInsertNode(to);\n        fromNode.outgoing.set(toNode.key, toNode);\n        toNode.incoming.set(fromNode.key, fromNode);\n    }\n    removeNode(data) {\n        const key = this._hashFn(data);\n        this._nodes.delete(key);\n        for (const node of this._nodes.values()) {\n            node.outgoing.delete(key);\n            node.incoming.delete(key);\n        }\n    }\n    lookupOrInsertNode(data) {\n        const key = this._hashFn(data);\n        let node = this._nodes.get(key);\n        if (!node) {\n            node = new Node(key, data);\n            this._nodes.set(key, node);\n        }\n        return node;\n    }\n    isEmpty() {\n        return this._nodes.size === 0;\n    }\n    toString() {\n        const data = [];\n        for (const [key, value] of this._nodes) {\n            data.push(`${key}\\n\\t(-> incoming)[${[...value.incoming.keys()].join(', ')}]\\n\\t(outgoing ->)[${[...value.outgoing.keys()].join(',')}]\\n`);\n        }\n        return data.join('\\n');\n    }\n    /**\n     * This is brute force and slow and **only** be used\n     * to trouble shoot.\n     */\n    findCycleSlow() {\n        for (const [id, node] of this._nodes) {\n            const seen = new Set([id]);\n            const res = this._findCycle(node, seen);\n            if (res) {\n                return res;\n            }\n        }\n        return undefined;\n    }\n    _findCycle(node, seen) {\n        for (const [id, outgoing] of node.outgoing) {\n            if (seen.has(id)) {\n                return [...seen, id].join(' -> ');\n            }\n            seen.add(id);\n            const value = this._findCycle(outgoing, seen);\n            if (value) {\n                return value;\n            }\n            seen.delete(id);\n        }\n        return undefined;\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { GlobalIdleValue } from '../../../base/common/async.js';\nimport { illegalState } from '../../../base/common/errors.js';\nimport { dispose, isDisposable, toDisposable } from '../../../base/common/lifecycle.js';\nimport { SyncDescriptor } from './descriptors.js';\nimport { Graph } from './graph.js';\nimport { IInstantiationService, _util } from './instantiation.js';\nimport { ServiceCollection } from './serviceCollection.js';\nimport { LinkedList } from '../../../base/common/linkedList.js';\n// TRACING\nconst _enableAllTracing = false;\nclass CyclicDependencyError extends Error {\n    constructor(graph) {\n        var _a;\n        super('cyclic dependency between services');\n        this.message = (_a = graph.findCycleSlow()) !== null && _a !== void 0 ? _a : `UNABLE to detect cycle, dumping graph: \\n${graph.toString()}`;\n    }\n}\nexport class InstantiationService {\n    constructor(_services = new ServiceCollection(), _strict = false, _parent, _enableTracing = _enableAllTracing) {\n        var _a;\n        this._services = _services;\n        this._strict = _strict;\n        this._parent = _parent;\n        this._enableTracing = _enableTracing;\n        this._isDisposed = false;\n        this._servicesToMaybeDispose = new Set();\n        this._children = new Set();\n        this._activeInstantiations = new Set();\n        this._services.set(IInstantiationService, this);\n        this._globalGraph = _enableTracing ? (_a = _parent === null || _parent === void 0 ? void 0 : _parent._globalGraph) !== null && _a !== void 0 ? _a : new Graph(e => e) : undefined;\n    }\n    dispose() {\n        if (!this._isDisposed) {\n            this._isDisposed = true;\n            // dispose all child services\n            dispose(this._children);\n            this._children.clear();\n            // dispose all services created by this service\n            for (const candidate of this._servicesToMaybeDispose) {\n                if (isDisposable(candidate)) {\n                    candidate.dispose();\n                }\n            }\n            this._servicesToMaybeDispose.clear();\n        }\n    }\n    _throwIfDisposed() {\n        if (this._isDisposed) {\n            throw new Error('InstantiationService has been disposed');\n        }\n    }\n    createChild(services, store) {\n        this._throwIfDisposed();\n        const that = this;\n        const result = new class extends InstantiationService {\n            dispose() {\n                that._children.delete(result);\n                super.dispose();\n            }\n        }(services, this._strict, this, this._enableTracing);\n        this._children.add(result);\n        store === null || store === void 0 ? void 0 : store.add(result);\n        return result;\n    }\n    invokeFunction(fn, ...args) {\n        this._throwIfDisposed();\n        const _trace = Trace.traceInvocation(this._enableTracing, fn);\n        let _done = false;\n        try {\n            const accessor = {\n                get: (id) => {\n                    if (_done) {\n                        throw illegalState('service accessor is only valid during the invocation of its target method');\n                    }\n                    const result = this._getOrCreateServiceInstance(id, _trace);\n                    if (!result) {\n                        throw new Error(`[invokeFunction] unknown service '${id}'`);\n                    }\n                    return result;\n                }\n            };\n            return fn(accessor, ...args);\n        }\n        finally {\n            _done = true;\n            _trace.stop();\n        }\n    }\n    createInstance(ctorOrDescriptor, ...rest) {\n        this._throwIfDisposed();\n        let _trace;\n        let result;\n        if (ctorOrDescriptor instanceof SyncDescriptor) {\n            _trace = Trace.traceCreation(this._enableTracing, ctorOrDescriptor.ctor);\n            result = this._createInstance(ctorOrDescriptor.ctor, ctorOrDescriptor.staticArguments.concat(rest), _trace);\n        }\n        else {\n            _trace = Trace.traceCreation(this._enableTracing, ctorOrDescriptor);\n            result = this._createInstance(ctorOrDescriptor, rest, _trace);\n        }\n        _trace.stop();\n        return result;\n    }\n    _createInstance(ctor, args = [], _trace) {\n        // arguments defined by service decorators\n        const serviceDependencies = _util.getServiceDependencies(ctor).sort((a, b) => a.index - b.index);\n        const serviceArgs = [];\n        for (const dependency of serviceDependencies) {\n            const service = this._getOrCreateServiceInstance(dependency.id, _trace);\n            if (!service) {\n                this._throwIfStrict(`[createInstance] ${ctor.name} depends on UNKNOWN service ${dependency.id}.`, false);\n            }\n            serviceArgs.push(service);\n        }\n        const firstServiceArgPos = serviceDependencies.length > 0 ? serviceDependencies[0].index : args.length;\n        // check for argument mismatches, adjust static args if needed\n        if (args.length !== firstServiceArgPos) {\n            console.trace(`[createInstance] First service dependency of ${ctor.name} at position ${firstServiceArgPos + 1} conflicts with ${args.length} static arguments`);\n            const delta = firstServiceArgPos - args.length;\n            if (delta > 0) {\n                args = args.concat(new Array(delta));\n            }\n            else {\n                args = args.slice(0, firstServiceArgPos);\n            }\n        }\n        // now create the instance\n        return Reflect.construct(ctor, args.concat(serviceArgs));\n    }\n    _setCreatedServiceInstance(id, instance) {\n        if (this._services.get(id) instanceof SyncDescriptor) {\n            this._services.set(id, instance);\n        }\n        else if (this._parent) {\n            this._parent._setCreatedServiceInstance(id, instance);\n        }\n        else {\n            throw new Error('illegalState - setting UNKNOWN service instance');\n        }\n    }\n    _getServiceInstanceOrDescriptor(id) {\n        const instanceOrDesc = this._services.get(id);\n        if (!instanceOrDesc && this._parent) {\n            return this._parent._getServiceInstanceOrDescriptor(id);\n        }\n        else {\n            return instanceOrDesc;\n        }\n    }\n    _getOrCreateServiceInstance(id, _trace) {\n        if (this._globalGraph && this._globalGraphImplicitDependency) {\n            this._globalGraph.insertEdge(this._globalGraphImplicitDependency, String(id));\n        }\n        const thing = this._getServiceInstanceOrDescriptor(id);\n        if (thing instanceof SyncDescriptor) {\n            return this._safeCreateAndCacheServiceInstance(id, thing, _trace.branch(id, true));\n        }\n        else {\n            _trace.branch(id, false);\n            return thing;\n        }\n    }\n    _safeCreateAndCacheServiceInstance(id, desc, _trace) {\n        if (this._activeInstantiations.has(id)) {\n            throw new Error(`illegal state - RECURSIVELY instantiating service '${id}'`);\n        }\n        this._activeInstantiations.add(id);\n        try {\n            return this._createAndCacheServiceInstance(id, desc, _trace);\n        }\n        finally {\n            this._activeInstantiations.delete(id);\n        }\n    }\n    _createAndCacheServiceInstance(id, desc, _trace) {\n        var _a;\n        const graph = new Graph(data => data.id.toString());\n        let cycleCount = 0;\n        const stack = [{ id, desc, _trace }];\n        while (stack.length) {\n            const item = stack.pop();\n            graph.lookupOrInsertNode(item);\n            // a weak but working heuristic for cycle checks\n            if (cycleCount++ > 1000) {\n                throw new CyclicDependencyError(graph);\n            }\n            // check all dependencies for existence and if they need to be created first\n            for (const dependency of _util.getServiceDependencies(item.desc.ctor)) {\n                const instanceOrDesc = this._getServiceInstanceOrDescriptor(dependency.id);\n                if (!instanceOrDesc) {\n                    this._throwIfStrict(`[createInstance] ${id} depends on ${dependency.id} which is NOT registered.`, true);\n                }\n                // take note of all service dependencies\n                (_a = this._globalGraph) === null || _a === void 0 ? void 0 : _a.insertEdge(String(item.id), String(dependency.id));\n                if (instanceOrDesc instanceof SyncDescriptor) {\n                    const d = { id: dependency.id, desc: instanceOrDesc, _trace: item._trace.branch(dependency.id, true) };\n                    graph.insertEdge(item, d);\n                    stack.push(d);\n                }\n            }\n        }\n        while (true) {\n            const roots = graph.roots();\n            // if there is no more roots but still\n            // nodes in the graph we have a cycle\n            if (roots.length === 0) {\n                if (!graph.isEmpty()) {\n                    throw new CyclicDependencyError(graph);\n                }\n                break;\n            }\n            for (const { data } of roots) {\n                // Repeat the check for this still being a service sync descriptor. That's because\n                // instantiating a dependency might have side-effect and recursively trigger instantiation\n                // so that some dependencies are now fullfilled already.\n                const instanceOrDesc = this._getServiceInstanceOrDescriptor(data.id);\n                if (instanceOrDesc instanceof SyncDescriptor) {\n                    // create instance and overwrite the service collections\n                    const instance = this._createServiceInstanceWithOwner(data.id, data.desc.ctor, data.desc.staticArguments, data.desc.supportsDelayedInstantiation, data._trace);\n                    this._setCreatedServiceInstance(data.id, instance);\n                }\n                graph.removeNode(data);\n            }\n        }\n        return this._getServiceInstanceOrDescriptor(id);\n    }\n    _createServiceInstanceWithOwner(id, ctor, args = [], supportsDelayedInstantiation, _trace) {\n        if (this._services.get(id) instanceof SyncDescriptor) {\n            return this._createServiceInstance(id, ctor, args, supportsDelayedInstantiation, _trace, this._servicesToMaybeDispose);\n        }\n        else if (this._parent) {\n            return this._parent._createServiceInstanceWithOwner(id, ctor, args, supportsDelayedInstantiation, _trace);\n        }\n        else {\n            throw new Error(`illegalState - creating UNKNOWN service instance ${ctor.name}`);\n        }\n    }\n    _createServiceInstance(id, ctor, args = [], supportsDelayedInstantiation, _trace, disposeBucket) {\n        if (!supportsDelayedInstantiation) {\n            // eager instantiation\n            const result = this._createInstance(ctor, args, _trace);\n            disposeBucket.add(result);\n            return result;\n        }\n        else {\n            const child = new InstantiationService(undefined, this._strict, this, this._enableTracing);\n            child._globalGraphImplicitDependency = String(id);\n            // Return a proxy object that's backed by an idle value. That\n            // strategy is to instantiate services in our idle time or when actually\n            // needed but not when injected into a consumer\n            // return \"empty events\" when the service isn't instantiated yet\n            const earlyListeners = new Map();\n            const idle = new GlobalIdleValue(() => {\n                const result = child._createInstance(ctor, args, _trace);\n                // early listeners that we kept are now being subscribed to\n                // the real service\n                for (const [key, values] of earlyListeners) {\n                    const candidate = result[key];\n                    if (typeof candidate === 'function') {\n                        for (const value of values) {\n                            value.disposable = candidate.apply(result, value.listener);\n                        }\n                    }\n                }\n                earlyListeners.clear();\n                disposeBucket.add(result);\n                return result;\n            });\n            return new Proxy(Object.create(null), {\n                get(target, key) {\n                    if (!idle.isInitialized) {\n                        // looks like an event\n                        if (typeof key === 'string' && (key.startsWith('onDid') || key.startsWith('onWill'))) {\n                            let list = earlyListeners.get(key);\n                            if (!list) {\n                                list = new LinkedList();\n                                earlyListeners.set(key, list);\n                            }\n                            const event = (callback, thisArg, disposables) => {\n                                if (idle.isInitialized) {\n                                    return idle.value[key](callback, thisArg, disposables);\n                                }\n                                else {\n                                    const entry = { listener: [callback, thisArg, disposables], disposable: undefined };\n                                    const rm = list.push(entry);\n                                    const result = toDisposable(() => {\n                                        var _a;\n                                        rm();\n                                        (_a = entry.disposable) === null || _a === void 0 ? void 0 : _a.dispose();\n                                    });\n                                    return result;\n                                }\n                            };\n                            return event;\n                        }\n                    }\n                    // value already exists\n                    if (key in target) {\n                        return target[key];\n                    }\n                    // create value\n                    const obj = idle.value;\n                    let prop = obj[key];\n                    if (typeof prop !== 'function') {\n                        return prop;\n                    }\n                    prop = prop.bind(obj);\n                    target[key] = prop;\n                    return prop;\n                },\n                set(_target, p, value) {\n                    idle.value[p] = value;\n                    return true;\n                },\n                getPrototypeOf(_target) {\n                    return ctor.prototype;\n                }\n            });\n        }\n    }\n    _throwIfStrict(msg, printWarning) {\n        if (printWarning) {\n            console.warn(msg);\n        }\n        if (this._strict) {\n            throw new Error(msg);\n        }\n    }\n}\nexport class Trace {\n    static traceInvocation(_enableTracing, ctor) {\n        return !_enableTracing ? Trace._None : new Trace(2 /* TraceType.Invocation */, ctor.name || new Error().stack.split('\\n').slice(3, 4).join('\\n'));\n    }\n    static traceCreation(_enableTracing, ctor) {\n        return !_enableTracing ? Trace._None : new Trace(1 /* TraceType.Creation */, ctor.name);\n    }\n    constructor(type, name) {\n        this.type = type;\n        this.name = name;\n        this._start = Date.now();\n        this._dep = [];\n    }\n    branch(id, first) {\n        const child = new Trace(3 /* TraceType.Branch */, id.toString());\n        this._dep.push([id, first, child]);\n        return child;\n    }\n    stop() {\n        const dur = Date.now() - this._start;\n        Trace._totals += dur;\n        let causedCreation = false;\n        function printChild(n, trace) {\n            const res = [];\n            const prefix = new Array(n + 1).join('\\t');\n            for (const [id, first, child] of trace._dep) {\n                if (first && child) {\n                    causedCreation = true;\n                    res.push(`${prefix}CREATES -> ${id}`);\n                    const nested = printChild(n + 1, child);\n                    if (nested) {\n                        res.push(nested);\n                    }\n                }\n                else {\n                    res.push(`${prefix}uses -> ${id}`);\n                }\n            }\n            return res.join('\\n');\n        }\n        const lines = [\n            `${this.type === 1 /* TraceType.Creation */ ? 'CREATE' : 'CALL'} ${this.name}`,\n            `${printChild(1, this)}`,\n            `DONE, took ${dur.toFixed(2)}ms (grand total ${Trace._totals.toFixed(2)}ms)`\n        ];\n        if (dur > 2 || causedCreation) {\n            Trace.all.add(lines.join('\\n'));\n        }\n    }\n}\nTrace.all = new Set();\nTrace._None = new class extends Trace {\n    constructor() { super(0 /* TraceType.None */, null); }\n    stop() { }\n    branch() { return this; }\n};\nTrace._totals = 0;\n//#endregion\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport class ServiceCollection {\n    constructor(...entries) {\n        this._entries = new Map();\n        for (const [id, service] of entries) {\n            this.set(id, service);\n        }\n    }\n    set(id, instanceOrDescriptor) {\n        const result = this._entries.get(id);\n        this._entries.set(id, instanceOrDescriptor);\n        return result;\n    }\n    get(id) {\n        return this._entries.get(id);\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Emitter } from '../../../base/common/event.js';\nimport * as platform from '../../registry/common/platform.js';\nexport const Extensions = {\n    JSONContribution: 'base.contributions.json'\n};\nfunction normalizeId(id) {\n    if (id.length > 0 && id.charAt(id.length - 1) === '#') {\n        return id.substring(0, id.length - 1);\n    }\n    return id;\n}\nclass JSONContributionRegistry {\n    constructor() {\n        this._onDidChangeSchema = new Emitter();\n        this.schemasById = {};\n    }\n    registerSchema(uri, unresolvedSchemaContent) {\n        this.schemasById[normalizeId(uri)] = unresolvedSchemaContent;\n        this._onDidChangeSchema.fire(uri);\n    }\n    notifySchemaChanged(uri) {\n        this._onDidChangeSchema.fire(uri);\n    }\n}\nconst jsonContributionRegistry = new JSONContributionRegistry();\nplatform.Registry.add(Extensions.JSONContribution, jsonContributionRegistry);\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { IntervalTimer, TimeoutTimer } from '../../../base/common/async.js';\nimport { illegalState } from '../../../base/common/errors.js';\nimport { Emitter, Event } from '../../../base/common/event.js';\nimport { IME } from '../../../base/common/ime.js';\nimport { Disposable } from '../../../base/common/lifecycle.js';\nimport * as nls from '../../../nls.js';\nimport { NoMatchingKb } from './keybindingResolver.js';\nconst HIGH_FREQ_COMMANDS = /^(cursor|delete|undo|redo|tab|editor\\.action\\.clipboard)/;\nexport class AbstractKeybindingService extends Disposable {\n    get onDidUpdateKeybindings() {\n        return this._onDidUpdateKeybindings ? this._onDidUpdateKeybindings.event : Event.None; // Sinon stubbing walks properties on prototype\n    }\n    get inChordMode() {\n        return this._currentChords.length > 0;\n    }\n    constructor(_contextKeyService, _commandService, _telemetryService, _notificationService, _logService) {\n        super();\n        this._contextKeyService = _contextKeyService;\n        this._commandService = _commandService;\n        this._telemetryService = _telemetryService;\n        this._notificationService = _notificationService;\n        this._logService = _logService;\n        this._onDidUpdateKeybindings = this._register(new Emitter());\n        this._currentChords = [];\n        this._currentChordChecker = new IntervalTimer();\n        this._currentChordStatusMessage = null;\n        this._ignoreSingleModifiers = KeybindingModifierSet.EMPTY;\n        this._currentSingleModifier = null;\n        this._currentSingleModifierClearTimeout = new TimeoutTimer();\n        this._currentlyDispatchingCommandId = null;\n        this._logging = false;\n    }\n    dispose() {\n        super.dispose();\n    }\n    _log(str) {\n        if (this._logging) {\n            this._logService.info(`[KeybindingService]: ${str}`);\n        }\n    }\n    getKeybindings() {\n        return this._getResolver().getKeybindings();\n    }\n    lookupKeybinding(commandId, context) {\n        const result = this._getResolver().lookupPrimaryKeybinding(commandId, context || this._contextKeyService);\n        if (!result) {\n            return undefined;\n        }\n        return result.resolvedKeybinding;\n    }\n    dispatchEvent(e, target) {\n        return this._dispatch(e, target);\n    }\n    // TODO@ulugbekna: update namings to align with `_doDispatch`\n    // TODO@ulugbekna: this fn doesn't seem to take into account single-modifier keybindings, eg `shift shift`\n    softDispatch(e, target) {\n        this._log(`/ Soft dispatching keyboard event`);\n        const keybinding = this.resolveKeyboardEvent(e);\n        if (keybinding.hasMultipleChords()) {\n            console.warn('keyboard event should not be mapped to multiple chords');\n            return NoMatchingKb;\n        }\n        const [firstChord,] = keybinding.getDispatchChords();\n        if (firstChord === null) {\n            // cannot be dispatched, probably only modifier keys\n            this._log(`\\\\ Keyboard event cannot be dispatched`);\n            return NoMatchingKb;\n        }\n        const contextValue = this._contextKeyService.getContext(target);\n        const currentChords = this._currentChords.map((({ keypress }) => keypress));\n        return this._getResolver().resolve(contextValue, currentChords, firstChord);\n    }\n    _scheduleLeaveChordMode() {\n        const chordLastInteractedTime = Date.now();\n        this._currentChordChecker.cancelAndSet(() => {\n            if (!this._documentHasFocus()) {\n                // Focus has been lost => leave chord mode\n                this._leaveChordMode();\n                return;\n            }\n            if (Date.now() - chordLastInteractedTime > 5000) {\n                // 5 seconds elapsed => leave chord mode\n                this._leaveChordMode();\n            }\n        }, 500);\n    }\n    _expectAnotherChord(firstChord, keypressLabel) {\n        this._currentChords.push({ keypress: firstChord, label: keypressLabel });\n        switch (this._currentChords.length) {\n            case 0:\n                throw illegalState('impossible');\n            case 1:\n                // TODO@ulugbekna: revise this message and the one below (at least, fix terminology)\n                this._currentChordStatusMessage = this._notificationService.status(nls.localize('first.chord', \"({0}) was pressed. Waiting for second key of chord...\", keypressLabel));\n                break;\n            default: {\n                const fullKeypressLabel = this._currentChords.map(({ label }) => label).join(', ');\n                this._currentChordStatusMessage = this._notificationService.status(nls.localize('next.chord', \"({0}) was pressed. Waiting for next key of chord...\", fullKeypressLabel));\n            }\n        }\n        this._scheduleLeaveChordMode();\n        if (IME.enabled) {\n            IME.disable();\n        }\n    }\n    _leaveChordMode() {\n        if (this._currentChordStatusMessage) {\n            this._currentChordStatusMessage.dispose();\n            this._currentChordStatusMessage = null;\n        }\n        this._currentChordChecker.cancel();\n        this._currentChords = [];\n        IME.enable();\n    }\n    _dispatch(e, target) {\n        return this._doDispatch(this.resolveKeyboardEvent(e), target, /*isSingleModiferChord*/ false);\n    }\n    _singleModifierDispatch(e, target) {\n        const keybinding = this.resolveKeyboardEvent(e);\n        const [singleModifier,] = keybinding.getSingleModifierDispatchChords();\n        if (singleModifier) {\n            if (this._ignoreSingleModifiers.has(singleModifier)) {\n                this._log(`+ Ignoring single modifier ${singleModifier} due to it being pressed together with other keys.`);\n                this._ignoreSingleModifiers = KeybindingModifierSet.EMPTY;\n                this._currentSingleModifierClearTimeout.cancel();\n                this._currentSingleModifier = null;\n                return false;\n            }\n            this._ignoreSingleModifiers = KeybindingModifierSet.EMPTY;\n            if (this._currentSingleModifier === null) {\n                // we have a valid `singleModifier`, store it for the next keyup, but clear it in 300ms\n                this._log(`+ Storing single modifier for possible chord ${singleModifier}.`);\n                this._currentSingleModifier = singleModifier;\n                this._currentSingleModifierClearTimeout.cancelAndSet(() => {\n                    this._log(`+ Clearing single modifier due to 300ms elapsed.`);\n                    this._currentSingleModifier = null;\n                }, 300);\n                return false;\n            }\n            if (singleModifier === this._currentSingleModifier) {\n                // bingo!\n                this._log(`/ Dispatching single modifier chord ${singleModifier} ${singleModifier}`);\n                this._currentSingleModifierClearTimeout.cancel();\n                this._currentSingleModifier = null;\n                return this._doDispatch(keybinding, target, /*isSingleModiferChord*/ true);\n            }\n            this._log(`+ Clearing single modifier due to modifier mismatch: ${this._currentSingleModifier} ${singleModifier}`);\n            this._currentSingleModifierClearTimeout.cancel();\n            this._currentSingleModifier = null;\n            return false;\n        }\n        // When pressing a modifier and holding it pressed with any other modifier or key combination,\n        // the pressed modifiers should no longer be considered for single modifier dispatch.\n        const [firstChord,] = keybinding.getChords();\n        this._ignoreSingleModifiers = new KeybindingModifierSet(firstChord);\n        if (this._currentSingleModifier !== null) {\n            this._log(`+ Clearing single modifier due to other key up.`);\n        }\n        this._currentSingleModifierClearTimeout.cancel();\n        this._currentSingleModifier = null;\n        return false;\n    }\n    _doDispatch(userKeypress, target, isSingleModiferChord = false) {\n        var _a;\n        let shouldPreventDefault = false;\n        if (userKeypress.hasMultipleChords()) { // warn - because user can press a single chord at a time\n            console.warn('Unexpected keyboard event mapped to multiple chords');\n            return false;\n        }\n        let userPressedChord = null;\n        let currentChords = null;\n        if (isSingleModiferChord) {\n            // The keybinding is the second keypress of a single modifier chord, e.g. \"shift shift\".\n            // A single modifier can only occur when the same modifier is pressed in short sequence,\n            // hence we disregard `_currentChord` and use the same modifier instead.\n            const [dispatchKeyname,] = userKeypress.getSingleModifierDispatchChords();\n            userPressedChord = dispatchKeyname;\n            currentChords = dispatchKeyname ? [dispatchKeyname] : []; // TODO@ulugbekna: in the `else` case we assign an empty array - make sure `resolve` can handle an empty array well\n        }\n        else {\n            [userPressedChord,] = userKeypress.getDispatchChords();\n            currentChords = this._currentChords.map(({ keypress }) => keypress);\n        }\n        if (userPressedChord === null) {\n            this._log(`\\\\ Keyboard event cannot be dispatched in keydown phase.`);\n            // cannot be dispatched, probably only modifier keys\n            return shouldPreventDefault;\n        }\n        const contextValue = this._contextKeyService.getContext(target);\n        const keypressLabel = userKeypress.getLabel();\n        const resolveResult = this._getResolver().resolve(contextValue, currentChords, userPressedChord);\n        switch (resolveResult.kind) {\n            case 0 /* ResultKind.NoMatchingKb */: {\n                this._logService.trace('KeybindingService#dispatch', keypressLabel, `[ No matching keybinding ]`);\n                if (this.inChordMode) {\n                    const currentChordsLabel = this._currentChords.map(({ label }) => label).join(', ');\n                    this._log(`+ Leaving multi-chord mode: Nothing bound to \"${currentChordsLabel}, ${keypressLabel}\".`);\n                    this._notificationService.status(nls.localize('missing.chord', \"The key combination ({0}, {1}) is not a command.\", currentChordsLabel, keypressLabel), { hideAfter: 10 * 1000 /* 10s */ });\n                    this._leaveChordMode();\n                    shouldPreventDefault = true;\n                }\n                return shouldPreventDefault;\n            }\n            case 1 /* ResultKind.MoreChordsNeeded */: {\n                this._logService.trace('KeybindingService#dispatch', keypressLabel, `[ Several keybindings match - more chords needed ]`);\n                shouldPreventDefault = true;\n                this._expectAnotherChord(userPressedChord, keypressLabel);\n                this._log(this._currentChords.length === 1 ? `+ Entering multi-chord mode...` : `+ Continuing multi-chord mode...`);\n                return shouldPreventDefault;\n            }\n            case 2 /* ResultKind.KbFound */: {\n                this._logService.trace('KeybindingService#dispatch', keypressLabel, `[ Will dispatch command ${resolveResult.commandId} ]`);\n                if (resolveResult.commandId === null || resolveResult.commandId === '') {\n                    if (this.inChordMode) {\n                        const currentChordsLabel = this._currentChords.map(({ label }) => label).join(', ');\n                        this._log(`+ Leaving chord mode: Nothing bound to \"${currentChordsLabel}, ${keypressLabel}\".`);\n                        this._notificationService.status(nls.localize('missing.chord', \"The key combination ({0}, {1}) is not a command.\", currentChordsLabel, keypressLabel), { hideAfter: 10 * 1000 /* 10s */ });\n                        this._leaveChordMode();\n                        shouldPreventDefault = true;\n                    }\n                }\n                else {\n                    if (this.inChordMode) {\n                        this._leaveChordMode();\n                    }\n                    if (!resolveResult.isBubble) {\n                        shouldPreventDefault = true;\n                    }\n                    this._log(`+ Invoking command ${resolveResult.commandId}.`);\n                    this._currentlyDispatchingCommandId = resolveResult.commandId;\n                    try {\n                        if (typeof resolveResult.commandArgs === 'undefined') {\n                            this._commandService.executeCommand(resolveResult.commandId).then(undefined, err => this._notificationService.warn(err));\n                        }\n                        else {\n                            this._commandService.executeCommand(resolveResult.commandId, resolveResult.commandArgs).then(undefined, err => this._notificationService.warn(err));\n                        }\n                    }\n                    finally {\n                        this._currentlyDispatchingCommandId = null;\n                    }\n                    if (!HIGH_FREQ_COMMANDS.test(resolveResult.commandId)) {\n                        this._telemetryService.publicLog2('workbenchActionExecuted', { id: resolveResult.commandId, from: 'keybinding', detail: (_a = userKeypress.getUserSettingsLabel()) !== null && _a !== void 0 ? _a : undefined });\n                    }\n                }\n                return shouldPreventDefault;\n            }\n        }\n    }\n    mightProducePrintableCharacter(event) {\n        if (event.ctrlKey || event.metaKey) {\n            // ignore ctrl/cmd-combination but not shift/alt-combinatios\n            return false;\n        }\n        // weak check for certain ranges. this is properly implemented in a subclass\n        // with access to the KeyboardMapperFactory.\n        if ((event.keyCode >= 31 /* KeyCode.KeyA */ && event.keyCode <= 56 /* KeyCode.KeyZ */)\n            || (event.keyCode >= 21 /* KeyCode.Digit0 */ && event.keyCode <= 30 /* KeyCode.Digit9 */)) {\n            return true;\n        }\n        return false;\n    }\n}\nclass KeybindingModifierSet {\n    constructor(source) {\n        this._ctrlKey = source ? source.ctrlKey : false;\n        this._shiftKey = source ? source.shiftKey : false;\n        this._altKey = source ? source.altKey : false;\n        this._metaKey = source ? source.metaKey : false;\n    }\n    has(modifier) {\n        switch (modifier) {\n            case 'ctrl': return this._ctrlKey;\n            case 'shift': return this._shiftKey;\n            case 'alt': return this._altKey;\n            case 'meta': return this._metaKey;\n        }\n    }\n}\nKeybindingModifierSet.EMPTY = new KeybindingModifierSet(null);\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { createDecorator } from '../../instantiation/common/instantiation.js';\nexport const IKeybindingService = createDecorator('keybindingService');\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { implies, expressionsAreEqualWithConstantSubstitution } from '../../contextkey/common/contextkey.js';\n// util definitions to make working with the above types easier within this module:\nexport const NoMatchingKb = { kind: 0 /* ResultKind.NoMatchingKb */ };\nconst MoreChordsNeeded = { kind: 1 /* ResultKind.MoreChordsNeeded */ };\nfunction KbFound(commandId, commandArgs, isBubble) {\n    return { kind: 2 /* ResultKind.KbFound */, commandId, commandArgs, isBubble };\n}\n//#endregion\n/**\n * Stores mappings from keybindings to commands and from commands to keybindings.\n * Given a sequence of chords, `resolve`s which keybinding it matches\n */\nexport class KeybindingResolver {\n    constructor(\n    /** built-in and extension-provided keybindings */\n    defaultKeybindings, \n    /** user's keybindings */\n    overrides, log) {\n        var _a;\n        this._log = log;\n        this._defaultKeybindings = defaultKeybindings;\n        this._defaultBoundCommands = new Map();\n        for (const defaultKeybinding of defaultKeybindings) {\n            const command = defaultKeybinding.command;\n            if (command && command.charAt(0) !== '-') {\n                this._defaultBoundCommands.set(command, true);\n            }\n        }\n        this._map = new Map();\n        this._lookupMap = new Map();\n        this._keybindings = KeybindingResolver.handleRemovals([].concat(defaultKeybindings).concat(overrides));\n        for (let i = 0, len = this._keybindings.length; i < len; i++) {\n            const k = this._keybindings[i];\n            if (k.chords.length === 0) {\n                // unbound\n                continue;\n            }\n            // substitute with constants that are registered after startup - https://github.com/microsoft/vscode/issues/174218#issuecomment-1437972127\n            const when = (_a = k.when) === null || _a === void 0 ? void 0 : _a.substituteConstants();\n            if (when && when.type === 0 /* ContextKeyExprType.False */) {\n                // when condition is false\n                continue;\n            }\n            this._addKeyPress(k.chords[0], k);\n        }\n    }\n    static _isTargetedForRemoval(defaultKb, keypress, when) {\n        if (keypress) {\n            for (let i = 0; i < keypress.length; i++) {\n                if (keypress[i] !== defaultKb.chords[i]) {\n                    return false;\n                }\n            }\n        }\n        // `true` means always, as does `undefined`\n        // so we will treat `true` === `undefined`\n        if (when && when.type !== 1 /* ContextKeyExprType.True */) {\n            if (!defaultKb.when) {\n                return false;\n            }\n            if (!expressionsAreEqualWithConstantSubstitution(when, defaultKb.when)) {\n                return false;\n            }\n        }\n        return true;\n    }\n    /**\n     * Looks for rules containing \"-commandId\" and removes them.\n     */\n    static handleRemovals(rules) {\n        // Do a first pass and construct a hash-map for removals\n        const removals = new Map();\n        for (let i = 0, len = rules.length; i < len; i++) {\n            const rule = rules[i];\n            if (rule.command && rule.command.charAt(0) === '-') {\n                const command = rule.command.substring(1);\n                if (!removals.has(command)) {\n                    removals.set(command, [rule]);\n                }\n                else {\n                    removals.get(command).push(rule);\n                }\n            }\n        }\n        if (removals.size === 0) {\n            // There are no removals\n            return rules;\n        }\n        // Do a second pass and keep only non-removed keybindings\n        const result = [];\n        for (let i = 0, len = rules.length; i < len; i++) {\n            const rule = rules[i];\n            if (!rule.command || rule.command.length === 0) {\n                result.push(rule);\n                continue;\n            }\n            if (rule.command.charAt(0) === '-') {\n                continue;\n            }\n            const commandRemovals = removals.get(rule.command);\n            if (!commandRemovals || !rule.isDefault) {\n                result.push(rule);\n                continue;\n            }\n            let isRemoved = false;\n            for (const commandRemoval of commandRemovals) {\n                const when = commandRemoval.when;\n                if (this._isTargetedForRemoval(rule, commandRemoval.chords, when)) {\n                    isRemoved = true;\n                    break;\n                }\n            }\n            if (!isRemoved) {\n                result.push(rule);\n                continue;\n            }\n        }\n        return result;\n    }\n    _addKeyPress(keypress, item) {\n        const conflicts = this._map.get(keypress);\n        if (typeof conflicts === 'undefined') {\n            // There is no conflict so far\n            this._map.set(keypress, [item]);\n            this._addToLookupMap(item);\n            return;\n        }\n        for (let i = conflicts.length - 1; i >= 0; i--) {\n            const conflict = conflicts[i];\n            if (conflict.command === item.command) {\n                continue;\n            }\n            // Test if the shorter keybinding is a prefix of the longer one.\n            // If the shorter keybinding is a prefix, it effectively will shadow the longer one and is considered a conflict.\n            let isShorterKbPrefix = true;\n            for (let i = 1; i < conflict.chords.length && i < item.chords.length; i++) {\n                if (conflict.chords[i] !== item.chords[i]) {\n                    // The ith step does not conflict\n                    isShorterKbPrefix = false;\n                    break;\n                }\n            }\n            if (!isShorterKbPrefix) {\n                continue;\n            }\n            if (KeybindingResolver.whenIsEntirelyIncluded(conflict.when, item.when)) {\n                // `item` completely overwrites `conflict`\n                // Remove conflict from the lookupMap\n                this._removeFromLookupMap(conflict);\n            }\n        }\n        conflicts.push(item);\n        this._addToLookupMap(item);\n    }\n    _addToLookupMap(item) {\n        if (!item.command) {\n            return;\n        }\n        let arr = this._lookupMap.get(item.command);\n        if (typeof arr === 'undefined') {\n            arr = [item];\n            this._lookupMap.set(item.command, arr);\n        }\n        else {\n            arr.push(item);\n        }\n    }\n    _removeFromLookupMap(item) {\n        if (!item.command) {\n            return;\n        }\n        const arr = this._lookupMap.get(item.command);\n        if (typeof arr === 'undefined') {\n            return;\n        }\n        for (let i = 0, len = arr.length; i < len; i++) {\n            if (arr[i] === item) {\n                arr.splice(i, 1);\n                return;\n            }\n        }\n    }\n    /**\n     * Returns true if it is provable `a` implies `b`.\n     */\n    static whenIsEntirelyIncluded(a, b) {\n        if (!b || b.type === 1 /* ContextKeyExprType.True */) {\n            return true;\n        }\n        if (!a || a.type === 1 /* ContextKeyExprType.True */) {\n            return false;\n        }\n        return implies(a, b);\n    }\n    getKeybindings() {\n        return this._keybindings;\n    }\n    lookupPrimaryKeybinding(commandId, context) {\n        const items = this._lookupMap.get(commandId);\n        if (typeof items === 'undefined' || items.length === 0) {\n            return null;\n        }\n        if (items.length === 1) {\n            return items[0];\n        }\n        for (let i = items.length - 1; i >= 0; i--) {\n            const item = items[i];\n            if (context.contextMatchesRules(item.when)) {\n                return item;\n            }\n        }\n        return items[items.length - 1];\n    }\n    /**\n     * Looks up a keybinding trigged as a result of pressing a sequence of chords - `[...currentChords, keypress]`\n     *\n     * Example: resolving 3 chords pressed sequentially - `cmd+k cmd+p cmd+i`:\n     * \t`currentChords = [ 'cmd+k' , 'cmd+p' ]` and `keypress = `cmd+i` - last pressed chord\n     */\n    resolve(context, currentChords, keypress) {\n        const pressedChords = [...currentChords, keypress];\n        this._log(`| Resolving ${pressedChords}`);\n        const kbCandidates = this._map.get(pressedChords[0]);\n        if (kbCandidates === undefined) {\n            // No bindings with such 0-th chord\n            this._log(`\\\\ No keybinding entries.`);\n            return NoMatchingKb;\n        }\n        let lookupMap = null;\n        if (pressedChords.length < 2) {\n            lookupMap = kbCandidates;\n        }\n        else {\n            // Fetch all chord bindings for `currentChords`\n            lookupMap = [];\n            for (let i = 0, len = kbCandidates.length; i < len; i++) {\n                const candidate = kbCandidates[i];\n                if (pressedChords.length > candidate.chords.length) { // # of pressed chords can't be less than # of chords in a keybinding to invoke\n                    continue;\n                }\n                let prefixMatches = true;\n                for (let i = 1; i < pressedChords.length; i++) {\n                    if (candidate.chords[i] !== pressedChords[i]) {\n                        prefixMatches = false;\n                        break;\n                    }\n                }\n                if (prefixMatches) {\n                    lookupMap.push(candidate);\n                }\n            }\n        }\n        // check there's a keybinding with a matching when clause\n        const result = this._findCommand(context, lookupMap);\n        if (!result) {\n            this._log(`\\\\ From ${lookupMap.length} keybinding entries, no when clauses matched the context.`);\n            return NoMatchingKb;\n        }\n        // check we got all chords necessary to be sure a particular keybinding needs to be invoked\n        if (pressedChords.length < result.chords.length) {\n            // The chord sequence is not complete\n            this._log(`\\\\ From ${lookupMap.length} keybinding entries, awaiting ${result.chords.length - pressedChords.length} more chord(s), when: ${printWhenExplanation(result.when)}, source: ${printSourceExplanation(result)}.`);\n            return MoreChordsNeeded;\n        }\n        this._log(`\\\\ From ${lookupMap.length} keybinding entries, matched ${result.command}, when: ${printWhenExplanation(result.when)}, source: ${printSourceExplanation(result)}.`);\n        return KbFound(result.command, result.commandArgs, result.bubble);\n    }\n    _findCommand(context, matches) {\n        for (let i = matches.length - 1; i >= 0; i--) {\n            const k = matches[i];\n            if (!KeybindingResolver._contextMatchesRules(context, k.when)) {\n                continue;\n            }\n            return k;\n        }\n        return null;\n    }\n    static _contextMatchesRules(context, rules) {\n        if (!rules) {\n            return true;\n        }\n        return rules.evaluate(context);\n    }\n}\nfunction printWhenExplanation(when) {\n    if (!when) {\n        return `no when condition`;\n    }\n    return `${when.serialize()}`;\n}\nfunction printSourceExplanation(kb) {\n    return (kb.extensionId\n        ? (kb.isBuiltinExtension ? `built-in extension ${kb.extensionId}` : `user extension ${kb.extensionId}`)\n        : (kb.isDefault ? `built-in` : `user`));\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { decodeKeybinding } from '../../../base/common/keybindings.js';\nimport { OS } from '../../../base/common/platform.js';\nimport { CommandsRegistry } from '../../commands/common/commands.js';\nimport { Registry } from '../../registry/common/platform.js';\nimport { combinedDisposable, DisposableStore, toDisposable } from '../../../base/common/lifecycle.js';\nimport { LinkedList } from '../../../base/common/linkedList.js';\n/**\n * Stores all built-in and extension-provided keybindings (but not ones that user defines themselves)\n */\nclass KeybindingsRegistryImpl {\n    constructor() {\n        this._coreKeybindings = new LinkedList();\n        this._extensionKeybindings = [];\n        this._cachedMergedKeybindings = null;\n    }\n    /**\n     * Take current platform into account and reduce to primary & secondary.\n     */\n    static bindToCurrentPlatform(kb) {\n        if (OS === 1 /* OperatingSystem.Windows */) {\n            if (kb && kb.win) {\n                return kb.win;\n            }\n        }\n        else if (OS === 2 /* OperatingSystem.Macintosh */) {\n            if (kb && kb.mac) {\n                return kb.mac;\n            }\n        }\n        else {\n            if (kb && kb.linux) {\n                return kb.linux;\n            }\n        }\n        return kb;\n    }\n    registerKeybindingRule(rule) {\n        const actualKb = KeybindingsRegistryImpl.bindToCurrentPlatform(rule);\n        const result = new DisposableStore();\n        if (actualKb && actualKb.primary) {\n            const kk = decodeKeybinding(actualKb.primary, OS);\n            if (kk) {\n                result.add(this._registerDefaultKeybinding(kk, rule.id, rule.args, rule.weight, 0, rule.when));\n            }\n        }\n        if (actualKb && Array.isArray(actualKb.secondary)) {\n            for (let i = 0, len = actualKb.secondary.length; i < len; i++) {\n                const k = actualKb.secondary[i];\n                const kk = decodeKeybinding(k, OS);\n                if (kk) {\n                    result.add(this._registerDefaultKeybinding(kk, rule.id, rule.args, rule.weight, -i - 1, rule.when));\n                }\n            }\n        }\n        return result;\n    }\n    registerCommandAndKeybindingRule(desc) {\n        return combinedDisposable(this.registerKeybindingRule(desc), CommandsRegistry.registerCommand(desc));\n    }\n    _registerDefaultKeybinding(keybinding, commandId, commandArgs, weight1, weight2, when) {\n        const remove = this._coreKeybindings.push({\n            keybinding: keybinding,\n            command: commandId,\n            commandArgs: commandArgs,\n            when: when,\n            weight1: weight1,\n            weight2: weight2,\n            extensionId: null,\n            isBuiltinExtension: false\n        });\n        this._cachedMergedKeybindings = null;\n        return toDisposable(() => {\n            remove();\n            this._cachedMergedKeybindings = null;\n        });\n    }\n    getDefaultKeybindings() {\n        if (!this._cachedMergedKeybindings) {\n            this._cachedMergedKeybindings = Array.from(this._coreKeybindings).concat(this._extensionKeybindings);\n            this._cachedMergedKeybindings.sort(sorter);\n        }\n        return this._cachedMergedKeybindings.slice(0);\n    }\n}\nexport const KeybindingsRegistry = new KeybindingsRegistryImpl();\n// Define extension point ids\nexport const Extensions = {\n    EditorModes: 'platform.keybindingsRegistry'\n};\nRegistry.add(Extensions.EditorModes, KeybindingsRegistry);\nfunction sorter(a, b) {\n    if (a.weight1 !== b.weight1) {\n        return a.weight1 - b.weight1;\n    }\n    if (a.command && b.command) {\n        if (a.command < b.command) {\n            return -1;\n        }\n        if (a.command > b.command) {\n            return 1;\n        }\n    }\n    return a.weight2 - b.weight2;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport class ResolvedKeybindingItem {\n    constructor(resolvedKeybinding, command, commandArgs, when, isDefault, extensionId, isBuiltinExtension) {\n        this._resolvedKeybindingItemBrand = undefined;\n        this.resolvedKeybinding = resolvedKeybinding;\n        this.chords = resolvedKeybinding ? toEmptyArrayIfContainsNull(resolvedKeybinding.getDispatchChords()) : [];\n        if (resolvedKeybinding && this.chords.length === 0) {\n            // handle possible single modifier chord keybindings\n            this.chords = toEmptyArrayIfContainsNull(resolvedKeybinding.getSingleModifierDispatchChords());\n        }\n        this.bubble = (command ? command.charCodeAt(0) === 94 /* CharCode.Caret */ : false);\n        this.command = this.bubble ? command.substr(1) : command;\n        this.commandArgs = commandArgs;\n        this.when = when;\n        this.isDefault = isDefault;\n        this.extensionId = extensionId;\n        this.isBuiltinExtension = isBuiltinExtension;\n    }\n}\nexport function toEmptyArrayIfContainsNull(arr) {\n    const result = [];\n    for (let i = 0, len = arr.length; i < len; i++) {\n        const element = arr[i];\n        if (!element) {\n            return [];\n        }\n        result.push(element);\n    }\n    return result;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { illegalArgument } from '../../../base/common/errors.js';\nimport { AriaLabelProvider, ElectronAcceleratorLabelProvider, UILabelProvider, UserSettingsLabelProvider } from '../../../base/common/keybindingLabels.js';\nimport { ResolvedKeybinding, ResolvedChord } from '../../../base/common/keybindings.js';\nexport class BaseResolvedKeybinding extends ResolvedKeybinding {\n    constructor(os, chords) {\n        super();\n        if (chords.length === 0) {\n            throw illegalArgument(`chords`);\n        }\n        this._os = os;\n        this._chords = chords;\n    }\n    getLabel() {\n        return UILabelProvider.toLabel(this._os, this._chords, (keybinding) => this._getLabel(keybinding));\n    }\n    getAriaLabel() {\n        return AriaLabelProvider.toLabel(this._os, this._chords, (keybinding) => this._getAriaLabel(keybinding));\n    }\n    getElectronAccelerator() {\n        if (this._chords.length > 1) {\n            // [Electron Accelerators] Electron cannot handle chords\n            return null;\n        }\n        if (this._chords[0].isDuplicateModifierCase()) {\n            // [Electron Accelerators] Electron cannot handle modifier only keybindings\n            // e.g. \"shift shift\"\n            return null;\n        }\n        return ElectronAcceleratorLabelProvider.toLabel(this._os, this._chords, (keybinding) => this._getElectronAccelerator(keybinding));\n    }\n    getUserSettingsLabel() {\n        return UserSettingsLabelProvider.toLabel(this._os, this._chords, (keybinding) => this._getUserSettingsLabel(keybinding));\n    }\n    hasMultipleChords() {\n        return (this._chords.length > 1);\n    }\n    getChords() {\n        return this._chords.map((keybinding) => this._getChord(keybinding));\n    }\n    _getChord(keybinding) {\n        return new ResolvedChord(keybinding.ctrlKey, keybinding.shiftKey, keybinding.altKey, keybinding.metaKey, this._getLabel(keybinding), this._getAriaLabel(keybinding));\n    }\n    getDispatchChords() {\n        return this._chords.map((keybinding) => this._getChordDispatch(keybinding));\n    }\n    getSingleModifierDispatchChords() {\n        return this._chords.map((keybinding) => this._getSingleModifierChordDispatch(keybinding));\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { KeyCodeUtils, IMMUTABLE_CODE_TO_KEY_CODE } from '../../../base/common/keyCodes.js';\nimport { KeyCodeChord } from '../../../base/common/keybindings.js';\nimport { BaseResolvedKeybinding } from './baseResolvedKeybinding.js';\nimport { toEmptyArrayIfContainsNull } from './resolvedKeybindingItem.js';\n/**\n * Do not instantiate. Use KeybindingService to get a ResolvedKeybinding seeded with information about the current kb layout.\n */\nexport class USLayoutResolvedKeybinding extends BaseResolvedKeybinding {\n    constructor(chords, os) {\n        super(os, chords);\n    }\n    _keyCodeToUILabel(keyCode) {\n        if (this._os === 2 /* OperatingSystem.Macintosh */) {\n            switch (keyCode) {\n                case 15 /* KeyCode.LeftArrow */:\n                    return '←';\n                case 16 /* KeyCode.UpArrow */:\n                    return '↑';\n                case 17 /* KeyCode.RightArrow */:\n                    return '→';\n                case 18 /* KeyCode.DownArrow */:\n                    return '↓';\n            }\n        }\n        return KeyCodeUtils.toString(keyCode);\n    }\n    _getLabel(chord) {\n        if (chord.isDuplicateModifierCase()) {\n            return '';\n        }\n        return this._keyCodeToUILabel(chord.keyCode);\n    }\n    _getAriaLabel(chord) {\n        if (chord.isDuplicateModifierCase()) {\n            return '';\n        }\n        return KeyCodeUtils.toString(chord.keyCode);\n    }\n    _getElectronAccelerator(chord) {\n        return KeyCodeUtils.toElectronAccelerator(chord.keyCode);\n    }\n    _getUserSettingsLabel(chord) {\n        if (chord.isDuplicateModifierCase()) {\n            return '';\n        }\n        const result = KeyCodeUtils.toUserSettingsUS(chord.keyCode);\n        return (result ? result.toLowerCase() : result);\n    }\n    _getChordDispatch(chord) {\n        return USLayoutResolvedKeybinding.getDispatchStr(chord);\n    }\n    static getDispatchStr(chord) {\n        if (chord.isModifierKey()) {\n            return null;\n        }\n        let result = '';\n        if (chord.ctrlKey) {\n            result += 'ctrl+';\n        }\n        if (chord.shiftKey) {\n            result += 'shift+';\n        }\n        if (chord.altKey) {\n            result += 'alt+';\n        }\n        if (chord.metaKey) {\n            result += 'meta+';\n        }\n        result += KeyCodeUtils.toString(chord.keyCode);\n        return result;\n    }\n    _getSingleModifierChordDispatch(keybinding) {\n        if (keybinding.keyCode === 5 /* KeyCode.Ctrl */ && !keybinding.shiftKey && !keybinding.altKey && !keybinding.metaKey) {\n            return 'ctrl';\n        }\n        if (keybinding.keyCode === 4 /* KeyCode.Shift */ && !keybinding.ctrlKey && !keybinding.altKey && !keybinding.metaKey) {\n            return 'shift';\n        }\n        if (keybinding.keyCode === 6 /* KeyCode.Alt */ && !keybinding.ctrlKey && !keybinding.shiftKey && !keybinding.metaKey) {\n            return 'alt';\n        }\n        if (keybinding.keyCode === 57 /* KeyCode.Meta */ && !keybinding.ctrlKey && !keybinding.shiftKey && !keybinding.altKey) {\n            return 'meta';\n        }\n        return null;\n    }\n    /**\n     * *NOTE*: Check return value for `KeyCode.Unknown`.\n     */\n    static _scanCodeToKeyCode(scanCode) {\n        const immutableKeyCode = IMMUTABLE_CODE_TO_KEY_CODE[scanCode];\n        if (immutableKeyCode !== -1 /* KeyCode.DependsOnKbLayout */) {\n            return immutableKeyCode;\n        }\n        switch (scanCode) {\n            case 10 /* ScanCode.KeyA */: return 31 /* KeyCode.KeyA */;\n            case 11 /* ScanCode.KeyB */: return 32 /* KeyCode.KeyB */;\n            case 12 /* ScanCode.KeyC */: return 33 /* KeyCode.KeyC */;\n            case 13 /* ScanCode.KeyD */: return 34 /* KeyCode.KeyD */;\n            case 14 /* ScanCode.KeyE */: return 35 /* KeyCode.KeyE */;\n            case 15 /* ScanCode.KeyF */: return 36 /* KeyCode.KeyF */;\n            case 16 /* ScanCode.KeyG */: return 37 /* KeyCode.KeyG */;\n            case 17 /* ScanCode.KeyH */: return 38 /* KeyCode.KeyH */;\n            case 18 /* ScanCode.KeyI */: return 39 /* KeyCode.KeyI */;\n            case 19 /* ScanCode.KeyJ */: return 40 /* KeyCode.KeyJ */;\n            case 20 /* ScanCode.KeyK */: return 41 /* KeyCode.KeyK */;\n            case 21 /* ScanCode.KeyL */: return 42 /* KeyCode.KeyL */;\n            case 22 /* ScanCode.KeyM */: return 43 /* KeyCode.KeyM */;\n            case 23 /* ScanCode.KeyN */: return 44 /* KeyCode.KeyN */;\n            case 24 /* ScanCode.KeyO */: return 45 /* KeyCode.KeyO */;\n            case 25 /* ScanCode.KeyP */: return 46 /* KeyCode.KeyP */;\n            case 26 /* ScanCode.KeyQ */: return 47 /* KeyCode.KeyQ */;\n            case 27 /* ScanCode.KeyR */: return 48 /* KeyCode.KeyR */;\n            case 28 /* ScanCode.KeyS */: return 49 /* KeyCode.KeyS */;\n            case 29 /* ScanCode.KeyT */: return 50 /* KeyCode.KeyT */;\n            case 30 /* ScanCode.KeyU */: return 51 /* KeyCode.KeyU */;\n            case 31 /* ScanCode.KeyV */: return 52 /* KeyCode.KeyV */;\n            case 32 /* ScanCode.KeyW */: return 53 /* KeyCode.KeyW */;\n            case 33 /* ScanCode.KeyX */: return 54 /* KeyCode.KeyX */;\n            case 34 /* ScanCode.KeyY */: return 55 /* KeyCode.KeyY */;\n            case 35 /* ScanCode.KeyZ */: return 56 /* KeyCode.KeyZ */;\n            case 36 /* ScanCode.Digit1 */: return 22 /* KeyCode.Digit1 */;\n            case 37 /* ScanCode.Digit2 */: return 23 /* KeyCode.Digit2 */;\n            case 38 /* ScanCode.Digit3 */: return 24 /* KeyCode.Digit3 */;\n            case 39 /* ScanCode.Digit4 */: return 25 /* KeyCode.Digit4 */;\n            case 40 /* ScanCode.Digit5 */: return 26 /* KeyCode.Digit5 */;\n            case 41 /* ScanCode.Digit6 */: return 27 /* KeyCode.Digit6 */;\n            case 42 /* ScanCode.Digit7 */: return 28 /* KeyCode.Digit7 */;\n            case 43 /* ScanCode.Digit8 */: return 29 /* KeyCode.Digit8 */;\n            case 44 /* ScanCode.Digit9 */: return 30 /* KeyCode.Digit9 */;\n            case 45 /* ScanCode.Digit0 */: return 21 /* KeyCode.Digit0 */;\n            case 51 /* ScanCode.Minus */: return 88 /* KeyCode.Minus */;\n            case 52 /* ScanCode.Equal */: return 86 /* KeyCode.Equal */;\n            case 53 /* ScanCode.BracketLeft */: return 92 /* KeyCode.BracketLeft */;\n            case 54 /* ScanCode.BracketRight */: return 94 /* KeyCode.BracketRight */;\n            case 55 /* ScanCode.Backslash */: return 93 /* KeyCode.Backslash */;\n            case 56 /* ScanCode.IntlHash */: return 0 /* KeyCode.Unknown */; // missing\n            case 57 /* ScanCode.Semicolon */: return 85 /* KeyCode.Semicolon */;\n            case 58 /* ScanCode.Quote */: return 95 /* KeyCode.Quote */;\n            case 59 /* ScanCode.Backquote */: return 91 /* KeyCode.Backquote */;\n            case 60 /* ScanCode.Comma */: return 87 /* KeyCode.Comma */;\n            case 61 /* ScanCode.Period */: return 89 /* KeyCode.Period */;\n            case 62 /* ScanCode.Slash */: return 90 /* KeyCode.Slash */;\n            case 106 /* ScanCode.IntlBackslash */: return 97 /* KeyCode.IntlBackslash */;\n        }\n        return 0 /* KeyCode.Unknown */;\n    }\n    static _toKeyCodeChord(chord) {\n        if (!chord) {\n            return null;\n        }\n        if (chord instanceof KeyCodeChord) {\n            return chord;\n        }\n        const keyCode = this._scanCodeToKeyCode(chord.scanCode);\n        if (keyCode === 0 /* KeyCode.Unknown */) {\n            return null;\n        }\n        return new KeyCodeChord(chord.ctrlKey, chord.shiftKey, chord.altKey, chord.metaKey, keyCode);\n    }\n    static resolveKeybinding(keybinding, os) {\n        const chords = toEmptyArrayIfContainsNull(keybinding.chords.map(chord => this._toKeyCodeChord(chord)));\n        if (chords.length > 0) {\n            return [new USLayoutResolvedKeybinding(chords, os)];\n        }\n        return [];\n    }\n}\n"],"names":["IEnvironmentService","ExtensionIdentifier","constructor","value","this","_lower","toLowerCase","toKey","id","ExtensionIdentifierSet","iterable","_set","Set","add","has","FileKind","__decorate","decorators","target","key","desc","d","c","arguments","length","r","Object","getOwnPropertyDescriptor","Reflect","decorate","i","defineProperty","__param","paramIndex","decorator","historyNavigationVisible","HistoryNavigationWidgetFocusContext","HistoryNavigationForwardsEnablementContext","HistoryNavigationBackwardsEnablementContext","lastFocusedWidget","widgets","registerAndCreateHistoryNavigationContext","scopedContextKeyService","widget","includes","Error","push","disposableStore","historyNavigationWidgetFocus","bindTo","historyNavigationForwardsEnablement","historyNavigationBackwardsEnablement","onDidFocus","set","onDidBlur","undefined","element","splice","indexOf","dispose","ContextScopedFindInput","container","contextViewProvider","options","contextKeyService","super","_register","createScoped","inputBox","ContextScopedReplaceInput","R","showReplaceOptions","weight","when","isEqualTo","primary","secondary","handler","accessor","showPreviousValue","showNextValue","showHistoryKeybindingHint","keybindingService","_a","_b","lookupKeybinding","getElectronAccelerator","IHoverService","WorkbenchHoverDelegate","delay","isInstantlyHovering","_delay","placement","instantHover","overrideOptions","configurationService","hoverService","lastHoverHideTime","timeLimit","hoverDisposables","getValue","onDidChangeConfiguration","e","affectsConfiguration","showHover","focus","clear","targets","targetElements","equals","hideHover","content","toString","persistence","hideOnKeyDown","appearance","compact","skipFadeInAnimation","Date","now","onDidHideHover","SyncDescriptor","ctor","staticArguments","supportsDelayedInstantiation","_registry","registerSingleton","ctorOrDescriptor","Boolean","getSingletonServiceDescriptors","_util","serviceIds","Map","DI_TARGET","DI_DEPENDENCIES","getServiceDependencies","IInstantiationService","createDecorator","serviceId","get","index","storeServiceDependency","Node","data","incoming","outgoing","Graph","_hashFn","_nodes","roots","ret","node","values","size","insertEdge","from","to","fromNode","lookupOrInsertNode","toNode","removeNode","delete","isEmpty","keys","join","findCycleSlow","seen","res","_findCycle","CyclicDependencyError","graph","message","InstantiationService","_services","_strict","_parent","_enableTracing","_isDisposed","_servicesToMaybeDispose","_children","_activeInstantiations","_globalGraph","candidate","_throwIfDisposed","createChild","services","store","that","result","invokeFunction","fn","args","_trace","Trace","traceInvocation","_done","_getOrCreateServiceInstance","stop","createInstance","rest","traceCreation","_createInstance","concat","serviceDependencies","sort","a","b","serviceArgs","dependency","service","_throwIfStrict","name","firstServiceArgPos","console","trace","delta","Array","slice","construct","_setCreatedServiceInstance","instance","_getServiceInstanceOrDescriptor","instanceOrDesc","_globalGraphImplicitDependency","String","thing","_safeCreateAndCacheServiceInstance","branch","_createAndCacheServiceInstance","cycleCount","stack","item","pop","_createServiceInstanceWithOwner","_createServiceInstance","disposeBucket","child","earlyListeners","idle","disposable","apply","listener","Proxy","create","isInitialized","startsWith","list","callback","thisArg","disposables","entry","rm","obj","prop","bind","_target","p","getPrototypeOf","prototype","msg","printWarning","warn","split","_None","type","_start","_dep","first","dur","_totals","causedCreation","lines","printChild","n","prefix","nested","toFixed","all","ServiceCollection","entries","_entries","instanceOrDescriptor","Extensions","JSONContribution","jsonContributionRegistry","_onDidChangeSchema","schemasById","registerSchema","uri","unresolvedSchemaContent","charAt","substring","fire","notifySchemaChanged","HIGH_FREQ_COMMANDS","AbstractKeybindingService","onDidUpdateKeybindings","_onDidUpdateKeybindings","event","inChordMode","_currentChords","_contextKeyService","_commandService","_telemetryService","_notificationService","_logService","_currentChordChecker","_currentChordStatusMessage","_ignoreSingleModifiers","KeybindingModifierSet","EMPTY","_currentSingleModifier","_currentSingleModifierClearTimeout","_currentlyDispatchingCommandId","_logging","_log","str","info","getKeybindings","_getResolver","commandId","context","lookupPrimaryKeybinding","resolvedKeybinding","dispatchEvent","_dispatch","softDispatch","keybinding","resolveKeyboardEvent","hasMultipleChords","N","firstChord","getDispatchChords","contextValue","getContext","currentChords","map","keypress","resolve","_scheduleLeaveChordMode","chordLastInteractedTime","cancelAndSet","_documentHasFocus","_leaveChordMode","_expectAnotherChord","keypressLabel","label","status","fullKeypressLabel","cancel","_doDispatch","_singleModifierDispatch","singleModifier","getSingleModifierDispatchChords","getChords","userKeypress","isSingleModiferChord","shouldPreventDefault","userPressedChord","dispatchKeyname","getLabel","resolveResult","kind","currentChordsLabel","hideAfter","isBubble","commandArgs","executeCommand","then","err","test","publicLog2","detail","getUserSettingsLabel","mightProducePrintableCharacter","ctrlKey","metaKey","keyCode","source","_ctrlKey","_shiftKey","shiftKey","_altKey","altKey","_metaKey","modifier","IKeybindingService","NoMatchingKb","MoreChordsNeeded","KeybindingResolver","defaultKeybindings","overrides","log","_defaultKeybindings","_defaultBoundCommands","defaultKeybinding","command","_map","_lookupMap","_keybindings","handleRemovals","len","k","chords","substituteConstants","_addKeyPress","_isTargetedForRemoval","defaultKb","rules","removals","rule","commandRemovals","isDefault","isRemoved","commandRemoval","conflicts","_addToLookupMap","conflict","isShorterKbPrefix","whenIsEntirelyIncluded","_removeFromLookupMap","arr","items","contextMatchesRules","pressedChords","kbCandidates","lookupMap","prefixMatches","_findCommand","printWhenExplanation","printSourceExplanation","bubble","matches","_contextMatchesRules","evaluate","serialize","kb","extensionId","isBuiltinExtension","KeybindingsRegistryImpl","_coreKeybindings","_extensionKeybindings","_cachedMergedKeybindings","bindToCurrentPlatform","OS","win","mac","linux","registerKeybindingRule","actualKb","kk","_registerDefaultKeybinding","isArray","registerCommandAndKeybindingRule","weight1","weight2","remove","getDefaultKeybindings","sorter","KeybindingsRegistry","ResolvedKeybindingItem","_resolvedKeybindingItemBrand","toEmptyArrayIfContainsNull","charCodeAt","substr","BaseResolvedKeybinding","os","_os","_chords","_getLabel","getAriaLabel","_getAriaLabel","isDuplicateModifierCase","_getElectronAccelerator","_getUserSettingsLabel","_getChord","_getChordDispatch","_getSingleModifierChordDispatch","USLayoutResolvedKeybinding","_keyCodeToUILabel","chord","getDispatchStr","isModifierKey","_scanCodeToKeyCode","scanCode","immutableKeyCode","_toKeyCodeChord","resolveKeybinding"],"sourceRoot":""}