@codingame/monaco-vscode-view-common-service-override 11.1.2 → 12.0.0

package/vscode/src/vs/workbench/contrib/languageStatus/browser/languageStatus.js

@@ -0,0 +1,385 @@
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
+import './media/languageStatus.css.js';
+import { getWindow, isHTMLElement, addDisposableListener, append } from 'vscode/vscode/vs/base/browser/dom';
+import { renderLabelWithIcons } from 'vscode/vscode/vs/base/browser/ui/iconLabel/iconLabels';
+import { Disposable, DisposableStore, dispose, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import Severity from 'vscode/vscode/vs/base/common/severity';
+import { getCodeEditor } from 'vscode/vscode/vs/editor/browser/editorBrowser';
+import { localize, localize2 } from 'vscode/vscode/vs/nls';
+import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
+import { ILanguageStatusService } from 'vscode/vscode/vs/workbench/services/languageStatus/common/languageStatusService.service';
+import { ShowTooltipCommand, StatusbarAlignment } from 'vscode/vscode/vs/workbench/services/statusbar/browser/statusbar';
+import { IStatusbarService } from 'vscode/vscode/vs/workbench/services/statusbar/browser/statusbar.service';
+import { parseLinkedText } from 'vscode/vscode/vs/base/common/linkedText';
+import { Link } from 'vscode/vscode/vs/platform/opener/browser/link';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener.service';
+import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
+import { ActionBar } from 'vscode/vscode/vs/base/browser/ui/actionbar/actionbar';
+import { Action } from 'vscode/vscode/vs/base/common/actions';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { equals } from 'vscode/vscode/vs/base/common/arrays';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { Categories } from 'vscode/vscode/vs/platform/action/common/actionCommonCategories';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { nativeHoverDelegate } from 'vscode/vscode/vs/platform/hover/browser/hover';
+import { IHoverService } from 'vscode/vscode/vs/platform/hover/browser/hover.service';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { joinStrings } from 'vscode/vscode/vs/base/common/strings';
+
+var LanguageStatus_1;
+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, StorageScope.PROFILE, 0);
+    }
+    increment() {
+        const n = this.value + 1;
+        this._storageService.store(this._key, n, StorageScope.PROFILE, StorageTarget.MACHINE);
+        return n;
+    }
+};
+StoredCounter = ( __decorate([
+    ( __param(0, IStorageService))
+], StoredCounter));
+let LanguageStatusContribution = class LanguageStatusContribution extends Disposable {
+    static { this.Id = 'status.languageStatus'; }
+    constructor(editorGroupService) {
+        super();
+        this.editorGroupService = editorGroupService;
+        for (const part of editorGroupService.parts) {
+            this.createLanguageStatus(part);
+        }
+        this._register(editorGroupService.onDidCreateAuxiliaryEditorPart(part => this.createLanguageStatus(part)));
+    }
+    createLanguageStatus(part) {
+        const disposables = ( new DisposableStore());
+        Event.once(part.onWillDispose)(() => disposables.dispose());
+        const scopedInstantiationService = this.editorGroupService.getScopedInstantiationService(part);
+        disposables.add(scopedInstantiationService.createInstance(LanguageStatus));
+    }
+};
+LanguageStatusContribution = ( __decorate([
+    ( __param(0, IEditorGroupsService))
+], LanguageStatusContribution));
+let LanguageStatus = class LanguageStatus {
+    static { LanguageStatus_1 = this; }
+    static { this._id = 'status.languageStatus'; }
+    static { this._keyDedicatedItems = 'languageStatus.dedicated'; }
+    constructor(_languageStatusService, _statusBarService, _editorService, _hoverService, _openerService, _storageService) {
+        this._languageStatusService = _languageStatusService;
+        this._statusBarService = _statusBarService;
+        this._editorService = _editorService;
+        this._hoverService = _hoverService;
+        this._openerService = _openerService;
+        this._storageService = _storageService;
+        this._disposables = ( new DisposableStore());
+        this._dedicated = ( new Set());
+        this._dedicatedEntries = ( new Map());
+        this._renderDisposables = ( new DisposableStore());
+        _storageService.onDidChangeValue(StorageScope.PROFILE, LanguageStatus_1._keyDedicatedItems, this._disposables)(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();
+            }
+        }, undefined, this._disposables);
+    }
+    dispose() {
+        this._disposables.dispose();
+        this._combinedEntry?.dispose();
+        dispose(( this._dedicatedEntries.values()));
+        this._renderDisposables.dispose();
+    }
+    _handleStorageChange() {
+        this._restoreState();
+        this._update();
+    }
+    _restoreState() {
+        const raw = this._storageService.get(LanguageStatus_1._keyDedicatedItems, StorageScope.PROFILE, '[]');
+        try {
+            const ids = JSON.parse(raw);
+            this._dedicated = ( new Set(ids));
+        }
+        catch {
+            this._dedicated.clear();
+        }
+    }
+    _storeState() {
+        if (this._dedicated.size === 0) {
+            this._storageService.remove(LanguageStatus_1._keyDedicatedItems, StorageScope.PROFILE);
+        }
+        else {
+            const raw = JSON.stringify(Array.from(( this._dedicated.keys())));
+            this._storageService.store(LanguageStatus_1._keyDedicatedItems, raw, StorageScope.PROFILE, StorageTarget.USER);
+        }
+    }
+    _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 = LanguageStatus_1._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(LanguageStatus_1._accessibilityInformation(status).label);
+                isOneBusy = isOneBusy || (!isPinned && status.busy);
+            }
+            const props = {
+                name: ( localize(6937, "Editor Language Status")),
+                ariaLabel: ( localize(6938, "Editor Language Status: {0}", ariaLabels.join(', next: '))),
+                tooltip: element,
+                command: ShowTooltipCommand,
+                text: isOneBusy ? '$(loading~spin)' : text,
+            };
+            if (!this._combinedEntry) {
+                this._combinedEntry = this._statusBarService.addEntry(props, LanguageStatus_1._id, StatusbarAlignment.RIGHT, { id: 'status.editor.mode', alignment: StatusbarAlignment.LEFT, compact: true });
+            }
+            else {
+                this._combinedEntry.update(props);
+            }
+            const userHasInteractedWithStatus = this._interactionCounter.value >= 3;
+            const targetWindow = getWindow(editor?.getContainerDomNode());
+            const node = targetWindow.document.querySelector('.monaco-workbench .statusbar DIV#status\\.languageStatus A>SPAN.codicon');
+            const container = targetWindow.document.querySelector('.monaco-workbench .statusbar DIV#status\\.languageStatus');
+            if (isHTMLElement(node) && container) {
+                const _wiggle = 'wiggle';
+                const _flash = 'flash';
+                if (!isOneBusy) {
+                    node.classList.toggle(_wiggle, showSeverity || !userHasInteractedWithStatus);
+                    this._renderDisposables.add(addDisposableListener(node, 'animationend', _e => node.classList.remove(_wiggle)));
+                    container.classList.toggle(_flash, showSeverity);
+                    this._renderDisposables.add(addDisposableListener(container, 'animationend', _e => container.classList.remove(_flash)));
+                }
+                else {
+                    node.classList.remove(_wiggle);
+                    container.classList.remove(_flash);
+                }
+            }
+            if (!userHasInteractedWithStatus) {
+                const hoverTarget = targetWindow.document.querySelector('.monaco-workbench .context-view');
+                if (isHTMLElement(hoverTarget)) {
+                    const observer = ( new MutationObserver(() => {
+                        if (targetWindow.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 = LanguageStatus_1._asStatusbarEntry(status);
+            let entry = this._dedicatedEntries.get(status.id);
+            if (!entry) {
+                entry = this._statusBarService.addEntry(props, status.id, StatusbarAlignment.RIGHT, { id: 'status.editor.mode', alignment: StatusbarAlignment.RIGHT });
+            }
+            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 = LanguageStatus_1._severityToSingleCodicon(status.severity);
+        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');
+        const labelValue = typeof status.label === 'string' ? status.label : status.label.value;
+        append(label, ...renderLabelWithIcons(computeText(labelValue, status.busy)));
+        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())
+            }, { hoverDelegate: nativeHoverDelegate }, this._hoverService, this._openerService)));
+        }
+        const actionBar = ( new ActionBar(right, { hoverDelegate: nativeHoverDelegate }));
+        const actionLabel = isPinned ? ( localize(6939, "Remove from Status Bar")) : ( localize(6940, "Add to Status Bar"));
+        actionBar.setAriaLabel(actionLabel);
+        store.add(actionBar);
+        let action;
+        if (!isPinned) {
+            action = ( new Action('pin', actionLabel, 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', actionLabel, 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);
+                append(target, ...parts);
+            }
+            else {
+                store.add(( new Link(target, node, undefined, this._hoverService, this._openerService)));
+            }
+        }
+    }
+    static _accessibilityInformation(status) {
+        if (status.accessibilityInfo) {
+            return status.accessibilityInfo;
+        }
+        const textValue = typeof status.label === 'string' ? status.label : status.label.value;
+        if (status.detail) {
+            return { label: ( localize(6941, '{0}, {1}', textValue, status.detail)) };
+        }
+        else {
+            return { label: ( localize(6942, '{0}', textValue)) };
+        }
+    }
+    static _asStatusbarEntry(item) {
+        let kind;
+        if (item.severity === Severity.Warning) {
+            kind = 'warning';
+        }
+        else if (item.severity === Severity.Error) {
+            kind = 'error';
+        }
+        const textValue = typeof item.label === 'string' ? item.label : item.label.shortValue;
+        return {
+            name: ( localize(6943, '{0} (Language Status)', item.name)),
+            text: computeText(textValue, item.busy),
+            ariaLabel: LanguageStatus_1._accessibilityInformation(item).label,
+            role: item.accessibilityInfo?.role,
+            tooltip: item.command?.tooltip || ( new MarkdownString(item.detail, { isTrusted: true, supportThemeIcons: true })),
+            kind,
+            command: item.command
+        };
+    }
+};
+LanguageStatus = LanguageStatus_1 = ( __decorate([
+    ( __param(0, ILanguageStatusService)),
+    ( __param(1, IStatusbarService)),
+    ( __param(2, IEditorService)),
+    ( __param(3, IHoverService)),
+    ( __param(4, IOpenerService)),
+    ( __param(5, IStorageService))
+], LanguageStatus));
+class ResetAction extends Action2 {
+    constructor() {
+        super({
+            id: 'editor.inlayHints.Reset',
+            title: ( localize2(6944, "Reset Language Status Interaction Counter")),
+            category: Categories.View,
+            f1: true
+        });
+    }
+    run(accessor) {
+        accessor.get(IStorageService).remove('languageStatus.interactCount', StorageScope.PROFILE);
+    }
+}
+function computeText(text, loading) {
+    return joinStrings([text !== '' && text, loading && '$(loading~spin)'], '\u00A0\u00A0');
+}
+
+export { LanguageStatusContribution, ResetAction };

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

@@ -1,4 +1,4 @@
-import n from 'vscode/external/rollup-plugin-styles/dist/runtime/inject-css.js';
+import n from 'vscode/external/rollup-plugin-styles/dist/runtime/inject-css';
 
 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}.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;text-decoration:var(--text-link-decoration);white-space:nowrap}.monaco-workbench .hover-language-status>.element .right .monaco-action-bar:not(:first-child){padding-left:8px}";
 n(css,{});

package/vscode/src/vs/workbench/contrib/limitIndicator/browser/limitIndicator.contribution.d.ts

@@ -0,0 +1,13 @@
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IEditorService } from "vscode/vscode/vs/workbench/services/editor/common/editorService.service";
+import { ILanguageStatusService } from "vscode/vscode/vs/workbench/services/languageStatus/common/languageStatusService.service";
+import { IWorkbenchContribution } from "vscode/vscode/vs/workbench/common/contributions";
+import { Event } from "vscode/vscode/vs/base/common/event";
+export declare class LimitIndicatorContribution extends Disposable implements IWorkbenchContribution {
+    constructor(editorService: IEditorService, languageStatusService: ILanguageStatusService);
+}
+export interface LimitInfo {
+    readonly onDidChange: Event<void>;
+    readonly computed: number;
+    readonly limited: number | false;
+}

package/vscode/src/vs/workbench/contrib/limitIndicator/browser/limitIndicator.contribution.js

@@ -1,24 +1,24 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import Severity$1 from 'vscode/vscode/vs/base/common/severity';
+import Severity from 'vscode/vscode/vs/base/common/severity';
 import { getCodeEditor } from 'vscode/vscode/vs/editor/browser/editorBrowser';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
 import { ILanguageStatusService } from 'vscode/vscode/vs/workbench/services/languageStatus/common/languageStatusService.service';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { LifecyclePhase } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
 import { localize } from 'vscode/vscode/vs/nls';
 import { FoldingController } from 'vscode/vscode/vs/editor/contrib/folding/browser/folding';
 import { ColorDetector } from 'vscode/vscode/vs/editor/contrib/colorPicker/browser/colorDetector';
 
 const openSettingsCommand = 'workbench.action.openSettings';
-const configureSettingsLabel = ( localize(4444, "Configure"));
+const configureSettingsLabel = ( localize(6945, "Configure"));
 let LimitIndicatorContribution = class LimitIndicatorContribution extends Disposable {
     constructor(editorService, languageStatusService) {
         super();
-        const accessors = [( (new ColorDecorationAccessor())), ( (new FoldingRangeAccessor()))];
-        const statusEntries = ( (accessors.map(
-            indicator => ( (new LanguageStatusEntry(languageStatusService, indicator)))
-        )));
+        const accessors = [( new ColorDecorationAccessor()), ( new FoldingRangeAccessor())];
+        const statusEntries = ( accessors.map(indicator => ( new LanguageStatusEntry(languageStatusService, indicator))));
         statusEntries.forEach(entry => this._register(entry));
         let control;
         const onActiveEditorChanged = () => {
@@ -34,16 +34,16 @@ let LimitIndicatorContribution = class LimitIndicatorContribution extends Dispos
         onActiveEditorChanged();
     }
 };
-LimitIndicatorContribution = ( (__decorate([
-    ( (__param(0, IEditorService))),
-    ( (__param(1, ILanguageStatusService)))
-], LimitIndicatorContribution)));
+LimitIndicatorContribution = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, ILanguageStatusService))
+], LimitIndicatorContribution));
 class ColorDecorationAccessor {
     constructor() {
         this.id = 'decoratorsLimitInfo';
-        this.name = ( localize(4445, 'Color Decorator Status'));
-        this.label = ( localize(4446, 'Color Decorators'));
-        this.source = ( localize(4447, 'Color Decorators'));
+        this.name = ( localize(6946, 'Color Decorator Status'));
+        this.label = ( localize(6947, 'Color Decorators'));
+        this.source = ( localize(6948, 'Color Decorators'));
         this.settingsId = 'editor.colorDecoratorsLimit';
     }
     getLimitReporter(editor) {
@@ -53,9 +53,9 @@ class ColorDecorationAccessor {
 class FoldingRangeAccessor {
     constructor() {
         this.id = 'foldingLimitInfo';
-        this.name = ( localize(4448, 'Folding Status'));
-        this.label = ( localize(4449, 'Folding Ranges'));
-        this.source = ( localize(4450, 'Folding'));
+        this.name = ( localize(6949, 'Folding Status'));
+        this.label = ( localize(6950, 'Folding Ranges'));
+        this.source = ( localize(6951, 'Folding'));
         this.settingsId = 'editor.foldingMaximumRegions';
     }
     getLimitReporter(editor) {
@@ -95,9 +95,9 @@ class LanguageStatusEntry {
                 id: this.accessor.id,
                 selector: '*',
                 name: this.accessor.name,
-                severity: Severity$1.Warning,
+                severity: Severity.Warning,
                 label: this.accessor.label,
-                detail: ( localize(4451, 'only {0} shown for performance reasons', info.limited)),
+                detail: ( localize(6952, 'only {0} shown for performance reasons', info.limited)),
                 command: { id: openSettingsCommand, arguments: [this.accessor.settingsId], title: configureSettingsLabel },
                 accessibilityInfo: undefined,
                 source: this.accessor.source,
@@ -111,6 +111,6 @@ class LanguageStatusEntry {
         this._indicatorChangeListener = undefined;
     }
 }
-( (Registry.as(Extensions.Workbench))).registerWorkbenchContribution(LimitIndicatorContribution, 3 );
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(LimitIndicatorContribution, LifecyclePhase.Restored);
 
 export { LimitIndicatorContribution };

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/commands/commands.d.ts

@@ -0,0 +1,105 @@
+import { Action2, IAction2Options } from "vscode/vscode/vs/platform/actions/common/actions";
+import { ServicesAccessor } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { IEditorIdentifier } from "vscode/vscode/vs/workbench/common/editor";
+import { MergeEditorInput } from "@codingame/monaco-vscode-8ccb7637-50ea-5359-97bf-00015d7fe567-common/vscode/vs/workbench/contrib/mergeEditor/browser/mergeEditorInput";
+import { IMergeEditorInputModel } from "@codingame/monaco-vscode-8ccb7637-50ea-5359-97bf-00015d7fe567-common/vscode/vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel";
+import { MergeEditorViewModel } from "../view/viewModel.js";
+declare abstract class MergeEditorAction extends Action2 {
+    constructor(desc: Readonly<IAction2Options>);
+    run(accessor: ServicesAccessor): void;
+    abstract runWithViewModel(viewModel: MergeEditorViewModel, accessor: ServicesAccessor): void;
+}
+interface MergeEditorAction2Args {
+    inputModel: IMergeEditorInputModel;
+    viewModel: MergeEditorViewModel;
+    input: MergeEditorInput;
+    editorIdentifier: IEditorIdentifier;
+}
+declare abstract class MergeEditorAction2 extends Action2 {
+    constructor(desc: Readonly<IAction2Options>);
+    run(accessor: ServicesAccessor, ...args: any[]): void;
+    abstract runWithMergeEditor(context: MergeEditorAction2Args, accessor: ServicesAccessor, ...args: any[]): unknown;
+}
+export declare class OpenMergeEditor extends Action2 {
+    constructor();
+    run(accessor: ServicesAccessor, ...args: unknown[]): void;
+}
+export declare class SetMixedLayout extends Action2 {
+    constructor();
+    run(accessor: ServicesAccessor): void;
+}
+export declare class SetColumnLayout extends Action2 {
+    constructor();
+    run(accessor: ServicesAccessor): void;
+}
+export declare class ShowNonConflictingChanges extends Action2 {
+    constructor();
+    run(accessor: ServicesAccessor): void;
+}
+export declare class ShowHideBase extends Action2 {
+    constructor();
+    run(accessor: ServicesAccessor): void;
+}
+export declare class ShowHideTopBase extends Action2 {
+    constructor();
+    run(accessor: ServicesAccessor): void;
+}
+export declare class ShowHideCenterBase extends Action2 {
+    constructor();
+    run(accessor: ServicesAccessor): void;
+}
+export declare class OpenResultResource extends MergeEditorAction {
+    constructor();
+    runWithViewModel(viewModel: MergeEditorViewModel, accessor: ServicesAccessor): void;
+}
+export declare class GoToNextUnhandledConflict extends MergeEditorAction {
+    constructor();
+    runWithViewModel(viewModel: MergeEditorViewModel): void;
+}
+export declare class GoToPreviousUnhandledConflict extends MergeEditorAction {
+    constructor();
+    runWithViewModel(viewModel: MergeEditorViewModel): void;
+}
+export declare class ToggleActiveConflictInput1 extends MergeEditorAction {
+    constructor();
+    runWithViewModel(viewModel: MergeEditorViewModel): void;
+}
+export declare class ToggleActiveConflictInput2 extends MergeEditorAction {
+    constructor();
+    runWithViewModel(viewModel: MergeEditorViewModel): void;
+}
+export declare class CompareInput1WithBaseCommand extends MergeEditorAction {
+    constructor();
+    runWithViewModel(viewModel: MergeEditorViewModel, accessor: ServicesAccessor): void;
+}
+export declare class CompareInput2WithBaseCommand extends MergeEditorAction {
+    constructor();
+    runWithViewModel(viewModel: MergeEditorViewModel, accessor: ServicesAccessor): void;
+}
+export declare class OpenBaseFile extends MergeEditorAction {
+    constructor();
+    runWithViewModel(viewModel: MergeEditorViewModel, accessor: ServicesAccessor): void;
+}
+export declare class AcceptAllInput1 extends MergeEditorAction {
+    constructor();
+    runWithViewModel(viewModel: MergeEditorViewModel): void;
+}
+export declare class AcceptAllInput2 extends MergeEditorAction {
+    constructor();
+    runWithViewModel(viewModel: MergeEditorViewModel): void;
+}
+export declare class ResetToBaseAndAutoMergeCommand extends MergeEditorAction {
+    constructor();
+    runWithViewModel(viewModel: MergeEditorViewModel, accessor: ServicesAccessor): void;
+}
+export declare class ResetCloseWithConflictsChoice extends Action2 {
+    constructor();
+    run(accessor: ServicesAccessor): void;
+}
+export declare class AcceptMerge extends MergeEditorAction2 {
+    constructor();
+    runWithMergeEditor({ inputModel, editorIdentifier, viewModel }: MergeEditorAction2Args, accessor: ServicesAccessor): Promise<{
+        successful: boolean;
+    }>;
+}
+export {};