@codingame/monaco-vscode-extensions-service-override 28.4.0 → 29.0.0

package/vscode/src/vs/workbench/api/browser/mainThreadWorkspace.js

@@ -1,7 +1,7 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { isCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
-import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { isNative } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
@@ -28,7 +28,7 @@ import { ICanonicalUriService } from '@codingame/monaco-vscode-api/vscode/vs/pla
 import { revive } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshalling';
 import { ITextFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service';
 
-let MainThreadWorkspace = class MainThreadWorkspace {
+let MainThreadWorkspace = class MainThreadWorkspace extends Disposable {
     constructor(
         extHostContext,
         _searchService,
@@ -47,6 +47,7 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         _workspaceTrustRequestService,
         _textFileService
     ) {
+        super();
         this._searchService = _searchService;
         this._contextService = _contextService;
         this._editSessionIdentityService = _editSessionIdentityService;
@@ -61,10 +62,9 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         this._workspaceTrustManagementService = _workspaceTrustManagementService;
         this._workspaceTrustRequestService = _workspaceTrustRequestService;
         this._textFileService = _textFileService;
-        this._toDispose = ( new DisposableStore());
         this._activeCancelTokens = Object.create(null);
-        this.registeredEditSessionProviders = ( new Map());
-        this.registeredCanonicalUriProviders = ( new Map());
+        this.registeredEditSessionProviders = this._register(( new DisposableMap()));
+        this.registeredCanonicalUriProviders = this._register(( new DisposableMap()));
         this._queryBuilder = this._instantiationService.createInstance(QueryBuilder);
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostWorkspace));
         const workspace = this._contextService.getWorkspace();
@@ -75,13 +75,21 @@ let MainThreadWorkspace = class MainThreadWorkspace {
                 workspace => this._proxy.$initializeWorkspace(this.getWorkspaceData(workspace), this.isWorkspaceTrusted())
             );
         }
-        this._contextService.onDidChangeWorkspaceFolders(this._onDidChangeWorkspace, this, this._toDispose);
-        this._contextService.onDidChangeWorkbenchState(this._onDidChangeWorkspace, this, this._toDispose);
-        this._workspaceTrustManagementService.onDidChangeTrust(this._onDidGrantWorkspaceTrust, this, this._toDispose);
-        this._workspaceTrustManagementService.onDidChangeTrustedFolders(this._onDidChangeWorkspaceTrustedFolders, this, this._toDispose);
+        this._register(
+            this._contextService.onDidChangeWorkspaceFolders(this._onDidChangeWorkspace, this)
+        );
+        this._register(
+            this._contextService.onDidChangeWorkbenchState(this._onDidChangeWorkspace, this)
+        );
+        this._register(
+            this._workspaceTrustManagementService.onDidChangeTrust(this._onDidGrantWorkspaceTrust, this)
+        );
+        this._register(
+            this._workspaceTrustManagementService.onDidChangeTrustedFolders(this._onDidChangeWorkspaceTrustedFolders, this)
+        );
     }
     dispose() {
-        this._toDispose.dispose();
+        super.dispose();
         for (const requestId in this._activeCancelTokens) {
             const tokenSource = this._activeCancelTokens[requestId];
             tokenSource.cancel();
@@ -106,10 +114,10 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         const wantsToDelete = removeCount > 0;
         if (wantsToAdd && !wantsToDelete) {
             if (addCount === 1) {
-                message = ( localize(2607, "Extension '{0}' added 1 folder to the workspace", extensionName));
+                message = ( localize(2615, "Extension '{0}' added 1 folder to the workspace", extensionName));
             } else {
                 message = ( localize(
-                    2608,
+                    2616,
                     "Extension '{0}' added {1} folders to the workspace",
                     extensionName,
                     addCount
@@ -118,10 +126,10 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         }
         else if (wantsToDelete && !wantsToAdd) {
             if (removeCount === 1) {
-                message = ( localize(2609, "Extension '{0}' removed 1 folder from the workspace", extensionName));
+                message = ( localize(2617, "Extension '{0}' removed 1 folder from the workspace", extensionName));
             } else {
                 message = ( localize(
-                    2610,
+                    2618,
                     "Extension '{0}' removed {1} folders from the workspace",
                     extensionName,
                     removeCount
@@ -129,7 +137,7 @@ let MainThreadWorkspace = class MainThreadWorkspace {
             }
         }
         else {
-            message = ( localize(2611, "Extension '{0}' changed folders of the workspace", extensionName));
+            message = ( localize(2619, "Extension '{0}' changed folders of the workspace", extensionName));
         }
         return message;
     }
@@ -260,12 +268,9 @@ let MainThreadWorkspace = class MainThreadWorkspace {
             }
         });
         this.registeredEditSessionProviders.set(handle, disposable);
-        this._toDispose.add(disposable);
     }
     $unregisterEditSessionIdentityProvider(handle) {
-        const disposable = this.registeredEditSessionProviders.get(handle);
-        disposable?.dispose();
-        this.registeredEditSessionProviders.delete(handle);
+        this.registeredEditSessionProviders.deleteAndDispose(handle);
     }
     $registerCanonicalUriProvider(handle, scheme) {
         const disposable = this._canonicalUriService.registerCanonicalUriProvider({
@@ -279,12 +284,9 @@ let MainThreadWorkspace = class MainThreadWorkspace {
             }
         });
         this.registeredCanonicalUriProviders.set(handle, disposable);
-        this._toDispose.add(disposable);
     }
     $unregisterCanonicalUriProvider(handle) {
-        const disposable = this.registeredCanonicalUriProviders.get(handle);
-        disposable?.dispose();
-        this.registeredCanonicalUriProviders.delete(handle);
+        this.registeredCanonicalUriProviders.deleteAndDispose(handle);
     }
     $resolveDecoding(resource, options) {
         return this._textFileService.resolveDecoding(URI.revive(resource), options);

package/vscode/src/vs/workbench/api/common/shared/tasks.d.ts

@@ -18,6 +18,7 @@ export interface ITaskPresentationOptionsDTO {
 }
 export interface IRunOptionsDTO {
     reevaluateOnRerun?: boolean;
+    runOn?: number;
 }
 export interface IExecutionOptionsDTO {
     cwd?: string;

package/vscode/src/vs/workbench/contrib/browserView/common/browserEditorInput.d.ts

@@ -0,0 +1,60 @@
+import { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IBrowserEditorViewState, IBrowserViewModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/browserView/common/browserView";
+import { IBrowserViewWorkbenchService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/browserView/common/browserView.service";
+import { EditorInputCapabilities, IEditorSerializer, IUntypedEditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor";
+import { EditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorInput";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILifecycleService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+/**
+ * JSON-serializable type used during browser state serialization/deserialization
+ */
+export interface IBrowserEditorInputData extends IBrowserEditorViewState {
+    readonly id: string;
+}
+export declare class BrowserEditorInput extends EditorInput {
+    private readonly themeService;
+    private readonly browserViewWorkbenchService;
+    private readonly lifecycleService;
+    private readonly instantiationService;
+    private readonly telemetryService;
+    static readonly ID = "workbench.editorinputs.browser";
+    static readonly EDITOR_ID = "workbench.editor.browser";
+    private static readonly DEFAULT_LABEL;
+    private readonly _id;
+    private readonly _initialData;
+    private _model;
+    private _modelPromise;
+    constructor(options: IBrowserEditorInputData, themeService: IThemeService, browserViewWorkbenchService: IBrowserViewWorkbenchService, lifecycleService: ILifecycleService, instantiationService: IInstantiationService, telemetryService: ITelemetryService);
+    get id(): string;
+    get url(): string | undefined;
+    get title(): string | undefined;
+    get favicon(): string | undefined;
+    resolve(): Promise<IBrowserViewModel>;
+    get typeId(): string;
+    get editorId(): string;
+    get capabilities(): EditorInputCapabilities;
+    get resource(): URI;
+    getIcon(): ThemeIcon | URI | undefined;
+    getName(): string;
+    getTitle(): string;
+    getDescription(): string | undefined;
+    canReopen(): boolean;
+    matches(otherInput: EditorInput | IUntypedEditorInput): boolean;
+    /**
+     * Creates a copy of this browser editor input with a new unique ID, creating an independent browser view with no linked state.
+     * This is used during Copy into New Window.
+     */
+    copy(): EditorInput;
+    toUntyped(): IUntypedEditorInput;
+    private _resourceBeforeDisposal;
+    dispose(): void;
+    serialize(): IBrowserEditorInputData;
+}
+export declare class BrowserEditorSerializer implements IEditorSerializer {
+    canSerialize(editorInput: EditorInput): editorInput is BrowserEditorInput;
+    serialize(editorInput: EditorInput): string | undefined;
+    deserialize(instantiationService: IInstantiationService, serializedEditor: string): EditorInput | undefined;
+}

package/vscode/src/vs/workbench/contrib/browserView/common/browserEditorInput.js

@@ -0,0 +1,222 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { truncate } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { BrowserViewUri } from '../../../../platform/browserView/common/browserViewUri.js';
+import { IBrowserViewWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/browserView/common/browserView.service';
+import { EditorInputCapabilities } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { EditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorInput';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { TAB_ACTIVE_FOREGROUND } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/theme';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { hasKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { ShutdownReason } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { logBrowserOpen } from '../../../../platform/browserView/common/browserViewTelemetry.js';
+
+var BrowserEditorInput_1;
+const LOADING_SPINNER_SVG = color => `
+    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" width="16" height="16">
+        <path d="M8 1a7 7 0 1 0 0 14 7 7 0 0 0 0-14zm0 1.5a5.5 5.5 0 1 1 0 11 5.5 5.5 0 0 1 0-11z" fill="${color}" opacity="0.3"/>
+        <path d="M8 1a7 7 0 0 1 7 7h-1.5A5.5 5.5 0 0 0 8 2.5V1z" fill="${color}">
+            <animateTransform attributeName="transform" type="rotate" dur="1s" repeatCount="indefinite" values="0 8 8;360 8 8"/>
+        </path>
+    </svg>
+`;
+const MAX_TITLE_LENGTH = 30;
+let BrowserEditorInput = class BrowserEditorInput extends EditorInput {
+    static {
+        BrowserEditorInput_1 = this;
+    }
+    static {
+        this.ID = "workbench.editorinputs.browser";
+    }
+    static {
+        this.EDITOR_ID = "workbench.editor.browser";
+    }
+    static {
+        this.DEFAULT_LABEL = ( localize(4618, "Browser"));
+    }
+    constructor(
+        options,
+        themeService,
+        browserViewWorkbenchService,
+        lifecycleService,
+        instantiationService,
+        telemetryService
+    ) {
+        super();
+        this.themeService = themeService;
+        this.browserViewWorkbenchService = browserViewWorkbenchService;
+        this.lifecycleService = lifecycleService;
+        this.instantiationService = instantiationService;
+        this.telemetryService = telemetryService;
+        this._id = options.id;
+        this._initialData = options;
+        this._register(this.lifecycleService.onWillShutdown(e => {
+            if (this._model) {
+                if (e.reason === ShutdownReason.RELOAD) {
+                    void this._model.setVisible(false);
+                } else {
+                    this._model.dispose();
+                    this._model = undefined;
+                }
+            }
+        }));
+    }
+    get id() {
+        return this._id;
+    }
+    get url() {
+        return this._model ? this._model.url : this._initialData.url;
+    }
+    get title() {
+        return this._model ? this._model.title : this._initialData.title;
+    }
+    get favicon() {
+        return this._model ? this._model.favicon : this._initialData.favicon;
+    }
+    async resolve() {
+        if (!this._model && !this._modelPromise) {
+            this._modelPromise = (async () => {
+                this._model = await this.browserViewWorkbenchService.getOrCreateBrowserViewModel(this._id);
+                this._modelPromise = undefined;
+                this._register(this._model.onWillDispose(() => {
+                    this._model = undefined;
+                }));
+                this._register(this._model.onDidClose(() => {
+                    this.dispose();
+                }));
+                this._register(this._model.onDidChangeTitle(() => this._onDidChangeLabel.fire()));
+                this._register(this._model.onDidChangeFavicon(() => this._onDidChangeLabel.fire()));
+                this._register(this._model.onDidChangeLoadingState(() => this._onDidChangeLabel.fire()));
+                this._register(this._model.onDidNavigate(() => this._onDidChangeLabel.fire()));
+                if (this._initialData.url && this._model.url !== this._initialData.url) {
+                    void this._model.loadURL(this._initialData.url);
+                }
+                return this._model;
+            })();
+        }
+        return this._model || this._modelPromise;
+    }
+    get typeId() {
+        return BrowserEditorInput_1.ID;
+    }
+    get editorId() {
+        return BrowserEditorInput_1.EDITOR_ID;
+    }
+    get capabilities() {
+        return EditorInputCapabilities.ForceReveal | EditorInputCapabilities.Readonly;
+    }
+    get resource() {
+        if (this._resourceBeforeDisposal) {
+            return this._resourceBeforeDisposal;
+        }
+        return BrowserViewUri.forId(this._id);
+    }
+    getIcon() {
+        if (this._model) {
+            if (this._model.loading) {
+                const color = this.themeService.getColorTheme().getColor(TAB_ACTIVE_FOREGROUND);
+                return ( URI.parse(
+                    "data:image/svg+xml;utf8," + encodeURIComponent(LOADING_SPINNER_SVG(color?.toString()))
+                ));
+            }
+            if (this._model.favicon) {
+                return ( URI.parse(this._model.favicon));
+            }
+            return Codicon.globe;
+        }
+        if (this._initialData.favicon) {
+            return ( URI.parse(this._initialData.favicon));
+        }
+        return Codicon.globe;
+    }
+    getName() {
+        return truncate(this.getTitle(), MAX_TITLE_LENGTH);
+    }
+    getTitle() {
+        if (this._model && this._model.url) {
+            if (this._model.title) {
+                return this._model.title;
+            }
+            const authority = ( URI.parse(this._model.url)).authority;
+            return authority || BrowserEditorInput_1.DEFAULT_LABEL;
+        }
+        if (this._initialData.title) {
+            return this._initialData.title;
+        }
+        const url = this._initialData.url ?? "";
+        const authority = ( URI.parse(url)).authority;
+        return authority || BrowserEditorInput_1.DEFAULT_LABEL;
+    }
+    getDescription() {
+        return this.url;
+    }
+    canReopen() {
+        return true;
+    }
+    matches(otherInput) {
+        if (super.matches(otherInput)) {
+            return true;
+        }
+        if (otherInput instanceof BrowserEditorInput_1) {
+            return this._id === otherInput._id;
+        }
+        if (hasKey(otherInput, {
+            resource: true
+        }) && otherInput.resource?.scheme === BrowserViewUri.scheme) {
+            const parsed = BrowserViewUri.parse(otherInput.resource);
+            if (parsed) {
+                return this._id === parsed.id;
+            }
+        }
+        return false;
+    }
+    copy() {
+        logBrowserOpen(this.telemetryService, "copyToNewWindow");
+        return this.instantiationService.createInstance(BrowserEditorInput_1, {
+            id: generateUuid(),
+            url: this.url,
+            title: this.title,
+            favicon: this.favicon
+        });
+    }
+    toUntyped() {
+        const viewState = {
+            url: this.url,
+            title: this.title,
+            favicon: this.favicon
+        };
+        return {
+            resource: this.resource,
+            options: {
+                override: BrowserEditorInput_1.ID,
+                viewState
+            }
+        };
+    }
+    dispose() {
+        if (this._model) {
+            this._resourceBeforeDisposal = this.resource;
+            this._model.dispose();
+            this._model = undefined;
+        }
+        super.dispose();
+    }
+    serialize() {
+        return {
+            id: this._id,
+            url: this.url,
+            title: this.title,
+            favicon: this.favicon
+        };
+    }
+};
+BrowserEditorInput = BrowserEditorInput_1 = ( __decorate([( __param(1, IThemeService)), ( __param(2, IBrowserViewWorkbenchService)), ( __param(3, ILifecycleService)), ( __param(4, IInstantiationService)), ( __param(5, ITelemetryService))], BrowserEditorInput));
+
+export { BrowserEditorInput };

package/vscode/src/vs/workbench/contrib/customEditor/common/customTextEditorModel.js

@@ -60,7 +60,7 @@ let CustomTextEditorModel = CustomTextEditorModel_1 = class CustomTextEditorMode
         }));
         this._register(extensionService.onWillStop(e => {
             e.veto(true, ( localize(
-                7723,
+                7949,
                 "An extension provided text editor for '{0}' is still open that would close otherwise.",
                 this.name
             )));

package/vscode/src/vs/workbench/contrib/git/common/gitService.d.ts

@@ -18,14 +18,32 @@ export interface GitRefQuery {
     readonly pattern?: string | string[];
     readonly sort?: "alphabetically" | "committerdate" | "creatordate";
 }
+export interface GitChange {
+    readonly uri: URI;
+    readonly originalUri: URI | undefined;
+    readonly modifiedUri: URI | undefined;
+}
+export interface GitDiffChange extends GitChange {
+    readonly insertions: number;
+    readonly deletions: number;
+}
 export interface GitRepositoryState {
     readonly HEAD?: GitBranch;
+    readonly mergeChanges: readonly GitChange[];
+    readonly indexChanges: readonly GitChange[];
+    readonly workingTreeChanges: readonly GitChange[];
+    readonly untrackedChanges: readonly GitChange[];
 }
 export interface GitBranch extends GitRef {
+    readonly base?: GitBaseRef;
     readonly upstream?: GitUpstreamRef;
     readonly ahead?: number;
     readonly behind?: number;
 }
+export interface GitBaseRef {
+    readonly name: string;
+    readonly isProtected: boolean;
+}
 export interface GitUpstreamRef {
     readonly remote: string;
     readonly name: string;
@@ -36,9 +54,13 @@ export interface IGitRepository {
     readonly state: IObservable<GitRepositoryState>;
     updateState(state: GitRepositoryState): void;
     getRefs(query: GitRefQuery, token?: CancellationToken): Promise<GitRef[]>;
+    diffBetweenWithStats(ref1: string, ref2: string, path?: string): Promise<GitDiffChange[]>;
+    diffBetweenWithStats2(ref: string, path?: string): Promise<GitDiffChange[]>;
 }
 export interface IGitExtensionDelegate {
     readonly repositories: Iterable<IGitRepository>;
     openRepository(uri: URI): Promise<IGitRepository | undefined>;
     getRefs(root: URI, query?: GitRefQuery, token?: CancellationToken): Promise<GitRef[]>;
+    diffBetweenWithStats(root: URI, ref1: string, ref2: string, path?: string): Promise<GitDiffChange[]>;
+    diffBetweenWithStats2(root: URI, ref: string, path?: string): Promise<GitDiffChange[]>;
 }

package/vscode/src/vs/workbench/services/extensionManagement/browser/extensionBisect.js

@@ -169,11 +169,11 @@ let ExtensionBisectUi = class ExtensionBisectUi {
     }
     _showBisectPrompt() {
         const goodPrompt = {
-            label: ( localize(15597, "I can't reproduce")),
+            label: ( localize(15893, "I can't reproduce")),
             run: () => this._commandService.executeCommand("extension.bisect.next", false)
         };
         const badPrompt = {
-            label: ( localize(15598, "I can reproduce")),
+            label: ( localize(15894, "I can reproduce")),
             run: () => this._commandService.executeCommand("extension.bisect.next", true)
         };
         const stop = {
@@ -181,10 +181,10 @@ let ExtensionBisectUi = class ExtensionBisectUi {
             run: () => this._commandService.executeCommand("extension.bisect.stop")
         };
         const message = this._extensionBisectService.disabledCount === 1 ? ( localize(
-            15599,
+            15895,
             "Extension Bisect is active and has disabled 1 extension. Check if you can still reproduce the problem and proceed by selecting from these options."
         )) : ( localize(
-            15600,
+            15896,
             "Extension Bisect is active and has disabled {0} extensions. Check if you can still reproduce the problem and proceed by selecting from these options.",
             this._extensionBisectService.disabledCount
         ));
@@ -200,7 +200,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "extension.bisect.start",
-            title: ( localize2(15601, "Start Extension Bisect")),
+            title: ( localize2(15897, "Start Extension Bisect")),
             category: Categories.Help,
             f1: true,
             precondition: ( ExtensionBisectUi.ctxIsBisectActive.negate()),
@@ -220,13 +220,13 @@ registerAction2(class extends Action2 {
         const extensionsBisect = accessor.get(IExtensionBisectService);
         const extensions = (await extensionManagement.getInstalled(ExtensionType.User)).filter(ext => extensionEnablementService.isEnabled(ext));
         const res = await dialogService.confirm({
-            message: ( localize(15602, "Extension Bisect")),
+            message: ( localize(15898, "Extension Bisect")),
             detail: ( localize(
-                15603,
+                15899,
                 "Extension Bisect will use binary search to find an extension that causes a problem. During the process the window reloads repeatedly (~{0} times). Each time you must confirm if you are still seeing problems.",
                 2 + Math.log2(extensions.length) | 0
             )),
-            primaryButton: ( localize(15604, "&&Start Extension Bisect"))
+            primaryButton: ( localize(15900, "&&Start Extension Bisect"))
         });
         if (res.confirmed) {
             await extensionsBisect.start(extensions);
@@ -238,7 +238,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "extension.bisect.next",
-            title: ( localize2(15605, "Continue Extension Bisect")),
+            title: ( localize2(15901, "Continue Extension Bisect")),
             category: Categories.Help,
             f1: true,
             precondition: ExtensionBisectUi.ctxIsBisectActive
@@ -272,24 +272,24 @@ registerAction2(class extends Action2 {
             return;
         }
         if (done.bad) {
-            await dialogService.info(( localize(15606, "Extension Bisect")), ( localize(
-                15607,
+            await dialogService.info(( localize(15902, "Extension Bisect")), ( localize(
+                15903,
                 "Extension Bisect is done but no extension has been identified. This might be a problem with {0}.",
                 productService.nameShort
             )));
         } else {
             const res = await dialogService.confirm({
                 type: Severity.Info,
-                message: ( localize(15606, "Extension Bisect")),
-                primaryButton: ( localize(15608, "&&Report Issue & Continue")),
-                cancelButton: ( localize(15609, "Continue")),
+                message: ( localize(15902, "Extension Bisect")),
+                primaryButton: ( localize(15904, "&&Report Issue & Continue")),
+                cancelButton: ( localize(15905, "Continue")),
                 detail: ( localize(
-                    15610,
+                    15906,
                     "Extension Bisect is done and has identified {0} as the extension causing the problem.",
                     done.id
                 )),
                 checkbox: {
-                    label: ( localize(15611, "Keep this extension disabled")),
+                    label: ( localize(15907, "Keep this extension disabled")),
                     checked: true
                 }
             });
@@ -310,24 +310,24 @@ registerAction2(class extends Action2 {
             result
         } = await dialogService.prompt({
             type: Severity.Info,
-            message: ( localize(15612, "Extension Bisect")),
+            message: ( localize(15908, "Extension Bisect")),
             detail: ( localize(
-                15613,
+                15909,
                 "Extension Bisect is active and has disabled {0} extensions. Check if you can still reproduce the problem and proceed by selecting from these options.",
                 bisectService.disabledCount
             )),
             buttons: [{
-                label: ( localize(15614, "I ca&&n't reproduce")),
+                label: ( localize(15910, "I ca&&n't reproduce")),
                 run: () => false
             }, {
-                label: ( localize(15615, "I can &&reproduce")),
+                label: ( localize(15911, "I can &&reproduce")),
                 run: () => true
             }, {
-                label: ( localize(15616, "&&Stop Bisect")),
+                label: ( localize(15912, "&&Stop Bisect")),
                 run: () => undefined
             }],
             cancelButton: {
-                label: ( localize(15617, "&&Cancel Bisect")),
+                label: ( localize(15913, "&&Cancel Bisect")),
                 run: () => null
             }
         });
@@ -338,7 +338,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "extension.bisect.stop",
-            title: ( localize2(15618, "Stop Extension Bisect")),
+            title: ( localize2(15914, "Stop Extension Bisect")),
             category: Categories.Help,
             f1: true,
             precondition: ExtensionBisectUi.ctxIsBisectActive

package/vscode/src/vs/workbench/services/extensionManagement/browser/webExtensionsScannerService.js

@@ -768,7 +768,7 @@ let WebExtensionsScannerService = class WebExtensionsScannerService extends Disp
         }
         if (!this.extensionManifestPropertiesService.canExecuteOnWeb(manifest)) {
             throw ( new Error(( localize(
-                15633,
+                15929,
                 "Cannot add '{0}' because this extension is not a web extension.",
                 manifest.displayName || manifest.name
             ))));
@@ -1049,7 +1049,7 @@ if (isWeb) {
         constructor() {
             super({
                 id: "workbench.extensions.action.openInstalledWebExtensionsResource",
-                title: ( localize2(15634, "Open Installed Web Extensions Resource")),
+                title: ( localize2(15930, "Open Installed Web Extensions Resource")),
                 category: Categories.Developer,
                 f1: true,
                 precondition: IsWebContext