@codingame/monaco-vscode-edit-sessions-service-override 4.5.0 → 4.5.2

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

@@ -72,42 +72,27 @@ import { IWorkspaceIdentityService } from 'vscode/vscode/vs/workbench/services/w
 import Severity$1 from 'vscode/vscode/vs/base/common/severity';
 
 var EditSessionsContribution_1;
+const _moduleId = "vs/workbench/contrib/editSessions/browser/editSessions.contribution";
 const continueWorkingOnCommand = {
     id: '_workbench.editSessions.actions.continueEditSession',
-    title: ( localize2WithPath(
-        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-        'continue working on',
-        'Continue Working On...'
-    )),
-    precondition: ( WorkspaceFolderCountContext.notEqualsTo('0')),
+    title: ( localize2WithPath(_moduleId, 0, 'Continue Working On...')),
+    precondition: ( (WorkspaceFolderCountContext.notEqualsTo('0'))),
     f1: true
 };
 const openLocalFolderCommand = {
     id: '_workbench.editSessions.actions.continueEditSession.openLocalFolder',
-    title: ( localize2WithPath(
-        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-        'continue edit session in local folder',
-        'Open In Local Folder'
-    )),
+    title: ( localize2WithPath(_moduleId, 1, 'Open In Local Folder')),
     category: EDIT_SESSION_SYNC_CATEGORY,
-    precondition: ( ContextKeyExpr.and(( IsWebContext.toNegated()), VirtualWorkspaceContext))
+    precondition: ( (ContextKeyExpr.and( (IsWebContext.toNegated()), VirtualWorkspaceContext)))
 };
 const showOutputChannelCommand = {
     id: 'workbench.editSessions.actions.showOutputChannel',
-    title: ( localize2WithPath(
-        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-        'show log',
-        "Show Log"
-    )),
+    title: ( localize2WithPath(_moduleId, 2, "Show Log")),
     category: EDIT_SESSION_SYNC_CATEGORY
 };
 const installAdditionalContinueOnOptionsCommand = {
     id: 'workbench.action.continueOn.extensions',
-    title: ( localizeWithPath(
-        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-        'continueOn.installAdditional',
-        'Install additional development environment options'
-    )),
+    title: ( localizeWithPath(_moduleId, 3, 'Install additional development environment options')),
 };
 registerAction2(class extends Action2 {
     constructor() {
@@ -120,11 +105,7 @@ registerAction2(class extends Action2 {
         view?.search('@tag:continueOn');
     }
 });
-const resumeProgressOptionsTitle = `[${( localizeWithPath(
-    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-    'resuming working changes window',
-    'Resuming working changes...'
-))}](command:${showOutputChannelCommand.id})`;
+const resumeProgressOptionsTitle = `[${( localizeWithPath(_moduleId, 4, 'Resuming working changes...'))}](command:${showOutputChannelCommand.id})`;
 const resumeProgressOptions = {
     location: 10 ,
     type: 'syncing',
@@ -166,17 +147,25 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
         this.uriIdentityService = uriIdentityService;
         this.workspaceIdentityService = workspaceIdentityService;
         this.continueEditSessionOptions = [];
-        this.accountsMenuBadgeDisposable = this._register(( new MutableDisposable()));
-        this.registeredCommands = ( new Set());
+        this.accountsMenuBadgeDisposable = this._register(( (new MutableDisposable())));
+        this.registeredCommands = ( (new Set()));
         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) {
             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.workspaceStateSynchronizer = ( (new WorkspaceStateSynchroniser(
             this.userDataProfilesService.defaultProfile,
             undefined,
             this.editSessionsStorageClient,
@@ -189,19 +178,15 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
             this.uriIdentityService,
             this.workspaceIdentityService,
             this.editSessionsStorageService
-        ));
+        )));
         this.autoResumeEditSession();
         this.registerActions();
         this.registerViews();
         this.registerContributedEditSessionOptions();
-        this._register(this.fileService.registerProvider(EditSessionsFileSystemProvider.SCHEMA, ( new EditSessionsFileSystemProvider(this.editSessionsStorageService))));
+        this._register(this.fileService.registerProvider(EditSessionsFileSystemProvider.SCHEMA, ( (new EditSessionsFileSystemProvider(this.editSessionsStorageService)))));
         this.lifecycleService.onWillShutdown((e) => {
             if (e.reason !== 3  && this.editSessionsStorageService.isSignedIn && this.configurationService.getValue('workbench.experimental.cloudChanges.autoStore') === 'onShutdown' && !isWeb) {
-                e.join(this.autoStoreEditSession(), { id: 'autoStoreWorkingChanges', label: ( localizeWithPath(
-                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                    'autoStoreWorkingChanges',
-                    'Storing current working changes...'
-                )) });
+                e.join(this.autoStoreEditSession(), { id: 'autoStoreWorkingChanges', label: ( localizeWithPath(_moduleId, 5, 'Storing current working changes...')) });
             }
         });
         this._register(this.editSessionsStorageService.onDidSignIn(() => this.updateAccountsMenuBadge()));
@@ -259,36 +244,28 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
         if (this.editSessionsStorageService.isSignedIn) {
             return this.accountsMenuBadgeDisposable.clear();
         }
-        const badge = ( new NumberBadge(1, () => ( localizeWithPath(
-            'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-            'check for pending cloud changes',
-            'Check for pending cloud changes'
-        ))));
+        const badge = ( (new NumberBadge(1, () => ( localizeWithPath(_moduleId, 6, 'Check for pending cloud changes')))));
         this.accountsMenuBadgeDisposable.value = this.activityService.showAccountsActivity({ badge });
     }
     async autoStoreEditSession() {
-        const cancellationTokenSource = ( new CancellationTokenSource());
+        const cancellationTokenSource = ( (new CancellationTokenSource()));
         await this.progressService.withProgress({
             location: 10 ,
             type: 'syncing',
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                'store working changes',
-                'Storing working changes...'
-            ))
+            title: ( localizeWithPath(_moduleId, 7, 'Storing working changes...'))
         }, async () => this.storeEditSession(false, cancellationTokenSource.token), () => {
             cancellationTokenSource.cancel();
             cancellationTokenSource.dispose();
         });
     }
     registerViews() {
-        const container = ( Registry.as(Extensions.ViewContainersRegistry)).registerViewContainer({
+        const container = ( (Registry.as(Extensions.ViewContainersRegistry))).registerViewContainer({
             id: EDIT_SESSIONS_CONTAINER_ID,
             title: EDIT_SESSIONS_TITLE,
-            ctorDescriptor: ( new SyncDescriptor(
+            ctorDescriptor: ( (new SyncDescriptor(
                 ViewPaneContainer,
                 [EDIT_SESSIONS_CONTAINER_ID, { mergeViewWithContainerWhenSingleView: true }]
-            )),
+            ))),
             icon: EDIT_SESSIONS_VIEW_ICON,
             hideIfEmpty: true
         }, 0 , { doNotRegisterOpenCommand: true });
@@ -319,11 +296,7 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
             constructor() {
                 super({
                     id: 'workbench.editSessions.actions.showEditSessions',
-                    title: ( localize2WithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                        'show cloud changes',
-                        'Show Cloud Changes'
-                    )),
+                    title: ( localize2WithPath(_moduleId, 8, 'Show Cloud Changes')),
                     category: EDIT_SESSION_SYNC_CATEGORY,
                     f1: true
                 });
@@ -354,17 +327,13 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
                 let ref;
                 if (shouldStoreEditSession) {
                     that.telemetryService.publicLog2('continueOn.editSessions.store');
-                    const cancellationTokenSource = ( new CancellationTokenSource());
+                    const cancellationTokenSource = ( (new CancellationTokenSource()));
                     try {
                         ref = await that.progressService.withProgress({
                             location: 15 ,
                             cancellable: true,
                             type: 'syncing',
-                            title: ( localizeWithPath(
-                                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                                'store your working changes',
-                                'Storing your working changes...'
-                            ))
+                            title: ( localizeWithPath(_moduleId, 9, 'Storing your working changes...'))
                         }, async () => {
                             const ref = await that.storeEditSession(false, cancellationTokenSource.token);
                             if (ref !== undefined) {
@@ -394,11 +363,11 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
                     uri = uri.with({
                         query: uri.query.length > 0 ? (uri.query + `&${queryParamName}=${encodedRef}&continueOn=1`) : `${queryParamName}=${encodedRef}&continueOn=1`
                     });
-                    that.logService.info(`Opening ${( uri.toString())}`);
+                    that.logService.info(`Opening ${( (uri.toString()))}`);
                     await that.openerService.open(uri, { openExternal: true });
                 }
                 else if (!shouldStoreEditSession && uri !== 'noDestinationUri') {
-                    that.logService.info(`Opening ${( uri.toString())}`);
+                    that.logService.info(`Opening ${( (uri.toString()))}`);
                     await that.openerService.open(uri, { openExternal: true });
                 }
                 else if (ref === undefined && shouldStoreEditSession) {
@@ -413,11 +382,7 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
             constructor() {
                 super({
                     id: 'workbench.editSessions.actions.resumeLatest',
-                    title: ( localize2WithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                        'resume latest cloud changes',
-                        'Resume Latest Changes from Cloud'
-                    )),
+                    title: ( localize2WithPath(_moduleId, 10, 'Resume Latest Changes from Cloud')),
                     category: EDIT_SESSION_SYNC_CATEGORY,
                     f1: true,
                 });
@@ -430,11 +395,7 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
             constructor() {
                 super({
                     id: 'workbench.editSessions.actions.resumeFromSerializedPayload',
-                    title: ( localize2WithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                        'resume cloud changes',
-                        'Resume Changes from Serialized Data'
-                    )),
+                    title: ( localize2WithPath(_moduleId, 11, 'Resume Changes from Serialized Data')),
                     category: 'Developer',
                     f1: true,
                 });
@@ -454,24 +415,16 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
             constructor() {
                 super({
                     id: 'workbench.editSessions.actions.storeCurrent',
-                    title: ( localize2WithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                        'store working changes in cloud',
-                        'Store Working Changes in Cloud'
-                    )),
+                    title: ( localize2WithPath(_moduleId, 12, 'Store Working Changes in Cloud')),
                     category: EDIT_SESSION_SYNC_CATEGORY,
                     f1: true,
                 });
             }
             async run(accessor) {
-                const cancellationTokenSource = ( new CancellationTokenSource());
+                const cancellationTokenSource = ( (new CancellationTokenSource()));
                 await that.progressService.withProgress({
                     location: 15 ,
-                    title: ( localizeWithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                        'storing working changes',
-                        'Storing working changes...'
-                    ))
+                    title: ( localizeWithPath(_moduleId, 13, 'Storing working changes...'))
                 }, async () => {
                     that.telemetryService.publicLog2('editSessions.store');
                     await that.storeEditSession(true, cancellationTokenSource.token);
@@ -493,27 +446,14 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
         }
         this.telemetryService.publicLog2('editSessions.resume');
         performance.mark('code/willResumeEditSessionFromIdentifier');
-        progress?.report({ message: ( localizeWithPath(
-            'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-            'checkingForWorkingChanges',
-            'Checking for pending cloud changes...'
-        )) });
+        progress?.report({ message: ( localizeWithPath(_moduleId, 14, '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(( localizeWithPath(
-                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                    'no cloud changes',
-                    'There are no changes to resume from the cloud.'
-                )));
+                this.notificationService.info(( localizeWithPath(_moduleId, 15, 'There are no changes to resume from the cloud.')));
             }
             else if (ref !== undefined) {
-                this.notificationService.warn(( localizeWithPath(
-                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                    'no cloud changes for ref',
-                    'Could not resume changes from the cloud for ID {0}.',
-                    ref
-                )));
+                this.notificationService.warn(( localizeWithPath(_moduleId, 16, '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`);
             return;
@@ -523,8 +463,8 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
         ref = data.ref;
         if (editSession.version > EditSessionSchemaVersion) {
             this.notificationService.error(( localizeWithPath(
-                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                'client too old',
+                _moduleId,
+                17,
                 "Please upgrade to a newer version of {0} to resume your working changes from the cloud.",
                 this.productService.nameLong
             )));
@@ -541,18 +481,18 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
                     type: Severity$1.Warning,
                     message: conflictingChanges.length > 1 ?
                         ( localizeWithPath(
-                            'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                            'resume edit session warning many',
+                            _moduleId,
+                            18,
                             'Resuming your working changes from the cloud will overwrite the following {0} files. Do you want to proceed?',
                             conflictingChanges.length
                         )) :
                         ( localizeWithPath(
-                            'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                            'resume edit session warning 1',
+                            _moduleId,
+                            19,
                             '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;
@@ -573,12 +513,8 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
             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(( localizeWithPath(
-                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                'resume failed',
-                "Failed to resume your working changes from the cloud."
-            )));
+            this.logService.error('Failed to resume edit session, reason: ', ( (ex.toString())));
+            this.notificationService.error(( localizeWithPath(_moduleId, 20, "Failed to resume your working changes from the cloud.")));
         }
         performance.mark('code/didResumeEditSessionFromIdentifier');
     }
@@ -586,7 +522,7 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
         const changes = [];
         const conflictingChanges = [];
         const workspaceFolders = this.contextService.getWorkspace().folders;
-        const cancellationTokenSource = ( new CancellationTokenSource());
+        const cancellationTokenSource = ( (new CancellationTokenSource()));
         for (const folder of editSession.folders) {
             let folderRoot;
             if (folder.canonicalIdentity) {
@@ -607,14 +543,10 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
                             this.configurationService.getValue('workbench.experimental.cloudChanges.partialMatches.enabled') === true) {
                             if (!applyPartialMatch) {
                                 this.notificationService.prompt(Severity$1.Info, ( localizeWithPath(
-                                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                                    'editSessionPartialMatch',
+                                    _moduleId,
+                                    21,
                                     'You have pending working changes in the cloud for this workspace. Would you like to resume them?'
-                                )), [{ label: ( localizeWithPath(
-                                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                                    'resume',
-                                    'Resume'
-                                )), run: () => this.resumeEditSession(ref, false, undefined, true) }]);
+                                )), [{ label: ( localizeWithPath(_moduleId, 22, 'Resume')), run: () => this.resumeEditSession(ref, false, undefined, true) }]);
                             }
                             else {
                                 folderRoot = f;
@@ -631,12 +563,12 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
                 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());
+            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) {
                     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) {
@@ -650,7 +582,7 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
         return { changes, conflictingChanges };
     }
     async willChangeLocalContents(localChanges, uriWithIncomingChanges, incomingChange) {
-        if (!( localChanges.has(( uriWithIncomingChanges.toString())))) {
+        if (!( (localChanges.has( (uriWithIncomingChanges.toString()))))) {
             return false;
         }
         const { contents, type } = incomingChange;
@@ -663,7 +595,7 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
                 return await this.fileService.exists(uriWithIncomingChanges);
             }
             default:
-                throw new Error('Unhandled change type.');
+                throw ( (new Error('Unhandled change type.')));
         }
     }
     async storeEditSession(fromStoreCommand, cancellationToken) {
@@ -680,7 +612,7 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
             for (const uri of trackedUris) {
                 const workspaceFolder = this.contextService.getWorkspaceFolder(uri);
                 if (!workspaceFolder) {
-                    this.logService.info(`Skipping working change ${( uri.toString())} as no associated workspace folder was found.`);
+                    this.logService.info(`Skipping working change ${( (uri.toString()))} as no associated workspace folder was found.`);
                     continue;
                 }
                 await this.editSessionIdentityService.onWillCreateEditSessionIdentity(workspaceFolder, cancellationToken);
@@ -698,8 +630,8 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
                     editSessionSize += contents.length;
                     if (editSessionSize > this.editSessionsStorageService.SIZE_LIMIT) {
                         this.notificationService.error(( localizeWithPath(
-                            'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                            'payload too large',
+                            _moduleId,
+                            23,
                             'Your working changes exceed the size limit and cannot be stored.'
                         )));
                         return undefined;
@@ -721,8 +653,8 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
             this.logService.info('Skipped storing working changes in the cloud as there are no edits to store.');
             if (fromStoreCommand) {
                 this.notificationService.info(( localizeWithPath(
-                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                    'no working changes to store',
+                    _moduleId,
+                    24,
                     'Skipped storing working changes in the cloud as there are no edits to store.'
                 )));
             }
@@ -736,24 +668,20 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
             return ref;
         }
         catch (ex) {
-            this.logService.error(`Failed to store edit session, reason: `, ( ex.toString()));
+            this.logService.error(`Failed to store edit session, reason: `, ( (ex.toString())));
             if (ex instanceof UserDataSyncStoreError) {
                 switch (ex.code) {
                     case "TooLarge" :
                         this.telemetryService.publicLog2('editSessions.upload.failed', { reason: 'TooLarge' });
                         this.notificationService.error(( localizeWithPath(
-                            'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                            'payload too large',
+                            _moduleId,
+                            23,
                             'Your working changes exceed the size limit and cannot be stored.'
                         )));
                         break;
                     default:
                         this.telemetryService.publicLog2('editSessions.upload.failed', { reason: 'unknown' });
-                        this.notificationService.error(( localizeWithPath(
-                            'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                            'payload failed',
-                            'Your working changes cannot be stored.'
-                        )));
+                        this.notificationService.error(( localizeWithPath(_moduleId, 25, 'Your working changes cannot be stored.')));
                         break;
                 }
             }
@@ -764,7 +692,7 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
         return repository.provider.groups.reduce((resources, resourceGroups) => {
             resourceGroups.resources.forEach((resource) => resources.add(resource.sourceUri));
             return resources;
-        }, ( new Set()));
+        }, ( (new Set())));
     }
     hasEditSession() {
         for (const repository of this.scmService.repositories) {
@@ -784,35 +712,23 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
         }
         if (this.hasEditSession()) {
             const quickpick = this.quickInputService.createQuickPick();
-            quickpick.placeholder = ( localizeWithPath(
-                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                'continue with cloud changes',
-                "Select whether to bring your working changes with you"
-            ));
+            quickpick.placeholder = ( localizeWithPath(_moduleId, 26, "Select whether to bring your working changes with you"));
             quickpick.ok = false;
             quickpick.ignoreFocusOut = true;
-            const withCloudChanges = { label: ( localizeWithPath(
-                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                'with cloud changes',
-                "Yes, continue with my working changes"
-            )) };
-            const withoutCloudChanges = { label: ( localizeWithPath(
-                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                'without cloud changes',
-                "No, continue without my working changes"
-            )) };
+            const withCloudChanges = { label: ( localizeWithPath(_moduleId, 27, "Yes, continue with my working changes")) };
+            const withoutCloudChanges = { label: ( localizeWithPath(_moduleId, 28, "No, continue without my working changes")) };
             quickpick.items = [withCloudChanges, withoutCloudChanges];
-            const continueWithCloudChanges = await ( new Promise((resolve, reject) => {
+            const continueWithCloudChanges = await ( (new Promise((resolve, reject) => {
                 quickpick.onDidAccept(() => {
                     resolve(quickpick.selectedItems[0] === withCloudChanges);
                     quickpick.hide();
                 });
                 quickpick.onDidHide(() => {
-                    reject(( new CancellationError()));
+                    reject(( (new CancellationError())));
                     quickpick.hide();
                 });
                 quickpick.show();
-            }));
+            })));
             if (!continueWithCloudChanges) {
                 this.telemetryService.publicLog2('continueOn.editSessions.canStore.outcome', { outcome: 'didNotEnableEditSessionsWhenPrompted' });
                 return continueWithCloudChanges;
@@ -843,13 +759,13 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
                     const icon = command.icon;
                     const title = typeof command.title === 'string' ? command.title : command.title.value;
                     const when = ContextKeyExpr.deserialize(contribution.when);
-                    continueEditSessionOptions.push(( new ContinueEditSessionItem(
+                    continueEditSessionOptions.push(( (new ContinueEditSessionItem(
                         ThemeIcon.isThemeIcon(icon) ? `$(${icon.id}) ${title}` : title,
                         command.id,
                         command.source?.title,
                         when,
                         contribution.documentation
-                    )));
+                    ))));
                     if (contribution.qualifiedName) {
                         this.generateStandaloneOptionCommand(command.id, contribution.qualifiedName, contribution.category ?? command.category, when, contribution.remoteGroup);
                     }
@@ -866,7 +782,7 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
             precondition: when,
             f1: true
         };
-        if (!( this.registeredCommands.has(command.id))) {
+        if (!( (this.registeredCommands.has(command.id)))) {
             this.registeredCommands.add(command.id);
             this._register(registerAction2(class StandaloneContinueOnOption extends Action2 {
                 constructor() {
@@ -893,39 +809,31 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
             }
             async run(accessor) {
                 const selection = await that.fileDialogService.showOpenDialog({
-                    title: ( localizeWithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                        'continueEditSession.openLocalFolder.title.v2',
-                        'Select a local folder to continue working in'
-                    )),
+                    title: ( localizeWithPath(_moduleId, 29, 'Select a local folder to continue working in')),
                     canSelectFolders: true,
                     canSelectMany: false,
                     canSelectFiles: false,
                     availableFileSystems: [Schemas.file]
                 });
-                return selection?.length !== 1 ? undefined : ( URI.from({
+                return selection?.length !== 1 ? undefined : ( (URI.from({
                     scheme: that.productService.urlProtocol,
                     authority: Schemas.file,
                     path: selection[0].path
-                }));
+                })));
             }
         }));
         if (getVirtualWorkspaceLocation(this.contextService.getWorkspace()) !== undefined && isNative) {
-            this.generateStandaloneOptionCommand(openLocalFolderCommand.id, ( localizeWithPath(
-                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                'continueWorkingOn.existingLocalFolder',
-                'Continue Working in Existing Local Folder'
-            )), undefined, openLocalFolderCommand.precondition, undefined);
+            this.generateStandaloneOptionCommand(openLocalFolderCommand.id, ( localizeWithPath(_moduleId, 30, 'Continue Working in Existing Local Folder')), undefined, openLocalFolderCommand.precondition, undefined);
         }
     }
     async pickContinueEditSessionDestination() {
         const quickPick = this.quickInputService.createQuickPick();
         const workspaceContext = this.contextService.getWorkbenchState() === 2
             ? this.contextService.getWorkspace().folders[0].name
-            : ( this.contextService.getWorkspace().folders.map((folder) => folder.name)).join(', ');
+            : ( (this.contextService.getWorkspace().folders.map((folder) => folder.name))).join(', ');
         quickPick.placeholder = ( localizeWithPath(
-            'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-            'continueEditSessionPick.title.v2',
+            _moduleId,
+            31,
             "Select a development environment to continue working on {0} in",
             `'${workspaceContext}'`
         ));
@@ -933,7 +841,7 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
         this.extensionService.onDidChangeExtensions(() => {
             quickPick.items = this.createPickItems();
         });
-        const command = await ( new Promise((resolve, reject) => {
+        const command = await ( (new Promise((resolve, reject) => {
             quickPick.onDidHide(() => resolve(undefined));
             quickPick.onDidAccept((e) => {
                 const selection = quickPick.activeItems[0].command;
@@ -948,11 +856,11 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
             quickPick.show();
             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);
+                    const uri = URI.isUri(e.item.documentation) ? ( (URI.parse(e.item.documentation))) : await this.commandService.executeCommand(e.item.documentation);
                     void this.openerService.open(uri, { openExternal: true });
                 }
             });
-        }));
+        })));
         quickPick.dispose();
         return command;
     }
@@ -983,54 +891,46 @@ let EditSessionsContribution = class EditSessionsContribution extends Disposable
     createPickItems() {
         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) ' + ( localizeWithPath(
-                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                'continueEditSessionItem.openInLocalFolder.v2',
-                'Open in Local Folder'
-            )), openLocalFolderCommand.id, ( localizeWithPath(
-                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                'continueEditSessionItem.builtin',
-                'Built-in'
-            )))));
+            items.push(( (new ContinueEditSessionItem('$(folder) ' + ( localizeWithPath(_moduleId, 32, 'Open in Local Folder')), openLocalFolderCommand.id, ( localizeWithPath(_moduleId, 33, '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) {
@@ -1042,11 +942,7 @@ class ContinueEditSessionItem {
         if (documentation !== undefined) {
             this.buttons = [{
                     iconClass: infoButtonClass,
-                    tooltip: ( localizeWithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                        'learnMoreTooltip',
-                        'Learn More'
-                    )),
+                    tooltip: ( localizeWithPath(_moduleId, 34, 'Learn More')),
                 }];
         }
     }
@@ -1055,8 +951,8 @@ const continueEditSessionExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'continueEditSession',
     jsonSchema: {
         description: ( localizeWithPath(
-            'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-            'continueEditSessionExtPoint',
+            _moduleId,
+            35,
             'Contributes options for continuing the current edit session in a different environment'
         )),
         type: 'array',
@@ -1065,50 +961,42 @@ const continueEditSessionExtPoint = ExtensionsRegistry.registerExtensionPoint({
             properties: {
                 command: {
                     description: ( localizeWithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                        'continueEditSessionExtPoint.command',
+                        _moduleId,
+                        36,
                         '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'
                 },
                 group: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                        'continueEditSessionExtPoint.group',
-                        'Group into which this item belongs.'
-                    )),
+                    description: ( localizeWithPath(_moduleId, 37, 'Group into which this item belongs.')),
                     type: 'string'
                 },
                 qualifiedName: {
                     description: ( localizeWithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                        'continueEditSessionExtPoint.qualifiedName',
+                        _moduleId,
+                        38,
                         'A fully qualified name for this item which is used for display in menus.'
                     )),
                     type: 'string'
                 },
                 description: {
                     description: ( localizeWithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                        'continueEditSessionExtPoint.description',
+                        _moduleId,
+                        39,
                         "The url, or a command that returns the url, to the option's documentation page."
                     )),
                     type: 'string'
                 },
                 remoteGroup: {
                     description: ( localizeWithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                        'continueEditSessionExtPoint.remoteGroup',
+                        _moduleId,
+                        40,
                         'Group into which this item belongs in the remote indicator.'
                     )),
                     type: 'string'
                 },
                 when: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                        'continueEditSessionExtPoint.when',
-                        'Condition which must be true to show this item.'
-                    )),
+                    description: ( localizeWithPath(_moduleId, 41, 'Condition which must be true to show this item.')),
                     type: 'string'
                 }
             },
@@ -1116,22 +1004,22 @@ const continueEditSessionExtPoint = ExtensionsRegistry.registerExtensionPoint({
         }
     }
 });
-const workbenchRegistry = ( Registry.as(Extensions$1.Workbench));
+const workbenchRegistry = ( (Registry.as(Extensions$1.Workbench)));
 workbenchRegistry.registerWorkbenchContribution(EditSessionsContribution, 3 );
-( Registry.as(Extensions$2.Configuration)).registerConfiguration({
+( (Registry.as(Extensions$2.Configuration))).registerConfiguration({
     ...workbenchConfigurationNodeBase,
     'properties': {
         'workbench.experimental.cloudChanges.autoStore': {
             enum: ['onShutdown', 'off'],
             enumDescriptions: [
                 ( localizeWithPath(
-                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                    'autoStoreWorkingChanges.onShutdown',
+                    _moduleId,
+                    42,
                     "Automatically store current working changes in the cloud on window close."
                 )),
                 ( localizeWithPath(
-                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                    'autoStoreWorkingChanges.off',
+                    _moduleId,
+                    43,
                     "Never attempt to automatically store working changes in the cloud."
                 ))
             ],
@@ -1139,8 +1027,8 @@ workbenchRegistry.registerWorkbenchContribution(EditSessionsContribution, 3 );
             'tags': ['experimental', 'usesOnlineServices'],
             'default': 'off',
             'markdownDescription': ( localizeWithPath(
-                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                'autoStoreWorkingChangesDescription',
+                _moduleId,
+                44,
                 "Controls whether to automatically store available working changes in the cloud for the current workspace. This setting has no effect in the web."
             )),
         },
@@ -1148,22 +1036,18 @@ workbenchRegistry.registerWorkbenchContribution(EditSessionsContribution, 3 );
             enum: ['onReload', 'off'],
             enumDescriptions: [
                 ( localizeWithPath(
-                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                    'autoResumeWorkingChanges.onReload',
+                    _moduleId,
+                    45,
                     "Automatically resume available working changes from the cloud on window reload."
                 )),
-                ( localizeWithPath(
-                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                    'autoResumeWorkingChanges.off',
-                    "Never attempt to resume working changes from the cloud."
-                ))
+                ( localizeWithPath(_moduleId, 46, "Never attempt to resume working changes from the cloud."))
             ],
             'type': 'string',
             'tags': ['usesOnlineServices'],
             'default': 'onReload',
             'markdownDescription': ( localizeWithPath(
-                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                'autoResumeWorkingChanges',
+                _moduleId,
+                47,
                 "Controls whether to automatically resume available working changes stored in the cloud for the current workspace."
             )),
         },
@@ -1171,13 +1055,13 @@ workbenchRegistry.registerWorkbenchContribution(EditSessionsContribution, 3 );
             enum: ['prompt', 'off'],
             enumDescriptions: [
                 ( localizeWithPath(
-                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                    'continueOnCloudChanges.promptForAuth',
+                    _moduleId,
+                    48,
                     'Prompt the user to sign in to store working changes in the cloud with Continue Working On.'
                 )),
                 ( localizeWithPath(
-                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                    'continueOnCloudChanges.off',
+                    _moduleId,
+                    49,
                     'Do not store working changes in the cloud with Continue Working On unless the user has already turned on Cloud Changes.'
                 ))
             ],
@@ -1185,8 +1069,8 @@ workbenchRegistry.registerWorkbenchContribution(EditSessionsContribution, 3 );
             tags: ['usesOnlineServices'],
             default: 'prompt',
             markdownDescription: ( localizeWithPath(
-                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                'continueOnCloudChanges',
+                _moduleId,
+                50,
                 'Controls whether to prompt the user to store working changes in the cloud when using Continue Working On.'
             ))
         },
@@ -1195,8 +1079,8 @@ workbenchRegistry.registerWorkbenchContribution(EditSessionsContribution, 3 );
             'tags': ['experimental', 'usesOnlineServices'],
             'default': false,
             'markdownDescription': ( localizeWithPath(
-                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                'cloudChangesPartialMatchesEnabled',
+                _moduleId,
+                51,
                 "Controls whether to surface cloud changes which partially match the current session."
             ))
         }