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

package/dist/vscode/vs/workbench/services/configuration/common/configurationModels.js

@@ -0,0 +1,119 @@
+import { equals } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { toValuesTree } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Configuration as Configuration$1, ConfigurationModelParser, ConfigurationModel } from 'monaco-editor/esm/vs/platform/configuration/common/configurationModels.js';
+import { isBoolean } from 'monaco-editor/esm/vs/base/common/types.js';
+import { distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
+class WorkspaceConfigurationModelParser extends ConfigurationModelParser {
+    constructor(name) {
+        super(name);
+        this._folders = [];
+        this._transient = false;
+        this._settingsModelParser = ( new ConfigurationModelParser(name));
+        this._launchModel = ( new ConfigurationModel());
+        this._tasksModel = ( new ConfigurationModel());
+    }
+    get folders() {
+        return this._folders;
+    }
+    get transient() {
+        return this._transient;
+    }
+    get settingsModel() {
+        return this._settingsModelParser.configurationModel;
+    }
+    get launchModel() {
+        return this._launchModel;
+    }
+    get tasksModel() {
+        return this._tasksModel;
+    }
+    reparseWorkspaceSettings(configurationParseOptions) {
+        this._settingsModelParser.reparse(configurationParseOptions);
+    }
+    getRestrictedWorkspaceSettings() {
+        return this._settingsModelParser.restrictedConfigurations;
+    }
+    doParseRaw(raw, configurationParseOptions) {
+        this._folders = (raw['folders'] || []);
+        this._transient = isBoolean(raw['transient']) && raw['transient'];
+        this._settingsModelParser.parseRaw(raw['settings'], configurationParseOptions);
+        this._launchModel = this.createConfigurationModelFrom(raw, 'launch');
+        this._tasksModel = this.createConfigurationModelFrom(raw, 'tasks');
+        return super.doParseRaw(raw, configurationParseOptions);
+    }
+    createConfigurationModelFrom(raw, key) {
+        const data = raw[key];
+        if (data) {
+            const contents = toValuesTree(data, message => console.error(`Conflict in settings file ${this._name}: ${message}`));
+            const scopedContents = Object.create(null);
+            scopedContents[key] = contents;
+            const keys = ( ( Object.keys(data)).map(k => `${key}.${k}`));
+            return ( new ConfigurationModel(scopedContents, keys, []));
+        }
+        return ( new ConfigurationModel());
+    }
+}
+class StandaloneConfigurationModelParser extends ConfigurationModelParser {
+    constructor(name, scope) {
+        super(name);
+        this.scope = scope;
+    }
+    doParseRaw(raw, configurationParseOptions) {
+        const contents = toValuesTree(raw, message => console.error(`Conflict in settings file ${this._name}: ${message}`));
+        const scopedContents = Object.create(null);
+        scopedContents[this.scope] = contents;
+        const keys = ( ( Object.keys(raw)).map(key => `${this.scope}.${key}`));
+        return { contents: scopedContents, keys, overrides: [] };
+    }
+}
+class Configuration extends Configuration$1 {
+    constructor(defaults, policy, application, localUser, remoteUser, workspaceConfiguration, folders, memoryConfiguration, memoryConfigurationByResource, _workspace) {
+        super(defaults, policy, application, localUser, remoteUser, workspaceConfiguration, folders, memoryConfiguration, memoryConfigurationByResource);
+        this._workspace = _workspace;
+    }
+    getValue(key, overrides = {}) {
+        return super.getValue(key, overrides, this._workspace);
+    }
+    inspect(key, overrides = {}) {
+        return super.inspect(key, overrides, this._workspace);
+    }
+    keys() {
+        return ( super.keys(this._workspace));
+    }
+    compareAndDeleteFolderConfiguration(folder) {
+        if (this._workspace && this._workspace.folders.length > 0 && ( this._workspace.folders[0].uri.toString()) === ( folder.toString())) {
+            return { keys: [], overrides: [] };
+        }
+        return super.compareAndDeleteFolderConfiguration(folder);
+    }
+    compare(other) {
+        const compare = (fromKeys, toKeys, overrideIdentifier) => {
+            const keys = [];
+            keys.push(...toKeys.filter(key => fromKeys.indexOf(key) === -1));
+            keys.push(...fromKeys.filter(key => toKeys.indexOf(key) === -1));
+            keys.push(...fromKeys.filter(key => {
+                if (toKeys.indexOf(key) === -1) {
+                    return false;
+                }
+                if (!equals(this.getValue(key, { overrideIdentifier }), other.getValue(key, { overrideIdentifier }))) {
+                    return true;
+                }
+                return this._workspace && ( this._workspace.folders.some(
+                    folder => !equals(this.getValue(key, { resource: folder.uri, overrideIdentifier }), other.getValue(key, { resource: folder.uri, overrideIdentifier }))
+                ));
+            }));
+            return keys;
+        };
+        const keys = compare(this.allKeys(), other.allKeys());
+        const overrides = [];
+        const allOverrideIdentifiers = distinct([...this.allOverrideIdentifiers(), ...other.allOverrideIdentifiers()]);
+        for (const overrideIdentifier of allOverrideIdentifiers) {
+            const keys = compare(this.getAllKeysForOverrideIdentifier(overrideIdentifier), other.getAllKeysForOverrideIdentifier(overrideIdentifier), overrideIdentifier);
+            if (keys.length) {
+                overrides.push([overrideIdentifier, keys]);
+            }
+        }
+        return { keys, overrides };
+    }
+}
+export { Configuration, StandaloneConfigurationModelParser, WorkspaceConfigurationModelParser };

package/dist/vscode/vs/workbench/services/configuration/common/jsonEditing.js

@@ -0,0 +1,9 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IJSONEditingService = ( createDecorator('jsonEditingService'));
+class JSONEditingError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+    }
+}
+export { IJSONEditingService, JSONEditingError };

package/dist/vscode/vs/workbench/services/configuration/common/jsonEditingService.js

@@ -0,0 +1,119 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { parse } from '../../../../base/common/json.js';
+import { setProperty } from '../../../../base/common/jsonEdit.js';
+import { Queue } from 'monaco-editor/esm/vs/base/common/async.js';
+import { EditOperation } from 'monaco-editor/esm/vs/editor/common/core/editOperation.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { Selection } from 'monaco-editor/esm/vs/editor/common/core/selection.js';
+import { ITextFileService } from '../../textfile/common/textfiles.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 { JSONEditingError } from './jsonEditing.js';
+let JSONEditingService = class JSONEditingService {
+    constructor(fileService, textModelResolverService, textFileService) {
+        this.fileService = fileService;
+        this.textModelResolverService = textModelResolverService;
+        this.textFileService = textFileService;
+        this.queue = ( new Queue());
+    }
+    write(resource, values) {
+        return Promise.resolve(this.queue.queue(() => this.doWriteConfiguration(resource, values)));
+    }
+    async doWriteConfiguration(resource, values) {
+        const reference = await this.resolveAndValidate(resource, true);
+        try {
+            await this.writeToBuffer(reference.object.textEditorModel, values);
+        }
+        finally {
+            reference.dispose();
+        }
+    }
+    async writeToBuffer(model, values) {
+        let hasEdits = false;
+        for (const value of values) {
+            const edit = this.getEdits(model, value)[0];
+            hasEdits = !!edit && this.applyEditsToBuffer(edit, model);
+        }
+        if (hasEdits) {
+            return this.textFileService.save(model.uri);
+        }
+    }
+    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(model, configurationValue) {
+        const { tabSize, insertSpaces } = model.getOptions();
+        const eol = model.getEOL();
+        const { path, value } = configurationValue;
+        if (!path.length) {
+            const content = JSON.stringify(value, null, insertSpaces ? ' '.repeat(tabSize) : '\t');
+            return [{
+                    content,
+                    length: content.length,
+                    offset: 0
+                }];
+        }
+        return setProperty(model.getValue(), path, value, { tabSize, insertSpaces, eol });
+    }
+    async resolveModelReference(resource) {
+        const exists = await this.fileService.exists(resource);
+        if (!exists) {
+            await this.textFileService.write(resource, '{}', { encoding: 'utf8' });
+        }
+        return this.textModelResolverService.createModelReference(resource);
+    }
+    hasParseErrors(model) {
+        const parseErrors = [];
+        parse(model.getValue(), parseErrors, { allowTrailingComma: true, allowEmptyContent: true });
+        return parseErrors.length > 0;
+    }
+    async resolveAndValidate(resource, checkDirty) {
+        const reference = await this.resolveModelReference(resource);
+        const model = reference.object.textEditorModel;
+        if (this.hasParseErrors(model)) {
+            reference.dispose();
+            return this.reject(0 );
+        }
+        return reference;
+    }
+    reject(code) {
+        const message = this.toErrorMessage(code);
+        return Promise.reject(( new JSONEditingError(message, code)));
+    }
+    toErrorMessage(error) {
+        switch (error) {
+            case 0 : {
+                return ( nls.localize(
+                    'errorInvalidFile',
+                    "Unable to write into the file. Please open the file to correct errors/warnings in the file and try again."
+                ));
+            }
+        }
+    }
+};
+JSONEditingService = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, ITextModelService)),
+    ( __param(2, ITextFileService))
+], JSONEditingService));
+export { JSONEditingService };

package/dist/vscode/vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService.js

@@ -0,0 +1,303 @@
+import { Queue } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import * as types from 'monaco-editor/esm/vs/base/common/types.js';
+import { isCodeEditor, isDiffEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
+import { AbstractVariableResolverService } from '../common/variableResolver.js';
+class BaseConfigurationResolverService extends AbstractVariableResolverService {
+    constructor(context, envVariablesPromise, editorService, configurationService, commandService, workspaceContextService, quickInputService, labelService, pathService, extensionService) {
+        super({
+            getFolderUri: (folderName) => {
+                const folder = workspaceContextService.getWorkspace().folders.filter(f => f.name === folderName).pop();
+                return folder ? folder.uri : undefined;
+            },
+            getWorkspaceFolderCount: () => {
+                return workspaceContextService.getWorkspace().folders.length;
+            },
+            getConfigurationValue: (folderUri, suffix) => {
+                return configurationService.getValue(suffix, folderUri ? { resource: folderUri } : {});
+            },
+            getAppRoot: () => {
+                return context.getAppRoot();
+            },
+            getExecPath: () => {
+                return context.getExecPath();
+            },
+            getFilePath: () => {
+                const fileResource = EditorResourceAccessor.getOriginalUri(editorService.activeEditor, {
+                    supportSideBySide: SideBySideEditor.PRIMARY,
+                    filterByScheme: [Schemas.file, Schemas.vscodeUserData, this.pathService.defaultUriScheme]
+                });
+                if (!fileResource) {
+                    return undefined;
+                }
+                return this.labelService.getUriLabel(fileResource, { noPrefix: true });
+            },
+            getWorkspaceFolderPathForFile: () => {
+                const fileResource = EditorResourceAccessor.getOriginalUri(editorService.activeEditor, {
+                    supportSideBySide: SideBySideEditor.PRIMARY,
+                    filterByScheme: [Schemas.file, Schemas.vscodeUserData, this.pathService.defaultUriScheme]
+                });
+                if (!fileResource) {
+                    return undefined;
+                }
+                const wsFolder = workspaceContextService.getWorkspaceFolder(fileResource);
+                if (!wsFolder) {
+                    return undefined;
+                }
+                return this.labelService.getUriLabel(wsFolder.uri, { noPrefix: true });
+            },
+            getSelectedText: () => {
+                const activeTextEditorControl = editorService.activeTextEditorControl;
+                let activeControl = null;
+                if (isCodeEditor(activeTextEditorControl)) {
+                    activeControl = activeTextEditorControl;
+                }
+                else if (isDiffEditor(activeTextEditorControl)) {
+                    const original = activeTextEditorControl.getOriginalEditor();
+                    const modified = activeTextEditorControl.getModifiedEditor();
+                    activeControl = original.hasWidgetFocus() ? original : modified;
+                }
+                const activeModel = activeControl?.getModel();
+                const activeSelection = activeControl?.getSelection();
+                if (activeModel && activeSelection) {
+                    return activeModel.getValueInRange(activeSelection);
+                }
+                return undefined;
+            },
+            getLineNumber: () => {
+                const activeTextEditorControl = editorService.activeTextEditorControl;
+                if (isCodeEditor(activeTextEditorControl)) {
+                    const selection = activeTextEditorControl.getSelection();
+                    if (selection) {
+                        const lineNumber = selection.positionLineNumber;
+                        return String(lineNumber);
+                    }
+                }
+                return undefined;
+            },
+            getExtension: id => {
+                return extensionService.getExtension(id);
+            },
+        }, labelService, pathService.userHome().then(home => home.path), envVariablesPromise);
+        this.configurationService = configurationService;
+        this.commandService = commandService;
+        this.workspaceContextService = workspaceContextService;
+        this.quickInputService = quickInputService;
+        this.labelService = labelService;
+        this.pathService = pathService;
+        this.userInputAccessQueue = ( new Queue());
+    }
+    async resolveWithInteractionReplace(folder, config, section, variables, target) {
+        config = await this.resolveAnyAsync(folder, config);
+        return this.resolveWithInteraction(folder, config, section, variables, target).then(mapping => {
+            if (!mapping) {
+                return null;
+            }
+            else if (mapping.size > 0) {
+                return this.resolveAnyAsync(folder, config, Object.fromEntries(mapping));
+            }
+            else {
+                return config;
+            }
+        });
+    }
+    async resolveWithInteraction(folder, config, section, variables, target) {
+        const resolved = await this.resolveAnyMap(folder, config);
+        config = resolved.newConfig;
+        const allVariableMapping = resolved.resolvedVariables;
+        return this.resolveWithInputAndCommands(folder, config, variables, section, target).then(inputOrCommandMapping => {
+            if (this.updateMapping(inputOrCommandMapping, allVariableMapping)) {
+                return allVariableMapping;
+            }
+            return undefined;
+        });
+    }
+    updateMapping(newMapping, fullMapping) {
+        if (!newMapping) {
+            return false;
+        }
+        for (const [key, value] of Object.entries(newMapping)) {
+            fullMapping.set(key, value);
+        }
+        return true;
+    }
+    async resolveWithInputAndCommands(folder, configuration, variableToCommandMap, section, target) {
+        if (!configuration) {
+            return Promise.resolve(undefined);
+        }
+        let inputs = [];
+        if (this.workspaceContextService.getWorkbenchState() !== 1  && section) {
+            const overrides = folder ? { resource: folder.uri } : {};
+            const result = this.configurationService.inspect(section, overrides);
+            if (result && (result.userValue || result.workspaceValue || result.workspaceFolderValue)) {
+                switch (target) {
+                    case 2 :
+                        inputs = result.userValue?.inputs;
+                        break;
+                    case 5 :
+                        inputs = result.workspaceValue?.inputs;
+                        break;
+                    default: inputs = result.workspaceFolderValue?.inputs;
+                }
+            }
+            else {
+                const valueResult = this.configurationService.getValue(section, overrides);
+                if (valueResult) {
+                    inputs = valueResult.inputs;
+                }
+            }
+        }
+        const variables = [];
+        this.findVariables(configuration, variables);
+        const variableValues = Object.create(null);
+        for (const variable of variables) {
+            const [type, name] = variable.split(':', 2);
+            let result;
+            switch (type) {
+                case 'input':
+                    result = await this.showUserInput(name, inputs);
+                    break;
+                case 'command': {
+                    const commandId = (variableToCommandMap ? variableToCommandMap[name] : undefined) || name;
+                    result = await this.commandService.executeCommand(commandId, configuration);
+                    if (typeof result !== 'string' && !types.isUndefinedOrNull(result)) {
+                        throw new Error(nls.localize('commandVariable.noStringType', "Cannot substitute command variable '{0}' because command did not return a result of type string.", commandId));
+                    }
+                    break;
+                }
+                default:
+                    if (this._contributedVariables.has(variable)) {
+                        result = await this._contributedVariables.get(variable)();
+                    }
+            }
+            if (typeof result === 'string') {
+                variableValues[variable] = result;
+            }
+            else {
+                return undefined;
+            }
+        }
+        return variableValues;
+    }
+    findVariables(object, variables) {
+        if (typeof object === 'string') {
+            let matches;
+            while ((matches = BaseConfigurationResolverService.INPUT_OR_COMMAND_VARIABLES_PATTERN.exec(object)) !== null) {
+                if (matches.length === 4) {
+                    const command = matches[1];
+                    if (variables.indexOf(command) < 0) {
+                        variables.push(command);
+                    }
+                }
+            }
+            for (const contributed of ( this._contributedVariables.keys())) {
+                if ((variables.indexOf(contributed) < 0) && (object.indexOf('${' + contributed + '}') >= 0)) {
+                    variables.push(contributed);
+                }
+            }
+        }
+        else if (Array.isArray(object)) {
+            for (const value of object) {
+                this.findVariables(value, variables);
+            }
+        }
+        else if (object) {
+            for (const value of ( Object.values(object))) {
+                this.findVariables(value, variables);
+            }
+        }
+    }
+    showUserInput(variable, inputInfos) {
+        if (!inputInfos) {
+            return Promise.reject(( new Error(( nls.localize(
+                'inputVariable.noInputSection',
+                "Variable '{0}' must be defined in an '{1}' section of the debug or task configuration.",
+                variable,
+                'input'
+            )))));
+        }
+        const info = inputInfos.filter(item => item.id === variable).pop();
+        if (info) {
+            const missingAttribute = (attrName) => {
+                throw new Error(nls.localize('inputVariable.missingAttribute', "Input variable '{0}' is of type '{1}' and must include '{2}'.", variable, info.type, attrName));
+            };
+            switch (info.type) {
+                case 'promptString': {
+                    if (!types.isString(info.description)) {
+                        missingAttribute('description');
+                    }
+                    const inputOptions = { prompt: info.description, ignoreFocusLost: true };
+                    if (info.default) {
+                        inputOptions.value = info.default;
+                    }
+                    if (info.password) {
+                        inputOptions.password = info.password;
+                    }
+                    return this.userInputAccessQueue.queue(() => this.quickInputService.input(inputOptions)).then(resolvedInput => {
+                        return resolvedInput;
+                    });
+                }
+                case 'pickString': {
+                    if (!types.isString(info.description)) {
+                        missingAttribute('description');
+                    }
+                    if (Array.isArray(info.options)) {
+                        for (const pickOption of info.options) {
+                            if (!types.isString(pickOption) && !types.isString(pickOption.value)) {
+                                missingAttribute('value');
+                            }
+                        }
+                    }
+                    else {
+                        missingAttribute('options');
+                    }
+                    const picks = ( new Array());
+                    for (const pickOption of info.options) {
+                        const value = types.isString(pickOption) ? pickOption : pickOption.value;
+                        const label = types.isString(pickOption) ? undefined : pickOption.label;
+                        const item = {
+                            label: label ? `${label}: ${value}` : value,
+                            value: value
+                        };
+                        if (value === info.default) {
+                            item.description = ( nls.localize('inputVariable.defaultInputValue', "(Default)"));
+                            picks.unshift(item);
+                        }
+                        else {
+                            picks.push(item);
+                        }
+                    }
+                    const pickOptions = { placeHolder: info.description, matchOnDetail: true, ignoreFocusLost: true };
+                    return this.userInputAccessQueue.queue(() => this.quickInputService.pick(picks, pickOptions, undefined)).then(resolvedInput => {
+                        if (resolvedInput) {
+                            return resolvedInput.value;
+                        }
+                        return undefined;
+                    });
+                }
+                case 'command': {
+                    if (!types.isString(info.command)) {
+                        missingAttribute('command');
+                    }
+                    return this.userInputAccessQueue.queue(() => this.commandService.executeCommand(info.command, info.args)).then(result => {
+                        if (typeof result === 'string' || types.isUndefinedOrNull(result)) {
+                            return result;
+                        }
+                        throw new Error(nls.localize('inputVariable.command.noStringType', "Cannot substitute input variable '{0}' because command '{1}' did not return a result of type string.", variable, info.command));
+                    });
+                }
+                default:
+                    throw new Error(nls.localize('inputVariable.unknownType', "Input variable '{0}' can only be of type 'promptString', 'pickString', or 'command'.", variable));
+            }
+        }
+        return Promise.reject(( new Error(( nls.localize(
+            'inputVariable.undefinedVariable',
+            "Undefined input variable '{0}' encountered. Remove or define '{0}' to continue.",
+            variable
+        )))));
+    }
+}
+BaseConfigurationResolverService.INPUT_OR_COMMAND_VARIABLES_PATTERN = /\${((input|command):(.*?))}/g;
+export { BaseConfigurationResolverService };

package/dist/vscode/vs/workbench/services/configurationResolver/browser/configurationResolverService.js

@@ -0,0 +1,26 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { BaseConfigurationResolverService } from './baseConfigurationResolverService.js';
+import { IEditorService } from '../../editor/common/editorService.js';
+import { IExtensionService } from '../../extensions/common/extensions.js';
+import { IPathService } from '../../path/common/pathService.js';
+let ConfigurationResolverService = class ConfigurationResolverService extends BaseConfigurationResolverService {
+    constructor(editorService, configurationService, commandService, workspaceContextService, quickInputService, labelService, pathService, extensionService) {
+        super({ getAppRoot: () => undefined, getExecPath: () => undefined }, Promise.resolve(Object.create(null)), editorService, configurationService, commandService, workspaceContextService, quickInputService, labelService, pathService, extensionService);
+    }
+};
+ConfigurationResolverService = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IConfigurationService)),
+    ( __param(2, ICommandService)),
+    ( __param(3, IWorkspaceContextService)),
+    ( __param(4, IQuickInputService)),
+    ( __param(5, ILabelService)),
+    ( __param(6, IPathService)),
+    ( __param(7, IExtensionService))
+], ConfigurationResolverService));
+export { ConfigurationResolverService };

package/dist/vscode/vs/workbench/services/configurationResolver/common/configurationResolver.js

@@ -0,0 +1,36 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IConfigurationResolverService = ( createDecorator('configurationResolverService'));
+var VariableKind;
+( (function(VariableKind) {
+    VariableKind["Unknown"] = "unknown";
+    VariableKind["Env"] = "env";
+    VariableKind["Config"] = "config";
+    VariableKind["Command"] = "command";
+    VariableKind["Input"] = "input";
+    VariableKind["ExtensionInstallFolder"] = "extensionInstallFolder";
+    VariableKind["WorkspaceFolder"] = "workspaceFolder";
+    VariableKind["Cwd"] = "cwd";
+    VariableKind["WorkspaceFolderBasename"] = "workspaceFolderBasename";
+    VariableKind["UserHome"] = "userHome";
+    VariableKind["LineNumber"] = "lineNumber";
+    VariableKind["SelectedText"] = "selectedText";
+    VariableKind["File"] = "file";
+    VariableKind["FileWorkspaceFolder"] = "fileWorkspaceFolder";
+    VariableKind["RelativeFile"] = "relativeFile";
+    VariableKind["RelativeFileDirname"] = "relativeFileDirname";
+    VariableKind["FileDirname"] = "fileDirname";
+    VariableKind["FileExtname"] = "fileExtname";
+    VariableKind["FileBasename"] = "fileBasename";
+    VariableKind["FileBasenameNoExtension"] = "fileBasenameNoExtension";
+    VariableKind["FileDirnameBasename"] = "fileDirnameBasename";
+    VariableKind["ExecPath"] = "execPath";
+    VariableKind["ExecInstallFolder"] = "execInstallFolder";
+    VariableKind["PathSeparator"] = "pathSeparator";
+})(VariableKind || (VariableKind = {})));
+class VariableError extends Error {
+    constructor(variable, message) {
+        super(message);
+        this.variable = variable;
+    }
+}
+export { IConfigurationResolverService, VariableError, VariableKind };