@codingame/monaco-vscode-api 3.2.3 → 4.1.0

package/vscode/src/vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService.js

@@ -0,0 +1,1752 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/userDataProfileView.css.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { SyncDescriptor } from '../../../../platform/instantiation/common/descriptors.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.js';
+import { Event, Emitter } from '../../../../base/common/event.js';
+import { $, append, addDisposableListener, Dimension, getClientArea, clearNode, EventHelper, EventType } from '../../../../base/browser/dom.js';
+import { IS_PROFILE_EXPORT_IN_PROGRESS_CONTEXT, IS_PROFILE_IMPORT_IN_PROGRESS_CONTEXT, PROFILES_TITLE, defaultUserDataProfileIcon, PROFILE_URL_AUTHORITY, PROFILE_FILTER, PROFILE_EXTENSION, PROFILES_CATEGORY, toUserDataProfileUri, IUserDataProfileService, IUserDataProfileManagementService } from '../common/userDataProfile.js';
+import { Disposable, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
+import { ITextFileService } from '../../textfile/common/textfiles.js';
+import { IFileService } from '../../../../platform/files/common/files.js';
+import { URI } from '../../../../base/common/uri.js';
+import { Extensions, TreeItemCollapsibleState, IViewDescriptorService } from '../../../common/views.js';
+import { IViewsService } from '../../views/common/viewsService.js';
+import { isUserDataProfile, toUserDataProfile, IUserDataProfilesService } from '../../../../platform/userDataProfile/common/userDataProfile.js';
+import { ContextKeyExpr, IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { ViewPaneContainer } from '../../../browser/parts/views/viewPaneContainer.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { TreeView, TreeViewPane } from '../../../browser/parts/views/treeView.js';
+import { SettingsResource, SettingsResourceTreeItem } from './settingsResource.js';
+import { KeybindingsResource, KeybindingsResourceTreeItem } from './keybindingsResource.js';
+import { SnippetsResource, SnippetsResourceTreeItem } from './snippetsResource.js';
+import { TasksResource, TasksResourceTreeItem } from './tasksResource.js';
+import { ExtensionsResource, ExtensionsResourceExportTreeItem, ExtensionsResourceImportTreeItem, ExtensionsResourceTreeItem } from './extensionsResource.js';
+import { GlobalStateResource, GlobalStateResourceExportTreeItem, GlobalStateResourceImportTreeItem, GlobalStateResourceTreeItem } from './globalStateResource.js';
+import { InMemoryFileSystemProvider } from '../../../../platform/files/common/inMemoryFilesystemProvider.js';
+import { Button } from '../../../../base/browser/ui/button/button.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { IContextViewService, IContextMenuService } from '../../../../platform/contextview/browser/contextView.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { IOpenerService } from '../../../../platform/opener/common/opener.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+import { defaultInputBoxStyles, defaultSelectBoxStyles, defaultButtonStyles } from '../../../../platform/theme/browser/defaultStyles.js';
+import { generateUuid } from '../../../../base/common/uuid.js';
+import { IEditorService } from '../../editor/common/editorService.js';
+import { getErrorMessage, onUnexpectedError } from '../../../../base/common/errors.js';
+import { IProgressService } from '../../../../platform/progress/common/progress.js';
+import { IExtensionService } from '../../extensions/common/extensions.js';
+import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
+import { VSBuffer } from '../../../../base/common/buffer.js';
+import { joinPath } from '../../../../base/common/resources.js';
+import { escapeRegExpCharacters } from '../../../../base/common/strings.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import Severity$1 from '../../../../base/common/severity.js';
+import { IClipboardService } from '../../../../platform/clipboard/common/clipboardService.js';
+import { IURLService } from '../../../../platform/url/common/url.js';
+import { asText, IRequestService } from '../../../../platform/request/common/request.js';
+import { IProductService } from '../../../../platform/product/common/productService.js';
+import { isUndefined } from '../../../../base/common/types.js';
+import { Action, ActionRunner } from '../../../../base/common/actions.js';
+import { isWeb } from '../../../../base/common/platform.js';
+import { registerAction2, Action2, MenuId } from '../../../../platform/actions/common/actions.js';
+import { getAllCodicons, Codicon } from '../../../../base/common/codicons.js';
+import { Barrier } from '../../../../base/common/async.js';
+import { IExtensionManagementService } from '../../../../platform/extensionManagement/common/extensionManagement.js';
+import { areSameExtensions } from '../../../../platform/extensionManagement/common/extensionManagementUtil.js';
+import { MarkdownString } from '../../../../base/common/htmlContent.js';
+import { renderMarkdown } from '../../../../base/browser/markdownRenderer.js';
+import { showWindowLogActionId } from '../../log/common/logConstants.js';
+import { SelectBox } from '../../../../base/browser/ui/selectBox/selectBox.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { IHoverService } from '../../../../platform/hover/browser/hover.js';
+import { ICONS, DEFAULT_ICON } from '../common/userDataProfileIcons.js';
+import { WorkbenchIconSelectBox } from './iconSelectBox.js';
+import { StandardKeyboardEvent } from '../../../../base/browser/keyboardEvent.js';
+import { IDialogService, IFileDialogService } from '../../../../platform/dialogs/common/dialogs.js';
+var UserDataProfileImportExportService_1;
+function isUserDataProfileTemplate(thing) {
+    const candidate = thing;
+    return !!(candidate && typeof candidate === 'object'
+        && (candidate.name && typeof candidate.name === 'string')
+        && (isUndefined(candidate.icon) || typeof candidate.icon === 'string')
+        && (isUndefined(candidate.settings) || typeof candidate.settings === 'string')
+        && (isUndefined(candidate.globalState) || typeof candidate.globalState === 'string')
+        && (isUndefined(candidate.extensions) || typeof candidate.extensions === 'string'));
+}
+const EXPORT_PROFILE_PREVIEW_VIEW = 'workbench.views.profiles.export.preview';
+const IMPORT_PROFILE_PREVIEW_VIEW = 'workbench.views.profiles.import.preview';
+let UserDataProfileImportExportService = class UserDataProfileImportExportService extends Disposable {
+    static { UserDataProfileImportExportService_1 = this; }
+    static { this.PROFILE_URL_AUTHORITY_PREFIX = 'profile-'; }
+    constructor(instantiationService, userDataProfileService, viewsService, editorService, contextKeyService, userDataProfileManagementService, userDataProfilesService, extensionService, extensionManagementService, quickInputService, notificationService, progressService, dialogService, clipboardService, openerService, requestService, urlService, productService, uriIdentityService, telemetryService, contextViewService, hoverService, logService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.userDataProfileService = userDataProfileService;
+        this.viewsService = viewsService;
+        this.editorService = editorService;
+        this.userDataProfileManagementService = userDataProfileManagementService;
+        this.userDataProfilesService = userDataProfilesService;
+        this.extensionService = extensionService;
+        this.extensionManagementService = extensionManagementService;
+        this.quickInputService = quickInputService;
+        this.notificationService = notificationService;
+        this.progressService = progressService;
+        this.dialogService = dialogService;
+        this.clipboardService = clipboardService;
+        this.openerService = openerService;
+        this.requestService = requestService;
+        this.productService = productService;
+        this.uriIdentityService = uriIdentityService;
+        this.telemetryService = telemetryService;
+        this.contextViewService = contextViewService;
+        this.hoverService = hoverService;
+        this.logService = logService;
+        this.profileContentHandlers = ( new Map());
+        this.registerProfileContentHandler(Schemas.file, this.fileUserDataProfileContentHandler = instantiationService.createInstance(FileUserDataProfileContentHandler));
+        this.isProfileExportInProgressContextKey = IS_PROFILE_EXPORT_IN_PROGRESS_CONTEXT.bindTo(contextKeyService);
+        this.isProfileImportInProgressContextKey = IS_PROFILE_IMPORT_IN_PROGRESS_CONTEXT.bindTo(contextKeyService);
+        this.viewContainer = ( Registry.as(Extensions.ViewContainersRegistry)).registerViewContainer({
+            id: 'userDataProfiles',
+            title: PROFILES_TITLE,
+            ctorDescriptor: ( new SyncDescriptor(
+                ViewPaneContainer,
+                ['userDataProfiles', { mergeViewWithContainerWhenSingleView: true }]
+            )),
+            icon: defaultUserDataProfileIcon,
+            hideIfEmpty: true,
+        }, 0 );
+        urlService.registerHandler(this);
+    }
+    isProfileURL(uri) {
+        return uri.authority === PROFILE_URL_AUTHORITY || ( new RegExp(`^${UserDataProfileImportExportService_1.PROFILE_URL_AUTHORITY_PREFIX}`)).test(uri.authority);
+    }
+    async handleURL(uri) {
+        if (this.isProfileURL(uri)) {
+            try {
+                await this.importProfile(uri);
+            }
+            catch (error) {
+                this.notificationService.error(( localizeWithPath(
+                    'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                    'profile import error',
+                    "Error while importing profile: {0}",
+                    getErrorMessage(error)
+                )));
+            }
+            return true;
+        }
+        return false;
+    }
+    registerProfileContentHandler(id, profileContentHandler) {
+        if (( this.profileContentHandlers.has(id))) {
+            throw new Error(`Profile content handler with id '${id}' already registered.`);
+        }
+        this.profileContentHandlers.set(id, profileContentHandler);
+        return toDisposable(() => this.unregisterProfileContentHandler(id));
+    }
+    unregisterProfileContentHandler(id) {
+        this.profileContentHandlers.delete(id);
+    }
+    async exportProfile() {
+        if (this.isProfileExportInProgressContextKey.get()) {
+            this.logService.warn('Profile export already in progress.');
+            return;
+        }
+        return this.showProfileContents();
+    }
+    async importProfile(uri, options) {
+        if (this.isProfileImportInProgressContextKey.get()) {
+            this.notificationService.warn('Profile import already in progress.');
+            return;
+        }
+        this.isProfileImportInProgressContextKey.set(true);
+        const disposables = ( new DisposableStore());
+        disposables.add(toDisposable(() => this.isProfileImportInProgressContextKey.set(false)));
+        try {
+            const mode = options?.mode ?? 'preview';
+            const profileTemplate = await this.progressService.withProgress({
+                location: 10 ,
+                command: showWindowLogActionId,
+                title: ( localizeWithPath(
+                    'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                    'resolving uri',
+                    "{0}: Resolving profile content...",
+                    options?.mode ? ( localizeWithPath(
+                        'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                        'preview profile',
+                        "Preview Profile"
+                    )) : ( localizeWithPath(
+                        'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                        'import profile',
+                        "Create Profile"
+                    ))
+                )),
+            }, () => this.resolveProfileTemplate(uri, options));
+            if (!profileTemplate) {
+                return;
+            }
+            if (mode === 'preview') {
+                await this.previewProfile(profileTemplate, options);
+            }
+            else if (mode === 'apply') {
+                await this.createAndSwitch(profileTemplate, false, true, options, ( localizeWithPath(
+                    'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                    'create profile',
+                    "Create Profile"
+                )));
+            }
+            else if (mode === 'both') {
+                await this.importAndPreviewProfile(uri, profileTemplate, options);
+            }
+        }
+        finally {
+            disposables.dispose();
+        }
+    }
+    createProfile(from) {
+        return this.saveProfile(undefined, from);
+    }
+    editProfile(profile) {
+        return this.saveProfile(profile);
+    }
+    async saveProfile(profile, source) {
+        const createProfileTelemetryData = { source: source instanceof URI ? 'template' : isUserDataProfile(source) ? 'profile' : source ? 'external' : undefined };
+        if (profile) {
+            this.telemetryService.publicLog2('userDataProfile.startEdit');
+        }
+        else {
+            this.telemetryService.publicLog2('userDataProfile.startCreate', createProfileTelemetryData);
+        }
+        const disposables = ( new DisposableStore());
+        const title = profile ? ( localizeWithPath(
+            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+            'save profile',
+            "Edit {0} Profile...",
+            profile.name
+        )) : ( localizeWithPath(
+            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+            'create new profle',
+            "Create New Profile..."
+        ));
+        const settings = { id: "settings" , label: ( localizeWithPath(
+            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+            'settings',
+            "Settings"
+        )), picked: !profile?.useDefaultFlags?.settings };
+        const keybindings = { id: "keybindings" , label: ( localizeWithPath(
+            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+            'keybindings',
+            "Keyboard Shortcuts"
+        )), picked: !profile?.useDefaultFlags?.keybindings };
+        const snippets = { id: "snippets" , label: ( localizeWithPath(
+            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+            'snippets',
+            "User Snippets"
+        )), picked: !profile?.useDefaultFlags?.snippets };
+        const tasks = { id: "tasks" , label: ( localizeWithPath(
+            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+            'tasks',
+            "User Tasks"
+        )), picked: !profile?.useDefaultFlags?.tasks };
+        const extensions = { id: "extensions" , label: ( localizeWithPath(
+            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+            'extensions',
+            "Extensions"
+        )), picked: !profile?.useDefaultFlags?.extensions };
+        const resources = [settings, keybindings, snippets, tasks, extensions];
+        const quickPick = this.quickInputService.createQuickPick();
+        quickPick.title = title;
+        quickPick.placeholder = ( localizeWithPath(
+            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+            'name placeholder',
+            "Profile name"
+        ));
+        quickPick.value = profile?.name ?? (isUserDataProfileTemplate(source) ? this.generateProfileName(source.name) : '');
+        quickPick.canSelectMany = true;
+        quickPick.matchOnDescription = false;
+        quickPick.matchOnDetail = false;
+        quickPick.matchOnLabel = false;
+        quickPick.sortByLabel = false;
+        quickPick.hideCountBadge = true;
+        quickPick.ok = false;
+        quickPick.customButton = true;
+        quickPick.hideCheckAll = true;
+        quickPick.ignoreFocusOut = true;
+        quickPick.customLabel = profile ? ( localizeWithPath(
+            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+            'save',
+            "Save"
+        )) : ( localizeWithPath(
+            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+            'create',
+            "Create"
+        ));
+        quickPick.description = ( localizeWithPath(
+            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+            'customise the profile',
+            "Choose what to configure in your Profile:"
+        ));
+        quickPick.items = [...resources];
+        const update = () => {
+            quickPick.items = resources;
+            quickPick.selectedItems = resources.filter(item => item.picked);
+        };
+        update();
+        const validate = () => {
+            if (!profile && ( this.userDataProfilesService.profiles.some(p => p.name === quickPick.value))) {
+                quickPick.validationMessage = ( localizeWithPath(
+                    'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                    'profileExists',
+                    "Profile with name {0} already exists.",
+                    quickPick.value
+                ));
+                quickPick.severity = Severity$1.Warning;
+                return;
+            }
+            if (resources.every(resource => !resource.picked)) {
+                quickPick.validationMessage = ( localizeWithPath(
+                    'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                    'invalid configurations',
+                    "The profile should contain at least one configuration."
+                ));
+                quickPick.severity = Severity$1.Warning;
+                return;
+            }
+            quickPick.severity = Severity$1.Ignore;
+            quickPick.validationMessage = undefined;
+        };
+        disposables.add(quickPick.onDidChangeSelection(items => {
+            let needUpdate = false;
+            for (const resource of resources) {
+                resource.picked = items.includes(resource);
+                const description = resource.picked ? undefined : ( localizeWithPath(
+                    'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                    'use default profile',
+                    "Using Default Profile"
+                ));
+                if (resource.description !== description) {
+                    resource.description = description;
+                    needUpdate = true;
+                }
+            }
+            if (needUpdate) {
+                update();
+            }
+            validate();
+        }));
+        disposables.add(quickPick.onDidChangeValue(validate));
+        let icon = DEFAULT_ICON;
+        if (profile?.icon) {
+            icon = ThemeIcon.fromId(profile.icon);
+        }
+        if (isUserDataProfileTemplate(source) && source.icon) {
+            icon = ThemeIcon.fromId(source.icon);
+        }
+        if (icon.id !== DEFAULT_ICON.id && !( ICONS.some(({ id }) => id === icon.id)) && !( getAllCodicons().some(({ id }) => id === icon.id))) {
+            icon = DEFAULT_ICON;
+        }
+        let result;
+        disposables.add(Event.any(quickPick.onDidCustom, quickPick.onDidAccept)(() => {
+            const name = quickPick.value.trim();
+            if (!name) {
+                quickPick.validationMessage = ( localizeWithPath(
+                    'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                    'name required',
+                    "Profile name is required and must be a non-empty value."
+                ));
+                quickPick.severity = Severity$1.Error;
+            }
+            if (quickPick.validationMessage) {
+                return;
+            }
+            result = { name, items: quickPick.selectedItems, icon: icon.id === DEFAULT_ICON.id ? null : icon.id };
+            quickPick.hide();
+            quickPick.severity = Severity$1.Ignore;
+            quickPick.validationMessage = undefined;
+        }));
+        const domNode = $('.profile-edit-widget');
+        const profileIconContainer = $('.profile-icon-container');
+        append(profileIconContainer, $('.profile-icon-label', undefined, ( localizeWithPath(
+            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+            'icon',
+            "Icon:"
+        ))));
+        const profileIconElement = append(profileIconContainer, $(`.profile-icon${ThemeIcon.asCSSSelector(icon)}`));
+        profileIconElement.tabIndex = 0;
+        profileIconElement.role = 'button';
+        profileIconElement.ariaLabel = ( localizeWithPath(
+            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+            'select icon',
+            "Icon: {0}",
+            icon.id
+        ));
+        const iconSelectBox = disposables.add(this.instantiationService.createInstance(WorkbenchIconSelectBox, { icons: ICONS, inputBoxStyles: defaultInputBoxStyles }));
+        const dimension = new Dimension(486, 260);
+        iconSelectBox.layout(dimension);
+        let hoverWidget;
+        const updateIcon = (updated) => {
+            icon = updated ?? DEFAULT_ICON;
+            profileIconElement.className = `profile-icon ${ThemeIcon.asClassName(icon)}`;
+            profileIconElement.ariaLabel = ( localizeWithPath(
+                'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                'select icon',
+                "Icon: {0}",
+                icon.id
+            ));
+        };
+        disposables.add(iconSelectBox.onDidSelect(selectedIcon => {
+            if (icon.id !== selectedIcon.id) {
+                updateIcon(selectedIcon);
+            }
+            hoverWidget?.dispose();
+            profileIconElement.focus();
+        }));
+        const showIconSelectBox = () => {
+            iconSelectBox.clearInput();
+            hoverWidget = this.hoverService.showHover({
+                content: iconSelectBox.domNode,
+                target: profileIconElement,
+                position: {
+                    hoverPosition: 2 ,
+                },
+                persistence: {
+                    sticky: true,
+                },
+                appearance: {
+                    showPointer: true,
+                },
+            }, true);
+            if (hoverWidget) {
+                iconSelectBox.layout(dimension);
+                disposables.add(hoverWidget);
+            }
+            iconSelectBox.focus();
+        };
+        disposables.add(addDisposableListener(profileIconElement, EventType.CLICK, (e) => {
+            EventHelper.stop(e, true);
+            showIconSelectBox();
+        }));
+        disposables.add(addDisposableListener(profileIconElement, EventType.KEY_DOWN, e => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.equals(3 ) || event.equals(10 )) {
+                EventHelper.stop(event, true);
+                showIconSelectBox();
+            }
+        }));
+        disposables.add(addDisposableListener(iconSelectBox.domNode, EventType.KEY_DOWN, e => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.equals(9 )) {
+                EventHelper.stop(event, true);
+                hoverWidget?.dispose();
+                profileIconElement.focus();
+            }
+        }));
+        if (!profile && !isUserDataProfileTemplate(source)) {
+            const profileTypeContainer = append(domNode, $('.profile-type-container'));
+            append(profileTypeContainer, $('.profile-type-create-label', undefined, ( localizeWithPath(
+                'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                'create from',
+                "Copy from:"
+            ))));
+            const separator = { text: '\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500', isDisabled: true };
+            const profileOptions = [];
+            profileOptions.push({ text: ( localizeWithPath(
+                'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                'empty profile',
+                "None"
+            )) });
+            const templates = await this.userDataProfileManagementService.getBuiltinProfileTemplates();
+            if (templates.length) {
+                profileOptions.push({ ...separator, decoratorRight: ( localizeWithPath(
+                    'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                    'from templates',
+                    "Profile Templates"
+                )) });
+                for (const template of templates) {
+                    profileOptions.push({ text: template.name, id: template.url, source: ( URI.parse(template.url)) });
+                }
+            }
+            profileOptions.push({ ...separator, decoratorRight: ( localizeWithPath(
+                'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                'from existing profiles',
+                "Existing Profiles"
+            )) });
+            for (const profile of this.userDataProfilesService.profiles) {
+                profileOptions.push({ text: profile.name, id: profile.id, source: profile });
+            }
+            const findOptionIndex = () => {
+                const index = profileOptions.findIndex(option => {
+                    if (source instanceof URI) {
+                        return option.source instanceof URI && this.uriIdentityService.extUri.isEqual(option.source, source);
+                    }
+                    else if (isUserDataProfile(source)) {
+                        return option.id === source.id;
+                    }
+                    return false;
+                });
+                return index > -1 ? index : 0;
+            };
+            const initialIndex = findOptionIndex();
+            const selectBox = disposables.add(this.instantiationService.createInstance(SelectBox, profileOptions, initialIndex, this.contextViewService, defaultSelectBoxStyles, {
+                useCustomDrawn: true,
+                ariaLabel: ( localizeWithPath(
+                    'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                    'copy profile from',
+                    "Copy profile from"
+                )),
+            }));
+            selectBox.render(append(profileTypeContainer, $('.profile-type-select-container')));
+            if (profileOptions[initialIndex].source) {
+                quickPick.value = this.generateProfileName(profileOptions[initialIndex].text);
+            }
+            const updateOptions = () => {
+                const option = profileOptions[findOptionIndex()];
+                for (const resource of resources) {
+                    resource.picked = option.source && !(option.source instanceof URI) ? !option.source?.useDefaultFlags?.[resource.id] : true;
+                }
+                updateIcon(!(option.source instanceof URI) && option.source?.icon ? ThemeIcon.fromId(option.source.icon) : undefined);
+                update();
+            };
+            updateOptions();
+            disposables.add(selectBox.onDidSelect(({ index }) => {
+                source = profileOptions[index].source;
+                updateOptions();
+            }));
+        }
+        append(domNode, profileIconContainer);
+        quickPick.widget = domNode;
+        quickPick.show();
+        await ( new Promise((c, e) => {
+            disposables.add(quickPick.onDidHide(() => {
+                disposables.dispose();
+                c();
+            }));
+        }));
+        if (!result) {
+            if (profile) {
+                this.telemetryService.publicLog2('userDataProfile.cancelEdit');
+            }
+            else {
+                this.telemetryService.publicLog2('userDataProfile.cancelCreate', createProfileTelemetryData);
+            }
+            return;
+        }
+        try {
+            const useDefaultFlags = result.items.length === resources.length
+                ? undefined
+                : {
+                    settings: !result.items.includes(settings),
+                    keybindings: !result.items.includes(keybindings),
+                    snippets: !result.items.includes(snippets),
+                    tasks: !result.items.includes(tasks),
+                    extensions: !result.items.includes(extensions)
+                };
+            if (profile) {
+                await this.userDataProfileManagementService.updateProfile(profile, { name: result.name, icon: result.icon, useDefaultFlags: profile.useDefaultFlags && !useDefaultFlags ? {} : useDefaultFlags });
+            }
+            else {
+                if (source instanceof URI) {
+                    this.telemetryService.publicLog2('userDataProfile.createFromTemplate', createProfileTelemetryData);
+                    await this.importProfile(source, { mode: 'apply', name: result.name, useDefaultFlags, icon: result.icon ? result.icon : undefined });
+                }
+                else if (isUserDataProfile(source)) {
+                    this.telemetryService.publicLog2('userDataProfile.createFromProfile', createProfileTelemetryData);
+                    await this.createFromProfile(source, result.name, { useDefaultFlags, icon: result.icon ? result.icon : undefined });
+                }
+                else if (isUserDataProfileTemplate(source)) {
+                    source.name = result.name;
+                    this.telemetryService.publicLog2('userDataProfile.createFromExternalTemplate', createProfileTelemetryData);
+                    await this.createAndSwitch(source, false, true, { useDefaultFlags, icon: result.icon ? result.icon : undefined }, ( localizeWithPath(
+                        'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                        'create profile',
+                        "Create Profile"
+                    )));
+                }
+                else {
+                    this.telemetryService.publicLog2('userDataProfile.createEmptyProfile', createProfileTelemetryData);
+                    await this.userDataProfileManagementService.createAndEnterProfile(result.name, { useDefaultFlags, icon: result.icon ? result.icon : undefined });
+                }
+            }
+        }
+        catch (error) {
+            this.notificationService.error(error);
+        }
+    }
+    async showProfileContents() {
+        const view = this.viewsService.getViewWithId(EXPORT_PROFILE_PREVIEW_VIEW);
+        if (view) {
+            this.viewsService.openView(view.id, true);
+            return;
+        }
+        const disposables = ( new DisposableStore());
+        try {
+            const userDataProfilesExportState = disposables.add(this.instantiationService.createInstance(UserDataProfileExportState, this.userDataProfileService.currentProfile));
+            const barrier = ( new Barrier());
+            const exportAction = ( new BarrierAction(barrier, ( new Action('export', ( localizeWithPath(
+                'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                'export',
+                "Export"
+            )), undefined, true, async () => {
+                exportAction.enabled = false;
+                try {
+                    await this.doExportProfile(userDataProfilesExportState);
+                }
+                catch (error) {
+                    this.notificationService.error(error);
+                    throw error;
+                }
+            })), this.notificationService));
+            const closeAction = ( new BarrierAction(barrier, ( new Action('close', ( localizeWithPath(
+                'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                'close',
+                "Close"
+            )))), this.notificationService));
+            await this.showProfilePreviewView(EXPORT_PROFILE_PREVIEW_VIEW, userDataProfilesExportState.profile.name, exportAction, closeAction, true, userDataProfilesExportState);
+            disposables.add(this.userDataProfileService.onDidChangeCurrentProfile(e => barrier.open()));
+            await barrier.wait();
+            await this.hideProfilePreviewView(EXPORT_PROFILE_PREVIEW_VIEW);
+        }
+        finally {
+            disposables.dispose();
+        }
+    }
+    async createFromProfile(profile, name, options) {
+        const userDataProfilesExportState = this.instantiationService.createInstance(UserDataProfileExportState, profile);
+        try {
+            const profileTemplate = await userDataProfilesExportState.getProfileTemplate(name, options?.icon);
+            await this.progressService.withProgress({
+                location: 15 ,
+                delay: 500,
+                sticky: true,
+            }, async (progress) => {
+                const reportProgress = (message) => progress.report({ message: ( localizeWithPath(
+                    'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                    'create from profile',
+                    "Create Profile: {0}",
+                    message
+                )) });
+                const createdProfile = await this.doCreateProfile(profileTemplate, false, false, { useDefaultFlags: options?.useDefaultFlags, icon: options?.icon }, reportProgress);
+                if (createdProfile) {
+                    reportProgress(( localizeWithPath(
+                        'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                        'progress extensions',
+                        "Applying Extensions..."
+                    )));
+                    await this.instantiationService.createInstance(ExtensionsResource).copy(profile, createdProfile, false);
+                    reportProgress(( localizeWithPath(
+                        'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                        'switching profile',
+                        "Switching Profile..."
+                    )));
+                    await this.userDataProfileManagementService.switchProfile(createdProfile);
+                }
+            });
+        }
+        finally {
+            userDataProfilesExportState.dispose();
+        }
+    }
+    async createTroubleshootProfile() {
+        const userDataProfilesExportState = this.instantiationService.createInstance(UserDataProfileExportState, this.userDataProfileService.currentProfile);
+        try {
+            const profileTemplate = await userDataProfilesExportState.getProfileTemplate(( localizeWithPath(
+                'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                'troubleshoot issue',
+                "Troubleshoot Issue"
+            )), undefined);
+            await this.progressService.withProgress({
+                location: 15 ,
+                delay: 1000,
+                sticky: true,
+            }, async (progress) => {
+                const reportProgress = (message) => progress.report({ message: ( localizeWithPath(
+                    'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                    'troubleshoot profile progress',
+                    "Setting up Troubleshoot Profile: {0}",
+                    message
+                )) });
+                const profile = await this.doCreateProfile(profileTemplate, true, false, { useDefaultFlags: this.userDataProfileService.currentProfile.useDefaultFlags }, reportProgress);
+                if (profile) {
+                    reportProgress(( localizeWithPath(
+                        'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                        'progress extensions',
+                        "Applying Extensions..."
+                    )));
+                    await this.instantiationService.createInstance(ExtensionsResource).copy(this.userDataProfileService.currentProfile, profile, true);
+                    reportProgress(( localizeWithPath(
+                        'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                        'switching profile',
+                        "Switching Profile..."
+                    )));
+                    await this.userDataProfileManagementService.switchProfile(profile);
+                }
+            });
+        }
+        finally {
+            userDataProfilesExportState.dispose();
+        }
+    }
+    async doExportProfile(userDataProfilesExportState) {
+        const profile = await userDataProfilesExportState.getProfileToExport();
+        if (!profile) {
+            return;
+        }
+        this.isProfileExportInProgressContextKey.set(true);
+        const disposables = ( new DisposableStore());
+        disposables.add(toDisposable(() => this.isProfileExportInProgressContextKey.set(false)));
+        try {
+            await this.progressService.withProgress({
+                location: EXPORT_PROFILE_PREVIEW_VIEW,
+                title: ( localizeWithPath(
+                    'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                    'profiles.exporting',
+                    "{0}: Exporting...",
+                    PROFILES_CATEGORY.value
+                )),
+            }, async (progress) => {
+                const id = await this.pickProfileContentHandler(profile.name);
+                if (!id) {
+                    return;
+                }
+                const profileContentHandler = this.profileContentHandlers.get(id);
+                if (!profileContentHandler) {
+                    return;
+                }
+                const saveResult = await profileContentHandler.saveProfile(profile.name.replace('/', '-'), JSON.stringify(profile), CancellationToken.None);
+                if (!saveResult) {
+                    return;
+                }
+                const message = ( localizeWithPath(
+                    'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                    'export success',
+                    "Profile '{0}' was exported successfully.",
+                    profile.name
+                ));
+                if (profileContentHandler.extensionId) {
+                    const buttons = [];
+                    const link = this.productService.webUrl ? `${this.productService.webUrl}/${PROFILE_URL_AUTHORITY}/${id}/${saveResult.id}` : ( toUserDataProfileUri(`/${id}/${saveResult.id}`, this.productService).toString());
+                    buttons.push({
+                        label: ( localizeWithPath(
+                            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                            { key: 'copy', comment: ['&& denotes a mnemonic'] },
+                            "&&Copy Link"
+                        )),
+                        run: () => this.clipboardService.writeText(link)
+                    });
+                    if (this.productService.webUrl) {
+                        buttons.push({
+                            label: ( localizeWithPath(
+                                'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                                { key: 'open', comment: ['&& denotes a mnemonic'] },
+                                "&&Open Link"
+                            )),
+                            run: async () => {
+                                await this.openerService.open(link);
+                            }
+                        });
+                    }
+                    else {
+                        buttons.push({
+                            label: ( localizeWithPath(
+                                'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                                { key: 'open in', comment: ['&& denotes a mnemonic'] },
+                                "&&Open in {0}",
+                                profileContentHandler.name
+                            )),
+                            run: async () => {
+                                await this.openerService.open(( saveResult.link.toString()));
+                            }
+                        });
+                    }
+                    await this.dialogService.prompt({
+                        type: Severity$1.Info,
+                        message,
+                        buttons,
+                        cancelButton: ( localizeWithPath(
+                            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                            'close',
+                            "Close"
+                        ))
+                    });
+                }
+                else {
+                    await this.dialogService.info(message);
+                }
+            });
+        }
+        finally {
+            disposables.dispose();
+        }
+    }
+    async resolveProfileTemplate(uri, options) {
+        const profileContent = await this.resolveProfileContent(uri);
+        if (profileContent === null) {
+            return null;
+        }
+        const profileTemplate = JSON.parse(profileContent);
+        if (!isUserDataProfileTemplate(profileTemplate)) {
+            throw new Error('Invalid profile content.');
+        }
+        if (options?.name) {
+            profileTemplate.name = options.name;
+        }
+        if (options?.icon) {
+            profileTemplate.icon = options.icon;
+        }
+        return profileTemplate;
+    }
+    async importAndPreviewProfile(uri, profileTemplate, options) {
+        const disposables = ( new DisposableStore());
+        try {
+            const userDataProfileImportState = disposables.add(this.instantiationService.createInstance(UserDataProfileImportState, profileTemplate));
+            profileTemplate = await userDataProfileImportState.getProfileTemplateToImport();
+            const importedProfile = await this.createAndSwitch(profileTemplate, true, false, options, ( localizeWithPath(
+                'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                'preview profile',
+                "Preview Profile"
+            )));
+            if (!importedProfile) {
+                return;
+            }
+            const barrier = ( new Barrier());
+            const importAction = this.getCreateAction(barrier, userDataProfileImportState);
+            const primaryAction = isWeb
+                ? ( new Action('importInDesktop', ( localizeWithPath(
+                'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                'import in desktop',
+                "Create Profile in {0}",
+                this.productService.nameLong
+            )), undefined, true, async () => this.openerService.open(uri, { openExternal: true })))
+                : importAction;
+            const secondaryAction = isWeb
+                ? importAction
+                : ( new BarrierAction(barrier, ( new Action('close', ( localizeWithPath(
+                'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                'close',
+                "Close"
+            )))), this.notificationService));
+            const view = await this.showProfilePreviewView(IMPORT_PROFILE_PREVIEW_VIEW, importedProfile.name, primaryAction, secondaryAction, false, userDataProfileImportState);
+            const message = ( new MarkdownString());
+            message.appendMarkdown(( localizeWithPath(
+                'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                'preview profile message',
+                "By default, extensions aren't installed when previewing a profile on the web. You can still install them manually before importing the profile. "
+            )));
+            message.appendMarkdown(`[${( localizeWithPath(
+                'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                'learn more',
+                "Learn more"
+            ))}](https://aka.ms/vscode-extension-marketplace#_can-i-trust-extensions-from-the-marketplace).`);
+            view.setMessage(message);
+            const that = this;
+            const disposable = disposables.add(registerAction2(class extends Action2 {
+                constructor() {
+                    super({
+                        id: 'previewProfile.installExtensions',
+                        title: ( localizeWithPath(
+                            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                            'install extensions title',
+                            "Install Extensions"
+                        )),
+                        icon: Codicon.cloudDownload,
+                        menu: {
+                            id: MenuId.ViewItemContext,
+                            group: 'inline',
+                            when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', IMPORT_PROFILE_PREVIEW_VIEW)), ( ContextKeyExpr.equals('viewItem', "extensions" )))),
+                        }
+                    });
+                }
+                async run() {
+                    return that.progressService.withProgress({
+                        location: IMPORT_PROFILE_PREVIEW_VIEW,
+                    }, async (progress) => {
+                        view.setMessage(undefined);
+                        const profileTemplate = await userDataProfileImportState.getProfileTemplateToImport();
+                        if (profileTemplate.extensions) {
+                            await that.instantiationService.createInstance(ExtensionsResource).apply(profileTemplate.extensions, importedProfile);
+                        }
+                        disposable.dispose();
+                    });
+                }
+            }));
+            disposables.add(Event.debounce(this.extensionManagementService.onDidInstallExtensions, () => undefined, 100)(async () => {
+                const profileTemplate = await userDataProfileImportState.getProfileTemplateToImport();
+                if (profileTemplate.extensions) {
+                    const profileExtensions = await that.instantiationService.createInstance(ExtensionsResource).getProfileExtensions(profileTemplate.extensions);
+                    const installed = await this.extensionManagementService.getInstalled(1 );
+                    if (profileExtensions.every(e => ( installed.some(i => areSameExtensions(e.identifier, i.identifier))))) {
+                        disposable.dispose();
+                    }
+                }
+            }));
+            await barrier.wait();
+            await this.hideProfilePreviewView(IMPORT_PROFILE_PREVIEW_VIEW);
+        }
+        finally {
+            disposables.dispose();
+        }
+    }
+    async previewProfile(profileTemplate, options) {
+        const disposables = ( new DisposableStore());
+        try {
+            const userDataProfileImportState = disposables.add(this.instantiationService.createInstance(UserDataProfileImportState, profileTemplate));
+            if (userDataProfileImportState.isEmpty()) {
+                await this.createAndSwitch(profileTemplate, false, true, options, ( localizeWithPath(
+                    'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                    'create profile',
+                    "Create Profile"
+                )));
+            }
+            else {
+                const barrier = ( new Barrier());
+                const cancelAction = ( new BarrierAction(barrier, ( new Action('cancel', ( localizeWithPath(
+                    'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                    'cancel',
+                    "Cancel"
+                )))), this.notificationService));
+                const importAction = this.getCreateAction(barrier, userDataProfileImportState, cancelAction);
+                await this.showProfilePreviewView(IMPORT_PROFILE_PREVIEW_VIEW, profileTemplate.name, importAction, cancelAction, false, userDataProfileImportState);
+                await barrier.wait();
+                await this.hideProfilePreviewView(IMPORT_PROFILE_PREVIEW_VIEW);
+            }
+        }
+        finally {
+            disposables.dispose();
+        }
+    }
+    getCreateAction(barrier, userDataProfileImportState, cancelAction) {
+        const importAction = ( new BarrierAction(barrier, ( new Action('title', ( localizeWithPath(
+            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+            'import',
+            "Create Profile"
+        )), undefined, true, async () => {
+            importAction.enabled = false;
+            if (cancelAction) {
+                cancelAction.enabled = false;
+            }
+            const profileTemplate = await userDataProfileImportState.getProfileTemplateToImport();
+            return this.saveProfile(undefined, profileTemplate);
+        })), this.notificationService));
+        return importAction;
+    }
+    async createAndSwitch(profileTemplate, temporaryProfile, extensions, options, title) {
+        return this.progressService.withProgress({
+            location: 15 ,
+            delay: 500,
+            sticky: true,
+        }, async (progress) => {
+            title = `${title} (${profileTemplate.name})`;
+            progress.report({ message: title });
+            const reportProgress = (message) => progress.report({ message: `${title}: ${message}` });
+            const profile = await this.doCreateProfile(profileTemplate, temporaryProfile, extensions, options, reportProgress);
+            if (profile) {
+                reportProgress(( localizeWithPath(
+                    'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                    'switching profile',
+                    "Switching Profile..."
+                )));
+                await this.userDataProfileManagementService.switchProfile(profile);
+            }
+            return profile;
+        });
+    }
+    async doCreateProfile(profileTemplate, temporaryProfile, extensions, options, progress) {
+        const profile = await this.getProfileToImport(profileTemplate, temporaryProfile, options);
+        if (!profile) {
+            return undefined;
+        }
+        if (profileTemplate.settings && !profile.useDefaultFlags?.settings) {
+            progress(( localizeWithPath(
+                'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                'progress settings',
+                "Applying Settings..."
+            )));
+            await this.instantiationService.createInstance(SettingsResource).apply(profileTemplate.settings, profile);
+        }
+        if (profileTemplate.keybindings && !profile.useDefaultFlags?.keybindings) {
+            progress(( localizeWithPath(
+                'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                'progress keybindings',
+                "Applying Keyboard Shortcuts..."
+            )));
+            await this.instantiationService.createInstance(KeybindingsResource).apply(profileTemplate.keybindings, profile);
+        }
+        if (profileTemplate.tasks && !profile.useDefaultFlags?.tasks) {
+            progress(( localizeWithPath(
+                'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                'progress tasks',
+                "Applying Tasks..."
+            )));
+            await this.instantiationService.createInstance(TasksResource).apply(profileTemplate.tasks, profile);
+        }
+        if (profileTemplate.snippets && !profile.useDefaultFlags?.snippets) {
+            progress(( localizeWithPath(
+                'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                'progress snippets',
+                "Applying Snippets..."
+            )));
+            await this.instantiationService.createInstance(SnippetsResource).apply(profileTemplate.snippets, profile);
+        }
+        if (profileTemplate.globalState && !profile.useDefaultFlags?.globalState) {
+            progress(( localizeWithPath(
+                'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                'progress global state',
+                "Applying State..."
+            )));
+            await this.instantiationService.createInstance(GlobalStateResource).apply(profileTemplate.globalState, profile);
+        }
+        if (profileTemplate.extensions && extensions && !profile.useDefaultFlags?.extensions) {
+            progress(( localizeWithPath(
+                'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                'progress extensions',
+                "Applying Extensions..."
+            )));
+            await this.instantiationService.createInstance(ExtensionsResource).apply(profileTemplate.extensions, profile);
+        }
+        return profile;
+    }
+    async resolveProfileContent(resource) {
+        if (await this.fileUserDataProfileContentHandler.canHandle(resource)) {
+            return this.fileUserDataProfileContentHandler.readProfile(resource, CancellationToken.None);
+        }
+        if (this.isProfileURL(resource)) {
+            let handlerId, idOrUri;
+            if (resource.authority === PROFILE_URL_AUTHORITY) {
+                idOrUri = this.uriIdentityService.extUri.basename(resource);
+                handlerId = this.uriIdentityService.extUri.basename(this.uriIdentityService.extUri.dirname(resource));
+            }
+            else {
+                handlerId = resource.authority.substring(UserDataProfileImportExportService_1.PROFILE_URL_AUTHORITY_PREFIX.length);
+                idOrUri = ( URI.parse(resource.path.substring(1)));
+            }
+            await this.extensionService.activateByEvent(`onProfile:${handlerId}`);
+            const profileContentHandler = this.profileContentHandlers.get(handlerId);
+            if (profileContentHandler) {
+                return profileContentHandler.readProfile(idOrUri, CancellationToken.None);
+            }
+        }
+        await this.extensionService.activateByEvent('onProfile');
+        for (const profileContentHandler of ( this.profileContentHandlers.values())) {
+            const content = await profileContentHandler.readProfile(resource, CancellationToken.None);
+            if (content !== null) {
+                return content;
+            }
+        }
+        const context = await this.requestService.request({ type: 'GET', url: ( resource.toString(true)) }, CancellationToken.None);
+        if (context.res.statusCode === 200) {
+            return await asText(context);
+        }
+        else {
+            const message = await asText(context);
+            throw new Error(`Failed to get profile from URL: ${resource.toString()}. Status code: ${context.res.statusCode}. Message: ${message}`);
+        }
+    }
+    async pickProfileContentHandler(name) {
+        await this.extensionService.activateByEvent('onProfile');
+        if (this.profileContentHandlers.size === 1) {
+            return ( this.profileContentHandlers.keys()).next().value;
+        }
+        const options = [];
+        for (const [id, profileContentHandler] of this.profileContentHandlers) {
+            options.push({ id, label: profileContentHandler.name, description: profileContentHandler.description });
+        }
+        const result = await this.quickInputService.pick(options.reverse(), {
+            title: ( localizeWithPath(
+                'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                'select profile content handler',
+                "Export '{0}' profile as...",
+                name
+            )),
+            hideInput: true
+        });
+        return result?.id;
+    }
+    async getProfileToImport(profileTemplate, temp, options) {
+        const profileName = profileTemplate.name;
+        const profile = this.userDataProfilesService.profiles.find(p => p.name === profileName);
+        if (profile) {
+            if (temp) {
+                return this.userDataProfilesService.createNamedProfile(`${profileName} ${this.getProfileNameIndex(profileName)}`, { ...options, transient: temp });
+            }
+            let ImportProfileChoice;
+            ( (function(ImportProfileChoice) {
+                ImportProfileChoice[ImportProfileChoice["Overwrite"] = 0] = "Overwrite";
+                ImportProfileChoice[ImportProfileChoice["CreateNew"] = 1] = "CreateNew";
+                ImportProfileChoice[ImportProfileChoice["Cancel"] = 2] = "Cancel";
+            })(ImportProfileChoice || (ImportProfileChoice = {})));
+            const { result } = await this.dialogService.prompt({
+                type: Severity$1.Info,
+                message: ( localizeWithPath(
+                    'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                    'profile already exists',
+                    "Profile with name '{0}' already exists. Do you want to overwrite it?",
+                    profileName
+                )),
+                buttons: [
+                    {
+                        label: ( localizeWithPath(
+                            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                            { key: 'overwrite', comment: ['&& denotes a mnemonic'] },
+                            "&&Overwrite"
+                        )),
+                        run: () => ImportProfileChoice.Overwrite
+                    },
+                    {
+                        label: ( localizeWithPath(
+                            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                            { key: 'create new', comment: ['&& denotes a mnemonic'] },
+                            "&&Create New Profile"
+                        )),
+                        run: () => ImportProfileChoice.CreateNew
+                    },
+                ],
+                cancelButton: {
+                    run: () => ImportProfileChoice.Cancel
+                }
+            });
+            if (result === ImportProfileChoice.Overwrite) {
+                return profile;
+            }
+            if (result === ImportProfileChoice.Cancel) {
+                return undefined;
+            }
+            const name = await this.quickInputService.input({
+                placeHolder: ( localizeWithPath(
+                    'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                    'name',
+                    "Profile name"
+                )),
+                title: ( localizeWithPath(
+                    'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                    'create new title',
+                    "Create New Profile"
+                )),
+                value: `${profileName} ${this.getProfileNameIndex(profileName)}`,
+                validateInput: async (value) => {
+                    if (( this.userDataProfilesService.profiles.some(p => p.name === value))) {
+                        return ( localizeWithPath(
+                            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                            'profileExists',
+                            "Profile with name {0} already exists.",
+                            value
+                        ));
+                    }
+                    return undefined;
+                }
+            });
+            if (!name) {
+                return undefined;
+            }
+            return this.userDataProfilesService.createNamedProfile(name);
+        }
+        else {
+            return this.userDataProfilesService.createNamedProfile(profileName, { ...options, transient: temp });
+        }
+    }
+    generateProfileName(profileName) {
+        const existingProfile = this.userDataProfilesService.profiles.find(p => p.name === profileName);
+        return existingProfile ? `${profileName} ${this.getProfileNameIndex(profileName)}` : profileName;
+    }
+    getProfileNameIndex(name) {
+        const nameRegEx = ( new RegExp(`${escapeRegExpCharacters(name)}\\s(\\d+)`));
+        let nameIndex = 0;
+        for (const profile of this.userDataProfilesService.profiles) {
+            const matches = nameRegEx.exec(profile.name);
+            const index = matches ? parseInt(matches[1]) : 0;
+            nameIndex = index > nameIndex ? index : nameIndex;
+        }
+        return nameIndex + 1;
+    }
+    async showProfilePreviewView(id, name, primary, secondary, refreshAction, userDataProfilesData) {
+        const viewsRegistry = ( Registry.as(Extensions.ViewsRegistry));
+        const treeView = this.instantiationService.createInstance(TreeView, id, name);
+        if (refreshAction) {
+            treeView.showRefreshAction = true;
+        }
+        const actionRunner = ( new ActionRunner());
+        const descriptor = {
+            id,
+            name: { value: name, original: name },
+            ctorDescriptor: ( new SyncDescriptor(
+                UserDataProfilePreviewViewPane,
+                [userDataProfilesData, primary, secondary, actionRunner]
+            )),
+            canToggleVisibility: false,
+            canMoveView: false,
+            treeView,
+            collapsed: false,
+        };
+        viewsRegistry.registerViews([descriptor], this.viewContainer);
+        return (await this.viewsService.openView(id, true));
+    }
+    async hideProfilePreviewView(id) {
+        const viewsRegistry = ( Registry.as(Extensions.ViewsRegistry));
+        const viewDescriptor = viewsRegistry.getView(id);
+        if (viewDescriptor) {
+            viewDescriptor.treeView.dispose();
+            viewsRegistry.deregisterViews([viewDescriptor], this.viewContainer);
+        }
+        await this.closeAllImportExportPreviewEditors();
+    }
+    async closeAllImportExportPreviewEditors() {
+        const editorsToColse = this.editorService.getEditors(1 ).filter(({ editor }) => editor.resource?.scheme === USER_DATA_PROFILE_EXPORT_SCHEME || editor.resource?.scheme === USER_DATA_PROFILE_EXPORT_PREVIEW_SCHEME || editor.resource?.scheme === USER_DATA_PROFILE_IMPORT_PREVIEW_SCHEME);
+        if (editorsToColse.length) {
+            await this.editorService.closeEditors(editorsToColse);
+        }
+    }
+    async setProfile(profile) {
+        await this.progressService.withProgress({
+            location: 15 ,
+            title: ( localizeWithPath(
+                'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                'profiles.applying',
+                "{0}: Applying...",
+                PROFILES_CATEGORY.value
+            )),
+        }, async (progress) => {
+            if (profile.settings) {
+                await this.instantiationService.createInstance(SettingsResource).apply(profile.settings, this.userDataProfileService.currentProfile);
+            }
+            if (profile.globalState) {
+                await this.instantiationService.createInstance(GlobalStateResource).apply(profile.globalState, this.userDataProfileService.currentProfile);
+            }
+            if (profile.extensions) {
+                await this.instantiationService.createInstance(ExtensionsResource).apply(profile.extensions, this.userDataProfileService.currentProfile);
+            }
+        });
+        this.notificationService.info(( localizeWithPath(
+            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+            'applied profile',
+            "{0}: Applied successfully.",
+            PROFILES_CATEGORY.value
+        )));
+    }
+};
+UserDataProfileImportExportService = UserDataProfileImportExportService_1 = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IUserDataProfileService)),
+    ( __param(2, IViewsService)),
+    ( __param(3, IEditorService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IUserDataProfileManagementService)),
+    ( __param(6, IUserDataProfilesService)),
+    ( __param(7, IExtensionService)),
+    ( __param(8, IExtensionManagementService)),
+    ( __param(9, IQuickInputService)),
+    ( __param(10, INotificationService)),
+    ( __param(11, IProgressService)),
+    ( __param(12, IDialogService)),
+    ( __param(13, IClipboardService)),
+    ( __param(14, IOpenerService)),
+    ( __param(15, IRequestService)),
+    ( __param(16, IURLService)),
+    ( __param(17, IProductService)),
+    ( __param(18, IUriIdentityService)),
+    ( __param(19, ITelemetryService)),
+    ( __param(20, IContextViewService)),
+    ( __param(21, IHoverService)),
+    ( __param(22, ILogService))
+], UserDataProfileImportExportService));
+let FileUserDataProfileContentHandler = class FileUserDataProfileContentHandler {
+    constructor(fileDialogService, uriIdentityService, fileService, textFileService) {
+        this.fileDialogService = fileDialogService;
+        this.uriIdentityService = uriIdentityService;
+        this.fileService = fileService;
+        this.textFileService = textFileService;
+        this.name = ( localizeWithPath(
+            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+            'local',
+            "Local"
+        ));
+        this.description = ( localizeWithPath(
+            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+            'file',
+            "file"
+        ));
+    }
+    async saveProfile(name, content, token) {
+        const link = await this.fileDialogService.showSaveDialog({
+            title: ( localizeWithPath(
+                'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                'export profile dialog',
+                "Save Profile"
+            )),
+            filters: PROFILE_FILTER,
+            defaultUri: this.uriIdentityService.extUri.joinPath(await this.fileDialogService.defaultFilePath(), `${name}.${PROFILE_EXTENSION}`),
+        });
+        if (!link) {
+            return null;
+        }
+        await this.textFileService.create([{ resource: link, value: content, options: { overwrite: true } }]);
+        return { link, id: ( link.toString()) };
+    }
+    async canHandle(uri) {
+        return uri.scheme !== Schemas.http && uri.scheme !== Schemas.https && (await this.fileService.canHandleResource(uri));
+    }
+    async readProfile(uri, token) {
+        if (await this.canHandle(uri)) {
+            return ( (await this.fileService.readFile(uri, undefined, token)).value.toString());
+        }
+        return null;
+    }
+    async selectProfile() {
+        const profileLocation = await this.fileDialogService.showOpenDialog({
+            canSelectFolders: false,
+            canSelectFiles: true,
+            canSelectMany: false,
+            filters: PROFILE_FILTER,
+            title: ( localizeWithPath(
+                'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                'select profile',
+                "Select Profile"
+            )),
+        });
+        return profileLocation ? profileLocation[0] : null;
+    }
+};
+FileUserDataProfileContentHandler = ( __decorate([
+    ( __param(0, IFileDialogService)),
+    ( __param(1, IUriIdentityService)),
+    ( __param(2, IFileService)),
+    ( __param(3, ITextFileService))
+], FileUserDataProfileContentHandler));
+let UserDataProfilePreviewViewPane = class UserDataProfilePreviewViewPane extends TreeViewPane {
+    constructor(userDataProfileData, primaryAction, secondaryAction, actionRunner, options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, notificationService) {
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, notificationService);
+        this.userDataProfileData = userDataProfileData;
+        this.primaryAction = primaryAction;
+        this.secondaryAction = secondaryAction;
+        this.actionRunner = actionRunner;
+        this.totalTreeItemsCount = 0;
+        this.renderDisposables = this._register(( new DisposableStore()));
+    }
+    renderTreeView(container) {
+        this.treeView.dataProvider = this.userDataProfileData;
+        super.renderTreeView(append(container, $('.profile-view-tree-container')));
+        this.messageContainer = append(container, $('.profile-view-message-container.hide'));
+        this.createButtons(container);
+        this._register(this.treeView.onDidChangeCheckboxState(() => this.updateConfirmButtonEnablement()));
+        this.computeAndLayout();
+        this._register(Event.any(this.userDataProfileData.onDidChangeRoots, this.treeView.onDidCollapseItem, this.treeView.onDidExpandItem)(() => this.computeAndLayout()));
+    }
+    async computeAndLayout() {
+        const roots = await this.userDataProfileData.getRoots();
+        const children = await Promise.all(( roots.map(async (root) => {
+            let expanded = root.collapsibleState === TreeItemCollapsibleState.Expanded;
+            try {
+                expanded = !this.treeView.isCollapsed(root);
+            }
+            catch (error) {  }
+            if (expanded) {
+                const children = await root.getChildren();
+                return children ?? [];
+            }
+            return [];
+        })));
+        this.totalTreeItemsCount = roots.length + children.flat().length;
+        this.updateConfirmButtonEnablement();
+        if (this.dimension) {
+            this.layoutTreeView(this.dimension.height, this.dimension.width);
+        }
+    }
+    createButtons(container) {
+        this.buttonsContainer = append(container, $('.profile-view-buttons-container'));
+        this.primaryButton = this._register(( new Button(this.buttonsContainer, { ...defaultButtonStyles })));
+        this.primaryButton.element.classList.add('profile-view-button');
+        this.primaryButton.label = this.primaryAction.label;
+        this.primaryButton.enabled = this.primaryAction.enabled;
+        this._register(this.primaryButton.onDidClick(() => this.actionRunner.run(this.primaryAction)));
+        this._register(this.primaryAction.onDidChange(e => {
+            if (e.enabled !== undefined) {
+                this.primaryButton.enabled = e.enabled;
+            }
+        }));
+        this.secondaryButton = this._register(( new Button(this.buttonsContainer, { secondary: true, ...defaultButtonStyles })));
+        this.secondaryButton.label = this.secondaryAction.label;
+        this.secondaryButton.element.classList.add('profile-view-button');
+        this.secondaryButton.enabled = this.secondaryAction.enabled;
+        this._register(this.secondaryButton.onDidClick(() => this.actionRunner.run(this.secondaryAction)));
+        this._register(this.secondaryAction.onDidChange(e => {
+            if (e.enabled !== undefined) {
+                this.secondaryButton.enabled = e.enabled;
+            }
+        }));
+    }
+    layoutTreeView(height, width) {
+        this.dimension = new Dimension(width, height);
+        let messageContainerHeight = 0;
+        if (!this.messageContainer.classList.contains('hide')) {
+            messageContainerHeight = getClientArea(this.messageContainer).height;
+        }
+        const buttonContainerHeight = 108;
+        this.buttonsContainer.style.height = `${buttonContainerHeight}px`;
+        this.buttonsContainer.style.width = `${width}px`;
+        super.layoutTreeView(Math.min(height - buttonContainerHeight - messageContainerHeight, 22 * this.totalTreeItemsCount), width);
+    }
+    updateConfirmButtonEnablement() {
+        this.primaryButton.enabled = this.primaryAction.enabled && this.userDataProfileData.isEnabled();
+    }
+    setMessage(message) {
+        this.messageContainer.classList.toggle('hide', !message);
+        clearNode(this.messageContainer);
+        if (message) {
+            this.renderDisposables.clear();
+            const rendered = this.renderDisposables.add(renderMarkdown(message, {
+                actionHandler: {
+                    callback: (content) => {
+                        this.openerService.open(content, { allowCommands: true }).catch(onUnexpectedError);
+                    },
+                    disposables: this.renderDisposables
+                }
+            }));
+            append(this.messageContainer, rendered.element);
+        }
+    }
+    refresh() {
+        return this.treeView.refresh();
+    }
+};
+UserDataProfilePreviewViewPane = ( __decorate([
+    ( __param(5, IKeybindingService)),
+    ( __param(6, IContextMenuService)),
+    ( __param(7, IConfigurationService)),
+    ( __param(8, IContextKeyService)),
+    ( __param(9, IViewDescriptorService)),
+    ( __param(10, IInstantiationService)),
+    ( __param(11, IOpenerService)),
+    ( __param(12, IThemeService)),
+    ( __param(13, ITelemetryService)),
+    ( __param(14, INotificationService))
+], UserDataProfilePreviewViewPane));
+const USER_DATA_PROFILE_EXPORT_SCHEME = 'userdataprofileexport';
+const USER_DATA_PROFILE_EXPORT_PREVIEW_SCHEME = 'userdataprofileexportpreview';
+const USER_DATA_PROFILE_IMPORT_PREVIEW_SCHEME = 'userdataprofileimportpreview';
+let UserDataProfileImportExportState = class UserDataProfileImportExportState extends Disposable {
+    constructor(quickInputService) {
+        super();
+        this.quickInputService = quickInputService;
+        this._onDidChangeRoots = this._register(( new Emitter()));
+        this.onDidChangeRoots = this._onDidChangeRoots.event;
+        this.roots = [];
+    }
+    async getChildren(element) {
+        if (element) {
+            const children = await element.getChildren();
+            if (children) {
+                for (const child of children) {
+                    if (child.parent.checkbox && child.checkbox) {
+                        child.checkbox.isChecked = child.parent.checkbox.isChecked && child.checkbox.isChecked;
+                    }
+                }
+            }
+            return children;
+        }
+        else {
+            this.rootsPromise = undefined;
+            this._onDidChangeRoots.fire();
+            return this.getRoots();
+        }
+    }
+    getRoots() {
+        if (!this.rootsPromise) {
+            this.rootsPromise = (async () => {
+                this.roots = await this.fetchRoots();
+                for (const root of this.roots) {
+                    root.checkbox = {
+                        isChecked: !root.isFromDefaultProfile(),
+                        tooltip: ( localizeWithPath(
+                            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                            'select',
+                            "Select {0}",
+                            root.label.label
+                        )),
+                        accessibilityInformation: {
+                            label: ( localizeWithPath(
+                                'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                                'select',
+                                "Select {0}",
+                                root.label.label
+                            )),
+                        }
+                    };
+                    if (root.isFromDefaultProfile()) {
+                        root.description = ( localizeWithPath(
+                            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                            'from default',
+                            "From Default Profile"
+                        ));
+                    }
+                }
+                return this.roots;
+            })();
+        }
+        return this.rootsPromise;
+    }
+    isEnabled(resourceType) {
+        if (resourceType !== undefined) {
+            return ( this.roots.some(root => root.type === resourceType && this.isSelected(root)));
+        }
+        return ( this.roots.some(root => this.isSelected(root)));
+    }
+    async getProfileTemplate(name, icon) {
+        const roots = await this.getRoots();
+        let settings;
+        let keybindings;
+        let tasks;
+        let snippets;
+        let extensions;
+        let globalState;
+        for (const root of roots) {
+            if (!this.isSelected(root)) {
+                continue;
+            }
+            if (root instanceof SettingsResourceTreeItem) {
+                settings = await root.getContent();
+            }
+            else if (root instanceof KeybindingsResourceTreeItem) {
+                keybindings = await root.getContent();
+            }
+            else if (root instanceof TasksResourceTreeItem) {
+                tasks = await root.getContent();
+            }
+            else if (root instanceof SnippetsResourceTreeItem) {
+                snippets = await root.getContent();
+            }
+            else if (root instanceof ExtensionsResourceTreeItem) {
+                extensions = await root.getContent();
+            }
+            else if (root instanceof GlobalStateResourceTreeItem) {
+                globalState = await root.getContent();
+            }
+        }
+        return {
+            name,
+            icon,
+            settings,
+            keybindings,
+            tasks,
+            snippets,
+            extensions,
+            globalState
+        };
+    }
+    isSelected(treeItem) {
+        if (treeItem.checkbox) {
+            return treeItem.checkbox.isChecked || !!treeItem.children?.some(child => child.checkbox?.isChecked);
+        }
+        return true;
+    }
+};
+UserDataProfileImportExportState = ( __decorate([
+    ( __param(0, IQuickInputService))
+], UserDataProfileImportExportState));
+let UserDataProfileExportState = class UserDataProfileExportState extends UserDataProfileImportExportState {
+    constructor(profile, quickInputService, fileService, instantiationService) {
+        super(quickInputService);
+        this.profile = profile;
+        this.fileService = fileService;
+        this.instantiationService = instantiationService;
+        this.disposables = this._register(( new DisposableStore()));
+    }
+    async fetchRoots() {
+        this.disposables.clear();
+        this.disposables.add(this.fileService.registerProvider(USER_DATA_PROFILE_EXPORT_SCHEME, this._register(( new InMemoryFileSystemProvider()))));
+        const previewFileSystemProvider = this._register(( new InMemoryFileSystemProvider()));
+        this.disposables.add(this.fileService.registerProvider(USER_DATA_PROFILE_EXPORT_PREVIEW_SCHEME, previewFileSystemProvider));
+        const roots = [];
+        const exportPreviewProfle = this.createExportPreviewProfile(this.profile);
+        const settingsResource = this.instantiationService.createInstance(SettingsResource);
+        const settingsContent = await settingsResource.getContent(this.profile);
+        await settingsResource.apply(settingsContent, exportPreviewProfle);
+        const settingsResourceTreeItem = this.instantiationService.createInstance(SettingsResourceTreeItem, exportPreviewProfle);
+        if (await settingsResourceTreeItem.hasContent()) {
+            roots.push(settingsResourceTreeItem);
+        }
+        const keybindingsResource = this.instantiationService.createInstance(KeybindingsResource);
+        const keybindingsContent = await keybindingsResource.getContent(this.profile);
+        await keybindingsResource.apply(keybindingsContent, exportPreviewProfle);
+        const keybindingsResourceTreeItem = this.instantiationService.createInstance(KeybindingsResourceTreeItem, exportPreviewProfle);
+        if (await keybindingsResourceTreeItem.hasContent()) {
+            roots.push(keybindingsResourceTreeItem);
+        }
+        const snippetsResource = this.instantiationService.createInstance(SnippetsResource);
+        const snippetsContent = await snippetsResource.getContent(this.profile);
+        await snippetsResource.apply(snippetsContent, exportPreviewProfle);
+        const snippetsResourceTreeItem = this.instantiationService.createInstance(SnippetsResourceTreeItem, exportPreviewProfle);
+        if (await snippetsResourceTreeItem.hasContent()) {
+            roots.push(snippetsResourceTreeItem);
+        }
+        const tasksResource = this.instantiationService.createInstance(TasksResource);
+        const tasksContent = await tasksResource.getContent(this.profile);
+        await tasksResource.apply(tasksContent, exportPreviewProfle);
+        const tasksResourceTreeItem = this.instantiationService.createInstance(TasksResourceTreeItem, exportPreviewProfle);
+        if (await tasksResourceTreeItem.hasContent()) {
+            roots.push(tasksResourceTreeItem);
+        }
+        const globalStateResource = joinPath(exportPreviewProfle.globalStorageHome, 'globalState.json').with({ scheme: USER_DATA_PROFILE_EXPORT_PREVIEW_SCHEME });
+        const globalStateResourceTreeItem = this.instantiationService.createInstance(GlobalStateResourceExportTreeItem, exportPreviewProfle, globalStateResource);
+        const content = await globalStateResourceTreeItem.getContent();
+        if (content) {
+            await this.fileService.writeFile(globalStateResource, VSBuffer.fromString(JSON.stringify(JSON.parse(content), null, '\t')));
+            roots.push(globalStateResourceTreeItem);
+        }
+        const extensionsResourceTreeItem = this.instantiationService.createInstance(ExtensionsResourceExportTreeItem, exportPreviewProfle);
+        if (await extensionsResourceTreeItem.hasContent()) {
+            roots.push(extensionsResourceTreeItem);
+        }
+        previewFileSystemProvider.setReadOnly(true);
+        return roots;
+    }
+    createExportPreviewProfile(profile) {
+        return {
+            id: profile.id,
+            name: profile.name,
+            location: profile.location,
+            isDefault: profile.isDefault,
+            shortName: profile.shortName,
+            icon: profile.icon,
+            globalStorageHome: profile.globalStorageHome,
+            settingsResource: profile.settingsResource.with({ scheme: USER_DATA_PROFILE_EXPORT_SCHEME }),
+            keybindingsResource: profile.keybindingsResource.with({ scheme: USER_DATA_PROFILE_EXPORT_SCHEME }),
+            tasksResource: profile.tasksResource.with({ scheme: USER_DATA_PROFILE_EXPORT_SCHEME }),
+            snippetsHome: profile.snippetsHome.with({ scheme: USER_DATA_PROFILE_EXPORT_SCHEME }),
+            extensionsResource: profile.extensionsResource,
+            cacheHome: profile.cacheHome,
+            useDefaultFlags: profile.useDefaultFlags,
+            isTransient: profile.isTransient
+        };
+    }
+    async getProfileToExport() {
+        let name = this.profile.name;
+        if (this.profile.isDefault) {
+            name = await this.quickInputService.input({
+                placeHolder: ( localizeWithPath(
+                    'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                    'export profile name',
+                    "Name the profile"
+                )),
+                title: ( localizeWithPath(
+                    'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                    'export profile title',
+                    "Export Profile"
+                )),
+                async validateInput(input) {
+                    if (!input.trim()) {
+                        return ( localizeWithPath(
+                            'vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService',
+                            'profile name required',
+                            "Profile name must be provided."
+                        ));
+                    }
+                    return undefined;
+                },
+            });
+            if (!name) {
+                return null;
+            }
+        }
+        return super.getProfileTemplate(name, this.profile.icon);
+    }
+};
+UserDataProfileExportState = ( __decorate([
+    ( __param(1, IQuickInputService)),
+    ( __param(2, IFileService)),
+    ( __param(3, IInstantiationService))
+], UserDataProfileExportState));
+let UserDataProfileImportState = class UserDataProfileImportState extends UserDataProfileImportExportState {
+    constructor(profile, fileService, quickInputService, instantiationService) {
+        super(quickInputService);
+        this.profile = profile;
+        this.fileService = fileService;
+        this.instantiationService = instantiationService;
+        this.disposables = this._register(( new DisposableStore()));
+    }
+    async fetchRoots() {
+        this.disposables.clear();
+        const inMemoryProvider = this._register(( new InMemoryFileSystemProvider()));
+        this.disposables.add(this.fileService.registerProvider(USER_DATA_PROFILE_IMPORT_PREVIEW_SCHEME, inMemoryProvider));
+        const roots = [];
+        const importPreviewProfle = toUserDataProfile(generateUuid(), this.profile.name, URI.file('/root').with({ scheme: USER_DATA_PROFILE_IMPORT_PREVIEW_SCHEME }), URI.file('/cache').with({ scheme: USER_DATA_PROFILE_IMPORT_PREVIEW_SCHEME }));
+        if (this.profile.settings) {
+            const settingsResource = this.instantiationService.createInstance(SettingsResource);
+            await settingsResource.apply(this.profile.settings, importPreviewProfle);
+            const settingsResourceTreeItem = this.instantiationService.createInstance(SettingsResourceTreeItem, importPreviewProfle);
+            if (await settingsResourceTreeItem.hasContent()) {
+                roots.push(settingsResourceTreeItem);
+            }
+        }
+        if (this.profile.keybindings) {
+            const keybindingsResource = this.instantiationService.createInstance(KeybindingsResource);
+            await keybindingsResource.apply(this.profile.keybindings, importPreviewProfle);
+            const keybindingsResourceTreeItem = this.instantiationService.createInstance(KeybindingsResourceTreeItem, importPreviewProfle);
+            if (await keybindingsResourceTreeItem.hasContent()) {
+                roots.push(keybindingsResourceTreeItem);
+            }
+        }
+        if (this.profile.snippets) {
+            const snippetsResource = this.instantiationService.createInstance(SnippetsResource);
+            await snippetsResource.apply(this.profile.snippets, importPreviewProfle);
+            const snippetsResourceTreeItem = this.instantiationService.createInstance(SnippetsResourceTreeItem, importPreviewProfle);
+            if (await snippetsResourceTreeItem.hasContent()) {
+                roots.push(snippetsResourceTreeItem);
+            }
+        }
+        if (this.profile.tasks) {
+            const tasksResource = this.instantiationService.createInstance(TasksResource);
+            await tasksResource.apply(this.profile.tasks, importPreviewProfle);
+            const tasksResourceTreeItem = this.instantiationService.createInstance(TasksResourceTreeItem, importPreviewProfle);
+            if (await tasksResourceTreeItem.hasContent()) {
+                roots.push(tasksResourceTreeItem);
+            }
+        }
+        if (this.profile.globalState) {
+            const globalStateResource = joinPath(importPreviewProfle.globalStorageHome, 'globalState.json');
+            const content = VSBuffer.fromString(JSON.stringify(JSON.parse(this.profile.globalState), null, '\t'));
+            if (content) {
+                await this.fileService.writeFile(globalStateResource, content);
+                roots.push(this.instantiationService.createInstance(GlobalStateResourceImportTreeItem, this.profile.globalState, globalStateResource));
+            }
+        }
+        if (this.profile.extensions) {
+            const extensionsResourceTreeItem = this.instantiationService.createInstance(ExtensionsResourceImportTreeItem, this.profile.extensions);
+            if (await extensionsResourceTreeItem.hasContent()) {
+                roots.push(extensionsResourceTreeItem);
+            }
+        }
+        inMemoryProvider.setReadOnly(true);
+        return roots;
+    }
+    isEmpty() {
+        return !(this.profile.settings || this.profile.keybindings || this.profile.tasks || this.profile.snippets || this.profile.globalState || this.profile.extensions);
+    }
+    async getProfileTemplateToImport() {
+        return this.getProfileTemplate(this.profile.name, this.profile.icon);
+    }
+};
+UserDataProfileImportState = ( __decorate([
+    ( __param(1, IFileService)),
+    ( __param(2, IQuickInputService)),
+    ( __param(3, IInstantiationService))
+], UserDataProfileImportState));
+class BarrierAction extends Action {
+    constructor(barrier, action, notificationService) {
+        super(action.id, action.label, action.class, action.enabled, async () => {
+            try {
+                await action.run();
+            }
+            catch (error) {
+                notificationService.error(error);
+                throw error;
+            }
+            barrier.open();
+        });
+    }
+}
+export { UserDataProfileImportExportService };