/*!--------------------------------------------------------
 * Copyright (C) Microsoft Corporation. All rights reserved.
 *--------------------------------------------------------*/
(function() {
var __m = ["require","exports","vs/base/common/lifecycle","vs/base/common/platform","vs/base/common/event","vs/base/common/path","vs/base/common/uri","vs/base/common/errors","vs/nls","vs/platform/log/common/log","vs/base/common/types","vs/base/common/strings","vs/base/common/async","vs/base/common/charCode","vs/base/common/decorators","vs/base/common/process","vs/platform/terminal/common/terminal","vs/base/common/arrays","vs/base/common/cancellation","vs/base/common/buffer","vs/base/common/network","os","vs/platform/instantiation/common/instantiation","vs/platform/terminal/common/capabilities/capabilities","vs/base/common/lazy","vs/base/common/resources","vs/base/common/map","vs/base/common/marshallingIds","vs/base/node/pfs","child_process","vs/base/parts/ipc/common/ipc","vs/base/common/functional","vs/base/common/objects","vs/base/parts/sandbox/node/electronTypes","vs/nls.messages","vs/base/common/extpath","vs/base/common/processes","fs","vs/base/node/processes","vs/platform/contextkey/common/contextkey","vs/platform/terminal/common/environmentVariable","vs/platform/terminal/common/terminalEnvironment","vs/platform/terminal/node/childProcessMonitor","vs/platform/terminal/node/terminalEnvironment","vs/base/common/arraysFind","vs/base/common/collections","vs/base/common/assert","vs/base/common/iterator","vs/base/common/linkedList","vs/base/common/normalization","vs/base/common/stopwatch","vs/base/common/cache","vs/base/common/stream","vs/base/common/symbols","vs/base/common/uint","vs/base/common/hash","vs/base/common/ternarySearchTree","vs/base/common/uuid","vs/base/common/date","vs/base/common/errorMessage","vs/base/common/console","vs/base/common/marshalling","vs/base/common/uriIpc","vs/base/node/powershell","vs/base/node/ps","vs/base/node/shell","vs/base/parts/ipc/node/ipc.cp","vs/base/parts/ipc/node/ipc.mp","vs/platform/contextkey/common/scanner","vs/platform/environment/common/environmentService","vs/platform/environment/node/argv","vs/platform/environment/node/userDataPath","path","vs/platform/environment/node/environmentService","vs/platform/files/common/files","vs/platform/log/common/logIpc","vs/platform/log/common/logService","vs/platform/log/node/spdlogLog","vs/platform/log/node/loggerService","vs/platform/product/common/product","vs/platform/product/common/productService","vs/platform/registry/common/platform","vs/platform/terminal/common/capabilities/bufferMarkCapability","vs/platform/terminal/common/capabilities/commandDetection/promptInputModel","vs/platform/terminal/common/capabilities/commandDetection/terminalCommand","vs/platform/terminal/common/capabilities/commandDetectionCapability","vs/platform/terminal/common/capabilities/cwdDetectionCapability","vs/platform/terminal/common/capabilities/partialCommandDetectionCapability","vs/platform/terminal/common/capabilities/terminalCapabilityStore","vs/platform/terminal/common/environmentVariableCollection","vs/platform/terminal/common/environmentVariableShared","vs/platform/terminal/common/requestStore","vs/platform/terminal/common/terminalAutoResponder","vs/platform/terminal/common/terminalDataBuffering","vs/platform/terminal/common/terminalProcess","vs/platform/terminal/common/terminalStrings","vs/platform/terminal/common/xterm/shellIntegrationAddon","vs/platform/terminal/node/heartbeatService","vs/platform/terminal/node/windowsShellHelper","vs/platform/terminal/node/terminalProcess","vs/platform/terminal/node/ptyService","util","minimist","node-pty","vs/base/common/performance","@xterm/headless","vs/platform/terminal/node/ptyHostMain"];
var __M = function(deps) {
  var result = [];
  for (var i = 0, len = deps.length; i < len; i++) {
    result[i] = __m[deps[i]];
  }
  return result;
};
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[44/*vs/base/common/arraysFind*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$qb = void 0;
    exports.$jb = $jb;
    exports.$kb = $kb;
    exports.$lb = $lb;
    exports.$mb = $mb;
    exports.$nb = $nb;
    exports.$ob = $ob;
    exports.$pb = $pb;
    exports.$rb = $rb;
    exports.$sb = $sb;
    exports.$tb = $tb;
    exports.$ub = $ub;
    exports.$vb = $vb;
    function $jb(array, predicate) {
        const idx = $kb(array, predicate);
        if (idx === -1) {
            return undefined;
        }
        return array[idx];
    }
    function $kb(array, predicate, fromIndex = array.length - 1) {
        for (let i = fromIndex; i >= 0; i--) {
            const element = array[i];
            if (predicate(element)) {
                return i;
            }
        }
        return -1;
    }
    /**
     * Finds the last item where predicate is true using binary search.
     * `predicate` must be monotonous, i.e. `arr.map(predicate)` must be like `[true, ..., true, false, ..., false]`!
     *
     * @returns `undefined` if no item matches, otherwise the last item that matches the predicate.
     */
    function $lb(array, predicate) {
        const idx = $mb(array, predicate);
        return idx === -1 ? undefined : array[idx];
    }
    /**
     * Finds the last item where predicate is true using binary search.
     * `predicate` must be monotonous, i.e. `arr.map(predicate)` must be like `[true, ..., true, false, ..., false]`!
     *
     * @returns `startIdx - 1` if predicate is false for all items, otherwise the index of the last item that matches the predicate.
     */
    function $mb(array, predicate, startIdx = 0, endIdxEx = array.length) {
        let i = startIdx;
        let j = endIdxEx;
        while (i < j) {
            const k = Math.floor((i + j) / 2);
            if (predicate(array[k])) {
                i = k + 1;
            }
            else {
                j = k;
            }
        }
        return i - 1;
    }
    /**
     * Finds the first item where predicate is true using binary search.
     * `predicate` must be monotonous, i.e. `arr.map(predicate)` must be like `[false, ..., false, true, ..., true]`!
     *
     * @returns `undefined` if no item matches, otherwise the first item that matches the predicate.
     */
    function $nb(array, predicate) {
        const idx = $ob(array, predicate);
        return idx === array.length ? undefined : array[idx];
    }
    /**
     * Finds the first item where predicate is true using binary search.
     * `predicate` must be monotonous, i.e. `arr.map(predicate)` must be like `[false, ..., false, true, ..., true]`!
     *
     * @returns `endIdxEx` if predicate is false for all items, otherwise the index of the first item that matches the predicate.
     */
    function $ob(array, predicate, startIdx = 0, endIdxEx = array.length) {
        let i = startIdx;
        let j = endIdxEx;
        while (i < j) {
            const k = Math.floor((i + j) / 2);
            if (predicate(array[k])) {
                j = k;
            }
            else {
                i = k + 1;
            }
        }
        return i;
    }
    function $pb(array, predicate, startIdx = 0, endIdxEx = array.length) {
        const idx = $ob(array, predicate, startIdx, endIdxEx);
        return idx === array.length ? -1 : idx;
    }
    /**
     * Use this when
     * * You have a sorted array
     * * You query this array with a monotonous predicate to find the last item that has a certain property.
     * * You query this array multiple times with monotonous predicates that get weaker and weaker.
     */
    class $qb {
        static { this.assertInvariants = false; }
        constructor(e) {
            this.e = e;
            this.c = 0;
        }
        /**
         * The predicate must be monotonous, i.e. `arr.map(predicate)` must be like `[true, ..., true, false, ..., false]`!
         * For subsequent calls, current predicate must be weaker than (or equal to) the previous predicate, i.e. more entries must be `true`.
         */
        findLastMonotonous(predicate) {
            if ($qb.assertInvariants) {
                if (this.d) {
                    for (const item of this.e) {
                        if (this.d(item) && !predicate(item)) {
                            throw new Error('MonotonousArray: current predicate must be weaker than (or equal to) the previous predicate.');
                        }
                    }
                }
                this.d = predicate;
            }
            const idx = $mb(this.e, predicate, this.c);
            this.c = idx + 1;
            return idx === -1 ? undefined : this.e[idx];
        }
    }
    exports.$qb = $qb;
    /**
     * Returns the first item that is equal to or greater than every other item.
    */
    function $rb(array, comparator) {
        if (array.length === 0) {
            return undefined;
        }
        let max = array[0];
        for (let i = 1; i < array.length; i++) {
            const item = array[i];
            if (comparator(item, max) > 0) {
                max = item;
            }
        }
        return max;
    }
    /**
     * Returns the last item that is equal to or greater than every other item.
    */
    function $sb(array, comparator) {
        if (array.length === 0) {
            return undefined;
        }
        let max = array[0];
        for (let i = 1; i < array.length; i++) {
            const item = array[i];
            if (comparator(item, max) >= 0) {
                max = item;
            }
        }
        return max;
    }
    /**
     * Returns the first item that is equal to or less than every other item.
    */
    function $tb(array, comparator) {
        return $rb(array, (a, b) => -comparator(a, b));
    }
    function $ub(array, comparator) {
        if (array.length === 0) {
            return -1;
        }
        let maxIdx = 0;
        for (let i = 1; i < array.length; i++) {
            const item = array[i];
            if (comparator(item, array[maxIdx]) > 0) {
                maxIdx = i;
            }
        }
        return maxIdx;
    }
    /**
     * Returns the first mapped value of the array which is not undefined.
     */
    function $vb(items, mapFn) {
        for (const value of items) {
            const mapped = mapFn(value);
            if (mapped !== undefined) {
                return mapped;
            }
        }
        return undefined;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[13/*vs/base/common/charCode*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.CharCode = void 0;
    // Names from https://blog.codinghorror.com/ascii-pronunciation-rules-for-programmers/
    /**
     * An inlined enum containing useful character codes (to be used with String.charCodeAt).
     * Please leave the const keyword such that it gets inlined when compiled to JavaScript!
     */
    var CharCode;
    (function (CharCode) {
        CharCode[CharCode["Null"] = 0] = "Null";
        /**
         * The `\b` character.
         */
        CharCode[CharCode["Backspace"] = 8] = "Backspace";
        /**
         * The `\t` character.
         */
        CharCode[CharCode["Tab"] = 9] = "Tab";
        /**
         * The `\n` character.
         */
        CharCode[CharCode["LineFeed"] = 10] = "LineFeed";
        /**
         * The `\r` character.
         */
        CharCode[CharCode["CarriageReturn"] = 13] = "CarriageReturn";
        CharCode[CharCode["Space"] = 32] = "Space";
        /**
         * The `!` character.
         */
        CharCode[CharCode["ExclamationMark"] = 33] = "ExclamationMark";
        /**
         * The `"` character.
         */
        CharCode[CharCode["DoubleQuote"] = 34] = "DoubleQuote";
        /**
         * The `#` character.
         */
        CharCode[CharCode["Hash"] = 35] = "Hash";
        /**
         * The `$` character.
         */
        CharCode[CharCode["DollarSign"] = 36] = "DollarSign";
        /**
         * The `%` character.
         */
        CharCode[CharCode["PercentSign"] = 37] = "PercentSign";
        /**
         * The `&` character.
         */
        CharCode[CharCode["Ampersand"] = 38] = "Ampersand";
        /**
         * The `'` character.
         */
        CharCode[CharCode["SingleQuote"] = 39] = "SingleQuote";
        /**
         * The `(` character.
         */
        CharCode[CharCode["OpenParen"] = 40] = "OpenParen";
        /**
         * The `)` character.
         */
        CharCode[CharCode["CloseParen"] = 41] = "CloseParen";
        /**
         * The `*` character.
         */
        CharCode[CharCode["Asterisk"] = 42] = "Asterisk";
        /**
         * The `+` character.
         */
        CharCode[CharCode["Plus"] = 43] = "Plus";
        /**
         * The `,` character.
         */
        CharCode[CharCode["Comma"] = 44] = "Comma";
        /**
         * The `-` character.
         */
        CharCode[CharCode["Dash"] = 45] = "Dash";
        /**
         * The `.` character.
         */
        CharCode[CharCode["Period"] = 46] = "Period";
        /**
         * The `/` character.
         */
        CharCode[CharCode["Slash"] = 47] = "Slash";
        CharCode[CharCode["Digit0"] = 48] = "Digit0";
        CharCode[CharCode["Digit1"] = 49] = "Digit1";
        CharCode[CharCode["Digit2"] = 50] = "Digit2";
        CharCode[CharCode["Digit3"] = 51] = "Digit3";
        CharCode[CharCode["Digit4"] = 52] = "Digit4";
        CharCode[CharCode["Digit5"] = 53] = "Digit5";
        CharCode[CharCode["Digit6"] = 54] = "Digit6";
        CharCode[CharCode["Digit7"] = 55] = "Digit7";
        CharCode[CharCode["Digit8"] = 56] = "Digit8";
        CharCode[CharCode["Digit9"] = 57] = "Digit9";
        /**
         * The `:` character.
         */
        CharCode[CharCode["Colon"] = 58] = "Colon";
        /**
         * The `;` character.
         */
        CharCode[CharCode["Semicolon"] = 59] = "Semicolon";
        /**
         * The `<` character.
         */
        CharCode[CharCode["LessThan"] = 60] = "LessThan";
        /**
         * The `=` character.
         */
        CharCode[CharCode["Equals"] = 61] = "Equals";
        /**
         * The `>` character.
         */
        CharCode[CharCode["GreaterThan"] = 62] = "GreaterThan";
        /**
         * The `?` character.
         */
        CharCode[CharCode["QuestionMark"] = 63] = "QuestionMark";
        /**
         * The `@` character.
         */
        CharCode[CharCode["AtSign"] = 64] = "AtSign";
        CharCode[CharCode["A"] = 65] = "A";
        CharCode[CharCode["B"] = 66] = "B";
        CharCode[CharCode["C"] = 67] = "C";
        CharCode[CharCode["D"] = 68] = "D";
        CharCode[CharCode["E"] = 69] = "E";
        CharCode[CharCode["F"] = 70] = "F";
        CharCode[CharCode["G"] = 71] = "G";
        CharCode[CharCode["H"] = 72] = "H";
        CharCode[CharCode["I"] = 73] = "I";
        CharCode[CharCode["J"] = 74] = "J";
        CharCode[CharCode["K"] = 75] = "K";
        CharCode[CharCode["L"] = 76] = "L";
        CharCode[CharCode["M"] = 77] = "M";
        CharCode[CharCode["N"] = 78] = "N";
        CharCode[CharCode["O"] = 79] = "O";
        CharCode[CharCode["P"] = 80] = "P";
        CharCode[CharCode["Q"] = 81] = "Q";
        CharCode[CharCode["R"] = 82] = "R";
        CharCode[CharCode["S"] = 83] = "S";
        CharCode[CharCode["T"] = 84] = "T";
        CharCode[CharCode["U"] = 85] = "U";
        CharCode[CharCode["V"] = 86] = "V";
        CharCode[CharCode["W"] = 87] = "W";
        CharCode[CharCode["X"] = 88] = "X";
        CharCode[CharCode["Y"] = 89] = "Y";
        CharCode[CharCode["Z"] = 90] = "Z";
        /**
         * The `[` character.
         */
        CharCode[CharCode["OpenSquareBracket"] = 91] = "OpenSquareBracket";
        /**
         * The `\` character.
         */
        CharCode[CharCode["Backslash"] = 92] = "Backslash";
        /**
         * The `]` character.
         */
        CharCode[CharCode["CloseSquareBracket"] = 93] = "CloseSquareBracket";
        /**
         * The `^` character.
         */
        CharCode[CharCode["Caret"] = 94] = "Caret";
        /**
         * The `_` character.
         */
        CharCode[CharCode["Underline"] = 95] = "Underline";
        /**
         * The ``(`)`` character.
         */
        CharCode[CharCode["BackTick"] = 96] = "BackTick";
        CharCode[CharCode["a"] = 97] = "a";
        CharCode[CharCode["b"] = 98] = "b";
        CharCode[CharCode["c"] = 99] = "c";
        CharCode[CharCode["d"] = 100] = "d";
        CharCode[CharCode["e"] = 101] = "e";
        CharCode[CharCode["f"] = 102] = "f";
        CharCode[CharCode["g"] = 103] = "g";
        CharCode[CharCode["h"] = 104] = "h";
        CharCode[CharCode["i"] = 105] = "i";
        CharCode[CharCode["j"] = 106] = "j";
        CharCode[CharCode["k"] = 107] = "k";
        CharCode[CharCode["l"] = 108] = "l";
        CharCode[CharCode["m"] = 109] = "m";
        CharCode[CharCode["n"] = 110] = "n";
        CharCode[CharCode["o"] = 111] = "o";
        CharCode[CharCode["p"] = 112] = "p";
        CharCode[CharCode["q"] = 113] = "q";
        CharCode[CharCode["r"] = 114] = "r";
        CharCode[CharCode["s"] = 115] = "s";
        CharCode[CharCode["t"] = 116] = "t";
        CharCode[CharCode["u"] = 117] = "u";
        CharCode[CharCode["v"] = 118] = "v";
        CharCode[CharCode["w"] = 119] = "w";
        CharCode[CharCode["x"] = 120] = "x";
        CharCode[CharCode["y"] = 121] = "y";
        CharCode[CharCode["z"] = 122] = "z";
        /**
         * The `{` character.
         */
        CharCode[CharCode["OpenCurlyBrace"] = 123] = "OpenCurlyBrace";
        /**
         * The `|` character.
         */
        CharCode[CharCode["Pipe"] = 124] = "Pipe";
        /**
         * The `}` character.
         */
        CharCode[CharCode["CloseCurlyBrace"] = 125] = "CloseCurlyBrace";
        /**
         * The `~` character.
         */
        CharCode[CharCode["Tilde"] = 126] = "Tilde";
        /**
         * The &nbsp; (no-break space) character.
         * Unicode Character 'NO-BREAK SPACE' (U+00A0)
         */
        CharCode[CharCode["NoBreakSpace"] = 160] = "NoBreakSpace";
        CharCode[CharCode["U_Combining_Grave_Accent"] = 768] = "U_Combining_Grave_Accent";
        CharCode[CharCode["U_Combining_Acute_Accent"] = 769] = "U_Combining_Acute_Accent";
        CharCode[CharCode["U_Combining_Circumflex_Accent"] = 770] = "U_Combining_Circumflex_Accent";
        CharCode[CharCode["U_Combining_Tilde"] = 771] = "U_Combining_Tilde";
        CharCode[CharCode["U_Combining_Macron"] = 772] = "U_Combining_Macron";
        CharCode[CharCode["U_Combining_Overline"] = 773] = "U_Combining_Overline";
        CharCode[CharCode["U_Combining_Breve"] = 774] = "U_Combining_Breve";
        CharCode[CharCode["U_Combining_Dot_Above"] = 775] = "U_Combining_Dot_Above";
        CharCode[CharCode["U_Combining_Diaeresis"] = 776] = "U_Combining_Diaeresis";
        CharCode[CharCode["U_Combining_Hook_Above"] = 777] = "U_Combining_Hook_Above";
        CharCode[CharCode["U_Combining_Ring_Above"] = 778] = "U_Combining_Ring_Above";
        CharCode[CharCode["U_Combining_Double_Acute_Accent"] = 779] = "U_Combining_Double_Acute_Accent";
        CharCode[CharCode["U_Combining_Caron"] = 780] = "U_Combining_Caron";
        CharCode[CharCode["U_Combining_Vertical_Line_Above"] = 781] = "U_Combining_Vertical_Line_Above";
        CharCode[CharCode["U_Combining_Double_Vertical_Line_Above"] = 782] = "U_Combining_Double_Vertical_Line_Above";
        CharCode[CharCode["U_Combining_Double_Grave_Accent"] = 783] = "U_Combining_Double_Grave_Accent";
        CharCode[CharCode["U_Combining_Candrabindu"] = 784] = "U_Combining_Candrabindu";
        CharCode[CharCode["U_Combining_Inverted_Breve"] = 785] = "U_Combining_Inverted_Breve";
        CharCode[CharCode["U_Combining_Turned_Comma_Above"] = 786] = "U_Combining_Turned_Comma_Above";
        CharCode[CharCode["U_Combining_Comma_Above"] = 787] = "U_Combining_Comma_Above";
        CharCode[CharCode["U_Combining_Reversed_Comma_Above"] = 788] = "U_Combining_Reversed_Comma_Above";
        CharCode[CharCode["U_Combining_Comma_Above_Right"] = 789] = "U_Combining_Comma_Above_Right";
        CharCode[CharCode["U_Combining_Grave_Accent_Below"] = 790] = "U_Combining_Grave_Accent_Below";
        CharCode[CharCode["U_Combining_Acute_Accent_Below"] = 791] = "U_Combining_Acute_Accent_Below";
        CharCode[CharCode["U_Combining_Left_Tack_Below"] = 792] = "U_Combining_Left_Tack_Below";
        CharCode[CharCode["U_Combining_Right_Tack_Below"] = 793] = "U_Combining_Right_Tack_Below";
        CharCode[CharCode["U_Combining_Left_Angle_Above"] = 794] = "U_Combining_Left_Angle_Above";
        CharCode[CharCode["U_Combining_Horn"] = 795] = "U_Combining_Horn";
        CharCode[CharCode["U_Combining_Left_Half_Ring_Below"] = 796] = "U_Combining_Left_Half_Ring_Below";
        CharCode[CharCode["U_Combining_Up_Tack_Below"] = 797] = "U_Combining_Up_Tack_Below";
        CharCode[CharCode["U_Combining_Down_Tack_Below"] = 798] = "U_Combining_Down_Tack_Below";
        CharCode[CharCode["U_Combining_Plus_Sign_Below"] = 799] = "U_Combining_Plus_Sign_Below";
        CharCode[CharCode["U_Combining_Minus_Sign_Below"] = 800] = "U_Combining_Minus_Sign_Below";
        CharCode[CharCode["U_Combining_Palatalized_Hook_Below"] = 801] = "U_Combining_Palatalized_Hook_Below";
        CharCode[CharCode["U_Combining_Retroflex_Hook_Below"] = 802] = "U_Combining_Retroflex_Hook_Below";
        CharCode[CharCode["U_Combining_Dot_Below"] = 803] = "U_Combining_Dot_Below";
        CharCode[CharCode["U_Combining_Diaeresis_Below"] = 804] = "U_Combining_Diaeresis_Below";
        CharCode[CharCode["U_Combining_Ring_Below"] = 805] = "U_Combining_Ring_Below";
        CharCode[CharCode["U_Combining_Comma_Below"] = 806] = "U_Combining_Comma_Below";
        CharCode[CharCode["U_Combining_Cedilla"] = 807] = "U_Combining_Cedilla";
        CharCode[CharCode["U_Combining_Ogonek"] = 808] = "U_Combining_Ogonek";
        CharCode[CharCode["U_Combining_Vertical_Line_Below"] = 809] = "U_Combining_Vertical_Line_Below";
        CharCode[CharCode["U_Combining_Bridge_Below"] = 810] = "U_Combining_Bridge_Below";
        CharCode[CharCode["U_Combining_Inverted_Double_Arch_Below"] = 811] = "U_Combining_Inverted_Double_Arch_Below";
        CharCode[CharCode["U_Combining_Caron_Below"] = 812] = "U_Combining_Caron_Below";
        CharCode[CharCode["U_Combining_Circumflex_Accent_Below"] = 813] = "U_Combining_Circumflex_Accent_Below";
        CharCode[CharCode["U_Combining_Breve_Below"] = 814] = "U_Combining_Breve_Below";
        CharCode[CharCode["U_Combining_Inverted_Breve_Below"] = 815] = "U_Combining_Inverted_Breve_Below";
        CharCode[CharCode["U_Combining_Tilde_Below"] = 816] = "U_Combining_Tilde_Below";
        CharCode[CharCode["U_Combining_Macron_Below"] = 817] = "U_Combining_Macron_Below";
        CharCode[CharCode["U_Combining_Low_Line"] = 818] = "U_Combining_Low_Line";
        CharCode[CharCode["U_Combining_Double_Low_Line"] = 819] = "U_Combining_Double_Low_Line";
        CharCode[CharCode["U_Combining_Tilde_Overlay"] = 820] = "U_Combining_Tilde_Overlay";
        CharCode[CharCode["U_Combining_Short_Stroke_Overlay"] = 821] = "U_Combining_Short_Stroke_Overlay";
        CharCode[CharCode["U_Combining_Long_Stroke_Overlay"] = 822] = "U_Combining_Long_Stroke_Overlay";
        CharCode[CharCode["U_Combining_Short_Solidus_Overlay"] = 823] = "U_Combining_Short_Solidus_Overlay";
        CharCode[CharCode["U_Combining_Long_Solidus_Overlay"] = 824] = "U_Combining_Long_Solidus_Overlay";
        CharCode[CharCode["U_Combining_Right_Half_Ring_Below"] = 825] = "U_Combining_Right_Half_Ring_Below";
        CharCode[CharCode["U_Combining_Inverted_Bridge_Below"] = 826] = "U_Combining_Inverted_Bridge_Below";
        CharCode[CharCode["U_Combining_Square_Below"] = 827] = "U_Combining_Square_Below";
        CharCode[CharCode["U_Combining_Seagull_Below"] = 828] = "U_Combining_Seagull_Below";
        CharCode[CharCode["U_Combining_X_Above"] = 829] = "U_Combining_X_Above";
        CharCode[CharCode["U_Combining_Vertical_Tilde"] = 830] = "U_Combining_Vertical_Tilde";
        CharCode[CharCode["U_Combining_Double_Overline"] = 831] = "U_Combining_Double_Overline";
        CharCode[CharCode["U_Combining_Grave_Tone_Mark"] = 832] = "U_Combining_Grave_Tone_Mark";
        CharCode[CharCode["U_Combining_Acute_Tone_Mark"] = 833] = "U_Combining_Acute_Tone_Mark";
        CharCode[CharCode["U_Combining_Greek_Perispomeni"] = 834] = "U_Combining_Greek_Perispomeni";
        CharCode[CharCode["U_Combining_Greek_Koronis"] = 835] = "U_Combining_Greek_Koronis";
        CharCode[CharCode["U_Combining_Greek_Dialytika_Tonos"] = 836] = "U_Combining_Greek_Dialytika_Tonos";
        CharCode[CharCode["U_Combining_Greek_Ypogegrammeni"] = 837] = "U_Combining_Greek_Ypogegrammeni";
        CharCode[CharCode["U_Combining_Bridge_Above"] = 838] = "U_Combining_Bridge_Above";
        CharCode[CharCode["U_Combining_Equals_Sign_Below"] = 839] = "U_Combining_Equals_Sign_Below";
        CharCode[CharCode["U_Combining_Double_Vertical_Line_Below"] = 840] = "U_Combining_Double_Vertical_Line_Below";
        CharCode[CharCode["U_Combining_Left_Angle_Below"] = 841] = "U_Combining_Left_Angle_Below";
        CharCode[CharCode["U_Combining_Not_Tilde_Above"] = 842] = "U_Combining_Not_Tilde_Above";
        CharCode[CharCode["U_Combining_Homothetic_Above"] = 843] = "U_Combining_Homothetic_Above";
        CharCode[CharCode["U_Combining_Almost_Equal_To_Above"] = 844] = "U_Combining_Almost_Equal_To_Above";
        CharCode[CharCode["U_Combining_Left_Right_Arrow_Below"] = 845] = "U_Combining_Left_Right_Arrow_Below";
        CharCode[CharCode["U_Combining_Upwards_Arrow_Below"] = 846] = "U_Combining_Upwards_Arrow_Below";
        CharCode[CharCode["U_Combining_Grapheme_Joiner"] = 847] = "U_Combining_Grapheme_Joiner";
        CharCode[CharCode["U_Combining_Right_Arrowhead_Above"] = 848] = "U_Combining_Right_Arrowhead_Above";
        CharCode[CharCode["U_Combining_Left_Half_Ring_Above"] = 849] = "U_Combining_Left_Half_Ring_Above";
        CharCode[CharCode["U_Combining_Fermata"] = 850] = "U_Combining_Fermata";
        CharCode[CharCode["U_Combining_X_Below"] = 851] = "U_Combining_X_Below";
        CharCode[CharCode["U_Combining_Left_Arrowhead_Below"] = 852] = "U_Combining_Left_Arrowhead_Below";
        CharCode[CharCode["U_Combining_Right_Arrowhead_Below"] = 853] = "U_Combining_Right_Arrowhead_Below";
        CharCode[CharCode["U_Combining_Right_Arrowhead_And_Up_Arrowhead_Below"] = 854] = "U_Combining_Right_Arrowhead_And_Up_Arrowhead_Below";
        CharCode[CharCode["U_Combining_Right_Half_Ring_Above"] = 855] = "U_Combining_Right_Half_Ring_Above";
        CharCode[CharCode["U_Combining_Dot_Above_Right"] = 856] = "U_Combining_Dot_Above_Right";
        CharCode[CharCode["U_Combining_Asterisk_Below"] = 857] = "U_Combining_Asterisk_Below";
        CharCode[CharCode["U_Combining_Double_Ring_Below"] = 858] = "U_Combining_Double_Ring_Below";
        CharCode[CharCode["U_Combining_Zigzag_Above"] = 859] = "U_Combining_Zigzag_Above";
        CharCode[CharCode["U_Combining_Double_Breve_Below"] = 860] = "U_Combining_Double_Breve_Below";
        CharCode[CharCode["U_Combining_Double_Breve"] = 861] = "U_Combining_Double_Breve";
        CharCode[CharCode["U_Combining_Double_Macron"] = 862] = "U_Combining_Double_Macron";
        CharCode[CharCode["U_Combining_Double_Macron_Below"] = 863] = "U_Combining_Double_Macron_Below";
        CharCode[CharCode["U_Combining_Double_Tilde"] = 864] = "U_Combining_Double_Tilde";
        CharCode[CharCode["U_Combining_Double_Inverted_Breve"] = 865] = "U_Combining_Double_Inverted_Breve";
        CharCode[CharCode["U_Combining_Double_Rightwards_Arrow_Below"] = 866] = "U_Combining_Double_Rightwards_Arrow_Below";
        CharCode[CharCode["U_Combining_Latin_Small_Letter_A"] = 867] = "U_Combining_Latin_Small_Letter_A";
        CharCode[CharCode["U_Combining_Latin_Small_Letter_E"] = 868] = "U_Combining_Latin_Small_Letter_E";
        CharCode[CharCode["U_Combining_Latin_Small_Letter_I"] = 869] = "U_Combining_Latin_Small_Letter_I";
        CharCode[CharCode["U_Combining_Latin_Small_Letter_O"] = 870] = "U_Combining_Latin_Small_Letter_O";
        CharCode[CharCode["U_Combining_Latin_Small_Letter_U"] = 871] = "U_Combining_Latin_Small_Letter_U";
        CharCode[CharCode["U_Combining_Latin_Small_Letter_C"] = 872] = "U_Combining_Latin_Small_Letter_C";
        CharCode[CharCode["U_Combining_Latin_Small_Letter_D"] = 873] = "U_Combining_Latin_Small_Letter_D";
        CharCode[CharCode["U_Combining_Latin_Small_Letter_H"] = 874] = "U_Combining_Latin_Small_Letter_H";
        CharCode[CharCode["U_Combining_Latin_Small_Letter_M"] = 875] = "U_Combining_Latin_Small_Letter_M";
        CharCode[CharCode["U_Combining_Latin_Small_Letter_R"] = 876] = "U_Combining_Latin_Small_Letter_R";
        CharCode[CharCode["U_Combining_Latin_Small_Letter_T"] = 877] = "U_Combining_Latin_Small_Letter_T";
        CharCode[CharCode["U_Combining_Latin_Small_Letter_V"] = 878] = "U_Combining_Latin_Small_Letter_V";
        CharCode[CharCode["U_Combining_Latin_Small_Letter_X"] = 879] = "U_Combining_Latin_Small_Letter_X";
        /**
         * Unicode Character 'LINE SEPARATOR' (U+2028)
         * http://www.fileformat.info/info/unicode/char/2028/index.htm
         */
        CharCode[CharCode["LINE_SEPARATOR"] = 8232] = "LINE_SEPARATOR";
        /**
         * Unicode Character 'PARAGRAPH SEPARATOR' (U+2029)
         * http://www.fileformat.info/info/unicode/char/2029/index.htm
         */
        CharCode[CharCode["PARAGRAPH_SEPARATOR"] = 8233] = "PARAGRAPH_SEPARATOR";
        /**
         * Unicode Character 'NEXT LINE' (U+0085)
         * http://www.fileformat.info/info/unicode/char/0085/index.htm
         */
        CharCode[CharCode["NEXT_LINE"] = 133] = "NEXT_LINE";
        // http://www.fileformat.info/info/unicode/category/Sk/list.htm
        CharCode[CharCode["U_CIRCUMFLEX"] = 94] = "U_CIRCUMFLEX";
        CharCode[CharCode["U_GRAVE_ACCENT"] = 96] = "U_GRAVE_ACCENT";
        CharCode[CharCode["U_DIAERESIS"] = 168] = "U_DIAERESIS";
        CharCode[CharCode["U_MACRON"] = 175] = "U_MACRON";
        CharCode[CharCode["U_ACUTE_ACCENT"] = 180] = "U_ACUTE_ACCENT";
        CharCode[CharCode["U_CEDILLA"] = 184] = "U_CEDILLA";
        CharCode[CharCode["U_MODIFIER_LETTER_LEFT_ARROWHEAD"] = 706] = "U_MODIFIER_LETTER_LEFT_ARROWHEAD";
        CharCode[CharCode["U_MODIFIER_LETTER_RIGHT_ARROWHEAD"] = 707] = "U_MODIFIER_LETTER_RIGHT_ARROWHEAD";
        CharCode[CharCode["U_MODIFIER_LETTER_UP_ARROWHEAD"] = 708] = "U_MODIFIER_LETTER_UP_ARROWHEAD";
        CharCode[CharCode["U_MODIFIER_LETTER_DOWN_ARROWHEAD"] = 709] = "U_MODIFIER_LETTER_DOWN_ARROWHEAD";
        CharCode[CharCode["U_MODIFIER_LETTER_CENTRED_RIGHT_HALF_RING"] = 722] = "U_MODIFIER_LETTER_CENTRED_RIGHT_HALF_RING";
        CharCode[CharCode["U_MODIFIER_LETTER_CENTRED_LEFT_HALF_RING"] = 723] = "U_MODIFIER_LETTER_CENTRED_LEFT_HALF_RING";
        CharCode[CharCode["U_MODIFIER_LETTER_UP_TACK"] = 724] = "U_MODIFIER_LETTER_UP_TACK";
        CharCode[CharCode["U_MODIFIER_LETTER_DOWN_TACK"] = 725] = "U_MODIFIER_LETTER_DOWN_TACK";
        CharCode[CharCode["U_MODIFIER_LETTER_PLUS_SIGN"] = 726] = "U_MODIFIER_LETTER_PLUS_SIGN";
        CharCode[CharCode["U_MODIFIER_LETTER_MINUS_SIGN"] = 727] = "U_MODIFIER_LETTER_MINUS_SIGN";
        CharCode[CharCode["U_BREVE"] = 728] = "U_BREVE";
        CharCode[CharCode["U_DOT_ABOVE"] = 729] = "U_DOT_ABOVE";
        CharCode[CharCode["U_RING_ABOVE"] = 730] = "U_RING_ABOVE";
        CharCode[CharCode["U_OGONEK"] = 731] = "U_OGONEK";
        CharCode[CharCode["U_SMALL_TILDE"] = 732] = "U_SMALL_TILDE";
        CharCode[CharCode["U_DOUBLE_ACUTE_ACCENT"] = 733] = "U_DOUBLE_ACUTE_ACCENT";
        CharCode[CharCode["U_MODIFIER_LETTER_RHOTIC_HOOK"] = 734] = "U_MODIFIER_LETTER_RHOTIC_HOOK";
        CharCode[CharCode["U_MODIFIER_LETTER_CROSS_ACCENT"] = 735] = "U_MODIFIER_LETTER_CROSS_ACCENT";
        CharCode[CharCode["U_MODIFIER_LETTER_EXTRA_HIGH_TONE_BAR"] = 741] = "U_MODIFIER_LETTER_EXTRA_HIGH_TONE_BAR";
        CharCode[CharCode["U_MODIFIER_LETTER_HIGH_TONE_BAR"] = 742] = "U_MODIFIER_LETTER_HIGH_TONE_BAR";
        CharCode[CharCode["U_MODIFIER_LETTER_MID_TONE_BAR"] = 743] = "U_MODIFIER_LETTER_MID_TONE_BAR";
        CharCode[CharCode["U_MODIFIER_LETTER_LOW_TONE_BAR"] = 744] = "U_MODIFIER_LETTER_LOW_TONE_BAR";
        CharCode[CharCode["U_MODIFIER_LETTER_EXTRA_LOW_TONE_BAR"] = 745] = "U_MODIFIER_LETTER_EXTRA_LOW_TONE_BAR";
        CharCode[CharCode["U_MODIFIER_LETTER_YIN_DEPARTING_TONE_MARK"] = 746] = "U_MODIFIER_LETTER_YIN_DEPARTING_TONE_MARK";
        CharCode[CharCode["U_MODIFIER_LETTER_YANG_DEPARTING_TONE_MARK"] = 747] = "U_MODIFIER_LETTER_YANG_DEPARTING_TONE_MARK";
        CharCode[CharCode["U_MODIFIER_LETTER_UNASPIRATED"] = 749] = "U_MODIFIER_LETTER_UNASPIRATED";
        CharCode[CharCode["U_MODIFIER_LETTER_LOW_DOWN_ARROWHEAD"] = 751] = "U_MODIFIER_LETTER_LOW_DOWN_ARROWHEAD";
        CharCode[CharCode["U_MODIFIER_LETTER_LOW_UP_ARROWHEAD"] = 752] = "U_MODIFIER_LETTER_LOW_UP_ARROWHEAD";
        CharCode[CharCode["U_MODIFIER_LETTER_LOW_LEFT_ARROWHEAD"] = 753] = "U_MODIFIER_LETTER_LOW_LEFT_ARROWHEAD";
        CharCode[CharCode["U_MODIFIER_LETTER_LOW_RIGHT_ARROWHEAD"] = 754] = "U_MODIFIER_LETTER_LOW_RIGHT_ARROWHEAD";
        CharCode[CharCode["U_MODIFIER_LETTER_LOW_RING"] = 755] = "U_MODIFIER_LETTER_LOW_RING";
        CharCode[CharCode["U_MODIFIER_LETTER_MIDDLE_GRAVE_ACCENT"] = 756] = "U_MODIFIER_LETTER_MIDDLE_GRAVE_ACCENT";
        CharCode[CharCode["U_MODIFIER_LETTER_MIDDLE_DOUBLE_GRAVE_ACCENT"] = 757] = "U_MODIFIER_LETTER_MIDDLE_DOUBLE_GRAVE_ACCENT";
        CharCode[CharCode["U_MODIFIER_LETTER_MIDDLE_DOUBLE_ACUTE_ACCENT"] = 758] = "U_MODIFIER_LETTER_MIDDLE_DOUBLE_ACUTE_ACCENT";
        CharCode[CharCode["U_MODIFIER_LETTER_LOW_TILDE"] = 759] = "U_MODIFIER_LETTER_LOW_TILDE";
        CharCode[CharCode["U_MODIFIER_LETTER_RAISED_COLON"] = 760] = "U_MODIFIER_LETTER_RAISED_COLON";
        CharCode[CharCode["U_MODIFIER_LETTER_BEGIN_HIGH_TONE"] = 761] = "U_MODIFIER_LETTER_BEGIN_HIGH_TONE";
        CharCode[CharCode["U_MODIFIER_LETTER_END_HIGH_TONE"] = 762] = "U_MODIFIER_LETTER_END_HIGH_TONE";
        CharCode[CharCode["U_MODIFIER_LETTER_BEGIN_LOW_TONE"] = 763] = "U_MODIFIER_LETTER_BEGIN_LOW_TONE";
        CharCode[CharCode["U_MODIFIER_LETTER_END_LOW_TONE"] = 764] = "U_MODIFIER_LETTER_END_LOW_TONE";
        CharCode[CharCode["U_MODIFIER_LETTER_SHELF"] = 765] = "U_MODIFIER_LETTER_SHELF";
        CharCode[CharCode["U_MODIFIER_LETTER_OPEN_SHELF"] = 766] = "U_MODIFIER_LETTER_OPEN_SHELF";
        CharCode[CharCode["U_MODIFIER_LETTER_LOW_LEFT_ARROW"] = 767] = "U_MODIFIER_LETTER_LOW_LEFT_ARROW";
        CharCode[CharCode["U_GREEK_LOWER_NUMERAL_SIGN"] = 885] = "U_GREEK_LOWER_NUMERAL_SIGN";
        CharCode[CharCode["U_GREEK_TONOS"] = 900] = "U_GREEK_TONOS";
        CharCode[CharCode["U_GREEK_DIALYTIKA_TONOS"] = 901] = "U_GREEK_DIALYTIKA_TONOS";
        CharCode[CharCode["U_GREEK_KORONIS"] = 8125] = "U_GREEK_KORONIS";
        CharCode[CharCode["U_GREEK_PSILI"] = 8127] = "U_GREEK_PSILI";
        CharCode[CharCode["U_GREEK_PERISPOMENI"] = 8128] = "U_GREEK_PERISPOMENI";
        CharCode[CharCode["U_GREEK_DIALYTIKA_AND_PERISPOMENI"] = 8129] = "U_GREEK_DIALYTIKA_AND_PERISPOMENI";
        CharCode[CharCode["U_GREEK_PSILI_AND_VARIA"] = 8141] = "U_GREEK_PSILI_AND_VARIA";
        CharCode[CharCode["U_GREEK_PSILI_AND_OXIA"] = 8142] = "U_GREEK_PSILI_AND_OXIA";
        CharCode[CharCode["U_GREEK_PSILI_AND_PERISPOMENI"] = 8143] = "U_GREEK_PSILI_AND_PERISPOMENI";
        CharCode[CharCode["U_GREEK_DASIA_AND_VARIA"] = 8157] = "U_GREEK_DASIA_AND_VARIA";
        CharCode[CharCode["U_GREEK_DASIA_AND_OXIA"] = 8158] = "U_GREEK_DASIA_AND_OXIA";
        CharCode[CharCode["U_GREEK_DASIA_AND_PERISPOMENI"] = 8159] = "U_GREEK_DASIA_AND_PERISPOMENI";
        CharCode[CharCode["U_GREEK_DIALYTIKA_AND_VARIA"] = 8173] = "U_GREEK_DIALYTIKA_AND_VARIA";
        CharCode[CharCode["U_GREEK_DIALYTIKA_AND_OXIA"] = 8174] = "U_GREEK_DIALYTIKA_AND_OXIA";
        CharCode[CharCode["U_GREEK_VARIA"] = 8175] = "U_GREEK_VARIA";
        CharCode[CharCode["U_GREEK_OXIA"] = 8189] = "U_GREEK_OXIA";
        CharCode[CharCode["U_GREEK_DASIA"] = 8190] = "U_GREEK_DASIA";
        CharCode[CharCode["U_IDEOGRAPHIC_FULL_STOP"] = 12290] = "U_IDEOGRAPHIC_FULL_STOP";
        CharCode[CharCode["U_LEFT_CORNER_BRACKET"] = 12300] = "U_LEFT_CORNER_BRACKET";
        CharCode[CharCode["U_RIGHT_CORNER_BRACKET"] = 12301] = "U_RIGHT_CORNER_BRACKET";
        CharCode[CharCode["U_LEFT_BLACK_LENTICULAR_BRACKET"] = 12304] = "U_LEFT_BLACK_LENTICULAR_BRACKET";
        CharCode[CharCode["U_RIGHT_BLACK_LENTICULAR_BRACKET"] = 12305] = "U_RIGHT_BLACK_LENTICULAR_BRACKET";
        CharCode[CharCode["U_OVERLINE"] = 8254] = "U_OVERLINE";
        /**
         * UTF-8 BOM
         * Unicode Character 'ZERO WIDTH NO-BREAK SPACE' (U+FEFF)
         * http://www.fileformat.info/info/unicode/char/feff/index.htm
         */
        CharCode[CharCode["UTF8_BOM"] = 65279] = "UTF8_BOM";
        CharCode[CharCode["U_FULLWIDTH_SEMICOLON"] = 65307] = "U_FULLWIDTH_SEMICOLON";
        CharCode[CharCode["U_FULLWIDTH_COMMA"] = 65292] = "U_FULLWIDTH_COMMA";
    })(CharCode || (exports.CharCode = CharCode = {}));
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[45/*vs/base/common/collections*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    var _a;
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$i = void 0;
    exports.$e = $e;
    exports.$f = $f;
    exports.$g = $g;
    exports.$h = $h;
    /**
     * Groups the collection into a dictionary based on the provided
     * group function.
     */
    function $e(data, groupFn) {
        const result = Object.create(null);
        for (const element of data) {
            const key = groupFn(element);
            let target = result[key];
            if (!target) {
                target = result[key] = [];
            }
            target.push(element);
        }
        return result;
    }
    function $f(before, after) {
        const removed = [];
        const added = [];
        for (const element of before) {
            if (!after.has(element)) {
                removed.push(element);
            }
        }
        for (const element of after) {
            if (!before.has(element)) {
                added.push(element);
            }
        }
        return { removed, added };
    }
    function $g(before, after) {
        const removed = [];
        const added = [];
        for (const [index, value] of before) {
            if (!after.has(index)) {
                removed.push(value);
            }
        }
        for (const [index, value] of after) {
            if (!before.has(index)) {
                added.push(value);
            }
        }
        return { removed, added };
    }
    /**
     * Computes the intersection of two sets.
     *
     * @param setA - The first set.
     * @param setB - The second iterable.
     * @returns A new set containing the elements that are in both `setA` and `setB`.
     */
    function $h(setA, setB) {
        const result = new Set();
        for (const elem of setB) {
            if (setA.has(elem)) {
                result.add(elem);
            }
        }
        return result;
    }
    class $i {
        static { _a = Symbol.toStringTag; }
        constructor(values, b) {
            this.b = b;
            this.a = new Map();
            this[_a] = 'SetWithKey';
            for (const value of values) {
                this.add(value);
            }
        }
        get size() {
            return this.a.size;
        }
        add(value) {
            const key = this.b(value);
            this.a.set(key, value);
            return this;
        }
        delete(value) {
            return this.a.delete(this.b(value));
        }
        has(value) {
            return this.a.has(this.b(value));
        }
        *entries() {
            for (const entry of this.a.values()) {
                yield [entry, entry];
            }
        }
        keys() {
            return this.values();
        }
        *values() {
            for (const entry of this.a.values()) {
                yield entry;
            }
        }
        clear() {
            this.a.clear();
        }
        forEach(callbackfn, thisArg) {
            this.a.forEach(entry => callbackfn.call(thisArg, entry, entry, this));
        }
        [Symbol.iterator]() {
            return this.values();
        }
    }
    exports.$i = $i;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[14/*vs/base/common/decorators*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$ci = $ci;
    exports.$di = $di;
    exports.$ei = $ei;
    function createDecorator(mapFn) {
        return (target, key, descriptor) => {
            let fnKey = null;
            let fn = null;
            if (typeof descriptor.value === 'function') {
                fnKey = 'value';
                fn = descriptor.value;
            }
            else if (typeof descriptor.get === 'function') {
                fnKey = 'get';
                fn = descriptor.get;
            }
            if (!fn) {
                throw new Error('not supported');
            }
            descriptor[fnKey] = mapFn(fn, key);
        };
    }
    function $ci(_target, key, descriptor) {
        let fnKey = null;
        let fn = null;
        if (typeof descriptor.value === 'function') {
            fnKey = 'value';
            fn = descriptor.value;
            if (fn.length !== 0) {
                console.warn('Memoize should only be used in functions with zero parameters');
            }
        }
        else if (typeof descriptor.get === 'function') {
            fnKey = 'get';
            fn = descriptor.get;
        }
        if (!fn) {
            throw new Error('not supported');
        }
        const memoizeKey = `$memoize$${key}`;
        descriptor[fnKey] = function (...args) {
            if (!this.hasOwnProperty(memoizeKey)) {
                Object.defineProperty(this, memoizeKey, {
                    configurable: false,
                    enumerable: false,
                    writable: false,
                    value: fn.apply(this, args)
                });
            }
            return this[memoizeKey];
        };
    }
    function $di(delay, reducer, initialValueProvider) {
        return createDecorator((fn, key) => {
            const timerKey = `$debounce$${key}`;
            const resultKey = `$debounce$result$${key}`;
            return function (...args) {
                if (!this[resultKey]) {
                    this[resultKey] = initialValueProvider ? initialValueProvider() : undefined;
                }
                clearTimeout(this[timerKey]);
                if (reducer) {
                    this[resultKey] = reducer(this[resultKey], ...args);
                    args = [this[resultKey]];
                }
                this[timerKey] = setTimeout(() => {
                    fn.apply(this, args);
                    this[resultKey] = initialValueProvider ? initialValueProvider() : undefined;
                }, delay);
            };
        });
    }
    function $ei(delay, reducer, initialValueProvider) {
        return createDecorator((fn, key) => {
            const timerKey = `$throttle$timer$${key}`;
            const resultKey = `$throttle$result$${key}`;
            const lastRunKey = `$throttle$lastRun$${key}`;
            const pendingKey = `$throttle$pending$${key}`;
            return function (...args) {
                if (!this[resultKey]) {
                    this[resultKey] = initialValueProvider ? initialValueProvider() : undefined;
                }
                if (this[lastRunKey] === null || this[lastRunKey] === undefined) {
                    this[lastRunKey] = -Number.MAX_VALUE;
                }
                if (reducer) {
                    this[resultKey] = reducer(this[resultKey], ...args);
                }
                if (this[pendingKey]) {
                    return;
                }
                const nextTime = this[lastRunKey] + delay;
                if (nextTime <= Date.now()) {
                    this[lastRunKey] = Date.now();
                    fn.apply(this, [this[resultKey]]);
                    this[resultKey] = initialValueProvider ? initialValueProvider() : undefined;
                }
                else {
                    this[pendingKey] = true;
                    this[timerKey] = setTimeout(() => {
                        this[pendingKey] = false;
                        this[lastRunKey] = Date.now();
                        fn.apply(this, [this[resultKey]]);
                        this[resultKey] = initialValueProvider ? initialValueProvider() : undefined;
                    }, nextTime - Date.now());
                }
            };
        });
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[7/*vs/base/common/errors*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$gb = exports.$fb = exports.$eb = exports.$db = exports.$cb = exports.$ab = exports.$9 = exports.$1 = exports.$Z = void 0;
    exports.setUnexpectedErrorHandler = setUnexpectedErrorHandler;
    exports.$3 = $3;
    exports.$4 = $4;
    exports.$5 = $5;
    exports.$6 = $6;
    exports.$7 = $7;
    exports.$8 = $8;
    exports.$0 = $0;
    exports.$$ = $$;
    exports.$_ = $_;
    exports.$bb = $bb;
    // Avoid circular dependency on EventEmitter by implementing a subset of the interface.
    class $Z {
        constructor() {
            this.b = [];
            this.a = function (e) {
                setTimeout(() => {
                    if (e.stack) {
                        if ($fb.isErrorNoTelemetry(e)) {
                            throw new $fb(e.message + '\n\n' + e.stack);
                        }
                        throw new Error(e.message + '\n\n' + e.stack);
                    }
                    throw e;
                }, 0);
            };
        }
        addListener(listener) {
            this.b.push(listener);
            return () => {
                this.d(listener);
            };
        }
        c(e) {
            this.b.forEach((listener) => {
                listener(e);
            });
        }
        d(listener) {
            this.b.splice(this.b.indexOf(listener), 1);
        }
        setUnexpectedErrorHandler(newUnexpectedErrorHandler) {
            this.a = newUnexpectedErrorHandler;
        }
        getUnexpectedErrorHandler() {
            return this.a;
        }
        onUnexpectedError(e) {
            this.a(e);
            this.c(e);
        }
        // For external errors, we don't want the listeners to be called
        onUnexpectedExternalError(e) {
            this.a(e);
        }
    }
    exports.$Z = $Z;
    exports.$1 = new $Z();
    /** @skipMangle */
    function setUnexpectedErrorHandler(newUnexpectedErrorHandler) {
        exports.$1.setUnexpectedErrorHandler(newUnexpectedErrorHandler);
    }
    /**
     * Returns if the error is a SIGPIPE error. SIGPIPE errors should generally be
     * logged at most once, to avoid a loop.
     *
     * @see https://github.com/microsoft/vscode-remote-release/issues/6481
     */
    function $3(e) {
        if (!e || typeof e !== 'object') {
            return false;
        }
        const cast = e;
        return cast.code === 'EPIPE' && cast.syscall?.toUpperCase() === 'WRITE';
    }
    function $4(e) {
        // ignore errors from cancelled promises
        if (!$8(e)) {
            exports.$1.onUnexpectedError(e);
        }
        return undefined;
    }
    function $5(e) {
        // ignore errors from cancelled promises
        if (!$8(e)) {
            exports.$1.onUnexpectedExternalError(e);
        }
        return undefined;
    }
    function $6(error) {
        if (error instanceof Error) {
            const { name, message } = error;
            const stack = error.stacktrace || error.stack;
            return {
                $isError: true,
                name,
                message,
                stack,
                noTelemetry: $fb.isErrorNoTelemetry(error)
            };
        }
        // return as is
        return error;
    }
    function $7(data) {
        let error;
        if (data.noTelemetry) {
            error = new $fb();
        }
        else {
            error = new Error();
            error.name = data.name;
        }
        error.message = data.message;
        error.stack = data.stack;
        return error;
    }
    const canceledName = 'Canceled';
    /**
     * Checks if the given error is a promise in canceled state
     */
    function $8(error) {
        if (error instanceof $9) {
            return true;
        }
        return error instanceof Error && error.name === canceledName && error.message === canceledName;
    }
    // !!!IMPORTANT!!!
    // Do NOT change this class because it is also used as an API-type.
    class $9 extends Error {
        constructor() {
            super(canceledName);
            this.name = this.message;
        }
    }
    exports.$9 = $9;
    /**
     * @deprecated use {@link $9 `new CancellationError()`} instead
     */
    function $0() {
        const error = new Error(canceledName);
        error.name = error.message;
        return error;
    }
    function $$(name) {
        if (name) {
            return new Error(`Illegal argument: ${name}`);
        }
        else {
            return new Error('Illegal argument');
        }
    }
    function $_(name) {
        if (name) {
            return new Error(`Illegal state: ${name}`);
        }
        else {
            return new Error('Illegal state');
        }
    }
    class $ab extends TypeError {
        constructor(name) {
            super(name ? `${name} is read-only and cannot be changed` : 'Cannot change read-only property');
        }
    }
    exports.$ab = $ab;
    function $bb(err) {
        if (!err) {
            return 'Error';
        }
        if (err.message) {
            return err.message;
        }
        if (err.stack) {
            return err.stack.split('\n')[0];
        }
        return String(err);
    }
    class $cb extends Error {
        constructor(message) {
            super('NotImplemented');
            if (message) {
                this.message = message;
            }
        }
    }
    exports.$cb = $cb;
    class $db extends Error {
        constructor(message) {
            super('NotSupported');
            if (message) {
                this.message = message;
            }
        }
    }
    exports.$db = $db;
    class $eb extends Error {
        constructor() {
            super(...arguments);
            this.isExpected = true;
        }
    }
    exports.$eb = $eb;
    /**
     * Error that when thrown won't be logged in telemetry as an unhandled error.
     */
    class $fb extends Error {
        constructor(msg) {
            super(msg);
            this.name = 'CodeExpectedError';
        }
        static fromError(err) {
            if (err instanceof $fb) {
                return err;
            }
            const result = new $fb();
            result.message = err.message;
            result.stack = err.stack;
            return result;
        }
        static isErrorNoTelemetry(err) {
            return err.name === 'CodeExpectedError';
        }
    }
    exports.$fb = $fb;
    /**
     * This error indicates a bug.
     * Do not throw this for invalid user input.
     * Only catch this error to recover gracefully from bugs.
     */
    class $gb extends Error {
        constructor(message) {
            super(message || 'An unexpected bug occurred.');
            Object.setPrototypeOf(this, $gb.prototype);
            // Because we know for sure only buggy code throws this,
            // we definitely want to break here and fix the bug.
            // eslint-disable-next-line no-debugger
            // debugger;
        }
    }
    exports.$gb = $gb;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[17/*vs/base/common/arrays*/], __M([0/*require*/,1/*exports*/,7/*vs/base/common/errors*/,44/*vs/base/common/arraysFind*/]), function (require, exports, errors_1, arraysFind_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$ec = exports.$dc = exports.$cc = exports.$ac = exports.$_b = exports.CompareResult = void 0;
    exports.$wb = $wb;
    exports.$xb = $xb;
    exports.$yb = $yb;
    exports.$zb = $zb;
    exports.$Ab = $Ab;
    exports.$Bb = $Bb;
    exports.$Cb = $Cb;
    exports.$Db = $Db;
    exports.$Eb = $Eb;
    exports.$Fb = $Fb;
    exports.$Gb = $Gb;
    exports.$Hb = $Hb;
    exports.$Ib = $Ib;
    exports.top = top;
    exports.$Kb = $Kb;
    exports.$Lb = $Lb;
    exports.$Mb = $Mb;
    exports.$Nb = $Nb;
    exports.$Ob = $Ob;
    exports.$Pb = $Pb;
    exports.$Qb = $Qb;
    exports.$Rb = $Rb;
    exports.$Sb = $Sb;
    exports.$Tb = $Tb;
    exports.$Ub = $Ub;
    exports.$Vb = $Vb;
    exports.$Wb = $Wb;
    exports.$Xb = $Xb;
    exports.$Yb = $Yb;
    exports.$Zb = $Zb;
    exports.$1b = $1b;
    exports.$2b = $2b;
    exports.$3b = $3b;
    exports.$4b = $4b;
    exports.$5b = $5b;
    exports.$6b = $6b;
    exports.$7b = $7b;
    exports.$8b = $8b;
    exports.$9b = $9b;
    exports.$0b = $0b;
    exports.$$b = $$b;
    exports.$bc = $bc;
    exports.$fc = $fc;
    /**
     * Returns the last element of an array.
     * @param array The array.
     * @param n Which element from the end (default is zero).
     */
    function $wb(array, n = 0) {
        return array[array.length - (1 + n)];
    }
    function $xb(arr) {
        if (arr.length === 0) {
            throw new Error('Invalid tail call');
        }
        return [arr.slice(0, arr.length - 1), arr[arr.length - 1]];
    }
    function $yb(one, other, itemEquals = (a, b) => a === b) {
        if (one === other) {
            return true;
        }
        if (!one || !other) {
            return false;
        }
        if (one.length !== other.length) {
            return false;
        }
        for (let i = 0, len = one.length; i < len; i++) {
            if (!itemEquals(one[i], other[i])) {
                return false;
            }
        }
        return true;
    }
    /**
     * Remove the element at `index` by replacing it with the last element. This is faster than `splice`
     * but changes the order of the array
     */
    function $zb(array, index) {
        const last = array.length - 1;
        if (index < last) {
            array[index] = array[last];
        }
        array.pop();
    }
    /**
     * Performs a binary search algorithm over a sorted array.
     *
     * @param array The array being searched.
     * @param key The value we search for.
     * @param comparator A function that takes two array elements and returns zero
     *   if they are equal, a negative number if the first element precedes the
     *   second one in the sorting order, or a positive number if the second element
     *   precedes the first one.
     * @return See {@link $Bb}
     */
    function $Ab(array, key, comparator) {
        return $Bb(array.length, i => comparator(array[i], key));
    }
    /**
     * Performs a binary search algorithm over a sorted collection. Useful for cases
     * when we need to perform a binary search over something that isn't actually an
     * array, and converting data to an array would defeat the use of binary search
     * in the first place.
     *
     * @param length The collection length.
     * @param compareToKey A function that takes an index of an element in the
     *   collection and returns zero if the value at this index is equal to the
     *   search key, a negative number if the value precedes the search key in the
     *   sorting order, or a positive number if the search key precedes the value.
     * @return A non-negative index of an element, if found. If not found, the
     *   result is -(n+1) (or ~n, using bitwise notation), where n is the index
     *   where the key should be inserted to maintain the sorting order.
     */
    function $Bb(length, compareToKey) {
        let low = 0, high = length - 1;
        while (low <= high) {
            const mid = ((low + high) / 2) | 0;
            const comp = compareToKey(mid);
            if (comp < 0) {
                low = mid + 1;
            }
            else if (comp > 0) {
                high = mid - 1;
            }
            else {
                return mid;
            }
        }
        return -(low + 1);
    }
    function $Cb(nth, data, compare) {
        nth = nth | 0;
        if (nth >= data.length) {
            throw new TypeError('invalid index');
        }
        const pivotValue = data[Math.floor(data.length * Math.random())];
        const lower = [];
        const higher = [];
        const pivots = [];
        for (const value of data) {
            const val = compare(value, pivotValue);
            if (val < 0) {
                lower.push(value);
            }
            else if (val > 0) {
                higher.push(value);
            }
            else {
                pivots.push(value);
            }
        }
        if (nth < lower.length) {
            return $Cb(nth, lower, compare);
        }
        else if (nth < lower.length + pivots.length) {
            return pivots[0];
        }
        else {
            return $Cb(nth - (lower.length + pivots.length), higher, compare);
        }
    }
    function $Db(data, compare) {
        const result = [];
        let currentGroup = undefined;
        for (const element of data.slice(0).sort(compare)) {
            if (!currentGroup || compare(currentGroup[0], element) !== 0) {
                currentGroup = [element];
                result.push(currentGroup);
            }
            else {
                currentGroup.push(element);
            }
        }
        return result;
    }
    /**
     * Splits the given items into a list of (non-empty) groups.
     * `shouldBeGrouped` is used to decide if two consecutive items should be in the same group.
     * The order of the items is preserved.
     */
    function* $Eb(items, shouldBeGrouped) {
        let currentGroup;
        let last;
        for (const item of items) {
            if (last !== undefined && shouldBeGrouped(last, item)) {
                currentGroup.push(item);
            }
            else {
                if (currentGroup) {
                    yield currentGroup;
                }
                currentGroup = [item];
            }
            last = item;
        }
        if (currentGroup) {
            yield currentGroup;
        }
    }
    function $Fb(arr, f) {
        for (let i = 0; i <= arr.length; i++) {
            f(i === 0 ? undefined : arr[i - 1], i === arr.length ? undefined : arr[i]);
        }
    }
    function $Gb(arr, f) {
        for (let i = 0; i < arr.length; i++) {
            f(i === 0 ? undefined : arr[i - 1], arr[i], i + 1 === arr.length ? undefined : arr[i + 1]);
        }
    }
    /**
     * Diffs two *sorted* arrays and computes the splices which apply the diff.
     */
    function $Hb(before, after, compare) {
        const result = [];
        function pushSplice(start, deleteCount, toInsert) {
            if (deleteCount === 0 && toInsert.length === 0) {
                return;
            }
            const latest = result[result.length - 1];
            if (latest && latest.start + latest.deleteCount === start) {
                latest.deleteCount += deleteCount;
                latest.toInsert.push(...toInsert);
            }
            else {
                result.push({ start, deleteCount, toInsert });
            }
        }
        let beforeIdx = 0;
        let afterIdx = 0;
        while (true) {
            if (beforeIdx === before.length) {
                pushSplice(beforeIdx, 0, after.slice(afterIdx));
                break;
            }
            if (afterIdx === after.length) {
                pushSplice(beforeIdx, before.length - beforeIdx, []);
                break;
            }
            const beforeElement = before[beforeIdx];
            const afterElement = after[afterIdx];
            const n = compare(beforeElement, afterElement);
            if (n === 0) {
                // equal
                beforeIdx += 1;
                afterIdx += 1;
            }
            else if (n < 0) {
                // beforeElement is smaller -> before element removed
                pushSplice(beforeIdx, 1, []);
                beforeIdx += 1;
            }
            else if (n > 0) {
                // beforeElement is greater -> after element added
                pushSplice(beforeIdx, 0, [afterElement]);
                afterIdx += 1;
            }
        }
        return result;
    }
    /**
     * Takes two *sorted* arrays and computes their delta (removed, added elements).
     * Finishes in `Math.min(before.length, after.length)` steps.
     */
    function $Ib(before, after, compare) {
        const splices = $Hb(before, after, compare);
        const removed = [];
        const added = [];
        for (const splice of splices) {
            removed.push(...before.slice(splice.start, splice.start + splice.deleteCount));
            added.push(...splice.toInsert);
        }
        return { removed, added };
    }
    /**
     * Returns the top N elements from the array.
     *
     * Faster than sorting the entire array when the array is a lot larger than N.
     *
     * @param array The unsorted array.
     * @param compare A sort function for the elements.
     * @param n The number of elements to return.
     * @return The first n elements from array when sorted with compare.
     */
    function top(array, compare, n) {
        if (n === 0) {
            return [];
        }
        const result = array.slice(0, n).sort(compare);
        topStep(array, compare, result, n, array.length);
        return result;
    }
    /**
     * Asynchronous variant of `top()` allowing for splitting up work in batches between which the event loop can run.
     *
     * Returns the top N elements from the array.
     *
     * Faster than sorting the entire array when the array is a lot larger than N.
     *
     * @param array The unsorted array.
     * @param compare A sort function for the elements.
     * @param n The number of elements to return.
     * @param batch The number of elements to examine before yielding to the event loop.
     * @return The first n elements from array when sorted with compare.
     */
    function $Kb(array, compare, n, batch, token) {
        if (n === 0) {
            return Promise.resolve([]);
        }
        return new Promise((resolve, reject) => {
            (async () => {
                const o = array.length;
                const result = array.slice(0, n).sort(compare);
                for (let i = n, m = Math.min(n + batch, o); i < o; i = m, m = Math.min(m + batch, o)) {
                    if (i > n) {
                        await new Promise(resolve => setTimeout(resolve)); // any other delay function would starve I/O
                    }
                    if (token && token.isCancellationRequested) {
                        throw new errors_1.$9();
                    }
                    topStep(array, compare, result, i, m);
                }
                return result;
            })()
                .then(resolve, reject);
        });
    }
    function topStep(array, compare, result, i, m) {
        for (const n = result.length; i < m; i++) {
            const element = array[i];
            if (compare(element, result[n - 1]) < 0) {
                result.pop();
                const j = (0, arraysFind_1.$ob)(result, e => compare(element, e) < 0);
                result.splice(j, 0, element);
            }
        }
    }
    /**
     * @returns New array with all falsy values removed. The original array IS NOT modified.
     */
    function $Lb(array) {
        return array.filter((e) => !!e);
    }
    /**
     * Remove all falsy values from `array`. The original array IS modified.
     */
    function $Mb(array) {
        let to = 0;
        for (let i = 0; i < array.length; i++) {
            if (!!array[i]) {
                array[to] = array[i];
                to += 1;
            }
        }
        array.length = to;
    }
    /**
     * @deprecated Use `Array.copyWithin` instead
     */
    function $Nb(array, from, to) {
        array.splice(to, 0, array.splice(from, 1)[0]);
    }
    /**
     * @returns false if the provided object is an array and not empty.
     */
    function $Ob(obj) {
        return !Array.isArray(obj) || obj.length === 0;
    }
    function $Pb(obj) {
        return Array.isArray(obj) && obj.length > 0;
    }
    /**
     * Removes duplicates from the given array. The optional keyFn allows to specify
     * how elements are checked for equality by returning an alternate value for each.
     */
    function $Qb(array, keyFn = value => value) {
        const seen = new Set();
        return array.filter(element => {
            const key = keyFn(element);
            if (seen.has(key)) {
                return false;
            }
            seen.add(key);
            return true;
        });
    }
    function $Rb(keyFn) {
        const seen = new Set();
        return element => {
            const key = keyFn(element);
            if (seen.has(key)) {
                return false;
            }
            seen.add(key);
            return true;
        };
    }
    function $Sb(array, notFoundValue) {
        return array.length > 0 ? array[0] : notFoundValue;
    }
    function $Tb(array, notFoundValue) {
        return array.length > 0 ? array[array.length - 1] : notFoundValue;
    }
    function $Ub(one, other, equals = (a, b) => a === b) {
        let result = 0;
        for (let i = 0, len = Math.min(one.length, other.length); i < len && equals(one[i], other[i]); i++) {
            result++;
        }
        return result;
    }
    function $Vb(arg, to) {
        let from = typeof to === 'number' ? arg : 0;
        if (typeof to === 'number') {
            from = arg;
        }
        else {
            from = 0;
            to = arg;
        }
        const result = [];
        if (from <= to) {
            for (let i = from; i < to; i++) {
                result.push(i);
            }
        }
        else {
            for (let i = from; i > to; i--) {
                result.push(i);
            }
        }
        return result;
    }
    function $Wb(array, indexer, mapper) {
        return array.reduce((r, t) => {
            r[indexer(t)] = mapper ? mapper(t) : t;
            return r;
        }, Object.create(null));
    }
    /**
     * Inserts an element into an array. Returns a function which, when
     * called, will remove that element from the array.
     *
     * @deprecated In almost all cases, use a `Set<T>` instead.
     */
    function $Xb(array, element) {
        array.push(element);
        return () => $Yb(array, element);
    }
    /**
     * Removes an element from an array if it can be found.
     *
     * @deprecated In almost all cases, use a `Set<T>` instead.
     */
    function $Yb(array, element) {
        const index = array.indexOf(element);
        if (index > -1) {
            array.splice(index, 1);
            return element;
        }
        return undefined;
    }
    /**
     * Insert `insertArr` inside `target` at `insertIndex`.
     * Please don't touch unless you understand https://jsperf.com/inserting-an-array-within-an-array
     */
    function $Zb(target, insertIndex, insertArr) {
        const before = target.slice(0, insertIndex);
        const after = target.slice(insertIndex);
        return before.concat(insertArr, after);
    }
    /**
     * Uses Fisher-Yates shuffle to shuffle the given array
     */
    function $1b(array, _seed) {
        let rand;
        if (typeof _seed === 'number') {
            let seed = _seed;
            // Seeded random number generator in JS. Modified from:
            // https://stackoverflow.com/questions/521295/seeding-the-random-number-generator-in-javascript
            rand = () => {
                const x = Math.sin(seed++) * 179426549; // throw away most significant digits and reduce any potential bias
                return x - Math.floor(x);
            };
        }
        else {
            rand = Math.random;
        }
        for (let i = array.length - 1; i > 0; i -= 1) {
            const j = Math.floor(rand() * (i + 1));
            const temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
    }
    /**
     * Pushes an element to the start of the array, if found.
     */
    function $2b(arr, value) {
        const index = arr.indexOf(value);
        if (index > -1) {
            arr.splice(index, 1);
            arr.unshift(value);
        }
    }
    /**
     * Pushes an element to the end of the array, if found.
     */
    function $3b(arr, value) {
        const index = arr.indexOf(value);
        if (index > -1) {
            arr.splice(index, 1);
            arr.push(value);
        }
    }
    function $4b(arr, items) {
        for (const item of items) {
            arr.push(item);
        }
    }
    function $5b(items, fn) {
        return Array.isArray(items) ?
            items.map(fn) :
            fn(items);
    }
    function $6b(x) {
        return Array.isArray(x) ? x : [x];
    }
    function $7b(arr) {
        return arr[Math.floor(Math.random() * arr.length)];
    }
    /**
     * Insert the new items in the array.
     * @param array The original array.
     * @param start The zero-based location in the array from which to start inserting elements.
     * @param newItems The items to be inserted
     */
    function $8b(array, start, newItems) {
        const startIdx = getActualStartIndex(array, start);
        const originalLength = array.length;
        const newItemsLength = newItems.length;
        array.length = originalLength + newItemsLength;
        // Move the items after the start index, start from the end so that we don't overwrite any value.
        for (let i = originalLength - 1; i >= startIdx; i--) {
            array[i + newItemsLength] = array[i];
        }
        for (let i = 0; i < newItemsLength; i++) {
            array[i + startIdx] = newItems[i];
        }
    }
    /**
     * Removes elements from an array and inserts new elements in their place, returning the deleted elements. Alternative to the native Array.splice method, it
     * can only support limited number of items due to the maximum call stack size limit.
     * @param array The original array.
     * @param start The zero-based location in the array from which to start removing elements.
     * @param deleteCount The number of elements to remove.
     * @returns An array containing the elements that were deleted.
     */
    function $9b(array, start, deleteCount, newItems) {
        const index = getActualStartIndex(array, start);
        let result = array.splice(index, deleteCount);
        if (result === undefined) {
            // see https://bugs.webkit.org/show_bug.cgi?id=261140
            result = [];
        }
        $8b(array, index, newItems);
        return result;
    }
    /**
     * Determine the actual start index (same logic as the native splice() or slice())
     * If greater than the length of the array, start will be set to the length of the array. In this case, no element will be deleted but the method will behave as an adding function, adding as many element as item[n*] provided.
     * If negative, it will begin that many elements from the end of the array. (In this case, the origin -1, meaning -n is the index of the nth last element, and is therefore equivalent to the index of array.length - n.) If array.length + start is less than 0, it will begin from index 0.
     * @param array The target array.
     * @param start The operation index.
     */
    function getActualStartIndex(array, start) {
        return start < 0 ? Math.max(start + array.length, 0) : Math.min(start, array.length);
    }
    var CompareResult;
    (function (CompareResult) {
        function isLessThan(result) {
            return result < 0;
        }
        CompareResult.isLessThan = isLessThan;
        function isLessThanOrEqual(result) {
            return result <= 0;
        }
        CompareResult.isLessThanOrEqual = isLessThanOrEqual;
        function isGreaterThan(result) {
            return result > 0;
        }
        CompareResult.isGreaterThan = isGreaterThan;
        function isNeitherLessOrGreaterThan(result) {
            return result === 0;
        }
        CompareResult.isNeitherLessOrGreaterThan = isNeitherLessOrGreaterThan;
        CompareResult.greaterThan = 1;
        CompareResult.lessThan = -1;
        CompareResult.neitherLessOrGreaterThan = 0;
    })(CompareResult || (exports.CompareResult = CompareResult = {}));
    function $0b(selector, comparator) {
        return (a, b) => comparator(selector(a), selector(b));
    }
    function $$b(...comparators) {
        return (item1, item2) => {
            for (const comparator of comparators) {
                const result = comparator(item1, item2);
                if (!CompareResult.isNeitherLessOrGreaterThan(result)) {
                    return result;
                }
            }
            return CompareResult.neitherLessOrGreaterThan;
        };
    }
    /**
     * The natural order on numbers.
    */
    const $_b = (a, b) => a - b;
    exports.$_b = $_b;
    const $ac = (a, b) => (0, exports.$_b)(a ? 1 : 0, b ? 1 : 0);
    exports.$ac = $ac;
    function $bc(comparator) {
        return (a, b) => -comparator(a, b);
    }
    class $cc {
        /**
         * Constructs a queue that is backed by the given array. Runtime is O(1).
        */
        constructor(g) {
            this.g = g;
            this.c = 0;
            this.d = this.g.length - 1;
        }
        get length() {
            return this.d - this.c + 1;
        }
        /**
         * Consumes elements from the beginning of the queue as long as the predicate returns true.
         * If no elements were consumed, `null` is returned. Has a runtime of O(result.length).
        */
        takeWhile(predicate) {
            // P(k) := k <= this.lastIdx && predicate(this.items[k])
            // Find s := min { k | k >= this.firstIdx && !P(k) } and return this.data[this.firstIdx...s)
            let startIdx = this.c;
            while (startIdx < this.g.length && predicate(this.g[startIdx])) {
                startIdx++;
            }
            const result = startIdx === this.c ? null : this.g.slice(this.c, startIdx);
            this.c = startIdx;
            return result;
        }
        /**
         * Consumes elements from the end of the queue as long as the predicate returns true.
         * If no elements were consumed, `null` is returned.
         * The result has the same order as the underlying array!
        */
        takeFromEndWhile(predicate) {
            // P(k) := this.firstIdx >= k && predicate(this.items[k])
            // Find s := max { k | k <= this.lastIdx && !P(k) } and return this.data(s...this.lastIdx]
            let endIdx = this.d;
            while (endIdx >= 0 && predicate(this.g[endIdx])) {
                endIdx--;
            }
            const result = endIdx === this.d ? null : this.g.slice(endIdx + 1, this.d + 1);
            this.d = endIdx;
            return result;
        }
        peek() {
            if (this.length === 0) {
                return undefined;
            }
            return this.g[this.c];
        }
        peekLast() {
            if (this.length === 0) {
                return undefined;
            }
            return this.g[this.d];
        }
        dequeue() {
            const result = this.g[this.c];
            this.c++;
            return result;
        }
        removeLast() {
            const result = this.g[this.d];
            this.d--;
            return result;
        }
        takeCount(count) {
            const result = this.g.slice(this.c, this.c + count);
            this.c += count;
            return result;
        }
    }
    exports.$cc = $cc;
    /**
     * This class is faster than an iterator and array for lazy computed data.
    */
    class $dc {
        static { this.empty = new $dc(_callback => { }); }
        constructor(
        /**
         * Calls the callback for every item.
         * Stops when the callback returns false.
        */
        iterate) {
            this.iterate = iterate;
        }
        forEach(handler) {
            this.iterate(item => { handler(item); return true; });
        }
        toArray() {
            const result = [];
            this.iterate(item => { result.push(item); return true; });
            return result;
        }
        filter(predicate) {
            return new $dc(cb => this.iterate(item => predicate(item) ? cb(item) : true));
        }
        map(mapFn) {
            return new $dc(cb => this.iterate(item => cb(mapFn(item))));
        }
        some(predicate) {
            let result = false;
            this.iterate(item => { result = predicate(item); return !result; });
            return result;
        }
        findFirst(predicate) {
            let result;
            this.iterate(item => {
                if (predicate(item)) {
                    result = item;
                    return false;
                }
                return true;
            });
            return result;
        }
        findLast(predicate) {
            let result;
            this.iterate(item => {
                if (predicate(item)) {
                    result = item;
                }
                return true;
            });
            return result;
        }
        findLastMaxBy(comparator) {
            let result;
            let first = true;
            this.iterate(item => {
                if (first || CompareResult.isGreaterThan(comparator(item, result))) {
                    first = false;
                    result = item;
                }
                return true;
            });
            return result;
        }
    }
    exports.$dc = $dc;
    /**
     * Represents a re-arrangement of items in an array.
     */
    class $ec {
        constructor(c) {
            this.c = c;
        }
        /**
         * Returns a permutation that sorts the given array according to the given compare function.
         */
        static createSortPermutation(arr, compareFn) {
            const sortIndices = Array.from(arr.keys()).sort((index1, index2) => compareFn(arr[index1], arr[index2]));
            return new $ec(sortIndices);
        }
        /**
         * Returns a new array with the elements of the given array re-arranged according to this permutation.
         */
        apply(arr) {
            return arr.map((_, index) => arr[this.c[index]]);
        }
        /**
         * Returns a new permutation that undoes the re-arrangement of this permutation.
        */
        inverse() {
            const inverseIndexMap = this.c.slice();
            for (let i = 0; i < this.c.length; i++) {
                inverseIndexMap[this.c[i]] = i;
            }
            return new $ec(inverseIndexMap);
        }
    }
    exports.$ec = $ec;
    /**
     * Asynchronous variant of `Array.find()`, returning the first element in
     * the array for which the predicate returns true.
     *
     * This implementation does not bail early and waits for all promises to
     * resolve before returning.
     */
    async function $fc(array, predicate) {
        const results = await Promise.all(array.map(async (element, index) => ({ element, ok: await predicate(element, index) })));
        return results.find(r => r.ok)?.element;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[46/*vs/base/common/assert*/], __M([0/*require*/,1/*exports*/,7/*vs/base/common/errors*/]), function (require, exports, errors_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.ok = ok;
    exports.$jd = $jd;
    exports.$kd = $kd;
    exports.$ld = $ld;
    exports.$md = $md;
    exports.$nd = $nd;
    /**
     * Throws an error with the provided message if the provided value does not evaluate to a true Javascript value.
     *
     * @deprecated Use `assert(...)` instead.
     * This method is usually used like this:
     * ```ts
     * import * as assert from 'vs/base/common/assert';
     * assert.ok(...);
     * ```
     *
     * However, `assert` in that example is a user chosen name.
     * There is no tooling for generating such an import statement.
     * Thus, the `assert(...)` function should be used instead.
     */
    function ok(value, message) {
        if (!value) {
            throw new Error(message ? `Assertion failed (${message})` : 'Assertion Failed');
        }
    }
    function $jd(value, message = 'Unreachable') {
        throw new Error(message);
    }
    function $kd(condition, message = 'unexpected state') {
        if (!condition) {
            throw new errors_1.$gb(`Assertion Failed: ${message}`);
        }
    }
    /**
     * Like assert, but doesn't throw.
     */
    function $ld(condition) {
        if (!condition) {
            (0, errors_1.$4)(new errors_1.$gb('Soft Assertion Failed'));
        }
    }
    /**
     * condition must be side-effect free!
     */
    function $md(condition) {
        if (!condition()) {
            // eslint-disable-next-line no-debugger
            debugger;
            // Reevaluate `condition` again to make debugging easier
            condition();
            (0, errors_1.$4)(new errors_1.$gb('Assertion Failed'));
        }
    }
    function $nd(items, predicate) {
        let i = 0;
        while (i < items.length - 1) {
            const a = items[i];
            const b = items[i + 1];
            if (!predicate(a, b)) {
                return false;
            }
            i++;
        }
        return true;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[31/*vs/base/common/functional*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$hb = $hb;
    /**
     * Given a function, returns a function that is only calling that function once.
     */
    function $hb(fn, fnDidRunCallback) {
        const _this = this;
        let didCall = false;
        let result;
        return function () {
            if (didCall) {
                return result;
            }
            didCall = true;
            if (fnDidRunCallback) {
                try {
                    result = fn.apply(_this, arguments);
                }
                finally {
                    fnDidRunCallback();
                }
            }
            else {
                result = fn.apply(_this, arguments);
            }
            return result;
        };
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[47/*vs/base/common/iterator*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.Iterable = void 0;
    var Iterable;
    (function (Iterable) {
        function is(thing) {
            return thing && typeof thing === 'object' && typeof thing[Symbol.iterator] === 'function';
        }
        Iterable.is = is;
        const _empty = Object.freeze([]);
        function empty() {
            return _empty;
        }
        Iterable.empty = empty;
        function* single(element) {
            yield element;
        }
        Iterable.single = single;
        function wrap(iterableOrElement) {
            if (is(iterableOrElement)) {
                return iterableOrElement;
            }
            else {
                return single(iterableOrElement);
            }
        }
        Iterable.wrap = wrap;
        function from(iterable) {
            return iterable || _empty;
        }
        Iterable.from = from;
        function* reverse(array) {
            for (let i = array.length - 1; i >= 0; i--) {
                yield array[i];
            }
        }
        Iterable.reverse = reverse;
        function isEmpty(iterable) {
            return !iterable || iterable[Symbol.iterator]().next().done === true;
        }
        Iterable.isEmpty = isEmpty;
        function first(iterable) {
            return iterable[Symbol.iterator]().next().value;
        }
        Iterable.first = first;
        function some(iterable, predicate) {
            let i = 0;
            for (const element of iterable) {
                if (predicate(element, i++)) {
                    return true;
                }
            }
            return false;
        }
        Iterable.some = some;
        function find(iterable, predicate) {
            for (const element of iterable) {
                if (predicate(element)) {
                    return element;
                }
            }
            return undefined;
        }
        Iterable.find = find;
        function* filter(iterable, predicate) {
            for (const element of iterable) {
                if (predicate(element)) {
                    yield element;
                }
            }
        }
        Iterable.filter = filter;
        function* map(iterable, fn) {
            let index = 0;
            for (const element of iterable) {
                yield fn(element, index++);
            }
        }
        Iterable.map = map;
        function* flatMap(iterable, fn) {
            let index = 0;
            for (const element of iterable) {
                yield* fn(element, index++);
            }
        }
        Iterable.flatMap = flatMap;
        function* concat(...iterables) {
            for (const iterable of iterables) {
                yield* iterable;
            }
        }
        Iterable.concat = concat;
        function reduce(iterable, reducer, initialValue) {
            let value = initialValue;
            for (const element of iterable) {
                value = reducer(value, element);
            }
            return value;
        }
        Iterable.reduce = reduce;
        /**
         * Returns an iterable slice of the array, with the same semantics as `array.slice()`.
         */
        function* slice(arr, from, to = arr.length) {
            if (from < 0) {
                from += arr.length;
            }
            if (to < 0) {
                to += arr.length;
            }
            else if (to > arr.length) {
                to = arr.length;
            }
            for (; from < to; from++) {
                yield arr[from];
            }
        }
        Iterable.slice = slice;
        /**
         * Consumes `atMost` elements from iterable and returns the consumed elements,
         * and an iterable for the rest of the elements.
         */
        function consume(iterable, atMost = Number.POSITIVE_INFINITY) {
            const consumed = [];
            if (atMost === 0) {
                return [consumed, iterable];
            }
            const iterator = iterable[Symbol.iterator]();
            for (let i = 0; i < atMost; i++) {
                const next = iterator.next();
                if (next.done) {
                    return [consumed, Iterable.empty()];
                }
                consumed.push(next.value);
            }
            return [consumed, { [Symbol.iterator]() { return iterator; } }];
        }
        Iterable.consume = consume;
        async function asyncToArray(iterable) {
            const result = [];
            for await (const item of iterable) {
                result.push(item);
            }
            return Promise.resolve(result);
        }
        Iterable.asyncToArray = asyncToArray;
    })(Iterable || (exports.Iterable = Iterable = {}));
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[24/*vs/base/common/lazy*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$Y = void 0;
    class $Y {
        constructor(d) {
            this.d = d;
            this.a = false;
        }
        /**
         * True if the lazy value has been resolved.
         */
        get hasValue() { return this.a; }
        /**
         * Get the wrapped value.
         *
         * This will force evaluation of the lazy value if it has not been resolved yet. Lazy values are only
         * resolved once. `getValue` will re-throw exceptions that are hit while resolving the value
         */
        get value() {
            if (!this.a) {
                try {
                    this.b = this.d();
                }
                catch (err) {
                    this.c = err;
                }
                finally {
                    this.a = true;
                }
            }
            if (this.c) {
                throw this.c;
            }
            return this.b;
        }
        /**
         * Get the wrapped value without forcing evaluation.
         */
        get rawValue() { return this.b; }
    }
    exports.$Y = $Y;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[48/*vs/base/common/linkedList*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$0c = void 0;
    class Node {
        static { this.Undefined = new Node(undefined); }
        constructor(element) {
            this.element = element;
            this.next = Node.Undefined;
            this.prev = Node.Undefined;
        }
    }
    class $0c {
        constructor() {
            this.a = Node.Undefined;
            this.b = Node.Undefined;
            this.c = 0;
        }
        get size() {
            return this.c;
        }
        isEmpty() {
            return this.a === Node.Undefined;
        }
        clear() {
            let node = this.a;
            while (node !== Node.Undefined) {
                const next = node.next;
                node.prev = Node.Undefined;
                node.next = Node.Undefined;
                node = next;
            }
            this.a = Node.Undefined;
            this.b = Node.Undefined;
            this.c = 0;
        }
        unshift(element) {
            return this.d(element, false);
        }
        push(element) {
            return this.d(element, true);
        }
        d(element, atTheEnd) {
            const newNode = new Node(element);
            if (this.a === Node.Undefined) {
                this.a = newNode;
                this.b = newNode;
            }
            else if (atTheEnd) {
                // push
                const oldLast = this.b;
                this.b = newNode;
                newNode.prev = oldLast;
                oldLast.next = newNode;
            }
            else {
                // unshift
                const oldFirst = this.a;
                this.a = newNode;
                newNode.next = oldFirst;
                oldFirst.prev = newNode;
            }
            this.c += 1;
            let didRemove = false;
            return () => {
                if (!didRemove) {
                    didRemove = true;
                    this.e(newNode);
                }
            };
        }
        shift() {
            if (this.a === Node.Undefined) {
                return undefined;
            }
            else {
                const res = this.a.element;
                this.e(this.a);
                return res;
            }
        }
        pop() {
            if (this.b === Node.Undefined) {
                return undefined;
            }
            else {
                const res = this.b.element;
                this.e(this.b);
                return res;
            }
        }
        e(node) {
            if (node.prev !== Node.Undefined && node.next !== Node.Undefined) {
                // middle
                const anchor = node.prev;
                anchor.next = node.next;
                node.next.prev = anchor;
            }
            else if (node.prev === Node.Undefined && node.next === Node.Undefined) {
                // only node
                this.a = Node.Undefined;
                this.b = Node.Undefined;
            }
            else if (node.next === Node.Undefined) {
                // last
                this.b = this.b.prev;
                this.b.next = Node.Undefined;
            }
            else if (node.prev === Node.Undefined) {
                // first
                this.a = this.a.next;
                this.a.prev = Node.Undefined;
            }
            // done
            this.c -= 1;
        }
        *[Symbol.iterator]() {
            let node = this.a;
            while (node !== Node.Undefined) {
                yield node.element;
                node = node.next;
            }
        }
    }
    exports.$0c = $0c;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[26/*vs/base/common/map*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    var _a, _b, _c;
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$Mc = exports.$Lc = exports.$Kc = exports.$Jc = exports.$Ic = exports.$Hc = exports.Touch = exports.$Gc = exports.$Fc = void 0;
    exports.$Cc = $Cc;
    exports.$Dc = $Dc;
    exports.$Ec = $Ec;
    exports.$Nc = $Nc;
    function $Cc(map, key, value) {
        let result = map.get(key);
        if (result === undefined) {
            result = value;
            map.set(key, result);
        }
        return result;
    }
    function $Dc(map) {
        const entries = [];
        map.forEach((value, key) => {
            entries.push(`${key} => ${value}`);
        });
        return `Map(${map.size}) {${entries.join(', ')}}`;
    }
    function $Ec(set) {
        const entries = [];
        set.forEach(value => {
            entries.push(value);
        });
        return `Set(${set.size}) {${entries.join(', ')}}`;
    }
    class ResourceMapEntry {
        constructor(uri, value) {
            this.uri = uri;
            this.value = value;
        }
    }
    function isEntries(arg) {
        return Array.isArray(arg);
    }
    class $Fc {
        static { this.c = (resource) => resource.toString(); }
        constructor(arg, toKey) {
            this[_a] = 'ResourceMap';
            if (arg instanceof $Fc) {
                this.d = new Map(arg.d);
                this.e = toKey ?? $Fc.c;
            }
            else if (isEntries(arg)) {
                this.d = new Map();
                this.e = toKey ?? $Fc.c;
                for (const [resource, value] of arg) {
                    this.set(resource, value);
                }
            }
            else {
                this.d = new Map();
                this.e = arg ?? $Fc.c;
            }
        }
        set(resource, value) {
            this.d.set(this.e(resource), new ResourceMapEntry(resource, value));
            return this;
        }
        get(resource) {
            return this.d.get(this.e(resource))?.value;
        }
        has(resource) {
            return this.d.has(this.e(resource));
        }
        get size() {
            return this.d.size;
        }
        clear() {
            this.d.clear();
        }
        delete(resource) {
            return this.d.delete(this.e(resource));
        }
        forEach(clb, thisArg) {
            if (typeof thisArg !== 'undefined') {
                clb = clb.bind(thisArg);
            }
            for (const [_, entry] of this.d) {
                clb(entry.value, entry.uri, this);
            }
        }
        *values() {
            for (const entry of this.d.values()) {
                yield entry.value;
            }
        }
        *keys() {
            for (const entry of this.d.values()) {
                yield entry.uri;
            }
        }
        *entries() {
            for (const entry of this.d.values()) {
                yield [entry.uri, entry.value];
            }
        }
        *[(_a = Symbol.toStringTag, Symbol.iterator)]() {
            for (const [, entry] of this.d) {
                yield [entry.uri, entry.value];
            }
        }
    }
    exports.$Fc = $Fc;
    class $Gc {
        constructor(entriesOrKey, toKey) {
            this[_b] = 'ResourceSet';
            if (!entriesOrKey || typeof entriesOrKey === 'function') {
                this.c = new $Fc(entriesOrKey);
            }
            else {
                this.c = new $Fc(toKey);
                entriesOrKey.forEach(this.add, this);
            }
        }
        get size() {
            return this.c.size;
        }
        add(value) {
            this.c.set(value, value);
            return this;
        }
        clear() {
            this.c.clear();
        }
        delete(value) {
            return this.c.delete(value);
        }
        forEach(callbackfn, thisArg) {
            this.c.forEach((_value, key) => callbackfn.call(thisArg, key, key, this));
        }
        has(value) {
            return this.c.has(value);
        }
        entries() {
            return this.c.entries();
        }
        keys() {
            return this.c.keys();
        }
        values() {
            return this.c.keys();
        }
        [(_b = Symbol.toStringTag, Symbol.iterator)]() {
            return this.keys();
        }
    }
    exports.$Gc = $Gc;
    var Touch;
    (function (Touch) {
        Touch[Touch["None"] = 0] = "None";
        Touch[Touch["AsOld"] = 1] = "AsOld";
        Touch[Touch["AsNew"] = 2] = "AsNew";
    })(Touch || (exports.Touch = Touch = {}));
    class $Hc {
        constructor() {
            this[_c] = 'LinkedMap';
            this.c = new Map();
            this.d = undefined;
            this.e = undefined;
            this.f = 0;
            this.g = 0;
        }
        clear() {
            this.c.clear();
            this.d = undefined;
            this.e = undefined;
            this.f = 0;
            this.g++;
        }
        isEmpty() {
            return !this.d && !this.e;
        }
        get size() {
            return this.f;
        }
        get first() {
            return this.d?.value;
        }
        get last() {
            return this.e?.value;
        }
        has(key) {
            return this.c.has(key);
        }
        get(key, touch = Touch.None) {
            const item = this.c.get(key);
            if (!item) {
                return undefined;
            }
            if (touch !== Touch.None) {
                this.m(item, touch);
            }
            return item.value;
        }
        set(key, value, touch = Touch.None) {
            let item = this.c.get(key);
            if (item) {
                item.value = value;
                if (touch !== Touch.None) {
                    this.m(item, touch);
                }
            }
            else {
                item = { key, value, next: undefined, previous: undefined };
                switch (touch) {
                    case Touch.None:
                        this.k(item);
                        break;
                    case Touch.AsOld:
                        this.j(item);
                        break;
                    case Touch.AsNew:
                        this.k(item);
                        break;
                    default:
                        this.k(item);
                        break;
                }
                this.c.set(key, item);
                this.f++;
            }
            return this;
        }
        delete(key) {
            return !!this.remove(key);
        }
        remove(key) {
            const item = this.c.get(key);
            if (!item) {
                return undefined;
            }
            this.c.delete(key);
            this.l(item);
            this.f--;
            return item.value;
        }
        shift() {
            if (!this.d && !this.e) {
                return undefined;
            }
            if (!this.d || !this.e) {
                throw new Error('Invalid list');
            }
            const item = this.d;
            this.c.delete(item.key);
            this.l(item);
            this.f--;
            return item.value;
        }
        forEach(callbackfn, thisArg) {
            const state = this.g;
            let current = this.d;
            while (current) {
                if (thisArg) {
                    callbackfn.bind(thisArg)(current.value, current.key, this);
                }
                else {
                    callbackfn(current.value, current.key, this);
                }
                if (this.g !== state) {
                    throw new Error(`LinkedMap got modified during iteration.`);
                }
                current = current.next;
            }
        }
        keys() {
            const map = this;
            const state = this.g;
            let current = this.d;
            const iterator = {
                [Symbol.iterator]() {
                    return iterator;
                },
                next() {
                    if (map.g !== state) {
                        throw new Error(`LinkedMap got modified during iteration.`);
                    }
                    if (current) {
                        const result = { value: current.key, done: false };
                        current = current.next;
                        return result;
                    }
                    else {
                        return { value: undefined, done: true };
                    }
                }
            };
            return iterator;
        }
        values() {
            const map = this;
            const state = this.g;
            let current = this.d;
            const iterator = {
                [Symbol.iterator]() {
                    return iterator;
                },
                next() {
                    if (map.g !== state) {
                        throw new Error(`LinkedMap got modified during iteration.`);
                    }
                    if (current) {
                        const result = { value: current.value, done: false };
                        current = current.next;
                        return result;
                    }
                    else {
                        return { value: undefined, done: true };
                    }
                }
            };
            return iterator;
        }
        entries() {
            const map = this;
            const state = this.g;
            let current = this.d;
            const iterator = {
                [Symbol.iterator]() {
                    return iterator;
                },
                next() {
                    if (map.g !== state) {
                        throw new Error(`LinkedMap got modified during iteration.`);
                    }
                    if (current) {
                        const result = { value: [current.key, current.value], done: false };
                        current = current.next;
                        return result;
                    }
                    else {
                        return { value: undefined, done: true };
                    }
                }
            };
            return iterator;
        }
        [(_c = Symbol.toStringTag, Symbol.iterator)]() {
            return this.entries();
        }
        h(newSize) {
            if (newSize >= this.size) {
                return;
            }
            if (newSize === 0) {
                this.clear();
                return;
            }
            let current = this.d;
            let currentSize = this.size;
            while (current && currentSize > newSize) {
                this.c.delete(current.key);
                current = current.next;
                currentSize--;
            }
            this.d = current;
            this.f = currentSize;
            if (current) {
                current.previous = undefined;
            }
            this.g++;
        }
        i(newSize) {
            if (newSize >= this.size) {
                return;
            }
            if (newSize === 0) {
                this.clear();
                return;
            }
            let current = this.e;
            let currentSize = this.size;
            while (current && currentSize > newSize) {
                this.c.delete(current.key);
                current = current.previous;
                currentSize--;
            }
            this.e = current;
            this.f = currentSize;
            if (current) {
                current.next = undefined;
            }
            this.g++;
        }
        j(item) {
            // First time Insert
            if (!this.d && !this.e) {
                this.e = item;
            }
            else if (!this.d) {
                throw new Error('Invalid list');
            }
            else {
                item.next = this.d;
                this.d.previous = item;
            }
            this.d = item;
            this.g++;
        }
        k(item) {
            // First time Insert
            if (!this.d && !this.e) {
                this.d = item;
            }
            else if (!this.e) {
                throw new Error('Invalid list');
            }
            else {
                item.previous = this.e;
                this.e.next = item;
            }
            this.e = item;
            this.g++;
        }
        l(item) {
            if (item === this.d && item === this.e) {
                this.d = undefined;
                this.e = undefined;
            }
            else if (item === this.d) {
                // This can only happen if size === 1 which is handled
                // by the case above.
                if (!item.next) {
                    throw new Error('Invalid list');
                }
                item.next.previous = undefined;
                this.d = item.next;
            }
            else if (item === this.e) {
                // This can only happen if size === 1 which is handled
                // by the case above.
                if (!item.previous) {
                    throw new Error('Invalid list');
                }
                item.previous.next = undefined;
                this.e = item.previous;
            }
            else {
                const next = item.next;
                const previous = item.previous;
                if (!next || !previous) {
                    throw new Error('Invalid list');
                }
                next.previous = previous;
                previous.next = next;
            }
            item.next = undefined;
            item.previous = undefined;
            this.g++;
        }
        m(item, touch) {
            if (!this.d || !this.e) {
                throw new Error('Invalid list');
            }
            if ((touch !== Touch.AsOld && touch !== Touch.AsNew)) {
                return;
            }
            if (touch === Touch.AsOld) {
                if (item === this.d) {
                    return;
                }
                const next = item.next;
                const previous = item.previous;
                // Unlink the item
                if (item === this.e) {
                    // previous must be defined since item was not head but is tail
                    // So there are more than on item in the map
                    previous.next = undefined;
                    this.e = previous;
                }
                else {
                    // Both next and previous are not undefined since item was neither head nor tail.
                    next.previous = previous;
                    previous.next = next;
                }
                // Insert the node at head
                item.previous = undefined;
                item.next = this.d;
                this.d.previous = item;
                this.d = item;
                this.g++;
            }
            else if (touch === Touch.AsNew) {
                if (item === this.e) {
                    return;
                }
                const next = item.next;
                const previous = item.previous;
                // Unlink the item.
                if (item === this.d) {
                    // next must be defined since item was not tail but is head
                    // So there are more than on item in the map
                    next.previous = undefined;
                    this.d = next;
                }
                else {
                    // Both next and previous are not undefined since item was neither head nor tail.
                    next.previous = previous;
                    previous.next = next;
                }
                item.next = undefined;
                item.previous = this.e;
                this.e.next = item;
                this.e = item;
                this.g++;
            }
        }
        toJSON() {
            const data = [];
            this.forEach((value, key) => {
                data.push([key, value]);
            });
            return data;
        }
        fromJSON(data) {
            this.clear();
            for (const [key, value] of data) {
                this.set(key, value);
            }
        }
    }
    exports.$Hc = $Hc;
    class Cache extends $Hc {
        constructor(limit, ratio = 1) {
            super();
            this.n = limit;
            this.o = Math.min(Math.max(0, ratio), 1);
        }
        get limit() {
            return this.n;
        }
        set limit(limit) {
            this.n = limit;
            this.p();
        }
        get ratio() {
            return this.o;
        }
        set ratio(ratio) {
            this.o = Math.min(Math.max(0, ratio), 1);
            this.p();
        }
        get(key, touch = Touch.AsNew) {
            return super.get(key, touch);
        }
        peek(key) {
            return super.get(key, Touch.None);
        }
        set(key, value) {
            super.set(key, value, Touch.AsNew);
            return this;
        }
        p() {
            if (this.size > this.n) {
                this.q(Math.round(this.n * this.o));
            }
        }
    }
    class $Ic extends Cache {
        constructor(limit, ratio = 1) {
            super(limit, ratio);
        }
        q(newSize) {
            this.h(newSize);
        }
        set(key, value) {
            super.set(key, value);
            this.p();
            return this;
        }
    }
    exports.$Ic = $Ic;
    class $Jc extends Cache {
        constructor(limit, ratio = 1) {
            super(limit, ratio);
        }
        q(newSize) {
            this.i(newSize);
        }
        set(key, value) {
            if (this.n <= this.size && !this.has(key)) {
                this.q(Math.round(this.n * this.o) - 1);
            }
            super.set(key, value);
            return this;
        }
    }
    exports.$Jc = $Jc;
    class $Kc {
        constructor() {
            this.c = new Map();
        }
        add(value) {
            this.c.set(value, (this.c.get(value) || 0) + 1);
            return this;
        }
        delete(value) {
            let counter = this.c.get(value) || 0;
            if (counter === 0) {
                return false;
            }
            counter--;
            if (counter === 0) {
                this.c.delete(value);
            }
            else {
                this.c.set(value, counter);
            }
            return true;
        }
        has(value) {
            return this.c.has(value);
        }
    }
    exports.$Kc = $Kc;
    /**
     * A map that allows access both by keys and values.
     * **NOTE**: values need to be unique.
     */
    class $Lc {
        constructor(entries) {
            this.c = new Map();
            this.d = new Map();
            if (entries) {
                for (const [key, value] of entries) {
                    this.set(key, value);
                }
            }
        }
        clear() {
            this.c.clear();
            this.d.clear();
        }
        set(key, value) {
            this.c.set(key, value);
            this.d.set(value, key);
        }
        get(key) {
            return this.c.get(key);
        }
        getKey(value) {
            return this.d.get(value);
        }
        delete(key) {
            const value = this.c.get(key);
            if (value === undefined) {
                return false;
            }
            this.c.delete(key);
            this.d.delete(value);
            return true;
        }
        forEach(callbackfn, thisArg) {
            this.c.forEach((value, key) => {
                callbackfn.call(thisArg, value, key, this);
            });
        }
        keys() {
            return this.c.keys();
        }
        values() {
            return this.c.values();
        }
    }
    exports.$Lc = $Lc;
    class $Mc {
        constructor() {
            this.c = new Map();
        }
        add(key, value) {
            let values = this.c.get(key);
            if (!values) {
                values = new Set();
                this.c.set(key, values);
            }
            values.add(value);
        }
        delete(key, value) {
            const values = this.c.get(key);
            if (!values) {
                return;
            }
            values.delete(value);
            if (values.size === 0) {
                this.c.delete(key);
            }
        }
        forEach(key, fn) {
            const values = this.c.get(key);
            if (!values) {
                return;
            }
            values.forEach(fn);
        }
        get(key) {
            const values = this.c.get(key);
            if (!values) {
                return new Set();
            }
            return values;
        }
    }
    exports.$Mc = $Mc;
    function $Nc(a, b) {
        if (a === b) {
            return true;
        }
        if (a.size !== b.size) {
            return false;
        }
        for (const [key, value] of a) {
            if (!b.has(key) || b.get(key) !== value) {
                return false;
            }
        }
        for (const [key] of b) {
            if (!a.has(key)) {
                return false;
            }
        }
        return true;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[2/*vs/base/common/lifecycle*/], __M([0/*require*/,1/*exports*/,17/*vs/base/common/arrays*/,45/*vs/base/common/collections*/,26/*vs/base/common/map*/,31/*vs/base/common/functional*/,47/*vs/base/common/iterator*/]), function (require, exports, arrays_1, collections_1, map_1, functional_1, iterator_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$9c = exports.$7c = exports.$6c = exports.$5c = exports.$4c = exports.$3c = exports.$2c = exports.$1c = exports.$Zc = exports.$Yc = exports.$Oc = void 0;
    exports.$Pc = $Pc;
    exports.$Qc = $Qc;
    exports.$Rc = $Rc;
    exports.$Sc = $Sc;
    exports.$Tc = $Tc;
    exports.$Uc = $Uc;
    exports.$Vc = $Vc;
    exports.$Wc = $Wc;
    exports.$Xc = $Xc;
    exports.$8c = $8c;
    // #region Disposable Tracking
    /**
     * Enables logging of potentially leaked disposables.
     *
     * A disposable is considered leaked if it is not disposed or not registered as the child of
     * another disposable. This tracking is very simple an only works for classes that either
     * extend Disposable or use a DisposableStore. This means there are a lot of false positives.
     */
    const TRACK_DISPOSABLES = false;
    let disposableTracker = null;
    class $Oc {
        constructor() {
            this.b = new Map();
        }
        static { this.a = 0; }
        c(d) {
            let val = this.b.get(d);
            if (!val) {
                val = { parent: null, source: null, isSingleton: false, value: d, idx: $Oc.a++ };
                this.b.set(d, val);
            }
            return val;
        }
        trackDisposable(d) {
            const data = this.c(d);
            if (!data.source) {
                data.source =
                    new Error().stack;
            }
        }
        setParent(child, parent) {
            const data = this.c(child);
            data.parent = parent;
        }
        markAsDisposed(x) {
            this.b.delete(x);
        }
        markAsSingleton(disposable) {
            this.c(disposable).isSingleton = true;
        }
        f(data, cache) {
            const cacheValue = cache.get(data);
            if (cacheValue) {
                return cacheValue;
            }
            const result = data.parent ? this.f(this.c(data.parent), cache) : data;
            cache.set(data, result);
            return result;
        }
        getTrackedDisposables() {
            const rootParentCache = new Map();
            const leaking = [...this.b.entries()]
                .filter(([, v]) => v.source !== null && !this.f(v, rootParentCache).isSingleton)
                .flatMap(([k]) => k);
            return leaking;
        }
        computeLeakingDisposables(maxReported = 10, preComputedLeaks) {
            let uncoveredLeakingObjs;
            if (preComputedLeaks) {
                uncoveredLeakingObjs = preComputedLeaks;
            }
            else {
                const rootParentCache = new Map();
                const leakingObjects = [...this.b.values()]
                    .filter((info) => info.source !== null && !this.f(info, rootParentCache).isSingleton);
                if (leakingObjects.length === 0) {
                    return;
                }
                const leakingObjsSet = new Set(leakingObjects.map(o => o.value));
                // Remove all objects that are a child of other leaking objects. Assumes there are no cycles.
                uncoveredLeakingObjs = leakingObjects.filter(l => {
                    return !(l.parent && leakingObjsSet.has(l.parent));
                });
                if (uncoveredLeakingObjs.length === 0) {
                    throw new Error('There are cyclic diposable chains!');
                }
            }
            if (!uncoveredLeakingObjs) {
                return undefined;
            }
            function getStackTracePath(leaking) {
                function removePrefix(array, linesToRemove) {
                    while (array.length > 0 && linesToRemove.some(regexp => typeof regexp === 'string' ? regexp === array[0] : array[0].match(regexp))) {
                        array.shift();
                    }
                }
                const lines = leaking.source.split('\n').map(p => p.trim().replace('at ', '')).filter(l => l !== '');
                removePrefix(lines, ['Error', /^trackDisposable \(.*\)$/, /^DisposableTracker.trackDisposable \(.*\)$/]);
                return lines.reverse();
            }
            const stackTraceStarts = new map_1.$Mc();
            for (const leaking of uncoveredLeakingObjs) {
                const stackTracePath = getStackTracePath(leaking);
                for (let i = 0; i <= stackTracePath.length; i++) {
                    stackTraceStarts.add(stackTracePath.slice(0, i).join('\n'), leaking);
                }
            }
            // Put earlier leaks first
            uncoveredLeakingObjs.sort((0, arrays_1.$0b)(l => l.idx, arrays_1.$_b));
            let message = '';
            let i = 0;
            for (const leaking of uncoveredLeakingObjs.slice(0, maxReported)) {
                i++;
                const stackTracePath = getStackTracePath(leaking);
                const stackTraceFormattedLines = [];
                for (let i = 0; i < stackTracePath.length; i++) {
                    let line = stackTracePath[i];
                    const starts = stackTraceStarts.get(stackTracePath.slice(0, i + 1).join('\n'));
                    line = `(shared with ${starts.size}/${uncoveredLeakingObjs.length} leaks) at ${line}`;
                    const prevStarts = stackTraceStarts.get(stackTracePath.slice(0, i).join('\n'));
                    const continuations = (0, collections_1.$e)([...prevStarts].map(d => getStackTracePath(d)[i]), v => v);
                    delete continuations[stackTracePath[i]];
                    for (const [cont, set] of Object.entries(continuations)) {
                        stackTraceFormattedLines.unshift(`    - stacktraces of ${set.length} other leaks continue with ${cont}`);
                    }
                    stackTraceFormattedLines.unshift(line);
                }
                message += `\n\n\n==================== Leaking disposable ${i}/${uncoveredLeakingObjs.length}: ${leaking.value.constructor.name} ====================\n${stackTraceFormattedLines.join('\n')}\n============================================================\n\n`;
            }
            if (uncoveredLeakingObjs.length > maxReported) {
                message += `\n\n\n... and ${uncoveredLeakingObjs.length - maxReported} more leaking disposables\n\n`;
            }
            return { leaks: uncoveredLeakingObjs, details: message };
        }
    }
    exports.$Oc = $Oc;
    function $Pc(tracker) {
        disposableTracker = tracker;
    }
    if (TRACK_DISPOSABLES) {
        const __is_disposable_tracked__ = '__is_disposable_tracked__';
        $Pc(new class {
            trackDisposable(x) {
                const stack = new Error('Potentially leaked disposable').stack;
                setTimeout(() => {
                    if (!x[__is_disposable_tracked__]) {
                        console.log(stack);
                    }
                }, 3000);
            }
            setParent(child, parent) {
                if (child && child !== $Zc.None) {
                    try {
                        child[__is_disposable_tracked__] = true;
                    }
                    catch {
                        // noop
                    }
                }
            }
            markAsDisposed(disposable) {
                if (disposable && disposable !== $Zc.None) {
                    try {
                        disposable[__is_disposable_tracked__] = true;
                    }
                    catch {
                        // noop
                    }
                }
            }
            markAsSingleton(disposable) { }
        });
    }
    function $Qc(x) {
        disposableTracker?.trackDisposable(x);
        return x;
    }
    function $Rc(disposable) {
        disposableTracker?.markAsDisposed(disposable);
    }
    function setParentOfDisposable(child, parent) {
        disposableTracker?.setParent(child, parent);
    }
    function setParentOfDisposables(children, parent) {
        if (!disposableTracker) {
            return;
        }
        for (const child of children) {
            disposableTracker.setParent(child, parent);
        }
    }
    /**
     * Indicates that the given object is a singleton which does not need to be disposed.
    */
    function $Sc(singleton) {
        disposableTracker?.markAsSingleton(singleton);
        return singleton;
    }
    /**
     * Check if `thing` is {@link IDisposable disposable}.
     */
    function $Tc(thing) {
        return typeof thing === 'object' && thing !== null && typeof thing.dispose === 'function' && thing.dispose.length === 0;
    }
    function $Uc(arg) {
        if (iterator_1.Iterable.is(arg)) {
            const errors = [];
            for (const d of arg) {
                if (d) {
                    try {
                        d.dispose();
                    }
                    catch (e) {
                        errors.push(e);
                    }
                }
            }
            if (errors.length === 1) {
                throw errors[0];
            }
            else if (errors.length > 1) {
                throw new AggregateError(errors, 'Encountered errors while disposing of store');
            }
            return Array.isArray(arg) ? [] : arg;
        }
        else if (arg) {
            arg.dispose();
            return arg;
        }
    }
    function $Vc(disposables) {
        for (const d of disposables) {
            if ($Tc(d)) {
                d.dispose();
            }
        }
        return [];
    }
    /**
     * Combine multiple disposable values into a single {@link IDisposable}.
     */
    function $Wc(...disposables) {
        const parent = $Xc(() => $Uc(disposables));
        setParentOfDisposables(disposables, parent);
        return parent;
    }
    /**
     * Turn a function that implements dispose into an {@link IDisposable}.
     *
     * @param fn Clean up function, guaranteed to be called only **once**.
     */
    function $Xc(fn) {
        const self = $Qc({
            dispose: (0, functional_1.$hb)(() => {
                $Rc(self);
                fn();
            })
        });
        return self;
    }
    /**
     * Manages a collection of disposable values.
     *
     * This is the preferred way to manage multiple disposables. A `DisposableStore` is safer to work with than an
     * `IDisposable[]` as it considers edge cases, such as registering the same value multiple times or adding an item to a
     * store that has already been disposed of.
     */
    class $Yc {
        static { this.DISABLE_DISPOSED_WARNING = false; }
        constructor() {
            this.f = new Set();
            this.g = false;
            $Qc(this);
        }
        /**
         * Dispose of all registered disposables and mark this object as disposed.
         *
         * Any future disposables added to this object will be disposed of on `add`.
         */
        dispose() {
            if (this.g) {
                return;
            }
            $Rc(this);
            this.g = true;
            this.clear();
        }
        /**
         * @return `true` if this object has been disposed of.
         */
        get isDisposed() {
            return this.g;
        }
        /**
         * Dispose of all registered disposables but do not mark this object as disposed.
         */
        clear() {
            if (this.f.size === 0) {
                return;
            }
            try {
                $Uc(this.f);
            }
            finally {
                this.f.clear();
            }
        }
        /**
         * Add a new {@link IDisposable disposable} to the collection.
         */
        add(o) {
            if (!o) {
                return o;
            }
            if (o === this) {
                throw new Error('Cannot register a disposable on itself!');
            }
            setParentOfDisposable(o, this);
            if (this.g) {
                if (!$Yc.DISABLE_DISPOSED_WARNING) {
                    console.warn(new Error('Trying to add a disposable to a DisposableStore that has already been disposed of. The added object will be leaked!').stack);
                }
            }
            else {
                this.f.add(o);
            }
            return o;
        }
        /**
         * Deletes a disposable from store and disposes of it. This will not throw or warn and proceed to dispose the
         * disposable even when the disposable is not part in the store.
         */
        delete(o) {
            if (!o) {
                return;
            }
            if (o === this) {
                throw new Error('Cannot dispose a disposable on itself!');
            }
            this.f.delete(o);
            o.dispose();
        }
        /**
         * Deletes the value from the store, but does not dispose it.
         */
        deleteAndLeak(o) {
            if (!o) {
                return;
            }
            if (this.f.has(o)) {
                this.f.delete(o);
                setParentOfDisposable(o, null);
            }
        }
    }
    exports.$Yc = $Yc;
    /**
     * Abstract base class for a {@link IDisposable disposable} object.
     *
     * Subclasses can {@linkcode B} disposables that will be automatically cleaned up when this object is disposed of.
     */
    class $Zc {
        /**
         * A disposable that does nothing when it is disposed of.
         *
         * TODO: This should not be a static property.
         */
        static { this.None = Object.freeze({ dispose() { } }); }
        constructor() {
            this.q = new $Yc();
            $Qc(this);
            setParentOfDisposable(this.q, this);
        }
        dispose() {
            $Rc(this);
            this.q.dispose();
        }
        /**
         * Adds `o` to the collection of disposables managed by this object.
         */
        B(o) {
            if (o === this) {
                throw new Error('Cannot register a disposable on itself!');
            }
            return this.q.add(o);
        }
    }
    exports.$Zc = $Zc;
    /**
     * Manages the lifecycle of a disposable value that may be changed.
     *
     * This ensures that when the disposable value is changed, the previously held disposable is disposed of. You can
     * also register a `MutableDisposable` on a `Disposable` to ensure it is automatically cleaned up.
     */
    class $1c {
        constructor() {
            this.b = false;
            $Qc(this);
        }
        get value() {
            return this.b ? undefined : this.a;
        }
        set value(value) {
            if (this.b || value === this.a) {
                return;
            }
            this.a?.dispose();
            if (value) {
                setParentOfDisposable(value, this);
            }
            this.a = value;
        }
        /**
         * Resets the stored value and disposed of the previously stored value.
         */
        clear() {
            this.value = undefined;
        }
        dispose() {
            this.b = true;
            $Rc(this);
            this.a?.dispose();
            this.a = undefined;
        }
        /**
         * Clears the value, but does not dispose it.
         * The old value is returned.
        */
        clearAndLeak() {
            const oldValue = this.a;
            this.a = undefined;
            if (oldValue) {
                setParentOfDisposable(oldValue, null);
            }
            return oldValue;
        }
    }
    exports.$1c = $1c;
    /**
     * Manages the lifecycle of a disposable value that may be changed like {@link $1c}, but the value must
     * exist and cannot be undefined.
     */
    class $2c {
        constructor(initialValue) {
            this.a = new $1c();
            this.b = false;
            this.a.value = initialValue;
        }
        get value() {
            return this.a.value;
        }
        set value(value) {
            if (this.b || value === this.a.value) {
                return;
            }
            this.a.value = value;
        }
        dispose() {
            this.b = true;
            this.a.dispose();
        }
    }
    exports.$2c = $2c;
    class $3c {
        constructor(b) {
            this.b = b;
            this.a = 1;
        }
        acquire() {
            this.a++;
            return this;
        }
        release() {
            if (--this.a === 0) {
                this.b.dispose();
            }
            return this;
        }
    }
    exports.$3c = $3c;
    /**
     * A safe disposable can be `unset` so that a leaked reference (listener)
     * can be cut-off.
     */
    class $4c {
        constructor() {
            this.dispose = () => { };
            this.unset = () => { };
            this.isset = () => false;
            $Qc(this);
        }
        set(fn) {
            let callback = fn;
            this.unset = () => callback = undefined;
            this.isset = () => callback !== undefined;
            this.dispose = () => {
                if (callback) {
                    callback();
                    callback = undefined;
                    $Rc(this);
                }
            };
            return this;
        }
    }
    exports.$4c = $4c;
    class $5c {
        constructor() {
            this.a = new Map();
        }
        acquire(key, ...args) {
            let reference = this.a.get(key);
            if (!reference) {
                reference = { counter: 0, object: this.b(key, ...args) };
                this.a.set(key, reference);
            }
            const { object } = reference;
            const dispose = (0, functional_1.$hb)(() => {
                if (--reference.counter === 0) {
                    this.c(key, reference.object);
                    this.a.delete(key);
                }
            });
            reference.counter++;
            return { object, dispose };
        }
    }
    exports.$5c = $5c;
    /**
     * Unwraps a reference collection of promised values. Makes sure
     * references are disposed whenever promises get rejected.
     */
    class $6c {
        constructor(a) {
            this.a = a;
        }
        async acquire(key, ...args) {
            const ref = this.a.acquire(key, ...args);
            try {
                const object = await ref.object;
                return {
                    object,
                    dispose: () => ref.dispose()
                };
            }
            catch (error) {
                ref.dispose();
                throw error;
            }
        }
    }
    exports.$6c = $6c;
    class $7c {
        constructor(object) {
            this.object = object;
        }
        dispose() { }
    }
    exports.$7c = $7c;
    function $8c(fn) {
        const store = new $Yc();
        try {
            fn(store);
        }
        finally {
            store.dispose();
        }
    }
    /**
     * A map the manages the lifecycle of the values that it stores.
     */
    class $9c {
        constructor() {
            this.a = new Map();
            this.b = false;
            $Qc(this);
        }
        /**
         * Disposes of all stored values and mark this object as disposed.
         *
         * Trying to use this object after it has been disposed of is an error.
         */
        dispose() {
            $Rc(this);
            this.b = true;
            this.clearAndDisposeAll();
        }
        /**
         * Disposes of all stored values and clear the map, but DO NOT mark this object as disposed.
         */
        clearAndDisposeAll() {
            if (!this.a.size) {
                return;
            }
            try {
                $Uc(this.a.values());
            }
            finally {
                this.a.clear();
            }
        }
        has(key) {
            return this.a.has(key);
        }
        get size() {
            return this.a.size;
        }
        get(key) {
            return this.a.get(key);
        }
        set(key, value, skipDisposeOnOverwrite = false) {
            if (this.b) {
                console.warn(new Error('Trying to add a disposable to a DisposableMap that has already been disposed of. The added object will be leaked!').stack);
            }
            if (!skipDisposeOnOverwrite) {
                this.a.get(key)?.dispose();
            }
            this.a.set(key, value);
        }
        /**
         * Delete the value stored for `key` from this map and also dispose of it.
         */
        deleteAndDispose(key) {
            this.a.get(key)?.dispose();
            this.a.delete(key);
        }
        /**
         * Delete the value stored for `key` from this map but return it. The caller is
         * responsible for disposing of the value.
         */
        deleteAndLeak(key) {
            const value = this.a.get(key);
            this.a.delete(key);
            return value;
        }
        keys() {
            return this.a.keys();
        }
        values() {
            return this.a.values();
        }
        [Symbol.iterator]() {
            return this.a[Symbol.iterator]();
        }
    }
    exports.$9c = $9c;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[27/*vs/base/common/marshallingIds*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.MarshalledId = void 0;
    var MarshalledId;
    (function (MarshalledId) {
        MarshalledId[MarshalledId["Uri"] = 1] = "Uri";
        MarshalledId[MarshalledId["Regexp"] = 2] = "Regexp";
        MarshalledId[MarshalledId["ScmResource"] = 3] = "ScmResource";
        MarshalledId[MarshalledId["ScmResourceGroup"] = 4] = "ScmResourceGroup";
        MarshalledId[MarshalledId["ScmProvider"] = 5] = "ScmProvider";
        MarshalledId[MarshalledId["CommentController"] = 6] = "CommentController";
        MarshalledId[MarshalledId["CommentThread"] = 7] = "CommentThread";
        MarshalledId[MarshalledId["CommentThreadInstance"] = 8] = "CommentThreadInstance";
        MarshalledId[MarshalledId["CommentThreadReply"] = 9] = "CommentThreadReply";
        MarshalledId[MarshalledId["CommentNode"] = 10] = "CommentNode";
        MarshalledId[MarshalledId["CommentThreadNode"] = 11] = "CommentThreadNode";
        MarshalledId[MarshalledId["TimelineActionContext"] = 12] = "TimelineActionContext";
        MarshalledId[MarshalledId["NotebookCellActionContext"] = 13] = "NotebookCellActionContext";
        MarshalledId[MarshalledId["NotebookActionContext"] = 14] = "NotebookActionContext";
        MarshalledId[MarshalledId["TerminalContext"] = 15] = "TerminalContext";
        MarshalledId[MarshalledId["TestItemContext"] = 16] = "TestItemContext";
        MarshalledId[MarshalledId["Date"] = 17] = "Date";
        MarshalledId[MarshalledId["TestMessageMenuArgs"] = 18] = "TestMessageMenuArgs";
    })(MarshalledId || (exports.MarshalledId = MarshalledId = {}));
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[49/*vs/base/common/normalization*/], __M([0/*require*/,1/*exports*/,26/*vs/base/common/map*/]), function (require, exports, map_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$um = void 0;
    exports.$sm = $sm;
    exports.$tm = $tm;
    const nfcCache = new map_1.$Ic(10000); // bounded to 10000 elements
    function $sm(str) {
        return normalize(str, 'NFC', nfcCache);
    }
    const nfdCache = new map_1.$Ic(10000); // bounded to 10000 elements
    function $tm(str) {
        return normalize(str, 'NFD', nfdCache);
    }
    const nonAsciiCharactersPattern = /[^\u0000-\u0080]/;
    function normalize(str, form, normalizedCache) {
        if (!str) {
            return str;
        }
        const cached = normalizedCache.get(str);
        if (cached) {
            return cached;
        }
        let res;
        if (nonAsciiCharactersPattern.test(str)) {
            res = str.normalize(form);
        }
        else {
            res = str;
        }
        // Use the cache for fast lookup
        normalizedCache.set(str, res);
        return res;
    }
    exports.$um = (function () {
        // transform into NFD form and remove accents
        // see: https://stackoverflow.com/questions/990904/remove-accents-diacritics-in-a-string-in-javascript/37511463#37511463
        const regex = /[\u0300-\u036f]/g;
        return function (str) {
            return $tm(str).replace(regex, '');
        };
    })();
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

//@ts-check
'use strict';

// ESM-uncomment-begin
// /** @type any */
// const module = { exports: {} };
// ESM-uncomment-end

(function () {

	/**
	 * @returns {{mark(name:string):void, getMarks():{name:string, startTime:number}[]}}
	 */
	function _definePolyfillMarks(timeOrigin) {

		const _data = [];
		if (typeof timeOrigin === 'number') {
			_data.push('code/timeOrigin', timeOrigin);
		}

		function mark(name) {
			_data.push(name, Date.now());
		}
		function getMarks() {
			const result = [];
			for (let i = 0; i < _data.length; i += 2) {
				result.push({
					name: _data[i],
					startTime: _data[i + 1],
				});
			}
			return result;
		}
		return { mark, getMarks };
	}

	/**
	 * @returns {{mark(name:string):void, getMarks():{name:string, startTime:number}[]}}
	 */
	function _define() {

		// Identify browser environment when following property is not present
		// https://nodejs.org/dist/latest-v16.x/docs/api/perf_hooks.html#performancenodetiming
		// @ts-ignore
		if (typeof performance === 'object' && typeof performance.mark === 'function' && !performance.nodeTiming) {
			// in a browser context, reuse performance-util

			if (typeof performance.timeOrigin !== 'number' && !performance.timing) {
				// safari & webworker: because there is no timeOrigin and no workaround
				// we use the `Date.now`-based polyfill.
				return _definePolyfillMarks();

			} else {
				// use "native" performance for mark and getMarks
				return {
					mark(name) {
						performance.mark(name);
					},
					getMarks() {
						let timeOrigin = performance.timeOrigin;
						if (typeof timeOrigin !== 'number') {
							// safari: there is no timerOrigin but in renderers there is the timing-property
							// see https://bugs.webkit.org/show_bug.cgi?id=174862
							timeOrigin = performance.timing.navigationStart || performance.timing.redirectStart || performance.timing.fetchStart;
						}
						const result = [{ name: 'code/timeOrigin', startTime: Math.round(timeOrigin) }];
						for (const entry of performance.getEntriesByType('mark')) {
							result.push({
								name: entry.name,
								startTime: Math.round(timeOrigin + entry.startTime)
							});
						}
						return result;
					}
				};
			}

		} else if (typeof process === 'object') {
			// node.js: use the normal polyfill but add the timeOrigin
			// from the node perf_hooks API as very first mark
			const timeOrigin = performance?.timeOrigin;// ?? Math.round((require.__$__nodeRequire ?? require /* TODO@esm this is fishy */)('perf_hooks').performance.timeOrigin);
			return _definePolyfillMarks(timeOrigin);

		} else {
			// unknown environment
			console.trace('perf-util loaded in UNKNOWN environment');
			return _definePolyfillMarks();
		}
	}

	function _factory(sharedObj) {
		if (!sharedObj.MonacoPerformanceMarks) {
			sharedObj.MonacoPerformanceMarks = _define();
		}
		return sharedObj.MonacoPerformanceMarks;
	}

	// This module can be loaded in an amd and commonjs-context.
	// Because we want both instances to use the same perf-data
	// we store them globally

	// eslint-disable-next-line no-var
	var sharedObj;
	if (typeof global === 'object') {
		// nodejs
		sharedObj = global;
	} else if (typeof self === 'object') {
		// browser
		sharedObj = self;
	} else {
		sharedObj = {};
	}

	if (typeof define === 'function') {
		// amd
		define("vs/base/common/performance", [], function () { return _factory(sharedObj); });
	} else if (typeof module === 'object' && typeof module.exports === 'object') {
		// commonjs
		module.exports = _factory(sharedObj);
	} else {
		console.trace('perf-util defined in UNKNOWN context (neither requirejs or commonjs)');
		// @ts-ignore
		sharedObj.perf = _factory(sharedObj);
	}

})();

// ESM-uncomment-begin
// export const mark = module.exports.mark;
// export const getMarks = module.exports.getMarks;
// ESM-uncomment-end

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[50/*vs/base/common/stopwatch*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$ke = void 0;
    const hasPerformanceNow = (globalThis.performance && typeof globalThis.performance.now === 'function');
    class $ke {
        static create(highResolution) {
            return new $ke(highResolution);
        }
        constructor(highResolution) {
            this.c = hasPerformanceNow && highResolution === false ? Date.now : globalThis.performance.now.bind(globalThis.performance);
            this.a = this.c();
            this.b = -1;
        }
        stop() {
            this.b = this.c();
        }
        reset() {
            this.a = this.c();
            this.b = -1;
        }
        elapsed() {
            if (this.b !== -1) {
                return this.b - this.a;
            }
            return this.c() - this.a;
        }
    }
    exports.$ke = $ke;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[4/*vs/base/common/event*/], __M([0/*require*/,1/*exports*/,7/*vs/base/common/errors*/,31/*vs/base/common/functional*/,2/*vs/base/common/lifecycle*/,48/*vs/base/common/linkedList*/,50/*vs/base/common/stopwatch*/]), function (require, exports, errors_1, functional_1, lifecycle_1, linkedList_1, stopwatch_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$Ae = exports.$ze = exports.$ye = exports.$xe = exports.$we = exports.$ve = exports.$ue = exports.$te = exports.$se = exports.$re = exports.$qe = exports.$pe = exports.$oe = exports.$me = exports.Event = void 0;
    exports.$ne = $ne;
    // -----------------------------------------------------------------------------------------------------------------------
    // Uncomment the next line to print warnings whenever a listener is GC'ed without having been disposed. This is a LEAK.
    // -----------------------------------------------------------------------------------------------------------------------
    const _enableListenerGCedWarning = false;
    // -----------------------------------------------------------------------------------------------------------------------
    // Uncomment the next line to print warnings whenever an emitter with listeners is disposed. That is a sign of code smell.
    // -----------------------------------------------------------------------------------------------------------------------
    const _enableDisposeWithListenerWarning = false;
    // -----------------------------------------------------------------------------------------------------------------------
    // Uncomment the next line to print warnings whenever a snapshotted event is used repeatedly without cleanup.
    // See https://github.com/microsoft/vscode/issues/142851
    // -----------------------------------------------------------------------------------------------------------------------
    const _enableSnapshotPotentialLeakWarning = false;
    var Event;
    (function (Event) {
        Event.None = () => lifecycle_1.$Zc.None;
        function _addLeakageTraceLogic(options) {
            if (_enableSnapshotPotentialLeakWarning) {
                const { onDidAddListener: origListenerDidAdd } = options;
                const stack = Stacktrace.create();
                let count = 0;
                options.onDidAddListener = () => {
                    if (++count === 2) {
                        console.warn('snapshotted emitter LIKELY used public and SHOULD HAVE BEEN created with DisposableStore. snapshotted here');
                        stack.print();
                    }
                    origListenerDidAdd?.();
                };
            }
        }
        /**
         * Given an event, returns another event which debounces calls and defers the listeners to a later task via a shared
         * `setTimeout`. The event is converted into a signal (`Event<void>`) to avoid additional object creation as a
         * result of merging events and to try prevent race conditions that could arise when using related deferred and
         * non-deferred events.
         *
         * This is useful for deferring non-critical work (eg. general UI updates) to ensure it does not block critical work
         * (eg. latency of keypress to text rendered).
         *
         * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
         * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
         * returned event causes this utility to leak a listener on the original event.
         *
         * @param event The event source for the new event.
         * @param disposable A disposable store to add the new EventEmitter to.
         */
        function defer(event, disposable) {
            return debounce(event, () => void 0, 0, undefined, true, undefined, disposable);
        }
        Event.defer = defer;
        /**
         * Given an event, returns another event which only fires once.
         *
         * @param event The event source for the new event.
         */
        function once(event) {
            return (listener, thisArgs = null, disposables) => {
                // we need this, in case the event fires during the listener call
                let didFire = false;
                let result = undefined;
                result = event(e => {
                    if (didFire) {
                        return;
                    }
                    else if (result) {
                        result.dispose();
                    }
                    else {
                        didFire = true;
                    }
                    return listener.call(thisArgs, e);
                }, null, disposables);
                if (didFire) {
                    result.dispose();
                }
                return result;
            };
        }
        Event.once = once;
        /**
         * Given an event, returns another event which only fires once, and only when the condition is met.
         *
         * @param event The event source for the new event.
         */
        function onceIf(event, condition) {
            return Event.once(Event.filter(event, condition));
        }
        Event.onceIf = onceIf;
        /**
         * Maps an event of one type into an event of another type using a mapping function, similar to how
         * `Array.prototype.map` works.
         *
         * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
         * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
         * returned event causes this utility to leak a listener on the original event.
         *
         * @param event The event source for the new event.
         * @param map The mapping function.
         * @param disposable A disposable store to add the new EventEmitter to.
         */
        function map(event, map, disposable) {
            return snapshot((listener, thisArgs = null, disposables) => event(i => listener.call(thisArgs, map(i)), null, disposables), disposable);
        }
        Event.map = map;
        /**
         * Wraps an event in another event that performs some function on the event object before firing.
         *
         * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
         * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
         * returned event causes this utility to leak a listener on the original event.
         *
         * @param event The event source for the new event.
         * @param each The function to perform on the event object.
         * @param disposable A disposable store to add the new EventEmitter to.
         */
        function forEach(event, each, disposable) {
            return snapshot((listener, thisArgs = null, disposables) => event(i => { each(i); listener.call(thisArgs, i); }, null, disposables), disposable);
        }
        Event.forEach = forEach;
        function filter(event, filter, disposable) {
            return snapshot((listener, thisArgs = null, disposables) => event(e => filter(e) && listener.call(thisArgs, e), null, disposables), disposable);
        }
        Event.filter = filter;
        /**
         * Given an event, returns the same event but typed as `Event<void>`.
         */
        function signal(event) {
            return event;
        }
        Event.signal = signal;
        function any(...events) {
            return (listener, thisArgs = null, disposables) => {
                const disposable = (0, lifecycle_1.$Wc)(...events.map(event => event(e => listener.call(thisArgs, e))));
                return addAndReturnDisposable(disposable, disposables);
            };
        }
        Event.any = any;
        /**
         * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
         * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
         * returned event causes this utility to leak a listener on the original event.
         */
        function reduce(event, merge, initial, disposable) {
            let output = initial;
            return map(event, e => {
                output = merge(output, e);
                return output;
            }, disposable);
        }
        Event.reduce = reduce;
        function snapshot(event, disposable) {
            let listener;
            const options = {
                onWillAddFirstListener() {
                    listener = event(emitter.fire, emitter);
                },
                onDidRemoveLastListener() {
                    listener?.dispose();
                }
            };
            if (!disposable) {
                _addLeakageTraceLogic(options);
            }
            const emitter = new $qe(options);
            disposable?.add(emitter);
            return emitter.event;
        }
        /**
         * Adds the IDisposable to the store if it's set, and returns it. Useful to
         * Event function implementation.
         */
        function addAndReturnDisposable(d, store) {
            if (store instanceof Array) {
                store.push(d);
            }
            else if (store) {
                store.add(d);
            }
            return d;
        }
        function debounce(event, merge, delay = 100, leading = false, flushOnListenerRemove = false, leakWarningThreshold, disposable) {
            let subscription;
            let output = undefined;
            let handle = undefined;
            let numDebouncedCalls = 0;
            let doFire;
            const options = {
                leakWarningThreshold,
                onWillAddFirstListener() {
                    subscription = event(cur => {
                        numDebouncedCalls++;
                        output = merge(output, cur);
                        if (leading && !handle) {
                            emitter.fire(output);
                            output = undefined;
                        }
                        doFire = () => {
                            const _output = output;
                            output = undefined;
                            handle = undefined;
                            if (!leading || numDebouncedCalls > 1) {
                                emitter.fire(_output);
                            }
                            numDebouncedCalls = 0;
                        };
                        if (typeof delay === 'number') {
                            clearTimeout(handle);
                            handle = setTimeout(doFire, delay);
                        }
                        else {
                            if (handle === undefined) {
                                handle = 0;
                                queueMicrotask(doFire);
                            }
                        }
                    });
                },
                onWillRemoveListener() {
                    if (flushOnListenerRemove && numDebouncedCalls > 0) {
                        doFire?.();
                    }
                },
                onDidRemoveLastListener() {
                    doFire = undefined;
                    subscription.dispose();
                }
            };
            if (!disposable) {
                _addLeakageTraceLogic(options);
            }
            const emitter = new $qe(options);
            disposable?.add(emitter);
            return emitter.event;
        }
        Event.debounce = debounce;
        /**
         * Debounces an event, firing after some delay (default=0) with an array of all event original objects.
         *
         * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
         * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
         * returned event causes this utility to leak a listener on the original event.
         */
        function accumulate(event, delay = 0, disposable) {
            return Event.debounce(event, (last, e) => {
                if (!last) {
                    return [e];
                }
                last.push(e);
                return last;
            }, delay, undefined, true, undefined, disposable);
        }
        Event.accumulate = accumulate;
        /**
         * Filters an event such that some condition is _not_ met more than once in a row, effectively ensuring duplicate
         * event objects from different sources do not fire the same event object.
         *
         * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
         * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
         * returned event causes this utility to leak a listener on the original event.
         *
         * @param event The event source for the new event.
         * @param equals The equality condition.
         * @param disposable A disposable store to add the new EventEmitter to.
         *
         * @example
         * ```
         * // Fire only one time when a single window is opened or focused
         * Event.latch(Event.any(onDidOpenWindow, onDidFocusWindow))
         * ```
         */
        function latch(event, equals = (a, b) => a === b, disposable) {
            let firstCall = true;
            let cache;
            return filter(event, value => {
                const shouldEmit = firstCall || !equals(value, cache);
                firstCall = false;
                cache = value;
                return shouldEmit;
            }, disposable);
        }
        Event.latch = latch;
        /**
         * Splits an event whose parameter is a union type into 2 separate events for each type in the union.
         *
         * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
         * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
         * returned event causes this utility to leak a listener on the original event.
         *
         * @example
         * ```
         * const event = new EventEmitter<number | undefined>().event;
         * const [numberEvent, undefinedEvent] = Event.split(event, isUndefined);
         * ```
         *
         * @param event The event source for the new event.
         * @param isT A function that determines what event is of the first type.
         * @param disposable A disposable store to add the new EventEmitter to.
         */
        function split(event, isT, disposable) {
            return [
                Event.filter(event, isT, disposable),
                Event.filter(event, e => !isT(e), disposable),
            ];
        }
        Event.split = split;
        /**
         * Buffers an event until it has a listener attached.
         *
         * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
         * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
         * returned event causes this utility to leak a listener on the original event.
         *
         * @param event The event source for the new event.
         * @param flushAfterTimeout Determines whether to flush the buffer after a timeout immediately or after a
         * `setTimeout` when the first event listener is added.
         * @param _buffer Internal: A source event array used for tests.
         *
         * @example
         * ```
         * // Start accumulating events, when the first listener is attached, flush
         * // the event after a timeout such that multiple listeners attached before
         * // the timeout would receive the event
         * this.onInstallExtension = Event.buffer(service.onInstallExtension, true);
         * ```
         */
        function buffer(event, flushAfterTimeout = false, _buffer = [], disposable) {
            let buffer = _buffer.slice();
            let listener = event(e => {
                if (buffer) {
                    buffer.push(e);
                }
                else {
                    emitter.fire(e);
                }
            });
            if (disposable) {
                disposable.add(listener);
            }
            const flush = () => {
                buffer?.forEach(e => emitter.fire(e));
                buffer = null;
            };
            const emitter = new $qe({
                onWillAddFirstListener() {
                    if (!listener) {
                        listener = event(e => emitter.fire(e));
                        if (disposable) {
                            disposable.add(listener);
                        }
                    }
                },
                onDidAddFirstListener() {
                    if (buffer) {
                        if (flushAfterTimeout) {
                            setTimeout(flush);
                        }
                        else {
                            flush();
                        }
                    }
                },
                onDidRemoveLastListener() {
                    if (listener) {
                        listener.dispose();
                    }
                    listener = null;
                }
            });
            if (disposable) {
                disposable.add(emitter);
            }
            return emitter.event;
        }
        Event.buffer = buffer;
        /**
         * Wraps the event in an {@link IChainableEvent}, allowing a more functional programming style.
         *
         * @example
         * ```
         * // Normal
         * const onEnterPressNormal = Event.filter(
         *   Event.map(onKeyPress.event, e => new StandardKeyboardEvent(e)),
         *   e.keyCode === KeyCode.Enter
         * ).event;
         *
         * // Using chain
         * const onEnterPressChain = Event.chain(onKeyPress.event, $ => $
         *   .map(e => new StandardKeyboardEvent(e))
         *   .filter(e => e.keyCode === KeyCode.Enter)
         * );
         * ```
         */
        function chain(event, sythensize) {
            const fn = (listener, thisArgs, disposables) => {
                const cs = sythensize(new ChainableSynthesis());
                return event(function (value) {
                    const result = cs.evaluate(value);
                    if (result !== HaltChainable) {
                        listener.call(thisArgs, result);
                    }
                }, undefined, disposables);
            };
            return fn;
        }
        Event.chain = chain;
        const HaltChainable = Symbol('HaltChainable');
        class ChainableSynthesis {
            constructor() {
                this.f = [];
            }
            map(fn) {
                this.f.push(fn);
                return this;
            }
            forEach(fn) {
                this.f.push(v => {
                    fn(v);
                    return v;
                });
                return this;
            }
            filter(fn) {
                this.f.push(v => fn(v) ? v : HaltChainable);
                return this;
            }
            reduce(merge, initial) {
                let last = initial;
                this.f.push(v => {
                    last = merge(last, v);
                    return last;
                });
                return this;
            }
            latch(equals = (a, b) => a === b) {
                let firstCall = true;
                let cache;
                this.f.push(value => {
                    const shouldEmit = firstCall || !equals(value, cache);
                    firstCall = false;
                    cache = value;
                    return shouldEmit ? value : HaltChainable;
                });
                return this;
            }
            evaluate(value) {
                for (const step of this.f) {
                    value = step(value);
                    if (value === HaltChainable) {
                        break;
                    }
                }
                return value;
            }
        }
        /**
         * Creates an {@link Event} from a node event emitter.
         */
        function fromNodeEventEmitter(emitter, eventName, map = id => id) {
            const fn = (...args) => result.fire(map(...args));
            const onFirstListenerAdd = () => emitter.on(eventName, fn);
            const onLastListenerRemove = () => emitter.removeListener(eventName, fn);
            const result = new $qe({ onWillAddFirstListener: onFirstListenerAdd, onDidRemoveLastListener: onLastListenerRemove });
            return result.event;
        }
        Event.fromNodeEventEmitter = fromNodeEventEmitter;
        /**
         * Creates an {@link Event} from a DOM event emitter.
         */
        function fromDOMEventEmitter(emitter, eventName, map = id => id) {
            const fn = (...args) => result.fire(map(...args));
            const onFirstListenerAdd = () => emitter.addEventListener(eventName, fn);
            const onLastListenerRemove = () => emitter.removeEventListener(eventName, fn);
            const result = new $qe({ onWillAddFirstListener: onFirstListenerAdd, onDidRemoveLastListener: onLastListenerRemove });
            return result.event;
        }
        Event.fromDOMEventEmitter = fromDOMEventEmitter;
        /**
         * Creates a promise out of an event, using the {@link Event.once} helper.
         */
        function toPromise(event) {
            return new Promise(resolve => once(event)(resolve));
        }
        Event.toPromise = toPromise;
        /**
         * Creates an event out of a promise that fires once when the promise is
         * resolved with the result of the promise or `undefined`.
         */
        function fromPromise(promise) {
            const result = new $qe();
            promise.then(res => {
                result.fire(res);
            }, () => {
                result.fire(undefined);
            }).finally(() => {
                result.dispose();
            });
            return result.event;
        }
        Event.fromPromise = fromPromise;
        /**
         * A convenience function for forwarding an event to another emitter which
         * improves readability.
         *
         * This is similar to {@link $ze} but allows instantiating and forwarding
         * on a single line and also allows for multiple source events.
         * @param from The event to forward.
         * @param to The emitter to forward the event to.
         * @example
         * Event.forward(event, emitter);
         * // equivalent to
         * event(e => emitter.fire(e));
         * // equivalent to
         * event(emitter.fire, emitter);
         */
        function forward(from, to) {
            return from(e => to.fire(e));
        }
        Event.forward = forward;
        function runAndSubscribe(event, handler, initial) {
            handler(initial);
            return event(e => handler(e));
        }
        Event.runAndSubscribe = runAndSubscribe;
        class EmitterObserver {
            constructor(_observable, store) {
                this._observable = _observable;
                this.f = 0;
                this.g = false;
                const options = {
                    onWillAddFirstListener: () => {
                        _observable.addObserver(this);
                        // Communicate to the observable that we received its current value and would like to be notified about future changes.
                        this._observable.reportChanges();
                    },
                    onDidRemoveLastListener: () => {
                        _observable.removeObserver(this);
                    }
                };
                if (!store) {
                    _addLeakageTraceLogic(options);
                }
                this.emitter = new $qe(options);
                if (store) {
                    store.add(this.emitter);
                }
            }
            beginUpdate(_observable) {
                // assert(_observable === this.obs);
                this.f++;
            }
            handlePossibleChange(_observable) {
                // assert(_observable === this.obs);
            }
            handleChange(_observable, _change) {
                // assert(_observable === this.obs);
                this.g = true;
            }
            endUpdate(_observable) {
                // assert(_observable === this.obs);
                this.f--;
                if (this.f === 0) {
                    this._observable.reportChanges();
                    if (this.g) {
                        this.g = false;
                        this.emitter.fire(this._observable.get());
                    }
                }
            }
        }
        /**
         * Creates an event emitter that is fired when the observable changes.
         * Each listeners subscribes to the emitter.
         */
        function fromObservable(obs, store) {
            const observer = new EmitterObserver(obs, store);
            return observer.emitter.event;
        }
        Event.fromObservable = fromObservable;
        /**
         * Each listener is attached to the observable directly.
         */
        function fromObservableLight(observable) {
            return (listener, thisArgs, disposables) => {
                let count = 0;
                let didChange = false;
                const observer = {
                    beginUpdate() {
                        count++;
                    },
                    endUpdate() {
                        count--;
                        if (count === 0) {
                            observable.reportChanges();
                            if (didChange) {
                                didChange = false;
                                listener.call(thisArgs);
                            }
                        }
                    },
                    handlePossibleChange() {
                        // noop
                    },
                    handleChange() {
                        didChange = true;
                    }
                };
                observable.addObserver(observer);
                observable.reportChanges();
                const disposable = {
                    dispose() {
                        observable.removeObserver(observer);
                    }
                };
                if (disposables instanceof lifecycle_1.$Yc) {
                    disposables.add(disposable);
                }
                else if (Array.isArray(disposables)) {
                    disposables.push(disposable);
                }
                return disposable;
            };
        }
        Event.fromObservableLight = fromObservableLight;
    })(Event || (exports.Event = Event = {}));
    class $me {
        static { this.all = new Set(); }
        static { this.f = 0; }
        constructor(name) {
            this.listenerCount = 0;
            this.invocationCount = 0;
            this.elapsedOverall = 0;
            this.durations = [];
            this.name = `${name}_${$me.f++}`;
            $me.all.add(this);
        }
        start(listenerCount) {
            this.g = new stopwatch_1.$ke();
            this.listenerCount = listenerCount;
        }
        stop() {
            if (this.g) {
                const elapsed = this.g.elapsed();
                this.durations.push(elapsed);
                this.elapsedOverall += elapsed;
                this.invocationCount += 1;
                this.g = undefined;
            }
        }
    }
    exports.$me = $me;
    let _globalLeakWarningThreshold = -1;
    function $ne(n) {
        const oldValue = _globalLeakWarningThreshold;
        _globalLeakWarningThreshold = n;
        return {
            dispose() {
                _globalLeakWarningThreshold = oldValue;
            }
        };
    }
    class LeakageMonitor {
        static { this.f = 1; }
        constructor(j, threshold, name = (LeakageMonitor.f++).toString(16).padStart(3, '0')) {
            this.j = j;
            this.threshold = threshold;
            this.name = name;
            this.h = 0;
        }
        dispose() {
            this.g?.clear();
        }
        check(stack, listenerCount) {
            const threshold = this.threshold;
            if (threshold <= 0 || listenerCount < threshold) {
                return undefined;
            }
            if (!this.g) {
                this.g = new Map();
            }
            const count = (this.g.get(stack.value) || 0);
            this.g.set(stack.value, count + 1);
            this.h -= 1;
            if (this.h <= 0) {
                // only warn on first exceed and then every time the limit
                // is exceeded by 50% again
                this.h = threshold * 0.5;
                const [topStack, topCount] = this.getMostFrequentStack();
                const message = `[${this.name}] potential listener LEAK detected, having ${listenerCount} listeners already. MOST frequent listener (${topCount}):`;
                console.warn(message);
                console.warn(topStack);
                const error = new $oe(message, topStack);
                this.j(error);
            }
            return () => {
                const count = (this.g.get(stack.value) || 0);
                this.g.set(stack.value, count - 1);
            };
        }
        getMostFrequentStack() {
            if (!this.g) {
                return undefined;
            }
            let topStack;
            let topCount = 0;
            for (const [stack, count] of this.g) {
                if (!topStack || topCount < count) {
                    topStack = [stack, count];
                    topCount = count;
                }
            }
            return topStack;
        }
    }
    class Stacktrace {
        static create() {
            const err = new Error();
            return new Stacktrace(err.stack ?? '');
        }
        constructor(value) {
            this.value = value;
        }
        print() {
            console.warn(this.value.split('\n').slice(2).join('\n'));
        }
    }
    // error that is logged when going over the configured listener threshold
    class $oe extends Error {
        constructor(message, stack) {
            super(message);
            this.name = 'ListenerLeakError';
            this.stack = stack;
        }
    }
    exports.$oe = $oe;
    // SEVERE error that is logged when having gone way over the configured listener
    // threshold so that the emitter refuses to accept more listeners
    class $pe extends Error {
        constructor(message, stack) {
            super(message);
            this.name = 'ListenerRefusalError';
            this.stack = stack;
        }
    }
    exports.$pe = $pe;
    let id = 0;
    class UniqueContainer {
        constructor(value) {
            this.value = value;
            this.id = id++;
        }
    }
    const compactionThreshold = 2;
    const forEachListener = (listeners, fn) => {
        if (listeners instanceof UniqueContainer) {
            fn(listeners);
        }
        else {
            for (let i = 0; i < listeners.length; i++) {
                const l = listeners[i];
                if (l) {
                    fn(l);
                }
            }
        }
    };
    let _listenerFinalizers;
    if (_enableListenerGCedWarning) {
        const leaks = [];
        setInterval(() => {
            if (leaks.length === 0) {
                return;
            }
            console.warn('[LEAKING LISTENERS] GC\'ed these listeners that were NOT yet disposed:');
            console.warn(leaks.join('\n'));
            leaks.length = 0;
        }, 3000);
        _listenerFinalizers = new FinalizationRegistry(heldValue => {
            if (typeof heldValue === 'string') {
                leaks.push(heldValue);
            }
        });
    }
    /**
     * The Emitter can be used to expose an Event to the public
     * to fire it from the insides.
     * Sample:
        class Document {
    
            private readonly _onDidChange = new Emitter<(value:string)=>any>();
    
            public onDidChange = this._onDidChange.event;
    
            // getter-style
            // get onDidChange(): Event<(value:string)=>any> {
            // 	return this._onDidChange.event;
            // }
    
            private _doIt() {
                //...
                this._onDidChange.fire(value);
            }
        }
     */
    class $qe {
        constructor(options) {
            this.z = 0;
            this.f = options;
            this.g = (_globalLeakWarningThreshold > 0 || this.f?.leakWarningThreshold)
                ? new LeakageMonitor(options?.onListenerError ?? errors_1.$4, this.f?.leakWarningThreshold ?? _globalLeakWarningThreshold) :
                undefined;
            this.j = this.f?._profName ? new $me(this.f._profName) : undefined;
            this.w = this.f?.deliveryQueue;
        }
        dispose() {
            if (!this.m) {
                this.m = true;
                // It is bad to have listeners at the time of disposing an emitter, it is worst to have listeners keep the emitter
                // alive via the reference that's embedded in their disposables. Therefore we loop over all remaining listeners and
                // unset their subscriptions/disposables. Looping and blaming remaining listeners is done on next tick because the
                // the following programming pattern is very popular:
                //
                // const someModel = this._disposables.add(new ModelObject()); // (1) create and register model
                // this._disposables.add(someModel.onDidChange(() => { ... }); // (2) subscribe and register model-event listener
                // ...later...
                // this._disposables.dispose(); disposes (1) then (2): don't warn after (1) but after the "overall dispose" is done
                if (this.w?.current === this) {
                    this.w.reset();
                }
                if (this.u) {
                    if (_enableDisposeWithListenerWarning) {
                        const listeners = this.u;
                        queueMicrotask(() => {
                            forEachListener(listeners, l => l.stack?.print());
                        });
                    }
                    this.u = undefined;
                    this.z = 0;
                }
                this.f?.onDidRemoveLastListener?.();
                this.g?.dispose();
            }
        }
        /**
         * For the public to allow to subscribe
         * to events from this Emitter
         */
        get event() {
            this.q ??= (callback, thisArgs, disposables) => {
                if (this.g && this.z > this.g.threshold ** 2) {
                    const message = `[${this.g.name}] REFUSES to accept new listeners because it exceeded its threshold by far (${this.z} vs ${this.g.threshold})`;
                    console.warn(message);
                    const tuple = this.g.getMostFrequentStack() ?? ['UNKNOWN stack', -1];
                    const error = new $pe(`${message}. HINT: Stack shows most frequent listener (${tuple[1]}-times)`, tuple[0]);
                    const errorHandler = this.f?.onListenerError || errors_1.$4;
                    errorHandler(error);
                    return lifecycle_1.$Zc.None;
                }
                if (this.m) {
                    // todo: should we warn if a listener is added to a disposed emitter? This happens often
                    return lifecycle_1.$Zc.None;
                }
                if (thisArgs) {
                    callback = callback.bind(thisArgs);
                }
                const contained = new UniqueContainer(callback);
                let removeMonitor;
                let stack;
                if (this.g && this.z >= Math.ceil(this.g.threshold * 0.2)) {
                    // check and record this emitter for potential leakage
                    contained.stack = Stacktrace.create();
                    removeMonitor = this.g.check(contained.stack, this.z + 1);
                }
                if (_enableDisposeWithListenerWarning) {
                    contained.stack = stack ?? Stacktrace.create();
                }
                if (!this.u) {
                    this.f?.onWillAddFirstListener?.(this);
                    this.u = contained;
                    this.f?.onDidAddFirstListener?.(this);
                }
                else if (this.u instanceof UniqueContainer) {
                    this.w ??= new EventDeliveryQueuePrivate();
                    this.u = [this.u, contained];
                }
                else {
                    this.u.push(contained);
                }
                this.z++;
                const result = (0, lifecycle_1.$Xc)(() => {
                    _listenerFinalizers?.unregister(result);
                    removeMonitor?.();
                    this.A(contained);
                });
                if (disposables instanceof lifecycle_1.$Yc) {
                    disposables.add(result);
                }
                else if (Array.isArray(disposables)) {
                    disposables.push(result);
                }
                if (_listenerFinalizers) {
                    const stack = new Error().stack.split('\n').slice(2, 3).join('\n').trim();
                    const match = /(file:|vscode-file:\/\/vscode-app)?(\/[^:]*:\d+:\d+)/.exec(stack);
                    _listenerFinalizers.register(result, match?.[2] ?? stack, result);
                }
                return result;
            };
            return this.q;
        }
        A(listener) {
            this.f?.onWillRemoveListener?.(this);
            if (!this.u) {
                return; // expected if a listener gets disposed
            }
            if (this.z === 1) {
                this.u = undefined;
                this.f?.onDidRemoveLastListener?.(this);
                this.z = 0;
                return;
            }
            // size > 1 which requires that listeners be a list:
            const listeners = this.u;
            const index = listeners.indexOf(listener);
            if (index === -1) {
                console.log('disposed?', this.m);
                console.log('size?', this.z);
                console.log('arr?', JSON.stringify(this.u));
                throw new Error('Attempted to dispose unknown listener');
            }
            this.z--;
            listeners[index] = undefined;
            const adjustDeliveryQueue = this.w.current === this;
            if (this.z * compactionThreshold <= listeners.length) {
                let n = 0;
                for (let i = 0; i < listeners.length; i++) {
                    if (listeners[i]) {
                        listeners[n++] = listeners[i];
                    }
                    else if (adjustDeliveryQueue) {
                        this.w.end--;
                        if (n < this.w.i) {
                            this.w.i--;
                        }
                    }
                }
                listeners.length = n;
            }
        }
        B(listener, value) {
            if (!listener) {
                return;
            }
            const errorHandler = this.f?.onListenerError || errors_1.$4;
            if (!errorHandler) {
                listener.value(value);
                return;
            }
            try {
                listener.value(value);
            }
            catch (e) {
                errorHandler(e);
            }
        }
        /** Delivers items in the queue. Assumes the queue is ready to go. */
        C(dq) {
            const listeners = dq.current.u;
            while (dq.i < dq.end) {
                // important: dq.i is incremented before calling deliver() because it might reenter deliverQueue()
                this.B(listeners[dq.i++], dq.value);
            }
            dq.reset();
        }
        /**
         * To be kept private to fire an event to
         * subscribers
         */
        fire(event) {
            if (this.w?.current) {
                this.C(this.w);
                this.j?.stop(); // last fire() will have starting perfmon, stop it before starting the next dispatch
            }
            this.j?.start(this.z);
            if (!this.u) {
                // no-op
            }
            else if (this.u instanceof UniqueContainer) {
                this.B(this.u, event);
            }
            else {
                const dq = this.w;
                dq.enqueue(this, event, this.u.length);
                this.C(dq);
            }
            this.j?.stop();
        }
        hasListeners() {
            return this.z > 0;
        }
    }
    exports.$qe = $qe;
    const $re = () => new EventDeliveryQueuePrivate();
    exports.$re = $re;
    class EventDeliveryQueuePrivate {
        constructor() {
            /**
             * Index in current's listener list.
             */
            this.i = -1;
            /**
             * The last index in the listener's list to deliver.
             */
            this.end = 0;
        }
        enqueue(emitter, value, end) {
            this.i = 0;
            this.end = end;
            this.current = emitter;
            this.value = value;
        }
        reset() {
            this.i = this.end; // force any current emission loop to stop, mainly for during dispose
            this.current = undefined;
            this.value = undefined;
        }
    }
    class $se extends $qe {
        async fireAsync(data, token, promiseJoin) {
            if (!this.u) {
                return;
            }
            if (!this.h) {
                this.h = new linkedList_1.$0c();
            }
            forEachListener(this.u, listener => this.h.push([listener.value, data]));
            while (this.h.size > 0 && !token.isCancellationRequested) {
                const [listener, data] = this.h.shift();
                const thenables = [];
                const event = {
                    ...data,
                    token,
                    waitUntil: (p) => {
                        if (Object.isFrozen(thenables)) {
                            throw new Error('waitUntil can NOT be called asynchronous');
                        }
                        if (promiseJoin) {
                            p = promiseJoin(p, listener);
                        }
                        thenables.push(p);
                    }
                };
                try {
                    listener(event);
                }
                catch (e) {
                    (0, errors_1.$4)(e);
                    continue;
                }
                // freeze thenables-collection to enforce sync-calls to
                // wait until and then wait for all thenables to resolve
                Object.freeze(thenables);
                await Promise.allSettled(thenables).then(values => {
                    for (const value of values) {
                        if (value.status === 'rejected') {
                            (0, errors_1.$4)(value.reason);
                        }
                    }
                });
            }
        }
    }
    exports.$se = $se;
    class $te extends $qe {
        get isPaused() {
            return this.h !== 0;
        }
        constructor(options) {
            super(options);
            this.h = 0;
            this.s = new linkedList_1.$0c();
            this.t = options?.merge;
        }
        pause() {
            this.h++;
        }
        resume() {
            if (this.h !== 0 && --this.h === 0) {
                if (this.t) {
                    // use the merge function to create a single composite
                    // event. make a copy in case firing pauses this emitter
                    if (this.s.size > 0) {
                        const events = Array.from(this.s);
                        this.s.clear();
                        super.fire(this.t(events));
                    }
                }
                else {
                    // no merging, fire each event individually and test
                    // that this emitter isn't paused halfway through
                    while (!this.h && this.s.size !== 0) {
                        super.fire(this.s.shift());
                    }
                }
            }
        }
        fire(event) {
            if (this.z) {
                if (this.h !== 0) {
                    this.s.push(event);
                }
                else {
                    super.fire(event);
                }
            }
        }
    }
    exports.$te = $te;
    class $ue extends $te {
        constructor(options) {
            super(options);
            this.k = options.delay ?? 100;
        }
        fire(event) {
            if (!this.o) {
                this.pause();
                this.o = setTimeout(() => {
                    this.o = undefined;
                    this.resume();
                }, this.k);
            }
            super.fire(event);
        }
    }
    exports.$ue = $ue;
    /**
     * An emitter which queue all events and then process them at the
     * end of the event loop.
     */
    class $ve extends $qe {
        constructor(options) {
            super(options);
            this.h = [];
            this.k = options?.merge;
        }
        fire(event) {
            if (!this.hasListeners()) {
                return;
            }
            this.h.push(event);
            if (this.h.length === 1) {
                queueMicrotask(() => {
                    if (this.k) {
                        super.fire(this.k(this.h));
                    }
                    else {
                        this.h.forEach(e => super.fire(e));
                    }
                    this.h = [];
                });
            }
        }
    }
    exports.$ve = $ve;
    /**
     * An event emitter that multiplexes many events into a single event.
     *
     * @example Listen to the `onData` event of all `Thing`s, dynamically adding and removing `Thing`s
     * to the multiplexer as needed.
     *
     * ```typescript
     * const anythingDataMultiplexer = new EventMultiplexer<{ data: string }>();
     *
     * const thingListeners = DisposableMap<Thing, IDisposable>();
     *
     * thingService.onDidAddThing(thing => {
     *   thingListeners.set(thing, anythingDataMultiplexer.add(thing.onData);
     * });
     * thingService.onDidRemoveThing(thing => {
     *   thingListeners.deleteAndDispose(thing);
     * });
     *
     * anythingDataMultiplexer.event(e => {
     *   console.log('Something fired data ' + e.data)
     * });
     * ```
     */
    class $we {
        constructor() {
            this.g = false;
            this.h = [];
            this.f = new $qe({
                onWillAddFirstListener: () => this.j(),
                onDidRemoveLastListener: () => this.k()
            });
        }
        get event() {
            return this.f.event;
        }
        add(event) {
            const e = { event: event, listener: null };
            this.h.push(e);
            if (this.g) {
                this.m(e);
            }
            const dispose = () => {
                if (this.g) {
                    this.o(e);
                }
                const idx = this.h.indexOf(e);
                this.h.splice(idx, 1);
            };
            return (0, lifecycle_1.$Xc)((0, functional_1.$hb)(dispose));
        }
        j() {
            this.g = true;
            this.h.forEach(e => this.m(e));
        }
        k() {
            this.g = false;
            this.h.forEach(e => this.o(e));
        }
        m(e) {
            e.listener = e.event(r => this.f.fire(r));
        }
        o(e) {
            e.listener?.dispose();
            e.listener = null;
        }
        dispose() {
            this.f.dispose();
            for (const e of this.h) {
                e.listener?.dispose();
            }
            this.h = [];
        }
    }
    exports.$we = $we;
    class $xe {
        constructor(items, onAddItem, onRemoveItem, getEvent) {
            this.f = new lifecycle_1.$Yc();
            const multiplexer = this.f.add(new $we());
            const itemListeners = this.f.add(new lifecycle_1.$9c());
            function addItem(instance) {
                itemListeners.set(instance, multiplexer.add(getEvent(instance)));
            }
            // Existing items
            for (const instance of items) {
                addItem(instance);
            }
            // Added items
            this.f.add(onAddItem(instance => {
                addItem(instance);
            }));
            // Removed items
            this.f.add(onRemoveItem(instance => {
                itemListeners.deleteAndDispose(instance);
            }));
            this.event = multiplexer.event;
        }
        dispose() {
            this.f.dispose();
        }
    }
    exports.$xe = $xe;
    /**
     * The EventBufferer is useful in situations in which you want
     * to delay firing your events during some code.
     * You can wrap that code and be sure that the event will not
     * be fired during that wrap.
     *
     * ```
     * const emitter: Emitter;
     * const delayer = new EventDelayer();
     * const delayedEvent = delayer.wrapEvent(emitter.event);
     *
     * delayedEvent(console.log);
     *
     * delayer.bufferEvents(() => {
     *   emitter.fire(); // event will not be fired yet
     * });
     *
     * // event will only be fired at this point
     * ```
     */
    class $ye {
        constructor() {
            this.f = [];
        }
        wrapEvent(event, reduce, initial) {
            return (listener, thisArgs, disposables) => {
                return event(i => {
                    const data = this.f[this.f.length - 1];
                    // Non-reduce scenario
                    if (!reduce) {
                        // Buffering case
                        if (data) {
                            data.buffers.push(() => listener.call(thisArgs, i));
                        }
                        else {
                            // Not buffering case
                            listener.call(thisArgs, i);
                        }
                        return;
                    }
                    // Reduce scenario
                    const reduceData = data;
                    // Not buffering case
                    if (!reduceData) {
                        // TODO: Is there a way to cache this reduce call for all listeners?
                        listener.call(thisArgs, reduce(initial, i));
                        return;
                    }
                    // Buffering case
                    reduceData.items ??= [];
                    reduceData.items.push(i);
                    if (reduceData.buffers.length === 0) {
                        // Include a single buffered function that will reduce all events when we're done buffering events
                        data.buffers.push(() => {
                            // cache the reduced result so that the value can be shared across all listeners
                            reduceData.reducedResult ??= initial
                                ? reduceData.items.reduce(reduce, initial)
                                : reduceData.items.reduce(reduce);
                            listener.call(thisArgs, reduceData.reducedResult);
                        });
                    }
                }, undefined, disposables);
            };
        }
        bufferEvents(fn) {
            const data = { buffers: new Array() };
            this.f.push(data);
            const r = fn();
            this.f.pop();
            data.buffers.forEach(flush => flush());
            return r;
        }
    }
    exports.$ye = $ye;
    /**
     * A Relay is an event forwarder which functions as a replugabble event pipe.
     * Once created, you can connect an input event to it and it will simply forward
     * events from that input event through its own `event` property. The `input`
     * can be changed at any point in time.
     */
    class $ze {
        constructor() {
            this.f = false;
            this.g = Event.None;
            this.h = lifecycle_1.$Zc.None;
            this.j = new $qe({
                onDidAddFirstListener: () => {
                    this.f = true;
                    this.h = this.g(this.j.fire, this.j);
                },
                onDidRemoveLastListener: () => {
                    this.f = false;
                    this.h.dispose();
                }
            });
            this.event = this.j.event;
        }
        set input(event) {
            this.g = event;
            if (this.f) {
                this.h.dispose();
                this.h = event(this.j.fire, this.j);
            }
        }
        dispose() {
            this.h.dispose();
            this.j.dispose();
        }
    }
    exports.$ze = $ze;
    class $Ae {
        static const(value) {
            return new ConstValueWithChangeEvent(value);
        }
        constructor(g) {
            this.g = g;
            this.f = new $qe();
            this.onDidChange = this.f.event;
        }
        get value() {
            return this.g;
        }
        set value(value) {
            if (value !== this.g) {
                this.g = value;
                this.f.fire(undefined);
            }
        }
    }
    exports.$Ae = $Ae;
    class ConstValueWithChangeEvent {
        constructor(value) {
            this.value = value;
            this.onDidChange = Event.None;
        }
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[18/*vs/base/common/cancellation*/], __M([0/*require*/,1/*exports*/,4/*vs/base/common/event*/]), function (require, exports, event_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$Be = exports.CancellationToken = void 0;
    exports.$Ce = $Ce;
    const shortcutEvent = Object.freeze(function (callback, context) {
        const handle = setTimeout(callback.bind(context), 0);
        return { dispose() { clearTimeout(handle); } };
    });
    var CancellationToken;
    (function (CancellationToken) {
        function isCancellationToken(thing) {
            if (thing === CancellationToken.None || thing === CancellationToken.Cancelled) {
                return true;
            }
            if (thing instanceof MutableToken) {
                return true;
            }
            if (!thing || typeof thing !== 'object') {
                return false;
            }
            return typeof thing.isCancellationRequested === 'boolean'
                && typeof thing.onCancellationRequested === 'function';
        }
        CancellationToken.isCancellationToken = isCancellationToken;
        CancellationToken.None = Object.freeze({
            isCancellationRequested: false,
            onCancellationRequested: event_1.Event.None
        });
        CancellationToken.Cancelled = Object.freeze({
            isCancellationRequested: true,
            onCancellationRequested: shortcutEvent
        });
    })(CancellationToken || (exports.CancellationToken = CancellationToken = {}));
    class MutableToken {
        constructor() {
            this.a = false;
            this.b = null;
        }
        cancel() {
            if (!this.a) {
                this.a = true;
                if (this.b) {
                    this.b.fire(undefined);
                    this.dispose();
                }
            }
        }
        get isCancellationRequested() {
            return this.a;
        }
        get onCancellationRequested() {
            if (this.a) {
                return shortcutEvent;
            }
            if (!this.b) {
                this.b = new event_1.$qe();
            }
            return this.b.event;
        }
        dispose() {
            if (this.b) {
                this.b.dispose();
                this.b = null;
            }
        }
    }
    class $Be {
        constructor(parent) {
            this.f = undefined;
            this.g = undefined;
            this.g = parent && parent.onCancellationRequested(this.cancel, this);
        }
        get token() {
            if (!this.f) {
                // be lazy and create the token only when
                // actually needed
                this.f = new MutableToken();
            }
            return this.f;
        }
        cancel() {
            if (!this.f) {
                // save an object by returning the default
                // cancelled token when cancellation happens
                // before someone asks for the token
                this.f = CancellationToken.Cancelled;
            }
            else if (this.f instanceof MutableToken) {
                // actually cancel
                this.f.cancel();
            }
        }
        dispose(cancel = false) {
            if (cancel) {
                this.cancel();
            }
            this.g?.dispose();
            if (!this.f) {
                // ensure to initialize with an empty token if we had none
                this.f = CancellationToken.None;
            }
            else if (this.f instanceof MutableToken) {
                // actually dispose
                this.f.dispose();
            }
        }
    }
    exports.$Be = $Be;
    function $Ce(store) {
        const source = new $Be();
        store.add({ dispose() { source.cancel(); } });
        return source.token;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[51/*vs/base/common/cache*/], __M([0/*require*/,1/*exports*/,18/*vs/base/common/cancellation*/]), function (require, exports, cancellation_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$ef = exports.$df = exports.$bf = void 0;
    exports.$cf = $cf;
    class $bf {
        constructor(b) {
            this.b = b;
            this.a = null;
        }
        get() {
            if (this.a) {
                return this.a;
            }
            const cts = new cancellation_1.$Be();
            const promise = this.b(cts.token);
            this.a = {
                promise,
                dispose: () => {
                    this.a = null;
                    cts.cancel();
                    cts.dispose();
                }
            };
            return this.a;
        }
    }
    exports.$bf = $bf;
    function $cf(t) {
        return t;
    }
    /**
     * Uses a LRU cache to make a given parametrized function cached.
     * Caches just the last key/value.
    */
    class $df {
        constructor(arg1, arg2) {
            this.a = undefined;
            this.b = undefined;
            if (typeof arg1 === 'function') {
                this.c = arg1;
                this.d = $cf;
            }
            else {
                this.c = arg2;
                this.d = arg1.getCacheKey;
            }
        }
        get(arg) {
            const key = this.d(arg);
            if (this.b !== key) {
                this.b = key;
                this.a = this.c(arg);
            }
            return this.a;
        }
    }
    exports.$df = $df;
    /**
     * Uses an unbounded cache to memoize the results of the given function.
    */
    class $ef {
        get cachedValues() {
            return this.a;
        }
        constructor(arg1, arg2) {
            this.a = new Map();
            this.b = new Map();
            if (typeof arg1 === 'function') {
                this.c = arg1;
                this.d = $cf;
            }
            else {
                this.c = arg2;
                this.d = arg1.getCacheKey;
            }
        }
        get(arg) {
            const key = this.d(arg);
            if (this.b.has(key)) {
                return this.b.get(key);
            }
            const value = this.c(arg);
            this.a.set(arg, value);
            this.b.set(key, value);
            return value;
        }
    }
    exports.$ef = $ef;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[52/*vs/base/common/stream*/], __M([0/*require*/,1/*exports*/,7/*vs/base/common/errors*/,2/*vs/base/common/lifecycle*/]), function (require, exports, errors_1, lifecycle_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$De = $De;
    exports.$Ee = $Ee;
    exports.$Fe = $Fe;
    exports.$Ge = $Ge;
    exports.$He = $He;
    exports.$Ie = $Ie;
    exports.$Je = $Je;
    exports.$Ke = $Ke;
    exports.$Le = $Le;
    exports.$Me = $Me;
    exports.$Ne = $Ne;
    exports.$Oe = $Oe;
    exports.$Pe = $Pe;
    exports.$Qe = $Qe;
    exports.$Re = $Re;
    function $De(obj) {
        const candidate = obj;
        if (!candidate) {
            return false;
        }
        return typeof candidate.read === 'function';
    }
    function $Ee(obj) {
        const candidate = obj;
        if (!candidate) {
            return false;
        }
        return [candidate.on, candidate.pause, candidate.resume, candidate.destroy].every(fn => typeof fn === 'function');
    }
    function $Fe(obj) {
        const candidate = obj;
        if (!candidate) {
            return false;
        }
        return $Ee(candidate.stream) && Array.isArray(candidate.buffer) && typeof candidate.ended === 'boolean';
    }
    function $Ge(reducer, options) {
        return new WriteableStreamImpl(reducer, options);
    }
    class WriteableStreamImpl {
        constructor(e, f) {
            this.e = e;
            this.f = f;
            this.a = {
                flowing: false,
                ended: false,
                destroyed: false
            };
            this.b = {
                data: [],
                error: []
            };
            this.c = {
                data: [],
                error: [],
                end: []
            };
            this.d = [];
        }
        pause() {
            if (this.a.destroyed) {
                return;
            }
            this.a.flowing = false;
        }
        resume() {
            if (this.a.destroyed) {
                return;
            }
            if (!this.a.flowing) {
                this.a.flowing = true;
                // emit buffered events
                this.j();
                this.k();
                this.l();
            }
        }
        write(data) {
            if (this.a.destroyed) {
                return;
            }
            // flowing: directly send the data to listeners
            if (this.a.flowing) {
                this.g(data);
            }
            // not yet flowing: buffer data until flowing
            else {
                this.b.data.push(data);
                // highWaterMark: if configured, signal back when buffer reached limits
                if (typeof this.f?.highWaterMark === 'number' && this.b.data.length > this.f.highWaterMark) {
                    return new Promise(resolve => this.d.push(resolve));
                }
            }
        }
        error(error) {
            if (this.a.destroyed) {
                return;
            }
            // flowing: directly send the error to listeners
            if (this.a.flowing) {
                this.h(error);
            }
            // not yet flowing: buffer errors until flowing
            else {
                this.b.error.push(error);
            }
        }
        end(result) {
            if (this.a.destroyed) {
                return;
            }
            // end with data if provided
            if (typeof result !== 'undefined') {
                this.write(result);
            }
            // flowing: send end event to listeners
            if (this.a.flowing) {
                this.i();
                this.destroy();
            }
            // not yet flowing: remember state
            else {
                this.a.ended = true;
            }
        }
        g(data) {
            this.c.data.slice(0).forEach(listener => listener(data)); // slice to avoid listener mutation from delivering event
        }
        h(error) {
            if (this.c.error.length === 0) {
                (0, errors_1.$4)(error); // nobody listened to this error so we log it as unexpected
            }
            else {
                this.c.error.slice(0).forEach(listener => listener(error)); // slice to avoid listener mutation from delivering event
            }
        }
        i() {
            this.c.end.slice(0).forEach(listener => listener()); // slice to avoid listener mutation from delivering event
        }
        on(event, callback) {
            if (this.a.destroyed) {
                return;
            }
            switch (event) {
                case 'data':
                    this.c.data.push(callback);
                    // switch into flowing mode as soon as the first 'data'
                    // listener is added and we are not yet in flowing mode
                    this.resume();
                    break;
                case 'end':
                    this.c.end.push(callback);
                    // emit 'end' event directly if we are flowing
                    // and the end has already been reached
                    //
                    // finish() when it went through
                    if (this.a.flowing && this.l()) {
                        this.destroy();
                    }
                    break;
                case 'error':
                    this.c.error.push(callback);
                    // emit buffered 'error' events unless done already
                    // now that we know that we have at least one listener
                    if (this.a.flowing) {
                        this.k();
                    }
                    break;
            }
        }
        removeListener(event, callback) {
            if (this.a.destroyed) {
                return;
            }
            let listeners = undefined;
            switch (event) {
                case 'data':
                    listeners = this.c.data;
                    break;
                case 'end':
                    listeners = this.c.end;
                    break;
                case 'error':
                    listeners = this.c.error;
                    break;
            }
            if (listeners) {
                const index = listeners.indexOf(callback);
                if (index >= 0) {
                    listeners.splice(index, 1);
                }
            }
        }
        j() {
            if (this.b.data.length > 0) {
                const fullDataBuffer = this.e(this.b.data);
                this.g(fullDataBuffer);
                this.b.data.length = 0;
                // When the buffer is empty, resolve all pending writers
                const pendingWritePromises = [...this.d];
                this.d.length = 0;
                pendingWritePromises.forEach(pendingWritePromise => pendingWritePromise());
            }
        }
        k() {
            if (this.c.error.length > 0) {
                for (const error of this.b.error) {
                    this.h(error);
                }
                this.b.error.length = 0;
            }
        }
        l() {
            if (this.a.ended) {
                this.i();
                return this.c.end.length > 0;
            }
            return false;
        }
        destroy() {
            if (!this.a.destroyed) {
                this.a.destroyed = true;
                this.a.ended = true;
                this.b.data.length = 0;
                this.b.error.length = 0;
                this.c.data.length = 0;
                this.c.error.length = 0;
                this.c.end.length = 0;
                this.d.length = 0;
            }
        }
    }
    /**
     * Helper to fully read a T readable into a T.
     */
    function $He(readable, reducer) {
        const chunks = [];
        let chunk;
        while ((chunk = readable.read()) !== null) {
            chunks.push(chunk);
        }
        return reducer(chunks);
    }
    /**
     * Helper to read a T readable up to a maximum of chunks. If the limit is
     * reached, will return a readable instead to ensure all data can still
     * be read.
     */
    function $Ie(readable, reducer, maxChunks) {
        const chunks = [];
        let chunk = undefined;
        while ((chunk = readable.read()) !== null && chunks.length < maxChunks) {
            chunks.push(chunk);
        }
        // If the last chunk is null, it means we reached the end of
        // the readable and return all the data at once
        if (chunk === null && chunks.length > 0) {
            return reducer(chunks);
        }
        // Otherwise, we still have a chunk, it means we reached the maxChunks
        // value and as such we return a new Readable that first returns
        // the existing read chunks and then continues with reading from
        // the underlying readable.
        return {
            read: () => {
                // First consume chunks from our array
                if (chunks.length > 0) {
                    return chunks.shift();
                }
                // Then ensure to return our last read chunk
                if (typeof chunk !== 'undefined') {
                    const lastReadChunk = chunk;
                    // explicitly use undefined here to indicate that we consumed
                    // the chunk, which could have either been null or valued.
                    chunk = undefined;
                    return lastReadChunk;
                }
                // Finally delegate back to the Readable
                return readable.read();
            }
        };
    }
    function $Je(stream, reducer) {
        return new Promise((resolve, reject) => {
            const chunks = [];
            $Ke(stream, {
                onData: chunk => {
                    if (reducer) {
                        chunks.push(chunk);
                    }
                },
                onError: error => {
                    if (reducer) {
                        reject(error);
                    }
                    else {
                        resolve(undefined);
                    }
                },
                onEnd: () => {
                    if (reducer) {
                        resolve(reducer(chunks));
                    }
                    else {
                        resolve(undefined);
                    }
                }
            });
        });
    }
    /**
     * Helper to listen to all events of a T stream in proper order.
     */
    function $Ke(stream, listener, token) {
        stream.on('error', error => {
            if (!token?.isCancellationRequested) {
                listener.onError(error);
            }
        });
        stream.on('end', () => {
            if (!token?.isCancellationRequested) {
                listener.onEnd();
            }
        });
        // Adding the `data` listener will turn the stream
        // into flowing mode. As such it is important to
        // add this listener last (DO NOT CHANGE!)
        stream.on('data', data => {
            if (!token?.isCancellationRequested) {
                listener.onData(data);
            }
        });
    }
    /**
     * Helper to peek up to `maxChunks` into a stream. The return type signals if
     * the stream has ended or not. If not, caller needs to add a `data` listener
     * to continue reading.
     */
    function $Le(stream, maxChunks) {
        return new Promise((resolve, reject) => {
            const streamListeners = new lifecycle_1.$Yc();
            const buffer = [];
            // Data Listener
            const dataListener = (chunk) => {
                // Add to buffer
                buffer.push(chunk);
                // We reached maxChunks and thus need to return
                if (buffer.length > maxChunks) {
                    // Dispose any listeners and ensure to pause the
                    // stream so that it can be consumed again by caller
                    streamListeners.dispose();
                    stream.pause();
                    return resolve({ stream, buffer, ended: false });
                }
            };
            // Error Listener
            const errorListener = (error) => {
                streamListeners.dispose();
                return reject(error);
            };
            // End Listener
            const endListener = () => {
                streamListeners.dispose();
                return resolve({ stream, buffer, ended: true });
            };
            streamListeners.add((0, lifecycle_1.$Xc)(() => stream.removeListener('error', errorListener)));
            stream.on('error', errorListener);
            streamListeners.add((0, lifecycle_1.$Xc)(() => stream.removeListener('end', endListener)));
            stream.on('end', endListener);
            // Important: leave the `data` listener last because
            // this can turn the stream into flowing mode and we
            // want `error` events to be received as well.
            streamListeners.add((0, lifecycle_1.$Xc)(() => stream.removeListener('data', dataListener)));
            stream.on('data', dataListener);
        });
    }
    /**
     * Helper to create a readable stream from an existing T.
     */
    function $Me(t, reducer) {
        const stream = $Ge(reducer);
        stream.end(t);
        return stream;
    }
    /**
     * Helper to create an empty stream
     */
    function $Ne() {
        const stream = $Ge(() => { throw new Error('not supported'); });
        stream.end();
        return stream;
    }
    /**
     * Helper to convert a T into a Readable<T>.
     */
    function $Oe(t) {
        let consumed = false;
        return {
            read: () => {
                if (consumed) {
                    return null;
                }
                consumed = true;
                return t;
            }
        };
    }
    /**
     * Helper to transform a readable stream into another stream.
     */
    function $Pe(stream, transformer, reducer) {
        const target = $Ge(reducer);
        $Ke(stream, {
            onData: data => target.write(transformer.data(data)),
            onError: error => target.error(transformer.error ? transformer.error(error) : error),
            onEnd: () => target.end()
        });
        return target;
    }
    /**
     * Helper to take an existing readable that will
     * have a prefix injected to the beginning.
     */
    function $Qe(prefix, readable, reducer) {
        let prefixHandled = false;
        return {
            read: () => {
                const chunk = readable.read();
                // Handle prefix only once
                if (!prefixHandled) {
                    prefixHandled = true;
                    // If we have also a read-result, make
                    // sure to reduce it to a single result
                    if (chunk !== null) {
                        return reducer([prefix, chunk]);
                    }
                    // Otherwise, just return prefix directly
                    return prefix;
                }
                return chunk;
            }
        };
    }
    /**
     * Helper to take an existing stream that will
     * have a prefix injected to the beginning.
     */
    function $Re(prefix, stream, reducer) {
        let prefixHandled = false;
        const target = $Ge(reducer);
        $Ke(stream, {
            onData: data => {
                // Handle prefix only once
                if (!prefixHandled) {
                    prefixHandled = true;
                    return target.write(reducer([prefix, data]));
                }
                return target.write(data);
            },
            onError: error => target.error(error),
            onEnd: () => {
                // Handle prefix only once
                if (!prefixHandled) {
                    prefixHandled = true;
                    target.write(prefix);
                }
                target.end();
            }
        });
        return target;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
define(__m[19/*vs/base/common/buffer*/], __M([0/*require*/,1/*exports*/,24/*vs/base/common/lazy*/,52/*vs/base/common/stream*/]), function (require, exports, lazy_1, streams) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$Se = void 0;
    exports.$Te = $Te;
    exports.$Ue = $Ue;
    exports.$Ve = $Ve;
    exports.$We = $We;
    exports.$Xe = $Xe;
    exports.$Ye = $Ye;
    exports.$Ze = $Ze;
    exports.$1e = $1e;
    exports.$2e = $2e;
    exports.$3e = $3e;
    exports.$4e = $4e;
    exports.$5e = $5e;
    exports.$6e = $6e;
    exports.$7e = $7e;
    exports.$8e = $8e;
    exports.$9e = $9e;
    exports.$0e = $0e;
    exports.$$e = $$e;
    exports.$_e = $_e;
    exports.$af = $af;
    streams = __importStar(streams);
    const hasBuffer = (typeof Buffer !== 'undefined');
    const indexOfTable = new lazy_1.$Y(() => new Uint8Array(256));
    let textEncoder;
    let textDecoder;
    class $Se {
        /**
         * When running in a nodejs context, the backing store for the returned `VSBuffer` instance
         * might use a nodejs Buffer allocated from node's Buffer pool, which is not transferrable.
         */
        static alloc(byteLength) {
            if (hasBuffer) {
                return new $Se(Buffer.allocUnsafe(byteLength));
            }
            else {
                return new $Se(new Uint8Array(byteLength));
            }
        }
        /**
         * When running in a nodejs context, if `actual` is not a nodejs Buffer, the backing store for
         * the returned `VSBuffer` instance might use a nodejs Buffer allocated from node's Buffer pool,
         * which is not transferrable.
         */
        static wrap(actual) {
            if (hasBuffer && !(Buffer.isBuffer(actual))) {
                // https://nodejs.org/dist/latest-v10.x/docs/api/buffer.html#buffer_class_method_buffer_from_arraybuffer_byteoffset_length
                // Create a zero-copy Buffer wrapper around the ArrayBuffer pointed to by the Uint8Array
                actual = Buffer.from(actual.buffer, actual.byteOffset, actual.byteLength);
            }
            return new $Se(actual);
        }
        /**
         * When running in a nodejs context, the backing store for the returned `VSBuffer` instance
         * might use a nodejs Buffer allocated from node's Buffer pool, which is not transferrable.
         */
        static fromString(source, options) {
            const dontUseNodeBuffer = options?.dontUseNodeBuffer || false;
            if (!dontUseNodeBuffer && hasBuffer) {
                return new $Se(Buffer.from(source));
            }
            else {
                if (!textEncoder) {
                    textEncoder = new TextEncoder();
                }
                return new $Se(textEncoder.encode(source));
            }
        }
        /**
         * When running in a nodejs context, the backing store for the returned `VSBuffer` instance
         * might use a nodejs Buffer allocated from node's Buffer pool, which is not transferrable.
         */
        static fromByteArray(source) {
            const result = $Se.alloc(source.length);
            for (let i = 0, len = source.length; i < len; i++) {
                result.buffer[i] = source[i];
            }
            return result;
        }
        /**
         * When running in a nodejs context, the backing store for the returned `VSBuffer` instance
         * might use a nodejs Buffer allocated from node's Buffer pool, which is not transferrable.
         */
        static concat(buffers, totalLength) {
            if (typeof totalLength === 'undefined') {
                totalLength = 0;
                for (let i = 0, len = buffers.length; i < len; i++) {
                    totalLength += buffers[i].byteLength;
                }
            }
            const ret = $Se.alloc(totalLength);
            let offset = 0;
            for (let i = 0, len = buffers.length; i < len; i++) {
                const element = buffers[i];
                ret.set(element, offset);
                offset += element.byteLength;
            }
            return ret;
        }
        constructor(buffer) {
            this.buffer = buffer;
            this.byteLength = this.buffer.byteLength;
        }
        /**
         * When running in a nodejs context, the backing store for the returned `VSBuffer` instance
         * might use a nodejs Buffer allocated from node's Buffer pool, which is not transferrable.
         */
        clone() {
            const result = $Se.alloc(this.byteLength);
            result.set(this);
            return result;
        }
        toString() {
            if (hasBuffer) {
                return this.buffer.toString();
            }
            else {
                if (!textDecoder) {
                    textDecoder = new TextDecoder();
                }
                return textDecoder.decode(this.buffer);
            }
        }
        slice(start, end) {
            // IMPORTANT: use subarray instead of slice because TypedArray#slice
            // creates shallow copy and NodeBuffer#slice doesn't. The use of subarray
            // ensures the same, performance, behaviour.
            return new $Se(this.buffer.subarray(start, end));
        }
        set(array, offset) {
            if (array instanceof $Se) {
                this.buffer.set(array.buffer, offset);
            }
            else if (array instanceof Uint8Array) {
                this.buffer.set(array, offset);
            }
            else if (array instanceof ArrayBuffer) {
                this.buffer.set(new Uint8Array(array), offset);
            }
            else if (ArrayBuffer.isView(array)) {
                this.buffer.set(new Uint8Array(array.buffer, array.byteOffset, array.byteLength), offset);
            }
            else {
                throw new Error(`Unknown argument 'array'`);
            }
        }
        readUInt32BE(offset) {
            return $We(this.buffer, offset);
        }
        writeUInt32BE(value, offset) {
            $Xe(this.buffer, value, offset);
        }
        readUInt32LE(offset) {
            return $Ye(this.buffer, offset);
        }
        writeUInt32LE(value, offset) {
            $Ze(this.buffer, value, offset);
        }
        readUInt8(offset) {
            return $1e(this.buffer, offset);
        }
        writeUInt8(value, offset) {
            $2e(this.buffer, value, offset);
        }
        indexOf(subarray, offset = 0) {
            return $Te(this.buffer, subarray instanceof $Se ? subarray.buffer : subarray, offset);
        }
    }
    exports.$Se = $Se;
    /**
     * Like String.indexOf, but works on Uint8Arrays.
     * Uses the boyer-moore-horspool algorithm to be reasonably speedy.
     */
    function $Te(haystack, needle, offset = 0) {
        const needleLen = needle.byteLength;
        const haystackLen = haystack.byteLength;
        if (needleLen === 0) {
            return 0;
        }
        if (needleLen === 1) {
            return haystack.indexOf(needle[0]);
        }
        if (needleLen > haystackLen - offset) {
            return -1;
        }
        // find index of the subarray using boyer-moore-horspool algorithm
        const table = indexOfTable.value;
        table.fill(needle.length);
        for (let i = 0; i < needle.length; i++) {
            table[needle[i]] = needle.length - i - 1;
        }
        let i = offset + needle.length - 1;
        let j = i;
        let result = -1;
        while (i < haystackLen) {
            if (haystack[i] === needle[j]) {
                if (j === 0) {
                    result = i;
                    break;
                }
                i--;
                j--;
            }
            else {
                i += Math.max(needle.length - j, table[haystack[i]]);
                j = needle.length - 1;
            }
        }
        return result;
    }
    function $Ue(source, offset) {
        return (((source[offset + 0] << 0) >>> 0) |
            ((source[offset + 1] << 8) >>> 0));
    }
    function $Ve(destination, value, offset) {
        destination[offset + 0] = (value & 0b11111111);
        value = value >>> 8;
        destination[offset + 1] = (value & 0b11111111);
    }
    function $We(source, offset) {
        return (source[offset] * 2 ** 24
            + source[offset + 1] * 2 ** 16
            + source[offset + 2] * 2 ** 8
            + source[offset + 3]);
    }
    function $Xe(destination, value, offset) {
        destination[offset + 3] = value;
        value = value >>> 8;
        destination[offset + 2] = value;
        value = value >>> 8;
        destination[offset + 1] = value;
        value = value >>> 8;
        destination[offset] = value;
    }
    function $Ye(source, offset) {
        return (((source[offset + 0] << 0) >>> 0) |
            ((source[offset + 1] << 8) >>> 0) |
            ((source[offset + 2] << 16) >>> 0) |
            ((source[offset + 3] << 24) >>> 0));
    }
    function $Ze(destination, value, offset) {
        destination[offset + 0] = (value & 0b11111111);
        value = value >>> 8;
        destination[offset + 1] = (value & 0b11111111);
        value = value >>> 8;
        destination[offset + 2] = (value & 0b11111111);
        value = value >>> 8;
        destination[offset + 3] = (value & 0b11111111);
    }
    function $1e(source, offset) {
        return source[offset];
    }
    function $2e(destination, value, offset) {
        destination[offset] = value;
    }
    function $3e(readable) {
        return streams.$He(readable, chunks => $Se.concat(chunks));
    }
    function $4e(buffer) {
        return streams.$Oe(buffer);
    }
    function $5e(stream) {
        return streams.$Je(stream, chunks => $Se.concat(chunks));
    }
    async function $6e(bufferedStream) {
        if (bufferedStream.ended) {
            return $Se.concat(bufferedStream.buffer);
        }
        return $Se.concat([
            // Include already read chunks...
            ...bufferedStream.buffer,
            // ...and all additional chunks
            await $5e(bufferedStream.stream)
        ]);
    }
    function $7e(buffer) {
        return streams.$Me(buffer, chunks => $Se.concat(chunks));
    }
    function $8e(stream) {
        return streams.$Pe(stream, { data: data => typeof data === 'string' ? $Se.fromString(data) : $Se.wrap(data) }, chunks => $Se.concat(chunks));
    }
    function $9e(options) {
        return streams.$Ge(chunks => $Se.concat(chunks), options);
    }
    function $0e(prefix, readable) {
        return streams.$Qe(prefix, readable, chunks => $Se.concat(chunks));
    }
    function $$e(prefix, stream) {
        return streams.$Re(prefix, stream, chunks => $Se.concat(chunks));
    }
    /** Decodes base64 to a uint8 array. URL-encoded and unpadded base64 is allowed. */
    function $_e(encoded) {
        let building = 0;
        let remainder = 0;
        let bufi = 0;
        // The simpler way to do this is `Uint8Array.from(atob(str), c => c.charCodeAt(0))`,
        // but that's about 10-20x slower than this function in current Chromium versions.
        const buffer = new Uint8Array(Math.floor(encoded.length / 4 * 3));
        const append = (value) => {
            switch (remainder) {
                case 3:
                    buffer[bufi++] = building | value;
                    remainder = 0;
                    break;
                case 2:
                    buffer[bufi++] = building | (value >>> 2);
                    building = value << 6;
                    remainder = 3;
                    break;
                case 1:
                    buffer[bufi++] = building | (value >>> 4);
                    building = value << 4;
                    remainder = 2;
                    break;
                default:
                    building = value << 2;
                    remainder = 1;
            }
        };
        for (let i = 0; i < encoded.length; i++) {
            const code = encoded.charCodeAt(i);
            // See https://datatracker.ietf.org/doc/html/rfc4648#section-4
            // This branchy code is about 3x faster than an indexOf on a base64 char string.
            if (code >= 65 && code <= 90) {
                append(code - 65); // A-Z starts ranges from char code 65 to 90
            }
            else if (code >= 97 && code <= 122) {
                append(code - 97 + 26); // a-z starts ranges from char code 97 to 122, starting at byte 26
            }
            else if (code >= 48 && code <= 57) {
                append(code - 48 + 52); // 0-9 starts ranges from char code 48 to 58, starting at byte 52
            }
            else if (code === 43 || code === 45) {
                append(62); // "+" or "-" for URLS
            }
            else if (code === 47 || code === 95) {
                append(63); // "/" or "_" for URLS
            }
            else if (code === 61) {
                break; // "="
            }
            else {
                throw new SyntaxError(`Unexpected base64 character ${encoded[i]}`);
            }
        }
        const unpadded = bufi;
        while (remainder > 0) {
            append(0);
        }
        // slice is needed to account for overestimation due to padding
        return $Se.wrap(buffer).slice(0, unpadded);
    }
    const base64Alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
    const base64UrlSafeAlphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
    /** Encodes a buffer to a base64 string. */
    function $af({ buffer }, padded = true, urlSafe = false) {
        const dictionary = urlSafe ? base64UrlSafeAlphabet : base64Alphabet;
        let output = '';
        const remainder = buffer.byteLength % 3;
        let i = 0;
        for (; i < buffer.byteLength - remainder; i += 3) {
            const a = buffer[i + 0];
            const b = buffer[i + 1];
            const c = buffer[i + 2];
            output += dictionary[a >>> 2];
            output += dictionary[(a << 4 | b >>> 4) & 0b111111];
            output += dictionary[(b << 2 | c >>> 6) & 0b111111];
            output += dictionary[c & 0b111111];
        }
        if (remainder === 1) {
            const a = buffer[i + 0];
            output += dictionary[a >>> 2];
            output += dictionary[(a << 4) & 0b111111];
            if (padded) {
                output += '==';
            }
        }
        else if (remainder === 2) {
            const a = buffer[i + 0];
            const b = buffer[i + 1];
            output += dictionary[a >>> 2];
            output += dictionary[(a << 4 | b >>> 4) & 0b111111];
            output += dictionary[(b << 2) & 0b111111];
            if (padded) {
                output += '=';
            }
        }
        return output;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[53/*vs/base/common/symbols*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$le = void 0;
    /**
     * Can be passed into the Delayed to defer using a microtask
     * */
    exports.$le = Symbol('MicrotaskDelay');
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[10/*vs/base/common/types*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$jg = $jg;
    exports.$kg = $kg;
    exports.$lg = $lg;
    exports.$mg = $mg;
    exports.$ng = $ng;
    exports.$og = $og;
    exports.$pg = $pg;
    exports.$qg = $qg;
    exports.$rg = $rg;
    exports.$sg = $sg;
    exports.$tg = $tg;
    exports.$ug = $ug;
    exports.$vg = $vg;
    exports.$wg = $wg;
    exports.$xg = $xg;
    exports.$yg = $yg;
    exports.$zg = $zg;
    exports.$Ag = $Ag;
    exports.$Bg = $Bg;
    /**
     * @returns whether the provided parameter is a JavaScript String or not.
     */
    function $jg(str) {
        return (typeof str === 'string');
    }
    /**
     * @returns whether the provided parameter is a JavaScript Array and each element in the array is a string.
     */
    function $kg(value) {
        return Array.isArray(value) && value.every(elem => $jg(elem));
    }
    /**
     * @returns whether the provided parameter is of type `object` but **not**
     *	`null`, an `array`, a `regexp`, nor a `date`.
     */
    function $lg(obj) {
        // The method can't do a type cast since there are type (like strings) which
        // are subclasses of any put not positvely matched by the function. Hence type
        // narrowing results in wrong results.
        return typeof obj === 'object'
            && obj !== null
            && !Array.isArray(obj)
            && !(obj instanceof RegExp)
            && !(obj instanceof Date);
    }
    /**
     * @returns whether the provided parameter is of type `Buffer` or Uint8Array dervived type
     */
    function $mg(obj) {
        const TypedArray = Object.getPrototypeOf(Uint8Array);
        return typeof obj === 'object'
            && obj instanceof TypedArray;
    }
    /**
     * In **contrast** to just checking `typeof` this will return `false` for `NaN`.
     * @returns whether the provided parameter is a JavaScript Number or not.
     */
    function $ng(obj) {
        return (typeof obj === 'number' && !isNaN(obj));
    }
    /**
     * @returns whether the provided parameter is an Iterable, casting to the given generic
     */
    function $og(obj) {
        return !!obj && typeof obj[Symbol.iterator] === 'function';
    }
    /**
     * @returns whether the provided parameter is a JavaScript Boolean or not.
     */
    function $pg(obj) {
        return (obj === true || obj === false);
    }
    /**
     * @returns whether the provided parameter is undefined.
     */
    function $qg(obj) {
        return (typeof obj === 'undefined');
    }
    /**
     * @returns whether the provided parameter is defined.
     */
    function $rg(arg) {
        return !$sg(arg);
    }
    /**
     * @returns whether the provided parameter is undefined or null.
     */
    function $sg(obj) {
        return ($qg(obj) || obj === null);
    }
    function $tg(condition, type) {
        if (!condition) {
            throw new Error(type ? `Unexpected type, expected '${type}'` : 'Unexpected type');
        }
    }
    /**
     * Asserts that the argument passed in is neither undefined nor null.
     */
    function $ug(arg) {
        if ($sg(arg)) {
            throw new Error('Assertion Failed: argument is undefined or null');
        }
        return arg;
    }
    function $vg(...args) {
        const result = [];
        for (let i = 0; i < args.length; i++) {
            const arg = args[i];
            if ($sg(arg)) {
                throw new Error(`Assertion Failed: argument at index ${i} is undefined or null`);
            }
            result.push(arg);
        }
        return result;
    }
    const hasOwnProperty = Object.prototype.hasOwnProperty;
    /**
     * @returns whether the provided parameter is an empty JavaScript Object or not.
     */
    function $wg(obj) {
        if (!$lg(obj)) {
            return false;
        }
        for (const key in obj) {
            if (hasOwnProperty.call(obj, key)) {
                return false;
            }
        }
        return true;
    }
    /**
     * @returns whether the provided parameter is a JavaScript Function or not.
     */
    function $xg(obj) {
        return (typeof obj === 'function');
    }
    /**
     * @returns whether the provided parameters is are JavaScript Function or not.
     */
    function $yg(...objects) {
        return objects.length > 0 && objects.every($xg);
    }
    function $zg(args, constraints) {
        const len = Math.min(args.length, constraints.length);
        for (let i = 0; i < len; i++) {
            $Ag(args[i], constraints[i]);
        }
    }
    function $Ag(arg, constraint) {
        if ($jg(constraint)) {
            if (typeof arg !== constraint) {
                throw new Error(`argument does not match constraint: typeof ${constraint}`);
            }
        }
        else if ($xg(constraint)) {
            try {
                if (arg instanceof constraint) {
                    return;
                }
            }
            catch {
                // ignore
            }
            if (!$sg(arg) && arg.constructor === constraint) {
                return;
            }
            if (constraint.length === 1 && constraint.call(undefined, arg) === true) {
                return;
            }
            throw new Error(`argument does not match one of these constraints: arg instanceof constraint, arg.constructor === constraint, nor constraint(arg) === true`);
        }
    }
    /**
     * Helper type assertion that safely upcasts a type to a supertype.
     *
     * This can be used to make sure the argument correctly conforms to the subtype while still being able to pass it
     * to contexts that expects the supertype.
     */
    function $Bg(x) {
        return x;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[32/*vs/base/common/objects*/], __M([0/*require*/,1/*exports*/,10/*vs/base/common/types*/]), function (require, exports, types_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$ko = $ko;
    exports.$lo = $lo;
    exports.$mo = $mo;
    exports.$no = $no;
    exports.$oo = $oo;
    exports.$po = $po;
    exports.$qo = $qo;
    exports.$ro = $ro;
    exports.$so = $so;
    exports.$to = $to;
    exports.$uo = $uo;
    exports.$vo = $vo;
    exports.$wo = $wo;
    function $ko(obj) {
        if (!obj || typeof obj !== 'object') {
            return obj;
        }
        if (obj instanceof RegExp) {
            return obj;
        }
        const result = Array.isArray(obj) ? [] : {};
        Object.entries(obj).forEach(([key, value]) => {
            result[key] = value && typeof value === 'object' ? $ko(value) : value;
        });
        return result;
    }
    function $lo(obj) {
        if (!obj || typeof obj !== 'object') {
            return obj;
        }
        const stack = [obj];
        while (stack.length > 0) {
            const obj = stack.shift();
            Object.freeze(obj);
            for (const key in obj) {
                if (_hasOwnProperty.call(obj, key)) {
                    const prop = obj[key];
                    if (typeof prop === 'object' && !Object.isFrozen(prop) && !(0, types_1.$mg)(prop)) {
                        stack.push(prop);
                    }
                }
            }
        }
        return obj;
    }
    const _hasOwnProperty = Object.prototype.hasOwnProperty;
    function $mo(obj, changer) {
        return _cloneAndChange(obj, changer, new Set());
    }
    function _cloneAndChange(obj, changer, seen) {
        if ((0, types_1.$sg)(obj)) {
            return obj;
        }
        const changed = changer(obj);
        if (typeof changed !== 'undefined') {
            return changed;
        }
        if (Array.isArray(obj)) {
            const r1 = [];
            for (const e of obj) {
                r1.push(_cloneAndChange(e, changer, seen));
            }
            return r1;
        }
        if ((0, types_1.$lg)(obj)) {
            if (seen.has(obj)) {
                throw new Error('Cannot clone recursive data-structure');
            }
            seen.add(obj);
            const r2 = {};
            for (const i2 in obj) {
                if (_hasOwnProperty.call(obj, i2)) {
                    r2[i2] = _cloneAndChange(obj[i2], changer, seen);
                }
            }
            seen.delete(obj);
            return r2;
        }
        return obj;
    }
    /**
     * Copies all properties of source into destination. The optional parameter "overwrite" allows to control
     * if existing properties on the destination should be overwritten or not. Defaults to true (overwrite).
     */
    function $no(destination, source, overwrite = true) {
        if (!(0, types_1.$lg)(destination)) {
            return source;
        }
        if ((0, types_1.$lg)(source)) {
            Object.keys(source).forEach(key => {
                if (key in destination) {
                    if (overwrite) {
                        if ((0, types_1.$lg)(destination[key]) && (0, types_1.$lg)(source[key])) {
                            $no(destination[key], source[key], overwrite);
                        }
                        else {
                            destination[key] = source[key];
                        }
                    }
                }
                else {
                    destination[key] = source[key];
                }
            });
        }
        return destination;
    }
    function $oo(one, other) {
        if (one === other) {
            return true;
        }
        if (one === null || one === undefined || other === null || other === undefined) {
            return false;
        }
        if (typeof one !== typeof other) {
            return false;
        }
        if (typeof one !== 'object') {
            return false;
        }
        if ((Array.isArray(one)) !== (Array.isArray(other))) {
            return false;
        }
        let i;
        let key;
        if (Array.isArray(one)) {
            if (one.length !== other.length) {
                return false;
            }
            for (i = 0; i < one.length; i++) {
                if (!$oo(one[i], other[i])) {
                    return false;
                }
            }
        }
        else {
            const oneKeys = [];
            for (key in one) {
                oneKeys.push(key);
            }
            oneKeys.sort();
            const otherKeys = [];
            for (key in other) {
                otherKeys.push(key);
            }
            otherKeys.sort();
            if (!$oo(oneKeys, otherKeys)) {
                return false;
            }
            for (i = 0; i < oneKeys.length; i++) {
                if (!$oo(one[oneKeys[i]], other[oneKeys[i]])) {
                    return false;
                }
            }
        }
        return true;
    }
    /**
     * Calls `JSON.Stringify` with a replacer to break apart any circular references.
     * This prevents `JSON`.stringify` from throwing the exception
     *  "Uncaught TypeError: Converting circular structure to JSON"
     */
    function $po(obj) {
        const seen = new Set();
        return JSON.stringify(obj, (key, value) => {
            if ((0, types_1.$lg)(value) || Array.isArray(value)) {
                if (seen.has(value)) {
                    return '[Circular]';
                }
                else {
                    seen.add(value);
                }
            }
            if (typeof value === 'bigint') {
                return `[BigInt ${value.toString()}]`;
            }
            return value;
        });
    }
    /**
     * Returns an object that has keys for each value that is different in the base object. Keys
     * that do not exist in the target but in the base object are not considered.
     *
     * Note: This is not a deep-diffing method, so the values are strictly taken into the resulting
     * object if they differ.
     *
     * @param base the object to diff against
     * @param obj the object to use for diffing
     */
    function $qo(base, target) {
        const result = Object.create(null);
        if (!base || !target) {
            return result;
        }
        const targetKeys = Object.keys(target);
        targetKeys.forEach(k => {
            const baseValue = base[k];
            const targetValue = target[k];
            if (!$oo(baseValue, targetValue)) {
                result[k] = targetValue;
            }
        });
        return result;
    }
    function $ro(target, key) {
        const lowercaseKey = key.toLowerCase();
        const equivalentKey = Object.keys(target).find(k => k.toLowerCase() === lowercaseKey);
        return equivalentKey ? target[equivalentKey] : target[key];
    }
    function $so(obj, predicate) {
        const result = Object.create(null);
        for (const [key, value] of Object.entries(obj)) {
            if (predicate(key, value)) {
                result[key] = value;
            }
        }
        return result;
    }
    function $to(obj) {
        let res = [];
        while (Object.prototype !== obj) {
            res = res.concat(Object.getOwnPropertyNames(obj));
            obj = Object.getPrototypeOf(obj);
        }
        return res;
    }
    function $uo(obj) {
        const methods = [];
        for (const prop of $to(obj)) {
            if (typeof obj[prop] === 'function') {
                methods.push(prop);
            }
        }
        return methods;
    }
    function $vo(methodNames, invoke) {
        const createProxyMethod = (method) => {
            return function () {
                const args = Array.prototype.slice.call(arguments, 0);
                return invoke(method, args);
            };
        };
        const result = {};
        for (const methodName of methodNames) {
            result[methodName] = createProxyMethod(methodName);
        }
        return result;
    }
    function $wo(obj, fn) {
        const result = {};
        for (const [key, value] of Object.entries(obj)) {
            result[key] = fn(value, key);
        }
        return result;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[54/*vs/base/common/uint*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.Constants = void 0;
    exports.$ff = $ff;
    exports.$gf = $gf;
    var Constants;
    (function (Constants) {
        /**
         * MAX SMI (SMall Integer) as defined in v8.
         * one bit is lost for boxing/unboxing flag.
         * one bit is lost for sign flag.
         * See https://thibaultlaurens.github.io/javascript/2013/04/29/how-the-v8-engine-works/#tagged-values
         */
        Constants[Constants["MAX_SAFE_SMALL_INTEGER"] = 1073741824] = "MAX_SAFE_SMALL_INTEGER";
        /**
         * MIN SMI (SMall Integer) as defined in v8.
         * one bit is lost for boxing/unboxing flag.
         * one bit is lost for sign flag.
         * See https://thibaultlaurens.github.io/javascript/2013/04/29/how-the-v8-engine-works/#tagged-values
         */
        Constants[Constants["MIN_SAFE_SMALL_INTEGER"] = -1073741824] = "MIN_SAFE_SMALL_INTEGER";
        /**
         * Max unsigned integer that fits on 8 bits.
         */
        Constants[Constants["MAX_UINT_8"] = 255] = "MAX_UINT_8";
        /**
         * Max unsigned integer that fits on 16 bits.
         */
        Constants[Constants["MAX_UINT_16"] = 65535] = "MAX_UINT_16";
        /**
         * Max unsigned integer that fits on 32 bits.
         */
        Constants[Constants["MAX_UINT_32"] = 4294967295] = "MAX_UINT_32";
        Constants[Constants["UNICODE_SUPPLEMENTARY_PLANE_BEGIN"] = 65536] = "UNICODE_SUPPLEMENTARY_PLANE_BEGIN";
    })(Constants || (exports.Constants = Constants = {}));
    function $ff(v) {
        if (v < 0) {
            return 0;
        }
        if (v > Constants.MAX_UINT_8) {
            return Constants.MAX_UINT_8;
        }
        return v | 0;
    }
    function $gf(v) {
        if (v < 0) {
            return 0;
        }
        if (v > Constants.MAX_UINT_32) {
            return Constants.MAX_UINT_32;
        }
        return v | 0;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[11/*vs/base/common/strings*/], __M([0/*require*/,1/*exports*/,51/*vs/base/common/cache*/,13/*vs/base/common/charCode*/,24/*vs/base/common/lazy*/,54/*vs/base/common/uint*/]), function (require, exports, cache_1, charCode_1, lazy_1, uint_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$ig = exports.$hg = exports.$gg = exports.GraphemeBreakType = exports.$9f = exports.$1f = exports.$Tf = exports.$Sf = void 0;
    exports.$hf = $hf;
    exports.$if = $if;
    exports.$jf = $jf;
    exports.$kf = $kf;
    exports.$lf = $lf;
    exports.$mf = $mf;
    exports.$nf = $nf;
    exports.$of = $of;
    exports.$pf = $pf;
    exports.$qf = $qf;
    exports.$rf = $rf;
    exports.$sf = $sf;
    exports.$tf = $tf;
    exports.$uf = $uf;
    exports.$vf = $vf;
    exports.$wf = $wf;
    exports.$xf = $xf;
    exports.$yf = $yf;
    exports.$zf = $zf;
    exports.$Af = $Af;
    exports.$Bf = $Bf;
    exports.$Cf = $Cf;
    exports.$Df = $Df;
    exports.$Ef = $Ef;
    exports.$Ff = $Ff;
    exports.$Gf = $Gf;
    exports.$Hf = $Hf;
    exports.$If = $If;
    exports.$Jf = $Jf;
    exports.$Kf = $Kf;
    exports.$Lf = $Lf;
    exports.$Mf = $Mf;
    exports.$Nf = $Nf;
    exports.$Of = $Of;
    exports.$Pf = $Pf;
    exports.$Qf = $Qf;
    exports.$Rf = $Rf;
    exports.$Uf = $Uf;
    exports.$Vf = $Vf;
    exports.$Wf = $Wf;
    exports.$Xf = $Xf;
    exports.$Yf = $Yf;
    exports.$Zf = $Zf;
    exports.$2f = $2f;
    exports.$3f = $3f;
    exports.$4f = $4f;
    exports.$5f = $5f;
    exports.$6f = $6f;
    exports.$7f = $7f;
    exports.$8f = $8f;
    exports.$0f = $0f;
    exports.$$f = $$f;
    exports.$_f = $_f;
    exports.$ag = $ag;
    exports.$bg = $bg;
    exports.$cg = $cg;
    exports.$dg = $dg;
    exports.$eg = $eg;
    exports.$fg = $fg;
    function $hf(str) {
        if (!str || typeof str !== 'string') {
            return true;
        }
        return str.trim().length === 0;
    }
    const _formatRegexp = /{(\d+)}/g;
    /**
     * Helper to produce a string with a variable number of arguments. Insert variable segments
     * into the string using the {n} notation where N is the index of the argument following the string.
     * @param value string to which formatting is applied
     * @param args replacements for {n}-entries
     */
    function $if(value, ...args) {
        if (args.length === 0) {
            return value;
        }
        return value.replace(_formatRegexp, function (match, group) {
            const idx = parseInt(group, 10);
            return isNaN(idx) || idx < 0 || idx >= args.length ?
                match :
                args[idx];
        });
    }
    const _format2Regexp = /{([^}]+)}/g;
    /**
     * Helper to create a string from a template and a string record.
     * Similar to `format` but with objects instead of positional arguments.
     */
    function $jf(template, values) {
        if (Object.keys(values).length === 0) {
            return template;
        }
        return template.replace(_format2Regexp, (match, group) => (values[group] ?? match));
    }
    /**
     * Encodes the given value so that it can be used as literal value in html attributes.
     *
     * In other words, computes `$val`, such that `attr` in `<div attr="$val" />` has the runtime value `value`.
     * This prevents XSS injection.
     */
    function $kf(value) {
        return value.replace(/[<>"'&]/g, ch => {
            switch (ch) {
                case '<': return '&lt;';
                case '>': return '&gt;';
                case '"': return '&quot;';
                case '\'': return '&apos;';
                case '&': return '&amp;';
            }
            return ch;
        });
    }
    /**
     * Converts HTML characters inside the string to use entities instead. Makes the string safe from
     * being used e.g. in HTMLElement.innerHTML.
     */
    function $lf(html) {
        return html.replace(/[<>&]/g, function (match) {
            switch (match) {
                case '<': return '&lt;';
                case '>': return '&gt;';
                case '&': return '&amp;';
                default: return match;
            }
        });
    }
    /**
     * Escapes regular expression characters in a given string
     */
    function $mf(value) {
        return value.replace(/[\\\{\}\*\+\?\|\^\$\.\[\]\(\)]/g, '\\$&');
    }
    /**
     * Counts how often `substr` occurs inside `value`.
     */
    function $nf(value, substr) {
        let result = 0;
        let index = value.indexOf(substr);
        while (index !== -1) {
            result++;
            index = value.indexOf(substr, index + substr.length);
        }
        return result;
    }
    function $of(value, maxLength, suffix = '…') {
        if (value.length <= maxLength) {
            return value;
        }
        return `${value.substr(0, maxLength)}${suffix}`;
    }
    function $pf(value, maxLength, suffix = '…') {
        if (value.length <= maxLength) {
            return value;
        }
        const prefixLength = Math.ceil(maxLength / 2) - suffix.length / 2;
        const suffixLength = Math.floor(maxLength / 2) - suffix.length / 2;
        return `${value.substr(0, prefixLength)}${suffix}${value.substr(value.length - suffixLength)}`;
    }
    /**
     * Removes all occurrences of needle from the beginning and end of haystack.
     * @param haystack string to trim
     * @param needle the thing to trim (default is a blank)
     */
    function $qf(haystack, needle = ' ') {
        const trimmed = $rf(haystack, needle);
        return $sf(trimmed, needle);
    }
    /**
     * Removes all occurrences of needle from the beginning of haystack.
     * @param haystack string to trim
     * @param needle the thing to trim
     */
    function $rf(haystack, needle) {
        if (!haystack || !needle) {
            return haystack;
        }
        const needleLen = needle.length;
        if (needleLen === 0 || haystack.length === 0) {
            return haystack;
        }
        let offset = 0;
        while (haystack.indexOf(needle, offset) === offset) {
            offset = offset + needleLen;
        }
        return haystack.substring(offset);
    }
    /**
     * Removes all occurrences of needle from the end of haystack.
     * @param haystack string to trim
     * @param needle the thing to trim
     */
    function $sf(haystack, needle) {
        if (!haystack || !needle) {
            return haystack;
        }
        const needleLen = needle.length, haystackLen = haystack.length;
        if (needleLen === 0 || haystackLen === 0) {
            return haystack;
        }
        let offset = haystackLen, idx = -1;
        while (true) {
            idx = haystack.lastIndexOf(needle, offset - 1);
            if (idx === -1 || idx + needleLen !== offset) {
                break;
            }
            if (idx === 0) {
                return '';
            }
            offset = idx;
        }
        return haystack.substring(0, offset);
    }
    function $tf(pattern) {
        return pattern.replace(/[\-\\\{\}\+\?\|\^\$\.\,\[\]\(\)\#\s]/g, '\\$&').replace(/[\*]/g, '.*');
    }
    function $uf(pattern) {
        return pattern.replace(/\*/g, '');
    }
    function $vf(searchString, isRegex, options = {}) {
        if (!searchString) {
            throw new Error('Cannot create regex from empty string');
        }
        if (!isRegex) {
            searchString = $mf(searchString);
        }
        if (options.wholeWord) {
            if (!/\B/.test(searchString.charAt(0))) {
                searchString = '\\b' + searchString;
            }
            if (!/\B/.test(searchString.charAt(searchString.length - 1))) {
                searchString = searchString + '\\b';
            }
        }
        let modifiers = '';
        if (options.global) {
            modifiers += 'g';
        }
        if (!options.matchCase) {
            modifiers += 'i';
        }
        if (options.multiline) {
            modifiers += 'm';
        }
        if (options.unicode) {
            modifiers += 'u';
        }
        return new RegExp(searchString, modifiers);
    }
    function $wf(regexp) {
        // Exit early if it's one of these special cases which are meant to match
        // against an empty string
        if (regexp.source === '^' || regexp.source === '^$' || regexp.source === '$' || regexp.source === '^\\s*$') {
            return false;
        }
        // We check against an empty string. If the regular expression doesn't advance
        // (e.g. ends in an endless loop) it will match an empty string.
        const match = regexp.exec('');
        return !!(match && regexp.lastIndex === 0);
    }
    function $xf(str) {
        return str.split(/\r\n|\r|\n/);
    }
    function $yf(str) {
        const linesWithSeparators = [];
        const splitLinesAndSeparators = str.split(/(\r\n|\r|\n)/);
        for (let i = 0; i < Math.ceil(splitLinesAndSeparators.length / 2); i++) {
            linesWithSeparators.push(splitLinesAndSeparators[2 * i] + (splitLinesAndSeparators[2 * i + 1] ?? ''));
        }
        return linesWithSeparators;
    }
    /**
     * Returns first index of the string that is not whitespace.
     * If string is empty or contains only whitespaces, returns -1
     */
    function $zf(str) {
        for (let i = 0, len = str.length; i < len; i++) {
            const chCode = str.charCodeAt(i);
            if (chCode !== charCode_1.CharCode.Space && chCode !== charCode_1.CharCode.Tab) {
                return i;
            }
        }
        return -1;
    }
    /**
     * Returns the leading whitespace of the string.
     * If the string contains only whitespaces, returns entire string
     */
    function $Af(str, start = 0, end = str.length) {
        for (let i = start; i < end; i++) {
            const chCode = str.charCodeAt(i);
            if (chCode !== charCode_1.CharCode.Space && chCode !== charCode_1.CharCode.Tab) {
                return str.substring(start, i);
            }
        }
        return str.substring(start, end);
    }
    /**
     * Returns last index of the string that is not whitespace.
     * If string is empty or contains only whitespaces, returns -1
     */
    function $Bf(str, startIndex = str.length - 1) {
        for (let i = startIndex; i >= 0; i--) {
            const chCode = str.charCodeAt(i);
            if (chCode !== charCode_1.CharCode.Space && chCode !== charCode_1.CharCode.Tab) {
                return i;
            }
        }
        return -1;
    }
    /**
     * Function that works identically to String.prototype.replace, except, the
     * replace function is allowed to be async and return a Promise.
     */
    function $Cf(str, search, replacer) {
        const parts = [];
        let last = 0;
        for (const match of str.matchAll(search)) {
            parts.push(str.slice(last, match.index));
            if (match.index === undefined) {
                throw new Error('match.index should be defined');
            }
            last = match.index + match[0].length;
            parts.push(replacer(match[0], ...match.slice(1), match.index, str, match.groups));
        }
        parts.push(str.slice(last));
        return Promise.all(parts).then(p => p.join(''));
    }
    function $Df(a, b) {
        if (a < b) {
            return -1;
        }
        else if (a > b) {
            return 1;
        }
        else {
            return 0;
        }
    }
    function $Ef(a, b, aStart = 0, aEnd = a.length, bStart = 0, bEnd = b.length) {
        for (; aStart < aEnd && bStart < bEnd; aStart++, bStart++) {
            const codeA = a.charCodeAt(aStart);
            const codeB = b.charCodeAt(bStart);
            if (codeA < codeB) {
                return -1;
            }
            else if (codeA > codeB) {
                return 1;
            }
        }
        const aLen = aEnd - aStart;
        const bLen = bEnd - bStart;
        if (aLen < bLen) {
            return -1;
        }
        else if (aLen > bLen) {
            return 1;
        }
        return 0;
    }
    function $Ff(a, b) {
        return $Gf(a, b, 0, a.length, 0, b.length);
    }
    function $Gf(a, b, aStart = 0, aEnd = a.length, bStart = 0, bEnd = b.length) {
        for (; aStart < aEnd && bStart < bEnd; aStart++, bStart++) {
            let codeA = a.charCodeAt(aStart);
            let codeB = b.charCodeAt(bStart);
            if (codeA === codeB) {
                // equal
                continue;
            }
            if (codeA >= 128 || codeB >= 128) {
                // not ASCII letters -> fallback to lower-casing strings
                return $Ef(a.toLowerCase(), b.toLowerCase(), aStart, aEnd, bStart, bEnd);
            }
            // mapper lower-case ascii letter onto upper-case varinats
            // [97-122] (lower ascii) --> [65-90] (upper ascii)
            if ($If(codeA)) {
                codeA -= 32;
            }
            if ($If(codeB)) {
                codeB -= 32;
            }
            // compare both code points
            const diff = codeA - codeB;
            if (diff === 0) {
                continue;
            }
            return diff;
        }
        const aLen = aEnd - aStart;
        const bLen = bEnd - bStart;
        if (aLen < bLen) {
            return -1;
        }
        else if (aLen > bLen) {
            return 1;
        }
        return 0;
    }
    function $Hf(code) {
        return code >= charCode_1.CharCode.Digit0 && code <= charCode_1.CharCode.Digit9;
    }
    function $If(code) {
        return code >= charCode_1.CharCode.a && code <= charCode_1.CharCode.z;
    }
    function $Jf(code) {
        return code >= charCode_1.CharCode.A && code <= charCode_1.CharCode.Z;
    }
    function $Kf(a, b) {
        return a.length === b.length && $Gf(a, b) === 0;
    }
    function $Lf(str, candidate) {
        const candidateLength = candidate.length;
        if (candidate.length > str.length) {
            return false;
        }
        return $Gf(str, candidate, 0, candidateLength) === 0;
    }
    /**
     * @returns the length of the common prefix of the two strings.
     */
    function $Mf(a, b) {
        const len = Math.min(a.length, b.length);
        let i;
        for (i = 0; i < len; i++) {
            if (a.charCodeAt(i) !== b.charCodeAt(i)) {
                return i;
            }
        }
        return len;
    }
    /**
     * @returns the length of the common suffix of the two strings.
     */
    function $Nf(a, b) {
        const len = Math.min(a.length, b.length);
        let i;
        const aLastIndex = a.length - 1;
        const bLastIndex = b.length - 1;
        for (i = 0; i < len; i++) {
            if (a.charCodeAt(aLastIndex - i) !== b.charCodeAt(bLastIndex - i)) {
                return i;
            }
        }
        return len;
    }
    /**
     * See http://en.wikipedia.org/wiki/Surrogate_pair
     */
    function $Of(charCode) {
        return (0xD800 <= charCode && charCode <= 0xDBFF);
    }
    /**
     * See http://en.wikipedia.org/wiki/Surrogate_pair
     */
    function $Pf(charCode) {
        return (0xDC00 <= charCode && charCode <= 0xDFFF);
    }
    /**
     * See http://en.wikipedia.org/wiki/Surrogate_pair
     */
    function $Qf(highSurrogate, lowSurrogate) {
        return ((highSurrogate - 0xD800) << 10) + (lowSurrogate - 0xDC00) + 0x10000;
    }
    /**
     * get the code point that begins at offset `offset`
     */
    function $Rf(str, len, offset) {
        const charCode = str.charCodeAt(offset);
        if ($Of(charCode) && offset + 1 < len) {
            const nextCharCode = str.charCodeAt(offset + 1);
            if ($Pf(nextCharCode)) {
                return $Qf(charCode, nextCharCode);
            }
        }
        return charCode;
    }
    /**
     * get the code point that ends right before offset `offset`
     */
    function getPrevCodePoint(str, offset) {
        const charCode = str.charCodeAt(offset - 1);
        if ($Pf(charCode) && offset > 1) {
            const prevCharCode = str.charCodeAt(offset - 2);
            if ($Of(prevCharCode)) {
                return $Qf(prevCharCode, charCode);
            }
        }
        return charCode;
    }
    class $Sf {
        get offset() {
            return this.e;
        }
        constructor(str, offset = 0) {
            this.c = str;
            this.d = str.length;
            this.e = offset;
        }
        setOffset(offset) {
            this.e = offset;
        }
        prevCodePoint() {
            const codePoint = getPrevCodePoint(this.c, this.e);
            this.e -= (codePoint >= uint_1.Constants.UNICODE_SUPPLEMENTARY_PLANE_BEGIN ? 2 : 1);
            return codePoint;
        }
        nextCodePoint() {
            const codePoint = $Rf(this.c, this.d, this.e);
            this.e += (codePoint >= uint_1.Constants.UNICODE_SUPPLEMENTARY_PLANE_BEGIN ? 2 : 1);
            return codePoint;
        }
        eol() {
            return (this.e >= this.d);
        }
    }
    exports.$Sf = $Sf;
    class $Tf {
        get offset() {
            return this.c.offset;
        }
        constructor(str, offset = 0) {
            this.c = new $Sf(str, offset);
        }
        nextGraphemeLength() {
            const graphemeBreakTree = GraphemeBreakTree.getInstance();
            const iterator = this.c;
            const initialOffset = iterator.offset;
            let graphemeBreakType = graphemeBreakTree.getGraphemeBreakType(iterator.nextCodePoint());
            while (!iterator.eol()) {
                const offset = iterator.offset;
                const nextGraphemeBreakType = graphemeBreakTree.getGraphemeBreakType(iterator.nextCodePoint());
                if (breakBetweenGraphemeBreakType(graphemeBreakType, nextGraphemeBreakType)) {
                    // move iterator back
                    iterator.setOffset(offset);
                    break;
                }
                graphemeBreakType = nextGraphemeBreakType;
            }
            return (iterator.offset - initialOffset);
        }
        prevGraphemeLength() {
            const graphemeBreakTree = GraphemeBreakTree.getInstance();
            const iterator = this.c;
            const initialOffset = iterator.offset;
            let graphemeBreakType = graphemeBreakTree.getGraphemeBreakType(iterator.prevCodePoint());
            while (iterator.offset > 0) {
                const offset = iterator.offset;
                const prevGraphemeBreakType = graphemeBreakTree.getGraphemeBreakType(iterator.prevCodePoint());
                if (breakBetweenGraphemeBreakType(prevGraphemeBreakType, graphemeBreakType)) {
                    // move iterator back
                    iterator.setOffset(offset);
                    break;
                }
                graphemeBreakType = prevGraphemeBreakType;
            }
            return (initialOffset - iterator.offset);
        }
        eol() {
            return this.c.eol();
        }
    }
    exports.$Tf = $Tf;
    function $Uf(str, initialOffset) {
        const iterator = new $Tf(str, initialOffset);
        return iterator.nextGraphemeLength();
    }
    function $Vf(str, initialOffset) {
        const iterator = new $Tf(str, initialOffset);
        return iterator.prevGraphemeLength();
    }
    function $Wf(str, offset) {
        if (offset > 0 && $Pf(str.charCodeAt(offset))) {
            offset--;
        }
        const endOffset = offset + $Uf(str, offset);
        const startOffset = endOffset - $Vf(str, endOffset);
        return [startOffset, endOffset];
    }
    function $Xf(str) {
        const iterator = new $Tf(str);
        let length = 0;
        while (!iterator.eol()) {
            length++;
            iterator.nextGraphemeLength();
        }
        return length;
    }
    let CONTAINS_RTL = undefined;
    function makeContainsRtl() {
        // Generated using https://github.com/alexdima/unicode-utils/blob/main/rtl-test.js
        return /(?:[\u05BE\u05C0\u05C3\u05C6\u05D0-\u05F4\u0608\u060B\u060D\u061B-\u064A\u066D-\u066F\u0671-\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u0710\u0712-\u072F\u074D-\u07A5\u07B1-\u07EA\u07F4\u07F5\u07FA\u07FE-\u0815\u081A\u0824\u0828\u0830-\u0858\u085E-\u088E\u08A0-\u08C9\u200F\uFB1D\uFB1F-\uFB28\uFB2A-\uFD3D\uFD50-\uFDC7\uFDF0-\uFDFC\uFE70-\uFEFC]|\uD802[\uDC00-\uDD1B\uDD20-\uDE00\uDE10-\uDE35\uDE40-\uDEE4\uDEEB-\uDF35\uDF40-\uDFFF]|\uD803[\uDC00-\uDD23\uDE80-\uDEA9\uDEAD-\uDF45\uDF51-\uDF81\uDF86-\uDFF6]|\uD83A[\uDC00-\uDCCF\uDD00-\uDD43\uDD4B-\uDFFF]|\uD83B[\uDC00-\uDEBB])/;
    }
    /**
     * Returns true if `str` contains any Unicode character that is classified as "R" or "AL".
     */
    function $Yf(str) {
        if (!CONTAINS_RTL) {
            CONTAINS_RTL = makeContainsRtl();
        }
        return CONTAINS_RTL.test(str);
    }
    const IS_BASIC_ASCII = /^[\t\n\r\x20-\x7E]*$/;
    /**
     * Returns true if `str` contains only basic ASCII characters in the range 32 - 126 (including 32 and 126) or \n, \r, \t
     */
    function $Zf(str) {
        return IS_BASIC_ASCII.test(str);
    }
    exports.$1f = /[\u2028\u2029]/; // LINE SEPARATOR (LS) or PARAGRAPH SEPARATOR (PS)
    /**
     * Returns true if `str` contains unusual line terminators, like LS or PS
     */
    function $2f(str) {
        return exports.$1f.test(str);
    }
    function $3f(charCode) {
        // Do a cheap trick to better support wrapping of wide characters, treat them as 2 columns
        // http://jrgraphix.net/research/unicode_blocks.php
        //          2E80 - 2EFF   CJK Radicals Supplement
        //          2F00 - 2FDF   Kangxi Radicals
        //          2FF0 - 2FFF   Ideographic Description Characters
        //          3000 - 303F   CJK Symbols and Punctuation
        //          3040 - 309F   Hiragana
        //          30A0 - 30FF   Katakana
        //          3100 - 312F   Bopomofo
        //          3130 - 318F   Hangul Compatibility Jamo
        //          3190 - 319F   Kanbun
        //          31A0 - 31BF   Bopomofo Extended
        //          31F0 - 31FF   Katakana Phonetic Extensions
        //          3200 - 32FF   Enclosed CJK Letters and Months
        //          3300 - 33FF   CJK Compatibility
        //          3400 - 4DBF   CJK Unified Ideographs Extension A
        //          4DC0 - 4DFF   Yijing Hexagram Symbols
        //          4E00 - 9FFF   CJK Unified Ideographs
        //          A000 - A48F   Yi Syllables
        //          A490 - A4CF   Yi Radicals
        //          AC00 - D7AF   Hangul Syllables
        // [IGNORE] D800 - DB7F   High Surrogates
        // [IGNORE] DB80 - DBFF   High Private Use Surrogates
        // [IGNORE] DC00 - DFFF   Low Surrogates
        // [IGNORE] E000 - F8FF   Private Use Area
        //          F900 - FAFF   CJK Compatibility Ideographs
        // [IGNORE] FB00 - FB4F   Alphabetic Presentation Forms
        // [IGNORE] FB50 - FDFF   Arabic Presentation Forms-A
        // [IGNORE] FE00 - FE0F   Variation Selectors
        // [IGNORE] FE20 - FE2F   Combining Half Marks
        // [IGNORE] FE30 - FE4F   CJK Compatibility Forms
        // [IGNORE] FE50 - FE6F   Small Form Variants
        // [IGNORE] FE70 - FEFF   Arabic Presentation Forms-B
        //          FF00 - FFEF   Halfwidth and Fullwidth Forms
        //               [https://en.wikipedia.org/wiki/Halfwidth_and_fullwidth_forms]
        //               of which FF01 - FF5E fullwidth ASCII of 21 to 7E
        // [IGNORE]    and FF65 - FFDC halfwidth of Katakana and Hangul
        // [IGNORE] FFF0 - FFFF   Specials
        return ((charCode >= 0x2E80 && charCode <= 0xD7AF)
            || (charCode >= 0xF900 && charCode <= 0xFAFF)
            || (charCode >= 0xFF01 && charCode <= 0xFF5E));
    }
    /**
     * A fast function (therefore imprecise) to check if code points are emojis.
     * Generated using https://github.com/alexdima/unicode-utils/blob/main/emoji-test.js
     */
    function $4f(x) {
        return ((x >= 0x1F1E6 && x <= 0x1F1FF) || (x === 8986) || (x === 8987) || (x === 9200)
            || (x === 9203) || (x >= 9728 && x <= 10175) || (x === 11088) || (x === 11093)
            || (x >= 127744 && x <= 128591) || (x >= 128640 && x <= 128764)
            || (x >= 128992 && x <= 129008) || (x >= 129280 && x <= 129535)
            || (x >= 129648 && x <= 129782));
    }
    /**
     * Given a string and a max length returns a shorted version. Shorting
     * happens at favorable positions - such as whitespace or punctuation characters.
     * The return value can be longer than the given value of `n`. Leading whitespace is always trimmed.
     */
    function $5f(text, n, prefix = '') {
        const trimmed = text.trimStart();
        if (trimmed.length < n) {
            return trimmed;
        }
        const re = /\b/g;
        let i = 0;
        while (re.test(trimmed)) {
            if (trimmed.length - re.lastIndex < n) {
                break;
            }
            i = re.lastIndex;
            re.lastIndex += 1;
        }
        if (i === 0) {
            return trimmed;
        }
        return prefix + trimmed.substring(i).trimStart();
    }
    // Escape codes, compiled from https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Functions-using-CSI-_-ordered-by-the-final-character_s_
    // Plus additional markers for custom `\x1b]...\x07` instructions.
    const CSI_SEQUENCE = /(?:(?:\x1b\[|\x9B)[=?>!]?[\d;:]*["$#'* ]?[a-zA-Z@^`{}|~])|(:?\x1b\].*?\x07)/g;
    /** Iterates over parts of a string with CSI sequences */
    function* $6f(str) {
        let last = 0;
        for (const match of str.matchAll(CSI_SEQUENCE)) {
            if (last !== match.index) {
                yield { isCode: false, str: str.substring(last, match.index) };
            }
            yield { isCode: true, str: match[0] };
            last = match.index + match[0].length;
        }
        if (last !== str.length) {
            yield { isCode: false, str: str.substring(last) };
        }
    }
    /**
     * Strips ANSI escape sequences from a string.
     * @param str The dastringa stringo strip the ANSI escape sequences from.
     *
     * @example
     * removeAnsiEscapeCodes('\u001b[31mHello, World!\u001b[0m');
     * // 'Hello, World!'
     */
    function $7f(str) {
        if (str) {
            str = str.replace(CSI_SEQUENCE, '');
        }
        return str;
    }
    const PROMPT_NON_PRINTABLE = /\\\[.*?\\\]/g;
    /**
     * Strips ANSI escape sequences from a UNIX-style prompt string (eg. `$PS1`).
     * @param str The string to strip the ANSI escape sequences from.
     *
     * @example
     * removeAnsiEscapeCodesFromPrompt('\n\\[\u001b[01;34m\\]\\w\\[\u001b[00m\\]\n\\[\u001b[1;32m\\]> \\[\u001b[0m\\]');
     * // '\n\\w\n> '
     */
    function $8f(str) {
        return $7f(str).replace(PROMPT_NON_PRINTABLE, '');
    }
    // -- UTF-8 BOM
    exports.$9f = String.fromCharCode(charCode_1.CharCode.UTF8_BOM);
    function $0f(str) {
        return !!(str && str.length > 0 && str.charCodeAt(0) === charCode_1.CharCode.UTF8_BOM);
    }
    function $$f(str) {
        return $0f(str) ? str.substr(1) : str;
    }
    /**
     * Checks if the characters of the provided query string are included in the
     * target string. The characters do not have to be contiguous within the string.
     */
    function $_f(target, query) {
        if (!target || !query) {
            return false; // return early if target or query are undefined
        }
        if (target.length < query.length) {
            return false; // impossible for query to be contained in target
        }
        const queryLen = query.length;
        const targetLower = target.toLowerCase();
        let index = 0;
        let lastIndexOf = -1;
        while (index < queryLen) {
            const indexOf = targetLower.indexOf(query[index], lastIndexOf + 1);
            if (indexOf < 0) {
                return false;
            }
            lastIndexOf = indexOf;
            index++;
        }
        return true;
    }
    function $ag(target, ignoreEscapedChars = false) {
        if (!target) {
            return false;
        }
        if (ignoreEscapedChars) {
            target = target.replace(/\\./g, '');
        }
        return target.toLowerCase() !== target;
    }
    function $bg(str) {
        return str.charAt(0).toUpperCase() + str.slice(1);
    }
    function $cg(str, n = 1) {
        if (n === 0) {
            return '';
        }
        let idx = -1;
        do {
            idx = str.indexOf('\n', idx + 1);
            n--;
        } while (n > 0 && idx >= 0);
        if (idx === -1) {
            return str;
        }
        if (str[idx - 1] === '\r') {
            idx--;
        }
        return str.substr(0, idx);
    }
    /**
     * Produces 'a'-'z', followed by 'A'-'Z'... followed by 'a'-'z', etc.
     */
    function $dg(n) {
        const LETTERS_CNT = (charCode_1.CharCode.Z - charCode_1.CharCode.A + 1);
        n = n % (2 * LETTERS_CNT);
        if (n < LETTERS_CNT) {
            return String.fromCharCode(charCode_1.CharCode.a + n);
        }
        return String.fromCharCode(charCode_1.CharCode.A + n - LETTERS_CNT);
    }
    //#region Unicode Grapheme Break
    function $eg(codePoint) {
        const graphemeBreakTree = GraphemeBreakTree.getInstance();
        return graphemeBreakTree.getGraphemeBreakType(codePoint);
    }
    function breakBetweenGraphemeBreakType(breakTypeA, breakTypeB) {
        // http://www.unicode.org/reports/tr29/#Grapheme_Cluster_Boundary_Rules
        // !!! Let's make the common case a bit faster
        if (breakTypeA === GraphemeBreakType.Other) {
            // see https://www.unicode.org/Public/13.0.0/ucd/auxiliary/GraphemeBreakTest-13.0.0d10.html#table
            return (breakTypeB !== GraphemeBreakType.Extend && breakTypeB !== GraphemeBreakType.SpacingMark);
        }
        // Do not break between a CR and LF. Otherwise, break before and after controls.
        // GB3                                        CR × LF
        // GB4                       (Control | CR | LF) ÷
        // GB5                                           ÷ (Control | CR | LF)
        if (breakTypeA === GraphemeBreakType.CR) {
            if (breakTypeB === GraphemeBreakType.LF) {
                return false; // GB3
            }
        }
        if (breakTypeA === GraphemeBreakType.Control || breakTypeA === GraphemeBreakType.CR || breakTypeA === GraphemeBreakType.LF) {
            return true; // GB4
        }
        if (breakTypeB === GraphemeBreakType.Control || breakTypeB === GraphemeBreakType.CR || breakTypeB === GraphemeBreakType.LF) {
            return true; // GB5
        }
        // Do not break Hangul syllable sequences.
        // GB6                                         L × (L | V | LV | LVT)
        // GB7                                  (LV | V) × (V | T)
        // GB8                                 (LVT | T) × T
        if (breakTypeA === GraphemeBreakType.L) {
            if (breakTypeB === GraphemeBreakType.L || breakTypeB === GraphemeBreakType.V || breakTypeB === GraphemeBreakType.LV || breakTypeB === GraphemeBreakType.LVT) {
                return false; // GB6
            }
        }
        if (breakTypeA === GraphemeBreakType.LV || breakTypeA === GraphemeBreakType.V) {
            if (breakTypeB === GraphemeBreakType.V || breakTypeB === GraphemeBreakType.T) {
                return false; // GB7
            }
        }
        if (breakTypeA === GraphemeBreakType.LVT || breakTypeA === GraphemeBreakType.T) {
            if (breakTypeB === GraphemeBreakType.T) {
                return false; // GB8
            }
        }
        // Do not break before extending characters or ZWJ.
        // GB9                                           × (Extend | ZWJ)
        if (breakTypeB === GraphemeBreakType.Extend || breakTypeB === GraphemeBreakType.ZWJ) {
            return false; // GB9
        }
        // The GB9a and GB9b rules only apply to extended grapheme clusters:
        // Do not break before SpacingMarks, or after Prepend characters.
        // GB9a                                          × SpacingMark
        // GB9b                                  Prepend ×
        if (breakTypeB === GraphemeBreakType.SpacingMark) {
            return false; // GB9a
        }
        if (breakTypeA === GraphemeBreakType.Prepend) {
            return false; // GB9b
        }
        // Do not break within emoji modifier sequences or emoji zwj sequences.
        // GB11    \p{Extended_Pictographic} Extend* ZWJ × \p{Extended_Pictographic}
        if (breakTypeA === GraphemeBreakType.ZWJ && breakTypeB === GraphemeBreakType.Extended_Pictographic) {
            // Note: we are not implementing the rule entirely here to avoid introducing states
            return false; // GB11
        }
        // GB12                          sot (RI RI)* RI × RI
        // GB13                        [^RI] (RI RI)* RI × RI
        if (breakTypeA === GraphemeBreakType.Regional_Indicator && breakTypeB === GraphemeBreakType.Regional_Indicator) {
            // Note: we are not implementing the rule entirely here to avoid introducing states
            return false; // GB12 & GB13
        }
        // GB999                                     Any ÷ Any
        return true;
    }
    var GraphemeBreakType;
    (function (GraphemeBreakType) {
        GraphemeBreakType[GraphemeBreakType["Other"] = 0] = "Other";
        GraphemeBreakType[GraphemeBreakType["Prepend"] = 1] = "Prepend";
        GraphemeBreakType[GraphemeBreakType["CR"] = 2] = "CR";
        GraphemeBreakType[GraphemeBreakType["LF"] = 3] = "LF";
        GraphemeBreakType[GraphemeBreakType["Control"] = 4] = "Control";
        GraphemeBreakType[GraphemeBreakType["Extend"] = 5] = "Extend";
        GraphemeBreakType[GraphemeBreakType["Regional_Indicator"] = 6] = "Regional_Indicator";
        GraphemeBreakType[GraphemeBreakType["SpacingMark"] = 7] = "SpacingMark";
        GraphemeBreakType[GraphemeBreakType["L"] = 8] = "L";
        GraphemeBreakType[GraphemeBreakType["V"] = 9] = "V";
        GraphemeBreakType[GraphemeBreakType["T"] = 10] = "T";
        GraphemeBreakType[GraphemeBreakType["LV"] = 11] = "LV";
        GraphemeBreakType[GraphemeBreakType["LVT"] = 12] = "LVT";
        GraphemeBreakType[GraphemeBreakType["ZWJ"] = 13] = "ZWJ";
        GraphemeBreakType[GraphemeBreakType["Extended_Pictographic"] = 14] = "Extended_Pictographic";
    })(GraphemeBreakType || (exports.GraphemeBreakType = GraphemeBreakType = {}));
    class GraphemeBreakTree {
        static { this.c = null; }
        static getInstance() {
            if (!GraphemeBreakTree.c) {
                GraphemeBreakTree.c = new GraphemeBreakTree();
            }
            return GraphemeBreakTree.c;
        }
        constructor() {
            this.d = getGraphemeBreakRawData();
        }
        getGraphemeBreakType(codePoint) {
            // !!! Let's make 7bit ASCII a bit faster: 0..31
            if (codePoint < 32) {
                if (codePoint === charCode_1.CharCode.LineFeed) {
                    return GraphemeBreakType.LF;
                }
                if (codePoint === charCode_1.CharCode.CarriageReturn) {
                    return GraphemeBreakType.CR;
                }
                return GraphemeBreakType.Control;
            }
            // !!! Let's make 7bit ASCII a bit faster: 32..126
            if (codePoint < 127) {
                return GraphemeBreakType.Other;
            }
            const data = this.d;
            const nodeCount = data.length / 3;
            let nodeIndex = 1;
            while (nodeIndex <= nodeCount) {
                if (codePoint < data[3 * nodeIndex]) {
                    // go left
                    nodeIndex = 2 * nodeIndex;
                }
                else if (codePoint > data[3 * nodeIndex + 1]) {
                    // go right
                    nodeIndex = 2 * nodeIndex + 1;
                }
                else {
                    // hit
                    return data[3 * nodeIndex + 2];
                }
            }
            return GraphemeBreakType.Other;
        }
    }
    function getGraphemeBreakRawData() {
        // generated using https://github.com/alexdima/unicode-utils/blob/main/grapheme-break.js
        return JSON.parse('[0,0,0,51229,51255,12,44061,44087,12,127462,127487,6,7083,7085,5,47645,47671,12,54813,54839,12,128678,128678,14,3270,3270,5,9919,9923,14,45853,45879,12,49437,49463,12,53021,53047,12,71216,71218,7,128398,128399,14,129360,129374,14,2519,2519,5,4448,4519,9,9742,9742,14,12336,12336,14,44957,44983,12,46749,46775,12,48541,48567,12,50333,50359,12,52125,52151,12,53917,53943,12,69888,69890,5,73018,73018,5,127990,127990,14,128558,128559,14,128759,128760,14,129653,129655,14,2027,2035,5,2891,2892,7,3761,3761,5,6683,6683,5,8293,8293,4,9825,9826,14,9999,9999,14,43452,43453,5,44509,44535,12,45405,45431,12,46301,46327,12,47197,47223,12,48093,48119,12,48989,49015,12,49885,49911,12,50781,50807,12,51677,51703,12,52573,52599,12,53469,53495,12,54365,54391,12,65279,65279,4,70471,70472,7,72145,72147,7,119173,119179,5,127799,127818,14,128240,128244,14,128512,128512,14,128652,128652,14,128721,128722,14,129292,129292,14,129445,129450,14,129734,129743,14,1476,1477,5,2366,2368,7,2750,2752,7,3076,3076,5,3415,3415,5,4141,4144,5,6109,6109,5,6964,6964,5,7394,7400,5,9197,9198,14,9770,9770,14,9877,9877,14,9968,9969,14,10084,10084,14,43052,43052,5,43713,43713,5,44285,44311,12,44733,44759,12,45181,45207,12,45629,45655,12,46077,46103,12,46525,46551,12,46973,46999,12,47421,47447,12,47869,47895,12,48317,48343,12,48765,48791,12,49213,49239,12,49661,49687,12,50109,50135,12,50557,50583,12,51005,51031,12,51453,51479,12,51901,51927,12,52349,52375,12,52797,52823,12,53245,53271,12,53693,53719,12,54141,54167,12,54589,54615,12,55037,55063,12,69506,69509,5,70191,70193,5,70841,70841,7,71463,71467,5,72330,72342,5,94031,94031,5,123628,123631,5,127763,127765,14,127941,127941,14,128043,128062,14,128302,128317,14,128465,128467,14,128539,128539,14,128640,128640,14,128662,128662,14,128703,128703,14,128745,128745,14,129004,129007,14,129329,129330,14,129402,129402,14,129483,129483,14,129686,129704,14,130048,131069,14,173,173,4,1757,1757,1,2200,2207,5,2434,2435,7,2631,2632,5,2817,2817,5,3008,3008,5,3201,3201,5,3387,3388,5,3542,3542,5,3902,3903,7,4190,4192,5,6002,6003,5,6439,6440,5,6765,6770,7,7019,7027,5,7154,7155,7,8205,8205,13,8505,8505,14,9654,9654,14,9757,9757,14,9792,9792,14,9852,9853,14,9890,9894,14,9937,9937,14,9981,9981,14,10035,10036,14,11035,11036,14,42654,42655,5,43346,43347,7,43587,43587,5,44006,44007,7,44173,44199,12,44397,44423,12,44621,44647,12,44845,44871,12,45069,45095,12,45293,45319,12,45517,45543,12,45741,45767,12,45965,45991,12,46189,46215,12,46413,46439,12,46637,46663,12,46861,46887,12,47085,47111,12,47309,47335,12,47533,47559,12,47757,47783,12,47981,48007,12,48205,48231,12,48429,48455,12,48653,48679,12,48877,48903,12,49101,49127,12,49325,49351,12,49549,49575,12,49773,49799,12,49997,50023,12,50221,50247,12,50445,50471,12,50669,50695,12,50893,50919,12,51117,51143,12,51341,51367,12,51565,51591,12,51789,51815,12,52013,52039,12,52237,52263,12,52461,52487,12,52685,52711,12,52909,52935,12,53133,53159,12,53357,53383,12,53581,53607,12,53805,53831,12,54029,54055,12,54253,54279,12,54477,54503,12,54701,54727,12,54925,54951,12,55149,55175,12,68101,68102,5,69762,69762,7,70067,70069,7,70371,70378,5,70720,70721,7,71087,71087,5,71341,71341,5,71995,71996,5,72249,72249,7,72850,72871,5,73109,73109,5,118576,118598,5,121505,121519,5,127245,127247,14,127568,127569,14,127777,127777,14,127872,127891,14,127956,127967,14,128015,128016,14,128110,128172,14,128259,128259,14,128367,128368,14,128424,128424,14,128488,128488,14,128530,128532,14,128550,128551,14,128566,128566,14,128647,128647,14,128656,128656,14,128667,128673,14,128691,128693,14,128715,128715,14,128728,128732,14,128752,128752,14,128765,128767,14,129096,129103,14,129311,129311,14,129344,129349,14,129394,129394,14,129413,129425,14,129466,129471,14,129511,129535,14,129664,129666,14,129719,129722,14,129760,129767,14,917536,917631,5,13,13,2,1160,1161,5,1564,1564,4,1807,1807,1,2085,2087,5,2307,2307,7,2382,2383,7,2497,2500,5,2563,2563,7,2677,2677,5,2763,2764,7,2879,2879,5,2914,2915,5,3021,3021,5,3142,3144,5,3263,3263,5,3285,3286,5,3398,3400,7,3530,3530,5,3633,3633,5,3864,3865,5,3974,3975,5,4155,4156,7,4229,4230,5,5909,5909,7,6078,6085,7,6277,6278,5,6451,6456,7,6744,6750,5,6846,6846,5,6972,6972,5,7074,7077,5,7146,7148,7,7222,7223,5,7416,7417,5,8234,8238,4,8417,8417,5,9000,9000,14,9203,9203,14,9730,9731,14,9748,9749,14,9762,9763,14,9776,9783,14,9800,9811,14,9831,9831,14,9872,9873,14,9882,9882,14,9900,9903,14,9929,9933,14,9941,9960,14,9974,9974,14,9989,9989,14,10006,10006,14,10062,10062,14,10160,10160,14,11647,11647,5,12953,12953,14,43019,43019,5,43232,43249,5,43443,43443,5,43567,43568,7,43696,43696,5,43765,43765,7,44013,44013,5,44117,44143,12,44229,44255,12,44341,44367,12,44453,44479,12,44565,44591,12,44677,44703,12,44789,44815,12,44901,44927,12,45013,45039,12,45125,45151,12,45237,45263,12,45349,45375,12,45461,45487,12,45573,45599,12,45685,45711,12,45797,45823,12,45909,45935,12,46021,46047,12,46133,46159,12,46245,46271,12,46357,46383,12,46469,46495,12,46581,46607,12,46693,46719,12,46805,46831,12,46917,46943,12,47029,47055,12,47141,47167,12,47253,47279,12,47365,47391,12,47477,47503,12,47589,47615,12,47701,47727,12,47813,47839,12,47925,47951,12,48037,48063,12,48149,48175,12,48261,48287,12,48373,48399,12,48485,48511,12,48597,48623,12,48709,48735,12,48821,48847,12,48933,48959,12,49045,49071,12,49157,49183,12,49269,49295,12,49381,49407,12,49493,49519,12,49605,49631,12,49717,49743,12,49829,49855,12,49941,49967,12,50053,50079,12,50165,50191,12,50277,50303,12,50389,50415,12,50501,50527,12,50613,50639,12,50725,50751,12,50837,50863,12,50949,50975,12,51061,51087,12,51173,51199,12,51285,51311,12,51397,51423,12,51509,51535,12,51621,51647,12,51733,51759,12,51845,51871,12,51957,51983,12,52069,52095,12,52181,52207,12,52293,52319,12,52405,52431,12,52517,52543,12,52629,52655,12,52741,52767,12,52853,52879,12,52965,52991,12,53077,53103,12,53189,53215,12,53301,53327,12,53413,53439,12,53525,53551,12,53637,53663,12,53749,53775,12,53861,53887,12,53973,53999,12,54085,54111,12,54197,54223,12,54309,54335,12,54421,54447,12,54533,54559,12,54645,54671,12,54757,54783,12,54869,54895,12,54981,55007,12,55093,55119,12,55243,55291,10,66045,66045,5,68325,68326,5,69688,69702,5,69817,69818,5,69957,69958,7,70089,70092,5,70198,70199,5,70462,70462,5,70502,70508,5,70750,70750,5,70846,70846,7,71100,71101,5,71230,71230,7,71351,71351,5,71737,71738,5,72000,72000,7,72160,72160,5,72273,72278,5,72752,72758,5,72882,72883,5,73031,73031,5,73461,73462,7,94192,94193,7,119149,119149,7,121403,121452,5,122915,122916,5,126980,126980,14,127358,127359,14,127535,127535,14,127759,127759,14,127771,127771,14,127792,127793,14,127825,127867,14,127897,127899,14,127945,127945,14,127985,127986,14,128000,128007,14,128021,128021,14,128066,128100,14,128184,128235,14,128249,128252,14,128266,128276,14,128335,128335,14,128379,128390,14,128407,128419,14,128444,128444,14,128481,128481,14,128499,128499,14,128526,128526,14,128536,128536,14,128543,128543,14,128556,128556,14,128564,128564,14,128577,128580,14,128643,128645,14,128649,128649,14,128654,128654,14,128660,128660,14,128664,128664,14,128675,128675,14,128686,128689,14,128695,128696,14,128705,128709,14,128717,128719,14,128725,128725,14,128736,128741,14,128747,128748,14,128755,128755,14,128762,128762,14,128981,128991,14,129009,129023,14,129160,129167,14,129296,129304,14,129320,129327,14,129340,129342,14,129356,129356,14,129388,129392,14,129399,129400,14,129404,129407,14,129432,129442,14,129454,129455,14,129473,129474,14,129485,129487,14,129648,129651,14,129659,129660,14,129671,129679,14,129709,129711,14,129728,129730,14,129751,129753,14,129776,129782,14,917505,917505,4,917760,917999,5,10,10,3,127,159,4,768,879,5,1471,1471,5,1536,1541,1,1648,1648,5,1767,1768,5,1840,1866,5,2070,2073,5,2137,2139,5,2274,2274,1,2363,2363,7,2377,2380,7,2402,2403,5,2494,2494,5,2507,2508,7,2558,2558,5,2622,2624,7,2641,2641,5,2691,2691,7,2759,2760,5,2786,2787,5,2876,2876,5,2881,2884,5,2901,2902,5,3006,3006,5,3014,3016,7,3072,3072,5,3134,3136,5,3157,3158,5,3260,3260,5,3266,3266,5,3274,3275,7,3328,3329,5,3391,3392,7,3405,3405,5,3457,3457,5,3536,3537,7,3551,3551,5,3636,3642,5,3764,3772,5,3895,3895,5,3967,3967,7,3993,4028,5,4146,4151,5,4182,4183,7,4226,4226,5,4253,4253,5,4957,4959,5,5940,5940,7,6070,6070,7,6087,6088,7,6158,6158,4,6432,6434,5,6448,6449,7,6679,6680,5,6742,6742,5,6754,6754,5,6783,6783,5,6912,6915,5,6966,6970,5,6978,6978,5,7042,7042,7,7080,7081,5,7143,7143,7,7150,7150,7,7212,7219,5,7380,7392,5,7412,7412,5,8203,8203,4,8232,8232,4,8265,8265,14,8400,8412,5,8421,8432,5,8617,8618,14,9167,9167,14,9200,9200,14,9410,9410,14,9723,9726,14,9733,9733,14,9745,9745,14,9752,9752,14,9760,9760,14,9766,9766,14,9774,9774,14,9786,9786,14,9794,9794,14,9823,9823,14,9828,9828,14,9833,9850,14,9855,9855,14,9875,9875,14,9880,9880,14,9885,9887,14,9896,9897,14,9906,9916,14,9926,9927,14,9935,9935,14,9939,9939,14,9962,9962,14,9972,9972,14,9978,9978,14,9986,9986,14,9997,9997,14,10002,10002,14,10017,10017,14,10055,10055,14,10071,10071,14,10133,10135,14,10548,10549,14,11093,11093,14,12330,12333,5,12441,12442,5,42608,42610,5,43010,43010,5,43045,43046,5,43188,43203,7,43302,43309,5,43392,43394,5,43446,43449,5,43493,43493,5,43571,43572,7,43597,43597,7,43703,43704,5,43756,43757,5,44003,44004,7,44009,44010,7,44033,44059,12,44089,44115,12,44145,44171,12,44201,44227,12,44257,44283,12,44313,44339,12,44369,44395,12,44425,44451,12,44481,44507,12,44537,44563,12,44593,44619,12,44649,44675,12,44705,44731,12,44761,44787,12,44817,44843,12,44873,44899,12,44929,44955,12,44985,45011,12,45041,45067,12,45097,45123,12,45153,45179,12,45209,45235,12,45265,45291,12,45321,45347,12,45377,45403,12,45433,45459,12,45489,45515,12,45545,45571,12,45601,45627,12,45657,45683,12,45713,45739,12,45769,45795,12,45825,45851,12,45881,45907,12,45937,45963,12,45993,46019,12,46049,46075,12,46105,46131,12,46161,46187,12,46217,46243,12,46273,46299,12,46329,46355,12,46385,46411,12,46441,46467,12,46497,46523,12,46553,46579,12,46609,46635,12,46665,46691,12,46721,46747,12,46777,46803,12,46833,46859,12,46889,46915,12,46945,46971,12,47001,47027,12,47057,47083,12,47113,47139,12,47169,47195,12,47225,47251,12,47281,47307,12,47337,47363,12,47393,47419,12,47449,47475,12,47505,47531,12,47561,47587,12,47617,47643,12,47673,47699,12,47729,47755,12,47785,47811,12,47841,47867,12,47897,47923,12,47953,47979,12,48009,48035,12,48065,48091,12,48121,48147,12,48177,48203,12,48233,48259,12,48289,48315,12,48345,48371,12,48401,48427,12,48457,48483,12,48513,48539,12,48569,48595,12,48625,48651,12,48681,48707,12,48737,48763,12,48793,48819,12,48849,48875,12,48905,48931,12,48961,48987,12,49017,49043,12,49073,49099,12,49129,49155,12,49185,49211,12,49241,49267,12,49297,49323,12,49353,49379,12,49409,49435,12,49465,49491,12,49521,49547,12,49577,49603,12,49633,49659,12,49689,49715,12,49745,49771,12,49801,49827,12,49857,49883,12,49913,49939,12,49969,49995,12,50025,50051,12,50081,50107,12,50137,50163,12,50193,50219,12,50249,50275,12,50305,50331,12,50361,50387,12,50417,50443,12,50473,50499,12,50529,50555,12,50585,50611,12,50641,50667,12,50697,50723,12,50753,50779,12,50809,50835,12,50865,50891,12,50921,50947,12,50977,51003,12,51033,51059,12,51089,51115,12,51145,51171,12,51201,51227,12,51257,51283,12,51313,51339,12,51369,51395,12,51425,51451,12,51481,51507,12,51537,51563,12,51593,51619,12,51649,51675,12,51705,51731,12,51761,51787,12,51817,51843,12,51873,51899,12,51929,51955,12,51985,52011,12,52041,52067,12,52097,52123,12,52153,52179,12,52209,52235,12,52265,52291,12,52321,52347,12,52377,52403,12,52433,52459,12,52489,52515,12,52545,52571,12,52601,52627,12,52657,52683,12,52713,52739,12,52769,52795,12,52825,52851,12,52881,52907,12,52937,52963,12,52993,53019,12,53049,53075,12,53105,53131,12,53161,53187,12,53217,53243,12,53273,53299,12,53329,53355,12,53385,53411,12,53441,53467,12,53497,53523,12,53553,53579,12,53609,53635,12,53665,53691,12,53721,53747,12,53777,53803,12,53833,53859,12,53889,53915,12,53945,53971,12,54001,54027,12,54057,54083,12,54113,54139,12,54169,54195,12,54225,54251,12,54281,54307,12,54337,54363,12,54393,54419,12,54449,54475,12,54505,54531,12,54561,54587,12,54617,54643,12,54673,54699,12,54729,54755,12,54785,54811,12,54841,54867,12,54897,54923,12,54953,54979,12,55009,55035,12,55065,55091,12,55121,55147,12,55177,55203,12,65024,65039,5,65520,65528,4,66422,66426,5,68152,68154,5,69291,69292,5,69633,69633,5,69747,69748,5,69811,69814,5,69826,69826,5,69932,69932,7,70016,70017,5,70079,70080,7,70095,70095,5,70196,70196,5,70367,70367,5,70402,70403,7,70464,70464,5,70487,70487,5,70709,70711,7,70725,70725,7,70833,70834,7,70843,70844,7,70849,70849,7,71090,71093,5,71103,71104,5,71227,71228,7,71339,71339,5,71344,71349,5,71458,71461,5,71727,71735,5,71985,71989,7,71998,71998,5,72002,72002,7,72154,72155,5,72193,72202,5,72251,72254,5,72281,72283,5,72344,72345,5,72766,72766,7,72874,72880,5,72885,72886,5,73023,73029,5,73104,73105,5,73111,73111,5,92912,92916,5,94095,94098,5,113824,113827,4,119142,119142,7,119155,119162,4,119362,119364,5,121476,121476,5,122888,122904,5,123184,123190,5,125252,125258,5,127183,127183,14,127340,127343,14,127377,127386,14,127491,127503,14,127548,127551,14,127744,127756,14,127761,127761,14,127769,127769,14,127773,127774,14,127780,127788,14,127796,127797,14,127820,127823,14,127869,127869,14,127894,127895,14,127902,127903,14,127943,127943,14,127947,127950,14,127972,127972,14,127988,127988,14,127992,127994,14,128009,128011,14,128019,128019,14,128023,128041,14,128064,128064,14,128102,128107,14,128174,128181,14,128238,128238,14,128246,128247,14,128254,128254,14,128264,128264,14,128278,128299,14,128329,128330,14,128348,128359,14,128371,128377,14,128392,128393,14,128401,128404,14,128421,128421,14,128433,128434,14,128450,128452,14,128476,128478,14,128483,128483,14,128495,128495,14,128506,128506,14,128519,128520,14,128528,128528,14,128534,128534,14,128538,128538,14,128540,128542,14,128544,128549,14,128552,128555,14,128557,128557,14,128560,128563,14,128565,128565,14,128567,128576,14,128581,128591,14,128641,128642,14,128646,128646,14,128648,128648,14,128650,128651,14,128653,128653,14,128655,128655,14,128657,128659,14,128661,128661,14,128663,128663,14,128665,128666,14,128674,128674,14,128676,128677,14,128679,128685,14,128690,128690,14,128694,128694,14,128697,128702,14,128704,128704,14,128710,128714,14,128716,128716,14,128720,128720,14,128723,128724,14,128726,128727,14,128733,128735,14,128742,128744,14,128746,128746,14,128749,128751,14,128753,128754,14,128756,128758,14,128761,128761,14,128763,128764,14,128884,128895,14,128992,129003,14,129008,129008,14,129036,129039,14,129114,129119,14,129198,129279,14,129293,129295,14,129305,129310,14,129312,129319,14,129328,129328,14,129331,129338,14,129343,129343,14,129351,129355,14,129357,129359,14,129375,129387,14,129393,129393,14,129395,129398,14,129401,129401,14,129403,129403,14,129408,129412,14,129426,129431,14,129443,129444,14,129451,129453,14,129456,129465,14,129472,129472,14,129475,129482,14,129484,129484,14,129488,129510,14,129536,129647,14,129652,129652,14,129656,129658,14,129661,129663,14,129667,129670,14,129680,129685,14,129705,129708,14,129712,129718,14,129723,129727,14,129731,129733,14,129744,129750,14,129754,129759,14,129768,129775,14,129783,129791,14,917504,917504,4,917506,917535,4,917632,917759,4,918000,921599,4,0,9,4,11,12,4,14,31,4,169,169,14,174,174,14,1155,1159,5,1425,1469,5,1473,1474,5,1479,1479,5,1552,1562,5,1611,1631,5,1750,1756,5,1759,1764,5,1770,1773,5,1809,1809,5,1958,1968,5,2045,2045,5,2075,2083,5,2089,2093,5,2192,2193,1,2250,2273,5,2275,2306,5,2362,2362,5,2364,2364,5,2369,2376,5,2381,2381,5,2385,2391,5,2433,2433,5,2492,2492,5,2495,2496,7,2503,2504,7,2509,2509,5,2530,2531,5,2561,2562,5,2620,2620,5,2625,2626,5,2635,2637,5,2672,2673,5,2689,2690,5,2748,2748,5,2753,2757,5,2761,2761,7,2765,2765,5,2810,2815,5,2818,2819,7,2878,2878,5,2880,2880,7,2887,2888,7,2893,2893,5,2903,2903,5,2946,2946,5,3007,3007,7,3009,3010,7,3018,3020,7,3031,3031,5,3073,3075,7,3132,3132,5,3137,3140,7,3146,3149,5,3170,3171,5,3202,3203,7,3262,3262,7,3264,3265,7,3267,3268,7,3271,3272,7,3276,3277,5,3298,3299,5,3330,3331,7,3390,3390,5,3393,3396,5,3402,3404,7,3406,3406,1,3426,3427,5,3458,3459,7,3535,3535,5,3538,3540,5,3544,3550,7,3570,3571,7,3635,3635,7,3655,3662,5,3763,3763,7,3784,3789,5,3893,3893,5,3897,3897,5,3953,3966,5,3968,3972,5,3981,3991,5,4038,4038,5,4145,4145,7,4153,4154,5,4157,4158,5,4184,4185,5,4209,4212,5,4228,4228,7,4237,4237,5,4352,4447,8,4520,4607,10,5906,5908,5,5938,5939,5,5970,5971,5,6068,6069,5,6071,6077,5,6086,6086,5,6089,6099,5,6155,6157,5,6159,6159,5,6313,6313,5,6435,6438,7,6441,6443,7,6450,6450,5,6457,6459,5,6681,6682,7,6741,6741,7,6743,6743,7,6752,6752,5,6757,6764,5,6771,6780,5,6832,6845,5,6847,6862,5,6916,6916,7,6965,6965,5,6971,6971,7,6973,6977,7,6979,6980,7,7040,7041,5,7073,7073,7,7078,7079,7,7082,7082,7,7142,7142,5,7144,7145,5,7149,7149,5,7151,7153,5,7204,7211,7,7220,7221,7,7376,7378,5,7393,7393,7,7405,7405,5,7415,7415,7,7616,7679,5,8204,8204,5,8206,8207,4,8233,8233,4,8252,8252,14,8288,8292,4,8294,8303,4,8413,8416,5,8418,8420,5,8482,8482,14,8596,8601,14,8986,8987,14,9096,9096,14,9193,9196,14,9199,9199,14,9201,9202,14,9208,9210,14,9642,9643,14,9664,9664,14,9728,9729,14,9732,9732,14,9735,9741,14,9743,9744,14,9746,9746,14,9750,9751,14,9753,9756,14,9758,9759,14,9761,9761,14,9764,9765,14,9767,9769,14,9771,9773,14,9775,9775,14,9784,9785,14,9787,9791,14,9793,9793,14,9795,9799,14,9812,9822,14,9824,9824,14,9827,9827,14,9829,9830,14,9832,9832,14,9851,9851,14,9854,9854,14,9856,9861,14,9874,9874,14,9876,9876,14,9878,9879,14,9881,9881,14,9883,9884,14,9888,9889,14,9895,9895,14,9898,9899,14,9904,9905,14,9917,9918,14,9924,9925,14,9928,9928,14,9934,9934,14,9936,9936,14,9938,9938,14,9940,9940,14,9961,9961,14,9963,9967,14,9970,9971,14,9973,9973,14,9975,9977,14,9979,9980,14,9982,9985,14,9987,9988,14,9992,9996,14,9998,9998,14,10000,10001,14,10004,10004,14,10013,10013,14,10024,10024,14,10052,10052,14,10060,10060,14,10067,10069,14,10083,10083,14,10085,10087,14,10145,10145,14,10175,10175,14,11013,11015,14,11088,11088,14,11503,11505,5,11744,11775,5,12334,12335,5,12349,12349,14,12951,12951,14,42607,42607,5,42612,42621,5,42736,42737,5,43014,43014,5,43043,43044,7,43047,43047,7,43136,43137,7,43204,43205,5,43263,43263,5,43335,43345,5,43360,43388,8,43395,43395,7,43444,43445,7,43450,43451,7,43454,43456,7,43561,43566,5,43569,43570,5,43573,43574,5,43596,43596,5,43644,43644,5,43698,43700,5,43710,43711,5,43755,43755,7,43758,43759,7,43766,43766,5,44005,44005,5,44008,44008,5,44012,44012,7,44032,44032,11,44060,44060,11,44088,44088,11,44116,44116,11,44144,44144,11,44172,44172,11,44200,44200,11,44228,44228,11,44256,44256,11,44284,44284,11,44312,44312,11,44340,44340,11,44368,44368,11,44396,44396,11,44424,44424,11,44452,44452,11,44480,44480,11,44508,44508,11,44536,44536,11,44564,44564,11,44592,44592,11,44620,44620,11,44648,44648,11,44676,44676,11,44704,44704,11,44732,44732,11,44760,44760,11,44788,44788,11,44816,44816,11,44844,44844,11,44872,44872,11,44900,44900,11,44928,44928,11,44956,44956,11,44984,44984,11,45012,45012,11,45040,45040,11,45068,45068,11,45096,45096,11,45124,45124,11,45152,45152,11,45180,45180,11,45208,45208,11,45236,45236,11,45264,45264,11,45292,45292,11,45320,45320,11,45348,45348,11,45376,45376,11,45404,45404,11,45432,45432,11,45460,45460,11,45488,45488,11,45516,45516,11,45544,45544,11,45572,45572,11,45600,45600,11,45628,45628,11,45656,45656,11,45684,45684,11,45712,45712,11,45740,45740,11,45768,45768,11,45796,45796,11,45824,45824,11,45852,45852,11,45880,45880,11,45908,45908,11,45936,45936,11,45964,45964,11,45992,45992,11,46020,46020,11,46048,46048,11,46076,46076,11,46104,46104,11,46132,46132,11,46160,46160,11,46188,46188,11,46216,46216,11,46244,46244,11,46272,46272,11,46300,46300,11,46328,46328,11,46356,46356,11,46384,46384,11,46412,46412,11,46440,46440,11,46468,46468,11,46496,46496,11,46524,46524,11,46552,46552,11,46580,46580,11,46608,46608,11,46636,46636,11,46664,46664,11,46692,46692,11,46720,46720,11,46748,46748,11,46776,46776,11,46804,46804,11,46832,46832,11,46860,46860,11,46888,46888,11,46916,46916,11,46944,46944,11,46972,46972,11,47000,47000,11,47028,47028,11,47056,47056,11,47084,47084,11,47112,47112,11,47140,47140,11,47168,47168,11,47196,47196,11,47224,47224,11,47252,47252,11,47280,47280,11,47308,47308,11,47336,47336,11,47364,47364,11,47392,47392,11,47420,47420,11,47448,47448,11,47476,47476,11,47504,47504,11,47532,47532,11,47560,47560,11,47588,47588,11,47616,47616,11,47644,47644,11,47672,47672,11,47700,47700,11,47728,47728,11,47756,47756,11,47784,47784,11,47812,47812,11,47840,47840,11,47868,47868,11,47896,47896,11,47924,47924,11,47952,47952,11,47980,47980,11,48008,48008,11,48036,48036,11,48064,48064,11,48092,48092,11,48120,48120,11,48148,48148,11,48176,48176,11,48204,48204,11,48232,48232,11,48260,48260,11,48288,48288,11,48316,48316,11,48344,48344,11,48372,48372,11,48400,48400,11,48428,48428,11,48456,48456,11,48484,48484,11,48512,48512,11,48540,48540,11,48568,48568,11,48596,48596,11,48624,48624,11,48652,48652,11,48680,48680,11,48708,48708,11,48736,48736,11,48764,48764,11,48792,48792,11,48820,48820,11,48848,48848,11,48876,48876,11,48904,48904,11,48932,48932,11,48960,48960,11,48988,48988,11,49016,49016,11,49044,49044,11,49072,49072,11,49100,49100,11,49128,49128,11,49156,49156,11,49184,49184,11,49212,49212,11,49240,49240,11,49268,49268,11,49296,49296,11,49324,49324,11,49352,49352,11,49380,49380,11,49408,49408,11,49436,49436,11,49464,49464,11,49492,49492,11,49520,49520,11,49548,49548,11,49576,49576,11,49604,49604,11,49632,49632,11,49660,49660,11,49688,49688,11,49716,49716,11,49744,49744,11,49772,49772,11,49800,49800,11,49828,49828,11,49856,49856,11,49884,49884,11,49912,49912,11,49940,49940,11,49968,49968,11,49996,49996,11,50024,50024,11,50052,50052,11,50080,50080,11,50108,50108,11,50136,50136,11,50164,50164,11,50192,50192,11,50220,50220,11,50248,50248,11,50276,50276,11,50304,50304,11,50332,50332,11,50360,50360,11,50388,50388,11,50416,50416,11,50444,50444,11,50472,50472,11,50500,50500,11,50528,50528,11,50556,50556,11,50584,50584,11,50612,50612,11,50640,50640,11,50668,50668,11,50696,50696,11,50724,50724,11,50752,50752,11,50780,50780,11,50808,50808,11,50836,50836,11,50864,50864,11,50892,50892,11,50920,50920,11,50948,50948,11,50976,50976,11,51004,51004,11,51032,51032,11,51060,51060,11,51088,51088,11,51116,51116,11,51144,51144,11,51172,51172,11,51200,51200,11,51228,51228,11,51256,51256,11,51284,51284,11,51312,51312,11,51340,51340,11,51368,51368,11,51396,51396,11,51424,51424,11,51452,51452,11,51480,51480,11,51508,51508,11,51536,51536,11,51564,51564,11,51592,51592,11,51620,51620,11,51648,51648,11,51676,51676,11,51704,51704,11,51732,51732,11,51760,51760,11,51788,51788,11,51816,51816,11,51844,51844,11,51872,51872,11,51900,51900,11,51928,51928,11,51956,51956,11,51984,51984,11,52012,52012,11,52040,52040,11,52068,52068,11,52096,52096,11,52124,52124,11,52152,52152,11,52180,52180,11,52208,52208,11,52236,52236,11,52264,52264,11,52292,52292,11,52320,52320,11,52348,52348,11,52376,52376,11,52404,52404,11,52432,52432,11,52460,52460,11,52488,52488,11,52516,52516,11,52544,52544,11,52572,52572,11,52600,52600,11,52628,52628,11,52656,52656,11,52684,52684,11,52712,52712,11,52740,52740,11,52768,52768,11,52796,52796,11,52824,52824,11,52852,52852,11,52880,52880,11,52908,52908,11,52936,52936,11,52964,52964,11,52992,52992,11,53020,53020,11,53048,53048,11,53076,53076,11,53104,53104,11,53132,53132,11,53160,53160,11,53188,53188,11,53216,53216,11,53244,53244,11,53272,53272,11,53300,53300,11,53328,53328,11,53356,53356,11,53384,53384,11,53412,53412,11,53440,53440,11,53468,53468,11,53496,53496,11,53524,53524,11,53552,53552,11,53580,53580,11,53608,53608,11,53636,53636,11,53664,53664,11,53692,53692,11,53720,53720,11,53748,53748,11,53776,53776,11,53804,53804,11,53832,53832,11,53860,53860,11,53888,53888,11,53916,53916,11,53944,53944,11,53972,53972,11,54000,54000,11,54028,54028,11,54056,54056,11,54084,54084,11,54112,54112,11,54140,54140,11,54168,54168,11,54196,54196,11,54224,54224,11,54252,54252,11,54280,54280,11,54308,54308,11,54336,54336,11,54364,54364,11,54392,54392,11,54420,54420,11,54448,54448,11,54476,54476,11,54504,54504,11,54532,54532,11,54560,54560,11,54588,54588,11,54616,54616,11,54644,54644,11,54672,54672,11,54700,54700,11,54728,54728,11,54756,54756,11,54784,54784,11,54812,54812,11,54840,54840,11,54868,54868,11,54896,54896,11,54924,54924,11,54952,54952,11,54980,54980,11,55008,55008,11,55036,55036,11,55064,55064,11,55092,55092,11,55120,55120,11,55148,55148,11,55176,55176,11,55216,55238,9,64286,64286,5,65056,65071,5,65438,65439,5,65529,65531,4,66272,66272,5,68097,68099,5,68108,68111,5,68159,68159,5,68900,68903,5,69446,69456,5,69632,69632,7,69634,69634,7,69744,69744,5,69759,69761,5,69808,69810,7,69815,69816,7,69821,69821,1,69837,69837,1,69927,69931,5,69933,69940,5,70003,70003,5,70018,70018,7,70070,70078,5,70082,70083,1,70094,70094,7,70188,70190,7,70194,70195,7,70197,70197,7,70206,70206,5,70368,70370,7,70400,70401,5,70459,70460,5,70463,70463,7,70465,70468,7,70475,70477,7,70498,70499,7,70512,70516,5,70712,70719,5,70722,70724,5,70726,70726,5,70832,70832,5,70835,70840,5,70842,70842,5,70845,70845,5,70847,70848,5,70850,70851,5,71088,71089,7,71096,71099,7,71102,71102,7,71132,71133,5,71219,71226,5,71229,71229,5,71231,71232,5,71340,71340,7,71342,71343,7,71350,71350,7,71453,71455,5,71462,71462,7,71724,71726,7,71736,71736,7,71984,71984,5,71991,71992,7,71997,71997,7,71999,71999,1,72001,72001,1,72003,72003,5,72148,72151,5,72156,72159,7,72164,72164,7,72243,72248,5,72250,72250,1,72263,72263,5,72279,72280,7,72324,72329,1,72343,72343,7,72751,72751,7,72760,72765,5,72767,72767,5,72873,72873,7,72881,72881,7,72884,72884,7,73009,73014,5,73020,73021,5,73030,73030,1,73098,73102,7,73107,73108,7,73110,73110,7,73459,73460,5,78896,78904,4,92976,92982,5,94033,94087,7,94180,94180,5,113821,113822,5,118528,118573,5,119141,119141,5,119143,119145,5,119150,119154,5,119163,119170,5,119210,119213,5,121344,121398,5,121461,121461,5,121499,121503,5,122880,122886,5,122907,122913,5,122918,122922,5,123566,123566,5,125136,125142,5,126976,126979,14,126981,127182,14,127184,127231,14,127279,127279,14,127344,127345,14,127374,127374,14,127405,127461,14,127489,127490,14,127514,127514,14,127538,127546,14,127561,127567,14,127570,127743,14,127757,127758,14,127760,127760,14,127762,127762,14,127766,127768,14,127770,127770,14,127772,127772,14,127775,127776,14,127778,127779,14,127789,127791,14,127794,127795,14,127798,127798,14,127819,127819,14,127824,127824,14,127868,127868,14,127870,127871,14,127892,127893,14,127896,127896,14,127900,127901,14,127904,127940,14,127942,127942,14,127944,127944,14,127946,127946,14,127951,127955,14,127968,127971,14,127973,127984,14,127987,127987,14,127989,127989,14,127991,127991,14,127995,127999,5,128008,128008,14,128012,128014,14,128017,128018,14,128020,128020,14,128022,128022,14,128042,128042,14,128063,128063,14,128065,128065,14,128101,128101,14,128108,128109,14,128173,128173,14,128182,128183,14,128236,128237,14,128239,128239,14,128245,128245,14,128248,128248,14,128253,128253,14,128255,128258,14,128260,128263,14,128265,128265,14,128277,128277,14,128300,128301,14,128326,128328,14,128331,128334,14,128336,128347,14,128360,128366,14,128369,128370,14,128378,128378,14,128391,128391,14,128394,128397,14,128400,128400,14,128405,128406,14,128420,128420,14,128422,128423,14,128425,128432,14,128435,128443,14,128445,128449,14,128453,128464,14,128468,128475,14,128479,128480,14,128482,128482,14,128484,128487,14,128489,128494,14,128496,128498,14,128500,128505,14,128507,128511,14,128513,128518,14,128521,128525,14,128527,128527,14,128529,128529,14,128533,128533,14,128535,128535,14,128537,128537,14]');
    }
    //#endregion
    /**
     * Computes the offset after performing a left delete on the given string,
     * while considering unicode grapheme/emoji rules.
    */
    function $fg(offset, str) {
        if (offset === 0) {
            return 0;
        }
        // Try to delete emoji part.
        const emojiOffset = getOffsetBeforeLastEmojiComponent(offset, str);
        if (emojiOffset !== undefined) {
            return emojiOffset;
        }
        // Otherwise, just skip a single code point.
        const iterator = new $Sf(str, offset);
        iterator.prevCodePoint();
        return iterator.offset;
    }
    function getOffsetBeforeLastEmojiComponent(initialOffset, str) {
        // See https://www.unicode.org/reports/tr51/tr51-14.html#EBNF_and_Regex for the
        // structure of emojis.
        const iterator = new $Sf(str, initialOffset);
        let codePoint = iterator.prevCodePoint();
        // Skip modifiers
        while ((isEmojiModifier(codePoint) || codePoint === CodePoint.emojiVariantSelector || codePoint === CodePoint.enclosingKeyCap)) {
            if (iterator.offset === 0) {
                // Cannot skip modifier, no preceding emoji base.
                return undefined;
            }
            codePoint = iterator.prevCodePoint();
        }
        // Expect base emoji
        if (!$4f(codePoint)) {
            // Unexpected code point, not a valid emoji.
            return undefined;
        }
        let resultOffset = iterator.offset;
        if (resultOffset > 0) {
            // Skip optional ZWJ code points that combine multiple emojis.
            // In theory, we should check if that ZWJ actually combines multiple emojis
            // to prevent deleting ZWJs in situations we didn't account for.
            const optionalZwjCodePoint = iterator.prevCodePoint();
            if (optionalZwjCodePoint === CodePoint.zwj) {
                resultOffset = iterator.offset;
            }
        }
        return resultOffset;
    }
    function isEmojiModifier(codePoint) {
        return 0x1F3FB <= codePoint && codePoint <= 0x1F3FF;
    }
    var CodePoint;
    (function (CodePoint) {
        CodePoint[CodePoint["zwj"] = 8205] = "zwj";
        /**
         * Variation Selector-16 (VS16)
        */
        CodePoint[CodePoint["emojiVariantSelector"] = 65039] = "emojiVariantSelector";
        /**
         * Combining Enclosing Keycap
         */
        CodePoint[CodePoint["enclosingKeyCap"] = 8419] = "enclosingKeyCap";
    })(CodePoint || (CodePoint = {}));
    exports.$gg = '\xa0';
    class $hg {
        static { this.c = new lazy_1.$Y(() => {
            // Generated using https://github.com/hediet/vscode-unicode-data
            // Stored as key1, value1, key2, value2, ...
            return JSON.parse('{\"_common\":[8232,32,8233,32,5760,32,8192,32,8193,32,8194,32,8195,32,8196,32,8197,32,8198,32,8200,32,8201,32,8202,32,8287,32,8199,32,8239,32,2042,95,65101,95,65102,95,65103,95,8208,45,8209,45,8210,45,65112,45,1748,45,8259,45,727,45,8722,45,10134,45,11450,45,1549,44,1643,44,8218,44,184,44,42233,44,894,59,2307,58,2691,58,1417,58,1795,58,1796,58,5868,58,65072,58,6147,58,6153,58,8282,58,1475,58,760,58,42889,58,8758,58,720,58,42237,58,451,33,11601,33,660,63,577,63,2429,63,5038,63,42731,63,119149,46,8228,46,1793,46,1794,46,42510,46,68176,46,1632,46,1776,46,42232,46,1373,96,65287,96,8219,96,8242,96,1370,96,1523,96,8175,96,65344,96,900,96,8189,96,8125,96,8127,96,8190,96,697,96,884,96,712,96,714,96,715,96,756,96,699,96,701,96,700,96,702,96,42892,96,1497,96,2036,96,2037,96,5194,96,5836,96,94033,96,94034,96,65339,91,10088,40,10098,40,12308,40,64830,40,65341,93,10089,41,10099,41,12309,41,64831,41,10100,123,119060,123,10101,125,65342,94,8270,42,1645,42,8727,42,66335,42,5941,47,8257,47,8725,47,8260,47,9585,47,10187,47,10744,47,119354,47,12755,47,12339,47,11462,47,20031,47,12035,47,65340,92,65128,92,8726,92,10189,92,10741,92,10745,92,119311,92,119355,92,12756,92,20022,92,12034,92,42872,38,708,94,710,94,5869,43,10133,43,66203,43,8249,60,10094,60,706,60,119350,60,5176,60,5810,60,5120,61,11840,61,12448,61,42239,61,8250,62,10095,62,707,62,119351,62,5171,62,94015,62,8275,126,732,126,8128,126,8764,126,65372,124,65293,45,120784,50,120794,50,120804,50,120814,50,120824,50,130034,50,42842,50,423,50,1000,50,42564,50,5311,50,42735,50,119302,51,120785,51,120795,51,120805,51,120815,51,120825,51,130035,51,42923,51,540,51,439,51,42858,51,11468,51,1248,51,94011,51,71882,51,120786,52,120796,52,120806,52,120816,52,120826,52,130036,52,5070,52,71855,52,120787,53,120797,53,120807,53,120817,53,120827,53,130037,53,444,53,71867,53,120788,54,120798,54,120808,54,120818,54,120828,54,130038,54,11474,54,5102,54,71893,54,119314,55,120789,55,120799,55,120809,55,120819,55,120829,55,130039,55,66770,55,71878,55,2819,56,2538,56,2666,56,125131,56,120790,56,120800,56,120810,56,120820,56,120830,56,130040,56,547,56,546,56,66330,56,2663,57,2920,57,2541,57,3437,57,120791,57,120801,57,120811,57,120821,57,120831,57,130041,57,42862,57,11466,57,71884,57,71852,57,71894,57,9082,97,65345,97,119834,97,119886,97,119938,97,119990,97,120042,97,120094,97,120146,97,120198,97,120250,97,120302,97,120354,97,120406,97,120458,97,593,97,945,97,120514,97,120572,97,120630,97,120688,97,120746,97,65313,65,119808,65,119860,65,119912,65,119964,65,120016,65,120068,65,120120,65,120172,65,120224,65,120276,65,120328,65,120380,65,120432,65,913,65,120488,65,120546,65,120604,65,120662,65,120720,65,5034,65,5573,65,42222,65,94016,65,66208,65,119835,98,119887,98,119939,98,119991,98,120043,98,120095,98,120147,98,120199,98,120251,98,120303,98,120355,98,120407,98,120459,98,388,98,5071,98,5234,98,5551,98,65314,66,8492,66,119809,66,119861,66,119913,66,120017,66,120069,66,120121,66,120173,66,120225,66,120277,66,120329,66,120381,66,120433,66,42932,66,914,66,120489,66,120547,66,120605,66,120663,66,120721,66,5108,66,5623,66,42192,66,66178,66,66209,66,66305,66,65347,99,8573,99,119836,99,119888,99,119940,99,119992,99,120044,99,120096,99,120148,99,120200,99,120252,99,120304,99,120356,99,120408,99,120460,99,7428,99,1010,99,11429,99,43951,99,66621,99,128844,67,71922,67,71913,67,65315,67,8557,67,8450,67,8493,67,119810,67,119862,67,119914,67,119966,67,120018,67,120174,67,120226,67,120278,67,120330,67,120382,67,120434,67,1017,67,11428,67,5087,67,42202,67,66210,67,66306,67,66581,67,66844,67,8574,100,8518,100,119837,100,119889,100,119941,100,119993,100,120045,100,120097,100,120149,100,120201,100,120253,100,120305,100,120357,100,120409,100,120461,100,1281,100,5095,100,5231,100,42194,100,8558,68,8517,68,119811,68,119863,68,119915,68,119967,68,120019,68,120071,68,120123,68,120175,68,120227,68,120279,68,120331,68,120383,68,120435,68,5024,68,5598,68,5610,68,42195,68,8494,101,65349,101,8495,101,8519,101,119838,101,119890,101,119942,101,120046,101,120098,101,120150,101,120202,101,120254,101,120306,101,120358,101,120410,101,120462,101,43826,101,1213,101,8959,69,65317,69,8496,69,119812,69,119864,69,119916,69,120020,69,120072,69,120124,69,120176,69,120228,69,120280,69,120332,69,120384,69,120436,69,917,69,120492,69,120550,69,120608,69,120666,69,120724,69,11577,69,5036,69,42224,69,71846,69,71854,69,66182,69,119839,102,119891,102,119943,102,119995,102,120047,102,120099,102,120151,102,120203,102,120255,102,120307,102,120359,102,120411,102,120463,102,43829,102,42905,102,383,102,7837,102,1412,102,119315,70,8497,70,119813,70,119865,70,119917,70,120021,70,120073,70,120125,70,120177,70,120229,70,120281,70,120333,70,120385,70,120437,70,42904,70,988,70,120778,70,5556,70,42205,70,71874,70,71842,70,66183,70,66213,70,66853,70,65351,103,8458,103,119840,103,119892,103,119944,103,120048,103,120100,103,120152,103,120204,103,120256,103,120308,103,120360,103,120412,103,120464,103,609,103,7555,103,397,103,1409,103,119814,71,119866,71,119918,71,119970,71,120022,71,120074,71,120126,71,120178,71,120230,71,120282,71,120334,71,120386,71,120438,71,1292,71,5056,71,5107,71,42198,71,65352,104,8462,104,119841,104,119945,104,119997,104,120049,104,120101,104,120153,104,120205,104,120257,104,120309,104,120361,104,120413,104,120465,104,1211,104,1392,104,5058,104,65320,72,8459,72,8460,72,8461,72,119815,72,119867,72,119919,72,120023,72,120179,72,120231,72,120283,72,120335,72,120387,72,120439,72,919,72,120494,72,120552,72,120610,72,120668,72,120726,72,11406,72,5051,72,5500,72,42215,72,66255,72,731,105,9075,105,65353,105,8560,105,8505,105,8520,105,119842,105,119894,105,119946,105,119998,105,120050,105,120102,105,120154,105,120206,105,120258,105,120310,105,120362,105,120414,105,120466,105,120484,105,618,105,617,105,953,105,8126,105,890,105,120522,105,120580,105,120638,105,120696,105,120754,105,1110,105,42567,105,1231,105,43893,105,5029,105,71875,105,65354,106,8521,106,119843,106,119895,106,119947,106,119999,106,120051,106,120103,106,120155,106,120207,106,120259,106,120311,106,120363,106,120415,106,120467,106,1011,106,1112,106,65322,74,119817,74,119869,74,119921,74,119973,74,120025,74,120077,74,120129,74,120181,74,120233,74,120285,74,120337,74,120389,74,120441,74,42930,74,895,74,1032,74,5035,74,5261,74,42201,74,119844,107,119896,107,119948,107,120000,107,120052,107,120104,107,120156,107,120208,107,120260,107,120312,107,120364,107,120416,107,120468,107,8490,75,65323,75,119818,75,119870,75,119922,75,119974,75,120026,75,120078,75,120130,75,120182,75,120234,75,120286,75,120338,75,120390,75,120442,75,922,75,120497,75,120555,75,120613,75,120671,75,120729,75,11412,75,5094,75,5845,75,42199,75,66840,75,1472,108,8739,73,9213,73,65512,73,1633,108,1777,73,66336,108,125127,108,120783,73,120793,73,120803,73,120813,73,120823,73,130033,73,65321,73,8544,73,8464,73,8465,73,119816,73,119868,73,119920,73,120024,73,120128,73,120180,73,120232,73,120284,73,120336,73,120388,73,120440,73,65356,108,8572,73,8467,108,119845,108,119897,108,119949,108,120001,108,120053,108,120105,73,120157,73,120209,73,120261,73,120313,73,120365,73,120417,73,120469,73,448,73,120496,73,120554,73,120612,73,120670,73,120728,73,11410,73,1030,73,1216,73,1493,108,1503,108,1575,108,126464,108,126592,108,65166,108,65165,108,1994,108,11599,73,5825,73,42226,73,93992,73,66186,124,66313,124,119338,76,8556,76,8466,76,119819,76,119871,76,119923,76,120027,76,120079,76,120131,76,120183,76,120235,76,120287,76,120339,76,120391,76,120443,76,11472,76,5086,76,5290,76,42209,76,93974,76,71843,76,71858,76,66587,76,66854,76,65325,77,8559,77,8499,77,119820,77,119872,77,119924,77,120028,77,120080,77,120132,77,120184,77,120236,77,120288,77,120340,77,120392,77,120444,77,924,77,120499,77,120557,77,120615,77,120673,77,120731,77,1018,77,11416,77,5047,77,5616,77,5846,77,42207,77,66224,77,66321,77,119847,110,119899,110,119951,110,120003,110,120055,110,120107,110,120159,110,120211,110,120263,110,120315,110,120367,110,120419,110,120471,110,1400,110,1404,110,65326,78,8469,78,119821,78,119873,78,119925,78,119977,78,120029,78,120081,78,120185,78,120237,78,120289,78,120341,78,120393,78,120445,78,925,78,120500,78,120558,78,120616,78,120674,78,120732,78,11418,78,42208,78,66835,78,3074,111,3202,111,3330,111,3458,111,2406,111,2662,111,2790,111,3046,111,3174,111,3302,111,3430,111,3664,111,3792,111,4160,111,1637,111,1781,111,65359,111,8500,111,119848,111,119900,111,119952,111,120056,111,120108,111,120160,111,120212,111,120264,111,120316,111,120368,111,120420,111,120472,111,7439,111,7441,111,43837,111,959,111,120528,111,120586,111,120644,111,120702,111,120760,111,963,111,120532,111,120590,111,120648,111,120706,111,120764,111,11423,111,4351,111,1413,111,1505,111,1607,111,126500,111,126564,111,126596,111,65259,111,65260,111,65258,111,65257,111,1726,111,64428,111,64429,111,64427,111,64426,111,1729,111,64424,111,64425,111,64423,111,64422,111,1749,111,3360,111,4125,111,66794,111,71880,111,71895,111,66604,111,1984,79,2534,79,2918,79,12295,79,70864,79,71904,79,120782,79,120792,79,120802,79,120812,79,120822,79,130032,79,65327,79,119822,79,119874,79,119926,79,119978,79,120030,79,120082,79,120134,79,120186,79,120238,79,120290,79,120342,79,120394,79,120446,79,927,79,120502,79,120560,79,120618,79,120676,79,120734,79,11422,79,1365,79,11604,79,4816,79,2848,79,66754,79,42227,79,71861,79,66194,79,66219,79,66564,79,66838,79,9076,112,65360,112,119849,112,119901,112,119953,112,120005,112,120057,112,120109,112,120161,112,120213,112,120265,112,120317,112,120369,112,120421,112,120473,112,961,112,120530,112,120544,112,120588,112,120602,112,120646,112,120660,112,120704,112,120718,112,120762,112,120776,112,11427,112,65328,80,8473,80,119823,80,119875,80,119927,80,119979,80,120031,80,120083,80,120187,80,120239,80,120291,80,120343,80,120395,80,120447,80,929,80,120504,80,120562,80,120620,80,120678,80,120736,80,11426,80,5090,80,5229,80,42193,80,66197,80,119850,113,119902,113,119954,113,120006,113,120058,113,120110,113,120162,113,120214,113,120266,113,120318,113,120370,113,120422,113,120474,113,1307,113,1379,113,1382,113,8474,81,119824,81,119876,81,119928,81,119980,81,120032,81,120084,81,120188,81,120240,81,120292,81,120344,81,120396,81,120448,81,11605,81,119851,114,119903,114,119955,114,120007,114,120059,114,120111,114,120163,114,120215,114,120267,114,120319,114,120371,114,120423,114,120475,114,43847,114,43848,114,7462,114,11397,114,43905,114,119318,82,8475,82,8476,82,8477,82,119825,82,119877,82,119929,82,120033,82,120189,82,120241,82,120293,82,120345,82,120397,82,120449,82,422,82,5025,82,5074,82,66740,82,5511,82,42211,82,94005,82,65363,115,119852,115,119904,115,119956,115,120008,115,120060,115,120112,115,120164,115,120216,115,120268,115,120320,115,120372,115,120424,115,120476,115,42801,115,445,115,1109,115,43946,115,71873,115,66632,115,65331,83,119826,83,119878,83,119930,83,119982,83,120034,83,120086,83,120138,83,120190,83,120242,83,120294,83,120346,83,120398,83,120450,83,1029,83,1359,83,5077,83,5082,83,42210,83,94010,83,66198,83,66592,83,119853,116,119905,116,119957,116,120009,116,120061,116,120113,116,120165,116,120217,116,120269,116,120321,116,120373,116,120425,116,120477,116,8868,84,10201,84,128872,84,65332,84,119827,84,119879,84,119931,84,119983,84,120035,84,120087,84,120139,84,120191,84,120243,84,120295,84,120347,84,120399,84,120451,84,932,84,120507,84,120565,84,120623,84,120681,84,120739,84,11430,84,5026,84,42196,84,93962,84,71868,84,66199,84,66225,84,66325,84,119854,117,119906,117,119958,117,120010,117,120062,117,120114,117,120166,117,120218,117,120270,117,120322,117,120374,117,120426,117,120478,117,42911,117,7452,117,43854,117,43858,117,651,117,965,117,120534,117,120592,117,120650,117,120708,117,120766,117,1405,117,66806,117,71896,117,8746,85,8899,85,119828,85,119880,85,119932,85,119984,85,120036,85,120088,85,120140,85,120192,85,120244,85,120296,85,120348,85,120400,85,120452,85,1357,85,4608,85,66766,85,5196,85,42228,85,94018,85,71864,85,8744,118,8897,118,65366,118,8564,118,119855,118,119907,118,119959,118,120011,118,120063,118,120115,118,120167,118,120219,118,120271,118,120323,118,120375,118,120427,118,120479,118,7456,118,957,118,120526,118,120584,118,120642,118,120700,118,120758,118,1141,118,1496,118,71430,118,43945,118,71872,118,119309,86,1639,86,1783,86,8548,86,119829,86,119881,86,119933,86,119985,86,120037,86,120089,86,120141,86,120193,86,120245,86,120297,86,120349,86,120401,86,120453,86,1140,86,11576,86,5081,86,5167,86,42719,86,42214,86,93960,86,71840,86,66845,86,623,119,119856,119,119908,119,119960,119,120012,119,120064,119,120116,119,120168,119,120220,119,120272,119,120324,119,120376,119,120428,119,120480,119,7457,119,1121,119,1309,119,1377,119,71434,119,71438,119,71439,119,43907,119,71919,87,71910,87,119830,87,119882,87,119934,87,119986,87,120038,87,120090,87,120142,87,120194,87,120246,87,120298,87,120350,87,120402,87,120454,87,1308,87,5043,87,5076,87,42218,87,5742,120,10539,120,10540,120,10799,120,65368,120,8569,120,119857,120,119909,120,119961,120,120013,120,120065,120,120117,120,120169,120,120221,120,120273,120,120325,120,120377,120,120429,120,120481,120,5441,120,5501,120,5741,88,9587,88,66338,88,71916,88,65336,88,8553,88,119831,88,119883,88,119935,88,119987,88,120039,88,120091,88,120143,88,120195,88,120247,88,120299,88,120351,88,120403,88,120455,88,42931,88,935,88,120510,88,120568,88,120626,88,120684,88,120742,88,11436,88,11613,88,5815,88,42219,88,66192,88,66228,88,66327,88,66855,88,611,121,7564,121,65369,121,119858,121,119910,121,119962,121,120014,121,120066,121,120118,121,120170,121,120222,121,120274,121,120326,121,120378,121,120430,121,120482,121,655,121,7935,121,43866,121,947,121,8509,121,120516,121,120574,121,120632,121,120690,121,120748,121,1199,121,4327,121,71900,121,65337,89,119832,89,119884,89,119936,89,119988,89,120040,89,120092,89,120144,89,120196,89,120248,89,120300,89,120352,89,120404,89,120456,89,933,89,978,89,120508,89,120566,89,120624,89,120682,89,120740,89,11432,89,1198,89,5033,89,5053,89,42220,89,94019,89,71844,89,66226,89,119859,122,119911,122,119963,122,120015,122,120067,122,120119,122,120171,122,120223,122,120275,122,120327,122,120379,122,120431,122,120483,122,7458,122,43923,122,71876,122,66293,90,71909,90,65338,90,8484,90,8488,90,119833,90,119885,90,119937,90,119989,90,120041,90,120197,90,120249,90,120301,90,120353,90,120405,90,120457,90,918,90,120493,90,120551,90,120609,90,120667,90,120725,90,5059,90,42204,90,71849,90,65282,34,65284,36,65285,37,65286,38,65290,42,65291,43,65294,46,65295,47,65296,48,65297,49,65298,50,65299,51,65300,52,65301,53,65302,54,65303,55,65304,56,65305,57,65308,60,65309,61,65310,62,65312,64,65316,68,65318,70,65319,71,65324,76,65329,81,65330,82,65333,85,65334,86,65335,87,65343,95,65346,98,65348,100,65350,102,65355,107,65357,109,65358,110,65361,113,65362,114,65364,116,65365,117,65367,119,65370,122,65371,123,65373,125,119846,109],\"_default\":[160,32,8211,45,65374,126,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\"cs\":[65374,126,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\"de\":[65374,126,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\"es\":[8211,45,65374,126,65306,58,65281,33,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\"fr\":[65374,126,65306,58,65281,33,8216,96,8245,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\"it\":[160,32,8211,45,65374,126,65306,58,65281,33,8216,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\"ja\":[8211,45,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65292,44,65307,59],\"ko\":[8211,45,65374,126,65306,58,65281,33,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\"pl\":[65374,126,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\"pt-BR\":[65374,126,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\"qps-ploc\":[160,32,8211,45,65374,126,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\"ru\":[65374,126,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,305,105,921,73,1009,112,215,120,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\"tr\":[160,32,8211,45,65374,126,65306,58,65281,33,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65288,40,65289,41,65292,44,65307,59,65311,63],\"zh-hans\":[65374,126,65306,58,65281,33,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65288,40,65289,41],\"zh-hant\":[8211,45,65374,126,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,73,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89,65283,35,65307,59]}');
        }); }
        static { this.d = new cache_1.$df({ getCacheKey: JSON.stringify }, (locales) => {
            function arrayToMap(arr) {
                const result = new Map();
                for (let i = 0; i < arr.length; i += 2) {
                    result.set(arr[i], arr[i + 1]);
                }
                return result;
            }
            function mergeMaps(map1, map2) {
                const result = new Map(map1);
                for (const [key, value] of map2) {
                    result.set(key, value);
                }
                return result;
            }
            function intersectMaps(map1, map2) {
                if (!map1) {
                    return map2;
                }
                const result = new Map();
                for (const [key, value] of map1) {
                    if (map2.has(key)) {
                        result.set(key, value);
                    }
                }
                return result;
            }
            const data = this.c.value;
            let filteredLocales = locales.filter((l) => !l.startsWith('_') && l in data);
            if (filteredLocales.length === 0) {
                filteredLocales = ['_default'];
            }
            let languageSpecificMap = undefined;
            for (const locale of filteredLocales) {
                const map = arrayToMap(data[locale]);
                languageSpecificMap = intersectMaps(languageSpecificMap, map);
            }
            const commonMap = arrayToMap(data['_common']);
            const map = mergeMaps(commonMap, languageSpecificMap);
            return new $hg(map);
        }); }
        static getInstance(locales) {
            return $hg.d.get(Array.from(locales));
        }
        static { this.e = new lazy_1.$Y(() => Object.keys($hg.c.value).filter((k) => !k.startsWith('_'))); }
        static getLocales() {
            return $hg.e.value;
        }
        constructor(f) {
            this.f = f;
        }
        isAmbiguous(codePoint) {
            return this.f.has(codePoint);
        }
        containsAmbiguousCharacter(str) {
            for (let i = 0; i < str.length; i++) {
                const codePoint = str.codePointAt(i);
                if (typeof codePoint === 'number' && this.isAmbiguous(codePoint)) {
                    return true;
                }
            }
            return false;
        }
        /**
         * Returns the non basic ASCII code point that the given code point can be confused,
         * or undefined if such code point does note exist.
         */
        getPrimaryConfusable(codePoint) {
            return this.f.get(codePoint);
        }
        getConfusableCodePoints() {
            return new Set(this.f.keys());
        }
    }
    exports.$hg = $hg;
    class $ig {
        static c() {
            // Generated using https://github.com/hediet/vscode-unicode-data
            return JSON.parse('[9,10,11,12,13,32,127,160,173,847,1564,4447,4448,6068,6069,6155,6156,6157,6158,7355,7356,8192,8193,8194,8195,8196,8197,8198,8199,8200,8201,8202,8203,8204,8205,8206,8207,8234,8235,8236,8237,8238,8239,8287,8288,8289,8290,8291,8292,8293,8294,8295,8296,8297,8298,8299,8300,8301,8302,8303,10240,12288,12644,65024,65025,65026,65027,65028,65029,65030,65031,65032,65033,65034,65035,65036,65037,65038,65039,65279,65440,65520,65521,65522,65523,65524,65525,65526,65527,65528,65532,78844,119155,119156,119157,119158,119159,119160,119161,119162,917504,917505,917506,917507,917508,917509,917510,917511,917512,917513,917514,917515,917516,917517,917518,917519,917520,917521,917522,917523,917524,917525,917526,917527,917528,917529,917530,917531,917532,917533,917534,917535,917536,917537,917538,917539,917540,917541,917542,917543,917544,917545,917546,917547,917548,917549,917550,917551,917552,917553,917554,917555,917556,917557,917558,917559,917560,917561,917562,917563,917564,917565,917566,917567,917568,917569,917570,917571,917572,917573,917574,917575,917576,917577,917578,917579,917580,917581,917582,917583,917584,917585,917586,917587,917588,917589,917590,917591,917592,917593,917594,917595,917596,917597,917598,917599,917600,917601,917602,917603,917604,917605,917606,917607,917608,917609,917610,917611,917612,917613,917614,917615,917616,917617,917618,917619,917620,917621,917622,917623,917624,917625,917626,917627,917628,917629,917630,917631,917760,917761,917762,917763,917764,917765,917766,917767,917768,917769,917770,917771,917772,917773,917774,917775,917776,917777,917778,917779,917780,917781,917782,917783,917784,917785,917786,917787,917788,917789,917790,917791,917792,917793,917794,917795,917796,917797,917798,917799,917800,917801,917802,917803,917804,917805,917806,917807,917808,917809,917810,917811,917812,917813,917814,917815,917816,917817,917818,917819,917820,917821,917822,917823,917824,917825,917826,917827,917828,917829,917830,917831,917832,917833,917834,917835,917836,917837,917838,917839,917840,917841,917842,917843,917844,917845,917846,917847,917848,917849,917850,917851,917852,917853,917854,917855,917856,917857,917858,917859,917860,917861,917862,917863,917864,917865,917866,917867,917868,917869,917870,917871,917872,917873,917874,917875,917876,917877,917878,917879,917880,917881,917882,917883,917884,917885,917886,917887,917888,917889,917890,917891,917892,917893,917894,917895,917896,917897,917898,917899,917900,917901,917902,917903,917904,917905,917906,917907,917908,917909,917910,917911,917912,917913,917914,917915,917916,917917,917918,917919,917920,917921,917922,917923,917924,917925,917926,917927,917928,917929,917930,917931,917932,917933,917934,917935,917936,917937,917938,917939,917940,917941,917942,917943,917944,917945,917946,917947,917948,917949,917950,917951,917952,917953,917954,917955,917956,917957,917958,917959,917960,917961,917962,917963,917964,917965,917966,917967,917968,917969,917970,917971,917972,917973,917974,917975,917976,917977,917978,917979,917980,917981,917982,917983,917984,917985,917986,917987,917988,917989,917990,917991,917992,917993,917994,917995,917996,917997,917998,917999]');
        }
        static { this.d = undefined; }
        static e() {
            if (!this.d) {
                this.d = new Set($ig.c());
            }
            return this.d;
        }
        static isInvisibleCharacter(codePoint) {
            return $ig.e().has(codePoint);
        }
        static containsInvisibleCharacter(str) {
            for (let i = 0; i < str.length; i++) {
                const codePoint = str.codePointAt(i);
                if (typeof codePoint === 'number' && $ig.isInvisibleCharacter(codePoint)) {
                    return true;
                }
            }
            return false;
        }
        static get codePoints() {
            return $ig.e();
        }
    }
    exports.$ig = $ig;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/























define(__m[55/*vs/base/common/hash*/], __M([0/*require*/,1/*exports*/,11/*vs/base/common/strings*/]), function (require, exports, strings) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$Ej = exports.$Cj = void 0;
    exports.$yj = $yj;
    exports.$zj = $zj;
    exports.$Aj = $Aj;
    exports.$Bj = $Bj;
    exports.$Dj = $Dj;
    strings = __importStar(strings);
    /**
     * Return a hash value for an object.
     */
    function $yj(obj) {
        return $zj(obj, 0);
    }
    function $zj(obj, hashVal) {
        switch (typeof obj) {
            case 'object':
                if (obj === null) {
                    return $Aj(349, hashVal);
                }
                else if (Array.isArray(obj)) {
                    return arrayHash(obj, hashVal);
                }
                return objectHash(obj, hashVal);
            case 'string':
                return $Bj(obj, hashVal);
            case 'boolean':
                return booleanHash(obj, hashVal);
            case 'number':
                return $Aj(obj, hashVal);
            case 'undefined':
                return $Aj(937, hashVal);
            default:
                return $Aj(617, hashVal);
        }
    }
    function $Aj(val, initialHashVal) {
        return (((initialHashVal << 5) - initialHashVal) + val) | 0; // hashVal * 31 + ch, keep as int32
    }
    function booleanHash(b, initialHashVal) {
        return $Aj(b ? 433 : 863, initialHashVal);
    }
    function $Bj(s, hashVal) {
        hashVal = $Aj(149417, hashVal);
        for (let i = 0, length = s.length; i < length; i++) {
            hashVal = $Aj(s.charCodeAt(i), hashVal);
        }
        return hashVal;
    }
    function arrayHash(arr, initialHashVal) {
        initialHashVal = $Aj(104579, initialHashVal);
        return arr.reduce((hashVal, item) => $zj(item, hashVal), initialHashVal);
    }
    function objectHash(obj, initialHashVal) {
        initialHashVal = $Aj(181387, initialHashVal);
        return Object.keys(obj).sort().reduce((hashVal, key) => {
            hashVal = $Bj(key, hashVal);
            return $zj(obj[key], hashVal);
        }, initialHashVal);
    }
    class $Cj {
        constructor() {
            this.g = 0;
        }
        get value() {
            return this.g;
        }
        hash(obj) {
            this.g = $zj(obj, this.g);
            return this.g;
        }
    }
    exports.$Cj = $Cj;
    var SHA1Constant;
    (function (SHA1Constant) {
        SHA1Constant[SHA1Constant["BLOCK_SIZE"] = 64] = "BLOCK_SIZE";
        SHA1Constant[SHA1Constant["UNICODE_REPLACEMENT"] = 65533] = "UNICODE_REPLACEMENT";
    })(SHA1Constant || (SHA1Constant = {}));
    function leftRotate(value, bits, totalBits = 32) {
        // delta + bits = totalBits
        const delta = totalBits - bits;
        // All ones, expect `delta` zeros aligned to the right
        const mask = ~((1 << delta) - 1);
        // Join (value left-shifted `bits` bits) with (masked value right-shifted `delta` bits)
        return ((value << bits) | ((mask & value) >>> delta)) >>> 0;
    }
    function fill(dest, index = 0, count = dest.byteLength, value = 0) {
        for (let i = 0; i < count; i++) {
            dest[index + i] = value;
        }
    }
    function leftPad(value, length, char = '0') {
        while (value.length < length) {
            value = char + value;
        }
        return value;
    }
    function $Dj(bufferOrValue, bitsize = 32) {
        if (bufferOrValue instanceof ArrayBuffer) {
            return Array.from(new Uint8Array(bufferOrValue)).map(b => b.toString(16).padStart(2, '0')).join('');
        }
        return leftPad((bufferOrValue >>> 0).toString(16), bitsize / 4);
    }
    /**
     * A SHA1 implementation that works with strings and does not allocate.
     */
    class $Ej {
        static { this.g = new DataView(new ArrayBuffer(320)); } // 80 * 4 = 320
        constructor() {
            this.h = 0x67452301;
            this.l = 0xEFCDAB89;
            this.m = 0x98BADCFE;
            this.n = 0x10325476;
            this.o = 0xC3D2E1F0;
            this.p = new Uint8Array(SHA1Constant.BLOCK_SIZE + 3 /* to fit any utf-8 */);
            this.q = new DataView(this.p.buffer);
            this.r = 0;
            this.t = 0;
            this.u = 0;
            this.v = false;
        }
        update(str) {
            const strLen = str.length;
            if (strLen === 0) {
                return;
            }
            const buff = this.p;
            let buffLen = this.r;
            let leftoverHighSurrogate = this.u;
            let charCode;
            let offset;
            if (leftoverHighSurrogate !== 0) {
                charCode = leftoverHighSurrogate;
                offset = -1;
                leftoverHighSurrogate = 0;
            }
            else {
                charCode = str.charCodeAt(0);
                offset = 0;
            }
            while (true) {
                let codePoint = charCode;
                if (strings.$Of(charCode)) {
                    if (offset + 1 < strLen) {
                        const nextCharCode = str.charCodeAt(offset + 1);
                        if (strings.$Pf(nextCharCode)) {
                            offset++;
                            codePoint = strings.$Qf(charCode, nextCharCode);
                        }
                        else {
                            // illegal => unicode replacement character
                            codePoint = SHA1Constant.UNICODE_REPLACEMENT;
                        }
                    }
                    else {
                        // last character is a surrogate pair
                        leftoverHighSurrogate = charCode;
                        break;
                    }
                }
                else if (strings.$Pf(charCode)) {
                    // illegal => unicode replacement character
                    codePoint = SHA1Constant.UNICODE_REPLACEMENT;
                }
                buffLen = this.w(buff, buffLen, codePoint);
                offset++;
                if (offset < strLen) {
                    charCode = str.charCodeAt(offset);
                }
                else {
                    break;
                }
            }
            this.r = buffLen;
            this.u = leftoverHighSurrogate;
        }
        w(buff, buffLen, codePoint) {
            if (codePoint < 0x0080) {
                buff[buffLen++] = codePoint;
            }
            else if (codePoint < 0x0800) {
                buff[buffLen++] = 0b11000000 | ((codePoint & 0b00000000000000000000011111000000) >>> 6);
                buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);
            }
            else if (codePoint < 0x10000) {
                buff[buffLen++] = 0b11100000 | ((codePoint & 0b00000000000000001111000000000000) >>> 12);
                buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000111111000000) >>> 6);
                buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);
            }
            else {
                buff[buffLen++] = 0b11110000 | ((codePoint & 0b00000000000111000000000000000000) >>> 18);
                buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000111111000000000000) >>> 12);
                buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000111111000000) >>> 6);
                buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);
            }
            if (buffLen >= SHA1Constant.BLOCK_SIZE) {
                this.y();
                buffLen -= SHA1Constant.BLOCK_SIZE;
                this.t += SHA1Constant.BLOCK_SIZE;
                // take last 3 in case of UTF8 overflow
                buff[0] = buff[SHA1Constant.BLOCK_SIZE + 0];
                buff[1] = buff[SHA1Constant.BLOCK_SIZE + 1];
                buff[2] = buff[SHA1Constant.BLOCK_SIZE + 2];
            }
            return buffLen;
        }
        digest() {
            if (!this.v) {
                this.v = true;
                if (this.u) {
                    // illegal => unicode replacement character
                    this.u = 0;
                    this.r = this.w(this.p, this.r, SHA1Constant.UNICODE_REPLACEMENT);
                }
                this.t += this.r;
                this.x();
            }
            return $Dj(this.h) + $Dj(this.l) + $Dj(this.m) + $Dj(this.n) + $Dj(this.o);
        }
        x() {
            this.p[this.r++] = 0x80;
            fill(this.p, this.r);
            if (this.r > 56) {
                this.y();
                fill(this.p);
            }
            // this will fit because the mantissa can cover up to 52 bits
            const ml = 8 * this.t;
            this.q.setUint32(56, Math.floor(ml / 4294967296), false);
            this.q.setUint32(60, ml % 4294967296, false);
            this.y();
        }
        y() {
            const bigBlock32 = $Ej.g;
            const data = this.q;
            for (let j = 0; j < 64 /* 16*4 */; j += 4) {
                bigBlock32.setUint32(j, data.getUint32(j, false), false);
            }
            for (let j = 64; j < 320 /* 80*4 */; j += 4) {
                bigBlock32.setUint32(j, leftRotate((bigBlock32.getUint32(j - 12, false) ^ bigBlock32.getUint32(j - 32, false) ^ bigBlock32.getUint32(j - 56, false) ^ bigBlock32.getUint32(j - 64, false)), 1), false);
            }
            let a = this.h;
            let b = this.l;
            let c = this.m;
            let d = this.n;
            let e = this.o;
            let f, k;
            let temp;
            for (let j = 0; j < 80; j++) {
                if (j < 20) {
                    f = (b & c) | ((~b) & d);
                    k = 0x5A827999;
                }
                else if (j < 40) {
                    f = b ^ c ^ d;
                    k = 0x6ED9EBA1;
                }
                else if (j < 60) {
                    f = (b & c) | (b & d) | (c & d);
                    k = 0x8F1BBCDC;
                }
                else {
                    f = b ^ c ^ d;
                    k = 0xCA62C1D6;
                }
                temp = (leftRotate(a, 5) + f + e + k + bigBlock32.getUint32(j * 4, false)) & 0xffffffff;
                e = d;
                d = c;
                c = leftRotate(b, 30);
                b = a;
                a = temp;
            }
            this.h = (this.h + a) & 0xffffffff;
            this.l = (this.l + b) & 0xffffffff;
            this.m = (this.m + c) & 0xffffffff;
            this.n = (this.n + d) & 0xffffffff;
            this.o = (this.o + e) & 0xffffffff;
        }
    }
    exports.$Ej = $Ej;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[56/*vs/base/common/ternarySearchTree*/], __M([0/*require*/,1/*exports*/,17/*vs/base/common/arrays*/,13/*vs/base/common/charCode*/,11/*vs/base/common/strings*/]), function (require, exports, arrays_1, charCode_1, strings_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$Qi = exports.$Pi = exports.$Oi = exports.$Ni = exports.$Mi = void 0;
    class $Mi {
        constructor() {
            this.b = '';
            this.c = 0;
        }
        reset(key) {
            this.b = key;
            this.c = 0;
            return this;
        }
        next() {
            this.c += 1;
            return this;
        }
        hasNext() {
            return this.c < this.b.length - 1;
        }
        cmp(a) {
            const aCode = a.charCodeAt(0);
            const thisCode = this.b.charCodeAt(this.c);
            return aCode - thisCode;
        }
        value() {
            return this.b[this.c];
        }
    }
    exports.$Mi = $Mi;
    class $Ni {
        constructor(e = true) {
            this.e = e;
        }
        reset(key) {
            this.b = key;
            this.c = 0;
            this.d = 0;
            return this.next();
        }
        hasNext() {
            return this.d < this.b.length;
        }
        next() {
            // this._data = key.split(/[\\/]/).filter(s => !!s);
            this.c = this.d;
            let justSeps = true;
            for (; this.d < this.b.length; this.d++) {
                const ch = this.b.charCodeAt(this.d);
                if (ch === charCode_1.CharCode.Period) {
                    if (justSeps) {
                        this.c++;
                    }
                    else {
                        break;
                    }
                }
                else {
                    justSeps = false;
                }
            }
            return this;
        }
        cmp(a) {
            return this.e
                ? (0, strings_1.$Ef)(a, this.b, 0, a.length, this.c, this.d)
                : (0, strings_1.$Gf)(a, this.b, 0, a.length, this.c, this.d);
        }
        value() {
            return this.b.substring(this.c, this.d);
        }
    }
    exports.$Ni = $Ni;
    class $Oi {
        constructor(f = true, g = true) {
            this.f = f;
            this.g = g;
        }
        reset(key) {
            this.d = 0;
            this.e = 0;
            this.b = key;
            this.c = key.length;
            for (let pos = key.length - 1; pos >= 0; pos--, this.c--) {
                const ch = this.b.charCodeAt(pos);
                if (!(ch === charCode_1.CharCode.Slash || this.f && ch === charCode_1.CharCode.Backslash)) {
                    break;
                }
            }
            return this.next();
        }
        hasNext() {
            return this.e < this.c;
        }
        next() {
            // this._data = key.split(/[\\/]/).filter(s => !!s);
            this.d = this.e;
            let justSeps = true;
            for (; this.e < this.c; this.e++) {
                const ch = this.b.charCodeAt(this.e);
                if (ch === charCode_1.CharCode.Slash || this.f && ch === charCode_1.CharCode.Backslash) {
                    if (justSeps) {
                        this.d++;
                    }
                    else {
                        break;
                    }
                }
                else {
                    justSeps = false;
                }
            }
            return this;
        }
        cmp(a) {
            return this.g
                ? (0, strings_1.$Ef)(a, this.b, 0, a.length, this.d, this.e)
                : (0, strings_1.$Gf)(a, this.b, 0, a.length, this.d, this.e);
        }
        value() {
            return this.b.substring(this.d, this.e);
        }
    }
    exports.$Oi = $Oi;
    var UriIteratorState;
    (function (UriIteratorState) {
        UriIteratorState[UriIteratorState["Scheme"] = 1] = "Scheme";
        UriIteratorState[UriIteratorState["Authority"] = 2] = "Authority";
        UriIteratorState[UriIteratorState["Path"] = 3] = "Path";
        UriIteratorState[UriIteratorState["Query"] = 4] = "Query";
        UriIteratorState[UriIteratorState["Fragment"] = 5] = "Fragment";
    })(UriIteratorState || (UriIteratorState = {}));
    class $Pi {
        constructor(f, g) {
            this.f = f;
            this.g = g;
            this.d = [];
            this.e = 0;
        }
        reset(key) {
            this.c = key;
            this.d = [];
            if (this.c.scheme) {
                this.d.push(UriIteratorState.Scheme);
            }
            if (this.c.authority) {
                this.d.push(UriIteratorState.Authority);
            }
            if (this.c.path) {
                this.b = new $Oi(false, !this.f(key));
                this.b.reset(key.path);
                if (this.b.value()) {
                    this.d.push(UriIteratorState.Path);
                }
            }
            if (!this.g(key)) {
                if (this.c.query) {
                    this.d.push(UriIteratorState.Query);
                }
                if (this.c.fragment) {
                    this.d.push(UriIteratorState.Fragment);
                }
            }
            this.e = 0;
            return this;
        }
        next() {
            if (this.d[this.e] === UriIteratorState.Path && this.b.hasNext()) {
                this.b.next();
            }
            else {
                this.e += 1;
            }
            return this;
        }
        hasNext() {
            return (this.d[this.e] === UriIteratorState.Path && this.b.hasNext())
                || this.e < this.d.length - 1;
        }
        cmp(a) {
            if (this.d[this.e] === UriIteratorState.Scheme) {
                return (0, strings_1.$Ff)(a, this.c.scheme);
            }
            else if (this.d[this.e] === UriIteratorState.Authority) {
                return (0, strings_1.$Ff)(a, this.c.authority);
            }
            else if (this.d[this.e] === UriIteratorState.Path) {
                return this.b.cmp(a);
            }
            else if (this.d[this.e] === UriIteratorState.Query) {
                return (0, strings_1.$Df)(a, this.c.query);
            }
            else if (this.d[this.e] === UriIteratorState.Fragment) {
                return (0, strings_1.$Df)(a, this.c.fragment);
            }
            throw new Error();
        }
        value() {
            if (this.d[this.e] === UriIteratorState.Scheme) {
                return this.c.scheme;
            }
            else if (this.d[this.e] === UriIteratorState.Authority) {
                return this.c.authority;
            }
            else if (this.d[this.e] === UriIteratorState.Path) {
                return this.b.value();
            }
            else if (this.d[this.e] === UriIteratorState.Query) {
                return this.c.query;
            }
            else if (this.d[this.e] === UriIteratorState.Fragment) {
                return this.c.fragment;
            }
            throw new Error();
        }
    }
    exports.$Pi = $Pi;
    class TernarySearchTreeNode {
        constructor() {
            this.height = 1;
        }
        isEmpty() {
            return !this.left && !this.mid && !this.right && !this.value;
        }
        rotateLeft() {
            const tmp = this.right;
            this.right = tmp.left;
            tmp.left = this;
            this.updateHeight();
            tmp.updateHeight();
            return tmp;
        }
        rotateRight() {
            const tmp = this.left;
            this.left = tmp.right;
            tmp.right = this;
            this.updateHeight();
            tmp.updateHeight();
            return tmp;
        }
        updateHeight() {
            this.height = 1 + Math.max(this.heightLeft, this.heightRight);
        }
        balanceFactor() {
            return this.heightRight - this.heightLeft;
        }
        get heightLeft() {
            return this.left?.height ?? 0;
        }
        get heightRight() {
            return this.right?.height ?? 0;
        }
    }
    var Dir;
    (function (Dir) {
        Dir[Dir["Left"] = -1] = "Left";
        Dir[Dir["Mid"] = 0] = "Mid";
        Dir[Dir["Right"] = 1] = "Right";
    })(Dir || (Dir = {}));
    class $Qi {
        static forUris(ignorePathCasing = () => false, ignoreQueryAndFragment = () => false) {
            return new $Qi(new $Pi(ignorePathCasing, ignoreQueryAndFragment));
        }
        static forPaths(ignorePathCasing = false) {
            return new $Qi(new $Oi(undefined, !ignorePathCasing));
        }
        static forStrings() {
            return new $Qi(new $Mi());
        }
        static forConfigKeys() {
            return new $Qi(new $Ni());
        }
        constructor(segments) {
            this.b = segments;
        }
        clear() {
            this.c = undefined;
        }
        fill(values, keys) {
            if (keys) {
                const arr = keys.slice(0);
                (0, arrays_1.$1b)(arr);
                for (const k of arr) {
                    this.set(k, values);
                }
            }
            else {
                const arr = values.slice(0);
                (0, arrays_1.$1b)(arr);
                for (const entry of arr) {
                    this.set(entry[0], entry[1]);
                }
            }
        }
        set(key, element) {
            const iter = this.b.reset(key);
            let node;
            if (!this.c) {
                this.c = new TernarySearchTreeNode();
                this.c.segment = iter.value();
            }
            const stack = [];
            // find insert_node
            node = this.c;
            while (true) {
                const val = iter.cmp(node.segment);
                if (val > 0) {
                    // left
                    if (!node.left) {
                        node.left = new TernarySearchTreeNode();
                        node.left.segment = iter.value();
                    }
                    stack.push([Dir.Left, node]);
                    node = node.left;
                }
                else if (val < 0) {
                    // right
                    if (!node.right) {
                        node.right = new TernarySearchTreeNode();
                        node.right.segment = iter.value();
                    }
                    stack.push([Dir.Right, node]);
                    node = node.right;
                }
                else if (iter.hasNext()) {
                    // mid
                    iter.next();
                    if (!node.mid) {
                        node.mid = new TernarySearchTreeNode();
                        node.mid.segment = iter.value();
                    }
                    stack.push([Dir.Mid, node]);
                    node = node.mid;
                }
                else {
                    break;
                }
            }
            // set value
            const oldElement = node.value;
            node.value = element;
            node.key = key;
            // balance
            for (let i = stack.length - 1; i >= 0; i--) {
                const node = stack[i][1];
                node.updateHeight();
                const bf = node.balanceFactor();
                if (bf < -1 || bf > 1) {
                    // needs rotate
                    const d1 = stack[i][0];
                    const d2 = stack[i + 1][0];
                    if (d1 === Dir.Right && d2 === Dir.Right) {
                        //right, right -> rotate left
                        stack[i][1] = node.rotateLeft();
                    }
                    else if (d1 === Dir.Left && d2 === Dir.Left) {
                        // left, left -> rotate right
                        stack[i][1] = node.rotateRight();
                    }
                    else if (d1 === Dir.Right && d2 === Dir.Left) {
                        // right, left -> double rotate right, left
                        node.right = stack[i + 1][1] = stack[i + 1][1].rotateRight();
                        stack[i][1] = node.rotateLeft();
                    }
                    else if (d1 === Dir.Left && d2 === Dir.Right) {
                        // left, right -> double rotate left, right
                        node.left = stack[i + 1][1] = stack[i + 1][1].rotateLeft();
                        stack[i][1] = node.rotateRight();
                    }
                    else {
                        throw new Error();
                    }
                    // patch path to parent
                    if (i > 0) {
                        switch (stack[i - 1][0]) {
                            case Dir.Left:
                                stack[i - 1][1].left = stack[i][1];
                                break;
                            case Dir.Right:
                                stack[i - 1][1].right = stack[i][1];
                                break;
                            case Dir.Mid:
                                stack[i - 1][1].mid = stack[i][1];
                                break;
                        }
                    }
                    else {
                        this.c = stack[0][1];
                    }
                }
            }
            return oldElement;
        }
        get(key) {
            return this.d(key)?.value;
        }
        d(key) {
            const iter = this.b.reset(key);
            let node = this.c;
            while (node) {
                const val = iter.cmp(node.segment);
                if (val > 0) {
                    // left
                    node = node.left;
                }
                else if (val < 0) {
                    // right
                    node = node.right;
                }
                else if (iter.hasNext()) {
                    // mid
                    iter.next();
                    node = node.mid;
                }
                else {
                    break;
                }
            }
            return node;
        }
        has(key) {
            const node = this.d(key);
            return !(node?.value === undefined && node?.mid === undefined);
        }
        delete(key) {
            return this.e(key, false);
        }
        deleteSuperstr(key) {
            return this.e(key, true);
        }
        e(key, superStr) {
            const iter = this.b.reset(key);
            const stack = [];
            let node = this.c;
            // find node
            while (node) {
                const val = iter.cmp(node.segment);
                if (val > 0) {
                    // left
                    stack.push([Dir.Left, node]);
                    node = node.left;
                }
                else if (val < 0) {
                    // right
                    stack.push([Dir.Right, node]);
                    node = node.right;
                }
                else if (iter.hasNext()) {
                    // mid
                    iter.next();
                    stack.push([Dir.Mid, node]);
                    node = node.mid;
                }
                else {
                    break;
                }
            }
            if (!node) {
                // node not found
                return;
            }
            if (superStr) {
                // removing children, reset height
                node.left = undefined;
                node.mid = undefined;
                node.right = undefined;
                node.height = 1;
            }
            else {
                // removing element
                node.key = undefined;
                node.value = undefined;
            }
            // BST node removal
            if (!node.mid && !node.value) {
                if (node.left && node.right) {
                    // full node
                    // replace deleted-node with the min-node of the right branch.
                    // If there is no true min-node leave things as they are
                    const min = this.f(node.right);
                    if (min.key) {
                        const { key, value, segment } = min;
                        this.e(min.key, false);
                        node.key = key;
                        node.value = value;
                        node.segment = segment;
                    }
                }
                else {
                    // empty or half empty
                    const newChild = node.left ?? node.right;
                    if (stack.length > 0) {
                        const [dir, parent] = stack[stack.length - 1];
                        switch (dir) {
                            case Dir.Left:
                                parent.left = newChild;
                                break;
                            case Dir.Mid:
                                parent.mid = newChild;
                                break;
                            case Dir.Right:
                                parent.right = newChild;
                                break;
                        }
                    }
                    else {
                        this.c = newChild;
                    }
                }
            }
            // AVL balance
            for (let i = stack.length - 1; i >= 0; i--) {
                const node = stack[i][1];
                node.updateHeight();
                const bf = node.balanceFactor();
                if (bf > 1) {
                    // right heavy
                    if (node.right.balanceFactor() >= 0) {
                        // right, right -> rotate left
                        stack[i][1] = node.rotateLeft();
                    }
                    else {
                        // right, left -> double rotate
                        node.right = node.right.rotateRight();
                        stack[i][1] = node.rotateLeft();
                    }
                }
                else if (bf < -1) {
                    // left heavy
                    if (node.left.balanceFactor() <= 0) {
                        // left, left -> rotate right
                        stack[i][1] = node.rotateRight();
                    }
                    else {
                        // left, right -> double rotate
                        node.left = node.left.rotateLeft();
                        stack[i][1] = node.rotateRight();
                    }
                }
                // patch path to parent
                if (i > 0) {
                    switch (stack[i - 1][0]) {
                        case Dir.Left:
                            stack[i - 1][1].left = stack[i][1];
                            break;
                        case Dir.Right:
                            stack[i - 1][1].right = stack[i][1];
                            break;
                        case Dir.Mid:
                            stack[i - 1][1].mid = stack[i][1];
                            break;
                    }
                }
                else {
                    this.c = stack[0][1];
                }
            }
        }
        f(node) {
            while (node.left) {
                node = node.left;
            }
            return node;
        }
        findSubstr(key) {
            const iter = this.b.reset(key);
            let node = this.c;
            let candidate = undefined;
            while (node) {
                const val = iter.cmp(node.segment);
                if (val > 0) {
                    // left
                    node = node.left;
                }
                else if (val < 0) {
                    // right
                    node = node.right;
                }
                else if (iter.hasNext()) {
                    // mid
                    iter.next();
                    candidate = node.value || candidate;
                    node = node.mid;
                }
                else {
                    break;
                }
            }
            return node && node.value || candidate;
        }
        findSuperstr(key) {
            return this.g(key, false);
        }
        g(key, allowValue) {
            const iter = this.b.reset(key);
            let node = this.c;
            while (node) {
                const val = iter.cmp(node.segment);
                if (val > 0) {
                    // left
                    node = node.left;
                }
                else if (val < 0) {
                    // right
                    node = node.right;
                }
                else if (iter.hasNext()) {
                    // mid
                    iter.next();
                    node = node.mid;
                }
                else {
                    // collect
                    if (!node.mid) {
                        if (allowValue) {
                            return node.value;
                        }
                        else {
                            return undefined;
                        }
                    }
                    else {
                        return this.h(node.mid);
                    }
                }
            }
            return undefined;
        }
        hasElementOrSubtree(key) {
            return this.g(key, true) !== undefined;
        }
        forEach(callback) {
            for (const [key, value] of this) {
                callback(value, key);
            }
        }
        *[Symbol.iterator]() {
            yield* this.h(this.c);
        }
        h(node) {
            const result = [];
            this.j(node, result);
            return result[Symbol.iterator]();
        }
        j(node, bucket) {
            // DFS
            if (!node) {
                return;
            }
            if (node.left) {
                this.j(node.left, bucket);
            }
            if (node.value) {
                bucket.push([node.key, node.value]);
            }
            if (node.mid) {
                this.j(node.mid, bucket);
            }
            if (node.right) {
                this.j(node.right, bucket);
            }
        }
        // for debug/testing
        _isBalanced() {
            const nodeIsBalanced = (node) => {
                if (!node) {
                    return true;
                }
                const bf = node.balanceFactor();
                if (bf < -1 || bf > 1) {
                    return false;
                }
                return nodeIsBalanced(node.left) && nodeIsBalanced(node.right);
            };
            return nodeIsBalanced(this.c);
        }
    }
    exports.$Qi = $Qi;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[57/*vs/base/common/uuid*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$7g = void 0;
    exports.$6g = $6g;
    const _UUIDPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
    function $6g(value) {
        return _UUIDPattern.test(value);
    }
    exports.$7g = (function () {
        // use `randomUUID` if possible
        if (typeof crypto === 'object' && typeof crypto.randomUUID === 'function') {
            return crypto.randomUUID.bind(crypto);
        }
        // use `randomValues` if possible
        let getRandomValues;
        if (typeof crypto === 'object' && typeof crypto.getRandomValues === 'function') {
            getRandomValues = crypto.getRandomValues.bind(crypto);
        }
        else {
            getRandomValues = function (bucket) {
                for (let i = 0; i < bucket.length; i++) {
                    bucket[i] = Math.floor(Math.random() * 256);
                }
                return bucket;
            };
        }
        // prep-work
        const _data = new Uint8Array(16);
        const _hex = [];
        for (let i = 0; i < 256; i++) {
            _hex.push(i.toString(16).padStart(2, '0'));
        }
        return function generateUuid() {
            // get data
            getRandomValues(_data);
            // set version bits
            _data[6] = (_data[6] & 0x0f) | 0x40;
            _data[8] = (_data[8] & 0x3f) | 0x80;
            // print as string
            let i = 0;
            let result = '';
            result += _hex[_data[i++]];
            result += _hex[_data[i++]];
            result += _hex[_data[i++]];
            result += _hex[_data[i++]];
            result += '-';
            result += _hex[_data[i++]];
            result += _hex[_data[i++]];
            result += '-';
            result += _hex[_data[i++]];
            result += _hex[_data[i++]];
            result += '-';
            result += _hex[_data[i++]];
            result += _hex[_data[i++]];
            result += '-';
            result += _hex[_data[i++]];
            result += _hex[_data[i++]];
            result += _hex[_data[i++]];
            result += _hex[_data[i++]];
            result += _hex[_data[i++]];
            result += _hex[_data[i++]];
            return result;
        };
    })();
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[33/*vs/base/parts/sandbox/node/electronTypes*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$QY = $QY;
    function $QY(process) {
        return !!process.parentPort;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[34/*vs/nls.messages*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$a = $a;
    exports.$b = $b;
    /*
     * This module exists so that the AMD build of the monaco editor can replace this with an async loader plugin.
     * If you add new functions to this module make sure that they are also provided in the AMD build of the monaco editor.
     */
    function $a() {
        return globalThis._VSCODE_NLS_MESSAGES;
    }
    function $b() {
        return globalThis._VSCODE_NLS_LANGUAGE;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[8/*vs/nls*/], __M([0/*require*/,1/*exports*/,34/*vs/nls.messages*/,34/*vs/nls.messages*/]), function (require, exports, nls_messages_1, nls_messages_2) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.getNLSMessages = exports.getNLSLanguage = void 0;
    exports.localize = localize;
    exports.localize2 = localize2;
    Object.defineProperty(exports, "getNLSLanguage", { enumerable: true, get: function () { return nls_messages_2.$b; } });
    Object.defineProperty(exports, "getNLSMessages", { enumerable: true, get: function () { return nls_messages_2.$a; } });
    const isPseudo = (0, nls_messages_1.$b)() === 'pseudo' || (typeof document !== 'undefined' && document.location && document.location.hash.indexOf('pseudo=true') >= 0);
    function _format(message, args) {
        let result;
        if (args.length === 0) {
            result = message;
        }
        else {
            result = message.replace(/\{(\d+)\}/g, (match, rest) => {
                const index = rest[0];
                const arg = args[index];
                let result = match;
                if (typeof arg === 'string') {
                    result = arg;
                }
                else if (typeof arg === 'number' || typeof arg === 'boolean' || arg === void 0 || arg === null) {
                    result = String(arg);
                }
                return result;
            });
        }
        if (isPseudo) {
            // FF3B and FF3D is the Unicode zenkaku representation for [ and ]
            result = '\uFF3B' + result.replace(/[aouei]/g, '$&$&') + '\uFF3D';
        }
        return result;
    }
    /**
     * @skipMangle
     */
    function localize(data /* | number when built */, message /* | null when built */, ...args) {
        if (typeof data === 'number') {
            return _format(lookupMessage(data, message), args);
        }
        return _format(message, args);
    }
    /**
     * Only used when built: Looks up the message in the global NLS table.
     * This table is being made available as a global through bootstrapping
     * depending on the target context.
     */
    function lookupMessage(index, fallback) {
        const message = (0, nls_messages_1.$a)()?.[index];
        if (typeof message !== 'string') {
            if (typeof fallback === 'string') {
                return fallback;
            }
            throw new Error(`!!! NLS MISSING: ${index} !!!`);
        }
        return message;
    }
    /**
     * @skipMangle
     */
    function localize2(data /* | number when built */, originalMessage, ...args) {
        let message;
        if (typeof data === 'number') {
            message = lookupMessage(data, originalMessage);
        }
        else {
            message = originalMessage;
        }
        const value = _format(message, args);
        return {
            value,
            original: originalMessage === message ? value : _format(originalMessage, args)
        };
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[58/*vs/base/common/date*/], __M([0/*require*/,1/*exports*/,8/*vs/nls*/]), function (require, exports, nls_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$7m = $7m;
    exports.$8m = $8m;
    exports.$9m = $9m;
    exports.$0m = $0m;
    const minute = 60;
    const hour = minute * 60;
    const day = hour * 24;
    const week = day * 7;
    const month = day * 30;
    const year = day * 365;
    /**
     * Create a localized difference of the time between now and the specified date.
     * @param date The date to generate the difference from.
     * @param appendAgoLabel Whether to append the " ago" to the end.
     * @param useFullTimeWords Whether to use full words (eg. seconds) instead of
     * shortened (eg. secs).
     * @param disallowNow Whether to disallow the string "now" when the difference
     * is less than 30 seconds.
     */
    function $7m(date, appendAgoLabel, useFullTimeWords, disallowNow) {
        if (typeof date !== 'number') {
            date = date.getTime();
        }
        const seconds = Math.round((new Date().getTime() - date) / 1000);
        if (seconds < -30) {
            return (0, nls_1.localize)(42, null, $7m(new Date().getTime() + seconds * 1000, false));
        }
        if (!disallowNow && seconds < 30) {
            return (0, nls_1.localize)(43, null);
        }
        let value;
        if (seconds < minute) {
            value = seconds;
            if (appendAgoLabel) {
                if (value === 1) {
                    return useFullTimeWords
                        ? (0, nls_1.localize)(44, null, value)
                        : (0, nls_1.localize)(45, null, value);
                }
                else {
                    return useFullTimeWords
                        ? (0, nls_1.localize)(46, null, value)
                        : (0, nls_1.localize)(47, null, value);
                }
            }
            else {
                if (value === 1) {
                    return useFullTimeWords
                        ? (0, nls_1.localize)(48, null, value)
                        : (0, nls_1.localize)(49, null, value);
                }
                else {
                    return useFullTimeWords
                        ? (0, nls_1.localize)(50, null, value)
                        : (0, nls_1.localize)(51, null, value);
                }
            }
        }
        if (seconds < hour) {
            value = Math.floor(seconds / minute);
            if (appendAgoLabel) {
                if (value === 1) {
                    return useFullTimeWords
                        ? (0, nls_1.localize)(52, null, value)
                        : (0, nls_1.localize)(53, null, value);
                }
                else {
                    return useFullTimeWords
                        ? (0, nls_1.localize)(54, null, value)
                        : (0, nls_1.localize)(55, null, value);
                }
            }
            else {
                if (value === 1) {
                    return useFullTimeWords
                        ? (0, nls_1.localize)(56, null, value)
                        : (0, nls_1.localize)(57, null, value);
                }
                else {
                    return useFullTimeWords
                        ? (0, nls_1.localize)(58, null, value)
                        : (0, nls_1.localize)(59, null, value);
                }
            }
        }
        if (seconds < day) {
            value = Math.floor(seconds / hour);
            if (appendAgoLabel) {
                if (value === 1) {
                    return useFullTimeWords
                        ? (0, nls_1.localize)(60, null, value)
                        : (0, nls_1.localize)(61, null, value);
                }
                else {
                    return useFullTimeWords
                        ? (0, nls_1.localize)(62, null, value)
                        : (0, nls_1.localize)(63, null, value);
                }
            }
            else {
                if (value === 1) {
                    return useFullTimeWords
                        ? (0, nls_1.localize)(64, null, value)
                        : (0, nls_1.localize)(65, null, value);
                }
                else {
                    return useFullTimeWords
                        ? (0, nls_1.localize)(66, null, value)
                        : (0, nls_1.localize)(67, null, value);
                }
            }
        }
        if (seconds < week) {
            value = Math.floor(seconds / day);
            if (appendAgoLabel) {
                return value === 1
                    ? (0, nls_1.localize)(68, null, value)
                    : (0, nls_1.localize)(69, null, value);
            }
            else {
                return value === 1
                    ? (0, nls_1.localize)(70, null, value)
                    : (0, nls_1.localize)(71, null, value);
            }
        }
        if (seconds < month) {
            value = Math.floor(seconds / week);
            if (appendAgoLabel) {
                if (value === 1) {
                    return useFullTimeWords
                        ? (0, nls_1.localize)(72, null, value)
                        : (0, nls_1.localize)(73, null, value);
                }
                else {
                    return useFullTimeWords
                        ? (0, nls_1.localize)(74, null, value)
                        : (0, nls_1.localize)(75, null, value);
                }
            }
            else {
                if (value === 1) {
                    return useFullTimeWords
                        ? (0, nls_1.localize)(76, null, value)
                        : (0, nls_1.localize)(77, null, value);
                }
                else {
                    return useFullTimeWords
                        ? (0, nls_1.localize)(78, null, value)
                        : (0, nls_1.localize)(79, null, value);
                }
            }
        }
        if (seconds < year) {
            value = Math.floor(seconds / month);
            if (appendAgoLabel) {
                if (value === 1) {
                    return useFullTimeWords
                        ? (0, nls_1.localize)(80, null, value)
                        : (0, nls_1.localize)(81, null, value);
                }
                else {
                    return useFullTimeWords
                        ? (0, nls_1.localize)(82, null, value)
                        : (0, nls_1.localize)(83, null, value);
                }
            }
            else {
                if (value === 1) {
                    return useFullTimeWords
                        ? (0, nls_1.localize)(84, null, value)
                        : (0, nls_1.localize)(85, null, value);
                }
                else {
                    return useFullTimeWords
                        ? (0, nls_1.localize)(86, null, value)
                        : (0, nls_1.localize)(87, null, value);
                }
            }
        }
        value = Math.floor(seconds / year);
        if (appendAgoLabel) {
            if (value === 1) {
                return useFullTimeWords
                    ? (0, nls_1.localize)(88, null, value)
                    : (0, nls_1.localize)(89, null, value);
            }
            else {
                return useFullTimeWords
                    ? (0, nls_1.localize)(90, null, value)
                    : (0, nls_1.localize)(91, null, value);
            }
        }
        else {
            if (value === 1) {
                return useFullTimeWords
                    ? (0, nls_1.localize)(92, null, value)
                    : (0, nls_1.localize)(93, null, value);
            }
            else {
                return useFullTimeWords
                    ? (0, nls_1.localize)(94, null, value)
                    : (0, nls_1.localize)(95, null, value);
            }
        }
    }
    function $8m(date, appendAgoLabel, useFullTimeWords) {
        if (typeof date !== 'number') {
            date = date.getTime();
        }
        const todayMidnightTime = new Date();
        todayMidnightTime.setHours(0, 0, 0, 0);
        const yesterdayMidnightTime = new Date(todayMidnightTime.getTime());
        yesterdayMidnightTime.setDate(yesterdayMidnightTime.getDate() - 1);
        if (date > todayMidnightTime.getTime()) {
            return (0, nls_1.localize)(96, null);
        }
        if (date > yesterdayMidnightTime.getTime()) {
            return (0, nls_1.localize)(97, null);
        }
        return $7m(date, appendAgoLabel, useFullTimeWords);
    }
    /**
     * Gets a readable duration with intelligent/lossy precision. For example "40ms" or "3.040s")
     * @param ms The duration to get in milliseconds.
     * @param useFullTimeWords Whether to use full words (eg. seconds) instead of
     * shortened (eg. secs).
     */
    function $9m(ms, useFullTimeWords) {
        const seconds = Math.abs(ms / 1000);
        if (seconds < 1) {
            return useFullTimeWords
                ? (0, nls_1.localize)(98, null, ms)
                : (0, nls_1.localize)(99, null, ms);
        }
        if (seconds < minute) {
            return useFullTimeWords
                ? (0, nls_1.localize)(100, null, Math.round(ms) / 1000)
                : (0, nls_1.localize)(101, null, Math.round(ms) / 1000);
        }
        if (seconds < hour) {
            return useFullTimeWords
                ? (0, nls_1.localize)(102, null, Math.round(ms / (1000 * minute)))
                : (0, nls_1.localize)(103, null, Math.round(ms / (1000 * minute)));
        }
        if (seconds < day) {
            return useFullTimeWords
                ? (0, nls_1.localize)(104, null, Math.round(ms / (1000 * hour)))
                : (0, nls_1.localize)(105, null, Math.round(ms / (1000 * hour)));
        }
        return (0, nls_1.localize)(106, null, Math.round(ms / (1000 * day)));
    }
    function $0m(date) {
        return date.getFullYear() +
            '-' + String(date.getMonth() + 1).padStart(2, '0') +
            '-' + String(date.getDate()).padStart(2, '0') +
            'T' + String(date.getHours()).padStart(2, '0') +
            ':' + String(date.getMinutes()).padStart(2, '0') +
            ':' + String(date.getSeconds()).padStart(2, '0') +
            '.' + (date.getMilliseconds() / 1000).toFixed(3).slice(2, 5) +
            'Z';
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/























define(__m[59/*vs/base/common/errorMessage*/], __M([0/*require*/,1/*exports*/,17/*vs/base/common/arrays*/,10/*vs/base/common/types*/,8/*vs/nls*/]), function (require, exports, arrays, types, nls) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$vj = $vj;
    exports.$wj = $wj;
    exports.$xj = $xj;
    arrays = __importStar(arrays);
    types = __importStar(types);
    nls = __importStar(nls);
    function exceptionToErrorMessage(exception, verbose) {
        if (verbose && (exception.stack || exception.stacktrace)) {
            return nls.localize(107, null, detectSystemErrorMessage(exception), stackToString(exception.stack) || stackToString(exception.stacktrace));
        }
        return detectSystemErrorMessage(exception);
    }
    function stackToString(stack) {
        if (Array.isArray(stack)) {
            return stack.join('\n');
        }
        return stack;
    }
    function detectSystemErrorMessage(exception) {
        // Custom node.js error from us
        if (exception.code === 'ERR_UNC_HOST_NOT_ALLOWED') {
            return `${exception.message}. Please update the 'security.allowedUNCHosts' setting if you want to allow this host.`;
        }
        // See https://nodejs.org/api/errors.html#errors_class_system_error
        if (typeof exception.code === 'string' && typeof exception.errno === 'number' && typeof exception.syscall === 'string') {
            return nls.localize(108, null, exception.message);
        }
        return exception.message || nls.localize(109, null);
    }
    /**
     * Tries to generate a human readable error message out of the error. If the verbose parameter
     * is set to true, the error message will include stacktrace details if provided.
     *
     * @returns A string containing the error message.
     */
    function $vj(error = null, verbose = false) {
        if (!error) {
            return nls.localize(110, null);
        }
        if (Array.isArray(error)) {
            const errors = arrays.$Lb(error);
            const msg = $vj(errors[0], verbose);
            if (errors.length > 1) {
                return nls.localize(111, null, msg, errors.length);
            }
            return msg;
        }
        if (types.$jg(error)) {
            return error;
        }
        if (error.detail) {
            const detail = error.detail;
            if (detail.error) {
                return exceptionToErrorMessage(detail.error, verbose);
            }
            if (detail.exception) {
                return exceptionToErrorMessage(detail.exception, verbose);
            }
        }
        if (error.stack) {
            return exceptionToErrorMessage(error, verbose);
        }
        if (error.message) {
            return error.message;
        }
        return nls.localize(112, null);
    }
    function $wj(obj) {
        const candidate = obj;
        return candidate instanceof Error && Array.isArray(candidate.actions);
    }
    function $xj(messageOrError, actions) {
        let error;
        if (typeof messageOrError === 'string') {
            error = new Error(messageOrError);
        }
        else {
            error = messageOrError;
        }
        error.actions = actions;
        return error;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/























define(__m[3/*vs/base/common/platform*/], __M([0/*require*/,1/*exports*/,8/*vs/nls*/]), function (require, exports, nls) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$L = exports.$K = exports.$J = exports.$I = exports.$H = exports.OS = exports.OperatingSystem = exports.$E = exports.$D = exports.$C = exports.$B = exports.$A = exports.Language = exports.$z = exports.$y = exports.$x = exports.$w = exports.$v = exports.$u = exports.$t = exports.$s = exports.$r = exports.$q = exports.$p = exports.$o = exports.$n = exports.$m = exports.$l = exports.Platform = exports.$j = void 0;
    exports.$k = $k;
    exports.$G = $G;
    exports.$M = $M;
    nls = __importStar(nls);
    exports.$j = 'en';
    let _isWindows = false;
    let _isMacintosh = false;
    let _isLinux = false;
    let _isLinuxSnap = false;
    let _isNative = false;
    let _isWeb = false;
    let _isElectron = false;
    let _isIOS = false;
    let _isCI = false;
    let _isMobile = false;
    let _locale = undefined;
    let _language = exports.$j;
    let _platformLocale = exports.$j;
    let _translationsConfigFile = undefined;
    let _userAgent = undefined;
    const $globalThis = globalThis;
    let nodeProcess = undefined;
    if (typeof $globalThis.vscode !== 'undefined' && typeof $globalThis.vscode.process !== 'undefined') {
        // Native environment (sandboxed)
        nodeProcess = $globalThis.vscode.process;
    }
    else if (typeof process !== 'undefined' && typeof process?.versions?.node === 'string') {
        // Native environment (non-sandboxed)
        nodeProcess = process;
    }
    const isElectronProcess = typeof nodeProcess?.versions?.electron === 'string';
    const isElectronRenderer = isElectronProcess && nodeProcess?.type === 'renderer';
    // Native environment
    if (typeof nodeProcess === 'object') {
        _isWindows = (nodeProcess.platform === 'win32');
        _isMacintosh = (nodeProcess.platform === 'darwin');
        _isLinux = (nodeProcess.platform === 'linux');
        _isLinuxSnap = _isLinux && !!nodeProcess.env['SNAP'] && !!nodeProcess.env['SNAP_REVISION'];
        _isElectron = isElectronProcess;
        _isCI = !!nodeProcess.env['CI'] || !!nodeProcess.env['BUILD_ARTIFACTSTAGINGDIRECTORY'];
        _locale = exports.$j;
        _language = exports.$j;
        const rawNlsConfig = nodeProcess.env['VSCODE_NLS_CONFIG'];
        if (rawNlsConfig) {
            try {
                const nlsConfig = JSON.parse(rawNlsConfig);
                _locale = nlsConfig.userLocale;
                _platformLocale = nlsConfig.osLocale;
                _language = nlsConfig.resolvedLanguage || exports.$j;
                _translationsConfigFile = nlsConfig.languagePack?.translationsConfigFile;
            }
            catch (e) {
            }
        }
        _isNative = true;
    }
    // Web environment
    else if (typeof navigator === 'object' && !isElectronRenderer) {
        _userAgent = navigator.userAgent;
        _isWindows = _userAgent.indexOf('Windows') >= 0;
        _isMacintosh = _userAgent.indexOf('Macintosh') >= 0;
        _isIOS = (_userAgent.indexOf('Macintosh') >= 0 || _userAgent.indexOf('iPad') >= 0 || _userAgent.indexOf('iPhone') >= 0) && !!navigator.maxTouchPoints && navigator.maxTouchPoints > 0;
        _isLinux = _userAgent.indexOf('Linux') >= 0;
        _isMobile = _userAgent?.indexOf('Mobi') >= 0;
        _isWeb = true;
        _language = nls.getNLSLanguage() || exports.$j;
        _locale = navigator.language.toLowerCase();
        _platformLocale = _locale;
    }
    // Unknown environment
    else {
        console.error('Unable to resolve platform.');
    }
    var Platform;
    (function (Platform) {
        Platform[Platform["Web"] = 0] = "Web";
        Platform[Platform["Mac"] = 1] = "Mac";
        Platform[Platform["Linux"] = 2] = "Linux";
        Platform[Platform["Windows"] = 3] = "Windows";
    })(Platform || (exports.Platform = Platform = {}));
    function $k(platform) {
        switch (platform) {
            case Platform.Web: return 'Web';
            case Platform.Mac: return 'Mac';
            case Platform.Linux: return 'Linux';
            case Platform.Windows: return 'Windows';
        }
    }
    let _platform = Platform.Web;
    if (_isMacintosh) {
        _platform = Platform.Mac;
    }
    else if (_isWindows) {
        _platform = Platform.Windows;
    }
    else if (_isLinux) {
        _platform = Platform.Linux;
    }
    exports.$l = _isWindows;
    exports.$m = _isMacintosh;
    exports.$n = _isLinux;
    exports.$o = _isLinuxSnap;
    exports.$p = _isNative;
    exports.$q = _isElectron;
    exports.$r = _isWeb;
    exports.$s = (_isWeb && typeof $globalThis.importScripts === 'function');
    exports.$t = exports.$s ? $globalThis.origin : undefined;
    exports.$u = _isIOS;
    exports.$v = _isMobile;
    /**
     * Whether we run inside a CI environment, such as
     * GH actions or Azure Pipelines.
     */
    exports.$w = _isCI;
    exports.$x = _platform;
    exports.$y = _userAgent;
    /**
     * The language used for the user interface. The format of
     * the string is all lower case (e.g. zh-tw for Traditional
     * Chinese or de for German)
     */
    exports.$z = _language;
    var Language;
    (function (Language) {
        function value() {
            return exports.$z;
        }
        Language.value = value;
        function isDefaultVariant() {
            if (exports.$z.length === 2) {
                return exports.$z === 'en';
            }
            else if (exports.$z.length >= 3) {
                return exports.$z[0] === 'e' && exports.$z[1] === 'n' && exports.$z[2] === '-';
            }
            else {
                return false;
            }
        }
        Language.isDefaultVariant = isDefaultVariant;
        function isDefault() {
            return exports.$z === 'en';
        }
        Language.isDefault = isDefault;
    })(Language || (exports.Language = Language = {}));
    /**
     * Desktop: The OS locale or the locale specified by --locale or `argv.json`.
     * Web: matches `platformLocale`.
     *
     * The UI is not necessarily shown in the provided locale.
     */
    exports.$A = _locale;
    /**
     * This will always be set to the OS/browser's locale regardless of
     * what was specified otherwise. The format of the string is all
     * lower case (e.g. zh-tw for Traditional Chinese). The UI is not
     * necessarily shown in the provided locale.
     */
    exports.$B = _platformLocale;
    /**
     * The translations that are available through language packs.
     */
    exports.$C = _translationsConfigFile;
    exports.$D = (typeof $globalThis.postMessage === 'function' && !$globalThis.importScripts);
    /**
     * See https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#:~:text=than%204%2C%20then-,set%20timeout%20to%204,-.
     *
     * Works similarly to `setTimeout(0)` but doesn't suffer from the 4ms artificial delay
     * that browsers set when the nesting level is > 5.
     */
    exports.$E = (() => {
        if (exports.$D) {
            const pending = [];
            $globalThis.addEventListener('message', (e) => {
                if (e.data && e.data.vscodeScheduleAsyncWork) {
                    for (let i = 0, len = pending.length; i < len; i++) {
                        const candidate = pending[i];
                        if (candidate.id === e.data.vscodeScheduleAsyncWork) {
                            pending.splice(i, 1);
                            candidate.callback();
                            return;
                        }
                    }
                }
            });
            let lastId = 0;
            return (callback) => {
                const myId = ++lastId;
                pending.push({
                    id: myId,
                    callback: callback
                });
                $globalThis.postMessage({ vscodeScheduleAsyncWork: myId }, '*');
            };
        }
        return (callback) => setTimeout(callback);
    })();
    var OperatingSystem;
    (function (OperatingSystem) {
        OperatingSystem[OperatingSystem["Windows"] = 1] = "Windows";
        OperatingSystem[OperatingSystem["Macintosh"] = 2] = "Macintosh";
        OperatingSystem[OperatingSystem["Linux"] = 3] = "Linux";
    })(OperatingSystem || (exports.OperatingSystem = OperatingSystem = {}));
    exports.OS = (_isMacintosh || _isIOS ? OperatingSystem.Macintosh : (_isWindows ? OperatingSystem.Windows : OperatingSystem.Linux));
    let _isLittleEndian = true;
    let _isLittleEndianComputed = false;
    function $G() {
        if (!_isLittleEndianComputed) {
            _isLittleEndianComputed = true;
            const test = new Uint8Array(2);
            test[0] = 1;
            test[1] = 2;
            const view = new Uint16Array(test.buffer);
            _isLittleEndian = (view[0] === (2 << 8) + 1);
        }
        return _isLittleEndian;
    }
    exports.$H = !!(exports.$y && exports.$y.indexOf('Chrome') >= 0);
    exports.$I = !!(exports.$y && exports.$y.indexOf('Firefox') >= 0);
    exports.$J = !!(!exports.$H && (exports.$y && exports.$y.indexOf('Safari') >= 0));
    exports.$K = !!(exports.$y && exports.$y.indexOf('Edg/') >= 0);
    exports.$L = !!(exports.$y && exports.$y.indexOf('Android') >= 0);
    function $M(osVersion) {
        return parseFloat(osVersion) >= 20;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[15/*vs/base/common/process*/], __M([0/*require*/,1/*exports*/,3/*vs/base/common/platform*/]), function (require, exports, platform_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$jc = exports.$ic = exports.env = exports.cwd = void 0;
    let safeProcess;
    // Native sandbox environment
    const vscodeGlobal = globalThis.vscode;
    if (typeof vscodeGlobal !== 'undefined' && typeof vscodeGlobal.process !== 'undefined') {
        const sandboxProcess = vscodeGlobal.process;
        safeProcess = {
            get platform() { return sandboxProcess.platform; },
            get arch() { return sandboxProcess.arch; },
            get env() { return sandboxProcess.env; },
            cwd() { return sandboxProcess.cwd(); }
        };
    }
    // Native node.js environment
    else if (typeof process !== 'undefined' && typeof process?.versions?.node === 'string') {
        safeProcess = {
            get platform() { return process.platform; },
            get arch() { return process.arch; },
            get env() { return process.env; },
            cwd() { return process.env['VSCODE_CWD'] || process.cwd(); }
        };
    }
    // Web environment
    else {
        safeProcess = {
            // Supported
            get platform() { return platform_1.$l ? 'win32' : platform_1.$m ? 'darwin' : 'linux'; },
            get arch() { return undefined; /* arch is undefined in web */ },
            // Unsupported
            get env() { return {}; },
            cwd() { return '/'; }
        };
    }
    /**
     * Provides safe access to the `cwd` property in node.js, sandboxed or web
     * environments.
     *
     * Note: in web, this property is hardcoded to be `/`.
     *
     * @skipMangle
     */
    exports.cwd = safeProcess.cwd;
    /**
     * Provides safe access to the `env` property in node.js, sandboxed or web
     * environments.
     *
     * Note: in web, this property is hardcoded to be `{}`.
     */
    exports.env = safeProcess.env;
    /**
     * Provides safe access to the `platform` property in node.js, sandboxed or web
     * environments.
     */
    exports.$ic = safeProcess.platform;
    /**
     * Provides safe access to the `arch` method in node.js, sandboxed or web
     * environments.
     * Note: `arch` is `undefined` in web
     */
    exports.$jc = safeProcess.arch;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/























define(__m[5/*vs/base/common/path*/], __M([0/*require*/,1/*exports*/,15/*vs/base/common/process*/]), function (require, exports, process) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$yc = exports.sep = exports.$wc = exports.$vc = exports.$uc = exports.$tc = exports.$sc = exports.$rc = exports.$qc = exports.$pc = exports.$oc = exports.$nc = exports.$mc = exports.$lc = exports.$kc = void 0;
    process = __importStar(process);
    const CHAR_UPPERCASE_A = 65; /* A */
    const CHAR_LOWERCASE_A = 97; /* a */
    const CHAR_UPPERCASE_Z = 90; /* Z */
    const CHAR_LOWERCASE_Z = 122; /* z */
    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) {
            // determiner: 'must be' or 'must not be'
            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 = (process.$ic === '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);
    }
    // Resolves . and .. elements in a path with directory names
    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) {
                    // NOOP
                }
                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 formatExt(ext) {
        return ext ? `${ext[0] === '.' ? '' : '.'}${ext}` : '';
    }
    function _format(sep, pathObject) {
        validateObject(pathObject, 'pathObject');
        const dir = pathObject.dir || pathObject.root;
        const base = pathObject.base ||
            `${pathObject.name || ''}${formatExt(pathObject.ext)}`;
        if (!dir) {
            return base;
        }
        return dir === pathObject.root ? `${dir}${base}` : `${dir}${sep}${base}`;
    }
    exports.$kc = {
        // path.resolve([from ...], to)
        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, `paths[${i}]`);
                    // Skip empty entries
                    if (path.length === 0) {
                        continue;
                    }
                }
                else if (resolvedDevice.length === 0) {
                    path = process.cwd();
                }
                else {
                    // Windows has the concept of drive-specific current working
                    // directories. If we've resolved a drive letter but not yet an
                    // absolute path, get cwd for that drive, or the process cwd if
                    // the drive cwd is not available. We're sure the device is not
                    // a UNC path at this points, because UNC paths are always absolute.
                    path = process.env[`=${resolvedDevice}`] || process.cwd();
                    // Verify that a cwd was found and that it actually points
                    // to our drive. If not, default to the drive's root.
                    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);
                // Try to match a root
                if (len === 1) {
                    if (isPathSeparator(code)) {
                        // `path` contains just a path separator
                        rootEnd = 1;
                        isAbsolute = true;
                    }
                }
                else if (isPathSeparator(code)) {
                    // Possible UNC root
                    // If we started with a separator, we know we at least have an
                    // absolute path of some kind (UNC or otherwise)
                    isAbsolute = true;
                    if (isPathSeparator(path.charCodeAt(1))) {
                        // Matched double path separator at beginning
                        let j = 2;
                        let last = j;
                        // Match 1 or more non-path separators
                        while (j < len && !isPathSeparator(path.charCodeAt(j))) {
                            j++;
                        }
                        if (j < len && j !== last) {
                            const firstPart = path.slice(last, j);
                            // Matched!
                            last = j;
                            // Match 1 or more path separators
                            while (j < len && isPathSeparator(path.charCodeAt(j))) {
                                j++;
                            }
                            if (j < len && j !== last) {
                                // Matched!
                                last = j;
                                // Match 1 or more non-path separators
                                while (j < len && !isPathSeparator(path.charCodeAt(j))) {
                                    j++;
                                }
                                if (j === len || j !== last) {
                                    // We matched a UNC root
                                    device = `\\\\${firstPart}\\${path.slice(last, j)}`;
                                    rootEnd = j;
                                }
                            }
                        }
                    }
                    else {
                        rootEnd = 1;
                    }
                }
                else if (isWindowsDeviceRoot(code) &&
                    path.charCodeAt(1) === CHAR_COLON) {
                    // Possible device root
                    device = path.slice(0, 2);
                    rootEnd = 2;
                    if (len > 2 && isPathSeparator(path.charCodeAt(2))) {
                        // Treat separator following drive name as an absolute path
                        // indicator
                        isAbsolute = true;
                        rootEnd = 3;
                    }
                }
                if (device.length > 0) {
                    if (resolvedDevice.length > 0) {
                        if (device.toLowerCase() !== resolvedDevice.toLowerCase()) {
                            // This path points to another device so it is not applicable
                            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;
                    }
                }
            }
            // At this point the path should be resolved to a full absolute path,
            // but handle relative paths to be safe (might happen when process.cwd()
            // fails)
            // Normalize the tail path
            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);
            // Try to match a root
            if (len === 1) {
                // `path` contains just a single char, exit early to avoid
                // unnecessary work
                return isPosixPathSeparator(code) ? '\\' : path;
            }
            if (isPathSeparator(code)) {
                // Possible UNC root
                // If we started with a separator, we know we at least have an absolute
                // path of some kind (UNC or otherwise)
                isAbsolute = true;
                if (isPathSeparator(path.charCodeAt(1))) {
                    // Matched double path separator at beginning
                    let j = 2;
                    let last = j;
                    // Match 1 or more non-path separators
                    while (j < len && !isPathSeparator(path.charCodeAt(j))) {
                        j++;
                    }
                    if (j < len && j !== last) {
                        const firstPart = path.slice(last, j);
                        // Matched!
                        last = j;
                        // Match 1 or more path separators
                        while (j < len && isPathSeparator(path.charCodeAt(j))) {
                            j++;
                        }
                        if (j < len && j !== last) {
                            // Matched!
                            last = j;
                            // Match 1 or more non-path separators
                            while (j < len && !isPathSeparator(path.charCodeAt(j))) {
                                j++;
                            }
                            if (j === len) {
                                // We matched a UNC root only
                                // Return the normalized version of the UNC root since there
                                // is nothing left to process
                                return `\\\\${firstPart}\\${path.slice(last)}\\`;
                            }
                            if (j !== last) {
                                // We matched a UNC root with leftovers
                                device = `\\\\${firstPart}\\${path.slice(last, j)}`;
                                rootEnd = j;
                            }
                        }
                    }
                }
                else {
                    rootEnd = 1;
                }
            }
            else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {
                // Possible device root
                device = path.slice(0, 2);
                rootEnd = 2;
                if (len > 2 && isPathSeparator(path.charCodeAt(2))) {
                    // Treat separator following drive name as an absolute path
                    // indicator
                    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) ||
                // Possible device root
                (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 '.';
            }
            // Make sure that the joined path doesn't start with two slashes, because
            // normalize() will mistake it for a UNC path then.
            //
            // This step is skipped when it is very clear that the user actually
            // intended to point at a UNC path. This is assumed when the first
            // non-empty string arguments starts with exactly two slashes followed by
            // at least one more non-slash character.
            //
            // Note that for normalize() to treat a path as a UNC path it needs to
            // have at least 2 components, so we don't filter for that here.
            // This means that the user can use join to construct UNC paths from
            // a server name and a share name; for example:
            //   path.join('//server', 'share') -> '\\\\server\\share\\')
            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 {
                            // We matched a UNC path in the first part
                            needsReplace = false;
                        }
                    }
                }
            }
            if (needsReplace) {
                // Find any more consecutive slashes we need to replace
                while (slashCount < joined.length &&
                    isPathSeparator(joined.charCodeAt(slashCount))) {
                    slashCount++;
                }
                // Replace the slashes if needed
                if (slashCount >= 2) {
                    joined = `\\${joined.slice(slashCount)}`;
                }
            }
            return exports.$kc.normalize(joined);
        },
        // It will solve the relative path from `from` to `to`, for instance:
        //  from = 'C:\\orandea\\test\\aaa'
        //  to = 'C:\\orandea\\impl\\bbb'
        // The output of the function should be: '..\\..\\impl\\bbb'
        relative(from, to) {
            validateString(from, 'from');
            validateString(to, 'to');
            if (from === to) {
                return '';
            }
            const fromOrig = exports.$kc.resolve(from);
            const toOrig = exports.$kc.resolve(to);
            if (fromOrig === toOrig) {
                return '';
            }
            from = fromOrig.toLowerCase();
            to = toOrig.toLowerCase();
            if (from === to) {
                return '';
            }
            // Trim any leading backslashes
            let fromStart = 0;
            while (fromStart < from.length &&
                from.charCodeAt(fromStart) === CHAR_BACKWARD_SLASH) {
                fromStart++;
            }
            // Trim trailing backslashes (applicable to UNC paths only)
            let fromEnd = from.length;
            while (fromEnd - 1 > fromStart &&
                from.charCodeAt(fromEnd - 1) === CHAR_BACKWARD_SLASH) {
                fromEnd--;
            }
            const fromLen = fromEnd - fromStart;
            // Trim any leading backslashes
            let toStart = 0;
            while (toStart < to.length &&
                to.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) {
                toStart++;
            }
            // Trim trailing backslashes (applicable to UNC paths only)
            let toEnd = to.length;
            while (toEnd - 1 > toStart &&
                to.charCodeAt(toEnd - 1) === CHAR_BACKWARD_SLASH) {
                toEnd--;
            }
            const toLen = toEnd - toStart;
            // Compare paths to find the longest common path from root
            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;
                }
            }
            // We found a mismatch before the first common path separator was seen, so
            // return the original `to`.
            if (i !== length) {
                if (lastCommonSep === -1) {
                    return toOrig;
                }
            }
            else {
                if (toLen > length) {
                    if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) {
                        // We get here if `from` is the exact base path for `to`.
                        // For example: from='C:\\foo\\bar'; to='C:\\foo\\bar\\baz'
                        return toOrig.slice(toStart + i + 1);
                    }
                    if (i === 2) {
                        // We get here if `from` is the device root.
                        // For example: from='C:\\'; to='C:\\foo'
                        return toOrig.slice(toStart + i);
                    }
                }
                if (fromLen > length) {
                    if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) {
                        // We get here if `to` is the exact base path for `from`.
                        // For example: from='C:\\foo\\bar'; to='C:\\foo'
                        lastCommonSep = i;
                    }
                    else if (i === 2) {
                        // We get here if `to` is the device root.
                        // For example: from='C:\\foo\\bar'; to='C:\\'
                        lastCommonSep = 3;
                    }
                }
                if (lastCommonSep === -1) {
                    lastCommonSep = 0;
                }
            }
            let out = '';
            // Generate the relative path based on the path difference between `to` and
            // `from`
            for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
                if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) {
                    out += out.length === 0 ? '..' : '\\..';
                }
            }
            toStart += lastCommonSep;
            // Lastly, append the rest of the destination (`to`) path that comes after
            // the common path parts
            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) {
            // Note: this will *probably* throw somewhere.
            if (typeof path !== 'string' || path.length === 0) {
                return path;
            }
            const resolvedPath = exports.$kc.resolve(path);
            if (resolvedPath.length <= 2) {
                return path;
            }
            if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) {
                // Possible UNC root
                if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) {
                    const code = resolvedPath.charCodeAt(2);
                    if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) {
                        // Matched non-long UNC root, convert the path to a long UNC path
                        return `\\\\?\\UNC\\${resolvedPath.slice(2)}`;
                    }
                }
            }
            else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0)) &&
                resolvedPath.charCodeAt(1) === CHAR_COLON &&
                resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH) {
                // Matched device root, convert the path to a long UNC path
                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) {
                // `path` contains just a path separator, exit early to avoid
                // unnecessary work or a dot.
                return isPathSeparator(code) ? path : '.';
            }
            // Try to match a root
            if (isPathSeparator(code)) {
                // Possible UNC root
                rootEnd = offset = 1;
                if (isPathSeparator(path.charCodeAt(1))) {
                    // Matched double path separator at beginning
                    let j = 2;
                    let last = j;
                    // Match 1 or more non-path separators
                    while (j < len && !isPathSeparator(path.charCodeAt(j))) {
                        j++;
                    }
                    if (j < len && j !== last) {
                        // Matched!
                        last = j;
                        // Match 1 or more path separators
                        while (j < len && isPathSeparator(path.charCodeAt(j))) {
                            j++;
                        }
                        if (j < len && j !== last) {
                            // Matched!
                            last = j;
                            // Match 1 or more non-path separators
                            while (j < len && !isPathSeparator(path.charCodeAt(j))) {
                                j++;
                            }
                            if (j === len) {
                                // We matched a UNC root only
                                return path;
                            }
                            if (j !== last) {
                                // We matched a UNC root with leftovers
                                // Offset by 1 to include the separator after the UNC root to
                                // treat it as a "normal root" on top of a (UNC) root
                                rootEnd = offset = j + 1;
                            }
                        }
                    }
                }
                // Possible device root
            }
            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 {
                    // We saw the first non-path separator
                    matchedSlash = false;
                }
            }
            if (end === -1) {
                if (rootEnd === -1) {
                    return '.';
                }
                end = rootEnd;
            }
            return path.slice(0, end);
        },
        basename(path, suffix) {
            if (suffix !== undefined) {
                validateString(suffix, 'suffix');
            }
            validateString(path, 'path');
            let start = 0;
            let end = -1;
            let matchedSlash = true;
            let i;
            // Check for a drive letter prefix so as not to mistake the following
            // path separator as an extra separator at the end of the path that can be
            // disregarded
            if (path.length >= 2 &&
                isWindowsDeviceRoot(path.charCodeAt(0)) &&
                path.charCodeAt(1) === CHAR_COLON) {
                start = 2;
            }
            if (suffix !== undefined && suffix.length > 0 && suffix.length <= path.length) {
                if (suffix === path) {
                    return '';
                }
                let extIdx = suffix.length - 1;
                let firstNonSlashEnd = -1;
                for (i = path.length - 1; i >= start; --i) {
                    const code = path.charCodeAt(i);
                    if (isPathSeparator(code)) {
                        // If we reached a path separator that was not part of a set of path
                        // separators at the end of the string, stop now
                        if (!matchedSlash) {
                            start = i + 1;
                            break;
                        }
                    }
                    else {
                        if (firstNonSlashEnd === -1) {
                            // We saw the first non-path separator, remember this index in case
                            // we need it if the extension ends up not matching
                            matchedSlash = false;
                            firstNonSlashEnd = i + 1;
                        }
                        if (extIdx >= 0) {
                            // Try to match the explicit extension
                            if (code === suffix.charCodeAt(extIdx)) {
                                if (--extIdx === -1) {
                                    // We matched the extension, so mark this as the end of our path
                                    // component
                                    end = i;
                                }
                            }
                            else {
                                // Extension does not match, so our result is the entire path
                                // component
                                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 we reached a path separator that was not part of a set of path
                    // separators at the end of the string, stop now
                    if (!matchedSlash) {
                        start = i + 1;
                        break;
                    }
                }
                else if (end === -1) {
                    // We saw the first non-path separator, mark this as the end of our
                    // path component
                    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;
            // Track the state of characters (if any) we see before our first dot and
            // after any path separator we find
            let preDotState = 0;
            // Check for a drive letter prefix so as not to mistake the following
            // path separator as an extra separator at the end of the path that can be
            // disregarded
            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 we reached a path separator that was not part of a set of path
                    // separators at the end of the string, stop now
                    if (!matchedSlash) {
                        startPart = i + 1;
                        break;
                    }
                    continue;
                }
                if (end === -1) {
                    // We saw the first non-path separator, mark this as the end of our
                    // extension
                    matchedSlash = false;
                    end = i + 1;
                }
                if (code === CHAR_DOT) {
                    // If this is our first dot, mark it as the start of our extension
                    if (startDot === -1) {
                        startDot = i;
                    }
                    else if (preDotState !== 1) {
                        preDotState = 1;
                    }
                }
                else if (startDot !== -1) {
                    // We saw a non-dot and non-path separator before our dot, so we should
                    // have a good chance at having a non-empty extension
                    preDotState = -1;
                }
            }
            if (startDot === -1 ||
                end === -1 ||
                // We saw a non-dot character immediately before the dot
                preDotState === 0 ||
                // The (right-most) trimmed path component is exactly '..'
                (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)) {
                    // `path` contains just a path separator, exit early to avoid
                    // unnecessary work
                    ret.root = ret.dir = path;
                    return ret;
                }
                ret.base = ret.name = path;
                return ret;
            }
            // Try to match a root
            if (isPathSeparator(code)) {
                // Possible UNC root
                rootEnd = 1;
                if (isPathSeparator(path.charCodeAt(1))) {
                    // Matched double path separator at beginning
                    let j = 2;
                    let last = j;
                    // Match 1 or more non-path separators
                    while (j < len && !isPathSeparator(path.charCodeAt(j))) {
                        j++;
                    }
                    if (j < len && j !== last) {
                        // Matched!
                        last = j;
                        // Match 1 or more path separators
                        while (j < len && isPathSeparator(path.charCodeAt(j))) {
                            j++;
                        }
                        if (j < len && j !== last) {
                            // Matched!
                            last = j;
                            // Match 1 or more non-path separators
                            while (j < len && !isPathSeparator(path.charCodeAt(j))) {
                                j++;
                            }
                            if (j === len) {
                                // We matched a UNC root only
                                rootEnd = j;
                            }
                            else if (j !== last) {
                                // We matched a UNC root with leftovers
                                rootEnd = j + 1;
                            }
                        }
                    }
                }
            }
            else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {
                // Possible device root
                if (len <= 2) {
                    // `path` contains just a drive root, exit early to avoid
                    // unnecessary work
                    ret.root = ret.dir = path;
                    return ret;
                }
                rootEnd = 2;
                if (isPathSeparator(path.charCodeAt(2))) {
                    if (len === 3) {
                        // `path` contains just a drive root, exit early to avoid
                        // unnecessary work
                        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;
            // Track the state of characters (if any) we see before our first dot and
            // after any path separator we find
            let preDotState = 0;
            // Get non-dir info
            for (; i >= rootEnd; --i) {
                code = path.charCodeAt(i);
                if (isPathSeparator(code)) {
                    // If we reached a path separator that was not part of a set of path
                    // separators at the end of the string, stop now
                    if (!matchedSlash) {
                        startPart = i + 1;
                        break;
                    }
                    continue;
                }
                if (end === -1) {
                    // We saw the first non-path separator, mark this as the end of our
                    // extension
                    matchedSlash = false;
                    end = i + 1;
                }
                if (code === CHAR_DOT) {
                    // If this is our first dot, mark it as the start of our extension
                    if (startDot === -1) {
                        startDot = i;
                    }
                    else if (preDotState !== 1) {
                        preDotState = 1;
                    }
                }
                else if (startDot !== -1) {
                    // We saw a non-dot and non-path separator before our dot, so we should
                    // have a good chance at having a non-empty extension
                    preDotState = -1;
                }
            }
            if (end !== -1) {
                if (startDot === -1 ||
                    // We saw a non-dot character immediately before the dot
                    preDotState === 0 ||
                    // The (right-most) trimmed path component is exactly '..'
                    (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 the directory is the root, use the entire root as the `dir` including
            // the trailing slash if any (`C:\abc` -> `C:\`). Otherwise, strip out the
            // trailing slash (`C:\abc\def` -> `C:\abc`).
            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) {
            // Converts Windows' backslash path separators to POSIX forward slashes
            // and truncates any drive indicator
            const regexp = /\\/g;
            return () => {
                const cwd = process.cwd().replace(regexp, '/');
                return cwd.slice(cwd.indexOf('/'));
            };
        }
        // We're already on POSIX, no need for any transformations
        return () => process.cwd();
    })();
    exports.$lc = {
        // path.resolve([from ...], to)
        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, `paths[${i}]`);
                // Skip empty entries
                if (path.length === 0) {
                    continue;
                }
                resolvedPath = `${path}/${resolvedPath}`;
                resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
            }
            // At this point the path should be resolved to a full absolute path, but
            // handle relative paths to be safe (might happen when process.cwd() fails)
            // Normalize the path
            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;
            // Normalize the path
            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 exports.$lc.normalize(joined);
        },
        relative(from, to) {
            validateString(from, 'from');
            validateString(to, 'to');
            if (from === to) {
                return '';
            }
            // Trim leading forward slashes.
            from = exports.$lc.resolve(from);
            to = exports.$lc.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;
            // Compare paths to find the longest common path from root
            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) {
                        // We get here if `from` is the exact base path for `to`.
                        // For example: from='/foo/bar'; to='/foo/bar/baz'
                        return to.slice(toStart + i + 1);
                    }
                    if (i === 0) {
                        // We get here if `from` is the root
                        // For example: from='/'; to='/foo'
                        return to.slice(toStart + i);
                    }
                }
                else if (fromLen > length) {
                    if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) {
                        // We get here if `to` is the exact base path for `from`.
                        // For example: from='/foo/bar/baz'; to='/foo/bar'
                        lastCommonSep = i;
                    }
                    else if (i === 0) {
                        // We get here if `to` is the root.
                        // For example: from='/foo/bar'; to='/'
                        lastCommonSep = 0;
                    }
                }
            }
            let out = '';
            // Generate the relative path based on the path difference between `to`
            // and `from`.
            for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
                if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) {
                    out += out.length === 0 ? '..' : '/..';
                }
            }
            // Lastly, append the rest of the destination (`to`) path that comes after
            // the common path parts.
            return `${out}${to.slice(toStart + lastCommonSep)}`;
        },
        toNamespacedPath(path) {
            // Non-op on posix systems
            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 {
                    // We saw the first non-path separator
                    matchedSlash = false;
                }
            }
            if (end === -1) {
                return hasRoot ? '/' : '.';
            }
            if (hasRoot && end === 1) {
                return '//';
            }
            return path.slice(0, end);
        },
        basename(path, suffix) {
            if (suffix !== undefined) {
                validateString(suffix, 'ext');
            }
            validateString(path, 'path');
            let start = 0;
            let end = -1;
            let matchedSlash = true;
            let i;
            if (suffix !== undefined && suffix.length > 0 && suffix.length <= path.length) {
                if (suffix === path) {
                    return '';
                }
                let extIdx = suffix.length - 1;
                let firstNonSlashEnd = -1;
                for (i = path.length - 1; i >= 0; --i) {
                    const code = path.charCodeAt(i);
                    if (code === CHAR_FORWARD_SLASH) {
                        // If we reached a path separator that was not part of a set of path
                        // separators at the end of the string, stop now
                        if (!matchedSlash) {
                            start = i + 1;
                            break;
                        }
                    }
                    else {
                        if (firstNonSlashEnd === -1) {
                            // We saw the first non-path separator, remember this index in case
                            // we need it if the extension ends up not matching
                            matchedSlash = false;
                            firstNonSlashEnd = i + 1;
                        }
                        if (extIdx >= 0) {
                            // Try to match the explicit extension
                            if (code === suffix.charCodeAt(extIdx)) {
                                if (--extIdx === -1) {
                                    // We matched the extension, so mark this as the end of our path
                                    // component
                                    end = i;
                                }
                            }
                            else {
                                // Extension does not match, so our result is the entire path
                                // component
                                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 we reached a path separator that was not part of a set of path
                    // separators at the end of the string, stop now
                    if (!matchedSlash) {
                        start = i + 1;
                        break;
                    }
                }
                else if (end === -1) {
                    // We saw the first non-path separator, mark this as the end of our
                    // path component
                    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;
            // Track the state of characters (if any) we see before our first dot and
            // after any path separator we find
            let preDotState = 0;
            for (let i = path.length - 1; i >= 0; --i) {
                const code = path.charCodeAt(i);
                if (code === CHAR_FORWARD_SLASH) {
                    // If we reached a path separator that was not part of a set of path
                    // separators at the end of the string, stop now
                    if (!matchedSlash) {
                        startPart = i + 1;
                        break;
                    }
                    continue;
                }
                if (end === -1) {
                    // We saw the first non-path separator, mark this as the end of our
                    // extension
                    matchedSlash = false;
                    end = i + 1;
                }
                if (code === CHAR_DOT) {
                    // If this is our first dot, mark it as the start of our extension
                    if (startDot === -1) {
                        startDot = i;
                    }
                    else if (preDotState !== 1) {
                        preDotState = 1;
                    }
                }
                else if (startDot !== -1) {
                    // We saw a non-dot and non-path separator before our dot, so we should
                    // have a good chance at having a non-empty extension
                    preDotState = -1;
                }
            }
            if (startDot === -1 ||
                end === -1 ||
                // We saw a non-dot character immediately before the dot
                preDotState === 0 ||
                // The (right-most) trimmed path component is exactly '..'
                (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;
            // Track the state of characters (if any) we see before our first dot and
            // after any path separator we find
            let preDotState = 0;
            // Get non-dir info
            for (; i >= start; --i) {
                const code = path.charCodeAt(i);
                if (code === CHAR_FORWARD_SLASH) {
                    // If we reached a path separator that was not part of a set of path
                    // separators at the end of the string, stop now
                    if (!matchedSlash) {
                        startPart = i + 1;
                        break;
                    }
                    continue;
                }
                if (end === -1) {
                    // We saw the first non-path separator, mark this as the end of our
                    // extension
                    matchedSlash = false;
                    end = i + 1;
                }
                if (code === CHAR_DOT) {
                    // If this is our first dot, mark it as the start of our extension
                    if (startDot === -1) {
                        startDot = i;
                    }
                    else if (preDotState !== 1) {
                        preDotState = 1;
                    }
                }
                else if (startDot !== -1) {
                    // We saw a non-dot and non-path separator before our dot, so we should
                    // have a good chance at having a non-empty extension
                    preDotState = -1;
                }
            }
            if (end !== -1) {
                const start = startPart === 0 && isAbsolute ? 1 : startPart;
                if (startDot === -1 ||
                    // We saw a non-dot character immediately before the dot
                    preDotState === 0 ||
                    // The (right-most) trimmed path component is exactly '..'
                    (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
    };
    exports.$lc.win32 = exports.$kc.win32 = exports.$kc;
    exports.$lc.posix = exports.$kc.posix = exports.$lc;
    exports.$mc = (platformIsWin32 ? exports.$kc.normalize : exports.$lc.normalize);
    exports.$nc = (platformIsWin32 ? exports.$kc.isAbsolute : exports.$lc.isAbsolute);
    exports.$oc = (platformIsWin32 ? exports.$kc.join : exports.$lc.join);
    exports.$pc = (platformIsWin32 ? exports.$kc.resolve : exports.$lc.resolve);
    exports.$qc = (platformIsWin32 ? exports.$kc.relative : exports.$lc.relative);
    exports.$rc = (platformIsWin32 ? exports.$kc.dirname : exports.$lc.dirname);
    exports.$sc = (platformIsWin32 ? exports.$kc.basename : exports.$lc.basename);
    exports.$tc = (platformIsWin32 ? exports.$kc.extname : exports.$lc.extname);
    exports.$uc = (platformIsWin32 ? exports.$kc.format : exports.$lc.format);
    exports.$vc = (platformIsWin32 ? exports.$kc.parse : exports.$lc.parse);
    exports.$wc = (platformIsWin32 ? exports.$kc.toNamespacedPath : exports.$lc.toNamespacedPath);
    exports.sep = (platformIsWin32 ? exports.$kc.sep : exports.$lc.sep);
    exports.$yc = (platformIsWin32 ? exports.$kc.delimiter : exports.$lc.delimiter);
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[35/*vs/base/common/extpath*/], __M([0/*require*/,1/*exports*/,13/*vs/base/common/charCode*/,5/*vs/base/common/path*/,3/*vs/base/common/platform*/,11/*vs/base/common/strings*/,10/*vs/base/common/types*/]), function (require, exports, charCode_1, path_1, platform_1, strings_1, types_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$Cg = $Cg;
    exports.$Dg = $Dg;
    exports.$Eg = $Eg;
    exports.$Fg = $Fg;
    exports.$Gg = $Gg;
    exports.$Hg = $Hg;
    exports.$Ig = $Ig;
    exports.$Jg = $Jg;
    exports.$Kg = $Kg;
    exports.$Lg = $Lg;
    exports.$Mg = $Mg;
    exports.$Ng = $Ng;
    exports.$Og = $Og;
    exports.$Pg = $Pg;
    exports.$Qg = $Qg;
    exports.$Rg = $Rg;
    exports.$Sg = $Sg;
    function $Cg(code) {
        return code === charCode_1.CharCode.Slash || code === charCode_1.CharCode.Backslash;
    }
    /**
     * Takes a Windows OS path and changes backward slashes to forward slashes.
     * This should only be done for OS paths from Windows (or user provided paths potentially from Windows).
     * Using it on a Linux or MaxOS path might change it.
     */
    function $Dg(osPath) {
        return osPath.replace(/[\\/]/g, path_1.$lc.sep);
    }
    /**
     * Takes a Windows OS path (using backward or forward slashes) and turns it into a posix path:
     * - turns backward slashes into forward slashes
     * - makes it absolute if it starts with a drive letter
     * This should only be done for OS paths from Windows (or user provided paths potentially from Windows).
     * Using it on a Linux or MaxOS path might change it.
     */
    function $Eg(osPath) {
        if (osPath.indexOf('/') === -1) {
            osPath = $Dg(osPath);
        }
        if (/^[a-zA-Z]:(\/|$)/.test(osPath)) { // starts with a drive letter
            osPath = '/' + osPath;
        }
        return osPath;
    }
    /**
     * Computes the _root_ this path, like `getRoot('c:\files') === c:\`,
     * `getRoot('files:///files/path') === files:///`,
     * or `getRoot('\\server\shares\path') === \\server\shares\`
     */
    function $Fg(path, sep = path_1.$lc.sep) {
        if (!path) {
            return '';
        }
        const len = path.length;
        const firstLetter = path.charCodeAt(0);
        if ($Cg(firstLetter)) {
            if ($Cg(path.charCodeAt(1))) {
                // UNC candidate \\localhost\shares\ddd
                //               ^^^^^^^^^^^^^^^^^^^
                if (!$Cg(path.charCodeAt(2))) {
                    let pos = 3;
                    const start = pos;
                    for (; pos < len; pos++) {
                        if ($Cg(path.charCodeAt(pos))) {
                            break;
                        }
                    }
                    if (start !== pos && !$Cg(path.charCodeAt(pos + 1))) {
                        pos += 1;
                        for (; pos < len; pos++) {
                            if ($Cg(path.charCodeAt(pos))) {
                                return path.slice(0, pos + 1) // consume this separator
                                    .replace(/[\\/]/g, sep);
                            }
                        }
                    }
                }
            }
            // /user/far
            // ^
            return sep;
        }
        else if ($Kg(firstLetter)) {
            // check for windows drive letter c:\ or c:
            if (path.charCodeAt(1) === charCode_1.CharCode.Colon) {
                if ($Cg(path.charCodeAt(2))) {
                    // C:\fff
                    // ^^^
                    return path.slice(0, 2) + sep;
                }
                else {
                    // C:
                    // ^^
                    return path.slice(0, 2);
                }
            }
        }
        // check for URI
        // scheme://authority/path
        // ^^^^^^^^^^^^^^^^^^^
        let pos = path.indexOf('://');
        if (pos !== -1) {
            pos += 3; // 3 -> "://".length
            for (; pos < len; pos++) {
                if ($Cg(path.charCodeAt(pos))) {
                    return path.slice(0, pos + 1); // consume this separator
                }
            }
        }
        return '';
    }
    /**
     * Check if the path follows this pattern: `\\hostname\sharename`.
     *
     * @see https://msdn.microsoft.com/en-us/library/gg465305.aspx
     * @return A boolean indication if the path is a UNC path, on none-windows
     * always false.
     */
    function $Gg(path) {
        if (!platform_1.$l) {
            // UNC is a windows concept
            return false;
        }
        if (!path || path.length < 5) {
            // at least \\a\b
            return false;
        }
        let code = path.charCodeAt(0);
        if (code !== charCode_1.CharCode.Backslash) {
            return false;
        }
        code = path.charCodeAt(1);
        if (code !== charCode_1.CharCode.Backslash) {
            return false;
        }
        let pos = 2;
        const start = pos;
        for (; pos < path.length; pos++) {
            code = path.charCodeAt(pos);
            if (code === charCode_1.CharCode.Backslash) {
                break;
            }
        }
        if (start === pos) {
            return false;
        }
        code = path.charCodeAt(pos + 1);
        if (isNaN(code) || code === charCode_1.CharCode.Backslash) {
            return false;
        }
        return true;
    }
    // Reference: https://en.wikipedia.org/wiki/Filename
    const WINDOWS_INVALID_FILE_CHARS = /[\\/:\*\?"<>\|]/g;
    const UNIX_INVALID_FILE_CHARS = /[/]/g;
    const WINDOWS_FORBIDDEN_NAMES = /^(con|prn|aux|clock\$|nul|lpt[0-9]|com[0-9])(\.(.*?))?$/i;
    function $Hg(name, isWindowsOS = platform_1.$l) {
        const invalidFileChars = isWindowsOS ? WINDOWS_INVALID_FILE_CHARS : UNIX_INVALID_FILE_CHARS;
        if (!name || name.length === 0 || /^\s+$/.test(name)) {
            return false; // require a name that is not just whitespace
        }
        invalidFileChars.lastIndex = 0; // the holy grail of software development
        if (invalidFileChars.test(name)) {
            return false; // check for certain invalid file characters
        }
        if (isWindowsOS && WINDOWS_FORBIDDEN_NAMES.test(name)) {
            return false; // check for certain invalid file names
        }
        if (name === '.' || name === '..') {
            return false; // check for reserved values
        }
        if (isWindowsOS && name[name.length - 1] === '.') {
            return false; // Windows: file cannot end with a "."
        }
        if (isWindowsOS && name.length !== name.trim().length) {
            return false; // Windows: file cannot end with a whitespace
        }
        if (name.length > 255) {
            return false; // most file systems do not allow files > 255 length
        }
        return true;
    }
    /**
     * @deprecated please use `IUriIdentityService.extUri.isEqual` instead. If you are
     * in a context without services, consider to pass down the `extUri` from the outside
     * or use `extUriBiasedIgnorePathCase` if you know what you are doing.
     */
    function $Ig(pathA, pathB, ignoreCase) {
        const identityEquals = (pathA === pathB);
        if (!ignoreCase || identityEquals) {
            return identityEquals;
        }
        if (!pathA || !pathB) {
            return false;
        }
        return (0, strings_1.$Kf)(pathA, pathB);
    }
    /**
     * @deprecated please use `IUriIdentityService.extUri.isEqualOrParent` instead. If
     * you are in a context without services, consider to pass down the `extUri` from the
     * outside, or use `extUriBiasedIgnorePathCase` if you know what you are doing.
     */
    function $Jg(base, parentCandidate, ignoreCase, separator = path_1.sep) {
        if (base === parentCandidate) {
            return true;
        }
        if (!base || !parentCandidate) {
            return false;
        }
        if (parentCandidate.length > base.length) {
            return false;
        }
        if (ignoreCase) {
            const beginsWith = (0, strings_1.$Lf)(base, parentCandidate);
            if (!beginsWith) {
                return false;
            }
            if (parentCandidate.length === base.length) {
                return true; // same path, different casing
            }
            let sepOffset = parentCandidate.length;
            if (parentCandidate.charAt(parentCandidate.length - 1) === separator) {
                sepOffset--; // adjust the expected sep offset in case our candidate already ends in separator character
            }
            return base.charAt(sepOffset) === separator;
        }
        if (parentCandidate.charAt(parentCandidate.length - 1) !== separator) {
            parentCandidate += separator;
        }
        return base.indexOf(parentCandidate) === 0;
    }
    function $Kg(char0) {
        return char0 >= charCode_1.CharCode.A && char0 <= charCode_1.CharCode.Z || char0 >= charCode_1.CharCode.a && char0 <= charCode_1.CharCode.z;
    }
    function $Lg(candidate, cwd) {
        // Special case: allow to open a drive letter without trailing backslash
        if (platform_1.$l && candidate.endsWith(':')) {
            candidate += path_1.sep;
        }
        // Ensure absolute
        if (!(0, path_1.$nc)(candidate)) {
            candidate = (0, path_1.$oc)(cwd, candidate);
        }
        // Ensure normalized
        candidate = (0, path_1.$mc)(candidate);
        // Ensure no trailing slash/backslash
        return $Mg(candidate);
    }
    function $Mg(candidate) {
        if (platform_1.$l) {
            candidate = (0, strings_1.$sf)(candidate, path_1.sep);
            // Special case: allow to open drive root ('C:\')
            if (candidate.endsWith(':')) {
                candidate += path_1.sep;
            }
        }
        else {
            candidate = (0, strings_1.$sf)(candidate, path_1.sep);
            // Special case: allow to open root ('/')
            if (!candidate) {
                candidate = path_1.sep;
            }
        }
        return candidate;
    }
    function $Ng(path) {
        const pathNormalized = (0, path_1.$mc)(path);
        if (platform_1.$l) {
            if (path.length > 3) {
                return false;
            }
            return $Og(pathNormalized) &&
                (path.length === 2 || pathNormalized.charCodeAt(2) === charCode_1.CharCode.Backslash);
        }
        return pathNormalized === path_1.$lc.sep;
    }
    function $Og(path, isWindowsOS = platform_1.$l) {
        if (isWindowsOS) {
            return $Kg(path.charCodeAt(0)) && path.charCodeAt(1) === charCode_1.CharCode.Colon;
        }
        return false;
    }
    function $Pg(path, isWindowsOS = platform_1.$l) {
        return $Og(path, isWindowsOS) ? path[0] : undefined;
    }
    function $Qg(path, candidate, ignoreCase) {
        if (candidate.length > path.length) {
            return -1;
        }
        if (path === candidate) {
            return 0;
        }
        if (ignoreCase) {
            path = path.toLowerCase();
            candidate = candidate.toLowerCase();
        }
        return path.indexOf(candidate);
    }
    function $Rg(rawPath) {
        const segments = rawPath.split(':'); // C:\file.txt:<line>:<column>
        let path = undefined;
        let line = undefined;
        let column = undefined;
        for (const segment of segments) {
            const segmentAsNumber = Number(segment);
            if (!(0, types_1.$ng)(segmentAsNumber)) {
                path = !!path ? [path, segment].join(':') : segment; // a colon can well be part of a path (e.g. C:\...)
            }
            else if (line === undefined) {
                line = segmentAsNumber;
            }
            else if (column === undefined) {
                column = segmentAsNumber;
            }
        }
        if (!path) {
            throw new Error('Format for `--goto` should be: `FILE:LINE(:COLUMN)`');
        }
        return {
            path,
            line: line !== undefined ? line : undefined,
            column: column !== undefined ? column : line !== undefined ? 1 : undefined // if we have a line, make sure column is also set
        };
    }
    const pathChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    const windowsSafePathFirstChars = 'BDEFGHIJKMOQRSTUVWXYZbdefghijkmoqrstuvwxyz0123456789';
    function $Sg(parent, prefix, randomLength = 8) {
        let suffix = '';
        for (let i = 0; i < randomLength; i++) {
            let pathCharsTouse;
            if (i === 0 && platform_1.$l && !prefix && (randomLength === 3 || randomLength === 4)) {
                // Windows has certain reserved file names that cannot be used, such
                // as AUX, CON, PRN, etc. We want to avoid generating a random name
                // that matches that pattern, so we use a different set of characters
                // for the first character of the name that does not include any of
                // the reserved names first characters.
                pathCharsTouse = windowsSafePathFirstChars;
            }
            else {
                pathCharsTouse = pathChars;
            }
            suffix += pathCharsTouse.charAt(Math.floor(Math.random() * pathCharsTouse.length));
        }
        let randomFileName;
        if (prefix) {
            randomFileName = `${prefix}-${suffix}`;
        }
        else {
            randomFileName = suffix;
        }
        if (parent) {
            return (0, path_1.$oc)(parent, randomFileName);
        }
        return randomFileName;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[36/*vs/base/common/processes*/], __M([0/*require*/,1/*exports*/,3/*vs/base/common/platform*/]), function (require, exports, platform_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.TerminateResponseCode = exports.Source = void 0;
    exports.$qm = $qm;
    exports.$rm = $rm;
    var Source;
    (function (Source) {
        Source[Source["stdout"] = 0] = "stdout";
        Source[Source["stderr"] = 1] = "stderr";
    })(Source || (exports.Source = Source = {}));
    var TerminateResponseCode;
    (function (TerminateResponseCode) {
        TerminateResponseCode[TerminateResponseCode["Success"] = 0] = "Success";
        TerminateResponseCode[TerminateResponseCode["Unknown"] = 1] = "Unknown";
        TerminateResponseCode[TerminateResponseCode["AccessDenied"] = 2] = "AccessDenied";
        TerminateResponseCode[TerminateResponseCode["ProcessNotFound"] = 3] = "ProcessNotFound";
    })(TerminateResponseCode || (exports.TerminateResponseCode = TerminateResponseCode = {}));
    /**
     * Sanitizes a VS Code process environment by removing all Electron/VS Code-related values.
     */
    function $qm(env, ...preserve) {
        const set = preserve.reduce((set, key) => {
            set[key] = true;
            return set;
        }, {});
        const keysToRemove = [
            /^ELECTRON_.+$/,
            /^VSCODE_(?!(PORTABLE|SHELL_LOGIN|ENV_REPLACE|ENV_APPEND|ENV_PREPEND)).+$/,
            /^SNAP(|_.*)$/,
            /^GDK_PIXBUF_.+$/,
        ];
        const envKeys = Object.keys(env);
        envKeys
            .filter(key => !set[key])
            .forEach(envKey => {
            for (let i = 0; i < keysToRemove.length; i++) {
                if (envKey.search(keysToRemove[i]) !== -1) {
                    delete env[envKey];
                    break;
                }
            }
        });
    }
    /**
     * Remove dangerous environment variables that have caused crashes
     * in forked processes (i.e. in ELECTRON_RUN_AS_NODE processes)
     *
     * @param env The env object to change
     */
    function $rm(env) {
        if (!env) {
            return;
        }
        // Unset `DEBUG`, as an invalid value might lead to process crashes
        // See https://github.com/microsoft/vscode/issues/130072
        delete env['DEBUG'];
        if (platform_1.$n) {
            // Unset `LD_PRELOAD`, as it might lead to process crashes
            // See https://github.com/microsoft/vscode/issues/134177
            delete env['LD_PRELOAD'];
        }
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/























define(__m[6/*vs/base/common/uri*/], __M([0/*require*/,1/*exports*/,13/*vs/base/common/charCode*/,27/*vs/base/common/marshallingIds*/,5/*vs/base/common/path*/,3/*vs/base/common/platform*/]), function (require, exports, charCode_1, marshallingIds_1, paths, platform_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.URI = void 0;
    exports.$Ac = $Ac;
    exports.$Bc = $Bc;
    paths = __importStar(paths);
    const _schemePattern = /^\w[\w\d+.-]*$/;
    const _singleSlashStart = /^\//;
    const _doubleSlashStart = /^\/\//;
    function _validateUri(ret, _strict) {
        // scheme, must be set
        if (!ret.scheme && _strict) {
            throw new Error(`[UriError]: Scheme is missing: {scheme: "", authority: "${ret.authority}", path: "${ret.path}", query: "${ret.query}", fragment: "${ret.fragment}"}`);
        }
        // scheme, https://tools.ietf.org/html/rfc3986#section-3.1
        // ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
        if (ret.scheme && !_schemePattern.test(ret.scheme)) {
            throw new Error('[UriError]: Scheme contains illegal characters.');
        }
        // path, http://tools.ietf.org/html/rfc3986#section-3.3
        // If a URI contains an authority component, then the path component
        // must either be empty or begin with a slash ("/") character.  If a URI
        // does not contain an authority component, then the path cannot begin
        // with two slash characters ("//").
        if (ret.path) {
            if (ret.authority) {
                if (!_singleSlashStart.test(ret.path)) {
                    throw new Error('[UriError]: If a URI contains an authority component, then the path component must either be empty or begin with a slash ("/") character');
                }
            }
            else {
                if (_doubleSlashStart.test(ret.path)) {
                    throw new Error('[UriError]: If a URI does not contain an authority component, then the path cannot begin with two slash characters ("//")');
                }
            }
        }
    }
    // for a while we allowed uris *without* schemes and this is the migration
    // for them, e.g. an uri without scheme and without strict-mode warns and falls
    // back to the file-scheme. that should cause the least carnage and still be a
    // clear warning
    function _schemeFix(scheme, _strict) {
        if (!scheme && !_strict) {
            return 'file';
        }
        return scheme;
    }
    // implements a bit of https://tools.ietf.org/html/rfc3986#section-5
    function _referenceResolution(scheme, path) {
        // the slash-character is our 'default base' as we don't
        // support constructing URIs relative to other URIs. This
        // also means that we alter and potentially break paths.
        // see https://tools.ietf.org/html/rfc3986#section-5.1.4
        switch (scheme) {
            case 'https':
            case 'http':
            case 'file':
                if (!path) {
                    path = _slash;
                }
                else if (path[0] !== _slash) {
                    path = _slash + path;
                }
                break;
        }
        return path;
    }
    const _empty = '';
    const _slash = '/';
    const _regexp = /^(([^:/?#]+?):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;
    /**
     * Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986.
     * This class is a simple parser which creates the basic component parts
     * (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation
     * and encoding.
     *
     * ```txt
     *       foo://example.com:8042/over/there?name=ferret#nose
     *       \_/   \______________/\_________/ \_________/ \__/
     *        |           |            |            |        |
     *     scheme     authority       path        query   fragment
     *        |   _____________________|__
     *       / \ /                        \
     *       urn:example:animal:ferret:nose
     * ```
     */
    class URI {
        static isUri(thing) {
            if (thing instanceof URI) {
                return true;
            }
            if (!thing) {
                return false;
            }
            return typeof thing.authority === 'string'
                && typeof thing.fragment === 'string'
                && typeof thing.path === 'string'
                && typeof thing.query === 'string'
                && typeof thing.scheme === 'string'
                && typeof thing.fsPath === 'string'
                && typeof thing.with === 'function'
                && typeof thing.toString === 'function';
        }
        /**
         * @internal
         */
        constructor(schemeOrData, authority, path, query, fragment, _strict = false) {
            if (typeof schemeOrData === 'object') {
                this.scheme = schemeOrData.scheme || _empty;
                this.authority = schemeOrData.authority || _empty;
                this.path = schemeOrData.path || _empty;
                this.query = schemeOrData.query || _empty;
                this.fragment = schemeOrData.fragment || _empty;
                // no validation because it's this URI
                // that creates uri components.
                // _validateUri(this);
            }
            else {
                this.scheme = _schemeFix(schemeOrData, _strict);
                this.authority = authority || _empty;
                this.path = _referenceResolution(this.scheme, path || _empty);
                this.query = query || _empty;
                this.fragment = fragment || _empty;
                _validateUri(this, _strict);
            }
        }
        // ---- filesystem path -----------------------
        /**
         * Returns a string representing the corresponding file system path of this URI.
         * Will handle UNC paths, normalizes windows drive letters to lower-case, and uses the
         * platform specific path separator.
         *
         * * Will *not* validate the path for invalid characters and semantics.
         * * Will *not* look at the scheme of this URI.
         * * The result shall *not* be used for display purposes but for accessing a file on disk.
         *
         *
         * The *difference* to `URI#path` is the use of the platform specific separator and the handling
         * of UNC paths. See the below sample of a file-uri with an authority (UNC path).
         *
         * ```ts
            const u = URI.parse('file://server/c$/folder/file.txt')
            u.authority === 'server'
            u.path === '/shares/c$/file.txt'
            u.fsPath === '\\server\c$\folder\file.txt'
        ```
         *
         * Using `URI#path` to read a file (using fs-apis) would not be enough because parts of the path,
         * namely the server name, would be missing. Therefore `URI#fsPath` exists - it's sugar to ease working
         * with URIs that represent files on disk (`file` scheme).
         */
        get fsPath() {
            // if (this.scheme !== 'file') {
            // 	console.warn(`[UriError] calling fsPath with scheme ${this.scheme}`);
            // }
            return $Bc(this, false);
        }
        // ---- modify to new -------------------------
        with(change) {
            if (!change) {
                return this;
            }
            let { scheme, authority, path, query, fragment } = change;
            if (scheme === undefined) {
                scheme = this.scheme;
            }
            else if (scheme === null) {
                scheme = _empty;
            }
            if (authority === undefined) {
                authority = this.authority;
            }
            else if (authority === null) {
                authority = _empty;
            }
            if (path === undefined) {
                path = this.path;
            }
            else if (path === null) {
                path = _empty;
            }
            if (query === undefined) {
                query = this.query;
            }
            else if (query === null) {
                query = _empty;
            }
            if (fragment === undefined) {
                fragment = this.fragment;
            }
            else if (fragment === null) {
                fragment = _empty;
            }
            if (scheme === this.scheme
                && authority === this.authority
                && path === this.path
                && query === this.query
                && fragment === this.fragment) {
                return this;
            }
            return new Uri(scheme, authority, path, query, fragment);
        }
        // ---- parse & validate ------------------------
        /**
         * Creates a new URI from a string, e.g. `http://www.example.com/some/path`,
         * `file:///usr/home`, or `scheme:with/path`.
         *
         * @param value A string which represents an URI (see `URI#toString`).
         */
        static parse(value, _strict = false) {
            const match = _regexp.exec(value);
            if (!match) {
                return new Uri(_empty, _empty, _empty, _empty, _empty);
            }
            return new Uri(match[2] || _empty, percentDecode(match[4] || _empty), percentDecode(match[5] || _empty), percentDecode(match[7] || _empty), percentDecode(match[9] || _empty), _strict);
        }
        /**
         * Creates a new URI from a file system path, e.g. `c:\my\files`,
         * `/usr/home`, or `\\server\share\some\path`.
         *
         * The *difference* between `URI#parse` and `URI#file` is that the latter treats the argument
         * as path, not as stringified-uri. E.g. `URI.file(path)` is **not the same as**
         * `URI.parse('file://' + path)` because the path might contain characters that are
         * interpreted (# and ?). See the following sample:
         * ```ts
        const good = URI.file('/coding/c#/project1');
        good.scheme === 'file';
        good.path === '/coding/c#/project1';
        good.fragment === '';
        const bad = URI.parse('file://' + '/coding/c#/project1');
        bad.scheme === 'file';
        bad.path === '/coding/c'; // path is now broken
        bad.fragment === '/project1';
        ```
         *
         * @param path A file system path (see `URI#fsPath`)
         */
        static file(path) {
            let authority = _empty;
            // normalize to fwd-slashes on windows,
            // on other systems bwd-slashes are valid
            // filename character, eg /f\oo/ba\r.txt
            if (platform_1.$l) {
                path = path.replace(/\\/g, _slash);
            }
            // check for authority as used in UNC shares
            // or use the path as given
            if (path[0] === _slash && path[1] === _slash) {
                const idx = path.indexOf(_slash, 2);
                if (idx === -1) {
                    authority = path.substring(2);
                    path = _slash;
                }
                else {
                    authority = path.substring(2, idx);
                    path = path.substring(idx) || _slash;
                }
            }
            return new Uri('file', authority, path, _empty, _empty);
        }
        /**
         * Creates new URI from uri components.
         *
         * Unless `strict` is `true` the scheme is defaults to be `file`. This function performs
         * validation and should be used for untrusted uri components retrieved from storage,
         * user input, command arguments etc
         */
        static from(components, strict) {
            const result = new Uri(components.scheme, components.authority, components.path, components.query, components.fragment, strict);
            return result;
        }
        /**
         * Join a URI path with path fragments and normalizes the resulting path.
         *
         * @param uri The input URI.
         * @param pathFragment The path fragment to add to the URI path.
         * @returns The resulting URI.
         */
        static joinPath(uri, ...pathFragment) {
            if (!uri.path) {
                throw new Error(`[UriError]: cannot call joinPath on URI without path`);
            }
            let newPath;
            if (platform_1.$l && uri.scheme === 'file') {
                newPath = URI.file(paths.$kc.join($Bc(uri, true), ...pathFragment)).path;
            }
            else {
                newPath = paths.$lc.join(uri.path, ...pathFragment);
            }
            return uri.with({ path: newPath });
        }
        // ---- printing/externalize ---------------------------
        /**
         * Creates a string representation for this URI. It's guaranteed that calling
         * `URI.parse` with the result of this function creates an URI which is equal
         * to this URI.
         *
         * * The result shall *not* be used for display purposes but for externalization or transport.
         * * The result will be encoded using the percentage encoding and encoding happens mostly
         * ignore the scheme-specific encoding rules.
         *
         * @param skipEncoding Do not encode the result, default is `false`
         */
        toString(skipEncoding = false) {
            return _asFormatted(this, skipEncoding);
        }
        toJSON() {
            return this;
        }
        static revive(data) {
            if (!data) {
                return data;
            }
            else if (data instanceof URI) {
                return data;
            }
            else {
                const result = new Uri(data);
                result._formatted = data.external ?? null;
                result._fsPath = data._sep === _pathSepMarker ? data.fsPath ?? null : null;
                return result;
            }
        }
        [Symbol.for('debug.description')]() {
            return `URI(${this.toString()})`;
        }
    }
    exports.URI = URI;
    function $Ac(thing) {
        if (!thing || typeof thing !== 'object') {
            return false;
        }
        return typeof thing.scheme === 'string'
            && (typeof thing.authority === 'string' || typeof thing.authority === 'undefined')
            && (typeof thing.path === 'string' || typeof thing.path === 'undefined')
            && (typeof thing.query === 'string' || typeof thing.query === 'undefined')
            && (typeof thing.fragment === 'string' || typeof thing.fragment === 'undefined');
    }
    const _pathSepMarker = platform_1.$l ? 1 : undefined;
    // This class exists so that URI is compatible with vscode.Uri (API).
    class Uri extends URI {
        constructor() {
            super(...arguments);
            this._formatted = null;
            this._fsPath = null;
        }
        get fsPath() {
            if (!this._fsPath) {
                this._fsPath = $Bc(this, false);
            }
            return this._fsPath;
        }
        toString(skipEncoding = false) {
            if (!skipEncoding) {
                if (!this._formatted) {
                    this._formatted = _asFormatted(this, false);
                }
                return this._formatted;
            }
            else {
                // we don't cache that
                return _asFormatted(this, true);
            }
        }
        toJSON() {
            const res = {
                $mid: marshallingIds_1.MarshalledId.Uri
            };
            // cached state
            if (this._fsPath) {
                res.fsPath = this._fsPath;
                res._sep = _pathSepMarker;
            }
            if (this._formatted) {
                res.external = this._formatted;
            }
            //--- uri components
            if (this.path) {
                res.path = this.path;
            }
            // TODO
            // this isn't correct and can violate the UriComponents contract but
            // this is part of the vscode.Uri API and we shouldn't change how that
            // works anymore
            if (this.scheme) {
                res.scheme = this.scheme;
            }
            if (this.authority) {
                res.authority = this.authority;
            }
            if (this.query) {
                res.query = this.query;
            }
            if (this.fragment) {
                res.fragment = this.fragment;
            }
            return res;
        }
    }
    // reserved characters: https://tools.ietf.org/html/rfc3986#section-2.2
    const encodeTable = {
        [charCode_1.CharCode.Colon]: '%3A', // gen-delims
        [charCode_1.CharCode.Slash]: '%2F',
        [charCode_1.CharCode.QuestionMark]: '%3F',
        [charCode_1.CharCode.Hash]: '%23',
        [charCode_1.CharCode.OpenSquareBracket]: '%5B',
        [charCode_1.CharCode.CloseSquareBracket]: '%5D',
        [charCode_1.CharCode.AtSign]: '%40',
        [charCode_1.CharCode.ExclamationMark]: '%21', // sub-delims
        [charCode_1.CharCode.DollarSign]: '%24',
        [charCode_1.CharCode.Ampersand]: '%26',
        [charCode_1.CharCode.SingleQuote]: '%27',
        [charCode_1.CharCode.OpenParen]: '%28',
        [charCode_1.CharCode.CloseParen]: '%29',
        [charCode_1.CharCode.Asterisk]: '%2A',
        [charCode_1.CharCode.Plus]: '%2B',
        [charCode_1.CharCode.Comma]: '%2C',
        [charCode_1.CharCode.Semicolon]: '%3B',
        [charCode_1.CharCode.Equals]: '%3D',
        [charCode_1.CharCode.Space]: '%20',
    };
    function encodeURIComponentFast(uriComponent, isPath, isAuthority) {
        let res = undefined;
        let nativeEncodePos = -1;
        for (let pos = 0; pos < uriComponent.length; pos++) {
            const code = uriComponent.charCodeAt(pos);
            // unreserved characters: https://tools.ietf.org/html/rfc3986#section-2.3
            if ((code >= charCode_1.CharCode.a && code <= charCode_1.CharCode.z)
                || (code >= charCode_1.CharCode.A && code <= charCode_1.CharCode.Z)
                || (code >= charCode_1.CharCode.Digit0 && code <= charCode_1.CharCode.Digit9)
                || code === charCode_1.CharCode.Dash
                || code === charCode_1.CharCode.Period
                || code === charCode_1.CharCode.Underline
                || code === charCode_1.CharCode.Tilde
                || (isPath && code === charCode_1.CharCode.Slash)
                || (isAuthority && code === charCode_1.CharCode.OpenSquareBracket)
                || (isAuthority && code === charCode_1.CharCode.CloseSquareBracket)
                || (isAuthority && code === charCode_1.CharCode.Colon)) {
                // check if we are delaying native encode
                if (nativeEncodePos !== -1) {
                    res += encodeURIComponent(uriComponent.substring(nativeEncodePos, pos));
                    nativeEncodePos = -1;
                }
                // check if we write into a new string (by default we try to return the param)
                if (res !== undefined) {
                    res += uriComponent.charAt(pos);
                }
            }
            else {
                // encoding needed, we need to allocate a new string
                if (res === undefined) {
                    res = uriComponent.substr(0, pos);
                }
                // check with default table first
                const escaped = encodeTable[code];
                if (escaped !== undefined) {
                    // check if we are delaying native encode
                    if (nativeEncodePos !== -1) {
                        res += encodeURIComponent(uriComponent.substring(nativeEncodePos, pos));
                        nativeEncodePos = -1;
                    }
                    // append escaped variant to result
                    res += escaped;
                }
                else if (nativeEncodePos === -1) {
                    // use native encode only when needed
                    nativeEncodePos = pos;
                }
            }
        }
        if (nativeEncodePos !== -1) {
            res += encodeURIComponent(uriComponent.substring(nativeEncodePos));
        }
        return res !== undefined ? res : uriComponent;
    }
    function encodeURIComponentMinimal(path) {
        let res = undefined;
        for (let pos = 0; pos < path.length; pos++) {
            const code = path.charCodeAt(pos);
            if (code === charCode_1.CharCode.Hash || code === charCode_1.CharCode.QuestionMark) {
                if (res === undefined) {
                    res = path.substr(0, pos);
                }
                res += encodeTable[code];
            }
            else {
                if (res !== undefined) {
                    res += path[pos];
                }
            }
        }
        return res !== undefined ? res : path;
    }
    /**
     * Compute `fsPath` for the given uri
     */
    function $Bc(uri, keepDriveLetterCasing) {
        let value;
        if (uri.authority && uri.path.length > 1 && uri.scheme === 'file') {
            // unc path: file://shares/c$/far/boo
            value = `//${uri.authority}${uri.path}`;
        }
        else if (uri.path.charCodeAt(0) === charCode_1.CharCode.Slash
            && (uri.path.charCodeAt(1) >= charCode_1.CharCode.A && uri.path.charCodeAt(1) <= charCode_1.CharCode.Z || uri.path.charCodeAt(1) >= charCode_1.CharCode.a && uri.path.charCodeAt(1) <= charCode_1.CharCode.z)
            && uri.path.charCodeAt(2) === charCode_1.CharCode.Colon) {
            if (!keepDriveLetterCasing) {
                // windows drive letter: file:///c:/far/boo
                value = uri.path[1].toLowerCase() + uri.path.substr(2);
            }
            else {
                value = uri.path.substr(1);
            }
        }
        else {
            // other path
            value = uri.path;
        }
        if (platform_1.$l) {
            value = value.replace(/\//g, '\\');
        }
        return value;
    }
    /**
     * Create the external version of a uri
     */
    function _asFormatted(uri, skipEncoding) {
        const encoder = !skipEncoding
            ? encodeURIComponentFast
            : encodeURIComponentMinimal;
        let res = '';
        let { scheme, authority, path, query, fragment } = uri;
        if (scheme) {
            res += scheme;
            res += ':';
        }
        if (authority || scheme === 'file') {
            res += _slash;
            res += _slash;
        }
        if (authority) {
            let idx = authority.indexOf('@');
            if (idx !== -1) {
                // <user>@<auth>
                const userinfo = authority.substr(0, idx);
                authority = authority.substr(idx + 1);
                idx = userinfo.lastIndexOf(':');
                if (idx === -1) {
                    res += encoder(userinfo, false, false);
                }
                else {
                    // <user>:<pass>@<auth>
                    res += encoder(userinfo.substr(0, idx), false, false);
                    res += ':';
                    res += encoder(userinfo.substr(idx + 1), false, true);
                }
                res += '@';
            }
            authority = authority.toLowerCase();
            idx = authority.lastIndexOf(':');
            if (idx === -1) {
                res += encoder(authority, false, true);
            }
            else {
                // <auth>:<port>
                res += encoder(authority.substr(0, idx), false, true);
                res += authority.substr(idx);
            }
        }
        if (path) {
            // lower-case windows drive letters in /C:/fff or C:/fff
            if (path.length >= 3 && path.charCodeAt(0) === charCode_1.CharCode.Slash && path.charCodeAt(2) === charCode_1.CharCode.Colon) {
                const code = path.charCodeAt(1);
                if (code >= charCode_1.CharCode.A && code <= charCode_1.CharCode.Z) {
                    path = `/${String.fromCharCode(code + 32)}:${path.substr(3)}`; // "/c:".length === 3
                }
            }
            else if (path.length >= 2 && path.charCodeAt(1) === charCode_1.CharCode.Colon) {
                const code = path.charCodeAt(0);
                if (code >= charCode_1.CharCode.A && code <= charCode_1.CharCode.Z) {
                    path = `${String.fromCharCode(code + 32)}:${path.substr(2)}`; // "/c:".length === 3
                }
            }
            // encode the rest of the path
            res += encoder(path, true, false);
        }
        if (query) {
            res += '?';
            res += encoder(query, false, false);
        }
        if (fragment) {
            res += '#';
            res += !skipEncoding ? encodeURIComponentFast(fragment, false, false) : fragment;
        }
        return res;
    }
    // --- decode
    function decodeURIComponentGraceful(str) {
        try {
            return decodeURIComponent(str);
        }
        catch {
            if (str.length > 3) {
                return str.substr(0, 3) + decodeURIComponentGraceful(str.substr(3));
            }
            else {
                return str;
            }
        }
    }
    const _rEncodedAsHex = /(%[0-9A-Za-z][0-9A-Za-z])+/g;
    function percentDecode(str) {
        if (!str.match(_rEncodedAsHex)) {
            return str;
        }
        return str.replace(_rEncodedAsHex, (match) => decodeURIComponentGraceful(match));
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[60/*vs/base/common/console*/], __M([0/*require*/,1/*exports*/,6/*vs/base/common/uri*/]), function (require, exports, uri_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$lr = $lr;
    exports.$mr = $mr;
    exports.$nr = $nr;
    exports.log = log;
    function $lr(obj) {
        const entry = obj;
        return entry && typeof entry.type === 'string' && typeof entry.severity === 'string';
    }
    function $mr(entry) {
        const args = [];
        let stack;
        // Parse Entry
        try {
            const parsedArguments = JSON.parse(entry.arguments);
            // Check for special stack entry as last entry
            const stackArgument = parsedArguments[parsedArguments.length - 1];
            if (stackArgument && stackArgument.__$stack) {
                parsedArguments.pop(); // stack is handled specially
                stack = stackArgument.__$stack;
            }
            args.push(...parsedArguments);
        }
        catch (error) {
            args.push('Unable to log remote console arguments', entry.arguments);
        }
        return { args, stack };
    }
    function $nr(arg0) {
        if (typeof arg0 !== 'string') {
            return $nr($mr(arg0).stack);
        }
        // Parse a source information out of the stack if we have one. Format can be:
        // at vscode.commands.registerCommand (/Users/someone/Desktop/test-ts/out/src/extension.js:18:17)
        // or
        // at /Users/someone/Desktop/test-ts/out/src/extension.js:18:17
        // or
        // at c:\Users\someone\Desktop\end-js\extension.js:19:17
        // or
        // at e.$executeContributedCommand(c:\Users\someone\Desktop\end-js\extension.js:19:17)
        const stack = arg0;
        if (stack) {
            const topFrame = findFirstFrame(stack);
            // at [^\/]* => line starts with "at" followed by any character except '/' (to not capture unix paths too late)
            // (?:(?:[a-zA-Z]+:)|(?:[\/])|(?:\\\\) => windows drive letter OR unix root OR unc root
            // (?:.+) => simple pattern for the path, only works because of the line/col pattern after
            // :(?:\d+):(?:\d+) => :line:column data
            const matches = /at [^\/]*((?:(?:[a-zA-Z]+:)|(?:[\/])|(?:\\\\))(?:.+)):(\d+):(\d+)/.exec(topFrame || '');
            if (matches && matches.length === 4) {
                return {
                    uri: uri_1.URI.file(matches[1]),
                    line: Number(matches[2]),
                    column: Number(matches[3])
                };
            }
        }
        return undefined;
    }
    function findFirstFrame(stack) {
        if (!stack) {
            return stack;
        }
        const newlineIndex = stack.indexOf('\n');
        if (newlineIndex === -1) {
            return stack;
        }
        return stack.substring(0, newlineIndex);
    }
    function log(entry, label) {
        const { args, stack } = $mr(entry);
        const isOneStringArg = typeof args[0] === 'string' && args.length === 1;
        let topFrame = findFirstFrame(stack);
        if (topFrame) {
            topFrame = `(${topFrame.trim()})`;
        }
        let consoleArgs = [];
        // First arg is a string
        if (typeof args[0] === 'string') {
            if (topFrame && isOneStringArg) {
                consoleArgs = [`%c[${label}] %c${args[0]} %c${topFrame}`, color('blue'), color(''), color('grey')];
            }
            else {
                consoleArgs = [`%c[${label}] %c${args[0]}`, color('blue'), color(''), ...args.slice(1)];
            }
        }
        // First arg is something else, just apply all
        else {
            consoleArgs = [`%c[${label}]%`, color('blue'), ...args];
        }
        // Stack: add to args unless already added
        if (topFrame && !isOneStringArg) {
            consoleArgs.push(topFrame);
        }
        // Log it
        if (typeof console[entry.severity] !== 'function') {
            throw new Error('Unknown console method');
        }
        console[entry.severity].apply(console, consoleArgs);
    }
    function color(color) {
        return `color: ${color}`;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[61/*vs/base/common/marshalling*/], __M([0/*require*/,1/*exports*/,19/*vs/base/common/buffer*/,6/*vs/base/common/uri*/,27/*vs/base/common/marshallingIds*/]), function (require, exports, buffer_1, uri_1, marshallingIds_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$fi = $fi;
    exports.$gi = $gi;
    exports.$hi = $hi;
    function $fi(obj) {
        return JSON.stringify(obj, replacer);
    }
    function $gi(text) {
        let data = JSON.parse(text);
        data = $hi(data);
        return data;
    }
    function replacer(key, value) {
        // URI is done via toJSON-member
        if (value instanceof RegExp) {
            return {
                $mid: marshallingIds_1.MarshalledId.Regexp,
                source: value.source,
                flags: value.flags,
            };
        }
        return value;
    }
    function $hi(obj, depth = 0) {
        if (!obj || depth > 200) {
            return obj;
        }
        if (typeof obj === 'object') {
            switch (obj.$mid) {
                case marshallingIds_1.MarshalledId.Uri: return uri_1.URI.revive(obj);
                case marshallingIds_1.MarshalledId.Regexp: return new RegExp(obj.source, obj.flags);
                case marshallingIds_1.MarshalledId.Date: return new Date(obj.source);
            }
            if (obj instanceof buffer_1.$Se
                || obj instanceof Uint8Array) {
                return obj;
            }
            if (Array.isArray(obj)) {
                for (let i = 0; i < obj.length; ++i) {
                    obj[i] = $hi(obj[i], depth + 1);
                }
            }
            else {
                // walk object
                for (const key in obj) {
                    if (Object.hasOwnProperty.call(obj, key)) {
                        obj[key] = $hi(obj[key], depth + 1);
                    }
                }
            }
        }
        return obj;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/























define(__m[20/*vs/base/common/network*/], __M([0/*require*/,1/*exports*/,7/*vs/base/common/errors*/,3/*vs/base/common/platform*/,11/*vs/base/common/strings*/,6/*vs/base/common/uri*/,5/*vs/base/common/path*/]), function (require, exports, errors, platform, strings_1, uri_1, paths) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.COI = exports.$5g = exports.$4g = exports.$3g = exports.$2g = exports.$1g = exports.$Zg = exports.$Xg = exports.$Wg = exports.$Vg = exports.Schemas = void 0;
    exports.$Tg = $Tg;
    exports.$Ug = $Ug;
    exports.$Yg = $Yg;
    errors = __importStar(errors);
    platform = __importStar(platform);
    paths = __importStar(paths);
    var Schemas;
    (function (Schemas) {
        /**
         * A schema that is used for models that exist in memory
         * only and that have no correspondence on a server or such.
         */
        Schemas.inMemory = 'inmemory';
        /**
         * A schema that is used for setting files
         */
        Schemas.vscode = 'vscode';
        /**
         * A schema that is used for internal private files
         */
        Schemas.internal = 'private';
        /**
         * A walk-through document.
         */
        Schemas.walkThrough = 'walkThrough';
        /**
         * An embedded code snippet.
         */
        Schemas.walkThroughSnippet = 'walkThroughSnippet';
        Schemas.http = 'http';
        Schemas.https = 'https';
        Schemas.file = 'file';
        Schemas.mailto = 'mailto';
        Schemas.untitled = 'untitled';
        Schemas.data = 'data';
        Schemas.command = 'command';
        Schemas.vscodeRemote = 'vscode-remote';
        Schemas.vscodeRemoteResource = 'vscode-remote-resource';
        Schemas.vscodeManagedRemoteResource = 'vscode-managed-remote-resource';
        Schemas.vscodeUserData = 'vscode-userdata';
        Schemas.vscodeCustomEditor = 'vscode-custom-editor';
        Schemas.vscodeNotebookCell = 'vscode-notebook-cell';
        Schemas.vscodeNotebookCellMetadata = 'vscode-notebook-cell-metadata';
        Schemas.vscodeNotebookCellMetadataDiff = 'vscode-notebook-cell-metadata-diff';
        Schemas.vscodeNotebookCellOutput = 'vscode-notebook-cell-output';
        Schemas.vscodeNotebookCellOutputDiff = 'vscode-notebook-cell-output-diff';
        Schemas.vscodeNotebookMetadata = 'vscode-notebook-metadata';
        Schemas.vscodeInteractiveInput = 'vscode-interactive-input';
        Schemas.vscodeSettings = 'vscode-settings';
        Schemas.vscodeWorkspaceTrust = 'vscode-workspace-trust';
        Schemas.vscodeTerminal = 'vscode-terminal';
        /** Scheme used for code blocks in chat. */
        Schemas.vscodeChatCodeBlock = 'vscode-chat-code-block';
        /** Scheme used for LHS of code compare (aka diff) blocks in chat. */
        Schemas.vscodeChatCodeCompareBlock = 'vscode-chat-code-compare-block';
        /** Scheme used for the chat input editor. */
        Schemas.vscodeChatSesssion = 'vscode-chat-editor';
        /**
         * Scheme used internally for webviews that aren't linked to a resource (i.e. not custom editors)
         */
        Schemas.webviewPanel = 'webview-panel';
        /**
         * Scheme used for loading the wrapper html and script in webviews.
         */
        Schemas.vscodeWebview = 'vscode-webview';
        /**
         * Scheme used for extension pages
         */
        Schemas.extension = 'extension';
        /**
         * Scheme used as a replacement of `file` scheme to load
         * files with our custom protocol handler (desktop only).
         */
        Schemas.vscodeFileResource = 'vscode-file';
        /**
         * Scheme used for temporary resources
         */
        Schemas.tmp = 'tmp';
        /**
         * Scheme used vs live share
         */
        Schemas.vsls = 'vsls';
        /**
         * Scheme used for the Source Control commit input's text document
         */
        Schemas.vscodeSourceControl = 'vscode-scm';
        /**
         * Scheme used for input box for creating comments.
         */
        Schemas.commentsInput = 'comment';
        /**
         * Scheme used for special rendering of settings in the release notes
         */
        Schemas.codeSetting = 'code-setting';
        /**
         * Scheme used for output panel resources
         */
        Schemas.outputChannel = 'output';
    })(Schemas || (exports.Schemas = Schemas = {}));
    function $Tg(target, scheme) {
        if (uri_1.URI.isUri(target)) {
            return (0, strings_1.$Kf)(target.scheme, scheme);
        }
        else {
            return (0, strings_1.$Lf)(target, scheme + ':');
        }
    }
    function $Ug(target, ...schemes) {
        return schemes.some(scheme => $Tg(target, scheme));
    }
    exports.$Vg = 'vscode-tkn';
    exports.$Wg = 'tkn';
    class RemoteAuthoritiesImpl {
        constructor() {
            this.a = Object.create(null);
            this.b = Object.create(null);
            this.c = Object.create(null);
            this.d = 'http';
            this.e = null;
            this.f = '/';
        }
        setPreferredWebSchema(schema) {
            this.d = schema;
        }
        setDelegate(delegate) {
            this.e = delegate;
        }
        setServerRootPath(product, serverBasePath) {
            this.f = $Yg(product, serverBasePath);
        }
        getServerRootPath() {
            return this.f;
        }
        get g() {
            return paths.$lc.join(this.f, Schemas.vscodeRemoteResource);
        }
        set(authority, host, port) {
            this.a[authority] = host;
            this.b[authority] = port;
        }
        setConnectionToken(authority, connectionToken) {
            this.c[authority] = connectionToken;
        }
        getPreferredWebSchema() {
            return this.d;
        }
        rewrite(uri) {
            if (this.e) {
                try {
                    return this.e(uri);
                }
                catch (err) {
                    errors.$4(err);
                    return uri;
                }
            }
            const authority = uri.authority;
            let host = this.a[authority];
            if (host && host.indexOf(':') !== -1 && host.indexOf('[') === -1) {
                host = `[${host}]`;
            }
            const port = this.b[authority];
            const connectionToken = this.c[authority];
            let query = `path=${encodeURIComponent(uri.path)}`;
            if (typeof connectionToken === 'string') {
                query += `&${exports.$Wg}=${encodeURIComponent(connectionToken)}`;
            }
            return uri_1.URI.from({
                scheme: platform.$r ? this.d : Schemas.vscodeRemoteResource,
                authority: `${host}:${port}`,
                path: platform.$r
                    ? (window.location.pathname + '/' + this.g).replace(/\/\/+/g, '/')
                    : this.g,
                query
            });
        }
    }
    exports.$Xg = new RemoteAuthoritiesImpl();
    function $Yg(product, basePath) {
        return paths.$lc.join(basePath ?? '/', `${product.quality ?? 'oss'}-${product.commit ?? 'dev'}`);
    }
    exports.$Zg = 'vs/../../extensions';
    exports.$1g = 'vs/../../node_modules';
    exports.$2g = 'vs/../../node_modules.asar';
    exports.$3g = 'vs/../../node_modules.asar.unpacked';
    exports.$4g = 'vscode-app';
    class FileAccessImpl {
        static { this.a = exports.$4g; }
        /**
         * Returns a URI to use in contexts where the browser is responsible
         * for loading (e.g. fetch()) or when used within the DOM.
         *
         * **Note:** use `dom.ts#asCSSUrl` whenever the URL is to be used in CSS context.
         */
        asBrowserUri(resourcePath) {
            // ESM-comment-begin
            const uri = this.b(resourcePath, require);
            // ESM-comment-end
            // ESM-uncomment-begin
            // const uri = this.toUri(resourcePath);
            // ESM-uncomment-end
            return this.uriToBrowserUri(uri);
        }
        /**
         * Returns a URI to use in contexts where the browser is responsible
         * for loading (e.g. fetch()) or when used within the DOM.
         *
         * **Note:** use `dom.ts#asCSSUrl` whenever the URL is to be used in CSS context.
         */
        uriToBrowserUri(uri) {
            // Handle remote URIs via `RemoteAuthorities`
            if (uri.scheme === Schemas.vscodeRemote) {
                return exports.$Xg.rewrite(uri);
            }
            // Convert to `vscode-file` resource..
            if (
            // ...only ever for `file` resources
            uri.scheme === Schemas.file &&
                (
                // ...and we run in native environments
                platform.$p ||
                    // ...or web worker extensions on desktop
                    (platform.$t === `${Schemas.vscodeFileResource}://${FileAccessImpl.a}`))) {
                return uri.with({
                    scheme: Schemas.vscodeFileResource,
                    // We need to provide an authority here so that it can serve
                    // as origin for network and loading matters in chromium.
                    // If the URI is not coming with an authority already, we
                    // add our own
                    authority: uri.authority || FileAccessImpl.a,
                    query: null,
                    fragment: null
                });
            }
            return uri;
        }
        /**
         * Returns the `file` URI to use in contexts where node.js
         * is responsible for loading.
         */
        asFileUri(resourcePath) {
            // ESM-comment-begin
            const uri = this.b(resourcePath, require);
            // ESM-comment-end
            // ESM-uncomment-begin
            // const uri = this.toUri(resourcePath);
            // ESM-uncomment-end
            return this.uriToFileUri(uri);
        }
        /**
         * Returns the `file` URI to use in contexts where node.js
         * is responsible for loading.
         */
        uriToFileUri(uri) {
            // Only convert the URI if it is `vscode-file:` scheme
            if (uri.scheme === Schemas.vscodeFileResource) {
                return uri.with({
                    scheme: Schemas.file,
                    // Only preserve the `authority` if it is different from
                    // our fallback authority. This ensures we properly preserve
                    // Windows UNC paths that come with their own authority.
                    authority: uri.authority !== FileAccessImpl.a ? uri.authority : null,
                    query: null,
                    fragment: null
                });
            }
            return uri;
        }
        b(uriOrModule, moduleIdToUrl) {
            if (uri_1.URI.isUri(uriOrModule)) {
                return uriOrModule;
            }
            if (globalThis._VSCODE_FILE_ROOT) {
                const rootUriOrPath = globalThis._VSCODE_FILE_ROOT;
                // File URL (with scheme)
                if (/^\w[\w\d+.-]*:\/\//.test(rootUriOrPath)) {
                    return uri_1.URI.joinPath(uri_1.URI.parse(rootUriOrPath, true), uriOrModule);
                }
                // File Path (no scheme)
                const modulePath = paths.$oc(rootUriOrPath, uriOrModule);
                return uri_1.URI.file(modulePath);
            }
            return uri_1.URI.parse(moduleIdToUrl.toUrl(uriOrModule));
        }
    }
    exports.$5g = new FileAccessImpl();
    var COI;
    (function (COI) {
        const coiHeaders = new Map([
            ['1', { 'Cross-Origin-Opener-Policy': 'same-origin' }],
            ['2', { 'Cross-Origin-Embedder-Policy': 'require-corp' }],
            ['3', { 'Cross-Origin-Opener-Policy': 'same-origin', 'Cross-Origin-Embedder-Policy': 'require-corp' }],
        ]);
        COI.CoopAndCoep = Object.freeze(coiHeaders.get('3'));
        const coiSearchParamName = 'vscode-coi';
        /**
         * Extract desired headers from `vscode-coi` invocation
         */
        function getHeadersFromQuery(url) {
            let params;
            if (typeof url === 'string') {
                params = new URL(url).searchParams;
            }
            else if (url instanceof URL) {
                params = url.searchParams;
            }
            else if (uri_1.URI.isUri(url)) {
                params = new URL(url.toString(true)).searchParams;
            }
            const value = params?.get(coiSearchParamName);
            if (!value) {
                return undefined;
            }
            return coiHeaders.get(value);
        }
        COI.getHeadersFromQuery = getHeadersFromQuery;
        /**
         * Add the `vscode-coi` query attribute based on wanting `COOP` and `COEP`. Will be a noop when `crossOriginIsolated`
         * isn't enabled the current context
         */
        function addSearchParam(urlOrSearch, coop, coep) {
            if (!globalThis.crossOriginIsolated) {
                // depends on the current context being COI
                return;
            }
            const value = coop && coep ? '3' : coep ? '2' : '1';
            if (urlOrSearch instanceof URLSearchParams) {
                urlOrSearch.set(coiSearchParamName, value);
            }
            else {
                urlOrSearch[coiSearchParamName] = value;
            }
        }
        COI.addSearchParam = addSearchParam;
    })(COI || (exports.COI = COI = {}));
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/























define(__m[25/*vs/base/common/resources*/], __M([0/*require*/,1/*exports*/,13/*vs/base/common/charCode*/,35/*vs/base/common/extpath*/,20/*vs/base/common/network*/,5/*vs/base/common/path*/,3/*vs/base/common/platform*/,11/*vs/base/common/strings*/,6/*vs/base/common/uri*/]), function (require, exports, charCode_1, extpath, network_1, paths, platform_1, strings_1, uri_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.DataUri = exports.$th = exports.$sh = exports.$rh = exports.$qh = exports.$ph = exports.$oh = exports.$nh = exports.$mh = exports.$lh = exports.$kh = exports.$jh = exports.$ih = exports.$hh = exports.$gh = exports.$fh = exports.$eh = exports.$dh = exports.$ch = exports.$bh = exports.$ah = void 0;
    exports.$_g = $_g;
    exports.$uh = $uh;
    exports.$vh = $vh;
    extpath = __importStar(extpath);
    paths = __importStar(paths);
    function $_g(uri) {
        return (0, uri_1.$Bc)(uri, true);
    }
    class $ah {
        constructor(a) {
            this.a = a;
        }
        compare(uri1, uri2, ignoreFragment = false) {
            if (uri1 === uri2) {
                return 0;
            }
            return (0, strings_1.$Df)(this.getComparisonKey(uri1, ignoreFragment), this.getComparisonKey(uri2, ignoreFragment));
        }
        isEqual(uri1, uri2, ignoreFragment = false) {
            if (uri1 === uri2) {
                return true;
            }
            if (!uri1 || !uri2) {
                return false;
            }
            return this.getComparisonKey(uri1, ignoreFragment) === this.getComparisonKey(uri2, ignoreFragment);
        }
        getComparisonKey(uri, ignoreFragment = false) {
            return uri.with({
                path: this.a(uri) ? uri.path.toLowerCase() : undefined,
                fragment: ignoreFragment ? null : undefined
            }).toString();
        }
        ignorePathCasing(uri) {
            return this.a(uri);
        }
        isEqualOrParent(base, parentCandidate, ignoreFragment = false) {
            if (base.scheme === parentCandidate.scheme) {
                if (base.scheme === network_1.Schemas.file) {
                    return extpath.$Jg($_g(base), $_g(parentCandidate), this.a(base)) && base.query === parentCandidate.query && (ignoreFragment || base.fragment === parentCandidate.fragment);
                }
                if ((0, exports.$qh)(base.authority, parentCandidate.authority)) {
                    return extpath.$Jg(base.path, parentCandidate.path, this.a(base), '/') && base.query === parentCandidate.query && (ignoreFragment || base.fragment === parentCandidate.fragment);
                }
            }
            return false;
        }
        // --- path math
        joinPath(resource, ...pathFragment) {
            return uri_1.URI.joinPath(resource, ...pathFragment);
        }
        basenameOrAuthority(resource) {
            return (0, exports.$ih)(resource) || resource.authority;
        }
        basename(resource) {
            return paths.$lc.basename(resource.path);
        }
        extname(resource) {
            return paths.$lc.extname(resource.path);
        }
        dirname(resource) {
            if (resource.path.length === 0) {
                return resource;
            }
            let dirname;
            if (resource.scheme === network_1.Schemas.file) {
                dirname = uri_1.URI.file(paths.$rc($_g(resource))).path;
            }
            else {
                dirname = paths.$lc.dirname(resource.path);
                if (resource.authority && dirname.length && dirname.charCodeAt(0) !== charCode_1.CharCode.Slash) {
                    console.error(`dirname("${resource.toString})) resulted in a relative path`);
                    dirname = '/'; // If a URI contains an authority component, then the path component must either be empty or begin with a CharCode.Slash ("/") character
                }
            }
            return resource.with({
                path: dirname
            });
        }
        normalizePath(resource) {
            if (!resource.path.length) {
                return resource;
            }
            let normalizedPath;
            if (resource.scheme === network_1.Schemas.file) {
                normalizedPath = uri_1.URI.file(paths.$mc($_g(resource))).path;
            }
            else {
                normalizedPath = paths.$lc.normalize(resource.path);
            }
            return resource.with({
                path: normalizedPath
            });
        }
        relativePath(from, to) {
            if (from.scheme !== to.scheme || !(0, exports.$qh)(from.authority, to.authority)) {
                return undefined;
            }
            if (from.scheme === network_1.Schemas.file) {
                const relativePath = paths.$qc($_g(from), $_g(to));
                return platform_1.$l ? extpath.$Dg(relativePath) : relativePath;
            }
            let fromPath = from.path || '/';
            const toPath = to.path || '/';
            if (this.a(from)) {
                // make casing of fromPath match toPath
                let i = 0;
                for (const len = Math.min(fromPath.length, toPath.length); i < len; i++) {
                    if (fromPath.charCodeAt(i) !== toPath.charCodeAt(i)) {
                        if (fromPath.charAt(i).toLowerCase() !== toPath.charAt(i).toLowerCase()) {
                            break;
                        }
                    }
                }
                fromPath = toPath.substr(0, i) + fromPath.substr(i);
            }
            return paths.$lc.relative(fromPath, toPath);
        }
        resolvePath(base, path) {
            if (base.scheme === network_1.Schemas.file) {
                const newURI = uri_1.URI.file(paths.$pc($_g(base), path));
                return base.with({
                    authority: newURI.authority,
                    path: newURI.path
                });
            }
            path = extpath.$Eg(path); // we allow path to be a windows path
            return base.with({
                path: paths.$lc.resolve(base.path, path)
            });
        }
        // --- misc
        isAbsolutePath(resource) {
            return !!resource.path && resource.path[0] === '/';
        }
        isEqualAuthority(a1, a2) {
            return a1 === a2 || (a1 !== undefined && a2 !== undefined && (0, strings_1.$Kf)(a1, a2));
        }
        hasTrailingPathSeparator(resource, sep = paths.sep) {
            if (resource.scheme === network_1.Schemas.file) {
                const fsp = $_g(resource);
                return fsp.length > extpath.$Fg(fsp).length && fsp[fsp.length - 1] === sep;
            }
            else {
                const p = resource.path;
                return (p.length > 1 && p.charCodeAt(p.length - 1) === charCode_1.CharCode.Slash) && !(/^[a-zA-Z]:(\/$|\\$)/.test(resource.fsPath)); // ignore the slash at offset 0
            }
        }
        removeTrailingPathSeparator(resource, sep = paths.sep) {
            // Make sure that the path isn't a drive letter. A trailing separator there is not removable.
            if ((0, exports.$rh)(resource, sep)) {
                return resource.with({ path: resource.path.substr(0, resource.path.length - 1) });
            }
            return resource;
        }
        addTrailingPathSeparator(resource, sep = paths.sep) {
            let isRootSep = false;
            if (resource.scheme === network_1.Schemas.file) {
                const fsp = $_g(resource);
                isRootSep = ((fsp !== undefined) && (fsp.length === extpath.$Fg(fsp).length) && (fsp[fsp.length - 1] === sep));
            }
            else {
                sep = '/';
                const p = resource.path;
                isRootSep = p.length === 1 && p.charCodeAt(p.length - 1) === charCode_1.CharCode.Slash;
            }
            if (!isRootSep && !(0, exports.$rh)(resource, sep)) {
                return resource.with({ path: resource.path + '/' });
            }
            return resource;
        }
    }
    exports.$ah = $ah;
    /**
     * Unbiased utility that takes uris "as they are". This means it can be interchanged with
     * uri#toString() usages. The following is true
     * ```
     * assertEqual(aUri.toString() === bUri.toString(), exturi.isEqual(aUri, bUri))
     * ```
     */
    exports.$bh = new $ah(() => false);
    /**
     * BIASED utility that _mostly_ ignored the case of urs paths. ONLY use this util if you
     * understand what you are doing.
     *
     * This utility is INCOMPATIBLE with `uri.toString()`-usages and both CANNOT be used interchanged.
     *
     * When dealing with uris from files or documents, `extUri` (the unbiased friend)is sufficient
     * because those uris come from a "trustworthy source". When creating unknown uris it's always
     * better to use `IUriIdentityService` which exposes an `IExtUri`-instance which knows when path
     * casing matters.
     */
    exports.$ch = new $ah(uri => {
        // A file scheme resource is in the same platform as code, so ignore case for non linux platforms
        // Resource can be from another platform. Lowering the case as an hack. Should come from File system provider
        return uri.scheme === network_1.Schemas.file ? !platform_1.$n : true;
    });
    /**
     * BIASED utility that always ignores the casing of uris paths. ONLY use this util if you
     * understand what you are doing.
     *
     * This utility is INCOMPATIBLE with `uri.toString()`-usages and both CANNOT be used interchanged.
     *
     * When dealing with uris from files or documents, `extUri` (the unbiased friend)is sufficient
     * because those uris come from a "trustworthy source". When creating unknown uris it's always
     * better to use `IUriIdentityService` which exposes an `IExtUri`-instance which knows when path
     * casing matters.
     */
    exports.$dh = new $ah(_ => true);
    exports.$eh = exports.$bh.isEqual.bind(exports.$bh);
    exports.$fh = exports.$bh.isEqualOrParent.bind(exports.$bh);
    exports.$gh = exports.$bh.getComparisonKey.bind(exports.$bh);
    exports.$hh = exports.$bh.basenameOrAuthority.bind(exports.$bh);
    exports.$ih = exports.$bh.basename.bind(exports.$bh);
    exports.$jh = exports.$bh.extname.bind(exports.$bh);
    exports.$kh = exports.$bh.dirname.bind(exports.$bh);
    exports.$lh = exports.$bh.joinPath.bind(exports.$bh);
    exports.$mh = exports.$bh.normalizePath.bind(exports.$bh);
    exports.$nh = exports.$bh.relativePath.bind(exports.$bh);
    exports.$oh = exports.$bh.resolvePath.bind(exports.$bh);
    exports.$ph = exports.$bh.isAbsolutePath.bind(exports.$bh);
    exports.$qh = exports.$bh.isEqualAuthority.bind(exports.$bh);
    exports.$rh = exports.$bh.hasTrailingPathSeparator.bind(exports.$bh);
    exports.$sh = exports.$bh.removeTrailingPathSeparator.bind(exports.$bh);
    exports.$th = exports.$bh.addTrailingPathSeparator.bind(exports.$bh);
    //#endregion
    function $uh(items, resourceAccessor) {
        const distinctParents = [];
        for (let i = 0; i < items.length; i++) {
            const candidateResource = resourceAccessor(items[i]);
            if (items.some((otherItem, index) => {
                if (index === i) {
                    return false;
                }
                return (0, exports.$fh)(candidateResource, resourceAccessor(otherItem));
            })) {
                continue;
            }
            distinctParents.push(items[i]);
        }
        return distinctParents;
    }
    /**
     * Data URI related helpers.
     */
    var DataUri;
    (function (DataUri) {
        DataUri.META_DATA_LABEL = 'label';
        DataUri.META_DATA_DESCRIPTION = 'description';
        DataUri.META_DATA_SIZE = 'size';
        DataUri.META_DATA_MIME = 'mime';
        function parseMetaData(dataUri) {
            const metadata = new Map();
            // Given a URI of:  data:image/png;size:2313;label:SomeLabel;description:SomeDescription;base64,77+9UE5...
            // the metadata is: size:2313;label:SomeLabel;description:SomeDescription
            const meta = dataUri.path.substring(dataUri.path.indexOf(';') + 1, dataUri.path.lastIndexOf(';'));
            meta.split(';').forEach(property => {
                const [key, value] = property.split(':');
                if (key && value) {
                    metadata.set(key, value);
                }
            });
            // Given a URI of:  data:image/png;size:2313;label:SomeLabel;description:SomeDescription;base64,77+9UE5...
            // the mime is: image/png
            const mime = dataUri.path.substring(0, dataUri.path.indexOf(';'));
            if (mime) {
                metadata.set(DataUri.META_DATA_MIME, mime);
            }
            return metadata;
        }
        DataUri.parseMetaData = parseMetaData;
    })(DataUri || (exports.DataUri = DataUri = {}));
    function $vh(resource, authority, localScheme) {
        if (authority) {
            let path = resource.path;
            if (path && path[0] !== paths.$lc.sep) {
                path = paths.$lc.sep + path;
            }
            return resource.with({ scheme: localScheme, authority, path });
        }
        return resource.with({ scheme: localScheme });
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[12/*vs/base/common/async*/], __M([0/*require*/,1/*exports*/,18/*vs/base/common/cancellation*/,7/*vs/base/common/errors*/,4/*vs/base/common/event*/,2/*vs/base/common/lifecycle*/,25/*vs/base/common/resources*/,3/*vs/base/common/platform*/,53/*vs/base/common/symbols*/,24/*vs/base/common/lazy*/]), function (require, exports, cancellation_1, errors_1, event_1, lifecycle_1, resources_1, platform_1, symbols_1, lazy_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$bi = exports.$_h = exports.$$h = exports.$0h = exports.$9h = exports.Promises = exports.$8h = exports.$7h = exports.$6h = exports.$4h = exports.$3h = exports.$2h = exports.$1h = exports.$Zh = exports.$Yh = exports.$Xh = exports.$Wh = exports.$Vh = exports.$Uh = exports.$Th = exports.$Sh = exports.$Rh = exports.$Qh = exports.$Kh = exports.$Jh = exports.$Ih = exports.$Hh = exports.$Gh = exports.$Fh = exports.$Eh = void 0;
    exports.$wh = $wh;
    exports.$xh = $xh;
    exports.$yh = $yh;
    exports.$zh = $zh;
    exports.$Ah = $Ah;
    exports.$Bh = $Bh;
    exports.$Ch = $Ch;
    exports.$Dh = $Dh;
    exports.$Lh = $Lh;
    exports.$Mh = $Mh;
    exports.$Nh = $Nh;
    exports.$Oh = $Oh;
    exports.$Ph = $Ph;
    exports.$5h = $5h;
    exports.$ai = $ai;
    function $wh(obj) {
        return !!obj && typeof obj.then === 'function';
    }
    function $xh(callback) {
        const source = new cancellation_1.$Be();
        const thenable = callback(source.token);
        const promise = new Promise((resolve, reject) => {
            const subscription = source.token.onCancellationRequested(() => {
                subscription.dispose();
                reject(new errors_1.$9());
            });
            Promise.resolve(thenable).then(value => {
                subscription.dispose();
                source.dispose();
                resolve(value);
            }, err => {
                subscription.dispose();
                source.dispose();
                reject(err);
            });
        });
        return new class {
            cancel() {
                source.cancel();
                source.dispose();
            }
            then(resolve, reject) {
                return promise.then(resolve, reject);
            }
            catch(reject) {
                return this.then(undefined, reject);
            }
            finally(onfinally) {
                return promise.finally(onfinally);
            }
        };
    }
    function $yh(promise, token, defaultValue) {
        return new Promise((resolve, reject) => {
            const ref = token.onCancellationRequested(() => {
                ref.dispose();
                resolve(defaultValue);
            });
            promise.then(resolve, reject).finally(() => ref.dispose());
        });
    }
    /**
     * Returns a promise that rejects with an {@CancellationError} as soon as the passed token is cancelled.
     * @see {@link $yh}
     */
    function $zh(promise, token) {
        return new Promise((resolve, reject) => {
            const ref = token.onCancellationRequested(() => {
                ref.dispose();
                reject(new errors_1.$9());
            });
            promise.then(resolve, reject).finally(() => ref.dispose());
        });
    }
    /**
     * Returns as soon as one of the promises resolves or rejects and cancels remaining promises
     */
    async function $Ah(cancellablePromises) {
        let resolvedPromiseIndex = -1;
        const promises = cancellablePromises.map((promise, index) => promise.then(result => { resolvedPromiseIndex = index; return result; }));
        try {
            const result = await Promise.race(promises);
            return result;
        }
        finally {
            cancellablePromises.forEach((cancellablePromise, index) => {
                if (index !== resolvedPromiseIndex) {
                    cancellablePromise.cancel();
                }
            });
        }
    }
    function $Bh(promise, timeout, onTimeout) {
        let promiseResolve = undefined;
        const timer = setTimeout(() => {
            promiseResolve?.(undefined);
            onTimeout?.();
        }, timeout);
        return Promise.race([
            promise.finally(() => clearTimeout(timer)),
            new Promise(resolve => promiseResolve = resolve)
        ]);
    }
    function $Ch(callback) {
        return new Promise((resolve, reject) => {
            const item = callback();
            if ($wh(item)) {
                item.then(resolve, reject);
            }
            else {
                resolve(item);
            }
        });
    }
    /**
     * Creates and returns a new promise, plus its `resolve` and `reject` callbacks.
     *
     * Replace with standardized [`Promise.withResolvers`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers) once it is supported
     */
    function $Dh() {
        let resolve;
        let reject;
        const promise = new Promise((res, rej) => {
            resolve = res;
            reject = rej;
        });
        return { promise, resolve: resolve, reject: reject };
    }
    /**
     * A helper to prevent accumulation of sequential async tasks.
     *
     * Imagine a mail man with the sole task of delivering letters. As soon as
     * a letter submitted for delivery, he drives to the destination, delivers it
     * and returns to his base. Imagine that during the trip, N more letters were submitted.
     * When the mail man returns, he picks those N letters and delivers them all in a
     * single trip. Even though N+1 submissions occurred, only 2 deliveries were made.
     *
     * The throttler implements this via the queue() method, by providing it a task
     * factory. Following the example:
     *
     * 		const throttler = new Throttler();
     * 		const letters = [];
     *
     * 		function deliver() {
     * 			const lettersToDeliver = letters;
     * 			letters = [];
     * 			return makeTheTrip(lettersToDeliver);
     * 		}
     *
     * 		function onLetterReceived(l) {
     * 			letters.push(l);
     * 			throttler.queue(deliver);
     * 		}
     */
    class $Eh {
        constructor() {
            this.f = false;
            this.a = null;
            this.b = null;
            this.d = null;
        }
        queue(promiseFactory) {
            if (this.f) {
                return Promise.reject(new Error('Throttler is disposed'));
            }
            if (this.a) {
                this.d = promiseFactory;
                if (!this.b) {
                    const onComplete = () => {
                        this.b = null;
                        if (this.f) {
                            return;
                        }
                        const result = this.queue(this.d);
                        this.d = null;
                        return result;
                    };
                    this.b = new Promise(resolve => {
                        this.a.then(onComplete, onComplete).then(resolve);
                    });
                }
                return new Promise((resolve, reject) => {
                    this.b.then(resolve, reject);
                });
            }
            this.a = promiseFactory();
            return new Promise((resolve, reject) => {
                this.a.then((result) => {
                    this.a = null;
                    resolve(result);
                }, (err) => {
                    this.a = null;
                    reject(err);
                });
            });
        }
        dispose() {
            this.f = true;
        }
    }
    exports.$Eh = $Eh;
    class $Fh {
        constructor() {
            this.a = Promise.resolve(null);
        }
        queue(promiseTask) {
            return this.a = this.a.then(() => promiseTask(), () => promiseTask());
        }
    }
    exports.$Fh = $Fh;
    class $Gh {
        constructor() {
            this.a = new Map();
        }
        queue(key, promiseTask) {
            const runningPromise = this.a.get(key) ?? Promise.resolve();
            const newPromise = runningPromise
                .catch(() => { })
                .then(promiseTask)
                .finally(() => {
                if (this.a.get(key) === newPromise) {
                    this.a.delete(key);
                }
            });
            this.a.set(key, newPromise);
            return newPromise;
        }
    }
    exports.$Gh = $Gh;
    const timeoutDeferred = (timeout, fn) => {
        let scheduled = true;
        const handle = setTimeout(() => {
            scheduled = false;
            fn();
        }, timeout);
        return {
            isTriggered: () => scheduled,
            dispose: () => {
                clearTimeout(handle);
                scheduled = false;
            },
        };
    };
    const microtaskDeferred = (fn) => {
        let scheduled = true;
        queueMicrotask(() => {
            if (scheduled) {
                scheduled = false;
                fn();
            }
        });
        return {
            isTriggered: () => scheduled,
            dispose: () => { scheduled = false; },
        };
    };
    /**
     * A helper to delay (debounce) execution of a task that is being requested often.
     *
     * Following the throttler, now imagine the mail man wants to optimize the number of
     * trips proactively. The trip itself can be long, so he decides not to make the trip
     * as soon as a letter is submitted. Instead he waits a while, in case more
     * letters are submitted. After said waiting period, if no letters were submitted, he
     * decides to make the trip. Imagine that N more letters were submitted after the first
     * one, all within a short period of time between each other. Even though N+1
     * submissions occurred, only 1 delivery was made.
     *
     * The delayer offers this behavior via the trigger() method, into which both the task
     * to be executed and the waiting period (delay) must be passed in as arguments. Following
     * the example:
     *
     * 		const delayer = new Delayer(WAITING_PERIOD);
     * 		const letters = [];
     *
     * 		function letterReceived(l) {
     * 			letters.push(l);
     * 			delayer.trigger(() => { return makeTheTrip(); });
     * 		}
     */
    class $Hh {
        constructor(defaultDelay) {
            this.defaultDelay = defaultDelay;
            this.a = null;
            this.b = null;
            this.d = null;
            this.f = null;
            this.g = null;
        }
        trigger(task, delay = this.defaultDelay) {
            this.g = task;
            this.h();
            if (!this.b) {
                this.b = new Promise((resolve, reject) => {
                    this.d = resolve;
                    this.f = reject;
                }).then(() => {
                    this.b = null;
                    this.d = null;
                    if (this.g) {
                        const task = this.g;
                        this.g = null;
                        return task();
                    }
                    return undefined;
                });
            }
            const fn = () => {
                this.a = null;
                this.d?.(null);
            };
            this.a = delay === symbols_1.$le ? microtaskDeferred(fn) : timeoutDeferred(delay, fn);
            return this.b;
        }
        isTriggered() {
            return !!this.a?.isTriggered();
        }
        cancel() {
            this.h();
            if (this.b) {
                this.f?.(new errors_1.$9());
                this.b = null;
            }
        }
        h() {
            this.a?.dispose();
            this.a = null;
        }
        dispose() {
            this.cancel();
        }
    }
    exports.$Hh = $Hh;
    /**
     * A helper to delay execution of a task that is being requested often, while
     * preventing accumulation of consecutive executions, while the task runs.
     *
     * The mail man is clever and waits for a certain amount of time, before going
     * out to deliver letters. While the mail man is going out, more letters arrive
     * and can only be delivered once he is back. Once he is back the mail man will
     * do one more trip to deliver the letters that have accumulated while he was out.
     */
    class $Ih {
        constructor(defaultDelay) {
            this.a = new $Hh(defaultDelay);
            this.b = new $Eh();
        }
        trigger(promiseFactory, delay) {
            return this.a.trigger(() => this.b.queue(promiseFactory), delay);
        }
        isTriggered() {
            return this.a.isTriggered();
        }
        cancel() {
            this.a.cancel();
        }
        dispose() {
            this.a.dispose();
            this.b.dispose();
        }
    }
    exports.$Ih = $Ih;
    /**
     * A barrier that is initially closed and then becomes opened permanently.
     */
    class $Jh {
        constructor() {
            this.a = false;
            this.b = new Promise((c, e) => {
                this.d = c;
            });
        }
        isOpen() {
            return this.a;
        }
        open() {
            this.a = true;
            this.d(true);
        }
        wait() {
            return this.b;
        }
    }
    exports.$Jh = $Jh;
    /**
     * A barrier that is initially closed and then becomes opened permanently after a certain period of
     * time or when open is called explicitly
     */
    class $Kh extends $Jh {
        constructor(autoOpenTimeMs) {
            super();
            this.f = setTimeout(() => this.open(), autoOpenTimeMs);
        }
        open() {
            clearTimeout(this.f);
            super.open();
        }
    }
    exports.$Kh = $Kh;
    function $Lh(millis, token) {
        if (!token) {
            return $xh(token => $Lh(millis, token));
        }
        return new Promise((resolve, reject) => {
            const handle = setTimeout(() => {
                disposable.dispose();
                resolve();
            }, millis);
            const disposable = token.onCancellationRequested(() => {
                clearTimeout(handle);
                disposable.dispose();
                reject(new errors_1.$9());
            });
        });
    }
    /**
     * Creates a timeout that can be disposed using its returned value.
     * @param handler The timeout handler.
     * @param timeout An optional timeout in milliseconds.
     * @param store An optional {@link $Yc} that will have the timeout disposable managed automatically.
     *
     * @example
     * const store = new DisposableStore;
     * // Call the timeout after 1000ms at which point it will be automatically
     * // evicted from the store.
     * const timeoutDisposable = disposableTimeout(() => {}, 1000, store);
     *
     * if (foo) {
     *   // Cancel the timeout and evict it from store.
     *   timeoutDisposable.dispose();
     * }
     */
    function $Mh(handler, timeout = 0, store) {
        const timer = setTimeout(() => {
            handler();
            if (store) {
                disposable.dispose();
            }
        }, timeout);
        const disposable = (0, lifecycle_1.$Xc)(() => {
            clearTimeout(timer);
            store?.deleteAndLeak(disposable);
        });
        store?.add(disposable);
        return disposable;
    }
    /**
     * Runs the provided list of promise factories in sequential order. The returned
     * promise will complete to an array of results from each promise.
     */
    function $Nh(promiseFactories) {
        const results = [];
        let index = 0;
        const len = promiseFactories.length;
        function next() {
            return index < len ? promiseFactories[index++]() : null;
        }
        function thenHandler(result) {
            if (result !== undefined && result !== null) {
                results.push(result);
            }
            const n = next();
            if (n) {
                return n.then(thenHandler);
            }
            return Promise.resolve(results);
        }
        return Promise.resolve(null).then(thenHandler);
    }
    function $Oh(promiseFactories, shouldStop = t => !!t, defaultValue = null) {
        let index = 0;
        const len = promiseFactories.length;
        const loop = () => {
            if (index >= len) {
                return Promise.resolve(defaultValue);
            }
            const factory = promiseFactories[index++];
            const promise = Promise.resolve(factory());
            return promise.then(result => {
                if (shouldStop(result)) {
                    return Promise.resolve(result);
                }
                return loop();
            });
        };
        return loop();
    }
    function $Ph(promiseList, shouldStop = t => !!t, defaultValue = null) {
        if (promiseList.length === 0) {
            return Promise.resolve(defaultValue);
        }
        let todo = promiseList.length;
        const finish = () => {
            todo = -1;
            for (const promise of promiseList) {
                promise.cancel?.();
            }
        };
        return new Promise((resolve, reject) => {
            for (const promise of promiseList) {
                promise.then(result => {
                    if (--todo >= 0 && shouldStop(result)) {
                        finish();
                        resolve(result);
                    }
                    else if (todo === 0) {
                        resolve(defaultValue);
                    }
                })
                    .catch(err => {
                    if (--todo >= 0) {
                        finish();
                        reject(err);
                    }
                });
            }
        });
    }
    /**
     * A helper to queue N promises and run them all with a max degree of parallelism. The helper
     * ensures that at any time no more than M promises are running at the same time.
     */
    class $Qh {
        constructor(maxDegreeOfParalellism) {
            this.a = 0;
            this.b = false;
            this.f = maxDegreeOfParalellism;
            this.g = [];
            this.d = 0;
            this.h = new event_1.$qe();
        }
        /**
         *
         * @returns A promise that resolved when all work is done (onDrained) or when
         * there is nothing to do
         */
        whenIdle() {
            return this.size > 0
                ? event_1.Event.toPromise(this.onDrained)
                : Promise.resolve();
        }
        get onDrained() {
            return this.h.event;
        }
        get size() {
            return this.a;
        }
        queue(factory) {
            if (this.b) {
                throw new Error('Object has been disposed');
            }
            this.a++;
            return new Promise((c, e) => {
                this.g.push({ factory, c, e });
                this.j();
            });
        }
        j() {
            while (this.g.length && this.d < this.f) {
                const iLimitedTask = this.g.shift();
                this.d++;
                const promise = iLimitedTask.factory();
                promise.then(iLimitedTask.c, iLimitedTask.e);
                promise.then(() => this.k(), () => this.k());
            }
        }
        k() {
            if (this.b) {
                return;
            }
            this.d--;
            if (--this.a === 0) {
                this.h.fire();
            }
            if (this.g.length > 0) {
                this.j();
            }
        }
        clear() {
            if (this.b) {
                throw new Error('Object has been disposed');
            }
            this.g.length = 0;
            this.a = this.d;
        }
        dispose() {
            this.b = true;
            this.g.length = 0; // stop further processing
            this.a = 0;
            this.h.dispose();
        }
    }
    exports.$Qh = $Qh;
    /**
     * A queue is handles one promise at a time and guarantees that at any time only one promise is executing.
     */
    class $Rh extends $Qh {
        constructor() {
            super(1);
        }
    }
    exports.$Rh = $Rh;
    /**
     * Same as `Queue`, ensures that only 1 task is executed at the same time. The difference to `Queue` is that
     * there is only 1 task about to be scheduled next. As such, calling `queue` while a task is executing will
     * replace the currently queued task until it executes.
     *
     * As such, the returned promise may not be from the factory that is passed in but from the next factory that
     * is running after having called `queue`.
     */
    class $Sh {
        constructor() {
            this.a = new $6h();
            this.b = 0;
        }
        queue(factory) {
            if (!this.a.isRunning()) {
                return this.a.run(this.b++, factory());
            }
            return this.a.queue(() => {
                return this.a.run(this.b++, factory());
            });
        }
    }
    exports.$Sh = $Sh;
    /**
     * A helper to organize queues per resource. The ResourceQueue makes sure to manage queues per resource
     * by disposing them once the queue is empty.
     */
    class $Th {
        constructor() {
            this.a = new Map();
            this.b = new Set();
            this.d = undefined;
            this.f = 0;
        }
        async whenDrained() {
            if (this.g()) {
                return;
            }
            const promise = new $8h();
            this.b.add(promise);
            return promise.p;
        }
        g() {
            for (const [, queue] of this.a) {
                if (queue.size > 0) {
                    return false;
                }
            }
            return true;
        }
        queueSize(resource, extUri = resources_1.$bh) {
            const key = extUri.getComparisonKey(resource);
            return this.a.get(key)?.size ?? 0;
        }
        queueFor(resource, factory, extUri = resources_1.$bh) {
            const key = extUri.getComparisonKey(resource);
            let queue = this.a.get(key);
            if (!queue) {
                queue = new $Rh();
                const drainListenerId = this.f++;
                const drainListener = event_1.Event.once(queue.onDrained)(() => {
                    queue?.dispose();
                    this.a.delete(key);
                    this.h();
                    this.d?.deleteAndDispose(drainListenerId);
                    if (this.d?.size === 0) {
                        this.d.dispose();
                        this.d = undefined;
                    }
                });
                if (!this.d) {
                    this.d = new lifecycle_1.$9c();
                }
                this.d.set(drainListenerId, drainListener);
                this.a.set(key, queue);
            }
            return queue.queue(factory);
        }
        h() {
            if (!this.g()) {
                return; // not done yet
            }
            this.j();
        }
        j() {
            for (const drainer of this.b) {
                drainer.complete();
            }
            this.b.clear();
        }
        dispose() {
            for (const [, queue] of this.a) {
                queue.dispose();
            }
            this.a.clear();
            // Even though we might still have pending
            // tasks queued, after the queues have been
            // disposed, we can no longer track them, so
            // we release drainers to prevent hanging
            // promises when the resource queue is being
            // disposed.
            this.j();
            this.d?.dispose();
        }
    }
    exports.$Th = $Th;
    class $Uh {
        constructor(runner, timeout) {
            this.b = false;
            this.a = -1;
            if (typeof runner === 'function' && typeof timeout === 'number') {
                this.setIfNotSet(runner, timeout);
            }
        }
        dispose() {
            this.cancel();
            this.b = true;
        }
        cancel() {
            if (this.a !== -1) {
                clearTimeout(this.a);
                this.a = -1;
            }
        }
        cancelAndSet(runner, timeout) {
            if (this.b) {
                throw new errors_1.$gb(`Calling 'cancelAndSet' on a disposed TimeoutTimer`);
            }
            this.cancel();
            this.a = setTimeout(() => {
                this.a = -1;
                runner();
            }, timeout);
        }
        setIfNotSet(runner, timeout) {
            if (this.b) {
                throw new errors_1.$gb(`Calling 'setIfNotSet' on a disposed TimeoutTimer`);
            }
            if (this.a !== -1) {
                // timer is already set
                return;
            }
            this.a = setTimeout(() => {
                this.a = -1;
                runner();
            }, timeout);
        }
    }
    exports.$Uh = $Uh;
    class $Vh {
        constructor() {
            this.d = undefined;
            this.f = false;
        }
        cancel() {
            this.d?.dispose();
            this.d = undefined;
        }
        cancelAndSet(runner, interval, context = globalThis) {
            if (this.f) {
                throw new errors_1.$gb(`Calling 'cancelAndSet' on a disposed IntervalTimer`);
            }
            this.cancel();
            const handle = context.setInterval(() => {
                runner();
            }, interval);
            this.d = (0, lifecycle_1.$Xc)(() => {
                context.clearInterval(handle);
                this.d = undefined;
            });
        }
        dispose() {
            this.cancel();
            this.f = true;
        }
    }
    exports.$Vh = $Vh;
    class $Wh {
        constructor(runner, delay) {
            this.b = -1;
            this.a = runner;
            this.d = delay;
            this.f = this.g.bind(this);
        }
        /**
         * Dispose RunOnceScheduler
         */
        dispose() {
            this.cancel();
            this.a = null;
        }
        /**
         * Cancel current scheduled runner (if any).
         */
        cancel() {
            if (this.isScheduled()) {
                clearTimeout(this.b);
                this.b = -1;
            }
        }
        /**
         * Cancel previous runner (if any) & schedule a new runner.
         */
        schedule(delay = this.d) {
            this.cancel();
            this.b = setTimeout(this.f, delay);
        }
        get delay() {
            return this.d;
        }
        set delay(value) {
            this.d = value;
        }
        /**
         * Returns true if scheduled.
         */
        isScheduled() {
            return this.b !== -1;
        }
        flush() {
            if (this.isScheduled()) {
                this.cancel();
                this.h();
            }
        }
        g() {
            this.b = -1;
            if (this.a) {
                this.h();
            }
        }
        h() {
            this.a?.();
        }
    }
    exports.$Wh = $Wh;
    /**
     * Same as `RunOnceScheduler`, but doesn't count the time spent in sleep mode.
     * > **NOTE**: Only offers 1s resolution.
     *
     * When calling `setTimeout` with 3hrs, and putting the computer immediately to sleep
     * for 8hrs, `setTimeout` will fire **as soon as the computer wakes from sleep**. But
     * this scheduler will execute 3hrs **after waking the computer from sleep**.
     */
    class $Xh {
        constructor(runner, delay) {
            if (delay % 1000 !== 0) {
                console.warn(`ProcessTimeRunOnceScheduler resolution is 1s, ${delay}ms is not a multiple of 1000ms.`);
            }
            this.a = runner;
            this.b = delay;
            this.d = 0;
            this.f = -1;
            this.g = this.h.bind(this);
        }
        dispose() {
            this.cancel();
            this.a = null;
        }
        cancel() {
            if (this.isScheduled()) {
                clearInterval(this.f);
                this.f = -1;
            }
        }
        /**
         * Cancel previous runner (if any) & schedule a new runner.
         */
        schedule(delay = this.b) {
            if (delay % 1000 !== 0) {
                console.warn(`ProcessTimeRunOnceScheduler resolution is 1s, ${delay}ms is not a multiple of 1000ms.`);
            }
            this.cancel();
            this.d = Math.ceil(delay / 1000);
            this.f = setInterval(this.g, 1000);
        }
        /**
         * Returns true if scheduled.
         */
        isScheduled() {
            return this.f !== -1;
        }
        h() {
            this.d--;
            if (this.d > 0) {
                // still need to wait
                return;
            }
            // time elapsed
            clearInterval(this.f);
            this.f = -1;
            this.a?.();
        }
    }
    exports.$Xh = $Xh;
    class $Yh extends $Wh {
        constructor(runner, timeout) {
            super(runner, timeout);
            this.j = [];
        }
        work(unit) {
            this.j.push(unit);
            if (!this.isScheduled()) {
                this.schedule();
            }
        }
        h() {
            const units = this.j;
            this.j = [];
            this.a?.(units);
        }
        dispose() {
            this.j = [];
            super.dispose();
        }
    }
    exports.$Yh = $Yh;
    /**
     * The `ThrottledWorker` will accept units of work `T`
     * to handle. The contract is:
     * * there is a maximum of units the worker can handle at once (via `maxWorkChunkSize`)
     * * there is a maximum of units the worker will keep in memory for processing (via `maxBufferedWork`)
     * * after having handled `maxWorkChunkSize` units, the worker needs to rest (via `throttleDelay`)
     */
    class $Zh extends lifecycle_1.$Zc {
        constructor(g, h) {
            super();
            this.g = g;
            this.h = h;
            this.a = [];
            this.b = this.B(new lifecycle_1.$1c());
            this.f = false;
        }
        /**
         * The number of work units that are pending to be processed.
         */
        get pending() { return this.a.length; }
        /**
         * Add units to be worked on. Use `pending` to figure out
         * how many units are not yet processed after this method
         * was called.
         *
         * @returns whether the work was accepted or not. If the
         * worker is disposed, it will not accept any more work.
         * If the number of pending units would become larger
         * than `maxPendingWork`, more work will also not be accepted.
         */
        work(units) {
            if (this.f) {
                return false; // work not accepted: disposed
            }
            // Check for reaching maximum of pending work
            if (typeof this.g.maxBufferedWork === 'number') {
                // Throttled: simple check if pending + units exceeds max pending
                if (this.b.value) {
                    if (this.pending + units.length > this.g.maxBufferedWork) {
                        return false; // work not accepted: too much pending work
                    }
                }
                // Unthrottled: same as throttled, but account for max chunk getting
                // worked on directly without being pending
                else {
                    if (this.pending + units.length - this.g.maxWorkChunkSize > this.g.maxBufferedWork) {
                        return false; // work not accepted: too much pending work
                    }
                }
            }
            // Add to pending units first
            for (const unit of units) {
                this.a.push(unit);
            }
            // If not throttled, start working directly
            // Otherwise, when the throttle delay has
            // past, pending work will be worked again.
            if (!this.b.value) {
                this.j();
            }
            return true; // work accepted
        }
        j() {
            // Extract chunk to handle and handle it
            this.h(this.a.splice(0, this.g.maxWorkChunkSize));
            // If we have remaining work, schedule it after a delay
            if (this.a.length > 0) {
                this.b.value = new $Wh(() => {
                    this.b.clear();
                    this.j();
                }, this.g.throttleDelay);
                this.b.value.schedule();
            }
        }
        dispose() {
            super.dispose();
            this.f = true;
        }
    }
    exports.$Zh = $Zh;
    (function () {
        if (typeof globalThis.requestIdleCallback !== 'function' || typeof globalThis.cancelIdleCallback !== 'function') {
            exports.$2h = (_targetWindow, runner) => {
                (0, platform_1.$E)(() => {
                    if (disposed) {
                        return;
                    }
                    const end = Date.now() + 15; // one frame at 64fps
                    const deadline = {
                        didTimeout: true,
                        timeRemaining() {
                            return Math.max(0, end - Date.now());
                        }
                    };
                    runner(Object.freeze(deadline));
                });
                let disposed = false;
                return {
                    dispose() {
                        if (disposed) {
                            return;
                        }
                        disposed = true;
                    }
                };
            };
        }
        else {
            exports.$2h = (targetWindow, runner, timeout) => {
                const handle = targetWindow.requestIdleCallback(runner, typeof timeout === 'number' ? { timeout } : undefined);
                let disposed = false;
                return {
                    dispose() {
                        if (disposed) {
                            return;
                        }
                        disposed = true;
                        targetWindow.cancelIdleCallback(handle);
                    }
                };
            };
        }
        exports.$1h = (runner) => (0, exports.$2h)(globalThis, runner);
    })();
    class $3h {
        constructor(targetWindow, executor) {
            this.g = false;
            this.d = () => {
                try {
                    this.j = executor();
                }
                catch (err) {
                    this.l = err;
                }
                finally {
                    this.g = true;
                }
            };
            this.f = (0, exports.$2h)(targetWindow, () => this.d());
        }
        dispose() {
            this.f.dispose();
        }
        get value() {
            if (!this.g) {
                this.f.dispose();
                this.d();
            }
            if (this.l) {
                throw this.l;
            }
            return this.j;
        }
        get isInitialized() {
            return this.g;
        }
    }
    exports.$3h = $3h;
    /**
     * An `IdleValue` that always uses the current window (which might be throttled or inactive)
     *
     * **Note** that there is `dom.ts#WindowIdleValue` which is better suited when running inside a browser
     * context
     */
    class $4h extends $3h {
        constructor(executor) {
            super(globalThis, executor);
        }
    }
    exports.$4h = $4h;
    //#endregion
    async function $5h(task, delay, retries) {
        let lastError;
        for (let i = 0; i < retries; i++) {
            try {
                return await task();
            }
            catch (error) {
                lastError = error;
                await $Lh(delay);
            }
        }
        throw lastError;
    }
    /**
     * @deprecated use `LimitedQueue` instead for an easier to use API
     */
    class $6h {
        isRunning(taskId) {
            if (typeof taskId === 'number') {
                return this.a?.taskId === taskId;
            }
            return !!this.a;
        }
        get running() {
            return this.a?.promise;
        }
        cancelRunning() {
            this.a?.cancel();
        }
        run(taskId, promise, onCancel) {
            this.a = { taskId, cancel: () => onCancel?.(), promise };
            promise.then(() => this.d(taskId), () => this.d(taskId));
            return promise;
        }
        d(taskId) {
            if (this.a && taskId === this.a.taskId) {
                // only set running to done if the promise finished that is associated with that taskId
                this.a = undefined;
                // schedule the queued task now that we are free if we have any
                this.f();
            }
        }
        f() {
            if (this.b) {
                const queued = this.b;
                this.b = undefined;
                // Run queued task and complete on the associated promise
                queued.run().then(queued.promiseResolve, queued.promiseReject);
            }
        }
        /**
         * Note: the promise to schedule as next run MUST itself call `run`.
         *       Otherwise, this sequentializer will report `false` for `isRunning`
         *       even when this task is running. Missing this detail means that
         *       suddenly multiple tasks will run in parallel.
         */
        queue(run) {
            // this is our first queued task, so we create associated promise with it
            // so that we can return a promise that completes when the task has
            // completed.
            if (!this.b) {
                const { promise, resolve: promiseResolve, reject: promiseReject } = $Dh();
                this.b = {
                    run,
                    promise,
                    promiseResolve: promiseResolve,
                    promiseReject: promiseReject
                };
            }
            // we have a previous queued task, just overwrite it
            else {
                this.b.run = run;
            }
            return this.b.promise;
        }
        hasQueued() {
            return !!this.b;
        }
        async join() {
            return this.b?.promise ?? this.a?.promise;
        }
    }
    exports.$6h = $6h;
    //#endregion
    //#region
    /**
     * The `IntervalCounter` allows to count the number
     * of calls to `increment()` over a duration of
     * `interval`. This utility can be used to conditionally
     * throttle a frequent task when a certain threshold
     * is reached.
     */
    class $7h {
        constructor(d, f = () => Date.now()) {
            this.d = d;
            this.f = f;
            this.a = 0;
            this.b = 0;
        }
        increment() {
            const now = this.f();
            // We are outside of the range of `interval` and as such
            // start counting from 0 and remember the time
            if (now - this.a > this.d) {
                this.a = now;
                this.b = 0;
            }
            this.b++;
            return this.b;
        }
    }
    exports.$7h = $7h;
    var DeferredOutcome;
    (function (DeferredOutcome) {
        DeferredOutcome[DeferredOutcome["Resolved"] = 0] = "Resolved";
        DeferredOutcome[DeferredOutcome["Rejected"] = 1] = "Rejected";
    })(DeferredOutcome || (DeferredOutcome = {}));
    /**
     * Creates a promise whose resolution or rejection can be controlled imperatively.
     */
    class $8h {
        get isRejected() {
            return this.d?.outcome === DeferredOutcome.Rejected;
        }
        get isResolved() {
            return this.d?.outcome === DeferredOutcome.Resolved;
        }
        get isSettled() {
            return !!this.d;
        }
        get value() {
            return this.d?.outcome === DeferredOutcome.Resolved ? this.d?.value : undefined;
        }
        constructor() {
            this.p = new Promise((c, e) => {
                this.a = c;
                this.b = e;
            });
        }
        complete(value) {
            return new Promise(resolve => {
                this.a(value);
                this.d = { outcome: DeferredOutcome.Resolved, value };
                resolve();
            });
        }
        error(err) {
            return new Promise(resolve => {
                this.b(err);
                this.d = { outcome: DeferredOutcome.Rejected, value: err };
                resolve();
            });
        }
        cancel() {
            return this.error(new errors_1.$9());
        }
    }
    exports.$8h = $8h;
    //#endregion
    //#region Promises
    var Promises;
    (function (Promises) {
        /**
         * A drop-in replacement for `Promise.all` with the only difference
         * that the method awaits every promise to either fulfill or reject.
         *
         * Similar to `Promise.all`, only the first error will be returned
         * if any.
         */
        async function settled(promises) {
            let firstError = undefined;
            const result = await Promise.all(promises.map(promise => promise.then(value => value, error => {
                if (!firstError) {
                    firstError = error;
                }
                return undefined; // do not rethrow so that other promises can settle
            })));
            if (typeof firstError !== 'undefined') {
                throw firstError;
            }
            return result; // cast is needed and protected by the `throw` above
        }
        Promises.settled = settled;
        /**
         * A helper to create a new `Promise<T>` with a body that is a promise
         * itself. By default, an error that raises from the async body will
         * end up as a unhandled rejection, so this utility properly awaits the
         * body and rejects the promise as a normal promise does without async
         * body.
         *
         * This method should only be used in rare cases where otherwise `async`
         * cannot be used (e.g. when callbacks are involved that require this).
         */
        function withAsyncBody(bodyFn) {
            // eslint-disable-next-line no-async-promise-executor
            return new Promise(async (resolve, reject) => {
                try {
                    await bodyFn(resolve, reject);
                }
                catch (error) {
                    reject(error);
                }
            });
        }
        Promises.withAsyncBody = withAsyncBody;
    })(Promises || (exports.Promises = Promises = {}));
    class $9h {
        get value() { return this.a; }
        get error() { return this.b; }
        get isResolved() { return this.d; }
        constructor(promise) {
            this.a = undefined;
            this.b = undefined;
            this.d = false;
            this.promise = promise.then(value => {
                this.a = value;
                this.d = true;
                return value;
            }, error => {
                this.b = error;
                this.d = true;
                throw error;
            });
        }
        /**
         * Returns the resolved value.
         * Throws if the promise is not resolved yet.
         */
        requireValue() {
            if (!this.d) {
                throw new errors_1.$gb('Promise is not resolved yet');
            }
            if (this.b) {
                throw this.b;
            }
            return this.a;
        }
    }
    exports.$9h = $9h;
    class $0h {
        constructor(b) {
            this.b = b;
            this.a = new lazy_1.$Y(() => new $9h(this.b()));
        }
        /**
         * Returns the resolved value.
         * Throws if the promise is not resolved yet.
         */
        requireValue() {
            return this.a.value.requireValue();
        }
        /**
         * Returns the promise (and triggers a computation of the promise if not yet done so).
         */
        getPromise() {
            return this.a.value.promise;
        }
        /**
         * Reads the current value without triggering a computation of the promise.
         */
        get currentValue() {
            return this.a.rawValue?.value;
        }
    }
    exports.$0h = $0h;
    //#endregion
    //#region
    var AsyncIterableSourceState;
    (function (AsyncIterableSourceState) {
        AsyncIterableSourceState[AsyncIterableSourceState["Initial"] = 0] = "Initial";
        AsyncIterableSourceState[AsyncIterableSourceState["DoneOK"] = 1] = "DoneOK";
        AsyncIterableSourceState[AsyncIterableSourceState["DoneError"] = 2] = "DoneError";
    })(AsyncIterableSourceState || (AsyncIterableSourceState = {}));
    /**
     * A rich implementation for an `AsyncIterable<T>`.
     */
    class $$h {
        static fromArray(items) {
            return new $$h((writer) => {
                writer.emitMany(items);
            });
        }
        static fromPromise(promise) {
            return new $$h(async (emitter) => {
                emitter.emitMany(await promise);
            });
        }
        static fromPromises(promises) {
            return new $$h(async (emitter) => {
                await Promise.all(promises.map(async (p) => emitter.emitOne(await p)));
            });
        }
        static merge(iterables) {
            return new $$h(async (emitter) => {
                await Promise.all(iterables.map(async (iterable) => {
                    for await (const item of iterable) {
                        emitter.emitOne(item);
                    }
                }));
            });
        }
        static { this.EMPTY = $$h.fromArray([]); }
        constructor(executor, onReturn) {
            this.a = AsyncIterableSourceState.Initial;
            this.b = [];
            this.d = null;
            this.f = onReturn;
            this.g = new event_1.$qe();
            queueMicrotask(async () => {
                const writer = {
                    emitOne: (item) => this.h(item),
                    emitMany: (items) => this.j(items),
                    reject: (error) => this.l(error)
                };
                try {
                    await Promise.resolve(executor(writer));
                    this.k();
                }
                catch (err) {
                    this.l(err);
                }
                finally {
                    writer.emitOne = undefined;
                    writer.emitMany = undefined;
                    writer.reject = undefined;
                }
            });
        }
        [Symbol.asyncIterator]() {
            let i = 0;
            return {
                next: async () => {
                    do {
                        if (this.a === AsyncIterableSourceState.DoneError) {
                            throw this.d;
                        }
                        if (i < this.b.length) {
                            return { done: false, value: this.b[i++] };
                        }
                        if (this.a === AsyncIterableSourceState.DoneOK) {
                            return { done: true, value: undefined };
                        }
                        await event_1.Event.toPromise(this.g.event);
                    } while (true);
                },
                return: async () => {
                    this.f?.();
                    return { done: true, value: undefined };
                }
            };
        }
        static map(iterable, mapFn) {
            return new $$h(async (emitter) => {
                for await (const item of iterable) {
                    emitter.emitOne(mapFn(item));
                }
            });
        }
        map(mapFn) {
            return $$h.map(this, mapFn);
        }
        static filter(iterable, filterFn) {
            return new $$h(async (emitter) => {
                for await (const item of iterable) {
                    if (filterFn(item)) {
                        emitter.emitOne(item);
                    }
                }
            });
        }
        filter(filterFn) {
            return $$h.filter(this, filterFn);
        }
        static coalesce(iterable) {
            return $$h.filter(iterable, item => !!item);
        }
        coalesce() {
            return $$h.coalesce(this);
        }
        static async toPromise(iterable) {
            const result = [];
            for await (const item of iterable) {
                result.push(item);
            }
            return result;
        }
        toPromise() {
            return $$h.toPromise(this);
        }
        /**
         * The value will be appended at the end.
         *
         * **NOTE** If `resolve()` or `reject()` have already been called, this method has no effect.
         */
        h(value) {
            if (this.a !== AsyncIterableSourceState.Initial) {
                return;
            }
            // it is important to add new values at the end,
            // as we may have iterators already running on the array
            this.b.push(value);
            this.g.fire();
        }
        /**
         * The values will be appended at the end.
         *
         * **NOTE** If `resolve()` or `reject()` have already been called, this method has no effect.
         */
        j(values) {
            if (this.a !== AsyncIterableSourceState.Initial) {
                return;
            }
            // it is important to add new values at the end,
            // as we may have iterators already running on the array
            this.b = this.b.concat(values);
            this.g.fire();
        }
        /**
         * Calling `resolve()` will mark the result array as complete.
         *
         * **NOTE** `resolve()` must be called, otherwise all consumers of this iterable will hang indefinitely, similar to a non-resolved promise.
         * **NOTE** If `resolve()` or `reject()` have already been called, this method has no effect.
         */
        k() {
            if (this.a !== AsyncIterableSourceState.Initial) {
                return;
            }
            this.a = AsyncIterableSourceState.DoneOK;
            this.g.fire();
        }
        /**
         * Writing an error will permanently invalidate this iterable.
         * The current users will receive an error thrown, as will all future users.
         *
         * **NOTE** If `resolve()` or `reject()` have already been called, this method has no effect.
         */
        l(error) {
            if (this.a !== AsyncIterableSourceState.Initial) {
                return;
            }
            this.a = AsyncIterableSourceState.DoneError;
            this.d = error;
            this.g.fire();
        }
    }
    exports.$$h = $$h;
    class $_h extends $$h {
        constructor(m, executor) {
            super(executor);
            this.m = m;
        }
        cancel() {
            this.m.cancel();
        }
    }
    exports.$_h = $_h;
    function $ai(callback) {
        const source = new cancellation_1.$Be();
        const innerIterable = callback(source.token);
        return new $_h(source, async (emitter) => {
            const subscription = source.token.onCancellationRequested(() => {
                subscription.dispose();
                source.dispose();
                emitter.reject(new errors_1.$9());
            });
            try {
                for await (const item of innerIterable) {
                    if (source.token.isCancellationRequested) {
                        // canceled in the meantime
                        return;
                    }
                    emitter.emitOne(item);
                }
                subscription.dispose();
                source.dispose();
            }
            catch (err) {
                subscription.dispose();
                source.dispose();
                emitter.reject(err);
            }
        });
    }
    class $bi {
        /**
         *
         * @param onReturn A function that will be called when consuming the async iterable
         * has finished by the consumer, e.g the for-await-loop has be existed (break, return) early.
         * This is NOT called when resolving this source by its owner.
         */
        constructor(onReturn) {
            this.a = new $8h();
            this.b = new $$h(emitter => {
                if (earlyError) {
                    emitter.reject(earlyError);
                    return;
                }
                if (earlyItems) {
                    emitter.emitMany(earlyItems);
                }
                this.d = (error) => emitter.reject(error);
                this.f = (item) => emitter.emitOne(item);
                return this.a.p;
            }, onReturn);
            let earlyError;
            let earlyItems;
            this.f = (item) => {
                if (!earlyItems) {
                    earlyItems = [];
                }
                earlyItems.push(item);
            };
            this.d = (error) => {
                if (!earlyError) {
                    earlyError = error;
                }
            };
        }
        get asyncIterable() {
            return this.b;
        }
        resolve() {
            this.a.complete();
        }
        reject(error) {
            this.d(error);
            this.a.complete();
        }
        emitOne(item) {
            this.f(item);
        }
    }
    exports.$bi = $bi;
});
//#endregion

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[62/*vs/base/common/uriIpc*/], __M([0/*require*/,1/*exports*/,19/*vs/base/common/buffer*/,27/*vs/base/common/marshallingIds*/,6/*vs/base/common/uri*/]), function (require, exports, buffer_1, marshallingIds_1, uri_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$Tn = exports.$Sn = void 0;
    exports.$Un = $Un;
    exports.$Vn = $Vn;
    exports.$Wn = $Wn;
    function toJSON(uri) {
        return uri.toJSON();
    }
    class $Sn {
        constructor(uriTransformer) {
            this.a = uriTransformer;
        }
        transformIncoming(uri) {
            const result = this.a.transformIncoming(uri);
            return (result === uri ? uri : toJSON(uri_1.URI.from(result)));
        }
        transformOutgoing(uri) {
            const result = this.a.transformOutgoing(uri);
            return (result === uri ? uri : toJSON(uri_1.URI.from(result)));
        }
        transformOutgoingURI(uri) {
            const result = this.a.transformOutgoing(uri);
            return (result === uri ? uri : uri_1.URI.from(result));
        }
        transformOutgoingScheme(scheme) {
            return this.a.transformOutgoingScheme(scheme);
        }
    }
    exports.$Sn = $Sn;
    exports.$Tn = new class {
        transformIncoming(uri) {
            return uri;
        }
        transformOutgoing(uri) {
            return uri;
        }
        transformOutgoingURI(uri) {
            return uri;
        }
        transformOutgoingScheme(scheme) {
            return scheme;
        }
    };
    function _transformOutgoingURIs(obj, transformer, depth) {
        if (!obj || depth > 200) {
            return null;
        }
        if (typeof obj === 'object') {
            if (obj instanceof uri_1.URI) {
                return transformer.transformOutgoing(obj);
            }
            // walk object (or array)
            for (const key in obj) {
                if (Object.hasOwnProperty.call(obj, key)) {
                    const r = _transformOutgoingURIs(obj[key], transformer, depth + 1);
                    if (r !== null) {
                        obj[key] = r;
                    }
                }
            }
        }
        return null;
    }
    function $Un(obj, transformer) {
        const result = _transformOutgoingURIs(obj, transformer, 0);
        if (result === null) {
            // no change
            return obj;
        }
        return result;
    }
    function _transformIncomingURIs(obj, transformer, revive, depth) {
        if (!obj || depth > 200) {
            return null;
        }
        if (typeof obj === 'object') {
            if (obj.$mid === marshallingIds_1.MarshalledId.Uri) {
                return revive ? uri_1.URI.revive(transformer.transformIncoming(obj)) : transformer.transformIncoming(obj);
            }
            if (obj instanceof buffer_1.$Se) {
                return null;
            }
            // walk object (or array)
            for (const key in obj) {
                if (Object.hasOwnProperty.call(obj, key)) {
                    const r = _transformIncomingURIs(obj[key], transformer, revive, depth + 1);
                    if (r !== null) {
                        obj[key] = r;
                    }
                }
            }
        }
        return null;
    }
    function $Vn(obj, transformer) {
        const result = _transformIncomingURIs(obj, transformer, false, 0);
        if (result === null) {
            // no change
            return obj;
        }
        return result;
    }
    function $Wn(obj, transformer) {
        const result = _transformIncomingURIs(obj, transformer, true, 0);
        if (result === null) {
            // no change
            return obj;
        }
        return result;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/























define(__m[28/*vs/base/node/pfs*/], __M([0/*require*/,1/*exports*/,37/*fs*/,21/*os*/,101/*util*/,12/*vs/base/common/async*/,35/*vs/base/common/extpath*/,49/*vs/base/common/normalization*/,5/*vs/base/common/path*/,3/*vs/base/common/platform*/,25/*vs/base/common/resources*/,6/*vs/base/common/uri*/]), function (require, exports, fs, os_1, util_1, async_1, extpath_1, normalization_1, path_1, platform_1, resources_1, uri_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.Promises = exports.SymlinkSupport = exports.RimRafMode = void 0;
    exports.rimrafSync = rimrafSync;
    exports.readdirSync = readdirSync;
    exports.whenDeleted = whenDeleted;
    exports.configureFlushOnWrite = configureFlushOnWrite;
    exports.writeFileSync = writeFileSync;
    fs = __importStar(fs);
    //#region rimraf
    var RimRafMode;
    (function (RimRafMode) {
        /**
         * Slow version that unlinks each file and folder.
         */
        RimRafMode[RimRafMode["UNLINK"] = 0] = "UNLINK";
        /**
         * Fast version that first moves the file/folder
         * into a temp directory and then deletes that
         * without waiting for it.
         */
        RimRafMode[RimRafMode["MOVE"] = 1] = "MOVE";
    })(RimRafMode || (exports.RimRafMode = RimRafMode = {}));
    async function rimraf(path, mode = RimRafMode.UNLINK, moveToPath) {
        if ((0, extpath_1.$Ng)(path)) {
            throw new Error('rimraf - will refuse to recursively delete root');
        }
        // delete: via rm
        if (mode === RimRafMode.UNLINK) {
            return rimrafUnlink(path);
        }
        // delete: via move
        return rimrafMove(path, moveToPath);
    }
    async function rimrafMove(path, moveToPath = (0, extpath_1.$Sg)((0, os_1.tmpdir)())) {
        try {
            try {
                await fs.promises.rename(path, moveToPath);
            }
            catch (error) {
                if (error.code === 'ENOENT') {
                    return; // ignore - path to delete did not exist
                }
                return rimrafUnlink(path); // otherwise fallback to unlink
            }
            // Delete but do not return as promise
            rimrafUnlink(moveToPath).catch(error => { });
        }
        catch (error) {
            if (error.code !== 'ENOENT') {
                throw error;
            }
        }
    }
    async function rimrafUnlink(path) {
        return fs.promises.rm(path, { recursive: true, force: true, maxRetries: 3 });
    }
    function rimrafSync(path) {
        if ((0, extpath_1.$Ng)(path)) {
            throw new Error('rimraf - will refuse to recursively delete root');
        }
        fs.rmSync(path, { recursive: true, force: true, maxRetries: 3 });
    }
    async function readdir(path, options) {
        return handleDirectoryChildren(await (options ? safeReaddirWithFileTypes(path) : fs.promises.readdir(path)));
    }
    async function safeReaddirWithFileTypes(path) {
        try {
            return await fs.promises.readdir(path, { withFileTypes: true });
        }
        catch (error) {
            console.warn('[node.js fs] readdir with filetypes failed with error: ', error);
        }
        // Fallback to manually reading and resolving each
        // children of the folder in case we hit an error
        // previously.
        // This can only really happen on exotic file systems
        // such as explained in #115645 where we get entries
        // from `readdir` that we can later not `lstat`.
        const result = [];
        const children = await readdir(path);
        for (const child of children) {
            let isFile = false;
            let isDirectory = false;
            let isSymbolicLink = false;
            try {
                const lstat = await fs.promises.lstat((0, path_1.$oc)(path, child));
                isFile = lstat.isFile();
                isDirectory = lstat.isDirectory();
                isSymbolicLink = lstat.isSymbolicLink();
            }
            catch (error) {
                console.warn('[node.js fs] unexpected error from lstat after readdir: ', error);
            }
            result.push({
                name: child,
                isFile: () => isFile,
                isDirectory: () => isDirectory,
                isSymbolicLink: () => isSymbolicLink
            });
        }
        return result;
    }
    /**
     * Drop-in replacement of `fs.readdirSync` with support
     * for converting from macOS NFD unicon form to NFC
     * (https://github.com/nodejs/node/issues/2165)
     */
    function readdirSync(path) {
        return handleDirectoryChildren(fs.readdirSync(path));
    }
    function handleDirectoryChildren(children) {
        return children.map(child => {
            // Mac: uses NFD unicode form on disk, but we want NFC
            // See also https://github.com/nodejs/node/issues/2165
            if (typeof child === 'string') {
                return platform_1.$m ? (0, normalization_1.$sm)(child) : child;
            }
            child.name = platform_1.$m ? (0, normalization_1.$sm)(child.name) : child.name;
            return child;
        });
    }
    /**
     * A convenience method to read all children of a path that
     * are directories.
     */
    async function readDirsInDir(dirPath) {
        const children = await readdir(dirPath);
        const directories = [];
        for (const child of children) {
            if (await SymlinkSupport.existsDirectory((0, path_1.$oc)(dirPath, child))) {
                directories.push(child);
            }
        }
        return directories;
    }
    //#endregion
    //#region whenDeleted()
    /**
     * A `Promise` that resolves when the provided `path`
     * is deleted from disk.
     */
    function whenDeleted(path, intervalMs = 1000) {
        return new Promise(resolve => {
            let running = false;
            const interval = setInterval(() => {
                if (!running) {
                    running = true;
                    fs.access(path, err => {
                        running = false;
                        if (err) {
                            clearInterval(interval);
                            resolve(undefined);
                        }
                    });
                }
            }, intervalMs);
        });
    }
    //#endregion
    //#region Methods with symbolic links support
    var SymlinkSupport;
    (function (SymlinkSupport) {
        /**
         * Resolves the `fs.Stats` of the provided path. If the path is a
         * symbolic link, the `fs.Stats` will be from the target it points
         * to. If the target does not exist, `dangling: true` will be returned
         * as `symbolicLink` value.
         */
        async function stat(path) {
            // First stat the link
            let lstats;
            try {
                lstats = await fs.promises.lstat(path);
                // Return early if the stat is not a symbolic link at all
                if (!lstats.isSymbolicLink()) {
                    return { stat: lstats };
                }
            }
            catch (error) {
                /* ignore - use stat() instead */
            }
            // If the stat is a symbolic link or failed to stat, use fs.stat()
            // which for symbolic links will stat the target they point to
            try {
                const stats = await fs.promises.stat(path);
                return { stat: stats, symbolicLink: lstats?.isSymbolicLink() ? { dangling: false } : undefined };
            }
            catch (error) {
                // If the link points to a nonexistent file we still want
                // to return it as result while setting dangling: true flag
                if (error.code === 'ENOENT' && lstats) {
                    return { stat: lstats, symbolicLink: { dangling: true } };
                }
                // Windows: workaround a node.js bug where reparse points
                // are not supported (https://github.com/nodejs/node/issues/36790)
                if (platform_1.$l && error.code === 'EACCES') {
                    try {
                        const stats = await fs.promises.stat(await fs.promises.readlink(path));
                        return { stat: stats, symbolicLink: { dangling: false } };
                    }
                    catch (error) {
                        // If the link points to a nonexistent file we still want
                        // to return it as result while setting dangling: true flag
                        if (error.code === 'ENOENT' && lstats) {
                            return { stat: lstats, symbolicLink: { dangling: true } };
                        }
                        throw error;
                    }
                }
                throw error;
            }
        }
        SymlinkSupport.stat = stat;
        /**
         * Figures out if the `path` exists and is a file with support
         * for symlinks.
         *
         * Note: this will return `false` for a symlink that exists on
         * disk but is dangling (pointing to a nonexistent path).
         *
         * Use `exists` if you only care about the path existing on disk
         * or not without support for symbolic links.
         */
        async function existsFile(path) {
            try {
                const { stat, symbolicLink } = await SymlinkSupport.stat(path);
                return stat.isFile() && symbolicLink?.dangling !== true;
            }
            catch (error) {
                // Ignore, path might not exist
            }
            return false;
        }
        SymlinkSupport.existsFile = existsFile;
        /**
         * Figures out if the `path` exists and is a directory with support for
         * symlinks.
         *
         * Note: this will return `false` for a symlink that exists on
         * disk but is dangling (pointing to a nonexistent path).
         *
         * Use `exists` if you only care about the path existing on disk
         * or not without support for symbolic links.
         */
        async function existsDirectory(path) {
            try {
                const { stat, symbolicLink } = await SymlinkSupport.stat(path);
                return stat.isDirectory() && symbolicLink?.dangling !== true;
            }
            catch (error) {
                // Ignore, path might not exist
            }
            return false;
        }
        SymlinkSupport.existsDirectory = existsDirectory;
    })(SymlinkSupport || (exports.SymlinkSupport = SymlinkSupport = {}));
    //#endregion
    //#region Write File
    // According to node.js docs (https://nodejs.org/docs/v14.16.0/api/fs.html#fs_fs_writefile_file_data_options_callback)
    // it is not safe to call writeFile() on the same path multiple times without waiting for the callback to return.
    // Therefor we use a Queue on the path that is given to us to sequentialize calls to the same path properly.
    const writeQueues = new async_1.$Th();
    function writeFile(path, data, options) {
        return writeQueues.queueFor(uri_1.URI.file(path), () => {
            const ensuredOptions = ensureWriteOptions(options);
            return new Promise((resolve, reject) => doWriteFileAndFlush(path, data, ensuredOptions, error => error ? reject(error) : resolve()));
        }, resources_1.$ch);
    }
    let canFlush = true;
    function configureFlushOnWrite(enabled) {
        canFlush = enabled;
    }
    // Calls fs.writeFile() followed by a fs.sync() call to flush the changes to disk
    // We do this in cases where we want to make sure the data is really on disk and
    // not in some cache.
    //
    // See https://github.com/nodejs/node/blob/v5.10.0/lib/fs.js#L1194
    function doWriteFileAndFlush(path, data, options, callback) {
        if (!canFlush) {
            return fs.writeFile(path, data, { mode: options.mode, flag: options.flag }, callback);
        }
        // Open the file with same flags and mode as fs.writeFile()
        fs.open(path, options.flag, options.mode, (openError, fd) => {
            if (openError) {
                return callback(openError);
            }
            // It is valid to pass a fd handle to fs.writeFile() and this will keep the handle open!
            fs.writeFile(fd, data, writeError => {
                if (writeError) {
                    return fs.close(fd, () => callback(writeError)); // still need to close the handle on error!
                }
                // Flush contents (not metadata) of the file to disk
                // https://github.com/microsoft/vscode/issues/9589
                fs.fdatasync(fd, (syncError) => {
                    // In some exotic setups it is well possible that node fails to sync
                    // In that case we disable flushing and warn to the console
                    if (syncError) {
                        console.warn('[node.js fs] fdatasync is now disabled for this session because it failed: ', syncError);
                        configureFlushOnWrite(false);
                    }
                    return fs.close(fd, closeError => callback(closeError));
                });
            });
        });
    }
    /**
     * Same as `fs.writeFileSync` but with an additional call to
     * `fs.fdatasyncSync` after writing to ensure changes are
     * flushed to disk.
     */
    function writeFileSync(path, data, options) {
        const ensuredOptions = ensureWriteOptions(options);
        if (!canFlush) {
            return fs.writeFileSync(path, data, { mode: ensuredOptions.mode, flag: ensuredOptions.flag });
        }
        // Open the file with same flags and mode as fs.writeFile()
        const fd = fs.openSync(path, ensuredOptions.flag, ensuredOptions.mode);
        try {
            // It is valid to pass a fd handle to fs.writeFile() and this will keep the handle open!
            fs.writeFileSync(fd, data);
            // Flush contents (not metadata) of the file to disk
            try {
                fs.fdatasyncSync(fd); // https://github.com/microsoft/vscode/issues/9589
            }
            catch (syncError) {
                console.warn('[node.js fs] fdatasyncSync is now disabled for this session because it failed: ', syncError);
                configureFlushOnWrite(false);
            }
        }
        finally {
            fs.closeSync(fd);
        }
    }
    function ensureWriteOptions(options) {
        if (!options) {
            return { mode: 0o666 /* default node.js mode for files */, flag: 'w' };
        }
        return {
            mode: typeof options.mode === 'number' ? options.mode : 0o666 /* default node.js mode for files */,
            flag: typeof options.flag === 'string' ? options.flag : 'w'
        };
    }
    //#endregion
    //#region Move / Copy
    /**
     * A drop-in replacement for `fs.rename` that:
     * - allows to move across multiple disks
     * - attempts to retry the operation for certain error codes on Windows
     */
    async function rename(source, target, windowsRetryTimeout = 60000) {
        if (source === target) {
            return; // simulate node.js behaviour here and do a no-op if paths match
        }
        try {
            if (platform_1.$l && typeof windowsRetryTimeout === 'number') {
                // On Windows, a rename can fail when either source or target
                // is locked by AV software.
                await renameWithRetry(source, target, Date.now(), windowsRetryTimeout);
            }
            else {
                await fs.promises.rename(source, target);
            }
        }
        catch (error) {
            // In two cases we fallback to classic copy and delete:
            //
            // 1.) The EXDEV error indicates that source and target are on different devices
            // In this case, fallback to using a copy() operation as there is no way to
            // rename() between different devices.
            //
            // 2.) The user tries to rename a file/folder that ends with a dot. This is not
            // really possible to move then, at least on UNC devices.
            if (source.toLowerCase() !== target.toLowerCase() && error.code === 'EXDEV' || source.endsWith('.')) {
                await copy(source, target, { preserveSymlinks: false /* copying to another device */ });
                await rimraf(source, RimRafMode.MOVE);
            }
            else {
                throw error;
            }
        }
    }
    async function renameWithRetry(source, target, startTime, retryTimeout, attempt = 0) {
        try {
            return await fs.promises.rename(source, target);
        }
        catch (error) {
            if (error.code !== 'EACCES' && error.code !== 'EPERM' && error.code !== 'EBUSY') {
                throw error; // only for errors we think are temporary
            }
            if (Date.now() - startTime >= retryTimeout) {
                console.error(`[node.js fs] rename failed after ${attempt} retries with error: ${error}`);
                throw error; // give up after configurable timeout
            }
            if (attempt === 0) {
                let abortRetry = false;
                try {
                    const { stat } = await SymlinkSupport.stat(target);
                    if (!stat.isFile()) {
                        abortRetry = true; // if target is not a file, EPERM error may be raised and we should not attempt to retry
                    }
                }
                catch (error) {
                    // Ignore
                }
                if (abortRetry) {
                    throw error;
                }
            }
            // Delay with incremental backoff up to 100ms
            await (0, async_1.$Lh)(Math.min(100, attempt * 10));
            // Attempt again
            return renameWithRetry(source, target, startTime, retryTimeout, attempt + 1);
        }
    }
    /**
     * Recursively copies all of `source` to `target`.
     *
     * The options `preserveSymlinks` configures how symbolic
     * links should be handled when encountered. Set to
     * `false` to not preserve them and `true` otherwise.
     */
    async function copy(source, target, options) {
        return doCopy(source, target, { root: { source, target }, options, handledSourcePaths: new Set() });
    }
    // When copying a file or folder, we want to preserve the mode
    // it had and as such provide it when creating. However, modes
    // can go beyond what we expect (see link below), so we mask it.
    // (https://github.com/nodejs/node-v0.x-archive/issues/3045#issuecomment-4862588)
    const COPY_MODE_MASK = 0o777;
    async function doCopy(source, target, payload) {
        // Keep track of paths already copied to prevent
        // cycles from symbolic links to cause issues
        if (payload.handledSourcePaths.has(source)) {
            return;
        }
        else {
            payload.handledSourcePaths.add(source);
        }
        const { stat, symbolicLink } = await SymlinkSupport.stat(source);
        // Symlink
        if (symbolicLink) {
            // Try to re-create the symlink unless `preserveSymlinks: false`
            if (payload.options.preserveSymlinks) {
                try {
                    return await doCopySymlink(source, target, payload);
                }
                catch (error) {
                    // in any case of an error fallback to normal copy via dereferencing
                }
            }
            if (symbolicLink.dangling) {
                return; // skip dangling symbolic links from here on (https://github.com/microsoft/vscode/issues/111621)
            }
        }
        // Folder
        if (stat.isDirectory()) {
            return doCopyDirectory(source, target, stat.mode & COPY_MODE_MASK, payload);
        }
        // File or file-like
        else {
            return doCopyFile(source, target, stat.mode & COPY_MODE_MASK);
        }
    }
    async function doCopyDirectory(source, target, mode, payload) {
        // Create folder
        await fs.promises.mkdir(target, { recursive: true, mode });
        // Copy each file recursively
        const files = await readdir(source);
        for (const file of files) {
            await doCopy((0, path_1.$oc)(source, file), (0, path_1.$oc)(target, file), payload);
        }
    }
    async function doCopyFile(source, target, mode) {
        // Copy file
        await fs.promises.copyFile(source, target);
        // restore mode (https://github.com/nodejs/node/issues/1104)
        await fs.promises.chmod(target, mode);
    }
    async function doCopySymlink(source, target, payload) {
        // Figure out link target
        let linkTarget = await fs.promises.readlink(source);
        // Special case: the symlink points to a target that is
        // actually within the path that is being copied. In that
        // case we want the symlink to point to the target and
        // not the source
        if ((0, extpath_1.$Jg)(linkTarget, payload.root.source, !platform_1.$n)) {
            linkTarget = (0, path_1.$oc)(payload.root.target, linkTarget.substr(payload.root.source.length + 1));
        }
        // Create symlink
        await fs.promises.symlink(linkTarget, target);
    }
    //#endregion
    //#region Promise based fs methods
    /**
     * Some low level `fs` methods provided as `Promises` similar to
     * `fs.promises` but with notable differences, either implemented
     * by us or by restoring the original callback based behavior.
     *
     * At least `realpath` is implemented differently in the promise
     * based implementation compared to the callback based one. The
     * promise based implementation actually calls `fs.realpath.native`.
     * (https://github.com/microsoft/vscode/issues/118562)
     */
    exports.Promises = new class {
        //#region Implemented by node.js
        get read() {
            // Not using `promisify` here for a reason: the return
            // type is not an object as indicated by TypeScript but
            // just the bytes read, so we create our own wrapper.
            return (fd, buffer, offset, length, position) => {
                return new Promise((resolve, reject) => {
                    fs.read(fd, buffer, offset, length, position, (err, bytesRead, buffer) => {
                        if (err) {
                            return reject(err);
                        }
                        return resolve({ bytesRead, buffer });
                    });
                });
            };
        }
        get write() {
            // Not using `promisify` here for a reason: the return
            // type is not an object as indicated by TypeScript but
            // just the bytes written, so we create our own wrapper.
            return (fd, buffer, offset, length, position) => {
                return new Promise((resolve, reject) => {
                    fs.write(fd, buffer, offset, length, position, (err, bytesWritten, buffer) => {
                        if (err) {
                            return reject(err);
                        }
                        return resolve({ bytesWritten, buffer });
                    });
                });
            };
        }
        get fdatasync() { return (0, util_1.promisify)(fs.fdatasync); } // not exposed as API in 20.x yet
        get open() { return (0, util_1.promisify)(fs.open); } // changed to return `FileHandle` in promise API
        get close() { return (0, util_1.promisify)(fs.close); } // not exposed as API due to the `FileHandle` return type of `open`
        get realpath() { return (0, util_1.promisify)(fs.realpath); } // `fs.promises.realpath` will use `fs.realpath.native` which we do not want
        //#endregion
        //#region Implemented by us
        async exists(path) {
            try {
                await fs.promises.access(path);
                return true;
            }
            catch {
                return false;
            }
        }
        get readdir() { return readdir; }
        get readDirsInDir() { return readDirsInDir; }
        get writeFile() { return writeFile; }
        get rm() { return rimraf; }
        get rename() { return rename; }
        get copy() { return copy; }
    };
});
//#endregion

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/























define(__m[63/*vs/base/node/powershell*/], __M([0/*require*/,1/*exports*/,21/*os*/,5/*vs/base/common/path*/,28/*vs/base/node/pfs*/]), function (require, exports, os, path, pfs) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$Bm = $Bm;
    exports.$Cm = $Cm;
    os = __importStar(os);
    path = __importStar(path);
    pfs = __importStar(pfs);
    // This is required, since parseInt("7-preview") will return 7.
    const IntRegex = /^\d+$/;
    const PwshMsixRegex = /^Microsoft.PowerShell_.*/;
    const PwshPreviewMsixRegex = /^Microsoft.PowerShellPreview_.*/;
    var Arch;
    (function (Arch) {
        Arch[Arch["x64"] = 0] = "x64";
        Arch[Arch["x86"] = 1] = "x86";
        Arch[Arch["ARM"] = 2] = "ARM";
    })(Arch || (Arch = {}));
    let processArch;
    switch (process.arch) {
        case 'ia32':
            processArch = Arch.x86;
            break;
        case 'arm':
        case 'arm64':
            processArch = Arch.ARM;
            break;
        default:
            processArch = Arch.x64;
            break;
    }
    /*
    Currently, here are the values for these environment variables on their respective archs:
    
    On x86 process on x86:
    PROCESSOR_ARCHITECTURE is X86
    PROCESSOR_ARCHITEW6432 is undefined
    
    On x86 process on x64:
    PROCESSOR_ARCHITECTURE is X86
    PROCESSOR_ARCHITEW6432 is AMD64
    
    On x64 process on x64:
    PROCESSOR_ARCHITECTURE is AMD64
    PROCESSOR_ARCHITEW6432 is undefined
    
    On ARM process on ARM:
    PROCESSOR_ARCHITECTURE is ARM64
    PROCESSOR_ARCHITEW6432 is undefined
    
    On x86 process on ARM:
    PROCESSOR_ARCHITECTURE is X86
    PROCESSOR_ARCHITEW6432 is ARM64
    
    On x64 process on ARM:
    PROCESSOR_ARCHITECTURE is ARM64
    PROCESSOR_ARCHITEW6432 is undefined
    */
    let osArch;
    if (process.env['PROCESSOR_ARCHITEW6432']) {
        osArch = process.env['PROCESSOR_ARCHITEW6432'] === 'ARM64'
            ? Arch.ARM
            : Arch.x64;
    }
    else if (process.env['PROCESSOR_ARCHITECTURE'] === 'ARM64') {
        osArch = Arch.ARM;
    }
    else if (process.env['PROCESSOR_ARCHITECTURE'] === 'X86') {
        osArch = Arch.x86;
    }
    else {
        osArch = Arch.x64;
    }
    class PossiblePowerShellExe {
        constructor(exePath, displayName, a) {
            this.exePath = exePath;
            this.displayName = displayName;
            this.a = a;
        }
        async exists() {
            if (this.a === undefined) {
                this.a = await pfs.SymlinkSupport.existsFile(this.exePath);
            }
            return this.a;
        }
    }
    function getProgramFilesPath({ useAlternateBitness = false } = {}) {
        if (!useAlternateBitness) {
            // Just use the native system bitness
            return process.env.ProgramFiles || null;
        }
        // We might be a 64-bit process looking for 32-bit program files
        if (processArch === Arch.x64) {
            return process.env['ProgramFiles(x86)'] || null;
        }
        // We might be a 32-bit process looking for 64-bit program files
        if (osArch === Arch.x64) {
            return process.env.ProgramW6432 || null;
        }
        // We're a 32-bit process on 32-bit Windows, there is no other Program Files dir
        return null;
    }
    async function findPSCoreWindowsInstallation({ useAlternateBitness = false, findPreview = false } = {}) {
        const programFilesPath = getProgramFilesPath({ useAlternateBitness });
        if (!programFilesPath) {
            return null;
        }
        const powerShellInstallBaseDir = path.$oc(programFilesPath, 'PowerShell');
        // Ensure the base directory exists
        if (!await pfs.SymlinkSupport.existsDirectory(powerShellInstallBaseDir)) {
            return null;
        }
        let highestSeenVersion = -1;
        let pwshExePath = null;
        for (const item of await pfs.Promises.readdir(powerShellInstallBaseDir)) {
            let currentVersion = -1;
            if (findPreview) {
                // We are looking for something like "7-preview"
                // Preview dirs all have dashes in them
                const dashIndex = item.indexOf('-');
                if (dashIndex < 0) {
                    continue;
                }
                // Verify that the part before the dash is an integer
                // and that the part after the dash is "preview"
                const intPart = item.substring(0, dashIndex);
                if (!IntRegex.test(intPart) || item.substring(dashIndex + 1) !== 'preview') {
                    continue;
                }
                currentVersion = parseInt(intPart, 10);
            }
            else {
                // Search for a directory like "6" or "7"
                if (!IntRegex.test(item)) {
                    continue;
                }
                currentVersion = parseInt(item, 10);
            }
            // Ensure we haven't already seen a higher version
            if (currentVersion <= highestSeenVersion) {
                continue;
            }
            // Now look for the file
            const exePath = path.$oc(powerShellInstallBaseDir, item, 'pwsh.exe');
            if (!await pfs.SymlinkSupport.existsFile(exePath)) {
                continue;
            }
            pwshExePath = exePath;
            highestSeenVersion = currentVersion;
        }
        if (!pwshExePath) {
            return null;
        }
        const bitness = programFilesPath.includes('x86') ? ' (x86)' : '';
        const preview = findPreview ? ' Preview' : '';
        return new PossiblePowerShellExe(pwshExePath, `PowerShell${preview}${bitness}`, true);
    }
    async function findPSCoreMsix({ findPreview } = {}) {
        // We can't proceed if there's no LOCALAPPDATA path
        if (!process.env.LOCALAPPDATA) {
            return null;
        }
        // Find the base directory for MSIX application exe shortcuts
        const msixAppDir = path.$oc(process.env.LOCALAPPDATA, 'Microsoft', 'WindowsApps');
        if (!await pfs.SymlinkSupport.existsDirectory(msixAppDir)) {
            return null;
        }
        // Define whether we're looking for the preview or the stable
        const { pwshMsixDirRegex, pwshMsixName } = findPreview
            ? { pwshMsixDirRegex: PwshPreviewMsixRegex, pwshMsixName: 'PowerShell Preview (Store)' }
            : { pwshMsixDirRegex: PwshMsixRegex, pwshMsixName: 'PowerShell (Store)' };
        // We should find only one such application, so return on the first one
        for (const subdir of await pfs.Promises.readdir(msixAppDir)) {
            if (pwshMsixDirRegex.test(subdir)) {
                const pwshMsixPath = path.$oc(msixAppDir, subdir, 'pwsh.exe');
                return new PossiblePowerShellExe(pwshMsixPath, pwshMsixName);
            }
        }
        // If we find nothing, return null
        return null;
    }
    function findPSCoreDotnetGlobalTool() {
        const dotnetGlobalToolExePath = path.$oc(os.homedir(), '.dotnet', 'tools', 'pwsh.exe');
        return new PossiblePowerShellExe(dotnetGlobalToolExePath, '.NET Core PowerShell Global Tool');
    }
    function findWinPS() {
        const winPSPath = path.$oc(process.env.windir, processArch === Arch.x86 && osArch !== Arch.x86 ? 'SysNative' : 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
        return new PossiblePowerShellExe(winPSPath, 'Windows PowerShell', true);
    }
    /**
     * Iterates through all the possible well-known PowerShell installations on a machine.
     * Returned values may not exist, but come with an .exists property
     * which will check whether the executable exists.
     */
    async function* enumerateDefaultPowerShellInstallations() {
        // Find PSCore stable first
        let pwshExe = await findPSCoreWindowsInstallation();
        if (pwshExe) {
            yield pwshExe;
        }
        // Windows may have a 32-bit pwsh.exe
        pwshExe = await findPSCoreWindowsInstallation({ useAlternateBitness: true });
        if (pwshExe) {
            yield pwshExe;
        }
        // Also look for the MSIX/UWP installation
        pwshExe = await findPSCoreMsix();
        if (pwshExe) {
            yield pwshExe;
        }
        // Look for the .NET global tool
        // Some older versions of PowerShell have a bug in this where startup will fail,
        // but this is fixed in newer versions
        pwshExe = findPSCoreDotnetGlobalTool();
        if (pwshExe) {
            yield pwshExe;
        }
        // Look for PSCore preview
        pwshExe = await findPSCoreWindowsInstallation({ findPreview: true });
        if (pwshExe) {
            yield pwshExe;
        }
        // Find a preview MSIX
        pwshExe = await findPSCoreMsix({ findPreview: true });
        if (pwshExe) {
            yield pwshExe;
        }
        // Look for pwsh-preview with the opposite bitness
        pwshExe = await findPSCoreWindowsInstallation({ useAlternateBitness: true, findPreview: true });
        if (pwshExe) {
            yield pwshExe;
        }
        // Finally, get Windows PowerShell
        pwshExe = findWinPS();
        if (pwshExe) {
            yield pwshExe;
        }
    }
    /**
     * Iterates through PowerShell installations on the machine according
     * to configuration passed in through the constructor.
     * PowerShell items returned by this object are verified
     * to exist on the filesystem.
     */
    async function* $Bm() {
        // Get the default PowerShell installations first
        for await (const defaultPwsh of enumerateDefaultPowerShellInstallations()) {
            if (await defaultPwsh.exists()) {
                yield defaultPwsh;
            }
        }
    }
    /**
    * Returns the first available PowerShell executable found in the search order.
    */
    async function $Cm() {
        for await (const pwsh of $Bm()) {
            return pwsh;
        }
        return null;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/























define(__m[38/*vs/base/node/processes*/], __M([0/*require*/,1/*exports*/,37/*fs*/,5/*vs/base/common/path*/,3/*vs/base/common/platform*/,15/*vs/base/common/process*/,36/*vs/base/common/processes*/,10/*vs/base/common/types*/,28/*vs/base/node/pfs*/]), function (require, exports, fs_1, path, Platform, process, processes_1, Types, pfs) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.win32 = exports.TerminateResponseCode = exports.Source = void 0;
    exports.$Dm = $Dm;
    exports.$Em = $Em;
    path = __importStar(path);
    Platform = __importStar(Platform);
    process = __importStar(process);
    Types = __importStar(Types);
    pfs = __importStar(pfs);
    Object.defineProperty(exports, "Source", { enumerable: true, get: function () { return processes_1.Source; } });
    Object.defineProperty(exports, "TerminateResponseCode", { enumerable: true, get: function () { return processes_1.TerminateResponseCode; } });
    function $Dm(env = process.env) {
        return env['comspec'] || 'cmd.exe';
    }
    // Wrapper around process.send() that will queue any messages if the internal node.js
    // queue is filled with messages and only continue sending messages when the internal
    // queue is free again to consume messages.
    // On Windows we always wait for the send() method to return before sending the next message
    // to workaround https://github.com/nodejs/node/issues/7657 (IPC can freeze process)
    function $Em(childProcess) {
        let msgQueue = [];
        let useQueue = false;
        const send = function (msg) {
            if (useQueue) {
                msgQueue.push(msg); // add to the queue if the process cannot handle more messages
                return;
            }
            const result = childProcess.send(msg, (error) => {
                if (error) {
                    console.error(error); // unlikely to happen, best we can do is log this error
                }
                useQueue = false; // we are good again to send directly without queue
                // now send all the messages that we have in our queue and did not send yet
                if (msgQueue.length > 0) {
                    const msgQueueCopy = msgQueue.slice(0);
                    msgQueue = [];
                    msgQueueCopy.forEach(entry => send(entry));
                }
            });
            if (!result || Platform.$l /* workaround https://github.com/nodejs/node/issues/7657 */) {
                useQueue = true;
            }
        };
        return { send };
    }
    var win32;
    (function (win32) {
        async function findExecutable(command, cwd, paths) {
            // If we have an absolute path then we take it.
            if (path.$nc(command)) {
                return command;
            }
            if (cwd === undefined) {
                cwd = process.cwd();
            }
            const dir = path.$rc(command);
            if (dir !== '.') {
                // We have a directory and the directory is relative (see above). Make the path absolute
                // to the current working directory.
                return path.$oc(cwd, command);
            }
            if (paths === undefined && Types.$jg(process.env['PATH'])) {
                paths = process.env['PATH'].split(path.$yc);
            }
            // No PATH environment. Make path absolute to the cwd.
            if (paths === undefined || paths.length === 0) {
                return path.$oc(cwd, command);
            }
            async function fileExists(path) {
                if (await pfs.Promises.exists(path)) {
                    let statValue;
                    try {
                        statValue = await fs_1.promises.stat(path);
                    }
                    catch (e) {
                        if (e.message.startsWith('EACCES')) {
                            // it might be symlink
                            statValue = await fs_1.promises.lstat(path);
                        }
                    }
                    return statValue ? !statValue.isDirectory() : false;
                }
                return false;
            }
            // We have a simple file name. We get the path variable from the env
            // and try to find the executable on the path.
            for (const pathEntry of paths) {
                // The path entry is absolute.
                let fullPath;
                if (path.$nc(pathEntry)) {
                    fullPath = path.$oc(pathEntry, command);
                }
                else {
                    fullPath = path.$oc(cwd, pathEntry, command);
                }
                if (await fileExists(fullPath)) {
                    return fullPath;
                }
                let withExtension = fullPath + '.com';
                if (await fileExists(withExtension)) {
                    return withExtension;
                }
                withExtension = fullPath + '.exe';
                if (await fileExists(withExtension)) {
                    return withExtension;
                }
            }
            return path.$oc(cwd, command);
        }
        win32.findExecutable = findExecutable;
    })(win32 || (exports.win32 = win32 = {}));
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/























define(__m[64/*vs/base/node/ps*/], __M([0/*require*/,1/*exports*/,29/*child_process*/,20/*vs/base/common/network*/]), function (require, exports, child_process_1, network_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$6s = $6s;
    function $6s(rootPid) {
        return new Promise((resolve, reject) => {
            let rootItem;
            const map = new Map();
            function addToTree(pid, ppid, cmd, load, mem) {
                const parent = map.get(ppid);
                if (pid === rootPid || parent) {
                    const item = {
                        name: findName(cmd),
                        cmd,
                        pid,
                        ppid,
                        load,
                        mem
                    };
                    map.set(pid, item);
                    if (pid === rootPid) {
                        rootItem = item;
                    }
                    if (parent) {
                        if (!parent.children) {
                            parent.children = [];
                        }
                        parent.children.push(item);
                        if (parent.children.length > 1) {
                            parent.children = parent.children.sort((a, b) => a.pid - b.pid);
                        }
                    }
                }
            }
            function findName(cmd) {
                const UTILITY_NETWORK_HINT = /--utility-sub-type=network/i;
                const WINDOWS_CRASH_REPORTER = /--crashes-directory/i;
                const WINPTY = /\\pipe\\winpty-control/i;
                const CONPTY = /conhost\.exe.+--headless/i;
                const TYPE = /--type=([a-zA-Z-]+)/;
                // find windows crash reporter
                if (WINDOWS_CRASH_REPORTER.exec(cmd)) {
                    return 'electron-crash-reporter';
                }
                // find winpty process
                if (WINPTY.exec(cmd)) {
                    return 'winpty-agent';
                }
                // find conpty process
                if (CONPTY.exec(cmd)) {
                    return 'conpty-agent';
                }
                // find "--type=xxxx"
                let matches = TYPE.exec(cmd);
                if (matches && matches.length === 2) {
                    if (matches[1] === 'renderer') {
                        return `window`;
                    }
                    else if (matches[1] === 'utility') {
                        if (UTILITY_NETWORK_HINT.exec(cmd)) {
                            return 'utility-network-service';
                        }
                        return 'utility-process';
                    }
                    else if (matches[1] === 'extensionHost') {
                        return 'extension-host'; // normalize remote extension host type
                    }
                    return matches[1];
                }
                // find all xxxx.js
                const JS = /[a-zA-Z-]+\.js/g;
                let result = '';
                do {
                    matches = JS.exec(cmd);
                    if (matches) {
                        result += matches + ' ';
                    }
                } while (matches);
                if (result) {
                    if (cmd.indexOf('node ') < 0 && cmd.indexOf('node.exe') < 0) {
                        return `electron-nodejs (${result})`;
                    }
                }
                return cmd;
            }
            if (process.platform === 'win32') {
                const cleanUNCPrefix = (value) => {
                    if (value.indexOf('\\\\?\\') === 0) {
                        return value.substring(4);
                    }
                    else if (value.indexOf('\\??\\') === 0) {
                        return value.substring(4);
                    }
                    else if (value.indexOf('"\\\\?\\') === 0) {
                        return '"' + value.substring(5);
                    }
                    else if (value.indexOf('"\\??\\') === 0) {
                        return '"' + value.substring(5);
                    }
                    else {
                        return value;
                    }
                };
                (new Promise((resolve_1, reject_1) => { require(['@vscode/windows-process-tree'], resolve_1, reject_1); }).then(__importStar)).then(windowsProcessTree => {
                    windowsProcessTree.getProcessList(rootPid, (processList) => {
                        if (!processList) {
                            reject(new Error(`Root process ${rootPid} not found`));
                            return;
                        }
                        windowsProcessTree.getProcessCpuUsage(processList, (completeProcessList) => {
                            const processItems = new Map();
                            completeProcessList.forEach(process => {
                                const commandLine = cleanUNCPrefix(process.commandLine || '');
                                processItems.set(process.pid, {
                                    name: findName(commandLine),
                                    cmd: commandLine,
                                    pid: process.pid,
                                    ppid: process.ppid,
                                    load: process.cpu || 0,
                                    mem: process.memory || 0
                                });
                            });
                            rootItem = processItems.get(rootPid);
                            if (rootItem) {
                                processItems.forEach(item => {
                                    const parent = processItems.get(item.ppid);
                                    if (parent) {
                                        if (!parent.children) {
                                            parent.children = [];
                                        }
                                        parent.children.push(item);
                                    }
                                });
                                processItems.forEach(item => {
                                    if (item.children) {
                                        item.children = item.children.sort((a, b) => a.pid - b.pid);
                                    }
                                });
                                resolve(rootItem);
                            }
                            else {
                                reject(new Error(`Root process ${rootPid} not found`));
                            }
                        });
                    }, windowsProcessTree.ProcessDataFlag.CommandLine | windowsProcessTree.ProcessDataFlag.Memory);
                });
            }
            else { // OS X & Linux
                function calculateLinuxCpuUsage() {
                    // Flatten rootItem to get a list of all VSCode processes
                    let processes = [rootItem];
                    const pids = [];
                    while (processes.length) {
                        const process = processes.shift();
                        if (process) {
                            pids.push(process.pid);
                            if (process.children) {
                                processes = processes.concat(process.children);
                            }
                        }
                    }
                    // The cpu usage value reported on Linux is the average over the process lifetime,
                    // recalculate the usage over a one second interval
                    // JSON.stringify is needed to escape spaces, https://github.com/nodejs/node/issues/6803
                    let cmd = JSON.stringify(network_1.$5g.asFileUri('vs/base/node/cpuUsage.sh').fsPath);
                    cmd += ' ' + pids.join(' ');
                    (0, child_process_1.exec)(cmd, {}, (err, stdout, stderr) => {
                        if (err || stderr) {
                            reject(err || new Error(stderr.toString()));
                        }
                        else {
                            const cpuUsage = stdout.toString().split('\n');
                            for (let i = 0; i < pids.length; i++) {
                                const processInfo = map.get(pids[i]);
                                processInfo.load = parseFloat(cpuUsage[i]);
                            }
                            if (!rootItem) {
                                reject(new Error(`Root process ${rootPid} not found`));
                                return;
                            }
                            resolve(rootItem);
                        }
                    });
                }
                (0, child_process_1.exec)('which ps', {}, (err, stdout, stderr) => {
                    if (err || stderr) {
                        if (process.platform !== 'linux') {
                            reject(err || new Error(stderr.toString()));
                        }
                        else {
                            const cmd = JSON.stringify(network_1.$5g.asFileUri('vs/base/node/ps.sh').fsPath);
                            (0, child_process_1.exec)(cmd, {}, (err, stdout, stderr) => {
                                if (err || stderr) {
                                    reject(err || new Error(stderr.toString()));
                                }
                                else {
                                    parsePsOutput(stdout, addToTree);
                                    calculateLinuxCpuUsage();
                                }
                            });
                        }
                    }
                    else {
                        const ps = stdout.toString().trim();
                        const args = '-ax -o pid=,ppid=,pcpu=,pmem=,command=';
                        // Set numeric locale to ensure '.' is used as the decimal separator
                        (0, child_process_1.exec)(`${ps} ${args}`, { maxBuffer: 1000 * 1024, env: { LC_NUMERIC: 'en_US.UTF-8' } }, (err, stdout, stderr) => {
                            // Silently ignoring the screen size is bogus error. See https://github.com/microsoft/vscode/issues/98590
                            if (err || (stderr && !stderr.includes('screen size is bogus'))) {
                                reject(err || new Error(stderr.toString()));
                            }
                            else {
                                parsePsOutput(stdout, addToTree);
                                if (process.platform === 'linux') {
                                    calculateLinuxCpuUsage();
                                }
                                else {
                                    if (!rootItem) {
                                        reject(new Error(`Root process ${rootPid} not found`));
                                    }
                                    else {
                                        resolve(rootItem);
                                    }
                                }
                            }
                        });
                    }
                });
            }
        });
    }
    function parsePsOutput(stdout, addToTree) {
        const PID_CMD = /^\s*([0-9]+)\s+([0-9]+)\s+([0-9]+\.[0-9]+)\s+([0-9]+\.[0-9]+)\s+(.+)$/;
        const lines = stdout.toString().split('\n');
        for (const line of lines) {
            const matches = PID_CMD.exec(line.trim());
            if (matches && matches.length === 6) {
                addToTree(parseInt(matches[1]), parseInt(matches[2]), matches[5], parseFloat(matches[3]), parseFloat(matches[4]));
            }
        }
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/























define(__m[65/*vs/base/node/shell*/], __M([0/*require*/,1/*exports*/,21/*os*/,3/*vs/base/common/platform*/,63/*vs/base/node/powershell*/,38/*vs/base/node/processes*/]), function (require, exports, os_1, platform, powershell_1, processes) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$Fm = $Fm;
    platform = __importStar(platform);
    processes = __importStar(processes);
    /**
     * Gets the detected default shell for the _system_, not to be confused with VS Code's _default_
     * shell that the terminal uses by default.
     * @param os The platform to detect the shell of.
     */
    async function $Fm(os, env) {
        if (os === platform.OperatingSystem.Windows) {
            if (platform.$l) {
                return getSystemShellWindows();
            }
            // Don't detect Windows shell when not on Windows
            return processes.$Dm(env);
        }
        return getSystemShellUnixLike(os, env);
    }
    let _TERMINAL_DEFAULT_SHELL_UNIX_LIKE = null;
    function getSystemShellUnixLike(os, env) {
        // Only use $SHELL for the current OS
        if (platform.$n && os === platform.OperatingSystem.Macintosh || platform.$m && os === platform.OperatingSystem.Linux) {
            return '/bin/bash';
        }
        if (!_TERMINAL_DEFAULT_SHELL_UNIX_LIKE) {
            let unixLikeTerminal;
            if (platform.$l) {
                unixLikeTerminal = '/bin/bash'; // for WSL
            }
            else {
                unixLikeTerminal = env['SHELL'];
                if (!unixLikeTerminal) {
                    try {
                        // It's possible for $SHELL to be unset, this API reads /etc/passwd. See https://github.com/github/codespaces/issues/1639
                        // Node docs: "Throws a SystemError if a user has no username or homedir."
                        unixLikeTerminal = (0, os_1.userInfo)().shell;
                    }
                    catch (err) { }
                }
                if (!unixLikeTerminal) {
                    unixLikeTerminal = 'sh';
                }
                // Some systems have $SHELL set to /bin/false which breaks the terminal
                if (unixLikeTerminal === '/bin/false') {
                    unixLikeTerminal = '/bin/bash';
                }
            }
            _TERMINAL_DEFAULT_SHELL_UNIX_LIKE = unixLikeTerminal;
        }
        return _TERMINAL_DEFAULT_SHELL_UNIX_LIKE;
    }
    let _TERMINAL_DEFAULT_SHELL_WINDOWS = null;
    async function getSystemShellWindows() {
        if (!_TERMINAL_DEFAULT_SHELL_WINDOWS) {
            _TERMINAL_DEFAULT_SHELL_WINDOWS = (await (0, powershell_1.$Cm)()).exePath;
        }
        return _TERMINAL_DEFAULT_SHELL_WINDOWS;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
















var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};







define(__m[30/*vs/base/parts/ipc/common/ipc*/], __M([0/*require*/,1/*exports*/,17/*vs/base/common/arrays*/,12/*vs/base/common/async*/,19/*vs/base/common/buffer*/,18/*vs/base/common/cancellation*/,14/*vs/base/common/decorators*/,7/*vs/base/common/errors*/,4/*vs/base/common/event*/,2/*vs/base/common/lifecycle*/,61/*vs/base/common/marshalling*/,11/*vs/base/common/strings*/,10/*vs/base/common/types*/]), function (require, exports, arrays_1, async_1, buffer_1, cancellation_1, decorators_1, errors_1, event_1, lifecycle_1, marshalling_1, strings, types_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$ti = exports.ProxyChannel = exports.$si = exports.$pi = exports.$oi = exports.$ni = exports.RequestInitiator = exports.$mi = exports.$ji = exports.$ii = void 0;
    exports.$ki = $ki;
    exports.$li = $li;
    exports.$qi = $qi;
    exports.$ri = $ri;
    strings = __importStar(strings);
    var RequestType;
    (function (RequestType) {
        RequestType[RequestType["Promise"] = 100] = "Promise";
        RequestType[RequestType["PromiseCancel"] = 101] = "PromiseCancel";
        RequestType[RequestType["EventListen"] = 102] = "EventListen";
        RequestType[RequestType["EventDispose"] = 103] = "EventDispose";
    })(RequestType || (RequestType = {}));
    function requestTypeToStr(type) {
        switch (type) {
            case RequestType.Promise:
                return 'req';
            case RequestType.PromiseCancel:
                return 'cancel';
            case RequestType.EventListen:
                return 'subscribe';
            case RequestType.EventDispose:
                return 'unsubscribe';
        }
    }
    var ResponseType;
    (function (ResponseType) {
        ResponseType[ResponseType["Initialize"] = 200] = "Initialize";
        ResponseType[ResponseType["PromiseSuccess"] = 201] = "PromiseSuccess";
        ResponseType[ResponseType["PromiseError"] = 202] = "PromiseError";
        ResponseType[ResponseType["PromiseErrorObj"] = 203] = "PromiseErrorObj";
        ResponseType[ResponseType["EventFire"] = 204] = "EventFire";
    })(ResponseType || (ResponseType = {}));
    function responseTypeToStr(type) {
        switch (type) {
            case ResponseType.Initialize:
                return `init`;
            case ResponseType.PromiseSuccess:
                return `reply:`;
            case ResponseType.PromiseError:
            case ResponseType.PromiseErrorObj:
                return `replyErr:`;
            case ResponseType.EventFire:
                return `event:`;
        }
    }
    var State;
    (function (State) {
        State[State["Uninitialized"] = 0] = "Uninitialized";
        State[State["Idle"] = 1] = "Idle";
    })(State || (State = {}));
    /**
     * @see https://en.wikipedia.org/wiki/Variable-length_quantity
     */
    function readIntVQL(reader) {
        let value = 0;
        for (let n = 0;; n += 7) {
            const next = reader.read(1);
            value |= (next.buffer[0] & 0b01111111) << n;
            if (!(next.buffer[0] & 0b10000000)) {
                return value;
            }
        }
    }
    const vqlZero = createOneByteBuffer(0);
    /**
     * @see https://en.wikipedia.org/wiki/Variable-length_quantity
     */
    function writeInt32VQL(writer, value) {
        if (value === 0) {
            writer.write(vqlZero);
            return;
        }
        let len = 0;
        for (let v2 = value; v2 !== 0; v2 = v2 >>> 7) {
            len++;
        }
        const scratch = buffer_1.$Se.alloc(len);
        for (let i = 0; value !== 0; i++) {
            scratch.buffer[i] = value & 0b01111111;
            value = value >>> 7;
            if (value > 0) {
                scratch.buffer[i] |= 0b10000000;
            }
        }
        writer.write(scratch);
    }
    class $ii {
        constructor(b) {
            this.b = b;
            this.a = 0;
        }
        read(bytes) {
            const result = this.b.slice(this.a, this.a + bytes);
            this.a += result.byteLength;
            return result;
        }
    }
    exports.$ii = $ii;
    class $ji {
        constructor() {
            this.a = [];
        }
        get buffer() {
            return buffer_1.$Se.concat(this.a);
        }
        write(buffer) {
            this.a.push(buffer);
        }
    }
    exports.$ji = $ji;
    var DataType;
    (function (DataType) {
        DataType[DataType["Undefined"] = 0] = "Undefined";
        DataType[DataType["String"] = 1] = "String";
        DataType[DataType["Buffer"] = 2] = "Buffer";
        DataType[DataType["VSBuffer"] = 3] = "VSBuffer";
        DataType[DataType["Array"] = 4] = "Array";
        DataType[DataType["Object"] = 5] = "Object";
        DataType[DataType["Int"] = 6] = "Int";
    })(DataType || (DataType = {}));
    function createOneByteBuffer(value) {
        const result = buffer_1.$Se.alloc(1);
        result.writeUInt8(value, 0);
        return result;
    }
    const BufferPresets = {
        Undefined: createOneByteBuffer(DataType.Undefined),
        String: createOneByteBuffer(DataType.String),
        Buffer: createOneByteBuffer(DataType.Buffer),
        VSBuffer: createOneByteBuffer(DataType.VSBuffer),
        Array: createOneByteBuffer(DataType.Array),
        Object: createOneByteBuffer(DataType.Object),
        Uint: createOneByteBuffer(DataType.Int),
    };
    const hasBuffer = (typeof Buffer !== 'undefined');
    function $ki(writer, data) {
        if (typeof data === 'undefined') {
            writer.write(BufferPresets.Undefined);
        }
        else if (typeof data === 'string') {
            const buffer = buffer_1.$Se.fromString(data);
            writer.write(BufferPresets.String);
            writeInt32VQL(writer, buffer.byteLength);
            writer.write(buffer);
        }
        else if (hasBuffer && Buffer.isBuffer(data)) {
            const buffer = buffer_1.$Se.wrap(data);
            writer.write(BufferPresets.Buffer);
            writeInt32VQL(writer, buffer.byteLength);
            writer.write(buffer);
        }
        else if (data instanceof buffer_1.$Se) {
            writer.write(BufferPresets.VSBuffer);
            writeInt32VQL(writer, data.byteLength);
            writer.write(data);
        }
        else if (Array.isArray(data)) {
            writer.write(BufferPresets.Array);
            writeInt32VQL(writer, data.length);
            for (const el of data) {
                $ki(writer, el);
            }
        }
        else if (typeof data === 'number' && (data | 0) === data) {
            // write a vql if it's a number that we can do bitwise operations on
            writer.write(BufferPresets.Uint);
            writeInt32VQL(writer, data);
        }
        else {
            const buffer = buffer_1.$Se.fromString(JSON.stringify(data));
            writer.write(BufferPresets.Object);
            writeInt32VQL(writer, buffer.byteLength);
            writer.write(buffer);
        }
    }
    function $li(reader) {
        const type = reader.read(1).readUInt8(0);
        switch (type) {
            case DataType.Undefined: return undefined;
            case DataType.String: return reader.read(readIntVQL(reader)).toString();
            case DataType.Buffer: return reader.read(readIntVQL(reader)).buffer;
            case DataType.VSBuffer: return reader.read(readIntVQL(reader));
            case DataType.Array: {
                const length = readIntVQL(reader);
                const result = [];
                for (let i = 0; i < length; i++) {
                    result.push($li(reader));
                }
                return result;
            }
            case DataType.Object: return JSON.parse(reader.read(readIntVQL(reader)).toString());
            case DataType.Int: return readIntVQL(reader);
        }
    }
    class $mi {
        constructor(h, j, k = null, l = 1000) {
            this.h = h;
            this.j = j;
            this.k = k;
            this.l = l;
            this.b = new Map();
            this.d = new Map();
            // Requests might come in for channels which are not yet registered.
            // They will timeout after `timeoutDelay`.
            this.g = new Map();
            this.f = this.h.onMessage(msg => this.q(msg));
            this.m({ type: ResponseType.Initialize });
        }
        registerChannel(channelName, channel) {
            this.b.set(channelName, channel);
            // https://github.com/microsoft/vscode/issues/72531
            setTimeout(() => this.w(channelName), 0);
        }
        m(response) {
            switch (response.type) {
                case ResponseType.Initialize: {
                    const msgLength = this.o([response.type]);
                    this.k?.logOutgoing(msgLength, 0, RequestInitiator.OtherSide, responseTypeToStr(response.type));
                    return;
                }
                case ResponseType.PromiseSuccess:
                case ResponseType.PromiseError:
                case ResponseType.EventFire:
                case ResponseType.PromiseErrorObj: {
                    const msgLength = this.o([response.type, response.id], response.data);
                    this.k?.logOutgoing(msgLength, response.id, RequestInitiator.OtherSide, responseTypeToStr(response.type), response.data);
                    return;
                }
            }
        }
        o(header, body = undefined) {
            const writer = new $ji();
            $ki(writer, header);
            $ki(writer, body);
            return this.p(writer.buffer);
        }
        p(message) {
            try {
                this.h.send(message);
                return message.byteLength;
            }
            catch (err) {
                // noop
                return 0;
            }
        }
        q(message) {
            const reader = new $ii(message);
            const header = $li(reader);
            const body = $li(reader);
            const type = header[0];
            switch (type) {
                case RequestType.Promise:
                    this.k?.logIncoming(message.byteLength, header[1], RequestInitiator.OtherSide, `${requestTypeToStr(type)}: ${header[2]}.${header[3]}`, body);
                    return this.s({ type, id: header[1], channelName: header[2], name: header[3], arg: body });
                case RequestType.EventListen:
                    this.k?.logIncoming(message.byteLength, header[1], RequestInitiator.OtherSide, `${requestTypeToStr(type)}: ${header[2]}.${header[3]}`, body);
                    return this.t({ type, id: header[1], channelName: header[2], name: header[3], arg: body });
                case RequestType.PromiseCancel:
                    this.k?.logIncoming(message.byteLength, header[1], RequestInitiator.OtherSide, `${requestTypeToStr(type)}`);
                    return this.u({ type, id: header[1] });
                case RequestType.EventDispose:
                    this.k?.logIncoming(message.byteLength, header[1], RequestInitiator.OtherSide, `${requestTypeToStr(type)}`);
                    return this.u({ type, id: header[1] });
            }
        }
        s(request) {
            const channel = this.b.get(request.channelName);
            if (!channel) {
                this.v(request);
                return;
            }
            const cancellationTokenSource = new cancellation_1.$Be();
            let promise;
            try {
                promise = channel.call(this.j, request.name, request.arg, cancellationTokenSource.token);
            }
            catch (err) {
                promise = Promise.reject(err);
            }
            const id = request.id;
            promise.then(data => {
                this.m({ id, data, type: ResponseType.PromiseSuccess });
            }, err => {
                if (err instanceof Error) {
                    this.m({
                        id, data: {
                            message: err.message,
                            name: err.name,
                            stack: err.stack ? err.stack.split('\n') : undefined
                        }, type: ResponseType.PromiseError
                    });
                }
                else {
                    this.m({ id, data: err, type: ResponseType.PromiseErrorObj });
                }
            }).finally(() => {
                disposable.dispose();
                this.d.delete(request.id);
            });
            const disposable = (0, lifecycle_1.$Xc)(() => cancellationTokenSource.cancel());
            this.d.set(request.id, disposable);
        }
        t(request) {
            const channel = this.b.get(request.channelName);
            if (!channel) {
                this.v(request);
                return;
            }
            const id = request.id;
            const event = channel.listen(this.j, request.name, request.arg);
            const disposable = event(data => this.m({ id, data, type: ResponseType.EventFire }));
            this.d.set(request.id, disposable);
        }
        u(request) {
            const disposable = this.d.get(request.id);
            if (disposable) {
                disposable.dispose();
                this.d.delete(request.id);
            }
        }
        v(request) {
            let pendingRequests = this.g.get(request.channelName);
            if (!pendingRequests) {
                pendingRequests = [];
                this.g.set(request.channelName, pendingRequests);
            }
            const timer = setTimeout(() => {
                console.error(`Unknown channel: ${request.channelName}`);
                if (request.type === RequestType.Promise) {
                    this.m({
                        id: request.id,
                        data: { name: 'Unknown channel', message: `Channel name '${request.channelName}' timed out after ${this.l}ms`, stack: undefined },
                        type: ResponseType.PromiseError
                    });
                }
            }, this.l);
            pendingRequests.push({ request, timeoutTimer: timer });
        }
        w(channelName) {
            const requests = this.g.get(channelName);
            if (requests) {
                for (const request of requests) {
                    clearTimeout(request.timeoutTimer);
                    switch (request.request.type) {
                        case RequestType.Promise:
                            this.s(request.request);
                            break;
                        case RequestType.EventListen:
                            this.t(request.request);
                            break;
                    }
                }
                this.g.delete(channelName);
            }
        }
        dispose() {
            if (this.f) {
                this.f.dispose();
                this.f = null;
            }
            (0, lifecycle_1.$Uc)(this.d.values());
            this.d.clear();
        }
    }
    exports.$mi = $mi;
    var RequestInitiator;
    (function (RequestInitiator) {
        RequestInitiator[RequestInitiator["LocalSide"] = 0] = "LocalSide";
        RequestInitiator[RequestInitiator["OtherSide"] = 1] = "OtherSide";
    })(RequestInitiator || (exports.RequestInitiator = RequestInitiator = {}));
    class $ni {
        constructor(l, logger = null) {
            this.l = l;
            this.a = false;
            this.b = State.Uninitialized;
            this.d = new Set();
            this.f = new Map();
            this.g = 0;
            this.k = new event_1.$qe();
            this.onDidInitialize = this.k.event;
            this.h = this.l.onMessage(msg => this.s(msg));
            this.j = logger;
        }
        getChannel(channelName) {
            const that = this;
            return {
                call(command, arg, cancellationToken) {
                    if (that.a) {
                        return Promise.reject(new errors_1.$9());
                    }
                    return that.m(channelName, command, arg, cancellationToken);
                },
                listen(event, arg) {
                    if (that.a) {
                        return event_1.Event.None;
                    }
                    return that.o(channelName, event, arg);
                }
            };
        }
        m(channelName, name, arg, cancellationToken = cancellation_1.CancellationToken.None) {
            const id = this.g++;
            const type = RequestType.Promise;
            const request = { id, type, channelName, name, arg };
            if (cancellationToken.isCancellationRequested) {
                return Promise.reject(new errors_1.$9());
            }
            let disposable;
            const result = new Promise((c, e) => {
                if (cancellationToken.isCancellationRequested) {
                    return e(new errors_1.$9());
                }
                const doRequest = () => {
                    const handler = response => {
                        switch (response.type) {
                            case ResponseType.PromiseSuccess:
                                this.f.delete(id);
                                c(response.data);
                                break;
                            case ResponseType.PromiseError: {
                                this.f.delete(id);
                                const error = new Error(response.data.message);
                                error.stack = Array.isArray(response.data.stack) ? response.data.stack.join('\n') : response.data.stack;
                                error.name = response.data.name;
                                e(error);
                                break;
                            }
                            case ResponseType.PromiseErrorObj:
                                this.f.delete(id);
                                e(response.data);
                                break;
                        }
                    };
                    this.f.set(id, handler);
                    this.p(request);
                };
                let uninitializedPromise = null;
                if (this.b === State.Idle) {
                    doRequest();
                }
                else {
                    uninitializedPromise = (0, async_1.$xh)(_ => this.u());
                    uninitializedPromise.then(() => {
                        uninitializedPromise = null;
                        doRequest();
                    });
                }
                const cancel = () => {
                    if (uninitializedPromise) {
                        uninitializedPromise.cancel();
                        uninitializedPromise = null;
                    }
                    else {
                        this.p({ id, type: RequestType.PromiseCancel });
                    }
                    e(new errors_1.$9());
                };
                const cancellationTokenListener = cancellationToken.onCancellationRequested(cancel);
                disposable = (0, lifecycle_1.$Wc)((0, lifecycle_1.$Xc)(cancel), cancellationTokenListener);
                this.d.add(disposable);
            });
            return result.finally(() => {
                disposable.dispose();
                this.d.delete(disposable);
            });
        }
        o(channelName, name, arg) {
            const id = this.g++;
            const type = RequestType.EventListen;
            const request = { id, type, channelName, name, arg };
            let uninitializedPromise = null;
            const emitter = new event_1.$qe({
                onWillAddFirstListener: () => {
                    uninitializedPromise = (0, async_1.$xh)(_ => this.u());
                    uninitializedPromise.then(() => {
                        uninitializedPromise = null;
                        this.d.add(emitter);
                        this.p(request);
                    });
                },
                onDidRemoveLastListener: () => {
                    if (uninitializedPromise) {
                        uninitializedPromise.cancel();
                        uninitializedPromise = null;
                    }
                    else {
                        this.d.delete(emitter);
                        this.p({ id, type: RequestType.EventDispose });
                    }
                }
            });
            const handler = (res) => emitter.fire(res.data);
            this.f.set(id, handler);
            return emitter.event;
        }
        p(request) {
            switch (request.type) {
                case RequestType.Promise:
                case RequestType.EventListen: {
                    const msgLength = this.q([request.type, request.id, request.channelName, request.name], request.arg);
                    this.j?.logOutgoing(msgLength, request.id, RequestInitiator.LocalSide, `${requestTypeToStr(request.type)}: ${request.channelName}.${request.name}`, request.arg);
                    return;
                }
                case RequestType.PromiseCancel:
                case RequestType.EventDispose: {
                    const msgLength = this.q([request.type, request.id]);
                    this.j?.logOutgoing(msgLength, request.id, RequestInitiator.LocalSide, requestTypeToStr(request.type));
                    return;
                }
            }
        }
        q(header, body = undefined) {
            const writer = new $ji();
            $ki(writer, header);
            $ki(writer, body);
            return this.r(writer.buffer);
        }
        r(message) {
            try {
                this.l.send(message);
                return message.byteLength;
            }
            catch (err) {
                // noop
                return 0;
            }
        }
        s(message) {
            const reader = new $ii(message);
            const header = $li(reader);
            const body = $li(reader);
            const type = header[0];
            switch (type) {
                case ResponseType.Initialize:
                    this.j?.logIncoming(message.byteLength, 0, RequestInitiator.LocalSide, responseTypeToStr(type));
                    return this.t({ type: header[0] });
                case ResponseType.PromiseSuccess:
                case ResponseType.PromiseError:
                case ResponseType.EventFire:
                case ResponseType.PromiseErrorObj:
                    this.j?.logIncoming(message.byteLength, header[1], RequestInitiator.LocalSide, responseTypeToStr(type), body);
                    return this.t({ type: header[0], id: header[1], data: body });
            }
        }
        t(response) {
            if (response.type === ResponseType.Initialize) {
                this.b = State.Idle;
                this.k.fire();
                return;
            }
            const handler = this.f.get(response.id);
            handler?.(response);
        }
        get onDidInitializePromise() {
            return event_1.Event.toPromise(this.onDidInitialize);
        }
        u() {
            if (this.b === State.Idle) {
                return Promise.resolve();
            }
            else {
                return this.onDidInitializePromise;
            }
        }
        dispose() {
            this.a = true;
            if (this.h) {
                this.h.dispose();
                this.h = null;
            }
            (0, lifecycle_1.$Uc)(this.d.values());
            this.d.clear();
        }
    }
    exports.$ni = $ni;
    __decorate([
        decorators_1.$ci
    ], $ni.prototype, "onDidInitializePromise", null);
    /**
     * An `IPCServer` is both a channel server and a routing channel
     * client.
     *
     * As the owner of a protocol, you should extend both this
     * and the `IPCClient` classes to get IPC implementations
     * for your protocol.
     */
    class $oi {
        get connections() {
            const result = [];
            this.f.forEach(ctx => result.push(ctx));
            return result;
        }
        constructor(onDidClientConnect, ipcLogger, timeoutDelay) {
            this.a = new Map();
            this.f = new Set();
            this.g = new event_1.$qe();
            this.onDidAddConnection = this.g.event;
            this.h = new event_1.$qe();
            this.onDidRemoveConnection = this.h.event;
            this.j = new lifecycle_1.$Yc();
            this.j.add(onDidClientConnect(({ protocol, onDidClientDisconnect }) => {
                const onFirstMessage = event_1.Event.once(protocol.onMessage);
                this.j.add(onFirstMessage(msg => {
                    const reader = new $ii(msg);
                    const ctx = $li(reader);
                    const channelServer = new $mi(protocol, ctx, ipcLogger, timeoutDelay);
                    const channelClient = new $ni(protocol, ipcLogger);
                    this.a.forEach((channel, name) => channelServer.registerChannel(name, channel));
                    const connection = { channelServer, channelClient, ctx };
                    this.f.add(connection);
                    this.g.fire(connection);
                    this.j.add(onDidClientDisconnect(() => {
                        channelServer.dispose();
                        channelClient.dispose();
                        this.f.delete(connection);
                        this.h.fire(connection);
                    }));
                }));
            }));
        }
        getChannel(channelName, routerOrClientFilter) {
            const that = this;
            return {
                call(command, arg, cancellationToken) {
                    let connectionPromise;
                    if ((0, types_1.$xg)(routerOrClientFilter)) {
                        // when no router is provided, we go random client picking
                        const connection = (0, arrays_1.$7b)(that.connections.filter(routerOrClientFilter));
                        connectionPromise = connection
                            // if we found a client, let's call on it
                            ? Promise.resolve(connection)
                            // else, let's wait for a client to come along
                            : event_1.Event.toPromise(event_1.Event.filter(that.onDidAddConnection, routerOrClientFilter));
                    }
                    else {
                        connectionPromise = routerOrClientFilter.routeCall(that, command, arg);
                    }
                    const channelPromise = connectionPromise
                        .then(connection => connection.channelClient.getChannel(channelName));
                    return $qi(channelPromise)
                        .call(command, arg, cancellationToken);
                },
                listen(event, arg) {
                    if ((0, types_1.$xg)(routerOrClientFilter)) {
                        return that.k(channelName, routerOrClientFilter, event, arg);
                    }
                    const channelPromise = routerOrClientFilter.routeEvent(that, event, arg)
                        .then(connection => connection.channelClient.getChannel(channelName));
                    return $qi(channelPromise)
                        .listen(event, arg);
                }
            };
        }
        k(channelName, clientFilter, eventName, arg) {
            const that = this;
            let disposables;
            // Create an emitter which hooks up to all clients
            // as soon as first listener is added. It also
            // disconnects from all clients as soon as the last listener
            // is removed.
            const emitter = new event_1.$qe({
                onWillAddFirstListener: () => {
                    disposables = new lifecycle_1.$Yc();
                    // The event multiplexer is useful since the active
                    // client list is dynamic. We need to hook up and disconnection
                    // to/from clients as they come and go.
                    const eventMultiplexer = new event_1.$we();
                    const map = new Map();
                    const onDidAddConnection = (connection) => {
                        const channel = connection.channelClient.getChannel(channelName);
                        const event = channel.listen(eventName, arg);
                        const disposable = eventMultiplexer.add(event);
                        map.set(connection, disposable);
                    };
                    const onDidRemoveConnection = (connection) => {
                        const disposable = map.get(connection);
                        if (!disposable) {
                            return;
                        }
                        disposable.dispose();
                        map.delete(connection);
                    };
                    that.connections.filter(clientFilter).forEach(onDidAddConnection);
                    event_1.Event.filter(that.onDidAddConnection, clientFilter)(onDidAddConnection, undefined, disposables);
                    that.onDidRemoveConnection(onDidRemoveConnection, undefined, disposables);
                    eventMultiplexer.event(emitter.fire, emitter, disposables);
                    disposables.add(eventMultiplexer);
                },
                onDidRemoveLastListener: () => {
                    disposables?.dispose();
                    disposables = undefined;
                }
            });
            return emitter.event;
        }
        registerChannel(channelName, channel) {
            this.a.set(channelName, channel);
            for (const connection of this.f) {
                connection.channelServer.registerChannel(channelName, channel);
            }
        }
        dispose() {
            this.j.dispose();
            for (const connection of this.f) {
                connection.channelClient.dispose();
                connection.channelServer.dispose();
            }
            this.f.clear();
            this.a.clear();
            this.g.dispose();
            this.h.dispose();
        }
    }
    exports.$oi = $oi;
    /**
     * An `IPCClient` is both a channel client and a channel server.
     *
     * As the owner of a protocol, you should extend both this
     * and the `IPCServer` classes to get IPC implementations
     * for your protocol.
     */
    class $pi {
        constructor(protocol, ctx, ipcLogger = null) {
            const writer = new $ji();
            $ki(writer, ctx);
            protocol.send(writer.buffer);
            this.a = new $ni(protocol, ipcLogger);
            this.d = new $mi(protocol, ctx, ipcLogger);
        }
        getChannel(channelName) {
            return this.a.getChannel(channelName);
        }
        registerChannel(channelName, channel) {
            this.d.registerChannel(channelName, channel);
        }
        dispose() {
            this.a.dispose();
            this.d.dispose();
        }
    }
    exports.$pi = $pi;
    function $qi(promise) {
        return {
            call(command, arg, cancellationToken) {
                return promise.then(c => c.call(command, arg, cancellationToken));
            },
            listen(event, arg) {
                const relay = new event_1.$ze();
                promise.then(c => relay.input = c.listen(event, arg));
                return relay.event;
            }
        };
    }
    function $ri(channel) {
        let didTick = false;
        return {
            call(command, arg, cancellationToken) {
                if (didTick) {
                    return channel.call(command, arg, cancellationToken);
                }
                return (0, async_1.$Lh)(0)
                    .then(() => didTick = true)
                    .then(() => channel.call(command, arg, cancellationToken));
            },
            listen(event, arg) {
                if (didTick) {
                    return channel.listen(event, arg);
                }
                const relay = new event_1.$ze();
                (0, async_1.$Lh)(0)
                    .then(() => didTick = true)
                    .then(() => relay.input = channel.listen(event, arg));
                return relay.event;
            }
        };
    }
    class $si {
        constructor(a) {
            this.a = a;
        }
        routeCall(hub) {
            return this.b(hub);
        }
        routeEvent(hub) {
            return this.b(hub);
        }
        async b(hub) {
            for (const connection of hub.connections) {
                if (await Promise.resolve(this.a(connection.ctx))) {
                    return Promise.resolve(connection);
                }
            }
            await event_1.Event.toPromise(hub.onDidAddConnection);
            return await this.b(hub);
        }
    }
    exports.$si = $si;
    /**
     * Use ProxyChannels to automatically wrapping and unwrapping
     * services to/from IPC channels, instead of manually wrapping
     * each service method and event.
     *
     * Restrictions:
     * - If marshalling is enabled, only `URI` and `RegExp` is converted
     *   automatically for you
     * - Events must follow the naming convention `onUpperCase`
     * - `CancellationToken` is currently not supported
     * - If a context is provided, you can use `AddFirstParameterToFunctions`
     *   utility to signal this in the receiving side type
     */
    var ProxyChannel;
    (function (ProxyChannel) {
        function fromService(service, disposables, options) {
            const handler = service;
            const disableMarshalling = options && options.disableMarshalling;
            // Buffer any event that should be supported by
            // iterating over all property keys and finding them
            // However, this will not work for services that
            // are lazy and use a Proxy within. For that we
            // still need to check later (see below).
            const mapEventNameToEvent = new Map();
            for (const key in handler) {
                if (propertyIsEvent(key)) {
                    mapEventNameToEvent.set(key, event_1.Event.buffer(handler[key], true, undefined, disposables));
                }
            }
            return new class {
                listen(_, event, arg) {
                    const eventImpl = mapEventNameToEvent.get(event);
                    if (eventImpl) {
                        return eventImpl;
                    }
                    const target = handler[event];
                    if (typeof target === 'function') {
                        if (propertyIsDynamicEvent(event)) {
                            return target.call(handler, arg);
                        }
                        if (propertyIsEvent(event)) {
                            mapEventNameToEvent.set(event, event_1.Event.buffer(handler[event], true, undefined, disposables));
                            return mapEventNameToEvent.get(event);
                        }
                    }
                    throw new errors_1.$fb(`Event not found: ${event}`);
                }
                call(_, command, args) {
                    const target = handler[command];
                    if (typeof target === 'function') {
                        // Revive unless marshalling disabled
                        if (!disableMarshalling && Array.isArray(args)) {
                            for (let i = 0; i < args.length; i++) {
                                args[i] = (0, marshalling_1.$hi)(args[i]);
                            }
                        }
                        let res = target.apply(handler, args);
                        if (!(res instanceof Promise)) {
                            res = Promise.resolve(res);
                        }
                        return res;
                    }
                    throw new errors_1.$fb(`Method not found: ${command}`);
                }
            };
        }
        ProxyChannel.fromService = fromService;
        function toService(channel, options) {
            const disableMarshalling = options && options.disableMarshalling;
            return new Proxy({}, {
                get(_target, propKey) {
                    if (typeof propKey === 'string') {
                        // Check for predefined values
                        if (options?.properties?.has(propKey)) {
                            return options.properties.get(propKey);
                        }
                        // Dynamic Event
                        if (propertyIsDynamicEvent(propKey)) {
                            return function (arg) {
                                return channel.listen(propKey, arg);
                            };
                        }
                        // Event
                        if (propertyIsEvent(propKey)) {
                            return channel.listen(propKey);
                        }
                        // Function
                        return async function (...args) {
                            // Add context if any
                            let methodArgs;
                            if (options && !(0, types_1.$sg)(options.context)) {
                                methodArgs = [options.context, ...args];
                            }
                            else {
                                methodArgs = args;
                            }
                            const result = await channel.call(propKey, methodArgs);
                            // Revive unless marshalling disabled
                            if (!disableMarshalling) {
                                return (0, marshalling_1.$hi)(result);
                            }
                            return result;
                        };
                    }
                    throw new errors_1.$fb(`Property not found: ${String(propKey)}`);
                }
            });
        }
        ProxyChannel.toService = toService;
        function propertyIsEvent(name) {
            // Assume a property is an event if it has a form of "onSomething"
            return name[0] === 'o' && name[1] === 'n' && strings.$Jf(name.charCodeAt(2));
        }
        function propertyIsDynamicEvent(name) {
            // Assume a property is a dynamic event (a method that returns an event) if it has a form of "onDynamicSomething"
            return /^onDynamic/.test(name) && strings.$Jf(name.charCodeAt(9));
        }
    })(ProxyChannel || (exports.ProxyChannel = ProxyChannel = {}));
    const colorTables = [
        ['#2977B1', '#FC802D', '#34A13A', '#D3282F', '#9366BA'],
        ['#8B564C', '#E177C0', '#7F7F7F', '#BBBE3D', '#2EBECD']
    ];
    function prettyWithoutArrays(data) {
        if (Array.isArray(data)) {
            return data;
        }
        if (data && typeof data === 'object' && typeof data.toString === 'function') {
            const result = data.toString();
            if (result !== '[object Object]') {
                return result;
            }
        }
        return data;
    }
    function pretty(data) {
        if (Array.isArray(data)) {
            return data.map(prettyWithoutArrays);
        }
        return prettyWithoutArrays(data);
    }
    function logWithColors(direction, totalLength, msgLength, req, initiator, str, data) {
        data = pretty(data);
        const colorTable = colorTables[initiator];
        const color = colorTable[req % colorTable.length];
        let args = [`%c[${direction}]%c[${String(totalLength).padStart(7, ' ')}]%c[len: ${String(msgLength).padStart(5, ' ')}]%c${String(req).padStart(5, ' ')} - ${str}`, 'color: darkgreen', 'color: grey', 'color: grey', `color: ${color}`];
        if (/\($/.test(str)) {
            args = args.concat(data);
            args.push(')');
        }
        else {
            args.push(data);
        }
        console.log.apply(console, args);
    }
    class $ti {
        constructor(d, f) {
            this.d = d;
            this.f = f;
            this.a = 0;
            this.b = 0;
        }
        logOutgoing(msgLength, requestId, initiator, str, data) {
            this.b += msgLength;
            logWithColors(this.d, this.b, msgLength, requestId, initiator, str, data);
        }
        logIncoming(msgLength, requestId, initiator, str, data) {
            this.a += msgLength;
            logWithColors(this.f, this.a, msgLength, requestId, initiator, str, data);
        }
    }
    exports.$ti = $ti;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/























define(__m[66/*vs/base/parts/ipc/node/ipc.cp*/], __M([0/*require*/,1/*exports*/,29/*child_process*/,12/*vs/base/common/async*/,19/*vs/base/common/buffer*/,18/*vs/base/common/cancellation*/,60/*vs/base/common/console*/,7/*vs/base/common/errors*/,4/*vs/base/common/event*/,2/*vs/base/common/lifecycle*/,32/*vs/base/common/objects*/,38/*vs/base/node/processes*/,36/*vs/base/common/processes*/,30/*vs/base/parts/ipc/common/ipc*/]), function (require, exports, child_process_1, async_1, buffer_1, cancellation_1, console_1, errors, event_1, lifecycle_1, objects_1, processes_1, processes_2, ipc_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$qr = exports.$pr = void 0;
    errors = __importStar(errors);
    /**
     * This implementation doesn't perform well since it uses base64 encoding for buffers.
     * We should move all implementations to use named ipc.net, so we stop depending on cp.fork.
     */
    class $pr extends ipc_1.$mi {
        constructor(ctx) {
            super({
                send: r => {
                    try {
                        process.send?.(r.buffer.toString('base64'));
                    }
                    catch (e) { /* not much to do */ }
                },
                onMessage: event_1.Event.fromNodeEventEmitter(process, 'message', msg => buffer_1.$Se.wrap(Buffer.from(msg, 'base64')))
            }, ctx);
            process.once('disconnect', () => this.dispose());
        }
    }
    exports.$pr = $pr;
    class $qr {
        constructor(i, j) {
            this.i = i;
            this.j = j;
            this.c = new Set();
            this.g = new Map();
            this.h = new event_1.$qe();
            this.onDidProcessExit = this.h.event;
            const timeout = j && j.timeout ? j.timeout : 60000;
            this.b = new async_1.$Hh(timeout);
            this.d = null;
            this.f = null;
        }
        getChannel(channelName) {
            const that = this;
            return {
                call(command, arg, cancellationToken) {
                    return that.k(channelName, command, arg, cancellationToken);
                },
                listen(event, arg) {
                    return that.l(channelName, event, arg);
                }
            };
        }
        k(channelName, name, arg, cancellationToken = cancellation_1.CancellationToken.None) {
            if (!this.b) {
                return Promise.reject(new Error('disposed'));
            }
            if (cancellationToken.isCancellationRequested) {
                return Promise.reject(errors.$0());
            }
            this.b.cancel();
            const channel = this.n(channelName);
            const result = (0, async_1.$xh)(token => channel.call(name, arg, token));
            const cancellationTokenListener = cancellationToken.onCancellationRequested(() => result.cancel());
            const disposable = (0, lifecycle_1.$Xc)(() => result.cancel());
            this.c.add(disposable);
            result.finally(() => {
                cancellationTokenListener.dispose();
                this.c.delete(disposable);
                if (this.c.size === 0 && this.b) {
                    this.b.trigger(() => this.o());
                }
            });
            return result;
        }
        l(channelName, name, arg) {
            if (!this.b) {
                return event_1.Event.None;
            }
            this.b.cancel();
            let listener;
            const emitter = new event_1.$qe({
                onWillAddFirstListener: () => {
                    const channel = this.n(channelName);
                    const event = channel.listen(name, arg);
                    listener = event(emitter.fire, emitter);
                    this.c.add(listener);
                },
                onDidRemoveLastListener: () => {
                    this.c.delete(listener);
                    listener.dispose();
                    if (this.c.size === 0 && this.b) {
                        this.b.trigger(() => this.o());
                    }
                }
            });
            return emitter.event;
        }
        get m() {
            if (!this.f) {
                const args = this.j && this.j.args ? this.j.args : [];
                const forkOpts = Object.create(null);
                forkOpts.env = { ...(0, objects_1.$ko)(process.env), 'VSCODE_PARENT_PID': String(process.pid) };
                if (this.j && this.j.env) {
                    forkOpts.env = { ...forkOpts.env, ...this.j.env };
                }
                if (this.j && this.j.freshExecArgv) {
                    forkOpts.execArgv = [];
                }
                if (this.j && typeof this.j.debug === 'number') {
                    forkOpts.execArgv = ['--nolazy', '--inspect=' + this.j.debug];
                }
                if (this.j && typeof this.j.debugBrk === 'number') {
                    forkOpts.execArgv = ['--nolazy', '--inspect-brk=' + this.j.debugBrk];
                }
                if (forkOpts.execArgv === undefined) {
                    forkOpts.execArgv = process.execArgv // if not set, the forked process inherits the execArgv of the parent process
                        .filter(a => !/^--inspect(-brk)?=/.test(a)) // --inspect and --inspect-brk can not be inherited as the port would conflict
                        .filter(a => !a.startsWith('--vscode-')); // --vscode-* arguments are unsupported by node.js and thus need to remove
                }
                (0, processes_2.$rm)(forkOpts.env);
                this.d = (0, child_process_1.fork)(this.i, args, forkOpts);
                const onMessageEmitter = new event_1.$qe();
                const onRawMessage = event_1.Event.fromNodeEventEmitter(this.d, 'message', msg => msg);
                const rawMessageDisposable = onRawMessage(msg => {
                    // Handle remote console logs specially
                    if ((0, console_1.$lr)(msg)) {
                        (0, console_1.log)(msg, `IPC Library: ${this.j.serverName}`);
                        return;
                    }
                    // Anything else goes to the outside
                    onMessageEmitter.fire(buffer_1.$Se.wrap(Buffer.from(msg, 'base64')));
                });
                const sender = this.j.useQueue ? (0, processes_1.$Em)(this.d) : this.d;
                const send = (r) => this.d && this.d.connected && sender.send(r.buffer.toString('base64'));
                const onMessage = onMessageEmitter.event;
                const protocol = { send, onMessage };
                this.f = new ipc_1.$ni(protocol);
                const onExit = () => this.o();
                process.once('exit', onExit);
                this.d.on('error', err => console.warn('IPC "' + this.j.serverName + '" errored with ' + err));
                this.d.on('exit', (code, signal) => {
                    process.removeListener('exit', onExit); // https://github.com/electron/electron/issues/21475
                    rawMessageDisposable.dispose();
                    this.c.forEach(r => (0, lifecycle_1.$Uc)(r));
                    this.c.clear();
                    if (code !== 0 && signal !== 'SIGTERM') {
                        console.warn('IPC "' + this.j.serverName + '" crashed with exit code ' + code + ' and signal ' + signal);
                    }
                    this.b?.cancel();
                    this.o();
                    this.h.fire({ code, signal });
                });
            }
            return this.f;
        }
        n(name) {
            let channel = this.g.get(name);
            if (!channel) {
                channel = this.m.getChannel(name);
                this.g.set(name, channel);
            }
            return channel;
        }
        o() {
            if (this.f) {
                if (this.d) {
                    this.d.kill();
                    this.d = null;
                }
                this.f = null;
                this.g.clear();
            }
        }
        dispose() {
            this.h.dispose();
            this.b?.cancel();
            this.b = undefined;
            this.o();
            this.c.clear();
        }
    }
    exports.$qr = $qr;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[67/*vs/base/parts/ipc/node/ipc.mp*/], __M([0/*require*/,1/*exports*/,33/*vs/base/parts/sandbox/node/electronTypes*/,19/*vs/base/common/buffer*/,30/*vs/base/parts/ipc/common/ipc*/,4/*vs/base/common/event*/,10/*vs/base/common/types*/,17/*vs/base/common/arrays*/]), function (require, exports, electronTypes_1, buffer_1, ipc_1, event_1, types_1, arrays_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$RY = void 0;
    exports.$SY = $SY;
    /**
     * The MessagePort `Protocol` leverages MessagePortMain style IPC communication
     * for the implementation of the `IMessagePassingProtocol`.
     */
    class Protocol {
        constructor(a) {
            this.a = a;
            this.onMessage = event_1.Event.fromNodeEventEmitter(this.a, 'message', (e) => {
                if (e.data) {
                    return buffer_1.$Se.wrap(e.data);
                }
                return buffer_1.$Se.alloc(0);
            });
            // we must call start() to ensure messages are flowing
            a.start();
        }
        send(message) {
            this.a.postMessage(message.buffer);
        }
        disconnect() {
            this.a.close();
        }
    }
    /**
     * An implementation of a `IPCServer` on top of MessagePort style IPC communication.
     * The clients register themselves via Electron Utility Process IPC transfer.
     */
    class $RY extends ipc_1.$oi {
        static b(filter) {
            (0, types_1.$tg)((0, electronTypes_1.$QY)(process), 'Electron Utility Process');
            const onCreateMessageChannel = new event_1.$qe();
            process.parentPort.on('message', (e) => {
                if (filter?.handledClientConnection(e)) {
                    return;
                }
                const port = (0, arrays_1.$Sb)(e.ports);
                if (port) {
                    onCreateMessageChannel.fire(port);
                }
            });
            return event_1.Event.map(onCreateMessageChannel.event, port => {
                const protocol = new Protocol(port);
                const result = {
                    protocol,
                    // Not part of the standard spec, but in Electron we get a `close` event
                    // when the other side closes. We can use this to detect disconnects
                    // (https://github.com/electron/electron/blob/11-x-y/docs/api/message-port-main.md#event-close)
                    onDidClientDisconnect: event_1.Event.fromNodeEventEmitter(port, 'close')
                };
                return result;
            });
        }
        constructor(filter) {
            super($RY.b(filter));
        }
    }
    exports.$RY = $RY;
    function $SY(port, message, callback) {
        const listener = (e) => {
            if (e.data === message) {
                port.removeListener('message', listener);
                callback();
            }
        };
        port.on('message', listener);
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[68/*vs/platform/contextkey/common/scanner*/], __M([0/*require*/,1/*exports*/,13/*vs/base/common/charCode*/,7/*vs/base/common/errors*/,8/*vs/nls*/]), function (require, exports, charCode_1, errors_1, nls_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$Fj = exports.TokenType = void 0;
    var TokenType;
    (function (TokenType) {
        TokenType[TokenType["LParen"] = 0] = "LParen";
        TokenType[TokenType["RParen"] = 1] = "RParen";
        TokenType[TokenType["Neg"] = 2] = "Neg";
        TokenType[TokenType["Eq"] = 3] = "Eq";
        TokenType[TokenType["NotEq"] = 4] = "NotEq";
        TokenType[TokenType["Lt"] = 5] = "Lt";
        TokenType[TokenType["LtEq"] = 6] = "LtEq";
        TokenType[TokenType["Gt"] = 7] = "Gt";
        TokenType[TokenType["GtEq"] = 8] = "GtEq";
        TokenType[TokenType["RegexOp"] = 9] = "RegexOp";
        TokenType[TokenType["RegexStr"] = 10] = "RegexStr";
        TokenType[TokenType["True"] = 11] = "True";
        TokenType[TokenType["False"] = 12] = "False";
        TokenType[TokenType["In"] = 13] = "In";
        TokenType[TokenType["Not"] = 14] = "Not";
        TokenType[TokenType["And"] = 15] = "And";
        TokenType[TokenType["Or"] = 16] = "Or";
        TokenType[TokenType["Str"] = 17] = "Str";
        TokenType[TokenType["QuotedStr"] = 18] = "QuotedStr";
        TokenType[TokenType["Error"] = 19] = "Error";
        TokenType[TokenType["EOF"] = 20] = "EOF";
    })(TokenType || (exports.TokenType = TokenType = {}));
    function hintDidYouMean(...meant) {
        switch (meant.length) {
            case 1:
                return (0, nls_1.localize)(1693, null, meant[0]);
            case 2:
                return (0, nls_1.localize)(1694, null, meant[0], meant[1]);
            case 3:
                return (0, nls_1.localize)(1695, null, meant[0], meant[1], meant[2]);
            default: // we just don't expect that many
                return undefined;
        }
    }
    const hintDidYouForgetToOpenOrCloseQuote = (0, nls_1.localize)(1696, null);
    const hintDidYouForgetToEscapeSlash = (0, nls_1.localize)(1697, null);
    /**
     * A simple scanner for context keys.
     *
     * Example:
     *
     * ```ts
     * const scanner = new Scanner().reset('resourceFileName =~ /docker/ && !config.docker.enabled');
     * const tokens = [...scanner];
     * if (scanner.errorTokens.length > 0) {
     *     scanner.errorTokens.forEach(err => console.error(`Unexpected token at ${err.offset}: ${err.lexeme}\nHint: ${err.additional}`));
     * } else {
     *     // process tokens
     * }
     * ```
     */
    class $Fj {
        constructor() {
            this.c = '';
            this.d = 0;
            this.e = 0;
            this.f = [];
            this.g = [];
            // u - unicode, y - sticky // TODO@ulugbekna: we accept double quotes as part of the string rather than as a delimiter (to preserve old parser's behavior)
            this.m = /[a-zA-Z0-9_<>\-\./\\:\*\?\+\[\]\^,#@;"%\$\p{L}-]+/uy;
        }
        static getLexeme(token) {
            switch (token.type) {
                case TokenType.LParen:
                    return '(';
                case TokenType.RParen:
                    return ')';
                case TokenType.Neg:
                    return '!';
                case TokenType.Eq:
                    return token.isTripleEq ? '===' : '==';
                case TokenType.NotEq:
                    return token.isTripleEq ? '!==' : '!=';
                case TokenType.Lt:
                    return '<';
                case TokenType.LtEq:
                    return '<=';
                case TokenType.Gt:
                    return '>=';
                case TokenType.GtEq:
                    return '>=';
                case TokenType.RegexOp:
                    return '=~';
                case TokenType.RegexStr:
                    return token.lexeme;
                case TokenType.True:
                    return 'true';
                case TokenType.False:
                    return 'false';
                case TokenType.In:
                    return 'in';
                case TokenType.Not:
                    return 'not';
                case TokenType.And:
                    return '&&';
                case TokenType.Or:
                    return '||';
                case TokenType.Str:
                    return token.lexeme;
                case TokenType.QuotedStr:
                    return token.lexeme;
                case TokenType.Error:
                    return token.lexeme;
                case TokenType.EOF:
                    return 'EOF';
                default:
                    throw (0, errors_1.$_)(`unhandled token type: ${JSON.stringify(token)}; have you forgotten to add a case?`);
            }
        }
        static { this.a = new Set(['i', 'g', 's', 'm', 'y', 'u'].map(ch => ch.charCodeAt(0))); }
        static { this.b = new Map([
            ['not', TokenType.Not],
            ['in', TokenType.In],
            ['false', TokenType.False],
            ['true', TokenType.True],
        ]); }
        get errors() {
            return this.g;
        }
        reset(value) {
            this.c = value;
            this.d = 0;
            this.e = 0;
            this.f = [];
            this.g = [];
            return this;
        }
        scan() {
            while (!this.r()) {
                this.d = this.e;
                const ch = this.i();
                switch (ch) {
                    case charCode_1.CharCode.OpenParen:
                        this.k(TokenType.LParen);
                        break;
                    case charCode_1.CharCode.CloseParen:
                        this.k(TokenType.RParen);
                        break;
                    case charCode_1.CharCode.ExclamationMark:
                        if (this.h(charCode_1.CharCode.Equals)) {
                            const isTripleEq = this.h(charCode_1.CharCode.Equals); // eat last `=` if `!==`
                            this.f.push({ type: TokenType.NotEq, offset: this.d, isTripleEq });
                        }
                        else {
                            this.k(TokenType.Neg);
                        }
                        break;
                    case charCode_1.CharCode.SingleQuote:
                        this.o();
                        break;
                    case charCode_1.CharCode.Slash:
                        this.q();
                        break;
                    case charCode_1.CharCode.Equals:
                        if (this.h(charCode_1.CharCode.Equals)) { // support `==`
                            const isTripleEq = this.h(charCode_1.CharCode.Equals); // eat last `=` if `===`
                            this.f.push({ type: TokenType.Eq, offset: this.d, isTripleEq });
                        }
                        else if (this.h(charCode_1.CharCode.Tilde)) {
                            this.k(TokenType.RegexOp);
                        }
                        else {
                            this.l(hintDidYouMean('==', '=~'));
                        }
                        break;
                    case charCode_1.CharCode.LessThan:
                        this.k(this.h(charCode_1.CharCode.Equals) ? TokenType.LtEq : TokenType.Lt);
                        break;
                    case charCode_1.CharCode.GreaterThan:
                        this.k(this.h(charCode_1.CharCode.Equals) ? TokenType.GtEq : TokenType.Gt);
                        break;
                    case charCode_1.CharCode.Ampersand:
                        if (this.h(charCode_1.CharCode.Ampersand)) {
                            this.k(TokenType.And);
                        }
                        else {
                            this.l(hintDidYouMean('&&'));
                        }
                        break;
                    case charCode_1.CharCode.Pipe:
                        if (this.h(charCode_1.CharCode.Pipe)) {
                            this.k(TokenType.Or);
                        }
                        else {
                            this.l(hintDidYouMean('||'));
                        }
                        break;
                    // TODO@ulugbekna: 1) rewrite using a regex 2) reconsider what characters are considered whitespace, including unicode, nbsp, etc.
                    case charCode_1.CharCode.Space:
                    case charCode_1.CharCode.CarriageReturn:
                    case charCode_1.CharCode.Tab:
                    case charCode_1.CharCode.LineFeed:
                    case charCode_1.CharCode.NoBreakSpace: // &nbsp
                        break;
                    default:
                        this.n();
                }
            }
            this.d = this.e;
            this.k(TokenType.EOF);
            return Array.from(this.f);
        }
        h(expected) {
            if (this.r()) {
                return false;
            }
            if (this.c.charCodeAt(this.e) !== expected) {
                return false;
            }
            this.e++;
            return true;
        }
        i() {
            return this.c.charCodeAt(this.e++);
        }
        j() {
            return this.r() ? charCode_1.CharCode.Null : this.c.charCodeAt(this.e);
        }
        k(type) {
            this.f.push({ type, offset: this.d });
        }
        l(additional) {
            const offset = this.d;
            const lexeme = this.c.substring(this.d, this.e);
            const errToken = { type: TokenType.Error, offset: this.d, lexeme };
            this.g.push({ offset, lexeme, additionalInfo: additional });
            this.f.push(errToken);
        }
        n() {
            this.m.lastIndex = this.d;
            const match = this.m.exec(this.c);
            if (match) {
                this.e = this.d + match[0].length;
                const lexeme = this.c.substring(this.d, this.e);
                const keyword = $Fj.b.get(lexeme);
                if (keyword) {
                    this.k(keyword);
                }
                else {
                    this.f.push({ type: TokenType.Str, lexeme, offset: this.d });
                }
            }
        }
        // captures the lexeme without the leading and trailing '
        o() {
            while (this.j() !== charCode_1.CharCode.SingleQuote && !this.r()) { // TODO@ulugbekna: add support for escaping ' ?
                this.i();
            }
            if (this.r()) {
                this.l(hintDidYouForgetToOpenOrCloseQuote);
                return;
            }
            // consume the closing '
            this.i();
            this.f.push({ type: TokenType.QuotedStr, lexeme: this.c.substring(this.d + 1, this.e - 1), offset: this.d + 1 });
        }
        /*
         * Lexing a regex expression: /.../[igsmyu]*
         * Based on https://github.com/microsoft/TypeScript/blob/9247ef115e617805983740ba795d7a8164babf89/src/compiler/scanner.ts#L2129-L2181
         *
         * Note that we want slashes within a regex to be escaped, e.g., /file:\\/\\/\\// should match `file:///`
         */
        q() {
            let p = this.e;
            let inEscape = false;
            let inCharacterClass = false;
            while (true) {
                if (p >= this.c.length) {
                    this.e = p;
                    this.l(hintDidYouForgetToEscapeSlash);
                    return;
                }
                const ch = this.c.charCodeAt(p);
                if (inEscape) { // parsing an escape character
                    inEscape = false;
                }
                else if (ch === charCode_1.CharCode.Slash && !inCharacterClass) { // end of regex
                    p++;
                    break;
                }
                else if (ch === charCode_1.CharCode.OpenSquareBracket) {
                    inCharacterClass = true;
                }
                else if (ch === charCode_1.CharCode.Backslash) {
                    inEscape = true;
                }
                else if (ch === charCode_1.CharCode.CloseSquareBracket) {
                    inCharacterClass = false;
                }
                p++;
            }
            // Consume flags // TODO@ulugbekna: use regex instead
            while (p < this.c.length && $Fj.a.has(this.c.charCodeAt(p))) {
                p++;
            }
            this.e = p;
            const lexeme = this.c.substring(this.d, this.e);
            this.f.push({ type: TokenType.RegexStr, lexeme, offset: this.d });
        }
        r() {
            return this.e >= this.c.length;
        }
    }
    exports.$Fj = $Fj;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/






define(__m[69/*vs/platform/environment/common/environmentService*/], __M([0/*require*/,1/*exports*/,58/*vs/base/common/date*/,14/*vs/base/common/decorators*/,20/*vs/base/common/network*/,5/*vs/base/common/path*/,15/*vs/base/common/process*/,25/*vs/base/common/resources*/,6/*vs/base/common/uri*/]), function (require, exports, date_1, decorators_1, network_1, path_1, process_1, resources_1, uri_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$_m = exports.$$m = void 0;
    exports.$an = $an;
    exports.$bn = $bn;
    exports.$$m = /^([^.]+\..+)[:=](.+)$/;
    class $_m {
        get appRoot() { return (0, path_1.$rc)(network_1.$5g.asFileUri('').fsPath); }
        get userHome() { return uri_1.URI.file(this.b.homeDir); }
        get userDataPath() { return this.b.userDataDir; }
        get appSettingsHome() { return uri_1.URI.file((0, path_1.$oc)(this.userDataPath, 'User')); }
        get tmpDir() { return uri_1.URI.file(this.b.tmpDir); }
        get cacheHome() { return uri_1.URI.file(this.userDataPath); }
        get stateResource() { return (0, resources_1.$lh)(this.appSettingsHome, 'globalStorage', 'storage.json'); }
        get userRoamingDataHome() { return this.appSettingsHome.with({ scheme: network_1.Schemas.vscodeUserData }); }
        get userDataSyncHome() { return (0, resources_1.$lh)(this.appSettingsHome, 'sync'); }
        get logsHome() {
            if (!this.args.logsPath) {
                const key = (0, date_1.$0m)(new Date()).replace(/-|:|\.\d+Z$/g, '');
                this.args.logsPath = (0, path_1.$oc)(this.userDataPath, 'logs', key);
            }
            return uri_1.URI.file(this.args.logsPath);
        }
        get sync() { return this.args.sync; }
        get machineSettingsResource() { return (0, resources_1.$lh)(uri_1.URI.file((0, path_1.$oc)(this.userDataPath, 'Machine')), 'settings.json'); }
        get workspaceStorageHome() { return (0, resources_1.$lh)(this.appSettingsHome, 'workspaceStorage'); }
        get localHistoryHome() { return (0, resources_1.$lh)(this.appSettingsHome, 'History'); }
        get keyboardLayoutResource() { return (0, resources_1.$lh)(this.userRoamingDataHome, 'keyboardLayout.json'); }
        get argvResource() {
            const vscodePortable = process_1.env['VSCODE_PORTABLE'];
            if (vscodePortable) {
                return uri_1.URI.file((0, path_1.$oc)(vscodePortable, 'argv.json'));
            }
            return (0, resources_1.$lh)(this.userHome, this.c.dataFolderName, 'argv.json');
        }
        get isExtensionDevelopment() { return !!this.args.extensionDevelopmentPath; }
        get untitledWorkspacesHome() { return uri_1.URI.file((0, path_1.$oc)(this.userDataPath, 'Workspaces')); }
        get builtinExtensionsPath() {
            const cliBuiltinExtensionsDir = this.args['builtin-extensions-dir'];
            if (cliBuiltinExtensionsDir) {
                return (0, path_1.$pc)(cliBuiltinExtensionsDir);
            }
            return (0, path_1.$mc)((0, path_1.$oc)(network_1.$5g.asFileUri('').fsPath, '..', 'extensions'));
        }
        get extensionsDownloadLocation() {
            const cliExtensionsDownloadDir = this.args['extensions-download-dir'];
            if (cliExtensionsDownloadDir) {
                return uri_1.URI.file((0, path_1.$pc)(cliExtensionsDownloadDir));
            }
            return uri_1.URI.file((0, path_1.$oc)(this.userDataPath, 'CachedExtensionVSIXs'));
        }
        get extensionsPath() {
            const cliExtensionsDir = this.args['extensions-dir'];
            if (cliExtensionsDir) {
                return (0, path_1.$pc)(cliExtensionsDir);
            }
            const vscodeExtensions = process_1.env['VSCODE_EXTENSIONS'];
            if (vscodeExtensions) {
                return vscodeExtensions;
            }
            const vscodePortable = process_1.env['VSCODE_PORTABLE'];
            if (vscodePortable) {
                return (0, path_1.$oc)(vscodePortable, 'extensions');
            }
            return (0, resources_1.$lh)(this.userHome, this.c.dataFolderName, 'extensions').fsPath;
        }
        get extensionDevelopmentLocationURI() {
            const extensionDevelopmentPaths = this.args.extensionDevelopmentPath;
            if (Array.isArray(extensionDevelopmentPaths)) {
                return extensionDevelopmentPaths.map(extensionDevelopmentPath => {
                    if (/^[^:/?#]+?:\/\//.test(extensionDevelopmentPath)) {
                        return uri_1.URI.parse(extensionDevelopmentPath);
                    }
                    return uri_1.URI.file((0, path_1.$mc)(extensionDevelopmentPath));
                });
            }
            return undefined;
        }
        get extensionDevelopmentKind() {
            return this.args.extensionDevelopmentKind?.map(kind => kind === 'ui' || kind === 'workspace' || kind === 'web' ? kind : 'workspace');
        }
        get extensionTestsLocationURI() {
            const extensionTestsPath = this.args.extensionTestsPath;
            if (extensionTestsPath) {
                if (/^[^:/?#]+?:\/\//.test(extensionTestsPath)) {
                    return uri_1.URI.parse(extensionTestsPath);
                }
                return uri_1.URI.file((0, path_1.$mc)(extensionTestsPath));
            }
            return undefined;
        }
        get disableExtensions() {
            if (this.args['disable-extensions']) {
                return true;
            }
            const disableExtensions = this.args['disable-extension'];
            if (disableExtensions) {
                if (typeof disableExtensions === 'string') {
                    return [disableExtensions];
                }
                if (Array.isArray(disableExtensions) && disableExtensions.length > 0) {
                    return disableExtensions;
                }
            }
            return false;
        }
        get debugExtensionHost() { return $an(this.args, this.isBuilt); }
        get debugRenderer() { return !!this.args.debugRenderer; }
        get isBuilt() { return !process_1.env['VSCODE_DEV']; }
        get verbose() { return !!this.args.verbose; }
        get logLevel() { return this.args.log?.find(entry => !exports.$$m.test(entry)); }
        get extensionLogLevel() {
            const result = [];
            for (const entry of this.args.log || []) {
                const matches = exports.$$m.exec(entry);
                if (matches && matches[1] && matches[2]) {
                    result.push([matches[1], matches[2]]);
                }
            }
            return result.length ? result : undefined;
        }
        get serviceMachineIdResource() { return (0, resources_1.$lh)(uri_1.URI.file(this.userDataPath), 'machineid'); }
        get crashReporterId() { return this.args['crash-reporter-id']; }
        get crashReporterDirectory() { return this.args['crash-reporter-directory']; }
        get disableTelemetry() { return !!this.args['disable-telemetry']; }
        get disableWorkspaceTrust() { return !!this.args['disable-workspace-trust']; }
        get useInMemorySecretStorage() { return !!this.args['use-inmemory-secretstorage']; }
        get policyFile() {
            if (this.args['__enable-file-policy']) {
                const vscodePortable = process_1.env['VSCODE_PORTABLE'];
                if (vscodePortable) {
                    return uri_1.URI.file((0, path_1.$oc)(vscodePortable, 'policy.json'));
                }
                return (0, resources_1.$lh)(this.userHome, this.c.dataFolderName, 'policy.json');
            }
            return undefined;
        }
        get continueOn() {
            return this.args['continueOn'];
        }
        set continueOn(value) {
            this.args['continueOn'] = value;
        }
        get args() { return this.a; }
        constructor(a, b, c) {
            this.a = a;
            this.b = b;
            this.c = c;
            this.editSessionId = this.args['editSessionId'];
        }
    }
    exports.$_m = $_m;
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "appRoot", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "userHome", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "userDataPath", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "appSettingsHome", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "tmpDir", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "cacheHome", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "stateResource", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "userRoamingDataHome", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "userDataSyncHome", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "sync", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "machineSettingsResource", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "workspaceStorageHome", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "localHistoryHome", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "keyboardLayoutResource", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "argvResource", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "isExtensionDevelopment", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "untitledWorkspacesHome", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "builtinExtensionsPath", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "extensionsPath", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "extensionDevelopmentLocationURI", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "extensionDevelopmentKind", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "extensionTestsLocationURI", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "debugExtensionHost", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "logLevel", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "extensionLogLevel", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "serviceMachineIdResource", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "disableTelemetry", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "disableWorkspaceTrust", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "useInMemorySecretStorage", null);
    __decorate([
        decorators_1.$ci
    ], $_m.prototype, "policyFile", null);
    function $an(args, isBuilt) {
        return $bn(args['inspect-extensions'], args['inspect-brk-extensions'], 5870, isBuilt, args.debugId, args.extensionEnvironment);
    }
    function $bn(debugArg, debugBrkArg, defaultBuildPort, isBuilt, debugId, environmentString) {
        const portStr = debugBrkArg || debugArg;
        const port = Number(portStr) || (!isBuilt ? defaultBuildPort : null);
        const brk = port ? Boolean(!!debugBrkArg) : false;
        let env;
        if (environmentString) {
            try {
                env = JSON.parse(environmentString);
            }
            catch {
                // ignore
            }
        }
        return { port, break: brk, debugId, env };
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
define(__m[70/*vs/platform/environment/node/argv*/], __M([0/*require*/,1/*exports*/,102/*minimist*/,3/*vs/base/common/platform*/,8/*vs/nls*/]), function (require, exports, minimist_1, platform_1, nls_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$Hm = exports.$Gm = void 0;
    exports.$Im = $Im;
    exports.$Jm = $Jm;
    exports.$Km = $Km;
    exports.$Lm = $Lm;
    minimist_1 = __importDefault(minimist_1);
    /**
     * This code is also used by standalone cli's. Avoid adding any other dependencies.
     */
    const helpCategories = {
        o: (0, nls_1.localize)(1713, null),
        e: (0, nls_1.localize)(1714, null),
        t: (0, nls_1.localize)(1715, null)
    };
    exports.$Gm = ['tunnel', 'serve-web'];
    exports.$Hm = {
        'tunnel': {
            type: 'subcommand',
            description: 'Make the current machine accessible from vscode.dev or other machines through a secure tunnel',
            options: {
                'cli-data-dir': { type: 'string', args: 'dir', description: (0, nls_1.localize)(1716, null) },
                'disable-telemetry': { type: 'boolean' },
                'telemetry-level': { type: 'string' },
                user: {
                    type: 'subcommand',
                    options: {
                        login: {
                            type: 'subcommand',
                            options: {
                                provider: { type: 'string' },
                                'access-token': { type: 'string' }
                            }
                        }
                    }
                }
            }
        },
        'serve-web': {
            type: 'subcommand',
            description: 'Run a server that displays the editor UI in browsers.',
            options: {
                'cli-data-dir': { type: 'string', args: 'dir', description: (0, nls_1.localize)(1717, null) },
                'disable-telemetry': { type: 'boolean' },
                'telemetry-level': { type: 'string' },
            }
        },
        'diff': { type: 'boolean', cat: 'o', alias: 'd', args: ['file', 'file'], description: (0, nls_1.localize)(1718, null) },
        'merge': { type: 'boolean', cat: 'o', alias: 'm', args: ['path1', 'path2', 'base', 'result'], description: (0, nls_1.localize)(1719, null) },
        'add': { type: 'boolean', cat: 'o', alias: 'a', args: 'folder', description: (0, nls_1.localize)(1720, null) },
        'goto': { type: 'boolean', cat: 'o', alias: 'g', args: 'file:line[:character]', description: (0, nls_1.localize)(1721, null) },
        'new-window': { type: 'boolean', cat: 'o', alias: 'n', description: (0, nls_1.localize)(1722, null) },
        'reuse-window': { type: 'boolean', cat: 'o', alias: 'r', description: (0, nls_1.localize)(1723, null) },
        'wait': { type: 'boolean', cat: 'o', alias: 'w', description: (0, nls_1.localize)(1724, null) },
        'waitMarkerFilePath': { type: 'string' },
        'locale': { type: 'string', cat: 'o', args: 'locale', description: (0, nls_1.localize)(1725, null) },
        'user-data-dir': { type: 'string', cat: 'o', args: 'dir', description: (0, nls_1.localize)(1726, null) },
        'profile': { type: 'string', 'cat': 'o', args: 'profileName', description: (0, nls_1.localize)(1727, null) },
        'help': { type: 'boolean', cat: 'o', alias: 'h', description: (0, nls_1.localize)(1728, null) },
        'extensions-dir': { type: 'string', deprecates: ['extensionHomePath'], cat: 'e', args: 'dir', description: (0, nls_1.localize)(1729, null) },
        'extensions-download-dir': { type: 'string' },
        'builtin-extensions-dir': { type: 'string' },
        'list-extensions': { type: 'boolean', cat: 'e', description: (0, nls_1.localize)(1730, null) },
        'show-versions': { type: 'boolean', cat: 'e', description: (0, nls_1.localize)(1731, null) },
        'category': { type: 'string', allowEmptyValue: true, cat: 'e', description: (0, nls_1.localize)(1732, null), args: 'category' },
        'install-extension': { type: 'string[]', cat: 'e', args: 'ext-id | path', description: (0, nls_1.localize)(1733, null) },
        'pre-release': { type: 'boolean', cat: 'e', description: (0, nls_1.localize)(1734, null) },
        'uninstall-extension': { type: 'string[]', cat: 'e', args: 'ext-id', description: (0, nls_1.localize)(1735, null) },
        'update-extensions': { type: 'boolean', cat: 'e', description: (0, nls_1.localize)(1736, null) },
        'enable-proposed-api': { type: 'string[]', allowEmptyValue: true, cat: 'e', args: 'ext-id', description: (0, nls_1.localize)(1737, null) },
        'version': { type: 'boolean', cat: 't', alias: 'v', description: (0, nls_1.localize)(1738, null) },
        'verbose': { type: 'boolean', cat: 't', global: true, description: (0, nls_1.localize)(1739, null) },
        'log': { type: 'string[]', cat: 't', args: 'level', global: true, description: (0, nls_1.localize)(1740, null) },
        'status': { type: 'boolean', alias: 's', cat: 't', description: (0, nls_1.localize)(1741, null) },
        'prof-startup': { type: 'boolean', cat: 't', description: (0, nls_1.localize)(1742, null) },
        'prof-append-timers': { type: 'string' },
        'prof-duration-markers': { type: 'string[]' },
        'prof-duration-markers-file': { type: 'string' },
        'no-cached-data': { type: 'boolean' },
        'prof-startup-prefix': { type: 'string' },
        'prof-v8-extensions': { type: 'boolean' },
        'disable-extensions': { type: 'boolean', deprecates: ['disableExtensions'], cat: 't', description: (0, nls_1.localize)(1743, null) },
        'disable-extension': { type: 'string[]', cat: 't', args: 'ext-id', description: (0, nls_1.localize)(1744, null) },
        'sync': { type: 'string', cat: 't', description: (0, nls_1.localize)(1745, null), args: ['on | off'] },
        'inspect-extensions': { type: 'string', allowEmptyValue: true, deprecates: ['debugPluginHost'], args: 'port', cat: 't', description: (0, nls_1.localize)(1746, null) },
        'inspect-brk-extensions': { type: 'string', allowEmptyValue: true, deprecates: ['debugBrkPluginHost'], args: 'port', cat: 't', description: (0, nls_1.localize)(1747, null) },
        'disable-lcd-text': { type: 'boolean', cat: 't', description: (0, nls_1.localize)(1748, null) },
        'disable-gpu': { type: 'boolean', cat: 't', description: (0, nls_1.localize)(1749, null) },
        'disable-chromium-sandbox': { type: 'boolean', cat: 't', description: (0, nls_1.localize)(1750, null) },
        'sandbox': { type: 'boolean' },
        'telemetry': { type: 'boolean', cat: 't', description: (0, nls_1.localize)(1751, null) },
        'remote': { type: 'string', allowEmptyValue: true },
        'folder-uri': { type: 'string[]', cat: 'o', args: 'uri' },
        'file-uri': { type: 'string[]', cat: 'o', args: 'uri' },
        'locate-extension': { type: 'string[]' },
        'extensionDevelopmentPath': { type: 'string[]' },
        'extensionDevelopmentKind': { type: 'string[]' },
        'extensionTestsPath': { type: 'string' },
        'extensionEnvironment': { type: 'string' },
        'debugId': { type: 'string' },
        'debugRenderer': { type: 'boolean' },
        'inspect-ptyhost': { type: 'string', allowEmptyValue: true },
        'inspect-brk-ptyhost': { type: 'string', allowEmptyValue: true },
        'inspect-search': { type: 'string', deprecates: ['debugSearch'], allowEmptyValue: true },
        'inspect-brk-search': { type: 'string', deprecates: ['debugBrkSearch'], allowEmptyValue: true },
        'inspect-sharedprocess': { type: 'string', allowEmptyValue: true },
        'inspect-brk-sharedprocess': { type: 'string', allowEmptyValue: true },
        'export-default-configuration': { type: 'string' },
        'install-source': { type: 'string' },
        'enable-smoke-test-driver': { type: 'boolean' },
        'logExtensionHostCommunication': { type: 'boolean' },
        'skip-release-notes': { type: 'boolean' },
        'skip-welcome': { type: 'boolean' },
        'disable-telemetry': { type: 'boolean' },
        'disable-updates': { type: 'boolean' },
        'use-inmemory-secretstorage': { type: 'boolean', deprecates: ['disable-keytar'] },
        'password-store': { type: 'string' },
        'disable-workspace-trust': { type: 'boolean' },
        'disable-crash-reporter': { type: 'boolean' },
        'crash-reporter-directory': { type: 'string' },
        'crash-reporter-id': { type: 'string' },
        'skip-add-to-recently-opened': { type: 'boolean' },
        'open-url': { type: 'boolean' },
        'file-write': { type: 'boolean' },
        'file-chmod': { type: 'boolean' },
        'install-builtin-extension': { type: 'string[]' },
        'force': { type: 'boolean' },
        'do-not-sync': { type: 'boolean' },
        'trace': { type: 'boolean' },
        'trace-category-filter': { type: 'string' },
        'trace-options': { type: 'string' },
        'preserve-env': { type: 'boolean' },
        'force-user-env': { type: 'boolean' },
        'force-disable-user-env': { type: 'boolean' },
        'open-devtools': { type: 'boolean' },
        'disable-gpu-sandbox': { type: 'boolean' },
        'logsPath': { type: 'string' },
        '__enable-file-policy': { type: 'boolean' },
        'editSessionId': { type: 'string' },
        'continueOn': { type: 'string' },
        'locate-shell-integration-path': { type: 'string', args: ['bash', 'pwsh', 'zsh', 'fish'] },
        'enable-coi': { type: 'boolean' },
        // chromium flags
        'no-proxy-server': { type: 'boolean' },
        // Minimist incorrectly parses keys that start with `--no`
        // https://github.com/substack/minimist/blob/aeb3e27dae0412de5c0494e9563a5f10c82cc7a9/index.js#L118-L121
        // If --no-sandbox is passed via cli wrapper it will be treated as --sandbox which is incorrect, we use
        // the alias here to make sure --no-sandbox is always respected.
        // For https://github.com/microsoft/vscode/issues/128279
        'no-sandbox': { type: 'boolean', alias: 'sandbox' },
        'proxy-server': { type: 'string' },
        'proxy-bypass-list': { type: 'string' },
        'proxy-pac-url': { type: 'string' },
        'js-flags': { type: 'string' }, // chrome js flags
        'inspect': { type: 'string', allowEmptyValue: true },
        'inspect-brk': { type: 'string', allowEmptyValue: true },
        'nolazy': { type: 'boolean' }, // node inspect
        'force-device-scale-factor': { type: 'string' },
        'force-renderer-accessibility': { type: 'boolean' },
        'ignore-certificate-errors': { type: 'boolean' },
        'allow-insecure-localhost': { type: 'boolean' },
        'log-net-log': { type: 'string' },
        'vmodule': { type: 'string' },
        '_urls': { type: 'string[]' },
        'disable-dev-shm-usage': { type: 'boolean' },
        'profile-temp': { type: 'boolean' },
        'ozone-platform': { type: 'string' },
        'enable-tracing': { type: 'string' },
        'trace-startup-format': { type: 'string' },
        'trace-startup-file': { type: 'string' },
        'trace-startup-duration': { type: 'string' },
        _: { type: 'string[]' } // main arguments
    };
    const ignoringReporter = {
        onUnknownOption: () => { },
        onMultipleValues: () => { },
        onEmptyValue: () => { },
        onDeprecatedOption: () => { }
    };
    function $Im(args, options, errorReporter = ignoringReporter) {
        const firstArg = args.find(a => a.length > 0 && a[0] !== '-');
        const alias = {};
        const stringOptions = ['_'];
        const booleanOptions = [];
        const globalOptions = {};
        let command = undefined;
        for (const optionId in options) {
            const o = options[optionId];
            if (o.type === 'subcommand') {
                if (optionId === firstArg) {
                    command = o;
                }
            }
            else {
                if (o.alias) {
                    alias[optionId] = o.alias;
                }
                if (o.type === 'string' || o.type === 'string[]') {
                    stringOptions.push(optionId);
                    if (o.deprecates) {
                        stringOptions.push(...o.deprecates);
                    }
                }
                else if (o.type === 'boolean') {
                    booleanOptions.push(optionId);
                    if (o.deprecates) {
                        booleanOptions.push(...o.deprecates);
                    }
                }
                if (o.global) {
                    globalOptions[optionId] = o;
                }
            }
        }
        if (command && firstArg) {
            const options = globalOptions;
            for (const optionId in command.options) {
                options[optionId] = command.options[optionId];
            }
            const newArgs = args.filter(a => a !== firstArg);
            const reporter = errorReporter.getSubcommandReporter ? errorReporter.getSubcommandReporter(firstArg) : undefined;
            const subcommandOptions = $Im(newArgs, options, reporter);
            return {
                [firstArg]: subcommandOptions,
                _: []
            };
        }
        // remove aliases to avoid confusion
        const parsedArgs = (0, minimist_1.default)(args, { string: stringOptions, boolean: booleanOptions, alias });
        const cleanedArgs = {};
        const remainingArgs = parsedArgs;
        // https://github.com/microsoft/vscode/issues/58177, https://github.com/microsoft/vscode/issues/106617
        cleanedArgs._ = parsedArgs._.map(arg => String(arg)).filter(arg => arg.length > 0);
        delete remainingArgs._;
        for (const optionId in options) {
            const o = options[optionId];
            if (o.type === 'subcommand') {
                continue;
            }
            if (o.alias) {
                delete remainingArgs[o.alias];
            }
            let val = remainingArgs[optionId];
            if (o.deprecates) {
                for (const deprecatedId of o.deprecates) {
                    if (remainingArgs.hasOwnProperty(deprecatedId)) {
                        if (!val) {
                            val = remainingArgs[deprecatedId];
                            if (val) {
                                errorReporter.onDeprecatedOption(deprecatedId, o.deprecationMessage || (0, nls_1.localize)(1752, null, optionId));
                            }
                        }
                        delete remainingArgs[deprecatedId];
                    }
                }
            }
            if (typeof val !== 'undefined') {
                if (o.type === 'string[]') {
                    if (!Array.isArray(val)) {
                        val = [val];
                    }
                    if (!o.allowEmptyValue) {
                        const sanitized = val.filter((v) => v.length > 0);
                        if (sanitized.length !== val.length) {
                            errorReporter.onEmptyValue(optionId);
                            val = sanitized.length > 0 ? sanitized : undefined;
                        }
                    }
                }
                else if (o.type === 'string') {
                    if (Array.isArray(val)) {
                        val = val.pop(); // take the last
                        errorReporter.onMultipleValues(optionId, val);
                    }
                    else if (!val && !o.allowEmptyValue) {
                        errorReporter.onEmptyValue(optionId);
                        val = undefined;
                    }
                }
                cleanedArgs[optionId] = val;
                if (o.deprecationMessage) {
                    errorReporter.onDeprecatedOption(optionId, o.deprecationMessage);
                }
            }
            delete remainingArgs[optionId];
        }
        for (const key in remainingArgs) {
            errorReporter.onUnknownOption(key);
        }
        return cleanedArgs;
    }
    function formatUsage(optionId, option) {
        let args = '';
        if (option.args) {
            if (Array.isArray(option.args)) {
                args = ` <${option.args.join('> <')}>`;
            }
            else {
                args = ` <${option.args}>`;
            }
        }
        if (option.alias) {
            return `-${option.alias} --${optionId}${args}`;
        }
        return `--${optionId}${args}`;
    }
    // exported only for testing
    function $Jm(options, columns) {
        const usageTexts = [];
        for (const optionId in options) {
            const o = options[optionId];
            const usageText = formatUsage(optionId, o);
            usageTexts.push([usageText, o.description]);
        }
        return formatUsageTexts(usageTexts, columns);
    }
    function formatUsageTexts(usageTexts, columns) {
        const maxLength = usageTexts.reduce((previous, e) => Math.max(previous, e[0].length), 12);
        const argLength = maxLength + 2 /*left padding*/ + 1 /*right padding*/;
        if (columns - argLength < 25) {
            // Use a condensed version on narrow terminals
            return usageTexts.reduce((r, ut) => r.concat([`  ${ut[0]}`, `      ${ut[1]}`]), []);
        }
        const descriptionColumns = columns - argLength - 1;
        const result = [];
        for (const ut of usageTexts) {
            const usage = ut[0];
            const wrappedDescription = wrapText(ut[1], descriptionColumns);
            const keyPadding = indent(argLength - usage.length - 2 /*left padding*/);
            result.push('  ' + usage + keyPadding + wrappedDescription[0]);
            for (let i = 1; i < wrappedDescription.length; i++) {
                result.push(indent(argLength) + wrappedDescription[i]);
            }
        }
        return result;
    }
    function indent(count) {
        return ' '.repeat(count);
    }
    function wrapText(text, columns) {
        const lines = [];
        while (text.length) {
            const index = text.length < columns ? text.length : text.lastIndexOf(' ', columns);
            const line = text.slice(0, index).trim();
            text = text.slice(index);
            lines.push(line);
        }
        return lines;
    }
    function $Km(productName, executableName, version, options, capabilities) {
        const columns = (process.stdout).isTTY && (process.stdout).columns || 80;
        const inputFiles = capabilities?.noInputFiles !== true ? `[${(0, nls_1.localize)(1753, null)}...]` : '';
        const help = [`${productName} ${version}`];
        help.push('');
        help.push(`${(0, nls_1.localize)(1754, null)}: ${executableName} [${(0, nls_1.localize)(1755, null)}]${inputFiles}`);
        help.push('');
        if (capabilities?.noPipe !== true) {
            if (platform_1.$l) {
                help.push((0, nls_1.localize)(1756, null, executableName));
            }
            else {
                help.push((0, nls_1.localize)(1757, null, executableName));
            }
            help.push('');
        }
        const optionsByCategory = {};
        const subcommands = [];
        for (const optionId in options) {
            const o = options[optionId];
            if (o.type === 'subcommand') {
                if (o.description) {
                    subcommands.push({ command: optionId, description: o.description });
                }
            }
            else if (o.description && o.cat) {
                let optionsByCat = optionsByCategory[o.cat];
                if (!optionsByCat) {
                    optionsByCategory[o.cat] = optionsByCat = {};
                }
                optionsByCat[optionId] = o;
            }
        }
        for (const helpCategoryKey in optionsByCategory) {
            const key = helpCategoryKey;
            const categoryOptions = optionsByCategory[key];
            if (categoryOptions) {
                help.push(helpCategories[key]);
                help.push(...$Jm(categoryOptions, columns));
                help.push('');
            }
        }
        if (subcommands.length) {
            help.push((0, nls_1.localize)(1758, null));
            help.push(...formatUsageTexts(subcommands.map(s => [s.command, s.description]), columns));
            help.push('');
        }
        return help.join('\n');
    }
    function $Lm(version, commit) {
        return `${version || (0, nls_1.localize)(1759, null)}\n${commit || (0, nls_1.localize)(1760, null)}\n${process.arch}`;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

/// <reference path="../../../../typings/require.d.ts" />

//@ts-check
'use strict';

// ESM-uncomment-begin
// import * as os from 'os';
// import * as path from 'path';
//
// /** @type any */
// const module = { exports: {} };
// ESM-uncomment-end

(function () {

	/**
	 * @import { NativeParsedArgs } from '../../environment/common/argv'
	 */

	/**
	 * @param {typeof import('path')} path
	 * @param {typeof import('os')} os
	 * @param {string} cwd
	 */
	function factory(path, os, cwd) {

		/**
		 * @param {NativeParsedArgs} cliArgs
		 * @param {string} productName
		 *
		 * @returns {string}
		 */
		function getUserDataPath(cliArgs, productName) {
			const userDataPath = doGetUserDataPath(cliArgs, productName);
			const pathsToResolve = [userDataPath];

			// If the user-data-path is not absolute, make
			// sure to resolve it against the passed in
			// current working directory. We cannot use the
			// node.js `path.resolve()` logic because it will
			// not pick up our `VSCODE_CWD` environment variable
			// (https://github.com/microsoft/vscode/issues/120269)
			if (!path.isAbsolute(userDataPath)) {
				pathsToResolve.unshift(cwd);
			}

			return path.resolve(...pathsToResolve);
		}

		/**
		 * @param {NativeParsedArgs} cliArgs
		 * @param {string} productName
		 *
		 * @returns {string}
		 */
		function doGetUserDataPath(cliArgs, productName) {

			// 0. Running out of sources has a fixed productName
			if (process.env['VSCODE_DEV']) {
				productName = 'code-oss-dev';
			}

			// 1. Support portable mode
			const portablePath = process.env['VSCODE_PORTABLE'];
			if (portablePath) {
				return path.join(portablePath, 'user-data');
			}

			// 2. Support global VSCODE_APPDATA environment variable
			let appDataPath = process.env['VSCODE_APPDATA'];
			if (appDataPath) {
				return path.join(appDataPath, productName);
			}

			// With Electron>=13 --user-data-dir switch will be propagated to
			// all processes https://github.com/electron/electron/blob/1897b14af36a02e9aa7e4d814159303441548251/shell/browser/electron_browser_client.cc#L546-L553
			// Check VSCODE_PORTABLE and VSCODE_APPDATA before this case to get correct values.
			// 3. Support explicit --user-data-dir
			const cliPath = cliArgs['user-data-dir'];
			if (cliPath) {
				return cliPath;
			}

			// 4. Otherwise check per platform
			switch (process.platform) {
				case 'win32':
					appDataPath = process.env['APPDATA'];
					if (!appDataPath) {
						const userProfile = process.env['USERPROFILE'];
						if (typeof userProfile !== 'string') {
							throw new Error('Windows: Unexpected undefined %USERPROFILE% environment variable');
						}

						appDataPath = path.join(userProfile, 'AppData', 'Roaming');
					}
					break;
				case 'darwin':
					appDataPath = path.join(os.homedir(), 'Library', 'Application Support');
					break;
				case 'linux':
					appDataPath = process.env['XDG_CONFIG_HOME'] || path.join(os.homedir(), '.config');
					break;
				default:
					throw new Error('Platform not supported');
			}

			return path.join(appDataPath, productName);
		}

		return {
			getUserDataPath
		};
	}

	if (typeof define === 'function') {
		define(__m[71/*vs/platform/environment/node/userDataPath*/], __M([72/*path*/,21/*os*/,15/*vs/base/common/process*/]), function (
			/** @type {typeof import('path')} */ path,
			/** @type {typeof import('os')} */ os,
			/** @type {typeof import("../../../base/common/process")} */ process
		) {
			return factory(path, os, process.cwd()); // amd
		});
	} else if (typeof module === 'object' && typeof module.exports === 'object') {
		// ESM-comment-begin
		const path = require('path');
		const os = require('os');
		// ESM-comment-end

		module.exports = factory(path, os, process.env['VSCODE_CWD'] || process.cwd()); // commonjs
	} else {
		throw new Error('Unknown context');
	}
}());

// ESM-uncomment-begin
// export const getUserDataPath = module.exports.getUserDataPath;
// ESM-uncomment-end

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[73/*vs/platform/environment/node/environmentService*/], __M([0/*require*/,1/*exports*/,21/*os*/,69/*vs/platform/environment/common/environmentService*/,71/*vs/platform/environment/node/userDataPath*/]), function (require, exports, os_1, environmentService_1, userDataPath_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$cn = void 0;
    exports.$dn = $dn;
    exports.$en = $en;
    class $cn extends environmentService_1.$_m {
        constructor(args, productService) {
            super(args, {
                homeDir: (0, os_1.homedir)(),
                tmpDir: (0, os_1.tmpdir)(),
                userDataDir: (0, userDataPath_1.getUserDataPath)(args, productService.nameShort)
            }, productService);
        }
    }
    exports.$cn = $cn;
    function $dn(args, isBuilt) {
        return (0, environmentService_1.$bn)(args['inspect-ptyhost'], args['inspect-brk-ptyhost'], 5877, isBuilt, args.extensionEnvironment);
    }
    function $en(args, isBuilt) {
        return (0, environmentService_1.$bn)(args['inspect-sharedprocess'], args['inspect-brk-sharedprocess'], 5879, isBuilt, args.extensionEnvironment);
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[22/*vs/platform/instantiation/common/instantiation*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$Ji = exports._util = void 0;
    exports.$Ki = $Ki;
    exports.$Li = $Li;
    // ------ internal util
    var _util;
    (function (_util) {
        _util.serviceIds = new Map();
        _util.DI_TARGET = '$di$target';
        _util.DI_DEPENDENCIES = '$di$dependencies';
        function getServiceDependencies(ctor) {
            return ctor[_util.DI_DEPENDENCIES] || [];
        }
        _util.getServiceDependencies = getServiceDependencies;
    })(_util || (exports._util = _util = {}));
    exports.$Ji = $Ki('instantiationService');
    function storeServiceDependency(id, target, index) {
        if (target[_util.DI_TARGET] === target) {
            target[_util.DI_DEPENDENCIES].push({ id, index });
        }
        else {
            target[_util.DI_DEPENDENCIES] = [{ id, index }];
            target[_util.DI_TARGET] = target;
        }
    }
    /**
     * The *only* valid way to create a {{ServiceIdentifier}}.
     */
    function $Ki(serviceId) {
        if (_util.serviceIds.has(serviceId)) {
            return _util.serviceIds.get(serviceId);
        }
        const id = function (target, key, index) {
            if (arguments.length !== 3) {
                throw new Error('@IServiceName-decorator can only be used to decorate a parameter');
            }
            storeServiceDependency(id, target, index);
        };
        id.toString = () => serviceId;
        _util.serviceIds.set(serviceId, id);
        return id;
    }
    function $Li(serviceIdentifier) {
        return serviceIdentifier;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[39/*vs/platform/contextkey/common/contextkey*/], __M([0/*require*/,1/*exports*/,13/*vs/base/common/charCode*/,3/*vs/base/common/platform*/,11/*vs/base/common/strings*/,68/*vs/platform/contextkey/common/scanner*/,22/*vs/platform/instantiation/common/instantiation*/,8/*vs/nls*/,7/*vs/base/common/errors*/]), function (require, exports, charCode_1, platform_1, strings_1, scanner_1, instantiation_1, nls_1, errors_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$3j = exports.$2j = exports.$1j = exports.$Zj = exports.$Yj = exports.$Xj = exports.$Wj = exports.$Vj = exports.$Uj = exports.$Tj = exports.$Sj = exports.$Rj = exports.$Qj = exports.$Pj = exports.$Oj = exports.$Nj = exports.$Mj = exports.$Lj = exports.$Ij = exports.$Hj = exports.ContextKeyExprType = void 0;
    exports.$Gj = $Gj;
    exports.$Jj = $Jj;
    exports.$Kj = $Kj;
    exports.$4j = $4j;
    const CONSTANT_VALUES = new Map();
    CONSTANT_VALUES.set('false', false);
    CONSTANT_VALUES.set('true', true);
    CONSTANT_VALUES.set('isMac', platform_1.$m);
    CONSTANT_VALUES.set('isLinux', platform_1.$n);
    CONSTANT_VALUES.set('isWindows', platform_1.$l);
    CONSTANT_VALUES.set('isWeb', platform_1.$r);
    CONSTANT_VALUES.set('isMacNative', platform_1.$m && !platform_1.$r);
    CONSTANT_VALUES.set('isEdge', platform_1.$K);
    CONSTANT_VALUES.set('isFirefox', platform_1.$I);
    CONSTANT_VALUES.set('isChrome', platform_1.$H);
    CONSTANT_VALUES.set('isSafari', platform_1.$J);
    /** allow register constant context keys that are known only after startup; requires running `substituteConstants` on the context key - https://github.com/microsoft/vscode/issues/174218#issuecomment-1437972127 */
    function $Gj(key, value) {
        if (CONSTANT_VALUES.get(key) !== undefined) {
            throw (0, errors_1.$$)('contextkey.setConstant(k, v) invoked with already set constant `k`');
        }
        CONSTANT_VALUES.set(key, value);
    }
    const hasOwnProperty = Object.prototype.hasOwnProperty;
    var ContextKeyExprType;
    (function (ContextKeyExprType) {
        ContextKeyExprType[ContextKeyExprType["False"] = 0] = "False";
        ContextKeyExprType[ContextKeyExprType["True"] = 1] = "True";
        ContextKeyExprType[ContextKeyExprType["Defined"] = 2] = "Defined";
        ContextKeyExprType[ContextKeyExprType["Not"] = 3] = "Not";
        ContextKeyExprType[ContextKeyExprType["Equals"] = 4] = "Equals";
        ContextKeyExprType[ContextKeyExprType["NotEquals"] = 5] = "NotEquals";
        ContextKeyExprType[ContextKeyExprType["And"] = 6] = "And";
        ContextKeyExprType[ContextKeyExprType["Regex"] = 7] = "Regex";
        ContextKeyExprType[ContextKeyExprType["NotRegex"] = 8] = "NotRegex";
        ContextKeyExprType[ContextKeyExprType["Or"] = 9] = "Or";
        ContextKeyExprType[ContextKeyExprType["In"] = 10] = "In";
        ContextKeyExprType[ContextKeyExprType["NotIn"] = 11] = "NotIn";
        ContextKeyExprType[ContextKeyExprType["Greater"] = 12] = "Greater";
        ContextKeyExprType[ContextKeyExprType["GreaterEquals"] = 13] = "GreaterEquals";
        ContextKeyExprType[ContextKeyExprType["Smaller"] = 14] = "Smaller";
        ContextKeyExprType[ContextKeyExprType["SmallerEquals"] = 15] = "SmallerEquals";
    })(ContextKeyExprType || (exports.ContextKeyExprType = ContextKeyExprType = {}));
    const defaultConfig = {
        regexParsingWithErrorRecovery: true
    };
    const errorEmptyString = (0, nls_1.localize)(1673, null);
    const hintEmptyString = (0, nls_1.localize)(1674, null);
    const errorNoInAfterNot = (0, nls_1.localize)(1675, null);
    const errorClosingParenthesis = (0, nls_1.localize)(1676, null);
    const errorUnexpectedToken = (0, nls_1.localize)(1677, null);
    const hintUnexpectedToken = (0, nls_1.localize)(1678, null);
    const errorUnexpectedEOF = (0, nls_1.localize)(1679, null);
    const hintUnexpectedEOF = (0, nls_1.localize)(1680, null);
    /**
     * A parser for context key expressions.
     *
     * Example:
     * ```ts
     * const parser = new Parser();
     * const expr = parser.parse('foo == "bar" && baz == true');
     *
     * if (expr === undefined) {
     * 	// there were lexing or parsing errors
     * 	// process lexing errors with `parser.lexingErrors`
     *  // process parsing errors with `parser.parsingErrors`
     * } else {
     * 	// expr is a valid expression
     * }
     * ```
     */
    class $Hj {
        // Note: this doesn't produce an exact syntax tree but a normalized one
        // ContextKeyExpression's that we use as AST nodes do not expose constructors that do not normalize
        static { this.c = new Error(); }
        get lexingErrors() {
            return this.d.errors;
        }
        get parsingErrors() {
            return this.h;
        }
        constructor(k = defaultConfig) {
            this.k = k;
            // lifetime note: `_scanner` lives as long as the parser does, i.e., is not reset between calls to `parse`
            this.d = new scanner_1.$Fj();
            // lifetime note: `_tokens`, `_current`, and `_parsingErrors` must be reset between calls to `parse`
            this.f = [];
            this.g = 0; // invariant: 0 <= this._current < this._tokens.length ; any incrementation of this value must first call `_isAtEnd`
            this.h = [];
            this.v = /g|y/g;
        }
        /**
         * Parse a context key expression.
         *
         * @param input the expression to parse
         * @returns the parsed expression or `undefined` if there's an error - call `lexingErrors` and `parsingErrors` to see the errors
         */
        parse(input) {
            if (input === '') {
                this.h.push({ message: errorEmptyString, offset: 0, lexeme: '', additionalInfo: hintEmptyString });
                return undefined;
            }
            this.f = this.d.reset(input).scan();
            // @ulugbekna: we do not stop parsing if there are lexing errors to be able to reconstruct regexes with unescaped slashes; TODO@ulugbekna: make this respect config option for recovery
            this.g = 0;
            this.h = [];
            try {
                const expr = this.l();
                if (!this.E()) {
                    const peek = this.D();
                    const additionalInfo = peek.type === scanner_1.TokenType.Str ? hintUnexpectedToken : undefined;
                    this.h.push({ message: errorUnexpectedToken, offset: peek.offset, lexeme: scanner_1.$Fj.getLexeme(peek), additionalInfo });
                    throw $Hj.c;
                }
                return expr;
            }
            catch (e) {
                if (!(e === $Hj.c)) {
                    throw e;
                }
                return undefined;
            }
        }
        l() {
            return this.m();
        }
        m() {
            const expr = [this.o()];
            while (this.y(scanner_1.TokenType.Or)) {
                const right = this.o();
                expr.push(right);
            }
            return expr.length === 1 ? expr[0] : $Ij.or(...expr);
        }
        o() {
            const expr = [this.s()];
            while (this.y(scanner_1.TokenType.And)) {
                const right = this.s();
                expr.push(right);
            }
            return expr.length === 1 ? expr[0] : $Ij.and(...expr);
        }
        s() {
            if (this.y(scanner_1.TokenType.Neg)) {
                const peek = this.D();
                switch (peek.type) {
                    case scanner_1.TokenType.True:
                        this.z();
                        return $Lj.INSTANCE;
                    case scanner_1.TokenType.False:
                        this.z();
                        return $Mj.INSTANCE;
                    case scanner_1.TokenType.LParen: {
                        this.z();
                        const expr = this.l();
                        this.A(scanner_1.TokenType.RParen, errorClosingParenthesis);
                        return expr?.negate();
                    }
                    case scanner_1.TokenType.Str:
                        this.z();
                        return $Sj.create(peek.lexeme);
                    default:
                        throw this.B(`KEY | true | false | '(' expression ')'`, peek);
                }
            }
            return this.t();
        }
        t() {
            const peek = this.D();
            switch (peek.type) {
                case scanner_1.TokenType.True:
                    this.z();
                    return $Ij.true();
                case scanner_1.TokenType.False:
                    this.z();
                    return $Ij.false();
                case scanner_1.TokenType.LParen: {
                    this.z();
                    const expr = this.l();
                    this.A(scanner_1.TokenType.RParen, errorClosingParenthesis);
                    return expr;
                }
                case scanner_1.TokenType.Str: {
                    // KEY
                    const key = peek.lexeme;
                    this.z();
                    // =~ regex
                    if (this.y(scanner_1.TokenType.RegexOp)) {
                        // @ulugbekna: we need to reconstruct the regex from the tokens because some extensions use unescaped slashes in regexes
                        const expr = this.D();
                        if (!this.k.regexParsingWithErrorRecovery) {
                            this.z();
                            if (expr.type !== scanner_1.TokenType.RegexStr) {
                                throw this.B(`REGEX`, expr);
                            }
                            const regexLexeme = expr.lexeme;
                            const closingSlashIndex = regexLexeme.lastIndexOf('/');
                            const flags = closingSlashIndex === regexLexeme.length - 1 ? undefined : this.w(regexLexeme.substring(closingSlashIndex + 1));
                            let regexp;
                            try {
                                regexp = new RegExp(regexLexeme.substring(1, closingSlashIndex), flags);
                            }
                            catch (e) {
                                throw this.B(`REGEX`, expr);
                            }
                            return $Xj.create(key, regexp);
                        }
                        switch (expr.type) {
                            case scanner_1.TokenType.RegexStr:
                            case scanner_1.TokenType.Error: { // also handle an ErrorToken in case of smth such as /(/file)/
                                const lexemeReconstruction = [expr.lexeme]; // /REGEX/ or /REGEX/FLAGS
                                this.z();
                                let followingToken = this.D();
                                let parenBalance = 0;
                                for (let i = 0; i < expr.lexeme.length; i++) {
                                    if (expr.lexeme.charCodeAt(i) === charCode_1.CharCode.OpenParen) {
                                        parenBalance++;
                                    }
                                    else if (expr.lexeme.charCodeAt(i) === charCode_1.CharCode.CloseParen) {
                                        parenBalance--;
                                    }
                                }
                                while (!this.E() && followingToken.type !== scanner_1.TokenType.And && followingToken.type !== scanner_1.TokenType.Or) {
                                    switch (followingToken.type) {
                                        case scanner_1.TokenType.LParen:
                                            parenBalance++;
                                            break;
                                        case scanner_1.TokenType.RParen:
                                            parenBalance--;
                                            break;
                                        case scanner_1.TokenType.RegexStr:
                                        case scanner_1.TokenType.QuotedStr:
                                            for (let i = 0; i < followingToken.lexeme.length; i++) {
                                                if (followingToken.lexeme.charCodeAt(i) === charCode_1.CharCode.OpenParen) {
                                                    parenBalance++;
                                                }
                                                else if (expr.lexeme.charCodeAt(i) === charCode_1.CharCode.CloseParen) {
                                                    parenBalance--;
                                                }
                                            }
                                    }
                                    if (parenBalance < 0) {
                                        break;
                                    }
                                    lexemeReconstruction.push(scanner_1.$Fj.getLexeme(followingToken));
                                    this.z();
                                    followingToken = this.D();
                                }
                                const regexLexeme = lexemeReconstruction.join('');
                                const closingSlashIndex = regexLexeme.lastIndexOf('/');
                                const flags = closingSlashIndex === regexLexeme.length - 1 ? undefined : this.w(regexLexeme.substring(closingSlashIndex + 1));
                                let regexp;
                                try {
                                    regexp = new RegExp(regexLexeme.substring(1, closingSlashIndex), flags);
                                }
                                catch (e) {
                                    throw this.B(`REGEX`, expr);
                                }
                                return $Ij.regex(key, regexp);
                            }
                            case scanner_1.TokenType.QuotedStr: {
                                const serializedValue = expr.lexeme;
                                this.z();
                                // replicate old regex parsing behavior
                                let regex = null;
                                if (!(0, strings_1.$hf)(serializedValue)) {
                                    const start = serializedValue.indexOf('/');
                                    const end = serializedValue.lastIndexOf('/');
                                    if (start !== end && start >= 0) {
                                        const value = serializedValue.slice(start + 1, end);
                                        const caseIgnoreFlag = serializedValue[end + 1] === 'i' ? 'i' : '';
                                        try {
                                            regex = new RegExp(value, caseIgnoreFlag);
                                        }
                                        catch (_e) {
                                            throw this.B(`REGEX`, expr);
                                        }
                                    }
                                }
                                if (regex === null) {
                                    throw this.B('REGEX', expr);
                                }
                                return $Xj.create(key, regex);
                            }
                            default:
                                throw this.B('REGEX', this.D());
                        }
                    }
                    // [ 'not' 'in' value ]
                    if (this.y(scanner_1.TokenType.Not)) {
                        this.A(scanner_1.TokenType.In, errorNoInAfterNot);
                        const right = this.u();
                        return $Ij.notIn(key, right);
                    }
                    // [ ('==' | '!=' | '<' | '<=' | '>' | '>=' | 'in') value ]
                    const maybeOp = this.D().type;
                    switch (maybeOp) {
                        case scanner_1.TokenType.Eq: {
                            this.z();
                            const right = this.u();
                            if (this.x().type === scanner_1.TokenType.QuotedStr) { // to preserve old parser behavior: "foo == 'true'" is preserved as "foo == 'true'", but "foo == true" is optimized as "foo"
                                return $Ij.equals(key, right);
                            }
                            switch (right) {
                                case 'true':
                                    return $Ij.has(key);
                                case 'false':
                                    return $Ij.not(key);
                                default:
                                    return $Ij.equals(key, right);
                            }
                        }
                        case scanner_1.TokenType.NotEq: {
                            this.z();
                            const right = this.u();
                            if (this.x().type === scanner_1.TokenType.QuotedStr) { // same as above with "foo != 'true'"
                                return $Ij.notEquals(key, right);
                            }
                            switch (right) {
                                case 'true':
                                    return $Ij.not(key);
                                case 'false':
                                    return $Ij.has(key);
                                default:
                                    return $Ij.notEquals(key, right);
                            }
                        }
                        // TODO: ContextKeyExpr.smaller(key, right) accepts only `number` as `right` AND during eval of this node, we just eval to `false` if `right` is not a number
                        // consequently, package.json linter should _warn_ the user if they're passing undesired things to ops
                        case scanner_1.TokenType.Lt:
                            this.z();
                            return $Vj.create(key, this.u());
                        case scanner_1.TokenType.LtEq:
                            this.z();
                            return $Wj.create(key, this.u());
                        case scanner_1.TokenType.Gt:
                            this.z();
                            return $Tj.create(key, this.u());
                        case scanner_1.TokenType.GtEq:
                            this.z();
                            return $Uj.create(key, this.u());
                        case scanner_1.TokenType.In:
                            this.z();
                            return $Ij.in(key, this.u());
                        default:
                            return $Ij.has(key);
                    }
                }
                case scanner_1.TokenType.EOF:
                    this.h.push({ message: errorUnexpectedEOF, offset: peek.offset, lexeme: '', additionalInfo: hintUnexpectedEOF });
                    throw $Hj.c;
                default:
                    throw this.B(`true | false | KEY \n\t| KEY '=~' REGEX \n\t| KEY ('==' | '!=' | '<' | '<=' | '>' | '>=' | 'in' | 'not' 'in') value`, this.D());
            }
        }
        u() {
            const token = this.D();
            switch (token.type) {
                case scanner_1.TokenType.Str:
                case scanner_1.TokenType.QuotedStr:
                    this.z();
                    return token.lexeme;
                case scanner_1.TokenType.True:
                    this.z();
                    return 'true';
                case scanner_1.TokenType.False:
                    this.z();
                    return 'false';
                case scanner_1.TokenType.In: // we support `in` as a value, e.g., "when": "languageId == in" - exists in existing extensions
                    this.z();
                    return 'in';
                default:
                    // this allows "when": "foo == " which's used by existing extensions
                    // we do not call `_advance` on purpose - we don't want to eat unintended tokens
                    return '';
            }
        }
        w(flags) {
            return flags.replaceAll(this.v, '');
        }
        // careful: this can throw if current token is the initial one (ie index = 0)
        x() {
            return this.f[this.g - 1];
        }
        y(token) {
            if (this.C(token)) {
                this.z();
                return true;
            }
            return false;
        }
        z() {
            if (!this.E()) {
                this.g++;
            }
            return this.x();
        }
        A(type, message) {
            if (this.C(type)) {
                return this.z();
            }
            throw this.B(message, this.D());
        }
        B(expected, got, additionalInfo) {
            const message = (0, nls_1.localize)(1681, null, expected, scanner_1.$Fj.getLexeme(got));
            const offset = got.offset;
            const lexeme = scanner_1.$Fj.getLexeme(got);
            this.h.push({ message, offset, lexeme, additionalInfo });
            return $Hj.c;
        }
        C(type) {
            return this.D().type === type;
        }
        D() {
            return this.f[this.g];
        }
        E() {
            return this.D().type === scanner_1.TokenType.EOF;
        }
    }
    exports.$Hj = $Hj;
    class $Ij {
        static false() {
            return $Lj.INSTANCE;
        }
        static true() {
            return $Mj.INSTANCE;
        }
        static has(key) {
            return $Nj.create(key);
        }
        static equals(key, value) {
            return $Oj.create(key, value);
        }
        static notEquals(key, value) {
            return $Rj.create(key, value);
        }
        static regex(key, value) {
            return $Xj.create(key, value);
        }
        static in(key, value) {
            return $Pj.create(key, value);
        }
        static notIn(key, value) {
            return $Qj.create(key, value);
        }
        static not(key) {
            return $Sj.create(key);
        }
        static and(...expr) {
            return $Zj.create(expr, null, true);
        }
        static or(...expr) {
            return $1j.create(expr, null, true);
        }
        static greater(key, value) {
            return $Tj.create(key, value);
        }
        static greaterEquals(key, value) {
            return $Uj.create(key, value);
        }
        static smaller(key, value) {
            return $Vj.create(key, value);
        }
        static smallerEquals(key, value) {
            return $Wj.create(key, value);
        }
        static { this.c = new $Hj({ regexParsingWithErrorRecovery: false }); }
        static deserialize(serialized) {
            if (serialized === undefined || serialized === null) { // an empty string needs to be handled by the parser to get a corresponding parsing error reported
                return undefined;
            }
            const expr = this.c.parse(serialized);
            return expr;
        }
    }
    exports.$Ij = $Ij;
    function $Jj(whenClauses) {
        const parser = new $Hj({ regexParsingWithErrorRecovery: false }); // we run with no recovery to guide users to use correct regexes
        return whenClauses.map(whenClause => {
            parser.parse(whenClause);
            if (parser.lexingErrors.length > 0) {
                return parser.lexingErrors.map((se) => ({
                    errorMessage: se.additionalInfo ?
                        (0, nls_1.localize)(1682, null, se.additionalInfo) :
                        (0, nls_1.localize)(1683, null),
                    offset: se.offset,
                    length: se.lexeme.length,
                }));
            }
            else if (parser.parsingErrors.length > 0) {
                return parser.parsingErrors.map((pe) => ({
                    errorMessage: pe.additionalInfo ? `${pe.message}. ${pe.additionalInfo}` : pe.message,
                    offset: pe.offset,
                    length: pe.lexeme.length,
                }));
            }
            else {
                return [];
            }
        });
    }
    function $Kj(a, b) {
        const aExpr = a ? a.substituteConstants() : undefined;
        const bExpr = b ? b.substituteConstants() : undefined;
        if (!aExpr && !bExpr) {
            return true;
        }
        if (!aExpr || !bExpr) {
            return false;
        }
        return aExpr.equals(bExpr);
    }
    function cmp(a, b) {
        return a.cmp(b);
    }
    class $Lj {
        static { this.INSTANCE = new $Lj(); }
        constructor() {
            this.type = ContextKeyExprType.False;
        }
        cmp(other) {
            return this.type - other.type;
        }
        equals(other) {
            return (other.type === this.type);
        }
        substituteConstants() {
            return this;
        }
        evaluate(context) {
            return false;
        }
        serialize() {
            return 'false';
        }
        keys() {
            return [];
        }
        map(mapFnc) {
            return this;
        }
        negate() {
            return $Mj.INSTANCE;
        }
    }
    exports.$Lj = $Lj;
    class $Mj {
        static { this.INSTANCE = new $Mj(); }
        constructor() {
            this.type = ContextKeyExprType.True;
        }
        cmp(other) {
            return this.type - other.type;
        }
        equals(other) {
            return (other.type === this.type);
        }
        substituteConstants() {
            return this;
        }
        evaluate(context) {
            return true;
        }
        serialize() {
            return 'true';
        }
        keys() {
            return [];
        }
        map(mapFnc) {
            return this;
        }
        negate() {
            return $Lj.INSTANCE;
        }
    }
    exports.$Mj = $Mj;
    class $Nj {
        static create(key, negated = null) {
            const constantValue = CONSTANT_VALUES.get(key);
            if (typeof constantValue === 'boolean') {
                return constantValue ? $Mj.INSTANCE : $Lj.INSTANCE;
            }
            return new $Nj(key, negated);
        }
        constructor(key, c) {
            this.key = key;
            this.c = c;
            this.type = ContextKeyExprType.Defined;
        }
        cmp(other) {
            if (other.type !== this.type) {
                return this.type - other.type;
            }
            return cmp1(this.key, other.key);
        }
        equals(other) {
            if (other.type === this.type) {
                return (this.key === other.key);
            }
            return false;
        }
        substituteConstants() {
            const constantValue = CONSTANT_VALUES.get(this.key);
            if (typeof constantValue === 'boolean') {
                return constantValue ? $Mj.INSTANCE : $Lj.INSTANCE;
            }
            return this;
        }
        evaluate(context) {
            return (!!context.getValue(this.key));
        }
        serialize() {
            return this.key;
        }
        keys() {
            return [this.key];
        }
        map(mapFnc) {
            return mapFnc.mapDefined(this.key);
        }
        negate() {
            if (!this.c) {
                this.c = $Sj.create(this.key, this);
            }
            return this.c;
        }
    }
    exports.$Nj = $Nj;
    class $Oj {
        static create(key, value, negated = null) {
            if (typeof value === 'boolean') {
                return (value ? $Nj.create(key, negated) : $Sj.create(key, negated));
            }
            const constantValue = CONSTANT_VALUES.get(key);
            if (typeof constantValue === 'boolean') {
                const trueValue = constantValue ? 'true' : 'false';
                return (value === trueValue ? $Mj.INSTANCE : $Lj.INSTANCE);
            }
            return new $Oj(key, value, negated);
        }
        constructor(c, d, f) {
            this.c = c;
            this.d = d;
            this.f = f;
            this.type = ContextKeyExprType.Equals;
        }
        cmp(other) {
            if (other.type !== this.type) {
                return this.type - other.type;
            }
            return cmp2(this.c, this.d, other.c, other.d);
        }
        equals(other) {
            if (other.type === this.type) {
                return (this.c === other.c && this.d === other.d);
            }
            return false;
        }
        substituteConstants() {
            const constantValue = CONSTANT_VALUES.get(this.c);
            if (typeof constantValue === 'boolean') {
                const trueValue = constantValue ? 'true' : 'false';
                return (this.d === trueValue ? $Mj.INSTANCE : $Lj.INSTANCE);
            }
            return this;
        }
        evaluate(context) {
            // Intentional ==
            // eslint-disable-next-line eqeqeq
            return (context.getValue(this.c) == this.d);
        }
        serialize() {
            return `${this.c} == '${this.d}'`;
        }
        keys() {
            return [this.c];
        }
        map(mapFnc) {
            return mapFnc.mapEquals(this.c, this.d);
        }
        negate() {
            if (!this.f) {
                this.f = $Rj.create(this.c, this.d, this);
            }
            return this.f;
        }
    }
    exports.$Oj = $Oj;
    class $Pj {
        static create(key, valueKey) {
            return new $Pj(key, valueKey);
        }
        constructor(d, f) {
            this.d = d;
            this.f = f;
            this.type = ContextKeyExprType.In;
            this.c = null;
        }
        cmp(other) {
            if (other.type !== this.type) {
                return this.type - other.type;
            }
            return cmp2(this.d, this.f, other.d, other.f);
        }
        equals(other) {
            if (other.type === this.type) {
                return (this.d === other.d && this.f === other.f);
            }
            return false;
        }
        substituteConstants() {
            return this;
        }
        evaluate(context) {
            const source = context.getValue(this.f);
            const item = context.getValue(this.d);
            if (Array.isArray(source)) {
                return source.includes(item);
            }
            if (typeof item === 'string' && typeof source === 'object' && source !== null) {
                return hasOwnProperty.call(source, item);
            }
            return false;
        }
        serialize() {
            return `${this.d} in '${this.f}'`;
        }
        keys() {
            return [this.d, this.f];
        }
        map(mapFnc) {
            return mapFnc.mapIn(this.d, this.f);
        }
        negate() {
            if (!this.c) {
                this.c = $Qj.create(this.d, this.f);
            }
            return this.c;
        }
    }
    exports.$Pj = $Pj;
    class $Qj {
        static create(key, valueKey) {
            return new $Qj(key, valueKey);
        }
        constructor(d, f) {
            this.d = d;
            this.f = f;
            this.type = ContextKeyExprType.NotIn;
            this.c = $Pj.create(d, f);
        }
        cmp(other) {
            if (other.type !== this.type) {
                return this.type - other.type;
            }
            return this.c.cmp(other.c);
        }
        equals(other) {
            if (other.type === this.type) {
                return this.c.equals(other.c);
            }
            return false;
        }
        substituteConstants() {
            return this;
        }
        evaluate(context) {
            return !this.c.evaluate(context);
        }
        serialize() {
            return `${this.d} not in '${this.f}'`;
        }
        keys() {
            return this.c.keys();
        }
        map(mapFnc) {
            return mapFnc.mapNotIn(this.d, this.f);
        }
        negate() {
            return this.c;
        }
    }
    exports.$Qj = $Qj;
    class $Rj {
        static create(key, value, negated = null) {
            if (typeof value === 'boolean') {
                if (value) {
                    return $Sj.create(key, negated);
                }
                return $Nj.create(key, negated);
            }
            const constantValue = CONSTANT_VALUES.get(key);
            if (typeof constantValue === 'boolean') {
                const falseValue = constantValue ? 'true' : 'false';
                return (value === falseValue ? $Lj.INSTANCE : $Mj.INSTANCE);
            }
            return new $Rj(key, value, negated);
        }
        constructor(c, d, f) {
            this.c = c;
            this.d = d;
            this.f = f;
            this.type = ContextKeyExprType.NotEquals;
        }
        cmp(other) {
            if (other.type !== this.type) {
                return this.type - other.type;
            }
            return cmp2(this.c, this.d, other.c, other.d);
        }
        equals(other) {
            if (other.type === this.type) {
                return (this.c === other.c && this.d === other.d);
            }
            return false;
        }
        substituteConstants() {
            const constantValue = CONSTANT_VALUES.get(this.c);
            if (typeof constantValue === 'boolean') {
                const falseValue = constantValue ? 'true' : 'false';
                return (this.d === falseValue ? $Lj.INSTANCE : $Mj.INSTANCE);
            }
            return this;
        }
        evaluate(context) {
            // Intentional !=
            // eslint-disable-next-line eqeqeq
            return (context.getValue(this.c) != this.d);
        }
        serialize() {
            return `${this.c} != '${this.d}'`;
        }
        keys() {
            return [this.c];
        }
        map(mapFnc) {
            return mapFnc.mapNotEquals(this.c, this.d);
        }
        negate() {
            if (!this.f) {
                this.f = $Oj.create(this.c, this.d, this);
            }
            return this.f;
        }
    }
    exports.$Rj = $Rj;
    class $Sj {
        static create(key, negated = null) {
            const constantValue = CONSTANT_VALUES.get(key);
            if (typeof constantValue === 'boolean') {
                return (constantValue ? $Lj.INSTANCE : $Mj.INSTANCE);
            }
            return new $Sj(key, negated);
        }
        constructor(c, d) {
            this.c = c;
            this.d = d;
            this.type = ContextKeyExprType.Not;
        }
        cmp(other) {
            if (other.type !== this.type) {
                return this.type - other.type;
            }
            return cmp1(this.c, other.c);
        }
        equals(other) {
            if (other.type === this.type) {
                return (this.c === other.c);
            }
            return false;
        }
        substituteConstants() {
            const constantValue = CONSTANT_VALUES.get(this.c);
            if (typeof constantValue === 'boolean') {
                return (constantValue ? $Lj.INSTANCE : $Mj.INSTANCE);
            }
            return this;
        }
        evaluate(context) {
            return (!context.getValue(this.c));
        }
        serialize() {
            return `!${this.c}`;
        }
        keys() {
            return [this.c];
        }
        map(mapFnc) {
            return mapFnc.mapNot(this.c);
        }
        negate() {
            if (!this.d) {
                this.d = $Nj.create(this.c, this);
            }
            return this.d;
        }
    }
    exports.$Sj = $Sj;
    function withFloatOrStr(value, callback) {
        if (typeof value === 'string') {
            const n = parseFloat(value);
            if (!isNaN(n)) {
                value = n;
            }
        }
        if (typeof value === 'string' || typeof value === 'number') {
            return callback(value);
        }
        return $Lj.INSTANCE;
    }
    class $Tj {
        static create(key, _value, negated = null) {
            return withFloatOrStr(_value, (value) => new $Tj(key, value, negated));
        }
        constructor(c, d, f) {
            this.c = c;
            this.d = d;
            this.f = f;
            this.type = ContextKeyExprType.Greater;
        }
        cmp(other) {
            if (other.type !== this.type) {
                return this.type - other.type;
            }
            return cmp2(this.c, this.d, other.c, other.d);
        }
        equals(other) {
            if (other.type === this.type) {
                return (this.c === other.c && this.d === other.d);
            }
            return false;
        }
        substituteConstants() {
            return this;
        }
        evaluate(context) {
            if (typeof this.d === 'string') {
                return false;
            }
            return (parseFloat(context.getValue(this.c)) > this.d);
        }
        serialize() {
            return `${this.c} > ${this.d}`;
        }
        keys() {
            return [this.c];
        }
        map(mapFnc) {
            return mapFnc.mapGreater(this.c, this.d);
        }
        negate() {
            if (!this.f) {
                this.f = $Wj.create(this.c, this.d, this);
            }
            return this.f;
        }
    }
    exports.$Tj = $Tj;
    class $Uj {
        static create(key, _value, negated = null) {
            return withFloatOrStr(_value, (value) => new $Uj(key, value, negated));
        }
        constructor(c, d, f) {
            this.c = c;
            this.d = d;
            this.f = f;
            this.type = ContextKeyExprType.GreaterEquals;
        }
        cmp(other) {
            if (other.type !== this.type) {
                return this.type - other.type;
            }
            return cmp2(this.c, this.d, other.c, other.d);
        }
        equals(other) {
            if (other.type === this.type) {
                return (this.c === other.c && this.d === other.d);
            }
            return false;
        }
        substituteConstants() {
            return this;
        }
        evaluate(context) {
            if (typeof this.d === 'string') {
                return false;
            }
            return (parseFloat(context.getValue(this.c)) >= this.d);
        }
        serialize() {
            return `${this.c} >= ${this.d}`;
        }
        keys() {
            return [this.c];
        }
        map(mapFnc) {
            return mapFnc.mapGreaterEquals(this.c, this.d);
        }
        negate() {
            if (!this.f) {
                this.f = $Vj.create(this.c, this.d, this);
            }
            return this.f;
        }
    }
    exports.$Uj = $Uj;
    class $Vj {
        static create(key, _value, negated = null) {
            return withFloatOrStr(_value, (value) => new $Vj(key, value, negated));
        }
        constructor(c, d, f) {
            this.c = c;
            this.d = d;
            this.f = f;
            this.type = ContextKeyExprType.Smaller;
        }
        cmp(other) {
            if (other.type !== this.type) {
                return this.type - other.type;
            }
            return cmp2(this.c, this.d, other.c, other.d);
        }
        equals(other) {
            if (other.type === this.type) {
                return (this.c === other.c && this.d === other.d);
            }
            return false;
        }
        substituteConstants() {
            return this;
        }
        evaluate(context) {
            if (typeof this.d === 'string') {
                return false;
            }
            return (parseFloat(context.getValue(this.c)) < this.d);
        }
        serialize() {
            return `${this.c} < ${this.d}`;
        }
        keys() {
            return [this.c];
        }
        map(mapFnc) {
            return mapFnc.mapSmaller(this.c, this.d);
        }
        negate() {
            if (!this.f) {
                this.f = $Uj.create(this.c, this.d, this);
            }
            return this.f;
        }
    }
    exports.$Vj = $Vj;
    class $Wj {
        static create(key, _value, negated = null) {
            return withFloatOrStr(_value, (value) => new $Wj(key, value, negated));
        }
        constructor(c, d, f) {
            this.c = c;
            this.d = d;
            this.f = f;
            this.type = ContextKeyExprType.SmallerEquals;
        }
        cmp(other) {
            if (other.type !== this.type) {
                return this.type - other.type;
            }
            return cmp2(this.c, this.d, other.c, other.d);
        }
        equals(other) {
            if (other.type === this.type) {
                return (this.c === other.c && this.d === other.d);
            }
            return false;
        }
        substituteConstants() {
            return this;
        }
        evaluate(context) {
            if (typeof this.d === 'string') {
                return false;
            }
            return (parseFloat(context.getValue(this.c)) <= this.d);
        }
        serialize() {
            return `${this.c} <= ${this.d}`;
        }
        keys() {
            return [this.c];
        }
        map(mapFnc) {
            return mapFnc.mapSmallerEquals(this.c, this.d);
        }
        negate() {
            if (!this.f) {
                this.f = $Tj.create(this.c, this.d, this);
            }
            return this.f;
        }
    }
    exports.$Wj = $Wj;
    class $Xj {
        static create(key, regexp) {
            return new $Xj(key, regexp);
        }
        constructor(d, f) {
            this.d = d;
            this.f = f;
            this.type = ContextKeyExprType.Regex;
            this.c = null;
            //
        }
        cmp(other) {
            if (other.type !== this.type) {
                return this.type - other.type;
            }
            if (this.d < other.d) {
                return -1;
            }
            if (this.d > other.d) {
                return 1;
            }
            const thisSource = this.f ? this.f.source : '';
            const otherSource = other.f ? other.f.source : '';
            if (thisSource < otherSource) {
                return -1;
            }
            if (thisSource > otherSource) {
                return 1;
            }
            return 0;
        }
        equals(other) {
            if (other.type === this.type) {
                const thisSource = this.f ? this.f.source : '';
                const otherSource = other.f ? other.f.source : '';
                return (this.d === other.d && thisSource === otherSource);
            }
            return false;
        }
        substituteConstants() {
            return this;
        }
        evaluate(context) {
            const value = context.getValue(this.d);
            return this.f ? this.f.test(value) : false;
        }
        serialize() {
            const value = this.f
                ? `/${this.f.source}/${this.f.flags}`
                : '/invalid/';
            return `${this.d} =~ ${value}`;
        }
        keys() {
            return [this.d];
        }
        map(mapFnc) {
            return mapFnc.mapRegex(this.d, this.f);
        }
        negate() {
            if (!this.c) {
                this.c = $Yj.create(this);
            }
            return this.c;
        }
    }
    exports.$Xj = $Xj;
    class $Yj {
        static create(actual) {
            return new $Yj(actual);
        }
        constructor(c) {
            this.c = c;
            this.type = ContextKeyExprType.NotRegex;
            //
        }
        cmp(other) {
            if (other.type !== this.type) {
                return this.type - other.type;
            }
            return this.c.cmp(other.c);
        }
        equals(other) {
            if (other.type === this.type) {
                return this.c.equals(other.c);
            }
            return false;
        }
        substituteConstants() {
            return this;
        }
        evaluate(context) {
            return !this.c.evaluate(context);
        }
        serialize() {
            return `!(${this.c.serialize()})`;
        }
        keys() {
            return this.c.keys();
        }
        map(mapFnc) {
            return new $Yj(this.c.map(mapFnc));
        }
        negate() {
            return this.c;
        }
    }
    exports.$Yj = $Yj;
    /**
     * @returns the same instance if nothing changed.
     */
    function eliminateConstantsInArray(arr) {
        // Allocate array only if there is a difference
        let newArr = null;
        for (let i = 0, len = arr.length; i < len; i++) {
            const newExpr = arr[i].substituteConstants();
            if (arr[i] !== newExpr) {
                // something has changed!
                // allocate array on first difference
                if (newArr === null) {
                    newArr = [];
                    for (let j = 0; j < i; j++) {
                        newArr[j] = arr[j];
                    }
                }
            }
            if (newArr !== null) {
                newArr[i] = newExpr;
            }
        }
        if (newArr === null) {
            return arr;
        }
        return newArr;
    }
    class $Zj {
        static create(_expr, negated, extraRedundantCheck) {
            return $Zj.d(_expr, negated, extraRedundantCheck);
        }
        constructor(expr, c) {
            this.expr = expr;
            this.c = c;
            this.type = ContextKeyExprType.And;
        }
        cmp(other) {
            if (other.type !== this.type) {
                return this.type - other.type;
            }
            if (this.expr.length < other.expr.length) {
                return -1;
            }
            if (this.expr.length > other.expr.length) {
                return 1;
            }
            for (let i = 0, len = this.expr.length; i < len; i++) {
                const r = cmp(this.expr[i], other.expr[i]);
                if (r !== 0) {
                    return r;
                }
            }
            return 0;
        }
        equals(other) {
            if (other.type === this.type) {
                if (this.expr.length !== other.expr.length) {
                    return false;
                }
                for (let i = 0, len = this.expr.length; i < len; i++) {
                    if (!this.expr[i].equals(other.expr[i])) {
                        return false;
                    }
                }
                return true;
            }
            return false;
        }
        substituteConstants() {
            const exprArr = eliminateConstantsInArray(this.expr);
            if (exprArr === this.expr) {
                // no change
                return this;
            }
            return $Zj.create(exprArr, this.c, false);
        }
        evaluate(context) {
            for (let i = 0, len = this.expr.length; i < len; i++) {
                if (!this.expr[i].evaluate(context)) {
                    return false;
                }
            }
            return true;
        }
        static d(arr, negated, extraRedundantCheck) {
            const expr = [];
            let hasTrue = false;
            for (const e of arr) {
                if (!e) {
                    continue;
                }
                if (e.type === ContextKeyExprType.True) {
                    // anything && true ==> anything
                    hasTrue = true;
                    continue;
                }
                if (e.type === ContextKeyExprType.False) {
                    // anything && false ==> false
                    return $Lj.INSTANCE;
                }
                if (e.type === ContextKeyExprType.And) {
                    expr.push(...e.expr);
                    continue;
                }
                expr.push(e);
            }
            if (expr.length === 0 && hasTrue) {
                return $Mj.INSTANCE;
            }
            if (expr.length === 0) {
                return undefined;
            }
            if (expr.length === 1) {
                return expr[0];
            }
            expr.sort(cmp);
            // eliminate duplicate terms
            for (let i = 1; i < expr.length; i++) {
                if (expr[i - 1].equals(expr[i])) {
                    expr.splice(i, 1);
                    i--;
                }
            }
            if (expr.length === 1) {
                return expr[0];
            }
            // We must distribute any OR expression because we don't support parens
            // OR extensions will be at the end (due to sorting rules)
            while (expr.length > 1) {
                const lastElement = expr[expr.length - 1];
                if (lastElement.type !== ContextKeyExprType.Or) {
                    break;
                }
                // pop the last element
                expr.pop();
                // pop the second to last element
                const secondToLastElement = expr.pop();
                const isFinished = (expr.length === 0);
                // distribute `lastElement` over `secondToLastElement`
                const resultElement = $1j.create(lastElement.expr.map(el => $Zj.create([el, secondToLastElement], null, extraRedundantCheck)), null, isFinished);
                if (resultElement) {
                    expr.push(resultElement);
                    expr.sort(cmp);
                }
            }
            if (expr.length === 1) {
                return expr[0];
            }
            // resolve false AND expressions
            if (extraRedundantCheck) {
                for (let i = 0; i < expr.length; i++) {
                    for (let j = i + 1; j < expr.length; j++) {
                        if (expr[i].negate().equals(expr[j])) {
                            // A && !A case
                            return $Lj.INSTANCE;
                        }
                    }
                }
                if (expr.length === 1) {
                    return expr[0];
                }
            }
            return new $Zj(expr, negated);
        }
        serialize() {
            return this.expr.map(e => e.serialize()).join(' && ');
        }
        keys() {
            const result = [];
            for (const expr of this.expr) {
                result.push(...expr.keys());
            }
            return result;
        }
        map(mapFnc) {
            return new $Zj(this.expr.map(expr => expr.map(mapFnc)), null);
        }
        negate() {
            if (!this.c) {
                const result = [];
                for (const expr of this.expr) {
                    result.push(expr.negate());
                }
                this.c = $1j.create(result, this, true);
            }
            return this.c;
        }
    }
    exports.$Zj = $Zj;
    class $1j {
        static create(_expr, negated, extraRedundantCheck) {
            return $1j.d(_expr, negated, extraRedundantCheck);
        }
        constructor(expr, c) {
            this.expr = expr;
            this.c = c;
            this.type = ContextKeyExprType.Or;
        }
        cmp(other) {
            if (other.type !== this.type) {
                return this.type - other.type;
            }
            if (this.expr.length < other.expr.length) {
                return -1;
            }
            if (this.expr.length > other.expr.length) {
                return 1;
            }
            for (let i = 0, len = this.expr.length; i < len; i++) {
                const r = cmp(this.expr[i], other.expr[i]);
                if (r !== 0) {
                    return r;
                }
            }
            return 0;
        }
        equals(other) {
            if (other.type === this.type) {
                if (this.expr.length !== other.expr.length) {
                    return false;
                }
                for (let i = 0, len = this.expr.length; i < len; i++) {
                    if (!this.expr[i].equals(other.expr[i])) {
                        return false;
                    }
                }
                return true;
            }
            return false;
        }
        substituteConstants() {
            const exprArr = eliminateConstantsInArray(this.expr);
            if (exprArr === this.expr) {
                // no change
                return this;
            }
            return $1j.create(exprArr, this.c, false);
        }
        evaluate(context) {
            for (let i = 0, len = this.expr.length; i < len; i++) {
                if (this.expr[i].evaluate(context)) {
                    return true;
                }
            }
            return false;
        }
        static d(arr, negated, extraRedundantCheck) {
            let expr = [];
            let hasFalse = false;
            if (arr) {
                for (let i = 0, len = arr.length; i < len; i++) {
                    const e = arr[i];
                    if (!e) {
                        continue;
                    }
                    if (e.type === ContextKeyExprType.False) {
                        // anything || false ==> anything
                        hasFalse = true;
                        continue;
                    }
                    if (e.type === ContextKeyExprType.True) {
                        // anything || true ==> true
                        return $Mj.INSTANCE;
                    }
                    if (e.type === ContextKeyExprType.Or) {
                        expr = expr.concat(e.expr);
                        continue;
                    }
                    expr.push(e);
                }
                if (expr.length === 0 && hasFalse) {
                    return $Lj.INSTANCE;
                }
                expr.sort(cmp);
            }
            if (expr.length === 0) {
                return undefined;
            }
            if (expr.length === 1) {
                return expr[0];
            }
            // eliminate duplicate terms
            for (let i = 1; i < expr.length; i++) {
                if (expr[i - 1].equals(expr[i])) {
                    expr.splice(i, 1);
                    i--;
                }
            }
            if (expr.length === 1) {
                return expr[0];
            }
            // resolve true OR expressions
            if (extraRedundantCheck) {
                for (let i = 0; i < expr.length; i++) {
                    for (let j = i + 1; j < expr.length; j++) {
                        if (expr[i].negate().equals(expr[j])) {
                            // A || !A case
                            return $Mj.INSTANCE;
                        }
                    }
                }
                if (expr.length === 1) {
                    return expr[0];
                }
            }
            return new $1j(expr, negated);
        }
        serialize() {
            return this.expr.map(e => e.serialize()).join(' || ');
        }
        keys() {
            const result = [];
            for (const expr of this.expr) {
                result.push(...expr.keys());
            }
            return result;
        }
        map(mapFnc) {
            return new $1j(this.expr.map(expr => expr.map(mapFnc)), null);
        }
        negate() {
            if (!this.c) {
                const result = [];
                for (const expr of this.expr) {
                    result.push(expr.negate());
                }
                // We don't support parens, so here we distribute the AND over the OR terminals
                // We always take the first 2 AND pairs and distribute them
                while (result.length > 1) {
                    const LEFT = result.shift();
                    const RIGHT = result.shift();
                    const all = [];
                    for (const left of getTerminals(LEFT)) {
                        for (const right of getTerminals(RIGHT)) {
                            all.push($Zj.create([left, right], null, false));
                        }
                    }
                    result.unshift($1j.create(all, null, false));
                }
                this.c = $1j.create(result, this, true);
            }
            return this.c;
        }
    }
    exports.$1j = $1j;
    class $2j extends $Nj {
        static { this.d = []; }
        static all() {
            return $2j.d.values();
        }
        constructor(key, defaultValue, metaOrHide) {
            super(key, null);
            this.f = defaultValue;
            // collect all context keys into a central place
            if (typeof metaOrHide === 'object') {
                $2j.d.push({ ...metaOrHide, key });
            }
            else if (metaOrHide !== true) {
                $2j.d.push({ key, description: metaOrHide, type: defaultValue !== null && defaultValue !== undefined ? typeof defaultValue : undefined });
            }
        }
        bindTo(target) {
            return target.createKey(this.key, this.f);
        }
        getValue(target) {
            return target.getContextKeyValue(this.key);
        }
        toNegated() {
            return this.negate();
        }
        isEqualTo(value) {
            return $Oj.create(this.key, value);
        }
        notEqualsTo(value) {
            return $Rj.create(this.key, value);
        }
    }
    exports.$2j = $2j;
    exports.$3j = (0, instantiation_1.$Ki)('contextKeyService');
    function cmp1(key1, key2) {
        if (key1 < key2) {
            return -1;
        }
        if (key1 > key2) {
            return 1;
        }
        return 0;
    }
    function cmp2(key1, value1, key2, value2) {
        if (key1 < key2) {
            return -1;
        }
        if (key1 > key2) {
            return 1;
        }
        if (value1 < value2) {
            return -1;
        }
        if (value1 > value2) {
            return 1;
        }
        return 0;
    }
    /**
     * Returns true if it is provable `p` implies `q`.
     */
    function $4j(p, q) {
        if (p.type === ContextKeyExprType.False || q.type === ContextKeyExprType.True) {
            // false implies anything
            // anything implies true
            return true;
        }
        if (p.type === ContextKeyExprType.Or) {
            if (q.type === ContextKeyExprType.Or) {
                // `a || b || c` can only imply something like `a || b || c || d`
                return allElementsIncluded(p.expr, q.expr);
            }
            return false;
        }
        if (q.type === ContextKeyExprType.Or) {
            for (const element of q.expr) {
                if ($4j(p, element)) {
                    return true;
                }
            }
            return false;
        }
        if (p.type === ContextKeyExprType.And) {
            if (q.type === ContextKeyExprType.And) {
                // `a && b && c` implies `a && c`
                return allElementsIncluded(q.expr, p.expr);
            }
            for (const element of p.expr) {
                if ($4j(element, q)) {
                    return true;
                }
            }
            return false;
        }
        return p.equals(q);
    }
    /**
     * Returns true if all elements in `p` are also present in `q`.
     * The two arrays are assumed to be sorted
     */
    function allElementsIncluded(p, q) {
        let pIndex = 0;
        let qIndex = 0;
        while (pIndex < p.length && qIndex < q.length) {
            const cmp = p[pIndex].cmp(q[qIndex]);
            if (cmp < 0) {
                // an element from `p` is missing from `q`
                return false;
            }
            else if (cmp === 0) {
                pIndex++;
                qIndex++;
            }
            else {
                qIndex++;
            }
        }
        return (pIndex === p.length);
    }
    function getTerminals(node) {
        if (node.type === ContextKeyExprType.Or) {
            return node.expr;
        }
        return [node];
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[74/*vs/platform/files/common/files*/], __M([0/*require*/,1/*exports*/,56/*vs/base/common/ternarySearchTree*/,5/*vs/base/common/path*/,11/*vs/base/common/strings*/,10/*vs/base/common/types*/,6/*vs/base/common/uri*/,8/*vs/nls*/,22/*vs/platform/instantiation/common/instantiation*/,3/*vs/base/common/platform*/,20/*vs/base/common/network*/,24/*vs/base/common/lazy*/]), function (require, exports, ternarySearchTree_1, path_1, strings_1, types_1, uri_1, nls_1, instantiation_1, platform_1, network_1, lazy_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$Nl = exports.$Kl = exports.FileKind = exports.$Jl = exports.$Il = exports.$Hl = exports.$Gl = exports.$Fl = exports.$El = exports.$Dl = exports.FileOperationResult = exports.$Cl = exports.$Bl = exports.$Al = exports.$yl = exports.FileChangeType = exports.$xl = exports.FileOperation = exports.$rl = exports.FileSystemProviderErrorCode = exports.FileSystemProviderCapabilities = exports.FileChangeFilter = exports.FilePermission = exports.FileType = exports.$fl = void 0;
    exports.$gl = $gl;
    exports.$hl = $hl;
    exports.$il = $il;
    exports.$jl = $jl;
    exports.$kl = $kl;
    exports.$ll = $ll;
    exports.$ml = $ml;
    exports.$nl = $nl;
    exports.$ol = $ol;
    exports.$pl = $pl;
    exports.$ql = $ql;
    exports.$sl = $sl;
    exports.$tl = $tl;
    exports.$ul = $ul;
    exports.$vl = $vl;
    exports.$wl = $wl;
    exports.$zl = $zl;
    exports.$Ll = $Ll;
    exports.$Ml = $Ml;
    exports.$Ol = $Ol;
    //#region file service & providers
    exports.$fl = (0, instantiation_1.$Ki)('fileService');
    function $gl(options) {
        return options.create === true;
    }
    var FileType;
    (function (FileType) {
        /**
         * File is unknown (neither file, directory nor symbolic link).
         */
        FileType[FileType["Unknown"] = 0] = "Unknown";
        /**
         * File is a normal file.
         */
        FileType[FileType["File"] = 1] = "File";
        /**
         * File is a directory.
         */
        FileType[FileType["Directory"] = 2] = "Directory";
        /**
         * File is a symbolic link.
         *
         * Note: even when the file is a symbolic link, you can test for
         * `FileType.File` and `FileType.Directory` to know the type of
         * the target the link points to.
         */
        FileType[FileType["SymbolicLink"] = 64] = "SymbolicLink";
    })(FileType || (exports.FileType = FileType = {}));
    var FilePermission;
    (function (FilePermission) {
        /**
         * File is readonly. Components like editors should not
         * offer to edit the contents.
         */
        FilePermission[FilePermission["Readonly"] = 1] = "Readonly";
        /**
         * File is locked. Components like editors should offer
         * to edit the contents and ask the user upon saving to
         * remove the lock.
         */
        FilePermission[FilePermission["Locked"] = 2] = "Locked";
    })(FilePermission || (exports.FilePermission = FilePermission = {}));
    var FileChangeFilter;
    (function (FileChangeFilter) {
        FileChangeFilter[FileChangeFilter["UPDATED"] = 2] = "UPDATED";
        FileChangeFilter[FileChangeFilter["ADDED"] = 4] = "ADDED";
        FileChangeFilter[FileChangeFilter["DELETED"] = 8] = "DELETED";
    })(FileChangeFilter || (exports.FileChangeFilter = FileChangeFilter = {}));
    function $hl(thing) {
        const candidate = thing;
        return !!candidate && typeof candidate.onDidChange === 'function';
    }
    var FileSystemProviderCapabilities;
    (function (FileSystemProviderCapabilities) {
        /**
         * No capabilities.
         */
        FileSystemProviderCapabilities[FileSystemProviderCapabilities["None"] = 0] = "None";
        /**
         * Provider supports unbuffered read/write.
         */
        FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileReadWrite"] = 2] = "FileReadWrite";
        /**
         * Provider supports open/read/write/close low level file operations.
         */
        FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileOpenReadWriteClose"] = 4] = "FileOpenReadWriteClose";
        /**
         * Provider supports stream based reading.
         */
        FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileReadStream"] = 16] = "FileReadStream";
        /**
         * Provider supports copy operation.
         */
        FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileFolderCopy"] = 8] = "FileFolderCopy";
        /**
         * Provider is path case sensitive.
         */
        FileSystemProviderCapabilities[FileSystemProviderCapabilities["PathCaseSensitive"] = 1024] = "PathCaseSensitive";
        /**
         * All files of the provider are readonly.
         */
        FileSystemProviderCapabilities[FileSystemProviderCapabilities["Readonly"] = 2048] = "Readonly";
        /**
         * Provider supports to delete via trash.
         */
        FileSystemProviderCapabilities[FileSystemProviderCapabilities["Trash"] = 4096] = "Trash";
        /**
         * Provider support to unlock files for writing.
         */
        FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileWriteUnlock"] = 8192] = "FileWriteUnlock";
        /**
         * Provider support to read files atomically. This implies the
         * provider provides the `FileReadWrite` capability too.
         */
        FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileAtomicRead"] = 16384] = "FileAtomicRead";
        /**
         * Provider support to write files atomically. This implies the
         * provider provides the `FileReadWrite` capability too.
         */
        FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileAtomicWrite"] = 32768] = "FileAtomicWrite";
        /**
         * Provider support to delete atomically.
         */
        FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileAtomicDelete"] = 65536] = "FileAtomicDelete";
        /**
         * Provider support to clone files atomically.
         */
        FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileClone"] = 131072] = "FileClone";
    })(FileSystemProviderCapabilities || (exports.FileSystemProviderCapabilities = FileSystemProviderCapabilities = {}));
    function $il(provider) {
        return !!(provider.capabilities & FileSystemProviderCapabilities.FileReadWrite);
    }
    function $jl(provider) {
        return !!(provider.capabilities & FileSystemProviderCapabilities.FileFolderCopy);
    }
    function $kl(provider) {
        return !!(provider.capabilities & FileSystemProviderCapabilities.FileClone);
    }
    function $ll(provider) {
        return !!(provider.capabilities & FileSystemProviderCapabilities.FileOpenReadWriteClose);
    }
    function $ml(provider) {
        return !!(provider.capabilities & FileSystemProviderCapabilities.FileReadStream);
    }
    function $nl(provider) {
        if (!$il(provider)) {
            return false; // we require the `FileReadWrite` capability too
        }
        return !!(provider.capabilities & FileSystemProviderCapabilities.FileAtomicRead);
    }
    function $ol(provider) {
        if (!$il(provider)) {
            return false; // we require the `FileReadWrite` capability too
        }
        return !!(provider.capabilities & FileSystemProviderCapabilities.FileAtomicWrite);
    }
    function $pl(provider) {
        return !!(provider.capabilities & FileSystemProviderCapabilities.FileAtomicDelete);
    }
    function $ql(provider) {
        return !!(provider.capabilities & FileSystemProviderCapabilities.Readonly);
    }
    var FileSystemProviderErrorCode;
    (function (FileSystemProviderErrorCode) {
        FileSystemProviderErrorCode["FileExists"] = "EntryExists";
        FileSystemProviderErrorCode["FileNotFound"] = "EntryNotFound";
        FileSystemProviderErrorCode["FileNotADirectory"] = "EntryNotADirectory";
        FileSystemProviderErrorCode["FileIsADirectory"] = "EntryIsADirectory";
        FileSystemProviderErrorCode["FileExceedsStorageQuota"] = "EntryExceedsStorageQuota";
        FileSystemProviderErrorCode["FileTooLarge"] = "EntryTooLarge";
        FileSystemProviderErrorCode["FileWriteLocked"] = "EntryWriteLocked";
        FileSystemProviderErrorCode["NoPermissions"] = "NoPermissions";
        FileSystemProviderErrorCode["Unavailable"] = "Unavailable";
        FileSystemProviderErrorCode["Unknown"] = "Unknown";
    })(FileSystemProviderErrorCode || (exports.FileSystemProviderErrorCode = FileSystemProviderErrorCode = {}));
    class $rl extends Error {
        static create(error, code) {
            const providerError = new $rl(error.toString(), code);
            $ul(providerError, code);
            return providerError;
        }
        constructor(message, code) {
            super(message);
            this.code = code;
        }
    }
    exports.$rl = $rl;
    function $sl(error, code) {
        return $rl.create(error, code);
    }
    function $tl(error) {
        if (!error) {
            return $sl((0, nls_1.localize)(1865, null), FileSystemProviderErrorCode.Unknown); // https://github.com/microsoft/vscode/issues/72798
        }
        return error;
    }
    function $ul(error, code) {
        error.name = code ? `${code} (FileSystemError)` : `FileSystemError`;
        return error;
    }
    function $vl(error) {
        // Guard against abuse
        if (!error) {
            return FileSystemProviderErrorCode.Unknown;
        }
        // FileSystemProviderError comes with the code
        if (error instanceof $rl) {
            return error.code;
        }
        // Any other error, check for name match by assuming that the error
        // went through the markAsFileSystemProviderError() method
        const match = /^(.+) \(FileSystemError\)$/.exec(error.name);
        if (!match) {
            return FileSystemProviderErrorCode.Unknown;
        }
        switch (match[1]) {
            case FileSystemProviderErrorCode.FileExists: return FileSystemProviderErrorCode.FileExists;
            case FileSystemProviderErrorCode.FileIsADirectory: return FileSystemProviderErrorCode.FileIsADirectory;
            case FileSystemProviderErrorCode.FileNotADirectory: return FileSystemProviderErrorCode.FileNotADirectory;
            case FileSystemProviderErrorCode.FileNotFound: return FileSystemProviderErrorCode.FileNotFound;
            case FileSystemProviderErrorCode.FileTooLarge: return FileSystemProviderErrorCode.FileTooLarge;
            case FileSystemProviderErrorCode.FileWriteLocked: return FileSystemProviderErrorCode.FileWriteLocked;
            case FileSystemProviderErrorCode.NoPermissions: return FileSystemProviderErrorCode.NoPermissions;
            case FileSystemProviderErrorCode.Unavailable: return FileSystemProviderErrorCode.Unavailable;
        }
        return FileSystemProviderErrorCode.Unknown;
    }
    function $wl(error) {
        // FileSystemProviderError comes with the result already
        if (error instanceof $Al) {
            return error.fileOperationResult;
        }
        // Otherwise try to find from code
        switch ($vl(error)) {
            case FileSystemProviderErrorCode.FileNotFound:
                return FileOperationResult.FILE_NOT_FOUND;
            case FileSystemProviderErrorCode.FileIsADirectory:
                return FileOperationResult.FILE_IS_DIRECTORY;
            case FileSystemProviderErrorCode.FileNotADirectory:
                return FileOperationResult.FILE_NOT_DIRECTORY;
            case FileSystemProviderErrorCode.FileWriteLocked:
                return FileOperationResult.FILE_WRITE_LOCKED;
            case FileSystemProviderErrorCode.NoPermissions:
                return FileOperationResult.FILE_PERMISSION_DENIED;
            case FileSystemProviderErrorCode.FileExists:
                return FileOperationResult.FILE_MOVE_CONFLICT;
            case FileSystemProviderErrorCode.FileTooLarge:
                return FileOperationResult.FILE_TOO_LARGE;
            default:
                return FileOperationResult.FILE_OTHER_ERROR;
        }
    }
    var FileOperation;
    (function (FileOperation) {
        FileOperation[FileOperation["CREATE"] = 0] = "CREATE";
        FileOperation[FileOperation["DELETE"] = 1] = "DELETE";
        FileOperation[FileOperation["MOVE"] = 2] = "MOVE";
        FileOperation[FileOperation["COPY"] = 3] = "COPY";
        FileOperation[FileOperation["WRITE"] = 4] = "WRITE";
    })(FileOperation || (exports.FileOperation = FileOperation = {}));
    class $xl {
        constructor(resource, operation, target) {
            this.resource = resource;
            this.operation = operation;
            this.target = target;
        }
        isOperation(operation) {
            return this.operation === operation;
        }
    }
    exports.$xl = $xl;
    /**
     * Possible changes that can occur to a file.
     */
    var FileChangeType;
    (function (FileChangeType) {
        FileChangeType[FileChangeType["UPDATED"] = 0] = "UPDATED";
        FileChangeType[FileChangeType["ADDED"] = 1] = "ADDED";
        FileChangeType[FileChangeType["DELETED"] = 2] = "DELETED";
    })(FileChangeType || (exports.FileChangeType = FileChangeType = {}));
    class $yl {
        static { this.a = null; }
        constructor(changes, c) {
            this.c = c;
            this.b = undefined;
            this.d = new lazy_1.$Y(() => {
                const added = ternarySearchTree_1.$Qi.forUris(() => this.c);
                added.fill(this.rawAdded.map(resource => [resource, true]));
                return added;
            });
            this.f = new lazy_1.$Y(() => {
                const updated = ternarySearchTree_1.$Qi.forUris(() => this.c);
                updated.fill(this.rawUpdated.map(resource => [resource, true]));
                return updated;
            });
            this.g = new lazy_1.$Y(() => {
                const deleted = ternarySearchTree_1.$Qi.forUris(() => this.c);
                deleted.fill(this.rawDeleted.map(resource => [resource, true]));
                return deleted;
            });
            /**
             * @deprecated use the `contains` or `affects` method to efficiently find
             * out if the event relates to a given resource. these methods ensure:
             * - that there is no expensive lookup needed (by using a `TernarySearchTree`)
             * - correctly handles `FileChangeType.DELETED` events
             */
            this.rawAdded = [];
            /**
            * @deprecated use the `contains` or `affects` method to efficiently find
            * out if the event relates to a given resource. these methods ensure:
            * - that there is no expensive lookup needed (by using a `TernarySearchTree`)
            * - correctly handles `FileChangeType.DELETED` events
            */
            this.rawUpdated = [];
            /**
            * @deprecated use the `contains` or `affects` method to efficiently find
            * out if the event relates to a given resource. these methods ensure:
            * - that there is no expensive lookup needed (by using a `TernarySearchTree`)
            * - correctly handles `FileChangeType.DELETED` events
            */
            this.rawDeleted = [];
            for (const change of changes) {
                // Split by type
                switch (change.type) {
                    case FileChangeType.ADDED:
                        this.rawAdded.push(change.resource);
                        break;
                    case FileChangeType.UPDATED:
                        this.rawUpdated.push(change.resource);
                        break;
                    case FileChangeType.DELETED:
                        this.rawDeleted.push(change.resource);
                        break;
                }
                // Figure out events correlation
                if (this.b !== $yl.a) {
                    if (typeof change.cId === 'number') {
                        if (this.b === undefined) {
                            this.b = change.cId; // correlation not yet set, just take it
                        }
                        else if (this.b !== change.cId) {
                            this.b = $yl.a; // correlation mismatch, we have mixed correlation
                        }
                    }
                    else {
                        if (this.b !== undefined) {
                            this.b = $yl.a; // correlation mismatch, we have mixed correlation
                        }
                    }
                }
            }
        }
        /**
         * Find out if the file change events match the provided resource.
         *
         * Note: when passing `FileChangeType.DELETED`, we consider a match
         * also when the parent of the resource got deleted.
         */
        contains(resource, ...types) {
            return this.h(resource, { includeChildren: false }, ...types);
        }
        /**
         * Find out if the file change events either match the provided
         * resource, or contain a child of this resource.
         */
        affects(resource, ...types) {
            return this.h(resource, { includeChildren: true }, ...types);
        }
        h(resource, options, ...types) {
            if (!resource) {
                return false;
            }
            const hasTypesFilter = types.length > 0;
            // Added
            if (!hasTypesFilter || types.includes(FileChangeType.ADDED)) {
                if (this.d.value.get(resource)) {
                    return true;
                }
                if (options.includeChildren && this.d.value.findSuperstr(resource)) {
                    return true;
                }
            }
            // Updated
            if (!hasTypesFilter || types.includes(FileChangeType.UPDATED)) {
                if (this.f.value.get(resource)) {
                    return true;
                }
                if (options.includeChildren && this.f.value.findSuperstr(resource)) {
                    return true;
                }
            }
            // Deleted
            if (!hasTypesFilter || types.includes(FileChangeType.DELETED)) {
                if (this.g.value.findSubstr(resource) /* deleted also considers parent folders */) {
                    return true;
                }
                if (options.includeChildren && this.g.value.findSuperstr(resource)) {
                    return true;
                }
            }
            return false;
        }
        /**
         * Returns if this event contains added files.
         */
        gotAdded() {
            return this.rawAdded.length > 0;
        }
        /**
         * Returns if this event contains deleted files.
         */
        gotDeleted() {
            return this.rawDeleted.length > 0;
        }
        /**
         * Returns if this event contains updated files.
         */
        gotUpdated() {
            return this.rawUpdated.length > 0;
        }
        /**
         * Returns if this event contains changes that correlate to the
         * provided `correlationId`.
         *
         * File change event correlation is an advanced watch feature that
         * allows to  identify from which watch request the events originate
         * from. This correlation allows to route events specifically
         * only to the requestor and not emit them to all listeners.
         */
        correlates(correlationId) {
            return this.b === correlationId;
        }
        /**
         * Figure out if the event contains changes that correlate to one
         * correlation identifier.
         *
         * File change event correlation is an advanced watch feature that
         * allows to  identify from which watch request the events originate
         * from. This correlation allows to route events specifically
         * only to the requestor and not emit them to all listeners.
         */
        hasCorrelation() {
            return typeof this.b === 'number';
        }
    }
    exports.$yl = $yl;
    function $zl(path, candidate, ignoreCase) {
        if (!path || !candidate || path === candidate) {
            return false;
        }
        if (candidate.length > path.length) {
            return false;
        }
        if (candidate.charAt(candidate.length - 1) !== path_1.sep) {
            candidate += path_1.sep;
        }
        if (ignoreCase) {
            return (0, strings_1.$Lf)(path, candidate);
        }
        return path.indexOf(candidate) === 0;
    }
    class $Al extends Error {
        constructor(message, fileOperationResult, options) {
            super(message);
            this.fileOperationResult = fileOperationResult;
            this.options = options;
        }
    }
    exports.$Al = $Al;
    class $Bl extends $Al {
        constructor(message, fileOperationResult, size, options) {
            super(message, fileOperationResult, options);
            this.fileOperationResult = fileOperationResult;
            this.size = size;
        }
    }
    exports.$Bl = $Bl;
    class $Cl extends $Al {
        constructor(message, stat, options) {
            super(message, FileOperationResult.FILE_NOT_MODIFIED_SINCE, options);
            this.stat = stat;
        }
    }
    exports.$Cl = $Cl;
    var FileOperationResult;
    (function (FileOperationResult) {
        FileOperationResult[FileOperationResult["FILE_IS_DIRECTORY"] = 0] = "FILE_IS_DIRECTORY";
        FileOperationResult[FileOperationResult["FILE_NOT_FOUND"] = 1] = "FILE_NOT_FOUND";
        FileOperationResult[FileOperationResult["FILE_NOT_MODIFIED_SINCE"] = 2] = "FILE_NOT_MODIFIED_SINCE";
        FileOperationResult[FileOperationResult["FILE_MODIFIED_SINCE"] = 3] = "FILE_MODIFIED_SINCE";
        FileOperationResult[FileOperationResult["FILE_MOVE_CONFLICT"] = 4] = "FILE_MOVE_CONFLICT";
        FileOperationResult[FileOperationResult["FILE_WRITE_LOCKED"] = 5] = "FILE_WRITE_LOCKED";
        FileOperationResult[FileOperationResult["FILE_PERMISSION_DENIED"] = 6] = "FILE_PERMISSION_DENIED";
        FileOperationResult[FileOperationResult["FILE_TOO_LARGE"] = 7] = "FILE_TOO_LARGE";
        FileOperationResult[FileOperationResult["FILE_INVALID_PATH"] = 8] = "FILE_INVALID_PATH";
        FileOperationResult[FileOperationResult["FILE_NOT_DIRECTORY"] = 9] = "FILE_NOT_DIRECTORY";
        FileOperationResult[FileOperationResult["FILE_OTHER_ERROR"] = 10] = "FILE_OTHER_ERROR";
    })(FileOperationResult || (exports.FileOperationResult = FileOperationResult = {}));
    //#endregion
    //#region Settings
    exports.$Dl = {
        OFF: 'off',
        AFTER_DELAY: 'afterDelay',
        ON_FOCUS_CHANGE: 'onFocusChange',
        ON_WINDOW_CHANGE: 'onWindowChange'
    };
    exports.$El = {
        OFF: 'off',
        ON_EXIT: 'onExit',
        ON_EXIT_AND_WINDOW_CLOSE: 'onExitAndWindowClose'
    };
    exports.$Fl = 'files.associations';
    exports.$Gl = 'files.exclude';
    exports.$Hl = 'files.readonlyInclude';
    exports.$Il = 'files.readonlyExclude';
    exports.$Jl = 'files.readonlyFromPermissions';
    //#endregion
    //#region Utilities
    var FileKind;
    (function (FileKind) {
        FileKind[FileKind["FILE"] = 0] = "FILE";
        FileKind[FileKind["FOLDER"] = 1] = "FOLDER";
        FileKind[FileKind["ROOT_FOLDER"] = 2] = "ROOT_FOLDER";
    })(FileKind || (exports.FileKind = FileKind = {}));
    /**
     * A hint to disable etag checking for reading/writing.
     */
    exports.$Kl = '';
    function $Ll(stat) {
        if (typeof stat.size !== 'number' || typeof stat.mtime !== 'number') {
            return undefined;
        }
        return stat.mtime.toString(29) + stat.size.toString(31);
    }
    async function $Ml(file, fileService) {
        if (fileService.hasProvider(uri_1.URI.from({ scheme: file.scheme }))) {
            return;
        }
        return new Promise(resolve => {
            const disposable = fileService.onDidChangeFileSystemProviderRegistrations(e => {
                if (e.scheme === file.scheme && e.added) {
                    disposable.dispose();
                    resolve();
                }
            });
        });
    }
    /**
     * Helper to format a raw byte size into a human readable label.
     */
    class $Nl {
        static { this.KB = 1024; }
        static { this.MB = $Nl.KB * $Nl.KB; }
        static { this.GB = $Nl.MB * $Nl.KB; }
        static { this.TB = $Nl.GB * $Nl.KB; }
        static formatSize(size) {
            if (!(0, types_1.$ng)(size)) {
                size = 0;
            }
            if (size < $Nl.KB) {
                return (0, nls_1.localize)(1866, null, size.toFixed(0));
            }
            if (size < $Nl.MB) {
                return (0, nls_1.localize)(1867, null, (size / $Nl.KB).toFixed(2));
            }
            if (size < $Nl.GB) {
                return (0, nls_1.localize)(1868, null, (size / $Nl.MB).toFixed(2));
            }
            if (size < $Nl.TB) {
                return (0, nls_1.localize)(1869, null, (size / $Nl.GB).toFixed(2));
            }
            return (0, nls_1.localize)(1870, null, (size / $Nl.TB).toFixed(2));
        }
    }
    exports.$Nl = $Nl;
    function $Ol(arg) {
        const isRemote = typeof arg === 'string' || arg?.scheme === network_1.Schemas.vscodeRemote;
        const isLocal = typeof arg !== 'string' && arg?.scheme === network_1.Schemas.file;
        if (isLocal) {
            // Local almost has no limit in file size
            return 1024 * $Nl.MB;
        }
        if (isRemote) {
            // With a remote, pick a low limit to avoid
            // potentially costly file transfers
            return 10 * $Nl.MB;
        }
        if (platform_1.$r) {
            // Web: we cannot know for sure if a cost
            // is associated with the file transfer
            // so we pick a reasonably small limit
            return 50 * $Nl.MB;
        }
        // Local desktop: almost no limit in file size
        return 1024 * $Nl.MB;
    }
});
//#endregion

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/























define(__m[9/*vs/platform/log/common/log*/], __M([0/*require*/,1/*exports*/,8/*vs/nls*/,59/*vs/base/common/errorMessage*/,4/*vs/base/common/event*/,55/*vs/base/common/hash*/,2/*vs/base/common/lifecycle*/,26/*vs/base/common/map*/,3/*vs/base/common/platform*/,25/*vs/base/common/resources*/,10/*vs/base/common/types*/,6/*vs/base/common/uri*/,39/*vs/platform/contextkey/common/contextkey*/,22/*vs/platform/instantiation/common/instantiation*/]), function (require, exports, nls, errorMessage_1, event_1, hash_1, lifecycle_1, map_1, platform_1, resources_1, types_1, uri_1, contextkey_1, instantiation_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$xk = exports.$sk = exports.$rk = exports.$qk = exports.$pk = exports.$ok = exports.$nk = exports.$mk = exports.$lk = exports.$kk = exports.$ik = exports.LogLevel = exports.$gk = exports.$fk = void 0;
    exports.$hk = $hk;
    exports.log = log;
    exports.$tk = $tk;
    exports.$uk = $uk;
    exports.$vk = $vk;
    exports.$wk = $wk;
    nls = __importStar(nls);
    exports.$fk = (0, instantiation_1.$Ki)('logService');
    exports.$gk = (0, instantiation_1.$Ki)('loggerService');
    function now() {
        return new Date().toISOString();
    }
    function $hk(thing) {
        return (0, types_1.$ng)(thing);
    }
    var LogLevel;
    (function (LogLevel) {
        LogLevel[LogLevel["Off"] = 0] = "Off";
        LogLevel[LogLevel["Trace"] = 1] = "Trace";
        LogLevel[LogLevel["Debug"] = 2] = "Debug";
        LogLevel[LogLevel["Info"] = 3] = "Info";
        LogLevel[LogLevel["Warning"] = 4] = "Warning";
        LogLevel[LogLevel["Error"] = 5] = "Error";
    })(LogLevel || (exports.LogLevel = LogLevel = {}));
    exports.$ik = LogLevel.Info;
    function log(logger, level, message) {
        switch (level) {
            case LogLevel.Trace:
                logger.trace(message);
                break;
            case LogLevel.Debug:
                logger.debug(message);
                break;
            case LogLevel.Info:
                logger.info(message);
                break;
            case LogLevel.Warning:
                logger.warn(message);
                break;
            case LogLevel.Error:
                logger.error(message);
                break;
            case LogLevel.Off: /* do nothing */ break;
            default: throw new Error(`Invalid log level ${level}`);
        }
    }
    function format(args, verbose = false) {
        let result = '';
        for (let i = 0; i < args.length; i++) {
            let a = args[i];
            if (a instanceof Error) {
                a = (0, errorMessage_1.$vj)(a, verbose);
            }
            if (typeof a === 'object') {
                try {
                    a = JSON.stringify(a);
                }
                catch (e) { }
            }
            result += (i > 0 ? ' ' : '') + a;
        }
        return result;
    }
    class $kk extends lifecycle_1.$Zc {
        constructor() {
            super(...arguments);
            this.b = exports.$ik;
            this.c = this.B(new event_1.$qe());
            this.onDidChangeLogLevel = this.c.event;
        }
        setLevel(level) {
            if (this.b !== level) {
                this.b = level;
                this.c.fire(this.b);
            }
        }
        getLevel() {
            return this.b;
        }
        f(level) {
            return this.b !== LogLevel.Off && this.b <= level;
        }
    }
    exports.$kk = $kk;
    class $lk extends $kk {
        constructor(h) {
            super();
            this.h = h;
        }
        f(level) {
            return this.h || super.f(level);
        }
        trace(message, ...args) {
            if (this.f(LogLevel.Trace)) {
                this.g(LogLevel.Trace, format([message, ...args], true));
            }
        }
        debug(message, ...args) {
            if (this.f(LogLevel.Debug)) {
                this.g(LogLevel.Debug, format([message, ...args]));
            }
        }
        info(message, ...args) {
            if (this.f(LogLevel.Info)) {
                this.g(LogLevel.Info, format([message, ...args]));
            }
        }
        warn(message, ...args) {
            if (this.f(LogLevel.Warning)) {
                this.g(LogLevel.Warning, format([message, ...args]));
            }
        }
        error(message, ...args) {
            if (this.f(LogLevel.Error)) {
                if (message instanceof Error) {
                    const array = Array.prototype.slice.call(arguments);
                    array[0] = message.stack;
                    this.g(LogLevel.Error, format(array));
                }
                else {
                    this.g(LogLevel.Error, format([message, ...args]));
                }
            }
        }
        flush() { }
    }
    exports.$lk = $lk;
    class $mk extends $kk {
        constructor(logLevel = exports.$ik) {
            super();
            this.setLevel(logLevel);
            this.g = !platform_1.$l;
        }
        trace(message, ...args) {
            if (this.f(LogLevel.Trace)) {
                if (this.g) {
                    console.log(`\x1b[90m[main ${now()}]\x1b[0m`, message, ...args);
                }
                else {
                    console.log(`[main ${now()}]`, message, ...args);
                }
            }
        }
        debug(message, ...args) {
            if (this.f(LogLevel.Debug)) {
                if (this.g) {
                    console.log(`\x1b[90m[main ${now()}]\x1b[0m`, message, ...args);
                }
                else {
                    console.log(`[main ${now()}]`, message, ...args);
                }
            }
        }
        info(message, ...args) {
            if (this.f(LogLevel.Info)) {
                if (this.g) {
                    console.log(`\x1b[90m[main ${now()}]\x1b[0m`, message, ...args);
                }
                else {
                    console.log(`[main ${now()}]`, message, ...args);
                }
            }
        }
        warn(message, ...args) {
            if (this.f(LogLevel.Warning)) {
                if (this.g) {
                    console.warn(`\x1b[93m[main ${now()}]\x1b[0m`, message, ...args);
                }
                else {
                    console.warn(`[main ${now()}]`, message, ...args);
                }
            }
        }
        error(message, ...args) {
            if (this.f(LogLevel.Error)) {
                if (this.g) {
                    console.error(`\x1b[91m[main ${now()}]\x1b[0m`, message, ...args);
                }
                else {
                    console.error(`[main ${now()}]`, message, ...args);
                }
            }
        }
        flush() {
            // noop
        }
    }
    exports.$mk = $mk;
    class $nk extends $kk {
        constructor(logLevel = exports.$ik, g = true) {
            super();
            this.g = g;
            this.setLevel(logLevel);
        }
        trace(message, ...args) {
            if (this.f(LogLevel.Trace)) {
                if (this.g) {
                    console.log('%cTRACE', 'color: #888', message, ...args);
                }
                else {
                    console.log(message, ...args);
                }
            }
        }
        debug(message, ...args) {
            if (this.f(LogLevel.Debug)) {
                if (this.g) {
                    console.log('%cDEBUG', 'background: #eee; color: #888', message, ...args);
                }
                else {
                    console.log(message, ...args);
                }
            }
        }
        info(message, ...args) {
            if (this.f(LogLevel.Info)) {
                if (this.g) {
                    console.log('%c INFO', 'color: #33f', message, ...args);
                }
                else {
                    console.log(message, ...args);
                }
            }
        }
        warn(message, ...args) {
            if (this.f(LogLevel.Warning)) {
                if (this.g) {
                    console.log('%c WARN', 'color: #993', message, ...args);
                }
                else {
                    console.log(message, ...args);
                }
            }
        }
        error(message, ...args) {
            if (this.f(LogLevel.Error)) {
                if (this.g) {
                    console.log('%c  ERR', 'color: #f33', message, ...args);
                }
                else {
                    console.error(message, ...args);
                }
            }
        }
        flush() {
            // noop
        }
    }
    exports.$nk = $nk;
    class $ok extends $kk {
        constructor(g, logLevel = exports.$ik) {
            super();
            this.g = g;
            this.setLevel(logLevel);
        }
        trace(message, ...args) {
            if (this.f(LogLevel.Trace)) {
                this.g.log(LogLevel.Trace, [this.h(message), ...args]);
            }
        }
        debug(message, ...args) {
            if (this.f(LogLevel.Debug)) {
                this.g.log(LogLevel.Debug, [this.h(message), ...args]);
            }
        }
        info(message, ...args) {
            if (this.f(LogLevel.Info)) {
                this.g.log(LogLevel.Info, [this.h(message), ...args]);
            }
        }
        warn(message, ...args) {
            if (this.f(LogLevel.Warning)) {
                this.g.log(LogLevel.Warning, [this.h(message), ...args]);
            }
        }
        error(message, ...args) {
            if (this.f(LogLevel.Error)) {
                this.g.log(LogLevel.Error, [this.h(message), ...args]);
            }
        }
        h(msg) {
            if (typeof msg === 'string') {
                return msg;
            }
            return (0, errorMessage_1.$vj)(msg, this.f(LogLevel.Trace));
        }
        flush() {
            // noop
        }
    }
    exports.$ok = $ok;
    class $pk extends $kk {
        constructor(g) {
            super();
            this.g = g;
            if (g.length) {
                this.setLevel(g[0].getLevel());
            }
        }
        setLevel(level) {
            for (const logger of this.g) {
                logger.setLevel(level);
            }
            super.setLevel(level);
        }
        trace(message, ...args) {
            for (const logger of this.g) {
                logger.trace(message, ...args);
            }
        }
        debug(message, ...args) {
            for (const logger of this.g) {
                logger.debug(message, ...args);
            }
        }
        info(message, ...args) {
            for (const logger of this.g) {
                logger.info(message, ...args);
            }
        }
        warn(message, ...args) {
            for (const logger of this.g) {
                logger.warn(message, ...args);
            }
        }
        error(message, ...args) {
            for (const logger of this.g) {
                logger.error(message, ...args);
            }
        }
        flush() {
            for (const logger of this.g) {
                logger.flush();
            }
        }
        dispose() {
            for (const logger of this.g) {
                logger.dispose();
            }
            super.dispose();
        }
    }
    exports.$pk = $pk;
    class $qk extends lifecycle_1.$Zc {
        constructor(h, j, loggerResources) {
            super();
            this.h = h;
            this.j = j;
            this.b = new map_1.$Fc();
            this.c = this.B(new event_1.$qe);
            this.onDidChangeLoggers = this.c.event;
            this.f = this.B(new event_1.$qe);
            this.onDidChangeLogLevel = this.f.event;
            this.g = this.B(new event_1.$qe);
            this.onDidChangeVisibility = this.g.event;
            if (loggerResources) {
                for (const loggerResource of loggerResources) {
                    this.b.set(loggerResource.resource, { logger: undefined, info: loggerResource });
                }
            }
        }
        m(resourceOrId) {
            if ((0, types_1.$jg)(resourceOrId)) {
                return [...this.b.values()].find(logger => logger.info.id === resourceOrId);
            }
            return this.b.get(resourceOrId);
        }
        getLogger(resourceOrId) {
            return this.m(resourceOrId)?.logger;
        }
        createLogger(idOrResource, options) {
            const resource = this.n(idOrResource);
            const id = (0, types_1.$jg)(idOrResource) ? idOrResource : (options?.id ?? (0, hash_1.$yj)(resource.toString()).toString(16));
            let logger = this.b.get(resource)?.logger;
            const logLevel = options?.logLevel === 'always' ? LogLevel.Trace : options?.logLevel;
            if (!logger) {
                logger = this.s(resource, logLevel ?? this.getLogLevel(resource) ?? this.h, { ...options, id });
            }
            const loggerEntry = {
                logger,
                info: { resource, id, logLevel, name: options?.name, hidden: options?.hidden, extensionId: options?.extensionId, when: options?.when }
            };
            this.registerLogger(loggerEntry.info);
            // TODO: @sandy081 Remove this once registerLogger can take ILogger
            this.b.set(resource, loggerEntry);
            return logger;
        }
        n(idOrResource) {
            return (0, types_1.$jg)(idOrResource) ? (0, resources_1.$lh)(this.j, `${idOrResource}.log`) : idOrResource;
        }
        setLogLevel(arg1, arg2) {
            if (uri_1.URI.isUri(arg1)) {
                const resource = arg1;
                const logLevel = arg2;
                const logger = this.b.get(resource);
                if (logger && logLevel !== logger.info.logLevel) {
                    logger.info.logLevel = logLevel === this.h ? undefined : logLevel;
                    logger.logger?.setLevel(logLevel);
                    this.b.set(logger.info.resource, logger);
                    this.f.fire([resource, logLevel]);
                }
            }
            else {
                this.h = arg1;
                for (const [resource, logger] of this.b.entries()) {
                    if (this.b.get(resource)?.info.logLevel === undefined) {
                        logger.logger?.setLevel(this.h);
                    }
                }
                this.f.fire(this.h);
            }
        }
        setVisibility(resourceOrId, visibility) {
            const logger = this.m(resourceOrId);
            if (logger && visibility !== !logger.info.hidden) {
                logger.info.hidden = !visibility;
                this.b.set(logger.info.resource, logger);
                this.g.fire([logger.info.resource, visibility]);
            }
        }
        getLogLevel(resource) {
            let logLevel;
            if (resource) {
                logLevel = this.b.get(resource)?.info.logLevel;
            }
            return logLevel ?? this.h;
        }
        registerLogger(resource) {
            const existing = this.b.get(resource.resource);
            if (existing) {
                if (existing.info.hidden !== resource.hidden) {
                    this.setVisibility(resource.resource, !resource.hidden);
                }
            }
            else {
                this.b.set(resource.resource, { info: resource, logger: undefined });
                this.c.fire({ added: [resource], removed: [] });
            }
        }
        deregisterLogger(resource) {
            const existing = this.b.get(resource);
            if (existing) {
                if (existing.logger) {
                    existing.logger.dispose();
                }
                this.b.delete(resource);
                this.c.fire({ added: [], removed: [existing.info] });
            }
        }
        *getRegisteredLoggers() {
            for (const entry of this.b.values()) {
                yield entry.info;
            }
        }
        getRegisteredLogger(resource) {
            return this.b.get(resource)?.info;
        }
        dispose() {
            this.b.forEach(logger => logger.logger?.dispose());
            this.b.clear();
            super.dispose();
        }
    }
    exports.$qk = $qk;
    class $rk {
        constructor() {
            this.onDidChangeLogLevel = new event_1.$qe().event;
        }
        setLevel(level) { }
        getLevel() { return LogLevel.Info; }
        trace(message, ...args) { }
        debug(message, ...args) { }
        info(message, ...args) { }
        warn(message, ...args) { }
        error(message, ...args) { }
        critical(message, ...args) { }
        dispose() { }
        flush() { }
    }
    exports.$rk = $rk;
    class $sk extends $rk {
    }
    exports.$sk = $sk;
    function $tk(environmentService) {
        if (environmentService.verbose) {
            return LogLevel.Trace;
        }
        if (typeof environmentService.logLevel === 'string') {
            const logLevel = $wk(environmentService.logLevel.toLowerCase());
            if (logLevel !== undefined) {
                return logLevel;
            }
        }
        return exports.$ik;
    }
    function $uk(logLevel) {
        switch (logLevel) {
            case LogLevel.Trace: return 'trace';
            case LogLevel.Debug: return 'debug';
            case LogLevel.Info: return 'info';
            case LogLevel.Warning: return 'warn';
            case LogLevel.Error: return 'error';
            case LogLevel.Off: return 'off';
        }
    }
    function $vk(logLevel) {
        switch (logLevel) {
            case LogLevel.Trace: return { original: 'Trace', value: nls.localize(1959, null) };
            case LogLevel.Debug: return { original: 'Debug', value: nls.localize(1960, null) };
            case LogLevel.Info: return { original: 'Info', value: nls.localize(1961, null) };
            case LogLevel.Warning: return { original: 'Warning', value: nls.localize(1962, null) };
            case LogLevel.Error: return { original: 'Error', value: nls.localize(1963, null) };
            case LogLevel.Off: return { original: 'Off', value: nls.localize(1964, null) };
        }
    }
    function $wk(logLevel) {
        switch (logLevel) {
            case 'trace':
                return LogLevel.Trace;
            case 'debug':
                return LogLevel.Debug;
            case 'info':
                return LogLevel.Info;
            case 'warn':
                return LogLevel.Warning;
            case 'error':
                return LogLevel.Error;
            case 'critical':
                return LogLevel.Error;
            case 'off':
                return LogLevel.Off;
        }
        return undefined;
    }
    // Contexts
    exports.$xk = new contextkey_1.$2j('logLevel', $uk(LogLevel.Info));
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[75/*vs/platform/log/common/logIpc*/], __M([0/*require*/,1/*exports*/,6/*vs/base/common/uri*/,4/*vs/base/common/event*/,9/*vs/platform/log/common/log*/,2/*vs/base/common/lifecycle*/]), function (require, exports, uri_1, event_1, log_1, lifecycle_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$Ds = exports.$Cs = exports.$Bs = void 0;
    class $Bs extends log_1.$qk {
        constructor(r, logLevel, logsHome, loggers, t) {
            super(logLevel, logsHome, loggers);
            this.r = r;
            this.t = t;
            this.B(t.listen('onDidChangeLogLevel', r)(arg => {
                if ((0, log_1.$hk)(arg)) {
                    super.setLogLevel(arg);
                }
                else {
                    super.setLogLevel(uri_1.URI.revive(arg[0]), arg[1]);
                }
            }));
            this.B(t.listen('onDidChangeVisibility', r)(([resource, visibility]) => super.setVisibility(uri_1.URI.revive(resource), visibility)));
            this.B(t.listen('onDidChangeLoggers', r)(({ added, removed }) => {
                for (const loggerResource of added) {
                    super.registerLogger({ ...loggerResource, resource: uri_1.URI.revive(loggerResource.resource) });
                }
                for (const loggerResource of removed) {
                    super.deregisterLogger(loggerResource.resource);
                }
            }));
        }
        createConsoleMainLogger() {
            return new log_1.$ok({
                log: (level, args) => {
                    this.t.call('consoleLog', [level, args]);
                }
            });
        }
        registerLogger(logger) {
            super.registerLogger(logger);
            this.t.call('registerLogger', [logger, this.r]);
        }
        deregisterLogger(resource) {
            super.deregisterLogger(resource);
            this.t.call('deregisterLogger', [resource, this.r]);
        }
        setLogLevel(arg1, arg2) {
            super.setLogLevel(arg1, arg2);
            this.t.call('setLogLevel', [arg1, arg2]);
        }
        setVisibility(resourceOrId, visibility) {
            super.setVisibility(resourceOrId, visibility);
            this.t.call('setVisibility', [this.n(resourceOrId), visibility]);
        }
        s(file, logLevel, options) {
            return new Logger(this.t, file, logLevel, options, this.r);
        }
        static setLogLevel(channel, arg1, arg2) {
            return channel.call('setLogLevel', [arg1, arg2]);
        }
    }
    exports.$Bs = $Bs;
    class Logger extends log_1.$lk {
        constructor(r, s, logLevel, loggerOptions, windowId) {
            super(loggerOptions?.logLevel === 'always');
            this.r = r;
            this.s = s;
            this.m = false;
            this.n = [];
            this.setLevel(logLevel);
            this.r.call('createLogger', [s, loggerOptions, windowId])
                .then(() => {
                this.u(this.n);
                this.m = true;
            });
        }
        g(level, message) {
            const messages = [[level, message]];
            if (this.m) {
                this.u(messages);
            }
            else {
                this.n.push(...messages);
            }
        }
        u(messages) {
            this.r.call('log', [this.s, messages]);
        }
    }
    class $Cs {
        constructor(a, b) {
            this.a = a;
            this.b = b;
        }
        listen(context, event) {
            const uriTransformer = this.b(context);
            switch (event) {
                case 'onDidChangeLoggers': return event_1.Event.map(this.a.onDidChangeLoggers, (e) => ({
                    added: [...e.added].map(logger => this.c(logger, uriTransformer)),
                    removed: [...e.removed].map(logger => this.c(logger, uriTransformer)),
                }));
                case 'onDidChangeVisibility': return event_1.Event.map(this.a.onDidChangeVisibility, e => [uriTransformer.transformOutgoingURI(e[0]), e[1]]);
                case 'onDidChangeLogLevel': return event_1.Event.map(this.a.onDidChangeLogLevel, e => (0, log_1.$hk)(e) ? e : [uriTransformer.transformOutgoingURI(e[0]), e[1]]);
            }
            throw new Error(`Event not found: ${event}`);
        }
        async call(context, command, arg) {
            const uriTransformer = this.b(context);
            switch (command) {
                case 'setLogLevel': return (0, log_1.$hk)(arg[0]) ? this.a.setLogLevel(arg[0]) : this.a.setLogLevel(uri_1.URI.revive(uriTransformer.transformIncoming(arg[0][0])), arg[0][1]);
                case 'getRegisteredLoggers': return Promise.resolve([...this.a.getRegisteredLoggers()].map(logger => this.c(logger, uriTransformer)));
            }
            throw new Error(`Call not found: ${command}`);
        }
        c(logger, transformer) {
            return {
                ...logger,
                resource: transformer.transformOutgoingURI(logger.resource)
            };
        }
    }
    exports.$Cs = $Cs;
    class $Ds extends lifecycle_1.$Zc {
        constructor(loggerService, channel) {
            super();
            channel.call('setLogLevel', [loggerService.getLogLevel()]);
            this.B(loggerService.onDidChangeLogLevel(arg => channel.call('setLogLevel', [arg])));
            channel.call('getRegisteredLoggers').then(loggers => {
                for (const loggerResource of loggers) {
                    loggerService.registerLogger({ ...loggerResource, resource: uri_1.URI.revive(loggerResource.resource) });
                }
            });
            this.B(channel.listen('onDidChangeVisibility')(([resource, visibility]) => loggerService.setVisibility(uri_1.URI.revive(resource), visibility)));
            this.B(channel.listen('onDidChangeLoggers')(({ added, removed }) => {
                for (const loggerResource of added) {
                    loggerService.registerLogger({ ...loggerResource, resource: uri_1.URI.revive(loggerResource.resource) });
                }
                for (const loggerResource of removed) {
                    loggerService.deregisterLogger(loggerResource.resource);
                }
            }));
        }
    }
    exports.$Ds = $Ds;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[76/*vs/platform/log/common/logService*/], __M([0/*require*/,1/*exports*/,2/*vs/base/common/lifecycle*/,9/*vs/platform/log/common/log*/]), function (require, exports, lifecycle_1, log_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$aS = void 0;
    class $aS extends lifecycle_1.$Zc {
        constructor(primaryLogger, otherLoggers = []) {
            super();
            this.a = new log_1.$pk([primaryLogger, ...otherLoggers]);
            this.B(primaryLogger.onDidChangeLogLevel(level => this.setLevel(level)));
        }
        get onDidChangeLogLevel() {
            return this.a.onDidChangeLogLevel;
        }
        setLevel(level) {
            this.a.setLevel(level);
        }
        getLevel() {
            return this.a.getLevel();
        }
        trace(message, ...args) {
            this.a.trace(message, ...args);
        }
        debug(message, ...args) {
            this.a.debug(message, ...args);
        }
        info(message, ...args) {
            this.a.info(message, ...args);
        }
        warn(message, ...args) {
            this.a.warn(message, ...args);
        }
        error(message, ...args) {
            this.a.error(message, ...args);
        }
        flush() {
            this.a.flush();
        }
    }
    exports.$aS = $aS;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/























define(__m[77/*vs/platform/log/node/spdlogLog*/], __M([0/*require*/,1/*exports*/,74/*vs/platform/files/common/files*/,9/*vs/platform/log/common/log*/]), function (require, exports, files_1, log_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$2R = void 0;
    var SpdLogLevel;
    (function (SpdLogLevel) {
        SpdLogLevel[SpdLogLevel["Trace"] = 0] = "Trace";
        SpdLogLevel[SpdLogLevel["Debug"] = 1] = "Debug";
        SpdLogLevel[SpdLogLevel["Info"] = 2] = "Info";
        SpdLogLevel[SpdLogLevel["Warning"] = 3] = "Warning";
        SpdLogLevel[SpdLogLevel["Error"] = 4] = "Error";
        SpdLogLevel[SpdLogLevel["Critical"] = 5] = "Critical";
        SpdLogLevel[SpdLogLevel["Off"] = 6] = "Off";
    })(SpdLogLevel || (SpdLogLevel = {}));
    async function createSpdLogLogger(name, logfilePath, filesize, filecount, donotUseFormatters) {
        // Do not crash if spdlog cannot be loaded
        try {
            const _spdlog = await new Promise((resolve_1, reject_1) => { require(['@vscode/spdlog'], resolve_1, reject_1); }).then(__importStar);
            _spdlog.setFlushOn(SpdLogLevel.Trace);
            const logger = await _spdlog.createAsyncRotatingLogger(name, logfilePath, filesize, filecount);
            if (donotUseFormatters) {
                logger.clearFormatters();
            }
            else {
                logger.setPattern('%Y-%m-%d %H:%M:%S.%e [%l] %v');
            }
            return logger;
        }
        catch (e) {
            console.error(e);
        }
        return null;
    }
    function log(logger, level, message) {
        switch (level) {
            case log_1.LogLevel.Trace:
                logger.trace(message);
                break;
            case log_1.LogLevel.Debug:
                logger.debug(message);
                break;
            case log_1.LogLevel.Info:
                logger.info(message);
                break;
            case log_1.LogLevel.Warning:
                logger.warn(message);
                break;
            case log_1.LogLevel.Error:
                logger.error(message);
                break;
            case log_1.LogLevel.Off: /* do nothing */ break;
            default: throw new Error(`Invalid log level ${level}`);
        }
    }
    function setLogLevel(logger, level) {
        switch (level) {
            case log_1.LogLevel.Trace:
                logger.setLevel(SpdLogLevel.Trace);
                break;
            case log_1.LogLevel.Debug:
                logger.setLevel(SpdLogLevel.Debug);
                break;
            case log_1.LogLevel.Info:
                logger.setLevel(SpdLogLevel.Info);
                break;
            case log_1.LogLevel.Warning:
                logger.setLevel(SpdLogLevel.Warning);
                break;
            case log_1.LogLevel.Error:
                logger.setLevel(SpdLogLevel.Error);
                break;
            case log_1.LogLevel.Off:
                logger.setLevel(SpdLogLevel.Off);
                break;
            default: throw new Error(`Invalid log level ${level}`);
        }
    }
    class $2R extends log_1.$lk {
        constructor(name, filepath, rotating, donotUseFormatters, level) {
            super();
            this.m = [];
            this.setLevel(level);
            this.n = this.s(name, filepath, rotating, donotUseFormatters);
            this.B(this.onDidChangeLogLevel(level => {
                if (this.r) {
                    setLogLevel(this.r, level);
                }
            }));
        }
        async s(name, filepath, rotating, donotUseFormatters) {
            const filecount = rotating ? 6 : 1;
            const filesize = (30 / filecount) * files_1.$Nl.MB;
            const logger = await createSpdLogLogger(name, filepath, filesize, filecount, donotUseFormatters);
            if (logger) {
                this.r = logger;
                setLogLevel(this.r, this.getLevel());
                for (const { level, message } of this.m) {
                    log(this.r, level, message);
                }
                this.m = [];
            }
        }
        g(level, message) {
            if (this.r) {
                log(this.r, level, message);
            }
            else if (this.getLevel() <= level) {
                this.m.push({ level, message });
            }
        }
        flush() {
            if (this.r) {
                this.r.flush();
            }
            else {
                this.n.then(() => this.flush());
            }
        }
        dispose() {
            if (this.r) {
                this.u();
            }
            else {
                this.n.then(() => this.u());
            }
            super.dispose();
        }
        u() {
            if (this.r) {
                this.r.drop();
                this.r = undefined;
            }
        }
    }
    exports.$2R = $2R;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[78/*vs/platform/log/node/loggerService*/], __M([0/*require*/,1/*exports*/,57/*vs/base/common/uuid*/,9/*vs/platform/log/common/log*/,77/*vs/platform/log/node/spdlogLog*/]), function (require, exports, uuid_1, log_1, spdlogLog_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$3R = void 0;
    class $3R extends log_1.$qk {
        s(resource, logLevel, options) {
            return new spdlogLog_1.$2R((0, uuid_1.$7g)(), resource.fsPath, !options?.donotRotate, !!options?.donotUseFormatters, logLevel);
        }
    }
    exports.$3R = $3R;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[79/*vs/platform/product/common/product*/], __M([0/*require*/,1/*exports*/,15/*vs/base/common/process*/]), function (require, exports, process_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    /**
     * @deprecated You MUST use `IProductService` if possible.
     */
    let product;
    // Native sandbox environment
    const vscodeGlobal = globalThis.vscode;
    if (typeof vscodeGlobal !== 'undefined' && typeof vscodeGlobal.context !== 'undefined') {
        const configuration = vscodeGlobal.context.configuration();
        if (configuration) {
            product = configuration.product;
        }
        else {
            throw new Error('Sandbox: unable to resolve product configuration from preload script.');
        }
    }
    // _VSCODE environment
    else if (globalThis._VSCODE_PRODUCT_JSON && globalThis._VSCODE_PACKAGE_JSON) {
        // Obtain values from product.json and package.json-data
        product = globalThis._VSCODE_PRODUCT_JSON;
        // Running out of sources
        if (process_1.env['VSCODE_DEV']) {
            Object.assign(product, {
                nameShort: `${product.nameShort} Dev`,
                nameLong: `${product.nameLong} Dev`,
                dataFolderName: `${product.dataFolderName}-dev`,
                serverDataFolderName: product.serverDataFolderName ? `${product.serverDataFolderName}-dev` : undefined
            });
        }
        // Version is added during built time, but we still
        // want to have it running out of sources so we
        // read it from package.json only when we need it.
        if (!product.version) {
            const pkg = globalThis._VSCODE_PACKAGE_JSON;
            Object.assign(product, {
                version: pkg.version
            });
        }
        // --- Start PWB: Custom extensions gallery
        if (process_1.env['EXTENSIONS_GALLERY']) {
            Object.assign(product, {
                extensionsGallery: JSON.parse(process_1.env['EXTENSIONS_GALLERY'])
            });
        }
        // --- End PWB: Custom extensions gallery
    }
    // Web environment or unknown
    else {
        // Built time configuration (do NOT modify)
        product = { "nameShort":"Code - OSS with Posit Workbench","nameLong":"Code - OSS with Posit Workbench","applicationName":"code-server","dataFolderName":".vscode-server","win32MutexName":"vscodeoss","licenseName":"MIT","serverLicenseUrl":"https://posit.co/about/eula/","licenseUrl":"https://posit.co/about/eula/","serverGreeting":[],"serverLicense":[],"serverLicensePrompt":"","serverApplicationName":"vscode-server","serverDataFolderName":".vscode-server","tunnelApplicationName":"vscode-tunnel","win32DirName":"Microsoft Code OSS","win32NameVersion":"Microsoft Code OSS","win32RegValueName":"CodeOSS","win32AppId":"{{F9502347-C9F5-4EBE-8794-75836AAAD88D}","win32x64AppId":"{{8DA74215-C267-4C6C-A88D-CD657F897B03}","win32arm64AppId":"{{3AEBF0C8-F733-4AD4-BADE-FDB816D53D7B}","win32UserAppId":"{{BA70F482-04D8-4BD6-B6C5-976E94C73E13}","win32x64UserAppId":"{{D4272F45-0AAB-432E-89DE-DBC7DFA87F7D}","win32arm64UserAppId":"{{B9BE1090-E373-4510-829E-D98C416CB4D9}","win32AppUserModelId":"Microsoft.CodeOSS","win32ShellNameShort":"C&ode - OSS","win32TunnelServiceMutex":"vscodeoss-tunnelservice","win32TunnelMutex":"vscodeoss-tunnel","darwinBundleIdentifier":"com.visualstudio.code.oss","linuxIconName":"code-oss","licenseFileName":"LICENSE.txt","reportIssueUrl":"https://github.com/microsoft/vscode/issues/new","nodejsRepository":"https://nodejs.org","urlProtocol":"vscode-server","webviewContentExternalBaseUrlTemplate":"https://{{uuid}}.vscode-cdn.net/insider/ef65ac1ba57f57f2a3961bfe94aa20481caca4c6/out/vs/workbench/contrib/webview/browser/pre/","builtInExtensions":[{"name":"ms-vscode.js-debug-companion","version":"1.1.3","sha256":"7380a890787452f14b2db7835dfa94de538caf358ebc263f9d46dd68ac52de93","repo":"https://github.com/microsoft/vscode-js-debug-companion","metadata":{"id":"99cb0b7f-7354-4278-b8da-6cc79972169d","publisherId":{"publisherId":"5f5636e7-69ed-4afe-b5d6-8d231fb3d3ee","publisherName":"ms-vscode","displayName":"Microsoft","flags":"verified"},"publisherDisplayName":"Microsoft"}},{"name":"ms-vscode.js-debug","version":"1.93.0","sha256":"9339cb8e6b77f554df54d79e71f533279cb76b0f9b04c207f633bfd507442b6a","repo":"https://github.com/microsoft/vscode-js-debug","metadata":{"id":"25629058-ddac-4e17-abba-74678e126c5d","publisherId":{"publisherId":"5f5636e7-69ed-4afe-b5d6-8d231fb3d3ee","publisherName":"ms-vscode","displayName":"Microsoft","flags":"verified"},"publisherDisplayName":"Microsoft"}},{"name":"ms-vscode.vscode-js-profile-table","version":"1.0.9","sha256":"3b62ee4276a2bbea3fe230f94b1d5edd915b05966090ea56f882e1e0ab53e1a6","repo":"https://github.com/microsoft/vscode-js-profile-visualizer","metadata":{"id":"7e52b41b-71ad-457b-ab7e-0620f1fc4feb","publisherId":{"publisherId":"5f5636e7-69ed-4afe-b5d6-8d231fb3d3ee","publisherName":"ms-vscode","displayName":"Microsoft","flags":"verified"},"publisherDisplayName":"Microsoft"}},{"name":"rstudio.rstudio-workbench","version":"1.5.28","positUrl":"https://cdn.posit.co/pwb-components/extension","type":"reh-web","sha256":"a1052e6cf884977b68883950360d29b394acdbdd2a84f0b17a7cc9887436918f","metadata":{"publisherDisplayName":"Posit PBC"}}],"extensionsGallery":{"serviceUrl":"https://open-vsx.org/vscode/gallery","itemUrl":"https://open-vsx.org/vscode/item","resourceUrlTemplate":"https://open-vsx.org/vscode/asset/{publisher}/{name}/{version}/Microsoft.VisualStudio.Code.WebResources/{path}","controlUrl":"","recommendationsUrl":""},"linkProtectionTrustedDomains":["https://open-vsx.org"],"version":"1.93.0","commit":"38864289bf625c8ce6892e40c6e190c9d2f1d867","date":"2025-02-01T22:09:01.838Z"};
        // Running out of sources
        if (Object.keys(product).length === 0) {
            Object.assign(product, {
                version: '1.91.0-dev',
                nameShort: 'Code - OSS Dev',
                nameLong: 'Code - OSS Dev',
                applicationName: 'code-oss',
                dataFolderName: '.vscode-oss',
                urlProtocol: 'code-oss',
                reportIssueUrl: 'https://github.com/microsoft/vscode/issues/new',
                licenseName: 'MIT',
                licenseUrl: 'https://github.com/microsoft/vscode/blob/main/LICENSE.txt',
                serverLicenseUrl: 'https://github.com/microsoft/vscode/blob/main/LICENSE.txt'
            });
        }
    }
    /**
     * @deprecated You MUST use `IProductService` if possible.
     */
    exports.default = product;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[80/*vs/platform/product/common/productService*/], __M([0/*require*/,1/*exports*/,22/*vs/platform/instantiation/common/instantiation*/]), function (require, exports, instantiation_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$zk = exports.$yk = void 0;
    exports.$yk = (0, instantiation_1.$Ki)('productService');
    exports.$zk = 'vscode://schemas/vscode-product';
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/























define(__m[81/*vs/platform/registry/common/platform*/], __M([0/*require*/,1/*exports*/,46/*vs/base/common/assert*/,10/*vs/base/common/types*/]), function (require, exports, Assert, Types) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$xo = void 0;
    Assert = __importStar(Assert);
    Types = __importStar(Types);
    class RegistryImpl {
        constructor() {
            this.a = new Map();
        }
        add(id, data) {
            Assert.ok(Types.$jg(id));
            Assert.ok(Types.$lg(data));
            Assert.ok(!this.a.has(id), 'There is already an extension with this id');
            this.a.set(id, data);
        }
        knows(id) {
            return this.a.has(id);
        }
        as(id) {
            return this.a.get(id) || null;
        }
    }
    exports.$xo = new RegistryImpl();
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[23/*vs/platform/terminal/common/capabilities/capabilities*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.CommandInvalidationReason = exports.TerminalCapability = void 0;
    /**
     * Primarily driven by the shell integration feature, a terminal capability is the mechanism for
     * progressively enhancing various features that may not be supported in all terminals/shells.
     */
    var TerminalCapability;
    (function (TerminalCapability) {
        /**
         * The terminal can reliably detect the current working directory as soon as the change happens
         * within the buffer.
         */
        TerminalCapability[TerminalCapability["CwdDetection"] = 0] = "CwdDetection";
        /**
         * The terminal can reliably detect the current working directory when requested.
         */
        TerminalCapability[TerminalCapability["NaiveCwdDetection"] = 1] = "NaiveCwdDetection";
        /**
         * The terminal can reliably identify prompts, commands and command outputs within the buffer.
         */
        TerminalCapability[TerminalCapability["CommandDetection"] = 2] = "CommandDetection";
        /**
         * The terminal can often identify prompts, commands and command outputs within the buffer. It
         * may not be so good at remembering the position of commands that ran in the past. This state
         * may be enabled when something goes wrong or when using conpty for example.
         */
        TerminalCapability[TerminalCapability["PartialCommandDetection"] = 3] = "PartialCommandDetection";
        /**
         * Manages buffer marks that can be used for terminal navigation. The source of
         * the request (task, debug, etc) provides an ID, optional marker, hoverMessage, and hidden property. When
         * hidden is not provided, a generic decoration is added to the buffer and overview ruler.
         */
        TerminalCapability[TerminalCapability["BufferMarkDetection"] = 4] = "BufferMarkDetection";
    })(TerminalCapability || (exports.TerminalCapability = TerminalCapability = {}));
    var CommandInvalidationReason;
    (function (CommandInvalidationReason) {
        CommandInvalidationReason["Windows"] = "windows";
        CommandInvalidationReason["NoProblemsReported"] = "noProblemsReported";
    })(CommandInvalidationReason || (exports.CommandInvalidationReason = CommandInvalidationReason = {}));
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[82/*vs/platform/terminal/common/capabilities/bufferMarkCapability*/], __M([0/*require*/,1/*exports*/,4/*vs/base/common/event*/,2/*vs/base/common/lifecycle*/,23/*vs/platform/terminal/common/capabilities/capabilities*/]), function (require, exports, event_1, lifecycle_1, capabilities_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$czb = void 0;
    /**
     * Manages "marks" in the buffer which are lines that are tracked when lines are added to or removed
     * from the buffer.
     */
    class $czb extends lifecycle_1.$Zc {
        constructor(f) {
            super();
            this.f = f;
            this.type = capabilities_1.TerminalCapability.BufferMarkDetection;
            this.a = new Map();
            this.b = new Map();
            this.c = this.B(new event_1.$qe());
            this.onMarkAdded = this.c.event;
        }
        *markers() {
            for (const m of this.a.values()) {
                yield m;
            }
            for (const m of this.b.values()) {
                yield m;
            }
        }
        addMark(properties) {
            const marker = properties?.marker || this.f.registerMarker();
            const id = properties?.id;
            if (!marker) {
                return;
            }
            if (id) {
                this.a.set(id, marker);
                marker.onDispose(() => this.a.delete(id));
            }
            else {
                this.b.set(marker.id, marker);
                marker.onDispose(() => this.b.delete(marker.id));
            }
            this.c.fire({ marker, id, hidden: properties?.hidden, hoverMessage: properties?.hoverMessage });
        }
        getMark(id) {
            return this.a.get(id);
        }
    }
    exports.$czb = $czb;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/






var __param = (this && this.__param) || function (paramIndex, decorator) {
    return function (target, key) { decorator(target, key, paramIndex); }
};
define(__m[83/*vs/platform/terminal/common/capabilities/commandDetection/promptInputModel*/], __M([0/*require*/,1/*exports*/,4/*vs/base/common/event*/,2/*vs/base/common/lifecycle*/,9/*vs/platform/log/common/log*/,14/*vs/base/common/decorators*/]), function (require, exports, event_1, lifecycle_1, log_1, decorators_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$ss = void 0;
    var PromptInputState;
    (function (PromptInputState) {
        PromptInputState[PromptInputState["Unknown"] = 0] = "Unknown";
        PromptInputState[PromptInputState["Input"] = 1] = "Input";
        PromptInputState[PromptInputState["Execute"] = 2] = "Execute";
    })(PromptInputState || (PromptInputState = {}));
    let $ss = class $ss extends lifecycle_1.$Zc {
        get value() { return this.j; }
        get prefix() { return this.j.substring(0, this.m); }
        get suffix() { return this.j.substring(this.m, this.n === -1 ? undefined : this.n); }
        get cursorIndex() { return this.m; }
        get ghostTextIndex() { return this.n; }
        constructor(w, onCommandStart, onCommandExecuted, z) {
            super();
            this.w = w;
            this.z = z;
            this.a = PromptInputState.Unknown;
            this.c = 0;
            this.h = '';
            this.j = '';
            this.m = 0;
            this.n = -1;
            this.r = this.B(new event_1.$qe());
            this.onDidStartInput = this.r.event;
            this.s = this.B(new event_1.$qe());
            this.onDidChangeInput = this.s.event;
            this.t = this.B(new event_1.$qe());
            this.onDidFinishInput = this.t.event;
            this.u = this.B(new event_1.$qe());
            this.onDidInterrupt = this.u.event;
            this.B(event_1.Event.any(this.w.onCursorMove, this.w.onData, this.w.onWriteParsed)(() => this.G()));
            this.B(this.w.onData(e => this.I(e)));
            this.B(onCommandStart(e => this.D(e)));
            this.B(onCommandExecuted(() => this.F()));
            this.B(this.onDidStartInput(() => this.C('PromptInputModel#onDidStartInput')));
            this.B(this.onDidChangeInput(() => this.C('PromptInputModel#onDidChangeInput')));
            this.B(this.onDidFinishInput(() => this.C('PromptInputModel#onDidFinishInput')));
            this.B(this.onDidInterrupt(() => this.C('PromptInputModel#onDidInterrupt')));
        }
        C(message) {
            // Only generate the combined string if trace
            if (this.z.getLevel() === log_1.LogLevel.Trace) {
                this.z.trace(message, this.getCombinedString());
            }
        }
        setContinuationPrompt(value) {
            this.g = value;
            this.G();
        }
        setLastPromptLine(value) {
            this.f = value;
            this.G();
        }
        setConfidentCommandLine(value) {
            if (this.j !== value) {
                this.j = value;
                this.m = -1;
                this.n = -1;
                this.s.fire(this.Q());
            }
        }
        getCombinedString() {
            const value = this.j.replaceAll('\n', '\u23CE');
            if (this.m === -1) {
                return value;
            }
            let result = `${value.substring(0, this.cursorIndex)}|`;
            if (this.ghostTextIndex !== -1) {
                result += `${value.substring(this.cursorIndex, this.ghostTextIndex)}[`;
                result += `${value.substring(this.ghostTextIndex)}]`;
            }
            else {
                result += value.substring(this.cursorIndex);
            }
            return result;
        }
        serialize() {
            return {
                modelState: this.Q(),
                commandStartX: this.c,
                lastPromptLine: this.f,
                continuationPrompt: this.g,
                lastUserInput: this.h
            };
        }
        deserialize(serialized) {
            this.j = serialized.modelState.value;
            this.m = serialized.modelState.cursorIndex;
            this.n = serialized.modelState.ghostTextIndex;
            this.c = serialized.commandStartX;
            this.f = serialized.lastPromptLine;
            this.g = serialized.continuationPrompt;
            this.h = serialized.lastUserInput;
        }
        D(command) {
            if (this.a === PromptInputState.Input) {
                return;
            }
            this.a = PromptInputState.Input;
            this.b = command.marker;
            this.c = this.w.buffer.active.cursorX;
            this.j = '';
            this.m = 0;
            this.r.fire(this.Q());
            this.s.fire(this.Q());
            // Trigger a sync if prompt terminator is set as that could adjust the command start X
            if (this.f) {
                if (this.c !== this.f.length) {
                    const line = this.w.buffer.active.getLine(this.b.line);
                    if (line?.translateToString(true).startsWith(this.f)) {
                        this.c = this.f.length;
                        this.G();
                    }
                }
            }
        }
        F() {
            if (this.a === PromptInputState.Execute) {
                return;
            }
            this.m = -1;
            // Remove any ghost text from the input if it exists on execute
            if (this.n !== -1) {
                this.j = this.j.substring(0, this.n);
                this.n = -1;
            }
            const event = this.Q();
            if (this.h === '\u0003') {
                this.h = '';
                this.u.fire(event);
            }
            this.a = PromptInputState.Execute;
            this.t.fire(event);
            this.s.fire(event);
        }
        G() {
            try {
                this.H();
            }
            catch (e) {
                this.z.error('Error while syncing prompt input model', e);
            }
        }
        H() {
            if (this.a !== PromptInputState.Input) {
                return;
            }
            const commandStartY = this.b?.line;
            if (commandStartY === undefined) {
                return;
            }
            const buffer = this.w.buffer.active;
            let line = buffer.getLine(commandStartY);
            const commandLine = line?.translateToString(true, this.c);
            if (!line || commandLine === undefined) {
                this.z.trace(`PromptInputModel#_sync: no line`);
                return;
            }
            const absoluteCursorY = buffer.baseY + buffer.cursorY;
            let value = commandLine;
            let ghostTextIndex = -1;
            let cursorIndex;
            if (absoluteCursorY === commandStartY) {
                cursorIndex = this.O(this.c, buffer, line);
            }
            else {
                cursorIndex = commandLine.trimEnd().length;
            }
            // Detect ghost text by looking for italic or dim text in or after the cursor and
            // non-italic/dim text in the cell closest non-whitespace cell before the cursor
            if (absoluteCursorY === commandStartY && buffer.cursorX > 1) {
                // Ghost text in pwsh only appears to happen on the cursor line
                ghostTextIndex = this.J(buffer, line, cursorIndex);
            }
            // From command start line to cursor line
            for (let y = commandStartY + 1; y <= absoluteCursorY; y++) {
                line = buffer.getLine(y);
                const lineText = line?.translateToString(true);
                if (lineText && line) {
                    // Check if the line wrapped without a new line (continuation)
                    if (line.isWrapped) {
                        value += lineText;
                        const relativeCursorIndex = this.O(0, buffer, line);
                        if (absoluteCursorY === y) {
                            cursorIndex += relativeCursorIndex;
                        }
                        else {
                            cursorIndex += lineText.length;
                        }
                    }
                    // Verify continuation prompt if we have it, if this line doesn't have it then the
                    // user likely just pressed enter.
                    else if (this.g === undefined || this.M(lineText)) {
                        const trimmedLineText = this.L(lineText);
                        value += `\n${trimmedLineText}`;
                        if (absoluteCursorY === y) {
                            const continuationCellWidth = this.N(line, lineText);
                            const relativeCursorIndex = this.O(continuationCellWidth, buffer, line);
                            cursorIndex += relativeCursorIndex + 1;
                        }
                        else {
                            cursorIndex += trimmedLineText.length + 1;
                        }
                    }
                    else {
                        break;
                    }
                }
            }
            // Below cursor line
            for (let y = absoluteCursorY + 1; y < buffer.baseY + this.w.rows; y++) {
                line = buffer.getLine(y);
                const lineText = line?.translateToString(true);
                if (lineText && line) {
                    if (this.g === undefined || this.M(lineText)) {
                        value += `\n${this.L(lineText)}`;
                    }
                    else {
                        break;
                    }
                }
                else {
                    break;
                }
            }
            if (this.z.getLevel() === log_1.LogLevel.Trace) {
                this.z.trace(`PromptInputModel#_sync: ${this.getCombinedString()}`);
            }
            // Adjust trailing whitespace
            {
                let trailingWhitespace = this.j.length - this.j.trimEnd().length;
                // Handle backspace key
                if (this.h === '\x7F') {
                    this.h = '';
                    if (cursorIndex === this.m - 1) {
                        // If trailing whitespace is being increased by removing a non-whitespace character
                        if (this.j.trimEnd().length > value.trimEnd().length && value.trimEnd().length <= cursorIndex) {
                            trailingWhitespace = Math.max((this.j.length - 1) - value.trimEnd().length, 0);
                        }
                        // Standard case; subtract from trailing whitespace
                        else {
                            trailingWhitespace = Math.max(trailingWhitespace - 1, 0);
                        }
                    }
                }
                // Handle delete key
                if (this.h === '\x1b[3~') {
                    this.h = '';
                    if (cursorIndex === this.m) {
                        trailingWhitespace = Math.max(trailingWhitespace - 1, 0);
                    }
                }
                const valueLines = value.split('\n');
                const isMultiLine = valueLines.length > 1;
                const valueEndTrimmed = value.trimEnd();
                if (!isMultiLine) {
                    // Adjust trimmed whitespace value based on cursor position
                    if (valueEndTrimmed.length < value.length) {
                        // Handle space key
                        if (this.h === ' ') {
                            this.h = '';
                            if (cursorIndex > valueEndTrimmed.length && cursorIndex > this.m) {
                                trailingWhitespace++;
                            }
                        }
                        trailingWhitespace = Math.max(cursorIndex - valueEndTrimmed.length, trailingWhitespace, 0);
                    }
                    // Handle case where a non-space character is inserted in the middle of trailing whitespace
                    const charBeforeCursor = cursorIndex === 0 ? '' : value[cursorIndex - 1];
                    if (trailingWhitespace > 0 && cursorIndex === this.m + 1 && this.h !== '' && charBeforeCursor !== ' ') {
                        trailingWhitespace = this.j.length - this.m;
                    }
                }
                if (isMultiLine) {
                    valueLines[valueLines.length - 1] = valueLines.at(-1)?.trimEnd() ?? '';
                    const continuationOffset = (valueLines.length - 1) * (this.g?.length ?? 0);
                    trailingWhitespace = Math.max(0, cursorIndex - value.length - continuationOffset);
                }
                value = valueLines.map(e => e.trimEnd()).join('\n') + ' '.repeat(trailingWhitespace);
            }
            if (this.j !== value || this.m !== cursorIndex || this.n !== ghostTextIndex) {
                this.j = value;
                this.m = cursorIndex;
                this.n = ghostTextIndex;
                this.s.fire(this.Q());
            }
        }
        I(e) {
            this.h = e;
        }
        /**
         * Detect ghost text by looking for italic or dim text in or after the cursor and
         * non-italic/dim text in the cell closest non-whitespace cell before the cursor.
         */
        J(buffer, line, cursorIndex) {
            // Check last non-whitespace character has non-ghost text styles
            let ghostTextIndex = -1;
            let proceedWithGhostTextCheck = false;
            let x = buffer.cursorX;
            while (x > 0) {
                const cell = line.getCell(--x);
                if (!cell) {
                    break;
                }
                if (cell.getChars().trim().length > 0) {
                    proceedWithGhostTextCheck = !this.P(cell);
                    break;
                }
            }
            // Check to the end of the line for possible ghost text. For example pwsh's ghost text
            // can look like this `Get-|Ch[ildItem]`
            if (proceedWithGhostTextCheck) {
                let potentialGhostIndexOffset = 0;
                let x = buffer.cursorX;
                while (x < line.length) {
                    const cell = line.getCell(x++);
                    if (!cell || cell.getCode() === 0) {
                        break;
                    }
                    if (this.P(cell)) {
                        ghostTextIndex = cursorIndex + potentialGhostIndexOffset;
                        break;
                    }
                    potentialGhostIndexOffset += cell.getChars().length;
                }
            }
            return ghostTextIndex;
        }
        L(lineText) {
            if (this.M(lineText)) {
                lineText = lineText.substring(this.g.length);
            }
            return lineText;
        }
        M(lineText) {
            return !!(this.g && lineText.startsWith(this.g));
        }
        N(line, lineText) {
            if (!this.g || !lineText.startsWith(this.g)) {
                return 0;
            }
            let buffer = '';
            let x = 0;
            while (buffer !== this.g) {
                buffer += line.getCell(x++).getChars();
            }
            return x;
        }
        O(startCellX, buffer, line) {
            return line?.translateToString(true, startCellX, buffer.cursorX).length ?? 0;
        }
        P(cell) {
            return !!(cell.isItalic() || cell.isDim());
        }
        Q() {
            return Object.freeze({
                value: this.j,
                prefix: this.prefix,
                suffix: this.suffix,
                cursorIndex: this.m,
                ghostTextIndex: this.n
            });
        }
    };
    exports.$ss = $ss;
    __decorate([
        (0, decorators_1.$ei)(0)
    ], $ss.prototype, "G", null);
    exports.$ss = $ss = __decorate([
        __param(3, log_1.$fk)
    ], $ss);
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[84/*vs/platform/terminal/common/capabilities/commandDetection/terminalCommand*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$us = exports.$ts = void 0;
    class $ts {
        get command() { return this.b.command; }
        get commandLineConfidence() { return this.b.commandLineConfidence; }
        get isTrusted() { return this.b.isTrusted; }
        get timestamp() { return this.b.timestamp; }
        get duration() { return this.b.duration; }
        get promptStartMarker() { return this.b.promptStartMarker; }
        get marker() { return this.b.marker; }
        get endMarker() { return this.b.endMarker; }
        set endMarker(value) { this.b.endMarker = value; }
        get executedMarker() { return this.b.executedMarker; }
        get aliases() { return this.b.aliases; }
        get wasReplayed() { return this.b.wasReplayed; }
        get cwd() { return this.b.cwd; }
        get exitCode() { return this.b.exitCode; }
        get commandStartLineContent() { return this.b.commandStartLineContent; }
        get markProperties() { return this.b.markProperties; }
        get executedX() { return this.b.executedX; }
        get startX() { return this.b.startX; }
        constructor(a, b) {
            this.a = a;
            this.b = b;
        }
        static deserialize(xterm, serialized, isCommandStorageDisabled) {
            const buffer = xterm.buffer.normal;
            const marker = serialized.startLine !== undefined ? xterm.registerMarker(serialized.startLine - (buffer.baseY + buffer.cursorY)) : undefined;
            // Check for invalid command
            if (!marker) {
                return undefined;
            }
            const promptStartMarker = serialized.promptStartLine !== undefined ? xterm.registerMarker(serialized.promptStartLine - (buffer.baseY + buffer.cursorY)) : undefined;
            // Valid full command
            const endMarker = serialized.endLine !== undefined ? xterm.registerMarker(serialized.endLine - (buffer.baseY + buffer.cursorY)) : undefined;
            const executedMarker = serialized.executedLine !== undefined ? xterm.registerMarker(serialized.executedLine - (buffer.baseY + buffer.cursorY)) : undefined;
            const newCommand = new $ts(xterm, {
                command: isCommandStorageDisabled ? '' : serialized.command,
                commandLineConfidence: serialized.commandLineConfidence ?? 'low',
                isTrusted: serialized.isTrusted,
                promptStartMarker,
                marker,
                startX: serialized.startX,
                endMarker,
                executedMarker,
                executedX: serialized.executedX,
                timestamp: serialized.timestamp,
                duration: serialized.duration,
                cwd: serialized.cwd,
                commandStartLineContent: serialized.commandStartLineContent,
                exitCode: serialized.exitCode,
                markProperties: serialized.markProperties,
                aliases: undefined,
                wasReplayed: true
            });
            return newCommand;
        }
        serialize(isCommandStorageDisabled) {
            return {
                promptStartLine: this.promptStartMarker?.line,
                startLine: this.marker?.line,
                startX: undefined,
                endLine: this.endMarker?.line,
                executedLine: this.executedMarker?.line,
                executedX: this.executedX,
                command: isCommandStorageDisabled ? '' : this.command,
                commandLineConfidence: isCommandStorageDisabled ? 'low' : this.commandLineConfidence,
                isTrusted: this.isTrusted,
                cwd: this.cwd,
                exitCode: this.exitCode,
                commandStartLineContent: this.commandStartLineContent,
                timestamp: this.timestamp,
                duration: this.duration,
                markProperties: this.markProperties,
            };
        }
        extractCommandLine() {
            return extractCommandLine(this.a.buffer.active, this.a.cols, this.marker, this.startX, this.executedMarker, this.executedX);
        }
        getOutput() {
            if (!this.executedMarker || !this.endMarker) {
                return undefined;
            }
            const startLine = this.executedMarker.line;
            const endLine = this.endMarker.line;
            if (startLine === endLine) {
                return undefined;
            }
            let output = '';
            let line;
            for (let i = startLine; i < endLine; i++) {
                line = this.a.buffer.active.getLine(i);
                if (!line) {
                    continue;
                }
                output += line.translateToString(!line.isWrapped) + (line.isWrapped ? '' : '\n');
            }
            return output === '' ? undefined : output;
        }
        getOutputMatch(outputMatcher) {
            // TODO: Add back this check? this._ptyHeuristics.value instanceof WindowsPtyHeuristics && (executedMarker?.line === endMarker?.line) ? this._currentCommand.commandStartMarker : executedMarker
            if (!this.executedMarker || !this.endMarker) {
                return undefined;
            }
            const endLine = this.endMarker.line;
            if (endLine === -1) {
                return undefined;
            }
            const buffer = this.a.buffer.active;
            const startLine = Math.max(this.executedMarker.line, 0);
            const matcher = outputMatcher.lineMatcher;
            const linesToCheck = typeof matcher === 'string' ? 1 : outputMatcher.length || countNewLines(matcher);
            const lines = [];
            let match;
            if (outputMatcher.anchor === 'bottom') {
                for (let i = endLine - (outputMatcher.offset || 0); i >= startLine; i--) {
                    let wrappedLineStart = i;
                    const wrappedLineEnd = i;
                    while (wrappedLineStart >= startLine && buffer.getLine(wrappedLineStart)?.isWrapped) {
                        wrappedLineStart--;
                    }
                    i = wrappedLineStart;
                    lines.unshift(getXtermLineContent(buffer, wrappedLineStart, wrappedLineEnd, this.a.cols));
                    if (!match) {
                        match = lines[0].match(matcher);
                    }
                    if (lines.length >= linesToCheck) {
                        break;
                    }
                }
            }
            else {
                for (let i = startLine + (outputMatcher.offset || 0); i < endLine; i++) {
                    const wrappedLineStart = i;
                    let wrappedLineEnd = i;
                    while (wrappedLineEnd + 1 < endLine && buffer.getLine(wrappedLineEnd + 1)?.isWrapped) {
                        wrappedLineEnd++;
                    }
                    i = wrappedLineEnd;
                    lines.push(getXtermLineContent(buffer, wrappedLineStart, wrappedLineEnd, this.a.cols));
                    if (!match) {
                        match = lines[lines.length - 1].match(matcher);
                    }
                    if (lines.length >= linesToCheck) {
                        break;
                    }
                }
            }
            return match ? { regexMatch: match, outputLines: lines } : undefined;
        }
        hasOutput() {
            return (!this.executedMarker?.isDisposed &&
                !this.endMarker?.isDisposed &&
                !!(this.executedMarker &&
                    this.endMarker &&
                    this.executedMarker.line < this.endMarker.line));
        }
        getPromptRowCount() {
            return getPromptRowCount(this, this.a.buffer.active);
        }
        getCommandRowCount() {
            return getCommandRowCount(this);
        }
    }
    exports.$ts = $ts;
    class $us {
        constructor(c) {
            this.c = c;
        }
        serialize(cwd) {
            if (!this.commandStartMarker) {
                return undefined;
            }
            return {
                promptStartLine: this.promptStartMarker?.line,
                startLine: this.commandStartMarker.line,
                startX: this.commandStartX,
                endLine: undefined,
                executedLine: undefined,
                executedX: undefined,
                command: '',
                commandLineConfidence: 'low',
                isTrusted: true,
                cwd,
                exitCode: undefined,
                commandStartLineContent: undefined,
                timestamp: 0,
                duration: 0,
                markProperties: undefined
            };
        }
        promoteToFullCommand(cwd, exitCode, ignoreCommandLine, markProperties) {
            // When the command finishes and executed never fires the placeholder selector should be used.
            if (exitCode === undefined && this.command === undefined) {
                this.command = '';
            }
            if ((this.command !== undefined && !this.command.startsWith('\\')) || ignoreCommandLine) {
                return new $ts(this.c, {
                    command: ignoreCommandLine ? '' : (this.command || ''),
                    commandLineConfidence: ignoreCommandLine ? 'low' : (this.commandLineConfidence || 'low'),
                    isTrusted: !!this.isTrusted,
                    promptStartMarker: this.promptStartMarker,
                    marker: this.commandStartMarker,
                    startX: this.commandStartX,
                    endMarker: this.commandFinishedMarker,
                    executedMarker: this.commandExecutedMarker,
                    executedX: this.commandExecutedX,
                    timestamp: Date.now(),
                    duration: this.b || 0,
                    cwd,
                    exitCode,
                    commandStartLineContent: this.commandStartLineContent,
                    markProperties
                });
            }
            return undefined;
        }
        markExecutedTime() {
            if (this.a === undefined) {
                this.a = Date.now();
            }
        }
        markFinishedTime() {
            if (this.b === undefined && this.a !== undefined) {
                this.b = Date.now() - this.a;
            }
        }
        extractCommandLine() {
            return extractCommandLine(this.c.buffer.active, this.c.cols, this.commandStartMarker, this.commandStartX, this.commandExecutedMarker, this.commandExecutedX);
        }
        getPromptRowCount() {
            return getPromptRowCount(this, this.c.buffer.active);
        }
        getCommandRowCount() {
            return getCommandRowCount(this);
        }
    }
    exports.$us = $us;
    function extractCommandLine(buffer, cols, commandStartMarker, commandStartX, commandExecutedMarker, commandExecutedX) {
        if (!commandStartMarker || !commandExecutedMarker || commandStartX === undefined || commandExecutedX === undefined) {
            return '';
        }
        let content = '';
        for (let i = commandStartMarker.line; i <= commandExecutedMarker.line; i++) {
            const line = buffer.getLine(i);
            if (line) {
                content += line.translateToString(true, i === commandStartMarker.line ? commandStartX : 0, i === commandExecutedMarker.line ? commandExecutedX : cols);
            }
        }
        return content;
    }
    function getXtermLineContent(buffer, lineStart, lineEnd, cols) {
        // Cap the maximum number of lines generated to prevent potential performance problems. This is
        // more of a sanity check as the wrapped line should already be trimmed down at this point.
        const maxLineLength = Math.max(2048 / cols * 2);
        lineEnd = Math.min(lineEnd, lineStart + maxLineLength);
        let content = '';
        for (let i = lineStart; i <= lineEnd; i++) {
            // Make sure only 0 to cols are considered as resizing when windows mode is enabled will
            // retain buffer data outside of the terminal width as reflow is disabled.
            const line = buffer.getLine(i);
            if (line) {
                content += line.translateToString(true, 0, cols);
            }
        }
        return content;
    }
    function countNewLines(regex) {
        if (!regex.multiline) {
            return 1;
        }
        const source = regex.source;
        let count = 1;
        let i = source.indexOf('\\n');
        while (i !== -1) {
            count++;
            i = source.indexOf('\\n', i + 1);
        }
        return count;
    }
    function getPromptRowCount(command, buffer) {
        const marker = 'hasOutput' in command ? command.marker : command.commandStartMarker;
        if (!marker || !command.promptStartMarker) {
            return 1;
        }
        let promptRowCount = 1;
        let promptStartLine = command.promptStartMarker.line;
        // Trim any leading whitespace-only lines to retain vertical space
        while (promptStartLine < marker.line && (buffer.getLine(promptStartLine)?.translateToString(true) ?? '').length === 0) {
            promptStartLine++;
        }
        promptRowCount = marker.line - promptStartLine + 1;
        return promptRowCount;
    }
    function getCommandRowCount(command) {
        const marker = 'hasOutput' in command ? command.marker : command.commandStartMarker;
        const executedMarker = 'hasOutput' in command ? command.executedMarker : command.commandExecutedMarker;
        if (!marker || !executedMarker) {
            return 1;
        }
        const commandExecutedLine = Math.max(executedMarker.line, marker.line);
        let commandRowCount = commandExecutedLine - marker.line + 1;
        // Trim the last line if the cursor X is in the left-most cell
        const executedX = 'hasOutput' in command ? command.executedX : command.commandExecutedX;
        if (executedX === 0) {
            commandRowCount--;
        }
        return commandRowCount;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/









define(__m[85/*vs/platform/terminal/common/capabilities/commandDetectionCapability*/], __M([0/*require*/,1/*exports*/,12/*vs/base/common/async*/,14/*vs/base/common/decorators*/,4/*vs/base/common/event*/,2/*vs/base/common/lifecycle*/,9/*vs/platform/log/common/log*/,23/*vs/platform/terminal/common/capabilities/capabilities*/,84/*vs/platform/terminal/common/capabilities/commandDetection/terminalCommand*/,83/*vs/platform/terminal/common/capabilities/commandDetection/promptInputModel*/]), function (require, exports, async_1, decorators_1, event_1, lifecycle_1, log_1, capabilities_1, terminalCommand_1, promptInputModel_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$$yb = void 0;
    exports.$_yb = $_yb;
    let $$yb = class $$yb extends lifecycle_1.$Zc {
        get promptInputModel() { return this.c; }
        get commands() { return this.f; }
        get executingCommand() { return this.n.command; }
        // TODO: as is unsafe here and it duplicates behavor of executingCommand
        get executingCommandObject() {
            if (this.n.commandStartMarker) {
                return { marker: this.n.commandStartMarker };
            }
            return undefined;
        }
        get currentCommand() {
            return this.n;
        }
        get cwd() { return this.g; }
        get promptTerminator() { return this.h; }
        constructor(L, M) {
            super();
            this.L = L;
            this.M = M;
            this.type = capabilities_1.TerminalCapability.CommandDetection;
            this.f = [];
            this.n = new terminalCommand_1.$us(this.L);
            this.r = [];
            this.t = false;
            this.D = this.B(new event_1.$qe());
            this.onCommandStarted = this.D.event;
            this.F = this.B(new event_1.$qe());
            this.onBeforeCommandFinished = this.F.event;
            this.G = this.B(new event_1.$qe());
            this.onCommandFinished = this.G.event;
            this.H = this.B(new event_1.$qe());
            this.onCommandExecuted = this.H.event;
            this.I = this.B(new event_1.$qe());
            this.onCommandInvalidated = this.I.event;
            this.J = this.B(new event_1.$qe());
            this.onCurrentCommandInvalidated = this.J.event;
            this.c = this.B(new promptInputModel_1.$ss(this.L, this.onCommandStarted, this.onCommandExecuted, this.M));
            // Pull command line from the buffer if it was not set explicitly
            this.B(this.onCommandExecuted(command => {
                if (command.commandLineConfidence !== 'high') {
                    // HACK: onCommandExecuted actually fired with PartialTerminalCommand
                    const typedCommand = command;
                    command.command = typedCommand.extractCommandLine();
                    command.commandLineConfidence = 'low';
                    // ITerminalCommand
                    if ('getOutput' in typedCommand) {
                        if (
                        // Markers exist
                        typedCommand.promptStartMarker && typedCommand.marker && typedCommand.executedMarker &&
                            // Single line command
                            command.command.indexOf('\n') === -1 &&
                            // Start marker is not on the left-most column
                            typedCommand.startX !== undefined && typedCommand.startX > 0) {
                            command.commandLineConfidence = 'medium';
                        }
                    }
                    // PartialTerminalCommand
                    else {
                        if (
                        // Markers exist
                        typedCommand.promptStartMarker && typedCommand.commandStartMarker && typedCommand.commandExecutedMarker &&
                            // Single line command
                            command.command.indexOf('\n') === -1 &&
                            // Start marker is not on the left-most column
                            typedCommand.commandStartX !== undefined && typedCommand.commandStartX > 0) {
                            command.commandLineConfidence = 'medium';
                        }
                    }
                }
            }));
            // Set up platform-specific behaviors
            const that = this;
            this.z = new class {
                get onCurrentCommandInvalidatedEmitter() { return that.J; }
                get onCommandStartedEmitter() { return that.D; }
                get onCommandExecutedEmitter() { return that.H; }
                get dimensions() { return that.s; }
                get isCommandStorageDisabled() { return that.t; }
                get commandMarkers() { return that.r; }
                set commandMarkers(value) { that.r = value; }
                get clearCommandsInViewport() { return that.P.bind(that); }
                commitCommandFinished() {
                    that.w?.flush();
                    that.w = undefined;
                }
            };
            this.C = this.B(new lifecycle_1.$2c(new UnixPtyHeuristics(this.L, this, this.z, this.M)));
            this.s = {
                cols: this.L.cols,
                rows: this.L.rows
            };
            this.B(this.L.onResize(e => this.N(e)));
            this.B(this.L.onCursorMove(() => this.O()));
        }
        N(e) {
            this.C.value.preHandleResize?.(e);
            this.s.cols = e.cols;
            this.s.rows = e.rows;
        }
        O() {
            if (this.q.isDisposed) {
                return;
            }
            // Early versions of conpty do not have real support for an alt buffer, in addition certain
            // commands such as tsc watch will write to the top of the normal buffer. The following
            // checks when the cursor has moved while the normal buffer is empty and if it is above the
            // current command, all decorations within the viewport will be invalidated.
            //
            // This function is debounced so that the cursor is only checked when it is stable so
            // conpty's screen reprinting will not trigger decoration clearing.
            //
            // This is mostly a workaround for Windows but applies to all OS' because of the tsc watch
            // case.
            if (this.L.buffer.active === this.L.buffer.normal && this.n.commandStartMarker) {
                if (this.L.buffer.active.baseY + this.L.buffer.active.cursorY < this.n.commandStartMarker.line) {
                    this.P();
                    this.n.isInvalid = true;
                    this.J.fire({ reason: capabilities_1.CommandInvalidationReason.Windows });
                }
            }
        }
        P() {
            // Find the number of commands on the tail end of the array that are within the viewport
            let count = 0;
            for (let i = this.f.length - 1; i >= 0; i--) {
                const line = this.f[i].marker?.line;
                if (line && line < this.L.buffer.active.baseY) {
                    break;
                }
                count++;
            }
            // Remove them
            if (count > 0) {
                this.I.fire(this.f.splice(this.f.length - count, count));
            }
        }
        setContinuationPrompt(value) {
            this.c.setContinuationPrompt(value);
        }
        // TODO: Simplify this, can everything work off the last line?
        setPromptTerminator(promptTerminator, lastPromptLine) {
            this.M.debug('CommandDetectionCapability#setPromptTerminator', promptTerminator);
            this.h = promptTerminator;
            this.c.setLastPromptLine(lastPromptLine);
        }
        setCwd(value) {
            this.g = value;
        }
        setIsWindowsPty(value) {
            if (value && !(this.C.value instanceof WindowsPtyHeuristics)) {
                const that = this;
                this.C.value = new WindowsPtyHeuristics(this.L, this, new class {
                    get onCurrentCommandInvalidatedEmitter() { return that.J; }
                    get onCommandStartedEmitter() { return that.D; }
                    get onCommandExecutedEmitter() { return that.H; }
                    get dimensions() { return that.s; }
                    get isCommandStorageDisabled() { return that.t; }
                    get commandMarkers() { return that.r; }
                    set commandMarkers(value) { that.r = value; }
                    get clearCommandsInViewport() { return that.P.bind(that); }
                    commitCommandFinished() {
                        that.w?.flush();
                        that.w = undefined;
                    }
                }, this.M);
            }
            else if (!value && !(this.C.value instanceof UnixPtyHeuristics)) {
                this.C.value = new UnixPtyHeuristics(this.L, this, this.z, this.M);
            }
        }
        setIsCommandStorageDisabled() {
            this.t = true;
        }
        getCommandForLine(line) {
            // Handle the current partial command first, anything below it's prompt is considered part
            // of the current command
            if (this.n.promptStartMarker && line >= this.n.promptStartMarker?.line) {
                return this.n;
            }
            // No commands
            if (this.f.length === 0) {
                return undefined;
            }
            // Line is before any registered commands
            if ((this.f[0].promptStartMarker ?? this.f[0].marker).line > line) {
                return undefined;
            }
            // Iterate backwards through commands to find the right one
            for (let i = this.commands.length - 1; i >= 0; i--) {
                if ((this.commands[i].promptStartMarker ?? this.commands[i].marker).line <= line) {
                    return this.commands[i];
                }
            }
            return undefined;
        }
        getCwdForLine(line) {
            // Handle the current partial command first, anything below it's prompt is considered part
            // of the current command
            if (this.n.promptStartMarker && line >= this.n.promptStartMarker?.line) {
                return this.g;
            }
            const command = this.getCommandForLine(line);
            if (command && 'cwd' in command) {
                return command.cwd;
            }
            return undefined;
        }
        handlePromptStart(options) {
            // Adjust the last command's finished marker when needed. The standard position for the
            // finished marker `D` to appear is at the same position as the following prompt started
            // `A`.
            const lastCommand = this.commands.at(-1);
            if (lastCommand?.endMarker && lastCommand?.executedMarker && lastCommand.endMarker.line === lastCommand.executedMarker.line) {
                this.M.debug('CommandDetectionCapability#handlePromptStart adjusted commandFinished', `${lastCommand.endMarker.line} -> ${lastCommand.executedMarker.line + 1}`);
                lastCommand.endMarker = cloneMarker(this.L, lastCommand.executedMarker, 1);
            }
            this.n.promptStartMarker = options?.marker || (lastCommand?.endMarker ? cloneMarker(this.L, lastCommand.endMarker) : this.L.registerMarker(0));
            this.M.debug('CommandDetectionCapability#handlePromptStart', this.L.buffer.active.cursorX, this.n.promptStartMarker?.line);
        }
        handleContinuationStart() {
            this.n.currentContinuationMarker = this.L.registerMarker(0);
            this.M.debug('CommandDetectionCapability#handleContinuationStart', this.n.currentContinuationMarker);
        }
        handleContinuationEnd() {
            if (!this.n.currentContinuationMarker) {
                this.M.warn('CommandDetectionCapability#handleContinuationEnd Received continuation end without start');
                return;
            }
            if (!this.n.continuations) {
                this.n.continuations = [];
            }
            this.n.continuations.push({
                marker: this.n.currentContinuationMarker,
                end: this.L.buffer.active.cursorX
            });
            this.n.currentContinuationMarker = undefined;
            this.M.debug('CommandDetectionCapability#handleContinuationEnd', this.n.continuations[this.n.continuations.length - 1]);
        }
        handleRightPromptStart() {
            this.n.commandRightPromptStartX = this.L.buffer.active.cursorX;
            this.M.debug('CommandDetectionCapability#handleRightPromptStart', this.n.commandRightPromptStartX);
        }
        handleRightPromptEnd() {
            this.n.commandRightPromptEndX = this.L.buffer.active.cursorX;
            this.M.debug('CommandDetectionCapability#handleRightPromptEnd', this.n.commandRightPromptEndX);
        }
        handleCommandStart(options) {
            this.u = options;
            this.n.cwd = this.g;
            // Only update the column if the line has already been set
            this.n.commandStartMarker = options?.marker || this.n.commandStartMarker;
            if (this.n.commandStartMarker?.line === this.L.buffer.active.cursorY) {
                this.n.commandStartX = this.L.buffer.active.cursorX;
                this.M.debug('CommandDetectionCapability#handleCommandStart', this.n.commandStartX, this.n.commandStartMarker?.line);
                return;
            }
            this.C.value.handleCommandStart(options);
        }
        handleGenericCommand(options) {
            if (options?.markProperties?.disableCommandStorage) {
                this.setIsCommandStorageDisabled();
            }
            this.handlePromptStart(options);
            this.handleCommandStart(options);
            this.handleCommandExecuted(options);
            this.handleCommandFinished(undefined, options);
        }
        handleCommandExecuted(options) {
            this.C.value.handleCommandExecuted(options);
            this.n.markExecutedTime();
        }
        handleCommandFinished(exitCode, options) {
            this.n.markFinishedTime();
            this.C.value.preHandleCommandFinished?.();
            this.M.debug('CommandDetectionCapability#handleCommandFinished', this.L.buffer.active.cursorX, options?.marker?.line, this.n.command, this.n);
            // HACK: Handle a special case on some versions of bash where identical commands get merged
            // in the output of `history`, this detects that case and sets the exit code to the the last
            // command's exit code. This covered the majority of cases but will fail if the same command
            // runs with a different exit code, that will need a more robust fix where we send the
            // command ID and exit code over to the capability to adjust there.
            if (exitCode === undefined) {
                const lastCommand = this.commands.length > 0 ? this.commands[this.commands.length - 1] : undefined;
                if (this.n.command && this.n.command.length > 0 && lastCommand?.command === this.n.command) {
                    exitCode = lastCommand.exitCode;
                }
            }
            if (this.n.commandStartMarker === undefined || !this.L.buffer.active) {
                return;
            }
            this.n.commandFinishedMarker = options?.marker || this.L.registerMarker(0);
            this.C.value.postHandleCommandFinished?.();
            const newCommand = this.n.promoteToFullCommand(this.g, exitCode, this.u?.ignoreCommandLine ?? false, options?.markProperties);
            if (newCommand) {
                this.f.push(newCommand);
                this.w = new async_1.$Wh(() => {
                    this.F.fire(newCommand);
                    if (!this.n.isInvalid) {
                        this.M.debug('CommandDetectionCapability#onCommandFinished', newCommand);
                        this.G.fire(newCommand);
                    }
                }, 50);
                this.w.schedule();
            }
            this.n = new terminalCommand_1.$us(this.L);
            this.u = undefined;
        }
        setCommandLine(commandLine, isTrusted) {
            this.M.debug('CommandDetectionCapability#setCommandLine', commandLine, isTrusted);
            this.n.command = commandLine;
            this.n.commandLineConfidence = 'high';
            this.n.isTrusted = isTrusted;
            if (isTrusted) {
                this.c.setConfidentCommandLine(commandLine);
            }
        }
        serialize() {
            const commands = this.commands.map(e => e.serialize(this.t));
            const partialCommand = this.n.serialize(this.g);
            if (partialCommand) {
                commands.push(partialCommand);
            }
            return {
                isWindowsPty: this.C.value instanceof WindowsPtyHeuristics,
                commands,
                promptInputModel: this.c.serialize(),
            };
        }
        deserialize(serialized) {
            if (serialized.isWindowsPty) {
                this.setIsWindowsPty(serialized.isWindowsPty);
            }
            const buffer = this.L.buffer.normal;
            for (const e of serialized.commands) {
                // Partial command
                if (!e.endLine) {
                    // Check for invalid command
                    const marker = e.startLine !== undefined ? this.L.registerMarker(e.startLine - (buffer.baseY + buffer.cursorY)) : undefined;
                    if (!marker) {
                        continue;
                    }
                    this.n.commandStartMarker = e.startLine !== undefined ? this.L.registerMarker(e.startLine - (buffer.baseY + buffer.cursorY)) : undefined;
                    this.n.commandStartX = e.startX;
                    this.n.promptStartMarker = e.promptStartLine !== undefined ? this.L.registerMarker(e.promptStartLine - (buffer.baseY + buffer.cursorY)) : undefined;
                    this.g = e.cwd;
                    this.D.fire({ marker });
                    continue;
                }
                // Full command
                const newCommand = terminalCommand_1.$ts.deserialize(this.L, e, this.t);
                if (!newCommand) {
                    continue;
                }
                this.f.push(newCommand);
                this.M.debug('CommandDetectionCapability#onCommandFinished', newCommand);
                this.G.fire(newCommand);
            }
            if (serialized.promptInputModel) {
                this.c.deserialize(serialized.promptInputModel);
            }
        }
    };
    exports.$$yb = $$yb;
    __decorate([
        (0, decorators_1.$di)(500)
    ], $$yb.prototype, "O", null);
    exports.$$yb = $$yb = __decorate([
        __param(1, log_1.$fk)
    ], $$yb);
    /**
     * Non-Windows-specific behavior.
     */
    class UnixPtyHeuristics extends lifecycle_1.$Zc {
        constructor(c, f, g, h) {
            super();
            this.c = c;
            this.f = f;
            this.g = g;
            this.h = h;
            this.B(c.parser.registerCsiHandler({ final: 'J' }, params => {
                if (params.length >= 1 && (params[0] === 2 || params[0] === 3)) {
                    g.clearCommandsInViewport();
                }
                // We don't want to override xterm.js' default behavior, just augment it
                return false;
            }));
        }
        handleCommandStart(options) {
            this.g.commitCommandFinished();
            const currentCommand = this.f.currentCommand;
            currentCommand.commandStartX = this.c.buffer.active.cursorX;
            currentCommand.commandStartMarker = options?.marker || this.c.registerMarker(0);
            // Clear executed as it must happen after command start
            currentCommand.commandExecutedMarker?.dispose();
            currentCommand.commandExecutedMarker = undefined;
            currentCommand.commandExecutedX = undefined;
            for (const m of this.g.commandMarkers) {
                m.dispose();
            }
            this.g.commandMarkers.length = 0;
            this.g.onCommandStartedEmitter.fire({ marker: options?.marker || currentCommand.commandStartMarker, markProperties: options?.markProperties });
            this.h.debug('CommandDetectionCapability#handleCommandStart', currentCommand.commandStartX, currentCommand.commandStartMarker?.line);
        }
        handleCommandExecuted(options) {
            const currentCommand = this.f.currentCommand;
            currentCommand.commandExecutedMarker = options?.marker || this.c.registerMarker(0);
            currentCommand.commandExecutedX = this.c.buffer.active.cursorX;
            this.h.debug('CommandDetectionCapability#handleCommandExecuted', currentCommand.commandExecutedX, currentCommand.commandExecutedMarker?.line);
            // Sanity check optional props
            if (!currentCommand.commandStartMarker || !currentCommand.commandExecutedMarker || currentCommand.commandStartX === undefined) {
                return;
            }
            // Calculate the command
            currentCommand.command = this.g.isCommandStorageDisabled ? '' : this.c.buffer.active.getLine(currentCommand.commandStartMarker.line)?.translateToString(true, currentCommand.commandStartX, currentCommand.commandRightPromptStartX).trim();
            let y = currentCommand.commandStartMarker.line + 1;
            const commandExecutedLine = currentCommand.commandExecutedMarker.line;
            for (; y < commandExecutedLine; y++) {
                const line = this.c.buffer.active.getLine(y);
                if (line) {
                    const continuation = currentCommand.continuations?.find(e => e.marker.line === y);
                    if (continuation) {
                        currentCommand.command += '\n';
                    }
                    const startColumn = continuation?.end ?? 0;
                    currentCommand.command += line.translateToString(true, startColumn);
                }
            }
            if (y === commandExecutedLine) {
                currentCommand.command += this.c.buffer.active.getLine(commandExecutedLine)?.translateToString(true, undefined, currentCommand.commandExecutedX) || '';
            }
            this.g.onCommandExecutedEmitter.fire(currentCommand);
        }
    }
    var AdjustCommandStartMarkerConstants;
    (function (AdjustCommandStartMarkerConstants) {
        AdjustCommandStartMarkerConstants[AdjustCommandStartMarkerConstants["MaxCheckLineCount"] = 10] = "MaxCheckLineCount";
        AdjustCommandStartMarkerConstants[AdjustCommandStartMarkerConstants["Interval"] = 20] = "Interval";
        AdjustCommandStartMarkerConstants[AdjustCommandStartMarkerConstants["MaximumPollCount"] = 10] = "MaximumPollCount";
    })(AdjustCommandStartMarkerConstants || (AdjustCommandStartMarkerConstants = {}));
    /**
     * An object that integrated with and decorates the command detection capability to add heuristics
     * that adjust various markers to work better with Windows and ConPTY. This isn't depended upon the
     * frontend OS, or even the backend OS, but the `IsWindows` property which technically a non-Windows
     * client can emit (for example in tests).
     */
    let WindowsPtyHeuristics = class WindowsPtyHeuristics extends lifecycle_1.$Zc {
        constructor(n, r, s, t) {
            super();
            this.n = n;
            this.r = r;
            this.s = s;
            this.t = t;
            this.c = this.B(new lifecycle_1.$1c());
            this.g = 0;
            this.h = 0;
            this.B(n.parser.registerCsiHandler({ final: 'J' }, params => {
                // Clear commands when the viewport is cleared
                if (params.length >= 1 && (params[0] === 2 || params[0] === 3)) {
                    this.s.clearCommandsInViewport();
                }
                // We don't want to override xterm.js' default behavior, just augment it
                return false;
            }));
            this.B(this.r.onBeforeCommandFinished(command => {
                // For older Windows backends we cannot listen to CSI J, instead we assume running clear
                // or cls will clear all commands in the viewport. This is not perfect but it's right
                // most of the time.
                if (command.command.trim().toLowerCase() === 'clear' || command.command.trim().toLowerCase() === 'cls') {
                    this.f?.cancel();
                    this.f = undefined;
                    this.s.clearCommandsInViewport();
                    this.r.currentCommand.isInvalid = true;
                    this.s.onCurrentCommandInvalidatedEmitter.fire({ reason: capabilities_1.CommandInvalidationReason.Windows });
                }
            }));
        }
        preHandleResize(e) {
            // Resize behavior is different under conpty; instead of bringing parts of the scrollback
            // back into the viewport, new lines are inserted at the bottom (ie. the same behavior as if
            // there was no scrollback).
            //
            // On resize this workaround will wait for a conpty reprint to occur by waiting for the
            // cursor to move, it will then calculate the number of lines that the commands within the
            // viewport _may have_ shifted. After verifying the content of the current line is
            // incorrect, the line after shifting is checked and if that matches delete events are fired
            // on the xterm.js buffer to move the markers.
            //
            // While a bit hacky, this approach is quite safe and seems to work great at least for pwsh.
            const baseY = this.n.buffer.active.baseY;
            const rowsDifference = e.rows - this.s.dimensions.rows;
            // Only do when rows increase, do in the next frame as this needs to happen after
            // conpty reprints the screen
            if (rowsDifference > 0) {
                this.D().then(() => {
                    // Calculate the number of lines the content may have shifted, this will max out at
                    // scrollback count since the standard behavior will be used then
                    const potentialShiftedLineCount = Math.min(rowsDifference, baseY);
                    // For each command within the viewport, assume commands are in the correct order
                    for (let i = this.r.commands.length - 1; i >= 0; i--) {
                        const command = this.r.commands[i];
                        if (!command.marker || command.marker.line < baseY || command.commandStartLineContent === undefined) {
                            break;
                        }
                        const line = this.n.buffer.active.getLine(command.marker.line);
                        if (!line || line.translateToString(true) === command.commandStartLineContent) {
                            continue;
                        }
                        const shiftedY = command.marker.line - potentialShiftedLineCount;
                        const shiftedLine = this.n.buffer.active.getLine(shiftedY);
                        if (shiftedLine?.translateToString(true) !== command.commandStartLineContent) {
                            continue;
                        }
                        // HACK: xterm.js doesn't expose this by design as it's an internal core
                        // function an embedder could easily do damage with. Additionally, this
                        // can't really be upstreamed since the event relies on shell integration to
                        // verify the shifting is necessary.
                        this.n._core._bufferService.buffer.lines.onDeleteEmitter.fire({
                            index: this.n.buffer.active.baseY,
                            amount: potentialShiftedLineCount
                        });
                    }
                });
            }
        }
        handleCommandStart() {
            this.r.currentCommand.commandStartX = this.n.buffer.active.cursorX;
            // On Windows track all cursor movements after the command start sequence
            this.s.commandMarkers.length = 0;
            const initialCommandStartMarker = this.r.currentCommand.commandStartMarker = (this.r.currentCommand.promptStartMarker
                ? cloneMarker(this.n, this.r.currentCommand.promptStartMarker)
                : this.n.registerMarker(0));
            this.r.currentCommand.commandStartX = 0;
            // DEBUG: Add a decoration for the original unadjusted command start position
            // if ('registerDecoration' in this._terminal) {
            // 	const d = (this._terminal as any).registerDecoration({
            // 		marker: this._capability.currentCommand.commandStartMarker,
            // 		x: this._capability.currentCommand.commandStartX
            // 	});
            // 	d?.onRender((e: HTMLElement) => {
            // 		e.textContent = 'b';
            // 		e.classList.add('xterm-sequence-decoration', 'top', 'right');
            // 		e.title = 'Initial command start position';
            // 	});
            // }
            // The command started sequence may be printed before the actual prompt is, for example a
            // multi-line prompt will typically look like this where D, A and B signify the command
            // finished, prompt started and command started sequences respectively:
            //
            //     D/my/cwdB
            //     > C
            //
            // Due to this, it's likely that this will be called before the line has been parsed.
            // Unfortunately, it is also the case that the actual command start data may not be parsed
            // by the end of the task either, so a microtask cannot be used.
            //
            // The strategy used is to begin polling and scanning downwards for up to the next 5 lines.
            // If it looks like a prompt is found, the command started location is adjusted. If the
            // command executed sequences comes in before polling is done, polling is canceled and the
            // final polling task is executed synchronously.
            this.g = 0;
            this.h = 0;
            this.f = new async_1.$Wh(() => this.u(initialCommandStartMarker), AdjustCommandStartMarkerConstants.Interval);
            this.f.schedule();
            // TODO: Cache details about polling for the future - eg. if it always fails, stop bothering
        }
        u(start) {
            if (this.q.isDisposed) {
                return;
            }
            const buffer = this.n.buffer.active;
            let scannedLineCount = this.g;
            while (scannedLineCount < AdjustCommandStartMarkerConstants.MaxCheckLineCount && start.line + scannedLineCount < buffer.baseY + this.n.rows) {
                if (this.C()) {
                    const prompt = this.F(start.line + scannedLineCount);
                    if (prompt) {
                        const adjustedPrompt = typeof prompt === 'string' ? prompt : prompt.prompt;
                        this.r.currentCommand.commandStartMarker = this.n.registerMarker(0);
                        if (typeof prompt === 'object' && prompt.likelySingleLine) {
                            this.t.debug('CommandDetectionCapability#_tryAdjustCommandStartMarker adjusted promptStart', `${this.r.currentCommand.promptStartMarker?.line} -> ${this.r.currentCommand.commandStartMarker.line}`);
                            this.r.currentCommand.promptStartMarker?.dispose();
                            this.r.currentCommand.promptStartMarker = cloneMarker(this.n, this.r.currentCommand.commandStartMarker);
                            // Adjust the last command if it's not in the same position as the following
                            // prompt start marker
                            const lastCommand = this.r.commands.at(-1);
                            if (lastCommand && this.r.currentCommand.commandStartMarker.line !== lastCommand.endMarker?.line) {
                                lastCommand.endMarker?.dispose();
                                lastCommand.endMarker = cloneMarker(this.n, this.r.currentCommand.commandStartMarker);
                            }
                        }
                        // use the regex to set the position as it's possible input has occurred
                        this.r.currentCommand.commandStartX = adjustedPrompt.length;
                        this.t.debug('CommandDetectionCapability#_tryAdjustCommandStartMarker adjusted commandStart', `${start.line} -> ${this.r.currentCommand.commandStartMarker.line}:${this.r.currentCommand.commandStartX}`);
                        this.w();
                        return;
                    }
                }
                scannedLineCount++;
            }
            if (scannedLineCount < AdjustCommandStartMarkerConstants.MaxCheckLineCount) {
                this.g = scannedLineCount;
                if (++this.h < AdjustCommandStartMarkerConstants.MaximumPollCount) {
                    this.f?.schedule();
                }
                else {
                    this.w();
                }
            }
            else {
                this.w();
            }
        }
        w() {
            // Perform final try adjust if necessary
            if (this.f) {
                // Max out poll count to ensure it's the last run
                this.h = AdjustCommandStartMarkerConstants.MaximumPollCount;
                this.f.flush();
                this.f = undefined;
            }
            this.s.commitCommandFinished();
            if (!this.r.currentCommand.commandExecutedMarker) {
                this.c.value = this.n.onCursorMove(() => {
                    if (this.s.commandMarkers.length === 0 || this.s.commandMarkers[this.s.commandMarkers.length - 1].line !== this.n.buffer.active.cursorY) {
                        const marker = this.n.registerMarker(0);
                        if (marker) {
                            this.s.commandMarkers.push(marker);
                        }
                    }
                });
            }
            if (this.r.currentCommand.commandStartMarker) {
                const line = this.n.buffer.active.getLine(this.r.currentCommand.commandStartMarker.line);
                if (line) {
                    this.r.currentCommand.commandStartLineContent = line.translateToString(true);
                }
            }
            this.s.onCommandStartedEmitter.fire({ marker: this.r.currentCommand.commandStartMarker });
            this.t.debug('CommandDetectionCapability#_handleCommandStartWindows', this.r.currentCommand.commandStartX, this.r.currentCommand.commandStartMarker?.line);
        }
        handleCommandExecuted(options) {
            if (this.f) {
                this.w();
            }
            // Use the gathered cursor move markers to correct the command start and executed markers
            this.c.clear();
            this.z();
            this.r.currentCommand.commandExecutedX = this.n.buffer.active.cursorX;
            this.s.onCommandExecutedEmitter.fire(this.r.currentCommand);
            this.t.debug('CommandDetectionCapability#handleCommandExecuted', this.r.currentCommand.commandExecutedX, this.r.currentCommand.commandExecutedMarker?.line);
        }
        preHandleCommandFinished() {
            if (this.r.currentCommand.commandExecutedMarker) {
                return;
            }
            // This is done on command finished just in case command executed never happens (for example
            // PSReadLine tab completion)
            if (this.s.commandMarkers.length === 0) {
                // If the command start timeout doesn't happen before command finished, just use the
                // current marker.
                if (!this.r.currentCommand.commandStartMarker) {
                    this.r.currentCommand.commandStartMarker = this.n.registerMarker(0);
                }
                if (this.r.currentCommand.commandStartMarker) {
                    this.s.commandMarkers.push(this.r.currentCommand.commandStartMarker);
                }
            }
            this.z();
        }
        postHandleCommandFinished() {
            const currentCommand = this.r.currentCommand;
            const commandText = currentCommand.command;
            const commandLine = currentCommand.commandStartMarker?.line;
            const executedLine = currentCommand.commandExecutedMarker?.line;
            if (!commandText || commandText.length === 0 ||
                commandLine === undefined || commandLine === -1 ||
                executedLine === undefined || executedLine === -1) {
                return;
            }
            // Scan downwards from the command start line and search for every character in the actual
            // command line. This may end up matching the wrong characters, but it shouldn't matter at
            // least in the typical case as the entire command will still get matched.
            let current = 0;
            let found = false;
            for (let i = commandLine; i <= executedLine; i++) {
                const line = this.n.buffer.active.getLine(i);
                if (!line) {
                    break;
                }
                const text = line.translateToString(true);
                for (let j = 0; j < text.length; j++) {
                    // Skip whitespace in case it was not actually rendered or could be trimmed from the
                    // end of the line
                    while (commandText.length < current && commandText[current] === ' ') {
                        current++;
                    }
                    // Character match
                    if (text[j] === commandText[current]) {
                        current++;
                    }
                    // Full command match
                    if (current === commandText.length) {
                        // It's ambiguous whether the command executed marker should ideally appear at
                        // the end of the line or at the beginning of the next line. Since it's more
                        // useful for extracting the command at the end of the current line we go with
                        // that.
                        const wrapsToNextLine = j >= this.n.cols - 1;
                        currentCommand.commandExecutedMarker = this.n.registerMarker(i - (this.n.buffer.active.baseY + this.n.buffer.active.cursorY) + (wrapsToNextLine ? 1 : 0));
                        currentCommand.commandExecutedX = wrapsToNextLine ? 0 : j + 1;
                        found = true;
                        break;
                    }
                }
                if (found) {
                    break;
                }
            }
        }
        z() {
            // On Windows, use the gathered cursor move markers to correct the command start and
            // executed markers.
            if (this.s.commandMarkers.length === 0) {
                return;
            }
            this.s.commandMarkers = this.s.commandMarkers.sort((a, b) => a.line - b.line);
            this.r.currentCommand.commandStartMarker = this.s.commandMarkers[0];
            if (this.r.currentCommand.commandStartMarker) {
                const line = this.n.buffer.active.getLine(this.r.currentCommand.commandStartMarker.line);
                if (line) {
                    this.r.currentCommand.commandStartLineContent = line.translateToString(true);
                }
            }
            this.r.currentCommand.commandExecutedMarker = this.s.commandMarkers[this.s.commandMarkers.length - 1];
            // Fire this now to prevent issues like #197409
            this.s.onCommandExecutedEmitter.fire(this.r.currentCommand);
        }
        C() {
            const lastCommand = this.r.commands.at(-1);
            // There is only a single command, so this check is unnecessary
            if (!lastCommand) {
                return true;
            }
            const cursorYAbsolute = this.n.buffer.active.baseY + this.n.buffer.active.cursorY;
            // If the cursor position is within the last command, we should poll.
            const lastCommandYAbsolute = (lastCommand.endMarker ? lastCommand.endMarker.line : lastCommand.marker?.line) ?? -1;
            return cursorYAbsolute > lastCommandYAbsolute;
        }
        D() {
            const cursorX = this.n.buffer.active.cursorX;
            const cursorY = this.n.buffer.active.cursorY;
            let totalDelay = 0;
            return new Promise((resolve, reject) => {
                const interval = setInterval(() => {
                    if (cursorX !== this.n.buffer.active.cursorX || cursorY !== this.n.buffer.active.cursorY) {
                        resolve();
                        clearInterval(interval);
                        return;
                    }
                    totalDelay += 10;
                    if (totalDelay > 1000) {
                        clearInterval(interval);
                        resolve();
                    }
                }, 10);
            });
        }
        F(y = this.n.buffer.active.baseY + this.n.buffer.active.cursorY) {
            const line = this.n.buffer.active.getLine(y);
            if (!line) {
                return;
            }
            const lineText = line.translateToString(true);
            if (!lineText) {
                return;
            }
            // PowerShell
            const pwshPrompt = lineText.match(/(?<prompt>(\(.+\)\s)?(?:PS.+>\s?))/)?.groups?.prompt;
            if (pwshPrompt) {
                const adjustedPrompt = this.G(pwshPrompt, lineText, '>');
                if (adjustedPrompt) {
                    return {
                        prompt: adjustedPrompt,
                        likelySingleLine: true
                    };
                }
            }
            // Custom prompts like starship end in the common \u276f character
            const customPrompt = lineText.match(/.*\u276f(?=[^\u276f]*$)/g)?.[0];
            if (customPrompt) {
                const adjustedPrompt = this.G(customPrompt, lineText, '\u276f');
                if (adjustedPrompt) {
                    return adjustedPrompt;
                }
            }
            // Bash Prompt
            const bashPrompt = lineText.match(/^(?<prompt>\$)/)?.groups?.prompt;
            if (bashPrompt) {
                const adjustedPrompt = this.G(bashPrompt, lineText, '$');
                if (adjustedPrompt) {
                    return adjustedPrompt;
                }
            }
            // Python Prompt
            const pythonPrompt = lineText.match(/^(?<prompt>>>> )/g)?.groups?.prompt;
            if (pythonPrompt) {
                return {
                    prompt: pythonPrompt,
                    likelySingleLine: true
                };
            }
            // Dynamic prompt detection
            if (this.r.promptTerminator && lineText.trim().endsWith(this.r.promptTerminator)) {
                const adjustedPrompt = this.G(lineText, lineText, this.r.promptTerminator);
                if (adjustedPrompt) {
                    return adjustedPrompt;
                }
            }
            // Command Prompt
            const cmdMatch = lineText.match(/^(?<prompt>(\(.+\)\s)?(?:[A-Z]:\\.*>))/);
            return cmdMatch?.groups?.prompt ? {
                prompt: cmdMatch.groups.prompt,
                likelySingleLine: true
            } : undefined;
        }
        G(prompt, lineText, char) {
            if (!prompt) {
                return;
            }
            // Conpty may not 'render' the space at the end of the prompt
            if (lineText === prompt && prompt.endsWith(char)) {
                prompt += ' ';
            }
            return prompt;
        }
    };
    WindowsPtyHeuristics = __decorate([
        __param(3, log_1.$fk)
    ], WindowsPtyHeuristics);
    function $_yb(buffer, command, cols, outputMatcher) {
        if (!outputMatcher) {
            return undefined;
        }
        const executedMarker = command.executedMarker;
        const endMarker = command.endMarker;
        if (!executedMarker || !endMarker) {
            return undefined;
        }
        const startLine = executedMarker.line;
        const endLine = endMarker.line;
        const linesToCheck = outputMatcher.length;
        const lines = [];
        if (outputMatcher.anchor === 'bottom') {
            for (let i = endLine - (outputMatcher.offset || 0); i >= startLine; i--) {
                let wrappedLineStart = i;
                const wrappedLineEnd = i;
                while (wrappedLineStart >= startLine && buffer.getLine(wrappedLineStart)?.isWrapped) {
                    wrappedLineStart--;
                }
                i = wrappedLineStart;
                lines.unshift(getXtermLineContent(buffer, wrappedLineStart, wrappedLineEnd, cols));
                if (lines.length > linesToCheck) {
                    lines.pop();
                }
            }
        }
        else {
            for (let i = startLine + (outputMatcher.offset || 0); i < endLine; i++) {
                const wrappedLineStart = i;
                let wrappedLineEnd = i;
                while (wrappedLineEnd + 1 < endLine && buffer.getLine(wrappedLineEnd + 1)?.isWrapped) {
                    wrappedLineEnd++;
                }
                i = wrappedLineEnd;
                lines.push(getXtermLineContent(buffer, wrappedLineStart, wrappedLineEnd, cols));
                if (lines.length === linesToCheck) {
                    lines.shift();
                }
            }
        }
        return lines;
    }
    function getXtermLineContent(buffer, lineStart, lineEnd, cols) {
        // Cap the maximum number of lines generated to prevent potential performance problems. This is
        // more of a sanity check as the wrapped line should already be trimmed down at this point.
        const maxLineLength = Math.max(2048 / cols * 2);
        lineEnd = Math.min(lineEnd, lineStart + maxLineLength);
        let content = '';
        for (let i = lineStart; i <= lineEnd; i++) {
            // Make sure only 0 to cols are considered as resizing when windows mode is enabled will
            // retain buffer data outside of the terminal width as reflow is disabled.
            const line = buffer.getLine(i);
            if (line) {
                content += line.translateToString(true, 0, cols);
            }
        }
        return content;
    }
    function cloneMarker(xterm, marker, offset = 0) {
        return xterm.registerMarker(marker.line - (xterm.buffer.active.baseY + xterm.buffer.active.cursorY) + offset);
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[86/*vs/platform/terminal/common/capabilities/cwdDetectionCapability*/], __M([0/*require*/,1/*exports*/,4/*vs/base/common/event*/,2/*vs/base/common/lifecycle*/,23/*vs/platform/terminal/common/capabilities/capabilities*/]), function (require, exports, event_1, lifecycle_1, capabilities_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$azb = void 0;
    class $azb extends lifecycle_1.$Zc {
        constructor() {
            super(...arguments);
            this.type = capabilities_1.TerminalCapability.CwdDetection;
            this.a = '';
            this.b = new Map();
            this.c = this.B(new event_1.$qe());
            this.onDidChangeCwd = this.c.event;
        }
        /**
         * Gets the list of cwds seen in this session in order of last accessed.
         */
        get cwds() {
            return Array.from(this.b.keys());
        }
        getCwd() {
            return this.a;
        }
        updateCwd(cwd) {
            const didChange = this.a !== cwd;
            this.a = cwd;
            const count = this.b.get(this.a) || 0;
            this.b.delete(this.a); // Delete to put it at the bottom of the iterable
            this.b.set(this.a, count + 1);
            if (didChange) {
                this.c.fire(cwd);
            }
        }
    }
    exports.$azb = $azb;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[87/*vs/platform/terminal/common/capabilities/partialCommandDetectionCapability*/], __M([0/*require*/,1/*exports*/,4/*vs/base/common/event*/,2/*vs/base/common/lifecycle*/,23/*vs/platform/terminal/common/capabilities/capabilities*/]), function (require, exports, event_1, lifecycle_1, capabilities_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$bzb = void 0;
    var Constants;
    (function (Constants) {
        /**
         * The minimum size of the prompt in which to assume the line is a command.
         */
        Constants[Constants["MinimumPromptLength"] = 2] = "MinimumPromptLength";
    })(Constants || (Constants = {}));
    /**
     * This capability guesses where commands are based on where the cursor was when enter was pressed.
     * It's very hit or miss but it's often correct and better than nothing.
     */
    class $bzb extends lifecycle_1.$Yc {
        get commands() { return this.a; }
        constructor(c) {
            super();
            this.c = c;
            this.type = capabilities_1.TerminalCapability.PartialCommandDetection;
            this.a = [];
            this.b = this.add(new event_1.$qe());
            this.onCommandFinished = this.b.event;
            this.add(this.c.onData(e => this.h(e)));
            this.add(this.c.parser.registerCsiHandler({ final: 'J' }, params => {
                if (params.length >= 1 && (params[0] === 2 || params[0] === 3)) {
                    this.m();
                }
                // We don't want to override xterm.js' default behavior, just augment it
                return false;
            }));
        }
        h(data) {
            if (data === '\x0d') {
                this.j();
            }
        }
        j() {
            if (!this.c) {
                return;
            }
            if (this.c.buffer.active.cursorX >= Constants.MinimumPromptLength) {
                const marker = this.c.registerMarker(0);
                if (marker) {
                    this.a.push(marker);
                    this.b.fire(marker);
                }
            }
        }
        m() {
            // Find the number of commands on the tail end of the array that are within the viewport
            let count = 0;
            for (let i = this.a.length - 1; i >= 0; i--) {
                if (this.a[i].line < this.c.buffer.active.baseY) {
                    break;
                }
                count++;
            }
            // Remove them
            this.a.splice(this.a.length - count, count);
        }
    }
    exports.$bzb = $bzb;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[88/*vs/platform/terminal/common/capabilities/terminalCapabilityStore*/], __M([0/*require*/,1/*exports*/,4/*vs/base/common/event*/,2/*vs/base/common/lifecycle*/]), function (require, exports, event_1, lifecycle_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$0yb = exports.$9yb = void 0;
    class $9yb extends lifecycle_1.$Zc {
        constructor() {
            super(...arguments);
            this.a = new Map();
            this.b = this.B(new event_1.$qe());
            this.onDidRemoveCapabilityType = this.b.event;
            this.f = this.B(new event_1.$qe());
            this.onDidAddCapabilityType = this.f.event;
            this.g = this.B(new event_1.$qe());
            this.onDidRemoveCapability = this.g.event;
            this.h = this.B(new event_1.$qe());
            this.onDidAddCapability = this.h.event;
        }
        get items() {
            return this.a.keys();
        }
        add(capability, impl) {
            this.a.set(capability, impl);
            this.f.fire(capability);
            this.h.fire({ id: capability, capability: impl });
        }
        get(capability) {
            // HACK: This isn't totally safe since the Map key and value are not connected
            return this.a.get(capability);
        }
        remove(capability) {
            const impl = this.a.get(capability);
            if (!impl) {
                return;
            }
            this.a.delete(capability);
            this.b.fire(capability);
            this.h.fire({ id: capability, capability: impl });
        }
        has(capability) {
            return this.a.has(capability);
        }
    }
    exports.$9yb = $9yb;
    class $0yb extends lifecycle_1.$Zc {
        constructor() {
            super(...arguments);
            this._stores = [];
            this.a = this.B(new event_1.$qe());
            this.onDidRemoveCapabilityType = this.a.event;
            this.b = this.B(new event_1.$qe());
            this.onDidAddCapabilityType = this.b.event;
            this.f = this.B(new event_1.$qe());
            this.onDidRemoveCapability = this.f.event;
            this.g = this.B(new event_1.$qe());
            this.onDidAddCapability = this.g.event;
        }
        get items() {
            return this.h();
        }
        *h() {
            for (const store of this._stores) {
                for (const c of store.items) {
                    yield c;
                }
            }
        }
        has(capability) {
            for (const store of this._stores) {
                for (const c of store.items) {
                    if (c === capability) {
                        return true;
                    }
                }
            }
            return false;
        }
        get(capability) {
            for (const store of this._stores) {
                const c = store.get(capability);
                if (c) {
                    return c;
                }
            }
            return undefined;
        }
        add(store) {
            this._stores.push(store);
            for (const capability of store.items) {
                this.b.fire(capability);
                this.g.fire({ id: capability, capability: store.get(capability) });
            }
            this.B(store.onDidAddCapabilityType(e => this.b.fire(e)));
            this.B(store.onDidAddCapability(e => this.g.fire(e)));
            this.B(store.onDidRemoveCapabilityType(e => this.a.fire(e)));
            this.B(store.onDidRemoveCapability(e => this.f.fire(e)));
        }
    }
    exports.$0yb = $0yb;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[40/*vs/platform/terminal/common/environmentVariable*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.EnvironmentVariableMutatorType = void 0;
    var EnvironmentVariableMutatorType;
    (function (EnvironmentVariableMutatorType) {
        EnvironmentVariableMutatorType[EnvironmentVariableMutatorType["Replace"] = 1] = "Replace";
        EnvironmentVariableMutatorType[EnvironmentVariableMutatorType["Append"] = 2] = "Append";
        EnvironmentVariableMutatorType[EnvironmentVariableMutatorType["Prepend"] = 3] = "Prepend";
    })(EnvironmentVariableMutatorType || (exports.EnvironmentVariableMutatorType = EnvironmentVariableMutatorType = {}));
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[89/*vs/platform/terminal/common/environmentVariableCollection*/], __M([0/*require*/,1/*exports*/,3/*vs/base/common/platform*/,40/*vs/platform/terminal/common/environmentVariable*/]), function (require, exports, platform_1, environmentVariable_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$Ts = void 0;
    const mutatorTypeToLabelMap = new Map([
        [environmentVariable_1.EnvironmentVariableMutatorType.Append, 'APPEND'],
        [environmentVariable_1.EnvironmentVariableMutatorType.Prepend, 'PREPEND'],
        [environmentVariable_1.EnvironmentVariableMutatorType.Replace, 'REPLACE']
    ]);
    class $Ts {
        constructor(collections) {
            this.collections = collections;
            this.a = new Map();
            this.b = new Map();
            collections.forEach((collection, extensionIdentifier) => {
                this.d(collection, extensionIdentifier);
                const it = collection.map.entries();
                let next = it.next();
                while (!next.done) {
                    const mutator = next.value[1];
                    const key = next.value[0];
                    let entry = this.a.get(key);
                    if (!entry) {
                        entry = [];
                        this.a.set(key, entry);
                    }
                    // If the first item in the entry is replace ignore any other entries as they would
                    // just get replaced by this one.
                    if (entry.length > 0 && entry[0].type === environmentVariable_1.EnvironmentVariableMutatorType.Replace) {
                        next = it.next();
                        continue;
                    }
                    const extensionMutator = {
                        extensionIdentifier,
                        value: mutator.value,
                        type: mutator.type,
                        scope: mutator.scope,
                        variable: mutator.variable,
                        options: mutator.options
                    };
                    if (!extensionMutator.scope) {
                        delete extensionMutator.scope; // Convenient for tests
                    }
                    // Mutators get applied in the reverse order than they are created
                    entry.unshift(extensionMutator);
                    next = it.next();
                }
            });
        }
        async applyToProcessEnvironment(env, scope, variableResolver) {
            let lowerToActualVariableNames;
            if (platform_1.$l) {
                lowerToActualVariableNames = {};
                Object.keys(env).forEach(e => lowerToActualVariableNames[e.toLowerCase()] = e);
            }
            for (const [variable, mutators] of this.getVariableMap(scope)) {
                const actualVariable = platform_1.$l ? lowerToActualVariableNames[variable.toLowerCase()] || variable : variable;
                for (const mutator of mutators) {
                    const value = variableResolver ? await variableResolver(mutator.value) : mutator.value;
                    // Default: true
                    if (mutator.options?.applyAtProcessCreation ?? true) {
                        switch (mutator.type) {
                            case environmentVariable_1.EnvironmentVariableMutatorType.Append:
                                env[actualVariable] = (env[actualVariable] || '') + value;
                                break;
                            case environmentVariable_1.EnvironmentVariableMutatorType.Prepend:
                                env[actualVariable] = value + (env[actualVariable] || '');
                                break;
                            case environmentVariable_1.EnvironmentVariableMutatorType.Replace:
                                env[actualVariable] = value;
                                break;
                        }
                    }
                    // Default: false
                    if (mutator.options?.applyAtShellIntegration ?? false) {
                        const key = `VSCODE_ENV_${mutatorTypeToLabelMap.get(mutator.type)}`;
                        env[key] = (env[key] ? env[key] + ':' : '') + variable + '=' + this.c(value);
                    }
                }
            }
        }
        c(value) {
            return value.replaceAll(':', '\\x3a');
        }
        diff(other, scope) {
            const added = new Map();
            const changed = new Map();
            const removed = new Map();
            // Find added
            other.getVariableMap(scope).forEach((otherMutators, variable) => {
                const currentMutators = this.getVariableMap(scope).get(variable);
                const result = getMissingMutatorsFromArray(otherMutators, currentMutators);
                if (result) {
                    added.set(variable, result);
                }
            });
            // Find removed
            this.getVariableMap(scope).forEach((currentMutators, variable) => {
                const otherMutators = other.getVariableMap(scope).get(variable);
                const result = getMissingMutatorsFromArray(currentMutators, otherMutators);
                if (result) {
                    removed.set(variable, result);
                }
            });
            // Find changed
            this.getVariableMap(scope).forEach((currentMutators, variable) => {
                const otherMutators = other.getVariableMap(scope).get(variable);
                const result = getChangedMutatorsFromArray(currentMutators, otherMutators);
                if (result) {
                    changed.set(variable, result);
                }
            });
            if (added.size === 0 && changed.size === 0 && removed.size === 0) {
                return undefined;
            }
            return { added, changed, removed };
        }
        getVariableMap(scope) {
            const result = new Map();
            for (const mutators of this.a.values()) {
                const filteredMutators = mutators.filter(m => filterScope(m, scope));
                if (filteredMutators.length > 0) {
                    // All of these mutators are for the same variable because they are in the same scope, hence choose anyone to form a key.
                    result.set(filteredMutators[0].variable, filteredMutators);
                }
            }
            return result;
        }
        getDescriptionMap(scope) {
            const result = new Map();
            for (const mutators of this.b.values()) {
                const filteredMutators = mutators.filter(m => filterScope(m, scope, true));
                for (const mutator of filteredMutators) {
                    result.set(mutator.extensionIdentifier, mutator.description);
                }
            }
            return result;
        }
        d(collection, extensionIdentifier) {
            if (!collection.descriptionMap) {
                return;
            }
            const it = collection.descriptionMap.entries();
            let next = it.next();
            while (!next.done) {
                const mutator = next.value[1];
                const key = next.value[0];
                let entry = this.b.get(key);
                if (!entry) {
                    entry = [];
                    this.b.set(key, entry);
                }
                const extensionMutator = {
                    extensionIdentifier,
                    scope: mutator.scope,
                    description: mutator.description
                };
                if (!extensionMutator.scope) {
                    delete extensionMutator.scope; // Convenient for tests
                }
                entry.push(extensionMutator);
                next = it.next();
            }
        }
    }
    exports.$Ts = $Ts;
    /**
     * Returns whether a mutator matches with the scope provided.
     * @param mutator Mutator to filter
     * @param scope Scope to be used for querying
     * @param strictFilter If true, mutators with global scope is not returned when querying for workspace scope.
     * i.e whether mutator scope should always exactly match with query scope.
     */
    function filterScope(mutator, scope, strictFilter = false) {
        if (!mutator.scope) {
            if (strictFilter) {
                return scope === mutator.scope;
            }
            return true;
        }
        // If a mutator is scoped to a workspace folder, only apply it if the workspace
        // folder matches.
        if (mutator.scope.workspaceFolder && scope?.workspaceFolder && mutator.scope.workspaceFolder.index === scope.workspaceFolder.index) {
            return true;
        }
        return false;
    }
    function getMissingMutatorsFromArray(current, other) {
        // If it doesn't exist, all are removed
        if (!other) {
            return current;
        }
        // Create a map to help
        const otherMutatorExtensions = new Set();
        other.forEach(m => otherMutatorExtensions.add(m.extensionIdentifier));
        // Find entries removed from other
        const result = [];
        current.forEach(mutator => {
            if (!otherMutatorExtensions.has(mutator.extensionIdentifier)) {
                result.push(mutator);
            }
        });
        return result.length === 0 ? undefined : result;
    }
    function getChangedMutatorsFromArray(current, other) {
        // If it doesn't exist, none are changed (they are removed)
        if (!other) {
            return undefined;
        }
        // Create a map to help
        const otherMutatorExtensions = new Map();
        other.forEach(m => otherMutatorExtensions.set(m.extensionIdentifier, m));
        // Find entries that exist in both but are not equal
        const result = [];
        current.forEach(mutator => {
            const otherMutator = otherMutatorExtensions.get(mutator.extensionIdentifier);
            if (otherMutator && (mutator.type !== otherMutator.type || mutator.value !== otherMutator.value || mutator.scope?.workspaceFolder?.index !== otherMutator.scope?.workspaceFolder?.index)) {
                // Return the new result, not the old one
                result.push(otherMutator);
            }
        });
        return result.length === 0 ? undefined : result;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[90/*vs/platform/terminal/common/environmentVariableShared*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$Ns = $Ns;
    exports.$Os = $Os;
    exports.$Ps = $Ps;
    exports.$Qs = $Qs;
    exports.$Rs = $Rs;
    exports.$Ss = $Ss;
    // This file is shared between the renderer and extension host
    function $Ns(collection) {
        return [...collection.entries()];
    }
    function $Os(descriptionMap) {
        return descriptionMap ? [...descriptionMap.entries()] : [];
    }
    function $Ps(serializedCollection) {
        return new Map(serializedCollection);
    }
    function $Qs(serializableEnvironmentDescription) {
        return new Map(serializableEnvironmentDescription ?? []);
    }
    function $Rs(collections) {
        return Array.from(collections.entries()).map(e => {
            return [e[0], $Ns(e[1].map), $Os(e[1].descriptionMap)];
        });
    }
    function $Ss(serializedCollection) {
        return new Map(serializedCollection.map(e => {
            return [e[0], { map: $Ps(e[1]), descriptionMap: $Qs(e[2]) }];
        }));
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/









define(__m[91/*vs/platform/terminal/common/requestStore*/], __M([0/*require*/,1/*exports*/,12/*vs/base/common/async*/,18/*vs/base/common/cancellation*/,4/*vs/base/common/event*/,2/*vs/base/common/lifecycle*/,9/*vs/platform/log/common/log*/]), function (require, exports, async_1, cancellation_1, event_1, lifecycle_1, log_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$Es = void 0;
    /**
     * A helper class to track requests that have replies. Using this it's easy to implement an event
     * that accepts a reply.
     */
    let $Es = class $Es extends lifecycle_1.$Zc {
        /**
         * @param timeout How long in ms to allow requests to go unanswered for, undefined will use the
         * default (15 seconds).
         */
        constructor(timeout, h) {
            super();
            this.h = h;
            this.a = 0;
            this.c = new Map();
            this.f = new Map();
            this.g = this.B(new event_1.$qe());
            this.onCreateRequest = this.g.event;
            this.b = timeout === undefined ? 15000 : timeout;
            this.B((0, lifecycle_1.$Xc)(() => {
                for (const d of this.f.values()) {
                    (0, lifecycle_1.$Uc)(d);
                }
            }));
        }
        /**
         * Creates a request.
         * @param args The arguments to pass to the onCreateRequest event.
         */
        createRequest(args) {
            return new Promise((resolve, reject) => {
                const requestId = ++this.a;
                this.c.set(requestId, resolve);
                this.g.fire({ requestId, ...args });
                const tokenSource = new cancellation_1.$Be();
                (0, async_1.$Lh)(this.b, tokenSource.token).then(() => reject(`Request ${requestId} timed out (${this.b}ms)`));
                this.f.set(requestId, [(0, lifecycle_1.$Xc)(() => tokenSource.cancel())]);
            });
        }
        /**
         * Accept a reply to a request.
         * @param requestId The request ID originating from the onCreateRequest event.
         * @param data The reply data.
         */
        acceptReply(requestId, data) {
            const resolveRequest = this.c.get(requestId);
            if (resolveRequest) {
                this.c.delete(requestId);
                (0, lifecycle_1.$Uc)(this.f.get(requestId) || []);
                this.f.delete(requestId);
                resolveRequest(data);
            }
            else {
                this.h.warn(`RequestStore#acceptReply was called without receiving a matching request ${requestId}`);
            }
        }
    };
    exports.$Es = $Es;
    exports.$Es = $Es = __decorate([
        __param(1, log_1.$fk)
    ], $Es);
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[16/*vs/platform/terminal/common/terminal*/], __M([0/*require*/,1/*exports*/,22/*vs/platform/instantiation/common/instantiation*/,39/*vs/platform/contextkey/common/contextkey*/,81/*vs/platform/registry/common/platform*/]), function (require, exports, instantiation_1, contextkey_1, platform_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$As = exports.$zs = exports.$ys = exports.TerminalExitReason = exports.ShellIntegrationStatus = exports.ProfileSource = exports.FlowControlConstants = exports.LocalReconnectConstants = exports.TerminalLocationString = exports.TerminalLocation = exports.HeartbeatConstants = exports.$xs = exports.ProcessPropertyType = exports.TerminalIpcChannels = exports.TitleEventSource = exports.GeneralShellType = exports.WindowsShellType = exports.PosixShellType = exports.TerminalSettingId = exports.TerminalSettingPrefix = exports.$ws = void 0;
    exports.$ws = new contextkey_1.$2j('terminalTabFocusMode', false, true);
    var TerminalSettingPrefix;
    (function (TerminalSettingPrefix) {
        TerminalSettingPrefix["AutomationProfile"] = "terminal.integrated.automationProfile.";
        TerminalSettingPrefix["DefaultProfile"] = "terminal.integrated.defaultProfile.";
        TerminalSettingPrefix["Profiles"] = "terminal.integrated.profiles.";
    })(TerminalSettingPrefix || (exports.TerminalSettingPrefix = TerminalSettingPrefix = {}));
    var TerminalSettingId;
    (function (TerminalSettingId) {
        TerminalSettingId["SendKeybindingsToShell"] = "terminal.integrated.sendKeybindingsToShell";
        TerminalSettingId["AutomationProfileLinux"] = "terminal.integrated.automationProfile.linux";
        TerminalSettingId["AutomationProfileMacOs"] = "terminal.integrated.automationProfile.osx";
        TerminalSettingId["AutomationProfileWindows"] = "terminal.integrated.automationProfile.windows";
        TerminalSettingId["ProfilesWindows"] = "terminal.integrated.profiles.windows";
        TerminalSettingId["ProfilesMacOs"] = "terminal.integrated.profiles.osx";
        TerminalSettingId["ProfilesLinux"] = "terminal.integrated.profiles.linux";
        TerminalSettingId["DefaultProfileLinux"] = "terminal.integrated.defaultProfile.linux";
        TerminalSettingId["DefaultProfileMacOs"] = "terminal.integrated.defaultProfile.osx";
        TerminalSettingId["DefaultProfileWindows"] = "terminal.integrated.defaultProfile.windows";
        TerminalSettingId["UseWslProfiles"] = "terminal.integrated.useWslProfiles";
        TerminalSettingId["TabsDefaultColor"] = "terminal.integrated.tabs.defaultColor";
        TerminalSettingId["TabsDefaultIcon"] = "terminal.integrated.tabs.defaultIcon";
        TerminalSettingId["TabsEnabled"] = "terminal.integrated.tabs.enabled";
        TerminalSettingId["TabsEnableAnimation"] = "terminal.integrated.tabs.enableAnimation";
        TerminalSettingId["TabsHideCondition"] = "terminal.integrated.tabs.hideCondition";
        TerminalSettingId["TabsShowActiveTerminal"] = "terminal.integrated.tabs.showActiveTerminal";
        TerminalSettingId["TabsShowActions"] = "terminal.integrated.tabs.showActions";
        TerminalSettingId["TabsLocation"] = "terminal.integrated.tabs.location";
        TerminalSettingId["TabsFocusMode"] = "terminal.integrated.tabs.focusMode";
        TerminalSettingId["MacOptionIsMeta"] = "terminal.integrated.macOptionIsMeta";
        TerminalSettingId["MacOptionClickForcesSelection"] = "terminal.integrated.macOptionClickForcesSelection";
        TerminalSettingId["AltClickMovesCursor"] = "terminal.integrated.altClickMovesCursor";
        TerminalSettingId["CopyOnSelection"] = "terminal.integrated.copyOnSelection";
        TerminalSettingId["EnableMultiLinePasteWarning"] = "terminal.integrated.enableMultiLinePasteWarning";
        TerminalSettingId["DrawBoldTextInBrightColors"] = "terminal.integrated.drawBoldTextInBrightColors";
        TerminalSettingId["FontFamily"] = "terminal.integrated.fontFamily";
        TerminalSettingId["FontSize"] = "terminal.integrated.fontSize";
        TerminalSettingId["LetterSpacing"] = "terminal.integrated.letterSpacing";
        TerminalSettingId["LineHeight"] = "terminal.integrated.lineHeight";
        TerminalSettingId["MinimumContrastRatio"] = "terminal.integrated.minimumContrastRatio";
        TerminalSettingId["TabStopWidth"] = "terminal.integrated.tabStopWidth";
        TerminalSettingId["FastScrollSensitivity"] = "terminal.integrated.fastScrollSensitivity";
        TerminalSettingId["MouseWheelScrollSensitivity"] = "terminal.integrated.mouseWheelScrollSensitivity";
        TerminalSettingId["BellDuration"] = "terminal.integrated.bellDuration";
        TerminalSettingId["FontWeight"] = "terminal.integrated.fontWeight";
        TerminalSettingId["FontWeightBold"] = "terminal.integrated.fontWeightBold";
        TerminalSettingId["CursorBlinking"] = "terminal.integrated.cursorBlinking";
        TerminalSettingId["CursorStyle"] = "terminal.integrated.cursorStyle";
        TerminalSettingId["CursorStyleInactive"] = "terminal.integrated.cursorStyleInactive";
        TerminalSettingId["CursorWidth"] = "terminal.integrated.cursorWidth";
        TerminalSettingId["Scrollback"] = "terminal.integrated.scrollback";
        TerminalSettingId["DetectLocale"] = "terminal.integrated.detectLocale";
        TerminalSettingId["DefaultLocation"] = "terminal.integrated.defaultLocation";
        TerminalSettingId["GpuAcceleration"] = "terminal.integrated.gpuAcceleration";
        TerminalSettingId["TerminalTitleSeparator"] = "terminal.integrated.tabs.separator";
        TerminalSettingId["TerminalTitle"] = "terminal.integrated.tabs.title";
        TerminalSettingId["TerminalDescription"] = "terminal.integrated.tabs.description";
        TerminalSettingId["RightClickBehavior"] = "terminal.integrated.rightClickBehavior";
        TerminalSettingId["MiddleClickBehavior"] = "terminal.integrated.middleClickBehavior";
        TerminalSettingId["Cwd"] = "terminal.integrated.cwd";
        TerminalSettingId["ConfirmOnExit"] = "terminal.integrated.confirmOnExit";
        TerminalSettingId["ConfirmOnKill"] = "terminal.integrated.confirmOnKill";
        TerminalSettingId["EnableBell"] = "terminal.integrated.enableBell";
        TerminalSettingId["EnableVisualBell"] = "terminal.integrated.enableVisualBell";
        TerminalSettingId["CommandsToSkipShell"] = "terminal.integrated.commandsToSkipShell";
        TerminalSettingId["AllowChords"] = "terminal.integrated.allowChords";
        TerminalSettingId["AllowMnemonics"] = "terminal.integrated.allowMnemonics";
        TerminalSettingId["TabFocusMode"] = "terminal.integrated.tabFocusMode";
        TerminalSettingId["EnvMacOs"] = "terminal.integrated.env.osx";
        TerminalSettingId["EnvLinux"] = "terminal.integrated.env.linux";
        TerminalSettingId["EnvWindows"] = "terminal.integrated.env.windows";
        TerminalSettingId["EnvironmentChangesIndicator"] = "terminal.integrated.environmentChangesIndicator";
        TerminalSettingId["EnvironmentChangesRelaunch"] = "terminal.integrated.environmentChangesRelaunch";
        TerminalSettingId["ExperimentalWindowsUseConptyDll"] = "terminal.integrated.experimental.windowsUseConptyDll";
        TerminalSettingId["ShowExitAlert"] = "terminal.integrated.showExitAlert";
        TerminalSettingId["SplitCwd"] = "terminal.integrated.splitCwd";
        TerminalSettingId["WindowsEnableConpty"] = "terminal.integrated.windowsEnableConpty";
        TerminalSettingId["WordSeparators"] = "terminal.integrated.wordSeparators";
        TerminalSettingId["EnableFileLinks"] = "terminal.integrated.enableFileLinks";
        TerminalSettingId["AllowedLinkSchemes"] = "terminal.integrated.allowedLinkSchemes";
        TerminalSettingId["UnicodeVersion"] = "terminal.integrated.unicodeVersion";
        TerminalSettingId["EnablePersistentSessions"] = "terminal.integrated.enablePersistentSessions";
        TerminalSettingId["PersistentSessionReviveProcess"] = "terminal.integrated.persistentSessionReviveProcess";
        TerminalSettingId["HideOnStartup"] = "terminal.integrated.hideOnStartup";
        TerminalSettingId["CustomGlyphs"] = "terminal.integrated.customGlyphs";
        TerminalSettingId["RescaleOverlappingGlyphs"] = "terminal.integrated.rescaleOverlappingGlyphs";
        TerminalSettingId["PersistentSessionScrollback"] = "terminal.integrated.persistentSessionScrollback";
        TerminalSettingId["InheritEnv"] = "terminal.integrated.inheritEnv";
        TerminalSettingId["ShowLinkHover"] = "terminal.integrated.showLinkHover";
        TerminalSettingId["IgnoreProcessNames"] = "terminal.integrated.ignoreProcessNames";
        TerminalSettingId["AutoReplies"] = "terminal.integrated.autoReplies";
        TerminalSettingId["ShellIntegrationEnabled"] = "terminal.integrated.shellIntegration.enabled";
        TerminalSettingId["ShellIntegrationShowWelcome"] = "terminal.integrated.shellIntegration.showWelcome";
        TerminalSettingId["ShellIntegrationDecorationsEnabled"] = "terminal.integrated.shellIntegration.decorationsEnabled";
        TerminalSettingId["ShellIntegrationCommandHistory"] = "terminal.integrated.shellIntegration.history";
        TerminalSettingId["EnableImages"] = "terminal.integrated.enableImages";
        TerminalSettingId["SmoothScrolling"] = "terminal.integrated.smoothScrolling";
        TerminalSettingId["IgnoreBracketedPasteMode"] = "terminal.integrated.ignoreBracketedPasteMode";
        TerminalSettingId["FocusAfterRun"] = "terminal.integrated.focusAfterRun";
        // Debug settings that are hidden from user
        /** Simulated latency applied to all calls made to the pty host */
        TerminalSettingId["DeveloperPtyHostLatency"] = "terminal.integrated.developer.ptyHost.latency";
        /** Simulated startup delay of the pty host process */
        TerminalSettingId["DeveloperPtyHostStartupDelay"] = "terminal.integrated.developer.ptyHost.startupDelay";
        /** Shows the textarea element */
        TerminalSettingId["DevMode"] = "terminal.integrated.developer.devMode";
    })(TerminalSettingId || (exports.TerminalSettingId = TerminalSettingId = {}));
    var PosixShellType;
    (function (PosixShellType) {
        PosixShellType["Bash"] = "bash";
        PosixShellType["Fish"] = "fish";
        PosixShellType["Sh"] = "sh";
        PosixShellType["Csh"] = "csh";
        PosixShellType["Ksh"] = "ksh";
        PosixShellType["Zsh"] = "zsh";
    })(PosixShellType || (exports.PosixShellType = PosixShellType = {}));
    var WindowsShellType;
    (function (WindowsShellType) {
        WindowsShellType["CommandPrompt"] = "cmd";
        WindowsShellType["Wsl"] = "wsl";
        WindowsShellType["GitBash"] = "gitbash";
    })(WindowsShellType || (exports.WindowsShellType = WindowsShellType = {}));
    var GeneralShellType;
    (function (GeneralShellType) {
        GeneralShellType["PowerShell"] = "pwsh";
        GeneralShellType["Python"] = "python";
        GeneralShellType["Julia"] = "julia";
        GeneralShellType["NuShell"] = "nu";
    })(GeneralShellType || (exports.GeneralShellType = GeneralShellType = {}));
    var TitleEventSource;
    (function (TitleEventSource) {
        /** From the API or the rename command that overrides any other type */
        TitleEventSource[TitleEventSource["Api"] = 0] = "Api";
        /** From the process name property*/
        TitleEventSource[TitleEventSource["Process"] = 1] = "Process";
        /** From the VT sequence */
        TitleEventSource[TitleEventSource["Sequence"] = 2] = "Sequence";
        /** Config changed */
        TitleEventSource[TitleEventSource["Config"] = 3] = "Config";
    })(TitleEventSource || (exports.TitleEventSource = TitleEventSource = {}));
    var TerminalIpcChannels;
    (function (TerminalIpcChannels) {
        /**
         * Communicates between the renderer process and shared process.
         */
        TerminalIpcChannels["LocalPty"] = "localPty";
        /**
         * Communicates between the shared process and the pty host process.
         */
        TerminalIpcChannels["PtyHost"] = "ptyHost";
        /**
         * Communicates between the renderer process and the pty host process.
         */
        TerminalIpcChannels["PtyHostWindow"] = "ptyHostWindow";
        /**
         * Deals with logging from the pty host process.
         */
        TerminalIpcChannels["Logger"] = "logger";
        /**
         * Enables the detection of unresponsive pty hosts.
         */
        TerminalIpcChannels["Heartbeat"] = "heartbeat";
    })(TerminalIpcChannels || (exports.TerminalIpcChannels = TerminalIpcChannels = {}));
    var ProcessPropertyType;
    (function (ProcessPropertyType) {
        ProcessPropertyType["Cwd"] = "cwd";
        ProcessPropertyType["InitialCwd"] = "initialCwd";
        ProcessPropertyType["FixedDimensions"] = "fixedDimensions";
        ProcessPropertyType["Title"] = "title";
        ProcessPropertyType["ShellType"] = "shellType";
        ProcessPropertyType["HasChildProcesses"] = "hasChildProcesses";
        ProcessPropertyType["ResolvedShellLaunchConfig"] = "resolvedShellLaunchConfig";
        ProcessPropertyType["OverrideDimensions"] = "overrideDimensions";
        ProcessPropertyType["FailedShellIntegrationActivation"] = "failedShellIntegrationActivation";
        ProcessPropertyType["UsedShellIntegrationInjection"] = "usedShellIntegrationInjection";
    })(ProcessPropertyType || (exports.ProcessPropertyType = ProcessPropertyType = {}));
    exports.$xs = (0, instantiation_1.$Ki)('ptyService');
    var HeartbeatConstants;
    (function (HeartbeatConstants) {
        /**
         * The duration between heartbeats
         */
        HeartbeatConstants[HeartbeatConstants["BeatInterval"] = 5000] = "BeatInterval";
        /**
         * The duration of the first heartbeat while the pty host is starting up. This is much larger
         * than the regular BeatInterval to accommodate slow machines, we still want to warn about the
         * pty host's unresponsiveness eventually though.
         */
        HeartbeatConstants[HeartbeatConstants["ConnectingBeatInterval"] = 20000] = "ConnectingBeatInterval";
        /**
         * Defines a multiplier for BeatInterval for how long to wait before starting the second wait
         * timer.
         */
        HeartbeatConstants[HeartbeatConstants["FirstWaitMultiplier"] = 1.2] = "FirstWaitMultiplier";
        /**
         * Defines a multiplier for BeatInterval for how long to wait before telling the user about
         * non-responsiveness. The second timer is to avoid informing the user incorrectly when waking
         * the computer up from sleep
         */
        HeartbeatConstants[HeartbeatConstants["SecondWaitMultiplier"] = 1] = "SecondWaitMultiplier";
        /**
         * How long to wait before telling the user about non-responsiveness when they try to create a
         * process. This short circuits the standard wait timeouts to tell the user sooner and only
         * create process is handled to avoid additional perf overhead.
         */
        HeartbeatConstants[HeartbeatConstants["CreateProcessTimeout"] = 5000] = "CreateProcessTimeout";
    })(HeartbeatConstants || (exports.HeartbeatConstants = HeartbeatConstants = {}));
    var TerminalLocation;
    (function (TerminalLocation) {
        TerminalLocation[TerminalLocation["Panel"] = 1] = "Panel";
        TerminalLocation[TerminalLocation["Editor"] = 2] = "Editor";
    })(TerminalLocation || (exports.TerminalLocation = TerminalLocation = {}));
    var TerminalLocationString;
    (function (TerminalLocationString) {
        TerminalLocationString["TerminalView"] = "view";
        TerminalLocationString["Editor"] = "editor";
    })(TerminalLocationString || (exports.TerminalLocationString = TerminalLocationString = {}));
    var LocalReconnectConstants;
    (function (LocalReconnectConstants) {
        /**
         * If there is no reconnection within this time-frame, consider the connection permanently closed...
        */
        LocalReconnectConstants[LocalReconnectConstants["GraceTime"] = 60000] = "GraceTime";
        /**
         * Maximal grace time between the first and the last reconnection...
        */
        LocalReconnectConstants[LocalReconnectConstants["ShortGraceTime"] = 6000] = "ShortGraceTime";
    })(LocalReconnectConstants || (exports.LocalReconnectConstants = LocalReconnectConstants = {}));
    var FlowControlConstants;
    (function (FlowControlConstants) {
        /**
         * The number of _unacknowledged_ chars to have been sent before the pty is paused in order for
         * the client to catch up.
         */
        FlowControlConstants[FlowControlConstants["HighWatermarkChars"] = 100000] = "HighWatermarkChars";
        /**
         * After flow control pauses the pty for the client the catch up, this is the number of
         * _unacknowledged_ chars to have been caught up to on the client before resuming the pty again.
         * This is used to attempt to prevent pauses in the flowing data; ideally while the pty is
         * paused the number of unacknowledged chars would always be greater than 0 or the client will
         * appear to stutter. In reality this balance is hard to accomplish though so heavy commands
         * will likely pause as latency grows, not flooding the connection is the important thing as
         * it's shared with other core functionality.
         */
        FlowControlConstants[FlowControlConstants["LowWatermarkChars"] = 5000] = "LowWatermarkChars";
        /**
         * The number characters that are accumulated on the client side before sending an ack event.
         * This must be less than or equal to LowWatermarkChars or the terminal max never unpause.
         */
        FlowControlConstants[FlowControlConstants["CharCountAckSize"] = 5000] = "CharCountAckSize";
    })(FlowControlConstants || (exports.FlowControlConstants = FlowControlConstants = {}));
    var ProfileSource;
    (function (ProfileSource) {
        ProfileSource["GitBash"] = "Git Bash";
        ProfileSource["Pwsh"] = "PowerShell";
    })(ProfileSource || (exports.ProfileSource = ProfileSource = {}));
    var ShellIntegrationStatus;
    (function (ShellIntegrationStatus) {
        /** No shell integration sequences have been encountered. */
        ShellIntegrationStatus[ShellIntegrationStatus["Off"] = 0] = "Off";
        /** Final term shell integration sequences have been encountered. */
        ShellIntegrationStatus[ShellIntegrationStatus["FinalTerm"] = 1] = "FinalTerm";
        /** VS Code shell integration sequences have been encountered. Supercedes FinalTerm. */
        ShellIntegrationStatus[ShellIntegrationStatus["VSCode"] = 2] = "VSCode";
    })(ShellIntegrationStatus || (exports.ShellIntegrationStatus = ShellIntegrationStatus = {}));
    var TerminalExitReason;
    (function (TerminalExitReason) {
        TerminalExitReason[TerminalExitReason["Unknown"] = 0] = "Unknown";
        TerminalExitReason[TerminalExitReason["Shutdown"] = 1] = "Shutdown";
        TerminalExitReason[TerminalExitReason["Process"] = 2] = "Process";
        TerminalExitReason[TerminalExitReason["User"] = 3] = "User";
        TerminalExitReason[TerminalExitReason["Extension"] = 4] = "Extension";
    })(TerminalExitReason || (exports.TerminalExitReason = TerminalExitReason = {}));
    exports.$ys = {
        Backend: 'workbench.contributions.terminal.processBackend'
    };
    class TerminalBackendRegistry {
        constructor() {
            this.a = new Map();
        }
        get backends() { return this.a; }
        registerTerminalBackend(backend) {
            const key = this.b(backend.remoteAuthority);
            if (this.a.has(key)) {
                throw new Error(`A terminal backend with remote authority '${key}' was already registered.`);
            }
            this.a.set(key, backend);
        }
        getTerminalBackend(remoteAuthority) {
            return this.a.get(this.b(remoteAuthority));
        }
        b(remoteAuthority) {
            // Normalize the key to lowercase as the authority is case-insensitive
            return remoteAuthority?.toLowerCase() ?? '';
        }
    }
    platform_1.$xo.add(exports.$ys.Backend, new TerminalBackendRegistry());
    exports.$zs = (0, instantiation_1.$Ki)('localPtyService');
    exports.$As = (0, instantiation_1.$Ki)('terminalLogService');
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[92/*vs/platform/terminal/common/terminalAutoResponder*/], __M([0/*require*/,1/*exports*/,12/*vs/base/common/async*/,2/*vs/base/common/lifecycle*/,3/*vs/base/common/platform*/]), function (require, exports, async_1, lifecycle_1, platform_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$yoc = void 0;
    /**
     * Tracks a terminal process's data stream and responds immediately when a matching string is
     * received. This is done in a low overhead way and is ideally run on the same process as the
     * where the process is handled to minimize latency.
     */
    class $yoc extends lifecycle_1.$Zc {
        constructor(proc, matchWord, response, logService) {
            super();
            this.a = 0;
            this.b = false;
            /**
             * Each reply is throttled by a second to avoid resource starvation and responding to screen
             * reprints on Winodws.
             */
            this.c = false;
            this.B(proc.onProcessData(e => {
                if (this.b || this.c) {
                    return;
                }
                const data = typeof e === 'string' ? e : e.data;
                for (let i = 0; i < data.length; i++) {
                    if (data[i] === matchWord[this.a]) {
                        this.a++;
                    }
                    else {
                        this.f();
                    }
                    // Auto reply and reset
                    if (this.a === matchWord.length) {
                        logService.debug(`Auto reply match: "${matchWord}", response: "${response}"`);
                        proc.input(response);
                        this.c = true;
                        (0, async_1.$Lh)(1000).then(() => this.c = false);
                        this.f();
                    }
                }
            }));
        }
        f() {
            this.a = 0;
        }
        /**
         * No auto response will happen after a resize on Windows in case the resize is a result of
         * reprinting the screen.
         */
        handleResize() {
            if (platform_1.$l) {
                this.b = true;
            }
        }
        handleInput() {
            this.b = false;
        }
    }
    exports.$yoc = $yoc;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[93/*vs/platform/terminal/common/terminalDataBuffering*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$mAb = void 0;
    class $mAb {
        constructor(b) {
            this.b = b;
            this.a = new Map();
        }
        dispose() {
            for (const buffer of this.a.values()) {
                buffer.dispose();
            }
        }
        startBuffering(id, event, throttleBy = 5) {
            const disposable = event((e) => {
                const data = (typeof e === 'string' ? e : e.data);
                let buffer = this.a.get(id);
                if (buffer) {
                    buffer.data.push(data);
                    return;
                }
                const timeoutId = setTimeout(() => this.flushBuffer(id), throttleBy);
                buffer = {
                    data: [data],
                    timeoutId: timeoutId,
                    dispose: () => {
                        clearTimeout(timeoutId);
                        this.flushBuffer(id);
                        disposable.dispose();
                    }
                };
                this.a.set(id, buffer);
            });
            return disposable;
        }
        stopBuffering(id) {
            const buffer = this.a.get(id);
            buffer?.dispose();
        }
        flushBuffer(id) {
            const buffer = this.a.get(id);
            if (buffer) {
                this.a.delete(id);
                this.b(id, buffer.data.join(''));
            }
        }
    }
    exports.$mAb = $mAb;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[41/*vs/platform/terminal/common/terminalEnvironment*/], __M([0/*require*/,1/*exports*/,3/*vs/base/common/platform*/]), function (require, exports, platform_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$CR = $CR;
    exports.$DR = $DR;
    exports.$ER = $ER;
    exports.$FR = $FR;
    /**
     * Aggressively escape non-windows paths to prepare for being sent to a shell. This will do some
     * escaping inaccurately to be careful about possible script injection via the file path. For
     * example, we're trying to prevent this sort of attack: `/foo/file$(echo evil)`.
     */
    function $CR(path) {
        let newPath = path;
        if (newPath.includes('\\')) {
            newPath = newPath.replace(/\\/g, '\\\\');
        }
        const bannedChars = /[\`\$\|\&\>\~\#\!\^\*\;\<\"\']/g;
        newPath = newPath.replace(bannedChars, '');
        return `'${newPath}'`;
    }
    /**
     * Collapses the user's home directory into `~` if it exists within the path, this gives a shorter
     * path that is more suitable within the context of a terminal.
     */
    function $DR(path, userHome, separator) {
        if (!path) {
            return '';
        }
        if (!userHome) {
            return path;
        }
        // Trim the trailing separator from the end if it exists
        if (userHome.match(/[\/\\]$/)) {
            userHome = userHome.slice(0, userHome.length - 1);
        }
        const normalizedPath = path.replace(/\\/g, '/').toLowerCase();
        const normalizedUserHome = userHome.replace(/\\/g, '/').toLowerCase();
        if (!normalizedPath.includes(normalizedUserHome)) {
            return path;
        }
        return `~${separator}${path.slice(userHome.length + 1)}`;
    }
    /**
     * Sanitizes a cwd string, removing any wrapping quotes and making the Windows drive letter
     * uppercase.
     * @param cwd The directory to sanitize.
     */
    function $ER(cwd) {
        // Sanity check that the cwd is not wrapped in quotes (see #160109)
        if (cwd.match(/^['"].*['"]$/)) {
            cwd = cwd.substring(1, cwd.length - 1);
        }
        // Make the drive letter uppercase on Windows (see #9448)
        if (platform_1.OS === platform_1.OperatingSystem.Windows && cwd && cwd[1] === ':') {
            return cwd[0].toUpperCase() + cwd.substring(1);
        }
        return cwd;
    }
    /**
     * Determines whether the given shell launch config should use the environment variable collection.
     * @param slc The shell launch config to check.
     */
    function $FR(slc) {
        return !slc.strictEnv;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[94/*vs/platform/terminal/common/terminalProcess*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$vs = $vs;
    var Constants;
    (function (Constants) {
        /**
         * Writing large amounts of data can be corrupted for some reason, after looking into this is
         * appears to be a race condition around writing to the FD which may be based on how powerful
         * the hardware is. The workaround for this is to space out when large amounts of data is being
         * written to the terminal. See https://github.com/microsoft/vscode/issues/38137
         */
        Constants[Constants["WriteMaxChunkSize"] = 50] = "WriteMaxChunkSize";
    })(Constants || (Constants = {}));
    /**
     * Splits incoming pty data into chunks to try prevent data corruption that could occur when pasting
     * large amounts of data.
     */
    function $vs(data) {
        const chunks = [];
        let nextChunkStartIndex = 0;
        for (let i = 0; i < data.length - 1; i++) {
            if (
            // If the max chunk size is reached
            i - nextChunkStartIndex + 1 >= Constants.WriteMaxChunkSize ||
                // If the next character is ESC, send the pending data to avoid splitting the escape
                // sequence.
                data[i + 1] === '\x1b') {
                chunks.push(data.substring(nextChunkStartIndex, i + 1));
                nextChunkStartIndex = i + 1;
                // Skip the next character as the chunk would be a single character
                i++;
            }
        }
        // Push final chunk
        if (nextChunkStartIndex !== data.length) {
            chunks.push(data.substring(nextChunkStartIndex));
        }
        return chunks;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[95/*vs/platform/terminal/common/terminalStrings*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$MZb = $MZb;
    /**
     * Formats a message from the product to be written to the terminal.
     */
    function $MZb(message, options = {}) {
        let result = '';
        if (!options.excludeLeadingNewLine) {
            result += '\r\n';
        }
        result += '\x1b[0m\x1b[7m * ';
        if (options.loudFormatting) {
            result += '\x1b[0;104m';
        }
        else {
            result += '\x1b[0m';
        }
        result += ` ${message} \x1b[0m\n\r`;
        return result;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[96/*vs/platform/terminal/common/xterm/shellIntegrationAddon*/], __M([0/*require*/,1/*exports*/,16/*vs/platform/terminal/common/terminal*/,2/*vs/base/common/lifecycle*/,88/*vs/platform/terminal/common/capabilities/terminalCapabilityStore*/,85/*vs/platform/terminal/common/capabilities/commandDetectionCapability*/,86/*vs/platform/terminal/common/capabilities/cwdDetectionCapability*/,23/*vs/platform/terminal/common/capabilities/capabilities*/,87/*vs/platform/terminal/common/capabilities/partialCommandDetectionCapability*/,4/*vs/base/common/event*/,82/*vs/platform/terminal/common/capabilities/bufferMarkCapability*/,6/*vs/base/common/uri*/,41/*vs/platform/terminal/common/terminalEnvironment*/,11/*vs/base/common/strings*/]), function (require, exports, terminal_1, lifecycle_1, terminalCapabilityStore_1, commandDetectionCapability_1, cwdDetectionCapability_1, capabilities_1, partialCommandDetectionCapability_1, event_1, bufferMarkCapability_1, uri_1, terminalEnvironment_1, strings_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$dzb = exports.ShellIntegrationOscPs = void 0;
    exports.$ezb = $ezb;
    exports.$fzb = $fzb;
    exports.$gzb = $gzb;
    /**
     * Shell integration is a feature that enhances the terminal's understanding of what's happening
     * in the shell by injecting special sequences into the shell's prompt using the "Set Text
     * Parameters" sequence (`OSC Ps ; Pt ST`).
     *
     * Definitions:
     * - OSC: `\x1b]`
     * - Ps:  A single (usually optional) numeric parameter, composed of one or more digits.
     * - Pt:  A text parameter composed of printable characters.
     * - ST: `\x7`
     *
     * This is inspired by a feature of the same name in the FinalTerm, iTerm2 and kitty terminals.
     */
    /**
     * The identifier for the first numeric parameter (`Ps`) for OSC commands used by shell integration.
     */
    var ShellIntegrationOscPs;
    (function (ShellIntegrationOscPs) {
        /**
         * Sequences pioneered by FinalTerm.
         */
        ShellIntegrationOscPs[ShellIntegrationOscPs["FinalTerm"] = 133] = "FinalTerm";
        /**
         * Sequences pioneered by VS Code. The number is derived from the least significant digit of
         * "VSC" when encoded in hex ("VSC" = 0x56, 0x53, 0x43).
         */
        ShellIntegrationOscPs[ShellIntegrationOscPs["VSCode"] = 633] = "VSCode";
        /**
         * Sequences pioneered by iTerm.
         */
        ShellIntegrationOscPs[ShellIntegrationOscPs["ITerm"] = 1337] = "ITerm";
        ShellIntegrationOscPs[ShellIntegrationOscPs["SetCwd"] = 7] = "SetCwd";
        ShellIntegrationOscPs[ShellIntegrationOscPs["SetWindowsFriendlyCwd"] = 9] = "SetWindowsFriendlyCwd";
    })(ShellIntegrationOscPs || (exports.ShellIntegrationOscPs = ShellIntegrationOscPs = {}));
    /**
     * Sequences pioneered by FinalTerm.
     */
    var FinalTermOscPt;
    (function (FinalTermOscPt) {
        /**
         * The start of the prompt, this is expected to always appear at the start of a line.
         *
         * Format: `OSC 133 ; A ST`
         */
        FinalTermOscPt["PromptStart"] = "A";
        /**
         * The start of a command, ie. where the user inputs their command.
         *
         * Format: `OSC 133 ; B ST`
         */
        FinalTermOscPt["CommandStart"] = "B";
        /**
         * Sent just before the command output begins.
         *
         * Format: `OSC 133 ; C ST`
         */
        FinalTermOscPt["CommandExecuted"] = "C";
        /**
         * Sent just after a command has finished. The exit code is optional, when not specified it
         * means no command was run (ie. enter on empty prompt or ctrl+c).
         *
         * Format: `OSC 133 ; D [; <ExitCode>] ST`
         */
        FinalTermOscPt["CommandFinished"] = "D";
    })(FinalTermOscPt || (FinalTermOscPt = {}));
    /**
     * VS Code-specific shell integration sequences. Some of these are based on more common alternatives
     * like those pioneered in {@link FinalTermOscPt FinalTerm}. The decision to move to entirely custom
     * sequences was to try to improve reliability and prevent the possibility of applications confusing
     * the terminal. If multiple shell integration scripts run, VS Code will prioritize the VS
     * Code-specific ones.
     *
     * It's recommended that authors of shell integration scripts use the common sequences (`133`)
     * when building general purpose scripts and the VS Code-specific (`633`) when targeting only VS
     * Code or when there are no other alternatives (eg. {@link CommandLine `633 ; E`}). These sequences
     * support mix-and-matching.
     */
    var VSCodeOscPt;
    (function (VSCodeOscPt) {
        /**
         * The start of the prompt, this is expected to always appear at the start of a line.
         *
         * Format: `OSC 633 ; A ST`
         *
         * Based on {@link FinalTermOscPt.PromptStart}.
         */
        VSCodeOscPt["PromptStart"] = "A";
        /**
         * The start of a command, ie. where the user inputs their command.
         *
         * Format: `OSC 633 ; B ST`
         *
         * Based on  {@link FinalTermOscPt.CommandStart}.
         */
        VSCodeOscPt["CommandStart"] = "B";
        /**
         * Sent just before the command output begins.
         *
         * Format: `OSC 633 ; C ST`
         *
         * Based on {@link FinalTermOscPt.CommandExecuted}.
         */
        VSCodeOscPt["CommandExecuted"] = "C";
        /**
         * Sent just after a command has finished. The exit code is optional, when not specified it
         * means no command was run (ie. enter on empty prompt or ctrl+c).
         *
         * Format: `OSC 633 ; D [; <ExitCode>] ST`
         *
         * Based on {@link FinalTermOscPt.CommandFinished}.
         */
        VSCodeOscPt["CommandFinished"] = "D";
        /**
         * Explicitly set the command line. This helps workaround performance and reliability problems
         * with parsing out the command, such as conpty not guaranteeing the position of the sequence or
         * the shell not guaranteeing that the entire command is even visible. Ideally this is called
         * immediately before {@link CommandExecuted}, immediately before {@link CommandFinished} will
         * also work but that means terminal will only know the accurate command line when the command is
         * finished.
         *
         * The command line can escape ascii characters using the `\xAB` format, where AB are the
         * hexadecimal representation of the character code (case insensitive), and escape the `\`
         * character using `\\`. It's required to escape semi-colon (`0x3b`) and characters 0x20 and
         * below, this is particularly important for new line and semi-colon.
         *
         * Some examples:
         *
         * ```
         * "\"  -> "\\"
         * "\n" -> "\x0a"
         * ";"  -> "\x3b"
         * ```
         *
         * An optional nonce can be provided which is may be required by the terminal in order enable
         * some features. This helps ensure no malicious command injection has occurred.
         *
         * Format: `OSC 633 ; E [; <CommandLine> [; <Nonce>]] ST`
         */
        VSCodeOscPt["CommandLine"] = "E";
        /**
         * Similar to prompt start but for line continuations.
         *
         * WARNING: This sequence is unfinalized, DO NOT use this in your shell integration script.
         */
        VSCodeOscPt["ContinuationStart"] = "F";
        /**
         * Similar to command start but for line continuations.
         *
         * WARNING: This sequence is unfinalized, DO NOT use this in your shell integration script.
         */
        VSCodeOscPt["ContinuationEnd"] = "G";
        /**
         * The start of the right prompt.
         *
         * WARNING: This sequence is unfinalized, DO NOT use this in your shell integration script.
         */
        VSCodeOscPt["RightPromptStart"] = "H";
        /**
         * The end of the right prompt.
         *
         * WARNING: This sequence is unfinalized, DO NOT use this in your shell integration script.
         */
        VSCodeOscPt["RightPromptEnd"] = "I";
        /**
         * Set the value of an arbitrary property, only known properties will be handled by VS Code.
         *
         * Format: `OSC 633 ; P ; <Property>=<Value> ST`
         *
         * Known properties:
         *
         * - `Cwd` - Reports the current working directory to the terminal.
         * - `IsWindows` - Indicates whether the terminal is using a Windows backend like winpty or
         *   conpty. This may be used to enable additional heuristics as the positioning of the shell
         *   integration sequences are not guaranteed to be correct. Valid values: `True`, `False`.
         * - `ContinuationPrompt` - Reports the continuation prompt that is printed at the start of
         *   multi-line inputs.
         *
         * WARNING: Any other properties may be changed and are not guaranteed to work in the future.
         */
        VSCodeOscPt["Property"] = "P";
        /**
         * Sets a mark/point-of-interest in the buffer.
         *
         * Format: `OSC 633 ; SetMark [; Id=<string>] [; Hidden]`
         *
         * `Id` - The identifier of the mark that can be used to reference it
         * `Hidden` - When set, the mark will be available to reference internally but will not visible
         *
         * WARNING: This sequence is unfinalized, DO NOT use this in your shell integration script.
         */
        VSCodeOscPt["SetMark"] = "SetMark";
    })(VSCodeOscPt || (VSCodeOscPt = {}));
    /**
     * ITerm sequences
     */
    var ITermOscPt;
    (function (ITermOscPt) {
        /**
         * Sets a mark/point-of-interest in the buffer.
         *
         * Format: `OSC 1337 ; SetMark`
         */
        ITermOscPt["SetMark"] = "SetMark";
        /**
         * Reports current working directory (CWD).
         *
         * Format: `OSC 1337 ; CurrentDir=<Cwd> ST`
         */
        ITermOscPt["CurrentDir"] = "CurrentDir";
    })(ITermOscPt || (ITermOscPt = {}));
    /**
     * The shell integration addon extends xterm by reading shell integration sequences and creating
     * capabilities and passing along relevant sequences to the capabilities. This is meant to
     * encapsulate all handling/parsing of sequences so the capabilities don't need to.
     */
    class $dzb extends lifecycle_1.$Zc {
        get status() { return this.g; }
        constructor(j, m, n, r) {
            super();
            this.j = j;
            this.m = m;
            this.n = n;
            this.r = r;
            this.capabilities = this.B(new terminalCapabilityStore_1.$9yb());
            this.b = false;
            this.f = [];
            this.g = terminal_1.ShellIntegrationStatus.Off;
            this.h = new event_1.$qe();
            this.onDidChangeStatus = this.h.event;
            this.B((0, lifecycle_1.$Xc)(() => {
                this.z();
                this.s();
            }));
        }
        s() {
            (0, lifecycle_1.$Uc)(this.f);
            this.f.length = 0;
        }
        activate(xterm) {
            this.a = xterm;
            this.capabilities.add(capabilities_1.TerminalCapability.PartialCommandDetection, this.B(new partialCommandDetectionCapability_1.$bzb(this.a)));
            this.B(xterm.parser.registerOscHandler(ShellIntegrationOscPs.VSCode, data => this.w(data)));
            this.B(xterm.parser.registerOscHandler(ShellIntegrationOscPs.ITerm, data => this.H(data)));
            this.f.push(xterm.parser.registerOscHandler(ShellIntegrationOscPs.FinalTerm, data => this.t(data)));
            this.B(xterm.parser.registerOscHandler(ShellIntegrationOscPs.SetCwd, data => this.J(data)));
            this.B(xterm.parser.registerOscHandler(ShellIntegrationOscPs.SetWindowsFriendlyCwd, data => this.I(data)));
            this.y();
        }
        getMarkerId(terminal, vscodeMarkerId) {
            this.N(terminal).getMark(vscodeMarkerId);
        }
        t(data) {
            const didHandle = this.u(data);
            if (this.g === terminal_1.ShellIntegrationStatus.Off) {
                this.g = terminal_1.ShellIntegrationStatus.FinalTerm;
                this.h.fire(this.g);
            }
            return didHandle;
        }
        u(data) {
            if (!this.a) {
                return false;
            }
            // Pass the sequence along to the capability
            // It was considered to disable the common protocol in order to not confuse the VS Code
            // shell integration if both happen for some reason. This doesn't work for powerlevel10k
            // when instant prompt is enabled though. If this does end up being a problem we could pass
            // a type flag through the capability calls
            const [command, ...args] = data.split(';');
            switch (command) {
                case FinalTermOscPt.PromptStart:
                    this.M(this.a).handlePromptStart();
                    return true;
                case FinalTermOscPt.CommandStart:
                    // Ignore the command line for these sequences as it's unreliable for example in powerlevel10k
                    this.M(this.a).handleCommandStart({ ignoreCommandLine: true });
                    return true;
                case FinalTermOscPt.CommandExecuted:
                    this.M(this.a).handleCommandExecuted();
                    return true;
                case FinalTermOscPt.CommandFinished: {
                    const exitCode = args.length === 1 ? parseInt(args[0]) : undefined;
                    this.M(this.a).handleCommandFinished(exitCode);
                    return true;
                }
            }
            return false;
        }
        w(data) {
            const didHandle = this.C(data);
            if (!this.b && didHandle) {
                this.n?.publicLog2('terminal/shellIntegrationActivationSucceeded');
                this.b = true;
                this.z();
            }
            if (this.g !== terminal_1.ShellIntegrationStatus.VSCode) {
                this.g = terminal_1.ShellIntegrationStatus.VSCode;
                this.h.fire(this.g);
            }
            return didHandle;
        }
        async y() {
            if (!this.n || this.m) {
                return;
            }
            this.c = setTimeout(() => {
                if (!this.capabilities.get(capabilities_1.TerminalCapability.CommandDetection) && !this.capabilities.get(capabilities_1.TerminalCapability.CwdDetection)) {
                    this.n?.publicLog2('terminal/shellIntegrationActivationTimeout');
                    this.r.warn('Shell integration failed to add capabilities within 10 seconds');
                }
                this.b = true;
            }, 10000);
        }
        z() {
            if (this.c !== undefined) {
                clearTimeout(this.c);
                this.c = undefined;
            }
        }
        C(data) {
            if (!this.a) {
                return false;
            }
            // Pass the sequence along to the capability
            const argsIndex = data.indexOf(';');
            const sequenceCommand = argsIndex === -1 ? data : data.substring(0, argsIndex);
            // Cast to strict checked index access
            const args = argsIndex === -1 ? [] : data.substring(argsIndex + 1).split(';');
            switch (sequenceCommand) {
                case VSCodeOscPt.PromptStart:
                    this.M(this.a).handlePromptStart();
                    return true;
                case VSCodeOscPt.CommandStart:
                    this.M(this.a).handleCommandStart();
                    return true;
                case VSCodeOscPt.CommandExecuted:
                    this.M(this.a).handleCommandExecuted();
                    return true;
                case VSCodeOscPt.CommandFinished: {
                    const arg0 = args[0];
                    const exitCode = arg0 !== undefined ? parseInt(arg0) : undefined;
                    this.M(this.a).handleCommandFinished(exitCode);
                    return true;
                }
                case VSCodeOscPt.CommandLine: {
                    const arg0 = args[0];
                    const arg1 = args[1];
                    let commandLine;
                    if (arg0 !== undefined) {
                        commandLine = $ezb(arg0);
                    }
                    else {
                        commandLine = '';
                    }
                    this.M(this.a).setCommandLine(commandLine, arg1 === this.j);
                    return true;
                }
                case VSCodeOscPt.ContinuationStart: {
                    this.M(this.a).handleContinuationStart();
                    return true;
                }
                case VSCodeOscPt.ContinuationEnd: {
                    this.M(this.a).handleContinuationEnd();
                    return true;
                }
                case VSCodeOscPt.RightPromptStart: {
                    this.M(this.a).handleRightPromptStart();
                    return true;
                }
                case VSCodeOscPt.RightPromptEnd: {
                    this.M(this.a).handleRightPromptEnd();
                    return true;
                }
                case VSCodeOscPt.Property: {
                    const arg0 = args[0];
                    const deserialized = arg0 !== undefined ? $ezb(arg0) : '';
                    const { key, value } = $fzb(deserialized);
                    if (value === undefined) {
                        return true;
                    }
                    switch (key) {
                        case 'ContinuationPrompt': {
                            this.D((0, strings_1.$8f)(value));
                            return true;
                        }
                        case 'Cwd': {
                            this.G(value);
                            return true;
                        }
                        case 'IsWindows': {
                            this.M(this.a).setIsWindowsPty(value === 'True' ? true : false);
                            return true;
                        }
                        case 'Prompt': {
                            // Remove escape sequences from the user's prompt
                            const sanitizedValue = value.replace(/\x1b\[[0-9;]*m/g, '');
                            this.F(sanitizedValue);
                            return true;
                        }
                        case 'Task': {
                            this.N(this.a);
                            this.capabilities.get(capabilities_1.TerminalCapability.CommandDetection)?.setIsCommandStorageDisabled();
                            return true;
                        }
                    }
                }
                case VSCodeOscPt.SetMark: {
                    this.N(this.a).addMark($gzb(args));
                    return true;
                }
            }
            // Unrecognized sequence
            return false;
        }
        D(value) {
            if (!this.a) {
                return;
            }
            this.M(this.a).setContinuationPrompt(value);
        }
        F(prompt) {
            if (!this.a) {
                return;
            }
            const lastPromptLine = prompt.substring(prompt.lastIndexOf('\n') + 1);
            const promptTerminator = lastPromptLine.substring(lastPromptLine.lastIndexOf(' '));
            if (promptTerminator) {
                this.M(this.a).setPromptTerminator(promptTerminator, lastPromptLine);
            }
        }
        G(value) {
            value = (0, terminalEnvironment_1.$ER)(value);
            this.L().updateCwd(value);
            const commandDetection = this.capabilities.get(capabilities_1.TerminalCapability.CommandDetection);
            commandDetection?.setCwd(value);
        }
        H(data) {
            if (!this.a) {
                return false;
            }
            const [command] = data.split(';');
            switch (command) {
                case ITermOscPt.SetMark: {
                    this.N(this.a).addMark();
                }
                default: {
                    // Checking for known `<key>=<value>` pairs.
                    // Note that unlike `VSCodeOscPt.Property`, iTerm2 does not interpret backslash or hex-escape sequences.
                    // See: https://github.com/gnachman/iTerm2/blob/bb0882332cec5196e4de4a4225978d746e935279/sources/VT100Terminal.m#L2089-L2105
                    const { key, value } = $fzb(command);
                    if (value === undefined) {
                        // No '=' was found, so it's not a property assignment.
                        return true;
                    }
                    switch (key) {
                        case ITermOscPt.CurrentDir:
                            // Encountered: `OSC 1337 ; CurrentDir=<Cwd> ST`
                            this.G(value);
                            return true;
                    }
                }
            }
            // Unrecognized sequence
            return false;
        }
        I(data) {
            if (!this.a) {
                return false;
            }
            const [command, ...args] = data.split(';');
            switch (command) {
                case '9':
                    // Encountered `OSC 9 ; 9 ; <cwd> ST`
                    if (args.length) {
                        this.G(args[0]);
                    }
                    return true;
            }
            // Unrecognized sequence
            return false;
        }
        /**
         * Handles the sequence: `OSC 7 ; scheme://cwd ST`
         */
        J(data) {
            if (!this.a) {
                return false;
            }
            const [command] = data.split(';');
            if (command.match(/^file:\/\/.*\//)) {
                const uri = uri_1.URI.parse(command);
                if (uri.path && uri.path.length > 0) {
                    this.G(uri.path);
                    return true;
                }
            }
            // Unrecognized sequence
            return false;
        }
        serialize() {
            if (!this.a || !this.capabilities.has(capabilities_1.TerminalCapability.CommandDetection)) {
                return {
                    isWindowsPty: false,
                    commands: [],
                    promptInputModel: undefined,
                };
            }
            const result = this.M(this.a).serialize();
            return result;
        }
        deserialize(serialized) {
            if (!this.a) {
                throw new Error('Cannot restore commands before addon is activated');
            }
            this.M(this.a).deserialize(serialized);
        }
        L() {
            let cwdDetection = this.capabilities.get(capabilities_1.TerminalCapability.CwdDetection);
            if (!cwdDetection) {
                cwdDetection = this.B(new cwdDetectionCapability_1.$azb());
                this.capabilities.add(capabilities_1.TerminalCapability.CwdDetection, cwdDetection);
            }
            return cwdDetection;
        }
        M(terminal) {
            let commandDetection = this.capabilities.get(capabilities_1.TerminalCapability.CommandDetection);
            if (!commandDetection) {
                commandDetection = this.B(new commandDetectionCapability_1.$$yb(terminal, this.r));
                this.capabilities.add(capabilities_1.TerminalCapability.CommandDetection, commandDetection);
            }
            return commandDetection;
        }
        N(terminal) {
            let bufferMarkDetection = this.capabilities.get(capabilities_1.TerminalCapability.BufferMarkDetection);
            if (!bufferMarkDetection) {
                bufferMarkDetection = this.B(new bufferMarkCapability_1.$czb(terminal));
                this.capabilities.add(capabilities_1.TerminalCapability.BufferMarkDetection, bufferMarkDetection);
            }
            return bufferMarkDetection;
        }
    }
    exports.$dzb = $dzb;
    function $ezb(message) {
        return message.replaceAll(
        // Backslash ('\') followed by an escape operator: either another '\', or 'x' and two hex chars.
        /\\(\\|x([0-9a-f]{2}))/gi, 
        // If it's a hex value, parse it to a character.
        // Otherwise the operator is '\', which we return literally, now unescaped.
        (_match, op, hex) => hex ? String.fromCharCode(parseInt(hex, 16)) : op);
    }
    function $fzb(message) {
        const separatorIndex = message.indexOf('=');
        if (separatorIndex === -1) {
            return { key: message, value: undefined }; // No '=' was found.
        }
        return {
            key: message.substring(0, separatorIndex),
            value: message.substring(1 + separatorIndex)
        };
    }
    function $gzb(sequence) {
        let id = undefined;
        let hidden = false;
        for (const property of sequence) {
            // Sanity check, this shouldn't happen in practice
            if (property === undefined) {
                continue;
            }
            if (property === 'Hidden') {
                hidden = true;
            }
            if (property.startsWith('Id=')) {
                id = property.substring(3);
            }
        }
        return { id, hidden };
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/









define(__m[42/*vs/platform/terminal/node/childProcessMonitor*/], __M([0/*require*/,1/*exports*/,5/*vs/base/common/path*/,14/*vs/base/common/decorators*/,4/*vs/base/common/event*/,2/*vs/base/common/lifecycle*/,64/*vs/base/node/ps*/,9/*vs/platform/log/common/log*/]), function (require, exports, path_1, decorators_1, event_1, lifecycle_1, ps_1, log_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$Aoc = exports.$zoc = void 0;
    var Constants;
    (function (Constants) {
        /**
         * The amount of time to throttle checks when the process receives output.
         */
        Constants[Constants["InactiveThrottleDuration"] = 5000] = "InactiveThrottleDuration";
        /**
         * The amount of time to debounce check when the process receives input.
         */
        Constants[Constants["ActiveDebounceDuration"] = 1000] = "ActiveDebounceDuration";
    })(Constants || (Constants = {}));
    exports.$zoc = [];
    /**
     * Monitors a process for child processes, checking at differing times depending on input and output
     * calls into the monitor.
     */
    let $Aoc = class $Aoc extends lifecycle_1.$Zc {
        set hasChildProcesses(value) {
            if (this.a !== value) {
                this.a = value;
                this.f.debug('ChildProcessMonitor: Has child processes changed', value);
                this.b.fire(value);
            }
        }
        /**
         * Whether the process has child processes.
         */
        get hasChildProcesses() { return this.a; }
        constructor(c, f) {
            super();
            this.c = c;
            this.f = f;
            this.a = false;
            this.b = this.B(new event_1.$qe());
            /**
             * An event that fires when whether the process has child processes changes.
             */
            this.onDidChangeHasChildProcesses = this.b.event;
        }
        /**
         * Input was triggered on the process.
         */
        handleInput() {
            this.g();
        }
        /**
         * Output was triggered on the process.
         */
        handleOutput() {
            this.h();
        }
        async g() {
            if (this.q.isDisposed) {
                return;
            }
            try {
                const processItem = await (0, ps_1.$6s)(this.c);
                this.hasChildProcesses = this.j(processItem);
            }
            catch (e) {
                this.f.debug('ChildProcessMonitor: Fetching process tree failed', e);
            }
        }
        h() {
            this.g();
        }
        j(processItem) {
            // No child processes
            if (!processItem.children) {
                return false;
            }
            // A single child process, handle special cases
            if (processItem.children.length === 1) {
                const item = processItem.children[0];
                let cmd;
                if (item.cmd.startsWith(`"`)) {
                    cmd = item.cmd.substring(1, item.cmd.indexOf(`"`, 1));
                }
                else {
                    const spaceIndex = item.cmd.indexOf(` `);
                    if (spaceIndex === -1) {
                        cmd = item.cmd;
                    }
                    else {
                        cmd = item.cmd.substring(0, spaceIndex);
                    }
                }
                return exports.$zoc.indexOf((0, path_1.$vc)(cmd).name) === -1;
            }
            // Fallback, count child processes
            return processItem.children.length > 0;
        }
    };
    exports.$Aoc = $Aoc;
    __decorate([
        (0, decorators_1.$di)(Constants.ActiveDebounceDuration)
    ], $Aoc.prototype, "g", null);
    __decorate([
        (0, decorators_1.$ei)(Constants.InactiveThrottleDuration)
    ], $Aoc.prototype, "h", null);
    exports.$Aoc = $Aoc = __decorate([
        __param(1, log_1.$fk)
    ], $Aoc);
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[97/*vs/platform/terminal/node/heartbeatService*/], __M([0/*require*/,1/*exports*/,4/*vs/base/common/event*/,2/*vs/base/common/lifecycle*/,16/*vs/platform/terminal/common/terminal*/]), function (require, exports, event_1, lifecycle_1, terminal_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$Boc = void 0;
    class $Boc extends lifecycle_1.$Zc {
        constructor() {
            super();
            this.a = this.B(new event_1.$qe());
            this.onBeat = this.a.event;
            const interval = setInterval(() => {
                this.a.fire();
            }, terminal_1.HeartbeatConstants.BeatInterval);
            this.B((0, lifecycle_1.$Xc)(() => clearInterval(interval)));
        }
    }
    exports.$Boc = $Boc;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/























define(__m[43/*vs/platform/terminal/node/terminalEnvironment*/], __M([0/*require*/,1/*exports*/,21/*os*/,20/*vs/base/common/network*/,32/*vs/base/common/objects*/,5/*vs/base/common/path*/,3/*vs/base/common/platform*/,15/*vs/base/common/process*/,11/*vs/base/common/strings*/,10/*vs/base/common/types*/,28/*vs/base/node/pfs*/,40/*vs/platform/terminal/common/environmentVariable*/,90/*vs/platform/terminal/common/environmentVariableShared*/,89/*vs/platform/terminal/common/environmentVariableCollection*/]), function (require, exports, os, network_1, objects_1, path, platform_1, process, strings_1, types_1, pfs, environmentVariable_1, environmentVariableShared_1, environmentVariableCollection_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$Us = $Us;
    exports.$Vs = $Vs;
    exports.$Ws = $Ws;
    os = __importStar(os);
    path = __importStar(path);
    process = __importStar(process);
    pfs = __importStar(pfs);
    function $Us() {
        const osVersion = (/(\d+)\.(\d+)\.(\d+)/g).exec(os.release());
        let buildNumber = 0;
        if (osVersion && osVersion.length === 4) {
            buildNumber = parseInt(osVersion[3]);
        }
        return buildNumber;
    }
    async function $Vs(command, cwd, paths, env = process.env, exists = pfs.Promises.exists) {
        // If we have an absolute path then we take it.
        if (path.$nc(command)) {
            return await exists(command) ? command : undefined;
        }
        if (cwd === undefined) {
            cwd = process.cwd();
        }
        const dir = path.$rc(command);
        if (dir !== '.') {
            // We have a directory and the directory is relative (see above). Make the path absolute
            // to the current working directory.
            const fullPath = path.$oc(cwd, command);
            return await exists(fullPath) ? fullPath : undefined;
        }
        const envPath = (0, objects_1.$ro)(env, 'PATH');
        if (paths === undefined && (0, types_1.$jg)(envPath)) {
            paths = envPath.split(path.$yc);
        }
        // No PATH environment. Make path absolute to the cwd.
        if (paths === undefined || paths.length === 0) {
            const fullPath = path.$oc(cwd, command);
            return await exists(fullPath) ? fullPath : undefined;
        }
        // We have a simple file name. We get the path variable from the env
        // and try to find the executable on the path.
        for (const pathEntry of paths) {
            // The path entry is absolute.
            let fullPath;
            if (path.$nc(pathEntry)) {
                fullPath = path.$oc(pathEntry, command);
            }
            else {
                fullPath = path.$oc(cwd, pathEntry, command);
            }
            if (await exists(fullPath)) {
                return fullPath;
            }
            if (platform_1.$l) {
                let withExtension = fullPath + '.com';
                if (await exists(withExtension)) {
                    return withExtension;
                }
                withExtension = fullPath + '.exe';
                if (await exists(withExtension)) {
                    return withExtension;
                }
            }
        }
        const fullPath = path.$oc(cwd, command);
        return await exists(fullPath) ? fullPath : undefined;
    }
    /**
     * For a given shell launch config, returns arguments to replace and an optional environment to
     * mixin to the SLC's environment to enable shell integration. This must be run within the context
     * that creates the process to ensure accuracy. Returns undefined if shell integration cannot be
     * enabled.
     */
    function $Ws(shellLaunchConfig, options, env, logService, productService) {
        // Conditionally disable shell integration arg injection
        // - The global setting is disabled
        // - There is no executable (not sure what script to run)
        // - The terminal is used by a feature like tasks or debugging
        const useWinpty = platform_1.$l && (!options.windowsEnableConpty || $Us() < 18309);
        if (
        // The global setting is disabled
        !options.shellIntegration.enabled ||
            // There is no executable (so there's no way to determine how to inject)
            !shellLaunchConfig.executable ||
            // It's a feature terminal (tasks, debug), unless it's explicitly being forced
            (shellLaunchConfig.isFeatureTerminal && !shellLaunchConfig.forceShellIntegration) ||
            // The ignoreShellIntegration flag is passed (eg. relaunching without shell integration)
            shellLaunchConfig.ignoreShellIntegration ||
            // Winpty is unsupported
            useWinpty) {
            return undefined;
        }
        const originalArgs = shellLaunchConfig.args;
        const shell = process.$ic === 'win32' ? path.$sc(shellLaunchConfig.executable).toLowerCase() : path.$sc(shellLaunchConfig.executable);
        const appRoot = path.$rc(network_1.$5g.asFileUri('').fsPath);
        let newArgs;
        const envMixin = {
            'VSCODE_INJECTION': '1'
        };
        if (options.shellIntegration.nonce) {
            envMixin['VSCODE_NONCE'] = options.shellIntegration.nonce;
        }
        // Windows
        if (platform_1.$l) {
            if (shell === 'pwsh.exe' || shell === 'powershell.exe') {
                if (!originalArgs || arePwshImpliedArgs(originalArgs)) {
                    newArgs = shellIntegrationArgs.get(ShellIntegrationExecutable.WindowsPwsh);
                }
                else if (arePwshLoginArgs(originalArgs)) {
                    newArgs = shellIntegrationArgs.get(ShellIntegrationExecutable.WindowsPwshLogin);
                }
                if (!newArgs) {
                    return undefined;
                }
                newArgs = [...newArgs]; // Shallow clone the array to avoid setting the default array
                newArgs[newArgs.length - 1] = (0, strings_1.$if)(newArgs[newArgs.length - 1], appRoot, '');
                envMixin['VSCODE_STABLE'] = productService.quality === 'stable' ? '1' : '0';
                if (options.shellIntegration.suggestEnabled) {
                    envMixin['VSCODE_SUGGEST'] = '1';
                }
                return { newArgs, envMixin };
            }
            else if (shell === 'bash.exe') {
                if (!originalArgs || originalArgs.length === 0) {
                    newArgs = shellIntegrationArgs.get(ShellIntegrationExecutable.Bash);
                }
                else if (areZshBashLoginArgs(originalArgs)) {
                    envMixin['VSCODE_SHELL_LOGIN'] = '1';
                    addEnvMixinPathPrefix(options, envMixin);
                    newArgs = shellIntegrationArgs.get(ShellIntegrationExecutable.Bash);
                }
                if (!newArgs) {
                    return undefined;
                }
                newArgs = [...newArgs]; // Shallow clone the array to avoid setting the default array
                newArgs[newArgs.length - 1] = (0, strings_1.$if)(newArgs[newArgs.length - 1], appRoot);
                envMixin['VSCODE_STABLE'] = productService.quality === 'stable' ? '1' : '0';
                return { newArgs, envMixin };
            }
            logService.warn(`Shell integration cannot be enabled for executable "${shellLaunchConfig.executable}" and args`, shellLaunchConfig.args);
            return undefined;
        }
        // Linux & macOS
        switch (shell) {
            case 'bash': {
                if (!originalArgs || originalArgs.length === 0) {
                    newArgs = shellIntegrationArgs.get(ShellIntegrationExecutable.Bash);
                }
                else if (areZshBashLoginArgs(originalArgs)) {
                    envMixin['VSCODE_SHELL_LOGIN'] = '1';
                    addEnvMixinPathPrefix(options, envMixin);
                    newArgs = shellIntegrationArgs.get(ShellIntegrationExecutable.Bash);
                }
                if (!newArgs) {
                    return undefined;
                }
                newArgs = [...newArgs]; // Shallow clone the array to avoid setting the default array
                newArgs[newArgs.length - 1] = (0, strings_1.$if)(newArgs[newArgs.length - 1], appRoot);
                envMixin['VSCODE_STABLE'] = productService.quality === 'stable' ? '1' : '0';
                return { newArgs, envMixin };
            }
            case 'fish': {
                // The injection mechanism used for fish is to add a custom dir to $XDG_DATA_DIRS which
                // is similar to $ZDOTDIR in zsh but contains a list of directories to run from.
                const oldDataDirs = env?.XDG_DATA_DIRS ?? '/usr/local/share:/usr/share';
                const newDataDir = path.$oc(appRoot, 'out/vs/workbench/contrib/terminal/browser/media/fish_xdg_data');
                envMixin['XDG_DATA_DIRS'] = `${oldDataDirs}:${newDataDir}`;
                addEnvMixinPathPrefix(options, envMixin);
                return { newArgs: undefined, envMixin };
            }
            case 'pwsh': {
                if (!originalArgs || arePwshImpliedArgs(originalArgs)) {
                    newArgs = shellIntegrationArgs.get(ShellIntegrationExecutable.Pwsh);
                }
                else if (arePwshLoginArgs(originalArgs)) {
                    newArgs = shellIntegrationArgs.get(ShellIntegrationExecutable.PwshLogin);
                }
                if (!newArgs) {
                    return undefined;
                }
                if (options.shellIntegration.suggestEnabled) {
                    envMixin['VSCODE_SUGGEST'] = '1';
                }
                newArgs = [...newArgs]; // Shallow clone the array to avoid setting the default array
                newArgs[newArgs.length - 1] = (0, strings_1.$if)(newArgs[newArgs.length - 1], appRoot, '');
                envMixin['VSCODE_STABLE'] = productService.quality === 'stable' ? '1' : '0';
                return { newArgs, envMixin };
            }
            case 'zsh': {
                if (!originalArgs || originalArgs.length === 0) {
                    newArgs = shellIntegrationArgs.get(ShellIntegrationExecutable.Zsh);
                }
                else if (areZshBashLoginArgs(originalArgs)) {
                    newArgs = shellIntegrationArgs.get(ShellIntegrationExecutable.ZshLogin);
                    addEnvMixinPathPrefix(options, envMixin);
                }
                else if (originalArgs === shellIntegrationArgs.get(ShellIntegrationExecutable.Zsh) || originalArgs === shellIntegrationArgs.get(ShellIntegrationExecutable.ZshLogin)) {
                    newArgs = originalArgs;
                }
                if (!newArgs) {
                    return undefined;
                }
                newArgs = [...newArgs]; // Shallow clone the array to avoid setting the default array
                newArgs[newArgs.length - 1] = (0, strings_1.$if)(newArgs[newArgs.length - 1], appRoot);
                // Move .zshrc into $ZDOTDIR as the way to activate the script
                let username;
                try {
                    username = os.userInfo().username;
                }
                catch {
                    username = 'unknown';
                }
                const zdotdir = path.$oc(os.tmpdir(), `${username}-${productService.applicationName}-zsh`);
                envMixin['ZDOTDIR'] = zdotdir;
                const userZdotdir = env?.ZDOTDIR ?? os.homedir() ?? `~`;
                envMixin['USER_ZDOTDIR'] = userZdotdir;
                const filesToCopy = [];
                filesToCopy.push({
                    source: path.$oc(appRoot, 'out/vs/workbench/contrib/terminal/browser/media/shellIntegration-rc.zsh'),
                    dest: path.$oc(zdotdir, '.zshrc')
                });
                filesToCopy.push({
                    source: path.$oc(appRoot, 'out/vs/workbench/contrib/terminal/browser/media/shellIntegration-profile.zsh'),
                    dest: path.$oc(zdotdir, '.zprofile')
                });
                filesToCopy.push({
                    source: path.$oc(appRoot, 'out/vs/workbench/contrib/terminal/browser/media/shellIntegration-env.zsh'),
                    dest: path.$oc(zdotdir, '.zshenv')
                });
                filesToCopy.push({
                    source: path.$oc(appRoot, 'out/vs/workbench/contrib/terminal/browser/media/shellIntegration-login.zsh'),
                    dest: path.$oc(zdotdir, '.zlogin')
                });
                return { newArgs, envMixin, filesToCopy };
            }
        }
        logService.warn(`Shell integration cannot be enabled for executable "${shellLaunchConfig.executable}" and args`, shellLaunchConfig.args);
        return undefined;
    }
    /**
     * On macOS the profile calls path_helper which adds a bunch of standard bin directories to the
     * beginning of the PATH. This causes significant problems for the environment variable
     * collection API as the custom paths added to the end will now be somewhere in the middle of
     * the PATH. To combat this, VSCODE_PATH_PREFIX is used to re-apply any prefix after the profile
     * has run. This will cause duplication in the PATH but should fix the issue.
     *
     * See #99878 for more information.
     */
    function addEnvMixinPathPrefix(options, envMixin) {
        if (platform_1.$m && options.environmentVariableCollections) {
            // Deserialize and merge
            const deserialized = (0, environmentVariableShared_1.$Ss)(options.environmentVariableCollections);
            const merged = new environmentVariableCollection_1.$Ts(deserialized);
            // Get all prepend PATH entries
            const pathEntry = merged.getVariableMap({ workspaceFolder: options.workspaceFolder }).get('PATH');
            const prependToPath = [];
            if (pathEntry) {
                for (const mutator of pathEntry) {
                    if (mutator.type === environmentVariable_1.EnvironmentVariableMutatorType.Prepend) {
                        prependToPath.push(mutator.value);
                    }
                }
            }
            // Add to the environment mixin to be applied in the shell integration script
            if (prependToPath.length > 0) {
                envMixin['VSCODE_PATH_PREFIX'] = prependToPath.join('');
            }
        }
    }
    var ShellIntegrationExecutable;
    (function (ShellIntegrationExecutable) {
        ShellIntegrationExecutable["WindowsPwsh"] = "windows-pwsh";
        ShellIntegrationExecutable["WindowsPwshLogin"] = "windows-pwsh-login";
        ShellIntegrationExecutable["Pwsh"] = "pwsh";
        ShellIntegrationExecutable["PwshLogin"] = "pwsh-login";
        ShellIntegrationExecutable["Zsh"] = "zsh";
        ShellIntegrationExecutable["ZshLogin"] = "zsh-login";
        ShellIntegrationExecutable["Bash"] = "bash";
    })(ShellIntegrationExecutable || (ShellIntegrationExecutable = {}));
    const shellIntegrationArgs = new Map();
    // The try catch swallows execution policy errors in the case of the archive distributable
    shellIntegrationArgs.set(ShellIntegrationExecutable.WindowsPwsh, ['-noexit', '-command', 'try { . \"{0}\\out\\vs\\workbench\\contrib\\terminal\\browser\\media\\shellIntegration.ps1\" } catch {}{1}']);
    shellIntegrationArgs.set(ShellIntegrationExecutable.WindowsPwshLogin, ['-l', '-noexit', '-command', 'try { . \"{0}\\out\\vs\\workbench\\contrib\\terminal\\browser\\media\\shellIntegration.ps1\" } catch {}{1}']);
    shellIntegrationArgs.set(ShellIntegrationExecutable.Pwsh, ['-noexit', '-command', '. "{0}/out/vs/workbench/contrib/terminal/browser/media/shellIntegration.ps1"{1}']);
    shellIntegrationArgs.set(ShellIntegrationExecutable.PwshLogin, ['-l', '-noexit', '-command', '. "{0}/out/vs/workbench/contrib/terminal/browser/media/shellIntegration.ps1"']);
    shellIntegrationArgs.set(ShellIntegrationExecutable.Zsh, ['-i']);
    shellIntegrationArgs.set(ShellIntegrationExecutable.ZshLogin, ['-il']);
    shellIntegrationArgs.set(ShellIntegrationExecutable.Bash, ['--init-file', '{0}/out/vs/workbench/contrib/terminal/browser/media/shellIntegration-bash.sh']);
    const pwshLoginArgs = ['-login', '-l'];
    const shLoginArgs = ['--login', '-l'];
    const shInteractiveArgs = ['-i', '--interactive'];
    const pwshImpliedArgs = ['-nol', '-nologo'];
    function arePwshLoginArgs(originalArgs) {
        if (typeof originalArgs === 'string') {
            return pwshLoginArgs.includes(originalArgs.toLowerCase());
        }
        else {
            return originalArgs.length === 1 && pwshLoginArgs.includes(originalArgs[0].toLowerCase()) ||
                (originalArgs.length === 2 &&
                    (((pwshLoginArgs.includes(originalArgs[0].toLowerCase())) || pwshLoginArgs.includes(originalArgs[1].toLowerCase())))
                    && ((pwshImpliedArgs.includes(originalArgs[0].toLowerCase())) || pwshImpliedArgs.includes(originalArgs[1].toLowerCase())));
        }
    }
    function arePwshImpliedArgs(originalArgs) {
        if (typeof originalArgs === 'string') {
            return pwshImpliedArgs.includes(originalArgs.toLowerCase());
        }
        else {
            return originalArgs.length === 0 || originalArgs?.length === 1 && pwshImpliedArgs.includes(originalArgs[0].toLowerCase());
        }
    }
    function areZshBashLoginArgs(originalArgs) {
        if (typeof originalArgs !== 'string') {
            originalArgs = originalArgs.filter(arg => !shInteractiveArgs.includes(arg.toLowerCase()));
        }
        return originalArgs === 'string' && shLoginArgs.includes(originalArgs.toLowerCase())
            || typeof originalArgs !== 'string' && originalArgs.length === 1 && shLoginArgs.includes(originalArgs[0].toLowerCase());
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/





























define(__m[98/*vs/platform/terminal/node/windowsShellHelper*/], __M([0/*require*/,1/*exports*/,12/*vs/base/common/async*/,14/*vs/base/common/decorators*/,4/*vs/base/common/event*/,2/*vs/base/common/lifecycle*/,3/*vs/base/common/platform*/,16/*vs/platform/terminal/common/terminal*/]), function (require, exports, async_1, decorators_1, event_1, lifecycle_1, platform_1, terminal_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$Coc = void 0;
    const SHELL_EXECUTABLES = [
        'cmd.exe',
        'powershell.exe',
        'pwsh.exe',
        'bash.exe',
        'wsl.exe',
        'ubuntu.exe',
        'ubuntu1804.exe',
        'kali.exe',
        'debian.exe',
        'opensuse-42.exe',
        'sles-12.exe'
    ];
    let windowsProcessTree;
    class $Coc extends lifecycle_1.$Zc {
        get shellType() { return this.b; }
        get shellTitle() { return this.c; }
        get onShellNameChanged() { return this.f.event; }
        get onShellTypeChanged() { return this.g.event; }
        constructor(h) {
            super();
            this.h = h;
            this.c = '';
            this.f = new event_1.$qe();
            this.g = new event_1.$qe();
            if (!platform_1.$l) {
                throw new Error(`WindowsShellHelper cannot be instantiated on ${platform_1.$x}`);
            }
            this.j();
        }
        async j() {
            if (this.q.isDisposed) {
                return;
            }
            this.checkShell();
        }
        async checkShell() {
            if (platform_1.$l) {
                // Wait to give the shell some time to actually launch a process, this
                // could lead to a race condition but it would be recovered from when
                // data stops and should cover the majority of cases
                await (0, async_1.$Lh)(300);
                this.getShellName().then(title => {
                    const type = this.getShellType(title);
                    if (type !== this.b) {
                        this.g.fire(type);
                        this.f.fire(title);
                        this.b = type;
                        this.c = title;
                    }
                });
            }
        }
        m(tree) {
            if (!tree) {
                return '';
            }
            if (SHELL_EXECUTABLES.indexOf(tree.name) === -1) {
                return tree.name;
            }
            if (!tree.children || tree.children.length === 0) {
                return tree.name;
            }
            let favouriteChild = 0;
            for (; favouriteChild < tree.children.length; favouriteChild++) {
                const child = tree.children[favouriteChild];
                if (!child.children || child.children.length === 0) {
                    break;
                }
                if (child.children[0].name !== 'conhost.exe') {
                    break;
                }
            }
            if (favouriteChild >= tree.children.length) {
                return tree.name;
            }
            return this.m(tree.children[favouriteChild]);
        }
        /**
         * Returns the innermost shell executable running in the terminal
         */
        async getShellName() {
            if (this.q.isDisposed) {
                return Promise.resolve('');
            }
            // Prevent multiple requests at once, instead return current request
            if (this.a) {
                return this.a;
            }
            if (!windowsProcessTree) {
                windowsProcessTree = await new Promise((resolve_1, reject_1) => { require(['@vscode/windows-process-tree'], resolve_1, reject_1); }).then(__importStar);
            }
            this.a = new Promise(resolve => {
                windowsProcessTree.getProcessTree(this.h, tree => {
                    const name = this.m(tree);
                    this.a = undefined;
                    resolve(name);
                });
            });
            return this.a;
        }
        getShellType(executable) {
            switch (executable.toLowerCase()) {
                case 'cmd.exe':
                    return terminal_1.WindowsShellType.CommandPrompt;
                case 'powershell.exe':
                case 'pwsh.exe':
                    return terminal_1.GeneralShellType.PowerShell;
                case 'bash.exe':
                case 'git-cmd.exe':
                    return terminal_1.WindowsShellType.GitBash;
                case 'julia.exe:':
                    return terminal_1.GeneralShellType.Julia;
                case 'nu.exe':
                    return terminal_1.GeneralShellType.NuShell;
                case 'wsl.exe':
                case 'ubuntu.exe':
                case 'ubuntu1804.exe':
                case 'kali.exe':
                case 'debian.exe':
                case 'opensuse-42.exe':
                case 'sles-12.exe':
                    return terminal_1.WindowsShellType.Wsl;
                default:
                    if (executable.match(/python(\d(\.\d{0,2})?)?\.exe/)) {
                        return terminal_1.GeneralShellType.Python;
                    }
                    return undefined;
            }
        }
    }
    exports.$Coc = $Coc;
    __decorate([
        (0, decorators_1.$di)(500)
    ], $Coc.prototype, "checkShell", null);
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
































define(__m[99/*vs/platform/terminal/node/terminalProcess*/], __M([0/*require*/,1/*exports*/,37/*fs*/,29/*child_process*/,12/*vs/base/common/async*/,4/*vs/base/common/event*/,2/*vs/base/common/lifecycle*/,5/*vs/base/common/path*/,3/*vs/base/common/platform*/,6/*vs/base/common/uri*/,8/*vs/nls*/,9/*vs/platform/log/common/log*/,80/*vs/platform/product/common/productService*/,16/*vs/platform/terminal/common/terminal*/,42/*vs/platform/terminal/node/childProcessMonitor*/,43/*vs/platform/terminal/node/terminalEnvironment*/,98/*vs/platform/terminal/node/windowsShellHelper*/,103/*node-pty*/,94/*vs/platform/terminal/common/terminalProcess*/]), function (require, exports, fs, child_process_1, async_1, event_1, lifecycle_1, path, platform_1, uri_1, nls_1, log_1, productService_1, terminal_1, childProcessMonitor_1, terminalEnvironment_1, windowsShellHelper_1, node_pty_1, terminalProcess_1) {
    "use strict";
    var $Doc_1;
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$Doc = void 0;
    fs = __importStar(fs);
    path = __importStar(path);
    var ShutdownConstants;
    (function (ShutdownConstants) {
        /**
         * The amount of ms that must pass between data events after exit is queued before the actual
         * kill call is triggered. This data flush mechanism works around an [issue in node-pty][1]
         * where not all data is flushed which causes problems for task problem matchers. Additionally
         * on Windows under conpty, killing a process while data is being output will cause the [conhost
         * flush to hang the pty host][2] because [conhost should be hosted on another thread][3].
         *
         * [1]: https://github.com/Tyriar/node-pty/issues/72
         * [2]: https://github.com/microsoft/vscode/issues/71966
         * [3]: https://github.com/microsoft/node-pty/pull/415
         */
        ShutdownConstants[ShutdownConstants["DataFlushTimeout"] = 250] = "DataFlushTimeout";
        /**
         * The maximum ms to allow after dispose is called because forcefully killing the process.
         */
        ShutdownConstants[ShutdownConstants["MaximumShutdownTime"] = 5000] = "MaximumShutdownTime";
    })(ShutdownConstants || (ShutdownConstants = {}));
    var Constants;
    (function (Constants) {
        /**
         * The minimum duration between kill and spawn calls on Windows/conpty as a mitigation for a
         * hang issue. See:
         * - https://github.com/microsoft/vscode/issues/71966
         * - https://github.com/microsoft/vscode/issues/117956
         * - https://github.com/microsoft/vscode/issues/121336
         */
        Constants[Constants["KillSpawnThrottleInterval"] = 250] = "KillSpawnThrottleInterval";
        /**
         * The amount of time to wait when a call is throttles beyond the exact amount, this is used to
         * try prevent early timeouts causing a kill/spawn call to happen at double the regular
         * interval.
         */
        Constants[Constants["KillSpawnSpacingDuration"] = 50] = "KillSpawnSpacingDuration";
        /**
         * How long to wait between chunk writes.
         */
        Constants[Constants["WriteInterval"] = 5] = "WriteInterval";
    })(Constants || (Constants = {}));
    const posixShellTypeMap = new Map([
        ['bash', terminal_1.PosixShellType.Bash],
        ['csh', terminal_1.PosixShellType.Csh],
        ['fish', terminal_1.PosixShellType.Fish],
        ['ksh', terminal_1.PosixShellType.Ksh],
        ['sh', terminal_1.PosixShellType.Sh],
        ['zsh', terminal_1.PosixShellType.Zsh]
    ]);
    const generalShellTypeMap = new Map([
        ['pwsh', terminal_1.GeneralShellType.PowerShell],
        ['python', terminal_1.GeneralShellType.Python],
        ['julia', terminal_1.GeneralShellType.Julia],
        ['nu', terminal_1.GeneralShellType.NuShell],
    ]);
    let $Doc = class $Doc extends lifecycle_1.$Zc {
        static { $Doc_1 = this; }
        static { this.b = 0; }
        get exitMessage() { return this.h; }
        get currentTitle() { return this.t?.shellTitle || this.n; }
        get shellType() { return platform_1.$l ? this.t?.shellType : posixShellTypeMap.get(this.n) || generalShellTypeMap.get(this.n); }
        get hasChildProcesses() { return this.u?.hasChildProcesses || false; }
        constructor(shellLaunchConfig, cwd, cols, rows, env, 
        /**
         * environment used for `findExecutable`
         */
        N, O, P, Q) {
            super();
            this.shellLaunchConfig = shellLaunchConfig;
            this.N = N;
            this.O = O;
            this.P = P;
            this.Q = Q;
            this.id = 0;
            this.shouldPersist = false;
            this.a = {
                cwd: '',
                initialCwd: '',
                fixedDimensions: { cols: undefined, rows: undefined },
                title: '',
                shellType: undefined,
                hasChildProcesses: true,
                resolvedShellLaunchConfig: {},
                overrideDimensions: undefined,
                failedShellIntegrationActivation: false,
                usedShellIntegrationInjection: undefined
            };
            this.n = '';
            this.w = null;
            this.y = [];
            this.G = false;
            this.H = 0;
            this.I = this.B(new event_1.$qe());
            this.onProcessData = this.I.event;
            this.J = this.B(new event_1.$qe());
            this.onProcessReady = this.J.event;
            this.L = this.B(new event_1.$qe());
            this.onDidChangeProperty = this.L.event;
            this.M = this.B(new event_1.$qe());
            this.onProcessExit = this.M.event;
            let name;
            if (platform_1.$l) {
                name = path.$sc(this.shellLaunchConfig.executable || '');
            }
            else {
                // Using 'xterm-256color' here helps ensure that the majority of Linux distributions will use a
                // color prompt as defined in the default ~/.bashrc file.
                name = 'xterm-256color';
            }
            this.D = cwd;
            this.a[terminal_1.ProcessPropertyType.InitialCwd] = this.D;
            this.a[terminal_1.ProcessPropertyType.Cwd] = this.D;
            const useConpty = this.O.windowsEnableConpty && process.platform === 'win32' && (0, terminalEnvironment_1.$Us)() >= 18309;
            const useConptyDll = useConpty && this.O.windowsUseConptyDll;
            this.F = {
                name,
                cwd,
                // TODO: When node-pty is updated this cast can be removed
                env: env,
                cols,
                rows,
                useConpty,
                useConptyDll,
                // This option will force conpty to not redraw the whole viewport on launch
                conptyInheritCursor: useConpty && !!shellLaunchConfig.initialText
            };
            // Delay resizes to avoid conpty not respecting very early resize calls
            if (platform_1.$l) {
                if (useConpty && cols === 0 && rows === 0 && this.shellLaunchConfig.executable?.endsWith('Git\\bin\\bash.exe')) {
                    this.C = new DelayedResizer();
                    this.B(this.C.onTrigger(dimensions => {
                        this.C?.dispose();
                        this.C = undefined;
                        if (dimensions.cols && dimensions.rows) {
                            this.resize(dimensions.cols, dimensions.rows);
                        }
                    }));
                }
                // WindowsShellHelper is used to fetch the process title and shell type
                this.onProcessReady(e => {
                    this.t = this.B(new windowsShellHelper_1.$Coc(e.pid));
                    this.B(this.t.onShellTypeChanged(e => this.L.fire({ type: terminal_1.ProcessPropertyType.ShellType, value: e })));
                    this.B(this.t.onShellNameChanged(e => this.L.fire({ type: terminal_1.ProcessPropertyType.Title, value: e })));
                });
            }
            this.B((0, lifecycle_1.$Xc)(() => {
                if (this.w) {
                    clearInterval(this.w);
                    this.w = null;
                }
            }));
        }
        async start() {
            const results = await Promise.all([this.R(), this.S()]);
            const firstError = results.find(r => r !== undefined);
            if (firstError) {
                return firstError;
            }
            let injection;
            if (this.O.shellIntegration.enabled) {
                injection = (0, terminalEnvironment_1.$Ws)(this.shellLaunchConfig, this.O, this.F.env, this.P, this.Q);
                if (injection) {
                    this.L.fire({ type: terminal_1.ProcessPropertyType.UsedShellIntegrationInjection, value: true });
                    if (injection.envMixin) {
                        for (const [key, value] of Object.entries(injection.envMixin)) {
                            this.F.env ||= {};
                            this.F.env[key] = value;
                        }
                    }
                    if (injection.filesToCopy) {
                        for (const f of injection.filesToCopy) {
                            try {
                                await fs.promises.mkdir(path.$rc(f.dest), { recursive: true });
                                await fs.promises.copyFile(f.source, f.dest);
                            }
                            catch {
                                // Swallow error, this should only happen when multiple users are on the same
                                // machine. Since the shell integration scripts rarely change, plus the other user
                                // should be using the same version of the server in this case, assume the script is
                                // fine if copy fails and swallow the error.
                            }
                        }
                    }
                }
                else {
                    this.L.fire({ type: terminal_1.ProcessPropertyType.FailedShellIntegrationActivation, value: true });
                }
            }
            try {
                await this.U(this.shellLaunchConfig, this.F, injection);
                if (injection?.newArgs) {
                    return { injectedArgs: injection.newArgs };
                }
                return undefined;
            }
            catch (err) {
                this.P.trace('node-pty.node-pty.IPty#spawn native exception', err);
                return { message: `A native exception occurred during launch (${err.message})` };
            }
        }
        async R() {
            try {
                const result = await fs.promises.stat(this.D);
                if (!result.isDirectory()) {
                    return { message: (0, nls_1.localize)(2121, null, this.D.toString()) };
                }
            }
            catch (err) {
                if (err?.code === 'ENOENT') {
                    return { message: (0, nls_1.localize)(2122, null, this.D.toString()) };
                }
            }
            this.L.fire({ type: terminal_1.ProcessPropertyType.InitialCwd, value: this.D });
            return undefined;
        }
        async S() {
            const slc = this.shellLaunchConfig;
            if (!slc.executable) {
                throw new Error('IShellLaunchConfig.executable not set');
            }
            const cwd = slc.cwd instanceof uri_1.URI ? slc.cwd.path : slc.cwd;
            const envPaths = (slc.env && slc.env.PATH) ? slc.env.PATH.split(path.$yc) : undefined;
            const executable = await (0, terminalEnvironment_1.$Vs)(slc.executable, cwd, envPaths, this.N);
            if (!executable) {
                return { message: (0, nls_1.localize)(2123, null, slc.executable) };
            }
            try {
                const result = await fs.promises.stat(executable);
                if (!result.isFile() && !result.isSymbolicLink()) {
                    return { message: (0, nls_1.localize)(2124, null, slc.executable) };
                }
                // Set the executable explicitly here so that node-pty doesn't need to search the
                // $PATH too.
                slc.executable = executable;
            }
            catch (err) {
                if (err?.code === 'EACCES') {
                    // Swallow
                }
                else {
                    throw err;
                }
            }
            return undefined;
        }
        async U(shellLaunchConfig, options, shellIntegrationInjection) {
            const args = shellIntegrationInjection?.newArgs || shellLaunchConfig.args || [];
            await this.Z();
            this.P.trace('node-pty.IPty#spawn', shellLaunchConfig.executable, args, options);
            const ptyProcess = (0, node_pty_1.spawn)(shellLaunchConfig.executable, args, options);
            this.m = ptyProcess;
            this.u = this.B(new childProcessMonitor_1.$Aoc(ptyProcess.pid, this.P));
            this.u.onDidChangeHasChildProcesses(value => this.L.fire({ type: terminal_1.ProcessPropertyType.HasChildProcesses, value }));
            this.s = new Promise(c => {
                this.onProcessReady(() => c());
            });
            ptyProcess.onData(data => {
                // Handle flow control
                this.H += data.length;
                if (!this.G && this.H > terminal_1.FlowControlConstants.HighWatermarkChars) {
                    this.P.trace(`Flow control: Pause (${this.H} > ${terminal_1.FlowControlConstants.HighWatermarkChars})`);
                    this.G = true;
                    ptyProcess.pause();
                }
                // Refire the data event
                this.P.trace('node-pty.IPty#onData', data);
                this.I.fire(data);
                if (this.j) {
                    this.X();
                }
                this.t?.checkShell();
                this.u?.handleOutput();
            });
            ptyProcess.onExit(e => {
                this.g = e.exitCode;
                this.X();
            });
            this.$(ptyProcess.pid);
            this.W(ptyProcess);
        }
        W(ptyProcess) {
            // Send initial timeout async to give event listeners a chance to init
            setTimeout(() => this.ab(ptyProcess));
            // Setup polling for non-Windows, for Windows `process` doesn't change
            if (!platform_1.$l) {
                this.w = setInterval(() => {
                    if (this.n !== ptyProcess.process) {
                        this.ab(ptyProcess);
                    }
                }, 200);
            }
        }
        // Allow any trailing data events to be sent before the exit event is sent.
        // See https://github.com/Tyriar/node-pty/issues/72
        X() {
            if (this.P.getLevel() === log_1.LogLevel.Trace) {
                this.P.trace('TerminalProcess#_queueProcessExit', new Error().stack?.replace(/^Error/, ''));
            }
            if (this.j) {
                clearTimeout(this.j);
            }
            this.j = setTimeout(() => {
                this.j = undefined;
                this.Y();
            }, ShutdownConstants.DataFlushTimeout);
        }
        async Y() {
            // Wait to kill to process until the start up code has run. This prevents us from firing a process exit before a
            // process start.
            await this.s;
            if (this.q.isDisposed) {
                return;
            }
            // Attempt to kill the pty, it may have already been killed at this
            // point but we want to make sure
            try {
                if (this.m) {
                    await this.Z();
                    this.P.trace('node-pty.IPty#kill');
                    this.m.kill();
                }
            }
            catch (ex) {
                // Swallow, the pty has already been killed
            }
            this.M.fire(this.g || 0);
            this.dispose();
        }
        async Z() {
            // Only throttle on Windows/conpty
            if (!platform_1.$l || !('useConpty' in this.F) || !this.F.useConpty) {
                return;
            }
            // Use a loop to ensure multiple calls in a single interval space out
            while (Date.now() - $Doc_1.b < Constants.KillSpawnThrottleInterval) {
                this.P.trace('Throttling kill/spawn call');
                await (0, async_1.$Lh)(Constants.KillSpawnThrottleInterval - (Date.now() - $Doc_1.b) + Constants.KillSpawnSpacingDuration);
            }
            $Doc_1.b = Date.now();
        }
        $(pid) {
            this.J.fire({
                pid,
                cwd: this.D,
                windowsPty: this.getWindowsPty()
            });
        }
        ab(ptyProcess) {
            if (this.q.isDisposed) {
                return;
            }
            // HACK: The node-pty API can return undefined somehow https://github.com/microsoft/vscode/issues/222323
            this.n = (ptyProcess.process ?? '');
            this.L.fire({ type: terminal_1.ProcessPropertyType.Title, value: this.n });
            // If fig is installed it may change the title of the process
            const sanitizedTitle = this.currentTitle.replace(/ \(figterm\)$/g, '');
            if (sanitizedTitle.toLowerCase().startsWith('python')) {
                this.L.fire({ type: terminal_1.ProcessPropertyType.ShellType, value: terminal_1.GeneralShellType.Python });
            }
            else if (sanitizedTitle.toLowerCase().startsWith('julia')) {
                this.L.fire({ type: terminal_1.ProcessPropertyType.ShellType, value: terminal_1.GeneralShellType.Julia });
            }
            else {
                const shellTypeValue = posixShellTypeMap.get(sanitizedTitle) || generalShellTypeMap.get(sanitizedTitle);
                this.L.fire({ type: terminal_1.ProcessPropertyType.ShellType, value: shellTypeValue });
            }
        }
        shutdown(immediate) {
            if (this.P.getLevel() === log_1.LogLevel.Trace) {
                this.P.trace('TerminalProcess#shutdown', new Error().stack?.replace(/^Error/, ''));
            }
            // don't force immediate disposal of the terminal processes on Windows as an additional
            // mitigation for https://github.com/microsoft/vscode/issues/71966 which causes the pty host
            // to become unresponsive, disconnecting all terminals across all windows.
            if (immediate && !platform_1.$l) {
                this.Y();
            }
            else {
                if (!this.j && !this.q.isDisposed) {
                    this.X();
                    // Allow a maximum amount of time for the process to exit, otherwise force kill it
                    setTimeout(() => {
                        if (this.j && !this.q.isDisposed) {
                            this.j = undefined;
                            this.Y();
                        }
                    }, ShutdownConstants.MaximumShutdownTime);
                }
            }
        }
        input(data, isBinary = false) {
            if (this.q.isDisposed || !this.m) {
                return;
            }
            this.y.push(...(0, terminalProcess_1.$vs)(data).map(e => {
                return { isBinary, data: e };
            }));
            this.bb();
        }
        async processBinary(data) {
            this.input(data, true);
        }
        async refreshProperty(type) {
            switch (type) {
                case terminal_1.ProcessPropertyType.Cwd: {
                    const newCwd = await this.getCwd();
                    if (newCwd !== this.a.cwd) {
                        this.a.cwd = newCwd;
                        this.L.fire({ type: terminal_1.ProcessPropertyType.Cwd, value: this.a.cwd });
                    }
                    return newCwd;
                }
                case terminal_1.ProcessPropertyType.InitialCwd: {
                    const initialCwd = await this.getInitialCwd();
                    if (initialCwd !== this.a.initialCwd) {
                        this.a.initialCwd = initialCwd;
                        this.L.fire({ type: terminal_1.ProcessPropertyType.InitialCwd, value: this.a.initialCwd });
                    }
                    return initialCwd;
                }
                case terminal_1.ProcessPropertyType.Title:
                    return this.currentTitle;
                default:
                    return this.shellType;
            }
        }
        async updateProperty(type, value) {
            if (type === terminal_1.ProcessPropertyType.FixedDimensions) {
                this.a.fixedDimensions = value;
            }
        }
        bb() {
            // Don't write if it's already queued of is there is nothing to write
            if (this.z !== undefined || this.y.length === 0) {
                return;
            }
            this.cb();
            // Don't queue more writes if the queue is empty
            if (this.y.length === 0) {
                this.z = undefined;
                return;
            }
            // Queue the next write
            this.z = setTimeout(() => {
                this.z = undefined;
                this.bb();
            }, Constants.WriteInterval);
        }
        cb() {
            const object = this.y.shift();
            this.P.trace('node-pty.IPty#write', object.data);
            if (object.isBinary) {
                this.m.write(Buffer.from(object.data, 'binary'));
            }
            else {
                this.m.write(object.data);
            }
            this.u?.handleInput();
        }
        resize(cols, rows) {
            if (this.q.isDisposed) {
                return;
            }
            if (typeof cols !== 'number' || typeof rows !== 'number' || isNaN(cols) || isNaN(rows)) {
                return;
            }
            // Ensure that cols and rows are always >= 1, this prevents a native
            // exception in winpty.
            if (this.m) {
                cols = Math.max(cols, 1);
                rows = Math.max(rows, 1);
                // Delay resize if needed
                if (this.C) {
                    this.C.cols = cols;
                    this.C.rows = rows;
                    return;
                }
                this.P.trace('node-pty.IPty#resize', cols, rows);
                try {
                    this.m.resize(cols, rows);
                }
                catch (e) {
                    // Swallow error if the pty has already exited
                    this.P.trace('node-pty.IPty#resize exception ' + e.message);
                    if (this.g !== undefined &&
                        e.message !== 'ioctl(2) failed, EBADF' &&
                        e.message !== 'Cannot resize a pty that has already exited') {
                        throw e;
                    }
                }
            }
        }
        clearBuffer() {
            this.m?.clear();
        }
        acknowledgeDataEvent(charCount) {
            // Prevent lower than 0 to heal from errors
            this.H = Math.max(this.H - charCount, 0);
            this.P.trace(`Flow control: Ack ${charCount} chars (unacknowledged: ${this.H})`);
            if (this.G && this.H < terminal_1.FlowControlConstants.LowWatermarkChars) {
                this.P.trace(`Flow control: Resume (${this.H} < ${terminal_1.FlowControlConstants.LowWatermarkChars})`);
                this.m?.resume();
                this.G = false;
            }
        }
        clearUnacknowledgedChars() {
            this.H = 0;
            this.P.trace(`Flow control: Cleared all unacknowledged chars, forcing resume`);
            if (this.G) {
                this.m?.resume();
                this.G = false;
            }
        }
        async setUnicodeVersion(version) {
            // No-op
        }
        getInitialCwd() {
            return Promise.resolve(this.D);
        }
        async getCwd() {
            if (platform_1.$m) {
                // From Big Sur (darwin v20) there is a spawn blocking thread issue on Electron,
                // this is fixed in VS Code's internal Electron.
                // https://github.com/Microsoft/vscode/issues/105446
                return new Promise(resolve => {
                    if (!this.m) {
                        resolve(this.D);
                        return;
                    }
                    this.P.trace('node-pty.IPty#pid');
                    (0, child_process_1.exec)('lsof -OPln -p ' + this.m.pid + ' | grep cwd', { env: { ...process.env, LANG: 'en_US.UTF-8' } }, (error, stdout, stderr) => {
                        if (!error && stdout !== '') {
                            resolve(stdout.substring(stdout.indexOf('/'), stdout.length - 1));
                        }
                        else {
                            this.P.error('lsof did not run successfully, it may not be on the $PATH?', error, stdout, stderr);
                            resolve(this.D);
                        }
                    });
                });
            }
            if (platform_1.$n) {
                if (!this.m) {
                    return this.D;
                }
                this.P.trace('node-pty.IPty#pid');
                try {
                    return await fs.promises.readlink(`/proc/${this.m.pid}/cwd`);
                }
                catch (error) {
                    return this.D;
                }
            }
            return this.D;
        }
        getWindowsPty() {
            return platform_1.$l ? {
                backend: 'useConpty' in this.F && this.F.useConpty ? 'conpty' : 'winpty',
                buildNumber: (0, terminalEnvironment_1.$Us)()
            } : undefined;
        }
    };
    exports.$Doc = $Doc;
    exports.$Doc = $Doc = $Doc_1 = __decorate([
        __param(7, log_1.$fk),
        __param(8, productService_1.$yk)
    ], $Doc);
    /**
     * Tracks the latest resize event to be trigger at a later point.
     */
    class DelayedResizer extends lifecycle_1.$Zc {
        get onTrigger() { return this.b.event; }
        constructor() {
            super();
            this.b = this.B(new event_1.$qe());
            this.a = setTimeout(() => {
                this.b.fire({ rows: this.rows, cols: this.cols });
            }, 1000);
            this.B((0, lifecycle_1.$Xc)(() => clearTimeout(this.a)));
        }
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/





























define(__m[100/*vs/platform/terminal/node/ptyService*/], __M([0/*require*/,1/*exports*/,29/*child_process*/,12/*vs/base/common/async*/,4/*vs/base/common/event*/,2/*vs/base/common/lifecycle*/,3/*vs/base/common/platform*/,65/*vs/base/node/shell*/,9/*vs/platform/log/common/log*/,91/*vs/platform/terminal/common/requestStore*/,16/*vs/platform/terminal/common/terminal*/,93/*vs/platform/terminal/common/terminalDataBuffering*/,41/*vs/platform/terminal/common/terminalEnvironment*/,43/*vs/platform/terminal/node/terminalEnvironment*/,99/*vs/platform/terminal/node/terminalProcess*/,8/*vs/nls*/,42/*vs/platform/terminal/node/childProcessMonitor*/,92/*vs/platform/terminal/common/terminalAutoResponder*/,7/*vs/base/common/errors*/,96/*vs/platform/terminal/common/xterm/shellIntegrationAddon*/,95/*vs/platform/terminal/common/terminalStrings*/,72/*path*/,14/*vs/base/common/decorators*/,104/*vs/base/common/performance*/,105/*@xterm/headless*/]), function (require, exports, child_process_1, async_1, event_1, lifecycle_1, platform_1, shell_1, log_1, requestStore_1, terminal_1, terminalDataBuffering_1, terminalEnvironment_1, terminalEnvironment_2, terminalProcess_1, nls_1, childProcessMonitor_1, terminalAutoResponder_1, errors_1, shellIntegrationAddon_1, terminalStrings_1, path_1, decorators_1, performance, headless_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$Foc = void 0;
    exports.$Eoc = $Eoc;
    performance = __importStar(performance);
    // ESM-comment-end
    // ESM-uncomment-begin
    // import pkg from '@xterm/headless';
    // type XtermTerminal = pkg.Terminal;
    // const { Terminal: XtermTerminal } = pkg;
    // ESM-uncomment-end
    function $Eoc(_target, key, descriptor) {
        if (typeof descriptor.value !== 'function') {
            throw new Error('not supported');
        }
        const fnKey = 'value';
        const fn = descriptor.value;
        descriptor[fnKey] = async function (...args) {
            if (this.traceRpcArgs.logService.getLevel() === log_1.LogLevel.Trace) {
                this.traceRpcArgs.logService.trace(`[RPC Request] PtyService#${fn.name}(${args.map(e => JSON.stringify(e)).join(', ')})`);
            }
            if (this.traceRpcArgs.simulatedLatency) {
                await (0, async_1.$Lh)(this.traceRpcArgs.simulatedLatency);
            }
            let result;
            try {
                result = await fn.apply(this, args);
            }
            catch (e) {
                this.traceRpcArgs.logService.error(`[RPC Response] PtyService#${fn.name}`, e);
                throw e;
            }
            if (this.traceRpcArgs.logService.getLevel() === log_1.LogLevel.Trace) {
                this.traceRpcArgs.logService.trace(`[RPC Response] PtyService#${fn.name}`, result);
            }
            return result;
        };
    }
    let SerializeAddon;
    let Unicode11Addon;
    class $Foc extends lifecycle_1.$Zc {
        H(name, event) {
            event(e => {
                if (this.I.getLevel() === log_1.LogLevel.Trace) {
                    this.I.trace(`[RPC Event] PtyService#${name}.fire(${JSON.stringify(e)})`);
                }
            });
            return event;
        }
        get traceRpcArgs() {
            return {
                logService: this.I,
                simulatedLatency: this.M
            };
        }
        constructor(I, J, L, M) {
            super();
            this.I = I;
            this.J = J;
            this.L = L;
            this.M = M;
            this.a = new Map();
            this.b = new Map();
            this.g = new Map();
            this.j = new Map();
            this.n = 0;
            this.u = this.B(new event_1.$qe());
            this.onHeartbeat = this.H('_onHeartbeat', this.u.event);
            this.w = this.B(new event_1.$qe());
            this.onProcessData = this.H('_onProcessData', this.w.event);
            this.y = this.B(new event_1.$qe());
            this.onProcessReplay = this.H('_onProcessReplay', this.y.event);
            this.z = this.B(new event_1.$qe());
            this.onProcessReady = this.H('_onProcessReady', this.z.event);
            this.C = this.B(new event_1.$qe());
            this.onProcessExit = this.H('_onProcessExit', this.C.event);
            this.D = this.B(new event_1.$qe());
            this.onProcessOrphanQuestion = this.H('_onProcessOrphanQuestion', this.D.event);
            this.F = this.B(new event_1.$qe());
            this.onDidRequestDetach = this.H('_onDidRequestDetach', this.F.event);
            this.G = this.B(new event_1.$qe());
            this.onDidChangeProperty = this.H('_onDidChangeProperty', this.G.event);
            this.B((0, lifecycle_1.$Xc)(() => {
                for (const pty of this.a.values()) {
                    pty.shutdown(true);
                }
                this.a.clear();
            }));
            this.f = this.B(new requestStore_1.$Es(undefined, this.I));
            this.f.onCreateRequest(this.F.fire, this.F);
        }
        async refreshIgnoreProcessNames(names) {
            childProcessMonitor_1.$zoc.length = 0;
            childProcessMonitor_1.$zoc.push(...names);
        }
        async requestDetachInstance(workspaceId, instanceId) {
            return this.f.createRequest({ workspaceId, instanceId });
        }
        async acceptDetachInstanceReply(requestId, persistentProcessId) {
            let processDetails = undefined;
            const pty = this.a.get(persistentProcessId);
            if (pty) {
                processDetails = await this.S(persistentProcessId, pty);
            }
            this.f.acceptReply(requestId, processDetails);
        }
        async freePortKillProcess(port) {
            const stdout = await new Promise((resolve, reject) => {
                (0, child_process_1.exec)(platform_1.$l ? `netstat -ano | findstr "${port}"` : `lsof -nP -iTCP -sTCP:LISTEN | grep ${port}`, {}, (err, stdout) => {
                    if (err) {
                        return reject('Problem occurred when listing active processes');
                    }
                    resolve(stdout);
                });
            });
            const processesForPort = stdout.split(/\r?\n/).filter(s => !!s.trim());
            if (processesForPort.length >= 1) {
                const capturePid = /\s+(\d+)(?:\s+|$)/;
                const processId = processesForPort[0].match(capturePid)?.[1];
                if (processId) {
                    try {
                        process.kill(Number.parseInt(processId));
                    }
                    catch { }
                }
                else {
                    throw new Error(`Processes for port ${port} were not found`);
                }
                return { port, processId };
            }
            throw new Error(`Could not kill process with port ${port}`);
        }
        async serializeTerminalState(ids) {
            const promises = [];
            for (const [persistentProcessId, persistentProcess] of this.a.entries()) {
                // Only serialize persistent processes that have had data written or performed a replay
                if (persistentProcess.hasWrittenData && ids.indexOf(persistentProcessId) !== -1) {
                    promises.push(async_1.Promises.withAsyncBody(async (r) => {
                        r({
                            id: persistentProcessId,
                            shellLaunchConfig: persistentProcess.shellLaunchConfig,
                            processDetails: await this.S(persistentProcessId, persistentProcess),
                            processLaunchConfig: persistentProcess.processLaunchOptions,
                            unicodeVersion: persistentProcess.unicodeVersion,
                            replayEvent: await persistentProcess.serializeNormalBuffer(),
                            timestamp: Date.now()
                        });
                    }));
                }
            }
            const serialized = {
                version: 1,
                state: await Promise.all(promises)
            };
            return JSON.stringify(serialized);
        }
        async reviveTerminalProcesses(workspaceId, state, dateTimeFormatLocale) {
            const promises = [];
            for (const terminal of state) {
                promises.push(this.N(workspaceId, terminal));
            }
            await Promise.all(promises);
        }
        async N(workspaceId, terminal) {
            const restoreMessage = (0, nls_1.localize)(2120, null);
            // TODO: We may at some point want to show date information in a hover via a custom sequence:
            //   new Date(terminal.timestamp).toLocaleDateString(dateTimeFormatLocale)
            //   new Date(terminal.timestamp).toLocaleTimeString(dateTimeFormatLocale)
            const newId = await this.createProcess({
                ...terminal.shellLaunchConfig,
                cwd: terminal.processDetails.cwd,
                color: terminal.processDetails.color,
                icon: terminal.processDetails.icon,
                name: terminal.processDetails.titleSource === terminal_1.TitleEventSource.Api ? terminal.processDetails.title : undefined,
                initialText: terminal.replayEvent.events[0].data + (0, terminalStrings_1.$MZb)(restoreMessage, { loudFormatting: true })
            }, terminal.processDetails.cwd, terminal.replayEvent.events[0].cols, terminal.replayEvent.events[0].rows, terminal.unicodeVersion, terminal.processLaunchConfig.env, terminal.processLaunchConfig.executableEnv, terminal.processLaunchConfig.options, true, terminal.processDetails.workspaceId, terminal.processDetails.workspaceName, true, terminal.replayEvent.events[0].data);
            // Don't start the process here as there's no terminal to answer CPR
            const oldId = this.R(workspaceId, terminal.id);
            this.g.set(oldId, { newId, state: terminal });
            this.I.info(`Revived process, old id ${oldId} -> new id ${newId}`);
        }
        async shutdownAll() {
            this.dispose();
        }
        async createProcess(shellLaunchConfig, cwd, cols, rows, unicodeVersion, env, executableEnv, options, shouldPersist, workspaceId, workspaceName, isReviving, rawReviveBuffer) {
            if (shellLaunchConfig.attachPersistentProcess) {
                throw new Error('Attempt to create a process when attach object was provided');
            }
            const id = ++this.n;
            const process = new terminalProcess_1.$Doc(shellLaunchConfig, cwd, cols, rows, env, executableEnv, options, this.I, this.J);
            const processLaunchOptions = {
                env,
                executableEnv,
                options
            };
            const persistentProcess = new PersistentTerminalProcess(id, process, workspaceId, workspaceName, shouldPersist, cols, rows, processLaunchOptions, unicodeVersion, this.L, this.I, isReviving && typeof shellLaunchConfig.initialText === 'string' ? shellLaunchConfig.initialText : undefined, rawReviveBuffer, shellLaunchConfig.icon, shellLaunchConfig.color, shellLaunchConfig.name, shellLaunchConfig.fixedDimensions);
            process.onProcessExit(event => {
                persistentProcess.dispose();
                this.a.delete(id);
                this.C.fire({ id, event });
            });
            persistentProcess.onProcessData(event => this.w.fire({ id, event }));
            persistentProcess.onProcessReplay(event => this.y.fire({ id, event }));
            persistentProcess.onProcessReady(event => this.z.fire({ id, event }));
            persistentProcess.onProcessOrphanQuestion(() => this.D.fire({ id }));
            persistentProcess.onDidChangeProperty(property => this.G.fire({ id, property }));
            persistentProcess.onPersistentProcessReady(() => {
                for (const e of this.j.entries()) {
                    persistentProcess.installAutoReply(e[0], e[1]);
                }
            });
            this.a.set(id, persistentProcess);
            return id;
        }
        async attachToProcess(id) {
            try {
                await this.U(id).attach();
                this.I.info(`Persistent process reconnection "${id}"`);
            }
            catch (e) {
                this.I.warn(`Persistent process reconnection "${id}" failed`, e.message);
                throw e;
            }
        }
        async updateTitle(id, title, titleSource) {
            this.U(id).setTitle(title, titleSource);
        }
        async updateIcon(id, userInitiated, icon, color) {
            this.U(id).setIcon(userInitiated, icon, color);
        }
        async clearBuffer(id) {
            this.U(id).clearBuffer();
        }
        async refreshProperty(id, type) {
            return this.U(id).refreshProperty(type);
        }
        async updateProperty(id, type, value) {
            return this.U(id).updateProperty(type, value);
        }
        async detachFromProcess(id, forcePersist) {
            return this.U(id).detach(forcePersist);
        }
        async reduceConnectionGraceTime() {
            for (const pty of this.a.values()) {
                pty.reduceGraceTime();
            }
        }
        async listProcesses() {
            const persistentProcesses = Array.from(this.a.entries()).filter(([_, pty]) => pty.shouldPersistTerminal);
            this.I.info(`Listing ${persistentProcesses.length} persistent terminals, ${this.a.size} total terminals`);
            const promises = persistentProcesses.map(async ([id, terminalProcessData]) => this.S(id, terminalProcessData));
            const allTerminals = await Promise.all(promises);
            return allTerminals.filter(entry => entry.isOrphan);
        }
        async getPerformanceMarks() {
            return performance.getMarks();
        }
        async start(id) {
            const pty = this.a.get(id);
            return pty ? pty.start() : { message: `Could not find pty with id "${id}"` };
        }
        async shutdown(id, immediate) {
            // Don't throw if the pty is already shutdown
            return this.a.get(id)?.shutdown(immediate);
        }
        async input(id, data) {
            return this.U(id).input(data);
        }
        async processBinary(id, data) {
            return this.U(id).writeBinary(data);
        }
        async resize(id, cols, rows) {
            return this.U(id).resize(cols, rows);
        }
        async getInitialCwd(id) {
            return this.U(id).getInitialCwd();
        }
        async getCwd(id) {
            return this.U(id).getCwd();
        }
        async acknowledgeDataEvent(id, charCount) {
            return this.U(id).acknowledgeDataEvent(charCount);
        }
        async setUnicodeVersion(id, version) {
            return this.U(id).setUnicodeVersion(version);
        }
        async getLatency() {
            return [];
        }
        async orphanQuestionReply(id) {
            return this.U(id).orphanQuestionReply();
        }
        async installAutoReply(match, reply) {
            this.j.set(match, reply);
            // If the auto reply exists on any existing terminals it will be overridden
            for (const p of this.a.values()) {
                p.installAutoReply(match, reply);
            }
        }
        async uninstallAllAutoReplies() {
            for (const match of this.j.keys()) {
                for (const p of this.a.values()) {
                    p.uninstallAutoReply(match);
                }
            }
        }
        async uninstallAutoReply(match) {
            for (const p of this.a.values()) {
                p.uninstallAutoReply(match);
            }
        }
        async getDefaultSystemShell(osOverride = platform_1.OS) {
            return (0, shell_1.$Fm)(osOverride, process.env);
        }
        async getEnvironment() {
            return { ...process.env };
        }
        async getWslPath(original, direction) {
            if (direction === 'win-to-unix') {
                if (!platform_1.$l) {
                    return original;
                }
                if ((0, terminalEnvironment_2.$Us)() < 17063) {
                    return original.replace(/\\/g, '/');
                }
                const wslExecutable = this.O();
                if (!wslExecutable) {
                    return original;
                }
                return new Promise(c => {
                    const proc = (0, child_process_1.execFile)(wslExecutable, ['-e', 'wslpath', original], {}, (error, stdout, stderr) => {
                        c(error ? original : (0, terminalEnvironment_1.$CR)(stdout.trim()));
                    });
                    proc.stdin.end();
                });
            }
            if (direction === 'unix-to-win') {
                // The backend is Windows, for example a local Windows workspace with a wsl session in
                // the terminal.
                if (platform_1.$l) {
                    if ((0, terminalEnvironment_2.$Us)() < 17063) {
                        return original;
                    }
                    const wslExecutable = this.O();
                    if (!wslExecutable) {
                        return original;
                    }
                    return new Promise(c => {
                        const proc = (0, child_process_1.execFile)(wslExecutable, ['-e', 'wslpath', '-w', original], {}, (error, stdout, stderr) => {
                            c(error ? original : stdout.trim());
                        });
                        proc.stdin.end();
                    });
                }
            }
            // Fallback just in case
            return original;
        }
        O() {
            const useWSLexe = (0, terminalEnvironment_2.$Us)() >= 16299;
            const is32ProcessOn64Windows = process.env.hasOwnProperty('PROCESSOR_ARCHITEW6432');
            const systemRoot = process.env['SystemRoot'];
            if (systemRoot) {
                return (0, path_1.join)(systemRoot, is32ProcessOn64Windows ? 'Sysnative' : 'System32', useWSLexe ? 'wsl.exe' : 'bash.exe');
            }
            return undefined;
        }
        async getRevivedPtyNewId(workspaceId, id) {
            try {
                return this.g.get(this.R(workspaceId, id))?.newId;
            }
            catch (e) {
                this.I.warn(`Couldn't find terminal ID ${workspaceId}-${id}`, e.message);
            }
            return undefined;
        }
        async setTerminalLayoutInfo(args) {
            this.b.set(args.workspaceId, args);
        }
        async getTerminalLayoutInfo(args) {
            performance.mark('code/willGetTerminalLayoutInfo');
            const layout = this.b.get(args.workspaceId);
            if (layout) {
                const doneSet = new Set();
                const expandedTabs = await Promise.all(layout.tabs.map(async (tab) => this.P(args.workspaceId, tab, doneSet)));
                const tabs = expandedTabs.filter(t => t.terminals.length > 0);
                performance.mark('code/didGetTerminalLayoutInfo');
                return { tabs };
            }
            performance.mark('code/didGetTerminalLayoutInfo');
            return undefined;
        }
        async P(workspaceId, tab, doneSet) {
            const expandedTerminals = (await Promise.all(tab.terminals.map(t => this.Q(workspaceId, t, doneSet))));
            const filtered = expandedTerminals.filter(term => term.terminal !== null);
            return {
                isActive: tab.isActive,
                activePersistentProcessId: tab.activePersistentProcessId,
                terminals: filtered
            };
        }
        async Q(workspaceId, t, doneSet) {
            try {
                const oldId = this.R(workspaceId, t.terminal);
                const revivedPtyId = this.g.get(oldId)?.newId;
                this.I.info(`Expanding terminal instance, old id ${oldId} -> new id ${revivedPtyId}`);
                this.g.delete(oldId);
                const persistentProcessId = revivedPtyId ?? t.terminal;
                if (doneSet.has(persistentProcessId)) {
                    throw new Error(`Terminal ${persistentProcessId} has already been expanded`);
                }
                doneSet.add(persistentProcessId);
                const persistentProcess = this.U(persistentProcessId);
                const processDetails = persistentProcess && await this.S(t.terminal, persistentProcess, revivedPtyId !== undefined);
                return {
                    terminal: { ...processDetails, id: persistentProcessId },
                    relativeSize: t.relativeSize
                };
            }
            catch (e) {
                this.I.warn(`Couldn't get layout info, a terminal was probably disconnected`, e.message);
                this.I.debug('Reattach to wrong terminal debug info - layout info by id', t);
                this.I.debug('Reattach to wrong terminal debug info - _revivePtyIdMap', Array.from(this.g.values()));
                this.I.debug('Reattach to wrong terminal debug info - _ptys ids', Array.from(this.a.keys()));
                // this will be filtered out and not reconnected
                return {
                    terminal: null,
                    relativeSize: t.relativeSize
                };
            }
        }
        R(workspaceId, ptyId) {
            return `${workspaceId}-${ptyId}`;
        }
        async S(id, persistentProcess, wasRevived = false) {
            performance.mark(`code/willBuildProcessDetails/${id}`);
            // If the process was just revived, don't do the orphan check as it will
            // take some time
            const [cwd, isOrphan] = await Promise.all([persistentProcess.getCwd(), wasRevived ? true : persistentProcess.isOrphaned()]);
            const result = {
                id,
                title: persistentProcess.title,
                titleSource: persistentProcess.titleSource,
                pid: persistentProcess.pid,
                workspaceId: persistentProcess.workspaceId,
                workspaceName: persistentProcess.workspaceName,
                cwd,
                isOrphan,
                icon: persistentProcess.icon,
                color: persistentProcess.color,
                fixedDimensions: persistentProcess.fixedDimensions,
                environmentVariableCollections: persistentProcess.processLaunchOptions.options.environmentVariableCollections,
                reconnectionProperties: persistentProcess.shellLaunchConfig.reconnectionProperties,
                waitOnExit: persistentProcess.shellLaunchConfig.waitOnExit,
                hideFromUser: persistentProcess.shellLaunchConfig.hideFromUser,
                isFeatureTerminal: persistentProcess.shellLaunchConfig.isFeatureTerminal,
                type: persistentProcess.shellLaunchConfig.type,
                hasChildProcesses: persistentProcess.hasChildProcesses,
                shellIntegrationNonce: persistentProcess.processLaunchOptions.options.shellIntegration.nonce
            };
            performance.mark(`code/didBuildProcessDetails/${id}`);
            return result;
        }
        U(id) {
            const pty = this.a.get(id);
            if (!pty) {
                throw new errors_1.$fb(`Could not find pty on pty host`);
            }
            return pty;
        }
    }
    exports.$Foc = $Foc;
    __decorate([
        decorators_1.$ci
    ], $Foc.prototype, "traceRpcArgs", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "refreshIgnoreProcessNames", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "requestDetachInstance", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "acceptDetachInstanceReply", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "freePortKillProcess", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "serializeTerminalState", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "reviveTerminalProcesses", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "shutdownAll", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "createProcess", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "attachToProcess", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "updateTitle", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "updateIcon", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "clearBuffer", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "refreshProperty", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "updateProperty", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "detachFromProcess", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "reduceConnectionGraceTime", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "listProcesses", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "getPerformanceMarks", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "start", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "shutdown", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "input", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "processBinary", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "resize", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "getInitialCwd", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "getCwd", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "acknowledgeDataEvent", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "setUnicodeVersion", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "getLatency", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "orphanQuestionReply", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "installAutoReply", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "uninstallAllAutoReplies", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "uninstallAutoReply", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "getDefaultSystemShell", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "getEnvironment", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "getWslPath", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "getRevivedPtyNewId", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "setTerminalLayoutInfo", null);
    __decorate([
        $Eoc
    ], $Foc.prototype, "getTerminalLayoutInfo", null);
    var InteractionState;
    (function (InteractionState) {
        /** The terminal has not been interacted with. */
        InteractionState["None"] = "None";
        /** The terminal has only been interacted with by the replay mechanism. */
        InteractionState["ReplayOnly"] = "ReplayOnly";
        /** The terminal has been directly interacted with this session. */
        InteractionState["Session"] = "Session";
    })(InteractionState || (InteractionState = {}));
    class PersistentTerminalProcess extends lifecycle_1.$Zc {
        get pid() { return this.L; }
        get shellLaunchConfig() { return this.W.shellLaunchConfig; }
        get hasWrittenData() { return this.j.value !== InteractionState.None; }
        get title() { return this.N || this.W.currentTitle; }
        get titleSource() { return this.O; }
        get icon() { return this.Y; }
        get color() { return this.Z; }
        get fixedDimensions() { return this.R; }
        get hasChildProcesses() { return this.W.hasChildProcesses; }
        setTitle(title, titleSource) {
            if (titleSource === terminal_1.TitleEventSource.Api) {
                this.j.setValue(InteractionState.Session, 'setTitle');
                this.P.freeRawReviveBuffer();
            }
            this.N = title;
            this.O = titleSource;
        }
        setIcon(userInitiated, icon, color) {
            if (!this.Y || 'id' in icon && 'id' in this.Y && icon.id !== this.Y.id ||
                !this.color || color !== this.Z) {
                this.P.freeRawReviveBuffer();
                if (userInitiated) {
                    this.j.setValue(InteractionState.Session, 'setIcon');
                }
            }
            this.Y = icon;
            this.Z = color;
        }
        S(fixedDimensions) {
            this.R = fixedDimensions;
        }
        constructor(U, W, workspaceId, workspaceName, shouldPersistTerminal, cols, rows, processLaunchOptions, unicodeVersion, reconnectConstants, X, reviveBuffer, rawReviveBuffer, Y, Z, name, fixedDimensions) {
            super();
            this.U = U;
            this.W = W;
            this.workspaceId = workspaceId;
            this.workspaceName = workspaceName;
            this.shouldPersistTerminal = shouldPersistTerminal;
            this.processLaunchOptions = processLaunchOptions;
            this.unicodeVersion = unicodeVersion;
            this.X = X;
            this.Y = Y;
            this.Z = Z;
            this.b = new Map();
            this.f = new Map();
            this.g = false;
            this.w = new async_1.$Rh();
            this.C = this.B(new event_1.$qe());
            this.onProcessReplay = this.C.event;
            this.D = this.B(new event_1.$qe());
            this.onProcessReady = this.D.event;
            this.F = this.B(new event_1.$qe());
            /** Fired when the persistent process has a ready process and has finished its replay. */
            this.onPersistentProcessReady = this.F.event;
            this.G = this.B(new event_1.$qe());
            this.onProcessData = this.G.event;
            this.H = this.B(new event_1.$qe());
            this.onProcessOrphanQuestion = this.H.event;
            this.I = this.B(new event_1.$qe());
            this.onDidChangeProperty = this.I.event;
            this.J = false;
            this.L = -1;
            this.M = '';
            this.O = terminal_1.TitleEventSource.Process;
            this.j = new MutationLogger(`Persistent process "${this.U}" interaction state`, InteractionState.None, this.X);
            this.Q = reviveBuffer !== undefined;
            this.P = new XtermSerializer(cols, rows, reconnectConstants.scrollback, unicodeVersion, reviveBuffer, processLaunchOptions.options.shellIntegration.nonce, shouldPersistTerminal ? rawReviveBuffer : undefined, this.X);
            if (name) {
                this.setTitle(name, terminal_1.TitleEventSource.Api);
            }
            this.R = fixedDimensions;
            this.n = null;
            this.u = 0;
            this.y = this.B(new async_1.$Xh(() => {
                this.X.info(`Persistent process "${this.U}": The reconnection grace time of ${printTime(reconnectConstants.graceTime)} has expired, shutting down pid "${this.L}"`);
                this.shutdown(true);
            }, reconnectConstants.graceTime));
            this.z = this.B(new async_1.$Xh(() => {
                this.X.info(`Persistent process "${this.U}": The short reconnection grace time of ${printTime(reconnectConstants.shortGraceTime)} has expired, shutting down pid ${this.L}`);
                this.shutdown(true);
            }, reconnectConstants.shortGraceTime));
            this.B(this.W.onProcessExit(() => this.a.stopBuffering(this.U)));
            this.B(this.W.onProcessReady(e => {
                this.L = e.pid;
                this.M = e.cwd;
                this.D.fire(e);
            }));
            this.B(this.W.onDidChangeProperty(e => {
                this.I.fire(e);
            }));
            // Data buffering to reduce the amount of messages going to the renderer
            this.a = new terminalDataBuffering_1.$mAb((_, data) => this.G.fire(data));
            this.B(this.a.startBuffering(this.U, this.W.onProcessData));
            // Data recording for reconnect
            this.B(this.onProcessData(e => this.P.handleData(e)));
            // Clean up other disposables
            this.B((0, lifecycle_1.$Xc)(() => {
                for (const e of this.b.values()) {
                    e.dispose();
                }
                this.b.clear();
            }));
        }
        async attach() {
            if (!this.y.isScheduled() && !this.z.isScheduled()) {
                this.X.warn(`Persistent process "${this.U}": Process had no disconnect runners but was an orphan`);
            }
            this.y.cancel();
            this.z.cancel();
        }
        async detach(forcePersist) {
            // Keep the process around if it was indicated to persist and it has had some iteraction or
            // was replayed
            if (this.shouldPersistTerminal && (this.j.value !== InteractionState.None || forcePersist)) {
                this.y.schedule();
            }
            else {
                this.shutdown(true);
            }
        }
        serializeNormalBuffer() {
            return this.P.generateReplayEvent(true, this.j.value !== InteractionState.Session);
        }
        async refreshProperty(type) {
            return this.W.refreshProperty(type);
        }
        async updateProperty(type, value) {
            if (type === terminal_1.ProcessPropertyType.FixedDimensions) {
                return this.S(value);
            }
        }
        async start() {
            if (!this.g) {
                const result = await this.W.start();
                if (result && 'message' in result) {
                    // it's a terminal launch error
                    return result;
                }
                this.g = true;
                // If the process was revived, trigger a replay on first start. An alternative approach
                // could be to start it on the pty host before attaching but this fails on Windows as
                // conpty's inherit cursor option which is required, ends up sending DSR CPR which
                // causes conhost to hang when no response is received from the terminal (which wouldn't
                // be attached yet). https://github.com/microsoft/terminal/issues/11213
                if (this.Q) {
                    this.triggerReplay();
                }
                else {
                    this.F.fire();
                }
                return result;
            }
            this.D.fire({ pid: this.L, cwd: this.M, windowsPty: this.W.getWindowsPty() });
            this.I.fire({ type: terminal_1.ProcessPropertyType.Title, value: this.W.currentTitle });
            this.I.fire({ type: terminal_1.ProcessPropertyType.ShellType, value: this.W.shellType });
            this.triggerReplay();
            return undefined;
        }
        shutdown(immediate) {
            return this.W.shutdown(immediate);
        }
        input(data) {
            this.j.setValue(InteractionState.Session, 'input');
            this.P.freeRawReviveBuffer();
            if (this.J) {
                return;
            }
            for (const listener of this.b.values()) {
                listener.handleInput();
            }
            return this.W.input(data);
        }
        writeBinary(data) {
            return this.W.processBinary(data);
        }
        resize(cols, rows) {
            if (this.J) {
                return;
            }
            this.P.handleResize(cols, rows);
            // Buffered events should flush when a resize occurs
            this.a.flushBuffer(this.U);
            for (const listener of this.b.values()) {
                listener.handleResize();
            }
            return this.W.resize(cols, rows);
        }
        async clearBuffer() {
            this.P.clearBuffer();
            this.W.clearBuffer();
        }
        setUnicodeVersion(version) {
            this.unicodeVersion = version;
            this.P.setUnicodeVersion?.(version);
            // TODO: Pass in unicode version in ctor
        }
        acknowledgeDataEvent(charCount) {
            if (this.J) {
                return;
            }
            return this.W.acknowledgeDataEvent(charCount);
        }
        getInitialCwd() {
            return this.W.getInitialCwd();
        }
        getCwd() {
            return this.W.getCwd();
        }
        async triggerReplay() {
            if (this.j.value === InteractionState.None) {
                this.j.setValue(InteractionState.ReplayOnly, 'triggerReplay');
            }
            const ev = await this.P.generateReplayEvent();
            let dataLength = 0;
            for (const e of ev.events) {
                dataLength += e.data.length;
            }
            this.X.info(`Persistent process "${this.U}": Replaying ${dataLength} chars and ${ev.events.length} size events`);
            this.C.fire(ev);
            this.W.clearUnacknowledgedChars();
            this.F.fire();
        }
        installAutoReply(match, reply) {
            this.b.get(match)?.dispose();
            this.b.set(match, new terminalAutoResponder_1.$yoc(this.W, match, reply, this.X));
        }
        uninstallAutoReply(match) {
            const autoReply = this.b.get(match);
            autoReply?.dispose();
            this.b.delete(match);
        }
        sendCommandResult(reqId, isError, serializedPayload) {
            const data = this.f.get(reqId);
            if (!data) {
                return;
            }
            this.f.delete(reqId);
        }
        orphanQuestionReply() {
            this.u = Date.now();
            if (this.n) {
                const barrier = this.n;
                this.n = null;
                barrier.open();
            }
        }
        reduceGraceTime() {
            if (this.z.isScheduled()) {
                // we are disconnected and already running the short reconnection timer
                return;
            }
            if (this.y.isScheduled()) {
                // we are disconnected and running the long reconnection timer
                this.z.schedule();
            }
        }
        async isOrphaned() {
            return await this.w.queue(async () => this.$());
        }
        async $() {
            // The process is already known to be orphaned
            if (this.y.isScheduled() || this.z.isScheduled()) {
                return true;
            }
            // Ask whether the renderer(s) whether the process is orphaned and await the reply
            if (!this.n) {
                // the barrier opens after 4 seconds with or without a reply
                this.n = new async_1.$Kh(4000);
                this.u = 0;
                this.H.fire();
            }
            await this.n.wait();
            return (Date.now() - this.u > 500);
        }
    }
    class MutationLogger {
        get value() { return this.b; }
        setValue(value, reason) {
            if (this.b !== value) {
                this.b = value;
                this.f(reason);
            }
        }
        constructor(a, b, d) {
            this.a = a;
            this.b = b;
            this.d = d;
            this.f('initialized');
        }
        f(reason) {
            this.d.debug(`MutationLogger "${this.a}" set to "${this.b}", reason: ${reason}`);
        }
    }
    class XtermSerializer {
        constructor(cols, rows, scrollback, unicodeVersion, reviveBufferWithRestoreMessage, shellIntegrationNonce, f, logService) {
            this.f = f;
            this.a = new headless_1.Terminal({
                cols,
                rows,
                scrollback,
                allowProposedApi: true
            });
            if (reviveBufferWithRestoreMessage) {
                this.a.writeln(reviveBufferWithRestoreMessage);
            }
            this.setUnicodeVersion(unicodeVersion);
            this.b = new shellIntegrationAddon_1.$dzb(shellIntegrationNonce, true, undefined, logService);
            this.a.loadAddon(this.b);
        }
        freeRawReviveBuffer() {
            // Free the memory of the terminal if it will need to be re-serialized
            this.f = undefined;
        }
        handleData(data) {
            this.a.write(data);
        }
        handleResize(cols, rows) {
            this.a.resize(cols, rows);
        }
        clearBuffer() {
            this.a.clear();
        }
        async generateReplayEvent(normalBufferOnly, restoreToLastReviveBuffer) {
            const serialize = new (await this._getSerializeConstructor());
            this.a.loadAddon(serialize);
            const options = {
                scrollback: this.a.options.scrollback
            };
            if (normalBufferOnly) {
                options.excludeAltBuffer = true;
                options.excludeModes = true;
            }
            let serialized;
            if (restoreToLastReviveBuffer && this.f) {
                serialized = this.f;
            }
            else {
                serialized = serialize.serialize(options);
            }
            return {
                events: [
                    {
                        cols: this.a.cols,
                        rows: this.a.rows,
                        data: serialized
                    }
                ],
                commands: this.b.serialize()
            };
        }
        async setUnicodeVersion(version) {
            if (this.a.unicode.activeVersion === version) {
                return;
            }
            if (version === '11') {
                this.d = new (await this._getUnicode11Constructor());
                this.a.loadAddon(this.d);
            }
            else {
                this.d?.dispose();
                this.d = undefined;
            }
            this.a.unicode.activeVersion = version;
        }
        async _getUnicode11Constructor() {
            if (!Unicode11Addon) {
                Unicode11Addon = (await new Promise((resolve_1, reject_1) => { require(['@xterm/addon-unicode11'], resolve_1, reject_1); }).then(__importStar)).Unicode11Addon;
            }
            return Unicode11Addon;
        }
        async _getSerializeConstructor() {
            if (!SerializeAddon) {
                SerializeAddon = (await new Promise((resolve_2, reject_2) => { require(['@xterm/addon-serialize'], resolve_2, reject_2); }).then(__importStar)).SerializeAddon;
            }
            return SerializeAddon;
        }
    }
    function printTime(ms) {
        let h = 0;
        let m = 0;
        let s = 0;
        if (ms >= 1000) {
            s = Math.floor(ms / 1000);
            ms -= s * 1000;
        }
        if (s >= 60) {
            m = Math.floor(s / 60);
            s -= m * 60;
        }
        if (m >= 60) {
            h = Math.floor(m / 60);
            m -= h * 60;
        }
        const _h = h ? `${h}h` : ``;
        const _m = m ? `${m}m` : ``;
        const _s = s ? `${s}s` : ``;
        const _ms = ms ? `${ms}ms` : ``;
        return `${_h}${_m}${_s}${_ms}`;
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
define(__m[106/*vs/platform/terminal/node/ptyHostMain*/], __M([0/*require*/,1/*exports*/,62/*vs/base/common/uriIpc*/,30/*vs/base/parts/ipc/common/ipc*/,66/*vs/base/parts/ipc/node/ipc.cp*/,67/*vs/base/parts/ipc/node/ipc.mp*/,8/*vs/nls*/,70/*vs/platform/environment/node/argv*/,73/*vs/platform/environment/node/environmentService*/,9/*vs/platform/log/common/log*/,75/*vs/platform/log/common/logIpc*/,76/*vs/platform/log/common/logService*/,78/*vs/platform/log/node/loggerService*/,79/*vs/platform/product/common/product*/,16/*vs/platform/terminal/common/terminal*/,97/*vs/platform/terminal/node/heartbeatService*/,100/*vs/platform/terminal/node/ptyService*/,33/*vs/base/parts/sandbox/node/electronTypes*/,12/*vs/base/common/async*/,2/*vs/base/common/lifecycle*/]), function (require, exports, uriIpc_1, ipc_1, ipc_cp_1, ipc_mp_1, nls_1, argv_1, environmentService_1, log_1, logIpc_1, logService_1, loggerService_1, product_1, terminal_1, heartbeatService_1, ptyService_1, electronTypes_1, async_1, lifecycle_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    product_1 = __importDefault(product_1);
    startPtyHost();
    async function startPtyHost() {
        // Parse environment variables
        const startupDelay = parseInt(process.env.VSCODE_STARTUP_DELAY ?? '0');
        const simulatedLatency = parseInt(process.env.VSCODE_LATENCY ?? '0');
        const reconnectConstants = {
            graceTime: parseInt(process.env.VSCODE_RECONNECT_GRACE_TIME || '0'),
            shortGraceTime: parseInt(process.env.VSCODE_RECONNECT_SHORT_GRACE_TIME || '0'),
            scrollback: parseInt(process.env.VSCODE_RECONNECT_SCROLLBACK || '100')
        };
        // Sanitize environment
        delete process.env.VSCODE_RECONNECT_GRACE_TIME;
        delete process.env.VSCODE_RECONNECT_SHORT_GRACE_TIME;
        delete process.env.VSCODE_RECONNECT_SCROLLBACK;
        delete process.env.VSCODE_LATENCY;
        delete process.env.VSCODE_STARTUP_DELAY;
        // Delay startup if needed, this must occur before RPC is setup to avoid the channel from timing
        // out.
        if (startupDelay) {
            await (0, async_1.$Lh)(startupDelay);
        }
        // Setup RPC
        const _isUtilityProcess = (0, electronTypes_1.$QY)(process);
        let server;
        if (_isUtilityProcess) {
            server = new ipc_mp_1.$RY();
        }
        else {
            server = new ipc_cp_1.$pr(terminal_1.TerminalIpcChannels.PtyHost);
        }
        // Services
        const productService = { _serviceBrand: undefined, ...product_1.default };
        const environmentService = new environmentService_1.$cn((0, argv_1.$Im)(process.argv, argv_1.$Hm), productService);
        const loggerService = new loggerService_1.$3R((0, log_1.$tk)(environmentService), environmentService.logsHome);
        server.registerChannel(terminal_1.TerminalIpcChannels.Logger, new logIpc_1.$Cs(loggerService, () => uriIpc_1.$Tn));
        const logger = loggerService.createLogger('ptyhost', { name: (0, nls_1.localize)(2119, null) });
        const logService = new logService_1.$aS(logger);
        // Log developer config
        if (startupDelay) {
            logService.warn(`Pty Host startup is delayed ${startupDelay}ms`);
        }
        if (simulatedLatency) {
            logService.warn(`Pty host is simulating ${simulatedLatency}ms latency`);
        }
        const disposables = new lifecycle_1.$Yc();
        // Heartbeat responsiveness tracking
        const heartbeatService = new heartbeatService_1.$Boc();
        server.registerChannel(terminal_1.TerminalIpcChannels.Heartbeat, ipc_1.ProxyChannel.fromService(heartbeatService, disposables));
        // Init pty service
        const ptyService = new ptyService_1.$Foc(logService, productService, reconnectConstants, simulatedLatency);
        const ptyServiceChannel = ipc_1.ProxyChannel.fromService(ptyService, disposables);
        server.registerChannel(terminal_1.TerminalIpcChannels.PtyHost, ptyServiceChannel);
        // Register a channel for direct communication via Message Port
        if (_isUtilityProcess) {
            server.registerChannel(terminal_1.TerminalIpcChannels.PtyHostWindow, ptyServiceChannel);
        }
        // Clean up
        process.once('exit', () => {
            logService.trace('Pty host exiting');
            logService.dispose();
            heartbeatService.dispose();
            ptyService.dispose();
        });
    }
});

}).call(this);
//# sourceMappingURL=ptyHostMain.js.map
