monaco-editor11 1.1.1 → 1.1.2

package/dist/workers/autorunImpl.js

@@ -0,0 +1,215 @@
+import { assertFn } from '../../assert.js';
+import '../../arrays.js';
+import { onBugIndicatingError, BugIndicatingError } from '../../errors.js';
+import '../../event.js';
+import { DisposableStore } from '../../lifecycle.js';
+import { getLogger } from '../logging/logging.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+function autorunStateToString(state) {
+    switch (state) {
+        case 1 /* AutorunState.dependenciesMightHaveChanged */: return 'dependenciesMightHaveChanged';
+        case 2 /* AutorunState.stale */: return 'stale';
+        case 3 /* AutorunState.upToDate */: return 'upToDate';
+        default: return '<unknown>';
+    }
+}
+class AutorunObserver {
+    get debugName() {
+        return this._debugNameData.getDebugName(this) ?? '(anonymous)';
+    }
+    constructor(_debugNameData, _runFn, _changeTracker, debugLocation) {
+        this._debugNameData = _debugNameData;
+        this._runFn = _runFn;
+        this._changeTracker = _changeTracker;
+        this._state = 2 /* AutorunState.stale */;
+        this._updateCount = 0;
+        this._disposed = false;
+        this._dependencies = new Set();
+        this._dependenciesToBeRemoved = new Set();
+        this._isRunning = false;
+        this._store = undefined;
+        this._delayedStore = undefined;
+        this._changeSummary = this._changeTracker?.createChangeSummary(undefined);
+        getLogger()?.handleAutorunCreated(this, debugLocation);
+        this._run();
+    }
+    dispose() {
+        if (this._disposed) {
+            return;
+        }
+        this._disposed = true;
+        for (const o of this._dependencies) {
+            o.removeObserver(this); // Warning: external call!
+        }
+        this._dependencies.clear();
+        if (this._store !== undefined) {
+            this._store.dispose();
+        }
+        if (this._delayedStore !== undefined) {
+            this._delayedStore.dispose();
+        }
+        getLogger()?.handleAutorunDisposed(this);
+    }
+    _run() {
+        const emptySet = this._dependenciesToBeRemoved;
+        this._dependenciesToBeRemoved = this._dependencies;
+        this._dependencies = emptySet;
+        this._state = 3 /* AutorunState.upToDate */;
+        try {
+            if (!this._disposed) {
+                getLogger()?.handleAutorunStarted(this);
+                const changeSummary = this._changeSummary;
+                const delayedStore = this._delayedStore;
+                if (delayedStore !== undefined) {
+                    this._delayedStore = undefined;
+                }
+                try {
+                    this._isRunning = true;
+                    if (this._changeTracker) {
+                        this._changeTracker.beforeUpdate?.(this, changeSummary);
+                        this._changeSummary = this._changeTracker.createChangeSummary(changeSummary); // Warning: external call!
+                    }
+                    if (this._store !== undefined) {
+                        this._store.dispose();
+                        this._store = undefined;
+                    }
+                    this._runFn(this, changeSummary); // Warning: external call!
+                }
+                catch (e) {
+                    onBugIndicatingError(e);
+                }
+                finally {
+                    this._isRunning = false;
+                    if (delayedStore !== undefined) {
+                        delayedStore.dispose();
+                    }
+                }
+            }
+        }
+        finally {
+            if (!this._disposed) {
+                getLogger()?.handleAutorunFinished(this);
+            }
+            // We don't want our observed observables to think that they are (not even temporarily) not being observed.
+            // Thus, we only unsubscribe from observables that are definitely not read anymore.
+            for (const o of this._dependenciesToBeRemoved) {
+                o.removeObserver(this); // Warning: external call!
+            }
+            this._dependenciesToBeRemoved.clear();
+        }
+    }
+    toString() {
+        return `Autorun<${this.debugName}>`;
+    }
+    // IObserver implementation
+    beginUpdate(_observable) {
+        if (this._state === 3 /* AutorunState.upToDate */) {
+            this._state = 1 /* AutorunState.dependenciesMightHaveChanged */;
+        }
+        this._updateCount++;
+    }
+    endUpdate(_observable) {
+        try {
+            if (this._updateCount === 1) {
+                do {
+                    if (this._state === 1 /* AutorunState.dependenciesMightHaveChanged */) {
+                        this._state = 3 /* AutorunState.upToDate */;
+                        for (const d of this._dependencies) {
+                            d.reportChanges(); // Warning: external call!
+                            if (this._state === 2 /* AutorunState.stale */) {
+                                // The other dependencies will refresh on demand
+                                break;
+                            }
+                        }
+                    }
+                    if (this._state !== 3 /* AutorunState.upToDate */) {
+                        this._run(); // Warning: indirect external call!
+                    }
+                } while (this._state !== 3 /* AutorunState.upToDate */);
+            }
+        }
+        finally {
+            this._updateCount--;
+        }
+        assertFn(() => this._updateCount >= 0);
+    }
+    handlePossibleChange(observable) {
+        if (this._state === 3 /* AutorunState.upToDate */ && this._isDependency(observable)) {
+            this._state = 1 /* AutorunState.dependenciesMightHaveChanged */;
+        }
+    }
+    handleChange(observable, change) {
+        if (this._isDependency(observable)) {
+            getLogger()?.handleAutorunDependencyChanged(this, observable, change);
+            try {
+                // Warning: external call!
+                const shouldReact = this._changeTracker ? this._changeTracker.handleChange({
+                    changedObservable: observable,
+                    change,
+                    // eslint-disable-next-line local/code-no-any-casts
+                    didChange: (o) => o === observable,
+                }, this._changeSummary) : true;
+                if (shouldReact) {
+                    this._state = 2 /* AutorunState.stale */;
+                }
+            }
+            catch (e) {
+                onBugIndicatingError(e);
+            }
+        }
+    }
+    _isDependency(observable) {
+        return this._dependencies.has(observable) && !this._dependenciesToBeRemoved.has(observable);
+    }
+    // IReader implementation
+    _ensureNoRunning() {
+        if (!this._isRunning) {
+            throw new BugIndicatingError('The reader object cannot be used outside its compute function!');
+        }
+    }
+    readObservable(observable) {
+        this._ensureNoRunning();
+        // In case the run action disposes the autorun
+        if (this._disposed) {
+            return observable.get(); // warning: external call!
+        }
+        observable.addObserver(this); // warning: external call!
+        const value = observable.get(); // warning: external call!
+        this._dependencies.add(observable);
+        this._dependenciesToBeRemoved.delete(observable);
+        return value;
+    }
+    get store() {
+        this._ensureNoRunning();
+        if (this._disposed) {
+            throw new BugIndicatingError('Cannot access store after dispose');
+        }
+        if (this._store === undefined) {
+            this._store = new DisposableStore();
+        }
+        return this._store;
+    }
+    debugGetState() {
+        return {
+            isRunning: this._isRunning,
+            updateCount: this._updateCount,
+            dependencies: this._dependencies,
+            state: this._state,
+            stateStr: autorunStateToString(this._state),
+        };
+    }
+    debugRerun() {
+        if (!this._isRunning) {
+            this._run();
+        }
+        else {
+            this._state = 2 /* AutorunState.stale */;
+        }
+    }
+}
+
+export { AutorunObserver };

package/dist/workers/azcli.contribution.js

@@ -0,0 +1,8 @@
+import { registerLanguage } from '../_.contribution.js';
+
+registerLanguage({
+  id: "azcli",
+  extensions: [".azcli"],
+  aliases: ["Azure CLI", "azcli"],
+  loader: () => import('./azcli.js')
+});

package/dist/workers/azcli.js

@@ -0,0 +1,67 @@
+const conf = {
+  comments: {
+    lineComment: "#"
+  }
+};
+const language = {
+  defaultToken: "keyword",
+  ignoreCase: true,
+  tokenPostfix: ".azcli",
+  str: /[^#\s]/,
+  tokenizer: {
+    root: [
+      { include: "@comment" },
+      [
+        /\s-+@str*\s*/,
+        {
+          cases: {
+            "@eos": { token: "key.identifier", next: "@popall" },
+            "@default": { token: "key.identifier", next: "@type" }
+          }
+        }
+      ],
+      [
+        /^-+@str*\s*/,
+        {
+          cases: {
+            "@eos": { token: "key.identifier", next: "@popall" },
+            "@default": { token: "key.identifier", next: "@type" }
+          }
+        }
+      ]
+    ],
+    type: [
+      { include: "@comment" },
+      [
+        /-+@str*\s*/,
+        {
+          cases: {
+            "@eos": { token: "key.identifier", next: "@popall" },
+            "@default": "key.identifier"
+          }
+        }
+      ],
+      [
+        /@str+\s*/,
+        {
+          cases: {
+            "@eos": { token: "string", next: "@popall" },
+            "@default": "string"
+          }
+        }
+      ]
+    ],
+    comment: [
+      [
+        /#.*$/,
+        {
+          cases: {
+            "@eos": { token: "comment", next: "@popall" }
+          }
+        }
+      ]
+    ]
+  }
+};
+
+export { conf, language };

package/dist/workers/bannerController.js

@@ -0,0 +1,118 @@
+import './bannerController.css';
+import { localize } from '../../../../nls.js';
+import { $, clearNode, append } from '../../../../base/browser/dom.js';
+import { ActionBar } from '../../../../base/browser/ui/actionbar/actionbar.js';
+import { Action } from '../../../../base/common/actions.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { IMarkdownRendererService } from '../../../../platform/markdown/browser/markdownRenderer.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { Link } from '../../../../platform/opener/browser/link.js';
+import { widgetClose } from '../../../../platform/theme/common/iconRegistry.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+const BANNER_ELEMENT_HEIGHT = 26;
+let BannerController = class BannerController extends Disposable {
+    constructor(_editor, instantiationService) {
+        super();
+        this._editor = _editor;
+        this.instantiationService = instantiationService;
+        this.banner = this._register(this.instantiationService.createInstance(Banner));
+    }
+    hide() {
+        this._editor.setBanner(null, 0);
+        this.banner.clear();
+    }
+    show(item) {
+        this.banner.show({
+            ...item,
+            onClose: () => {
+                this.hide();
+                item.onClose?.();
+            }
+        });
+        this._editor.setBanner(this.banner.element, BANNER_ELEMENT_HEIGHT);
+    }
+};
+BannerController = __decorate([
+    __param(1, IInstantiationService)
+], BannerController);
+// TODO@hediet: Investigate if this can be reused by the workspace banner (bannerPart.ts).
+let Banner = class Banner extends Disposable {
+    constructor(instantiationService, markdownRendererService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.markdownRendererService = markdownRendererService;
+        this.element = $('div.editor-banner');
+        this.element.tabIndex = 0;
+    }
+    getAriaLabel(item) {
+        if (item.ariaLabel) {
+            return item.ariaLabel;
+        }
+        if (typeof item.message === 'string') {
+            return item.message;
+        }
+        return undefined;
+    }
+    getBannerMessage(message) {
+        if (typeof message === 'string') {
+            const element = $('span');
+            element.innerText = message;
+            return element;
+        }
+        return this.markdownRendererService.render(message).element;
+    }
+    clear() {
+        clearNode(this.element);
+    }
+    show(item) {
+        // Clear previous item
+        clearNode(this.element);
+        // Banner aria label
+        const ariaLabel = this.getAriaLabel(item);
+        if (ariaLabel) {
+            this.element.setAttribute('aria-label', ariaLabel);
+        }
+        // Icon
+        const iconContainer = append(this.element, $('div.icon-container'));
+        iconContainer.setAttribute('aria-hidden', 'true');
+        if (item.icon) {
+            iconContainer.appendChild($(`div${ThemeIcon.asCSSSelector(item.icon)}`));
+        }
+        // Message
+        const messageContainer = append(this.element, $('div.message-container'));
+        messageContainer.setAttribute('aria-hidden', 'true');
+        messageContainer.appendChild(this.getBannerMessage(item.message));
+        // Message Actions
+        this.messageActionsContainer = append(this.element, $('div.message-actions-container'));
+        if (item.actions) {
+            for (const action of item.actions) {
+                this._register(this.instantiationService.createInstance(Link, this.messageActionsContainer, { ...action, tabIndex: -1 }, {}));
+            }
+        }
+        // Action
+        const actionBarContainer = append(this.element, $('div.action-container'));
+        this.actionBar = this._register(new ActionBar(actionBarContainer));
+        this.actionBar.push(this._register(new Action('banner.close', localize(1533, "Close Banner"), ThemeIcon.asClassName(widgetClose), true, () => {
+            if (typeof item.onClose === 'function') {
+                item.onClose();
+            }
+        })), { icon: true, label: false });
+        this.actionBar.setFocusable(false);
+    }
+};
+Banner = __decorate([
+    __param(0, IInstantiationService),
+    __param(1, IMarkdownRendererService)
+], Banner);
+
+export { BannerController };

package/dist/workers/base.js

@@ -0,0 +1,19 @@
+import { onUnexpectedError } from '../errors.js';
+import '../arrays.js';
+import '../event.js';
+import '../lifecycle.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * This function is used to indicate that the caller recovered from an error that indicates a bug.
+*/
+function handleBugIndicatingErrorRecovery(message) {
+    const err = new Error('BugIndicatingErrorRecovery: ' + message);
+    onUnexpectedError(err);
+    console.error('recovered from an error that indicates a bug', err);
+}
+
+export { handleBugIndicatingErrorRecovery };

package/dist/workers/baseColors.js

@@ -0,0 +1,31 @@
+import { localize } from '../../../../nls.js';
+import { Color } from '../../../../base/common/color.js';
+import { registerColor, transparent } from '../colorUtils.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const foreground = registerColor('foreground', { dark: '#CCCCCC', light: '#616161', hcDark: '#FFFFFF', hcLight: '#292929' }, localize(1773, "Overall foreground color. This color is only used if not overridden by a component."));
+registerColor('disabledForeground', { dark: '#CCCCCC80', light: '#61616180', hcDark: '#A5A5A5', hcLight: '#7F7F7F' }, localize(1774, "Overall foreground for disabled elements. This color is only used if not overridden by a component."));
+registerColor('errorForeground', { dark: '#F48771', light: '#A1260D', hcDark: '#F48771', hcLight: '#B5200D' }, localize(1775, "Overall foreground color for error messages. This color is only used if not overridden by a component."));
+const descriptionForeground = registerColor('descriptionForeground', { light: '#717171', dark: transparent(foreground, 0.7), hcDark: transparent(foreground, 0.7), hcLight: transparent(foreground, 0.7) }, localize(1776, "Foreground color for description text providing additional information, for example for a label."));
+const iconForeground = registerColor('icon.foreground', { dark: '#C5C5C5', light: '#424242', hcDark: '#FFFFFF', hcLight: '#292929' }, localize(1777, "The default color for icons in the workbench."));
+const focusBorder = registerColor('focusBorder', { dark: '#007FD4', light: '#0090F1', hcDark: '#F38518', hcLight: '#006BBD' }, localize(1778, "Overall border color for focused elements. This color is only used if not overridden by a component."));
+const contrastBorder = registerColor('contrastBorder', { light: null, dark: null, hcDark: '#6FC3DF', hcLight: '#0F4A85' }, localize(1779, "An extra border around elements to separate them from others for greater contrast."));
+const activeContrastBorder = registerColor('contrastActiveBorder', { light: null, dark: null, hcDark: focusBorder, hcLight: focusBorder }, localize(1780, "An extra border around active elements to separate them from others for greater contrast."));
+registerColor('selection.background', null, localize(1781, "The background color of text selections in the workbench (e.g. for input fields or text areas). Note that this does not apply to selections within the editor."));
+// ------ text link
+const textLinkForeground = registerColor('textLink.foreground', { light: '#006AB1', dark: '#3794FF', hcDark: '#21A6FF', hcLight: '#0F4A85' }, localize(1782, "Foreground color for links in text."));
+registerColor('textLink.activeForeground', { light: '#006AB1', dark: '#3794FF', hcDark: '#21A6FF', hcLight: '#0F4A85' }, localize(1783, "Foreground color for links in text when clicked on and on mouse hover."));
+registerColor('textSeparator.foreground', { light: '#0000002e', dark: '#ffffff2e', hcDark: Color.black, hcLight: '#292929' }, localize(1784, "Color for text separators."));
+// ------ text preformat
+registerColor('textPreformat.foreground', { light: '#A31515', dark: '#D7BA7D', hcDark: '#000000', hcLight: '#FFFFFF' }, localize(1785, "Foreground color for preformatted text segments."));
+registerColor('textPreformat.background', { light: '#0000001A', dark: '#FFFFFF1A', hcDark: '#FFFFFF', hcLight: '#09345f' }, localize(1786, "Background color for preformatted text segments."));
+// ------ text block quote
+registerColor('textBlockQuote.background', { light: '#f2f2f2', dark: '#222222', hcDark: null, hcLight: '#F2F2F2' }, localize(1787, "Background color for block quotes in text."));
+registerColor('textBlockQuote.border', { light: '#007acc80', dark: '#007acc80', hcDark: Color.white, hcLight: '#292929' }, localize(1788, "Border color for block quotes in text."));
+// ------ text code block
+registerColor('textCodeBlock.background', { light: '#dcdcdc66', dark: '#0a0a0a66', hcDark: Color.black, hcLight: '#F2F2F2' }, localize(1789, "Background color for code blocks in text."));
+
+export { activeContrastBorder, contrastBorder, descriptionForeground, focusBorder, foreground, iconForeground, textLinkForeground };

package/dist/workers/baseObservable.js

@@ -0,0 +1,106 @@
+import { DebugLocation } from '../debugLocation.js';
+import { getFunctionName } from '../debugName.js';
+import { getLogger } from '../logging/logging.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+let _derived;
+/**
+ * @internal
+ * This is to allow splitting files.
+*/
+function _setDerivedOpts(derived) {
+    _derived = derived;
+}
+let _recomputeInitiallyAndOnChange;
+function _setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange) {
+    _recomputeInitiallyAndOnChange = recomputeInitiallyAndOnChange;
+}
+class ConvenientObservable {
+    get TChange() { return null; }
+    reportChanges() {
+        this.get();
+    }
+    /** @sealed */
+    read(reader) {
+        if (reader) {
+            return reader.readObservable(this);
+        }
+        else {
+            return this.get();
+        }
+    }
+    map(fnOrOwner, fnOrUndefined, debugLocation = DebugLocation.ofCaller()) {
+        const owner = fnOrUndefined === undefined ? undefined : fnOrOwner;
+        const fn = fnOrUndefined === undefined ? fnOrOwner : fnOrUndefined;
+        return _derived({
+            owner,
+            debugName: () => {
+                const name = getFunctionName(fn);
+                if (name !== undefined) {
+                    return name;
+                }
+                // regexp to match `x => x.y` or `x => x?.y` where x and y can be arbitrary identifiers (uses backref):
+                const regexp = /^\s*\(?\s*([a-zA-Z_$][a-zA-Z_$0-9]*)\s*\)?\s*=>\s*\1(?:\??)\.([a-zA-Z_$][a-zA-Z_$0-9]*)\s*$/;
+                const match = regexp.exec(fn.toString());
+                if (match) {
+                    return `${this.debugName}.${match[2]}`;
+                }
+                if (!owner) {
+                    return `${this.debugName} (mapped)`;
+                }
+                return undefined;
+            },
+            debugReferenceFn: fn,
+        }, (reader) => fn(this.read(reader), reader), debugLocation);
+    }
+    /**
+     * @sealed
+     * Converts an observable of an observable value into a direct observable of the value.
+    */
+    flatten() {
+        return _derived({
+            owner: undefined,
+            debugName: () => `${this.debugName} (flattened)`,
+        }, (reader) => this.read(reader).read(reader));
+    }
+    recomputeInitiallyAndOnChange(store, handleValue) {
+        store.add(_recomputeInitiallyAndOnChange(this, handleValue));
+        return this;
+    }
+}
+class BaseObservable extends ConvenientObservable {
+    constructor(debugLocation) {
+        super();
+        this._observers = new Set();
+        getLogger()?.handleObservableCreated(this, debugLocation);
+    }
+    addObserver(observer) {
+        const len = this._observers.size;
+        this._observers.add(observer);
+        if (len === 0) {
+            this.onFirstObserverAdded();
+        }
+        if (len !== this._observers.size) {
+            getLogger()?.handleOnListenerCountChanged(this, this._observers.size);
+        }
+    }
+    removeObserver(observer) {
+        const deleted = this._observers.delete(observer);
+        if (deleted && this._observers.size === 0) {
+            this.onLastObserverRemoved();
+        }
+        if (deleted) {
+            getLogger()?.handleOnListenerCountChanged(this, this._observers.size);
+        }
+    }
+    onFirstObserverAdded() { }
+    onLastObserverRemoved() { }
+    debugGetObservers() {
+        return this._observers;
+    }
+}
+
+export { BaseObservable, ConvenientObservable, _setDerivedOpts, _setRecomputeInitiallyAndOnChange };

package/dist/workers/baseRenderStrategy.js

@@ -0,0 +1,19 @@
+import { ViewEventHandler } from '../../../common/viewEventHandler.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class BaseRenderStrategy extends ViewEventHandler {
+    get glyphRasterizer() { return this._glyphRasterizer.value; }
+    constructor(_context, _viewGpuContext, _device, _glyphRasterizer) {
+        super();
+        this._context = _context;
+        this._viewGpuContext = _viewGpuContext;
+        this._device = _device;
+        this._glyphRasterizer = _glyphRasterizer;
+        this._context.addEventHandler(this);
+    }
+}
+
+export { BaseRenderStrategy };

package/dist/workers/baseResolvedKeybinding.js

@@ -0,0 +1,56 @@
+import { illegalArgument } from '../../../base/common/errors.js';
+import { UILabelProvider, AriaLabelProvider, ElectronAcceleratorLabelProvider, UserSettingsLabelProvider } from '../../../base/common/keybindingLabels.js';
+import { ResolvedKeybinding, ResolvedChord } from '../../../base/common/keybindings.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class BaseResolvedKeybinding extends ResolvedKeybinding {
+    constructor(os, chords) {
+        super();
+        if (chords.length === 0) {
+            throw illegalArgument(`chords`);
+        }
+        this._os = os;
+        this._chords = chords;
+    }
+    getLabel() {
+        return UILabelProvider.toLabel(this._os, this._chords, (keybinding) => this._getLabel(keybinding));
+    }
+    getAriaLabel() {
+        return AriaLabelProvider.toLabel(this._os, this._chords, (keybinding) => this._getAriaLabel(keybinding));
+    }
+    getElectronAccelerator() {
+        if (this._chords.length > 1) {
+            // [Electron Accelerators] Electron cannot handle chords
+            return null;
+        }
+        if (this._chords[0].isDuplicateModifierCase()) {
+            // [Electron Accelerators] Electron cannot handle modifier only keybindings
+            // e.g. "shift shift"
+            return null;
+        }
+        return ElectronAcceleratorLabelProvider.toLabel(this._os, this._chords, (keybinding) => this._getElectronAccelerator(keybinding));
+    }
+    getUserSettingsLabel() {
+        return UserSettingsLabelProvider.toLabel(this._os, this._chords, (keybinding) => this._getUserSettingsLabel(keybinding));
+    }
+    hasMultipleChords() {
+        return (this._chords.length > 1);
+    }
+    getChords() {
+        return this._chords.map((keybinding) => this._getChord(keybinding));
+    }
+    _getChord(keybinding) {
+        return new ResolvedChord(keybinding.ctrlKey, keybinding.shiftKey, keybinding.altKey, keybinding.metaKey, this._getLabel(keybinding), this._getAriaLabel(keybinding));
+    }
+    getDispatchChords() {
+        return this._chords.map((keybinding) => this._getChordDispatch(keybinding));
+    }
+    getSingleModifierDispatchChords() {
+        return this._chords.map((keybinding) => this._getSingleModifierChordDispatch(keybinding));
+    }
+}
+
+export { BaseResolvedKeybinding };

package/dist/workers/bat.contribution.js

@@ -0,0 +1,8 @@
+import { registerLanguage } from '../_.contribution.js';
+
+registerLanguage({
+  id: "bat",
+  extensions: [".bat", ".cmd"],
+  aliases: ["Batch", "bat"],
+  loader: () => import('./bat.js')
+});