@codingame/monaco-vscode-api 4.1.0 → 4.1.1

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

@@ -1,1197 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable, MutableDisposable } from '../../../../base/common/lifecycle.js';
-import { Extensions as Extensions$2 } from '../../../common/contributions.js';
-import { Registry } from '../../../../platform/registry/common/platform.js';
-import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';
-import { registerAction2, MenuRegistry, MenuId, Action2 } from '../../../../platform/actions/common/actions.js';
-import { localizeWithPath, localize2WithPath } from '../../../../nls.js';
-import { EDIT_SESSIONS_SHOW_VIEW, EDIT_SESSIONS_PENDING, EDIT_SESSIONS_CONTAINER_ID, EDIT_SESSIONS_TITLE, EDIT_SESSIONS_VIEW_ICON, EditSessionSchemaVersion, hashedEditSessionId, ChangeType, decodeEditSessionFileContent, EDIT_SESSION_SYNC_CATEGORY, FileType, editSessionsLogId, EDIT_SESSIONS_DATA_VIEW_ID, IEditSessionsStorageService, IEditSessionsLogService } from '../common/editSessions.js';
-import { ISCMService } from '../../scm/common/scm.js';
-import { IFileService } from '../../../../platform/files/common/files.js';
-import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
-import { URI } from '../../../../base/common/uri.js';
-import { basename, joinPath, relativePath } from '../../../../base/common/resources.js';
-import { encodeBase64 } from '../../../../base/common/buffer.js';
-import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
-import { IProgressService } from '../../../../platform/progress/common/progress.js';
-import './editSessionsStorageService.js';
-import { SyncDescriptor } from '../../../../platform/instantiation/common/descriptors.js';
-import { UserDataSyncStoreError } from '../../../../platform/userDataSync/common/userDataSync.js';
-import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
-import { Severity, INotificationService } from '../../../../platform/notification/common/notification.js';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { IProductService } from '../../../../platform/product/common/productService.js';
-import { IOpenerService } from '../../../../platform/opener/common/opener.js';
-import { IEnvironmentService } from '../../../../platform/environment/common/environment.js';
-import { workbenchConfigurationNodeBase } from '../../../common/configuration.js';
-import { Extensions as Extensions$1 } from '../../../../platform/configuration/common/configurationRegistry.js';
-import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
-import { ExtensionsRegistry } from '../../../services/extensions/common/extensionsRegistry.js';
-import { ContextKeyExpr, IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
-import { ICommandService } from '../../../../platform/commands/common/commands.js';
-import { getVirtualWorkspaceLocation } from '../../../../platform/workspace/common/virtualWorkspace.js';
-import { Schemas } from '../../../../base/common/network.js';
-import { IsWebContext } from '../../../../platform/contextkey/common/contextkeys.js';
-import { isProposedApiEnabled, IExtensionService } from '../../../services/extensions/common/extensions.js';
-import '../common/editSessionsLogService.js';
-import { Extensions } from '../../../common/views.js';
-import { IViewsService } from '../../../services/views/common/viewsService.js';
-import { ViewPaneContainer } from '../../../browser/parts/views/viewPaneContainer.js';
-import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-import { EditSessionsDataViews } from './editSessionsViews.js';
-import { EditSessionsFileSystemProvider } from './editSessionsFileSystemProvider.js';
-import { isWeb, isNative } from '../../../../base/common/platform.js';
-import { VirtualWorkspaceContext, WorkspaceFolderCountContext } from '../../../common/contextkeys.js';
-import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
-import { equals } from '../../../../base/common/objects.js';
-import { EditSessionIdentityMatch, IEditSessionIdentityService } from '../../../../platform/workspace/common/editSessions.js';
-import { ThemeIcon } from '../../../../base/common/themables.js';
-import { IOutputService } from '../../../services/output/common/output.js';
-import { sha1Hex } from '../../../../base/browser/hash.js';
-import { IStorageService } from '../../../../platform/storage/common/storage.js';
-import { NumberBadge, IActivityService } from '../../../services/activity/common/activity.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-import { Codicon } from '../../../../base/common/codicons.js';
-import { CancellationError } from '../../../../base/common/errors.js';
-import { IRemoteAgentService } from '../../../services/remote/common/remoteAgentService.js';
-import { VIEWLET_ID } from '../../extensions/common/extensions.js';
-import { IPaneCompositePartService } from '../../../services/panecomposite/browser/panecomposite.js';
-import { WorkspaceStateSynchroniser } from '../common/workspaceStateSync.js';
-import { IUserDataProfilesService } from '../../../../platform/userDataProfile/common/userDataProfile.js';
-import { IRequestService } from '../../../../platform/request/common/request.js';
-import { EditSessionsStoreClient } from '../common/editSessionsStorageClient.js';
-import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
-import { IWorkspaceIdentityService } from '../../../services/workspaces/common/workspaceIdentityService.js';
-import { getFileNamesMessage, IDialogService, IFileDialogService } from '../../../../platform/dialogs/common/dialogs.js';
-var EditSessionsContribution_1;
-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')),
-    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'
-    )),
-    category: EDIT_SESSION_SYNC_CATEGORY,
-    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"
-    )),
-    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'
-    )),
-};
-registerAction2(class extends Action2 {
-    constructor() {
-        super({ ...installAdditionalContinueOnOptionsCommand, f1: false });
-    }
-    async run(accessor) {
-        const paneCompositePartService = accessor.get(IPaneCompositePartService);
-        const viewlet = await paneCompositePartService.openPaneComposite(VIEWLET_ID, 0 , true);
-        const view = viewlet?.getViewPaneContainer();
-        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 resumeProgressOptions = {
-    location: 10 ,
-    type: 'syncing',
-};
-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) {
-        super();
-        this.editSessionsStorageService = editSessionsStorageService;
-        this.fileService = fileService;
-        this.progressService = progressService;
-        this.openerService = openerService;
-        this.telemetryService = telemetryService;
-        this.scmService = scmService;
-        this.notificationService = notificationService;
-        this.dialogService = dialogService;
-        this.logService = logService;
-        this.environmentService = environmentService;
-        this.instantiationService = instantiationService;
-        this.productService = productService;
-        this.configurationService = configurationService;
-        this.contextService = contextService;
-        this.editSessionIdentityService = editSessionIdentityService;
-        this.quickInputService = quickInputService;
-        this.commandService = commandService;
-        this.contextKeyService = contextKeyService;
-        this.fileDialogService = fileDialogService;
-        this.lifecycleService = lifecycleService;
-        this.storageService = storageService;
-        this.activityService = activityService;
-        this.editorService = editorService;
-        this.remoteAgentService = remoteAgentService;
-        this.extensionService = extensionService;
-        this.requestService = requestService;
-        this.userDataProfilesService = userDataProfilesService;
-        this.uriIdentityService = uriIdentityService;
-        this.workspaceIdentityService = workspaceIdentityService;
-        this.continueEditSessionOptions = [];
-        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.editSessionsStorageService.storeClient = this.editSessionsStorageClient;
-        this.workspaceStateSynchronizer = ( new WorkspaceStateSynchroniser(
-            this.userDataProfilesService.defaultProfile,
-            undefined,
-            this.editSessionsStorageClient,
-            this.logService,
-            this.fileService,
-            this.environmentService,
-            this.telemetryService,
-            this.configurationService,
-            this.storageService,
-            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.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...'
-                )) });
-            }
-        });
-        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';
-        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, -1 , 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.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, -1 );
-                    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, -1 , 1 );
-                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 {
-                    handlePendingEditSessions();
-                }
-            }
-            else if (!this.editSessionsStorageService.isSignedIn &&
-                hasApplicationLaunchedFromContinueOnFlow === true) {
-                handlePendingEditSessions();
-            }
-        }
-        else {
-            this.logService.debug('Auto resuming cloud changes disabled.');
-        }
-    }
-    updateAccountsMenuBadge() {
-        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'
-        ))));
-        this.accountsMenuBadgeDisposable.value = this.activityService.showAccountsActivity({ badge });
-    }
-    async autoStoreEditSession() {
-        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...'
-            ))
-        }, async () => this.storeEditSession(false, cancellationTokenSource.token), () => {
-            cancellationTokenSource.cancel();
-            cancellationTokenSource.dispose();
-        });
-    }
-    registerViews() {
-        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 }]
-            )),
-            icon: EDIT_SESSIONS_VIEW_ICON,
-            hideIfEmpty: true
-        }, 0 , { doNotRegisterOpenCommand: true });
-        this._register(this.instantiationService.createInstance(EditSessionsDataViews, container));
-    }
-    registerActions() {
-        this.registerContinueEditSessionAction();
-        this.registerResumeLatestEditSessionAction();
-        this.registerStoreLatestEditSessionAction();
-        this.registerContinueInLocalFolderAction();
-        this.registerShowEditSessionViewAction();
-        this.registerShowEditSessionOutputChannelAction();
-    }
-    registerShowEditSessionOutputChannelAction() {
-        this._register(registerAction2(class ShowEditSessionOutput extends Action2 {
-            constructor() {
-                super(showOutputChannelCommand);
-            }
-            run(accessor, ...args) {
-                const outputChannel = accessor.get(IOutputService);
-                void outputChannel.showChannel(editSessionsLogId);
-            }
-        }));
-    }
-    registerShowEditSessionViewAction() {
-        const that = this;
-        this._register(registerAction2(class ShowEditSessionView extends Action2 {
-            constructor() {
-                super({
-                    id: 'workbench.editSessions.actions.showEditSessions',
-                    title: ( localize2WithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                        'show cloud changes',
-                        'Show Cloud Changes'
-                    )),
-                    category: EDIT_SESSION_SYNC_CATEGORY,
-                    f1: true
-                });
-            }
-            async run(accessor) {
-                that.shouldShowViewsContext.set(true);
-                const viewsService = accessor.get(IViewsService);
-                await viewsService.openView(EDIT_SESSIONS_DATA_VIEW_ID);
-            }
-        }));
-    }
-    registerContinueEditSessionAction() {
-        const that = this;
-        this._register(registerAction2(class ContinueEditSessionAction extends Action2 {
-            constructor() {
-                super(continueWorkingOnCommand);
-            }
-            async run(accessor, workspaceUri, destination) {
-                let uri = workspaceUri;
-                if (!destination && !uri) {
-                    destination = await that.pickContinueEditSessionDestination();
-                    if (!destination) {
-                        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');
-                    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...'
-                            ))
-                        }, 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' });
-                            }
-                            return ref;
-                        }, () => {
-                            cancellationTokenSource.cancel();
-                            cancellationTokenSource.dispose();
-                            that.telemetryService.publicLog2('continueOn.editSessions.store.outcome', { outcome: 'storeCancelledByUser' });
-                        });
-                    }
-                    catch (ex) {
-                        that.telemetryService.publicLog2('continueOn.editSessions.store.outcome', { outcome: 'storeFailed' });
-                        throw ex;
-                    }
-                }
-                uri = destination ? await that.resolveDestination(destination) : uri;
-                if (uri === undefined) {
-                    return;
-                }
-                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 && 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}.`);
-                }
-            }
-        }));
-    }
-    registerResumeLatestEditSessionAction() {
-        const that = this;
-        this._register(registerAction2(class ResumeLatestEditSessionAction extends Action2 {
-            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'
-                    )),
-                    category: EDIT_SESSION_SYNC_CATEGORY,
-                    f1: true,
-                });
-            }
-            async run(accessor, editSessionId, 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: ( localize2WithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                        'resume cloud changes',
-                        'Resume Changes from Serialized Data'
-                    )),
-                    category: 'Developer',
-                    f1: true,
-                });
-            }
-            async run(accessor, editSessionId) {
-                const data = await that.quickInputService.input({ prompt: 'Enter serialized data' });
-                if (data) {
-                    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));
-            }
-        }));
-    }
-    registerStoreLatestEditSessionAction() {
-        const that = this;
-        this._register(registerAction2(class StoreLatestEditSessionAction extends Action2 {
-            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'
-                    )),
-                    category: EDIT_SESSION_SYNC_CATEGORY,
-                    f1: true,
-                });
-            }
-            async run(accessor) {
-                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...'
-                    ))
-                }, async () => {
-                    that.telemetryService.publicLog2('editSessions.store');
-                    await that.storeEditSession(true, cancellationTokenSource.token);
-                }, () => {
-                    cancellationTokenSource.cancel();
-                    cancellationTokenSource.dispose();
-                });
-            }
-        }));
-    }
-    async resumeEditSession(ref, silent, forceApplyUnrelatedChange, applyPartialMatch, progress, serializedData) {
-        await this.remoteAgentService.getEnvironment();
-        if (this.contextService.getWorkbenchState() === 1 ) {
-            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))) {
-            return;
-        }
-        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...'
-        )) });
-        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.'
-                )));
-            }
-            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.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 });
-        const editSession = JSON.parse(data.content);
-        ref = data.ref;
-        if (editSession.version > EditSessionSchemaVersion) {
-            this.notificationService.error(( localizeWithPath(
-                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                'client too old',
-                "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' });
-            return;
-        }
-        try {
-            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({
-                    type: Severity.Warning,
-                    message: conflictingChanges.length > 1 ?
-                        ( localizeWithPath(
-                            'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                            'resume edit session warning many',
-                            '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',
-                            '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
-                });
-                if (!confirmed) {
-                    return;
-                }
-            }
-            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))) {
-                    await this.fileService.del(uri);
-                }
-            }
-            await this.workspaceStateSynchronizer?.apply(false, {});
-            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' });
-        }
-        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."
-            )));
-        }
-        performance.mark('code/didResumeEditSessionFromIdentifier');
-    }
-    async generateChanges(editSession, ref, forceApplyUnrelatedChange = false, applyPartialMatch = false) {
-        const changes = [];
-        const conflictingChanges = [];
-        const workspaceFolders = this.contextService.getWorkspace().folders;
-        const cancellationTokenSource = ( new CancellationTokenSource());
-        for (const folder of editSession.folders) {
-            let folderRoot;
-            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}...`);
-                    if (equals(identity, folder.canonicalIdentity) || forceApplyUnrelatedChange) {
-                        folderRoot = f;
-                        break;
-                    }
-                    if (identity !== undefined) {
-                        const match = await this.editSessionIdentityService.provideEditSessionIdentityMatch(f, identity, folder.canonicalIdentity, cancellationTokenSource.token);
-                        if (match === EditSessionIdentityMatch.Complete) {
-                            folderRoot = f;
-                            break;
-                        }
-                        else if (match === EditSessionIdentityMatch.Partial &&
-                            this.configurationService.getValue('workbench.experimental.cloudChanges.partialMatches.enabled') === true) {
-                            if (!applyPartialMatch) {
-                                this.notificationService.prompt(Severity.Info, ( localizeWithPath(
-                                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                                    'editSessionPartialMatch',
-                                    '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) }]);
-                            }
-                            else {
-                                folderRoot = f;
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-            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: [] };
-            }
-            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())));
-                }
-            }
-            for (const change of folder.workingChanges) {
-                const uri = joinPath(folderRoot.uri, change.relativeFilePath);
-                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 });
-                }
-            }
-        }
-        return { changes, conflictingChanges };
-    }
-    async willChangeLocalContents(localChanges, uriWithIncomingChanges, incomingChange) {
-        if (!( localChanges.has(( uriWithIncomingChanges.toString())))) {
-            return false;
-        }
-        const { contents, type } = incomingChange;
-        switch (type) {
-            case (ChangeType.Addition): {
-                const [originalContents, incomingContents] = await Promise.all([sha1Hex(contents), sha1Hex(encodeBase64((await this.fileService.readFile(uriWithIncomingChanges)).value))]);
-                return originalContents !== incomingContents;
-            }
-            case (ChangeType.Deletion): {
-                return await this.fileService.exists(uriWithIncomingChanges);
-            }
-            default:
-                throw new Error('Unhandled change type.');
-        }
-    }
-    async storeEditSession(fromStoreCommand, cancellationToken) {
-        const folders = [];
-        let editSessionSize = 0;
-        let hasEdits = false;
-        await this.editorService.saveAll();
-        for (const repository of this.scmService.repositories) {
-            const trackedUris = this.getChangedResources(repository);
-            const workingChanges = [];
-            const { rootUri } = repository.provider;
-            const workspaceFolder = rootUri ? this.contextService.getWorkspaceFolder(rootUri) : undefined;
-            let name = workspaceFolder?.name;
-            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.`);
-                    continue;
-                }
-                await this.editSessionIdentityService.onWillCreateEditSessionIdentity(workspaceFolder, cancellationToken);
-                name = name ?? workspaceFolder.name;
-                const relativeFilePath = relativePath(workspaceFolder.uri, uri) ?? uri.path;
-                try {
-                    if (!(await this.fileService.stat(uri)).isFile) {
-                        continue;
-                    }
-                }
-                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(( localizeWithPath(
-                            'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                            'payload too large',
-                            '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 });
-                }
-            }
-            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() });
-        }
-        await this.workspaceStateSynchronizer?.sync(null, {});
-        if (!hasEdits) {
-            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',
-                    '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 };
-        try {
-            this.logService.info(`Storing edit session...`);
-            const ref = await this.editSessionsStorageService.write('editSessions', data);
-            this.logService.info(`Stored edit session with ref ${ref}.`);
-            return ref;
-        }
-        catch (ex) {
-            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',
-                            '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.'
-                        )));
-                        break;
-                }
-            }
-        }
-        return undefined;
-    }
-    getChangedResources(repository) {
-        return repository.provider.groups.reduce((resources, resourceGroups) => {
-            resourceGroups.resources.forEach((resource) => resources.add(resource.sourceUri));
-            return resources;
-        }, ( new Set()));
-    }
-    hasEditSession() {
-        for (const repository of this.scmService.repositories) {
-            if (this.getChangedResources(repository).size > 0) {
-                return true;
-            }
-        }
-        return false;
-    }
-    async shouldContinueOnWithEditSession() {
-        if (this.editSessionsStorageService.isSignedIn) {
-            return this.hasEditSession();
-        }
-        if (this.configurationService.getValue(useEditSessionsWithContinueOn) === 'off') {
-            this.telemetryService.publicLog2('continueOn.editSessions.canStore.outcome', { outcome: 'disabledEditSessionsViaSetting' });
-            return false;
-        }
-        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.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"
-            )) };
-            quickpick.items = [withCloudChanges, withoutCloudChanges];
-            const continueWithCloudChanges = await ( new Promise((resolve, reject) => {
-                quickpick.onDidAccept(() => {
-                    resolve(quickpick.selectedItems[0] === withCloudChanges);
-                    quickpick.hide();
-                });
-                quickpick.onDidHide(() => {
-                    reject(( new CancellationError()));
-                    quickpick.hide();
-                });
-                quickpick.show();
-            }));
-            if (!continueWithCloudChanges) {
-                this.telemetryService.publicLog2('continueOn.editSessions.canStore.outcome', { outcome: 'didNotEnableEditSessionsWhenPrompted' });
-                return continueWithCloudChanges;
-            }
-            const initialized = await this.editSessionsStorageService.initialize('write');
-            if (!initialized) {
-                this.telemetryService.publicLog2('continueOn.editSessions.canStore.outcome', { outcome: 'didNotEnableEditSessionsWhenPrompted' });
-            }
-            return initialized;
-        }
-        return false;
-    }
-    registerContributedEditSessionOptions() {
-        continueEditSessionExtPoint.setHandler(extensions => {
-            const continueEditSessionOptions = [];
-            for (const extension of extensions) {
-                if (!isProposedApiEnabled(extension.description, 'contribEditSessions')) {
-                    continue;
-                }
-                if (!Array.isArray(extension.value)) {
-                    continue;
-                }
-                for (const contribution of extension.value) {
-                    const command = MenuRegistry.getCommand(contribution.command);
-                    if (!command) {
-                        return;
-                    }
-                    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(
-                        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);
-                    }
-                }
-            }
-            this.continueEditSessionOptions = continueEditSessionOptions;
-        });
-    }
-    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,
-            precondition: when,
-            f1: true
-        };
-        if (!( this.registeredCommands.has(command.id))) {
-            this.registeredCommands.add(command.id);
-            this._register(registerAction2(class StandaloneContinueOnOption extends Action2 {
-                constructor() {
-                    super(command);
-                }
-                async run(accessor) {
-                    return accessor.get(ICommandService).executeCommand(continueWorkingOnCommand.id, undefined, commandId);
-                }
-            }));
-            if (remoteGroup !== undefined) {
-                MenuRegistry.appendMenuItem(MenuId.StatusBarRemoteIndicatorMenu, {
-                    group: remoteGroup,
-                    command: command,
-                    when: command.precondition
-                });
-            }
-        }
-    }
-    registerContinueInLocalFolderAction() {
-        const that = this;
-        this._register(registerAction2(class ContinueInLocalFolderAction extends Action2 {
-            constructor() {
-                super(openLocalFolderCommand);
-            }
-            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'
-                    )),
-                    canSelectFolders: true,
-                    canSelectMany: false,
-                    canSelectFiles: false,
-                    availableFileSystems: [Schemas.file]
-                });
-                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);
-        }
-    }
-    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(', ');
-        quickPick.placeholder = ( localizeWithPath(
-            'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-            'continueEditSessionPick.title.v2',
-            "Select a development environment to continue working on {0} in",
-            `'${workspaceContext}'`
-        ));
-        quickPick.items = this.createPickItems();
-        this.extensionService.onDidChangeExtensions(() => {
-            quickPick.items = this.createPickItems();
-        });
-        const command = await ( new Promise((resolve, reject) => {
-            quickPick.onDidHide(() => resolve(undefined));
-            quickPick.onDidAccept((e) => {
-                const selection = quickPick.activeItems[0].command;
-                if (selection === installAdditionalContinueOnOptionsCommand.id) {
-                    void this.commandService.executeCommand(installAdditionalContinueOnOptionsCommand.id);
-                }
-                else {
-                    resolve(selection);
-                    quickPick.hide();
-                }
-            });
-            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);
-                    void this.openerService.open(uri, { openExternal: true });
-                }
-            });
-        }));
-        quickPick.dispose();
-        return command;
-    }
-    async resolveDestination(command) {
-        try {
-            const uri = await this.commandService.executeCommand(command);
-            if (uri === undefined) {
-                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' });
-                return uri;
-            }
-            this.telemetryService.publicLog2('continueOn.openDestination.outcome', { selection: command, outcome: 'invalidDestination' });
-            return undefined;
-        }
-        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' });
-            }
-            return undefined;
-        }
-    }
-    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'
-            )))));
-        }
-        const sortedItems = items.sort((item1, item2) => item1.label.localeCompare(item2.label));
-        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));
-const infoButtonClass = ThemeIcon.asClassName(Codicon.info);
-class ContinueEditSessionItem {
-    constructor(label, command, description, when, documentation) {
-        this.label = label;
-        this.command = command;
-        this.description = description;
-        this.when = when;
-        this.documentation = documentation;
-        if (documentation !== undefined) {
-            this.buttons = [{
-                    iconClass: infoButtonClass,
-                    tooltip: ( localizeWithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                        'learnMoreTooltip',
-                        'Learn More'
-                    )),
-                }];
-        }
-    }
-}
-const continueEditSessionExtPoint = ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'continueEditSession',
-    jsonSchema: {
-        description: ( localizeWithPath(
-            'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-            'continueEditSessionExtPoint',
-            'Contributes options for continuing the current edit session in a different environment'
-        )),
-        type: 'array',
-        items: {
-            type: 'object',
-            properties: {
-                command: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                        'continueEditSessionExtPoint.command',
-                        '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.'
-                    )),
-                    type: 'string'
-                },
-                qualifiedName: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                        'continueEditSessionExtPoint.qualifiedName',
-                        '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',
-                        "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',
-                        '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.'
-                    )),
-                    type: 'string'
-                }
-            },
-            required: ['command']
-        }
-    }
-});
-const workbenchRegistry = ( Registry.as(Extensions$2.Workbench));
-workbenchRegistry.registerWorkbenchContribution(EditSessionsContribution, 3 );
-( Registry.as(Extensions$1.Configuration)).registerConfiguration({
-    ...workbenchConfigurationNodeBase,
-    'properties': {
-        'workbench.experimental.cloudChanges.autoStore': {
-            enum: ['onShutdown', 'off'],
-            enumDescriptions: [
-                ( localizeWithPath(
-                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                    'autoStoreWorkingChanges.onShutdown',
-                    "Automatically store current working changes in the cloud on window close."
-                )),
-                ( localizeWithPath(
-                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                    'autoStoreWorkingChanges.off',
-                    "Never attempt to automatically store working changes in the cloud."
-                ))
-            ],
-            'type': 'string',
-            'tags': ['experimental', 'usesOnlineServices'],
-            'default': 'off',
-            'markdownDescription': ( localizeWithPath(
-                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                'autoStoreWorkingChangesDescription',
-                "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: [
-                ( localizeWithPath(
-                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                    'autoResumeWorkingChanges.onReload',
-                    "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."
-                ))
-            ],
-            'type': 'string',
-            'tags': ['usesOnlineServices'],
-            'default': 'onReload',
-            'markdownDescription': ( localizeWithPath(
-                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                'autoResumeWorkingChanges',
-                "Controls whether to automatically resume available working changes stored in the cloud for the current workspace."
-            )),
-        },
-        'workbench.cloudChanges.continueOn': {
-            enum: ['prompt', 'off'],
-            enumDescriptions: [
-                ( localizeWithPath(
-                    'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                    'continueOnCloudChanges.promptForAuth',
-                    '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',
-                    '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: ( localizeWithPath(
-                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                'continueOnCloudChanges',
-                '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': ( localizeWithPath(
-                'vs/workbench/contrib/editSessions/browser/editSessions.contribution',
-                'cloudChangesPartialMatchesEnabled',
-                "Controls whether to surface cloud changes which partially match the current session."
-            ))
-        }
-    }
-});
-export { EditSessionsContribution };