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

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

@@ -1,119 +0,0 @@
-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/vscode/src/vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService.js

@@ -1,303 +0,0 @@
-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 {
-    static { this.INPUT_OR_COMMAND_VARIABLES_PATTERN = /\${((input|command):(.*?))}/g; }
-    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
-        )))));
-    }
-}
-export { BaseConfigurationResolverService };

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

@@ -1,26 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/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/vscode/src/vs/workbench/services/configurationResolver/common/configurationResolverSchema.js

@@ -1,174 +0,0 @@
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-const idDescription = ( nls.localize(
-    'JsonSchema.input.id',
-    "The input's id is used to associate an input with a variable of the form ${input:id}."
-));
-const typeDescription = ( nls.localize('JsonSchema.input.type', "The type of user input prompt to use."));
-const descriptionDescription = ( nls.localize(
-    'JsonSchema.input.description',
-    "The description is shown when the user is prompted for input."
-));
-const defaultDescription = ( nls.localize('JsonSchema.input.default', "The default value for the input."));
-const inputsSchema = {
-    definitions: {
-        inputs: {
-            type: 'array',
-            description: ( nls.localize(
-                'JsonSchema.inputs',
-                'User inputs. Used for defining user input prompts, such as free string input or a choice from several options.'
-            )),
-            items: {
-                oneOf: [
-                    {
-                        type: 'object',
-                        required: ['id', 'type', 'description'],
-                        additionalProperties: false,
-                        properties: {
-                            id: {
-                                type: 'string',
-                                description: idDescription
-                            },
-                            type: {
-                                type: 'string',
-                                description: typeDescription,
-                                enum: ['promptString'],
-                                enumDescriptions: [
-                                    ( nls.localize(
-                                        'JsonSchema.input.type.promptString',
-                                        "The 'promptString' type opens an input box to ask the user for input."
-                                    )),
-                                ]
-                            },
-                            description: {
-                                type: 'string',
-                                description: descriptionDescription
-                            },
-                            default: {
-                                type: 'string',
-                                description: defaultDescription
-                            },
-                            password: {
-                                type: 'boolean',
-                                description: ( nls.localize(
-                                    'JsonSchema.input.password',
-                                    "Controls if a password input is shown. Password input hides the typed text."
-                                )),
-                            },
-                        }
-                    },
-                    {
-                        type: 'object',
-                        required: ['id', 'type', 'description', 'options'],
-                        additionalProperties: false,
-                        properties: {
-                            id: {
-                                type: 'string',
-                                description: idDescription
-                            },
-                            type: {
-                                type: 'string',
-                                description: typeDescription,
-                                enum: ['pickString'],
-                                enumDescriptions: [
-                                    ( nls.localize(
-                                        'JsonSchema.input.type.pickString',
-                                        "The 'pickString' type shows a selection list."
-                                    )),
-                                ]
-                            },
-                            description: {
-                                type: 'string',
-                                description: descriptionDescription
-                            },
-                            default: {
-                                type: 'string',
-                                description: defaultDescription
-                            },
-                            options: {
-                                type: 'array',
-                                description: ( nls.localize(
-                                    'JsonSchema.input.options',
-                                    "An array of strings that defines the options for a quick pick."
-                                )),
-                                items: {
-                                    oneOf: [
-                                        {
-                                            type: 'string'
-                                        },
-                                        {
-                                            type: 'object',
-                                            required: ['value'],
-                                            additionalProperties: false,
-                                            properties: {
-                                                label: {
-                                                    type: 'string',
-                                                    description: ( nls.localize('JsonSchema.input.pickString.optionLabel', "Label for the option."))
-                                                },
-                                                value: {
-                                                    type: 'string',
-                                                    description: ( nls.localize('JsonSchema.input.pickString.optionValue', "Value for the option."))
-                                                }
-                                            }
-                                        }
-                                    ]
-                                }
-                            }
-                        }
-                    },
-                    {
-                        type: 'object',
-                        required: ['id', 'type', 'command'],
-                        additionalProperties: false,
-                        properties: {
-                            id: {
-                                type: 'string',
-                                description: idDescription
-                            },
-                            type: {
-                                type: 'string',
-                                description: typeDescription,
-                                enum: ['command'],
-                                enumDescriptions: [
-                                    ( nls.localize('JsonSchema.input.type.command', "The 'command' type executes a command.")),
-                                ]
-                            },
-                            command: {
-                                type: 'string',
-                                description: ( nls.localize(
-                                    'JsonSchema.input.command.command',
-                                    "The command to execute for this input variable."
-                                ))
-                            },
-                            args: {
-                                oneOf: [
-                                    {
-                                        type: 'object',
-                                        description: ( nls.localize(
-                                            'JsonSchema.input.command.args',
-                                            "Optional arguments passed to the command."
-                                        ))
-                                    },
-                                    {
-                                        type: 'array',
-                                        description: ( nls.localize(
-                                            'JsonSchema.input.command.args',
-                                            "Optional arguments passed to the command."
-                                        ))
-                                    },
-                                    {
-                                        type: 'string',
-                                        description: ( nls.localize(
-                                            'JsonSchema.input.command.args',
-                                            "Optional arguments passed to the command."
-                                        ))
-                                    }
-                                ]
-                            }
-                        }
-                    }
-                ]
-            }
-        }
-    }
-};
-export { inputsSchema };

package/vscode/src/vs/workbench/services/configurationResolver/common/configurationResolverUtils.js

@@ -1,10 +0,0 @@
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-function applyDeprecatedVariableMessage(schema) {
-    schema.pattern = schema.pattern || '^(?!.*\\$\\{(env|config|command)\\.)';
-    schema.patternErrorMessage = schema.patternErrorMessage ||
-        ( nls.localize(
-         'deprecatedVariables',
-         "'env.', 'config.' and 'command.' are deprecated, use 'env:', 'config:' and 'command:' instead."
-        ));
-}
-export { applyDeprecatedVariableMessage };