@codingame/monaco-vscode-api 4.1.0 → 4.1.2

package/vscode/src/vs/workbench/contrib/userDataSync/browser/userDataSync.js

@@ -1,1466 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Action } from '../../../../base/common/actions.js';
-import { isCancellationError, getErrorMessage } from '../../../../base/common/errors.js';
-import { Event } from '../../../../base/common/event.js';
-import { Disposable, MutableDisposable, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
-import { isEqual } from '../../../../base/common/resources.js';
-import { URI } from '../../../../base/common/uri.js';
-import { IModelService } from '../../../../editor/common/services/model.js';
-import { ILanguageService } from '../../../../editor/common/languages/language.js';
-import { ITextModelService } from '../../../../editor/common/services/resolverService.js';
-import { localizeWithPath, localize2WithPath } from '../../../../nls.js';
-import { registerAction2, MenuRegistry, MenuId, Action2 } from '../../../../platform/actions/common/actions.js';
-import { ICommandService } from '../../../../platform/commands/common/commands.js';
-import { ContextKeyExpr, RawContextKey, ContextKeyTrueExpr, IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-import { Severity, INotificationService } from '../../../../platform/notification/common/notification.js';
-import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
-import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
-import { registerConfiguration, USER_DATA_SYNC_SCHEME, UserDataSyncError, USER_DATA_SYNC_LOG_ID, IUserDataSyncEnablementService, IUserDataSyncService, IUserDataAutoSyncService, IUserDataSyncStoreManagementService } from '../../../../platform/userDataSync/common/userDataSync.js';
-import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
-import { IOutputService } from '../../../services/output/common/output.js';
-import { NumberBadge, ProgressBadge, IActivityService } from '../../../services/activity/common/activity.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-import { IPreferencesService } from '../../../services/preferences/common/preferences.js';
-import { fromNow } from '../../../../base/common/date.js';
-import { IProductService } from '../../../../platform/product/common/productService.js';
-import { IOpenerService } from '../../../../platform/opener/common/opener.js';
-import { IAuthenticationService } from '../../../services/authentication/common/authentication.js';
-import { Registry } from '../../../../platform/registry/common/platform.js';
-import { SyncDescriptor } from '../../../../platform/instantiation/common/descriptors.js';
-import { Extensions } from '../../../common/views.js';
-import { UserDataSyncDataViews } from './userDataSyncViews.js';
-import { SHOW_SYNC_LOG_COMMAND_ID, getSyncAreaLabel, SYNC_TITLE, SYNC_VIEW_CONTAINER_ID, SYNC_VIEW_ICON, CONTEXT_SYNC_STATE, CONTEXT_SYNC_ENABLEMENT, CONTEXT_ACCOUNT_STATE, CONTEXT_HAS_CONFLICTS, DOWNLOAD_ACTIVITY_ACTION_DESCRIPTOR, IUserDataSyncWorkbenchService, CONFIGURE_SYNC_COMMAND_ID } from '../../../services/userDataSync/common/userDataSync.js';
-import { Codicon } from '../../../../base/common/codicons.js';
-import { ViewPaneContainer } from '../../../browser/parts/views/viewPaneContainer.js';
-import { Categories } from '../../../../platform/action/common/actionCommonCategories.js';
-import { IHostService } from '../../../services/host/browser/host.js';
-import { IUserDataProfilesService } from '../../../../platform/userDataProfile/common/userDataProfile.js';
-import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
-import { ctxIsMergeResultEditor, ctxMergeBaseUri } from '../../mergeEditor/common/mergeEditor.js';
-import { IWorkbenchIssueService } from '../../../services/issue/common/issue.js';
-import { IUserDataProfileService } from '../../../services/userDataProfile/common/userDataProfile.js';
-import { isWeb } from '../../../../base/common/platform.js';
-import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
-const turnOffSyncCommand = { id: 'workbench.userDataSync.actions.turnOff', title: ( localize2WithPath(
-    'vs/workbench/contrib/userDataSync/browser/userDataSync',
-    'stop sync',
-    'Turn Off'
-)) };
-const configureSyncCommand = { id: CONFIGURE_SYNC_COMMAND_ID, title: ( localize2WithPath(
-    'vs/workbench/contrib/userDataSync/browser/userDataSync',
-    'configure sync',
-    'Configure...'
-)) };
-const showConflictsCommandId = 'workbench.userDataSync.actions.showConflicts';
-const syncNowCommand = {
-    id: 'workbench.userDataSync.actions.syncNow',
-    title: ( localize2WithPath(
-        'vs/workbench/contrib/userDataSync/browser/userDataSync',
-        'sync now',
-        'Sync Now'
-    )),
-    description(userDataSyncService) {
-        if (userDataSyncService.status === "syncing" ) {
-            return ( localizeWithPath(
-                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                'syncing',
-                "syncing"
-            ));
-        }
-        if (userDataSyncService.lastSyncTime) {
-            return ( localizeWithPath(
-                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                'synced with time',
-                "synced {0}",
-                fromNow(userDataSyncService.lastSyncTime, true)
-            ));
-        }
-        return undefined;
-    }
-};
-const showSyncSettingsCommand = { id: 'workbench.userDataSync.actions.settings', title: ( localize2WithPath(
-    'vs/workbench/contrib/userDataSync/browser/userDataSync',
-    'sync settings',
-    'Show Settings'
-)), };
-const showSyncedDataCommand = { id: 'workbench.userDataSync.actions.showSyncedData', title: ( localize2WithPath(
-    'vs/workbench/contrib/userDataSync/browser/userDataSync',
-    'show synced data',
-    'Show Synced Data'
-)), };
-const CONTEXT_TURNING_ON_STATE = ( new RawContextKey('userDataSyncTurningOn', false));
-let UserDataSyncWorkbenchContribution = class UserDataSyncWorkbenchContribution extends Disposable {
-    constructor(userDataSyncEnablementService, userDataSyncService, userDataSyncWorkbenchService, contextKeyService, activityService, notificationService, editorService, userDataProfilesService, userDataProfileService, dialogService, quickInputService, instantiationService, outputService, userDataAutoSyncService, textModelResolverService, preferencesService, telemetryService, productService, openerService, authenticationService, userDataSyncStoreManagementService, hostService, commandService, workbenchIssueService) {
-        super();
-        this.userDataSyncEnablementService = userDataSyncEnablementService;
-        this.userDataSyncService = userDataSyncService;
-        this.userDataSyncWorkbenchService = userDataSyncWorkbenchService;
-        this.activityService = activityService;
-        this.notificationService = notificationService;
-        this.editorService = editorService;
-        this.userDataProfilesService = userDataProfilesService;
-        this.userDataProfileService = userDataProfileService;
-        this.dialogService = dialogService;
-        this.quickInputService = quickInputService;
-        this.instantiationService = instantiationService;
-        this.outputService = outputService;
-        this.preferencesService = preferencesService;
-        this.telemetryService = telemetryService;
-        this.productService = productService;
-        this.openerService = openerService;
-        this.authenticationService = authenticationService;
-        this.userDataSyncStoreManagementService = userDataSyncStoreManagementService;
-        this.hostService = hostService;
-        this.commandService = commandService;
-        this.workbenchIssueService = workbenchIssueService;
-        this.globalActivityBadgeDisposable = this._register(( new MutableDisposable()));
-        this.accountBadgeDisposable = this._register(( new MutableDisposable()));
-        this.conflictsDisposables = ( new Map());
-        this.invalidContentErrorDisposables = ( new Map());
-        this.conflictsActionDisposable = this._register(( new MutableDisposable()));
-        this.turningOnSyncContext = CONTEXT_TURNING_ON_STATE.bindTo(contextKeyService);
-        if (userDataSyncWorkbenchService.enabled) {
-            registerConfiguration();
-            this.updateAccountBadge();
-            this.updateGlobalActivityBadge();
-            this.onDidChangeConflicts(this.userDataSyncService.conflicts);
-            this._register(Event.any(Event.debounce(userDataSyncService.onDidChangeStatus, () => undefined, 500), this.userDataSyncEnablementService.onDidChangeEnablement, this.userDataSyncWorkbenchService.onDidChangeAccountStatus)(() => {
-                this.updateAccountBadge();
-                this.updateGlobalActivityBadge();
-            }));
-            this._register(userDataSyncService.onDidChangeConflicts(() => this.onDidChangeConflicts(this.userDataSyncService.conflicts)));
-            this._register(userDataSyncEnablementService.onDidChangeEnablement(() => this.onDidChangeConflicts(this.userDataSyncService.conflicts)));
-            this._register(userDataSyncService.onSyncErrors(errors => this.onSynchronizerErrors(errors)));
-            this._register(userDataAutoSyncService.onError(error => this.onAutoSyncError(error)));
-            this.registerActions();
-            this.registerViews();
-            textModelResolverService.registerTextModelContentProvider(USER_DATA_SYNC_SCHEME, instantiationService.createInstance(UserDataRemoteContentProvider));
-            this._register(Event.any(userDataSyncService.onDidChangeStatus, userDataSyncEnablementService.onDidChangeEnablement)(() => this.turningOnSync = !userDataSyncEnablementService.isEnabled() && userDataSyncService.status !== "idle" ));
-        }
-    }
-    get turningOnSync() {
-        return !!this.turningOnSyncContext.get();
-    }
-    set turningOnSync(turningOn) {
-        this.turningOnSyncContext.set(turningOn);
-        this.updateGlobalActivityBadge();
-    }
-    toKey({ syncResource: resource, profile }) {
-        return `${profile.id}:${resource}`;
-    }
-    onDidChangeConflicts(conflicts) {
-        this.updateGlobalActivityBadge();
-        this.registerShowConflictsAction();
-        if (!this.userDataSyncEnablementService.isEnabled()) {
-            return;
-        }
-        if (conflicts.length) {
-            for (const [key, disposable] of this.conflictsDisposables.entries()) {
-                if (!( conflicts.some(conflict => this.toKey(conflict) === key))) {
-                    disposable.dispose();
-                    this.conflictsDisposables.delete(key);
-                }
-            }
-            for (const conflict of this.userDataSyncService.conflicts) {
-                const key = this.toKey(conflict);
-                if (!( this.conflictsDisposables.has(key))) {
-                    const conflictsArea = getSyncAreaLabel(conflict.syncResource);
-                    const handle = this.notificationService.prompt(Severity.Warning, ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                        'conflicts detected',
-                        "Unable to sync due to conflicts in {0}. Please resolve them to continue.",
-                        conflictsArea.toLowerCase()
-                    )), [
-                        {
-                            label: ( localizeWithPath(
-                                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                                'replace remote',
-                                "Replace Remote"
-                            )),
-                            run: () => {
-                                this.telemetryService.publicLog2('sync/handleConflicts', { source: conflict.syncResource, action: 'acceptLocal' });
-                                this.acceptLocal(conflict, conflict.conflicts[0]);
-                            }
-                        },
-                        {
-                            label: ( localizeWithPath(
-                                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                                'replace local',
-                                "Replace Local"
-                            )),
-                            run: () => {
-                                this.telemetryService.publicLog2('sync/handleConflicts', { source: conflict.syncResource, action: 'acceptRemote' });
-                                this.acceptRemote(conflict, conflict.conflicts[0]);
-                            }
-                        },
-                        {
-                            label: ( localizeWithPath(
-                                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                                'show conflicts',
-                                "Show Conflicts"
-                            )),
-                            run: () => {
-                                this.telemetryService.publicLog2('sync/showConflicts', { source: conflict.syncResource });
-                                this.userDataSyncWorkbenchService.showConflicts(conflict.conflicts[0]);
-                            }
-                        }
-                    ], {
-                        sticky: true
-                    });
-                    this.conflictsDisposables.set(key, toDisposable(() => {
-                        handle.close();
-                        this.conflictsDisposables.delete(key);
-                    }));
-                }
-            }
-        }
-        else {
-            this.conflictsDisposables.forEach(disposable => disposable.dispose());
-            this.conflictsDisposables.clear();
-        }
-    }
-    async acceptRemote(syncResource, conflict) {
-        try {
-            await this.userDataSyncService.accept(syncResource, conflict.remoteResource, undefined, this.userDataSyncEnablementService.isEnabled());
-        }
-        catch (e) {
-            this.notificationService.error(( localizeWithPath(
-                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                'accept failed',
-                "Error while accepting changes. Please check [logs]({0}) for more details.",
-                `command:${SHOW_SYNC_LOG_COMMAND_ID}`
-            )));
-        }
-    }
-    async acceptLocal(syncResource, conflict) {
-        try {
-            await this.userDataSyncService.accept(syncResource, conflict.localResource, undefined, this.userDataSyncEnablementService.isEnabled());
-        }
-        catch (e) {
-            this.notificationService.error(( localizeWithPath(
-                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                'accept failed',
-                "Error while accepting changes. Please check [logs]({0}) for more details.",
-                `command:${SHOW_SYNC_LOG_COMMAND_ID}`
-            )));
-        }
-    }
-    onAutoSyncError(error) {
-        switch (error.code) {
-            case "SessionExpired" :
-                this.notificationService.notify({
-                    severity: Severity.Info,
-                    message: ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                        'session expired',
-                        "Settings sync was turned off because current session is expired, please sign in again to turn on sync."
-                    )),
-                    actions: {
-                        primary: [( new Action('turn on sync', ( localizeWithPath(
-                            'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                            'turn on sync',
-                            "Turn on Settings Sync..."
-                        )), undefined, true, () => this.turnOn()))]
-                    }
-                });
-                break;
-            case "TurnedOff" :
-                this.notificationService.notify({
-                    severity: Severity.Info,
-                    message: ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                        'turned off',
-                        "Settings sync was turned off from another device, please turn on sync again."
-                    )),
-                    actions: {
-                        primary: [( new Action('turn on sync', ( localizeWithPath(
-                            'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                            'turn on sync',
-                            "Turn on Settings Sync..."
-                        )), undefined, true, () => this.turnOn()))]
-                    }
-                });
-                break;
-            case "TooLarge" :
-                if (error.resource === "keybindings"  || error.resource === "settings"  || error.resource === "tasks" ) {
-                    this.disableSync(error.resource);
-                    const sourceArea = getSyncAreaLabel(error.resource);
-                    this.handleTooLargeError(error.resource, ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                        'too large',
-                        "Disabled syncing {0} because size of the {1} file to sync is larger than {2}. Please open the file and reduce the size and enable sync",
-                        sourceArea.toLowerCase(),
-                        sourceArea.toLowerCase(),
-                        '100kb'
-                    )), error);
-                }
-                break;
-            case "LocalTooManyProfiles" :
-                this.disableSync("profiles" );
-                this.notificationService.error(( localizeWithPath(
-                    'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                    'too many profiles',
-                    "Disabled syncing profiles because there are too many profiles to sync. Settings Sync supports syncing maximum 20 profiles. Please reduce the number of profiles and enable sync"
-                )));
-                break;
-            case "IncompatibleLocalContent" :
-            case "Gone" :
-            case "UpgradeRequired" : {
-                const message = ( localizeWithPath(
-                    'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                    'error upgrade required',
-                    "Settings sync is disabled because the current version ({0}, {1}) is not compatible with the sync service. Please update before turning on sync.",
-                    this.productService.version,
-                    this.productService.commit
-                ));
-                const operationId = error.operationId ? ( localizeWithPath(
-                    'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                    'operationId',
-                    "Operation Id: {0}",
-                    error.operationId
-                )) : undefined;
-                this.notificationService.notify({
-                    severity: Severity.Error,
-                    message: operationId ? `${message} ${operationId}` : message,
-                });
-                break;
-            }
-            case "MethodNotFound" : {
-                const message = ( localizeWithPath(
-                    'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                    'method not found',
-                    "Settings sync is disabled because the client is making invalid requests. Please report an issue with the logs."
-                ));
-                const operationId = error.operationId ? ( localizeWithPath(
-                    'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                    'operationId',
-                    "Operation Id: {0}",
-                    error.operationId
-                )) : undefined;
-                this.notificationService.notify({
-                    severity: Severity.Error,
-                    message: operationId ? `${message} ${operationId}` : message,
-                    actions: {
-                        primary: [
-                            ( new Action('Show Sync Logs', ( localizeWithPath(
-                                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                                'show sync logs',
-                                "Show Log"
-                            )), undefined, true, () => this.commandService.executeCommand(SHOW_SYNC_LOG_COMMAND_ID))),
-                            ( new Action('Report Issue', ( localizeWithPath(
-                                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                                'report issue',
-                                "Report Issue"
-                            )), undefined, true, () => this.workbenchIssueService.openReporter()))
-                        ]
-                    }
-                });
-                break;
-            }
-            case "IncompatibleRemoteContent" :
-                this.notificationService.notify({
-                    severity: Severity.Error,
-                    message: ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                        'error reset required',
-                        "Settings sync is disabled because your data in the cloud is older than that of the client. Please clear your data in the cloud before turning on sync."
-                    )),
-                    actions: {
-                        primary: [
-                            ( new Action('reset', ( localizeWithPath(
-                                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                                'reset',
-                                "Clear Data in Cloud..."
-                            )), undefined, true, () => this.userDataSyncWorkbenchService.resetSyncedData())),
-                            ( new Action('show synced data', ( localizeWithPath(
-                                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                                'show synced data action',
-                                "Show Synced Data"
-                            )), undefined, true, () => this.userDataSyncWorkbenchService.showSyncActivity()))
-                        ]
-                    }
-                });
-                return;
-            case "ServiceChanged" :
-                this.notificationService.notify({
-                    severity: Severity.Info,
-                    message: this.userDataSyncStoreManagementService.userDataSyncStore?.type === 'insiders' ?
-                        ( localizeWithPath(
-                            'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                            'service switched to insiders',
-                            "Settings Sync has been switched to insiders service"
-                        )) :
-                        ( localizeWithPath(
-                            'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                            'service switched to stable',
-                            "Settings Sync has been switched to stable service"
-                        )),
-                });
-                return;
-            case "DefaultServiceChanged" :
-                if (this.userDataSyncEnablementService.isEnabled()) {
-                    this.notificationService.notify({
-                        severity: Severity.Info,
-                        message: ( localizeWithPath(
-                            'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                            'using separate service',
-                            "Settings sync now uses a separate service, more information is available in the [Settings Sync Documentation](https://aka.ms/vscode-settings-sync-help#_syncing-stable-versus-insiders)."
-                        )),
-                    });
-                }
-                else {
-                    this.notificationService.notify({
-                        severity: Severity.Info,
-                        message: ( localizeWithPath(
-                            'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                            'service changed and turned off',
-                            "Settings sync was turned off because {0} now uses a separate service. Please turn on sync again.",
-                            this.productService.nameLong
-                        )),
-                        actions: {
-                            primary: [( new Action('turn on sync', ( localizeWithPath(
-                                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                                'turn on sync',
-                                "Turn on Settings Sync..."
-                            )), undefined, true, () => this.turnOn()))]
-                        }
-                    });
-                }
-                return;
-        }
-    }
-    handleTooLargeError(resource, message, error) {
-        const operationId = error.operationId ? ( localizeWithPath(
-            'vs/workbench/contrib/userDataSync/browser/userDataSync',
-            'operationId',
-            "Operation Id: {0}",
-            error.operationId
-        )) : undefined;
-        this.notificationService.notify({
-            severity: Severity.Error,
-            message: operationId ? `${message} ${operationId}` : message,
-            actions: {
-                primary: [( new Action('open sync file', ( localizeWithPath(
-                    'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                    'open file',
-                    "Open {0} File",
-                    getSyncAreaLabel(resource)
-                )), undefined, true, () => resource === "settings"  ? this.preferencesService.openUserSettings({ jsonEditor: true }) : this.preferencesService.openGlobalKeybindingSettings(true)))]
-            }
-        });
-    }
-    onSynchronizerErrors(errors) {
-        if (errors.length) {
-            for (const { profile, syncResource: resource, error } of errors) {
-                switch (error.code) {
-                    case "LocalInvalidContent" :
-                        this.handleInvalidContentError({ profile, syncResource: resource });
-                        break;
-                    default: {
-                        const key = `${profile.id}:${resource}`;
-                        const disposable = this.invalidContentErrorDisposables.get(key);
-                        if (disposable) {
-                            disposable.dispose();
-                            this.invalidContentErrorDisposables.delete(key);
-                        }
-                    }
-                }
-            }
-        }
-        else {
-            this.invalidContentErrorDisposables.forEach(disposable => disposable.dispose());
-            this.invalidContentErrorDisposables.clear();
-        }
-    }
-    handleInvalidContentError({ profile, syncResource: source }) {
-        if (this.userDataProfileService.currentProfile.id !== profile.id) {
-            return;
-        }
-        const key = `${profile.id}:${source}`;
-        if (( this.invalidContentErrorDisposables.has(key))) {
-            return;
-        }
-        if (source !== "settings"  && source !== "keybindings"  && source !== "tasks" ) {
-            return;
-        }
-        if (!this.hostService.hasFocus) {
-            return;
-        }
-        const resource = source === "settings"  ? this.userDataProfileService.currentProfile.settingsResource
-            : source === "keybindings"  ? this.userDataProfileService.currentProfile.keybindingsResource
-                : this.userDataProfileService.currentProfile.tasksResource;
-        const editorUri = EditorResourceAccessor.getCanonicalUri(this.editorService.activeEditor, { supportSideBySide: SideBySideEditor.PRIMARY });
-        if (isEqual(resource, editorUri)) {
-            return;
-        }
-        const errorArea = getSyncAreaLabel(source);
-        const handle = this.notificationService.notify({
-            severity: Severity.Error,
-            message: ( localizeWithPath(
-                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                'errorInvalidConfiguration',
-                "Unable to sync {0} because the content in the file is not valid. Please open the file and correct it.",
-                errorArea.toLowerCase()
-            )),
-            actions: {
-                primary: [( new Action('open sync file', ( localizeWithPath(
-                    'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                    'open file',
-                    "Open {0} File",
-                    errorArea
-                )), undefined, true, () => source === "settings"  ? this.preferencesService.openUserSettings({ jsonEditor: true }) : this.preferencesService.openGlobalKeybindingSettings(true)))]
-            }
-        });
-        this.invalidContentErrorDisposables.set(key, toDisposable(() => {
-            handle.close();
-            this.invalidContentErrorDisposables.delete(key);
-        }));
-    }
-    getConflictsCount() {
-        return this.userDataSyncService.conflicts.reduce((result, { conflicts }) => { return result + conflicts.length; }, 0);
-    }
-    async updateGlobalActivityBadge() {
-        this.globalActivityBadgeDisposable.clear();
-        let badge = undefined;
-        let priority = undefined;
-        if (this.userDataSyncService.conflicts.length && this.userDataSyncEnablementService.isEnabled()) {
-            badge = ( new NumberBadge(this.getConflictsCount(), () => ( localizeWithPath(
-                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                'has conflicts',
-                "{0}: Conflicts Detected",
-                SYNC_TITLE.value
-            ))));
-        }
-        else if (this.turningOnSync) {
-            badge = ( new ProgressBadge(() => ( localizeWithPath(
-                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                'turning on syncing',
-                "Turning on Settings Sync..."
-            ))));
-            priority = 1;
-        }
-        if (badge) {
-            this.globalActivityBadgeDisposable.value = this.activityService.showGlobalActivity({ badge, priority });
-        }
-    }
-    async updateAccountBadge() {
-        this.accountBadgeDisposable.clear();
-        let badge = undefined;
-        if (this.userDataSyncService.status !== "uninitialized"  && this.userDataSyncEnablementService.isEnabled() && this.userDataSyncWorkbenchService.accountStatus === "unavailable" ) {
-            badge = ( new NumberBadge(1, () => ( localizeWithPath(
-                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                'sign in to sync',
-                "Sign in to Sync Settings"
-            ))));
-        }
-        if (badge) {
-            this.accountBadgeDisposable.value = this.activityService.showAccountsActivity({ badge, priority: undefined });
-        }
-    }
-    async turnOn() {
-        try {
-            if (!this.userDataSyncWorkbenchService.authenticationProviders.length) {
-                throw new Error(localizeWithPath('vs/workbench/contrib/userDataSync/browser/userDataSync', 'no authentication providers', "No authentication providers are available."));
-            }
-            const turnOn = await this.askToConfigure();
-            if (!turnOn) {
-                return;
-            }
-            if (this.userDataSyncStoreManagementService.userDataSyncStore?.canSwitch) {
-                await this.selectSettingsSyncService(this.userDataSyncStoreManagementService.userDataSyncStore);
-            }
-            await this.userDataSyncWorkbenchService.turnOn();
-        }
-        catch (e) {
-            if (isCancellationError(e)) {
-                return;
-            }
-            if (e instanceof UserDataSyncError) {
-                switch (e.code) {
-                    case "TooLarge" :
-                        if (e.resource === "keybindings"  || e.resource === "settings"  || e.resource === "tasks" ) {
-                            this.handleTooLargeError(e.resource, ( localizeWithPath(
-                                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                                'too large while starting sync',
-                                "Settings sync cannot be turned on because size of the {0} file to sync is larger than {1}. Please open the file and reduce the size and turn on sync",
-                                getSyncAreaLabel(e.resource).toLowerCase(),
-                                '100kb'
-                            )), e);
-                            return;
-                        }
-                        break;
-                    case "IncompatibleLocalContent" :
-                    case "Gone" :
-                    case "UpgradeRequired" : {
-                        const message = ( localizeWithPath(
-                            'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                            'error upgrade required while starting sync',
-                            "Settings sync cannot be turned on because the current version ({0}, {1}) is not compatible with the sync service. Please update before turning on sync.",
-                            this.productService.version,
-                            this.productService.commit
-                        ));
-                        const operationId = e.operationId ? ( localizeWithPath(
-                            'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                            'operationId',
-                            "Operation Id: {0}",
-                            e.operationId
-                        )) : undefined;
-                        this.notificationService.notify({
-                            severity: Severity.Error,
-                            message: operationId ? `${message} ${operationId}` : message,
-                        });
-                        return;
-                    }
-                    case "IncompatibleRemoteContent" :
-                        this.notificationService.notify({
-                            severity: Severity.Error,
-                            message: ( localizeWithPath(
-                                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                                'error reset required while starting sync',
-                                "Settings sync cannot be turned on because your data in the cloud is older than that of the client. Please clear your data in the cloud before turning on sync."
-                            )),
-                            actions: {
-                                primary: [
-                                    ( new Action('reset', ( localizeWithPath(
-                                        'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                                        'reset',
-                                        "Clear Data in Cloud..."
-                                    )), undefined, true, () => this.userDataSyncWorkbenchService.resetSyncedData())),
-                                    ( new Action('show synced data', ( localizeWithPath(
-                                        'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                                        'show synced data action',
-                                        "Show Synced Data"
-                                    )), undefined, true, () => this.userDataSyncWorkbenchService.showSyncActivity()))
-                                ]
-                            }
-                        });
-                        return;
-                    case "Unauthorized" :
-                    case "Forbidden" :
-                        this.notificationService.error(( localizeWithPath(
-                            'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                            'auth failed',
-                            "Error while turning on Settings Sync: Authentication failed."
-                        )));
-                        return;
-                }
-                this.notificationService.error(( localizeWithPath(
-                    'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                    'turn on failed with user data sync error',
-                    "Error while turning on Settings Sync. Please check [logs]({0}) for more details.",
-                    `command:${SHOW_SYNC_LOG_COMMAND_ID}`
-                )));
-            }
-            else {
-                this.notificationService.error(( localizeWithPath(
-                    'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                    { key: 'turn on failed', comment: ['Substitution is for error reason'] },
-                    "Error while turning on Settings Sync. {0}",
-                    getErrorMessage(e)
-                )));
-            }
-        }
-    }
-    async askToConfigure() {
-        return ( new Promise((c, e) => {
-            const disposables = ( new DisposableStore());
-            const quickPick = this.quickInputService.createQuickPick();
-            disposables.add(quickPick);
-            quickPick.title = SYNC_TITLE.value;
-            quickPick.ok = false;
-            quickPick.customButton = true;
-            quickPick.customLabel = ( localizeWithPath(
-                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                'sign in and turn on',
-                "Sign in"
-            ));
-            quickPick.description = ( localizeWithPath(
-                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                'configure and turn on sync detail',
-                "Please sign in to backup and sync your data across devices."
-            ));
-            quickPick.canSelectMany = true;
-            quickPick.ignoreFocusOut = true;
-            quickPick.hideInput = true;
-            quickPick.hideCheckAll = true;
-            const items = this.getConfigureSyncQuickPickItems();
-            quickPick.items = items;
-            quickPick.selectedItems = items.filter(item => this.userDataSyncEnablementService.isResourceEnabled(item.id));
-            let accepted = false;
-            disposables.add(Event.any(quickPick.onDidAccept, quickPick.onDidCustom)(() => {
-                accepted = true;
-                quickPick.hide();
-            }));
-            disposables.add(quickPick.onDidHide(() => {
-                try {
-                    if (accepted) {
-                        this.updateConfiguration(items, quickPick.selectedItems);
-                    }
-                    c(accepted);
-                }
-                catch (error) {
-                    e(error);
-                }
-                finally {
-                    disposables.dispose();
-                }
-            }));
-            quickPick.show();
-        }));
-    }
-    getConfigureSyncQuickPickItems() {
-        const result = [{
-                id: "settings" ,
-                label: getSyncAreaLabel("settings" )
-            }, {
-                id: "keybindings" ,
-                label: getSyncAreaLabel("keybindings" ),
-            }, {
-                id: "snippets" ,
-                label: getSyncAreaLabel("snippets" )
-            }, {
-                id: "tasks" ,
-                label: getSyncAreaLabel("tasks" )
-            }, {
-                id: "globalState" ,
-                label: getSyncAreaLabel("globalState" ),
-            }, {
-                id: "extensions" ,
-                label: getSyncAreaLabel("extensions" )
-            }];
-        if (this.userDataProfilesService.isEnabled()) {
-            result.push({
-                id: "profiles" ,
-                label: getSyncAreaLabel("profiles" ),
-            });
-        }
-        return result;
-    }
-    updateConfiguration(items, selectedItems) {
-        for (const item of items) {
-            const wasEnabled = this.userDataSyncEnablementService.isResourceEnabled(item.id);
-            const isEnabled = !!selectedItems.filter(selected => selected.id === item.id)[0];
-            if (wasEnabled !== isEnabled) {
-                this.userDataSyncEnablementService.setResourceEnablement(item.id, isEnabled);
-            }
-        }
-    }
-    async configureSyncOptions() {
-        return ( new Promise((c, e) => {
-            const disposables = ( new DisposableStore());
-            const quickPick = this.quickInputService.createQuickPick();
-            disposables.add(quickPick);
-            quickPick.title = ( localizeWithPath(
-                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                'configure sync title',
-                "{0}: Configure...",
-                SYNC_TITLE.value
-            ));
-            quickPick.placeholder = ( localizeWithPath(
-                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                'configure sync placeholder',
-                "Choose what to sync"
-            ));
-            quickPick.canSelectMany = true;
-            quickPick.ignoreFocusOut = true;
-            quickPick.ok = true;
-            const items = this.getConfigureSyncQuickPickItems();
-            quickPick.items = items;
-            quickPick.selectedItems = items.filter(item => this.userDataSyncEnablementService.isResourceEnabled(item.id));
-            disposables.add(quickPick.onDidAccept(async () => {
-                if (quickPick.selectedItems.length) {
-                    this.updateConfiguration(items, quickPick.selectedItems);
-                    quickPick.hide();
-                }
-            }));
-            disposables.add(quickPick.onDidHide(() => {
-                disposables.dispose();
-                c();
-            }));
-            quickPick.show();
-        }));
-    }
-    async turnOff() {
-        const result = await this.dialogService.confirm({
-            message: ( localizeWithPath(
-                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                'turn off sync confirmation',
-                "Do you want to turn off sync?"
-            )),
-            detail: ( localizeWithPath(
-                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                'turn off sync detail',
-                "Your settings, keybindings, extensions, snippets and UI State will no longer be synced."
-            )),
-            primaryButton: ( localizeWithPath(
-                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                { key: 'turn off', comment: ['&& denotes a mnemonic'] },
-                "&&Turn off"
-            )),
-            checkbox: this.userDataSyncWorkbenchService.accountStatus === "available"  ? {
-                label: ( localizeWithPath(
-                    'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                    'turn off sync everywhere',
-                    "Turn off sync on all your devices and clear the data from the cloud."
-                ))
-            } : undefined
-        });
-        if (result.confirmed) {
-            return this.userDataSyncWorkbenchService.turnoff(!!result.checkboxChecked);
-        }
-    }
-    disableSync(source) {
-        switch (source) {
-            case "settings" : return this.userDataSyncEnablementService.setResourceEnablement("settings" , false);
-            case "keybindings" : return this.userDataSyncEnablementService.setResourceEnablement("keybindings" , false);
-            case "snippets" : return this.userDataSyncEnablementService.setResourceEnablement("snippets" , false);
-            case "tasks" : return this.userDataSyncEnablementService.setResourceEnablement("tasks" , false);
-            case "extensions" : return this.userDataSyncEnablementService.setResourceEnablement("extensions" , false);
-            case "globalState" : return this.userDataSyncEnablementService.setResourceEnablement("globalState" , false);
-            case "profiles" : return this.userDataSyncEnablementService.setResourceEnablement("profiles" , false);
-        }
-    }
-    showSyncActivity() {
-        return this.outputService.showChannel(USER_DATA_SYNC_LOG_ID);
-    }
-    async selectSettingsSyncService(userDataSyncStore) {
-        return ( new Promise((c, e) => {
-            const disposables = ( new DisposableStore());
-            const quickPick = disposables.add(this.quickInputService.createQuickPick());
-            quickPick.title = ( localizeWithPath(
-                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                'switchSyncService.title',
-                "{0}: Select Service",
-                SYNC_TITLE.value
-            ));
-            quickPick.description = ( localizeWithPath(
-                'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                'switchSyncService.description',
-                "Ensure you are using the same settings sync service when syncing with multiple environments"
-            ));
-            quickPick.hideInput = true;
-            quickPick.ignoreFocusOut = true;
-            const getDescription = (url) => {
-                const isDefault = isEqual(url, userDataSyncStore.defaultUrl);
-                if (isDefault) {
-                    return ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                        'default',
-                        "Default"
-                    ));
-                }
-                return undefined;
-            };
-            quickPick.items = [
-                {
-                    id: 'insiders',
-                    label: ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                        'insiders',
-                        "Insiders"
-                    )),
-                    description: getDescription(userDataSyncStore.insidersUrl)
-                },
-                {
-                    id: 'stable',
-                    label: ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                        'stable',
-                        "Stable"
-                    )),
-                    description: getDescription(userDataSyncStore.stableUrl)
-                }
-            ];
-            disposables.add(quickPick.onDidAccept(async () => {
-                try {
-                    await this.userDataSyncStoreManagementService.switch(quickPick.selectedItems[0].id);
-                    c();
-                }
-                catch (error) {
-                    e(error);
-                }
-                finally {
-                    quickPick.hide();
-                }
-            }));
-            disposables.add(quickPick.onDidHide(() => disposables.dispose()));
-            quickPick.show();
-        }));
-    }
-    registerActions() {
-        if (this.userDataSyncEnablementService.canToggleEnablement()) {
-            this.registerTurnOnSyncAction();
-            this.registerTurnOffSyncAction();
-        }
-        this.registerTurningOnSyncAction();
-        this.registerCancelTurnOnSyncAction();
-        this.registerSignInAction();
-        this.registerShowConflictsAction();
-        this.registerEnableSyncViewsAction();
-        this.registerManageSyncAction();
-        this.registerSyncNowAction();
-        this.registerConfigureSyncAction();
-        this.registerShowSettingsAction();
-        this.registerHelpAction();
-        this.registerShowLogAction();
-        this.registerResetSyncDataAction();
-        this.registerAcceptMergesAction();
-        if (isWeb) {
-            this.registerDownloadSyncActivityAction();
-        }
-    }
-    registerTurnOnSyncAction() {
-        const that = this;
-        const when = ( ContextKeyExpr.and(( CONTEXT_SYNC_STATE.notEqualsTo("uninitialized" )), ( CONTEXT_SYNC_ENABLEMENT.toNegated()), ( CONTEXT_TURNING_ON_STATE.negate())));
-        this._register(registerAction2(class TurningOnSyncAction extends Action2 {
-            constructor() {
-                super({
-                    id: 'workbench.userDataSync.actions.turnOn',
-                    title: ( localize2WithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                        'global activity turn on sync',
-                        'Backup and Sync Settings...'
-                    )),
-                    category: SYNC_TITLE,
-                    f1: true,
-                    precondition: when,
-                    menu: [{
-                            group: '3_settings_sync',
-                            id: MenuId.GlobalActivity,
-                            when,
-                            order: 1
-                        }, {
-                            group: '3_settings_sync',
-                            id: MenuId.MenubarPreferencesMenu,
-                            when,
-                            order: 1
-                        }, {
-                            group: '1_settings',
-                            id: MenuId.AccountsContext,
-                            when,
-                            order: 2
-                        }]
-                });
-            }
-            async run() {
-                return that.turnOn();
-            }
-        }));
-    }
-    registerTurningOnSyncAction() {
-        const when = ( ContextKeyExpr.and(( CONTEXT_SYNC_STATE.notEqualsTo("uninitialized" )), ( CONTEXT_SYNC_ENABLEMENT.toNegated()), CONTEXT_TURNING_ON_STATE));
-        this._register(registerAction2(class TurningOnSyncAction extends Action2 {
-            constructor() {
-                super({
-                    id: 'workbench.userData.actions.turningOn',
-                    title: ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                        'turnin on sync',
-                        "Turning on Settings Sync..."
-                    )),
-                    precondition: ( ContextKeyExpr.false()),
-                    menu: [{
-                            group: '3_settings_sync',
-                            id: MenuId.GlobalActivity,
-                            when,
-                            order: 2
-                        }, {
-                            group: '1_settings',
-                            id: MenuId.AccountsContext,
-                            when,
-                        }]
-                });
-            }
-            async run() { }
-        }));
-    }
-    registerCancelTurnOnSyncAction() {
-        const that = this;
-        this._register(registerAction2(class TurningOnSyncAction extends Action2 {
-            constructor() {
-                super({
-                    id: 'workbench.userData.actions.cancelTurnOn',
-                    title: ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                        'cancel turning on sync',
-                        "Cancel"
-                    )),
-                    icon: Codicon.stopCircle,
-                    menu: {
-                        id: MenuId.ViewContainerTitle,
-                        when: ( ContextKeyExpr.and(CONTEXT_TURNING_ON_STATE, ( ContextKeyExpr.equals('viewContainer', SYNC_VIEW_CONTAINER_ID)))),
-                        group: 'navigation',
-                        order: 1
-                    }
-                });
-            }
-            async run() {
-                return that.userDataSyncWorkbenchService.turnoff(false);
-            }
-        }));
-    }
-    registerSignInAction() {
-        const that = this;
-        const id = 'workbench.userData.actions.signin';
-        const when = ( ContextKeyExpr.and(( CONTEXT_SYNC_STATE.notEqualsTo("uninitialized" )), CONTEXT_SYNC_ENABLEMENT, ( CONTEXT_ACCOUNT_STATE.isEqualTo("unavailable" ))));
-        this._register(registerAction2(class StopSyncAction extends Action2 {
-            constructor() {
-                super({
-                    id: 'workbench.userData.actions.signin',
-                    title: ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                        'sign in global',
-                        "Sign in to Sync Settings"
-                    )),
-                    menu: {
-                        group: '3_settings_sync',
-                        id: MenuId.GlobalActivity,
-                        when,
-                        order: 2
-                    }
-                });
-            }
-            async run() {
-                try {
-                    await that.userDataSyncWorkbenchService.signIn();
-                }
-                catch (e) {
-                    that.notificationService.error(e);
-                }
-            }
-        }));
-        this._register(( MenuRegistry.appendMenuItem(MenuId.AccountsContext, {
-            group: '1_settings',
-            command: {
-                id,
-                title: ( localizeWithPath(
-                    'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                    'sign in accounts',
-                    "Sign in to Sync Settings (1)"
-                )),
-            },
-            when
-        })));
-    }
-    getShowConflictsTitle() {
-        return ( localize2WithPath(
-            'vs/workbench/contrib/userDataSync/browser/userDataSync',
-            'resolveConflicts_global',
-            "Show Conflicts ({0})",
-            this.getConflictsCount()
-        ));
-    }
-    registerShowConflictsAction() {
-        this.conflictsActionDisposable.value = undefined;
-        const that = this;
-        this.conflictsActionDisposable.value = registerAction2(class TurningOnSyncAction extends Action2 {
-            constructor() {
-                super({
-                    id: showConflictsCommandId,
-                    get title() { return that.getShowConflictsTitle(); },
-                    category: SYNC_TITLE,
-                    f1: true,
-                    precondition: CONTEXT_HAS_CONFLICTS,
-                    menu: [{
-                            group: '3_settings_sync',
-                            id: MenuId.GlobalActivity,
-                            when: CONTEXT_HAS_CONFLICTS,
-                            order: 2
-                        }, {
-                            group: '3_settings_sync',
-                            id: MenuId.MenubarPreferencesMenu,
-                            when: CONTEXT_HAS_CONFLICTS,
-                            order: 2
-                        }]
-                });
-            }
-            async run() {
-                return that.userDataSyncWorkbenchService.showConflicts();
-            }
-        });
-    }
-    registerManageSyncAction() {
-        const that = this;
-        const when = ( ContextKeyExpr.and(CONTEXT_SYNC_ENABLEMENT, ( CONTEXT_ACCOUNT_STATE.isEqualTo("available" )), ( CONTEXT_SYNC_STATE.notEqualsTo("uninitialized" ))));
-        this._register(registerAction2(class SyncStatusAction extends Action2 {
-            constructor() {
-                super({
-                    id: 'workbench.userDataSync.actions.manage',
-                    title: ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                        'sync is on',
-                        "Settings Sync is On"
-                    )),
-                    toggled: ContextKeyTrueExpr.INSTANCE,
-                    menu: [
-                        {
-                            id: MenuId.GlobalActivity,
-                            group: '3_settings_sync',
-                            when,
-                            order: 2
-                        },
-                        {
-                            id: MenuId.MenubarPreferencesMenu,
-                            group: '3_settings_sync',
-                            when,
-                            order: 2,
-                        },
-                        {
-                            id: MenuId.AccountsContext,
-                            group: '1_settings',
-                            when,
-                        }
-                    ],
-                });
-            }
-            run(accessor) {
-                return ( new Promise((c, e) => {
-                    const quickInputService = accessor.get(IQuickInputService);
-                    const commandService = accessor.get(ICommandService);
-                    const disposables = ( new DisposableStore());
-                    const quickPick = quickInputService.createQuickPick();
-                    disposables.add(quickPick);
-                    const items = [];
-                    if (that.userDataSyncService.conflicts.length) {
-                        items.push({ id: showConflictsCommandId, label: `${SYNC_TITLE.value}: ${that.getShowConflictsTitle().original}` });
-                        items.push({ type: 'separator' });
-                    }
-                    items.push({ id: configureSyncCommand.id, label: `${SYNC_TITLE.value}: ${configureSyncCommand.title.original}` });
-                    items.push({ id: showSyncSettingsCommand.id, label: `${SYNC_TITLE.value}: ${showSyncSettingsCommand.title.original}` });
-                    items.push({ id: showSyncedDataCommand.id, label: `${SYNC_TITLE.value}: ${showSyncedDataCommand.title.original}` });
-                    items.push({ type: 'separator' });
-                    items.push({ id: syncNowCommand.id, label: `${SYNC_TITLE.value}: ${syncNowCommand.title.original}`, description: syncNowCommand.description(that.userDataSyncService) });
-                    if (that.userDataSyncEnablementService.canToggleEnablement()) {
-                        const account = that.userDataSyncWorkbenchService.current;
-                        items.push({ id: turnOffSyncCommand.id, label: `${SYNC_TITLE.value}: ${turnOffSyncCommand.title.original}`, description: account ? `${account.accountName} (${that.authenticationService.getProvider(account.authenticationProviderId).label})` : undefined });
-                    }
-                    quickPick.items = items;
-                    disposables.add(quickPick.onDidAccept(() => {
-                        if (quickPick.selectedItems[0] && quickPick.selectedItems[0].id) {
-                            commandService.executeCommand(quickPick.selectedItems[0].id);
-                        }
-                        quickPick.hide();
-                    }));
-                    disposables.add(quickPick.onDidHide(() => {
-                        disposables.dispose();
-                        c();
-                    }));
-                    quickPick.show();
-                }));
-            }
-        }));
-    }
-    registerEnableSyncViewsAction() {
-        const that = this;
-        const when = ( ContextKeyExpr.and(( CONTEXT_ACCOUNT_STATE.isEqualTo("available" )), ( CONTEXT_SYNC_STATE.notEqualsTo("uninitialized" ))));
-        this._register(registerAction2(class SyncStatusAction extends Action2 {
-            constructor() {
-                super({
-                    id: showSyncedDataCommand.id,
-                    title: showSyncedDataCommand.title,
-                    category: SYNC_TITLE,
-                    precondition: when,
-                    menu: {
-                        id: MenuId.CommandPalette,
-                        when
-                    }
-                });
-            }
-            run(accessor) {
-                return that.userDataSyncWorkbenchService.showSyncActivity();
-            }
-        }));
-    }
-    registerSyncNowAction() {
-        const that = this;
-        this._register(registerAction2(class SyncNowAction extends Action2 {
-            constructor() {
-                super({
-                    id: syncNowCommand.id,
-                    title: syncNowCommand.title,
-                    category: SYNC_TITLE,
-                    menu: {
-                        id: MenuId.CommandPalette,
-                        when: ( ContextKeyExpr.and(CONTEXT_SYNC_ENABLEMENT, ( CONTEXT_ACCOUNT_STATE.isEqualTo("available" )), ( CONTEXT_SYNC_STATE.notEqualsTo("uninitialized" ))))
-                    }
-                });
-            }
-            run(accessor) {
-                return that.userDataSyncWorkbenchService.syncNow();
-            }
-        }));
-    }
-    registerTurnOffSyncAction() {
-        const that = this;
-        this._register(registerAction2(class StopSyncAction extends Action2 {
-            constructor() {
-                super({
-                    id: turnOffSyncCommand.id,
-                    title: turnOffSyncCommand.title,
-                    category: SYNC_TITLE,
-                    menu: {
-                        id: MenuId.CommandPalette,
-                        when: ( ContextKeyExpr.and(( CONTEXT_SYNC_STATE.notEqualsTo("uninitialized" )), CONTEXT_SYNC_ENABLEMENT)),
-                    },
-                });
-            }
-            async run() {
-                try {
-                    await that.turnOff();
-                }
-                catch (e) {
-                    if (!isCancellationError(e)) {
-                        that.notificationService.error(( localizeWithPath(
-                            'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                            'turn off failed',
-                            "Error while turning off Settings Sync. Please check [logs]({0}) for more details.",
-                            `command:${SHOW_SYNC_LOG_COMMAND_ID}`
-                        )));
-                    }
-                }
-            }
-        }));
-    }
-    registerConfigureSyncAction() {
-        const that = this;
-        const when = ( ContextKeyExpr.and(( CONTEXT_SYNC_STATE.notEqualsTo("uninitialized" )), CONTEXT_SYNC_ENABLEMENT));
-        this._register(registerAction2(class ConfigureSyncAction extends Action2 {
-            constructor() {
-                super({
-                    id: configureSyncCommand.id,
-                    title: configureSyncCommand.title,
-                    category: SYNC_TITLE,
-                    icon: Codicon.settingsGear,
-                    tooltip: ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                        'configure',
-                        "Configure..."
-                    )),
-                    menu: [{
-                            id: MenuId.CommandPalette,
-                            when
-                        }, {
-                            id: MenuId.ViewContainerTitle,
-                            when: ( ContextKeyExpr.and(CONTEXT_SYNC_ENABLEMENT, ( ContextKeyExpr.equals('viewContainer', SYNC_VIEW_CONTAINER_ID)))),
-                            group: 'navigation',
-                            order: 2
-                        }]
-                });
-            }
-            run() { return that.configureSyncOptions(); }
-        }));
-    }
-    registerShowLogAction() {
-        const that = this;
-        this._register(registerAction2(class ShowSyncActivityAction extends Action2 {
-            constructor() {
-                super({
-                    id: SHOW_SYNC_LOG_COMMAND_ID,
-                    title: ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                        'show sync log title',
-                        "{0}: Show Log",
-                        SYNC_TITLE.value
-                    )),
-                    tooltip: ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                        'show sync log toolrip',
-                        "Show Log"
-                    )),
-                    icon: Codicon.output,
-                    menu: [{
-                            id: MenuId.CommandPalette,
-                            when: ( ContextKeyExpr.and(( CONTEXT_SYNC_STATE.notEqualsTo("uninitialized" )))),
-                        }, {
-                            id: MenuId.ViewContainerTitle,
-                            when: ( ContextKeyExpr.equals('viewContainer', SYNC_VIEW_CONTAINER_ID)),
-                            group: 'navigation',
-                            order: 1
-                        }],
-                });
-            }
-            run() { return that.showSyncActivity(); }
-        }));
-    }
-    registerShowSettingsAction() {
-        this._register(registerAction2(class ShowSyncSettingsAction extends Action2 {
-            constructor() {
-                super({
-                    id: showSyncSettingsCommand.id,
-                    title: showSyncSettingsCommand.title,
-                    category: SYNC_TITLE,
-                    menu: {
-                        id: MenuId.CommandPalette,
-                        when: ( ContextKeyExpr.and(( CONTEXT_SYNC_STATE.notEqualsTo("uninitialized" )))),
-                    },
-                });
-            }
-            run(accessor) {
-                accessor.get(IPreferencesService).openUserSettings({ jsonEditor: false, query: '@tag:sync' });
-            }
-        }));
-    }
-    registerHelpAction() {
-        const that = this;
-        this._register(registerAction2(class HelpAction extends Action2 {
-            constructor() {
-                super({
-                    id: 'workbench.userDataSync.actions.help',
-                    title: SYNC_TITLE,
-                    category: Categories.Help,
-                    menu: [{
-                            id: MenuId.CommandPalette,
-                            when: ( ContextKeyExpr.and(( CONTEXT_SYNC_STATE.notEqualsTo("uninitialized" )))),
-                        }],
-                });
-            }
-            run() { return that.openerService.open(( URI.parse('https://aka.ms/vscode-settings-sync-help'))); }
-        }));
-        MenuRegistry.appendMenuItem(MenuId.ViewContainerTitle, {
-            command: {
-                id: 'workbench.userDataSync.actions.help',
-                title: Categories.Help.value
-            },
-            when: ( ContextKeyExpr.equals('viewContainer', SYNC_VIEW_CONTAINER_ID)),
-            group: '1_help',
-        });
-    }
-    registerAcceptMergesAction() {
-        const that = this;
-        this._register(registerAction2(class AcceptMergesAction extends Action2 {
-            constructor() {
-                super({
-                    id: 'workbench.userDataSync.actions.acceptMerges',
-                    title: ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                        'complete merges title',
-                        "Complete Merge"
-                    )),
-                    menu: [{
-                            id: MenuId.EditorContent,
-                            when: ( ContextKeyExpr.and(ctxIsMergeResultEditor, ( ContextKeyExpr.regex(ctxMergeBaseUri.key, ( new RegExp(`^${USER_DATA_SYNC_SCHEME}:`)))))),
-                        }],
-                });
-            }
-            async run(accessor, previewResource) {
-                const textFileService = accessor.get(ITextFileService);
-                await textFileService.save(previewResource);
-                const content = await textFileService.read(previewResource);
-                await that.userDataSyncService.accept(this.getSyncResource(previewResource), previewResource, content.value, true);
-            }
-            getSyncResource(previewResource) {
-                const conflict = that.userDataSyncService.conflicts.find(({ conflicts }) => ( conflicts.some(conflict => isEqual(conflict.previewResource, previewResource))));
-                if (conflict) {
-                    return conflict;
-                }
-                throw new Error(`Unknown resource: ${previewResource.toString()}`);
-            }
-        }));
-    }
-    registerDownloadSyncActivityAction() {
-        this._register(registerAction2(class DownloadSyncActivityAction extends Action2 {
-            constructor() {
-                super(DOWNLOAD_ACTIVITY_ACTION_DESCRIPTOR);
-            }
-            async run(accessor) {
-                const userDataSyncWorkbenchService = accessor.get(IUserDataSyncWorkbenchService);
-                const notificationService = accessor.get(INotificationService);
-                const folder = await userDataSyncWorkbenchService.downloadSyncActivity();
-                if (folder) {
-                    notificationService.info(( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                        'download sync activity complete',
-                        "Successfully downloaded Settings Sync activity."
-                    )));
-                }
-            }
-        }));
-    }
-    registerViews() {
-        const container = this.registerViewContainer();
-        this.registerDataViews(container);
-    }
-    registerViewContainer() {
-        return ( Registry.as(Extensions.ViewContainersRegistry)).registerViewContainer({
-            id: SYNC_VIEW_CONTAINER_ID,
-            title: SYNC_TITLE,
-            ctorDescriptor: ( new SyncDescriptor(
-                ViewPaneContainer,
-                [SYNC_VIEW_CONTAINER_ID, { mergeViewWithContainerWhenSingleView: true }]
-            )),
-            icon: SYNC_VIEW_ICON,
-            hideIfEmpty: true,
-        }, 0 );
-    }
-    registerResetSyncDataAction() {
-        const that = this;
-        this._register(registerAction2(class extends Action2 {
-            constructor() {
-                super({
-                    id: 'workbench.actions.syncData.reset',
-                    title: ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSync',
-                        'workbench.actions.syncData.reset',
-                        "Clear Data in Cloud..."
-                    )),
-                    menu: [{
-                            id: MenuId.ViewContainerTitle,
-                            when: ( ContextKeyExpr.equals('viewContainer', SYNC_VIEW_CONTAINER_ID)),
-                            group: '0_configure',
-                        }],
-                });
-            }
-            run() { return that.userDataSyncWorkbenchService.resetSyncedData(); }
-        }));
-    }
-    registerDataViews(container) {
-        this._register(this.instantiationService.createInstance(UserDataSyncDataViews, container));
-    }
-};
-UserDataSyncWorkbenchContribution = ( __decorate([
-    ( __param(0, IUserDataSyncEnablementService)),
-    ( __param(1, IUserDataSyncService)),
-    ( __param(2, IUserDataSyncWorkbenchService)),
-    ( __param(3, IContextKeyService)),
-    ( __param(4, IActivityService)),
-    ( __param(5, INotificationService)),
-    ( __param(6, IEditorService)),
-    ( __param(7, IUserDataProfilesService)),
-    ( __param(8, IUserDataProfileService)),
-    ( __param(9, IDialogService)),
-    ( __param(10, IQuickInputService)),
-    ( __param(11, IInstantiationService)),
-    ( __param(12, IOutputService)),
-    ( __param(13, IUserDataAutoSyncService)),
-    ( __param(14, ITextModelService)),
-    ( __param(15, IPreferencesService)),
-    ( __param(16, ITelemetryService)),
-    ( __param(17, IProductService)),
-    ( __param(18, IOpenerService)),
-    ( __param(19, IAuthenticationService)),
-    ( __param(20, IUserDataSyncStoreManagementService)),
-    ( __param(21, IHostService)),
-    ( __param(22, ICommandService)),
-    ( __param(23, IWorkbenchIssueService))
-], UserDataSyncWorkbenchContribution));
-let UserDataRemoteContentProvider = class UserDataRemoteContentProvider {
-    constructor(userDataSyncService, modelService, languageService) {
-        this.userDataSyncService = userDataSyncService;
-        this.modelService = modelService;
-        this.languageService = languageService;
-    }
-    provideTextContent(uri) {
-        if (uri.scheme === USER_DATA_SYNC_SCHEME) {
-            return this.userDataSyncService.resolveContent(uri).then(content => this.modelService.createModel(content || '', this.languageService.createById('jsonc'), uri));
-        }
-        return null;
-    }
-};
-UserDataRemoteContentProvider = ( __decorate([
-    ( __param(0, IUserDataSyncService)),
-    ( __param(1, IModelService)),
-    ( __param(2, ILanguageService))
-], UserDataRemoteContentProvider));
-export { UserDataSyncWorkbenchContribution };