@codingame/monaco-vscode-user-data-profile-service-override 5.3.0

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

@@ -0,0 +1,1453 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import './media/userDataProfileView.css.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification.service';
+import { Event, Emitter } from 'vscode/vscode/vs/base/common/event';
+import { $, append, Dimension, addDisposableListener, EventType, EventHelper, getClientArea, clearNode } from 'vscode/vscode/vs/base/browser/dom';
+import { IS_PROFILE_EXPORT_IN_PROGRESS_CONTEXT, IS_PROFILE_IMPORT_IN_PROGRESS_CONTEXT, PROFILES_TITLE, defaultUserDataProfileIcon, PROFILE_URL_AUTHORITY, PROFILES_CATEGORY, toUserDataProfileUri, PROFILE_FILTER, PROFILE_EXTENSION } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+import { IUserDataProfileService, IUserDataProfileManagementService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
+import { Disposable, toDisposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IDialogService, IFileDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs.service';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles.service';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { Extensions, TreeItemCollapsibleState } from 'vscode/vscode/vs/workbench/common/views';
+import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views.service';
+import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService.service';
+import { isUserDataProfile, toUserDataProfile } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile';
+import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
+import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { ViewPaneContainer } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import { TreeView, TreeViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/treeView';
+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, ExtensionsResourceTreeItem, ExtensionsResourceExportTreeItem, ExtensionsResourceImportTreeItem } from './extensionsResource.js';
+import { GlobalStateResource, GlobalStateResourceTreeItem, GlobalStateResourceExportTreeItem, GlobalStateResourceImportTreeItem } from './globalStateResource.js';
+import { InMemoryFileSystemProvider } from 'vscode/vscode/vs/platform/files/common/inMemoryFilesystemProvider';
+import { Button } from 'vscode/vscode/vs/base/browser/ui/button/button';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding.service';
+import { IContextViewService, IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView.service';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener.service';
+import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService.service';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
+import { defaultInputBoxStyles, defaultSelectBoxStyles, defaultButtonStyles } from 'vscode/vscode/vs/platform/theme/browser/defaultStyles';
+import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
+import { getErrorMessage, onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
+import { IProgressService } from 'vscode/vscode/vs/platform/progress/common/progress.service';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput.service';
+import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
+import { joinPath } from 'vscode/vscode/vs/base/common/resources';
+import { escapeRegExpCharacters } from 'vscode/vscode/vs/base/common/strings';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
+import Severity$1 from 'vscode/vscode/vs/base/common/severity';
+import { IClipboardService } from 'vscode/vscode/vs/platform/clipboard/common/clipboardService.service';
+import { IURLService } from 'vscode/vscode/vs/platform/url/common/url.service';
+import { asText } from 'vscode/vscode/vs/platform/request/common/request';
+import { IRequestService } from 'vscode/vscode/vs/platform/request/common/request.service';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService.service';
+import { isUndefined } from 'vscode/vscode/vs/base/common/types';
+import { Action, ActionRunner } from 'vscode/vscode/vs/base/common/actions';
+import { isWeb } from 'vscode/vscode/vs/base/common/platform';
+import { registerAction2, Action2, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { getAllCodicons, Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { Barrier } from 'vscode/vscode/vs/base/common/async';
+import { IExtensionManagementService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement.service';
+import { areSameExtensions } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
+import { renderMarkdown } from 'vscode/vscode/vs/base/browser/markdownRenderer';
+import { showWindowLogActionId } from 'vscode/vscode/vs/workbench/services/log/common/logConstants';
+import { SelectBox } from 'vscode/vscode/vs/base/browser/ui/selectBox/selectBox';
+import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
+import { IHoverService } from 'vscode/vscode/vs/platform/hover/browser/hover.service';
+import { DEFAULT_ICON, ICONS } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfileIcons';
+import { WorkbenchIconSelectBox } from 'vscode/vscode/vs/workbench/services/userDataProfile/browser/iconSelectBox';
+import { StandardKeyboardEvent } from 'vscode/vscode/vs/base/browser/keyboardEvent';
+import { IAccessibleViewInformationService } from 'vscode/vscode/vs/workbench/services/accessibility/common/accessibleViewInformationService.service';
+
+var UserDataProfileImportExportService_1;
+const _moduleId = "vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService";
+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(_moduleId, 0, "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(
+                    _moduleId,
+                    1,
+                    "{0}: Resolving profile content...",
+                    options?.mode ? ( localizeWithPath(_moduleId, 2, "Preview Profile")) : ( localizeWithPath(_moduleId, 3, "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(_moduleId, 4, "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(_moduleId, 5, "Edit {0} Profile...", profile.name)) : ( localizeWithPath(_moduleId, 6, "Create New Profile..."));
+        const settings = { id: "settings" , label: ( localizeWithPath(_moduleId, 7, "Settings")), picked: !profile?.useDefaultFlags?.settings };
+        const keybindings = { id: "keybindings" , label: ( localizeWithPath(_moduleId, 8, "Keyboard Shortcuts")), picked: !profile?.useDefaultFlags?.keybindings };
+        const snippets = { id: "snippets" , label: ( localizeWithPath(_moduleId, 9, "User Snippets")), picked: !profile?.useDefaultFlags?.snippets };
+        const tasks = { id: "tasks" , label: ( localizeWithPath(_moduleId, 10, "User Tasks")), picked: !profile?.useDefaultFlags?.tasks };
+        const extensions = { id: "extensions" , label: ( localizeWithPath(_moduleId, 11, "Extensions")), picked: !profile?.useDefaultFlags?.extensions };
+        const resources = [settings, keybindings, snippets, tasks, extensions];
+        const quickPick = this.quickInputService.createQuickPick();
+        quickPick.title = title;
+        quickPick.placeholder = ( localizeWithPath(_moduleId, 12, "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(_moduleId, 13, "Save")) : ( localizeWithPath(_moduleId, 14, "Create"));
+        quickPick.description = ( localizeWithPath(_moduleId, 15, "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(_moduleId, 16, "Profile with name {0} already exists.", quickPick.value));
+                quickPick.severity = Severity$1.Warning;
+                return;
+            }
+            if (resources.every(resource => !resource.picked)) {
+                quickPick.validationMessage = ( localizeWithPath(_moduleId, 17, "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(_moduleId, 18, "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(_moduleId, 19, "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(_moduleId, 20, "Icon:"))));
+        const profileIconElement = append(profileIconContainer, $(`.profile-icon${ThemeIcon.asCSSSelector(icon)}`));
+        profileIconElement.tabIndex = 0;
+        profileIconElement.role = 'button';
+        profileIconElement.ariaLabel = ( localizeWithPath(_moduleId, 21, "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(_moduleId, 21, "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(_moduleId, 22, "Copy from:"))));
+            const separator = { text: '\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500', isDisabled: true };
+            const profileOptions = [];
+            profileOptions.push({ text: ( localizeWithPath(_moduleId, 23, "None")) });
+            const templates = await this.userDataProfileManagementService.getBuiltinProfileTemplates();
+            if (templates.length) {
+                profileOptions.push({ ...separator, decoratorRight: ( localizeWithPath(_moduleId, 24, "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(_moduleId, 25, "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(_moduleId, 26, "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(_moduleId, 4, "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(_moduleId, 27, "Export")), undefined, true, async () => {
+                exportAction.enabled = false;
+                try {
+                    await this.doExportProfile(userDataProfilesExportState);
+                }
+                catch (error) {
+                    exportAction.enabled = true;
+                    this.notificationService.error(error);
+                    throw error;
+                }
+            })), this.notificationService)));
+            const closeAction = ( (new BarrierAction(barrier,  (new Action('close', ( localizeWithPath(_moduleId, 28, "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(_moduleId, 29, "Create Profile: {0}", message)) });
+                const createdProfile = await this.doCreateProfile(profileTemplate, false, false, { useDefaultFlags: options?.useDefaultFlags, icon: options?.icon }, reportProgress);
+                if (createdProfile) {
+                    reportProgress(( localizeWithPath(_moduleId, 30, "Applying Extensions...")));
+                    await this.instantiationService.createInstance(ExtensionsResource).copy(profile, createdProfile, false);
+                    reportProgress(( localizeWithPath(_moduleId, 31, "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(_moduleId, 32, "Troubleshoot Issue")), undefined);
+            await this.progressService.withProgress({
+                location: 15 ,
+                delay: 1000,
+                sticky: true,
+            }, async (progress) => {
+                const reportProgress = (message) => progress.report({ message: ( localizeWithPath(_moduleId, 33, "Setting up Troubleshoot Profile: {0}", message)) });
+                const profile = await this.doCreateProfile(profileTemplate, true, false, { useDefaultFlags: this.userDataProfileService.currentProfile.useDefaultFlags }, reportProgress);
+                if (profile) {
+                    reportProgress(( localizeWithPath(_moduleId, 30, "Applying Extensions...")));
+                    await this.instantiationService.createInstance(ExtensionsResource).copy(this.userDataProfileService.currentProfile, profile, true);
+                    reportProgress(( localizeWithPath(_moduleId, 31, "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(_moduleId, 34, "{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(_moduleId, 35, "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(_moduleId, 36, "&&Copy Link")),
+                        run: () => this.clipboardService.writeText(link)
+                    });
+                    if (this.productService.webUrl) {
+                        buttons.push({
+                            label: ( localizeWithPath(_moduleId, 37, "&&Open Link")),
+                            run: async () => {
+                                await this.openerService.open(link);
+                            }
+                        });
+                    }
+                    else {
+                        buttons.push({
+                            label: ( localizeWithPath(_moduleId, 38, "&&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(_moduleId, 28, "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(_moduleId, 2, "Preview Profile")));
+            if (!importedProfile) {
+                return;
+            }
+            const barrier = ( (new Barrier()));
+            const importAction = this.getCreateAction(barrier, userDataProfileImportState);
+            const primaryAction = isWeb
+                ? ( (new Action('importInDesktop', ( localizeWithPath(_moduleId, 39, "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(_moduleId, 28, "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(
+                _moduleId,
+                40,
+                "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(_moduleId, 41, "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(_moduleId, 42, "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(_moduleId, 4, "Create Profile")));
+            }
+            else {
+                const barrier = ( (new Barrier()));
+                const cancelAction = ( (new BarrierAction(barrier,  (new Action('cancel', ( localizeWithPath(_moduleId, 43, "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(_moduleId, 44, "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(_moduleId, 31, "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(_moduleId, 45, "Applying Settings...")));
+            await this.instantiationService.createInstance(SettingsResource).apply(profileTemplate.settings, profile);
+        }
+        if (profileTemplate.keybindings && !profile.useDefaultFlags?.keybindings) {
+            progress(( localizeWithPath(_moduleId, 46, "Applying Keyboard Shortcuts...")));
+            await this.instantiationService.createInstance(KeybindingsResource).apply(profileTemplate.keybindings, profile);
+        }
+        if (profileTemplate.tasks && !profile.useDefaultFlags?.tasks) {
+            progress(( localizeWithPath(_moduleId, 47, "Applying Tasks...")));
+            await this.instantiationService.createInstance(TasksResource).apply(profileTemplate.tasks, profile);
+        }
+        if (profileTemplate.snippets && !profile.useDefaultFlags?.snippets) {
+            progress(( localizeWithPath(_moduleId, 48, "Applying Snippets...")));
+            await this.instantiationService.createInstance(SnippetsResource).apply(profileTemplate.snippets, profile);
+        }
+        if (profileTemplate.globalState && !profile.useDefaultFlags?.globalState) {
+            progress(( localizeWithPath(_moduleId, 49, "Applying State...")));
+            await this.instantiationService.createInstance(GlobalStateResource).apply(profileTemplate.globalState, profile);
+        }
+        if (profileTemplate.extensions && extensions && !profile.useDefaultFlags?.extensions) {
+            progress(( localizeWithPath(_moduleId, 30, "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(_moduleId, 50, "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(
+                    _moduleId,
+                    51,
+                    "Profile with name '{0}' already exists. Do you want to overwrite it?",
+                    profileName
+                )),
+                buttons: [
+                    {
+                        label: ( localizeWithPath(_moduleId, 52, "&&Overwrite")),
+                        run: () => ImportProfileChoice.Overwrite
+                    },
+                    {
+                        label: ( localizeWithPath(_moduleId, 53, "&&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(_moduleId, 54, "Profile name")),
+                title: ( localizeWithPath(_moduleId, 55, "Create New Profile")),
+                value: `${profileName} ${this.getProfileNameIndex(profileName)}`,
+                validateInput: async (value) => {
+                    if (( (this.userDataProfilesService.profiles.some(p => p.name === value)))) {
+                        return ( localizeWithPath(_moduleId, 16, "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(_moduleId, 56, "{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(_moduleId, 57, "{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(_moduleId, 58, "Local"));
+        this.description = ( localizeWithPath(_moduleId, 59, "file"));
+    }
+    async saveProfile(name, content, token) {
+        const link = await this.fileDialogService.showSaveDialog({
+            title: ( localizeWithPath(_moduleId, 60, "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(_moduleId, 61, "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, hoverService, accessibleViewService) {
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, notificationService, hoverService, accessibleViewService);
+        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))),
+    ( (__param(15, IHoverService))),
+    ( (__param(16, IAccessibleViewInformationService)))
+], 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(_moduleId, 62, "Select {0}", root.label.label)),
+                        accessibilityInformation: {
+                            label: ( localizeWithPath(_moduleId, 62, "Select {0}", root.label.label)),
+                        }
+                    };
+                    if (root.isFromDefaultProfile()) {
+                        root.description = ( localizeWithPath(_moduleId, 63, "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(_moduleId, 64, "Name the profile")),
+                title: ( localizeWithPath(_moduleId, 65, "Export Profile")),
+                async validateInput(input) {
+                    if (!input.trim()) {
+                        return ( localizeWithPath(_moduleId, 66, "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 };