@codingame/monaco-vscode-api 32.0.0 → 32.0.2

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

@@ -0,0 +1,179 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { EXTENSION_IDENTIFIER_PATTERN } from '../../../../platform/extensionManagement/common/extensionManagement.js';
+import { equals, distinct } from '../../../../base/common/arrays.js';
+import { ExtensionRecommendations } from './extensionRecommendations.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.service.js';
+import { ExtensionRecommendationReason } from '../../../services/extensionRecommendations/common/extensionRecommendations.js';
+import { localize } from '../../../../nls.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { IWorkspaceExtensionsConfigService } from '../../../services/extensionRecommendations/common/workspaceExtensionsConfig.service.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.service.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.service.js';
+import { FileChangeType } from '../../../../platform/files/common/files.js';
+import { IFileService } from '../../../../platform/files/common/files.service.js';
+import { RunOnceScheduler } from '../../../../base/common/async.js';
+import { IWorkbenchExtensionManagementService } from '../../../services/extensionManagement/common/extensionManagement.service.js';
+
+const WORKSPACE_EXTENSIONS_FOLDER = ".vscode/extensions";
+let WorkspaceRecommendations = class WorkspaceRecommendations extends ExtensionRecommendations {
+    get recommendations() {
+        return this._recommendations;
+    }
+    get ignoredRecommendations() {
+        return this._ignoredRecommendations;
+    }
+    constructor(
+        workspaceExtensionsConfigService,
+        contextService,
+        uriIdentityService,
+        fileService,
+        workbenchExtensionManagementService,
+        notificationService
+    ) {
+        super();
+        this.workspaceExtensionsConfigService = workspaceExtensionsConfigService;
+        this.contextService = contextService;
+        this.uriIdentityService = uriIdentityService;
+        this.fileService = fileService;
+        this.workbenchExtensionManagementService = workbenchExtensionManagementService;
+        this.notificationService = notificationService;
+        this._recommendations = [];
+        this._onDidChangeRecommendations = this._register(( new Emitter()));
+        this.onDidChangeRecommendations = this._onDidChangeRecommendations.event;
+        this._ignoredRecommendations = [];
+        this.workspaceExtensions = [];
+        this.onDidChangeWorkspaceExtensionsScheduler = this._register(( new RunOnceScheduler(() => this.onDidChangeWorkspaceExtensionsFolders(), 1000)));
+    }
+    async doActivate() {
+        this.workspaceExtensions = await this.fetchWorkspaceExtensions();
+        await this.fetch();
+        this._register(
+            this.workspaceExtensionsConfigService.onDidChangeExtensionsConfigs(() => this.onDidChangeExtensionsConfigs())
+        );
+        for (const folder of this.contextService.getWorkspace().folders) {
+            this._register(this.fileService.watch(
+                this.uriIdentityService.extUri.joinPath(folder.uri, WORKSPACE_EXTENSIONS_FOLDER)
+            ));
+        }
+        this._register(
+            this.contextService.onDidChangeWorkspaceFolders(() => this.onDidChangeWorkspaceExtensionsScheduler.schedule())
+        );
+        this._register(this.fileService.onDidFilesChange(e => {
+            if (( this.contextService.getWorkspace().folders.some(folder => e.affects(
+                this.uriIdentityService.extUri.joinPath(folder.uri, WORKSPACE_EXTENSIONS_FOLDER),
+                FileChangeType.ADDED,
+                FileChangeType.DELETED
+            )))) {
+                this.onDidChangeWorkspaceExtensionsScheduler.schedule();
+            }
+        }));
+    }
+    async onDidChangeWorkspaceExtensionsFolders() {
+        const existing = this.workspaceExtensions;
+        this.workspaceExtensions = await this.fetchWorkspaceExtensions();
+        if (!equals(
+            existing,
+            this.workspaceExtensions,
+            (a, b) => this.uriIdentityService.extUri.isEqual(a, b)
+        )) {
+            this.onDidChangeExtensionsConfigs();
+        }
+    }
+    async fetchWorkspaceExtensions() {
+        const workspaceExtensions = [];
+        for (const workspaceFolder of this.contextService.getWorkspace().folders) {
+            const extensionsLocaiton = this.uriIdentityService.extUri.joinPath(workspaceFolder.uri, WORKSPACE_EXTENSIONS_FOLDER);
+            try {
+                const stat = await this.fileService.resolve(extensionsLocaiton);
+                for (const extension of stat.children ?? []) {
+                    if (!extension.isDirectory) {
+                        continue;
+                    }
+                    workspaceExtensions.push(extension.resource);
+                }
+            } catch (error) {}
+        }
+        if (workspaceExtensions.length) {
+            const resourceExtensions = await this.workbenchExtensionManagementService.getExtensions(workspaceExtensions);
+            return ( resourceExtensions.map(extension => extension.location));
+        }
+        return [];
+    }
+    async fetch() {
+        const extensionsConfigs = await this.workspaceExtensionsConfigService.getExtensionsConfigs();
+        const {
+            invalidRecommendations,
+            message
+        } = await this.validateExtensions(extensionsConfigs);
+        if (invalidRecommendations.length) {
+            this.notificationService.warn(
+                `The ${invalidRecommendations.length} extension(s) below, in workspace recommendations have issues:\n${message}`
+            );
+        }
+        this._recommendations = [];
+        this._ignoredRecommendations = [];
+        for (const extensionsConfig of extensionsConfigs) {
+            if (extensionsConfig.unwantedRecommendations) {
+                for (const unwantedRecommendation of extensionsConfig.unwantedRecommendations) {
+                    if (invalidRecommendations.indexOf(unwantedRecommendation) === -1) {
+                        this._ignoredRecommendations.push(unwantedRecommendation);
+                    }
+                }
+            }
+            if (extensionsConfig.recommendations) {
+                for (const extensionId of extensionsConfig.recommendations) {
+                    if (invalidRecommendations.indexOf(extensionId) === -1) {
+                        this._recommendations.push({
+                            extension: extensionId,
+                            reason: {
+                                reasonId: ExtensionRecommendationReason.Workspace,
+                                reasonText: ( localize(9972, "This extension is recommended by users of the current workspace."))
+                            }
+                        });
+                    }
+                }
+            }
+        }
+        for (const extension of this.workspaceExtensions) {
+            this._recommendations.push({
+                extension,
+                reason: {
+                    reasonId: ExtensionRecommendationReason.Workspace,
+                    reasonText: ( localize(9972, "This extension is recommended by users of the current workspace."))
+                }
+            });
+        }
+    }
+    async validateExtensions(contents) {
+        const validExtensions = [];
+        const invalidExtensions = [];
+        let message = "";
+        const allRecommendations = distinct(contents.flatMap((
+            {
+                recommendations
+            }
+        ) => recommendations || []));
+        const regEx = ( new RegExp(EXTENSION_IDENTIFIER_PATTERN));
+        for (const extensionId of allRecommendations) {
+            if (regEx.test(extensionId)) {
+                validExtensions.push(extensionId);
+            } else {
+                invalidExtensions.push(extensionId);
+                message += `${extensionId} (bad format) Expected: <provider>.<name>\n`;
+            }
+        }
+        return {
+            validRecommendations: validExtensions,
+            invalidRecommendations: invalidExtensions,
+            message
+        };
+    }
+    async onDidChangeExtensionsConfigs() {
+        await this.fetch();
+        this._onDidChangeRecommendations.fire();
+    }
+};
+WorkspaceRecommendations = ( __decorate([( __param(0, IWorkspaceExtensionsConfigService)), ( __param(1, IWorkspaceContextService)), ( __param(2, IUriIdentityService)), ( __param(3, IFileService)), ( __param(4, IWorkbenchExtensionManagementService)), ( __param(5, INotificationService))], WorkspaceRecommendations));
+
+export { WorkspaceRecommendations };

package/vscode/src/vs/workbench/contrib/extensions/common/extensionQuery.d.ts

@@ -0,0 +1,11 @@
+import { IExtensionGalleryManifest } from "../../../../platform/extensionManagement/common/extensionGalleryManifest.js";
+export declare class Query {
+    value: string;
+    sortBy: string;
+    constructor(value: string, sortBy: string);
+    static suggestions(query: string, galleryManifest: IExtensionGalleryManifest | null): string[];
+    static parse(value: string): Query;
+    toString(): string;
+    isValid(): boolean;
+    equals(other: Query): boolean;
+}

package/vscode/src/vs/workbench/contrib/extensions/common/extensionQuery.js

@@ -0,0 +1,90 @@
+
+import { FilterType, SortBy } from '../../../../platform/extensionManagement/common/extensionManagement.js';
+import { EXTENSION_CATEGORIES } from '../../../../platform/extensions/common/extensions.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { Extensions } from '../../../services/extensionManagement/common/extensionFeatures.js';
+
+class Query {
+    constructor(value, sortBy) {
+        this.value = value;
+        this.sortBy = sortBy;
+        this.value = value.trim();
+    }
+    static suggestions(query, galleryManifest) {
+        const commands = ["installed", "updates", "enabled", "disabled", "builtin", "contribute"];
+        if (galleryManifest?.capabilities.extensionQuery?.filtering?.some(c => c.name === FilterType.Featured)) {
+            commands.push("featured");
+        }
+        commands.push(...[
+            "mcp",
+            "agentPlugins",
+            "popular",
+            "recommended",
+            "recentlyPublished",
+            "workspaceUnsupported",
+            "deprecated",
+            "sort"
+        ]);
+        const isCategoriesEnabled = galleryManifest?.capabilities.extensionQuery?.filtering?.some(c => c.name === FilterType.Category);
+        if (isCategoriesEnabled) {
+            commands.push("category");
+        }
+        commands.push(...["tag", "ext", "id", "outdated", "recentlyUpdated", "restartRequired"]);
+        const sortCommands = [];
+        if (galleryManifest?.capabilities.extensionQuery?.sorting?.some(c => c.name === SortBy.InstallCount)) {
+            sortCommands.push("installs");
+        }
+        if (galleryManifest?.capabilities.extensionQuery?.sorting?.some(c => c.name === SortBy.WeightedRating)) {
+            sortCommands.push("rating");
+        }
+        sortCommands.push("name", "publishedDate", "updateDate");
+        const contributeCommands = [];
+        for (const feature of ( Registry.as(Extensions.ExtensionFeaturesRegistry)).getExtensionFeatures()) {
+            contributeCommands.push(feature.id);
+        }
+        const subcommands = {
+            "sort": sortCommands,
+            "category": isCategoriesEnabled ? ( EXTENSION_CATEGORIES.map(c => `"${c.toLowerCase()}"`)) : [],
+            "tag": [""],
+            "ext": [""],
+            "id": [""],
+            "contribute": contributeCommands
+        };
+        const queryContains = substr => query.indexOf(substr) > -1;
+        const hasSort = ( subcommands.sort.some(subcommand => queryContains(`@sort:${subcommand}`)));
+        const hasCategory = ( subcommands.category.some(subcommand => queryContains(`@category:${subcommand}`)));
+        return commands.flatMap(command => {
+            if (hasSort && command === "sort" || hasCategory && command === "category") {
+                return [];
+            }
+            if (command in subcommands) {
+                return ( subcommands[command].map(subcommand => `@${command}:${subcommand}${subcommand === "" ? "" : " "}`));
+            } else {
+                return queryContains(`@${command}`) ? [] : [`@${command} `];
+            }
+        });
+    }
+    static parse(value) {
+        let sortBy = "";
+        value = value.replace(/@sort:(\w+)(-\w*)?/g, (match, by, order) => {
+            sortBy = by;
+            return "";
+        });
+        return ( new Query(value, sortBy));
+    }
+    toString() {
+        let result = this.value;
+        if (this.sortBy) {
+            result = `${result}${result ? " " : ""}@sort:${this.sortBy}`;
+        }
+        return result;
+    }
+    isValid() {
+        return !/@outdated/.test(this.value);
+    }
+    equals(other) {
+        return this.value === other.value && this.sortBy === other.sortBy;
+    }
+}
+
+export { Query };

package/vscode/src/vs/workbench/contrib/extensions/common/extensions.js

@@ -9,7 +9,7 @@ import { ExtensionGalleryManifestStatus } from '../../../../platform/extensionMa
 import { IExtensionsWorkbenchService } from './extensions.service.js';
 
 const VIEWLET_ID = "workbench.view.extensions";
-const EXTENSIONS_CATEGORY = ( localize2(9962, "Extensions"));
+const EXTENSIONS_CATEGORY = ( localize2(9973, "Extensions"));
 var ExtensionState;
 (function(ExtensionState) {
     ExtensionState[ExtensionState["Installing"] = 0] = "Installing";

package/vscode/src/vs/workbench/contrib/extensions/common/extensions.service.d.ts

@@ -8,7 +8,7 @@ import { ProgressLocation } from "../../../../platform/progress/common/progress.
 import { IExtensionManagementServer, EnablementState } from "../../../services/extensionManagement/common/extensionManagement.js";
 import { IExtensionsStatus as IExtensionRuntimeStatus } from "../../../services/extensions/common/extensions.js";
 import { IExtension, InstallExtensionOptions, AutoUpdateConfigurationValue, IExtensionsNotification } from "./extensions.js";
-import { IExtensionEditorOptions } from "@codingame/monaco-vscode-extension-gallery-service-override/vscode/vs/workbench/contrib/extensions/common/extensionsInput";
+import { IExtensionEditorOptions } from "./extensionsInput.js";
 export declare const IExtensionsWorkbenchService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IExtensionsWorkbenchService>;
 export interface IExtensionsWorkbenchService {
     readonly _serviceBrand: undefined;

package/vscode/src/vs/workbench/contrib/extensions/common/extensionsFileTemplate.js

@@ -8,31 +8,31 @@ const ExtensionsConfigurationSchema = {
     allowComments: true,
     allowTrailingCommas: true,
     type: "object",
-    title: ( localize(9963, "Extensions")),
+    title: ( localize(9974, "Extensions")),
     additionalProperties: false,
     properties: {
         recommendations: {
             type: "array",
             description: ( localize(
-                9964,
+                9975,
                 "List of extensions which should be recommended for users of this workspace. The identifier of an extension is always '${publisher}.${name}'. For example: 'vscode.csharp'."
             )),
             items: {
                 type: "string",
                 pattern: EXTENSION_IDENTIFIER_PATTERN,
-                errorMessage: ( localize(9965, "Expected format '${publisher}.${name}'. Example: 'vscode.csharp'."))
+                errorMessage: ( localize(9976, "Expected format '${publisher}.${name}'. Example: 'vscode.csharp'."))
             }
         },
         unwantedRecommendations: {
             type: "array",
             description: ( localize(
-                9966,
+                9977,
                 "List of extensions recommended by VS Code that should not be recommended for users of this workspace. The identifier of an extension is always '${publisher}.${name}'. For example: 'vscode.csharp'."
             )),
             items: {
                 type: "string",
                 pattern: EXTENSION_IDENTIFIER_PATTERN,
-                errorMessage: ( localize(9965, "Expected format '${publisher}.${name}'. Example: 'vscode.csharp'."))
+                errorMessage: ( localize(9976, "Expected format '${publisher}.${name}'. Example: 'vscode.csharp'."))
             }
         }
     }

package/vscode/src/vs/workbench/contrib/extensions/common/extensionsInput.d.ts

@@ -0,0 +1,24 @@
+import { URI } from "../../../../base/common/uri.js";
+import { EditorInputCapabilities, IUntypedEditorInput } from "../../../common/editor.js";
+import { EditorInput } from "../../../common/editor/editorInput.js";
+import { ExtensionEditorTab, IExtension } from "./extensions.js";
+import { IEditorOptions } from "../../../../platform/editor/common/editor.js";
+import { ThemeIcon } from "../../../../base/common/themables.js";
+export interface IExtensionEditorOptions extends IEditorOptions {
+    showPreReleaseVersion?: boolean;
+    tab?: ExtensionEditorTab;
+    feature?: string;
+    sideByside?: boolean;
+}
+export declare class ExtensionsInput extends EditorInput {
+    private _extension;
+    static readonly ID = "workbench.extensions.input2";
+    get typeId(): string;
+    get capabilities(): EditorInputCapabilities;
+    get resource(): URI;
+    constructor(_extension: IExtension);
+    get extension(): IExtension;
+    getName(): string;
+    getIcon(): ThemeIcon | undefined;
+    matches(other: EditorInput | IUntypedEditorInput): boolean;
+}

package/vscode/src/vs/workbench/contrib/extensions/common/extensionsInput.js

@@ -0,0 +1,50 @@
+
+import { Schemas } from '../../../../base/common/network.js';
+import { URI } from '../../../../base/common/uri.js';
+import { localize } from '../../../../nls.js';
+import { EditorInputCapabilities } from '../../../common/editor.js';
+import { EditorInput } from '../../../common/editor/editorInput.js';
+import { areSameExtensions } from '../../../../platform/extensionManagement/common/extensionManagementUtil.js';
+import { join } from '../../../../base/common/path.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
+
+const ExtensionEditorIcon = registerIcon("extensions-editor-label-icon", Codicon.extensions, ( localize(9978, "Icon of the extensions editor label.")));
+class ExtensionsInput extends EditorInput {
+    static {
+        this.ID = "workbench.extensions.input2";
+    }
+    get typeId() {
+        return ExtensionsInput.ID;
+    }
+    get capabilities() {
+        return EditorInputCapabilities.Readonly | EditorInputCapabilities.Singleton;
+    }
+    get resource() {
+        return ( URI.from({
+            scheme: Schemas.extension,
+            path: join(this._extension.identifier.id, "extension")
+        }));
+    }
+    constructor(_extension) {
+        super();
+        this._extension = _extension;
+    }
+    get extension() {
+        return this._extension;
+    }
+    getName() {
+        return localize(9979, "Extension: {0}", this._extension.displayName);
+    }
+    getIcon() {
+        return ExtensionEditorIcon;
+    }
+    matches(other) {
+        if (super.matches(other)) {
+            return true;
+        }
+        return other instanceof ExtensionsInput && areSameExtensions(this._extension.identifier, other._extension.identifier);
+    }
+}
+
+export { ExtensionsInput };

package/vscode/src/vs/workbench/contrib/extensions/common/extensionsUtils.js

@@ -56,14 +56,14 @@ let KeymapExtensions = class KeymapExtensions extends Disposable {
             }
         };
         this.notificationService.prompt(Severity$1.Info, ( localize(
-            9969,
+            9980,
             "Disable other keymaps ({0}) to avoid conflicts between keybindings?",
             ( oldKeymaps.map(k => `'${k.local.manifest.displayName}'`)).join(", ")
         )), [{
-            label: ( localize(9970, "Yes")),
+            label: ( localize(9981, "Yes")),
             run: () => onPrompt(true)
         }, {
-            label: ( localize(9971, "No")),
+            label: ( localize(9982, "No")),
             run: () => onPrompt(false)
         }]);
     }

package/vscode/src/vs/workbench/contrib/extensions/common/runtimeExtensionsInput.d.ts

@@ -0,0 +1,15 @@
+import { URI } from "../../../../base/common/uri.js";
+import { EditorInputCapabilities, IUntypedEditorInput } from "../../../common/editor.js";
+import { EditorInput } from "../../../common/editor/editorInput.js";
+import { ThemeIcon } from "../../../../base/common/themables.js";
+export declare class RuntimeExtensionsInput extends EditorInput {
+    static readonly ID = "workbench.runtimeExtensions.input";
+    get typeId(): string;
+    get capabilities(): EditorInputCapabilities;
+    static _instance: RuntimeExtensionsInput;
+    static get instance(): RuntimeExtensionsInput;
+    readonly resource: URI;
+    getName(): string;
+    getIcon(): ThemeIcon;
+    matches(other: EditorInput | IUntypedEditorInput): boolean;
+}

package/vscode/src/vs/workbench/contrib/extensions/common/runtimeExtensionsInput.js

@@ -0,0 +1,47 @@
+
+import { localize } from '../../../../nls.js';
+import { URI } from '../../../../base/common/uri.js';
+import { EditorInputCapabilities } from '../../../common/editor.js';
+import { EditorInput } from '../../../common/editor/editorInput.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
+
+const RuntimeExtensionsEditorIcon = registerIcon("runtime-extensions-editor-label-icon", Codicon.extensions, ( localize(9984, "Icon of the runtime extensions editor label.")));
+class RuntimeExtensionsInput extends EditorInput {
+    constructor() {
+        super(...arguments);
+        this.resource = ( URI.from({
+            scheme: "runtime-extensions",
+            path: "default"
+        }));
+    }
+    static {
+        this.ID = "workbench.runtimeExtensions.input";
+    }
+    get typeId() {
+        return RuntimeExtensionsInput.ID;
+    }
+    get capabilities() {
+        return EditorInputCapabilities.Readonly | EditorInputCapabilities.Singleton;
+    }
+    static get instance() {
+        if (!RuntimeExtensionsInput._instance || RuntimeExtensionsInput._instance.isDisposed()) {
+            RuntimeExtensionsInput._instance = ( new RuntimeExtensionsInput());
+        }
+        return RuntimeExtensionsInput._instance;
+    }
+    getName() {
+        return localize(9985, "Running Extensions");
+    }
+    getIcon() {
+        return RuntimeExtensionsEditorIcon;
+    }
+    matches(other) {
+        if (super.matches(other)) {
+            return true;
+        }
+        return other instanceof RuntimeExtensionsInput;
+    }
+}
+
+export { RuntimeExtensionsInput };

package/vscode/src/vs/workbench/contrib/extensions/common/searchExtensionsTool.js

@@ -15,9 +15,9 @@ const SearchExtensionsToolData = {
     toolReferenceName: "extensions",
     legacyToolReferenceFullNames: ["extensions"],
     icon: ThemeIcon.fromId(Codicon.extensions.id),
-    displayName: ( localize(9975, "Search Extensions")),
+    displayName: ( localize(9986, "Search Extensions")),
     modelDescription: "This is a tool for browsing Visual Studio Code Extensions Marketplace. It allows the model to search for extensions and retrieve detailed information about them. The model should use this tool whenever it needs to discover extensions or resolve information about known ones. To use the tool, the model has to provide the category of the extensions, relevant search keywords, or known extension IDs. Note that search results may include false positives, so reviewing and filtering is recommended.",
-    userDescription: ( localize(9976, "Search for VS Code extensions")),
+    userDescription: ( localize(9987, "Search for VS Code extensions")),
     source: ToolDataSource.Internal,
     inputSchema: {
         type: "object",
@@ -54,7 +54,7 @@ let SearchExtensionsTool = class SearchExtensionsTool {
             return {
                 content: [{
                     kind: "text",
-                    value: ( localize(9977, "Please provide a category or keywords or ids to search for."))
+                    value: ( localize(9988, "Please provide a category or keywords or ids to search for."))
                 }]
             };
         }

package/vscode/src/vs/workbench/contrib/externalUriOpener/common/configuration.js

@@ -26,7 +26,7 @@ const externalUriOpenersConfigurationNode = {
     properties: {
         [externalUriOpenersSettingId]: {
             type: "object",
-            markdownDescription: ( localize(9981, "Configure the opener to use for external URIs (http, https).")),
+            markdownDescription: ( localize(9992, "Configure the opener to use for external URIs (http, https).")),
             defaultSnippets: [{
                 body: {
                     "example.com": "$1"
@@ -36,19 +36,19 @@ const externalUriOpenersConfigurationNode = {
                 anyOf: [{
                     type: "string",
                     markdownDescription: ( localize(
-                        9982,
+                        9993,
                         "Map URI pattern to an opener id.\nExample patterns: \n{0}",
                         exampleUriPatterns
                     ))
                 }, {
                     type: "string",
                     markdownDescription: ( localize(
-                        9982,
+                        9993,
                         "Map URI pattern to an opener id.\nExample patterns: \n{0}",
                         exampleUriPatterns
                     )),
                     enum: [defaultExternalUriOpenerId],
-                    enumDescriptions: [( localize(9983, "Open using VS Code's standard opener."))]
+                    enumDescriptions: [( localize(9994, "Open using VS Code's standard opener."))]
                 }, externalUriOpenerIdSchemaAddition]
             }
         }

package/vscode/src/vs/workbench/contrib/externalUriOpener/common/externalUriOpenerService.js

@@ -136,16 +136,16 @@ let ExternalUriOpenerService = class ExternalUriOpenerService extends Disposable
             };
         }));
         items.push({
-            label: isWeb ? ( localize(9984, "Open in new browser window")) : ( localize(9985, "Open in default browser")),
+            label: isWeb ? ( localize(9995, "Open in new browser window")) : ( localize(9996, "Open in default browser")),
             opener: undefined
         }, {
             type: "separator"
         }, {
-            label: ( localize(9986, "Configure default opener...")),
+            label: ( localize(9997, "Configure default opener...")),
             opener: "configureDefault"
         });
         const picked = await this.quickInputService.pick(items, {
-            placeHolder: ( localize(9987, "How would you like to open: {0}", (targetUri.toString())))
+            placeHolder: ( localize(9998, "How would you like to open: {0}", (targetUri.toString())))
         });
         if (!picked) {
             return true;

package/vscode/src/vs/workbench/contrib/files/browser/editors/binaryFileEditor.js

@@ -70,7 +70,7 @@ let BinaryFileEditor = class BinaryFileEditor extends BaseBinaryResourceEditor {
         }
     }
     getTitle() {
-        return this.input ? this.input.getName() : ( localize(9988, "Binary File Viewer"));
+        return this.input ? this.input.getName() : ( localize(9999, "Binary File Viewer"));
     }
 };
 BinaryFileEditor = BinaryFileEditor_1 = ( __decorate([( __param(1, ITelemetryService)), ( __param(2, IThemeService)), ( __param(3, IEditorResolverService)), ( __param(4, IStorageService))], BinaryFileEditor));

package/vscode/src/vs/workbench/contrib/files/browser/editors/textFileEditor.js

@@ -102,7 +102,7 @@ let TextFileEditor = class TextFileEditor extends AbstractTextCodeEditor {
         if (this.input) {
             return this.input.getName();
         }
-        return localize(9989, "Text File Editor");
+        return localize(10000, "Text File Editor");
     }
     get input() {
         return this._input;
@@ -150,7 +150,7 @@ let TextFileEditor = class TextFileEditor extends AbstractTextCodeEditor {
             const actions = [];
             actions.push(toAction({
                 id: "workbench.files.action.openFolder",
-                label: ( localize(9990, "Open Folder")),
+                label: ( localize(10001, "Open Folder")),
                 run: async () => {
                     return this.hostService.openWindow([{
                         folderUri: input.resource
@@ -162,7 +162,7 @@ let TextFileEditor = class TextFileEditor extends AbstractTextCodeEditor {
             if (this.contextService.isInsideWorkspace(input.preferredResource)) {
                 actions.push(toAction({
                     id: "workbench.files.action.reveal",
-                    label: ( localize(9991, "Reveal Folder")),
+                    label: ( localize(10002, "Reveal Folder")),
                     run: async () => {
                         await this.paneCompositeService.openPaneComposite(VIEWLET_ID, ViewContainerLocation.Sidebar, true);
                         return this.explorerService.select(input.preferredResource, true);
@@ -170,7 +170,7 @@ let TextFileEditor = class TextFileEditor extends AbstractTextCodeEditor {
                 }));
             }
             throw createEditorOpenError(( localize(
-                9992,
+                10003,
                 "The file is not displayed in the text editor because it is a directory."
             )), actions, {
                 forceMessage: true
@@ -180,22 +180,22 @@ let TextFileEditor = class TextFileEditor extends AbstractTextCodeEditor {
             let message;
             if (error instanceof TooLargeFileOperationError) {
                 message = ( localize(
-                    9993,
+                    10004,
                     "The file is not displayed in the text editor because it is very large ({0}).",
                     ByteSize.formatSize(error.size)
                 ));
             } else {
                 message = ( localize(
-                    9994,
+                    10005,
                     "The file is not displayed in the text editor because it is very large."
                 ));
             }
             throw createTooLargeFileError(this.group, input, options, message, this.preferencesService);
         }
         if (error.fileOperationResult === FileOperationResult.FILE_NOT_FOUND && !this.filesConfigurationService.isReadonly(input.preferredResource) && (await this.pathService.hasValidBasename(input.preferredResource))) {
-            const fileNotFoundError = createEditorOpenError(( new FileOperationError(( localize(9995, "The editor could not be opened because the file was not found.")), FileOperationResult.FILE_NOT_FOUND)), [toAction({
+            const fileNotFoundError = createEditorOpenError(( new FileOperationError(( localize(10006, "The editor could not be opened because the file was not found.")), FileOperationResult.FILE_NOT_FOUND)), [toAction({
                 id: "workbench.files.action.createMissingFile",
-                label: ( localize(9996, "Create File")),
+                label: ( localize(10007, "Create File")),
                 run: async () => {
                     await this.textFileService.create([{
                         resource: input.preferredResource