@codingame/monaco-vscode-api 4.5.1 → 5.0.0

package/vscode/src/vs/platform/userDataProfile/common/userDataProfile.js

@@ -16,6 +16,7 @@ import { Promises } from '../../../base/common/async.js';
 import { generateUuid } from '../../../base/common/uuid.js';
 import { escapeRegExpCharacters } from '../../../base/common/strings.js';
 import { isString } from '../../../base/common/types.js';
+const _moduleId = "vs/platform/userDataProfile/common/userDataProfile";
 function isUserDataProfile(thing) {
     const candidate = thing;
     return !!(candidate && typeof candidate === 'object'
@@ -80,19 +81,19 @@ let UserDataProfilesService = class UserDataProfilesService extends Disposable {
         this.uriIdentityService = uriIdentityService;
         this.logService = logService;
         this.enabled = true;
-        this._onDidChangeProfiles = this._register(( new Emitter()));
+        this._onDidChangeProfiles = this._register(( (new Emitter())));
         this.onDidChangeProfiles = this._onDidChangeProfiles.event;
-        this._onWillCreateProfile = this._register(( new Emitter()));
+        this._onWillCreateProfile = this._register(( (new Emitter())));
         this.onWillCreateProfile = this._onWillCreateProfile.event;
-        this._onWillRemoveProfile = this._register(( new Emitter()));
+        this._onWillRemoveProfile = this._register(( (new Emitter())));
         this.onWillRemoveProfile = this._onWillRemoveProfile.event;
-        this._onDidResetWorkspaces = this._register(( new Emitter()));
+        this._onDidResetWorkspaces = this._register(( (new Emitter())));
         this.onDidResetWorkspaces = this._onDidResetWorkspaces.event;
-        this.profileCreationPromises = ( new Map());
+        this.profileCreationPromises = ( (new Map()));
         this.transientProfilesObject = {
             profiles: [],
-            workspaces: ( new ResourceMap()),
-            emptyWindows: ( new Map())
+            workspaces: ( (new ResourceMap())),
+            emptyWindows: ( (new Map()))
         };
         this.profilesHome = joinPath(this.environmentService.userRoamingDataHome, 'profiles');
         this.profilesCacheHome = joinPath(this.environmentService.cacheHome, 'CachedProfilesData');
@@ -127,14 +128,14 @@ let UserDataProfilesService = class UserDataProfilesService extends Disposable {
                     this.logService.error(error);
                 }
             }
-            const workspaces = ( new ResourceMap());
-            const emptyWindows = ( new Map());
+            const workspaces = ( (new ResourceMap()));
+            const emptyWindows = ( (new Map()));
             if (profiles.length) {
                 try {
                     const profileAssociaitions = this.getStoredProfileAssociations();
                     if (profileAssociaitions.workspaces) {
                         for (const [workspacePath, profileId] of Object.entries(profileAssociaitions.workspaces)) {
-                            const workspace = ( URI.parse(workspacePath));
+                            const workspace = ( (URI.parse(workspacePath)));
                             const profile = profiles.find(p => p.id === profileId);
                             if (profile) {
                                 workspaces.set(workspace, profile);
@@ -159,16 +160,12 @@ let UserDataProfilesService = class UserDataProfilesService extends Disposable {
         return this._profilesObject;
     }
     createDefaultProfile() {
-        const defaultProfile = toUserDataProfile('__default__profile__', ( localizeWithPath(
-            'vs/platform/userDataProfile/common/userDataProfile',
-            'defaultProfile',
-            "Default"
-        )), this.environmentService.userRoamingDataHome, this.profilesCacheHome);
+        const defaultProfile = toUserDataProfile('__default__profile__', ( localizeWithPath(_moduleId, 0, "Default")), this.environmentService.userRoamingDataHome, this.profilesCacheHome);
         return { ...defaultProfile, extensionsResource: this.getDefaultProfileExtensionsLocation() ?? defaultProfile.extensionsResource, isDefault: true };
     }
     async createTransientProfile(workspaceIdentifier) {
         const namePrefix = `Temp`;
-        const nameRegEx = ( new RegExp(`${escapeRegExpCharacters(namePrefix)}\\s(\\d+)`));
+        const nameRegEx = ( (new RegExp(`${escapeRegExpCharacters(namePrefix)}\\s(\\d+)`)));
         let nameIndex = 0;
         for (const profile of this.profiles) {
             const matches = nameRegEx.exec(profile.name);
@@ -176,14 +173,14 @@ let UserDataProfilesService = class UserDataProfilesService extends Disposable {
             nameIndex = index > nameIndex ? index : nameIndex;
         }
         const name = `${namePrefix} ${nameIndex + 1}`;
-        return this.createProfile(( hash(generateUuid()).toString(16)), name, { transient: true }, workspaceIdentifier);
+        return this.createProfile(( (hash(generateUuid()).toString(16))), name, { transient: true }, workspaceIdentifier);
     }
     async createNamedProfile(name, options, workspaceIdentifier) {
-        return this.createProfile(( hash(generateUuid()).toString(16)), name, options, workspaceIdentifier);
+        return this.createProfile(( (hash(generateUuid()).toString(16))), name, options, workspaceIdentifier);
     }
     async createProfile(id, name, options, workspaceIdentifier) {
         if (!this.enabled) {
-            throw new Error(`Profiles are disabled in the current environment.`);
+            throw ( (new Error(`Profiles are disabled in the current environment.`)));
         }
         const profile = await this.doCreateProfile(id, name, options);
         if (workspaceIdentifier) {
@@ -193,7 +190,7 @@ let UserDataProfilesService = class UserDataProfilesService extends Disposable {
     }
     async doCreateProfile(id, name, options) {
         if (!isString(name) || !name) {
-            throw new Error('Name of the profile is mandatory and must be of type `string`');
+            throw ( (new Error('Name of the profile is mandatory and must be of type `string`')));
         }
         let profileCreationPromise = this.profileCreationPromises.get(name);
         if (!profileCreationPromise) {
@@ -201,7 +198,7 @@ let UserDataProfilesService = class UserDataProfilesService extends Disposable {
                 try {
                     const existing = this.profiles.find(p => p.name === name || p.id === id);
                     if (existing) {
-                        return existing;
+                        throw ( (new Error(`Profile with ${name} name already exists`)));
                     }
                     const profile = toUserDataProfile(id, name, joinPath(this.profilesHome, id), this.profilesCacheHome, options, this.defaultProfile);
                     await this.fileService.createFolder(profile.location);
@@ -226,11 +223,11 @@ let UserDataProfilesService = class UserDataProfilesService extends Disposable {
     }
     async updateProfile(profileToUpdate, options) {
         if (!this.enabled) {
-            throw new Error(`Profiles are disabled in the current environment.`);
+            throw ( (new Error(`Profiles are disabled in the current environment.`)));
         }
         let profile = this.profiles.find(p => p.id === profileToUpdate.id);
         if (!profile) {
-            throw new Error(`Profile '${profileToUpdate.name}' does not exist`);
+            throw ( (new Error(`Profile '${profileToUpdate.name}' does not exist`)));
         }
         profile = toUserDataProfile(profile.id, options.name ?? profile.name, profile.location, this.profilesCacheHome, {
             shortName: options.shortName ?? profile.shortName,
@@ -243,14 +240,14 @@ let UserDataProfilesService = class UserDataProfilesService extends Disposable {
     }
     async removeProfile(profileToRemove) {
         if (!this.enabled) {
-            throw new Error(`Profiles are disabled in the current environment.`);
+            throw ( (new Error(`Profiles are disabled in the current environment.`)));
         }
         if (profileToRemove.isDefault) {
-            throw new Error('Cannot remove default profile');
+            throw ( (new Error('Cannot remove default profile')));
         }
         const profile = this.profiles.find(p => p.id === profileToRemove.id);
         if (!profile) {
-            throw new Error(`Profile '${profileToRemove.name}' does not exist`);
+            throw ( (new Error(`Profile '${profileToRemove.name}' does not exist`)));
         }
         const joiners = [];
         this._onWillRemoveProfile.fire({
@@ -265,12 +262,12 @@ let UserDataProfilesService = class UserDataProfilesService extends Disposable {
         catch (error) {
             this.logService.error(error);
         }
-        for (const windowId of [...( this.profilesObject.emptyWindows.keys())]) {
+        for (const windowId of [...( (this.profilesObject.emptyWindows.keys()))]) {
             if (profile.id === this.profilesObject.emptyWindows.get(windowId)?.id) {
                 this.profilesObject.emptyWindows.delete(windowId);
             }
         }
-        for (const workspace of [...( this.profilesObject.workspaces.keys())]) {
+        for (const workspace of [...( (this.profilesObject.workspaces.keys()))]) {
             if (profile.id === this.profilesObject.workspaces.get(workspace)?.id) {
                 this.profilesObject.workspaces.delete(workspace);
             }
@@ -288,17 +285,17 @@ let UserDataProfilesService = class UserDataProfilesService extends Disposable {
     }
     async setProfileForWorkspace(workspaceIdentifier, profileToSet) {
         if (!this.enabled) {
-            throw new Error(`Profiles are disabled in the current environment.`);
+            throw ( (new Error(`Profiles are disabled in the current environment.`)));
         }
         const profile = this.profiles.find(p => p.id === profileToSet.id);
         if (!profile) {
-            throw new Error(`Profile '${profileToSet.name}' does not exist`);
+            throw ( (new Error(`Profile '${profileToSet.name}' does not exist`)));
         }
         this.updateWorkspaceAssociation(workspaceIdentifier, profile);
     }
     unsetWorkspace(workspaceIdentifier, transient) {
         if (!this.enabled) {
-            throw new Error(`Profiles are disabled in the current environment.`);
+            throw ( (new Error(`Profiles are disabled in the current environment.`)));
         }
         this.updateWorkspaceAssociation(workspaceIdentifier, undefined, transient);
     }
@@ -316,9 +313,9 @@ let UserDataProfilesService = class UserDataProfilesService extends Disposable {
         }
         if (await this.fileService.exists(this.profilesHome)) {
             const stat = await this.fileService.resolve(this.profilesHome);
-            await Promise.all(( (stat.children || [])
+            await Promise.all(( ((stat.children || [])
                 .filter(child => child.isDirectory && this.profiles.every(p => !this.uriIdentityService.extUri.isEqual(p.location, child.resource)))
-                .map(child => this.fileService.del(child.resource, { recursive: true }))));
+                .map(child => this.fileService.del(child.resource, { recursive: true })))));
         }
     }
     async cleanUpTransientProfiles() {
@@ -326,7 +323,7 @@ let UserDataProfilesService = class UserDataProfilesService extends Disposable {
             return;
         }
         const unAssociatedTransientProfiles = this.transientProfilesObject.profiles.filter(p => !this.isProfileAssociatedToWorkspace(p));
-        await Promise.allSettled(( unAssociatedTransientProfiles.map(p => this.removeProfile(p))));
+        await Promise.allSettled(( (unAssociatedTransientProfiles.map(p => this.removeProfile(p)))));
     }
     getProfileForWorkspace(workspaceIdentifier) {
         const workspace = this.getWorkspace(workspaceIdentifier);
@@ -342,24 +339,24 @@ let UserDataProfilesService = class UserDataProfilesService extends Disposable {
         return workspaceIdentifier.id;
     }
     isProfileAssociatedToWorkspace(profile) {
-        if (( [...( this.transientProfilesObject.emptyWindows.values())].some(
+        if (( ([...( (this.transientProfilesObject.emptyWindows.values()))].some(
             windowProfile => this.uriIdentityService.extUri.isEqual(windowProfile.location, profile.location)
-        ))) {
+        )))) {
             return true;
         }
-        if (( [...( this.transientProfilesObject.workspaces.values())].some(
+        if (( ([...( (this.transientProfilesObject.workspaces.values()))].some(
             workspaceProfile => this.uriIdentityService.extUri.isEqual(workspaceProfile.location, profile.location)
-        ))) {
+        )))) {
             return true;
         }
-        if (( [...( this.profilesObject.emptyWindows.values())].some(
+        if (( ([...( (this.profilesObject.emptyWindows.values()))].some(
             windowProfile => this.uriIdentityService.extUri.isEqual(windowProfile.location, profile.location)
-        ))) {
+        )))) {
             return true;
         }
-        if (( [...( this.profilesObject.workspaces.values())].some(
+        if (( ([...( (this.profilesObject.workspaces.values()))].some(
             workspaceProfile => this.uriIdentityService.extUri.isEqual(workspaceProfile.location, profile.location)
-        ))) {
+        )))) {
             return true;
         }
         return false;
@@ -372,7 +369,7 @@ let UserDataProfilesService = class UserDataProfilesService extends Disposable {
             if (profile.isDefault) {
                 continue;
             }
-            if (( removed.some(p => profile.id === p.id))) {
+            if (( (removed.some(p => profile.id === p.id)))) {
                 continue;
             }
             profile = updated.find(p => profile.id === p.id) ?? profile;
@@ -416,11 +413,11 @@ let UserDataProfilesService = class UserDataProfilesService extends Disposable {
     updateStoredProfileAssociations() {
         const workspaces = {};
         for (const [workspace, profile] of this.profilesObject.workspaces.entries()) {
-            workspaces[( workspace.toString())] = profile.id;
+            workspaces[( (workspace.toString()))] = profile.id;
         }
         const emptyWindows = {};
         for (const [windowId, profile] of this.profilesObject.emptyWindows.entries()) {
-            emptyWindows[( windowId.toString())] = profile.id;
+            emptyWindows[( (windowId.toString()))] = profile.id;
         }
         this.saveStoredProfileAssociations({ workspaces, emptyWindows });
         this._profilesObject = undefined;
@@ -430,29 +427,29 @@ let UserDataProfilesService = class UserDataProfilesService extends Disposable {
         const defaultProfile = this.createDefaultProfile();
         if (storedProfileAssociations.workspaces) {
             for (const [workspace, location] of Object.entries(storedProfileAssociations.workspaces)) {
-                const uri = ( URI.parse(location));
+                const uri = ( (URI.parse(location)));
                 workspaces[workspace] = this.uriIdentityService.extUri.isEqual(uri, defaultProfile.location) ? defaultProfile.id : this.uriIdentityService.extUri.basename(uri);
             }
         }
         const emptyWindows = {};
         if (storedProfileAssociations.emptyWindows) {
             for (const [workspace, location] of Object.entries(storedProfileAssociations.emptyWindows)) {
-                const uri = ( URI.parse(location));
+                const uri = ( (URI.parse(location)));
                 emptyWindows[workspace] = this.uriIdentityService.extUri.isEqual(uri, defaultProfile.location) ? defaultProfile.id : this.uriIdentityService.extUri.basename(uri);
             }
         }
         return { workspaces, emptyWindows };
     }
     getStoredProfiles() { return []; }
-    saveStoredProfiles(storedProfiles) { throw new Error('not implemented'); }
+    saveStoredProfiles(storedProfiles) { throw ( (new Error('not implemented'))); }
     getStoredProfileAssociations() { return {}; }
-    saveStoredProfileAssociations(storedProfileAssociations) { throw new Error('not implemented'); }
+    saveStoredProfileAssociations(storedProfileAssociations) { throw ( (new Error('not implemented'))); }
     getDefaultProfileExtensionsLocation() { return undefined; }
 };
-UserDataProfilesService = ( __decorate([
-    ( __param(0, IEnvironmentService)),
-    ( __param(1, IFileService)),
-    ( __param(2, IUriIdentityService)),
-    ( __param(3, ILogService))
-], UserDataProfilesService));
+UserDataProfilesService = ( (__decorate([
+    ( (__param(0, IEnvironmentService))),
+    ( (__param(1, IFileService))),
+    ( (__param(2, IUriIdentityService))),
+    ( (__param(3, ILogService)))
+], UserDataProfilesService)));
 export { UserDataProfilesService, isUserDataProfile, reviveProfile, toUserDataProfile };

package/vscode/src/vs/platform/userDataSync/common/abstractSynchronizer.js

@@ -21,6 +21,7 @@ import { IUriIdentityService } from '../../uriIdentity/common/uriIdentity.servic
 import { getPathSegments, PREVIEW_DIR_NAME, getLastSyncResourceUri, UserDataSyncError, USER_DATA_SYNC_SCHEME, USER_DATA_SYNC_CONFIGURATION_SCOPE } from './userDataSync.js';
 import { IUserDataSyncStoreService, IUserDataSyncLocalStoreService, IUserDataSyncEnablementService, IUserDataSyncLogService, IUserDataSyncUtilService } from './userDataSync.service.js';
 import { IUserDataProfilesService } from '../../userDataProfile/common/userDataProfile.service.js';
+const _moduleId = "vs/platform/userDataSync/common/abstractSynchronizer";
 function isRemoteUserData(thing) {
     if (thing
         && (thing.ref !== undefined && typeof thing.ref === 'string' && thing.ref !== '')
@@ -206,7 +207,14 @@ let AbstractSynchroniser = class AbstractSynchroniser extends Disposable {
     async performSync(remoteUserData, lastSyncUserData, apply, userDataSyncConfiguration) {
         if (remoteUserData.syncData && remoteUserData.syncData.version > this.version) {
             this.telemetryService.publicLog2('sync/incompatible', { source: this.resource });
-            throw new UserDataSyncError(localizeWithPath('vs/platform/userDataSync/common/abstractSynchronizer', { key: 'incompatible', comment: ['This is an error while syncing a resource that its local version is not compatible with its remote version.'] }, "Cannot sync {0} as its local version {1} is not compatible with its remote version {2}", this.resource, this.version, remoteUserData.syncData.version), "IncompatibleLocalContent" , this.resource);
+            throw ( new UserDataSyncError(localizeWithPath(
+                _moduleId,
+                0,
+                "Cannot sync {0} as its local version {1} is not compatible with its remote version {2}",
+                this.resource,
+                this.version,
+                remoteUserData.syncData.version
+            ), "IncompatibleLocalContent" , this.resource));
         }
         try {
             return await this.doSync(remoteUserData, lastSyncUserData, apply, userDataSyncConfiguration);
@@ -488,7 +496,7 @@ let AbstractSynchroniser = class AbstractSynchroniser extends Disposable {
     }
     async updateLastSyncUserData(lastSyncRemoteUserData, additionalProps = {}) {
         if (additionalProps['ref'] || additionalProps['version']) {
-            throw new Error('Cannot have core properties as additional');
+            throw ( new Error('Cannot have core properties as additional'));
         }
         const version = this.userDataSyncEnablementService.getResourceSyncStateVersion(this.resource);
         const lastSyncUserDataState = {
@@ -562,7 +570,11 @@ let AbstractSynchroniser = class AbstractSynchroniser extends Disposable {
         catch (error) {
             this.logService.error(error);
         }
-        throw new UserDataSyncError(localizeWithPath('vs/platform/userDataSync/common/abstractSynchronizer', 'incompatible sync data', "Cannot parse sync data as it is not compatible with the current version."), "IncompatibleRemoteContent" , this.resource);
+        throw ( new UserDataSyncError(localizeWithPath(
+            _moduleId,
+            1,
+            "Cannot parse sync data as it is not compatible with the current version."
+        ), "IncompatibleRemoteContent" , this.resource));
     }
     async getUserData(lastSyncData) {
         const lastSyncUserData = lastSyncData ? { ref: lastSyncData.ref, content: lastSyncData.syncData ? JSON.stringify(lastSyncData.syncData) : null } : null;
@@ -643,7 +655,10 @@ let AbstractFileSynchroniser = class AbstractFileSynchroniser extends AbstractSy
         catch (e) {
             if (((e instanceof FileOperationError && e.fileOperationResult === 1) ) ||
                 ((e instanceof FileOperationError && e.fileOperationResult === 3) )) {
-                throw new UserDataSyncError(e.message, "LocalPreconditionFailed" );
+                throw ( new UserDataSyncError(
+                    e.message,
+                    "LocalPreconditionFailed"
+                ));
             }
             else {
                 throw e;
@@ -752,7 +767,7 @@ let AbstractInitializer = class AbstractInitializer {
     }
     async updateLastSyncUserData(lastSyncRemoteUserData, additionalProps = {}) {
         if (additionalProps['ref'] || additionalProps['version']) {
-            throw new Error('Cannot have core properties as additional');
+            throw ( new Error('Cannot have core properties as additional'));
         }
         const lastSyncUserDataState = {
             ref: lastSyncRemoteUserData.ref,

package/vscode/src/vs/platform/userDataSync/common/userDataSync.js

@@ -5,14 +5,15 @@ import { Extensions, allSettings } from '../../configuration/common/configuratio
 import { EXTENSION_IDENTIFIER_PATTERN } from '../../extensionManagement/common/extensionManagement.js';
 import { Extensions as Extensions$1 } from '../../jsonschemas/common/jsonContributionRegistry.js';
 import { Registry } from '../../registry/common/platform.js';
+const _moduleId = "vs/platform/userDataSync/common/userDataSync";
 function getDisallowedIgnoredSettings() {
-    const allSettings = ( Registry.as(Extensions.Configuration)).getConfigurationProperties();
-    return ( Object.keys(allSettings)).filter(setting => !!allSettings[setting].disallowSyncIgnore);
+    const allSettings = ( (Registry.as(Extensions.Configuration))).getConfigurationProperties();
+    return ( (Object.keys(allSettings))).filter(setting => !!allSettings[setting].disallowSyncIgnore);
 }
 function getDefaultIgnoredSettings() {
-    const allSettings = ( Registry.as(Extensions.Configuration)).getConfigurationProperties();
-    const ignoreSyncSettings = ( Object.keys(allSettings)).filter(setting => !!allSettings[setting].ignoreSync);
-    const machineSettings = ( Object.keys(allSettings)).filter(setting => allSettings[setting].scope === 2  || allSettings[setting].scope === 6 );
+    const allSettings = ( (Registry.as(Extensions.Configuration))).getConfigurationProperties();
+    const ignoreSyncSettings = ( (Object.keys(allSettings))).filter(setting => !!allSettings[setting].ignoreSync);
+    const machineSettings = ( (Object.keys(allSettings))).filter(setting => allSettings[setting].scope === 2  || allSettings[setting].scope === 6 );
     const disallowedSettings = getDisallowedIgnoredSettings();
     return distinct([...ignoreSyncSettings, ...machineSettings, ...disallowedSettings]);
 }
@@ -20,24 +21,16 @@ const USER_DATA_SYNC_CONFIGURATION_SCOPE = 'settingsSync';
 const CONFIG_SYNC_KEYBINDINGS_PER_PLATFORM = 'settingsSync.keybindingsPerPlatform';
 function registerConfiguration() {
     const ignoredSettingsSchemaId = 'vscode://schemas/ignoredSettings';
-    const configurationRegistry = ( Registry.as(Extensions.Configuration));
+    const configurationRegistry = ( (Registry.as(Extensions.Configuration)));
     configurationRegistry.registerConfiguration({
         id: 'settingsSync',
         order: 30,
-        title: ( localizeWithPath(
-            'vs/platform/userDataSync/common/userDataSync',
-            'settings sync',
-            "Settings Sync"
-        )),
+        title: ( localizeWithPath(_moduleId, 0, "Settings Sync")),
         type: 'object',
         properties: {
             [CONFIG_SYNC_KEYBINDINGS_PER_PLATFORM]: {
                 type: 'boolean',
-                description: ( localizeWithPath(
-                    'vs/platform/userDataSync/common/userDataSync',
-                    'settingsSync.keybindingsPerPlatform',
-                    "Synchronize keybindings for each platform."
-                )),
+                description: ( localizeWithPath(_moduleId, 1, "Synchronize keybindings for each platform.")),
                 default: true,
                 scope: 1 ,
                 tags: ['sync', 'usesOnlineServices']
@@ -45,16 +38,16 @@ function registerConfiguration() {
             'settingsSync.ignoredExtensions': {
                 'type': 'array',
                 markdownDescription: ( localizeWithPath(
-                    'vs/platform/userDataSync/common/userDataSync',
-                    'settingsSync.ignoredExtensions',
+                    _moduleId,
+                    2,
                     "List of extensions to be ignored while synchronizing. The identifier of an extension is always `${publisher}.${name}`. For example: `vscode.csharp`."
                 )),
                 items: [{
                         type: 'string',
                         pattern: EXTENSION_IDENTIFIER_PATTERN,
                         errorMessage: ( localizeWithPath(
-                            'vs/platform/userDataSync/common/userDataSync',
-                            'app.extension.identifier.errorMessage',
+                            _moduleId,
+                            3,
                             "Expected format '${publisher}.${name}'. Example: 'vscode.csharp'."
                         ))
                     }],
@@ -66,11 +59,7 @@ function registerConfiguration() {
             },
             'settingsSync.ignoredSettings': {
                 'type': 'array',
-                description: ( localizeWithPath(
-                    'vs/platform/userDataSync/common/userDataSync',
-                    'settingsSync.ignoredSettings',
-                    "Configure settings to be ignored while synchronizing."
-                )),
+                description: ( localizeWithPath(_moduleId, 4, "Configure settings to be ignored while synchronizing.")),
                 'default': [],
                 'scope': 1 ,
                 $ref: ignoredSettingsSchemaId,
@@ -81,16 +70,16 @@ function registerConfiguration() {
             }
         }
     });
-    const jsonRegistry = ( Registry.as(Extensions$1.JSONContribution));
+    const jsonRegistry = ( (Registry.as(Extensions$1.JSONContribution)));
     const registerIgnoredSettingsSchema = () => {
         const disallowedIgnoredSettings = getDisallowedIgnoredSettings();
         const defaultIgnoredSettings = getDefaultIgnoredSettings();
-        const settings = ( Object.keys(allSettings.properties)).filter(setting => !defaultIgnoredSettings.includes(setting));
+        const settings = ( (Object.keys(allSettings.properties))).filter(setting => !defaultIgnoredSettings.includes(setting));
         const ignoredSettings = defaultIgnoredSettings.filter(setting => !disallowedIgnoredSettings.includes(setting));
         const ignoredSettingsSchema = {
             items: {
                 type: 'string',
-                enum: [...settings, ...( ignoredSettings.map(setting => `-${setting}`))]
+                enum: [...settings, ...( (ignoredSettings.map(setting => `-${setting}`)))]
             },
         };
         jsonRegistry.registerSchema(ignoredSettingsSchemaId, ignoredSettingsSchema);
@@ -138,7 +127,7 @@ class UserDataAutoSyncError extends UserDataSyncError {
         super(message, code);
     }
 }
-( (function(UserDataSyncError) {
+( ((function(UserDataSyncError) {
     function toUserDataSyncError(error) {
         if (error instanceof UserDataSyncError) {
             return error;
@@ -147,12 +136,16 @@ class UserDataAutoSyncError extends UserDataSyncError {
         if (match && match[1]) {
             const syncResource = match[2] === 'unknown' ? undefined : match[2];
             const operationId = match[3] === 'unknown' ? undefined : match[3];
-            return ( new UserDataSyncError(error.message, match[1], syncResource, operationId));
+            return (
+                 (new UserDataSyncError(error.message, match[1], syncResource, operationId))
+            );
         }
-        return ( new UserDataSyncError(error.message, "Unknown" ));
+        return (
+             (new UserDataSyncError(error.message, "Unknown" ))
+        );
     }
     UserDataSyncError.toUserDataSyncError = toUserDataSyncError;
-})(UserDataSyncError || (UserDataSyncError = {})));
+})(UserDataSyncError || (UserDataSyncError = {}))));
 const SYNC_SERVICE_URL_TYPE = 'sync.store.url.type';
 function getEnablementKey(resource) { return `sync.enable.${resource}`; }
 const USER_DATA_SYNC_LOG_ID = 'userDataSync';

package/vscode/src/vs/platform/userDataSync/common/userDataSyncMachines.js

@@ -11,6 +11,7 @@ import { getServiceMachineId } from '../../externalServices/common/serviceMachin
 import { IStorageService } from '../../storage/common/storage.service.js';
 import { IUserDataSyncStoreService, IUserDataSyncLogService } from './userDataSync.service.js';
 var UserDataSyncMachinesService_1;
+const _moduleId = "vs/platform/userDataSync/common/userDataSyncMachines";
 const currentMachineNameKey = 'sync.currentMachineName';
 const Safari = 'Safari';
 const Chrome = 'Chrome';
@@ -127,7 +128,12 @@ let UserDataSyncMachinesService = class UserDataSyncMachinesService extends Disp
         this.userData = await this.readUserData(manifest);
         const machinesData = this.parse(this.userData);
         if (machinesData.version !== UserDataSyncMachinesService_1.VERSION) {
-            throw new Error(localizeWithPath('vs/platform/userDataSync/common/userDataSyncMachines', 'error incompatible', "Cannot read machines data as the current version is incompatible. Please update {0} and try again.", this.productService.nameLong));
+            throw ( new Error(localizeWithPath(
+                _moduleId,
+                0,
+                "Cannot read machines data as the current version is incompatible. Please update {0} and try again.",
+                this.productService.nameLong
+            )));
         }
         return machinesData;
     }