@codingame/monaco-vscode-api 32.0.0 → 32.0.1

package/vscode/src/vs/workbench/contrib/extensions/browser/extensionsActivationProgress.d.ts

@@ -0,0 +1,9 @@
+import { IWorkbenchContribution } from "../../../common/contributions.js";
+import { IExtensionService } from "../../../services/extensions/common/extensions.service.js";
+import { IProgressService } from "../../../../platform/progress/common/progress.service.js";
+import { ILogService } from "../../../../platform/log/common/log.service.js";
+export declare class ExtensionActivationProgress implements IWorkbenchContribution {
+    private readonly _listener;
+    constructor(extensionService: IExtensionService, progressService: IProgressService, logService: ILogService);
+    dispose(): void;
+}

package/vscode/src/vs/workbench/contrib/extensions/browser/extensionsActivationProgress.js

@@ -0,0 +1,40 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.service.js';
+import { ProgressLocation } from '../../../../platform/progress/common/progress.js';
+import { IProgressService } from '../../../../platform/progress/common/progress.service.js';
+import { localize } from '../../../../nls.js';
+import { DeferredPromise, timeout } from '../../../../base/common/async.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+
+let ExtensionActivationProgress = class ExtensionActivationProgress {
+    constructor(extensionService, progressService, logService) {
+        const options = {
+            location: ProgressLocation.Window,
+            title: ( localize(9766, "Activating Extensions..."))
+        };
+        let deferred;
+        let count = 0;
+        this._listener = extensionService.onWillActivateByEvent(e => {
+            logService.trace("onWillActivateByEvent: ", e.event);
+            if (!deferred) {
+                deferred = ( new DeferredPromise());
+                progressService.withProgress(options, _ => deferred.p);
+            }
+            count++;
+            Promise.race([e.activation, timeout(5000, CancellationToken.None)]).finally(() => {
+                if (--count === 0) {
+                    deferred.complete(undefined);
+                    deferred = undefined;
+                }
+            });
+        });
+    }
+    dispose() {
+        this._listener.dispose();
+    }
+};
+ExtensionActivationProgress = ( __decorate([( __param(0, IExtensionService)), ( __param(1, IProgressService)), ( __param(2, ILogService))], ExtensionActivationProgress));
+
+export { ExtensionActivationProgress };

package/vscode/src/vs/workbench/contrib/extensions/browser/extensionsCompletionItemsProvider.d.ts

@@ -0,0 +1,9 @@
+import { Disposable } from "../../../../base/common/lifecycle.js";
+import { IExtensionManagementService } from "../../../../platform/extensionManagement/common/extensionManagement.service.js";
+import { IWorkbenchContribution } from "../../../common/contributions.js";
+import { ILanguageFeaturesService } from "../../../../editor/common/services/languageFeatures.service.js";
+export declare class ExtensionsCompletionItemsProvider extends Disposable implements IWorkbenchContribution {
+    private readonly extensionManagementService;
+    constructor(extensionManagementService: IExtensionManagementService, languageFeaturesService: ILanguageFeaturesService);
+    private provideSupportUntrustedWorkspacesExtensionProposals;
+}

package/vscode/src/vs/workbench/contrib/extensions/browser/extensionsCompletionItemsProvider.js

@@ -0,0 +1,77 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localize } from '../../../../nls.js';
+import { getLocation, parse } from '../../../../base/common/json.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { CompletionItemKind } from '../../../../editor/common/languages.js';
+import { IExtensionManagementService } from '../../../../platform/extensionManagement/common/extensionManagement.service.js';
+import { Range } from '../../../../editor/common/core/range.js';
+import { ILanguageFeaturesService } from '../../../../editor/common/services/languageFeatures.service.js';
+
+let ExtensionsCompletionItemsProvider = class ExtensionsCompletionItemsProvider extends Disposable {
+    constructor(extensionManagementService, languageFeaturesService) {
+        super();
+        this.extensionManagementService = extensionManagementService;
+        this._register(languageFeaturesService.completionProvider.register({
+            language: "jsonc",
+            pattern: "**/settings.json"
+        }, {
+            _debugDisplayName: "extensionsCompletionProvider",
+            provideCompletionItems: async (model, position, _context, token) => {
+                const getWordRangeAtPosition = (model, position) => {
+                    const wordAtPosition = model.getWordAtPosition(position);
+                    return wordAtPosition ? ( new Range(
+                        position.lineNumber,
+                        wordAtPosition.startColumn,
+                        position.lineNumber,
+                        wordAtPosition.endColumn
+                    )) : null;
+                };
+                const location = getLocation(model.getValue(), model.getOffsetAt(position));
+                const range = getWordRangeAtPosition(model, position) ?? Range.fromPositions(position, position);
+                if (location.path[0] === "extensions.supportUntrustedWorkspaces" && location.path.length === 2 && location.isAtPropertyKey) {
+                    let alreadyConfigured = [];
+                    try {
+                        alreadyConfigured = ( Object.keys(parse(model.getValue())["extensions.supportUntrustedWorkspaces"]));
+                    } catch (e) {}
+                    return {
+                        suggestions: await this.provideSupportUntrustedWorkspacesExtensionProposals(alreadyConfigured, range)
+                    };
+                }
+                return {
+                    suggestions: []
+                };
+            }
+        }));
+    }
+    async provideSupportUntrustedWorkspacesExtensionProposals(alreadyConfigured, range) {
+        const suggestions = [];
+        const installedExtensions = (await this.extensionManagementService.getInstalled()).filter(e => e.manifest.main);
+        const proposedExtensions = installedExtensions.filter(e => alreadyConfigured.indexOf(e.identifier.id) === -1);
+        if (proposedExtensions.length) {
+            suggestions.push(...( proposedExtensions.map(e => {
+                const text = `"${e.identifier.id}": {\n\t"supported": true,\n\t"version": "${e.manifest.version}"\n},`;
+                return {
+                    label: e.identifier.id,
+                    kind: CompletionItemKind.Value,
+                    insertText: text,
+                    filterText: text,
+                    range
+                };
+            })));
+        } else {
+            const text = "\"vscode.csharp\": {\n\t\"supported\": true,\n\t\"version\": \"0.0.0\"\n},";
+            suggestions.push({
+                label: ( localize(9767, "Example")),
+                kind: CompletionItemKind.Value,
+                insertText: text,
+                filterText: text,
+                range
+            });
+        }
+        return suggestions;
+    }
+};
+ExtensionsCompletionItemsProvider = ( __decorate([( __param(0, IExtensionManagementService)), ( __param(1, ILanguageFeaturesService))], ExtensionsCompletionItemsProvider));
+
+export { ExtensionsCompletionItemsProvider };

package/vscode/src/vs/workbench/contrib/extensions/browser/extensionsDependencyChecker.d.ts

@@ -0,0 +1,16 @@
+import { IExtensionsWorkbenchService } from "../common/extensions.service.js";
+import { IWorkbenchContribution } from "../../../common/contributions.js";
+import { IExtensionService } from "../../../services/extensions/common/extensions.service.js";
+import { INotificationService } from "../../../../platform/notification/common/notification.service.js";
+import { IHostService } from "../../../services/host/browser/host.service.js";
+import { Disposable } from "../../../../base/common/lifecycle.js";
+export declare class ExtensionDependencyChecker extends Disposable implements IWorkbenchContribution {
+    private readonly extensionService;
+    private readonly extensionsWorkbenchService;
+    private readonly notificationService;
+    private readonly hostService;
+    constructor(extensionService: IExtensionService, extensionsWorkbenchService: IExtensionsWorkbenchService, notificationService: INotificationService, hostService: IHostService);
+    private getUninstalledMissingDependencies;
+    private getAllMissingDependencies;
+    private installMissingDependencies;
+}

package/vscode/src/vs/workbench/contrib/extensions/browser/extensionsDependencyChecker.js

@@ -0,0 +1,93 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IExtensionsWorkbenchService } from '../common/extensions.service.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.service.js';
+import { CommandsRegistry } from '../../../../platform/commands/common/commands.js';
+import { MenuRegistry, MenuId } from '../../../../platform/actions/common/actions.js';
+import { localize } from '../../../../nls.js';
+import { areSameExtensions } from '../../../../platform/extensionManagement/common/extensionManagementUtil.js';
+import '../../../../platform/notification/common/notification.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.service.js';
+import { Action } from '../../../../base/common/actions.js';
+import { IHostService } from '../../../services/host/browser/host.service.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { Promises } from '../../../../base/common/async.js';
+import Severity$1 from '../../../../base/common/severity.js';
+
+let ExtensionDependencyChecker = class ExtensionDependencyChecker extends Disposable {
+    constructor(
+        extensionService,
+        extensionsWorkbenchService,
+        notificationService,
+        hostService
+    ) {
+        super();
+        this.extensionService = extensionService;
+        this.extensionsWorkbenchService = extensionsWorkbenchService;
+        this.notificationService = notificationService;
+        this.hostService = hostService;
+        CommandsRegistry.registerCommand(
+            "workbench.extensions.installMissingDependencies",
+            () => this.installMissingDependencies()
+        );
+        MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+            command: {
+                id: "workbench.extensions.installMissingDependencies",
+                category: ( localize(9768, "Extensions")),
+                title: ( localize(9769, "Install Missing Dependencies"))
+            }
+        });
+    }
+    async getUninstalledMissingDependencies() {
+        const allMissingDependencies = await this.getAllMissingDependencies();
+        const localExtensions = await this.extensionsWorkbenchService.queryLocal();
+        return allMissingDependencies.filter(id => localExtensions.every(l => !areSameExtensions(l.identifier, {
+            id
+        })));
+    }
+    async getAllMissingDependencies() {
+        await this.extensionService.whenInstalledExtensionsRegistered();
+        const runningExtensionsIds = this.extensionService.extensions.reduce((result, r) => {
+            result.add(r.identifier.value.toLowerCase());
+            return result;
+        }, ( new Set()));
+        const missingDependencies = ( new Set());
+        for (const extension of this.extensionService.extensions) {
+            if (extension.extensionDependencies) {
+                extension.extensionDependencies.forEach(dep => {
+                    if (!( runningExtensionsIds.has(dep.toLowerCase()))) {
+                        missingDependencies.add(dep);
+                    }
+                });
+            }
+        }
+        return [...( missingDependencies.values())];
+    }
+    async installMissingDependencies() {
+        const missingDependencies = await this.getUninstalledMissingDependencies();
+        if (missingDependencies.length) {
+            const extensions = await this.extensionsWorkbenchService.getExtensions(( missingDependencies.map(id => ({
+                id
+            }))), CancellationToken.None);
+            if (extensions.length) {
+                await Promises.settled(( extensions.map(extension => this.extensionsWorkbenchService.install(extension))));
+                this.notificationService.notify({
+                    severity: Severity$1.Info,
+                    message: ( localize(
+                        9770,
+                        "Finished installing missing dependencies. Please reload the window now."
+                    )),
+                    actions: {
+                        primary: [( new Action("realod", ( localize(9771, "Reload Window")), "", true, () => this.hostService.reload()))]
+                    }
+                });
+            }
+        } else {
+            this.notificationService.info(( localize(9772, "There are no missing dependencies to install.")));
+        }
+    }
+};
+ExtensionDependencyChecker = ( __decorate([( __param(0, IExtensionService)), ( __param(1, IExtensionsWorkbenchService)), ( __param(2, INotificationService)), ( __param(3, IHostService))], ExtensionDependencyChecker));
+
+export { ExtensionDependencyChecker };

package/vscode/src/vs/workbench/contrib/extensions/browser/extensionsIcons.js

@@ -3,16 +3,16 @@ import { Codicon } from '../../../../base/common/codicons.js';
 import { localize } from '../../../../nls.js';
 import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
 
-const extensionsViewIcon = registerIcon("extensions-view-icon", Codicon.extensions, ( localize(9762, "View icon of the extensions view.")));
-const manageExtensionIcon = registerIcon("extensions-manage", Codicon.gear, ( localize(9763, "Icon for the 'Manage' action in the extensions view.")));
-const clearSearchResultsIcon = registerIcon("extensions-clear-search-results", Codicon.clearAll, ( localize(9764, "Icon for the 'Clear Search Result' action in the extensions view.")));
-const refreshIcon = registerIcon("extensions-refresh", Codicon.refresh, ( localize(9765, "Icon for the 'Refresh' action in the extensions view.")));
-const filterIcon = registerIcon("extensions-filter", Codicon.filter, ( localize(9766, "Icon for the 'Filter' action in the extensions view.")));
+const extensionsViewIcon = registerIcon("extensions-view-icon", Codicon.extensions, ( localize(9773, "View icon of the extensions view.")));
+const manageExtensionIcon = registerIcon("extensions-manage", Codicon.gear, ( localize(9774, "Icon for the 'Manage' action in the extensions view.")));
+const clearSearchResultsIcon = registerIcon("extensions-clear-search-results", Codicon.clearAll, ( localize(9775, "Icon for the 'Clear Search Result' action in the extensions view.")));
+const refreshIcon = registerIcon("extensions-refresh", Codicon.refresh, ( localize(9776, "Icon for the 'Refresh' action in the extensions view.")));
+const filterIcon = registerIcon("extensions-filter", Codicon.filter, ( localize(9777, "Icon for the 'Filter' action in the extensions view.")));
 const installLocalInRemoteIcon = registerIcon(
     "extensions-install-local-in-remote",
     Codicon.cloudDownload,
     ( localize(
-    9767,
+    9778,
     "Icon for the 'Install Local Extension in Remote' action in the extensions view."
 ))
 );
@@ -20,50 +20,50 @@ const installWorkspaceRecommendedIcon = registerIcon(
     "extensions-install-workspace-recommended",
     Codicon.cloudDownload,
     ( localize(
-    9768,
+    9779,
     "Icon for the 'Install Workspace Recommended Extensions' action in the extensions view."
 ))
 );
 const configureRecommendedIcon = registerIcon("extensions-configure-recommended", Codicon.pencil, ( localize(
-    9769,
+    9780,
     "Icon for the 'Configure Recommended Extensions' action in the extensions view."
 )));
-const syncEnabledIcon = registerIcon("extensions-sync-enabled", Codicon.sync, ( localize(9770, "Icon to indicate that an extension is synced.")));
-const syncIgnoredIcon = registerIcon("extensions-sync-ignored", Codicon.syncIgnored, ( localize(9771, "Icon to indicate that an extension is ignored when syncing.")));
+const syncEnabledIcon = registerIcon("extensions-sync-enabled", Codicon.sync, ( localize(9781, "Icon to indicate that an extension is synced.")));
+const syncIgnoredIcon = registerIcon("extensions-sync-ignored", Codicon.syncIgnored, ( localize(9782, "Icon to indicate that an extension is ignored when syncing.")));
 const remoteIcon = registerIcon("extensions-remote", Codicon.remote, ( localize(
-    9772,
+    9783,
     "Icon to indicate that an extension is remote in the extensions view and editor."
 )));
 const installCountIcon = registerIcon("extensions-install-count", Codicon.cloudDownload, ( localize(
-    9773,
+    9784,
     "Icon shown along with the install count in the extensions view and editor."
 )));
 const privateExtensionIcon = registerIcon("extensions-private", Codicon.lock, ( localize(
-    9774,
+    9785,
     "Icon shown for private extensions in the extensions view and editor."
 )));
 const ratingIcon = registerIcon("extensions-rating", Codicon.star, ( localize(
-    9775,
+    9786,
     "Icon shown along with the rating in the extensions view and editor."
 )));
 const preReleaseIcon = registerIcon("extensions-pre-release", Codicon.versions, ( localize(
-    9776,
+    9787,
     "Icon shown for extensions having pre-release versions in extensions view and editor."
 )));
 const sponsorIcon = registerIcon("extensions-sponsor", Codicon.heartFilled, ( localize(
-    9777,
+    9788,
     "Icon used for sponsoring extensions in the extensions view and editor."
 )));
-const starFullIcon = registerIcon("extensions-star-full", Codicon.starFull, ( localize(9778, "Full star icon used for the rating in the extensions editor.")));
-const starHalfIcon = registerIcon("extensions-star-half", Codicon.starHalf, ( localize(9779, "Half star icon used for the rating in the extensions editor.")));
-const starEmptyIcon = registerIcon("extensions-star-empty", Codicon.starEmpty, ( localize(9780, "Empty star icon used for the rating in the extensions editor.")));
-const errorIcon = registerIcon("extensions-error-message", Codicon.error, ( localize(9781, "Icon shown with a error message in the extensions editor.")));
-const warningIcon = registerIcon("extensions-warning-message", Codicon.warning, ( localize(9782, "Icon shown with a warning message in the extensions editor.")));
-const infoIcon = registerIcon("extensions-info-message", Codicon.info, ( localize(9783, "Icon shown with an info message in the extensions editor.")));
-const trustIcon = registerIcon("extension-workspace-trust", Codicon.shield, ( localize(9784, "Icon shown with a workspace trust message in the extension editor.")));
-const activationTimeIcon = registerIcon("extension-activation-time", Codicon.history, ( localize(9785, "Icon shown with a activation time message in the extension editor.")));
+const starFullIcon = registerIcon("extensions-star-full", Codicon.starFull, ( localize(9789, "Full star icon used for the rating in the extensions editor.")));
+const starHalfIcon = registerIcon("extensions-star-half", Codicon.starHalf, ( localize(9790, "Half star icon used for the rating in the extensions editor.")));
+const starEmptyIcon = registerIcon("extensions-star-empty", Codicon.starEmpty, ( localize(9791, "Empty star icon used for the rating in the extensions editor.")));
+const errorIcon = registerIcon("extensions-error-message", Codicon.error, ( localize(9792, "Icon shown with a error message in the extensions editor.")));
+const warningIcon = registerIcon("extensions-warning-message", Codicon.warning, ( localize(9793, "Icon shown with a warning message in the extensions editor.")));
+const infoIcon = registerIcon("extensions-info-message", Codicon.info, ( localize(9794, "Icon shown with an info message in the extensions editor.")));
+const trustIcon = registerIcon("extension-workspace-trust", Codicon.shield, ( localize(9795, "Icon shown with a workspace trust message in the extension editor.")));
+const activationTimeIcon = registerIcon("extension-activation-time", Codicon.history, ( localize(9796, "Icon shown with a activation time message in the extension editor.")));
 const restartRequiredIcon = registerIcon("extension-restart-required", Codicon.refresh, ( localize(
-    9786,
+    9797,
     "Icon shown when an extension requires a restart in the extensions view."
 )));
 

package/vscode/src/vs/workbench/contrib/extensions/browser/extensionsQuickAccess.d.ts

@@ -0,0 +1,27 @@
+import { IQuickPickSeparator } from "../../../../platform/quickinput/common/quickInput.js";
+import { IPickerQuickAccessItem, PickerQuickAccessProvider } from "../../../../platform/quickinput/browser/pickerQuickAccess.js";
+import { CancellationToken } from "../../../../base/common/cancellation.js";
+import { IExtensionManagementService } from "../../../../platform/extensionManagement/common/extensionManagement.service.js";
+import { IExtensionGalleryService } from "../../../../platform/extensionManagement/common/extensionManagement.service.js";
+import { INotificationService } from "../../../../platform/notification/common/notification.service.js";
+import { ILogService } from "../../../../platform/log/common/log.service.js";
+import { DisposableStore } from "../../../../base/common/lifecycle.js";
+import { IExtensionsWorkbenchService } from "../common/extensions.service.js";
+export declare class InstallExtensionQuickAccessProvider extends PickerQuickAccessProvider<IPickerQuickAccessItem> {
+    private readonly extensionsWorkbenchService;
+    private readonly galleryService;
+    private readonly extensionsService;
+    private readonly notificationService;
+    private readonly logService;
+    static PREFIX: string;
+    constructor(extensionsWorkbenchService: IExtensionsWorkbenchService, galleryService: IExtensionGalleryService, extensionsService: IExtensionManagementService, notificationService: INotificationService, logService: ILogService);
+    protected _getPicks(filter: string, disposables: DisposableStore, token: CancellationToken): Array<IPickerQuickAccessItem | IQuickPickSeparator> | Promise<Array<IPickerQuickAccessItem | IQuickPickSeparator>>;
+    private getPicksForExtensionId;
+    private installExtension;
+}
+export declare class ManageExtensionsQuickAccessProvider extends PickerQuickAccessProvider<IPickerQuickAccessItem> {
+    private readonly extensionsWorkbenchService;
+    static PREFIX: string;
+    constructor(extensionsWorkbenchService: IExtensionsWorkbenchService);
+    protected _getPicks(): Array<IPickerQuickAccessItem | IQuickPickSeparator>;
+}

package/vscode/src/vs/workbench/contrib/extensions/browser/extensionsQuickAccess.js

@@ -0,0 +1,100 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { PickerQuickAccessProvider } from '../../../../platform/quickinput/browser/pickerQuickAccess.js';
+import { localize } from '../../../../nls.js';
+import { IExtensionGalleryService, IExtensionManagementService } from '../../../../platform/extensionManagement/common/extensionManagement.service.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.service.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { IExtensionsWorkbenchService } from '../common/extensions.service.js';
+
+var InstallExtensionQuickAccessProvider_1, ManageExtensionsQuickAccessProvider_1;
+let InstallExtensionQuickAccessProvider = class InstallExtensionQuickAccessProvider extends PickerQuickAccessProvider {
+    static {
+        InstallExtensionQuickAccessProvider_1 = this;
+    }
+    static {
+        this.PREFIX = "ext install ";
+    }
+    constructor(
+        extensionsWorkbenchService,
+        galleryService,
+        extensionsService,
+        notificationService,
+        logService
+    ) {
+        super(InstallExtensionQuickAccessProvider_1.PREFIX);
+        this.extensionsWorkbenchService = extensionsWorkbenchService;
+        this.galleryService = galleryService;
+        this.extensionsService = extensionsService;
+        this.notificationService = notificationService;
+        this.logService = logService;
+    }
+    _getPicks(filter, disposables, token) {
+        if (!filter) {
+            return [{
+                label: ( localize(9798, "Type an extension name to install or search."))
+            }];
+        }
+        const genericSearchPickItem = {
+            label: ( localize(9799, "Press Enter to search for extension '{0}'.", filter)),
+            accept: () => this.extensionsWorkbenchService.openSearch(filter)
+        };
+        if (/\./.test(filter)) {
+            return this.getPicksForExtensionId(filter, genericSearchPickItem, token);
+        }
+        return [genericSearchPickItem];
+    }
+    async getPicksForExtensionId(filter, fallback, token) {
+        try {
+            const [galleryExtension] = await this.galleryService.getExtensions([{
+                id: filter
+            }], token);
+            if (token.isCancellationRequested) {
+                return [];
+            }
+            if (!galleryExtension) {
+                return [fallback];
+            }
+            return [{
+                label: ( localize(9800, "Press Enter to install extension '{0}'.", filter)),
+                accept: () => this.installExtension(galleryExtension, filter)
+            }];
+        } catch (error) {
+            if (token.isCancellationRequested) {
+                return [];
+            }
+            this.logService.error(error);
+            return [fallback];
+        }
+    }
+    async installExtension(extension, name) {
+        try {
+            await this.extensionsWorkbenchService.openSearch(`@id:${name}`);
+            await this.extensionsService.installFromGallery(extension);
+        } catch (error) {
+            this.notificationService.error(error);
+        }
+    }
+};
+InstallExtensionQuickAccessProvider = InstallExtensionQuickAccessProvider_1 = ( __decorate([( __param(0, IExtensionsWorkbenchService)), ( __param(1, IExtensionGalleryService)), ( __param(2, IExtensionManagementService)), ( __param(3, INotificationService)), ( __param(4, ILogService))], InstallExtensionQuickAccessProvider));
+let ManageExtensionsQuickAccessProvider = class ManageExtensionsQuickAccessProvider extends PickerQuickAccessProvider {
+    static {
+        ManageExtensionsQuickAccessProvider_1 = this;
+    }
+    static {
+        this.PREFIX = "ext ";
+    }
+    constructor(extensionsWorkbenchService) {
+        super(ManageExtensionsQuickAccessProvider_1.PREFIX);
+        this.extensionsWorkbenchService = extensionsWorkbenchService;
+    }
+    _getPicks() {
+        return [{
+            label: ( localize(9801, "Press Enter to manage your extensions.")),
+            accept: () => this.extensionsWorkbenchService.openSearch("")
+        }];
+    }
+};
+ManageExtensionsQuickAccessProvider = ManageExtensionsQuickAccessProvider_1 = ( __decorate([( __param(0, IExtensionsWorkbenchService))], ManageExtensionsQuickAccessProvider));
+
+export { InstallExtensionQuickAccessProvider, ManageExtensionsQuickAccessProvider };

package/vscode/src/vs/workbench/contrib/extensions/browser/extensionsViewer.js

@@ -49,10 +49,10 @@ function getAriaLabelForExtension(extension) {
     if (!extension) {
         return "";
     }
-    const publisher = extension.publisherDomain?.verified ? ( localize(9791, "Verified Publisher {0}", extension.publisherDisplayName)) : ( localize(9792, "Publisher {0}", extension.publisherDisplayName));
-    const deprecated = extension?.deprecationInfo ? ( localize(9793, "Deprecated")) : "";
+    const publisher = extension.publisherDomain?.verified ? ( localize(9802, "Verified Publisher {0}", extension.publisherDisplayName)) : ( localize(9803, "Publisher {0}", extension.publisherDisplayName));
+    const deprecated = extension?.deprecationInfo ? ( localize(9804, "Deprecated")) : "";
     const rating = extension?.rating ? ( localize(
-        9794,
+        9805,
         "Rated {0} out of 5 stars by {1} users",
         extension.rating.toFixed(2),
         extension.ratingCount
@@ -117,7 +117,7 @@ let ExtensionsList = class ExtensionsList extends Disposable {
                         return getAriaLabelForExtension(extension);
                     },
                     getWidgetAriaLabel() {
-                        return localize(9795, "Extensions");
+                        return localize(9806, "Extensions");
                     }
                 },
                 overrideStyles: getLocationBasedViewColors(viewDescriptorService.getViewLocationById(viewId)).listOverrideStyles,
@@ -341,8 +341,8 @@ class UnknownExtensionRenderer {
     }
     renderTemplate(container) {
         const messageContainer = append(container, $("div.unknown-extension"));
-        append(messageContainer, $("span.error-marker")).textContent = ( localize(9796, "Error"));
-        append(messageContainer, $("span.message")).textContent = ( localize(9797, "Unknown Extension:"));
+        append(messageContainer, $("span.error-marker")).textContent = ( localize(9807, "Error"));
+        append(messageContainer, $("span.message")).textContent = ( localize(9808, "Unknown Extension:"));
         const identifier = append(messageContainer, $("span.message"));
         return {
             identifier
@@ -408,7 +408,7 @@ let ExtensionsTree = class ExtensionsTree extends WorkbenchAsyncDataTree {
                     return getAriaLabelForExtension(extensionData.extension);
                 },
                 getWidgetAriaLabel() {
-                    return localize(9795, "Extensions");
+                    return localize(9806, "Extensions");
                 }
             }
         }, instantiationService, contextKeyService, listService, configurationService);