@codingame/monaco-vscode-api 1.80.0 → 1.80.1

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

@@ -0,0 +1,132 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.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 { Extensions } from '../../../common/contributions.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { IStatusbarService } from '../../../services/statusbar/browser/statusbar.js';
+import { ILanguageDetectionService, LanguageDetectionLanguageEventSource } from '../../../services/languageDetection/common/languageDetectionWorkerService.js';
+import { ThrottledDelayer } from 'monaco-editor/esm/vs/base/common/async.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { registerAction2, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { NOTEBOOK_EDITOR_EDITABLE } from '../../notebook/common/notebookContextKeys.js';
+import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+const detectLanguageCommandId = 'editor.detectLanguage';
+let LanguageDetectionStatusContribution = class LanguageDetectionStatusContribution {
+    constructor(_languageDetectionService, _statusBarService, _configurationService, _editorService, _languageService, _keybindingService) {
+        this._languageDetectionService = _languageDetectionService;
+        this._statusBarService = _statusBarService;
+        this._configurationService = _configurationService;
+        this._editorService = _editorService;
+        this._languageService = _languageService;
+        this._keybindingService = _keybindingService;
+        this._disposables = ( new DisposableStore());
+        this._delayer = ( new ThrottledDelayer(1000));
+        this._renderDisposables = ( new DisposableStore());
+        _editorService.onDidActiveEditorChange(() => this._update(true), this, this._disposables);
+        this._update(false);
+    }
+    dispose() {
+        this._disposables.dispose();
+        this._delayer.dispose();
+        this._combinedEntry?.dispose();
+        this._renderDisposables.dispose();
+    }
+    _update(clear) {
+        if (clear) {
+            this._combinedEntry?.dispose();
+            this._combinedEntry = undefined;
+        }
+        this._delayer.trigger(() => this._doUpdate());
+    }
+    async _doUpdate() {
+        const editor = getCodeEditor(this._editorService.activeTextEditorControl);
+        this._renderDisposables.clear();
+        editor?.onDidChangeModelLanguage(() => this._update(true), this, this._renderDisposables);
+        editor?.onDidChangeModelContent(() => this._update(false), this, this._renderDisposables);
+        const editorModel = editor?.getModel();
+        const editorUri = editorModel?.uri;
+        const existingId = editorModel?.getLanguageId();
+        const enablementConfig = this._configurationService.getValue('workbench.editor.languageDetectionHints');
+        const enabled = typeof enablementConfig === 'object' && enablementConfig?.untitledEditors;
+        const disableLightbulb = !enabled || editorUri?.scheme !== Schemas.untitled || !existingId;
+        if (disableLightbulb || !editorUri) {
+            this._combinedEntry?.dispose();
+            this._combinedEntry = undefined;
+        }
+        else {
+            const lang = await this._languageDetectionService.detectLanguage(editorUri);
+            const skip = { 'jsonc': 'json' };
+            const existing = editorModel.getLanguageId();
+            if (lang && lang !== existing && skip[existing] !== lang) {
+                const detectedName = this._languageService.getLanguageName(lang) || lang;
+                let tooltip = ( localize('status.autoDetectLanguage', "Accept Detected Language: {0}", detectedName));
+                const keybinding = this._keybindingService.lookupKeybinding(detectLanguageCommandId);
+                const label = keybinding?.getLabel();
+                if (label) {
+                    tooltip += ` (${label})`;
+                }
+                const props = {
+                    name: ( localize('langDetection.name', "Language Detection")),
+                    ariaLabel: ( localize('langDetection.aria', "Change to Detected Language: {0}", lang)),
+                    tooltip,
+                    command: detectLanguageCommandId,
+                    text: '$(lightbulb-autofix)',
+                };
+                if (!this._combinedEntry) {
+                    this._combinedEntry = this._statusBarService.addEntry(props, LanguageDetectionStatusContribution._id, 1 , { id: 'status.editor.mode', alignment: 1 , compact: true });
+                }
+                else {
+                    this._combinedEntry.update(props);
+                }
+            }
+            else {
+                this._combinedEntry?.dispose();
+                this._combinedEntry = undefined;
+            }
+        }
+    }
+};
+LanguageDetectionStatusContribution._id = 'status.languageDetectionStatus';
+LanguageDetectionStatusContribution = ( __decorate([
+    ( __param(0, ILanguageDetectionService)),
+    ( __param(1, IStatusbarService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IEditorService)),
+    ( __param(4, ILanguageService)),
+    ( __param(5, IKeybindingService))
+], LanguageDetectionStatusContribution));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(LanguageDetectionStatusContribution, 3 );
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: detectLanguageCommandId,
+            title: { value: ( localize('detectlang', 'Detect Language from Content')), original: 'Detect Language from Content' },
+            f1: true,
+            precondition: ( ContextKeyExpr.and(( NOTEBOOK_EDITOR_EDITABLE.toNegated()), EditorContextKeys.editorTextFocus)),
+            keybinding: { primary: 34  | 512  | 1024 , weight: 200  }
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const languageDetectionService = accessor.get(ILanguageDetectionService);
+        const editor = getCodeEditor(editorService.activeTextEditorControl);
+        const notificationService = accessor.get(INotificationService);
+        const editorUri = editor?.getModel()?.uri;
+        if (editorUri) {
+            const lang = await languageDetectionService.detectLanguage(editorUri);
+            if (lang) {
+                editor.getModel()?.setLanguage(lang, LanguageDetectionLanguageEventSource);
+            }
+            else {
+                notificationService.warn(( localize('noDetection', "Unable to detect editor language")));
+            }
+        }
+    }
+});

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/mergeEditor/browser/mergeEditorInputModel.js

@@ -9,7 +9,7 @@ import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
 import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
 import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
 import { SaveSourceRegistry } from '../../../common/editor.js';
@@ -20,6 +20,7 @@ import { MergeEditorModel } from './model/mergeEditorModel.js';
 import { StorageCloseWithConflicts } from '../common/mergeEditor.js';
 import { IEditorService } from '../../../services/editor/common/editorService.js';
 import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
 let TempFileMergeEditorModeFactory = class TempFileMergeEditorModeFactory {
     constructor(_mergeEditorTelemetry, _instantiationService, _textModelService, _modelService) {
         this._mergeEditorTelemetry = _mergeEditorTelemetry;

package/dist/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys.js

@@ -0,0 +1,3 @@
+import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+const NOTEBOOK_EDITOR_EDITABLE = ( new RawContextKey('notebookEditable', true));
+export { NOTEBOOK_EDITOR_EDITABLE };

package/dist/vscode/vs/workbench/contrib/quickaccess/browser/commandsQuickAccess.js

@@ -11,7 +11,7 @@ import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiati
 import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
 import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
 import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
 import { DefaultQuickAccessFilterValue } from 'monaco-editor/esm/vs/platform/quickinput/common/quickAccess.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
@@ -27,6 +27,7 @@ import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/pr
 import { ISemanticSimilarityService } from '../../../services/semanticSimilarity/common/semanticSimilarityService.js';
 import { IChatService } from '../../chat/common/chatService.js';
 import { ASK_QUICK_QUESTION_ACTION_ID } from '../../chat/browser/actions/chatQuickInputActions.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
 let CommandsQuickAccessProvider = class CommandsQuickAccessProvider extends AbstractEditorCommandsQuickAccessProvider {
     get activeTextEditorControl() { return this.editorService.activeTextEditorControl; }
     get defaultFilterValue() {

package/dist/vscode/vs/workbench/contrib/search/browser/searchView.js

@@ -27,7 +27,7 @@ import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/c
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { IContextViewService, IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
-import { IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
 import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { ServiceCollection } from 'monaco-editor/esm/vs/platform/instantiation/common/serviceCollection.js';
@@ -69,6 +69,7 @@ import { ITextFileService } from '../../../services/textfile/common/textfiles.js
 import { INotebookService } from '../../notebook/common/notebookService.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { TextSearchCompleteMessageType } from '../../../services/search/common/searchExtTypes.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
 const $ = dom.$;
 const SEARCH_CANCELLED_MESSAGE = ( nls.localize(
     'searchCanceled',

package/dist/vscode/vs/workbench/contrib/searchEditor/browser/searchEditorInput.js

@@ -6,7 +6,7 @@ import { isEqual, extname, joinPath } from 'monaco-editor/esm/vs/base/common/res
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { IFileDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
 import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
@@ -21,6 +21,7 @@ import { IWorkingCopyService } from '../../../services/workingCopy/common/workin
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { bufferToReadable, VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
 import { EditorInput } from '../../../common/editor/editorInput.js';
+import { IFileDialogService } from '../../../../platform/dialogs/common/dialogs.js';
 const SEARCH_EDITOR_EXT = '.code-search';
 let SearchEditorInput = class SearchEditorInput extends EditorInput {
     get typeId() {

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 };