@codingame/monaco-vscode-api 1.80.0-next.6 → 1.80.1-next.0

package/dist/vscode/vs/workbench/contrib/inlayHints/browser/inlayHintsAccessibilty.js

@@ -0,0 +1,172 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { EditorAction2, registerEditorContribution } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
+import { asCommandLink } from 'monaco-editor/esm/vs/editor/contrib/inlayHints/browser/inlayHints.js';
+import { InlayHintsController } from 'monaco-editor/esm/vs/editor/contrib/inlayHints/browser/inlayHintsController.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { AudioCue, IAudioCueService } from 'monaco-editor/esm/vs/platform/audioCues/browser/audioCueService.js';
+import { RawContextKey, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Link } from 'monaco-editor/esm/vs/platform/opener/browser/link.js';
+let InlayHintsAccessibility = class InlayHintsAccessibility {
+    static get(editor) {
+        return editor.getContribution(InlayHintsAccessibility.ID) ?? undefined;
+    }
+    constructor(_editor, contextKeyService, _audioCueService, _instaService) {
+        this._editor = _editor;
+        this._audioCueService = _audioCueService;
+        this._instaService = _instaService;
+        this._sessionDispoosables = ( new DisposableStore());
+        this._ariaElement = document.createElement('span');
+        this._ariaElement.style.position = 'fixed';
+        this._ariaElement.className = 'inlayhint-accessibility-element';
+        this._ariaElement.tabIndex = 0;
+        this._ariaElement.setAttribute('aria-description', ( localize('description', "Code with Inlay Hint Information")));
+        this._ctxIsReading = InlayHintsAccessibility.IsReading.bindTo(contextKeyService);
+    }
+    dispose() {
+        this._sessionDispoosables.dispose();
+        this._ctxIsReading.reset();
+        this._ariaElement.remove();
+    }
+    _reset() {
+        dom.clearNode(this._ariaElement);
+        this._sessionDispoosables.clear();
+        this._ctxIsReading.reset();
+    }
+    async _read(line, hints) {
+        this._sessionDispoosables.clear();
+        if (!this._ariaElement.isConnected) {
+            this._editor.getDomNode()?.appendChild(this._ariaElement);
+        }
+        if (!this._editor.hasModel() || !this._ariaElement.isConnected) {
+            this._ctxIsReading.set(false);
+            return;
+        }
+        const cts = ( new CancellationTokenSource());
+        this._sessionDispoosables.add(cts);
+        for (const hint of hints) {
+            await hint.resolve(cts.token);
+        }
+        if (cts.token.isCancellationRequested) {
+            return;
+        }
+        const model = this._editor.getModel();
+        const newChildren = [];
+        let start = 0;
+        let tooLongToRead = false;
+        for (const item of hints) {
+            const part = model.getValueInRange({ startLineNumber: line, startColumn: start + 1, endLineNumber: line, endColumn: item.hint.position.column });
+            if (part.length > 0) {
+                newChildren.push(part);
+                start = item.hint.position.column - 1;
+            }
+            if (start > 750) {
+                newChildren.push('…');
+                tooLongToRead = true;
+                break;
+            }
+            const em = document.createElement('em');
+            const { label } = item.hint;
+            if (typeof label === 'string') {
+                em.innerText = label;
+            }
+            else {
+                for (const part of label) {
+                    if (part.command) {
+                        const link = this._instaService.createInstance(Link, em, { href: asCommandLink(part.command), label: part.label, title: part.command.title }, undefined);
+                        this._sessionDispoosables.add(link);
+                    }
+                    else {
+                        em.innerText += part.label;
+                    }
+                }
+            }
+            newChildren.push(em);
+        }
+        if (!tooLongToRead) {
+            newChildren.push(model.getValueInRange({ startLineNumber: line, startColumn: start + 1, endLineNumber: line, endColumn: Number.MAX_SAFE_INTEGER }));
+        }
+        dom.reset(this._ariaElement, ...newChildren);
+        this._ariaElement.focus();
+        this._ctxIsReading.set(true);
+        this._sessionDispoosables.add(dom.addDisposableListener(this._ariaElement, 'focusout', () => {
+            this._reset();
+        }));
+    }
+    startInlayHintsReading() {
+        if (!this._editor.hasModel()) {
+            return;
+        }
+        const line = this._editor.getPosition().lineNumber;
+        const hints = InlayHintsController.get(this._editor)?.getInlayHintsForLine(line);
+        if (!hints || hints.length === 0) {
+            this._audioCueService.playAudioCue(AudioCue.noInlayHints);
+        }
+        else {
+            this._read(line, hints);
+        }
+    }
+    stopInlayHintsReading() {
+        this._reset();
+        this._editor.focus();
+    }
+};
+InlayHintsAccessibility.IsReading = ( new RawContextKey(
+    'isReadingLineWithInlayHints',
+    false,
+    { type: 'boolean', description: ( localize(
+        'isReadingLineWithInlayHints',
+        "Whether the current line and its inlay hints are currently focused"
+    )) }
+));
+InlayHintsAccessibility.ID = 'editor.contrib.InlayHintsAccessibility';
+InlayHintsAccessibility = ( __decorate([
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IAudioCueService)),
+    ( __param(3, IInstantiationService))
+], InlayHintsAccessibility));
+registerAction2(class StartReadHints extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'inlayHints.startReadingLineWithHint',
+            title: {
+                value: ( localize('read.title', 'Read Line With Inline Hints')),
+                original: 'Read Line With Inline Hints'
+            },
+            precondition: EditorContextKeys.hasInlayHintsProvider,
+            f1: true
+        });
+    }
+    runEditorCommand(_accessor, editor) {
+        const ctrl = InlayHintsAccessibility.get(editor);
+        ctrl?.startInlayHintsReading();
+    }
+});
+registerAction2(class StopReadHints extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'inlayHints.stopReadingLineWithHint',
+            title: {
+                value: ( localize('stop.title', 'Stop Inlay Hints Reading')),
+                original: 'Stop Inlay Hints Reading'
+            },
+            precondition: InlayHintsAccessibility.IsReading,
+            f1: true,
+            keybinding: {
+                weight: 100 ,
+                primary: 9
+            }
+        });
+    }
+    runEditorCommand(_accessor, editor) {
+        const ctrl = InlayHintsAccessibility.get(editor);
+        ctrl?.stopInlayHintsReading();
+    }
+});
+registerEditorContribution(InlayHintsAccessibility.ID, InlayHintsAccessibility, 4 );
+export { InlayHintsAccessibility };

package/dist/vscode/vs/workbench/contrib/keybindings/browser/keybindings.contribution.js

@@ -0,0 +1,24 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { showWindowLogActionId } from '../../../services/log/common/logConstants.js';
+class ToggleKeybindingsLogAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.toggleKeybindingsLog',
+            title: { value: ( nls.localize('toggleKeybindingsLog', "Toggle Keyboard Shortcuts Troubleshooting")), original: 'Toggle Keyboard Shortcuts Troubleshooting' },
+            category: Categories.Developer,
+            f1: true
+        });
+    }
+    run(accessor) {
+        const logging = accessor.get(IKeybindingService).toggleLogging();
+        if (logging) {
+            const commandService = accessor.get(ICommandService);
+            commandService.executeCommand(showWindowLogActionId);
+        }
+    }
+}
+registerAction2(ToggleKeybindingsLogAction);

package/dist/vscode/vs/workbench/contrib/languageStatus/browser/languageStatus.contribution.js

@@ -0,0 +1,360 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import './media/languageStatus.css.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { renderLabelWithIcons } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLabels.js';
+import { DisposableStore, dispose, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { getCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { themeColorFromId } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { Extensions } from '../../../common/contributions.js';
+import { STATUS_BAR_WARNING_ITEM_FOREGROUND, STATUS_BAR_WARNING_ITEM_BACKGROUND, STATUS_BAR_ERROR_ITEM_FOREGROUND, STATUS_BAR_ERROR_ITEM_BACKGROUND } from '../../../common/theme.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { ILanguageStatusService } from '../../../services/languageStatus/common/languageStatusService.js';
+import { ShowTooltipCommand, IStatusbarService } from '../../../services/statusbar/browser/statusbar.js';
+import { parseLinkedText } from 'monaco-editor/esm/vs/base/common/linkedText.js';
+import { Link } from 'monaco-editor/esm/vs/platform/opener/browser/link.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { MarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { equals } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { registerAction2, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
+class LanguageStatusViewModel {
+    constructor(combined, dedicated) {
+        this.combined = combined;
+        this.dedicated = dedicated;
+    }
+    isEqual(other) {
+        return equals(this.combined, other.combined) && equals(this.dedicated, other.dedicated);
+    }
+}
+let StoredCounter = class StoredCounter {
+    constructor(_storageService, _key) {
+        this._storageService = _storageService;
+        this._key = _key;
+    }
+    get value() {
+        return this._storageService.getNumber(this._key, 0 , 0);
+    }
+    increment() {
+        const n = this.value + 1;
+        this._storageService.store(this._key, n, 0 , 1 );
+        return n;
+    }
+};
+StoredCounter = ( __decorate([
+    ( __param(0, IStorageService))
+], StoredCounter));
+let EditorStatusContribution = class EditorStatusContribution {
+    constructor(_languageStatusService, _statusBarService, _editorService, _openerService, _storageService) {
+        this._languageStatusService = _languageStatusService;
+        this._statusBarService = _statusBarService;
+        this._editorService = _editorService;
+        this._openerService = _openerService;
+        this._storageService = _storageService;
+        this._disposables = ( new DisposableStore());
+        this._dedicated = ( new Set());
+        this._dedicatedEntries = ( new Map());
+        this._renderDisposables = ( new DisposableStore());
+        _storageService.onDidChangeValue(this._handleStorageChange, this, this._disposables);
+        this._restoreState();
+        this._interactionCounter = ( new StoredCounter(_storageService, 'languageStatus.interactCount'));
+        _languageStatusService.onDidChange(this._update, this, this._disposables);
+        _editorService.onDidActiveEditorChange(this._update, this, this._disposables);
+        this._update();
+        _statusBarService.onDidChangeEntryVisibility(e => {
+            if (!e.visible && ( this._dedicated.has(e.id))) {
+                this._dedicated.delete(e.id);
+                this._update();
+                this._storeState();
+            }
+        }, this._disposables);
+    }
+    dispose() {
+        this._disposables.dispose();
+        this._combinedEntry?.dispose();
+        dispose(( this._dedicatedEntries.values()));
+        this._renderDisposables.dispose();
+    }
+    _handleStorageChange(e) {
+        if (e.key !== EditorStatusContribution._keyDedicatedItems) {
+            return;
+        }
+        this._restoreState();
+        this._update();
+    }
+    _restoreState() {
+        const raw = this._storageService.get(EditorStatusContribution._keyDedicatedItems, 0 , '[]');
+        try {
+            const ids = JSON.parse(raw);
+            this._dedicated = ( new Set(ids));
+        }
+        catch {
+            this._dedicated.clear();
+        }
+    }
+    _storeState() {
+        if (this._dedicated.size === 0) {
+            this._storageService.remove(EditorStatusContribution._keyDedicatedItems, 0 );
+        }
+        else {
+            const raw = JSON.stringify(Array.from(( this._dedicated.keys())));
+            this._storageService.store(EditorStatusContribution._keyDedicatedItems, raw, 0 , 0 );
+        }
+    }
+    _createViewModel(editor) {
+        if (!editor?.hasModel()) {
+            return ( new LanguageStatusViewModel([], []));
+        }
+        const all = this._languageStatusService.getLanguageStatus(editor.getModel());
+        const combined = [];
+        const dedicated = [];
+        for (const item of all) {
+            if (( this._dedicated.has(item.id))) {
+                dedicated.push(item);
+            }
+            combined.push(item);
+        }
+        return ( new LanguageStatusViewModel(combined, dedicated));
+    }
+    _update() {
+        const editor = getCodeEditor(this._editorService.activeTextEditorControl);
+        const model = this._createViewModel(editor);
+        if (this._model?.isEqual(model)) {
+            return;
+        }
+        this._renderDisposables.clear();
+        this._model = model;
+        editor?.onDidChangeModelLanguage(this._update, this, this._renderDisposables);
+        if (model.combined.length === 0) {
+            this._combinedEntry?.dispose();
+            this._combinedEntry = undefined;
+        }
+        else {
+            const [first] = model.combined;
+            const showSeverity = first.severity >= Severity.Warning;
+            const text = EditorStatusContribution._severityToComboCodicon(first.severity);
+            let isOneBusy = false;
+            const ariaLabels = [];
+            const element = document.createElement('div');
+            for (const status of model.combined) {
+                const isPinned = model.dedicated.includes(status);
+                element.appendChild(this._renderStatus(status, showSeverity, isPinned, this._renderDisposables));
+                ariaLabels.push(this._asAriaLabel(status));
+                isOneBusy = isOneBusy || (!isPinned && status.busy);
+            }
+            const props = {
+                name: ( localize('langStatus.name', "Editor Language Status")),
+                ariaLabel: ( localize(
+                    'langStatus.aria',
+                    "Editor Language Status: {0}",
+                    ariaLabels.join(', next: ')
+                )),
+                tooltip: element,
+                command: ShowTooltipCommand,
+                text: isOneBusy ? `${text}\u00A0\u00A0$(sync~spin)` : text,
+            };
+            if (!this._combinedEntry) {
+                this._combinedEntry = this._statusBarService.addEntry(props, EditorStatusContribution._id, 1 , { id: 'status.editor.mode', alignment: 0 , compact: true });
+            }
+            else {
+                this._combinedEntry.update(props);
+            }
+            const userHasInteractedWithStatus = this._interactionCounter.value >= 3;
+            const node = document.querySelector('.monaco-workbench .statusbar DIV#status\\.languageStatus A>SPAN.codicon');
+            const container = document.querySelector('.monaco-workbench .statusbar DIV#status\\.languageStatus');
+            if (node instanceof HTMLElement && container) {
+                const _wiggle = 'wiggle';
+                const _flash = 'flash';
+                if (!isOneBusy) {
+                    node.classList.toggle(_wiggle, showSeverity || !userHasInteractedWithStatus);
+                    this._renderDisposables.add(dom.addDisposableListener(node, 'animationend', _e => node.classList.remove(_wiggle)));
+                    container.classList.toggle(_flash, showSeverity);
+                    this._renderDisposables.add(dom.addDisposableListener(container, 'animationend', _e => container.classList.remove(_flash)));
+                }
+                else {
+                    node.classList.remove(_wiggle);
+                    container.classList.remove(_flash);
+                }
+            }
+            if (!userHasInteractedWithStatus) {
+                const hoverTarget = document.querySelector('.monaco-workbench .context-view');
+                if (hoverTarget instanceof HTMLElement) {
+                    const observer = ( new MutationObserver(() => {
+                        if (document.contains(element)) {
+                            this._interactionCounter.increment();
+                            observer.disconnect();
+                        }
+                    }));
+                    observer.observe(hoverTarget, { childList: true, subtree: true });
+                    this._renderDisposables.add(toDisposable(() => observer.disconnect()));
+                }
+            }
+        }
+        const newDedicatedEntries = ( new Map());
+        for (const status of model.dedicated) {
+            const props = EditorStatusContribution._asStatusbarEntry(status);
+            let entry = this._dedicatedEntries.get(status.id);
+            if (!entry) {
+                entry = this._statusBarService.addEntry(props, status.id, 1 , { id: 'status.editor.mode', alignment: 1  });
+            }
+            else {
+                entry.update(props);
+                this._dedicatedEntries.delete(status.id);
+            }
+            newDedicatedEntries.set(status.id, entry);
+        }
+        dispose(( this._dedicatedEntries.values()));
+        this._dedicatedEntries = newDedicatedEntries;
+    }
+    _renderStatus(status, showSeverity, isPinned, store) {
+        const parent = document.createElement('div');
+        parent.classList.add('hover-language-status');
+        const severity = document.createElement('div');
+        severity.classList.add('severity', `sev${status.severity}`);
+        severity.classList.toggle('show', showSeverity);
+        const severityText = EditorStatusContribution._severityToSingleCodicon(status.severity);
+        dom.append(severity, ...renderLabelWithIcons(severityText));
+        parent.appendChild(severity);
+        const element = document.createElement('div');
+        element.classList.add('element');
+        parent.appendChild(element);
+        const left = document.createElement('div');
+        left.classList.add('left');
+        element.appendChild(left);
+        const label = document.createElement('span');
+        label.classList.add('label');
+        dom.append(label, ...renderLabelWithIcons(status.busy ? `$(sync~spin)\u00A0\u00A0${status.label}` : status.label));
+        left.appendChild(label);
+        const detail = document.createElement('span');
+        detail.classList.add('detail');
+        this._renderTextPlus(detail, status.detail, store);
+        left.appendChild(detail);
+        const right = document.createElement('div');
+        right.classList.add('right');
+        element.appendChild(right);
+        const { command } = status;
+        if (command) {
+            store.add(( new Link(right, {
+                label: command.title,
+                title: command.tooltip,
+                href: ( ( URI.from({
+                    scheme: 'command', path: command.id, query: command.arguments && JSON.stringify(command.arguments)
+                })).toString())
+            }, undefined, this._openerService)));
+        }
+        const actionBar = ( new ActionBar(right, {}));
+        store.add(actionBar);
+        let action;
+        if (!isPinned) {
+            action = ( new Action('pin', ( localize('pin', "Add to Status Bar")), ThemeIcon.asClassName(Codicon.pin), true, () => {
+                this._dedicated.add(status.id);
+                this._statusBarService.updateEntryVisibility(status.id, true);
+                this._update();
+                this._storeState();
+            }));
+        }
+        else {
+            action = ( new Action('unpin', ( localize('unpin', "Remove from Status Bar")), ThemeIcon.asClassName(Codicon.pinned), true, () => {
+                this._dedicated.delete(status.id);
+                this._statusBarService.updateEntryVisibility(status.id, false);
+                this._update();
+                this._storeState();
+            }));
+        }
+        actionBar.push(action, { icon: true, label: false });
+        store.add(action);
+        return parent;
+    }
+    static _severityToComboCodicon(sev) {
+        switch (sev) {
+            case Severity.Error: return '$(bracket-error)';
+            case Severity.Warning: return '$(bracket-dot)';
+            default: return '$(bracket)';
+        }
+    }
+    static _severityToSingleCodicon(sev) {
+        switch (sev) {
+            case Severity.Error: return '$(error)';
+            case Severity.Warning: return '$(info)';
+            default: return '$(check)';
+        }
+    }
+    _renderTextPlus(target, text, store) {
+        for (const node of parseLinkedText(text).nodes) {
+            if (typeof node === 'string') {
+                const parts = renderLabelWithIcons(node);
+                dom.append(target, ...parts);
+            }
+            else {
+                store.add(( new Link(target, node, undefined, this._openerService)));
+            }
+        }
+    }
+    _asAriaLabel(status) {
+        if (status.accessibilityInfo) {
+            return status.accessibilityInfo.label;
+        }
+        else if (status.detail) {
+            return ( localize('aria.1', '{0}, {1}', status.label, status.detail));
+        }
+        else {
+            return ( localize('aria.2', '{0}', status.label));
+        }
+    }
+    static _asStatusbarEntry(item) {
+        let color;
+        let backgroundColor;
+        if (item.severity === Severity.Warning) {
+            color = themeColorFromId(STATUS_BAR_WARNING_ITEM_FOREGROUND);
+            backgroundColor = themeColorFromId(STATUS_BAR_WARNING_ITEM_BACKGROUND);
+        }
+        else if (item.severity === Severity.Error) {
+            color = themeColorFromId(STATUS_BAR_ERROR_ITEM_FOREGROUND);
+            backgroundColor = themeColorFromId(STATUS_BAR_ERROR_ITEM_BACKGROUND);
+        }
+        return {
+            name: ( localize('name.pattern', '{0} (Language Status)', item.name)),
+            text: item.busy ? `${item.label}\u00A0\u00A0$(sync~spin)` : item.label,
+            ariaLabel: item.accessibilityInfo?.label ?? item.label,
+            role: item.accessibilityInfo?.role,
+            tooltip: item.command?.tooltip || ( new MarkdownString(item.detail, { isTrusted: true, supportThemeIcons: true })),
+            color,
+            backgroundColor,
+            command: item.command
+        };
+    }
+};
+EditorStatusContribution._id = 'status.languageStatus';
+EditorStatusContribution._keyDedicatedItems = 'languageStatus.dedicated';
+EditorStatusContribution = ( __decorate([
+    ( __param(0, ILanguageStatusService)),
+    ( __param(1, IStatusbarService)),
+    ( __param(2, IEditorService)),
+    ( __param(3, IOpenerService)),
+    ( __param(4, IStorageService))
+], EditorStatusContribution));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(EditorStatusContribution, 3 );
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'editor.inlayHints.Reset',
+            title: {
+                value: ( localize('reset', 'Reset Language Status Interaction Counter')),
+                original: 'Reset Language Status Interaction Counter'
+            },
+            category: Categories.View,
+            f1: true
+        });
+    }
+    run(accessor) {
+        accessor.get(IStorageService).remove('languageStatus.interactCount', 0 );
+    }
+});

package/dist/vscode/vs/workbench/contrib/languageStatus/browser/media/languageStatus.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../node_modules/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = "@keyframes wiggle{0%{transform:rotate(0) scale(1)}15%,45%{transform:rotate(.04turn) scale(1.1)}30%,60%{transform:rotate(-.04turn) scale(1.2)}to{transform:rotate(0) scale(1)}}.monaco-workbench .statusbar DIV#status\\.languageStatus A>SPAN.codicon.wiggle{animation-duration:.8s;animation-iteration-count:1;animation-name:wiggle}@keyframes flash{0%{background-color:initial}50%{background-color:var(--vscode-statusBarItem-prominentBackground)}to{background-color:initial}}.monaco-workbench .statusbar DIV#status\\.languageStatus.flash A{animation-duration:.8s;animation-iteration-count:1;animation-name:flash}.monaco-workbench .hover-language-status{display:flex;padding:4px 8px}.monaco-workbench .hover-language-status:not(:last-child){border-bottom:1px solid var(--vscode-notifications-border)}.monaco-workbench .hover-language-status>.severity{display:none;flex:1;margin:auto;padding-right:8px}.monaco-workbench .hover-language-status>.severity.sev3{color:var(--vscode-notificationsErrorIcon-foreground)}.monaco-workbench .hover-language-status>.severity.sev2{color:var(--vscode-notificationsInfoIcon-foreground)}.monaco-workbench .hover-language-status>.severity.show{display:inherit}.monaco-workbench .hover-language-status>.element{display:flex;flex-grow:100;justify-content:space-between;vertical-align:middle}.monaco-workbench .hover-language-status>.element>.left>.detail:not(:empty):before{content:\"\\2013\";opacity:.6;padding:0 4px}.monaco-workbench .hover-language-status>.element>.left>.label:empty{display:none}.monaco-workbench .hover-language-status>.element .left{margin:auto 0}.monaco-workbench .hover-language-status>.element .right{display:flex;margin:auto 0}.monaco-workbench .hover-language-status>.element .right:not(:empty){padding-left:16px}.monaco-workbench .hover-language-status>.element .right .monaco-link{margin:auto 0;white-space:nowrap}.monaco-workbench .hover-language-status>.element .right .monaco-action-bar:not(:first-child){padding-left:8px}";
+n(css,{});
+export { css, css as default };

package/dist/vscode/vs/workbench/contrib/list/browser/list.contribution.js

@@ -0,0 +1,15 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from '../../../common/contributions.js';
+let ListContext = class ListContext {
+    constructor(contextKeyService) {
+        contextKeyService.createKey('listSupportsTypeNavigation', true);
+        contextKeyService.createKey('listSupportsKeyboardNavigation', true);
+    }
+};
+ListContext = ( __decorate([
+    ( __param(0, IContextKeyService))
+], ListContext));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(ListContext, 1 );
+export { ListContext };

package/dist/vscode/vs/workbench/contrib/snippets/browser/commands/abstractSnippetsActions.js

@@ -0,0 +1,20 @@
+import { EditorAction2 } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+const defaultOptions = {
+    category: {
+        value: ( localize('snippets', 'Snippets')),
+        original: 'Snippets'
+    },
+};
+class SnippetsAction extends Action2 {
+    constructor(desc) {
+        super({ ...defaultOptions, ...desc });
+    }
+}
+class SnippetEditorAction extends EditorAction2 {
+    constructor(desc) {
+        super({ ...defaultOptions, ...desc });
+    }
+}
+export { SnippetEditorAction, SnippetsAction };