@codingame/monaco-vscode-api 1.78.5-next.0 → 1.78.6-next.0

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

@@ -1,427 +0,0 @@
-import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
-import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { joinPath, basename } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
-import { toFileOperationResult, IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { isSingleFolderWorkspaceIdentifier, isWorkspaceIdentifier } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
-import { IUriIdentityService } from '../../uriIdentity/common/uriIdentity.js';
-import { Promises } from 'monaco-editor/esm/vs/base/common/async.js';
-import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
-import { escapeRegExpCharacters } from 'monaco-editor/esm/vs/base/common/strings.js';
-import { isString } from 'monaco-editor/esm/vs/base/common/types.js';
-const IUserDataProfilesService = ( createDecorator('IUserDataProfilesService'));
-function toUserDataProfile(id, name, location, profilesCacheHome, options) {
-    return {
-        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.json'),
-        cacheHome: joinPath(profilesCacheHome, id),
-        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 = 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');
-        this.profilesCacheHome = joinPath(this.environmentService.cacheHome, 'CachedProfilesData');
-    }
-    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 = [];
-            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, this.profilesCacheHome, { 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) {
-                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);
-                            }
-                        }
-                    }
-                }
-                catch (error) {
-                    this.logService.error(error);
-                }
-            }
-            this._profilesObject = { profiles, workspaces, emptyWindows };
-        }
-        return this._profilesObject;
-    }
-    createDefaultProfile() {
-        return toUserDataProfile('__default__profile__', ( localize('defaultProfile', "Default")), this.environmentService.userRoamingDataHome, this.profilesCacheHome);
-    }
-    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;
-        }
-        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(id, name, options, workspaceIdentifier) {
-        if (!this.enabled) {
-            throw new Error(`Profiles are disabled in the current environment.`);
-        }
-        const profile = await this.doCreateProfile(id, name, options);
-        if (workspaceIdentifier) {
-            await this.setProfileForWorkspace(workspaceIdentifier, profile);
-        }
-        return profile;
-    }
-    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), this.profilesCacheHome, 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(`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(profile.id, options.name ?? profile.name, profile.location, this.profilesCacheHome, { shortName: options.shortName ?? profile.shortName, transient: options.transient ?? profile.isTransient, useDefaultFlags: options.useDefaultFlags ?? profile.useDefaultFlags });
-        this.updateProfiles([], [], [profile]);
-        return profile;
-    }
-    async removeProfile(profileToRemove) {
-        if (!this.enabled) {
-            throw new Error(`Profiles are disabled in the current environment.`);
-        }
-        if (profileToRemove.isDefault) {
-            throw new Error('Cannot remove default profile');
-        }
-        const profile = this.profiles.find(p => p.id === profileToRemove.id);
-        if (!profile) {
-            throw new Error(`Profile '${profileToRemove.name}' does not exist`);
-        }
-        const joiners = [];
-        this._onWillRemoveProfile.fire({
-            profile,
-            join(promise) {
-                joiners.push(promise);
-            }
-        });
-        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) {
-                this.profilesObject.workspaces.delete(workspace);
-            }
-        }
-        this.updateStoredProfileAssociations();
-        this.updateProfiles([], [profile], []);
-        try {
-            await this.fileService.del(profile.cacheHome, { recursive: true });
-        }
-        catch (error) {
-            if (toFileOperationResult(error) !== 1 ) {
-                this.logService.error(error);
-            }
-        }
-        try {
-            if (this.profiles.length === 1) {
-                await this.fileService.del(this.profilesHome, { recursive: true });
-            }
-            else {
-                await this.fileService.del(profile.location, { recursive: true });
-            }
-        }
-        catch (error) {
-            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 = [];
-        this.transientProfilesObject.profiles = [];
-        for (let profile of allProfiles) {
-            if (profile.isDefault) {
-                continue;
-            }
-            if (( removed.some(p => profile.id === p.id))) {
-                continue;
-            }
-            profile = updated.find(p => profile.id === p.id) ?? profile;
-            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;
-        this.triggerProfilesChanges(added, removed, updated);
-    }
-    triggerProfilesChanges(added, removed, updated) {
-        this._onDidChangeProfiles.fire({ added, removed, updated, all: this.profiles });
-    }
-    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)) {
-            profilesObject.workspaces.delete(workspace);
-            if (newProfile) {
-                profilesObject.workspaces.set(workspace, newProfile);
-            }
-        }
-        else {
-            profilesObject.emptyWindows.delete(workspace);
-            if (newProfile) {
-                profilesObject.emptyWindows.set(workspace, newProfile);
-            }
-        }
-        if (!transient) {
-            this.updateStoredProfileAssociations();
-        }
-    }
-    updateStoredProfileAssociations() {
-        const workspaces = {};
-        for (const [workspace, profile] of this.profilesObject.workspaces.entries()) {
-            workspaces[( workspace.toString())] = profile.id;
-        }
-        const emptyWindows = {};
-        for (const [windowId, profile] of this.profilesObject.emptyWindows.entries()) {
-            emptyWindows[( windowId.toString())] = profile.id;
-        }
-        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';
-UserDataProfilesService = ( __decorate([
-    ( __param(0, IEnvironmentService)),
-    ( __param(1, IFileService)),
-    ( __param(2, IUriIdentityService)),
-    ( __param(3, ILogService))
-], UserDataProfilesService));
-export { IUserDataProfilesService, UserDataProfilesService, toUserDataProfile };

package/dist/vscode/vs/workbench/browser/parts/editor/editorPane.js

@@ -1,242 +0,0 @@
-import { Composite } from '../../composite.js';
-import { isEditorInput } from '../../../common/editor.js';
-import { LRUCache } from 'monaco-editor/esm/vs/base/common/map.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { isEmptyObject } from 'monaco-editor/esm/vs/base/common/types.js';
-import { DEFAULT_EDITOR_MIN_DIMENSIONS, DEFAULT_EDITOR_MAX_DIMENSIONS } from './editor.js';
-import { isEqual, joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { indexOfPath } from 'monaco-editor/esm/vs/base/common/extpath.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-class EditorPane extends Composite {
-    get minimumWidth() { return DEFAULT_EDITOR_MIN_DIMENSIONS.width; }
-    get maximumWidth() { return DEFAULT_EDITOR_MAX_DIMENSIONS.width; }
-    get minimumHeight() { return DEFAULT_EDITOR_MIN_DIMENSIONS.height; }
-    get maximumHeight() { return DEFAULT_EDITOR_MAX_DIMENSIONS.height; }
-    get input() { return this._input; }
-    get options() { return this._options; }
-    get group() { return this._group; }
-    get scopedContextKeyService() { return undefined; }
-    constructor(id, telemetryService, themeService, storageService) {
-        super(id, telemetryService, themeService, storageService);
-        this.onDidChangeSizeConstraints = Event.None;
-        this._onDidChangeControl = this._register(( new Emitter()));
-        this.onDidChangeControl = this._onDidChangeControl.event;
-    }
-    create(parent) {
-        super.create(parent);
-        this.createEditor(parent);
-    }
-    async setInput(input, options, context, token) {
-        this._input = input;
-        this._options = options;
-    }
-    clearInput() {
-        this._input = undefined;
-        this._options = undefined;
-    }
-    setOptions(options) {
-        this._options = options;
-    }
-    setVisible(visible, group) {
-        super.setVisible(visible);
-        this.setEditorVisible(visible, group);
-    }
-    setEditorVisible(visible, group) {
-        this._group = group;
-    }
-    setBoundarySashes(_sashes) {
-    }
-    getEditorMemento(editorGroupService, configurationService, key, limit = 10) {
-        const mementoKey = `${this.getId()}${key}`;
-        let editorMemento = EditorPane.EDITOR_MEMENTOS.get(mementoKey);
-        if (!editorMemento) {
-            editorMemento = this._register(( new EditorMemento(
-                this.getId(),
-                key,
-                this.getMemento(1 , 1 ),
-                limit,
-                editorGroupService,
-                configurationService
-            )));
-            EditorPane.EDITOR_MEMENTOS.set(mementoKey, editorMemento);
-        }
-        return editorMemento;
-    }
-    getViewState() {
-        return undefined;
-    }
-    saveState() {
-        for (const [, editorMemento] of EditorPane.EDITOR_MEMENTOS) {
-            if (editorMemento.id === this.getId()) {
-                editorMemento.saveState();
-            }
-        }
-        super.saveState();
-    }
-    dispose() {
-        this._input = undefined;
-        this._options = undefined;
-        super.dispose();
-    }
-}
-EditorPane.EDITOR_MEMENTOS = ( new Map());
-class EditorMemento extends Disposable {
-    constructor(id, key, memento, limit, editorGroupService, configurationService) {
-        super();
-        this.id = id;
-        this.key = key;
-        this.memento = memento;
-        this.limit = limit;
-        this.editorGroupService = editorGroupService;
-        this.configurationService = configurationService;
-        this.cleanedUp = false;
-        this.shareEditorState = false;
-        this.updateConfiguration(undefined);
-        this.registerListeners();
-    }
-    registerListeners() {
-        this._register(this.configurationService.onDidChangeConfiguration(e => this.updateConfiguration(e)));
-    }
-    updateConfiguration(e) {
-        if (!e || e.affectsConfiguration(undefined, 'workbench.editor.sharedViewState')) {
-            this.shareEditorState = this.configurationService.getValue(undefined, 'workbench.editor.sharedViewState') === true;
-        }
-    }
-    saveEditorState(group, resourceOrEditor, state) {
-        const resource = this.doGetResource(resourceOrEditor);
-        if (!resource || !group) {
-            return;
-        }
-        const cache = this.doLoad();
-        let mementosForResource = cache.get(( resource.toString()));
-        if (!mementosForResource) {
-            mementosForResource = Object.create(null);
-            cache.set(( resource.toString()), mementosForResource);
-        }
-        mementosForResource[group.id] = state;
-        if (this.shareEditorState) {
-            mementosForResource[EditorMemento.SHARED_EDITOR_STATE] = state;
-        }
-        if (isEditorInput(resourceOrEditor)) {
-            this.clearEditorStateOnDispose(resource, resourceOrEditor);
-        }
-    }
-    loadEditorState(group, resourceOrEditor) {
-        const resource = this.doGetResource(resourceOrEditor);
-        if (!resource || !group) {
-            return;
-        }
-        const cache = this.doLoad();
-        const mementosForResource = cache.get(( resource.toString()));
-        if (mementosForResource) {
-            const mementoForResourceAndGroup = mementosForResource[group.id];
-            if (mementoForResourceAndGroup) {
-                return mementoForResourceAndGroup;
-            }
-            if (this.shareEditorState) {
-                return mementosForResource[EditorMemento.SHARED_EDITOR_STATE];
-            }
-        }
-        return undefined;
-    }
-    clearEditorState(resourceOrEditor, group) {
-        if (isEditorInput(resourceOrEditor)) {
-            this.editorDisposables?.delete(resourceOrEditor);
-        }
-        const resource = this.doGetResource(resourceOrEditor);
-        if (resource) {
-            const cache = this.doLoad();
-            if (group) {
-                const mementosForResource = cache.get(( resource.toString()));
-                if (mementosForResource) {
-                    delete mementosForResource[group.id];
-                    if (isEmptyObject(mementosForResource)) {
-                        cache.delete(( resource.toString()));
-                    }
-                }
-            }
-            else {
-                cache.delete(( resource.toString()));
-            }
-        }
-    }
-    clearEditorStateOnDispose(resource, editor) {
-        if (!this.editorDisposables) {
-            this.editorDisposables = ( new Map());
-        }
-        if (!this.editorDisposables.has(editor)) {
-            this.editorDisposables.set(editor, Event.once(editor.onWillDispose)(() => {
-                this.clearEditorState(resource);
-                this.editorDisposables?.delete(editor);
-            }));
-        }
-    }
-    moveEditorState(source, target, comparer) {
-        const cache = this.doLoad();
-        const cacheKeys = [...( cache.keys())];
-        for (const cacheKey of cacheKeys) {
-            const resource = ( URI.parse(cacheKey));
-            if (!comparer.isEqualOrParent(resource, source)) {
-                continue;
-            }
-            let targetResource;
-            if (isEqual(source, resource)) {
-                targetResource = target;
-            }
-            else {
-                const index = indexOfPath(resource.path, source.path);
-                targetResource = joinPath(target, resource.path.substr(index + source.path.length + 1));
-            }
-            const value = cache.get(cacheKey, 0 );
-            if (value) {
-                cache.delete(cacheKey);
-                cache.set(( targetResource.toString()), value);
-            }
-        }
-    }
-    doGetResource(resourceOrEditor) {
-        if (isEditorInput(resourceOrEditor)) {
-            return resourceOrEditor.resource;
-        }
-        return resourceOrEditor;
-    }
-    doLoad() {
-        if (!this.cache) {
-            this.cache = ( new LRUCache(this.limit));
-            const rawEditorMemento = this.memento[this.key];
-            if (Array.isArray(rawEditorMemento)) {
-                this.cache.fromJSON(rawEditorMemento);
-            }
-        }
-        return this.cache;
-    }
-    saveState() {
-        const cache = this.doLoad();
-        if (!this.cleanedUp) {
-            this.cleanUp();
-            this.cleanedUp = true;
-        }
-        this.memento[this.key] = cache.toJSON();
-    }
-    cleanUp() {
-        const cache = this.doLoad();
-        const entries = [...cache.entries()];
-        for (const [resource, mapGroupToMementos] of entries) {
-            for (const group of ( Object.keys(mapGroupToMementos))) {
-                const groupId = Number(group);
-                if (groupId === EditorMemento.SHARED_EDITOR_STATE && this.shareEditorState) {
-                    continue;
-                }
-                if (!this.editorGroupService.getGroup(groupId)) {
-                    delete mapGroupToMementos[groupId];
-                    if (isEmptyObject(mapGroupToMementos)) {
-                        cache.delete(resource);
-                    }
-                }
-            }
-        }
-    }
-}
-EditorMemento.SHARED_EDITOR_STATE = -1;
-export { EditorMemento, EditorPane };