@codingame/monaco-vscode-api 1.82.4-next.1 → 1.82.5-next.0

package/vscode/src/vs/workbench/services/configuration/common/configurationCache.js

@@ -1,80 +0,0 @@
-import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { Queue } from 'monaco-editor/esm/vs/base/common/async.js';
-class ConfigurationCache {
-    constructor(donotCacheResourcesWithSchemes, environmentService, fileService) {
-        this.donotCacheResourcesWithSchemes = donotCacheResourcesWithSchemes;
-        this.fileService = fileService;
-        this.cachedConfigurations = ( new Map());
-        this.cacheHome = environmentService.cacheHome;
-    }
-    needsCaching(resource) {
-        return !this.donotCacheResourcesWithSchemes.includes(resource.scheme);
-    }
-    read(key) {
-        return this.getCachedConfiguration(key).read();
-    }
-    write(key, content) {
-        return this.getCachedConfiguration(key).save(content);
-    }
-    remove(key) {
-        return this.getCachedConfiguration(key).remove();
-    }
-    getCachedConfiguration({ type, key }) {
-        const k = `${type}:${key}`;
-        let cachedConfiguration = this.cachedConfigurations.get(k);
-        if (!cachedConfiguration) {
-            cachedConfiguration = ( new CachedConfiguration({ type, key }, this.cacheHome, this.fileService));
-            this.cachedConfigurations.set(k, cachedConfiguration);
-        }
-        return cachedConfiguration;
-    }
-}
-class CachedConfiguration {
-    constructor({ type, key }, cacheHome, fileService) {
-        this.fileService = fileService;
-        this.cachedConfigurationFolderResource = joinPath(cacheHome, 'CachedConfigurations', type, key);
-        this.cachedConfigurationFileResource = joinPath(this.cachedConfigurationFolderResource, type === 'workspaces' ? 'workspace.json' : 'configuration.json');
-        this.queue = ( new Queue());
-    }
-    async read() {
-        try {
-            const content = await this.fileService.readFile(this.cachedConfigurationFileResource);
-            return ( content.value.toString());
-        }
-        catch (e) {
-            return '';
-        }
-    }
-    async save(content) {
-        const created = await this.createCachedFolder();
-        if (created) {
-            await this.queue.queue(async () => {
-                await this.fileService.writeFile(this.cachedConfigurationFileResource, VSBuffer.fromString(content));
-            });
-        }
-    }
-    async remove() {
-        try {
-            await this.queue.queue(() => this.fileService.del(this.cachedConfigurationFolderResource, { recursive: true, useTrash: false }));
-        }
-        catch (error) {
-            if (error.fileOperationResult !== 1 ) {
-                throw error;
-            }
-        }
-    }
-    async createCachedFolder() {
-        if (await this.fileService.exists(this.cachedConfigurationFolderResource)) {
-            return true;
-        }
-        try {
-            await this.fileService.createFolder(this.cachedConfigurationFolderResource);
-            return true;
-        }
-        catch (error) {
-            return false;
-        }
-    }
-}
-export { ConfigurationCache };

package/vscode/src/vs/workbench/services/configuration/common/configurationEditing.js

@@ -1,589 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import * as json from 'monaco-editor/esm/vs/base/common/json.js';
-import { setProperty } from '../../../../base/common/jsonEdit.js';
-import { Queue } from 'monaco-editor/esm/vs/base/common/async.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-import { ITextFileService } from '../../textfile/common/textfiles.js';
-import { TASKS_CONFIGURATION_KEY, LAUNCH_CONFIGURATION_KEY, TASKS_DEFAULT, FOLDER_SCOPES, FOLDER_SETTINGS_PATH, IWorkbenchConfigurationService, USER_STANDALONE_CONFIGURATIONS, WORKSPACE_STANDALONE_CONFIGURATIONS } from './configuration.js';
-import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
-import { Extensions, OVERRIDE_PROPERTY_REGEX, keyFromOverrideIdentifiers } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
-import { IEditorService } from '../../editor/common/editorService.js';
-import { Severity, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import { IPreferencesService } from '../../preferences/common/preferences.js';
-import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
-import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
-import { EditOperation } from 'monaco-editor/esm/vs/editor/common/core/editOperation.js';
-import { Selection } from 'monaco-editor/esm/vs/editor/common/core/selection.js';
-import { IUserDataProfileService } from '../../userDataProfile/common/userDataProfile.js';
-import { IUserDataProfilesService } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
-import { ErrorNoTelemetry } from 'monaco-editor/esm/vs/base/common/errors.js';
-class ConfigurationEditingError extends ErrorNoTelemetry {
-    constructor(message, code) {
-        super(message);
-        this.code = code;
-    }
-}
-let ConfigurationEditing = class ConfigurationEditing {
-    constructor(remoteSettingsResource, configurationService, contextService, userDataProfileService, userDataProfilesService, fileService, textModelResolverService, textFileService, notificationService, preferencesService, editorService, uriIdentityService) {
-        this.remoteSettingsResource = remoteSettingsResource;
-        this.configurationService = configurationService;
-        this.contextService = contextService;
-        this.userDataProfileService = userDataProfileService;
-        this.userDataProfilesService = userDataProfilesService;
-        this.fileService = fileService;
-        this.textModelResolverService = textModelResolverService;
-        this.textFileService = textFileService;
-        this.notificationService = notificationService;
-        this.preferencesService = preferencesService;
-        this.editorService = editorService;
-        this.uriIdentityService = uriIdentityService;
-        this.queue = ( new Queue());
-    }
-    async writeConfiguration(target, value, options = {}) {
-        const operation = this.getConfigurationEditOperation(target, value, options.scopes || {});
-        return this.queue.queue(async () => {
-            try {
-                await this.doWriteConfiguration(operation, options);
-            }
-            catch (error) {
-                if (options.donotNotifyError) {
-                    throw error;
-                }
-                await this.onError(error, operation, options.scopes);
-            }
-        });
-    }
-    async doWriteConfiguration(operation, options) {
-        await this.validate(operation.target, operation, !options.handleDirtyFile, options.scopes || {});
-        const resource = operation.resource;
-        const reference = await this.resolveModelReference(resource);
-        try {
-            const formattingOptions = this.getFormattingOptions(reference.object.textEditorModel);
-            await this.updateConfiguration(operation, reference.object.textEditorModel, formattingOptions, options);
-        }
-        finally {
-            reference.dispose();
-        }
-    }
-    async updateConfiguration(operation, model, formattingOptions, options) {
-        if (this.hasParseErrors(model.getValue(), operation)) {
-            throw this.toConfigurationEditingError(11 , operation.target, operation);
-        }
-        if (this.textFileService.isDirty(model.uri) && options.handleDirtyFile) {
-            switch (options.handleDirtyFile) {
-                case 'save':
-                    await this.save(model, operation);
-                    break;
-                case 'revert':
-                    await this.textFileService.revert(model.uri);
-                    break;
-            }
-        }
-        const edit = this.getEdits(operation, model.getValue(), formattingOptions)[0];
-        if (edit && this.applyEditsToBuffer(edit, model)) {
-            await this.save(model, operation);
-        }
-    }
-    async save(model, operation) {
-        try {
-            await this.textFileService.save(model.uri, { ignoreErrorHandler: true });
-        }
-        catch (error) {
-            if (error.fileOperationResult === 3 ) {
-                throw this.toConfigurationEditingError(10 , operation.target, operation);
-            }
-            throw new ConfigurationEditingError(nls.localize('fsError', "Error while writing to {0}. {1}", this.stringifyTarget(operation.target), error.message), 13 );
-        }
-    }
-    applyEditsToBuffer(edit, model) {
-        const startPosition = model.getPositionAt(edit.offset);
-        const endPosition = model.getPositionAt(edit.offset + edit.length);
-        const range = ( new Range(
-            startPosition.lineNumber,
-            startPosition.column,
-            endPosition.lineNumber,
-            endPosition.column
-        ));
-        const currentText = model.getValueInRange(range);
-        if (edit.content !== currentText) {
-            const editOperation = currentText ? EditOperation.replace(range, edit.content) : EditOperation.insert(startPosition, edit.content);
-            model.pushEditOperations([( new Selection(
-                startPosition.lineNumber,
-                startPosition.column,
-                startPosition.lineNumber,
-                startPosition.column
-            ))], [editOperation], () => []);
-            return true;
-        }
-        return false;
-    }
-    getEdits({ value, jsonPath }, modelContent, formattingOptions) {
-        if (jsonPath.length) {
-            return setProperty(modelContent, jsonPath, value, formattingOptions);
-        }
-        const content = JSON.stringify(value, null, formattingOptions.insertSpaces && formattingOptions.tabSize ? ' '.repeat(formattingOptions.tabSize) : '\t');
-        return [{
-                content,
-                length: modelContent.length,
-                offset: 0
-            }];
-    }
-    getFormattingOptions(model) {
-        const { insertSpaces, tabSize } = model.getOptions();
-        const eol = model.getEOL();
-        return { insertSpaces, tabSize, eol };
-    }
-    async onError(error, operation, scopes) {
-        switch (error.code) {
-            case 11 :
-                this.onInvalidConfigurationError(error, operation);
-                break;
-            case 9 :
-                this.onConfigurationFileDirtyError(error, operation, scopes);
-                break;
-            case 10 :
-                return this.doWriteConfiguration(operation, { scopes, handleDirtyFile: 'revert' });
-            default:
-                this.notificationService.error(error.message);
-        }
-    }
-    onInvalidConfigurationError(error, operation) {
-        const openStandAloneConfigurationActionLabel = operation.workspaceStandAloneConfigurationKey === TASKS_CONFIGURATION_KEY ? ( nls.localize('openTasksConfiguration', "Open Tasks Configuration"))
-            : operation.workspaceStandAloneConfigurationKey === LAUNCH_CONFIGURATION_KEY ? ( nls.localize('openLaunchConfiguration', "Open Launch Configuration"))
-                : null;
-        if (openStandAloneConfigurationActionLabel) {
-            this.notificationService.prompt(Severity.Error, error.message, [{
-                    label: openStandAloneConfigurationActionLabel,
-                    run: () => this.openFile(operation.resource)
-                }]);
-        }
-        else {
-            this.notificationService.prompt(Severity.Error, error.message, [{
-                    label: ( nls.localize('open', "Open Settings")),
-                    run: () => this.openSettings(operation)
-                }]);
-        }
-    }
-    onConfigurationFileDirtyError(error, operation, scopes) {
-        const openStandAloneConfigurationActionLabel = operation.workspaceStandAloneConfigurationKey === TASKS_CONFIGURATION_KEY ? ( nls.localize('openTasksConfiguration', "Open Tasks Configuration"))
-            : operation.workspaceStandAloneConfigurationKey === LAUNCH_CONFIGURATION_KEY ? ( nls.localize('openLaunchConfiguration', "Open Launch Configuration"))
-                : null;
-        if (openStandAloneConfigurationActionLabel) {
-            this.notificationService.prompt(Severity.Error, error.message, [{
-                    label: ( nls.localize('saveAndRetry', "Save and Retry")),
-                    run: () => {
-                        const key = operation.key ? `${operation.workspaceStandAloneConfigurationKey}.${operation.key}` : operation.workspaceStandAloneConfigurationKey;
-                        this.writeConfiguration(operation.target, { key, value: operation.value }, { handleDirtyFile: 'save', scopes });
-                    }
-                },
-                {
-                    label: openStandAloneConfigurationActionLabel,
-                    run: () => this.openFile(operation.resource)
-                }]);
-        }
-        else {
-            this.notificationService.prompt(Severity.Error, error.message, [{
-                    label: ( nls.localize('saveAndRetry', "Save and Retry")),
-                    run: () => this.writeConfiguration(operation.target, { key: operation.key, value: operation.value }, { handleDirtyFile: 'save', scopes })
-                },
-                {
-                    label: ( nls.localize('open', "Open Settings")),
-                    run: () => this.openSettings(operation)
-                }]);
-        }
-    }
-    openSettings(operation) {
-        const options = { jsonEditor: true };
-        switch (operation.target) {
-            case 1 :
-                this.preferencesService.openUserSettings(options);
-                break;
-            case 2 :
-                this.preferencesService.openRemoteSettings(options);
-                break;
-            case 3 :
-                this.preferencesService.openWorkspaceSettings(options);
-                break;
-            case 4 :
-                if (operation.resource) {
-                    const workspaceFolder = this.contextService.getWorkspaceFolder(operation.resource);
-                    if (workspaceFolder) {
-                        this.preferencesService.openFolderSettings({ folderUri: workspaceFolder.uri, jsonEditor: true });
-                    }
-                }
-                break;
-        }
-    }
-    openFile(resource) {
-        this.editorService.openEditor({ resource, options: { pinned: true } });
-    }
-    toConfigurationEditingError(code, target, operation) {
-        const message = this.toErrorMessage(code, target, operation);
-        return ( new ConfigurationEditingError(message, code));
-    }
-    toErrorMessage(error, target, operation) {
-        switch (error) {
-            case 12 : return ( nls.localize(
-                'errorPolicyConfiguration',
-                "Unable to write {0} because it is configured in system policy.",
-                operation.key
-            ));
-            case 0 : return ( nls.localize(
-                'errorUnknownKey',
-                "Unable to write to {0} because {1} is not a registered configuration.",
-                this.stringifyTarget(target),
-                operation.key
-            ));
-            case 1 : return ( nls.localize(
-                'errorInvalidWorkspaceConfigurationApplication',
-                "Unable to write {0} to Workspace Settings. This setting can be written only into User settings.",
-                operation.key
-            ));
-            case 2 : return ( nls.localize(
-                'errorInvalidWorkspaceConfigurationMachine',
-                "Unable to write {0} to Workspace Settings. This setting can be written only into User settings.",
-                operation.key
-            ));
-            case 3 : return ( nls.localize(
-                'errorInvalidFolderConfiguration',
-                "Unable to write to Folder Settings because {0} does not support the folder resource scope.",
-                operation.key
-            ));
-            case 4 : return ( nls.localize(
-                'errorInvalidUserTarget',
-                "Unable to write to User Settings because {0} does not support for global scope.",
-                operation.key
-            ));
-            case 5 : return ( nls.localize(
-                'errorInvalidWorkspaceTarget',
-                "Unable to write to Workspace Settings because {0} does not support for workspace scope in a multi folder workspace.",
-                operation.key
-            ));
-            case 6 : return ( nls.localize(
-                'errorInvalidFolderTarget',
-                "Unable to write to Folder Settings because no resource is provided."
-            ));
-            case 7 : return ( nls.localize(
-                'errorInvalidResourceLanguageConfiguration',
-                "Unable to write to Language Settings because {0} is not a resource language setting.",
-                operation.key
-            ));
-            case 8 : return ( nls.localize(
-                'errorNoWorkspaceOpened',
-                "Unable to write to {0} because no workspace is opened. Please open a workspace first and try again.",
-                this.stringifyTarget(target)
-            ));
-            case 11 : {
-                if (operation.workspaceStandAloneConfigurationKey === TASKS_CONFIGURATION_KEY) {
-                    return ( nls.localize(
-                        'errorInvalidTaskConfiguration',
-                        "Unable to write into the tasks configuration file. Please open it to correct errors/warnings in it and try again."
-                    ));
-                }
-                if (operation.workspaceStandAloneConfigurationKey === LAUNCH_CONFIGURATION_KEY) {
-                    return ( nls.localize(
-                        'errorInvalidLaunchConfiguration',
-                        "Unable to write into the launch configuration file. Please open it to correct errors/warnings in it and try again."
-                    ));
-                }
-                switch (target) {
-                    case 1 :
-                        return ( nls.localize(
-                            'errorInvalidConfiguration',
-                            "Unable to write into user settings. Please open the user settings to correct errors/warnings in it and try again."
-                        ));
-                    case 2 :
-                        return ( nls.localize(
-                            'errorInvalidRemoteConfiguration',
-                            "Unable to write into remote user settings. Please open the remote user settings to correct errors/warnings in it and try again."
-                        ));
-                    case 3 :
-                        return ( nls.localize(
-                            'errorInvalidConfigurationWorkspace',
-                            "Unable to write into workspace settings. Please open the workspace settings to correct errors/warnings in the file and try again."
-                        ));
-                    case 4 : {
-                        let workspaceFolderName = '<<unknown>>';
-                        if (operation.resource) {
-                            const folder = this.contextService.getWorkspaceFolder(operation.resource);
-                            if (folder) {
-                                workspaceFolderName = folder.name;
-                            }
-                        }
-                        return ( nls.localize(
-                            'errorInvalidConfigurationFolder',
-                            "Unable to write into folder settings. Please open the '{0}' folder settings to correct errors/warnings in it and try again.",
-                            workspaceFolderName
-                        ));
-                    }
-                    default:
-                        return '';
-                }
-            }
-            case 9 : {
-                if (operation.workspaceStandAloneConfigurationKey === TASKS_CONFIGURATION_KEY) {
-                    return ( nls.localize(
-                        'errorTasksConfigurationFileDirty',
-                        "Unable to write into tasks configuration file because the file has unsaved changes. Please save it first and then try again."
-                    ));
-                }
-                if (operation.workspaceStandAloneConfigurationKey === LAUNCH_CONFIGURATION_KEY) {
-                    return ( nls.localize(
-                        'errorLaunchConfigurationFileDirty',
-                        "Unable to write into launch configuration file because the file has unsaved changes. Please save it first and then try again."
-                    ));
-                }
-                switch (target) {
-                    case 1 :
-                        return ( nls.localize(
-                            'errorConfigurationFileDirty',
-                            "Unable to write into user settings because the file has unsaved changes. Please save the user settings file first and then try again."
-                        ));
-                    case 2 :
-                        return ( nls.localize(
-                            'errorRemoteConfigurationFileDirty',
-                            "Unable to write into remote user settings because the file has unsaved changes. Please save the remote user settings file first and then try again."
-                        ));
-                    case 3 :
-                        return ( nls.localize(
-                            'errorConfigurationFileDirtyWorkspace',
-                            "Unable to write into workspace settings because the file has unsaved changes. Please save the workspace settings file first and then try again."
-                        ));
-                    case 4 : {
-                        let workspaceFolderName = '<<unknown>>';
-                        if (operation.resource) {
-                            const folder = this.contextService.getWorkspaceFolder(operation.resource);
-                            if (folder) {
-                                workspaceFolderName = folder.name;
-                            }
-                        }
-                        return ( nls.localize(
-                            'errorConfigurationFileDirtyFolder',
-                            "Unable to write into folder settings because the file has unsaved changes. Please save the '{0}' folder settings file first and then try again.",
-                            workspaceFolderName
-                        ));
-                    }
-                    default:
-                        return '';
-                }
-            }
-            case 10 :
-                if (operation.workspaceStandAloneConfigurationKey === TASKS_CONFIGURATION_KEY) {
-                    return ( nls.localize(
-                        'errorTasksConfigurationFileModifiedSince',
-                        "Unable to write into tasks configuration file because the content of the file is newer."
-                    ));
-                }
-                if (operation.workspaceStandAloneConfigurationKey === LAUNCH_CONFIGURATION_KEY) {
-                    return ( nls.localize(
-                        'errorLaunchConfigurationFileModifiedSince',
-                        "Unable to write into launch configuration file because the content of the file is newer."
-                    ));
-                }
-                switch (target) {
-                    case 1 :
-                        return ( nls.localize(
-                            'errorConfigurationFileModifiedSince',
-                            "Unable to write into user settings because the content of the file is newer."
-                        ));
-                    case 2 :
-                        return ( nls.localize(
-                            'errorRemoteConfigurationFileModifiedSince',
-                            "Unable to write into remote user settings because the content of the file is newer."
-                        ));
-                    case 3 :
-                        return ( nls.localize(
-                            'errorConfigurationFileModifiedSinceWorkspace',
-                            "Unable to write into workspace settings because the content of the file is newer."
-                        ));
-                    case 4 :
-                        return ( nls.localize(
-                            'errorConfigurationFileModifiedSinceFolder',
-                            "Unable to write into folder settings because the content of the file is newer."
-                        ));
-                }
-            case 13 : return ( nls.localize(
-                'errorUnknown',
-                "Unable to write to {0} because of an internal error.",
-                this.stringifyTarget(target)
-            ));
-        }
-    }
-    stringifyTarget(target) {
-        switch (target) {
-            case 1 :
-                return ( nls.localize('userTarget', "User Settings"));
-            case 2 :
-                return ( nls.localize('remoteUserTarget', "Remote User Settings"));
-            case 3 :
-                return ( nls.localize('workspaceTarget', "Workspace Settings"));
-            case 4 :
-                return ( nls.localize('folderTarget', "Folder Settings"));
-            default:
-                return '';
-        }
-    }
-    defaultResourceValue(resource) {
-        const basename = this.uriIdentityService.extUri.basename(resource);
-        const configurationValue = basename.substr(0, basename.length - this.uriIdentityService.extUri.extname(resource).length);
-        switch (configurationValue) {
-            case TASKS_CONFIGURATION_KEY: return TASKS_DEFAULT;
-            default: return '{}';
-        }
-    }
-    async resolveModelReference(resource) {
-        const exists = await this.fileService.exists(resource);
-        if (!exists) {
-            await this.textFileService.write(resource, this.defaultResourceValue(resource), { encoding: 'utf8' });
-        }
-        return this.textModelResolverService.createModelReference(resource);
-    }
-    hasParseErrors(content, operation) {
-        if (operation.workspaceStandAloneConfigurationKey && !operation.key) {
-            return false;
-        }
-        const parseErrors = [];
-        json.parse(content, parseErrors, { allowTrailingComma: true, allowEmptyContent: true });
-        return parseErrors.length > 0;
-    }
-    async validate(target, operation, checkDirty, overrides) {
-        if (this.configurationService.inspect(operation.key).policyValue !== undefined) {
-            throw this.toConfigurationEditingError(12 , target, operation);
-        }
-        const configurationProperties = ( Registry.as(Extensions.Configuration)).getConfigurationProperties();
-        const configurationScope = configurationProperties[operation.key]?.scope;
-        if (!operation.workspaceStandAloneConfigurationKey) {
-            const validKeys = ( this.configurationService.keys()).default;
-            if (validKeys.indexOf(operation.key) < 0 && !OVERRIDE_PROPERTY_REGEX.test(operation.key) && operation.value !== undefined) {
-                throw this.toConfigurationEditingError(0 , target, operation);
-            }
-        }
-        if (operation.workspaceStandAloneConfigurationKey) {
-            if ((operation.workspaceStandAloneConfigurationKey !== TASKS_CONFIGURATION_KEY) && ((target === 1  || target === 2) )) {
-                throw this.toConfigurationEditingError(4 , target, operation);
-            }
-        }
-        if (((target === 3  || target === 4) ) && this.contextService.getWorkbenchState() === 1 ) {
-            throw this.toConfigurationEditingError(8 , target, operation);
-        }
-        if (target === 3 ) {
-            if (!operation.workspaceStandAloneConfigurationKey && !OVERRIDE_PROPERTY_REGEX.test(operation.key)) {
-                if (configurationScope === 1 ) {
-                    throw this.toConfigurationEditingError(1 , target, operation);
-                }
-                if (configurationScope === 2 ) {
-                    throw this.toConfigurationEditingError(2 , target, operation);
-                }
-            }
-        }
-        if (target === 4 ) {
-            if (!operation.resource) {
-                throw this.toConfigurationEditingError(6 , target, operation);
-            }
-            if (!operation.workspaceStandAloneConfigurationKey && !OVERRIDE_PROPERTY_REGEX.test(operation.key)) {
-                if (configurationScope !== undefined && !FOLDER_SCOPES.includes(configurationScope)) {
-                    throw this.toConfigurationEditingError(3 , target, operation);
-                }
-            }
-        }
-        if (overrides.overrideIdentifiers?.length) {
-            if (configurationScope !== 5 ) {
-                throw this.toConfigurationEditingError(7 , target, operation);
-            }
-        }
-        if (!operation.resource) {
-            throw this.toConfigurationEditingError(6 , target, operation);
-        }
-        if (checkDirty && this.textFileService.isDirty(operation.resource)) {
-            throw this.toConfigurationEditingError(9 , target, operation);
-        }
-    }
-    getConfigurationEditOperation(target, config, overrides) {
-        if (config.key) {
-            const standaloneConfigurationMap = target === 1  ? USER_STANDALONE_CONFIGURATIONS : WORKSPACE_STANDALONE_CONFIGURATIONS;
-            const standaloneConfigurationKeys = ( Object.keys(standaloneConfigurationMap));
-            for (const key of standaloneConfigurationKeys) {
-                const resource = this.getConfigurationFileResource(target, key, standaloneConfigurationMap[key], overrides.resource, undefined);
-                if (config.key === key) {
-                    const jsonPath = this.isWorkspaceConfigurationResource(resource) ? [key] : [];
-                    return { key: jsonPath[jsonPath.length - 1], jsonPath, value: config.value, resource: resource ?? undefined, workspaceStandAloneConfigurationKey: key, target };
-                }
-                const keyPrefix = `${key}.`;
-                if (config.key.indexOf(keyPrefix) === 0) {
-                    const jsonPath = this.isWorkspaceConfigurationResource(resource) ? [key, config.key.substr(keyPrefix.length)] : [config.key.substr(keyPrefix.length)];
-                    return { key: jsonPath[jsonPath.length - 1], jsonPath, value: config.value, resource: resource ?? undefined, workspaceStandAloneConfigurationKey: key, target };
-                }
-            }
-        }
-        const key = config.key;
-        const configurationProperties = ( Registry.as(Extensions.Configuration)).getConfigurationProperties();
-        const configurationScope = configurationProperties[key]?.scope;
-        let jsonPath = overrides.overrideIdentifiers?.length ? [keyFromOverrideIdentifiers(overrides.overrideIdentifiers), key] : [key];
-        if (target === 1  || target === 2 ) {
-            return { key, jsonPath, value: config.value, resource: this.getConfigurationFileResource(target, key, '', null, configurationScope) ?? undefined, target };
-        }
-        const resource = this.getConfigurationFileResource(target, key, FOLDER_SETTINGS_PATH, overrides.resource, configurationScope);
-        if (this.isWorkspaceConfigurationResource(resource)) {
-            jsonPath = ['settings', ...jsonPath];
-        }
-        return { key, jsonPath, value: config.value, resource: resource ?? undefined, target };
-    }
-    isWorkspaceConfigurationResource(resource) {
-        const workspace = this.contextService.getWorkspace();
-        return !!(workspace.configuration && resource && workspace.configuration.fsPath === resource.fsPath);
-    }
-    getConfigurationFileResource(target, key, relativePath, resource, scope) {
-        if (target === 1 ) {
-            if (key === TASKS_CONFIGURATION_KEY) {
-                return this.userDataProfileService.currentProfile.tasksResource;
-            }
-            else {
-                if (!this.userDataProfileService.currentProfile.isDefault && this.configurationService.isSettingAppliedForAllProfiles(key)) {
-                    return this.userDataProfilesService.defaultProfile.settingsResource;
-                }
-                return this.userDataProfileService.currentProfile.settingsResource;
-            }
-        }
-        if (target === 2 ) {
-            return this.remoteSettingsResource;
-        }
-        const workbenchState = this.contextService.getWorkbenchState();
-        if (workbenchState !== 1 ) {
-            const workspace = this.contextService.getWorkspace();
-            if (target === 3 ) {
-                if (workbenchState === 3 ) {
-                    return workspace.configuration ?? null;
-                }
-                if (workbenchState === 2 ) {
-                    return workspace.folders[0].toResource(relativePath);
-                }
-            }
-            if (target === 4 ) {
-                if (resource) {
-                    const folder = this.contextService.getWorkspaceFolder(resource);
-                    if (folder) {
-                        return folder.toResource(relativePath);
-                    }
-                }
-            }
-        }
-        return null;
-    }
-};
-ConfigurationEditing = ( __decorate([
-    ( __param(1, IWorkbenchConfigurationService)),
-    ( __param(2, IWorkspaceContextService)),
-    ( __param(3, IUserDataProfileService)),
-    ( __param(4, IUserDataProfilesService)),
-    ( __param(5, IFileService)),
-    ( __param(6, ITextModelService)),
-    ( __param(7, ITextFileService)),
-    ( __param(8, INotificationService)),
-    ( __param(9, IPreferencesService)),
-    ( __param(10, IEditorService)),
-    ( __param(11, IUriIdentityService))
-], ConfigurationEditing));
-export { ConfigurationEditing, ConfigurationEditingError };