@codingame/monaco-vscode-api 4.5.1 → 5.0.0

package/vscode/src/vs/platform/history/browser/contextScopedHistoryWidget.js

@@ -8,11 +8,8 @@ import { KeybindingsRegistry } from '../../keybinding/common/keybindingsRegistry
 import { localizeWithPath } from '../../../nls.js';
 import { toDisposable, DisposableStore } from '../../../base/common/lifecycle.js';
 import { isActiveElement } from '../../../base/browser/dom.js';
-const historyNavigationVisible = ( new RawContextKey('suggestWidgetVisible', false, ( localizeWithPath(
-    'vs/platform/history/browser/contextScopedHistoryWidget',
-    'suggestWidgetVisible',
-    "Whether suggestion are visible"
-))));
+const _moduleId = "vs/platform/history/browser/contextScopedHistoryWidget";
+const historyNavigationVisible = ( (new RawContextKey('suggestWidgetVisible', false, ( localizeWithPath(_moduleId, 0, "Whether suggestion are visible")))));
 const HistoryNavigationWidgetFocusContext = 'historyNavigationWidgetFocus';
 const HistoryNavigationForwardsEnablementContext = 'historyNavigationForwardsEnabled';
 const HistoryNavigationBackwardsEnablementContext = 'historyNavigationBackwardsEnabled';
@@ -20,13 +17,13 @@ let lastFocusedWidget = undefined;
 const widgets = [];
 function registerAndCreateHistoryNavigationContext(scopedContextKeyService, widget) {
     if (widgets.includes(widget)) {
-        throw new Error('Cannot register the same widget multiple times');
+        throw ( (new Error('Cannot register the same widget multiple times')));
     }
     widgets.push(widget);
-    const disposableStore = ( new DisposableStore());
-    const historyNavigationWidgetFocus = ( new RawContextKey(HistoryNavigationWidgetFocusContext, false)).bindTo(scopedContextKeyService);
-    const historyNavigationForwardsEnablement = ( new RawContextKey(HistoryNavigationForwardsEnablementContext, true)).bindTo(scopedContextKeyService);
-    const historyNavigationBackwardsEnablement = ( new RawContextKey(HistoryNavigationBackwardsEnablementContext, true)).bindTo(scopedContextKeyService);
+    const disposableStore = ( (new DisposableStore()));
+    const historyNavigationWidgetFocus = ( (new RawContextKey(HistoryNavigationWidgetFocusContext, false))).bindTo(scopedContextKeyService);
+    const historyNavigationForwardsEnablement = ( (new RawContextKey(HistoryNavigationForwardsEnablementContext, true))).bindTo(scopedContextKeyService);
+    const historyNavigationBackwardsEnablement = ( (new RawContextKey(HistoryNavigationBackwardsEnablementContext, true))).bindTo(scopedContextKeyService);
     const onDidFocus = () => {
         historyNavigationWidgetFocus.set(true);
         lastFocusedWidget = widget;
@@ -61,9 +58,9 @@ let ContextScopedHistoryInputBox = class ContextScopedHistoryInputBox extends Hi
         this._register(registerAndCreateHistoryNavigationContext(scopedContextKeyService, this));
     }
 };
-ContextScopedHistoryInputBox = ( __decorate([
-    ( __param(3, IContextKeyService))
-], ContextScopedHistoryInputBox));
+ContextScopedHistoryInputBox = ( (__decorate([
+    ( (__param(3, IContextKeyService)))
+], ContextScopedHistoryInputBox)));
 let ContextScopedFindInput = class ContextScopedFindInput extends FindInput {
     constructor(container, contextViewProvider, options, contextKeyService) {
         super(container, contextViewProvider, options);
@@ -71,9 +68,9 @@ let ContextScopedFindInput = class ContextScopedFindInput extends FindInput {
         this._register(registerAndCreateHistoryNavigationContext(scopedContextKeyService, this.inputBox));
     }
 };
-ContextScopedFindInput = ( __decorate([
-    ( __param(3, IContextKeyService))
-], ContextScopedFindInput));
+ContextScopedFindInput = ( (__decorate([
+    ( (__param(3, IContextKeyService)))
+], ContextScopedFindInput)));
 let ContextScopedReplaceInput = class ContextScopedReplaceInput extends ReplaceInput {
     constructor(container, contextViewProvider, options, contextKeyService, showReplaceOptions = false) {
         super(container, contextViewProvider, showReplaceOptions, options);
@@ -81,13 +78,18 @@ let ContextScopedReplaceInput = class ContextScopedReplaceInput extends ReplaceI
         this._register(registerAndCreateHistoryNavigationContext(scopedContextKeyService, this.inputBox));
     }
 };
-ContextScopedReplaceInput = ( __decorate([
-    ( __param(3, IContextKeyService))
-], ContextScopedReplaceInput));
+ContextScopedReplaceInput = ( (__decorate([
+    ( (__param(3, IContextKeyService)))
+], ContextScopedReplaceInput)));
 KeybindingsRegistry.registerCommandAndKeybindingRule({
     id: 'history.showPrevious',
     weight: 200 ,
-    when: ( ContextKeyExpr.and(( ContextKeyExpr.has(HistoryNavigationWidgetFocusContext)), ( ContextKeyExpr.equals(HistoryNavigationBackwardsEnablementContext, true)), ContextKeyExpr.not('isComposing'), ( historyNavigationVisible.isEqualTo(false)))),
+    when: ( (ContextKeyExpr.and(
+         (ContextKeyExpr.has(HistoryNavigationWidgetFocusContext)),
+         (ContextKeyExpr.equals(HistoryNavigationBackwardsEnablementContext, true)),
+        ContextKeyExpr.not('isComposing'),
+         (historyNavigationVisible.isEqualTo(false))
+    ))),
     primary: 16 ,
     secondary: [512  | 16 ],
     handler: (accessor) => {
@@ -97,7 +99,12 @@ KeybindingsRegistry.registerCommandAndKeybindingRule({
 KeybindingsRegistry.registerCommandAndKeybindingRule({
     id: 'history.showNext',
     weight: 200 ,
-    when: ( ContextKeyExpr.and(( ContextKeyExpr.has(HistoryNavigationWidgetFocusContext)), ( ContextKeyExpr.equals(HistoryNavigationForwardsEnablementContext, true)), ContextKeyExpr.not('isComposing'), ( historyNavigationVisible.isEqualTo(false)))),
+    when: ( (ContextKeyExpr.and(
+         (ContextKeyExpr.has(HistoryNavigationWidgetFocusContext)),
+         (ContextKeyExpr.equals(HistoryNavigationForwardsEnablementContext, true)),
+        ContextKeyExpr.not('isComposing'),
+         (historyNavigationVisible.isEqualTo(false))
+    ))),
     primary: 18 ,
     secondary: [512  | 18 ],
     handler: (accessor) => {

package/vscode/src/vs/platform/hover/browser/hover.js

@@ -60,7 +60,7 @@ let WorkbenchHoverDelegate = class WorkbenchHoverDelegate extends Disposable {
     }
     setInstantHoverTimeLimit(timeLimit) {
         if (!this.instantHover) {
-            throw new Error('Instant hover is not enabled');
+            throw ( new Error('Instant hover is not enabled'));
         }
         this.timeLimit = timeLimit;
     }
@@ -77,7 +77,7 @@ WorkbenchHoverDelegate = ( __decorate([
 ], WorkbenchHoverDelegate));
 const nativeHoverDelegate = {
     showHover: function () {
-        throw new Error('Native hover function not implemented.');
+        throw ( new Error('Native hover function not implemented.'));
     },
     delay: 0,
     showNativeHover: true

package/vscode/src/vs/platform/hover/browser/hover.service.d.ts

@@ -1,38 +1,9 @@
 import { ServiceIdentifier } from '../../instantiation/common/instantiation.js';
-import { IHoverWidget } from '../../../base/browser/ui/hover/updatableHoverWidget.js';
-import { IHoverOptions } from './hover.js';
+import { IHoverDelegate2 } from '../../../base/browser/ui/hover/hover.js';
 
 declare const IHoverService: ServiceIdentifier<IHoverService>;
-/**
-* Enables the convenient display of rich markdown-based hovers in the workbench.
-*/
-interface IHoverService {
+interface IHoverService extends IHoverDelegate2 {
     readonly _serviceBrand: undefined;
-    /**
-    * Shows a hover, provided a hover with the same options object is not already visible.
-    * @param options A set of options defining the characteristics of the hover.
-    * @param focus Whether to focus the hover (useful for keyboard accessibility).
-    *
-    * **Example:** A simple usage with a single element target.
-    *
-    * ```typescript
-    * showHover({
-    *   text: new MarkdownString('Hello world'),
-    *   target: someElement
-    * });
-    * ```
-    */
-    showHover(options: 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.
-    */
-    hideHover(): void;
-    /**
-    * This should only be used until we have the ability to show multiple context views
-    * simultaneously. #188822
-    */
-    showAndFocusLastHover(): void;
 }
 
 export { IHoverService };

package/vscode/src/vs/platform/instantiation/common/instantiation.d.ts

@@ -32,6 +32,15 @@ interface IInstantiationService {
      * and adds/overwrites the given services.
      */
     createChild(services: ServiceCollection): IInstantiationService;
+    /**
+     * Disposes this instantiation service.
+     *
+     * - Will dispose all services that this instantiation service has created.
+     * - Will dispose all its children but not its parent.
+     * - Will NOT dispose services-instances that this service has been created with
+     * - Will NOT dispose consumer-instances this service has created
+     */
+    dispose(): void;
 }
 /**
  * Identifies a service of type `T`.

package/vscode/src/vs/platform/instantiation/common/instantiation.js

@@ -24,7 +24,7 @@ function createDecorator(serviceId) {
     }
     const id = function (target, key, index) {
         if (arguments.length !== 3) {
-            throw new Error('@IServiceName-decorator can only be used to decorate a parameter');
+            throw ( new Error('@IServiceName-decorator can only be used to decorate a parameter'));
         }
         storeServiceDependency(id, target, index);
     };

package/vscode/src/vs/platform/instantiation/common/instantiationService.js

@@ -1,6 +1,6 @@
 import { GlobalIdleValue } from '../../../base/common/async.js';
 import { illegalState } from '../../../base/common/errors.js';
-import { toDisposable } from '../../../base/common/lifecycle.js';
+import { dispose, isDisposable, toDisposable } from '../../../base/common/lifecycle.js';
 import { SyncDescriptor } from './descriptors.js';
 import { Graph } from './graph.js';
 import { IInstantiationService, _util } from './instantiation.js';
@@ -19,14 +19,44 @@ class InstantiationService {
         this._strict = _strict;
         this._parent = _parent;
         this._enableTracing = _enableTracing;
+        this._isDisposed = false;
+        this._servicesToMaybeDispose = ( new Set());
+        this._children = ( new Set());
         this._activeInstantiations = ( new Set());
         this._services.set(IInstantiationService, this);
         this._globalGraph = _enableTracing ? _parent?._globalGraph ?? ( new Graph(e => e)) : undefined;
     }
+    dispose() {
+        if (!this._isDisposed) {
+            this._isDisposed = true;
+            dispose(this._children);
+            this._children.clear();
+            for (const candidate of this._servicesToMaybeDispose) {
+                if (isDisposable(candidate)) {
+                    candidate.dispose();
+                }
+            }
+            this._servicesToMaybeDispose.clear();
+        }
+    }
+    _throwIfDisposed() {
+        if (this._isDisposed) {
+            throw ( new Error('InstantiationService has been disposed'));
+        }
+    }
     createChild(services) {
-        return ( new InstantiationService(services, this._strict, this, this._enableTracing));
+        this._throwIfDisposed();
+        const result = new (class extends InstantiationService {
+            dispose() {
+                this._children.delete(result);
+                super.dispose();
+            }
+        })(services, this._strict, this, this._enableTracing);
+        this._children.add(result);
+        return result;
     }
     invokeFunction(fn, ...args) {
+        this._throwIfDisposed();
         const _trace = Trace.traceInvocation(this._enableTracing, fn);
         let _done = false;
         try {
@@ -37,7 +67,7 @@ class InstantiationService {
                     }
                     const result = this._getOrCreateServiceInstance(id, _trace);
                     if (!result) {
-                        throw new Error(`[invokeFunction] unknown service '${id}'`);
+                        throw ( new Error(`[invokeFunction] unknown service '${id}'`));
                     }
                     return result;
                 }
@@ -50,6 +80,7 @@ class InstantiationService {
         }
     }
     createInstance(ctorOrDescriptor, ...rest) {
+        this._throwIfDisposed();
         let _trace;
         let result;
         if (ctorOrDescriptor instanceof SyncDescriptor) {
@@ -86,15 +117,15 @@ class InstantiationService {
         }
         return Reflect.construct(ctor, args.concat(serviceArgs));
     }
-    _setServiceInstance(id, instance) {
+    _setCreatedServiceInstance(id, instance) {
         if (this._services.get(id) instanceof SyncDescriptor) {
             this._services.set(id, instance);
         }
         else if (this._parent) {
-            this._parent._setServiceInstance(id, instance);
+            this._parent._setCreatedServiceInstance(id, instance);
         }
         else {
-            throw new Error('illegalState - setting UNKNOWN service instance');
+            throw ( new Error('illegalState - setting UNKNOWN service instance'));
         }
     }
     _getServiceInstanceOrDescriptor(id) {
@@ -121,7 +152,7 @@ class InstantiationService {
     }
     _safeCreateAndCacheServiceInstance(id, desc, _trace) {
         if (( this._activeInstantiations.has(id))) {
-            throw new Error(`illegal state - RECURSIVELY instantiating service '${id}'`);
+            throw ( new Error(`illegal state - RECURSIVELY instantiating service '${id}'`));
         }
         this._activeInstantiations.add(id);
         try {
@@ -139,7 +170,7 @@ class InstantiationService {
             const item = stack.pop();
             graph.lookupOrInsertNode(item);
             if (cycleCount++ > 1000) {
-                throw new CyclicDependencyError(graph);
+                throw ( new CyclicDependencyError(graph));
             }
             for (const dependency of _util.getServiceDependencies(item.desc.ctor)) {
                 const instanceOrDesc = this._getServiceInstanceOrDescriptor(dependency.id);
@@ -160,7 +191,7 @@ class InstantiationService {
             const roots = graph.roots();
             if (roots.length === 0) {
                 if (!graph.isEmpty()) {
-                    throw new CyclicDependencyError(graph);
+                    throw ( new CyclicDependencyError(graph));
                 }
                 break;
             }
@@ -168,7 +199,7 @@ class InstantiationService {
                 const instanceOrDesc = this._getServiceInstanceOrDescriptor(data.id);
                 if (instanceOrDesc instanceof SyncDescriptor) {
                     const instance = this._createServiceInstanceWithOwner(data.id, data.desc.ctor, data.desc.staticArguments, data.desc.supportsDelayedInstantiation, data._trace);
-                    this._setServiceInstance(data.id, instance);
+                    this._setCreatedServiceInstance(data.id, instance);
                 }
                 graph.removeNode(data);
             }
@@ -177,18 +208,20 @@ class InstantiationService {
     }
     _createServiceInstanceWithOwner(id, ctor, args = [], supportsDelayedInstantiation, _trace) {
         if (this._services.get(id) instanceof SyncDescriptor) {
-            return this._createServiceInstance(id, ctor, args, supportsDelayedInstantiation, _trace);
+            return this._createServiceInstance(id, ctor, args, supportsDelayedInstantiation, _trace, this._servicesToMaybeDispose);
         }
         else if (this._parent) {
             return this._parent._createServiceInstanceWithOwner(id, ctor, args, supportsDelayedInstantiation, _trace);
         }
         else {
-            throw new Error(`illegalState - creating UNKNOWN service instance ${ctor.name}`);
+            throw ( new Error(`illegalState - creating UNKNOWN service instance ${ctor.name}`));
         }
     }
-    _createServiceInstance(id, ctor, args = [], supportsDelayedInstantiation, _trace) {
+    _createServiceInstance(id, ctor, args = [], supportsDelayedInstantiation, _trace, disposeBucket) {
         if (!supportsDelayedInstantiation) {
-            return this._createInstance(ctor, args, _trace);
+            const result = this._createInstance(ctor, args, _trace);
+            disposeBucket.add(result);
+            return result;
         }
         else {
             const child = ( new InstantiationService(undefined, this._strict, this, this._enableTracing));
@@ -205,6 +238,7 @@ class InstantiationService {
                     }
                 }
                 earlyListeners.clear();
+                disposeBucket.add(result);
                 return result;
             }));
             return ( new Proxy(Object.create(null), {
@@ -260,7 +294,7 @@ class InstantiationService {
             console.warn(msg);
         }
         if (this._strict) {
-            throw new Error(msg);
+            throw ( new Error(msg));
         }
     }
 }

package/vscode/src/vs/platform/keybinding/common/abstractKeybindingService.js

@@ -6,6 +6,7 @@ import { IME } from '../../../base/common/ime.js';
 import { Disposable } from '../../../base/common/lifecycle.js';
 import { localizeWithPath } from '../../../nls.js';
 import { NoMatchingKb } from './keybindingResolver.js';
+const _moduleId = "vs/platform/keybinding/common/abstractKeybindingService";
 const HIGH_FREQ_COMMANDS = /^(cursor|delete|undo|redo|tab|editor\.action\.clipboard)/;
 class AbstractKeybindingService extends Disposable {
     get onDidUpdateKeybindings() {
@@ -21,13 +22,13 @@ class AbstractKeybindingService extends Disposable {
         this._telemetryService = _telemetryService;
         this._notificationService = _notificationService;
         this._logService = _logService;
-        this._onDidUpdateKeybindings = this._register(( new Emitter()));
+        this._onDidUpdateKeybindings = this._register(( (new Emitter())));
         this._currentChords = [];
-        this._currentChordChecker = ( new IntervalTimer());
+        this._currentChordChecker = ( (new IntervalTimer()));
         this._currentChordStatusMessage = null;
         this._ignoreSingleModifiers = KeybindingModifierSet.EMPTY;
         this._currentSingleModifier = null;
-        this._currentSingleModifierClearTimeout = ( new TimeoutTimer());
+        this._currentSingleModifierClearTimeout = ( (new TimeoutTimer()));
         this._currentlyDispatchingCommandId = null;
         this._logging = false;
     }
@@ -56,7 +57,7 @@ class AbstractKeybindingService extends Disposable {
         return 0;
     }
     lookupKeybindings(commandId) {
-        return coalesce(( this._getResolver().lookupKeybindings(commandId).map(item => item.resolvedKeybinding)));
+        return coalesce(( (this._getResolver().lookupKeybindings(commandId).map(item => item.resolvedKeybinding))));
     }
     lookupKeybinding(commandId, context) {
         const result = this._getResolver().lookupPrimaryKeybinding(commandId, context || this._contextKeyService);
@@ -81,7 +82,7 @@ class AbstractKeybindingService extends Disposable {
             return NoMatchingKb;
         }
         const contextValue = this._contextKeyService.getContext(target);
-        const currentChords = ( this._currentChords.map((({ keypress }) => keypress)));
+        const currentChords = ( (this._currentChords.map((({ keypress }) => keypress))));
         return this._getResolver().resolve(contextValue, currentChords, firstChord);
     }
     _scheduleLeaveChordMode() {
@@ -103,17 +104,17 @@ class AbstractKeybindingService extends Disposable {
                 throw illegalState('impossible');
             case 1:
                 this._currentChordStatusMessage = this._notificationService.status(( localizeWithPath(
-                    'vs/platform/keybinding/common/abstractKeybindingService',
-                    'first.chord',
+                    _moduleId,
+                    0,
                     "({0}) was pressed. Waiting for second key of chord...",
                     keypressLabel
                 )));
                 break;
             default: {
-                const fullKeypressLabel = ( this._currentChords.map(({ label }) => label)).join(', ');
+                const fullKeypressLabel = ( (this._currentChords.map(({ label }) => label))).join(', ');
                 this._currentChordStatusMessage = this._notificationService.status(( localizeWithPath(
-                    'vs/platform/keybinding/common/abstractKeybindingService',
-                    'next.chord',
+                    _moduleId,
+                    1,
                     "({0}) was pressed. Waiting for next key of chord...",
                     fullKeypressLabel
                 )));
@@ -150,7 +151,7 @@ class AbstractKeybindingService extends Disposable {
         const keybinding = this.resolveKeyboardEvent(e);
         const [singleModifier,] = keybinding.getSingleModifierDispatchChords();
         if (singleModifier) {
-            if (( this._ignoreSingleModifiers.has(singleModifier))) {
+            if (( (this._ignoreSingleModifiers.has(singleModifier)))) {
                 this._log(`+ Ignoring single modifier ${singleModifier} due to it being pressed together with other keys.`);
                 this._ignoreSingleModifiers = KeybindingModifierSet.EMPTY;
                 this._currentSingleModifierClearTimeout.cancel();
@@ -179,7 +180,7 @@ class AbstractKeybindingService extends Disposable {
             return false;
         }
         const [firstChord,] = keybinding.getChords();
-        this._ignoreSingleModifiers = ( new KeybindingModifierSet(firstChord));
+        this._ignoreSingleModifiers = ( (new KeybindingModifierSet(firstChord)));
         if (this._currentSingleModifier !== null) {
             this._log(`+ Clearing single modifier due to other key up.`);
         }
@@ -202,7 +203,7 @@ class AbstractKeybindingService extends Disposable {
         }
         else {
             [userPressedChord,] = userKeypress.getDispatchChords();
-            currentChords = ( this._currentChords.map(({ keypress }) => keypress));
+            currentChords = ( (this._currentChords.map(({ keypress }) => keypress)));
         }
         if (userPressedChord === null) {
             this._log(`\\ Keyboard event cannot be dispatched in keydown phase.`);
@@ -215,11 +216,11 @@ class AbstractKeybindingService extends Disposable {
             case 0 : {
                 this._logService.trace('KeybindingService#dispatch', keypressLabel, `[ No matching keybinding ]`);
                 if (this.inChordMode) {
-                    const currentChordsLabel = ( this._currentChords.map(({ label }) => label)).join(', ');
+                    const currentChordsLabel = ( (this._currentChords.map(({ label }) => label))).join(', ');
                     this._log(`+ Leaving multi-chord mode: Nothing bound to "${currentChordsLabel}, ${keypressLabel}".`);
                     this._notificationService.status(( localizeWithPath(
-                        'vs/platform/keybinding/common/abstractKeybindingService',
-                        'missing.chord',
+                        _moduleId,
+                        2,
                         "The key combination ({0}, {1}) is not a command.",
                         currentChordsLabel,
                         keypressLabel
@@ -240,11 +241,11 @@ class AbstractKeybindingService extends Disposable {
                 this._logService.trace('KeybindingService#dispatch', keypressLabel, `[ Will dispatch command ${resolveResult.commandId} ]`);
                 if (resolveResult.commandId === null || resolveResult.commandId === '') {
                     if (this.inChordMode) {
-                        const currentChordsLabel = ( this._currentChords.map(({ label }) => label)).join(', ');
+                        const currentChordsLabel = ( (this._currentChords.map(({ label }) => label))).join(', ');
                         this._log(`+ Leaving chord mode: Nothing bound to "${currentChordsLabel}, ${keypressLabel}".`);
                         this._notificationService.status(( localizeWithPath(
-                            'vs/platform/keybinding/common/abstractKeybindingService',
-                            'missing.chord',
+                            _moduleId,
+                            2,
                             "The key combination ({0}, {1}) is not a command.",
                             currentChordsLabel,
                             keypressLabel
@@ -293,7 +294,7 @@ class AbstractKeybindingService extends Disposable {
     }
 }
 class KeybindingModifierSet {
-    static { this.EMPTY = ( new KeybindingModifierSet(null)); }
+    static { this.EMPTY = ( (new KeybindingModifierSet(null))); }
     constructor(source) {
         this._ctrlKey = source ? source.ctrlKey : false;
         this._shiftKey = source ? source.shiftKey : false;

package/vscode/src/vs/platform/languagePacks/common/languagePacks.js

@@ -1,9 +1,78 @@
-import '../../../base/common/cancellation.js';
-import '../../../base/common/lifecycle.js';
-import '../../../base/common/platform.js';
-import '../../../nls.js';
-import '../../instantiation/common/instantiation.js';
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { CancellationTokenSource } from '../../../base/common/cancellation.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { language } from '../../../base/common/platform.js';
+import { localizeWithPath } from '../../../nls.js';
+import { IExtensionGalleryService } from '../../extensionManagement/common/extensionManagement.service.js';
+const _moduleId = "vs/platform/languagePacks/common/languagePacks";
 function getLocale(extension) {
     return extension.tags.find(t => t.startsWith('lp-'))?.split('lp-')[1];
 }
-export { getLocale };
+let LanguagePackBaseService = class LanguagePackBaseService extends Disposable {
+    constructor(extensionGalleryService) {
+        super();
+        this.extensionGalleryService = extensionGalleryService;
+    }
+    async getAvailableLanguages() {
+        const timeout = ( (new CancellationTokenSource()));
+        setTimeout(() => timeout.cancel(), 1000);
+        let result;
+        try {
+            result = await this.extensionGalleryService.query({
+                text: 'category:"language packs"',
+                pageSize: 20
+            }, timeout.token);
+        }
+        catch (_) {
+            return [];
+        }
+        const languagePackExtensions = result.firstPage.filter(e => e.properties.localizedLanguages?.length && ( (e.tags.some(t => t.startsWith('lp-')))));
+        const allFromMarketplace = ( (languagePackExtensions.map(lp => {
+            const languageName = lp.properties.localizedLanguages?.[0];
+            const locale = getLocale(lp);
+            const baseQuickPick = this.createQuickPickItem(locale, languageName, lp);
+            return {
+                ...baseQuickPick,
+                extensionId: lp.identifier.id,
+                galleryExtension: lp
+            };
+        })));
+        allFromMarketplace.push(this.createQuickPickItem('en', 'English'));
+        return allFromMarketplace;
+    }
+    createQuickPickItem(locale, languageName, languagePack) {
+        const label = languageName ?? locale;
+        let description;
+        if (label !== locale) {
+            description = `(${locale})`;
+        }
+        if (locale.toLowerCase() === language.toLowerCase()) {
+            description ??= '';
+            description += ( localizeWithPath(_moduleId, 0, " (Current)"));
+        }
+        if (languagePack?.installCount) {
+            description ??= '';
+            const count = languagePack.installCount;
+            let countLabel;
+            if (count > 1000000) {
+                countLabel = `${Math.floor(count / 100000) / 10}M`;
+            }
+            else if (count > 1000) {
+                countLabel = `${Math.floor(count / 1000)}K`;
+            }
+            else {
+                countLabel = String(count);
+            }
+            description += ` $(cloud-download) ${countLabel}`;
+        }
+        return {
+            id: locale,
+            label,
+            description
+        };
+    }
+};
+LanguagePackBaseService = ( (__decorate([
+    ( (__param(0, IExtensionGalleryService)))
+], LanguagePackBaseService)));
+export { LanguagePackBaseService, getLocale };

package/vscode/src/vs/platform/layout/browser/zIndexRegistry.js

@@ -29,11 +29,13 @@ class ZIndexRegistry {
     }
     registerZIndex(relativeLayer, z, name) {
         if (this.zIndexMap.get(name)) {
-            throw new Error(`z-index with name ${name} has already been registered.`);
+            throw ( new Error(`z-index with name ${name} has already been registered.`));
         }
         const proposedZValue = relativeLayer + z;
         if (findBase(proposedZValue) !== relativeLayer) {
-            throw new Error(`Relative layer: ${relativeLayer} + z-index: ${z} exceeds next layer ${proposedZValue}.`);
+            throw ( new Error(
+                `Relative layer: ${relativeLayer} + z-index: ${z} exceeds next layer ${proposedZValue}.`
+            ));
         }
         this.zIndexMap.set(name, proposedZValue);
         this.scheduler.schedule();