@codingame/monaco-vscode-user-data-profile-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/services/userData/browser/userDataInit.js

@@ -41,21 +41,19 @@ class UserDataInitializationService {
 }
 let InitializeOtherResourcesContribution = class InitializeOtherResourcesContribution {
     constructor(userDataInitializeService, instantiationService, extensionService) {
-        extensionService.whenInstalledExtensionsRegistered().then(() => this.initializeOtherResource(userDataInitializeService, instantiationService));
+        extensionService.whenInstalledExtensionsRegistered().then(
+            () => this.initializeOtherResource(userDataInitializeService, instantiationService)
+        );
     }
     async initializeOtherResource(userDataInitializeService, instantiationService) {
         if (await userDataInitializeService.requiresInitialization()) {
-            mark('code/willInitOtherUserData');
+            mark("code/willInitOtherUserData");
             await userDataInitializeService.initializeOtherResources(instantiationService);
-            mark('code/didInitOtherUserData');
+            mark("code/didInitOtherUserData");
         }
     }
 };
-InitializeOtherResourcesContribution = ( __decorate([
-    ( __param(0, IUserDataInitializationService)),
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IExtensionService))
-], InitializeOtherResourcesContribution));
+InitializeOtherResourcesContribution = ( __decorate([( __param(0, IUserDataInitializationService)), ( __param(1, IInstantiationService)), ( __param(2, IExtensionService))], InitializeOtherResourcesContribution));
 if (isWeb) {
     const workbenchRegistry = ( Registry.as(Extensions.Workbench));
     workbenchRegistry.registerWorkbenchContribution(InitializeOtherResourcesContribution, LifecyclePhase.Restored);

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

@@ -20,7 +20,13 @@ import { IWorkbenchExtensionManagementService } from '@codingame/monaco-vscode-a
 import { IUserDataProfileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
 
 let ExtensionsResourceInitializer = class ExtensionsResourceInitializer {
-    constructor(userDataProfileService, extensionManagementService, extensionGalleryService, extensionEnablementService, logService) {
+    constructor(
+        userDataProfileService,
+        extensionManagementService,
+        extensionGalleryService,
+        extensionEnablementService,
+        logService
+    ) {
         this.userDataProfileService = userDataProfileService;
         this.extensionManagementService = extensionManagementService;
         this.extensionGalleryService = extensionGalleryService;
@@ -39,45 +45,71 @@ let ExtensionsResourceInitializer = class ExtensionsResourceInitializer {
                 extensionsToInstall.push(e);
             }
             if (isDisabled !== !!e.disabled) {
-                extensionsToEnableOrDisable.push({ extension: e.identifier, enable: !e.disabled });
+                extensionsToEnableOrDisable.push({
+                    extension: e.identifier,
+                    enable: !e.disabled
+                });
             }
         }
-        const extensionsToUninstall = installedExtensions.filter(extension => !extension.isBuiltin && !( profileExtensions.some(({ identifier }) => areSameExtensions(identifier, extension.identifier))));
-        for (const { extension, enable } of extensionsToEnableOrDisable) {
+        const extensionsToUninstall = installedExtensions.filter(extension => !extension.isBuiltin && !( profileExtensions.some((
+            {
+                identifier
+            }
+        ) => areSameExtensions(identifier, extension.identifier))));
+        for (const {
+            extension,
+            enable
+        } of extensionsToEnableOrDisable) {
             if (enable) {
                 this.logService.trace(`Initializing Profile: Enabling extension...`, extension.id);
                 await this.extensionEnablementService.enableExtension(extension);
                 this.logService.info(`Initializing Profile: Enabled extension...`, extension.id);
-            }
-            else {
+            } else {
                 this.logService.trace(`Initializing Profile: Disabling extension...`, extension.id);
                 await this.extensionEnablementService.disableExtension(extension);
                 this.logService.info(`Initializing Profile: Disabled extension...`, extension.id);
             }
         }
         if (extensionsToInstall.length) {
-            const galleryExtensions = await this.extensionGalleryService.getExtensions(( extensionsToInstall.map(
-                e => ({ ...e.identifier, version: e.version, hasPreRelease: e.version ? undefined : e.preRelease })
-            )), CancellationToken.None);
-            await Promise.all(( extensionsToInstall.map(async (e) => {
-                const extension = galleryExtensions.find(galleryExtension => areSameExtensions(galleryExtension.identifier, e.identifier));
+            const galleryExtensions = await this.extensionGalleryService.getExtensions(( extensionsToInstall.map(e => ({
+                ...e.identifier,
+                version: e.version,
+                hasPreRelease: e.version ? undefined : e.preRelease
+            }))), CancellationToken.None);
+            await Promise.all(( extensionsToInstall.map(async e => {
+                const extension = galleryExtensions.find(
+                    galleryExtension => areSameExtensions(galleryExtension.identifier, e.identifier)
+                );
                 if (!extension) {
                     return;
                 }
                 if ((await this.extensionManagementService.canInstall(extension)) === true) {
-                    this.logService.trace(`Initializing Profile: Installing extension...`, extension.identifier.id, extension.version);
+                    this.logService.trace(
+                        `Initializing Profile: Installing extension...`,
+                        extension.identifier.id,
+                        extension.version
+                    );
                     await this.extensionManagementService.installFromGallery(extension, {
                         isMachineScoped: false,
                         donotIncludePackAndDependencies: true,
                         installGivenVersion: !!e.version,
                         installPreReleaseVersion: e.preRelease,
                         profileLocation: this.userDataProfileService.currentProfile.extensionsResource,
-                        context: { [EXTENSION_INSTALL_SKIP_WALKTHROUGH_CONTEXT]: true, [EXTENSION_INSTALL_SKIP_PUBLISHER_TRUST_CONTEXT]: true }
+                        context: {
+                            [EXTENSION_INSTALL_SKIP_WALKTHROUGH_CONTEXT]: true,
+                            [EXTENSION_INSTALL_SKIP_PUBLISHER_TRUST_CONTEXT]: true
+                        }
                     });
-                    this.logService.info(`Initializing Profile: Installed extension...`, extension.identifier.id, extension.version);
-                }
-                else {
-                    this.logService.info(`Initializing Profile: Skipped installing extension because it cannot be installed.`, extension.identifier.id);
+                    this.logService.info(
+                        `Initializing Profile: Installed extension...`,
+                        extension.identifier.id,
+                        extension.version
+                    );
+                } else {
+                    this.logService.info(
+                        `Initializing Profile: Skipped installing extension because it cannot be installed.`,
+                        extension.identifier.id
+                    );
                 }
             })));
         }
@@ -86,15 +118,15 @@ let ExtensionsResourceInitializer = class ExtensionsResourceInitializer {
         }
     }
 };
-ExtensionsResourceInitializer = ( __decorate([
-    ( __param(0, IUserDataProfileService)),
-    ( __param(1, IExtensionManagementService)),
-    ( __param(2, IExtensionGalleryService)),
-    ( __param(3, IGlobalExtensionEnablementService)),
-    ( __param(4, ILogService))
-], ExtensionsResourceInitializer));
+ExtensionsResourceInitializer = ( __decorate([( __param(0, IUserDataProfileService)), ( __param(1, IExtensionManagementService)), ( __param(2, IExtensionGalleryService)), ( __param(3, IGlobalExtensionEnablementService)), ( __param(4, ILogService))], ExtensionsResourceInitializer));
 let ExtensionsResource = class ExtensionsResource {
-    constructor(extensionManagementService, extensionGalleryService, userDataProfileStorageService, instantiationService, logService) {
+    constructor(
+        extensionManagementService,
+        extensionGalleryService,
+        userDataProfileStorageService,
+        instantiationService,
+        logService
+    ) {
         this.extensionManagementService = extensionManagementService;
         this.extensionGalleryService = extensionGalleryService;
         this.userDataProfileStorageService = userDataProfileStorageService;
@@ -106,10 +138,12 @@ let ExtensionsResource = class ExtensionsResource {
         return this.toContent(extensions, exclude);
     }
     toContent(extensions, exclude) {
-        return JSON.stringify(exclude?.length ? extensions.filter(e => !exclude.includes(e.identifier.id.toLowerCase())) : extensions);
+        return JSON.stringify(
+            exclude?.length ? extensions.filter(e => !exclude.includes(e.identifier.id.toLowerCase())) : extensions
+        );
     }
     async apply(content, profile, progress, token) {
-        return this.withProfileScopedServices(profile, async (extensionEnablementService) => {
+        return this.withProfileScopedServices(profile, async extensionEnablementService => {
             const profileExtensions = await this.getProfileExtensions(content);
             const installedExtensions = await this.extensionManagementService.getInstalled(undefined, profile.extensionsResource);
             const extensionsToEnableOrDisable = [];
@@ -121,30 +155,46 @@ let ExtensionsResource = class ExtensionsResource {
                     extensionsToInstall.push(e);
                 }
                 if (isDisabled !== !!e.disabled) {
-                    extensionsToEnableOrDisable.push({ extension: e.identifier, enable: !e.disabled });
+                    extensionsToEnableOrDisable.push({
+                        extension: e.identifier,
+                        enable: !e.disabled
+                    });
                 }
             }
-            const extensionsToUninstall = installedExtensions.filter(extension => !extension.isBuiltin && !( profileExtensions.some(({ identifier }) => areSameExtensions(identifier, extension.identifier))) && !extension.isApplicationScoped);
-            for (const { extension, enable } of extensionsToEnableOrDisable) {
+            const extensionsToUninstall = installedExtensions.filter(extension => !extension.isBuiltin && !( profileExtensions.some((
+                {
+                    identifier
+                }
+            ) => areSameExtensions(identifier, extension.identifier))) && !extension.isApplicationScoped);
+            for (const {
+                extension,
+                enable
+            } of extensionsToEnableOrDisable) {
                 if (enable) {
                     this.logService.trace(`Importing Profile (${profile.name}): Enabling extension...`, extension.id);
                     await extensionEnablementService.enableExtension(extension);
                     this.logService.info(`Importing Profile (${profile.name}): Enabled extension...`, extension.id);
-                }
-                else {
-                    this.logService.trace(`Importing Profile (${profile.name}): Disabling extension...`, extension.id);
+                } else {
+                    this.logService.trace(
+                        `Importing Profile (${profile.name}): Disabling extension...`,
+                        extension.id
+                    );
                     await extensionEnablementService.disableExtension(extension);
                     this.logService.info(`Importing Profile (${profile.name}): Disabled extension...`, extension.id);
                 }
             }
             if (extensionsToInstall.length) {
                 this.logService.info(`Importing Profile (${profile.name}): Started installing extensions.`);
-                const galleryExtensions = await this.extensionGalleryService.getExtensions(( extensionsToInstall.map(
-                    e => ({ ...e.identifier, version: e.version, hasPreRelease: e.version ? undefined : e.preRelease })
-                )), CancellationToken.None);
+                const galleryExtensions = await this.extensionGalleryService.getExtensions(( extensionsToInstall.map(e => ({
+                    ...e.identifier,
+                    version: e.version,
+                    hasPreRelease: e.version ? undefined : e.preRelease
+                }))), CancellationToken.None);
                 const installExtensionInfos = [];
-                await Promise.all(( extensionsToInstall.map(async (e) => {
-                    const extension = galleryExtensions.find(galleryExtension => areSameExtensions(galleryExtension.identifier, e.identifier));
+                await Promise.all(( extensionsToInstall.map(async e => {
+                    const extension = galleryExtensions.find(
+                        galleryExtension => areSameExtensions(galleryExtension.identifier, e.identifier)
+                    );
                     if (!extension) {
                         return;
                     }
@@ -157,12 +207,16 @@ let ExtensionsResource = class ExtensionsResource {
                                 installGivenVersion: !!e.version,
                                 installPreReleaseVersion: e.preRelease,
                                 profileLocation: profile.extensionsResource,
-                                context: { [EXTENSION_INSTALL_SKIP_WALKTHROUGH_CONTEXT]: true }
+                                context: {
+                                    [EXTENSION_INSTALL_SKIP_WALKTHROUGH_CONTEXT]: true
+                                }
                             }
                         });
-                    }
-                    else {
-                        this.logService.info(`Importing Profile (${profile.name}): Skipped installing extension because it cannot be installed.`, extension.identifier.id);
+                    } else {
+                        this.logService.info(
+                            `Importing Profile (${profile.name}): Skipped installing extension because it cannot be installed.`,
+                            extension.identifier.id
+                        );
                     }
                 })));
                 if (installExtensionInfos.length) {
@@ -173,14 +227,13 @@ let ExtensionsResource = class ExtensionsResource {
                                 return;
                             }
                             progress?.(( localize(
-                                14511,
+                                14908,
                                 "Installing extension {0}...",
                                 installExtensionInfo.extension.displayName ?? installExtensionInfo.extension.identifier.id
                             )));
                             await this.extensionManagementService.installFromGallery(installExtensionInfo.extension, installExtensionInfo.options);
                         }
-                    }
-                    else {
+                    } else {
                         await this.extensionManagementService.installGalleryExtensions(installExtensionInfos);
                     }
                 }
@@ -193,22 +246,28 @@ let ExtensionsResource = class ExtensionsResource {
     }
     async copy(from, to, disableExtensions) {
         await this.extensionManagementService.copyExtensions(from.extensionsResource, to.extensionsResource);
-        const extensionsToDisable = await this.withProfileScopedServices(from, async (extensionEnablementService) => extensionEnablementService.getDisabledExtensions());
+        const extensionsToDisable = await this.withProfileScopedServices(
+            from,
+            async extensionEnablementService => extensionEnablementService.getDisabledExtensions()
+        );
         if (disableExtensions) {
             const extensions = await this.extensionManagementService.getInstalled(ExtensionType.User, to.extensionsResource);
             for (const extension of extensions) {
                 extensionsToDisable.push(extension.identifier);
             }
         }
-        await this.withProfileScopedServices(to, async (extensionEnablementService) => Promise.all(( extensionsToDisable.map(extension => extensionEnablementService.disableExtension(extension)))));
+        await this.withProfileScopedServices(to, async extensionEnablementService => Promise.all(( extensionsToDisable.map(extension => extensionEnablementService.disableExtension(extension)))));
     }
     async getLocalExtensions(profile) {
-        return this.withProfileScopedServices(profile, async (extensionEnablementService) => {
+        return this.withProfileScopedServices(profile, async extensionEnablementService => {
             const result = ( new Map());
             const installedExtensions = await this.extensionManagementService.getInstalled(undefined, profile.extensionsResource);
             const disabledExtensions = extensionEnablementService.getDisabledExtensions();
             for (const extension of installedExtensions) {
-                const { identifier, preRelease } = extension;
+                const {
+                    identifier,
+                    preRelease
+                } = extension;
                 const disabled = ( disabledExtensions.some(disabledExtension => areSameExtensions(disabledExtension, identifier)));
                 if (extension.isBuiltin && !disabled) {
                     continue;
@@ -222,7 +281,10 @@ let ExtensionsResource = class ExtensionsResource {
                 if (existing?.disabled) {
                     result.delete(identifier.id.toLowerCase());
                 }
-                const profileExtension = { identifier, displayName: extension.manifest.displayName };
+                const profileExtension = {
+                    identifier,
+                    displayName: extension.manifest.displayName
+                };
                 if (disabled) {
                     profileExtension.disabled = true;
                 }
@@ -242,64 +304,64 @@ let ExtensionsResource = class ExtensionsResource {
         return JSON.parse(content);
     }
     async withProfileScopedServices(profile, fn) {
-        return this.userDataProfileStorageService.withProfileScopedStorageService(profile, async (storageService) => {
+        return this.userDataProfileStorageService.withProfileScopedStorageService(profile, async storageService => {
             const disposables = ( new DisposableStore());
             const instantiationService = disposables.add(this.instantiationService.createChild(( new ServiceCollection([IStorageService, storageService]))));
             const extensionEnablementService = disposables.add(instantiationService.createInstance(GlobalExtensionEnablementService));
             try {
                 return await fn(extensionEnablementService);
-            }
-            finally {
+            } finally {
                 disposables.dispose();
             }
         });
     }
 };
-ExtensionsResource = ( __decorate([
-    ( __param(0, IWorkbenchExtensionManagementService)),
-    ( __param(1, IExtensionGalleryService)),
-    ( __param(2, IUserDataProfileStorageService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, ILogService))
-], ExtensionsResource));
+ExtensionsResource = ( __decorate([( __param(0, IWorkbenchExtensionManagementService)), ( __param(1, IExtensionGalleryService)), ( __param(2, IUserDataProfileStorageService)), ( __param(3, IInstantiationService)), ( __param(4, ILogService))], ExtensionsResource));
 class ExtensionsResourceTreeItem {
     constructor() {
         this.type = ProfileResourceType.Extensions;
         this.handle = ProfileResourceType.Extensions;
-        this.label = { label: ( localize(14512, "Extensions")) };
+        this.label = {
+            label: ( localize(14909, "Extensions"))
+        };
         this.collapsibleState = TreeItemCollapsibleState.Expanded;
         this.contextValue = ProfileResourceType.Extensions;
         this.excludedExtensions = ( new Set());
     }
     async getChildren() {
-        const extensions = (await this.getExtensions()).sort((a, b) => (a.displayName ?? a.identifier.id).localeCompare(b.displayName ?? b.identifier.id));
+        const extensions = (await this.getExtensions()).sort(
+            (a, b) => (a.displayName ?? a.identifier.id).localeCompare(b.displayName ?? b.identifier.id)
+        );
         const that = this;
         return (extensions.map(e => ({
             ...e,
             handle: e.identifier.id.toLowerCase(),
             parent: this,
-            label: { label: e.displayName || e.identifier.id },
-            description: e.applicationScoped ? ( localize(14513, "All Profiles")) : undefined,
+            label: {
+                label: e.displayName || e.identifier.id
+            },
+            description: e.applicationScoped ? ( localize(14910, "All Profiles")) : undefined,
             collapsibleState: TreeItemCollapsibleState.None,
             checkbox: that.checkbox ? {
-                get isChecked() { return !( that.excludedExtensions.has(e.identifier.id.toLowerCase())); },
+                get isChecked() {
+                    return !( that.excludedExtensions.has(e.identifier.id.toLowerCase()));
+                },
                 set isChecked(value) {
                     if (value) {
                         that.excludedExtensions.delete(e.identifier.id.toLowerCase());
-                    }
-                    else {
+                    } else {
                         that.excludedExtensions.add(e.identifier.id.toLowerCase());
                     }
                 },
-                tooltip: ( localize(14514, "Select {0} Extension", e.displayName || e.identifier.id)),
+                tooltip: ( localize(14911, "Select {0} Extension", e.displayName || e.identifier.id)),
                 accessibilityInformation: {
-                    label: ( localize(14514, "Select {0} Extension", e.displayName || e.identifier.id)),
+                    label: ( localize(14911, "Select {0} Extension", e.displayName || e.identifier.id))
                 }
             } : undefined,
             themeIcon: Codicon.extensions,
             command: {
-                id: 'extension.open',
-                title: '',
+                id: "extension.open",
+                title: "",
                 arguments: [e.identifier.id, undefined, true]
             }
         })));
@@ -325,9 +387,7 @@ let ExtensionsResourceExportTreeItem = class ExtensionsResourceExportTreeItem ex
         return this.instantiationService.createInstance(ExtensionsResource).getContent(this.profile, [...( this.excludedExtensions.values())]);
     }
 };
-ExtensionsResourceExportTreeItem = ( __decorate([
-    ( __param(1, IInstantiationService))
-], ExtensionsResourceExportTreeItem));
+ExtensionsResourceExportTreeItem = ( __decorate([( __param(1, IInstantiationService))], ExtensionsResourceExportTreeItem));
 let ExtensionsResourceImportTreeItem = class ExtensionsResourceImportTreeItem extends ExtensionsResourceTreeItem {
     constructor(content, instantiationService) {
         super();
@@ -346,8 +406,6 @@ let ExtensionsResourceImportTreeItem = class ExtensionsResourceImportTreeItem ex
         return extensionsResource.toContent(extensions, [...( this.excludedExtensions.values())]);
     }
 };
-ExtensionsResourceImportTreeItem = ( __decorate([
-    ( __param(1, IInstantiationService))
-], ExtensionsResourceImportTreeItem));
+ExtensionsResourceImportTreeItem = ( __decorate([( __param(1, IInstantiationService))], ExtensionsResourceImportTreeItem));
 
 export { ExtensionsResource, ExtensionsResourceExportTreeItem, ExtensionsResourceImportTreeItem, ExtensionsResourceInitializer, ExtensionsResourceTreeItem };

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

@@ -21,15 +21,18 @@ let GlobalStateResourceInitializer = class GlobalStateResourceInitializer {
         if (storageKeys.length) {
             const storageEntries = [];
             for (const key of storageKeys) {
-                storageEntries.push({ key, value: globalState.storage[key], scope: StorageScope.PROFILE, target: StorageTarget.USER });
+                storageEntries.push({
+                    key,
+                    value: globalState.storage[key],
+                    scope: StorageScope.PROFILE,
+                    target: StorageTarget.USER
+                });
             }
             this.storageService.storeAll(storageEntries, true);
         }
     }
 };
-GlobalStateResourceInitializer = ( __decorate([
-    ( __param(0, IStorageService))
-], GlobalStateResourceInitializer));
+GlobalStateResourceInitializer = ( __decorate([( __param(0, IStorageService))], GlobalStateResourceInitializer));
 let GlobalStateResource = class GlobalStateResource {
     constructor(storageService, userDataProfileStorageService, logService) {
         this.storageService = storageService;
@@ -52,7 +55,9 @@ let GlobalStateResource = class GlobalStateResource {
                 storage[key] = value.value;
             }
         }
-        return { storage };
+        return {
+            storage
+        };
     }
     async writeGlobalState(globalState, profile) {
         const storageKeys = ( Object.keys(globalState.storage));
@@ -61,13 +66,14 @@ let GlobalStateResource = class GlobalStateResource {
             const nonProfileKeys = [
                 ...( this.storageService.keys(StorageScope.APPLICATION, StorageTarget.MACHINE)),
                 ...( this.storageService.keys(StorageScope.WORKSPACE, StorageTarget.USER)),
-                ...( this.storageService.keys(StorageScope.WORKSPACE, StorageTarget.MACHINE)),
+                ...( this.storageService.keys(StorageScope.WORKSPACE, StorageTarget.MACHINE))
             ];
             for (const key of storageKeys) {
                 if (nonProfileKeys.includes(key)) {
-                    this.logService.info(`Importing Profile (${profile.name}): Ignoring global state key '${key}' because it is not a profile key.`);
-                }
-                else {
+                    this.logService.info(
+                        `Importing Profile (${profile.name}): Ignoring global state key '${key}' because it is not a profile key.`
+                    );
+                } else {
                     updatedStorage.set(key, globalState.storage[key]);
                 }
             }
@@ -75,35 +81,33 @@ let GlobalStateResource = class GlobalStateResource {
         }
     }
 };
-GlobalStateResource = ( __decorate([
-    ( __param(0, IStorageService)),
-    ( __param(1, IUserDataProfileStorageService)),
-    ( __param(2, ILogService))
-], GlobalStateResource));
+GlobalStateResource = ( __decorate([( __param(0, IStorageService)), ( __param(1, IUserDataProfileStorageService)), ( __param(2, ILogService))], GlobalStateResource));
 class GlobalStateResourceTreeItem {
     constructor(resource, uriIdentityService) {
         this.resource = resource;
         this.uriIdentityService = uriIdentityService;
         this.type = ProfileResourceType.GlobalState;
         this.handle = ProfileResourceType.GlobalState;
-        this.label = { label: ( localize(14515, "UI State")) };
+        this.label = {
+            label: ( localize(14912, "UI State"))
+        };
         this.collapsibleState = TreeItemCollapsibleState.Collapsed;
     }
     async getChildren() {
         return [{
-                handle: ( this.resource.toString()),
-                resourceUri: this.resource,
-                collapsibleState: TreeItemCollapsibleState.None,
-                accessibilityInformation: {
-                    label: this.uriIdentityService.extUri.basename(this.resource)
-                },
-                parent: this,
-                command: {
-                    id: API_OPEN_EDITOR_COMMAND_ID,
-                    title: '',
-                    arguments: [this.resource, undefined, undefined]
-                }
-            }];
+            handle: ( this.resource.toString()),
+            resourceUri: this.resource,
+            collapsibleState: TreeItemCollapsibleState.None,
+            accessibilityInformation: {
+                label: this.uriIdentityService.extUri.basename(this.resource)
+            },
+            parent: this,
+            command: {
+                id: API_OPEN_EDITOR_COMMAND_ID,
+                title: "",
+                arguments: [this.resource, undefined, undefined]
+            }
+        }];
     }
 }
 let GlobalStateResourceExportTreeItem = class GlobalStateResourceExportTreeItem extends GlobalStateResourceTreeItem {
@@ -123,9 +127,6 @@ let GlobalStateResourceExportTreeItem = class GlobalStateResourceExportTreeItem
         return !this.profile.isDefault && !!this.profile.useDefaultFlags?.globalState;
     }
 };
-GlobalStateResourceExportTreeItem = ( __decorate([
-    ( __param(2, IUriIdentityService)),
-    ( __param(3, IInstantiationService))
-], GlobalStateResourceExportTreeItem));
+GlobalStateResourceExportTreeItem = ( __decorate([( __param(2, IUriIdentityService)), ( __param(3, IInstantiationService))], GlobalStateResourceExportTreeItem));
 
 export { GlobalStateResource, GlobalStateResourceExportTreeItem, GlobalStateResourceInitializer, GlobalStateResourceTreeItem };

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

@@ -25,14 +25,13 @@ let KeybindingsResourceInitializer = class KeybindingsResourceInitializer {
             this.logService.info(`Initializing Profile: No keybindings to apply...`);
             return;
         }
-        await this.fileService.writeFile(this.userDataProfileService.currentProfile.keybindingsResource, VSBuffer.fromString(keybindingsContent.keybindings));
+        await this.fileService.writeFile(
+            this.userDataProfileService.currentProfile.keybindingsResource,
+            VSBuffer.fromString(keybindingsContent.keybindings)
+        );
     }
 };
-KeybindingsResourceInitializer = ( __decorate([
-    ( __param(0, IUserDataProfileService)),
-    ( __param(1, IFileService)),
-    ( __param(2, ILogService))
-], KeybindingsResourceInitializer));
+KeybindingsResourceInitializer = ( __decorate([( __param(0, IUserDataProfileService)), ( __param(1, IFileService)), ( __param(2, ILogService))], KeybindingsResourceInitializer));
 let KeybindingsResource = class KeybindingsResource {
     constructor(fileService, logService) {
         this.fileService = fileService;
@@ -44,7 +43,10 @@ let KeybindingsResource = class KeybindingsResource {
     }
     async getKeybindingsResourceContent(profile) {
         const keybindings = await this.getKeybindingsContent(profile);
-        return { keybindings, platform };
+        return {
+            keybindings,
+            platform
+        };
     }
     async apply(content, profile) {
         const keybindingsContent = JSON.parse(content);
@@ -52,27 +54,25 @@ let KeybindingsResource = class KeybindingsResource {
             this.logService.info(`Importing Profile (${profile.name}): No keybindings to apply...`);
             return;
         }
-        await this.fileService.writeFile(profile.keybindingsResource, VSBuffer.fromString(keybindingsContent.keybindings));
+        await this.fileService.writeFile(
+            profile.keybindingsResource,
+            VSBuffer.fromString(keybindingsContent.keybindings)
+        );
     }
     async getKeybindingsContent(profile) {
         try {
             const content = await this.fileService.readFile(profile.keybindingsResource);
             return ( content.value.toString());
-        }
-        catch (error) {
+        } catch (error) {
             if (error instanceof FileOperationError && error.fileOperationResult === FileOperationResult.FILE_NOT_FOUND) {
                 return null;
-            }
-            else {
+            } else {
                 throw error;
             }
         }
     }
 };
-KeybindingsResource = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, ILogService))
-], KeybindingsResource));
+KeybindingsResource = ( __decorate([( __param(0, IFileService)), ( __param(1, ILogService))], KeybindingsResource));
 let KeybindingsResourceTreeItem = class KeybindingsResourceTreeItem {
     constructor(profile, uriIdentityService, instantiationService) {
         this.profile = profile;
@@ -80,7 +80,9 @@ let KeybindingsResourceTreeItem = class KeybindingsResourceTreeItem {
         this.instantiationService = instantiationService;
         this.type = ProfileResourceType.Keybindings;
         this.handle = ProfileResourceType.Keybindings;
-        this.label = { label: ( localize(14516, "Keyboard Shortcuts")) };
+        this.label = {
+            label: ( localize(14913, "Keyboard Shortcuts"))
+        };
         this.collapsibleState = TreeItemCollapsibleState.Expanded;
     }
     isFromDefaultProfile() {
@@ -88,19 +90,19 @@ let KeybindingsResourceTreeItem = class KeybindingsResourceTreeItem {
     }
     async getChildren() {
         return [{
-                handle: ( this.profile.keybindingsResource.toString()),
-                resourceUri: this.profile.keybindingsResource,
-                collapsibleState: TreeItemCollapsibleState.None,
-                parent: this,
-                accessibilityInformation: {
-                    label: this.uriIdentityService.extUri.basename(this.profile.settingsResource)
-                },
-                command: {
-                    id: API_OPEN_EDITOR_COMMAND_ID,
-                    title: '',
-                    arguments: [this.profile.keybindingsResource, undefined, undefined]
-                }
-            }];
+            handle: ( this.profile.keybindingsResource.toString()),
+            resourceUri: this.profile.keybindingsResource,
+            collapsibleState: TreeItemCollapsibleState.None,
+            parent: this,
+            accessibilityInformation: {
+                label: this.uriIdentityService.extUri.basename(this.profile.settingsResource)
+            },
+            command: {
+                id: API_OPEN_EDITOR_COMMAND_ID,
+                title: "",
+                arguments: [this.profile.keybindingsResource, undefined, undefined]
+            }
+        }];
     }
     async hasContent() {
         const keybindingsContent = await this.instantiationService.createInstance(KeybindingsResource).getKeybindingsResourceContent(this.profile);
@@ -110,9 +112,6 @@ let KeybindingsResourceTreeItem = class KeybindingsResourceTreeItem {
         return this.instantiationService.createInstance(KeybindingsResource).getContent(this.profile);
     }
 };
-KeybindingsResourceTreeItem = ( __decorate([
-    ( __param(1, IUriIdentityService)),
-    ( __param(2, IInstantiationService))
-], KeybindingsResourceTreeItem));
+KeybindingsResourceTreeItem = ( __decorate([( __param(1, IUriIdentityService)), ( __param(2, IInstantiationService))], KeybindingsResourceTreeItem));
 
 export { KeybindingsResource, KeybindingsResourceInitializer, KeybindingsResourceTreeItem };