@codingame/monaco-vscode-api 1.81.8-next.3 → 1.82.0-next.0

package/vscode/src/vs/workbench/services/history/browser/historyService.js

@@ -25,7 +25,9 @@ import { IPathService } from '../../path/common/pathService.js';
 import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
 import { ILifecycleService } from '../../lifecycle/common/lifecycle.js';
 import { LogLevel, ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+var HistoryService_1, EditorNavigationStack_1;
 let HistoryService = class HistoryService extends Disposable {
+    static { HistoryService_1 = this; }
     static { this.MOUSE_NAVIGATION_SETTING = 'workbench.editor.mouseBackForwardToNavigate'; }
     static { this.NAVIGATION_SCOPE_SETTING = 'workbench.editor.navigationScope'; }
     constructor(editorService, editorGroupService, contextService, storageService, configurationService, fileService, workspacesService, instantiationService, layoutService, contextKeyService) {
@@ -127,13 +129,13 @@ let HistoryService = class HistoryService extends Disposable {
         const mouseBackForwardSupportListener = this._register(( (new DisposableStore())));
         const handleMouseBackForwardSupport = () => {
             mouseBackForwardSupportListener.clear();
-            if (this.configurationService.getValue(HistoryService.MOUSE_NAVIGATION_SETTING)) {
+            if (this.configurationService.getValue(HistoryService_1.MOUSE_NAVIGATION_SETTING)) {
                 mouseBackForwardSupportListener.add(addDisposableListener(this.layoutService.container, EventType.MOUSE_DOWN, e => this.onMouseDownOrUp(e, true)));
                 mouseBackForwardSupportListener.add(addDisposableListener(this.layoutService.container, EventType.MOUSE_UP, e => this.onMouseDownOrUp(e, false)));
             }
         };
         this._register(this.configurationService.onDidChangeConfiguration(event => {
-            if (event.affectsConfiguration(HistoryService.MOUSE_NAVIGATION_SETTING)) {
+            if (event.affectsConfiguration(HistoryService_1.MOUSE_NAVIGATION_SETTING)) {
                 handleMouseBackForwardSupport();
             }
         }));
@@ -240,7 +242,7 @@ let HistoryService = class HistoryService extends Disposable {
     registerEditorNavigationScopeChangeListener() {
         const handleEditorNavigationScopeChange = () => {
             this.disposeEditorNavigationStacks();
-            const configuredScope = this.configurationService.getValue(HistoryService.NAVIGATION_SCOPE_SETTING);
+            const configuredScope = this.configurationService.getValue(HistoryService_1.NAVIGATION_SCOPE_SETTING);
             if (configuredScope === 'editorGroup') {
                 this.editorNavigationScope = 1 ;
             }
@@ -252,7 +254,7 @@ let HistoryService = class HistoryService extends Disposable {
             }
         };
         this._register(this.configurationService.onDidChangeConfiguration(event => {
-            if (event.affectsConfiguration(HistoryService.NAVIGATION_SCOPE_SETTING)) {
+            if (event.affectsConfiguration(HistoryService_1.NAVIGATION_SCOPE_SETTING)) {
                 handleEditorNavigationScopeChange();
             }
         }));
@@ -474,7 +476,7 @@ let HistoryService = class HistoryService extends Disposable {
             index: event.index,
             sticky: event.sticky
         });
-        if (this.recentlyClosedEditors.length > HistoryService.MAX_RECENTLY_CLOSED_EDITORS) {
+        if (this.recentlyClosedEditors.length > HistoryService_1.MAX_RECENTLY_CLOSED_EDITORS) {
             this.recentlyClosedEditors.shift();
         }
         this.canReopenClosedEditorContextKey.set(true);
@@ -554,7 +556,7 @@ let HistoryService = class HistoryService extends Disposable {
         else {
             this.history.push(historyInput);
         }
-        if (this.history.length > HistoryService.MAX_HISTORY_ITEMS) {
+        if (this.history.length > HistoryService_1.MAX_HISTORY_ITEMS) {
             this.editorHelper.clearOnEditorDispose(this.history.pop(), this.editorHistoryListeners);
         }
         if (isEditorInput(historyInput)) {
@@ -682,7 +684,7 @@ let HistoryService = class HistoryService extends Disposable {
     }
     loadHistoryFromStorage() {
         const entries = [];
-        const entriesRaw = this.storageService.get(HistoryService.HISTORY_STORAGE_KEY, 1 );
+        const entriesRaw = this.storageService.get(HistoryService_1.HISTORY_STORAGE_KEY, 1 );
         if (entriesRaw) {
             try {
                 const entriesParsed = JSON.parse(entriesRaw);
@@ -726,7 +728,7 @@ let HistoryService = class HistoryService extends Disposable {
                 }
             });
         }
-        this.storageService.store(HistoryService.HISTORY_STORAGE_KEY, JSON.stringify(entries), 1 , 1 );
+        this.storageService.store(HistoryService_1.HISTORY_STORAGE_KEY, JSON.stringify(entries), 1 , 1 );
     }
     getLastActiveWorkspaceRoot(schemeFilter) {
         const folders = this.contextService.getWorkspace().folders;
@@ -776,7 +778,7 @@ let HistoryService = class HistoryService extends Disposable {
         return undefined;
     }
 };
-HistoryService = ( (__decorate([
+HistoryService = HistoryService_1 = ( (__decorate([
     ( (__param(0, IEditorService))),
     ( (__param(1, IEditorGroupsService))),
     ( (__param(2, IWorkspaceContextService))),
@@ -911,6 +913,7 @@ class NoOpEditorNavigationStacks {
     dispose() { }
 }
 let EditorNavigationStack = class EditorNavigationStack extends Disposable {
+    static { EditorNavigationStack_1 = this; }
     static { this.MAX_STACK_SIZE = 50; }
     get current() {
         return this.stack[this.index];
@@ -1136,7 +1139,7 @@ ${entryLabels.join('\n')}
                 this.stack = this.stack.slice(0, this.index + 1);
             }
             this.stack.splice(this.index + 1, 0, newStackEntry);
-            if (this.stack.length > EditorNavigationStack.MAX_STACK_SIZE) {
+            if (this.stack.length > EditorNavigationStack_1.MAX_STACK_SIZE) {
                 removedEntries.push(this.stack.shift());
                 if (this.previousIndex >= 0) {
                     this.previousIndex--;
@@ -1341,7 +1344,7 @@ ${entryLabels.join('\n')}
         return this.navigating;
     }
 };
-EditorNavigationStack = ( (__decorate([
+EditorNavigationStack = EditorNavigationStack_1 = ( (__decorate([
     ( (__param(2, IInstantiationService))),
     ( (__param(3, IEditorService))),
     ( (__param(4, IEditorGroupsService))),

package/vscode/src/vs/workbench/services/host/browser/browserHostService.d.ts

@@ -38,4 +38,4 @@ interface IWorkspaceProvider {
     }): Promise<boolean>;
 }
 
-export { IWorkspace, IWorkspaceProvider };
+export type { IWorkspace, IWorkspaceProvider };

package/vscode/src/vs/workbench/services/hover/browser/hover.d.ts

@@ -23,7 +23,7 @@ interface IHoverService {
      * });
      * ```
      */
-    showHover(options: IHoverOptions, focus?: boolean): IHoverWidget | undefined;
+    showHover(options: Readonly<IHoverOptions>, focus?: boolean): IHoverWidget | undefined;
     /**
      * Hides the hover if it was visible. This call will be ignored if the the hover is currently
      * "locked" via the alt/option key.
@@ -167,4 +167,4 @@ interface IHoverTarget extends IDisposable {
     y?: number;
 }
 
-export { IHoverAction, IHoverOptions, IHoverService, IHoverTarget, IHoverWidget };
+export { type IHoverAction, type IHoverOptions, IHoverService, type IHoverTarget, type IHoverWidget };

package/vscode/src/vs/workbench/services/hover/browser/hoverService.d.ts

@@ -15,7 +15,7 @@ declare class HoverService implements IHoverService {
     private _lastHoverOptions;
     private _lastFocusedElementBeforeOpen;
     constructor(_instantiationService: IInstantiationService, _contextViewService: IContextViewService, contextMenuService: IContextMenuService, _keybindingService: IKeybindingService, _accessibilityService: IAccessibilityService);
-    showHover(options: IHoverOptions, focus?: boolean, skipLastFocusedUpdate?: boolean): IHoverWidget | undefined;
+    showHover(options: Readonly<IHoverOptions>, focus?: boolean, skipLastFocusedUpdate?: boolean): IHoverWidget | undefined;
     hideHover(): void;
     private _intersectionChange;
     showAndFocusLastHover(): void;

package/vscode/src/vs/workbench/services/hover/browser/hoverWidget.js

@@ -5,7 +5,7 @@ import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
 import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { EDITOR_FONT_DEFAULTS } from 'monaco-editor/esm/vs/editor/common/config/editorOptions.js';
-import { HoverWidget as HoverWidget$1, HoverAction } from 'monaco-editor/esm/vs/base/browser/ui/hover/hoverWidget.js';
+import { HoverWidget as HoverWidget$1, HoverAction, getHoverAccessibleViewHint } from 'monaco-editor/esm/vs/base/browser/ui/hover/hoverWidget.js';
 import { Widget } from 'monaco-editor/esm/vs/base/browser/ui/widget.js';
 import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
@@ -13,6 +13,8 @@ import { openLinkFromMarkdown, MarkdownRenderer } from 'monaco-editor/esm/vs/edi
 import { isMarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
+import { status } from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
 const $ = dom.$;
 let HoverWidget = class HoverWidget extends Widget {
     get isDisposed() { return this._isDisposed; }
@@ -31,12 +33,13 @@ let HoverWidget = class HoverWidget extends Widget {
         this._isLocked = value;
         this._hoverContainer.classList.toggle('locked', this._isLocked);
     }
-    constructor(options, _keybindingService, _configurationService, _openerService, _instantiationService) {
+    constructor(options, _keybindingService, _configurationService, _openerService, _instantiationService, _accessibilityService) {
         super();
         this._keybindingService = _keybindingService;
         this._configurationService = _configurationService;
         this._openerService = _openerService;
         this._instantiationService = _instantiationService;
+        this._accessibilityService = _accessibilityService;
         this._messageListeners = ( new DisposableStore());
         this._isDisposed = false;
         this._forcePosition = false;
@@ -214,6 +217,10 @@ let HoverWidget = class HoverWidget extends Widget {
     }
     render(container) {
         container.appendChild(this._hoverContainer);
+        const accessibleViewHint = getHoverAccessibleViewHint(this._configurationService.getValue('accessibility.verbosity.hover') === true && this._accessibilityService.isScreenReaderOptimized(), this._keybindingService.lookupKeybinding('editor.action.accessibleView')?.getAriaLabel());
+        if (accessibleViewHint) {
+            status(accessibleViewHint);
+        }
         this.layout();
         this.addFocusTrap();
     }
@@ -467,7 +474,8 @@ HoverWidget = ( __decorate([
     ( __param(1, IKeybindingService)),
     ( __param(2, IConfigurationService)),
     ( __param(3, IOpenerService)),
-    ( __param(4, IInstantiationService))
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IAccessibilityService))
 ], HoverWidget));
 class CompositeMouseTracker extends Widget {
     get onMouseOut() { return this._onMouseOut.event; }

package/vscode/src/vs/workbench/services/keybinding/browser/keybindingService.js

@@ -37,6 +37,7 @@ import { getAllUnboundCommands } from './unboundCommands.js';
 import { KeybindingIO, OutputBuilder } from '../common/keybindingIO.js';
 import { IUserDataProfileService } from '../../userDataProfile/common/userDataProfile.js';
 import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+var WorkbenchKeybindingService_1;
 function isValidContributedKeyBinding(keyBinding, rejects) {
     if (!keyBinding) {
         rejects.push(( nls.localize('nonempty', "expected non-empty value.")));
@@ -188,7 +189,7 @@ otherMacNumpadMapping.set(101 , 28 );
 otherMacNumpadMapping.set(102 , 29 );
 otherMacNumpadMapping.set(103 , 30 );
 otherMacNumpadMapping.set(104 , 21 );
-let WorkbenchKeybindingService = class WorkbenchKeybindingService extends AbstractKeybindingService {
+let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchKeybindingService extends AbstractKeybindingService {
     constructor(contextKeyService, commandService, telemetryService, notificationService, userDataProfileService, hostService, extensionService, fileService, uriIdentityService, logService, keyboardLayoutService) {
         super(contextKeyService, commandService, telemetryService, notificationService, logService);
         this.hostService = hostService;
@@ -523,7 +524,7 @@ let WorkbenchKeybindingService = class WorkbenchKeybindingService extends Abstra
     }
     _asCommandRule(extensionId, isBuiltin, idx, binding) {
         const { command, args, when, key, mac, linux, win } = binding;
-        const keybinding = WorkbenchKeybindingService.bindToCurrentPlatform(key, mac, linux, win);
+        const keybinding = WorkbenchKeybindingService_1.bindToCurrentPlatform(key, mac, linux, win);
         if (!keybinding) {
             return undefined;
         }
@@ -561,9 +562,9 @@ let WorkbenchKeybindingService = class WorkbenchKeybindingService extends Abstra
         const resolver = this._getResolver();
         const defaultKeybindings = resolver.getDefaultKeybindings();
         const boundCommands = resolver.getDefaultBoundCommands();
-        return (WorkbenchKeybindingService._getDefaultKeybindings(defaultKeybindings)
+        return (WorkbenchKeybindingService_1._getDefaultKeybindings(defaultKeybindings)
             + '\n\n'
-            + WorkbenchKeybindingService._getAllCommandsAsComment(boundCommands));
+            + WorkbenchKeybindingService_1._getAllCommandsAsComment(boundCommands));
     }
     static _getDefaultKeybindings(defaultKeybindings) {
         const out = ( new OutputBuilder());
@@ -618,7 +619,7 @@ let WorkbenchKeybindingService = class WorkbenchKeybindingService extends Abstra
         return true;
     }
 };
-WorkbenchKeybindingService = ( __decorate([
+WorkbenchKeybindingService = WorkbenchKeybindingService_1 = ( __decorate([
     ( __param(0, IContextKeyService)),
     ( __param(1, ICommandService)),
     ( __param(2, ITelemetryService)),

package/vscode/src/vs/workbench/services/languageDetection/browser/languageDetectionWorkerServiceImpl.js

@@ -18,12 +18,14 @@ import { IEditorService } from '../../editor/common/editorService.js';
 import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
 import { LRUCache } from 'monaco-editor/esm/vs/base/common/map.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+var LanguageDetectionService_1;
 const TOP_LANG_COUNTS = 12;
 const regexpModuleLocation = `${nodeModulesPath}/vscode-regexp-languagedetection`;
 const regexpModuleLocationAsar = `${nodeModulesAsarPath}/vscode-regexp-languagedetection`;
 const moduleLocation = `${nodeModulesPath}/@vscode/vscode-languagedetection`;
 const moduleLocationAsar = `${nodeModulesAsarPath}/@vscode/vscode-languagedetection`;
 let LanguageDetectionService = class LanguageDetectionService extends Disposable {
+    static { LanguageDetectionService_1 = this; }
     static { this.enablementSettingKey = 'workbench.editor.languageDetection'; }
     static { this.historyBasedEnablementConfig = 'workbench.editor.historyBasedLanguageDetection'; }
     static { this.preferHistoryConfig = 'workbench.editor.preferHistoryBasedLanguageDetection'; }
@@ -84,7 +86,7 @@ let LanguageDetectionService = class LanguageDetectionService extends Disposable
         this.dirtyBiases = true;
     }
     isEnabledForLanguage(languageId) {
-        return !!languageId && this._configurationService.getValue(LanguageDetectionService.enablementSettingKey, { overrideIdentifier: languageId });
+        return !!languageId && this._configurationService.getValue(LanguageDetectionService_1.enablementSettingKey, { overrideIdentifier: languageId });
     }
     getLanguageBiases() {
         if (!this.dirtyBiases) {
@@ -105,8 +107,8 @@ let LanguageDetectionService = class LanguageDetectionService extends Disposable
         return biases;
     }
     async detectLanguage(resource, supportedLangs) {
-        const useHistory = this._configurationService.getValue(LanguageDetectionService.historyBasedEnablementConfig);
-        const preferHistory = this._configurationService.getValue(LanguageDetectionService.preferHistoryConfig);
+        const useHistory = this._configurationService.getValue(LanguageDetectionService_1.historyBasedEnablementConfig);
+        const preferHistory = this._configurationService.getValue(LanguageDetectionService_1.preferHistoryConfig);
         if (useHistory) {
             await this.resolveWorkspaceLanguageIds();
         }
@@ -115,14 +117,14 @@ let LanguageDetectionService = class LanguageDetectionService extends Disposable
     }
     initEditorOpenedListeners(storageService) {
         try {
-            const globalLangHistoryData = JSON.parse(storageService.get(LanguageDetectionService.globalOpenedLanguagesStorageKey, 0 , '[]'));
+            const globalLangHistoryData = JSON.parse(storageService.get(LanguageDetectionService_1.globalOpenedLanguagesStorageKey, 0 , '[]'));
             this.historicalGlobalOpenedLanguageIds.fromJSON(globalLangHistoryData);
         }
         catch (e) {
             console.error(e);
         }
         try {
-            const workspaceLangHistoryData = JSON.parse(storageService.get(LanguageDetectionService.workspaceOpenedLanguagesStorageKey, 1 , '[]'));
+            const workspaceLangHistoryData = JSON.parse(storageService.get(LanguageDetectionService_1.workspaceOpenedLanguagesStorageKey, 1 , '[]'));
             this.historicalWorkspaceOpenedLanguageIds.fromJSON(workspaceLangHistoryData);
         }
         catch (e) {
@@ -134,14 +136,14 @@ let LanguageDetectionService = class LanguageDetectionService extends Disposable
                 this.sessionOpenedLanguageIds.add(activeLanguage);
                 this.historicalGlobalOpenedLanguageIds.set(activeLanguage, true);
                 this.historicalWorkspaceOpenedLanguageIds.set(activeLanguage, true);
-                storageService.store(LanguageDetectionService.globalOpenedLanguagesStorageKey, JSON.stringify(this.historicalGlobalOpenedLanguageIds.toJSON()), 0 , 1 );
-                storageService.store(LanguageDetectionService.workspaceOpenedLanguagesStorageKey, JSON.stringify(this.historicalWorkspaceOpenedLanguageIds.toJSON()), 1 , 1 );
+                storageService.store(LanguageDetectionService_1.globalOpenedLanguagesStorageKey, JSON.stringify(this.historicalGlobalOpenedLanguageIds.toJSON()), 0 , 1 );
+                storageService.store(LanguageDetectionService_1.workspaceOpenedLanguagesStorageKey, JSON.stringify(this.historicalWorkspaceOpenedLanguageIds.toJSON()), 1 , 1 );
                 this.dirtyBiases = true;
             }
         }));
     }
 };
-LanguageDetectionService = ( __decorate([
+LanguageDetectionService = LanguageDetectionService_1 = ( __decorate([
     ( __param(0, IWorkbenchEnvironmentService)),
     ( __param(1, ILanguageService)),
     ( __param(2, IConfigurationService)),

package/vscode/src/vs/workbench/services/languageStatus/common/languageStatusService.d.ts

@@ -27,4 +27,4 @@ interface ILanguageStatusService {
     getLanguageStatus(model: ITextModel): ILanguageStatus[];
 }
 
-export { ILanguageStatus, ILanguageStatusService };
+export { type ILanguageStatus, ILanguageStatusService };

package/vscode/src/vs/workbench/services/layout/browser/layoutService.d.ts

@@ -175,4 +175,4 @@ interface IWorkbenchLayoutService extends ILayoutService {
     getVisibleNeighborPart(part: Parts, direction: Direction): Parts | undefined;
 }
 
-export { IWorkbenchLayoutService, PanelAlignment, Parts, Position };
+export { IWorkbenchLayoutService, type PanelAlignment, Parts, Position };

package/vscode/src/vs/workbench/services/lifecycle/common/lifecycle.d.ts

@@ -195,4 +195,4 @@ interface ILifecycleService {
     shutdown(): Promise<void>;
 }
 
-export { BeforeShutdownErrorEvent, BeforeShutdownEvent, ILifecycleService, IWillShutdownEventJoiner, LifecyclePhase, ShutdownReason, StartupKind, WillShutdownEvent };
+export { type BeforeShutdownErrorEvent, type BeforeShutdownEvent, ILifecycleService, type IWillShutdownEventJoiner, LifecyclePhase, ShutdownReason, StartupKind, type WillShutdownEvent };

package/vscode/src/vs/workbench/services/lifecycle/common/lifecycleService.js

@@ -6,7 +6,9 @@ import { LifecyclePhaseToString } from './lifecycle.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { mark } from 'monaco-editor/esm/vs/base/common/performance.js';
 import { WillSaveStateReason, IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+var AbstractLifecycleService_1;
 let AbstractLifecycleService = class AbstractLifecycleService extends Disposable {
+    static { AbstractLifecycleService_1 = this; }
     static { this.LAST_SHUTDOWN_REASON_KEY = 'lifecyle.lastShutdownReason'; }
     get startupKind() { return this._startupKind; }
     get phase() { return this._phase; }
@@ -29,13 +31,13 @@ let AbstractLifecycleService = class AbstractLifecycleService extends Disposable
         this._startupKind = this.resolveStartupKind();
         this.storageService.onWillSaveState(e => {
             if (e.reason === WillSaveStateReason.SHUTDOWN) {
-                this.storageService.store(AbstractLifecycleService.LAST_SHUTDOWN_REASON_KEY, this.shutdownReason, 1 , 1 );
+                this.storageService.store(AbstractLifecycleService_1.LAST_SHUTDOWN_REASON_KEY, this.shutdownReason, 1 , 1 );
             }
         });
     }
     resolveStartupKind() {
-        const lastShutdownReason = this.storageService.getNumber(AbstractLifecycleService.LAST_SHUTDOWN_REASON_KEY, 1 );
-        this.storageService.remove(AbstractLifecycleService.LAST_SHUTDOWN_REASON_KEY, 1 );
+        const lastShutdownReason = this.storageService.getNumber(AbstractLifecycleService_1.LAST_SHUTDOWN_REASON_KEY, 1 );
+        this.storageService.remove(AbstractLifecycleService_1.LAST_SHUTDOWN_REASON_KEY, 1 );
         let startupKind;
         switch (lastShutdownReason) {
             case 3 :
@@ -78,7 +80,7 @@ let AbstractLifecycleService = class AbstractLifecycleService extends Disposable
         await barrier.wait();
     }
 };
-AbstractLifecycleService = ( __decorate([
+AbstractLifecycleService = AbstractLifecycleService_1 = ( __decorate([
     ( __param(0, ILogService)),
     ( __param(1, IStorageService))
 ], AbstractLifecycleService));

package/vscode/src/vs/workbench/services/localization/common/locale.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const ILocaleService = ( createDecorator('localizationService'));
+export { ILocaleService };

package/vscode/src/vs/workbench/services/notification/common/notificationService.js

@@ -6,7 +6,9 @@ import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/li
 import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
 import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+var NotificationService_1;
 let NotificationService = class NotificationService extends Disposable {
+    static { NotificationService_1 = this; }
     constructor(storageService) {
         super();
         this.storageService = storageService;
@@ -17,7 +19,7 @@ let NotificationService = class NotificationService extends Disposable {
         this.onDidRemoveNotification = this._onDidRemoveNotification.event;
         this._onDidChangeDoNotDisturbMode = this._register(( new Emitter()));
         this.onDidChangeDoNotDisturbMode = this._onDidChangeDoNotDisturbMode.event;
-        this._doNotDisturbMode = this.storageService.getBoolean(NotificationService.DND_SETTINGS_KEY, -1 , false);
+        this._doNotDisturbMode = this.storageService.getBoolean(NotificationService_1.DND_SETTINGS_KEY, -1 , false);
         this.updateDoNotDisturbFilters();
         this.registerListeners();
     }
@@ -51,7 +53,7 @@ let NotificationService = class NotificationService extends Disposable {
         if (this._doNotDisturbMode === enabled) {
             return;
         }
-        this.storageService.store(NotificationService.DND_SETTINGS_KEY, enabled, -1 , 1 );
+        this.storageService.store(NotificationService_1.DND_SETTINGS_KEY, enabled, -1 , 1 );
         this._doNotDisturbMode = enabled;
         this.updateDoNotDisturbFilters();
         this._onDidChangeDoNotDisturbMode.fire();
@@ -180,7 +182,7 @@ let NotificationService = class NotificationService extends Disposable {
         return this.model.showStatusMessage(message, options);
     }
 };
-NotificationService = ( __decorate([
+NotificationService = NotificationService_1 = ( __decorate([
     ( __param(0, IStorageService))
 ], NotificationService));
 export { NotificationService };

package/vscode/src/vs/workbench/services/output/common/output.d.ts

@@ -84,4 +84,4 @@ interface IOutputChannelDescriptor {
     extensionId?: string;
 }
 
-export { IOutputChannel, IOutputChannelDescriptor, IOutputService, OutputChannelUpdateMode };
+export { type IOutputChannel, type IOutputChannelDescriptor, IOutputService, OutputChannelUpdateMode };

package/vscode/src/vs/workbench/services/path/common/pathService.js

@@ -10,8 +10,9 @@ import { getVirtualWorkspaceScheme } from '../../../../platform/workspace/common
 import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
 import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
 import { IRemoteAgentService } from '../../remote/common/remoteAgentService.js';
+var AbstractPathService_1;
 const IPathService = ( createDecorator('pathService'));
-let AbstractPathService = class AbstractPathService {
+let AbstractPathService = AbstractPathService_1 = class AbstractPathService {
     constructor(localUserHome, remoteAgentService, environmentService, contextService) {
         this.localUserHome = localUserHome;
         this.remoteAgentService = remoteAgentService;
@@ -40,7 +41,7 @@ let AbstractPathService = class AbstractPathService {
         return true;
     }
     get defaultUriScheme() {
-        return AbstractPathService.findDefaultUriScheme(this.environmentService, this.contextService);
+        return AbstractPathService_1.findDefaultUriScheme(this.environmentService, this.contextService);
     }
     static findDefaultUriScheme(environmentService, contextService) {
         if (environmentService.remoteAuthority) {
@@ -99,7 +100,7 @@ let AbstractPathService = class AbstractPathService {
         }));
     }
 };
-AbstractPathService = ( __decorate([
+AbstractPathService = AbstractPathService_1 = ( __decorate([
     ( __param(1, IRemoteAgentService)),
     ( __param(2, IWorkbenchEnvironmentService)),
     ( __param(3, IWorkspaceContextService))

package/vscode/src/vs/workbench/services/preferences/browser/keybindingsEditorInput.js

@@ -4,7 +4,9 @@ import * as nls from 'monaco-editor/esm/vs/nls.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { EditorInput } from '../../../common/editor/editorInput.js';
 import { KeybindingsEditorModel } from './keybindingsEditorModel.js';
+var KeybindingsEditorInput_1;
 let KeybindingsEditorInput = class KeybindingsEditorInput extends EditorInput {
+    static { KeybindingsEditorInput_1 = this; }
     static { this.ID = 'workbench.input.keybindings'; }
     constructor(instantiationService) {
         super();
@@ -13,7 +15,7 @@ let KeybindingsEditorInput = class KeybindingsEditorInput extends EditorInput {
         this.keybindingsModel = instantiationService.createInstance(KeybindingsEditorModel, OS);
     }
     get typeId() {
-        return KeybindingsEditorInput.ID;
+        return KeybindingsEditorInput_1.ID;
     }
     getName() {
         return ( nls.localize('keybindingsInputName', "Keyboard Shortcuts"));
@@ -22,14 +24,14 @@ let KeybindingsEditorInput = class KeybindingsEditorInput extends EditorInput {
         return this.keybindingsModel;
     }
     matches(otherInput) {
-        return otherInput instanceof KeybindingsEditorInput;
+        return otherInput instanceof KeybindingsEditorInput_1;
     }
     dispose() {
         this.keybindingsModel.dispose();
         super.dispose();
     }
 };
-KeybindingsEditorInput = ( __decorate([
+KeybindingsEditorInput = KeybindingsEditorInput_1 = ( __decorate([
     ( __param(0, IInstantiationService))
 ], KeybindingsEditorInput));
 export { KeybindingsEditorInput };

package/vscode/src/vs/workbench/services/preferences/browser/keybindingsEditorModel.js

@@ -13,6 +13,7 @@ import { getAllUnboundCommands } from '../../keybinding/browser/unboundCommands.
 import { isString, isEmptyObject } from 'monaco-editor/esm/vs/base/common/types.js';
 import { IExtensionService } from '../../extensions/common/extensions.js';
 import { ExtensionIdentifier, ExtensionIdentifierMap } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
+var KeybindingsEditorModel_1;
 const KEYBINDING_ENTRY_TEMPLATE_ID = 'keybinding.entry.template';
 const SOURCE_SYSTEM = ( localize('default', "System"));
 const SOURCE_EXTENSION = ( localize('extension', "Extension"));
@@ -20,7 +21,7 @@ const SOURCE_USER = ( localize('user', "User"));
 const wordFilter = or(matchesPrefix, matchesWords, matchesContiguousSubString);
 const SOURCE_REGEX = /@source:\s*(user|default|system|extension)/i;
 const EXTENSION_REGEX = /@ext:\s*((".+")|([^\s]+))/i;
-let KeybindingsEditorModel = class KeybindingsEditorModel extends EditorModel {
+let KeybindingsEditorModel = KeybindingsEditorModel_1 = class KeybindingsEditorModel extends EditorModel {
     constructor(os, keybindingsService, extensionService) {
         super();
         this.keybindingsService = keybindingsService;
@@ -39,7 +40,7 @@ let KeybindingsEditorModel = class KeybindingsEditorModel extends EditorModel {
         if (commandIdMatches && commandIdMatches[1]) {
             return ( keybindingItems.filter(k => k.command === commandIdMatches[1])
                 .map(
-                keybindingItem => ({ id: KeybindingsEditorModel.getId(keybindingItem), keybindingItem, templateId: KEYBINDING_ENTRY_TEMPLATE_ID })
+                keybindingItem => ({ id: KeybindingsEditorModel_1.getId(keybindingItem), keybindingItem, templateId: KEYBINDING_ENTRY_TEMPLATE_ID })
             ));
         }
         if (SOURCE_REGEX.test(searchValue)) {
@@ -63,7 +64,7 @@ let KeybindingsEditorModel = class KeybindingsEditorModel extends EditorModel {
         searchValue = searchValue.trim();
         if (!searchValue) {
             return ( keybindingItems.map(
-                keybindingItem => ({ id: KeybindingsEditorModel.getId(keybindingItem), keybindingItem, templateId: KEYBINDING_ENTRY_TEMPLATE_ID })
+                keybindingItem => ({ id: KeybindingsEditorModel_1.getId(keybindingItem), keybindingItem, templateId: KEYBINDING_ENTRY_TEMPLATE_ID })
             ));
         }
         return this.filterByText(keybindingItems, searchValue);
@@ -116,7 +117,7 @@ let KeybindingsEditorModel = class KeybindingsEditorModel extends EditorModel {
                 || keybindingMatches.extensionIdMatches
                 || keybindingMatches.extensionLabelMatches) {
                 result.push({
-                    id: KeybindingsEditorModel.getId(keybindingItem),
+                    id: KeybindingsEditorModel_1.getId(keybindingItem),
                     templateId: KEYBINDING_ENTRY_TEMPLATE_ID,
                     commandLabelMatches: keybindingMatches.commandLabelMatches || undefined,
                     commandDefaultLabelMatches: keybindingMatches.commandDefaultLabelMatches || undefined,
@@ -148,7 +149,7 @@ let KeybindingsEditorModel = class KeybindingsEditorModel extends EditorModel {
         const boundCommands = ( new Map());
         for (const keybinding of this.keybindingsService.getKeybindings()) {
             if (keybinding.command) {
-                this._keybindingItemsSortedByPrecedence.push(KeybindingsEditorModel.toKeybindingEntry(keybinding.command, keybinding, actionLabels, extensions));
+                this._keybindingItemsSortedByPrecedence.push(KeybindingsEditorModel_1.toKeybindingEntry(keybinding.command, keybinding, actionLabels, extensions));
                 boundCommands.set(keybinding.command, true);
             }
         }
@@ -163,10 +164,10 @@ let KeybindingsEditorModel = class KeybindingsEditorModel extends EditorModel {
                 null,
                 false
             ));
-            this._keybindingItemsSortedByPrecedence.push(KeybindingsEditorModel.toKeybindingEntry(command, keybindingItem, actionLabels, extensions));
+            this._keybindingItemsSortedByPrecedence.push(KeybindingsEditorModel_1.toKeybindingEntry(command, keybindingItem, actionLabels, extensions));
         }
-        this._keybindingItemsSortedByPrecedence = distinct(this._keybindingItemsSortedByPrecedence, keybindingItem => KeybindingsEditorModel.getId(keybindingItem));
-        this._keybindingItems = this._keybindingItemsSortedByPrecedence.slice(0).sort((a, b) => KeybindingsEditorModel.compareKeybindingData(a, b));
+        this._keybindingItemsSortedByPrecedence = distinct(this._keybindingItemsSortedByPrecedence, keybindingItem => KeybindingsEditorModel_1.getId(keybindingItem));
+        this._keybindingItems = this._keybindingItemsSortedByPrecedence.slice(0).sort((a, b) => KeybindingsEditorModel_1.compareKeybindingData(a, b));
         return super.resolve();
     }
     static getId(keybindingItem) {
@@ -207,8 +208,8 @@ let KeybindingsEditorModel = class KeybindingsEditorModel extends EditorModel {
             keybinding: keybindingItem.resolvedKeybinding,
             keybindingItem,
             command,
-            commandLabel: KeybindingsEditorModel.getCommandLabel(menuCommand, editorActionLabel),
-            commandDefaultLabel: KeybindingsEditorModel.getCommandDefaultLabel(menuCommand),
+            commandLabel: KeybindingsEditorModel_1.getCommandLabel(menuCommand, editorActionLabel),
+            commandDefaultLabel: KeybindingsEditorModel_1.getCommandDefaultLabel(menuCommand),
             when: keybindingItem.when ? keybindingItem.when.serialize() : '',
             source
         };
@@ -235,7 +236,7 @@ let KeybindingsEditorModel = class KeybindingsEditorModel extends EditorModel {
         return '';
     }
 };
-KeybindingsEditorModel = ( __decorate([
+KeybindingsEditorModel = KeybindingsEditorModel_1 = ( __decorate([
     ( __param(1, IKeybindingService)),
     ( __param(2, IExtensionService))
 ], KeybindingsEditorModel));

package/vscode/src/vs/workbench/services/preferences/common/preferences.d.ts

@@ -94,8 +94,9 @@ interface IFilterResult {
  */
 declare enum SettingMatchType {
     None = 0,
-    WholeWordMatch = 1,
-    KeyMatch = 2
+    RemoteMatch = 1,
+    WholeWordMatch = 2,
+    KeyMatch = 4
 }
 interface ISettingMatch {
     setting: ISetting;
@@ -187,4 +188,4 @@ interface IPreferencesService {
     createSplitJsonEditorInput(configurationTarget: ConfigurationTarget, resource: URI): EditorInput;
 }
 
-export { IFilterMetadata, IFilterResult, IGroupFilter, IKeybindingsEditorOptions, IOpenSettingsOptions, IPreferencesEditorModel, IPreferencesService, IRemoteSetting, IScoredResults, ISearchResult, ISearchResultGroup, ISetting, ISettingMatch, ISettingMatcher, ISettingsEditorModel, ISettingsEditorOptions, ISettingsGroup, ISettingsSection, SettingMatchType };
+export { type IFilterMetadata, type IFilterResult, type IGroupFilter, type IKeybindingsEditorOptions, type IOpenSettingsOptions, type IPreferencesEditorModel, IPreferencesService, type IRemoteSetting, type IScoredResults, type ISearchResult, type ISearchResultGroup, type ISetting, type ISettingMatch, type ISettingMatcher, type ISettingsEditorModel, type ISettingsEditorOptions, type ISettingsGroup, type ISettingsSection, SettingMatchType };

package/vscode/src/vs/workbench/services/preferences/common/preferences.js

@@ -23,8 +23,9 @@ var SettingValueType;
 var SettingMatchType;
 ( (function(SettingMatchType) {
     SettingMatchType[SettingMatchType["None"] = 0] = "None";
-    SettingMatchType[SettingMatchType["WholeWordMatch"] = 1] = "WholeWordMatch";
-    SettingMatchType[SettingMatchType["KeyMatch"] = 2] = "KeyMatch";
+    SettingMatchType[SettingMatchType["RemoteMatch"] = 1] = "RemoteMatch";
+    SettingMatchType[SettingMatchType["WholeWordMatch"] = 2] = "WholeWordMatch";
+    SettingMatchType[SettingMatchType["KeyMatch"] = 4] = "KeyMatch";
 })(SettingMatchType || (SettingMatchType = {})));
 function validateSettingsEditorOptions(options) {
     return {