@codingame/monaco-vscode-api 1.78.4-next.3 → 1.78.4

package/dist/textEditor.js

@@ -1,34 +0,0 @@
-import { ACTIVE_GROUP, SIDE_GROUP, preferredSideBySideGroupDirection } from './missing-services.js';
-var EditorActivation;
-( (function(EditorActivation) {
-    EditorActivation[EditorActivation["ACTIVATE"] = 1] = "ACTIVATE";
-    EditorActivation[EditorActivation["RESTORE"] = 2] = "RESTORE";
-    EditorActivation[EditorActivation["PRESERVE"] = 3] = "PRESERVE";
-})(EditorActivation || (EditorActivation = {})));
-var EditorResolution;
-( (function(EditorResolution) {
-    EditorResolution[EditorResolution["PICK"] = 0] = "PICK";
-    EditorResolution[EditorResolution["EXCLUSIVE_ONLY"] = 1] = "EXCLUSIVE_ONLY";
-})(EditorResolution || (EditorResolution = {})));
-function columnToEditorGroup(editorGroupService, configurationService, column = ACTIVE_GROUP) {
-    if (column === ACTIVE_GROUP || column === SIDE_GROUP) {
-        return column;
-    }
-    let groupInColumn = editorGroupService.getGroups(2 )[column];
-    if (!groupInColumn && column < 9) {
-        for (let i = 0; i <= column; i++) {
-            const editorGroups = editorGroupService.getGroups(2 );
-            if (!editorGroups[i]) {
-                editorGroupService.addGroup(editorGroups[i - 1], preferredSideBySideGroupDirection(configurationService));
-            }
-        }
-        groupInColumn = editorGroupService.getGroups(2 )[column];
-    }
-    return groupInColumn?.id ?? SIDE_GROUP;
-}
-function editorGroupToColumn(editorGroupService, editorGroup) {
-    const group = (typeof editorGroup === 'number') ? editorGroupService.getGroup(editorGroup) : editorGroup;
-    return editorGroupService.getGroups(2 ).indexOf(group ?? editorGroupService.activeGroup);
-}
-class AbstractTextEditor {}
-export { AbstractTextEditor, EditorActivation, EditorResolution, columnToEditorGroup, editorGroupToColumn };

package/dist/variableResolver.js

@@ -1,586 +0,0 @@
-import { Range$1, replaceAsync, VariableKind, VariableError, isAbsolute } from './missing-services.js';
-import { equalsIgnoreCase } from 'monaco-editor/esm/vs/base/common/strings.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
-import { deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { isWindows, isMacintosh, isLinux } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { isString, isObject, isUndefinedOrNull } from 'monaco-editor/esm/vs/base/common/types.js';
-import { sep, basename, dirname, extname, relative } from 'monaco-editor/esm/vs/base/common/path.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { normalizeDriveLetter } from 'monaco-editor/esm/vs/base/common/labels.js';
-import { cwd } from 'monaco-editor/esm/vs/base/common/process.js';
-const _formatPIIRegexp = /{([^}]+)}/g;
-function formatPII(value, excludePII, args) {
-    return value.replace(_formatPIIRegexp, function (match, group) {
-        if (excludePII && group.length > 0 && group[0] !== '_') {
-            return match;
-        }
-        return args && args.hasOwnProperty(group) ?
-            args[group] :
-            match;
-    });
-}
-function filterExceptionsFromTelemetry(data) {
-    const output = {};
-    for (const key of ( (Object.keys(data)))) {
-        if (!key.startsWith('!')) {
-            output[key] = data[key];
-        }
-    }
-    return output;
-}
-function isSessionAttach(session) {
-    return session.configuration.request === 'attach' && !getExtensionHostDebugSession(session) && (!session.parentSession || isSessionAttach(session.parentSession));
-}
-function getExtensionHostDebugSession(session) {
-    let type = session.configuration.type;
-    if (!type) {
-        return;
-    }
-    if (type === 'vslsShare') {
-        type = session.configuration.adapterProxy.configuration.type;
-    }
-    if (equalsIgnoreCase(type, 'extensionhost') || equalsIgnoreCase(type, 'pwa-extensionhost')) {
-        return session;
-    }
-    return session.parentSession ? getExtensionHostDebugSession(session.parentSession) : undefined;
-}
-function isDebuggerMainContribution(dbg) {
-    return dbg.type && (dbg.label || dbg.program || dbg.runtime);
-}
-function getExactExpressionStartAndEnd(lineContent, looseStart, looseEnd) {
-    let matchingExpression = undefined;
-    let startOffset = 0;
-    const expression = /([^()\[\]{}<>\s+\-/%~#^;=|,`!]|\->)+/g;
-    let result = null;
-    while (result = expression.exec(lineContent)) {
-        const start = result.index + 1;
-        const end = start + result[0].length;
-        if (start <= looseStart && end >= looseEnd) {
-            matchingExpression = result[0];
-            startOffset = start;
-            break;
-        }
-    }
-    if (matchingExpression) {
-        const subExpression = /\w+/g;
-        let subExpressionResult = null;
-        while (subExpressionResult = subExpression.exec(matchingExpression)) {
-            const subEnd = subExpressionResult.index + 1 + startOffset + subExpressionResult[0].length;
-            if (subEnd >= looseEnd) {
-                break;
-            }
-        }
-        if (subExpressionResult) {
-            matchingExpression = matchingExpression.substring(0, subExpression.lastIndex);
-        }
-    }
-    return matchingExpression ?
-        { start: startOffset, end: startOffset + matchingExpression.length - 1 } :
-        { start: 0, end: 0 };
-}
-async function getEvaluatableExpressionAtPosition(languageFeaturesService, model, position, token) {
-    if (languageFeaturesService.evaluatableExpressionProvider.has(model)) {
-        const supports = languageFeaturesService.evaluatableExpressionProvider.ordered(model);
-        const results = coalesce(await Promise.all(( (supports.map(async (support) => {
-            try {
-                return await support.provideEvaluatableExpression(model, position, token ?? CancellationToken.None);
-            }
-            catch (err) {
-                return undefined;
-            }
-        })))));
-        if (results.length > 0) {
-            let matchingExpression = results[0].expression;
-            const range = results[0].range;
-            if (!matchingExpression) {
-                const lineContent = model.getLineContent(position.lineNumber);
-                matchingExpression = lineContent.substring(range.startColumn - 1, range.endColumn - 1);
-            }
-            return { range, matchingExpression };
-        }
-    }
-    else {
-        const lineContent = model.getLineContent(position.lineNumber);
-        const { start, end } = getExactExpressionStartAndEnd(lineContent, position.column, position.column);
-        const matchingExpression = lineContent.substring(start - 1, end);
-        return {
-            matchingExpression,
-            range: ( (new Range$1(
-                position.lineNumber,
-                start,
-                position.lineNumber,
-                start + matchingExpression.length
-            )))
-        };
-    }
-    return null;
-}
-const _schemePattern = /^[a-zA-Z][a-zA-Z0-9\+\-\.]+:/;
-function isUri(s) {
-    return !!(s && s.match(_schemePattern));
-}
-function stringToUri(source) {
-    if (typeof source.path === 'string') {
-        if (typeof source.sourceReference === 'number' && source.sourceReference > 0) ;
-        else {
-            if (isUri(source.path)) {
-                return ( URI.parse(source.path));
-            }
-            else {
-                if (isAbsolute(source.path)) {
-                    return URI.file(source.path);
-                }
-            }
-        }
-    }
-    return source.path;
-}
-function uriToString(source) {
-    if (typeof source.path === 'object') {
-        const u = URI.revive(source.path);
-        if (u) {
-            if (u.scheme === Schemas.file) {
-                return u.fsPath;
-            }
-            else {
-                return (
-                     (u.toString())
-                );
-            }
-        }
-    }
-    return source.path;
-}
-function convertToDAPaths(message, toUri) {
-    const fixPath = toUri ? stringToUri : uriToString;
-    const msg = deepClone(message);
-    convertPaths(msg, (toDA, source) => {
-        if (toDA && source) {
-            source.path = fixPath(source);
-        }
-    });
-    return msg;
-}
-function convertToVSCPaths(message, toUri) {
-    const fixPath = toUri ? stringToUri : uriToString;
-    const msg = deepClone(message);
-    convertPaths(msg, (toDA, source) => {
-        if (!toDA && source) {
-            source.path = fixPath(source);
-        }
-    });
-    return msg;
-}
-function convertPaths(msg, fixSourcePath) {
-    switch (msg.type) {
-        case 'event': {
-            const event = msg;
-            switch (event.event) {
-                case 'output':
-                    fixSourcePath(false, event.body.source);
-                    break;
-                case 'loadedSource':
-                    fixSourcePath(false, event.body.source);
-                    break;
-                case 'breakpoint':
-                    fixSourcePath(false, event.body.breakpoint.source);
-                    break;
-            }
-            break;
-        }
-        case 'request': {
-            const request = msg;
-            switch (request.command) {
-                case 'setBreakpoints':
-                    fixSourcePath(true, request.arguments.source);
-                    break;
-                case 'breakpointLocations':
-                    fixSourcePath(true, request.arguments.source);
-                    break;
-                case 'source':
-                    fixSourcePath(true, request.arguments.source);
-                    break;
-                case 'gotoTargets':
-                    fixSourcePath(true, request.arguments.source);
-                    break;
-                case 'launchVSCode':
-                    request.arguments.args.forEach((arg) => fixSourcePath(false, arg));
-                    break;
-            }
-            break;
-        }
-        case 'response': {
-            const response = msg;
-            if (response.success && response.body) {
-                switch (response.command) {
-                    case 'stackTrace':
-                        response.body.stackFrames.forEach(frame => fixSourcePath(false, frame.source));
-                        break;
-                    case 'loadedSources':
-                        response.body.sources.forEach(source => fixSourcePath(false, source));
-                        break;
-                    case 'scopes':
-                        response.body.scopes.forEach(scope => fixSourcePath(false, scope.source));
-                        break;
-                    case 'setFunctionBreakpoints':
-                        response.body.breakpoints.forEach(bp => fixSourcePath(false, bp.source));
-                        break;
-                    case 'setBreakpoints':
-                        response.body.breakpoints.forEach(bp => fixSourcePath(false, bp.source));
-                        break;
-                    case 'disassemble':
-                        {
-                            const di = response;
-                            di.body?.instructions.forEach(di => fixSourcePath(false, di.location));
-                        }
-                        break;
-                }
-            }
-            break;
-        }
-    }
-}
-function getVisibleAndSorted(array) {
-    return array.filter(config => !config.presentation?.hidden).sort((first, second) => {
-        if (!first.presentation) {
-            if (!second.presentation) {
-                return 0;
-            }
-            return 1;
-        }
-        if (!second.presentation) {
-            return -1;
-        }
-        if (!first.presentation.group) {
-            if (!second.presentation.group) {
-                return compareOrders(first.presentation.order, second.presentation.order);
-            }
-            return 1;
-        }
-        if (!second.presentation.group) {
-            return -1;
-        }
-        if (first.presentation.group !== second.presentation.group) {
-            return first.presentation.group.localeCompare(second.presentation.group);
-        }
-        return compareOrders(first.presentation.order, second.presentation.order);
-    });
-}
-function compareOrders(first, second) {
-    if (typeof first !== 'number') {
-        if (typeof second !== 'number') {
-            return 0;
-        }
-        return 1;
-    }
-    if (typeof second !== 'number') {
-        return -1;
-    }
-    return first - second;
-}
-async function saveAllBeforeDebugStart(configurationService, editorService) {
-    const saveBeforeStartConfig = configurationService.getValue('debug.saveBeforeStart', { overrideIdentifier: editorService.activeTextEditorLanguageId });
-    if (saveBeforeStartConfig !== 'none') {
-        await editorService.saveAll();
-        if (saveBeforeStartConfig === 'allEditorsInActiveGroup') {
-            const activeEditor = editorService.activeEditorPane;
-            if (activeEditor && activeEditor.input.resource?.scheme === Schemas.untitled) {
-                await editorService.save({ editor: activeEditor.input, groupId: activeEditor.group.id });
-            }
-        }
-    }
-    await configurationService.reloadConfiguration();
-}
-class AbstractVariableResolverService {
-    constructor(_context, _labelService, _userHomePromise, _envVariablesPromise) {
-        this._contributedVariables = ( (new Map()));
-        this._context = _context;
-        this._labelService = _labelService;
-        this._userHomePromise = _userHomePromise;
-        if (_envVariablesPromise) {
-            this._envVariablesPromise = _envVariablesPromise.then(envVariables => {
-                return this.prepareEnv(envVariables);
-            });
-        }
-    }
-    prepareEnv(envVariables) {
-        if (isWindows) {
-            const ev = Object.create(null);
-            ( (Object.keys(envVariables))).forEach(key => {
-                ev[key.toLowerCase()] = envVariables[key];
-            });
-            return ev;
-        }
-        return envVariables;
-    }
-    resolveWithEnvironment(environment, root, value) {
-        return this.recursiveResolve({ env: this.prepareEnv(environment), userHome: undefined }, root ? root.uri : undefined, value);
-    }
-    async resolveAsync(root, value) {
-        const environment = {
-            env: await this._envVariablesPromise,
-            userHome: await this._userHomePromise
-        };
-        return this.recursiveResolve(environment, root ? root.uri : undefined, value);
-    }
-    async resolveAnyBase(workspaceFolder, config, commandValueMapping, resolvedVariables) {
-        const result = deepClone(config);
-        if (isWindows && result.windows) {
-            ( (Object.keys(result.windows))).forEach(key => result[key] = result.windows[key]);
-        }
-        else if (isMacintosh && result.osx) {
-            ( (Object.keys(result.osx))).forEach(key => result[key] = result.osx[key]);
-        }
-        else if (isLinux && result.linux) {
-            ( (Object.keys(result.linux))).forEach(key => result[key] = result.linux[key]);
-        }
-        delete result.windows;
-        delete result.osx;
-        delete result.linux;
-        const environmentPromises = {
-            env: await this._envVariablesPromise,
-            userHome: await this._userHomePromise
-        };
-        return this.recursiveResolve(environmentPromises, workspaceFolder ? workspaceFolder.uri : undefined, result, commandValueMapping, resolvedVariables);
-    }
-    async resolveAnyAsync(workspaceFolder, config, commandValueMapping) {
-        return this.resolveAnyBase(workspaceFolder, config, commandValueMapping);
-    }
-    async resolveAnyMap(workspaceFolder, config, commandValueMapping) {
-        const resolvedVariables = ( (new Map()));
-        const newConfig = await this.resolveAnyBase(workspaceFolder, config, commandValueMapping, resolvedVariables);
-        return { newConfig, resolvedVariables };
-    }
-    resolveWithInteractionReplace(folder, config, section, variables) {
-        throw new Error('resolveWithInteractionReplace not implemented.');
-    }
-    resolveWithInteraction(folder, config, section, variables) {
-        throw new Error('resolveWithInteraction not implemented.');
-    }
-    contributeVariable(variable, resolution) {
-        if (this._contributedVariables.has(variable)) {
-            throw new Error('Variable ' + variable + ' is contributed twice.');
-        }
-        else {
-            this._contributedVariables.set(variable, resolution);
-        }
-    }
-    async recursiveResolve(environment, folderUri, value, commandValueMapping, resolvedVariables) {
-        if (isString(value)) {
-            return this.resolveString(environment, folderUri, value, commandValueMapping, resolvedVariables);
-        }
-        else if (Array.isArray(value)) {
-            return Promise.all(( (value.map(
-                s => this.recursiveResolve(environment, folderUri, s, commandValueMapping, resolvedVariables)
-            ))));
-        }
-        else if (isObject(value)) {
-            const result = Object.create(null);
-            const replaced = await Promise.all(( (( (Object.keys(value))).map(async (key) => {
-                const replaced = await this.resolveString(environment, folderUri, key, commandValueMapping, resolvedVariables);
-                return [replaced, await this.recursiveResolve(environment, folderUri, value[key], commandValueMapping, resolvedVariables)];
-            }))));
-            for (const [key, value] of replaced) {
-                result[key] = value;
-            }
-            return result;
-        }
-        return value;
-    }
-    resolveString(environment, folderUri, value, commandValueMapping, resolvedVariables) {
-        return replaceAsync(value, AbstractVariableResolverService.VARIABLE_REGEXP, async (match, variable) => {
-            if (variable.includes(AbstractVariableResolverService.VARIABLE_LHS)) {
-                return match;
-            }
-            let resolvedValue = await this.evaluateSingleVariable(environment, match, variable, folderUri, commandValueMapping);
-            resolvedVariables?.set(variable, resolvedValue);
-            if ((resolvedValue !== match) && isString(resolvedValue) && resolvedValue.match(AbstractVariableResolverService.VARIABLE_REGEXP)) {
-                resolvedValue = await this.resolveString(environment, folderUri, resolvedValue, commandValueMapping, resolvedVariables);
-            }
-            return resolvedValue;
-        });
-    }
-    fsPath(displayUri) {
-        return this._labelService ? this._labelService.getUriLabel(displayUri, { noPrefix: true }) : displayUri.fsPath;
-    }
-    async evaluateSingleVariable(environment, match, variable, folderUri, commandValueMapping) {
-        let argument;
-        const parts = variable.split(':');
-        if (parts.length > 1) {
-            variable = parts[0];
-            argument = parts[1];
-        }
-        const getFilePath = (variableKind) => {
-            const filePath = this._context.getFilePath();
-            if (filePath) {
-                return normalizeDriveLetter(filePath);
-            }
-            throw new VariableError(variableKind, (localize('canNotResolveFile', "Variable {0} can not be resolved. Please open an editor.", match)));
-        };
-        const getFolderPathForFile = (variableKind) => {
-            const filePath = getFilePath(variableKind);
-            if (this._context.getWorkspaceFolderPathForFile) {
-                const folderPath = this._context.getWorkspaceFolderPathForFile();
-                if (folderPath) {
-                    return normalizeDriveLetter(folderPath);
-                }
-            }
-            throw new VariableError(variableKind, localize('canNotResolveFolderForFile', "Variable {0}: can not find workspace folder of '{1}'.", match, basename(filePath)));
-        };
-        const getFolderUri = (variableKind) => {
-            if (argument) {
-                const folder = this._context.getFolderUri(argument);
-                if (folder) {
-                    return folder;
-                }
-                throw new VariableError(variableKind, localize('canNotFindFolder', "Variable {0} can not be resolved. No such folder '{1}'.", match, argument));
-            }
-            if (folderUri) {
-                return folderUri;
-            }
-            if (this._context.getWorkspaceFolderCount() > 1) {
-                throw new VariableError(variableKind, localize('canNotResolveWorkspaceFolderMultiRoot', "Variable {0} can not be resolved in a multi folder workspace. Scope this variable using ':' and a workspace folder name.", match));
-            }
-            throw new VariableError(variableKind, localize('canNotResolveWorkspaceFolder', "Variable {0} can not be resolved. Please open a folder.", match));
-        };
-        switch (variable) {
-            case 'env':
-                if (argument) {
-                    if (environment.env) {
-                        const env = environment.env[isWindows ? argument.toLowerCase() : argument];
-                        if (isString(env)) {
-                            return env;
-                        }
-                    }
-                    return '';
-                }
-                throw new VariableError(VariableKind.Env, localize('missingEnvVarName', "Variable {0} can not be resolved because no environment variable name is given.", match));
-            case 'config':
-                if (argument) {
-                    const config = this._context.getConfigurationValue(folderUri, argument);
-                    if (isUndefinedOrNull(config)) {
-                        throw new VariableError(VariableKind.Config, localize('configNotFound', "Variable {0} can not be resolved because setting '{1}' not found.", match, argument));
-                    }
-                    if (isObject(config)) {
-                        throw new VariableError(VariableKind.Config, localize('configNoString', "Variable {0} can not be resolved because '{1}' is a structured value.", match, argument));
-                    }
-                    return config;
-                }
-                throw new VariableError(VariableKind.Config, localize('missingConfigName', "Variable {0} can not be resolved because no settings name is given.", match));
-            case 'command':
-                return this.resolveFromMap(VariableKind.Command, match, argument, commandValueMapping, 'command');
-            case 'input':
-                return this.resolveFromMap(VariableKind.Input, match, argument, commandValueMapping, 'input');
-            case 'extensionInstallFolder':
-                if (argument) {
-                    const ext = await this._context.getExtension(argument);
-                    if (!ext) {
-                        throw new VariableError(VariableKind.ExtensionInstallFolder, localize('extensionNotInstalled', "Variable {0} can not be resolved because the extension {1} is not installed.", match, argument));
-                    }
-                    return this.fsPath(ext.extensionLocation);
-                }
-                throw new VariableError(VariableKind.ExtensionInstallFolder, localize('missingExtensionName', "Variable {0} can not be resolved because no extension name is given.", match));
-            default: {
-                switch (variable) {
-                    case 'workspaceRoot':
-                    case 'workspaceFolder':
-                        return normalizeDriveLetter(this.fsPath(getFolderUri(VariableKind.WorkspaceFolder)));
-                    case 'cwd':
-                        return ((folderUri || argument) ? normalizeDriveLetter(this.fsPath(getFolderUri(VariableKind.Cwd))) : cwd());
-                    case 'workspaceRootFolderName':
-                    case 'workspaceFolderBasename':
-                        return normalizeDriveLetter(basename(this.fsPath(getFolderUri(VariableKind.WorkspaceFolderBasename))));
-                    case 'userHome': {
-                        if (environment.userHome) {
-                            return environment.userHome;
-                        }
-                        throw new VariableError(VariableKind.UserHome, localize('canNotResolveUserHome', "Variable {0} can not be resolved. UserHome path is not defined", match));
-                    }
-                    case 'lineNumber': {
-                        const lineNumber = this._context.getLineNumber();
-                        if (lineNumber) {
-                            return lineNumber;
-                        }
-                        throw new VariableError(VariableKind.LineNumber, localize('canNotResolveLineNumber', "Variable {0} can not be resolved. Make sure to have a line selected in the active editor.", match));
-                    }
-                    case 'selectedText': {
-                        const selectedText = this._context.getSelectedText();
-                        if (selectedText) {
-                            return selectedText;
-                        }
-                        throw new VariableError(VariableKind.SelectedText, localize('canNotResolveSelectedText', "Variable {0} can not be resolved. Make sure to have some text selected in the active editor.", match));
-                    }
-                    case 'file':
-                        return getFilePath(VariableKind.File);
-                    case 'fileWorkspaceFolder':
-                        return getFolderPathForFile(VariableKind.FileWorkspaceFolder);
-                    case 'relativeFile':
-                        if (folderUri || argument) {
-                            return relative(this.fsPath(getFolderUri(VariableKind.RelativeFile)), getFilePath(VariableKind.RelativeFile));
-                        }
-                        return getFilePath(VariableKind.RelativeFile);
-                    case 'relativeFileDirname': {
-                        const dirname$1 = dirname(getFilePath(VariableKind.RelativeFileDirname));
-                        if (folderUri || argument) {
-                            const relative$1 = relative(this.fsPath(getFolderUri(VariableKind.RelativeFileDirname)), dirname$1);
-                            return relative$1.length === 0 ? '.' : relative$1;
-                        }
-                        return dirname$1;
-                    }
-                    case 'fileDirname':
-                        return dirname(getFilePath(VariableKind.FileDirname));
-                    case 'fileExtname':
-                        return extname(getFilePath(VariableKind.FileExtname));
-                    case 'fileBasename':
-                        return basename(getFilePath(VariableKind.FileBasename));
-                    case 'fileBasenameNoExtension': {
-                        const basename$1 = basename(getFilePath(VariableKind.FileBasenameNoExtension));
-                        return (basename$1.slice(0, basename$1.length - extname(basename$1).length));
-                    }
-                    case 'fileDirnameBasename':
-                        return basename(dirname(getFilePath(VariableKind.FileDirnameBasename)));
-                    case 'execPath': {
-                        const ep = this._context.getExecPath();
-                        if (ep) {
-                            return ep;
-                        }
-                        return match;
-                    }
-                    case 'execInstallFolder': {
-                        const ar = this._context.getAppRoot();
-                        if (ar) {
-                            return ar;
-                        }
-                        return match;
-                    }
-                    case 'pathSeparator':
-                        return sep;
-                    default:
-                        try {
-                            const key = argument ? `${variable}:${argument}` : variable;
-                            return this.resolveFromMap(VariableKind.Unknown, match, key, commandValueMapping, undefined);
-                        }
-                        catch (error) {
-                            return match;
-                        }
-                }
-            }
-        }
-    }
-    resolveFromMap(variableKind, match, argument, commandValueMapping, prefix) {
-        if (argument && commandValueMapping) {
-            const v = (prefix === undefined) ? commandValueMapping[argument] : commandValueMapping[prefix + ':' + argument];
-            if (typeof v === 'string') {
-                return v;
-            }
-            throw new VariableError(variableKind, localize('noValueForCommand', "Variable {0} can not be resolved because the command has no value.", match));
-        }
-        return match;
-    }
-}
-AbstractVariableResolverService.VARIABLE_LHS = '${';
-AbstractVariableResolverService.VARIABLE_REGEXP = /\$\{(.*?)\}/g;
-export { AbstractVariableResolverService, convertToDAPaths, convertToVSCPaths, filterExceptionsFromTelemetry, formatPII, getEvaluatableExpressionAtPosition, getExtensionHostDebugSession, getVisibleAndSorted, isDebuggerMainContribution, isSessionAttach, isUri, saveAllBeforeDebugStart };