@codingame/monaco-vscode-edit-sessions-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/contrib/editSessions/browser/editSessions.contribution.js

@@ -79,45 +79,82 @@ import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severit
 
 var EditSessionsContribution_1;
 const continueWorkingOnCommand = {
-    id: '_workbench.editSessions.actions.continueEditSession',
-    title: ( localize2(7182, 'Continue Working On...')),
-    precondition: ( WorkspaceFolderCountContext.notEqualsTo('0')),
+    id: "_workbench.editSessions.actions.continueEditSession",
+    title: ( localize2(7493, "Continue Working On...")),
+    precondition: ( WorkspaceFolderCountContext.notEqualsTo("0")),
     f1: true
 };
 const openLocalFolderCommand = {
-    id: '_workbench.editSessions.actions.continueEditSession.openLocalFolder',
-    title: ( localize2(7183, 'Open In Local Folder')),
+    id: "_workbench.editSessions.actions.continueEditSession.openLocalFolder",
+    title: ( localize2(7494, "Open In Local Folder")),
     category: EDIT_SESSION_SYNC_CATEGORY,
     precondition: ( ContextKeyExpr.and(( IsWebContext.toNegated()), VirtualWorkspaceContext))
 };
 const showOutputChannelCommand = {
-    id: 'workbench.editSessions.actions.showOutputChannel',
-    title: ( localize2(7184, "Show Log")),
+    id: "workbench.editSessions.actions.showOutputChannel",
+    title: ( localize2(7495, "Show Log")),
     category: EDIT_SESSION_SYNC_CATEGORY
 };
 const installAdditionalContinueOnOptionsCommand = {
-    id: 'workbench.action.continueOn.extensions',
-    title: ( localize(7185, 'Install additional development environment options')),
+    id: "workbench.action.continueOn.extensions",
+    title: ( localize(7496, "Install additional development environment options"))
 };
 registerAction2(class extends Action2 {
     constructor() {
-        super({ ...installAdditionalContinueOnOptionsCommand, f1: false });
+        super({
+            ...installAdditionalContinueOnOptionsCommand,
+            f1: false
+        });
     }
     async run(accessor) {
-        return accessor.get(IExtensionsWorkbenchService).openSearch('@tag:continueOn');
+        return accessor.get(IExtensionsWorkbenchService).openSearch("@tag:continueOn");
     }
 });
-const resumeProgressOptionsTitle = `[${( localize(7186, 'Resuming working changes...'))}](command:${showOutputChannelCommand.id})`;
+const resumeProgressOptionsTitle = `[${( localize(7497, "Resuming working changes..."))}](command:${showOutputChannelCommand.id})`;
 const resumeProgressOptions = {
     location: ProgressLocation.Window,
-    type: 'syncing',
+    type: "syncing"
 };
-const queryParamName = 'editSessionId';
-const useEditSessionsWithContinueOn = 'workbench.editSessions.continueOn';
+const queryParamName = "editSessionId";
+const useEditSessionsWithContinueOn = "workbench.editSessions.continueOn";
 let EditSessionsContribution = class EditSessionsContribution extends Disposable {
-    static { EditSessionsContribution_1 = this; }
-    static { this.APPLICATION_LAUNCHED_VIA_CONTINUE_ON_STORAGE_KEY = 'applicationLaunchedViaContinueOn'; }
-    constructor(editSessionsStorageService, fileService, progressService, openerService, telemetryService, scmService, notificationService, dialogService, logService, environmentService, instantiationService, productService, configurationService, contextService, editSessionIdentityService, quickInputService, commandService, contextKeyService, fileDialogService, lifecycleService, storageService, activityService, editorService, remoteAgentService, extensionService, requestService, userDataProfilesService, uriIdentityService, workspaceIdentityService) {
+    static {
+        EditSessionsContribution_1 = this;
+    }
+    static {
+        this.APPLICATION_LAUNCHED_VIA_CONTINUE_ON_STORAGE_KEY = "applicationLaunchedViaContinueOn";
+    }
+    constructor(
+        editSessionsStorageService,
+        fileService,
+        progressService,
+        openerService,
+        telemetryService,
+        scmService,
+        notificationService,
+        dialogService,
+        logService,
+        environmentService,
+        instantiationService,
+        productService,
+        configurationService,
+        contextService,
+        editSessionIdentityService,
+        quickInputService,
+        commandService,
+        contextKeyService,
+        fileDialogService,
+        lifecycleService,
+        storageService,
+        activityService,
+        editorService,
+        remoteAgentService,
+        extensionService,
+        requestService,
+        userDataProfilesService,
+        uriIdentityService,
+        workspaceIdentityService
+    ) {
         super();
         this.editSessionsStorageService = editSessionsStorageService;
         this.fileService = fileService;
@@ -154,10 +191,10 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
         this.shouldShowViewsContext = EDIT_SESSIONS_SHOW_VIEW.bindTo(this.contextKeyService);
         this.pendingEditSessionsContext = EDIT_SESSIONS_PENDING.bindTo(this.contextKeyService);
         this.pendingEditSessionsContext.set(false);
-        if (!this.productService['editSessions.store']?.url) {
+        if (!this.productService["editSessions.store"]?.url) {
             return;
         }
-        this.editSessionsStorageClient = ( new EditSessionsStoreClient(( URI.parse(this.productService['editSessions.store'].url)), this.productService, this.requestService, this.logService, this.environmentService, this.fileService, this.storageService));
+        this.editSessionsStorageClient = ( new EditSessionsStoreClient(( URI.parse(this.productService["editSessions.store"].url)), this.productService, this.requestService, this.logService, this.environmentService, this.fileService, this.storageService));
         this.editSessionsStorageService.storeClient = this.editSessionsStorageClient;
         this.workspaceStateSynchronizer = ( new WorkspaceStateSynchroniser(
             this.userDataProfilesService.defaultProfile,
@@ -177,76 +214,114 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
         this.registerActions();
         this.registerViews();
         this.registerContributedEditSessionOptions();
-        this._register(this.fileService.registerProvider(EditSessionsFileSystemProvider.SCHEMA, ( new EditSessionsFileSystemProvider(this.editSessionsStorageService))));
-        this.lifecycleService.onWillShutdown((e) => {
-            if (e.reason !== ShutdownReason.RELOAD && this.editSessionsStorageService.isSignedIn && this.configurationService.getValue('workbench.experimental.cloudChanges.autoStore') === 'onShutdown' && !isWeb) {
-                e.join(this.autoStoreEditSession(), { id: 'autoStoreWorkingChanges', label: ( localize(7187, 'Storing current working changes...')) });
+        this._register(
+            this.fileService.registerProvider(EditSessionsFileSystemProvider.SCHEMA, ( new EditSessionsFileSystemProvider(this.editSessionsStorageService)))
+        );
+        this.lifecycleService.onWillShutdown(e => {
+            if (e.reason !== ShutdownReason.RELOAD && this.editSessionsStorageService.isSignedIn && this.configurationService.getValue("workbench.experimental.cloudChanges.autoStore") === "onShutdown" && !isWeb) {
+                e.join(this.autoStoreEditSession(), {
+                    id: "autoStoreWorkingChanges",
+                    label: ( localize(7498, "Storing current working changes..."))
+                });
             }
         });
-        this._register(this.editSessionsStorageService.onDidSignIn(() => this.updateAccountsMenuBadge()));
-        this._register(this.editSessionsStorageService.onDidSignOut(() => this.updateAccountsMenuBadge()));
+        this._register(
+            this.editSessionsStorageService.onDidSignIn(() => this.updateAccountsMenuBadge())
+        );
+        this._register(
+            this.editSessionsStorageService.onDidSignOut(() => this.updateAccountsMenuBadge())
+        );
     }
     async autoResumeEditSession() {
-        const shouldAutoResumeOnReload = this.configurationService.getValue('workbench.cloudChanges.autoResume') === 'onReload';
+        const shouldAutoResumeOnReload = this.configurationService.getValue("workbench.cloudChanges.autoResume") === "onReload";
         if (this.environmentService.editSessionId !== undefined) {
-            this.logService.info(`Resuming cloud changes, reason: found editSessionId ${this.environmentService.editSessionId} in environment service...`);
-            await this.progressService.withProgress(resumeProgressOptions, async (progress) => await this.resumeEditSession(this.environmentService.editSessionId, undefined, undefined, undefined, progress).finally(() => this.environmentService.editSessionId = undefined));
-        }
-        else if (shouldAutoResumeOnReload && this.editSessionsStorageService.isSignedIn) {
-            this.logService.info('Resuming cloud changes, reason: cloud changes enabled...');
-            await this.progressService.withProgress(resumeProgressOptions, async (progress) => await this.resumeEditSession(undefined, true, undefined, undefined, progress));
-        }
-        else if (shouldAutoResumeOnReload) {
-            const hasApplicationLaunchedFromContinueOnFlow = this.storageService.getBoolean(EditSessionsContribution_1.APPLICATION_LAUNCHED_VIA_CONTINUE_ON_STORAGE_KEY, StorageScope.APPLICATION, false);
-            this.logService.info(`Prompting to enable cloud changes, has application previously launched from Continue On flow: ${hasApplicationLaunchedFromContinueOnFlow}`);
+            this.logService.info(
+                `Resuming cloud changes, reason: found editSessionId ${this.environmentService.editSessionId} in environment service...`
+            );
+            await this.progressService.withProgress(resumeProgressOptions, async progress => await this.resumeEditSession(
+                this.environmentService.editSessionId,
+                undefined,
+                undefined,
+                undefined,
+                progress
+            ).finally(() => this.environmentService.editSessionId = undefined));
+        } else if (shouldAutoResumeOnReload && this.editSessionsStorageService.isSignedIn) {
+            this.logService.info("Resuming cloud changes, reason: cloud changes enabled...");
+            await this.progressService.withProgress(
+                resumeProgressOptions,
+                async progress => await this.resumeEditSession(undefined, true, undefined, undefined, progress)
+            );
+        } else if (shouldAutoResumeOnReload) {
+            const hasApplicationLaunchedFromContinueOnFlow = this.storageService.getBoolean(
+                EditSessionsContribution_1.APPLICATION_LAUNCHED_VIA_CONTINUE_ON_STORAGE_KEY,
+                StorageScope.APPLICATION,
+                false
+            );
+            this.logService.info(
+                `Prompting to enable cloud changes, has application previously launched from Continue On flow: ${hasApplicationLaunchedFromContinueOnFlow}`
+            );
             const handlePendingEditSessions = () => {
-                this.logService.info('Showing badge to enable cloud changes in accounts menu...');
+                this.logService.info("Showing badge to enable cloud changes in accounts menu...");
                 this.updateAccountsMenuBadge();
                 this.pendingEditSessionsContext.set(true);
                 const disposable = this.editSessionsStorageService.onDidSignIn(async () => {
                     disposable.dispose();
-                    this.logService.info('Showing badge to enable cloud changes in accounts menu succeeded, resuming cloud changes...');
-                    await this.progressService.withProgress(resumeProgressOptions, async (progress) => await this.resumeEditSession(undefined, true, undefined, undefined, progress));
-                    this.storageService.remove(EditSessionsContribution_1.APPLICATION_LAUNCHED_VIA_CONTINUE_ON_STORAGE_KEY, StorageScope.APPLICATION);
+                    this.logService.info(
+                        "Showing badge to enable cloud changes in accounts menu succeeded, resuming cloud changes..."
+                    );
+                    await this.progressService.withProgress(
+                        resumeProgressOptions,
+                        async progress => await this.resumeEditSession(undefined, true, undefined, undefined, progress)
+                    );
+                    this.storageService.remove(
+                        EditSessionsContribution_1.APPLICATION_LAUNCHED_VIA_CONTINUE_ON_STORAGE_KEY,
+                        StorageScope.APPLICATION
+                    );
                     this.environmentService.continueOn = undefined;
                 });
             };
-            if ((this.environmentService.continueOn !== undefined) &&
-                !this.editSessionsStorageService.isSignedIn &&
-                hasApplicationLaunchedFromContinueOnFlow === false) {
-                this.storageService.store(EditSessionsContribution_1.APPLICATION_LAUNCHED_VIA_CONTINUE_ON_STORAGE_KEY, true, StorageScope.APPLICATION, StorageTarget.MACHINE);
-                this.logService.info('Prompting to enable cloud changes...');
-                await this.editSessionsStorageService.initialize('read');
+            if ((this.environmentService.continueOn !== undefined) && !this.editSessionsStorageService.isSignedIn &&
+            hasApplicationLaunchedFromContinueOnFlow === false) {
+                this.storageService.store(
+                    EditSessionsContribution_1.APPLICATION_LAUNCHED_VIA_CONTINUE_ON_STORAGE_KEY,
+                    true,
+                    StorageScope.APPLICATION,
+                    StorageTarget.MACHINE
+                );
+                this.logService.info("Prompting to enable cloud changes...");
+                await this.editSessionsStorageService.initialize("read");
                 if (this.editSessionsStorageService.isSignedIn) {
-                    this.logService.info('Prompting to enable cloud changes succeeded, resuming cloud changes...');
-                    await this.progressService.withProgress(resumeProgressOptions, async (progress) => await this.resumeEditSession(undefined, true, undefined, undefined, progress));
-                }
-                else {
+                    this.logService.info("Prompting to enable cloud changes succeeded, resuming cloud changes...");
+                    await this.progressService.withProgress(
+                        resumeProgressOptions,
+                        async progress => await this.resumeEditSession(undefined, true, undefined, undefined, progress)
+                    );
+                } else {
                     handlePendingEditSessions();
                 }
-            }
-            else if (!this.editSessionsStorageService.isSignedIn &&
-                hasApplicationLaunchedFromContinueOnFlow === true) {
+            } else if (!this.editSessionsStorageService.isSignedIn &&
+            hasApplicationLaunchedFromContinueOnFlow === true) {
                 handlePendingEditSessions();
             }
-        }
-        else {
-            this.logService.debug('Auto resuming cloud changes disabled.');
+        } else {
+            this.logService.debug("Auto resuming cloud changes disabled.");
         }
     }
     updateAccountsMenuBadge() {
         if (this.editSessionsStorageService.isSignedIn) {
             return this.accountsMenuBadgeDisposable.clear();
         }
-        const badge = ( new NumberBadge(1, () => ( localize(7188, 'Check for pending cloud changes'))));
-        this.accountsMenuBadgeDisposable.value = this.activityService.showAccountsActivity({ badge });
+        const badge = ( new NumberBadge(1, () => ( localize(7499, "Check for pending cloud changes"))));
+        this.accountsMenuBadgeDisposable.value = this.activityService.showAccountsActivity({
+            badge
+        });
     }
     async autoStoreEditSession() {
         const cancellationTokenSource = ( new CancellationTokenSource());
         await this.progressService.withProgress({
             location: ProgressLocation.Window,
-            type: 'syncing',
-            title: ( localize(7189, 'Storing working changes...'))
+            type: "syncing",
+            title: ( localize(7500, "Storing working changes..."))
         }, async () => this.storeEditSession(false, cancellationTokenSource.token), () => {
             cancellationTokenSource.cancel();
             cancellationTokenSource.dispose();
@@ -256,13 +331,14 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
         const container = ( Registry.as(Extensions.ViewContainersRegistry)).registerViewContainer({
             id: EDIT_SESSIONS_CONTAINER_ID,
             title: EDIT_SESSIONS_TITLE,
-            ctorDescriptor: ( new SyncDescriptor(
-                ViewPaneContainer,
-                [EDIT_SESSIONS_CONTAINER_ID, { mergeViewWithContainerWhenSingleView: true }]
-            )),
+            ctorDescriptor: ( new SyncDescriptor(ViewPaneContainer, [EDIT_SESSIONS_CONTAINER_ID, {
+                mergeViewWithContainerWhenSingleView: true
+            }])),
             icon: EDIT_SESSIONS_VIEW_ICON,
             hideIfEmpty: true
-        }, ViewContainerLocation.Sidebar, { doNotRegisterOpenCommand: true });
+        }, ViewContainerLocation.Sidebar, {
+            doNotRegisterOpenCommand: true
+        });
         this._register(this.instantiationService.createInstance(EditSessionsDataViews, container));
     }
     registerActions() {
@@ -289,8 +365,8 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
         this._register(registerAction2(class ShowEditSessionView extends Action2 {
             constructor() {
                 super({
-                    id: 'workbench.editSessions.actions.showEditSessions',
-                    title: ( localize2(7190, 'Show Cloud Changes')),
+                    id: "workbench.editSessions.actions.showEditSessions",
+                    title: ( localize2(7501, "Show Cloud Changes")),
                     category: EDIT_SESSION_SYNC_CATEGORY,
                     f1: true
                 });
@@ -313,38 +389,47 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
                 if (!destination && !uri) {
                     destination = await that.pickContinueEditSessionDestination();
                     if (!destination) {
-                        that.telemetryService.publicLog2('continueOn.editSessions.pick.outcome', { outcome: 'noSelection' });
+                        that.telemetryService.publicLog2("continueOn.editSessions.pick.outcome", {
+                            outcome: "noSelection"
+                        });
                         return;
                     }
                 }
                 const shouldStoreEditSession = await that.shouldContinueOnWithEditSession();
                 let ref;
                 if (shouldStoreEditSession) {
-                    that.telemetryService.publicLog2('continueOn.editSessions.store');
+                    that.telemetryService.publicLog2("continueOn.editSessions.store");
                     const cancellationTokenSource = ( new CancellationTokenSource());
                     try {
                         ref = await that.progressService.withProgress({
                             location: ProgressLocation.Notification,
                             cancellable: true,
-                            type: 'syncing',
-                            title: ( localize(7191, 'Storing your working changes...'))
+                            type: "syncing",
+                            title: ( localize(7502, "Storing your working changes..."))
                         }, async () => {
                             const ref = await that.storeEditSession(false, cancellationTokenSource.token);
                             if (ref !== undefined) {
-                                that.telemetryService.publicLog2('continueOn.editSessions.store.outcome', { outcome: 'storeSucceeded', hashedId: hashedEditSessionId(ref) });
-                            }
-                            else {
-                                that.telemetryService.publicLog2('continueOn.editSessions.store.outcome', { outcome: 'storeSkipped' });
+                                that.telemetryService.publicLog2("continueOn.editSessions.store.outcome", {
+                                    outcome: "storeSucceeded",
+                                    hashedId: hashedEditSessionId(ref)
+                                });
+                            } else {
+                                that.telemetryService.publicLog2("continueOn.editSessions.store.outcome", {
+                                    outcome: "storeSkipped"
+                                });
                             }
                             return ref;
                         }, () => {
                             cancellationTokenSource.cancel();
                             cancellationTokenSource.dispose();
-                            that.telemetryService.publicLog2('continueOn.editSessions.store.outcome', { outcome: 'storeCancelledByUser' });
+                            that.telemetryService.publicLog2("continueOn.editSessions.store.outcome", {
+                                outcome: "storeCancelledByUser"
+                            });
+                        });
+                    } catch (ex) {
+                        that.telemetryService.publicLog2("continueOn.editSessions.store.outcome", {
+                            outcome: "storeFailed"
                         });
-                    }
-                    catch (ex) {
-                        that.telemetryService.publicLog2('continueOn.editSessions.store.outcome', { outcome: 'storeFailed' });
                         throw ex;
                     }
                 }
@@ -352,20 +437,24 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
                 if (uri === undefined) {
                     return;
                 }
-                if (ref !== undefined && uri !== 'noDestinationUri') {
+                if (ref !== undefined && uri !== "noDestinationUri") {
                     const encodedRef = encodeURIComponent(ref);
                     uri = uri.with({
                         query: uri.query.length > 0 ? (uri.query + `&${queryParamName}=${encodedRef}&continueOn=1`) : `${queryParamName}=${encodedRef}&continueOn=1`
                     });
                     that.logService.info(`Opening ${( uri.toString())}`);
-                    await that.openerService.open(uri, { openExternal: true });
-                }
-                else if ((!shouldStoreEditSession || ref === undefined) && uri !== 'noDestinationUri') {
+                    await that.openerService.open(uri, {
+                        openExternal: true
+                    });
+                } else if ((!shouldStoreEditSession || ref === undefined) && uri !== "noDestinationUri") {
                     that.logService.info(`Opening ${( uri.toString())}`);
-                    await that.openerService.open(uri, { openExternal: true });
-                }
-                else if (ref === undefined && shouldStoreEditSession) {
-                    that.logService.warn(`Failed to store working changes when invoking ${continueWorkingOnCommand.id}.`);
+                    await that.openerService.open(uri, {
+                        openExternal: true
+                    });
+                } else if (ref === undefined && shouldStoreEditSession) {
+                    that.logService.warn(
+                        `Failed to store working changes when invoking ${continueWorkingOnCommand.id}.`
+                    );
                 }
             }
         }));
@@ -375,31 +464,42 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
         this._register(registerAction2(class ResumeLatestEditSessionAction extends Action2 {
             constructor() {
                 super({
-                    id: 'workbench.editSessions.actions.resumeLatest',
-                    title: ( localize2(7192, 'Resume Latest Changes from Cloud')),
+                    id: "workbench.editSessions.actions.resumeLatest",
+                    title: ( localize2(7503, "Resume Latest Changes from Cloud")),
                     category: EDIT_SESSION_SYNC_CATEGORY,
-                    f1: true,
+                    f1: true
                 });
             }
             async run(accessor, editSessionId, forceApplyUnrelatedChange) {
-                await that.progressService.withProgress({ ...resumeProgressOptions, title: resumeProgressOptionsTitle }, async () => await that.resumeEditSession(editSessionId, undefined, forceApplyUnrelatedChange));
+                await that.progressService.withProgress({
+                    ...resumeProgressOptions,
+                    title: resumeProgressOptionsTitle
+                }, async () => await that.resumeEditSession(editSessionId, undefined, forceApplyUnrelatedChange));
             }
         }));
         this._register(registerAction2(class ResumeLatestEditSessionAction extends Action2 {
             constructor() {
                 super({
-                    id: 'workbench.editSessions.actions.resumeFromSerializedPayload',
-                    title: ( localize2(7193, 'Resume Changes from Serialized Data')),
-                    category: 'Developer',
-                    f1: true,
+                    id: "workbench.editSessions.actions.resumeFromSerializedPayload",
+                    title: ( localize2(7504, "Resume Changes from Serialized Data")),
+                    category: "Developer",
+                    f1: true
                 });
             }
             async run(accessor, editSessionId) {
-                const data = await that.quickInputService.input({ prompt: 'Enter serialized data' });
+                const data = await that.quickInputService.input({
+                    prompt: "Enter serialized data"
+                });
                 if (data) {
-                    that.editSessionsStorageService.lastReadResources.set('editSessions', { content: data, ref: '' });
+                    that.editSessionsStorageService.lastReadResources.set("editSessions", {
+                        content: data,
+                        ref: ""
+                    });
                 }
-                await that.progressService.withProgress({ ...resumeProgressOptions, title: resumeProgressOptionsTitle }, async () => await that.resumeEditSession(editSessionId, undefined, undefined, undefined, undefined, data));
+                await that.progressService.withProgress({
+                    ...resumeProgressOptions,
+                    title: resumeProgressOptionsTitle
+                }, async () => await that.resumeEditSession(editSessionId, undefined, undefined, undefined, undefined, data));
             }
         }));
     }
@@ -408,19 +508,19 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
         this._register(registerAction2(class StoreLatestEditSessionAction extends Action2 {
             constructor() {
                 super({
-                    id: 'workbench.editSessions.actions.storeCurrent',
-                    title: ( localize2(7194, 'Store Working Changes in Cloud')),
+                    id: "workbench.editSessions.actions.storeCurrent",
+                    title: ( localize2(7505, "Store Working Changes in Cloud")),
                     category: EDIT_SESSION_SYNC_CATEGORY,
-                    f1: true,
+                    f1: true
                 });
             }
             async run(accessor) {
                 const cancellationTokenSource = ( new CancellationTokenSource());
                 await that.progressService.withProgress({
                     location: ProgressLocation.Notification,
-                    title: ( localize(7195, 'Storing working changes...'))
+                    title: ( localize(7506, "Storing working changes..."))
                 }, async () => {
-                    that.telemetryService.publicLog2('editSessions.store');
+                    that.telemetryService.publicLog2("editSessions.store");
                     await that.storeEditSession(true, cancellationTokenSource.token);
                 }, () => {
                     cancellationTokenSource.cancel();
@@ -429,87 +529,122 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
             }
         }));
     }
-    async resumeEditSession(ref, silent, forceApplyUnrelatedChange, applyPartialMatch, progress, serializedData) {
+    async resumeEditSession(
+        ref,
+        silent,
+        forceApplyUnrelatedChange,
+        applyPartialMatch,
+        progress,
+        serializedData
+    ) {
         await this.remoteAgentService.getEnvironment();
         if (this.contextService.getWorkbenchState() === WorkbenchState.EMPTY) {
             return;
         }
-        this.logService.info(ref !== undefined ? `Resuming changes from cloud with ref ${ref}...` : 'Checking for pending cloud changes...');
-        if (silent && !(await this.editSessionsStorageService.initialize('read', true))) {
+        this.logService.info(
+            ref !== undefined ? `Resuming changes from cloud with ref ${ref}...` : "Checking for pending cloud changes..."
+        );
+        if (silent && !(await this.editSessionsStorageService.initialize("read", true))) {
             return;
         }
-        this.telemetryService.publicLog2('editSessions.resume');
-        performance.mark('code/willResumeEditSessionFromIdentifier');
-        progress?.report({ message: ( localize(7196, 'Checking for pending cloud changes...')) });
-        const data = serializedData ? { content: serializedData, ref: '' } : await this.editSessionsStorageService.read('editSessions', ref);
+        this.telemetryService.publicLog2("editSessions.resume");
+        performance.mark("code/willResumeEditSessionFromIdentifier");
+        progress?.report({
+            message: ( localize(7507, "Checking for pending cloud changes..."))
+        });
+        const data = serializedData ? {
+            content: serializedData,
+            ref: ""
+        } : await this.editSessionsStorageService.read("editSessions", ref);
         if (!data) {
             if (ref === undefined && !silent) {
-                this.notificationService.info(( localize(7197, 'There are no changes to resume from the cloud.')));
-            }
-            else if (ref !== undefined) {
-                this.notificationService.warn(( localize(7198, 'Could not resume changes from the cloud for ID {0}.', ref)));
+                this.notificationService.info(( localize(7508, "There are no changes to resume from the cloud.")));
+            } else if (ref !== undefined) {
+                this.notificationService.warn(( localize(7509, "Could not resume changes from the cloud for ID {0}.", ref)));
             }
-            this.logService.info(ref !== undefined ? `Aborting resuming changes from cloud as no edit session content is available to be applied from ref ${ref}.` : `Aborting resuming edit session as no edit session content is available to be applied`);
+            this.logService.info(
+                ref !== undefined ? `Aborting resuming changes from cloud as no edit session content is available to be applied from ref ${ref}.` : `Aborting resuming edit session as no edit session content is available to be applied`
+            );
             return;
         }
-        progress?.report({ message: resumeProgressOptionsTitle });
+        progress?.report({
+            message: resumeProgressOptionsTitle
+        });
         const editSession = JSON.parse(data.content);
         ref = data.ref;
         if (editSession.version > EditSessionSchemaVersion) {
             this.notificationService.error(( localize(
-                7199,
+                7510,
                 "Please upgrade to a newer version of {0} to resume your working changes from the cloud.",
                 this.productService.nameLong
             )));
-            this.telemetryService.publicLog2('editSessions.resume.outcome', { hashedId: hashedEditSessionId(ref), outcome: 'clientUpdateNeeded' });
+            this.telemetryService.publicLog2("editSessions.resume.outcome", {
+                hashedId: hashedEditSessionId(ref),
+                outcome: "clientUpdateNeeded"
+            });
             return;
         }
         try {
-            const { changes, conflictingChanges } = await this.generateChanges(editSession, ref, forceApplyUnrelatedChange, applyPartialMatch);
+            const {
+                changes,
+                conflictingChanges
+            } = await this.generateChanges(editSession, ref, forceApplyUnrelatedChange, applyPartialMatch);
             if (changes.length === 0) {
                 return;
             }
             if (conflictingChanges.length > 0) {
-                const { confirmed } = await this.dialogService.confirm({
+                const {
+                    confirmed
+                } = await this.dialogService.confirm({
                     type: Severity.Warning,
-                    message: conflictingChanges.length > 1 ?
-                        ( localize(
-                        7200,
-                        'Resuming your working changes from the cloud will overwrite the following {0} files. Do you want to proceed?',
+                    message: conflictingChanges.length > 1 ? ( localize(
+                        7511,
+                        "Resuming your working changes from the cloud will overwrite the following {0} files. Do you want to proceed?",
                         conflictingChanges.length
-                    )) :
-                        ( localize(
-                        7201,
-                        'Resuming your working changes from the cloud will overwrite {0}. Do you want to proceed?',
+                    )) : ( localize(
+                        7512,
+                        "Resuming your working changes from the cloud will overwrite {0}. Do you want to proceed?",
                         basename(conflictingChanges[0].uri)
                     )),
-                    detail: conflictingChanges.length > 1 ? getFileNamesMessage(( conflictingChanges.map((c) => c.uri))) : undefined
+                    detail: conflictingChanges.length > 1 ? getFileNamesMessage(( conflictingChanges.map(c => c.uri))) : undefined
                 });
                 if (!confirmed) {
                     return;
                 }
             }
-            for (const { uri, type, contents } of changes) {
+            for (const {
+                uri,
+                type,
+                contents
+            } of changes) {
                 if (type === ChangeType.Addition) {
                     await this.fileService.writeFile(uri, decodeEditSessionFileContent(editSession.version, contents));
-                }
-                else if (type === ChangeType.Deletion && (await this.fileService.exists(uri))) {
+                } else if (type === ChangeType.Deletion && (await this.fileService.exists(uri))) {
                     await this.fileService.del(uri);
                 }
             }
             await this.workspaceStateSynchronizer?.apply();
-            this.logService.info(`Deleting edit session with ref ${ref} after successfully applying it to current workspace...`);
-            await this.editSessionsStorageService.delete('editSessions', ref);
+            this.logService.info(
+                `Deleting edit session with ref ${ref} after successfully applying it to current workspace...`
+            );
+            await this.editSessionsStorageService.delete("editSessions", ref);
             this.logService.info(`Deleted edit session with ref ${ref}.`);
-            this.telemetryService.publicLog2('editSessions.resume.outcome', { hashedId: hashedEditSessionId(ref), outcome: 'resumeSucceeded' });
+            this.telemetryService.publicLog2("editSessions.resume.outcome", {
+                hashedId: hashedEditSessionId(ref),
+                outcome: "resumeSucceeded"
+            });
+        } catch (ex) {
+            this.logService.error("Failed to resume edit session, reason: ", ( ex.toString()));
+            this.notificationService.error(( localize(7513, "Failed to resume your working changes from the cloud.")));
         }
-        catch (ex) {
-            this.logService.error('Failed to resume edit session, reason: ', ( ex.toString()));
-            this.notificationService.error(( localize(7202, "Failed to resume your working changes from the cloud.")));
-        }
-        performance.mark('code/didResumeEditSessionFromIdentifier');
+        performance.mark("code/didResumeEditSessionFromIdentifier");
     }
-    async generateChanges(editSession, ref, forceApplyUnrelatedChange = false, applyPartialMatch = false) {
+    async generateChanges(
+        editSession,
+        ref,
+        forceApplyUnrelatedChange = false,
+        applyPartialMatch = false
+    ) {
         const changes = [];
         const conflictingChanges = [];
         const workspaceFolders = this.contextService.getWorkspace().folders;
@@ -519,7 +654,9 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
             if (folder.canonicalIdentity) {
                 for (const f of workspaceFolders) {
                     const identity = await this.editSessionIdentityService.getEditSessionIdentifier(f, cancellationTokenSource.token);
-                    this.logService.info(`Matching identity ${identity} against edit session folder identity ${folder.canonicalIdentity}...`);
+                    this.logService.info(
+                        `Matching identity ${identity} against edit session folder identity ${folder.canonicalIdentity}...`
+                    );
                     if (equals(identity, folder.canonicalIdentity) || forceApplyUnrelatedChange) {
                         folderRoot = f;
                         break;
@@ -529,66 +666,85 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
                         if (match === EditSessionIdentityMatch.Complete) {
                             folderRoot = f;
                             break;
-                        }
-                        else if (match === EditSessionIdentityMatch.Partial &&
-                            this.configurationService.getValue('workbench.experimental.cloudChanges.partialMatches.enabled') === true) {
+                        } else if (match === EditSessionIdentityMatch.Partial && this.configurationService.getValue("workbench.experimental.cloudChanges.partialMatches.enabled") === true) {
                             if (!applyPartialMatch) {
                                 this.notificationService.prompt(Severity.Info, ( localize(
-                                    7203,
-                                    'You have pending working changes in the cloud for this workspace. Would you like to resume them?'
-                                )), [{ label: ( localize(7204, 'Resume')), run: () => this.resumeEditSession(ref, false, undefined, true) }]);
-                            }
-                            else {
+                                    7514,
+                                    "You have pending working changes in the cloud for this workspace. Would you like to resume them?"
+                                )), [{
+                                    label: ( localize(7515, "Resume")),
+                                    run: () => this.resumeEditSession(ref, false, undefined, true)
+                                }]);
+                            } else {
                                 folderRoot = f;
                                 break;
                             }
                         }
                     }
                 }
-            }
-            else {
-                folderRoot = workspaceFolders.find((f) => f.name === folder.name);
+            } else {
+                folderRoot = workspaceFolders.find(f => f.name === folder.name);
             }
             if (!folderRoot) {
-                this.logService.info(`Skipping applying ${folder.workingChanges.length} changes from edit session with ref ${ref} as no matching workspace folder was found.`);
-                return { changes: [], conflictingChanges: [], contributedStateHandlers: [] };
+                this.logService.info(
+                    `Skipping applying ${folder.workingChanges.length} changes from edit session with ref ${ref} as no matching workspace folder was found.`
+                );
+                return {
+                    changes: [],
+                    conflictingChanges: [],
+                    contributedStateHandlers: []
+                };
             }
             const localChanges = ( new Set());
             for (const repository of this.scmService.repositories) {
-                if (repository.provider.rootUri !== undefined &&
-                    this.contextService.getWorkspaceFolder(repository.provider.rootUri)?.name === folder.name) {
+                if (repository.provider.rootUri !== undefined && this.contextService.getWorkspaceFolder(repository.provider.rootUri)?.name === folder.name) {
                     const repositoryChanges = this.getChangedResources(repository);
-                    repositoryChanges.forEach((change) => localChanges.add(( change.toString())));
+                    repositoryChanges.forEach(change => localChanges.add(( change.toString())));
                 }
             }
             for (const change of folder.workingChanges) {
                 const uri = joinPath(folderRoot.uri, change.relativeFilePath);
-                changes.push({ uri, type: change.type, contents: change.contents });
+                changes.push({
+                    uri,
+                    type: change.type,
+                    contents: change.contents
+                });
                 if (await this.willChangeLocalContents(localChanges, uri, change)) {
-                    conflictingChanges.push({ uri, type: change.type, contents: change.contents });
+                    conflictingChanges.push({
+                        uri,
+                        type: change.type,
+                        contents: change.contents
+                    });
                 }
             }
         }
-        return { changes, conflictingChanges };
+        return {
+            changes,
+            conflictingChanges
+        };
     }
     async willChangeLocalContents(localChanges, uriWithIncomingChanges, incomingChange) {
         if (!( localChanges.has(( uriWithIncomingChanges.toString())))) {
             return false;
         }
-        const { contents, type } = incomingChange;
+        const {
+            contents,
+            type
+        } = incomingChange;
         switch (type) {
-            case (ChangeType.Addition): {
-                const [originalContents, incomingContents] = await Promise.all([
-                    hashAsync(contents),
-                    hashAsync(encodeBase64((await this.fileService.readFile(uriWithIncomingChanges)).value))
-                ]);
+        case (ChangeType.Addition):
+            {
+                const [originalContents, incomingContents] = await Promise.all([hashAsync(contents), hashAsync(
+                    encodeBase64((await this.fileService.readFile(uriWithIncomingChanges)).value)
+                )]);
                 return originalContents !== incomingContents;
             }
-            case (ChangeType.Deletion): {
+        case (ChangeType.Deletion):
+            {
                 return await this.fileService.exists(uriWithIncomingChanges);
             }
-            default:
-                throw ( new Error('Unhandled change type.'));
+        default:
+            throw ( new Error("Unhandled change type."));
         }
     }
     async storeEditSession(fromStoreCommand, cancellationToken) {
@@ -614,7 +770,9 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
         for (const repository of this.scmService.repositories) {
             const trackedUris = this.getChangedResources(repository);
             const workingChanges = [];
-            const { rootUri } = repository.provider;
+            const {
+                rootUri
+            } = repository.provider;
             const workspaceFolder = rootUri ? this.contextService.getWorkspaceFolder(rootUri) : undefined;
             let name = workspaceFolder?.name;
             for (const uri of trackedUris) {
@@ -629,58 +787,80 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
                     if (!(await this.fileService.stat(uri)).isFile) {
                         continue;
                     }
-                }
-                catch { }
+                } catch {}
                 hasEdits = true;
                 if (await this.fileService.exists(uri)) {
                     const contents = encodeBase64((await this.fileService.readFile(uri)).value);
                     editSessionSize += contents.length;
                     if (editSessionSize > this.editSessionsStorageService.SIZE_LIMIT) {
-                        this.notificationService.error(( localize(7205, 'Your working changes exceed the size limit and cannot be stored.')));
+                        this.notificationService.error(( localize(7516, "Your working changes exceed the size limit and cannot be stored.")));
                         return undefined;
                     }
-                    workingChanges.push({ type: ChangeType.Addition, fileType: FileType.File, contents: contents, relativeFilePath: relativeFilePath });
-                }
-                else {
-                    workingChanges.push({ type: ChangeType.Deletion, fileType: FileType.File, contents: undefined, relativeFilePath: relativeFilePath });
+                    workingChanges.push({
+                        type: ChangeType.Addition,
+                        fileType: FileType.File,
+                        contents: contents,
+                        relativeFilePath: relativeFilePath
+                    });
+                } else {
+                    workingChanges.push({
+                        type: ChangeType.Deletion,
+                        fileType: FileType.File,
+                        contents: undefined,
+                        relativeFilePath: relativeFilePath
+                    });
                 }
             }
             let canonicalIdentity = undefined;
             if (workspaceFolder !== null && workspaceFolder !== undefined) {
                 canonicalIdentity = await this.editSessionIdentityService.getEditSessionIdentifier(workspaceFolder, cancellationToken);
             }
-            folders.push({ workingChanges, name: name ?? '', canonicalIdentity: canonicalIdentity ?? undefined, absoluteUri: workspaceFolder?.uri.toString() });
+            folders.push({
+                workingChanges,
+                name: name ?? "",
+                canonicalIdentity: canonicalIdentity ?? undefined,
+                absoluteUri: workspaceFolder?.uri.toString()
+            });
         }
         await this.workspaceStateSynchronizer?.sync();
         if (!hasEdits) {
-            this.logService.info('Skipped storing working changes in the cloud as there are no edits to store.');
+            this.logService.info(
+                "Skipped storing working changes in the cloud as there are no edits to store."
+            );
             if (fromStoreCommand) {
                 this.notificationService.info(( localize(
-                    7206,
-                    'Skipped storing working changes in the cloud as there are no edits to store.'
+                    7517,
+                    "Skipped storing working changes in the cloud as there are no edits to store."
                 )));
             }
             return undefined;
         }
-        const data = { folders, version: 2, workspaceStateId: this.editSessionsStorageService.lastWrittenResources.get('workspaceState')?.ref };
+        const data = {
+            folders,
+            version: 2,
+            workspaceStateId: this.editSessionsStorageService.lastWrittenResources.get("workspaceState")?.ref
+        };
         try {
             this.logService.info(`Storing edit session...`);
-            const ref = await this.editSessionsStorageService.write('editSessions', data);
+            const ref = await this.editSessionsStorageService.write("editSessions", data);
             this.logService.info(`Stored edit session with ref ${ref}.`);
             return ref;
-        }
-        catch (ex) {
+        } catch (ex) {
             this.logService.error(`Failed to store edit session, reason: `, ( ex.toString()));
             if (ex instanceof UserDataSyncStoreError) {
                 switch (ex.code) {
-                    case UserDataSyncErrorCode.TooLarge:
-                        this.telemetryService.publicLog2('editSessions.upload.failed', { reason: 'TooLarge' });
-                        this.notificationService.error(( localize(7205, 'Your working changes exceed the size limit and cannot be stored.')));
-                        break;
-                    default:
-                        this.telemetryService.publicLog2('editSessions.upload.failed', { reason: 'unknown' });
-                        this.notificationService.error(( localize(7207, 'Your working changes cannot be stored.')));
-                        break;
+                case UserDataSyncErrorCode.TooLarge:
+                    this.telemetryService.publicLog2("editSessions.upload.failed", {
+                        reason: "TooLarge"
+                    });
+                    this.notificationService.error(( localize(7516, "Your working changes exceed the size limit and cannot be stored.")));
+                    break;
+                default:
+                    this.telemetryService.publicLog2("editSessions.upload.failed", {
+                        reason: "unknown"
+                    });
+                    this.notificationService.error(( localize(7518, "Your working changes cannot be stored.")));
+                    break;
                 }
             }
         }
@@ -688,7 +868,7 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
     }
     getChangedResources(repository) {
         return repository.provider.groups.reduce((resources, resourceGroups) => {
-            resourceGroups.resources.forEach((resource) => resources.add(resource.sourceUri));
+            resourceGroups.resources.forEach(resource => resources.add(resource.sourceUri));
             return resources;
         }, ( new Set()));
     }
@@ -704,18 +884,24 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
         if (this.editSessionsStorageService.isSignedIn) {
             return this.hasEditSession();
         }
-        if (this.configurationService.getValue(useEditSessionsWithContinueOn) === 'off') {
-            this.telemetryService.publicLog2('continueOn.editSessions.canStore.outcome', { outcome: 'disabledEditSessionsViaSetting' });
+        if (this.configurationService.getValue(useEditSessionsWithContinueOn) === "off") {
+            this.telemetryService.publicLog2("continueOn.editSessions.canStore.outcome", {
+                outcome: "disabledEditSessionsViaSetting"
+            });
             return false;
         }
         if (this.hasEditSession()) {
             const disposables = ( new DisposableStore());
             const quickpick = disposables.add(this.quickInputService.createQuickPick());
-            quickpick.placeholder = ( localize(7208, "Select whether to bring your working changes with you"));
+            quickpick.placeholder = ( localize(7519, "Select whether to bring your working changes with you"));
             quickpick.ok = false;
             quickpick.ignoreFocusOut = true;
-            const withCloudChanges = { label: ( localize(7209, "Yes, continue with my working changes")) };
-            const withoutCloudChanges = { label: ( localize(7210, "No, continue without my working changes")) };
+            const withCloudChanges = {
+                label: ( localize(7520, "Yes, continue with my working changes"))
+            };
+            const withoutCloudChanges = {
+                label: ( localize(7521, "No, continue without my working changes"))
+            };
             quickpick.items = [withCloudChanges, withoutCloudChanges];
             const continueWithCloudChanges = await ( new Promise((resolve, reject) => {
                 disposables.add(quickpick.onDidAccept(() => {
@@ -729,12 +915,16 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
                 quickpick.show();
             }));
             if (!continueWithCloudChanges) {
-                this.telemetryService.publicLog2('continueOn.editSessions.canStore.outcome', { outcome: 'didNotEnableEditSessionsWhenPrompted' });
+                this.telemetryService.publicLog2("continueOn.editSessions.canStore.outcome", {
+                    outcome: "didNotEnableEditSessionsWhenPrompted"
+                });
                 return continueWithCloudChanges;
             }
-            const initialized = await this.editSessionsStorageService.initialize('write');
+            const initialized = await this.editSessionsStorageService.initialize("write");
             if (!initialized) {
-                this.telemetryService.publicLog2('continueOn.editSessions.canStore.outcome', { outcome: 'didNotEnableEditSessionsWhenPrompted' });
+                this.telemetryService.publicLog2("continueOn.editSessions.canStore.outcome", {
+                    outcome: "didNotEnableEditSessionsWhenPrompted"
+                });
             }
             return initialized;
         }
@@ -744,7 +934,7 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
         continueEditSessionExtPoint.setHandler(extensions => {
             const continueEditSessionOptions = [];
             for (const extension of extensions) {
-                if (!isProposedApiEnabled(extension.description, 'contribEditSessions')) {
+                if (!isProposedApiEnabled(extension.description, "contribEditSessions")) {
                     continue;
                 }
                 if (!Array.isArray(extension.value)) {
@@ -756,7 +946,7 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
                         return;
                     }
                     const icon = command.icon;
-                    const title = typeof command.title === 'string' ? command.title : command.title.value;
+                    const title = typeof command.title === "string" ? command.title : command.title.value;
                     const when = ContextKeyExpr.deserialize(contribution.when);
                     continueEditSessionOptions.push(( new ContinueEditSessionItem(
                         ThemeIcon.isThemeIcon(icon) ? `$(${icon.id}) ${title}` : title,
@@ -766,7 +956,13 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
                         contribution.documentation
                     )));
                     if (contribution.qualifiedName) {
-                        this.generateStandaloneOptionCommand(command.id, contribution.qualifiedName, contribution.category ?? command.category, when, contribution.remoteGroup);
+                        this.generateStandaloneOptionCommand(
+                            command.id,
+                            contribution.qualifiedName,
+                            contribution.category ?? command.category,
+                            when,
+                            contribution.remoteGroup
+                        );
                     }
                 }
             }
@@ -776,8 +972,14 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
     generateStandaloneOptionCommand(commandId, qualifiedName, category, when, remoteGroup) {
         const command = {
             id: `${continueWorkingOnCommand.id}.${commandId}`,
-            title: { original: qualifiedName, value: qualifiedName },
-            category: typeof category === 'string' ? { original: category, value: category } : category,
+            title: {
+                original: qualifiedName,
+                value: qualifiedName
+            },
+            category: typeof category === "string" ? {
+                original: category,
+                value: category
+            } : category,
             precondition: when,
             f1: true
         };
@@ -808,7 +1010,7 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
             }
             async run(accessor) {
                 const selection = await that.fileDialogService.showOpenDialog({
-                    title: ( localize(7211, 'Select a local folder to continue working in')),
+                    title: ( localize(7522, "Select a local folder to continue working in")),
                     canSelectFolders: true,
                     canSelectMany: false,
                     canSelectFiles: false,
@@ -822,17 +1024,17 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
             }
         }));
         if (getVirtualWorkspaceLocation(this.contextService.getWorkspace()) !== undefined && isNative) {
-            this.generateStandaloneOptionCommand(openLocalFolderCommand.id, ( localize(7212, 'Continue Working in Existing Local Folder')), undefined, openLocalFolderCommand.precondition, undefined);
+            this.generateStandaloneOptionCommand(openLocalFolderCommand.id, ( localize(7523, "Continue Working in Existing Local Folder")), undefined, openLocalFolderCommand.precondition, undefined);
         }
     }
     async pickContinueEditSessionDestination() {
         const disposables = ( new DisposableStore());
-        const quickPick = disposables.add(this.quickInputService.createQuickPick({ useSeparators: true }));
-        const workspaceContext = this.contextService.getWorkbenchState() === WorkbenchState.FOLDER
-            ? this.contextService.getWorkspace().folders[0].name
-            : ( this.contextService.getWorkspace().folders.map((folder) => folder.name)).join(', ');
+        const quickPick = disposables.add(this.quickInputService.createQuickPick({
+            useSeparators: true
+        }));
+        const workspaceContext = this.contextService.getWorkbenchState() === WorkbenchState.FOLDER ? this.contextService.getWorkspace().folders[0].name : ( this.contextService.getWorkspace().folders.map(folder => folder.name)).join(", ");
         quickPick.placeholder = ( localize(
-            7213,
+            7524,
             "Select a development environment to continue working on {0} in",
             `'${workspaceContext}'`
         ));
@@ -845,22 +1047,23 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
                 disposables.dispose();
                 resolve(undefined);
             }));
-            disposables.add(quickPick.onDidAccept((e) => {
+            disposables.add(quickPick.onDidAccept(e => {
                 const selection = quickPick.activeItems[0].command;
                 if (selection === installAdditionalContinueOnOptionsCommand.id) {
                     void this.commandService.executeCommand(installAdditionalContinueOnOptionsCommand.id);
-                }
-                else {
+                } else {
                     resolve(selection);
                     quickPick.hide();
                 }
             }));
             quickPick.show();
-            disposables.add(quickPick.onDidTriggerItemButton(async (e) => {
+            disposables.add(quickPick.onDidTriggerItemButton(async e => {
                 if (e.item.documentation !== undefined) {
                     const uri = URI.isUri(e.item.documentation) ? ( URI.parse(e.item.documentation)) : await this.commandService.executeCommand(e.item.documentation);
                     if (uri) {
-                        void this.openerService.open(uri, { openExternal: true });
+                        void this.openerService.open(uri, {
+                            openExternal: true
+                        });
                     }
                 }
             }));
@@ -872,69 +1075,56 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
         try {
             const uri = await this.commandService.executeCommand(command);
             if (uri === undefined) {
-                this.telemetryService.publicLog2('continueOn.openDestination.outcome', { selection: command, outcome: 'noDestinationUri' });
-                return 'noDestinationUri';
+                this.telemetryService.publicLog2("continueOn.openDestination.outcome", {
+                    selection: command,
+                    outcome: "noDestinationUri"
+                });
+                return "noDestinationUri";
             }
             if (URI.isUri(uri)) {
-                this.telemetryService.publicLog2('continueOn.openDestination.outcome', { selection: command, outcome: 'resolvedUri' });
+                this.telemetryService.publicLog2("continueOn.openDestination.outcome", {
+                    selection: command,
+                    outcome: "resolvedUri"
+                });
                 return uri;
             }
-            this.telemetryService.publicLog2('continueOn.openDestination.outcome', { selection: command, outcome: 'invalidDestination' });
+            this.telemetryService.publicLog2("continueOn.openDestination.outcome", {
+                selection: command,
+                outcome: "invalidDestination"
+            });
             return undefined;
-        }
-        catch (ex) {
+        } catch (ex) {
             if (ex instanceof CancellationError) {
-                this.telemetryService.publicLog2('continueOn.openDestination.outcome', { selection: command, outcome: 'cancelled' });
-            }
-            else {
-                this.telemetryService.publicLog2('continueOn.openDestination.outcome', { selection: command, outcome: 'unknownError' });
+                this.telemetryService.publicLog2("continueOn.openDestination.outcome", {
+                    selection: command,
+                    outcome: "cancelled"
+                });
+            } else {
+                this.telemetryService.publicLog2("continueOn.openDestination.outcome", {
+                    selection: command,
+                    outcome: "unknownError"
+                });
             }
             return undefined;
         }
     }
     createPickItems() {
-        const items = [...this.continueEditSessionOptions].filter((option) => option.when === undefined || this.contextKeyService.contextMatchesRules(option.when));
+        const items = [...this.continueEditSessionOptions].filter(
+            option => option.when === undefined || this.contextKeyService.contextMatchesRules(option.when)
+        );
         if (getVirtualWorkspaceLocation(this.contextService.getWorkspace()) !== undefined && isNative) {
-            items.push(( new ContinueEditSessionItem('$(folder) ' + ( localize(7214, 'Open in Local Folder')), openLocalFolderCommand.id, ( localize(7215, 'Built-in')))));
+            items.push(( new ContinueEditSessionItem("$(folder) " + ( localize(7525, "Open in Local Folder")), openLocalFolderCommand.id, ( localize(7526, "Built-in")))));
         }
         const sortedItems = items.sort((item1, item2) => item1.label.localeCompare(item2.label));
-        return sortedItems.concat({ type: 'separator' }, ( new ContinueEditSessionItem(
+        return sortedItems.concat({
+            type: "separator"
+        }, ( new ContinueEditSessionItem(
             installAdditionalContinueOnOptionsCommand.title,
             installAdditionalContinueOnOptionsCommand.id
         )));
     }
 };
-EditSessionsContribution = EditSessionsContribution_1 = ( __decorate([
-    ( __param(0, IEditSessionsStorageService)),
-    ( __param(1, IFileService)),
-    ( __param(2, IProgressService)),
-    ( __param(3, IOpenerService)),
-    ( __param(4, ITelemetryService)),
-    ( __param(5, ISCMService)),
-    ( __param(6, INotificationService)),
-    ( __param(7, IDialogService)),
-    ( __param(8, IEditSessionsLogService)),
-    ( __param(9, IEnvironmentService)),
-    ( __param(10, IInstantiationService)),
-    ( __param(11, IProductService)),
-    ( __param(12, IConfigurationService)),
-    ( __param(13, IWorkspaceContextService)),
-    ( __param(14, IEditSessionIdentityService)),
-    ( __param(15, IQuickInputService)),
-    ( __param(16, ICommandService)),
-    ( __param(17, IContextKeyService)),
-    ( __param(18, IFileDialogService)),
-    ( __param(19, ILifecycleService)),
-    ( __param(20, IStorageService)),
-    ( __param(21, IActivityService)),
-    ( __param(22, IEditorService)),
-    ( __param(23, IRemoteAgentService)),
-    ( __param(24, IExtensionService)),
-    ( __param(25, IRequestService)),
-    ( __param(26, IUserDataProfilesService)),
-    ( __param(27, IUriIdentityService)),
-    ( __param(28, IWorkspaceIdentityService))
-], EditSessionsContribution));
+EditSessionsContribution = EditSessionsContribution_1 = ( __decorate([( __param(0, IEditSessionsStorageService)), ( __param(1, IFileService)), ( __param(2, IProgressService)), ( __param(3, IOpenerService)), ( __param(4, ITelemetryService)), ( __param(5, ISCMService)), ( __param(6, INotificationService)), ( __param(7, IDialogService)), ( __param(8, IEditSessionsLogService)), ( __param(9, IEnvironmentService)), ( __param(10, IInstantiationService)), ( __param(11, IProductService)), ( __param(12, IConfigurationService)), ( __param(13, IWorkspaceContextService)), ( __param(14, IEditSessionIdentityService)), ( __param(15, IQuickInputService)), ( __param(16, ICommandService)), ( __param(17, IContextKeyService)), ( __param(18, IFileDialogService)), ( __param(19, ILifecycleService)), ( __param(20, IStorageService)), ( __param(21, IActivityService)), ( __param(22, IEditorService)), ( __param(23, IRemoteAgentService)), ( __param(24, IExtensionService)), ( __param(25, IRequestService)), ( __param(26, IUserDataProfilesService)), ( __param(27, IUriIdentityService)), ( __param(28, IWorkspaceIdentityService))], EditSessionsContribution));
 const infoButtonClass = ThemeIcon.asClassName(Codicon.info);
 class ContinueEditSessionItem {
     constructor(label, command, description, when, documentation) {
@@ -945,58 +1135,58 @@ class ContinueEditSessionItem {
         this.documentation = documentation;
         if (documentation !== undefined) {
             this.buttons = [{
-                    iconClass: infoButtonClass,
-                    tooltip: ( localize(7216, 'Learn More')),
-                }];
+                iconClass: infoButtonClass,
+                tooltip: ( localize(7527, "Learn More"))
+            }];
         }
     }
 }
 const continueEditSessionExtPoint = ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'continueEditSession',
+    extensionPoint: "continueEditSession",
     jsonSchema: {
         description: ( localize(
-            7217,
-            'Contributes options for continuing the current edit session in a different environment'
+            7528,
+            "Contributes options for continuing the current edit session in a different environment"
         )),
-        type: 'array',
+        type: "array",
         items: {
-            type: 'object',
+            type: "object",
             properties: {
                 command: {
                     description: ( localize(
-                        7218,
-                        'Identifier of the command to execute. The command must be declared in the \'commands\'-section and return a URI representing a different environment where the current edit session can be continued.'
+                        7529,
+                        "Identifier of the command to execute. The command must be declared in the 'commands'-section and return a URI representing a different environment where the current edit session can be continued."
                     )),
-                    type: 'string'
+                    type: "string"
                 },
                 group: {
-                    description: ( localize(7219, 'Group into which this item belongs.')),
-                    type: 'string'
+                    description: ( localize(7530, "Group into which this item belongs.")),
+                    type: "string"
                 },
                 qualifiedName: {
                     description: ( localize(
-                        7220,
-                        'A fully qualified name for this item which is used for display in menus.'
+                        7531,
+                        "A fully qualified name for this item which is used for display in menus."
                     )),
-                    type: 'string'
+                    type: "string"
                 },
                 description: {
                     description: ( localize(
-                        7221,
+                        7532,
                         "The url, or a command that returns the url, to the option's documentation page."
                     )),
-                    type: 'string'
+                    type: "string"
                 },
                 remoteGroup: {
-                    description: ( localize(7222, 'Group into which this item belongs in the remote indicator.')),
-                    type: 'string'
+                    description: ( localize(7533, "Group into which this item belongs in the remote indicator.")),
+                    type: "string"
                 },
                 when: {
-                    description: ( localize(7223, 'Condition which must be true to show this item.')),
-                    type: 'string'
+                    description: ( localize(7534, "Condition which must be true to show this item.")),
+                    type: "string"
                 }
             },
-            required: ['command']
+            required: ["command"]
         }
     }
 });
@@ -1004,67 +1194,58 @@ const workbenchRegistry = ( Registry.as(Extensions$1.Workbench));
 workbenchRegistry.registerWorkbenchContribution(EditSessionsContribution, LifecyclePhase.Restored);
 ( Registry.as(Extensions$2.Configuration)).registerConfiguration({
     ...workbenchConfigurationNodeBase,
-    'properties': {
-        'workbench.experimental.cloudChanges.autoStore': {
-            enum: ['onShutdown', 'off'],
-            enumDescriptions: [
-                ( localize(
-                7224,
+    "properties": {
+        "workbench.experimental.cloudChanges.autoStore": {
+            enum: ["onShutdown", "off"],
+            enumDescriptions: [( localize(
+                7535,
                 "Automatically store current working changes in the cloud on window close."
-            )),
-                ( localize(7225, "Never attempt to automatically store working changes in the cloud."))
-            ],
-            'type': 'string',
-            'tags': ['experimental', 'usesOnlineServices'],
-            'default': 'off',
-            'markdownDescription': ( localize(
-                7226,
+            )), ( localize(7536, "Never attempt to automatically store working changes in the cloud."))],
+            "type": "string",
+            "tags": ["experimental", "usesOnlineServices"],
+            "default": "off",
+            "markdownDescription": ( localize(
+                7537,
                 "Controls whether to automatically store available working changes in the cloud for the current workspace. This setting has no effect in the web."
-            )),
+            ))
         },
-        'workbench.cloudChanges.autoResume': {
-            enum: ['onReload', 'off'],
-            enumDescriptions: [
-                ( localize(
-                7227,
+        "workbench.cloudChanges.autoResume": {
+            enum: ["onReload", "off"],
+            enumDescriptions: [( localize(
+                7538,
                 "Automatically resume available working changes from the cloud on window reload."
-            )),
-                ( localize(7228, "Never attempt to resume working changes from the cloud."))
-            ],
-            'type': 'string',
-            'tags': ['usesOnlineServices'],
-            'default': 'onReload',
-            'markdownDescription': ( localize(
-                7229,
+            )), ( localize(7539, "Never attempt to resume working changes from the cloud."))],
+            "type": "string",
+            "tags": ["usesOnlineServices"],
+            "default": "onReload",
+            "markdownDescription": ( localize(
+                7540,
                 "Controls whether to automatically resume available working changes stored in the cloud for the current workspace."
-            )),
-        },
-        'workbench.cloudChanges.continueOn': {
-            enum: ['prompt', 'off'],
-            enumDescriptions: [
-                ( localize(
-                7230,
-                'Prompt the user to sign in to store working changes in the cloud with Continue Working On.'
-            )),
-                ( localize(
-                7231,
-                'Do not store working changes in the cloud with Continue Working On unless the user has already turned on Cloud Changes.'
             ))
-            ],
-            type: 'string',
-            tags: ['usesOnlineServices'],
-            default: 'prompt',
+        },
+        "workbench.cloudChanges.continueOn": {
+            enum: ["prompt", "off"],
+            enumDescriptions: [( localize(
+                7541,
+                "Prompt the user to sign in to store working changes in the cloud with Continue Working On."
+            )), ( localize(
+                7542,
+                "Do not store working changes in the cloud with Continue Working On unless the user has already turned on Cloud Changes."
+            ))],
+            type: "string",
+            tags: ["usesOnlineServices"],
+            default: "prompt",
             markdownDescription: ( localize(
-                7232,
-                'Controls whether to prompt the user to store working changes in the cloud when using Continue Working On.'
+                7543,
+                "Controls whether to prompt the user to store working changes in the cloud when using Continue Working On."
             ))
         },
-        'workbench.experimental.cloudChanges.partialMatches.enabled': {
-            'type': 'boolean',
-            'tags': ['experimental', 'usesOnlineServices'],
-            'default': false,
-            'markdownDescription': ( localize(
-                7233,
+        "workbench.experimental.cloudChanges.partialMatches.enabled": {
+            "type": "boolean",
+            "tags": ["experimental", "usesOnlineServices"],
+            "default": false,
+            "markdownDescription": ( localize(
+                7544,
                 "Controls whether to surface cloud changes which partially match the current session."
             ))
         }