@codingame/monaco-vscode-api 1.69.24 → 1.76.0-next.2

package/dist/services.js

@@ -1,5 +1,5 @@
 export { I as IEditorGroupsService, b as IEditorService, c as IFileService, d as IHostService, e as ILanguageStatusService, f as IPaneCompositePartService, g as IPathService, h as IProductService, i as ISnippetsService, j as ITextFileService, k as IUriIdentityService, l as IWorkbenchEnvironmentService, m as IWorkingCopyFileService, S as Services, n as StorageScope, o as StorageTarget } from './services2.js';
-export { C as ContextKeyExprType, N as NotificationsFilter } from './workspace.js';
+export { C as ContextKeyExprType, N as NotificationsFilter } from './contextkey.js';
 export { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 export { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
 export { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';

package/dist/services2.js

@@ -1,17 +1,19 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
-import { _ as __decorate, E as Emitter, i as isWorkspaceIdentifier, a as __param } from './workspace.js';
-import { ResourceMap, TernarySearchTree } from 'monaco-editor/esm/vs/base/common/map.js';
+import { _ as __decorate, E as Emitter, a as __param } from './contextkey.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { TernarySearchTree } from 'monaco-editor/esm/vs/base/common/ternarySearchTree.js';
 import { Disposable, MutableDisposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { isSingleFolderWorkspaceIdentifier } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { joinPath, basename } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { isString, isUndefinedOrNull } from 'monaco-editor/esm/vs/base/common/types.js';
+import { escapeRegExpCharacters } from 'monaco-editor/esm/vs/base/common/strings.js';
 import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
 import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
 import { Promises, RunOnceScheduler, runWhenIdle } from 'monaco-editor/esm/vs/base/common/async.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { isSingleFolderWorkspaceIdentifier, isWorkspaceIdentifier } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { isUndefinedOrNull, isUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
 import { PauseableEmitter } from 'monaco-editor/esm/vs/base/common/event.js';
 function refineServiceDecorator(serviceIdentifier) {
     return serviceIdentifier;
@@ -63,15 +65,18 @@ var FileSystemProviderErrorCode;
     FileSystemProviderErrorCode["Unknown"] = "Unknown";
 })(FileSystemProviderErrorCode || (FileSystemProviderErrorCode = {}))));
 class FileSystemProviderError extends Error {
+    static create(error, code) {
+        const providerError = ( (new FileSystemProviderError( (error.toString()), code)));
+        markAsFileSystemProviderError(providerError, code);
+        return providerError;
+    }
     constructor(message, code) {
         super(message);
         this.code = code;
     }
 }
 function createFileSystemProviderError(error, code) {
-    const providerError = ( (new FileSystemProviderError( (error.toString()), code)));
-    markAsFileSystemProviderError(providerError, code);
-    return providerError;
+    return FileSystemProviderError.create(error, code);
 }
 function ensureFileSystemProviderError(error) {
     if (!error) {
@@ -147,11 +152,9 @@ class FileChangesEvent {
         this.added = undefined;
         this.updated = undefined;
         this.deleted = undefined;
-        this.rawChanges = [];
         this.rawAdded = [];
         this.rawUpdated = [];
         this.rawDeleted = [];
-        this.rawChanges = changes;
         const entriesByType = ( (new Map()));
         for (const change of changes) {
             const array = entriesByType.get(change.type);
@@ -244,6 +247,13 @@ class FileOperationError extends Error {
         this.options = options;
     }
 }
+class TooLargeFileOperationError extends FileOperationError {
+    constructor(message, fileOperationResult, size, options) {
+        super(message, fileOperationResult, options);
+        this.fileOperationResult = fileOperationResult;
+        this.size = size;
+    }
+}
 class NotModifiedSinceFileOperationError extends FileOperationError {
     constructor(message, stat, options) {
         super(message, 2 , options);
@@ -271,147 +281,190 @@ function isUserDataProfile(thing) {
         && URI.isUri(candidate.keybindingsResource)
         && URI.isUri(candidate.tasksResource)
         && URI.isUri(candidate.snippetsHome)
-        && (isUndefined(candidate.extensionsResource) || URI.isUri(candidate.extensionsResource)));
+        && URI.isUri(candidate.extensionsResource));
 }
-const PROFILES_ENABLEMENT_CONFIG = 'workbench.experimental.settingsProfiles.enabled';
 const IUserDataProfilesService = ( (createDecorator('IUserDataProfilesService')));
-const EXTENSIONS_RESOURCE_NAME = 'extensions.json';
-function toUserDataProfile(name, location, useDefaultFlags) {
+function toUserDataProfile(id, name, location, options) {
     return {
-        id: ( (hash(location.path).toString(16))),
-        name: name,
-        location: location,
+        id,
+        name,
+        location,
         isDefault: false,
+        shortName: options?.shortName,
         globalStorageHome: joinPath(location, 'globalStorage'),
         settingsResource: joinPath(location, 'settings.json'),
         keybindingsResource: joinPath(location, 'keybindings.json'),
         tasksResource: joinPath(location, 'tasks.json'),
         snippetsHome: joinPath(location, 'snippets'),
-        extensionsResource: joinPath(location, EXTENSIONS_RESOURCE_NAME),
-        useDefaultFlags
+        extensionsResource: joinPath(location, 'extensions.json'),
+        useDefaultFlags: options?.useDefaultFlags,
+        isTransient: options?.transient
     };
 }
 let UserDataProfilesService = class UserDataProfilesService extends Disposable {
+    get defaultProfile() { return this.profiles[0]; }
+    get profiles() { return [...this.profilesObject.profiles, ...this.transientProfilesObject.profiles]; }
     constructor(environmentService, fileService, uriIdentityService, logService) {
         super();
         this.environmentService = environmentService;
         this.fileService = fileService;
         this.uriIdentityService = uriIdentityService;
         this.logService = logService;
-        this.enabled = false;
-        this.defaultProfileShouldIncludeExtensionsResourceAlways = false;
+        this.enabled = true;
         this._onDidChangeProfiles = this._register(( (new Emitter())));
         this.onDidChangeProfiles = this._onDidChangeProfiles.event;
         this._onWillCreateProfile = this._register(( (new Emitter())));
         this.onWillCreateProfile = this._onWillCreateProfile.event;
         this._onWillRemoveProfile = this._register(( (new Emitter())));
         this.onWillRemoveProfile = this._onWillRemoveProfile.event;
+        this._onDidResetWorkspaces = this._register(( (new Emitter())));
+        this.onDidResetWorkspaces = this._onDidResetWorkspaces.event;
+        this.profileCreationPromises = ( (new Map()));
+        this.transientProfilesObject = {
+            profiles: [],
+            workspaces: ( (new ResourceMap())),
+            emptyWindows: ( (new Map()))
+        };
         this.profilesHome = joinPath(this.environmentService.userRoamingDataHome, 'profiles');
     }
-    get defaultProfile() { return this.profiles[0]; }
-    get profiles() { return this.profilesObject.profiles; }
+    init() {
+        this._profilesObject = undefined;
+    }
     setEnablement(enabled) {
         if (this.enabled !== enabled) {
             this._profilesObject = undefined;
             this.enabled = enabled;
         }
     }
+    isEnabled() {
+        return this.enabled;
+    }
     get profilesObject() {
         if (!this._profilesObject) {
-            const profiles = this.enabled ? this.getStoredProfiles().map(storedProfile => toUserDataProfile(storedProfile.name, storedProfile.location, storedProfile.useDefaultFlags)) : [];
-            let emptyWindow;
+            const profiles = [];
+            if (this.enabled) {
+                try {
+                    for (const storedProfile of this.getStoredProfiles()) {
+                        if (!storedProfile.name || !isString(storedProfile.name) || !storedProfile.location) {
+                            this.logService.warn('Skipping the invalid stored profile', storedProfile.location || storedProfile.name);
+                            continue;
+                        }
+                        profiles.push(toUserDataProfile(basename(storedProfile.location), storedProfile.name, storedProfile.location, { shortName: storedProfile.shortName, useDefaultFlags: storedProfile.useDefaultFlags }));
+                    }
+                }
+                catch (error) {
+                    this.logService.error(error);
+                }
+            }
             const workspaces = ( (new ResourceMap()));
+            const emptyWindows = ( (new Map()));
+            const defaultProfile = this.createDefaultProfile();
+            profiles.unshift({ ...defaultProfile, extensionsResource: this.getDefaultProfileExtensionsLocation() ?? defaultProfile.extensionsResource, isDefault: true });
             if (profiles.length) {
-                const profileAssicaitions = this.getStoredProfileAssociations();
-                if (profileAssicaitions.workspaces) {
-                    for (const [workspacePath, profilePath] of Object.entries(profileAssicaitions.workspaces)) {
-                        const workspace = ( (URI.parse(workspacePath)));
-                        const profileLocation = ( (URI.parse(profilePath)));
-                        const profile = profiles.find(p => this.uriIdentityService.extUri.isEqual(p.location, profileLocation));
-                        if (profile) {
-                            workspaces.set(workspace, profile);
+                try {
+                    const profileAssociaitions = this.getStoredProfileAssociations();
+                    if (profileAssociaitions.workspaces) {
+                        for (const [workspacePath, profileId] of Object.entries(profileAssociaitions.workspaces)) {
+                            const workspace = ( (URI.parse(workspacePath)));
+                            const profile = profiles.find(p => p.id === profileId);
+                            if (profile) {
+                                workspaces.set(workspace, profile);
+                            }
+                        }
+                    }
+                    if (profileAssociaitions.emptyWindows) {
+                        for (const [windowId, profileId] of Object.entries(profileAssociaitions.emptyWindows)) {
+                            const profile = profiles.find(p => p.id === profileId);
+                            if (profile) {
+                                emptyWindows.set(windowId, profile);
+                            }
                         }
                     }
                 }
-                if (profileAssicaitions.emptyWindow) {
-                    const emptyWindowProfileLocation = ( (URI.parse(profileAssicaitions.emptyWindow)));
-                    emptyWindow = profiles.find(p => this.uriIdentityService.extUri.isEqual(p.location, emptyWindowProfileLocation));
+                catch (error) {
+                    this.logService.error(error);
                 }
             }
-            const profile = toUserDataProfile(( (localize('defaultProfile', "Default"))), this.environmentService.userRoamingDataHome);
-            profiles.unshift({ ...profile, isDefault: true, extensionsResource: this.defaultProfileShouldIncludeExtensionsResourceAlways || profiles.length > 0 ? profile.extensionsResource : undefined });
-            this._profilesObject = { profiles, workspaces, emptyWindow };
+            this._profilesObject = { profiles, workspaces, emptyWindows };
         }
         return this._profilesObject;
     }
-    getProfile(workspaceIdentifier) {
-        const workspace = this.getWorkspace(workspaceIdentifier);
-        const profile = URI.isUri(workspace) ? this.profilesObject.workspaces.get(workspace) : this.profilesObject.emptyWindow;
-        return profile ?? this.defaultProfile;
-    }
-    getWorkspace(workspaceIdentifier) {
-        if (isSingleFolderWorkspaceIdentifier(workspaceIdentifier)) {
-            return workspaceIdentifier.uri;
-        }
-        if (isWorkspaceIdentifier(workspaceIdentifier)) {
-            return workspaceIdentifier.configPath;
+    createDefaultProfile() {
+        return toUserDataProfile('__default__profile__', ( (localize('defaultProfile', "Default"))), this.environmentService.userRoamingDataHome);
+    }
+    async createTransientProfile(workspaceIdentifier) {
+        const namePrefix = `Temp`;
+        const nameRegEx = ( (new RegExp(`${escapeRegExpCharacters(namePrefix)}\\s(\\d+)`)));
+        let nameIndex = 0;
+        for (const profile of this.profiles) {
+            const matches = nameRegEx.exec(profile.name);
+            const index = matches ? parseInt(matches[1]) : 0;
+            nameIndex = index > nameIndex ? index : nameIndex;
         }
-        return 'empty-window';
+        const name = `${namePrefix} ${nameIndex + 1}`;
+        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);
     }
-    async createProfile(name, useDefaultFlags, workspaceIdentifier) {
+    async createProfile(id, name, options, workspaceIdentifier) {
         if (!this.enabled) {
-            throw new Error(`Settings Profiles are disabled. Enable them via the '${PROFILES_ENABLEMENT_CONFIG}' setting.`);
+            throw new Error(`Profiles are disabled in the current environment.`);
         }
-        if (this.getStoredProfiles().some(p => p.name === name)) {
-            throw new Error(`Profile with name ${name} already exists`);
-        }
-        const profile = toUserDataProfile(name, joinPath(this.profilesHome, ( (hash(generateUuid()).toString(16)))), useDefaultFlags);
-        await this.fileService.createFolder(profile.location);
-        const joiners = [];
-        this._onWillCreateProfile.fire({
-            profile,
-            join(promise) {
-                joiners.push(promise);
-            }
-        });
-        await Promises.settled(joiners);
-        this.updateProfiles([profile], [], []);
+        const profile = await this.doCreateProfile(id, name, options);
         if (workspaceIdentifier) {
-            await this.setProfileForWorkspace(profile, workspaceIdentifier);
+            await this.setProfileForWorkspace(workspaceIdentifier, profile);
         }
         return profile;
     }
-    async updateProfile(profileToUpdate, name, useDefaultFlags) {
+    async doCreateProfile(id, name, options) {
+        if (!isString(name) || !name) {
+            throw new Error('Name of the profile is mandatory and must be of type `string`');
+        }
+        let profileCreationPromise = this.profileCreationPromises.get(name);
+        if (!profileCreationPromise) {
+            profileCreationPromise = (async () => {
+                try {
+                    const existing = this.profiles.find(p => p.name === name || p.id === id);
+                    if (existing) {
+                        return existing;
+                    }
+                    const profile = toUserDataProfile(id, name, joinPath(this.profilesHome, id), options);
+                    await this.fileService.createFolder(profile.location);
+                    const joiners = [];
+                    this._onWillCreateProfile.fire({
+                        profile,
+                        join(promise) {
+                            joiners.push(promise);
+                        }
+                    });
+                    await Promises.settled(joiners);
+                    this.updateProfiles([profile], [], []);
+                    return profile;
+                }
+                finally {
+                    this.profileCreationPromises.delete(name);
+                }
+            })();
+            this.profileCreationPromises.set(name, profileCreationPromise);
+        }
+        return profileCreationPromise;
+    }
+    async updateProfile(profileToUpdate, options) {
         if (!this.enabled) {
-            throw new Error(`Settings Profiles are disabled. Enable them via the '${PROFILES_ENABLEMENT_CONFIG}' setting.`);
+            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`);
         }
-        profile = toUserDataProfile(name, profile.location, useDefaultFlags);
+        profile = toUserDataProfile(profile.id, options.name ?? profile.name, profile.location, { shortName: options.shortName ?? profile.shortName, transient: options.transient ?? profile.isTransient, useDefaultFlags: options.useDefaultFlags ?? profile.useDefaultFlags });
         this.updateProfiles([], [], [profile]);
         return profile;
     }
-    async setProfileForWorkspace(profileToSet, workspaceIdentifier) {
-        if (!this.enabled) {
-            throw new Error(`Settings Profiles are disabled. Enable them via the '${PROFILES_ENABLEMENT_CONFIG}' setting.`);
-        }
-        const profile = this.profiles.find(p => p.id === profileToSet.id);
-        if (!profile) {
-            throw new Error(`Profile '${profileToSet.name}' does not exist`);
-        }
-        this.updateWorkspaceAssociation(workspaceIdentifier, profile);
-    }
-    async unsetWorkspace(workspaceIdentifier) {
-        if (!this.enabled) {
-            throw new Error(`Settings Profiles are disabled. Enable them via the '${PROFILES_ENABLEMENT_CONFIG}' setting.`);
-        }
-        this.updateWorkspaceAssociation(workspaceIdentifier);
-    }
     async removeProfile(profileToRemove) {
         if (!this.enabled) {
-            throw new Error(`Settings Profiles are disabled. Enable them via the '${PROFILES_ENABLEMENT_CONFIG}' setting.`);
+            throw new Error(`Profiles are disabled in the current environment.`);
         }
         if (profileToRemove.isDefault) {
             throw new Error('Cannot remove default profile');
@@ -427,9 +480,16 @@ let UserDataProfilesService = class UserDataProfilesService extends Disposable {
                 joiners.push(promise);
             }
         });
-        await Promises.settled(joiners);
-        if (profile.id === this.profilesObject.emptyWindow?.id) {
-            this.profilesObject.emptyWindow = undefined;
+        try {
+            await Promise.allSettled(joiners);
+        }
+        catch (error) {
+            this.logService.error(error);
+        }
+        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()))]) {
             if (profile.id === this.profilesObject.workspaces.get(workspace)?.id) {
@@ -450,9 +510,81 @@ let UserDataProfilesService = class UserDataProfilesService extends Disposable {
             this.logService.error(error);
         }
     }
+    async setProfileForWorkspace(workspaceIdentifier, profileToSet) {
+        if (!this.enabled) {
+            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`);
+        }
+        this.updateWorkspaceAssociation(workspaceIdentifier, profile);
+    }
+    unsetWorkspace(workspaceIdentifier, transient) {
+        if (!this.enabled) {
+            throw new Error(`Profiles are disabled in the current environment.`);
+        }
+        this.updateWorkspaceAssociation(workspaceIdentifier, undefined, transient);
+    }
+    async resetWorkspaces() {
+        this.transientProfilesObject.workspaces.clear();
+        this.transientProfilesObject.emptyWindows.clear();
+        this.profilesObject.workspaces.clear();
+        this.profilesObject.emptyWindows.clear();
+        this.updateStoredProfileAssociations();
+        this._onDidResetWorkspaces.fire();
+    }
+    async cleanUp() {
+        if (!this.enabled) {
+            return;
+        }
+        if (await this.fileService.exists(this.profilesHome)) {
+            const stat = await this.fileService.resolve(this.profilesHome);
+            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 })));
+        }
+    }
+    async cleanUpTransientProfiles() {
+        if (!this.enabled) {
+            return;
+        }
+        const unAssociatedTransientProfiles = this.transientProfilesObject.profiles.filter(p => !this.isProfileAssociatedToWorkspace(p));
+        await Promise.allSettled(unAssociatedTransientProfiles.map(p => this.removeProfile(p)));
+    }
+    getProfileForWorkspace(workspaceIdentifier) {
+        const workspace = this.getWorkspace(workspaceIdentifier);
+        return URI.isUri(workspace) ? this.transientProfilesObject.workspaces.get(workspace) ?? this.profilesObject.workspaces.get(workspace) : this.transientProfilesObject.emptyWindows.get(workspace) ?? this.profilesObject.emptyWindows.get(workspace);
+    }
+    getWorkspace(workspaceIdentifier) {
+        if (isSingleFolderWorkspaceIdentifier(workspaceIdentifier)) {
+            return workspaceIdentifier.uri;
+        }
+        if (isWorkspaceIdentifier(workspaceIdentifier)) {
+            return workspaceIdentifier.configPath;
+        }
+        return workspaceIdentifier.id;
+    }
+    isProfileAssociatedToWorkspace(profile) {
+        if ([...( (this.transientProfilesObject.emptyWindows.values()))].some(windowProfile => this.uriIdentityService.extUri.isEqual(windowProfile.location, profile.location))) {
+            return true;
+        }
+        if ([...( (this.transientProfilesObject.workspaces.values()))].some(workspaceProfile => this.uriIdentityService.extUri.isEqual(workspaceProfile.location, profile.location))) {
+            return true;
+        }
+        if ([...( (this.profilesObject.emptyWindows.values()))].some(windowProfile => this.uriIdentityService.extUri.isEqual(windowProfile.location, profile.location))) {
+            return true;
+        }
+        if ([...( (this.profilesObject.workspaces.values()))].some(workspaceProfile => this.uriIdentityService.extUri.isEqual(workspaceProfile.location, profile.location))) {
+            return true;
+        }
+        return false;
+    }
     updateProfiles(added, removed, updated) {
+        const allProfiles = [...this.profiles, ...added];
         const storedProfiles = [];
-        for (let profile of [...this.profilesObject.profiles, ...added]) {
+        this.transientProfilesObject.profiles = [];
+        for (let profile of allProfiles) {
             if (profile.isDefault) {
                 continue;
             }
@@ -460,7 +592,12 @@ let UserDataProfilesService = class UserDataProfilesService extends Disposable {
                 continue;
             }
             profile = updated.find(p => profile.id === p.id) ?? profile;
-            storedProfiles.push({ location: profile.location, name: profile.name, useDefaultFlags: profile.useDefaultFlags });
+            if (profile.isTransient) {
+                this.transientProfilesObject.profiles.push(profile);
+            }
+            else {
+                storedProfiles.push({ location: profile.location, name: profile.name, shortName: profile.shortName, useDefaultFlags: profile.useDefaultFlags });
+            }
         }
         this.saveStoredProfiles(storedProfiles);
         this._profilesObject = undefined;
@@ -469,32 +606,64 @@ let UserDataProfilesService = class UserDataProfilesService extends Disposable {
     triggerProfilesChanges(added, removed, updated) {
         this._onDidChangeProfiles.fire({ added, removed, updated, all: this.profiles });
     }
-    updateWorkspaceAssociation(workspaceIdentifier, newProfile) {
+    updateWorkspaceAssociation(workspaceIdentifier, newProfile, transient) {
+        transient = newProfile?.isTransient ? true : transient;
+        if (!transient) {
+            this.updateWorkspaceAssociation(workspaceIdentifier, undefined, true);
+        }
         const workspace = this.getWorkspace(workspaceIdentifier);
+        const profilesObject = transient ? this.transientProfilesObject : this.profilesObject;
         if (URI.isUri(workspace)) {
-            this.profilesObject.workspaces.delete(workspace);
-            if (newProfile && !newProfile.isDefault) {
-                this.profilesObject.workspaces.set(workspace, newProfile);
+            profilesObject.workspaces.delete(workspace);
+            if (newProfile) {
+                profilesObject.workspaces.set(workspace, newProfile);
             }
         }
         else {
-            this.profilesObject.emptyWindow = !newProfile?.isDefault ? newProfile : undefined;
+            profilesObject.emptyWindows.delete(workspace);
+            if (newProfile) {
+                profilesObject.emptyWindows.set(workspace, newProfile);
+            }
+        }
+        if (!transient) {
+            this.updateStoredProfileAssociations();
         }
-        this.updateStoredProfileAssociations();
     }
     updateStoredProfileAssociations() {
         const workspaces = {};
         for (const [workspace, profile] of this.profilesObject.workspaces.entries()) {
-            workspaces[( (workspace.toString()))] = ( (profile.location.toString()));
+            workspaces[( (workspace.toString()))] = profile.id;
+        }
+        const emptyWindows = {};
+        for (const [windowId, profile] of this.profilesObject.emptyWindows.entries()) {
+            emptyWindows[( (windowId.toString()))] = profile.id;
         }
-        const emptyWindow = this.profilesObject.emptyWindow?.location.toString();
-        this.saveStoredProfileAssociations({ workspaces, emptyWindow });
+        this.saveStoredProfileAssociations({ workspaces, emptyWindows });
         this._profilesObject = undefined;
     }
+    migrateStoredProfileAssociations(storedProfileAssociations) {
+        const workspaces = {};
+        const defaultProfile = this.createDefaultProfile();
+        if (storedProfileAssociations.workspaces) {
+            for (const [workspace, location] of Object.entries(storedProfileAssociations.workspaces)) {
+                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)));
+                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'); }
     getStoredProfileAssociations() { return {}; }
     saveStoredProfileAssociations(storedProfileAssociations) { throw new Error('not implemented'); }
+    getDefaultProfileExtensionsLocation() { return undefined; }
 };
 UserDataProfilesService.PROFILES_KEY = 'userDataProfiles';
 UserDataProfilesService.PROFILE_ASSOCIATIONS_KEY = 'profileAssociations';
@@ -522,6 +691,17 @@ var StorageTarget;
     StorageTarget[StorageTarget["USER"] = 0] = "USER";
     StorageTarget[StorageTarget["MACHINE"] = 1] = "MACHINE";
 })(StorageTarget || (StorageTarget = {}))));
+function loadKeyTargets(storage) {
+    const keysRaw = storage.get(TARGET_KEY);
+    if (keysRaw) {
+        try {
+            return JSON.parse(keysRaw);
+        }
+        catch (error) {
+        }
+    }
+    return Object.create(null);
+}
 class AbstractStorageService extends Disposable {
     constructor(options = { flushInterval: AbstractStorageService.DEFAULT_FLUSH_INTERVAL }) {
         super();
@@ -678,15 +858,8 @@ class AbstractStorageService extends Disposable {
         }
     }
     loadKeyTargets(scope) {
-        const keysRaw = this.get(TARGET_KEY, scope);
-        if (keysRaw) {
-            try {
-                return JSON.parse(keysRaw);
-            }
-            catch (error) {
-            }
-        }
-        return Object.create(null);
+        const storage = this.getStorage(scope);
+        return storage ? loadKeyTargets(storage) : Object.create(null);
     }
     isNew(scope) {
         return this.getBoolean(IS_NEW_KEY, scope) === true;
@@ -828,6 +1001,13 @@ function isEditorGroup(obj) {
     const group = obj;
     return !!group && typeof group.id === 'number' && Array.isArray(group.editors);
 }
+function preferredSideBySideGroupDirection(configurationService) {
+    const openSideBySideDirection = configurationService.getValue('workbench.editor.openSideBySideDirection');
+    if (openSideBySideDirection === 'down') {
+        return 1 ;
+    }
+    return 3 ;
+}
 const IEditorService = ( (createDecorator('editorService')));
 const ACTIVE_GROUP = -1;
 const SIDE_GROUP = -2;
@@ -866,4 +1046,4 @@ var Services;
     }
     Services.install = install;
 })(Services || (Services = {})));
-export { ACTIVE_GROUP as A, toFileSystemProviderErrorCode as B, ensureFileSystemProviderError as C, etag as D, FileOperationEvent as E, FileType as F, toFileOperationResult as G, ETAG_DISABLED as H, IEditorGroupsService as I, hasFileAtomicReadCapability as J, hasFileFolderCopyCapability as K, hasFileCloneCapability as L, createFileSystemProviderError as M, NotModifiedSinceFileOperationError as N, FILES_ASSOCIATIONS_CONFIG as O, markAsFileSystemProviderError as P, productSchemaId as Q, Services as S, FilePermission as a, IEditorService as b, IFileService as c, IHostService as d, ILanguageStatusService as e, IPaneCompositePartService as f, IPathService as g, IProductService as h, ISnippetsService as i, ITextFileService as j, IUriIdentityService as k, IWorkbenchEnvironmentService as l, IWorkingCopyFileService as m, StorageScope as n, StorageTarget as o, SIDE_GROUP as p, isPreferredGroup as q, IUserDataProfilesService as r, refineServiceDecorator as s, FileSystemProviderError as t, FileSystemProviderErrorCode as u, FileChangesEvent as v, FileOperationError as w, hasOpenReadWriteCloseCapability as x, hasReadWriteCapability as y, hasFileReadStreamCapability as z };
+export { ACTIVE_GROUP as A, FileSystemProviderErrorCode as B, ensureFileSystemProviderError as C, etag as D, FileOperationEvent as E, FileType as F, toFileOperationResult as G, ETAG_DISABLED as H, IEditorGroupsService as I, hasFileAtomicReadCapability as J, hasFileFolderCopyCapability as K, hasFileCloneCapability as L, FileSystemProviderError as M, NotModifiedSinceFileOperationError as N, FILES_ASSOCIATIONS_CONFIG as O, markAsFileSystemProviderError as P, preferredSideBySideGroupDirection as Q, productSchemaId as R, Services as S, TooLargeFileOperationError as T, FilePermission as a, IEditorService as b, IFileService as c, IHostService as d, ILanguageStatusService as e, IPaneCompositePartService as f, IPathService as g, IProductService as h, ISnippetsService as i, ITextFileService as j, IUriIdentityService as k, IWorkbenchEnvironmentService as l, IWorkingCopyFileService as m, StorageScope as n, StorageTarget as o, SIDE_GROUP as p, isPreferredGroup as q, IUserDataProfilesService as r, refineServiceDecorator as s, createFileSystemProviderError as t, FileChangesEvent as u, FileOperationError as v, hasOpenReadWriteCloseCapability as w, hasReadWriteCapability as x, hasFileReadStreamCapability as y, toFileSystemProviderErrorCode as z };