@codingame/monaco-vscode-api 1.76.1 → 1.76.3-next.0

package/dist/variableResolver.js

@@ -0,0 +1,1711 @@
+import { R as Range } from './polyfill.js';
+import { cwd, env, platform } from 'monaco-editor/esm/vs/base/common/process.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 { cn as replaceAsync, co as VariableKind, cp as VariableError } from './missing-services.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';
+const CHAR_UPPERCASE_A = 65;
+const CHAR_LOWERCASE_A = 97;
+const CHAR_UPPERCASE_Z = 90;
+const CHAR_LOWERCASE_Z = 122;
+const CHAR_DOT = 46;
+const CHAR_FORWARD_SLASH = 47;
+const CHAR_BACKWARD_SLASH = 92;
+const CHAR_COLON = 58;
+const CHAR_QUESTION_MARK = 63;
+class ErrorInvalidArgType extends Error {
+    constructor(name, expected, actual) {
+        let determiner;
+        if (typeof expected === 'string' && expected.indexOf('not ') === 0) {
+            determiner = 'must not be';
+            expected = expected.replace(/^not /, '');
+        }
+        else {
+            determiner = 'must be';
+        }
+        const type = name.indexOf('.') !== -1 ? 'property' : 'argument';
+        let msg = `The "${name}" ${type} ${determiner} of type ${expected}`;
+        msg += `. Received type ${typeof actual}`;
+        super(msg);
+        this.code = 'ERR_INVALID_ARG_TYPE';
+    }
+}
+function validateObject(pathObject, name) {
+    if (pathObject === null || typeof pathObject !== 'object') {
+        throw new ErrorInvalidArgType(name, 'Object', pathObject);
+    }
+}
+function validateString(value, name) {
+    if (typeof value !== 'string') {
+        throw new ErrorInvalidArgType(name, 'string', value);
+    }
+}
+const platformIsWin32 = (platform === 'win32');
+function isPathSeparator(code) {
+    return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+}
+function isPosixPathSeparator(code) {
+    return code === CHAR_FORWARD_SLASH;
+}
+function isWindowsDeviceRoot(code) {
+    return (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z) ||
+        (code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z);
+}
+function normalizeString(path, allowAboveRoot, separator, isPathSeparator) {
+    let res = '';
+    let lastSegmentLength = 0;
+    let lastSlash = -1;
+    let dots = 0;
+    let code = 0;
+    for (let i = 0; i <= path.length; ++i) {
+        if (i < path.length) {
+            code = path.charCodeAt(i);
+        }
+        else if (isPathSeparator(code)) {
+            break;
+        }
+        else {
+            code = CHAR_FORWARD_SLASH;
+        }
+        if (isPathSeparator(code)) {
+            if (lastSlash === i - 1 || dots === 1) ;
+            else if (dots === 2) {
+                if (res.length < 2 || lastSegmentLength !== 2 ||
+                    res.charCodeAt(res.length - 1) !== CHAR_DOT ||
+                    res.charCodeAt(res.length - 2) !== CHAR_DOT) {
+                    if (res.length > 2) {
+                        const lastSlashIndex = res.lastIndexOf(separator);
+                        if (lastSlashIndex === -1) {
+                            res = '';
+                            lastSegmentLength = 0;
+                        }
+                        else {
+                            res = res.slice(0, lastSlashIndex);
+                            lastSegmentLength = res.length - 1 - res.lastIndexOf(separator);
+                        }
+                        lastSlash = i;
+                        dots = 0;
+                        continue;
+                    }
+                    else if (res.length !== 0) {
+                        res = '';
+                        lastSegmentLength = 0;
+                        lastSlash = i;
+                        dots = 0;
+                        continue;
+                    }
+                }
+                if (allowAboveRoot) {
+                    res += res.length > 0 ? `${separator}..` : '..';
+                    lastSegmentLength = 2;
+                }
+            }
+            else {
+                if (res.length > 0) {
+                    res += `${separator}${path.slice(lastSlash + 1, i)}`;
+                }
+                else {
+                    res = path.slice(lastSlash + 1, i);
+                }
+                lastSegmentLength = i - lastSlash - 1;
+            }
+            lastSlash = i;
+            dots = 0;
+        }
+        else if (code === CHAR_DOT && dots !== -1) {
+            ++dots;
+        }
+        else {
+            dots = -1;
+        }
+    }
+    return res;
+}
+function _format(sep, pathObject) {
+    validateObject(pathObject, 'pathObject');
+    const dir = pathObject.dir || pathObject.root;
+    const base = pathObject.base ||
+        `${pathObject.name || ''}${pathObject.ext || ''}`;
+    if (!dir) {
+        return base;
+    }
+    return dir === pathObject.root ? `${dir}${base}` : `${dir}${sep}${base}`;
+}
+const win32 = {
+    resolve(...pathSegments) {
+        let resolvedDevice = '';
+        let resolvedTail = '';
+        let resolvedAbsolute = false;
+        for (let i = pathSegments.length - 1; i >= -1; i--) {
+            let path;
+            if (i >= 0) {
+                path = pathSegments[i];
+                validateString(path, 'path');
+                if (path.length === 0) {
+                    continue;
+                }
+            }
+            else if (resolvedDevice.length === 0) {
+                path = cwd();
+            }
+            else {
+                path = env[`=${resolvedDevice}`] || cwd();
+                if (path === undefined ||
+                    (path.slice(0, 2).toLowerCase() !== resolvedDevice.toLowerCase() &&
+                        path.charCodeAt(2) === CHAR_BACKWARD_SLASH)) {
+                    path = `${resolvedDevice}\\`;
+                }
+            }
+            const len = path.length;
+            let rootEnd = 0;
+            let device = '';
+            let isAbsolute = false;
+            const code = path.charCodeAt(0);
+            if (len === 1) {
+                if (isPathSeparator(code)) {
+                    rootEnd = 1;
+                    isAbsolute = true;
+                }
+            }
+            else if (isPathSeparator(code)) {
+                isAbsolute = true;
+                if (isPathSeparator(path.charCodeAt(1))) {
+                    let j = 2;
+                    let last = j;
+                    while (j < len && !isPathSeparator(path.charCodeAt(j))) {
+                        j++;
+                    }
+                    if (j < len && j !== last) {
+                        const firstPart = path.slice(last, j);
+                        last = j;
+                        while (j < len && isPathSeparator(path.charCodeAt(j))) {
+                            j++;
+                        }
+                        if (j < len && j !== last) {
+                            last = j;
+                            while (j < len && !isPathSeparator(path.charCodeAt(j))) {
+                                j++;
+                            }
+                            if (j === len || j !== last) {
+                                device = `\\\\${firstPart}\\${path.slice(last, j)}`;
+                                rootEnd = j;
+                            }
+                        }
+                    }
+                }
+                else {
+                    rootEnd = 1;
+                }
+            }
+            else if (isWindowsDeviceRoot(code) &&
+                path.charCodeAt(1) === CHAR_COLON) {
+                device = path.slice(0, 2);
+                rootEnd = 2;
+                if (len > 2 && isPathSeparator(path.charCodeAt(2))) {
+                    isAbsolute = true;
+                    rootEnd = 3;
+                }
+            }
+            if (device.length > 0) {
+                if (resolvedDevice.length > 0) {
+                    if (device.toLowerCase() !== resolvedDevice.toLowerCase()) {
+                        continue;
+                    }
+                }
+                else {
+                    resolvedDevice = device;
+                }
+            }
+            if (resolvedAbsolute) {
+                if (resolvedDevice.length > 0) {
+                    break;
+                }
+            }
+            else {
+                resolvedTail = `${path.slice(rootEnd)}\\${resolvedTail}`;
+                resolvedAbsolute = isAbsolute;
+                if (isAbsolute && resolvedDevice.length > 0) {
+                    break;
+                }
+            }
+        }
+        resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, '\\', isPathSeparator);
+        return resolvedAbsolute ?
+            `${resolvedDevice}\\${resolvedTail}` :
+            `${resolvedDevice}${resolvedTail}` || '.';
+    },
+    normalize(path) {
+        validateString(path, 'path');
+        const len = path.length;
+        if (len === 0) {
+            return '.';
+        }
+        let rootEnd = 0;
+        let device;
+        let isAbsolute = false;
+        const code = path.charCodeAt(0);
+        if (len === 1) {
+            return isPosixPathSeparator(code) ? '\\' : path;
+        }
+        if (isPathSeparator(code)) {
+            isAbsolute = true;
+            if (isPathSeparator(path.charCodeAt(1))) {
+                let j = 2;
+                let last = j;
+                while (j < len && !isPathSeparator(path.charCodeAt(j))) {
+                    j++;
+                }
+                if (j < len && j !== last) {
+                    const firstPart = path.slice(last, j);
+                    last = j;
+                    while (j < len && isPathSeparator(path.charCodeAt(j))) {
+                        j++;
+                    }
+                    if (j < len && j !== last) {
+                        last = j;
+                        while (j < len && !isPathSeparator(path.charCodeAt(j))) {
+                            j++;
+                        }
+                        if (j === len) {
+                            return `\\\\${firstPart}\\${path.slice(last)}\\`;
+                        }
+                        if (j !== last) {
+                            device = `\\\\${firstPart}\\${path.slice(last, j)}`;
+                            rootEnd = j;
+                        }
+                    }
+                }
+            }
+            else {
+                rootEnd = 1;
+            }
+        }
+        else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {
+            device = path.slice(0, 2);
+            rootEnd = 2;
+            if (len > 2 && isPathSeparator(path.charCodeAt(2))) {
+                isAbsolute = true;
+                rootEnd = 3;
+            }
+        }
+        let tail = rootEnd < len ?
+            normalizeString(path.slice(rootEnd), !isAbsolute, '\\', isPathSeparator) :
+            '';
+        if (tail.length === 0 && !isAbsolute) {
+            tail = '.';
+        }
+        if (tail.length > 0 && isPathSeparator(path.charCodeAt(len - 1))) {
+            tail += '\\';
+        }
+        if (device === undefined) {
+            return isAbsolute ? `\\${tail}` : tail;
+        }
+        return isAbsolute ? `${device}\\${tail}` : `${device}${tail}`;
+    },
+    isAbsolute(path) {
+        validateString(path, 'path');
+        const len = path.length;
+        if (len === 0) {
+            return false;
+        }
+        const code = path.charCodeAt(0);
+        return isPathSeparator(code) ||
+            (len > 2 &&
+                isWindowsDeviceRoot(code) &&
+                path.charCodeAt(1) === CHAR_COLON &&
+                isPathSeparator(path.charCodeAt(2)));
+    },
+    join(...paths) {
+        if (paths.length === 0) {
+            return '.';
+        }
+        let joined;
+        let firstPart;
+        for (let i = 0; i < paths.length; ++i) {
+            const arg = paths[i];
+            validateString(arg, 'path');
+            if (arg.length > 0) {
+                if (joined === undefined) {
+                    joined = firstPart = arg;
+                }
+                else {
+                    joined += `\\${arg}`;
+                }
+            }
+        }
+        if (joined === undefined) {
+            return '.';
+        }
+        let needsReplace = true;
+        let slashCount = 0;
+        if (typeof firstPart === 'string' && isPathSeparator(firstPart.charCodeAt(0))) {
+            ++slashCount;
+            const firstLen = firstPart.length;
+            if (firstLen > 1 && isPathSeparator(firstPart.charCodeAt(1))) {
+                ++slashCount;
+                if (firstLen > 2) {
+                    if (isPathSeparator(firstPart.charCodeAt(2))) {
+                        ++slashCount;
+                    }
+                    else {
+                        needsReplace = false;
+                    }
+                }
+            }
+        }
+        if (needsReplace) {
+            while (slashCount < joined.length &&
+                isPathSeparator(joined.charCodeAt(slashCount))) {
+                slashCount++;
+            }
+            if (slashCount >= 2) {
+                joined = `\\${joined.slice(slashCount)}`;
+            }
+        }
+        return win32.normalize(joined);
+    },
+    relative(from, to) {
+        validateString(from, 'from');
+        validateString(to, 'to');
+        if (from === to) {
+            return '';
+        }
+        const fromOrig = win32.resolve(from);
+        const toOrig = win32.resolve(to);
+        if (fromOrig === toOrig) {
+            return '';
+        }
+        from = fromOrig.toLowerCase();
+        to = toOrig.toLowerCase();
+        if (from === to) {
+            return '';
+        }
+        let fromStart = 0;
+        while (fromStart < from.length &&
+            from.charCodeAt(fromStart) === CHAR_BACKWARD_SLASH) {
+            fromStart++;
+        }
+        let fromEnd = from.length;
+        while (fromEnd - 1 > fromStart &&
+            from.charCodeAt(fromEnd - 1) === CHAR_BACKWARD_SLASH) {
+            fromEnd--;
+        }
+        const fromLen = fromEnd - fromStart;
+        let toStart = 0;
+        while (toStart < to.length &&
+            to.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) {
+            toStart++;
+        }
+        let toEnd = to.length;
+        while (toEnd - 1 > toStart &&
+            to.charCodeAt(toEnd - 1) === CHAR_BACKWARD_SLASH) {
+            toEnd--;
+        }
+        const toLen = toEnd - toStart;
+        const length = fromLen < toLen ? fromLen : toLen;
+        let lastCommonSep = -1;
+        let i = 0;
+        for (; i < length; i++) {
+            const fromCode = from.charCodeAt(fromStart + i);
+            if (fromCode !== to.charCodeAt(toStart + i)) {
+                break;
+            }
+            else if (fromCode === CHAR_BACKWARD_SLASH) {
+                lastCommonSep = i;
+            }
+        }
+        if (i !== length) {
+            if (lastCommonSep === -1) {
+                return toOrig;
+            }
+        }
+        else {
+            if (toLen > length) {
+                if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) {
+                    return toOrig.slice(toStart + i + 1);
+                }
+                if (i === 2) {
+                    return toOrig.slice(toStart + i);
+                }
+            }
+            if (fromLen > length) {
+                if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) {
+                    lastCommonSep = i;
+                }
+                else if (i === 2) {
+                    lastCommonSep = 3;
+                }
+            }
+            if (lastCommonSep === -1) {
+                lastCommonSep = 0;
+            }
+        }
+        let out = '';
+        for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
+            if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) {
+                out += out.length === 0 ? '..' : '\\..';
+            }
+        }
+        toStart += lastCommonSep;
+        if (out.length > 0) {
+            return `${out}${toOrig.slice(toStart, toEnd)}`;
+        }
+        if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) {
+            ++toStart;
+        }
+        return toOrig.slice(toStart, toEnd);
+    },
+    toNamespacedPath(path) {
+        if (typeof path !== 'string' || path.length === 0) {
+            return path;
+        }
+        const resolvedPath = win32.resolve(path);
+        if (resolvedPath.length <= 2) {
+            return path;
+        }
+        if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) {
+            if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) {
+                const code = resolvedPath.charCodeAt(2);
+                if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) {
+                    return `\\\\?\\UNC\\${resolvedPath.slice(2)}`;
+                }
+            }
+        }
+        else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0)) &&
+            resolvedPath.charCodeAt(1) === CHAR_COLON &&
+            resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH) {
+            return `\\\\?\\${resolvedPath}`;
+        }
+        return path;
+    },
+    dirname(path) {
+        validateString(path, 'path');
+        const len = path.length;
+        if (len === 0) {
+            return '.';
+        }
+        let rootEnd = -1;
+        let offset = 0;
+        const code = path.charCodeAt(0);
+        if (len === 1) {
+            return isPathSeparator(code) ? path : '.';
+        }
+        if (isPathSeparator(code)) {
+            rootEnd = offset = 1;
+            if (isPathSeparator(path.charCodeAt(1))) {
+                let j = 2;
+                let last = j;
+                while (j < len && !isPathSeparator(path.charCodeAt(j))) {
+                    j++;
+                }
+                if (j < len && j !== last) {
+                    last = j;
+                    while (j < len && isPathSeparator(path.charCodeAt(j))) {
+                        j++;
+                    }
+                    if (j < len && j !== last) {
+                        last = j;
+                        while (j < len && !isPathSeparator(path.charCodeAt(j))) {
+                            j++;
+                        }
+                        if (j === len) {
+                            return path;
+                        }
+                        if (j !== last) {
+                            rootEnd = offset = j + 1;
+                        }
+                    }
+                }
+            }
+        }
+        else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {
+            rootEnd = len > 2 && isPathSeparator(path.charCodeAt(2)) ? 3 : 2;
+            offset = rootEnd;
+        }
+        let end = -1;
+        let matchedSlash = true;
+        for (let i = len - 1; i >= offset; --i) {
+            if (isPathSeparator(path.charCodeAt(i))) {
+                if (!matchedSlash) {
+                    end = i;
+                    break;
+                }
+            }
+            else {
+                matchedSlash = false;
+            }
+        }
+        if (end === -1) {
+            if (rootEnd === -1) {
+                return '.';
+            }
+            end = rootEnd;
+        }
+        return path.slice(0, end);
+    },
+    basename(path, ext) {
+        if (ext !== undefined) {
+            validateString(ext, 'ext');
+        }
+        validateString(path, 'path');
+        let start = 0;
+        let end = -1;
+        let matchedSlash = true;
+        let i;
+        if (path.length >= 2 &&
+            isWindowsDeviceRoot(path.charCodeAt(0)) &&
+            path.charCodeAt(1) === CHAR_COLON) {
+            start = 2;
+        }
+        if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+            if (ext === path) {
+                return '';
+            }
+            let extIdx = ext.length - 1;
+            let firstNonSlashEnd = -1;
+            for (i = path.length - 1; i >= start; --i) {
+                const code = path.charCodeAt(i);
+                if (isPathSeparator(code)) {
+                    if (!matchedSlash) {
+                        start = i + 1;
+                        break;
+                    }
+                }
+                else {
+                    if (firstNonSlashEnd === -1) {
+                        matchedSlash = false;
+                        firstNonSlashEnd = i + 1;
+                    }
+                    if (extIdx >= 0) {
+                        if (code === ext.charCodeAt(extIdx)) {
+                            if (--extIdx === -1) {
+                                end = i;
+                            }
+                        }
+                        else {
+                            extIdx = -1;
+                            end = firstNonSlashEnd;
+                        }
+                    }
+                }
+            }
+            if (start === end) {
+                end = firstNonSlashEnd;
+            }
+            else if (end === -1) {
+                end = path.length;
+            }
+            return path.slice(start, end);
+        }
+        for (i = path.length - 1; i >= start; --i) {
+            if (isPathSeparator(path.charCodeAt(i))) {
+                if (!matchedSlash) {
+                    start = i + 1;
+                    break;
+                }
+            }
+            else if (end === -1) {
+                matchedSlash = false;
+                end = i + 1;
+            }
+        }
+        if (end === -1) {
+            return '';
+        }
+        return path.slice(start, end);
+    },
+    extname(path) {
+        validateString(path, 'path');
+        let start = 0;
+        let startDot = -1;
+        let startPart = 0;
+        let end = -1;
+        let matchedSlash = true;
+        let preDotState = 0;
+        if (path.length >= 2 &&
+            path.charCodeAt(1) === CHAR_COLON &&
+            isWindowsDeviceRoot(path.charCodeAt(0))) {
+            start = startPart = 2;
+        }
+        for (let i = path.length - 1; i >= start; --i) {
+            const code = path.charCodeAt(i);
+            if (isPathSeparator(code)) {
+                if (!matchedSlash) {
+                    startPart = i + 1;
+                    break;
+                }
+                continue;
+            }
+            if (end === -1) {
+                matchedSlash = false;
+                end = i + 1;
+            }
+            if (code === CHAR_DOT) {
+                if (startDot === -1) {
+                    startDot = i;
+                }
+                else if (preDotState !== 1) {
+                    preDotState = 1;
+                }
+            }
+            else if (startDot !== -1) {
+                preDotState = -1;
+            }
+        }
+        if (startDot === -1 ||
+            end === -1 ||
+            preDotState === 0 ||
+            (preDotState === 1 &&
+                startDot === end - 1 &&
+                startDot === startPart + 1)) {
+            return '';
+        }
+        return path.slice(startDot, end);
+    },
+    format: _format.bind(null, '\\'),
+    parse(path) {
+        validateString(path, 'path');
+        const ret = { root: '', dir: '', base: '', ext: '', name: '' };
+        if (path.length === 0) {
+            return ret;
+        }
+        const len = path.length;
+        let rootEnd = 0;
+        let code = path.charCodeAt(0);
+        if (len === 1) {
+            if (isPathSeparator(code)) {
+                ret.root = ret.dir = path;
+                return ret;
+            }
+            ret.base = ret.name = path;
+            return ret;
+        }
+        if (isPathSeparator(code)) {
+            rootEnd = 1;
+            if (isPathSeparator(path.charCodeAt(1))) {
+                let j = 2;
+                let last = j;
+                while (j < len && !isPathSeparator(path.charCodeAt(j))) {
+                    j++;
+                }
+                if (j < len && j !== last) {
+                    last = j;
+                    while (j < len && isPathSeparator(path.charCodeAt(j))) {
+                        j++;
+                    }
+                    if (j < len && j !== last) {
+                        last = j;
+                        while (j < len && !isPathSeparator(path.charCodeAt(j))) {
+                            j++;
+                        }
+                        if (j === len) {
+                            rootEnd = j;
+                        }
+                        else if (j !== last) {
+                            rootEnd = j + 1;
+                        }
+                    }
+                }
+            }
+        }
+        else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {
+            if (len <= 2) {
+                ret.root = ret.dir = path;
+                return ret;
+            }
+            rootEnd = 2;
+            if (isPathSeparator(path.charCodeAt(2))) {
+                if (len === 3) {
+                    ret.root = ret.dir = path;
+                    return ret;
+                }
+                rootEnd = 3;
+            }
+        }
+        if (rootEnd > 0) {
+            ret.root = path.slice(0, rootEnd);
+        }
+        let startDot = -1;
+        let startPart = rootEnd;
+        let end = -1;
+        let matchedSlash = true;
+        let i = path.length - 1;
+        let preDotState = 0;
+        for (; i >= rootEnd; --i) {
+            code = path.charCodeAt(i);
+            if (isPathSeparator(code)) {
+                if (!matchedSlash) {
+                    startPart = i + 1;
+                    break;
+                }
+                continue;
+            }
+            if (end === -1) {
+                matchedSlash = false;
+                end = i + 1;
+            }
+            if (code === CHAR_DOT) {
+                if (startDot === -1) {
+                    startDot = i;
+                }
+                else if (preDotState !== 1) {
+                    preDotState = 1;
+                }
+            }
+            else if (startDot !== -1) {
+                preDotState = -1;
+            }
+        }
+        if (end !== -1) {
+            if (startDot === -1 ||
+                preDotState === 0 ||
+                (preDotState === 1 &&
+                    startDot === end - 1 &&
+                    startDot === startPart + 1)) {
+                ret.base = ret.name = path.slice(startPart, end);
+            }
+            else {
+                ret.name = path.slice(startPart, startDot);
+                ret.base = path.slice(startPart, end);
+                ret.ext = path.slice(startDot, end);
+            }
+        }
+        if (startPart > 0 && startPart !== rootEnd) {
+            ret.dir = path.slice(0, startPart - 1);
+        }
+        else {
+            ret.dir = ret.root;
+        }
+        return ret;
+    },
+    sep: '\\',
+    delimiter: ';',
+    win32: null,
+    posix: null
+};
+const posixCwd = (() => {
+    if (platformIsWin32) {
+        const regexp = /\\/g;
+        return () => {
+            const cwd$1 = cwd().replace(regexp, '/');
+            return cwd$1.slice(cwd$1.indexOf('/'));
+        };
+    }
+    return () => cwd();
+})();
+const posix = {
+    resolve(...pathSegments) {
+        let resolvedPath = '';
+        let resolvedAbsolute = false;
+        for (let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+            const path = i >= 0 ? pathSegments[i] : posixCwd();
+            validateString(path, 'path');
+            if (path.length === 0) {
+                continue;
+            }
+            resolvedPath = `${path}/${resolvedPath}`;
+            resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+        }
+        resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, '/', isPosixPathSeparator);
+        if (resolvedAbsolute) {
+            return `/${resolvedPath}`;
+        }
+        return resolvedPath.length > 0 ? resolvedPath : '.';
+    },
+    normalize(path) {
+        validateString(path, 'path');
+        if (path.length === 0) {
+            return '.';
+        }
+        const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+        const trailingSeparator = path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH;
+        path = normalizeString(path, !isAbsolute, '/', isPosixPathSeparator);
+        if (path.length === 0) {
+            if (isAbsolute) {
+                return '/';
+            }
+            return trailingSeparator ? './' : '.';
+        }
+        if (trailingSeparator) {
+            path += '/';
+        }
+        return isAbsolute ? `/${path}` : path;
+    },
+    isAbsolute(path) {
+        validateString(path, 'path');
+        return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+    },
+    join(...paths) {
+        if (paths.length === 0) {
+            return '.';
+        }
+        let joined;
+        for (let i = 0; i < paths.length; ++i) {
+            const arg = paths[i];
+            validateString(arg, 'path');
+            if (arg.length > 0) {
+                if (joined === undefined) {
+                    joined = arg;
+                }
+                else {
+                    joined += `/${arg}`;
+                }
+            }
+        }
+        if (joined === undefined) {
+            return '.';
+        }
+        return posix.normalize(joined);
+    },
+    relative(from, to) {
+        validateString(from, 'from');
+        validateString(to, 'to');
+        if (from === to) {
+            return '';
+        }
+        from = posix.resolve(from);
+        to = posix.resolve(to);
+        if (from === to) {
+            return '';
+        }
+        const fromStart = 1;
+        const fromEnd = from.length;
+        const fromLen = fromEnd - fromStart;
+        const toStart = 1;
+        const toLen = to.length - toStart;
+        const length = (fromLen < toLen ? fromLen : toLen);
+        let lastCommonSep = -1;
+        let i = 0;
+        for (; i < length; i++) {
+            const fromCode = from.charCodeAt(fromStart + i);
+            if (fromCode !== to.charCodeAt(toStart + i)) {
+                break;
+            }
+            else if (fromCode === CHAR_FORWARD_SLASH) {
+                lastCommonSep = i;
+            }
+        }
+        if (i === length) {
+            if (toLen > length) {
+                if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) {
+                    return to.slice(toStart + i + 1);
+                }
+                if (i === 0) {
+                    return to.slice(toStart + i);
+                }
+            }
+            else if (fromLen > length) {
+                if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) {
+                    lastCommonSep = i;
+                }
+                else if (i === 0) {
+                    lastCommonSep = 0;
+                }
+            }
+        }
+        let out = '';
+        for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
+            if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) {
+                out += out.length === 0 ? '..' : '/..';
+            }
+        }
+        return `${out}${to.slice(toStart + lastCommonSep)}`;
+    },
+    toNamespacedPath(path) {
+        return path;
+    },
+    dirname(path) {
+        validateString(path, 'path');
+        if (path.length === 0) {
+            return '.';
+        }
+        const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+        let end = -1;
+        let matchedSlash = true;
+        for (let i = path.length - 1; i >= 1; --i) {
+            if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {
+                if (!matchedSlash) {
+                    end = i;
+                    break;
+                }
+            }
+            else {
+                matchedSlash = false;
+            }
+        }
+        if (end === -1) {
+            return hasRoot ? '/' : '.';
+        }
+        if (hasRoot && end === 1) {
+            return '//';
+        }
+        return path.slice(0, end);
+    },
+    basename(path, ext) {
+        if (ext !== undefined) {
+            validateString(ext, 'ext');
+        }
+        validateString(path, 'path');
+        let start = 0;
+        let end = -1;
+        let matchedSlash = true;
+        let i;
+        if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+            if (ext === path) {
+                return '';
+            }
+            let extIdx = ext.length - 1;
+            let firstNonSlashEnd = -1;
+            for (i = path.length - 1; i >= 0; --i) {
+                const code = path.charCodeAt(i);
+                if (code === CHAR_FORWARD_SLASH) {
+                    if (!matchedSlash) {
+                        start = i + 1;
+                        break;
+                    }
+                }
+                else {
+                    if (firstNonSlashEnd === -1) {
+                        matchedSlash = false;
+                        firstNonSlashEnd = i + 1;
+                    }
+                    if (extIdx >= 0) {
+                        if (code === ext.charCodeAt(extIdx)) {
+                            if (--extIdx === -1) {
+                                end = i;
+                            }
+                        }
+                        else {
+                            extIdx = -1;
+                            end = firstNonSlashEnd;
+                        }
+                    }
+                }
+            }
+            if (start === end) {
+                end = firstNonSlashEnd;
+            }
+            else if (end === -1) {
+                end = path.length;
+            }
+            return path.slice(start, end);
+        }
+        for (i = path.length - 1; i >= 0; --i) {
+            if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {
+                if (!matchedSlash) {
+                    start = i + 1;
+                    break;
+                }
+            }
+            else if (end === -1) {
+                matchedSlash = false;
+                end = i + 1;
+            }
+        }
+        if (end === -1) {
+            return '';
+        }
+        return path.slice(start, end);
+    },
+    extname(path) {
+        validateString(path, 'path');
+        let startDot = -1;
+        let startPart = 0;
+        let end = -1;
+        let matchedSlash = true;
+        let preDotState = 0;
+        for (let i = path.length - 1; i >= 0; --i) {
+            const code = path.charCodeAt(i);
+            if (code === CHAR_FORWARD_SLASH) {
+                if (!matchedSlash) {
+                    startPart = i + 1;
+                    break;
+                }
+                continue;
+            }
+            if (end === -1) {
+                matchedSlash = false;
+                end = i + 1;
+            }
+            if (code === CHAR_DOT) {
+                if (startDot === -1) {
+                    startDot = i;
+                }
+                else if (preDotState !== 1) {
+                    preDotState = 1;
+                }
+            }
+            else if (startDot !== -1) {
+                preDotState = -1;
+            }
+        }
+        if (startDot === -1 ||
+            end === -1 ||
+            preDotState === 0 ||
+            (preDotState === 1 &&
+                startDot === end - 1 &&
+                startDot === startPart + 1)) {
+            return '';
+        }
+        return path.slice(startDot, end);
+    },
+    format: _format.bind(null, '/'),
+    parse(path) {
+        validateString(path, 'path');
+        const ret = { root: '', dir: '', base: '', ext: '', name: '' };
+        if (path.length === 0) {
+            return ret;
+        }
+        const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+        let start;
+        if (isAbsolute) {
+            ret.root = '/';
+            start = 1;
+        }
+        else {
+            start = 0;
+        }
+        let startDot = -1;
+        let startPart = 0;
+        let end = -1;
+        let matchedSlash = true;
+        let i = path.length - 1;
+        let preDotState = 0;
+        for (; i >= start; --i) {
+            const code = path.charCodeAt(i);
+            if (code === CHAR_FORWARD_SLASH) {
+                if (!matchedSlash) {
+                    startPart = i + 1;
+                    break;
+                }
+                continue;
+            }
+            if (end === -1) {
+                matchedSlash = false;
+                end = i + 1;
+            }
+            if (code === CHAR_DOT) {
+                if (startDot === -1) {
+                    startDot = i;
+                }
+                else if (preDotState !== 1) {
+                    preDotState = 1;
+                }
+            }
+            else if (startDot !== -1) {
+                preDotState = -1;
+            }
+        }
+        if (end !== -1) {
+            const start = startPart === 0 && isAbsolute ? 1 : startPart;
+            if (startDot === -1 ||
+                preDotState === 0 ||
+                (preDotState === 1 &&
+                    startDot === end - 1 &&
+                    startDot === startPart + 1)) {
+                ret.base = ret.name = path.slice(start, end);
+            }
+            else {
+                ret.name = path.slice(start, startDot);
+                ret.base = path.slice(start, end);
+                ret.ext = path.slice(startDot, end);
+            }
+        }
+        if (startPart > 0) {
+            ret.dir = path.slice(0, startPart - 1);
+        }
+        else if (isAbsolute) {
+            ret.dir = '/';
+        }
+        return ret;
+    },
+    sep: '/',
+    delimiter: ':',
+    win32: null,
+    posix: null
+};
+posix.win32 = win32.win32 = win32;
+posix.posix = win32.posix = posix;
+const isAbsolute = (platformIsWin32 ? win32.isAbsolute : posix.isAbsolute);
+const join = (platformIsWin32 ? win32.join : posix.join);
+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(
+                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 as A, convertToDAPaths as a, isSessionAttach as b, convertToVSCPaths as c, isAbsolute as d, getVisibleAndSorted as e, filterExceptionsFromTelemetry as f, getExtensionHostDebugSession as g, getEvaluatableExpressionAtPosition as h, isDebuggerMainContribution as i, join as j, isUri as k, formatPII as l, saveAllBeforeDebugStart as s };