@codingame/monaco-vscode-api 1.79.0 → 1.79.1

package/dist/vscode/vs/workbench/browser/parts/sidebar/media/sidebarpart.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../node_modules/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-workbench.nosidebar>.part.sidebar{display:none!important;visibility:hidden!important}.monaco-workbench .part.sidebar .title-actions .actions-container{justify-content:flex-end}.monaco-workbench .part.sidebar .title-actions .action-item{margin-right:4px}.monaco-workbench .part.sidebar>.title>.title-label h2{text-transform:uppercase}.monaco-workbench .viewlet .collapsible.header .title{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.monaco-workbench .viewlet .collapsible.header .actions{width:0}.monaco-workbench .viewlet .collapsible.header.focused .actions,.monaco-workbench .viewlet .split-view-view:hover>.header .actions{flex:1;width:auto}.monaco-workbench .viewlet .collapsible.header .actions .action-label{background-position:50%;background-repeat:no-repeat;background-size:16px;height:22px;margin-right:0;width:28px}.monaco-workbench .viewlet .collapsible.header .actions .action-label .label,.monaco-workbench .viewlet .collapsible.header.collapsed .actions{display:none}.monaco-workbench .viewlet .collapsible.header .action-label{background-repeat:no-repeat;height:16px;margin-right:.2em;width:16px}";
+n(css,{});
+export { css, css as default };

package/dist/vscode/vs/workbench/browser/parts/sidebar/sidebarPart.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import "../../../../../../assets/sidebarpart.css";
+import './media/sidebarpart.css.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { CompositePart } from '../compositePart.js';
 import { Extensions } from '../../panecomposite.js';

package/dist/vscode/vs/workbench/browser/parts/statusbar/media/statusbarpart.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../node_modules/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-workbench .part.statusbar{box-sizing:border-box;cursor:default;display:flex;font-size:12px;height:22px;overflow:hidden;width:100%}.monaco-workbench:not(.reduce-motion) .part.statusbar{transition:background-color .15s ease-out}.monaco-workbench .part.statusbar.status-border-top:after{background-color:var(--status-border-top-color);content:\"\";height:1px;left:0;pointer-events:none;position:absolute;top:0;width:100%;z-index:5}.monaco-workbench .part.statusbar>.left-items,.monaco-workbench .part.statusbar>.right-items{display:flex}.monaco-workbench .part.statusbar>.right-items{flex-direction:row-reverse;flex-wrap:wrap}.monaco-workbench .part.statusbar>.left-items{flex-grow:1}.monaco-workbench .part.statusbar>.items-container>.statusbar-item{display:inline-block;font-variant-numeric:tabular-nums;height:100%;line-height:22px;max-width:40vw;vertical-align:top}.monaco-workbench .part.statusbar>.items-container>.statusbar-item.has-beak{position:relative}.monaco-workbench .part.statusbar>.items-container>.statusbar-item.has-beak>.status-bar-item-beak-container{height:5px;left:calc(50% - 5px);position:absolute;top:-5px;width:10px}.monaco-workbench .part.statusbar>.items-container>.statusbar-item.has-beak>.status-bar-item-beak-container:before{border-bottom-style:solid;border-bottom-width:5px;border-left:5px solid transparent;border-right:5px solid transparent;content:\"\";position:fixed}.monaco-workbench .part.statusbar>.items-container>.statusbar-item>.statusbar-item-label{margin-left:3px;margin-right:3px}.monaco-workbench .part.statusbar>.items-container>.statusbar-item.compact-left>.statusbar-item-label{margin-left:0;margin-right:3px}.monaco-workbench .part.statusbar>.items-container>.statusbar-item.compact-right>.statusbar-item-label{margin-left:3px;margin-right:0}.monaco-workbench .part.statusbar>.items-container>.statusbar-item.left.first-visible-item{padding-left:7px}.monaco-workbench .part.statusbar>.items-container>.statusbar-item.right.last-visible-item{margin-right:7px}.monaco-workbench .part.statusbar>.items-container>.statusbar-item.has-background-color.left.first-visible-item,.monaco-workbench .part.statusbar>.items-container>.statusbar-item.has-background-color.right.last-visible-item{padding-left:0;padding-right:0}.monaco-workbench .part.statusbar>.items-container>.statusbar-item.has-background-color>.statusbar-item-label{margin-left:0;margin-right:0;padding-left:10px;padding-right:10px}.monaco-workbench .part.statusbar>.items-container>.statusbar-item.compact-left.has-background-color>.statusbar-item-label{padding-left:3px;padding-right:10px}.monaco-workbench .part.statusbar>.items-container>.statusbar-item.compact-right.has-background-color>.statusbar-item-label{padding-left:10px;padding-right:3px}.monaco-workbench .part.statusbar>.items-container>.statusbar-item>.statusbar-item-label{align-items:center;cursor:pointer;display:flex;height:100%;outline-width:0;overflow:hidden;padding:0 5px;text-overflow:ellipsis;white-space:pre}.monaco-workbench .part.statusbar>.items-container>.statusbar-item.compact-left>.statusbar-item-label{padding:0 5px 0 3px}.monaco-workbench .part.statusbar>.items-container>.statusbar-item.compact-right>.statusbar-item-label{padding:0 3px}.monaco-workbench .part.statusbar>.items-container>.statusbar-item>a:hover:not(.disabled){text-decoration:none}.monaco-workbench .part.statusbar>.items-container>.statusbar-item>a.disabled{cursor:default}.monaco-workbench .part.statusbar>.items-container>.statusbar-item span.codicon{color:inherit;font-size:14px;text-align:center}.monaco-workbench .part.statusbar>.items-container>.statusbar-item .status-bar-info{background-color:var(--vscode-statusBarItem-prominentBackground);color:var(--vscode-statusBarItem-prominentForeground)}.monaco-workbench .part.statusbar>.items-container>.statusbar-item a.status-bar-info:hover:not(.disabled){background-color:var(--vscode-statusBarItem-prominentHoverBackground)}.monaco-workbench .part.statusbar>.items-container>.statusbar-item a:active:not(.disabled){outline:1px solid var(--vscode-contrastActiveBorder)!important;outline-offset:-1px}.monaco-workbench:not(.hc-light):not(.hc-black) .part.statusbar>.items-container>.statusbar-item a:active:not(.disabled){background-color:var(--vscode-statusBarItem-activeBackground)!important}.monaco-workbench .part.statusbar>.items-container>.statusbar-item a:hover:not(.disabled){outline:1px dashed var(--vscode-contrastActiveBorder);outline-offset:-1px}.monaco-workbench:not(.hc-light):not(.hc-black) .part.statusbar>.items-container>.statusbar-item a:hover:not(.disabled){background-color:var(--vscode-statusBarItem-hoverBackground)}";
+n(css,{});
+export { css, css as default };

package/dist/vscode/vs/workbench/browser/parts/statusbar/statusbarActions.js

@@ -0,0 +1,109 @@
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IStatusbarService } from '../../../services/statusbar/browser/statusbar.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+import { KeybindingsRegistry } from 'monaco-editor/esm/vs/platform/keybinding/common/keybindingsRegistry.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';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { StatusBarFocused } from '../../../common/contextkeys.js';
+class ToggleStatusbarEntryVisibilityAction extends Action {
+    constructor(id, label, model) {
+        super(id, label, undefined, true);
+        this.model = model;
+        this.checked = !model.isHidden(id);
+    }
+    async run() {
+        if (this.model.isHidden(this.id)) {
+            this.model.show(this.id);
+        }
+        else {
+            this.model.hide(this.id);
+        }
+    }
+}
+class HideStatusbarEntryAction extends Action {
+    constructor(id, name, model) {
+        super(id, ( localize('hide', "Hide '{0}'", name)), undefined, true);
+        this.model = model;
+    }
+    async run() {
+        this.model.hide(this.id);
+    }
+}
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'workbench.statusBar.focusPrevious',
+    weight: 200 ,
+    primary: 15 ,
+    secondary: [16 ],
+    when: StatusBarFocused,
+    handler: (accessor) => {
+        const statusBarService = accessor.get(IStatusbarService);
+        statusBarService.focusPreviousEntry();
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'workbench.statusBar.focusNext',
+    weight: 200 ,
+    primary: 17 ,
+    secondary: [18 ],
+    when: StatusBarFocused,
+    handler: (accessor) => {
+        const statusBarService = accessor.get(IStatusbarService);
+        statusBarService.focusNextEntry();
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'workbench.statusBar.focusFirst',
+    weight: 200 ,
+    primary: 14 ,
+    when: StatusBarFocused,
+    handler: (accessor) => {
+        const statusBarService = accessor.get(IStatusbarService);
+        statusBarService.focus(false);
+        statusBarService.focusNextEntry();
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'workbench.statusBar.focusLast',
+    weight: 200 ,
+    primary: 13 ,
+    when: StatusBarFocused,
+    handler: (accessor) => {
+        const statusBarService = accessor.get(IStatusbarService);
+        statusBarService.focus(false);
+        statusBarService.focusPreviousEntry();
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'workbench.statusBar.clearFocus',
+    weight: 200 ,
+    primary: 9 ,
+    when: StatusBarFocused,
+    handler: (accessor) => {
+        const statusBarService = accessor.get(IStatusbarService);
+        const editorService = accessor.get(IEditorService);
+        if (statusBarService.isEntryFocused()) {
+            statusBarService.focus(false);
+        }
+        else if (editorService.activeEditorPane) {
+            editorService.activeEditorPane.focus();
+        }
+    }
+});
+class FocusStatusBarAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.focusStatusBar',
+            title: { value: ( localize('focusStatusBar', "Focus Status Bar")), original: 'Focus Status Bar' },
+            category: Categories.View,
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const layoutService = accessor.get(IWorkbenchLayoutService);
+        layoutService.focusPart("workbench.parts.statusbar" );
+    }
+}
+registerAction2(FocusStatusBarAction);
+export { HideStatusbarEntryAction, ToggleStatusbarEntryVisibilityAction };

package/dist/vscode/vs/workbench/browser/parts/statusbar/statusbarItem.js

@@ -0,0 +1,224 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
+import { Disposable, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { SimpleIconLabel } from '../../../../base/browser/ui/iconLabel/simpleIconLabel.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 { ShowTooltipCommand } from '../../../services/statusbar/browser/statusbar.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { isThemeColor } from 'monaco-editor/esm/vs/editor/common/editorCommon.js';
+import { show, hide, addDisposableListener, EventType, EventHelper, append } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
+import { renderIcon, renderLabelWithIcons } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLabels.js';
+import { syncing, spinningLoading } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { setupCustomHover } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLabelHover.js';
+import { isMarkdownString, markdownStringEqual } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
+import { Gesture, EventType as EventType$1 } from 'monaco-editor/esm/vs/base/browser/touch.js';
+let StatusbarEntryItem = class StatusbarEntryItem extends Disposable {
+    get name() {
+        return assertIsDefined(this.entry).name;
+    }
+    get hasCommand() {
+        return typeof this.entry?.command !== 'undefined';
+    }
+    constructor(container, entry, hoverDelegate, commandService, notificationService, telemetryService, themeService) {
+        super();
+        this.container = container;
+        this.hoverDelegate = hoverDelegate;
+        this.commandService = commandService;
+        this.notificationService = notificationService;
+        this.telemetryService = telemetryService;
+        this.themeService = themeService;
+        this.entry = undefined;
+        this.foregroundListener = this._register(( new MutableDisposable()));
+        this.backgroundListener = this._register(( new MutableDisposable()));
+        this.commandMouseListener = this._register(( new MutableDisposable()));
+        this.commandTouchListener = this._register(( new MutableDisposable()));
+        this.commandKeyboardListener = this._register(( new MutableDisposable()));
+        this.hover = undefined;
+        this.labelContainer = document.createElement('a');
+        this.labelContainer.tabIndex = -1;
+        this.labelContainer.setAttribute('role', 'button');
+        this.labelContainer.className = 'statusbar-item-label';
+        this._register(Gesture.addTarget(this.labelContainer));
+        this.label = ( new StatusBarCodiconLabel(this.labelContainer));
+        this.container.appendChild(this.labelContainer);
+        this.beakContainer = document.createElement('div');
+        this.beakContainer.className = 'status-bar-item-beak-container';
+        this.container.appendChild(this.beakContainer);
+        this.update(entry);
+    }
+    update(entry) {
+        this.label.showProgress = entry.showProgress ?? false;
+        if (!this.entry || entry.text !== this.entry.text) {
+            this.label.text = entry.text;
+            if (entry.text) {
+                show(this.labelContainer);
+            }
+            else {
+                hide(this.labelContainer);
+            }
+        }
+        if (!this.entry || entry.ariaLabel !== this.entry.ariaLabel) {
+            this.container.setAttribute('aria-label', entry.ariaLabel);
+            this.labelContainer.setAttribute('aria-label', entry.ariaLabel);
+        }
+        if (!this.entry || entry.role !== this.entry.role) {
+            this.labelContainer.setAttribute('role', entry.role || 'button');
+        }
+        if (!this.entry || !this.isEqualTooltip(this.entry, entry)) {
+            const hoverContents = isMarkdownString(entry.tooltip) ? { markdown: entry.tooltip, markdownNotSupportedFallback: undefined } : entry.tooltip;
+            if (this.hover) {
+                this.hover.update(hoverContents);
+            }
+            else {
+                this.hover = this._register(setupCustomHover(this.hoverDelegate, this.container, hoverContents));
+            }
+        }
+        if (!this.entry || entry.command !== this.entry.command) {
+            this.commandMouseListener.clear();
+            this.commandTouchListener.clear();
+            this.commandKeyboardListener.clear();
+            const command = entry.command;
+            if (command && (command !== ShowTooltipCommand || this.hover) ) {
+                this.commandMouseListener.value = addDisposableListener(this.labelContainer, EventType.CLICK, () => this.executeCommand(command));
+                this.commandTouchListener.value = addDisposableListener(this.labelContainer, EventType$1.Tap, () => this.executeCommand(command));
+                this.commandKeyboardListener.value = addDisposableListener(this.labelContainer, EventType.KEY_DOWN, e => {
+                    const event = ( new StandardKeyboardEvent(e));
+                    if (event.equals(10 ) || event.equals(3 )) {
+                        EventHelper.stop(e);
+                        this.executeCommand(command);
+                    }
+                });
+                this.labelContainer.classList.remove('disabled');
+            }
+            else {
+                this.labelContainer.classList.add('disabled');
+            }
+        }
+        if (!this.entry || entry.showBeak !== this.entry.showBeak) {
+            if (entry.showBeak) {
+                this.container.classList.add('has-beak');
+            }
+            else {
+                this.container.classList.remove('has-beak');
+            }
+        }
+        if (!this.entry || entry.color !== this.entry.color) {
+            this.applyColor(this.labelContainer, entry.color);
+        }
+        if (!this.entry || entry.backgroundColor !== this.entry.backgroundColor) {
+            this.container.classList.toggle('has-background-color', !!entry.backgroundColor);
+            this.applyColor(this.container, entry.backgroundColor, true);
+        }
+        this.entry = entry;
+    }
+    isEqualTooltip({ tooltip }, { tooltip: otherTooltip }) {
+        if (tooltip === undefined) {
+            return otherTooltip === undefined;
+        }
+        if (isMarkdownString(tooltip)) {
+            return isMarkdownString(otherTooltip) && markdownStringEqual(tooltip, otherTooltip);
+        }
+        return tooltip === otherTooltip;
+    }
+    async executeCommand(command) {
+        if (command === ShowTooltipCommand) {
+            this.hover?.show(true );
+        }
+        else {
+            const id = typeof command === 'string' ? command : command.id;
+            const args = typeof command === 'string' ? [] : command.arguments ?? [];
+            this.telemetryService.publicLog2('workbenchActionExecuted', { id, from: 'status bar' });
+            try {
+                await this.commandService.executeCommand(id, ...args);
+            }
+            catch (error) {
+                this.notificationService.error(toErrorMessage(error));
+            }
+        }
+    }
+    applyColor(container, color, isBackground) {
+        let colorResult = undefined;
+        if (isBackground) {
+            this.backgroundListener.clear();
+        }
+        else {
+            this.foregroundListener.clear();
+        }
+        if (color) {
+            if (isThemeColor(color)) {
+                colorResult = this.themeService.getColorTheme().getColor(color.id)?.toString();
+                const listener = this.themeService.onDidColorThemeChange(theme => {
+                    const colorValue = theme.getColor(color.id)?.toString();
+                    if (isBackground) {
+                        container.style.backgroundColor = colorValue ?? '';
+                    }
+                    else {
+                        container.style.color = colorValue ?? '';
+                    }
+                });
+                if (isBackground) {
+                    this.backgroundListener.value = listener;
+                }
+                else {
+                    this.foregroundListener.value = listener;
+                }
+            }
+            else {
+                colorResult = color;
+            }
+        }
+        if (isBackground) {
+            container.style.backgroundColor = colorResult ?? '';
+        }
+        else {
+            container.style.color = colorResult ?? '';
+        }
+    }
+};
+StatusbarEntryItem = ( __decorate([
+    ( __param(3, ICommandService)),
+    ( __param(4, INotificationService)),
+    ( __param(5, ITelemetryService)),
+    ( __param(6, IThemeService))
+], StatusbarEntryItem));
+class StatusBarCodiconLabel extends SimpleIconLabel {
+    constructor(container) {
+        super(container);
+        this.container = container;
+        this.progressCodicon = renderIcon(syncing);
+        this.currentText = '';
+        this.currentShowProgress = false;
+    }
+    set showProgress(showProgress) {
+        if (this.currentShowProgress !== showProgress) {
+            this.currentShowProgress = showProgress;
+            this.progressCodicon = renderIcon(showProgress === 'loading' ? spinningLoading : syncing);
+            this.text = this.currentText;
+        }
+    }
+    set text(text) {
+        if (this.currentShowProgress) {
+            if (this.container.firstChild !== this.progressCodicon) {
+                this.container.appendChild(this.progressCodicon);
+            }
+            for (const node of Array.from(this.container.childNodes)) {
+                if (node !== this.progressCodicon) {
+                    node.remove();
+                }
+            }
+            let textContent = text ?? '';
+            if (textContent) {
+                textContent = ` ${textContent}`;
+            }
+            append(this.container, ...renderLabelWithIcons(textContent));
+        }
+        else {
+            super.text = text;
+        }
+    }
+}
+export { StatusbarEntryItem };

package/dist/vscode/vs/workbench/browser/parts/statusbar/statusbarModel.js

@@ -0,0 +1,251 @@
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isStatusbarEntryLocation } from '../../../services/statusbar/browser/statusbar.js';
+import { isAncestor, hide, show } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+class StatusbarViewModel extends Disposable {
+    get entries() { return this._entries.slice(0); }
+    get lastFocusedEntry() {
+        return this._lastFocusedEntry && !this.isHidden(this._lastFocusedEntry.id) ? this._lastFocusedEntry : undefined;
+    }
+    constructor(storageService) {
+        super();
+        this.storageService = storageService;
+        this._onDidChangeEntryVisibility = this._register(( new Emitter()));
+        this.onDidChangeEntryVisibility = this._onDidChangeEntryVisibility.event;
+        this._entries = [];
+        this.hidden = ( new Set());
+        this.restoreState();
+        this.registerListeners();
+    }
+    restoreState() {
+        const hiddenRaw = this.storageService.get(StatusbarViewModel.HIDDEN_ENTRIES_KEY, 0 );
+        if (hiddenRaw) {
+            try {
+                const hiddenArray = JSON.parse(hiddenRaw);
+                this.hidden = ( new Set(hiddenArray));
+            }
+            catch (error) {
+            }
+        }
+    }
+    registerListeners() {
+        this._register(this.storageService.onDidChangeValue(e => this.onDidStorageValueChange(e)));
+    }
+    onDidStorageValueChange(event) {
+        if (event.key === StatusbarViewModel.HIDDEN_ENTRIES_KEY && event.scope === 0 ) {
+            const currentlyHidden = ( new Set(this.hidden));
+            this.hidden.clear();
+            this.restoreState();
+            const changed = ( new Set());
+            for (const id of currentlyHidden) {
+                if (!( this.hidden.has(id))) {
+                    changed.add(id);
+                }
+            }
+            for (const id of this.hidden) {
+                if (!( currentlyHidden.has(id))) {
+                    changed.add(id);
+                }
+            }
+            if (changed.size > 0) {
+                for (const entry of this._entries) {
+                    if (( changed.has(entry.id))) {
+                        this.updateVisibility(entry.id, true);
+                        changed.delete(entry.id);
+                    }
+                }
+            }
+        }
+    }
+    add(entry) {
+        this._entries.push(entry);
+        this.updateVisibility(entry, false);
+        this.sort();
+        this.markFirstLastVisibleEntry();
+    }
+    remove(entry) {
+        const index = this._entries.indexOf(entry);
+        if (index >= 0) {
+            this._entries.splice(index, 1);
+            if (( this._entries.some(
+                otherEntry => isStatusbarEntryLocation(otherEntry.priority.primary) && otherEntry.priority.primary.id === entry.id
+            ))) {
+                this.sort();
+            }
+            this.markFirstLastVisibleEntry();
+        }
+    }
+    isHidden(id) {
+        return ( this.hidden.has(id));
+    }
+    hide(id) {
+        if (!( this.hidden.has(id))) {
+            this.hidden.add(id);
+            this.updateVisibility(id, true);
+            this.saveState();
+        }
+    }
+    show(id) {
+        if (( this.hidden.has(id))) {
+            this.hidden.delete(id);
+            this.updateVisibility(id, true);
+            this.saveState();
+        }
+    }
+    findEntry(container) {
+        return this._entries.find(entry => entry.container === container);
+    }
+    getEntries(alignment) {
+        return this._entries.filter(entry => entry.alignment === alignment);
+    }
+    focusNextEntry() {
+        this.focusEntry(+1, 0);
+    }
+    focusPreviousEntry() {
+        this.focusEntry(-1, this.entries.length - 1);
+    }
+    isEntryFocused() {
+        return !!this.getFocusedEntry();
+    }
+    getFocusedEntry() {
+        return this._entries.find(entry => isAncestor(document.activeElement, entry.container));
+    }
+    focusEntry(delta, restartPosition) {
+        const getVisibleEntry = (start) => {
+            let indexToFocus = start;
+            let entry = (indexToFocus >= 0 && indexToFocus < this._entries.length) ? this._entries[indexToFocus] : undefined;
+            while (entry && this.isHidden(entry.id)) {
+                indexToFocus += delta;
+                entry = (indexToFocus >= 0 && indexToFocus < this._entries.length) ? this._entries[indexToFocus] : undefined;
+            }
+            return entry;
+        };
+        const focused = this.getFocusedEntry();
+        if (focused) {
+            const entry = getVisibleEntry(this._entries.indexOf(focused) + delta);
+            if (entry) {
+                this._lastFocusedEntry = entry;
+                entry.labelContainer.focus();
+                return;
+            }
+        }
+        const entry = getVisibleEntry(restartPosition);
+        if (entry) {
+            this._lastFocusedEntry = entry;
+            entry.labelContainer.focus();
+        }
+    }
+    updateVisibility(arg1, trigger) {
+        if (typeof arg1 === 'string') {
+            const id = arg1;
+            for (const entry of this._entries) {
+                if (entry.id === id) {
+                    this.updateVisibility(entry, trigger);
+                }
+            }
+        }
+        else {
+            const entry = arg1;
+            const isHidden = this.isHidden(entry.id);
+            if (isHidden) {
+                hide(entry.container);
+            }
+            else {
+                show(entry.container);
+            }
+            if (trigger) {
+                this._onDidChangeEntryVisibility.fire({ id: entry.id, visible: !isHidden });
+            }
+            this.markFirstLastVisibleEntry();
+        }
+    }
+    saveState() {
+        if (this.hidden.size > 0) {
+            this.storageService.store(StatusbarViewModel.HIDDEN_ENTRIES_KEY, JSON.stringify(Array.from(( this.hidden.values()))), 0 , 0 );
+        }
+        else {
+            this.storageService.remove(StatusbarViewModel.HIDDEN_ENTRIES_KEY, 0 );
+        }
+    }
+    sort() {
+        const mapEntryWithNumberedPriorityToIndex = ( new Map());
+        const mapEntryWithRelativePriority = ( new Map());
+        for (let i = 0; i < this._entries.length; i++) {
+            const entry = this._entries[i];
+            if (typeof entry.priority.primary === 'number') {
+                mapEntryWithNumberedPriorityToIndex.set(entry, i);
+            }
+            else {
+                let entries = mapEntryWithRelativePriority.get(entry.priority.primary.id);
+                if (!entries) {
+                    entries = [];
+                    mapEntryWithRelativePriority.set(entry.priority.primary.id, entries);
+                }
+                entries.push(entry);
+            }
+        }
+        const sortedEntriesWithNumberedPriority = Array.from(( mapEntryWithNumberedPriorityToIndex.keys()));
+        sortedEntriesWithNumberedPriority.sort((entryA, entryB) => {
+            if (entryA.alignment === entryB.alignment) {
+                if (entryA.priority.primary !== entryB.priority.primary) {
+                    return Number(entryB.priority.primary) - Number(entryA.priority.primary);
+                }
+                if (entryA.priority.secondary !== entryB.priority.secondary) {
+                    return entryB.priority.secondary - entryA.priority.secondary;
+                }
+                return mapEntryWithNumberedPriorityToIndex.get(entryA) - mapEntryWithNumberedPriorityToIndex.get(entryB);
+            }
+            if (entryA.alignment === 0 ) {
+                return -1;
+            }
+            if (entryB.alignment === 0 ) {
+                return 1;
+            }
+            return 0;
+        });
+        let sortedEntries;
+        if (mapEntryWithRelativePriority.size > 0) {
+            sortedEntries = [];
+            for (const entry of sortedEntriesWithNumberedPriority) {
+                const relativeEntries = mapEntryWithRelativePriority.get(entry.id);
+                if (relativeEntries) {
+                    sortedEntries.push(...relativeEntries.filter(entry => isStatusbarEntryLocation(entry.priority.primary) && entry.priority.primary.alignment === 0 ));
+                }
+                sortedEntries.push(entry);
+                if (relativeEntries) {
+                    sortedEntries.push(...relativeEntries.filter(entry => isStatusbarEntryLocation(entry.priority.primary) && entry.priority.primary.alignment === 1 ));
+                }
+                mapEntryWithRelativePriority.delete(entry.id);
+            }
+            for (const [, entries] of mapEntryWithRelativePriority) {
+                sortedEntries.push(...entries);
+            }
+        }
+        else {
+            sortedEntries = sortedEntriesWithNumberedPriority;
+        }
+        this._entries = sortedEntries;
+    }
+    markFirstLastVisibleEntry() {
+        this.doMarkFirstLastVisibleStatusbarItem(this.getEntries(0 ));
+        this.doMarkFirstLastVisibleStatusbarItem(this.getEntries(1 ));
+    }
+    doMarkFirstLastVisibleStatusbarItem(entries) {
+        let firstVisibleItem;
+        let lastVisibleItem;
+        for (const entry of entries) {
+            entry.container.classList.remove('first-visible-item', 'last-visible-item');
+            const isVisible = !this.isHidden(entry.id);
+            if (isVisible) {
+                if (!firstVisibleItem) {
+                    firstVisibleItem = entry;
+                }
+                lastVisibleItem = entry;
+            }
+        }
+        firstVisibleItem?.container.classList.add('first-visible-item');
+        lastVisibleItem?.container.classList.add('last-visible-item');
+    }
+}
+StatusbarViewModel.HIDDEN_ENTRIES_KEY = 'workbench.statusbar.hidden';
+export { StatusbarViewModel };