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

package/index.d.ts

@@ -0,0 +1 @@
+export { default } from 'vscode/service-override/userDataProfile';

package/index.js

@@ -0,0 +1 @@
+export { default } from './userDataProfile.js';

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@codingame/monaco-vscode-user-data-profile-service-override",
+  "version": "5.3.0",
+  "keywords": [],
+  "author": {
+    "name": "CodinGame",
+    "url": "http://www.codingame.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:CodinGame/monaco-vscode-api.git"
+  },
+  "type": "module",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - user-data-profile service-override",
+  "main": "index.js",
+  "module": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "default": "./index.js"
+    },
+    "./vscode/*": {
+      "default": "./vscode/src/*.js"
+    }
+  },
+  "dependencies": {
+    "vscode": "npm:@codingame/monaco-vscode-api@5.3.0"
+  }
+}

package/userDataProfile.js

@@ -0,0 +1,118 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
+import { IUserDataSyncStoreManagementService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync.service';
+import { BrowserUserDataProfilesService } from './vscode/src/vs/platform/userDataProfile/browser/userDataProfile.js';
+import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
+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 { UserDataProfileImportExportService } from './vscode/src/vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService.js';
+import { UserDataProfileManagementService } from './vscode/src/vs/workbench/services/userDataProfile/browser/userDataProfileManagement.js';
+import { IUserDataProfileStorageService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfileStorageService.service';
+import { UserDataProfileStorageService } from './vscode/src/vs/workbench/services/userDataProfile/browser/userDataProfileStorageService.js';
+import { UserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfileService';
+import { registerServiceInitializePostParticipant } from 'vscode/lifecycle';
+import { getWorkspaceIdentifier } from 'vscode/workbench';
+import './vscode/src/vs/workbench/contrib/userDataProfile/browser/userDataProfile.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 getCurrentProfile(workspace, userDataProfilesService, environmentService) {
+    if (environmentService.options?.profile != null) {
+        const profile = userDataProfilesService.profiles.find(p => p.name === environmentService.options?.profile?.name);
+        if (profile != null) {
+            return profile;
+        }
+        return userDataProfilesService.defaultProfile;
+    }
+    return userDataProfilesService.getProfileForWorkspace(workspace) ?? userDataProfilesService.defaultProfile;
+}
+let InjectedUserDataProfileService = class InjectedUserDataProfileService extends UserDataProfileService {
+    constructor(environmentService, userDataProfilesService, logService) {
+        const workspace = getWorkspaceIdentifier();
+        const profile = getCurrentProfile(workspace, userDataProfilesService, environmentService);
+        super(profile);
+        if (profile === userDataProfilesService.defaultProfile && environmentService.options?.profile != null) {
+            userDataProfilesService.createNamedProfile(environmentService.options.profile.name, undefined, workspace).then(async (profile) => {
+                await this.updateCurrentProfile(profile);
+            }).catch(err => {
+                logService.error(err);
+            });
+        }
+    }
+};
+InjectedUserDataProfileService = __decorate([
+    ( __param(0, IBrowserWorkbenchEnvironmentService)),
+    ( __param(1, IUserDataProfilesService)),
+    ( __param(2, ILogService))
+], InjectedUserDataProfileService);
+function getServiceOverride() {
+    return {
+        [( IUserDataProfileService.toString())]: new SyncDescriptor(InjectedUserDataProfileService, [], true),
+        [( IUserDataProfilesService.toString())]: new SyncDescriptor(BrowserUserDataProfilesService, [], true),
+        [( IUserDataInitializationService.toString())]: new SyncDescriptor(InjectedUserDataInitializationService, [], true),
+        [( IUserDataProfileImportExportService.toString())]: new SyncDescriptor(UserDataProfileImportExportService, [], true),
+        [( IUserDataProfileManagementService.toString())]: new SyncDescriptor(UserDataProfileManagementService, [], true),
+        [( IUserDataProfileStorageService.toString())]: new SyncDescriptor(UserDataProfileStorageService, [], true)
+    };
+}
+
+export { getServiceOverride as default };

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

@@ -0,0 +1,95 @@
+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.js

@@ -0,0 +1,84 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { Disposable, isDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { Storage } from 'vscode/vscode/vs/base/parts/storage/common/storage';
+import { AbstractStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import 'vscode/vscode/vs/base/common/event';
+import 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile';
+
+let AbstractUserDataProfileStorageService = class AbstractUserDataProfileStorageService extends Disposable {
+    constructor(storageService) {
+        super();
+        this.storageService = storageService;
+    }
+    async readStorageData(profile) {
+        return this.withProfileScopedStorageService(profile, async (storageService) => this.getItems(storageService));
+    }
+    async updateStorageData(profile, data, target) {
+        return this.withProfileScopedStorageService(profile, async (storageService) => this.writeItems(storageService, data, target));
+    }
+    async withProfileScopedStorageService(profile, fn) {
+        if (this.storageService.hasScope(profile)) {
+            return fn(this.storageService);
+        }
+        const storageDatabase = await this.createStorageDatabase(profile);
+        const storageService = ( new StorageService(storageDatabase));
+        try {
+            await storageService.initialize();
+            const result = await fn(storageService);
+            await storageService.flush();
+            return result;
+        }
+        finally {
+            storageService.dispose();
+            await this.closeAndDispose(storageDatabase);
+        }
+    }
+    getItems(storageService) {
+        const result = ( new Map());
+        const populate = (target) => {
+            for (const key of ( storageService.keys(0, target))) {
+                result.set(key, { value: storageService.get(key, 0 ), target });
+            }
+        };
+        populate(0 );
+        populate(1 );
+        return result;
+    }
+    writeItems(storageService, items, target) {
+        storageService.storeAll(( Array.from(items.entries()).map(
+            ([key, value]) => ({ key, value, scope: 0 , target })
+        )), true);
+    }
+    async closeAndDispose(storageDatabase) {
+        try {
+            await storageDatabase.close();
+        }
+        finally {
+            if (isDisposable(storageDatabase)) {
+                storageDatabase.dispose();
+            }
+        }
+    }
+};
+AbstractUserDataProfileStorageService = ( __decorate([
+    ( __param(0, IStorageService))
+], AbstractUserDataProfileStorageService));
+class StorageService extends AbstractStorageService {
+    constructor(profileStorageDatabase) {
+        super({ flushInterval: 100 });
+        this.profileStorage = this._register(( new Storage(profileStorageDatabase)));
+    }
+    doInitialize() {
+        return this.profileStorage.init();
+    }
+    getStorage(scope) {
+        return scope === 0  ? this.profileStorage : undefined;
+    }
+    getLogDetails() { return undefined; }
+    async switchToProfile() { }
+    async switchToWorkspace() { }
+    hasScope() { return false; }
+}
+
+export { AbstractUserDataProfileStorageService };

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

@@ -0,0 +1,331 @@
+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 };