@codingame/monaco-vscode-user-data-sync-service-override 5.2.0 → 5.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-user-data-sync-service-override",
-  "version": "5.2.0",
+  "version": "5.3.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -26,6 +26,7 @@
     }
   },
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@5.2.0"
+    "vscode": "npm:@codingame/monaco-vscode-api@5.3.0",
+    "@codingame/monaco-vscode-user-data-profile-service-override": "5.3.0"
   }
 }

package/userDataSync.js

@@ -1,6 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
-import { IUserDataSyncStoreManagementService, IUserDataAutoSyncService, IUserDataSyncStoreService, IUserDataSyncEnablementService, IUserDataSyncService, IUserDataSyncLogService, IUserDataSyncResourceProviderService, IUserDataSyncLocalStoreService, IUserDataSyncUtilService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync.service';
+import { IUserDataAutoSyncService, IUserDataSyncStoreManagementService, IUserDataSyncStoreService, IUserDataSyncEnablementService, IUserDataSyncService, IUserDataSyncLogService, IUserDataSyncResourceProviderService, IUserDataSyncLocalStoreService, IUserDataSyncUtilService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync.service';
 import { UserDataSyncAccountService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncAccount.js';
 import { IUserDataSyncAccountService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSyncAccount.service';
 import { UserDataSyncMachinesService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSyncMachines';
@@ -10,83 +9,17 @@ import { UserDataAutoSyncService } from './vscode/src/vs/platform/userDataSync/c
 import { WebUserDataSyncEnablementService } from './vscode/src/vs/workbench/services/userDataSync/browser/webUserDataSyncEnablementService.js';
 import { UserDataSyncService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncService.js';
 import { UserDataSyncLogService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncLog.js';
-import { BrowserUserDataProfilesService } from './vscode/src/vs/platform/userDataProfile/browser/userDataProfile.js';
-import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
 import { UserDataSyncResourceProviderService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncResourceProvider.js';
 import { UserDataSyncLocalStoreService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncLocalStoreService.js';
 import { UserDataSyncWorkbenchService } from './vscode/src/vs/workbench/services/userDataSync/browser/userDataSyncWorkbenchService.js';
 import { IUserDataSyncWorkbenchService } from 'vscode/vscode/vs/workbench/services/userDataSync/common/userDataSync.service';
-import './vscode/src/vs/workbench/contrib/userDataSync/browser/userDataSync.contribution.js';
-import { UserDataInitializationService } from './vscode/src/vs/workbench/services/userData/browser/userDataInit.js';
-import { IUserDataInitializationService } from 'vscode/vscode/vs/workbench/services/userData/browser/userDataInit.service';
-import { UserDataSyncInitializer } from './vscode/src/vs/workbench/services/userDataSync/browser/userDataSyncInit.js';
-import { UserDataProfileInitializer } from './vscode/src/vs/workbench/services/userDataProfile/browser/userDataProfileInit.js';
-import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService.service';
-import { ISecretStorageService } from 'vscode/vscode/vs/platform/secrets/common/secrets.service';
-import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
-import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService.service';
-import { IRequestService } from 'vscode/vscode/vs/platform/request/common/request.service';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
-import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
-import { IUserDataProfileService, IUserDataProfileImportExportService, IUserDataProfileManagementService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
-import { mark } from 'vscode/vscode/vs/base/common/performance';
-import { timeout } from 'vscode/vscode/vs/base/common/async';
-import { IWorkbenchConfigurationService } from 'vscode/vscode/vs/workbench/services/configuration/common/configuration.service';
 import { UserDataSyncUtilService } from './vscode/src/vs/workbench/services/userDataSync/common/userDataSyncUtil.js';
-import { UserDataProfileImportExportService } from './vscode/src/vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService.js';
-import { UserDataProfileManagementService } from './vscode/src/vs/workbench/services/userDataProfile/browser/userDataProfileManagement.js';
-import { registerServiceInitializePostParticipant } from 'vscode/lifecycle';
+import getServiceOverride$1 from '@codingame/monaco-vscode-user-data-profile-service-override';
+import './vscode/src/vs/workbench/contrib/userDataSync/browser/userDataSync.contribution.js';
 
-function isWorkspaceService(configurationService) {
-    return 'reloadLocalUserConfiguration' in configurationService;
-}
-async function initializeUserData(userDataInitializationService, configurationService) {
-    if (await userDataInitializationService.requiresInitialization()) {
-        mark('code/willInitRequiredUserData');
-        await userDataInitializationService.initializeRequiredResources();
-        if (isWorkspaceService(configurationService)) {
-            await configurationService.reloadLocalUserConfiguration();
-        }
-        mark('code/didInitRequiredUserData');
-    }
-}
-registerServiceInitializePostParticipant(async (accessor) => {
-    try {
-        await Promise.race([
-            timeout(5000),
-            initializeUserData(accessor.get(IUserDataInitializationService), accessor.get(IWorkbenchConfigurationService))
-        ]);
-    }
-    catch (error) {
-        accessor.get(ILogService).error(error);
-    }
-});
-let InjectedUserDataInitializationService = class InjectedUserDataInitializationService extends UserDataInitializationService {
-    constructor(environmentService, secretStorageService, userDataSyncStoreManagementService, fileService, userDataProfilesService, storageService, productService, requestService, logService, uriIdentityService, userDataProfileService) {
-        const userDataInitializers = [];
-        userDataInitializers.push(new UserDataSyncInitializer(environmentService, secretStorageService, userDataSyncStoreManagementService, fileService, userDataProfilesService, storageService, productService, requestService, logService, uriIdentityService));
-        if (environmentService.options?.profile != null) {
-            userDataInitializers.push(new UserDataProfileInitializer(environmentService, fileService, userDataProfileService, storageService, logService, uriIdentityService, requestService));
-        }
-        super(userDataInitializers);
-    }
-};
-InjectedUserDataInitializationService = __decorate([
-    ( __param(0, IBrowserWorkbenchEnvironmentService)),
-    ( __param(1, ISecretStorageService)),
-    ( __param(2, IUserDataSyncStoreManagementService)),
-    ( __param(3, IFileService)),
-    ( __param(4, IUserDataProfilesService)),
-    ( __param(5, IStorageService)),
-    ( __param(6, IProductService)),
-    ( __param(7, IRequestService)),
-    ( __param(8, ILogService)),
-    ( __param(9, IUriIdentityService)),
-    ( __param(10, IUserDataProfileService))
-], InjectedUserDataInitializationService);
 function getServiceOverride() {
     return {
+        ...getServiceOverride$1(),
         [( IUserDataAutoSyncService.toString())]: new SyncDescriptor(UserDataAutoSyncService, [], true),
         [( IUserDataSyncStoreManagementService.toString())]: new SyncDescriptor(UserDataSyncStoreManagementService, [], true),
         [( IUserDataSyncStoreService.toString())]: new SyncDescriptor(UserDataSyncStoreService, [], true),
@@ -95,14 +28,10 @@ function getServiceOverride() {
         [( IUserDataSyncLogService.toString())]: new SyncDescriptor(UserDataSyncLogService, [], true),
         [( IUserDataSyncAccountService.toString())]: new SyncDescriptor(UserDataSyncAccountService, [], true),
         [( IUserDataSyncMachinesService.toString())]: new SyncDescriptor(UserDataSyncMachinesService, [], true),
-        [( IUserDataProfilesService.toString())]: new SyncDescriptor(BrowserUserDataProfilesService, [], true),
         [( IUserDataSyncResourceProviderService.toString())]: new SyncDescriptor(UserDataSyncResourceProviderService, [], true),
         [( IUserDataSyncLocalStoreService.toString())]: new SyncDescriptor(UserDataSyncLocalStoreService, [], true),
         [( IUserDataSyncWorkbenchService.toString())]: new SyncDescriptor(UserDataSyncWorkbenchService, [], true),
-        [( IUserDataInitializationService.toString())]: new SyncDescriptor(InjectedUserDataInitializationService, [], true),
-        [( IUserDataSyncUtilService.toString())]: new SyncDescriptor(UserDataSyncUtilService, [], true),
-        [( IUserDataProfileImportExportService.toString())]: new SyncDescriptor(UserDataProfileImportExportService, [], true),
-        [( IUserDataProfileManagementService.toString())]: new SyncDescriptor(UserDataProfileManagementService, [], true)
+        [( IUserDataSyncUtilService.toString())]: new SyncDescriptor(UserDataSyncUtilService, [], true)
     };
 }
 

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

@@ -10,13 +10,13 @@ import { CONFIG_SYNC_KEYBINDINGS_PER_PLATFORM, USER_DATA_SYNC_SCHEME, UserDataSy
 import { IUserDataSyncStoreService, IUserDataSyncLocalStoreService, IUserDataSyncLogService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync.service';
 import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
 import { isSyncData } from 'vscode/vscode/vs/platform/userDataSync/common/abstractSynchronizer';
-import { parseSnippets } from './snippetsSync.js';
-import { parseSettingsSyncContent } from './settingsSync.js';
-import { getKeybindingsContentFromSyncContent } from './keybindingsSync.js';
+import { parseSnippets } from '@codingame/monaco-vscode-user-data-profile-service-override/vscode/vs/platform/userDataSync/common/snippetsSync';
+import { parseSettingsSyncContent } from '@codingame/monaco-vscode-user-data-profile-service-override/vscode/vs/platform/userDataSync/common/settingsSync';
+import { getKeybindingsContentFromSyncContent } from '@codingame/monaco-vscode-user-data-profile-service-override/vscode/vs/platform/userDataSync/common/keybindingsSync';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
-import { getTasksContentFromSyncContent } from './tasksSync.js';
-import { stringify, parseExtensions, LocalExtensionsProvider } from './extensionsSync.js';
-import { stringify as stringify$1, LocalGlobalStateProvider } from './globalStateSync.js';
+import { getTasksContentFromSyncContent } from '@codingame/monaco-vscode-user-data-profile-service-override/vscode/vs/platform/userDataSync/common/tasksSync';
+import { stringify, parseExtensions, LocalExtensionsProvider } from '@codingame/monaco-vscode-user-data-profile-service-override/vscode/vs/platform/userDataSync/common/extensionsSync';
+import { stringify as stringify$1, LocalGlobalStateProvider } from '@codingame/monaco-vscode-user-data-profile-service-override/vscode/vs/platform/userDataSync/common/globalStateSync';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { parseUserDataProfilesManifest, stringifyLocalProfiles } from './userDataProfilesManifestSync.js';
 import { toFormattedString } from 'vscode/vscode/vs/base/common/jsonFormatter';

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

@@ -15,12 +15,12 @@ import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/c
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
 import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
-import { ExtensionsSynchroniser } from './extensionsSync.js';
-import { GlobalStateSynchroniser } from './globalStateSync.js';
-import { KeybindingsSynchroniser } from './keybindingsSync.js';
-import { SettingsSynchroniser } from './settingsSync.js';
-import { SnippetsSynchroniser } from './snippetsSync.js';
-import { TasksSynchroniser } from './tasksSync.js';
+import { ExtensionsSynchroniser } from '@codingame/monaco-vscode-user-data-profile-service-override/vscode/vs/platform/userDataSync/common/extensionsSync';
+import { GlobalStateSynchroniser } from '@codingame/monaco-vscode-user-data-profile-service-override/vscode/vs/platform/userDataSync/common/globalStateSync';
+import { KeybindingsSynchroniser } from '@codingame/monaco-vscode-user-data-profile-service-override/vscode/vs/platform/userDataSync/common/keybindingsSync';
+import { SettingsSynchroniser } from '@codingame/monaco-vscode-user-data-profile-service-override/vscode/vs/platform/userDataSync/common/settingsSync';
+import { SnippetsSynchroniser } from '@codingame/monaco-vscode-user-data-profile-service-override/vscode/vs/platform/userDataSync/common/snippetsSync';
+import { TasksSynchroniser } from '@codingame/monaco-vscode-user-data-profile-service-override/vscode/vs/platform/userDataSync/common/tasksSync';
 import { UserDataProfilesManifestSynchroniser } from './userDataProfilesManifestSync.js';
 import { createSyncHeaders, UserDataSyncError, ALL_SYNC_RESOURCES, USER_DATA_SYNC_CONFIGURATION_SCOPE, UserDataSyncStoreError } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync';
 import { IUserDataSyncStoreService, IUserDataSyncStoreManagementService, IUserDataSyncLogService, IUserDataSyncEnablementService, IUserDataSyncResourceProviderService, IUserDataSyncLocalStoreService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync.service';

package/vscode/src/vs/workbench/services/userDataSync/browser/userDataSyncWorkbenchService.js

@@ -26,7 +26,7 @@ import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/
 import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
 import { isWeb } from 'vscode/vscode/vs/base/common/platform';
 import { UserDataSyncStoreClient } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSyncStoreService';
-import { UserDataSyncStoreTypeSynchronizer } from '../../../../platform/userDataSync/common/globalStateSync.js';
+import { UserDataSyncStoreTypeSynchronizer } from '@codingame/monaco-vscode-user-data-profile-service-override/vscode/vs/platform/userDataSync/common/globalStateSync';
 import { CancellationError } from 'vscode/vscode/vs/base/common/errors';
 import { raceCancellationError } from 'vscode/vscode/vs/base/common/async';
 import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';

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

@@ -1,95 +0,0 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { BroadcastDataChannel } from 'vscode/vscode/vs/base/browser/broadcast';
-import { revive } from 'vscode/vscode/vs/base/common/marshalling';
-import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment.service';
-import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
-import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
-import { UserDataProfilesService, reviveProfile } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile';
-
-let BrowserUserDataProfilesService = class BrowserUserDataProfilesService extends UserDataProfilesService {
-    constructor(environmentService, fileService, uriIdentityService, logService) {
-        super(environmentService, fileService, uriIdentityService, logService);
-        this.changesBroadcastChannel = this._register(( new BroadcastDataChannel(`${UserDataProfilesService.PROFILES_KEY}.changes`)));
-        this._register(this.changesBroadcastChannel.onDidReceiveData(changes => {
-            try {
-                this._profilesObject = undefined;
-                const added = ( changes.added.map(p => reviveProfile(p, this.profilesHome.scheme)));
-                const removed = ( changes.removed.map(p => reviveProfile(p, this.profilesHome.scheme)));
-                const updated = ( changes.updated.map(p => reviveProfile(p, this.profilesHome.scheme)));
-                this.updateTransientProfiles(added.filter(a => a.isTransient), removed.filter(a => a.isTransient), updated.filter(a => a.isTransient));
-                this._onDidChangeProfiles.fire({
-                    added,
-                    removed,
-                    updated,
-                    all: this.profiles
-                });
-            }
-            catch (error) {  }
-        }));
-    }
-    updateTransientProfiles(added, removed, updated) {
-        if (added.length) {
-            this.transientProfilesObject.profiles.push(...added);
-        }
-        if (removed.length || updated.length) {
-            const allTransientProfiles = this.transientProfilesObject.profiles;
-            this.transientProfilesObject.profiles = [];
-            for (const profile of allTransientProfiles) {
-                if (( removed.some(p => profile.id === p.id))) {
-                    continue;
-                }
-                this.transientProfilesObject.profiles.push(updated.find(p => profile.id === p.id) ?? profile);
-            }
-        }
-    }
-    getStoredProfiles() {
-        try {
-            const value = localStorage.getItem(UserDataProfilesService.PROFILES_KEY);
-            if (value) {
-                return revive(JSON.parse(value));
-            }
-        }
-        catch (error) {
-            this.logService.error(error);
-        }
-        return [];
-    }
-    triggerProfilesChanges(added, removed, updated) {
-        super.triggerProfilesChanges(added, removed, updated);
-        this.changesBroadcastChannel.postData({ added, removed, updated });
-    }
-    saveStoredProfiles(storedProfiles) {
-        localStorage.setItem(UserDataProfilesService.PROFILES_KEY, JSON.stringify(storedProfiles));
-    }
-    getStoredProfileAssociations() {
-        const migrateKey = 'profileAssociationsMigration';
-        try {
-            const value = localStorage.getItem(UserDataProfilesService.PROFILE_ASSOCIATIONS_KEY);
-            if (value) {
-                let associations = JSON.parse(value);
-                if (!localStorage.getItem(migrateKey)) {
-                    associations = this.migrateStoredProfileAssociations(associations);
-                    this.saveStoredProfileAssociations(associations);
-                    localStorage.setItem(migrateKey, 'true');
-                }
-                return associations;
-            }
-        }
-        catch (error) {
-            this.logService.error(error);
-        }
-        return {};
-    }
-    saveStoredProfileAssociations(storedProfileAssociations) {
-        localStorage.setItem(UserDataProfilesService.PROFILE_ASSOCIATIONS_KEY, JSON.stringify(storedProfileAssociations));
-    }
-};
-BrowserUserDataProfilesService = ( __decorate([
-    ( __param(0, IEnvironmentService)),
-    ( __param(1, IFileService)),
-    ( __param(2, IUriIdentityService)),
-    ( __param(3, ILogService))
-], BrowserUserDataProfilesService));
-
-export { BrowserUserDataProfilesService };

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

@@ -1,5 +0,0 @@
-import { createDecorator } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-
-const IUserDataProfileStorageService = ( createDecorator('IUserDataProfileStorageService'));
-
-export { IUserDataProfileStorageService };

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

@@ -1,331 +0,0 @@
-import { deepClone, equals } from 'vscode/vscode/vs/base/common/objects';
-import { semverExports } from 'vscode/external/vscode-semver/semver.js';
-import { assertIsDefined } from 'vscode/vscode/vs/base/common/types';
-
-function merge(localExtensions, remoteExtensions, lastSyncExtensions, skippedExtensions, ignoredExtensions, lastSyncBuiltinExtensions) {
-    const added = [];
-    const removed = [];
-    const updated = [];
-    if (!remoteExtensions) {
-        const remote = localExtensions.filter(({ identifier }) => ignoredExtensions.every(id => id.toLowerCase() !== identifier.id.toLowerCase()));
-        return {
-            local: {
-                added,
-                removed,
-                updated,
-            },
-            remote: remote.length > 0 ? {
-                added: remote,
-                updated: [],
-                removed: [],
-                all: remote
-            } : null
-        };
-    }
-    localExtensions = ( localExtensions.map(massageIncomingExtension));
-    remoteExtensions = ( remoteExtensions.map(massageIncomingExtension));
-    lastSyncExtensions = lastSyncExtensions ? ( lastSyncExtensions.map(massageIncomingExtension)) : null;
-    const uuids = ( new Map());
-    const addUUID = (identifier) => { if (identifier.uuid) {
-        uuids.set(identifier.id.toLowerCase(), identifier.uuid);
-    } };
-    localExtensions.forEach(({ identifier }) => addUUID(identifier));
-    remoteExtensions.forEach(({ identifier }) => addUUID(identifier));
-    lastSyncExtensions?.forEach(({ identifier }) => addUUID(identifier));
-    skippedExtensions?.forEach(({ identifier }) => addUUID(identifier));
-    lastSyncBuiltinExtensions?.forEach(identifier => addUUID(identifier));
-    const getKey = (extension) => {
-        const uuid = extension.identifier.uuid || uuids.get(extension.identifier.id.toLowerCase());
-        return uuid ? `uuid:${uuid}` : `id:${extension.identifier.id.toLowerCase()}`;
-    };
-    const addExtensionToMap = (map, extension) => {
-        map.set(getKey(extension), extension);
-        return map;
-    };
-    const localExtensionsMap = localExtensions.reduce(addExtensionToMap, ( new Map()));
-    const remoteExtensionsMap = remoteExtensions.reduce(addExtensionToMap, ( new Map()));
-    const newRemoteExtensionsMap = remoteExtensions.reduce((map, extension) => addExtensionToMap(map, deepClone(extension)), ( new Map()));
-    const lastSyncExtensionsMap = lastSyncExtensions ? lastSyncExtensions.reduce(addExtensionToMap, ( new Map())) : null;
-    const skippedExtensionsMap = skippedExtensions.reduce(addExtensionToMap, ( new Map()));
-    const ignoredExtensionsSet = ignoredExtensions.reduce((set, id) => {
-        const uuid = uuids.get(id.toLowerCase());
-        return set.add(uuid ? `uuid:${uuid}` : `id:${id.toLowerCase()}`);
-    }, ( new Set()));
-    const lastSyncBuiltinExtensionsSet = lastSyncBuiltinExtensions ? lastSyncBuiltinExtensions.reduce((set, { id, uuid }) => {
-        uuid = uuid ?? uuids.get(id.toLowerCase());
-        return set.add(uuid ? `uuid:${uuid}` : `id:${id.toLowerCase()}`);
-    }, ( new Set())) : null;
-    const localToRemote = compare(localExtensionsMap, remoteExtensionsMap, ignoredExtensionsSet, false);
-    if (localToRemote.added.size > 0 || localToRemote.removed.size > 0 || localToRemote.updated.size > 0) {
-        const baseToLocal = compare(lastSyncExtensionsMap, localExtensionsMap, ignoredExtensionsSet, false);
-        const baseToRemote = compare(lastSyncExtensionsMap, remoteExtensionsMap, ignoredExtensionsSet, true);
-        const merge = (key, localExtension, remoteExtension, preferred) => {
-            let pinned, version, preRelease;
-            if (localExtension.installed) {
-                pinned = preferred.pinned;
-                preRelease = preferred.preRelease;
-                if (pinned) {
-                    version = preferred.version;
-                }
-            }
-            else {
-                pinned = remoteExtension.pinned;
-                preRelease = remoteExtension.preRelease;
-                if (pinned) {
-                    version = remoteExtension.version;
-                }
-            }
-            if (pinned === undefined ) {
-                pinned = localExtension.pinned;
-                if (pinned) {
-                    version = localExtension.version;
-                }
-            }
-            if (preRelease === undefined ) {
-                preRelease = localExtension.preRelease;
-            }
-            return {
-                ...preferred,
-                installed: localExtension.installed || remoteExtension.installed,
-                pinned,
-                preRelease,
-                version: version ?? (remoteExtension.version && (!localExtension.installed || semverExports.gt(remoteExtension.version, localExtension.version)) ? remoteExtension.version : localExtension.version),
-                state: mergeExtensionState(localExtension, remoteExtension, lastSyncExtensionsMap?.get(key)),
-            };
-        };
-        for (const key of ( baseToRemote.removed.values())) {
-            const localExtension = localExtensionsMap.get(key);
-            if (!localExtension) {
-                continue;
-            }
-            const baseExtension = assertIsDefined(lastSyncExtensionsMap?.get(key));
-            const wasAnInstalledExtensionDuringLastSync = lastSyncBuiltinExtensionsSet && !( lastSyncBuiltinExtensionsSet.has(key)) && baseExtension.installed;
-            if (localExtension.installed && wasAnInstalledExtensionDuringLastSync ) {
-                removed.push(localExtension.identifier);
-            }
-            else {
-                newRemoteExtensionsMap.set(key, localExtension);
-            }
-        }
-        for (const key of ( baseToRemote.added.values())) {
-            const remoteExtension = assertIsDefined(remoteExtensionsMap.get(key));
-            const localExtension = localExtensionsMap.get(key);
-            if (localExtension) {
-                if (( localToRemote.updated.has(key))) {
-                    const mergedExtension = merge(key, localExtension, remoteExtension, remoteExtension);
-                    if (!areSame(localExtension, remoteExtension, false, false)) {
-                        updated.push(massageOutgoingExtension(mergedExtension, key));
-                    }
-                    newRemoteExtensionsMap.set(key, mergedExtension);
-                }
-            }
-            else {
-                if (remoteExtension.installed) {
-                    added.push(massageOutgoingExtension(remoteExtension, key));
-                }
-            }
-        }
-        for (const key of ( baseToRemote.updated.values())) {
-            const remoteExtension = assertIsDefined(remoteExtensionsMap.get(key));
-            const baseExtension = assertIsDefined(lastSyncExtensionsMap?.get(key));
-            const localExtension = localExtensionsMap.get(key);
-            if (localExtension) {
-                const wasAnInstalledExtensionDuringLastSync = lastSyncBuiltinExtensionsSet && !( lastSyncBuiltinExtensionsSet.has(key)) && baseExtension.installed;
-                if (wasAnInstalledExtensionDuringLastSync && localExtension.installed && !remoteExtension.installed) {
-                    removed.push(localExtension.identifier);
-                }
-                else {
-                    const mergedExtension = merge(key, localExtension, remoteExtension, remoteExtension);
-                    updated.push(massageOutgoingExtension(mergedExtension, key));
-                    newRemoteExtensionsMap.set(key, mergedExtension);
-                }
-            }
-            else if (remoteExtension.installed) {
-                added.push(massageOutgoingExtension(remoteExtension, key));
-            }
-        }
-        for (const key of ( baseToLocal.added.values())) {
-            if (( baseToRemote.added.has(key))) {
-                continue;
-            }
-            newRemoteExtensionsMap.set(key, assertIsDefined(localExtensionsMap.get(key)));
-        }
-        for (const key of ( baseToLocal.updated.values())) {
-            if (( baseToRemote.removed.has(key))) {
-                continue;
-            }
-            if (( baseToRemote.updated.has(key))) {
-                continue;
-            }
-            const localExtension = assertIsDefined(localExtensionsMap.get(key));
-            const remoteExtension = assertIsDefined(remoteExtensionsMap.get(key));
-            newRemoteExtensionsMap.set(key, merge(key, localExtension, remoteExtension, localExtension));
-        }
-        for (const key of ( baseToLocal.removed.values())) {
-            if (( baseToRemote.updated.has(key))) {
-                continue;
-            }
-            if (( baseToRemote.removed.has(key))) {
-                continue;
-            }
-            if (( skippedExtensionsMap.has(key))) {
-                continue;
-            }
-            if (!assertIsDefined(remoteExtensionsMap.get(key)).installed) {
-                continue;
-            }
-            if (!lastSyncBuiltinExtensionsSet) {
-                continue;
-            }
-            if (( lastSyncBuiltinExtensionsSet.has(key)) || !assertIsDefined(lastSyncExtensionsMap?.get(key)).installed) {
-                continue;
-            }
-            newRemoteExtensionsMap.delete(key);
-        }
-    }
-    const remote = [];
-    const remoteChanges = compare(remoteExtensionsMap, newRemoteExtensionsMap, ( new Set()), true);
-    const hasRemoteChanges = remoteChanges.added.size > 0 || remoteChanges.updated.size > 0 || remoteChanges.removed.size > 0;
-    if (hasRemoteChanges) {
-        newRemoteExtensionsMap.forEach((value, key) => remote.push(massageOutgoingExtension(value, key)));
-    }
-    return {
-        local: { added, removed, updated },
-        remote: hasRemoteChanges ? {
-            added: ( [...remoteChanges.added].map(id => newRemoteExtensionsMap.get(id))),
-            updated: ( [...remoteChanges.updated].map(id => newRemoteExtensionsMap.get(id))),
-            removed: ( [...remoteChanges.removed].map(id => remoteExtensionsMap.get(id))),
-            all: remote
-        } : null
-    };
-}
-function compare(from, to, ignoredExtensions, checkVersionProperty) {
-    const fromKeys = from ? [...( from.keys())].filter(key => !( ignoredExtensions.has(key))) : [];
-    const toKeys = [...( to.keys())].filter(key => !( ignoredExtensions.has(key)));
-    const added = toKeys.filter(key => !fromKeys.includes(key)).reduce((r, key) => { r.add(key); return r; }, ( new Set()));
-    const removed = fromKeys.filter(key => !toKeys.includes(key)).reduce((r, key) => { r.add(key); return r; }, ( new Set()));
-    const updated = ( new Set());
-    for (const key of fromKeys) {
-        if (( removed.has(key))) {
-            continue;
-        }
-        const fromExtension = from.get(key);
-        const toExtension = to.get(key);
-        if (!toExtension || !areSame(fromExtension, toExtension, checkVersionProperty, true)) {
-            updated.add(key);
-        }
-    }
-    return { added, removed, updated };
-}
-function areSame(fromExtension, toExtension, checkVersionProperty, checkInstalledProperty) {
-    if (fromExtension.disabled !== toExtension.disabled) {
-        return false;
-    }
-    if (!!fromExtension.isApplicationScoped !== !!toExtension.isApplicationScoped) {
-        return false;
-    }
-    if (checkInstalledProperty && fromExtension.installed !== toExtension.installed) {
-        return false;
-    }
-    if (fromExtension.installed && toExtension.installed) {
-        if (fromExtension.preRelease !== toExtension.preRelease) {
-            return false;
-        }
-        if (fromExtension.pinned !== toExtension.pinned) {
-            return false;
-        }
-        if (toExtension.pinned && fromExtension.version !== toExtension.version) {
-            return false;
-        }
-    }
-    if (!isSameExtensionState(fromExtension.state, toExtension.state)) {
-        return false;
-    }
-    if ((checkVersionProperty && fromExtension.version !== toExtension.version)) {
-        return false;
-    }
-    return true;
-}
-function mergeExtensionState(localExtension, remoteExtension, lastSyncExtension) {
-    const localState = localExtension.state;
-    const remoteState = remoteExtension.state;
-    const baseState = lastSyncExtension?.state;
-    if (!remoteExtension.version) {
-        return localState;
-    }
-    if (localState && semverExports.gt(localExtension.version, remoteExtension.version)) {
-        return localState;
-    }
-    if (remoteState && semverExports.gt(remoteExtension.version, localExtension.version)) {
-        return remoteState;
-    }
-    if (!localState) {
-        return remoteState;
-    }
-    if (!remoteState) {
-        return localState;
-    }
-    const mergedState = deepClone(localState);
-    const baseToRemote = baseState ? compareExtensionState(baseState, remoteState) : { added: ( Object.keys(remoteState)).reduce((r, k) => { r.add(k); return r; }, ( new Set())), removed: ( new Set()), updated: ( new Set()) };
-    const baseToLocal = baseState ? compareExtensionState(baseState, localState) : { added: ( Object.keys(localState)).reduce((r, k) => { r.add(k); return r; }, ( new Set())), removed: ( new Set()), updated: ( new Set()) };
-    for (const key of [...( baseToRemote.added.values()), ...( baseToRemote.updated.values())]) {
-        mergedState[key] = remoteState[key];
-    }
-    for (const key of ( baseToRemote.removed.values())) {
-        if (!( baseToLocal.updated.has(key))) {
-            delete mergedState[key];
-        }
-    }
-    return mergedState;
-}
-function compareExtensionState(from, to) {
-    const fromKeys = ( Object.keys(from));
-    const toKeys = ( Object.keys(to));
-    const added = toKeys.filter(key => !fromKeys.includes(key)).reduce((r, key) => { r.add(key); return r; }, ( new Set()));
-    const removed = fromKeys.filter(key => !toKeys.includes(key)).reduce((r, key) => { r.add(key); return r; }, ( new Set()));
-    const updated = ( new Set());
-    for (const key of fromKeys) {
-        if (( removed.has(key))) {
-            continue;
-        }
-        const value1 = from[key];
-        const value2 = to[key];
-        if (!equals(value1, value2)) {
-            updated.add(key);
-        }
-    }
-    return { added, removed, updated };
-}
-function isSameExtensionState(a = {}, b = {}) {
-    const { added, removed, updated } = compareExtensionState(a, b);
-    return added.size === 0 && removed.size === 0 && updated.size === 0;
-}
-function massageIncomingExtension(extension) {
-    return { ...extension, ...{ disabled: !!extension.disabled, installed: !!extension.installed } };
-}
-function massageOutgoingExtension(extension, key) {
-    const massagedExtension = {
-        ...extension,
-        identifier: {
-            id: extension.identifier.id,
-            uuid: key.startsWith('uuid:') ? key.substring('uuid:'.length) : undefined
-        },
-        preRelease: !!extension.preRelease,
-        pinned: !!extension.pinned,
-    };
-    if (!extension.disabled) {
-        delete massagedExtension.disabled;
-    }
-    if (!extension.installed) {
-        delete massagedExtension.installed;
-    }
-    if (!extension.state) {
-        delete massagedExtension.state;
-    }
-    if (!extension.isApplicationScoped) {
-        delete massagedExtension.isApplicationScoped;
-    }
-    return massagedExtension;
-}
-
-export { merge };