{"version":3,"file":"static/js/5934_dc994a9eda90b6dc2c7b.js","mappings":"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","sources":["file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/base/common/actions.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/base/common/arrays.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/base/common/arraysFind.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/base/common/assert.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/base/common/async.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/base/common/buffer.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/base/common/cache.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/base/common/cancellation.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/base/common/codiconsLibrary.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/base/common/codicons.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/base/common/codiconsUtil.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/base/common/collections.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/base/common/color.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/base/common/comparers.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/base/common/dataTransfer.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/base/common/decorators.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/base/common/diff/diffChange.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/base/common/diff/diff.js"],"sourcesContent":["/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Emitter } from './event.js';\nimport { Disposable } from './lifecycle.js';\nimport * as nls from '../../nls.js';\nexport class Action extends Disposable {\n    constructor(id, label = '', cssClass = '', enabled = true, actionCallback) {\n        super();\n        this._onDidChange = this._register(new Emitter());\n        this.onDidChange = this._onDidChange.event;\n        this._enabled = true;\n        this._id = id;\n        this._label = label;\n        this._cssClass = cssClass;\n        this._enabled = enabled;\n        this._actionCallback = actionCallback;\n    }\n    get id() {\n        return this._id;\n    }\n    get label() {\n        return this._label;\n    }\n    set label(value) {\n        this._setLabel(value);\n    }\n    _setLabel(value) {\n        if (this._label !== value) {\n            this._label = value;\n            this._onDidChange.fire({ label: value });\n        }\n    }\n    get tooltip() {\n        return this._tooltip || '';\n    }\n    set tooltip(value) {\n        this._setTooltip(value);\n    }\n    _setTooltip(value) {\n        if (this._tooltip !== value) {\n            this._tooltip = value;\n            this._onDidChange.fire({ tooltip: value });\n        }\n    }\n    get class() {\n        return this._cssClass;\n    }\n    set class(value) {\n        this._setClass(value);\n    }\n    _setClass(value) {\n        if (this._cssClass !== value) {\n            this._cssClass = value;\n            this._onDidChange.fire({ class: value });\n        }\n    }\n    get enabled() {\n        return this._enabled;\n    }\n    set enabled(value) {\n        this._setEnabled(value);\n    }\n    _setEnabled(value) {\n        if (this._enabled !== value) {\n            this._enabled = value;\n            this._onDidChange.fire({ enabled: value });\n        }\n    }\n    get checked() {\n        return this._checked;\n    }\n    set checked(value) {\n        this._setChecked(value);\n    }\n    _setChecked(value) {\n        if (this._checked !== value) {\n            this._checked = value;\n            this._onDidChange.fire({ checked: value });\n        }\n    }\n    async run(event, data) {\n        if (this._actionCallback) {\n            await this._actionCallback(event);\n        }\n    }\n}\nexport class ActionRunner extends Disposable {\n    constructor() {\n        super(...arguments);\n        this._onWillRun = this._register(new Emitter());\n        this.onWillRun = this._onWillRun.event;\n        this._onDidRun = this._register(new Emitter());\n        this.onDidRun = this._onDidRun.event;\n    }\n    async run(action, context) {\n        if (!action.enabled) {\n            return;\n        }\n        this._onWillRun.fire({ action });\n        let error = undefined;\n        try {\n            await this.runAction(action, context);\n        }\n        catch (e) {\n            error = e;\n        }\n        this._onDidRun.fire({ action, error });\n    }\n    async runAction(action, context) {\n        await action.run(context);\n    }\n}\nexport class Separator {\n    constructor() {\n        this.id = Separator.ID;\n        this.label = '';\n        this.tooltip = '';\n        this.class = 'separator';\n        this.enabled = false;\n        this.checked = false;\n    }\n    /**\n     * Joins all non-empty lists of actions with separators.\n     */\n    static join(...actionLists) {\n        let out = [];\n        for (const list of actionLists) {\n            if (!list.length) {\n                // skip\n            }\n            else if (out.length) {\n                out = [...out, new Separator(), ...list];\n            }\n            else {\n                out = list;\n            }\n        }\n        return out;\n    }\n    async run() { }\n}\nSeparator.ID = 'vs.actions.separator';\nexport class SubmenuAction {\n    get actions() { return this._actions; }\n    constructor(id, label, actions, cssClass) {\n        this.tooltip = '';\n        this.enabled = true;\n        this.checked = undefined;\n        this.id = id;\n        this.label = label;\n        this.class = cssClass;\n        this._actions = actions;\n    }\n    async run() { }\n}\nexport class EmptySubmenuAction extends Action {\n    constructor() {\n        super(EmptySubmenuAction.ID, nls.localize('submenu.empty', '(empty)'), undefined, false);\n    }\n}\nEmptySubmenuAction.ID = 'vs.actions.empty';\nexport function toAction(props) {\n    var _a, _b;\n    return {\n        id: props.id,\n        label: props.label,\n        tooltip: (_a = props.tooltip) !== null && _a !== void 0 ? _a : props.label,\n        class: props.class,\n        enabled: (_b = props.enabled) !== null && _b !== void 0 ? _b : true,\n        checked: props.checked,\n        run: async (...args) => props.run(...args),\n    };\n}\n","/**\n * Returns the last element of an array.\n * @param array The array.\n * @param n Which element from the end (default is zero).\n */\nexport function tail(array, n = 0) {\n    return array[array.length - (1 + n)];\n}\nexport function tail2(arr) {\n    if (arr.length === 0) {\n        throw new Error('Invalid tail call');\n    }\n    return [arr.slice(0, arr.length - 1), arr[arr.length - 1]];\n}\nexport function equals(one, other, itemEquals = (a, b) => a === b) {\n    if (one === other) {\n        return true;\n    }\n    if (!one || !other) {\n        return false;\n    }\n    if (one.length !== other.length) {\n        return false;\n    }\n    for (let i = 0, len = one.length; i < len; i++) {\n        if (!itemEquals(one[i], other[i])) {\n            return false;\n        }\n    }\n    return true;\n}\n/**\n * Remove the element at `index` by replacing it with the last element. This is faster than `splice`\n * but changes the order of the array\n */\nexport function removeFastWithoutKeepingOrder(array, index) {\n    const last = array.length - 1;\n    if (index < last) {\n        array[index] = array[last];\n    }\n    array.pop();\n}\n/**\n * Performs a binary search algorithm over a sorted array.\n *\n * @param array The array being searched.\n * @param key The value we search for.\n * @param comparator A function that takes two array elements and returns zero\n *   if they are equal, a negative number if the first element precedes the\n *   second one in the sorting order, or a positive number if the second element\n *   precedes the first one.\n * @return See {@link binarySearch2}\n */\nexport function binarySearch(array, key, comparator) {\n    return binarySearch2(array.length, i => comparator(array[i], key));\n}\n/**\n * Performs a binary search algorithm over a sorted collection. Useful for cases\n * when we need to perform a binary search over something that isn't actually an\n * array, and converting data to an array would defeat the use of binary search\n * in the first place.\n *\n * @param length The collection length.\n * @param compareToKey A function that takes an index of an element in the\n *   collection and returns zero if the value at this index is equal to the\n *   search key, a negative number if the value precedes the search key in the\n *   sorting order, or a positive number if the search key precedes the value.\n * @return A non-negative index of an element, if found. If not found, the\n *   result is -(n+1) (or ~n, using bitwise notation), where n is the index\n *   where the key should be inserted to maintain the sorting order.\n */\nexport function binarySearch2(length, compareToKey) {\n    let low = 0, high = length - 1;\n    while (low <= high) {\n        const mid = ((low + high) / 2) | 0;\n        const comp = compareToKey(mid);\n        if (comp < 0) {\n            low = mid + 1;\n        }\n        else if (comp > 0) {\n            high = mid - 1;\n        }\n        else {\n            return mid;\n        }\n    }\n    return -(low + 1);\n}\nexport function quickSelect(nth, data, compare) {\n    nth = nth | 0;\n    if (nth >= data.length) {\n        throw new TypeError('invalid index');\n    }\n    const pivotValue = data[Math.floor(data.length * Math.random())];\n    const lower = [];\n    const higher = [];\n    const pivots = [];\n    for (const value of data) {\n        const val = compare(value, pivotValue);\n        if (val < 0) {\n            lower.push(value);\n        }\n        else if (val > 0) {\n            higher.push(value);\n        }\n        else {\n            pivots.push(value);\n        }\n    }\n    if (nth < lower.length) {\n        return quickSelect(nth, lower, compare);\n    }\n    else if (nth < lower.length + pivots.length) {\n        return pivots[0];\n    }\n    else {\n        return quickSelect(nth - (lower.length + pivots.length), higher, compare);\n    }\n}\nexport function groupBy(data, compare) {\n    const result = [];\n    let currentGroup = undefined;\n    for (const element of data.slice(0).sort(compare)) {\n        if (!currentGroup || compare(currentGroup[0], element) !== 0) {\n            currentGroup = [element];\n            result.push(currentGroup);\n        }\n        else {\n            currentGroup.push(element);\n        }\n    }\n    return result;\n}\n/**\n * Splits the given items into a list of (non-empty) groups.\n * `shouldBeGrouped` is used to decide if two consecutive items should be in the same group.\n * The order of the items is preserved.\n */\nexport function* groupAdjacentBy(items, shouldBeGrouped) {\n    let currentGroup;\n    let last;\n    for (const item of items) {\n        if (last !== undefined && shouldBeGrouped(last, item)) {\n            currentGroup.push(item);\n        }\n        else {\n            if (currentGroup) {\n                yield currentGroup;\n            }\n            currentGroup = [item];\n        }\n        last = item;\n    }\n    if (currentGroup) {\n        yield currentGroup;\n    }\n}\nexport function forEachAdjacent(arr, f) {\n    for (let i = 0; i <= arr.length; i++) {\n        f(i === 0 ? undefined : arr[i - 1], i === arr.length ? undefined : arr[i]);\n    }\n}\nexport function forEachWithNeighbors(arr, f) {\n    for (let i = 0; i < arr.length; i++) {\n        f(i === 0 ? undefined : arr[i - 1], arr[i], i + 1 === arr.length ? undefined : arr[i + 1]);\n    }\n}\n/**\n * @returns New array with all falsy values removed. The original array IS NOT modified.\n */\nexport function coalesce(array) {\n    return array.filter((e) => !!e);\n}\n/**\n * Remove all falsy values from `array`. The original array IS modified.\n */\nexport function coalesceInPlace(array) {\n    let to = 0;\n    for (let i = 0; i < array.length; i++) {\n        if (!!array[i]) {\n            array[to] = array[i];\n            to += 1;\n        }\n    }\n    array.length = to;\n}\n/**\n * @returns false if the provided object is an array and not empty.\n */\nexport function isFalsyOrEmpty(obj) {\n    return !Array.isArray(obj) || obj.length === 0;\n}\nexport function isNonEmptyArray(obj) {\n    return Array.isArray(obj) && obj.length > 0;\n}\n/**\n * Removes duplicates from the given array. The optional keyFn allows to specify\n * how elements are checked for equality by returning an alternate value for each.\n */\nexport function distinct(array, keyFn = value => value) {\n    const seen = new Set();\n    return array.filter(element => {\n        const key = keyFn(element);\n        if (seen.has(key)) {\n            return false;\n        }\n        seen.add(key);\n        return true;\n    });\n}\nexport function firstOrDefault(array, notFoundValue) {\n    return array.length > 0 ? array[0] : notFoundValue;\n}\nexport function range(arg, to) {\n    let from = typeof to === 'number' ? arg : 0;\n    if (typeof to === 'number') {\n        from = arg;\n    }\n    else {\n        from = 0;\n        to = arg;\n    }\n    const result = [];\n    if (from <= to) {\n        for (let i = from; i < to; i++) {\n            result.push(i);\n        }\n    }\n    else {\n        for (let i = from; i > to; i--) {\n            result.push(i);\n        }\n    }\n    return result;\n}\n/**\n * Insert `insertArr` inside `target` at `insertIndex`.\n * Please don't touch unless you understand https://jsperf.com/inserting-an-array-within-an-array\n */\nexport function arrayInsert(target, insertIndex, insertArr) {\n    const before = target.slice(0, insertIndex);\n    const after = target.slice(insertIndex);\n    return before.concat(insertArr, after);\n}\n/**\n * Pushes an element to the start of the array, if found.\n */\nexport function pushToStart(arr, value) {\n    const index = arr.indexOf(value);\n    if (index > -1) {\n        arr.splice(index, 1);\n        arr.unshift(value);\n    }\n}\n/**\n * Pushes an element to the end of the array, if found.\n */\nexport function pushToEnd(arr, value) {\n    const index = arr.indexOf(value);\n    if (index > -1) {\n        arr.splice(index, 1);\n        arr.push(value);\n    }\n}\nexport function pushMany(arr, items) {\n    for (const item of items) {\n        arr.push(item);\n    }\n}\nexport function asArray(x) {\n    return Array.isArray(x) ? x : [x];\n}\n/**\n * Insert the new items in the array.\n * @param array The original array.\n * @param start The zero-based location in the array from which to start inserting elements.\n * @param newItems The items to be inserted\n */\nexport function insertInto(array, start, newItems) {\n    const startIdx = getActualStartIndex(array, start);\n    const originalLength = array.length;\n    const newItemsLength = newItems.length;\n    array.length = originalLength + newItemsLength;\n    // Move the items after the start index, start from the end so that we don't overwrite any value.\n    for (let i = originalLength - 1; i >= startIdx; i--) {\n        array[i + newItemsLength] = array[i];\n    }\n    for (let i = 0; i < newItemsLength; i++) {\n        array[i + startIdx] = newItems[i];\n    }\n}\n/**\n * Removes elements from an array and inserts new elements in their place, returning the deleted elements. Alternative to the native Array.splice method, it\n * can only support limited number of items due to the maximum call stack size limit.\n * @param array The original array.\n * @param start The zero-based location in the array from which to start removing elements.\n * @param deleteCount The number of elements to remove.\n * @returns An array containing the elements that were deleted.\n */\nexport function splice(array, start, deleteCount, newItems) {\n    const index = getActualStartIndex(array, start);\n    let result = array.splice(index, deleteCount);\n    if (result === undefined) {\n        // see https://bugs.webkit.org/show_bug.cgi?id=261140\n        result = [];\n    }\n    insertInto(array, index, newItems);\n    return result;\n}\n/**\n * Determine the actual start index (same logic as the native splice() or slice())\n * 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.\n * 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.\n * @param array The target array.\n * @param start The operation index.\n */\nfunction getActualStartIndex(array, start) {\n    return start < 0 ? Math.max(start + array.length, 0) : Math.min(start, array.length);\n}\nexport var CompareResult;\n(function (CompareResult) {\n    function isLessThan(result) {\n        return result < 0;\n    }\n    CompareResult.isLessThan = isLessThan;\n    function isLessThanOrEqual(result) {\n        return result <= 0;\n    }\n    CompareResult.isLessThanOrEqual = isLessThanOrEqual;\n    function isGreaterThan(result) {\n        return result > 0;\n    }\n    CompareResult.isGreaterThan = isGreaterThan;\n    function isNeitherLessOrGreaterThan(result) {\n        return result === 0;\n    }\n    CompareResult.isNeitherLessOrGreaterThan = isNeitherLessOrGreaterThan;\n    CompareResult.greaterThan = 1;\n    CompareResult.lessThan = -1;\n    CompareResult.neitherLessOrGreaterThan = 0;\n})(CompareResult || (CompareResult = {}));\nexport function compareBy(selector, comparator) {\n    return (a, b) => comparator(selector(a), selector(b));\n}\nexport function tieBreakComparators(...comparators) {\n    return (item1, item2) => {\n        for (const comparator of comparators) {\n            const result = comparator(item1, item2);\n            if (!CompareResult.isNeitherLessOrGreaterThan(result)) {\n                return result;\n            }\n        }\n        return CompareResult.neitherLessOrGreaterThan;\n    };\n}\n/**\n * The natural order on numbers.\n*/\nexport const numberComparator = (a, b) => a - b;\nexport const booleanComparator = (a, b) => numberComparator(a ? 1 : 0, b ? 1 : 0);\nexport function reverseOrder(comparator) {\n    return (a, b) => -comparator(a, b);\n}\nexport class ArrayQueue {\n    /**\n     * Constructs a queue that is backed by the given array. Runtime is O(1).\n    */\n    constructor(items) {\n        this.items = items;\n        this.firstIdx = 0;\n        this.lastIdx = this.items.length - 1;\n    }\n    get length() {\n        return this.lastIdx - this.firstIdx + 1;\n    }\n    /**\n     * Consumes elements from the beginning of the queue as long as the predicate returns true.\n     * If no elements were consumed, `null` is returned. Has a runtime of O(result.length).\n    */\n    takeWhile(predicate) {\n        // P(k) := k <= this.lastIdx && predicate(this.items[k])\n        // Find s := min { k | k >= this.firstIdx && !P(k) } and return this.data[this.firstIdx...s)\n        let startIdx = this.firstIdx;\n        while (startIdx < this.items.length && predicate(this.items[startIdx])) {\n            startIdx++;\n        }\n        const result = startIdx === this.firstIdx ? null : this.items.slice(this.firstIdx, startIdx);\n        this.firstIdx = startIdx;\n        return result;\n    }\n    /**\n     * Consumes elements from the end of the queue as long as the predicate returns true.\n     * If no elements were consumed, `null` is returned.\n     * The result has the same order as the underlying array!\n    */\n    takeFromEndWhile(predicate) {\n        // P(k) := this.firstIdx >= k && predicate(this.items[k])\n        // Find s := max { k | k <= this.lastIdx && !P(k) } and return this.data(s...this.lastIdx]\n        let endIdx = this.lastIdx;\n        while (endIdx >= 0 && predicate(this.items[endIdx])) {\n            endIdx--;\n        }\n        const result = endIdx === this.lastIdx ? null : this.items.slice(endIdx + 1, this.lastIdx + 1);\n        this.lastIdx = endIdx;\n        return result;\n    }\n    peek() {\n        if (this.length === 0) {\n            return undefined;\n        }\n        return this.items[this.firstIdx];\n    }\n    dequeue() {\n        const result = this.items[this.firstIdx];\n        this.firstIdx++;\n        return result;\n    }\n    takeCount(count) {\n        const result = this.items.slice(this.firstIdx, this.firstIdx + count);\n        this.firstIdx += count;\n        return result;\n    }\n}\n/**\n * This class is faster than an iterator and array for lazy computed data.\n*/\nexport class CallbackIterable {\n    constructor(\n    /**\n     * Calls the callback for every item.\n     * Stops when the callback returns false.\n    */\n    iterate) {\n        this.iterate = iterate;\n    }\n    toArray() {\n        const result = [];\n        this.iterate(item => { result.push(item); return true; });\n        return result;\n    }\n    filter(predicate) {\n        return new CallbackIterable(cb => this.iterate(item => predicate(item) ? cb(item) : true));\n    }\n    map(mapFn) {\n        return new CallbackIterable(cb => this.iterate(item => cb(mapFn(item))));\n    }\n    findLast(predicate) {\n        let result;\n        this.iterate(item => {\n            if (predicate(item)) {\n                result = item;\n            }\n            return true;\n        });\n        return result;\n    }\n    findLastMaxBy(comparator) {\n        let result;\n        let first = true;\n        this.iterate(item => {\n            if (first || CompareResult.isGreaterThan(comparator(item, result))) {\n                first = false;\n                result = item;\n            }\n            return true;\n        });\n        return result;\n    }\n}\nCallbackIterable.empty = new CallbackIterable(_callback => { });\n/**\n * Represents a re-arrangement of items in an array.\n */\nexport class Permutation {\n    constructor(_indexMap) {\n        this._indexMap = _indexMap;\n    }\n    /**\n     * Returns a permutation that sorts the given array according to the given compare function.\n     */\n    static createSortPermutation(arr, compareFn) {\n        const sortIndices = Array.from(arr.keys()).sort((index1, index2) => compareFn(arr[index1], arr[index2]));\n        return new Permutation(sortIndices);\n    }\n    /**\n     * Returns a new array with the elements of the given array re-arranged according to this permutation.\n     */\n    apply(arr) {\n        return arr.map((_, index) => arr[this._indexMap[index]]);\n    }\n    /**\n     * Returns a new permutation that undoes the re-arrangement of this permutation.\n    */\n    inverse() {\n        const inverseIndexMap = this._indexMap.slice();\n        for (let i = 0; i < this._indexMap.length; i++) {\n            inverseIndexMap[this._indexMap[i]] = i;\n        }\n        return new Permutation(inverseIndexMap);\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport function findLast(array, predicate) {\n    const idx = findLastIdx(array, predicate);\n    if (idx === -1) {\n        return undefined;\n    }\n    return array[idx];\n}\nexport function findLastIdx(array, predicate, fromIndex = array.length - 1) {\n    for (let i = fromIndex; i >= 0; i--) {\n        const element = array[i];\n        if (predicate(element)) {\n            return i;\n        }\n    }\n    return -1;\n}\n/**\n * Finds the last item where predicate is true using binary search.\n * `predicate` must be monotonous, i.e. `arr.map(predicate)` must be like `[true, ..., true, false, ..., false]`!\n *\n * @returns `undefined` if no item matches, otherwise the last item that matches the predicate.\n */\nexport function findLastMonotonous(array, predicate) {\n    const idx = findLastIdxMonotonous(array, predicate);\n    return idx === -1 ? undefined : array[idx];\n}\n/**\n * Finds the last item where predicate is true using binary search.\n * `predicate` must be monotonous, i.e. `arr.map(predicate)` must be like `[true, ..., true, false, ..., false]`!\n *\n * @returns `startIdx - 1` if predicate is false for all items, otherwise the index of the last item that matches the predicate.\n */\nexport function findLastIdxMonotonous(array, predicate, startIdx = 0, endIdxEx = array.length) {\n    let i = startIdx;\n    let j = endIdxEx;\n    while (i < j) {\n        const k = Math.floor((i + j) / 2);\n        if (predicate(array[k])) {\n            i = k + 1;\n        }\n        else {\n            j = k;\n        }\n    }\n    return i - 1;\n}\n/**\n * Finds the first item where predicate is true using binary search.\n * `predicate` must be monotonous, i.e. `arr.map(predicate)` must be like `[false, ..., false, true, ..., true]`!\n *\n * @returns `undefined` if no item matches, otherwise the first item that matches the predicate.\n */\nexport function findFirstMonotonous(array, predicate) {\n    const idx = findFirstIdxMonotonousOrArrLen(array, predicate);\n    return idx === array.length ? undefined : array[idx];\n}\n/**\n * Finds the first item where predicate is true using binary search.\n * `predicate` must be monotonous, i.e. `arr.map(predicate)` must be like `[false, ..., false, true, ..., true]`!\n *\n * @returns `endIdxEx` if predicate is false for all items, otherwise the index of the first item that matches the predicate.\n */\nexport function findFirstIdxMonotonousOrArrLen(array, predicate, startIdx = 0, endIdxEx = array.length) {\n    let i = startIdx;\n    let j = endIdxEx;\n    while (i < j) {\n        const k = Math.floor((i + j) / 2);\n        if (predicate(array[k])) {\n            j = k;\n        }\n        else {\n            i = k + 1;\n        }\n    }\n    return i;\n}\n/**\n * Use this when\n * * You have a sorted array\n * * You query this array with a monotonous predicate to find the last item that has a certain property.\n * * You query this array multiple times with monotonous predicates that get weaker and weaker.\n */\nexport class MonotonousArray {\n    constructor(_array) {\n        this._array = _array;\n        this._findLastMonotonousLastIdx = 0;\n    }\n    /**\n     * The predicate must be monotonous, i.e. `arr.map(predicate)` must be like `[true, ..., true, false, ..., false]`!\n     * For subsequent calls, current predicate must be weaker than (or equal to) the previous predicate, i.e. more entries must be `true`.\n     */\n    findLastMonotonous(predicate) {\n        if (MonotonousArray.assertInvariants) {\n            if (this._prevFindLastPredicate) {\n                for (const item of this._array) {\n                    if (this._prevFindLastPredicate(item) && !predicate(item)) {\n                        throw new Error('MonotonousArray: current predicate must be weaker than (or equal to) the previous predicate.');\n                    }\n                }\n            }\n            this._prevFindLastPredicate = predicate;\n        }\n        const idx = findLastIdxMonotonous(this._array, predicate, this._findLastMonotonousLastIdx);\n        this._findLastMonotonousLastIdx = idx + 1;\n        return idx === -1 ? undefined : this._array[idx];\n    }\n}\nMonotonousArray.assertInvariants = false;\n/**\n * Returns the first item that is equal to or greater than every other item.\n*/\nexport function findFirstMax(array, comparator) {\n    if (array.length === 0) {\n        return undefined;\n    }\n    let max = array[0];\n    for (let i = 1; i < array.length; i++) {\n        const item = array[i];\n        if (comparator(item, max) > 0) {\n            max = item;\n        }\n    }\n    return max;\n}\n/**\n * Returns the last item that is equal to or greater than every other item.\n*/\nexport function findLastMax(array, comparator) {\n    if (array.length === 0) {\n        return undefined;\n    }\n    let max = array[0];\n    for (let i = 1; i < array.length; i++) {\n        const item = array[i];\n        if (comparator(item, max) >= 0) {\n            max = item;\n        }\n    }\n    return max;\n}\n/**\n * Returns the first item that is equal to or less than every other item.\n*/\nexport function findFirstMin(array, comparator) {\n    return findFirstMax(array, (a, b) => -comparator(a, b));\n}\nexport function findMaxIdx(array, comparator) {\n    if (array.length === 0) {\n        return -1;\n    }\n    let maxIdx = 0;\n    for (let i = 1; i < array.length; i++) {\n        const item = array[i];\n        if (comparator(item, array[maxIdx]) > 0) {\n            maxIdx = i;\n        }\n    }\n    return maxIdx;\n}\n/**\n * Returns the first mapped value of the array which is not undefined.\n */\nexport function mapFindFirst(items, mapFn) {\n    for (const value of items) {\n        const mapped = mapFn(value);\n        if (mapped !== undefined) {\n            return mapped;\n        }\n    }\n    return undefined;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { BugIndicatingError, onUnexpectedError } from './errors.js';\n/**\n * Throws an error with the provided message if the provided value does not evaluate to a true Javascript value.\n *\n * @deprecated Use `assert(...)` instead.\n * This method is usually used like this:\n * ```ts\n * import * as assert from 'vs/base/common/assert';\n * assert.ok(...);\n * ```\n *\n * However, `assert` in that example is a user chosen name.\n * There is no tooling for generating such an import statement.\n * Thus, the `assert(...)` function should be used instead.\n */\nexport function ok(value, message) {\n    if (!value) {\n        throw new Error(message ? `Assertion failed (${message})` : 'Assertion Failed');\n    }\n}\nexport function assertNever(value, message = 'Unreachable') {\n    throw new Error(message);\n}\n/**\n * Like assert, but doesn't throw.\n */\nexport function softAssert(condition) {\n    if (!condition) {\n        onUnexpectedError(new BugIndicatingError('Soft Assertion Failed'));\n    }\n}\n/**\n * condition must be side-effect free!\n */\nexport function assertFn(condition) {\n    if (!condition()) {\n        // eslint-disable-next-line no-debugger\n        debugger;\n        // Reevaluate `condition` again to make debugging easier\n        condition();\n        onUnexpectedError(new BugIndicatingError('Assertion Failed'));\n    }\n}\nexport function checkAdjacentItems(items, predicate) {\n    let i = 0;\n    while (i < items.length - 1) {\n        const a = items[i];\n        const b = items[i + 1];\n        if (!predicate(a, b)) {\n            return false;\n        }\n        i++;\n    }\n    return true;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { CancellationTokenSource } from './cancellation.js';\nimport { BugIndicatingError, CancellationError } from './errors.js';\nimport { Emitter, Event } from './event.js';\nimport { toDisposable } from './lifecycle.js';\nimport { setTimeout0 } from './platform.js';\nimport { MicrotaskDelay } from './symbols.js';\nexport function isThenable(obj) {\n    return !!obj && typeof obj.then === 'function';\n}\nexport function createCancelablePromise(callback) {\n    const source = new CancellationTokenSource();\n    const thenable = callback(source.token);\n    const promise = new Promise((resolve, reject) => {\n        const subscription = source.token.onCancellationRequested(() => {\n            subscription.dispose();\n            reject(new CancellationError());\n        });\n        Promise.resolve(thenable).then(value => {\n            subscription.dispose();\n            source.dispose();\n            resolve(value);\n        }, err => {\n            subscription.dispose();\n            source.dispose();\n            reject(err);\n        });\n    });\n    return new class {\n        cancel() {\n            source.cancel();\n            source.dispose();\n        }\n        then(resolve, reject) {\n            return promise.then(resolve, reject);\n        }\n        catch(reject) {\n            return this.then(undefined, reject);\n        }\n        finally(onfinally) {\n            return promise.finally(onfinally);\n        }\n    };\n}\nexport function raceCancellation(promise, token, defaultValue) {\n    return new Promise((resolve, reject) => {\n        const ref = token.onCancellationRequested(() => {\n            ref.dispose();\n            resolve(defaultValue);\n        });\n        promise.then(resolve, reject).finally(() => ref.dispose());\n    });\n}\n/**\n * A helper to prevent accumulation of sequential async tasks.\n *\n * Imagine a mail man with the sole task of delivering letters. As soon as\n * a letter submitted for delivery, he drives to the destination, delivers it\n * and returns to his base. Imagine that during the trip, N more letters were submitted.\n * When the mail man returns, he picks those N letters and delivers them all in a\n * single trip. Even though N+1 submissions occurred, only 2 deliveries were made.\n *\n * The throttler implements this via the queue() method, by providing it a task\n * factory. Following the example:\n *\n * \t\tconst throttler = new Throttler();\n * \t\tconst letters = [];\n *\n * \t\tfunction deliver() {\n * \t\t\tconst lettersToDeliver = letters;\n * \t\t\tletters = [];\n * \t\t\treturn makeTheTrip(lettersToDeliver);\n * \t\t}\n *\n * \t\tfunction onLetterReceived(l) {\n * \t\t\tletters.push(l);\n * \t\t\tthrottler.queue(deliver);\n * \t\t}\n */\nexport class Throttler {\n    constructor() {\n        this.isDisposed = false;\n        this.activePromise = null;\n        this.queuedPromise = null;\n        this.queuedPromiseFactory = null;\n    }\n    queue(promiseFactory) {\n        if (this.isDisposed) {\n            return Promise.reject(new Error('Throttler is disposed'));\n        }\n        if (this.activePromise) {\n            this.queuedPromiseFactory = promiseFactory;\n            if (!this.queuedPromise) {\n                const onComplete = () => {\n                    this.queuedPromise = null;\n                    if (this.isDisposed) {\n                        return;\n                    }\n                    const result = this.queue(this.queuedPromiseFactory);\n                    this.queuedPromiseFactory = null;\n                    return result;\n                };\n                this.queuedPromise = new Promise(resolve => {\n                    this.activePromise.then(onComplete, onComplete).then(resolve);\n                });\n            }\n            return new Promise((resolve, reject) => {\n                this.queuedPromise.then(resolve, reject);\n            });\n        }\n        this.activePromise = promiseFactory();\n        return new Promise((resolve, reject) => {\n            this.activePromise.then((result) => {\n                this.activePromise = null;\n                resolve(result);\n            }, (err) => {\n                this.activePromise = null;\n                reject(err);\n            });\n        });\n    }\n    dispose() {\n        this.isDisposed = true;\n    }\n}\nconst timeoutDeferred = (timeout, fn) => {\n    let scheduled = true;\n    const handle = setTimeout(() => {\n        scheduled = false;\n        fn();\n    }, timeout);\n    return {\n        isTriggered: () => scheduled,\n        dispose: () => {\n            clearTimeout(handle);\n            scheduled = false;\n        },\n    };\n};\nconst microtaskDeferred = (fn) => {\n    let scheduled = true;\n    queueMicrotask(() => {\n        if (scheduled) {\n            scheduled = false;\n            fn();\n        }\n    });\n    return {\n        isTriggered: () => scheduled,\n        dispose: () => { scheduled = false; },\n    };\n};\n/**\n * A helper to delay (debounce) execution of a task that is being requested often.\n *\n * Following the throttler, now imagine the mail man wants to optimize the number of\n * trips proactively. The trip itself can be long, so he decides not to make the trip\n * as soon as a letter is submitted. Instead he waits a while, in case more\n * letters are submitted. After said waiting period, if no letters were submitted, he\n * decides to make the trip. Imagine that N more letters were submitted after the first\n * one, all within a short period of time between each other. Even though N+1\n * submissions occurred, only 1 delivery was made.\n *\n * The delayer offers this behavior via the trigger() method, into which both the task\n * to be executed and the waiting period (delay) must be passed in as arguments. Following\n * the example:\n *\n * \t\tconst delayer = new Delayer(WAITING_PERIOD);\n * \t\tconst letters = [];\n *\n * \t\tfunction letterReceived(l) {\n * \t\t\tletters.push(l);\n * \t\t\tdelayer.trigger(() => { return makeTheTrip(); });\n * \t\t}\n */\nexport class Delayer {\n    constructor(defaultDelay) {\n        this.defaultDelay = defaultDelay;\n        this.deferred = null;\n        this.completionPromise = null;\n        this.doResolve = null;\n        this.doReject = null;\n        this.task = null;\n    }\n    trigger(task, delay = this.defaultDelay) {\n        this.task = task;\n        this.cancelTimeout();\n        if (!this.completionPromise) {\n            this.completionPromise = new Promise((resolve, reject) => {\n                this.doResolve = resolve;\n                this.doReject = reject;\n            }).then(() => {\n                this.completionPromise = null;\n                this.doResolve = null;\n                if (this.task) {\n                    const task = this.task;\n                    this.task = null;\n                    return task();\n                }\n                return undefined;\n            });\n        }\n        const fn = () => {\n            var _a;\n            this.deferred = null;\n            (_a = this.doResolve) === null || _a === void 0 ? void 0 : _a.call(this, null);\n        };\n        this.deferred = delay === MicrotaskDelay ? microtaskDeferred(fn) : timeoutDeferred(delay, fn);\n        return this.completionPromise;\n    }\n    isTriggered() {\n        var _a;\n        return !!((_a = this.deferred) === null || _a === void 0 ? void 0 : _a.isTriggered());\n    }\n    cancel() {\n        var _a;\n        this.cancelTimeout();\n        if (this.completionPromise) {\n            (_a = this.doReject) === null || _a === void 0 ? void 0 : _a.call(this, new CancellationError());\n            this.completionPromise = null;\n        }\n    }\n    cancelTimeout() {\n        var _a;\n        (_a = this.deferred) === null || _a === void 0 ? void 0 : _a.dispose();\n        this.deferred = null;\n    }\n    dispose() {\n        this.cancel();\n    }\n}\n/**\n * A helper to delay execution of a task that is being requested often, while\n * preventing accumulation of consecutive executions, while the task runs.\n *\n * The mail man is clever and waits for a certain amount of time, before going\n * out to deliver letters. While the mail man is going out, more letters arrive\n * and can only be delivered once he is back. Once he is back the mail man will\n * do one more trip to deliver the letters that have accumulated while he was out.\n */\nexport class ThrottledDelayer {\n    constructor(defaultDelay) {\n        this.delayer = new Delayer(defaultDelay);\n        this.throttler = new Throttler();\n    }\n    trigger(promiseFactory, delay) {\n        return this.delayer.trigger(() => this.throttler.queue(promiseFactory), delay);\n    }\n    cancel() {\n        this.delayer.cancel();\n    }\n    dispose() {\n        this.delayer.dispose();\n        this.throttler.dispose();\n    }\n}\nexport function timeout(millis, token) {\n    if (!token) {\n        return createCancelablePromise(token => timeout(millis, token));\n    }\n    return new Promise((resolve, reject) => {\n        const handle = setTimeout(() => {\n            disposable.dispose();\n            resolve();\n        }, millis);\n        const disposable = token.onCancellationRequested(() => {\n            clearTimeout(handle);\n            disposable.dispose();\n            reject(new CancellationError());\n        });\n    });\n}\n/**\n * Creates a timeout that can be disposed using its returned value.\n * @param handler The timeout handler.\n * @param timeout An optional timeout in milliseconds.\n * @param store An optional {@link DisposableStore} that will have the timeout disposable managed automatically.\n *\n * @example\n * const store = new DisposableStore;\n * // Call the timeout after 1000ms at which point it will be automatically\n * // evicted from the store.\n * const timeoutDisposable = disposableTimeout(() => {}, 1000, store);\n *\n * if (foo) {\n *   // Cancel the timeout and evict it from store.\n *   timeoutDisposable.dispose();\n * }\n */\nexport function disposableTimeout(handler, timeout = 0, store) {\n    const timer = setTimeout(() => {\n        handler();\n        if (store) {\n            disposable.dispose();\n        }\n    }, timeout);\n    const disposable = toDisposable(() => {\n        clearTimeout(timer);\n        store === null || store === void 0 ? void 0 : store.deleteAndLeak(disposable);\n    });\n    store === null || store === void 0 ? void 0 : store.add(disposable);\n    return disposable;\n}\nexport function first(promiseFactories, shouldStop = t => !!t, defaultValue = null) {\n    let index = 0;\n    const len = promiseFactories.length;\n    const loop = () => {\n        if (index >= len) {\n            return Promise.resolve(defaultValue);\n        }\n        const factory = promiseFactories[index++];\n        const promise = Promise.resolve(factory());\n        return promise.then(result => {\n            if (shouldStop(result)) {\n                return Promise.resolve(result);\n            }\n            return loop();\n        });\n    };\n    return loop();\n}\nexport class TimeoutTimer {\n    constructor(runner, timeout) {\n        this._isDisposed = false;\n        this._token = -1;\n        if (typeof runner === 'function' && typeof timeout === 'number') {\n            this.setIfNotSet(runner, timeout);\n        }\n    }\n    dispose() {\n        this.cancel();\n        this._isDisposed = true;\n    }\n    cancel() {\n        if (this._token !== -1) {\n            clearTimeout(this._token);\n            this._token = -1;\n        }\n    }\n    cancelAndSet(runner, timeout) {\n        if (this._isDisposed) {\n            throw new BugIndicatingError(`Calling 'cancelAndSet' on a disposed TimeoutTimer`);\n        }\n        this.cancel();\n        this._token = setTimeout(() => {\n            this._token = -1;\n            runner();\n        }, timeout);\n    }\n    setIfNotSet(runner, timeout) {\n        if (this._isDisposed) {\n            throw new BugIndicatingError(`Calling 'setIfNotSet' on a disposed TimeoutTimer`);\n        }\n        if (this._token !== -1) {\n            // timer is already set\n            return;\n        }\n        this._token = setTimeout(() => {\n            this._token = -1;\n            runner();\n        }, timeout);\n    }\n}\nexport class IntervalTimer {\n    constructor() {\n        this.disposable = undefined;\n        this.isDisposed = false;\n    }\n    cancel() {\n        var _a;\n        (_a = this.disposable) === null || _a === void 0 ? void 0 : _a.dispose();\n        this.disposable = undefined;\n    }\n    cancelAndSet(runner, interval, context = globalThis) {\n        if (this.isDisposed) {\n            throw new BugIndicatingError(`Calling 'cancelAndSet' on a disposed IntervalTimer`);\n        }\n        this.cancel();\n        const handle = context.setInterval(() => {\n            runner();\n        }, interval);\n        this.disposable = toDisposable(() => {\n            context.clearInterval(handle);\n            this.disposable = undefined;\n        });\n    }\n    dispose() {\n        this.cancel();\n        this.isDisposed = true;\n    }\n}\nexport class RunOnceScheduler {\n    constructor(runner, delay) {\n        this.timeoutToken = -1;\n        this.runner = runner;\n        this.timeout = delay;\n        this.timeoutHandler = this.onTimeout.bind(this);\n    }\n    /**\n     * Dispose RunOnceScheduler\n     */\n    dispose() {\n        this.cancel();\n        this.runner = null;\n    }\n    /**\n     * Cancel current scheduled runner (if any).\n     */\n    cancel() {\n        if (this.isScheduled()) {\n            clearTimeout(this.timeoutToken);\n            this.timeoutToken = -1;\n        }\n    }\n    /**\n     * Cancel previous runner (if any) & schedule a new runner.\n     */\n    schedule(delay = this.timeout) {\n        this.cancel();\n        this.timeoutToken = setTimeout(this.timeoutHandler, delay);\n    }\n    get delay() {\n        return this.timeout;\n    }\n    set delay(value) {\n        this.timeout = value;\n    }\n    /**\n     * Returns true if scheduled.\n     */\n    isScheduled() {\n        return this.timeoutToken !== -1;\n    }\n    onTimeout() {\n        this.timeoutToken = -1;\n        if (this.runner) {\n            this.doRun();\n        }\n    }\n    doRun() {\n        var _a;\n        (_a = this.runner) === null || _a === void 0 ? void 0 : _a.call(this);\n    }\n}\n/**\n * Execute the callback the next time the browser is idle, returning an\n * {@link IDisposable} that will cancel the callback when disposed. This wraps\n * [requestIdleCallback] so it will fallback to [setTimeout] if the environment\n * doesn't support it.\n *\n * @param callback The callback to run when idle, this includes an\n * [IdleDeadline] that provides the time alloted for the idle callback by the\n * browser. Not respecting this deadline will result in a degraded user\n * experience.\n * @param timeout A timeout at which point to queue no longer wait for an idle\n * callback but queue it on the regular event loop (like setTimeout). Typically\n * this should not be used.\n *\n * [IdleDeadline]: https://developer.mozilla.org/en-US/docs/Web/API/IdleDeadline\n * [requestIdleCallback]: https://developer.mozilla.org/en-US/docs/Web/API/Window/requestIdleCallback\n * [setTimeout]: https://developer.mozilla.org/en-US/docs/Web/API/Window/setTimeout\n *\n * **Note** that there is `dom.ts#runWhenWindowIdle` which is better suited when running inside a browser\n * context\n */\nexport let runWhenGlobalIdle;\nexport let _runWhenIdle;\n(function () {\n    if (typeof globalThis.requestIdleCallback !== 'function' || typeof globalThis.cancelIdleCallback !== 'function') {\n        _runWhenIdle = (_targetWindow, runner) => {\n            setTimeout0(() => {\n                if (disposed) {\n                    return;\n                }\n                const end = Date.now() + 15; // one frame at 64fps\n                const deadline = {\n                    didTimeout: true,\n                    timeRemaining() {\n                        return Math.max(0, end - Date.now());\n                    }\n                };\n                runner(Object.freeze(deadline));\n            });\n            let disposed = false;\n            return {\n                dispose() {\n                    if (disposed) {\n                        return;\n                    }\n                    disposed = true;\n                }\n            };\n        };\n    }\n    else {\n        _runWhenIdle = (targetWindow, runner, timeout) => {\n            const handle = targetWindow.requestIdleCallback(runner, typeof timeout === 'number' ? { timeout } : undefined);\n            let disposed = false;\n            return {\n                dispose() {\n                    if (disposed) {\n                        return;\n                    }\n                    disposed = true;\n                    targetWindow.cancelIdleCallback(handle);\n                }\n            };\n        };\n    }\n    runWhenGlobalIdle = (runner) => _runWhenIdle(globalThis, runner);\n})();\nexport class AbstractIdleValue {\n    constructor(targetWindow, executor) {\n        this._didRun = false;\n        this._executor = () => {\n            try {\n                this._value = executor();\n            }\n            catch (err) {\n                this._error = err;\n            }\n            finally {\n                this._didRun = true;\n            }\n        };\n        this._handle = _runWhenIdle(targetWindow, () => this._executor());\n    }\n    dispose() {\n        this._handle.dispose();\n    }\n    get value() {\n        if (!this._didRun) {\n            this._handle.dispose();\n            this._executor();\n        }\n        if (this._error) {\n            throw this._error;\n        }\n        return this._value;\n    }\n    get isInitialized() {\n        return this._didRun;\n    }\n}\n/**\n * An `IdleValue` that always uses the current window (which might be throttled or inactive)\n *\n * **Note** that there is `dom.ts#WindowIdleValue` which is better suited when running inside a browser\n * context\n */\nexport class GlobalIdleValue extends AbstractIdleValue {\n    constructor(executor) {\n        super(globalThis, executor);\n    }\n}\n/**\n * Creates a promise whose resolution or rejection can be controlled imperatively.\n */\nexport class DeferredPromise {\n    get isRejected() {\n        var _a;\n        return ((_a = this.outcome) === null || _a === void 0 ? void 0 : _a.outcome) === 1 /* DeferredOutcome.Rejected */;\n    }\n    get isSettled() {\n        return !!this.outcome;\n    }\n    constructor() {\n        this.p = new Promise((c, e) => {\n            this.completeCallback = c;\n            this.errorCallback = e;\n        });\n    }\n    complete(value) {\n        return new Promise(resolve => {\n            this.completeCallback(value);\n            this.outcome = { outcome: 0 /* DeferredOutcome.Resolved */, value };\n            resolve();\n        });\n    }\n    error(err) {\n        return new Promise(resolve => {\n            this.errorCallback(err);\n            this.outcome = { outcome: 1 /* DeferredOutcome.Rejected */, value: err };\n            resolve();\n        });\n    }\n    cancel() {\n        return this.error(new CancellationError());\n    }\n}\n//#endregion\n//#region Promises\nexport var Promises;\n(function (Promises) {\n    /**\n     * A drop-in replacement for `Promise.all` with the only difference\n     * that the method awaits every promise to either fulfill or reject.\n     *\n     * Similar to `Promise.all`, only the first error will be returned\n     * if any.\n     */\n    async function settled(promises) {\n        let firstError = undefined;\n        const result = await Promise.all(promises.map(promise => promise.then(value => value, error => {\n            if (!firstError) {\n                firstError = error;\n            }\n            return undefined; // do not rethrow so that other promises can settle\n        })));\n        if (typeof firstError !== 'undefined') {\n            throw firstError;\n        }\n        return result; // cast is needed and protected by the `throw` above\n    }\n    Promises.settled = settled;\n    /**\n     * A helper to create a new `Promise<T>` with a body that is a promise\n     * itself. By default, an error that raises from the async body will\n     * end up as a unhandled rejection, so this utility properly awaits the\n     * body and rejects the promise as a normal promise does without async\n     * body.\n     *\n     * This method should only be used in rare cases where otherwise `async`\n     * cannot be used (e.g. when callbacks are involved that require this).\n     */\n    function withAsyncBody(bodyFn) {\n        // eslint-disable-next-line no-async-promise-executor\n        return new Promise(async (resolve, reject) => {\n            try {\n                await bodyFn(resolve, reject);\n            }\n            catch (error) {\n                reject(error);\n            }\n        });\n    }\n    Promises.withAsyncBody = withAsyncBody;\n})(Promises || (Promises = {}));\n/**\n * A rich implementation for an `AsyncIterable<T>`.\n */\nexport class AsyncIterableObject {\n    static fromArray(items) {\n        return new AsyncIterableObject((writer) => {\n            writer.emitMany(items);\n        });\n    }\n    static fromPromise(promise) {\n        return new AsyncIterableObject(async (emitter) => {\n            emitter.emitMany(await promise);\n        });\n    }\n    static fromPromises(promises) {\n        return new AsyncIterableObject(async (emitter) => {\n            await Promise.all(promises.map(async (p) => emitter.emitOne(await p)));\n        });\n    }\n    static merge(iterables) {\n        return new AsyncIterableObject(async (emitter) => {\n            await Promise.all(iterables.map(async (iterable) => {\n                for await (const item of iterable) {\n                    emitter.emitOne(item);\n                }\n            }));\n        });\n    }\n    constructor(executor, onReturn) {\n        this._state = 0 /* AsyncIterableSourceState.Initial */;\n        this._results = [];\n        this._error = null;\n        this._onReturn = onReturn;\n        this._onStateChanged = new Emitter();\n        queueMicrotask(async () => {\n            const writer = {\n                emitOne: (item) => this.emitOne(item),\n                emitMany: (items) => this.emitMany(items),\n                reject: (error) => this.reject(error)\n            };\n            try {\n                await Promise.resolve(executor(writer));\n                this.resolve();\n            }\n            catch (err) {\n                this.reject(err);\n            }\n            finally {\n                writer.emitOne = undefined;\n                writer.emitMany = undefined;\n                writer.reject = undefined;\n            }\n        });\n    }\n    [Symbol.asyncIterator]() {\n        let i = 0;\n        return {\n            next: async () => {\n                do {\n                    if (this._state === 2 /* AsyncIterableSourceState.DoneError */) {\n                        throw this._error;\n                    }\n                    if (i < this._results.length) {\n                        return { done: false, value: this._results[i++] };\n                    }\n                    if (this._state === 1 /* AsyncIterableSourceState.DoneOK */) {\n                        return { done: true, value: undefined };\n                    }\n                    await Event.toPromise(this._onStateChanged.event);\n                } while (true);\n            },\n            return: async () => {\n                var _a;\n                (_a = this._onReturn) === null || _a === void 0 ? void 0 : _a.call(this);\n                return { done: true, value: undefined };\n            }\n        };\n    }\n    static map(iterable, mapFn) {\n        return new AsyncIterableObject(async (emitter) => {\n            for await (const item of iterable) {\n                emitter.emitOne(mapFn(item));\n            }\n        });\n    }\n    map(mapFn) {\n        return AsyncIterableObject.map(this, mapFn);\n    }\n    static filter(iterable, filterFn) {\n        return new AsyncIterableObject(async (emitter) => {\n            for await (const item of iterable) {\n                if (filterFn(item)) {\n                    emitter.emitOne(item);\n                }\n            }\n        });\n    }\n    filter(filterFn) {\n        return AsyncIterableObject.filter(this, filterFn);\n    }\n    static coalesce(iterable) {\n        return AsyncIterableObject.filter(iterable, item => !!item);\n    }\n    coalesce() {\n        return AsyncIterableObject.coalesce(this);\n    }\n    static async toPromise(iterable) {\n        const result = [];\n        for await (const item of iterable) {\n            result.push(item);\n        }\n        return result;\n    }\n    toPromise() {\n        return AsyncIterableObject.toPromise(this);\n    }\n    /**\n     * The value will be appended at the end.\n     *\n     * **NOTE** If `resolve()` or `reject()` have already been called, this method has no effect.\n     */\n    emitOne(value) {\n        if (this._state !== 0 /* AsyncIterableSourceState.Initial */) {\n            return;\n        }\n        // it is important to add new values at the end,\n        // as we may have iterators already running on the array\n        this._results.push(value);\n        this._onStateChanged.fire();\n    }\n    /**\n     * The values will be appended at the end.\n     *\n     * **NOTE** If `resolve()` or `reject()` have already been called, this method has no effect.\n     */\n    emitMany(values) {\n        if (this._state !== 0 /* AsyncIterableSourceState.Initial */) {\n            return;\n        }\n        // it is important to add new values at the end,\n        // as we may have iterators already running on the array\n        this._results = this._results.concat(values);\n        this._onStateChanged.fire();\n    }\n    /**\n     * Calling `resolve()` will mark the result array as complete.\n     *\n     * **NOTE** `resolve()` must be called, otherwise all consumers of this iterable will hang indefinitely, similar to a non-resolved promise.\n     * **NOTE** If `resolve()` or `reject()` have already been called, this method has no effect.\n     */\n    resolve() {\n        if (this._state !== 0 /* AsyncIterableSourceState.Initial */) {\n            return;\n        }\n        this._state = 1 /* AsyncIterableSourceState.DoneOK */;\n        this._onStateChanged.fire();\n    }\n    /**\n     * Writing an error will permanently invalidate this iterable.\n     * The current users will receive an error thrown, as will all future users.\n     *\n     * **NOTE** If `resolve()` or `reject()` have already been called, this method has no effect.\n     */\n    reject(error) {\n        if (this._state !== 0 /* AsyncIterableSourceState.Initial */) {\n            return;\n        }\n        this._state = 2 /* AsyncIterableSourceState.DoneError */;\n        this._error = error;\n        this._onStateChanged.fire();\n    }\n}\nAsyncIterableObject.EMPTY = AsyncIterableObject.fromArray([]);\nexport class CancelableAsyncIterableObject extends AsyncIterableObject {\n    constructor(_source, executor) {\n        super(executor);\n        this._source = _source;\n    }\n    cancel() {\n        this._source.cancel();\n    }\n}\nexport function createCancelableAsyncIterable(callback) {\n    const source = new CancellationTokenSource();\n    const innerIterable = callback(source.token);\n    return new CancelableAsyncIterableObject(source, async (emitter) => {\n        const subscription = source.token.onCancellationRequested(() => {\n            subscription.dispose();\n            source.dispose();\n            emitter.reject(new CancellationError());\n        });\n        try {\n            for await (const item of innerIterable) {\n                if (source.token.isCancellationRequested) {\n                    // canceled in the meantime\n                    return;\n                }\n                emitter.emitOne(item);\n            }\n            subscription.dispose();\n            source.dispose();\n        }\n        catch (err) {\n            subscription.dispose();\n            source.dispose();\n            emitter.reject(err);\n        }\n    });\n}\n//#endregion\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Lazy } from './lazy.js';\nconst hasBuffer = (typeof Buffer !== 'undefined');\nconst indexOfTable = new Lazy(() => new Uint8Array(256));\nlet textDecoder;\nexport class VSBuffer {\n    /**\n     * When running in a nodejs context, if `actual` is not a nodejs Buffer, the backing store for\n     * the returned `VSBuffer` instance might use a nodejs Buffer allocated from node's Buffer pool,\n     * which is not transferrable.\n     */\n    static wrap(actual) {\n        if (hasBuffer && !(Buffer.isBuffer(actual))) {\n            // https://nodejs.org/dist/latest-v10.x/docs/api/buffer.html#buffer_class_method_buffer_from_arraybuffer_byteoffset_length\n            // Create a zero-copy Buffer wrapper around the ArrayBuffer pointed to by the Uint8Array\n            actual = Buffer.from(actual.buffer, actual.byteOffset, actual.byteLength);\n        }\n        return new VSBuffer(actual);\n    }\n    constructor(buffer) {\n        this.buffer = buffer;\n        this.byteLength = this.buffer.byteLength;\n    }\n    toString() {\n        if (hasBuffer) {\n            return this.buffer.toString();\n        }\n        else {\n            if (!textDecoder) {\n                textDecoder = new TextDecoder();\n            }\n            return textDecoder.decode(this.buffer);\n        }\n    }\n}\nexport function readUInt16LE(source, offset) {\n    return (((source[offset + 0] << 0) >>> 0) |\n        ((source[offset + 1] << 8) >>> 0));\n}\nexport function writeUInt16LE(destination, value, offset) {\n    destination[offset + 0] = (value & 0b11111111);\n    value = value >>> 8;\n    destination[offset + 1] = (value & 0b11111111);\n}\nexport function readUInt32BE(source, offset) {\n    return (source[offset] * 2 ** 24\n        + source[offset + 1] * 2 ** 16\n        + source[offset + 2] * 2 ** 8\n        + source[offset + 3]);\n}\nexport function writeUInt32BE(destination, value, offset) {\n    destination[offset + 3] = value;\n    value = value >>> 8;\n    destination[offset + 2] = value;\n    value = value >>> 8;\n    destination[offset + 1] = value;\n    value = value >>> 8;\n    destination[offset] = value;\n}\nexport function readUInt8(source, offset) {\n    return source[offset];\n}\nexport function writeUInt8(destination, value, offset) {\n    destination[offset] = value;\n}\n","export function identity(t) {\n    return t;\n}\n/**\n * Uses a LRU cache to make a given parametrized function cached.\n * Caches just the last key/value.\n*/\nexport class LRUCachedFunction {\n    constructor(arg1, arg2) {\n        this.lastCache = undefined;\n        this.lastArgKey = undefined;\n        if (typeof arg1 === 'function') {\n            this._fn = arg1;\n            this._computeKey = identity;\n        }\n        else {\n            this._fn = arg2;\n            this._computeKey = arg1.getCacheKey;\n        }\n    }\n    get(arg) {\n        const key = this._computeKey(arg);\n        if (this.lastArgKey !== key) {\n            this.lastArgKey = key;\n            this.lastCache = this._fn(arg);\n        }\n        return this.lastCache;\n    }\n}\n/**\n * Uses an unbounded cache to memoize the results of the given function.\n*/\nexport class CachedFunction {\n    get cachedValues() {\n        return this._map;\n    }\n    constructor(arg1, arg2) {\n        this._map = new Map();\n        this._map2 = new Map();\n        if (typeof arg1 === 'function') {\n            this._fn = arg1;\n            this._computeKey = identity;\n        }\n        else {\n            this._fn = arg2;\n            this._computeKey = arg1.getCacheKey;\n        }\n    }\n    get(arg) {\n        const key = this._computeKey(arg);\n        if (this._map2.has(key)) {\n            return this._map2.get(key);\n        }\n        const value = this._fn(arg);\n        this._map.set(arg, value);\n        this._map2.set(key, value);\n        return value;\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Emitter, Event } from './event.js';\nconst shortcutEvent = Object.freeze(function (callback, context) {\n    const handle = setTimeout(callback.bind(context), 0);\n    return { dispose() { clearTimeout(handle); } };\n});\nexport var CancellationToken;\n(function (CancellationToken) {\n    function isCancellationToken(thing) {\n        if (thing === CancellationToken.None || thing === CancellationToken.Cancelled) {\n            return true;\n        }\n        if (thing instanceof MutableToken) {\n            return true;\n        }\n        if (!thing || typeof thing !== 'object') {\n            return false;\n        }\n        return typeof thing.isCancellationRequested === 'boolean'\n            && typeof thing.onCancellationRequested === 'function';\n    }\n    CancellationToken.isCancellationToken = isCancellationToken;\n    CancellationToken.None = Object.freeze({\n        isCancellationRequested: false,\n        onCancellationRequested: Event.None\n    });\n    CancellationToken.Cancelled = Object.freeze({\n        isCancellationRequested: true,\n        onCancellationRequested: shortcutEvent\n    });\n})(CancellationToken || (CancellationToken = {}));\nclass MutableToken {\n    constructor() {\n        this._isCancelled = false;\n        this._emitter = null;\n    }\n    cancel() {\n        if (!this._isCancelled) {\n            this._isCancelled = true;\n            if (this._emitter) {\n                this._emitter.fire(undefined);\n                this.dispose();\n            }\n        }\n    }\n    get isCancellationRequested() {\n        return this._isCancelled;\n    }\n    get onCancellationRequested() {\n        if (this._isCancelled) {\n            return shortcutEvent;\n        }\n        if (!this._emitter) {\n            this._emitter = new Emitter();\n        }\n        return this._emitter.event;\n    }\n    dispose() {\n        if (this._emitter) {\n            this._emitter.dispose();\n            this._emitter = null;\n        }\n    }\n}\nexport class CancellationTokenSource {\n    constructor(parent) {\n        this._token = undefined;\n        this._parentListener = undefined;\n        this._parentListener = parent && parent.onCancellationRequested(this.cancel, this);\n    }\n    get token() {\n        if (!this._token) {\n            // be lazy and create the token only when\n            // actually needed\n            this._token = new MutableToken();\n        }\n        return this._token;\n    }\n    cancel() {\n        if (!this._token) {\n            // save an object by returning the default\n            // cancelled token when cancellation happens\n            // before someone asks for the token\n            this._token = CancellationToken.Cancelled;\n        }\n        else if (this._token instanceof MutableToken) {\n            // actually cancel\n            this._token.cancel();\n        }\n    }\n    dispose(cancel = false) {\n        var _a;\n        if (cancel) {\n            this.cancel();\n        }\n        (_a = this._parentListener) === null || _a === void 0 ? void 0 : _a.dispose();\n        if (!this._token) {\n            // ensure to initialize with an empty token if we had none\n            this._token = CancellationToken.None;\n        }\n        else if (this._token instanceof MutableToken) {\n            // actually dispose\n            this._token.dispose();\n        }\n    }\n}\nexport function cancelOnDispose(store) {\n    const source = new CancellationTokenSource();\n    store.add({ dispose() { source.cancel(); } });\n    return source.token;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { register } from './codiconsUtil.js';\n// This file is automatically generated by (microsoft/vscode-codicons)/scripts/export-to-ts.js\n// Please don't edit it, as your changes will be overwritten.\n// Instead, add mappings to codiconsDerived in codicons.ts.\nexport const codiconsLibrary = {\n    add: register('add', 0xea60),\n    plus: register('plus', 0xea60),\n    gistNew: register('gist-new', 0xea60),\n    repoCreate: register('repo-create', 0xea60),\n    lightbulb: register('lightbulb', 0xea61),\n    lightBulb: register('light-bulb', 0xea61),\n    repo: register('repo', 0xea62),\n    repoDelete: register('repo-delete', 0xea62),\n    gistFork: register('gist-fork', 0xea63),\n    repoForked: register('repo-forked', 0xea63),\n    gitPullRequest: register('git-pull-request', 0xea64),\n    gitPullRequestAbandoned: register('git-pull-request-abandoned', 0xea64),\n    recordKeys: register('record-keys', 0xea65),\n    keyboard: register('keyboard', 0xea65),\n    tag: register('tag', 0xea66),\n    gitPullRequestLabel: register('git-pull-request-label', 0xea66),\n    tagAdd: register('tag-add', 0xea66),\n    tagRemove: register('tag-remove', 0xea66),\n    person: register('person', 0xea67),\n    personFollow: register('person-follow', 0xea67),\n    personOutline: register('person-outline', 0xea67),\n    personFilled: register('person-filled', 0xea67),\n    gitBranch: register('git-branch', 0xea68),\n    gitBranchCreate: register('git-branch-create', 0xea68),\n    gitBranchDelete: register('git-branch-delete', 0xea68),\n    sourceControl: register('source-control', 0xea68),\n    mirror: register('mirror', 0xea69),\n    mirrorPublic: register('mirror-public', 0xea69),\n    star: register('star', 0xea6a),\n    starAdd: register('star-add', 0xea6a),\n    starDelete: register('star-delete', 0xea6a),\n    starEmpty: register('star-empty', 0xea6a),\n    comment: register('comment', 0xea6b),\n    commentAdd: register('comment-add', 0xea6b),\n    alert: register('alert', 0xea6c),\n    warning: register('warning', 0xea6c),\n    search: register('search', 0xea6d),\n    searchSave: register('search-save', 0xea6d),\n    logOut: register('log-out', 0xea6e),\n    signOut: register('sign-out', 0xea6e),\n    logIn: register('log-in', 0xea6f),\n    signIn: register('sign-in', 0xea6f),\n    eye: register('eye', 0xea70),\n    eyeUnwatch: register('eye-unwatch', 0xea70),\n    eyeWatch: register('eye-watch', 0xea70),\n    circleFilled: register('circle-filled', 0xea71),\n    primitiveDot: register('primitive-dot', 0xea71),\n    closeDirty: register('close-dirty', 0xea71),\n    debugBreakpoint: register('debug-breakpoint', 0xea71),\n    debugBreakpointDisabled: register('debug-breakpoint-disabled', 0xea71),\n    debugHint: register('debug-hint', 0xea71),\n    terminalDecorationSuccess: register('terminal-decoration-success', 0xea71),\n    primitiveSquare: register('primitive-square', 0xea72),\n    edit: register('edit', 0xea73),\n    pencil: register('pencil', 0xea73),\n    info: register('info', 0xea74),\n    issueOpened: register('issue-opened', 0xea74),\n    gistPrivate: register('gist-private', 0xea75),\n    gitForkPrivate: register('git-fork-private', 0xea75),\n    lock: register('lock', 0xea75),\n    mirrorPrivate: register('mirror-private', 0xea75),\n    close: register('close', 0xea76),\n    removeClose: register('remove-close', 0xea76),\n    x: register('x', 0xea76),\n    repoSync: register('repo-sync', 0xea77),\n    sync: register('sync', 0xea77),\n    clone: register('clone', 0xea78),\n    desktopDownload: register('desktop-download', 0xea78),\n    beaker: register('beaker', 0xea79),\n    microscope: register('microscope', 0xea79),\n    vm: register('vm', 0xea7a),\n    deviceDesktop: register('device-desktop', 0xea7a),\n    file: register('file', 0xea7b),\n    fileText: register('file-text', 0xea7b),\n    more: register('more', 0xea7c),\n    ellipsis: register('ellipsis', 0xea7c),\n    kebabHorizontal: register('kebab-horizontal', 0xea7c),\n    mailReply: register('mail-reply', 0xea7d),\n    reply: register('reply', 0xea7d),\n    organization: register('organization', 0xea7e),\n    organizationFilled: register('organization-filled', 0xea7e),\n    organizationOutline: register('organization-outline', 0xea7e),\n    newFile: register('new-file', 0xea7f),\n    fileAdd: register('file-add', 0xea7f),\n    newFolder: register('new-folder', 0xea80),\n    fileDirectoryCreate: register('file-directory-create', 0xea80),\n    trash: register('trash', 0xea81),\n    trashcan: register('trashcan', 0xea81),\n    history: register('history', 0xea82),\n    clock: register('clock', 0xea82),\n    folder: register('folder', 0xea83),\n    fileDirectory: register('file-directory', 0xea83),\n    symbolFolder: register('symbol-folder', 0xea83),\n    logoGithub: register('logo-github', 0xea84),\n    markGithub: register('mark-github', 0xea84),\n    github: register('github', 0xea84),\n    terminal: register('terminal', 0xea85),\n    console: register('console', 0xea85),\n    repl: register('repl', 0xea85),\n    zap: register('zap', 0xea86),\n    symbolEvent: register('symbol-event', 0xea86),\n    error: register('error', 0xea87),\n    stop: register('stop', 0xea87),\n    variable: register('variable', 0xea88),\n    symbolVariable: register('symbol-variable', 0xea88),\n    array: register('array', 0xea8a),\n    symbolArray: register('symbol-array', 0xea8a),\n    symbolModule: register('symbol-module', 0xea8b),\n    symbolPackage: register('symbol-package', 0xea8b),\n    symbolNamespace: register('symbol-namespace', 0xea8b),\n    symbolObject: register('symbol-object', 0xea8b),\n    symbolMethod: register('symbol-method', 0xea8c),\n    symbolFunction: register('symbol-function', 0xea8c),\n    symbolConstructor: register('symbol-constructor', 0xea8c),\n    symbolBoolean: register('symbol-boolean', 0xea8f),\n    symbolNull: register('symbol-null', 0xea8f),\n    symbolNumeric: register('symbol-numeric', 0xea90),\n    symbolNumber: register('symbol-number', 0xea90),\n    symbolStructure: register('symbol-structure', 0xea91),\n    symbolStruct: register('symbol-struct', 0xea91),\n    symbolParameter: register('symbol-parameter', 0xea92),\n    symbolTypeParameter: register('symbol-type-parameter', 0xea92),\n    symbolKey: register('symbol-key', 0xea93),\n    symbolText: register('symbol-text', 0xea93),\n    symbolReference: register('symbol-reference', 0xea94),\n    goToFile: register('go-to-file', 0xea94),\n    symbolEnum: register('symbol-enum', 0xea95),\n    symbolValue: register('symbol-value', 0xea95),\n    symbolRuler: register('symbol-ruler', 0xea96),\n    symbolUnit: register('symbol-unit', 0xea96),\n    activateBreakpoints: register('activate-breakpoints', 0xea97),\n    archive: register('archive', 0xea98),\n    arrowBoth: register('arrow-both', 0xea99),\n    arrowDown: register('arrow-down', 0xea9a),\n    arrowLeft: register('arrow-left', 0xea9b),\n    arrowRight: register('arrow-right', 0xea9c),\n    arrowSmallDown: register('arrow-small-down', 0xea9d),\n    arrowSmallLeft: register('arrow-small-left', 0xea9e),\n    arrowSmallRight: register('arrow-small-right', 0xea9f),\n    arrowSmallUp: register('arrow-small-up', 0xeaa0),\n    arrowUp: register('arrow-up', 0xeaa1),\n    bell: register('bell', 0xeaa2),\n    bold: register('bold', 0xeaa3),\n    book: register('book', 0xeaa4),\n    bookmark: register('bookmark', 0xeaa5),\n    debugBreakpointConditionalUnverified: register('debug-breakpoint-conditional-unverified', 0xeaa6),\n    debugBreakpointConditional: register('debug-breakpoint-conditional', 0xeaa7),\n    debugBreakpointConditionalDisabled: register('debug-breakpoint-conditional-disabled', 0xeaa7),\n    debugBreakpointDataUnverified: register('debug-breakpoint-data-unverified', 0xeaa8),\n    debugBreakpointData: register('debug-breakpoint-data', 0xeaa9),\n    debugBreakpointDataDisabled: register('debug-breakpoint-data-disabled', 0xeaa9),\n    debugBreakpointLogUnverified: register('debug-breakpoint-log-unverified', 0xeaaa),\n    debugBreakpointLog: register('debug-breakpoint-log', 0xeaab),\n    debugBreakpointLogDisabled: register('debug-breakpoint-log-disabled', 0xeaab),\n    briefcase: register('briefcase', 0xeaac),\n    broadcast: register('broadcast', 0xeaad),\n    browser: register('browser', 0xeaae),\n    bug: register('bug', 0xeaaf),\n    calendar: register('calendar', 0xeab0),\n    caseSensitive: register('case-sensitive', 0xeab1),\n    check: register('check', 0xeab2),\n    checklist: register('checklist', 0xeab3),\n    chevronDown: register('chevron-down', 0xeab4),\n    chevronLeft: register('chevron-left', 0xeab5),\n    chevronRight: register('chevron-right', 0xeab6),\n    chevronUp: register('chevron-up', 0xeab7),\n    chromeClose: register('chrome-close', 0xeab8),\n    chromeMaximize: register('chrome-maximize', 0xeab9),\n    chromeMinimize: register('chrome-minimize', 0xeaba),\n    chromeRestore: register('chrome-restore', 0xeabb),\n    circleOutline: register('circle-outline', 0xeabc),\n    circle: register('circle', 0xeabc),\n    debugBreakpointUnverified: register('debug-breakpoint-unverified', 0xeabc),\n    terminalDecorationIncomplete: register('terminal-decoration-incomplete', 0xeabc),\n    circleSlash: register('circle-slash', 0xeabd),\n    circuitBoard: register('circuit-board', 0xeabe),\n    clearAll: register('clear-all', 0xeabf),\n    clippy: register('clippy', 0xeac0),\n    closeAll: register('close-all', 0xeac1),\n    cloudDownload: register('cloud-download', 0xeac2),\n    cloudUpload: register('cloud-upload', 0xeac3),\n    code: register('code', 0xeac4),\n    collapseAll: register('collapse-all', 0xeac5),\n    colorMode: register('color-mode', 0xeac6),\n    commentDiscussion: register('comment-discussion', 0xeac7),\n    creditCard: register('credit-card', 0xeac9),\n    dash: register('dash', 0xeacc),\n    dashboard: register('dashboard', 0xeacd),\n    database: register('database', 0xeace),\n    debugContinue: register('debug-continue', 0xeacf),\n    debugDisconnect: register('debug-disconnect', 0xead0),\n    debugPause: register('debug-pause', 0xead1),\n    debugRestart: register('debug-restart', 0xead2),\n    debugStart: register('debug-start', 0xead3),\n    debugStepInto: register('debug-step-into', 0xead4),\n    debugStepOut: register('debug-step-out', 0xead5),\n    debugStepOver: register('debug-step-over', 0xead6),\n    debugStop: register('debug-stop', 0xead7),\n    debug: register('debug', 0xead8),\n    deviceCameraVideo: register('device-camera-video', 0xead9),\n    deviceCamera: register('device-camera', 0xeada),\n    deviceMobile: register('device-mobile', 0xeadb),\n    diffAdded: register('diff-added', 0xeadc),\n    diffIgnored: register('diff-ignored', 0xeadd),\n    diffModified: register('diff-modified', 0xeade),\n    diffRemoved: register('diff-removed', 0xeadf),\n    diffRenamed: register('diff-renamed', 0xeae0),\n    diff: register('diff', 0xeae1),\n    diffSidebyside: register('diff-sidebyside', 0xeae1),\n    discard: register('discard', 0xeae2),\n    editorLayout: register('editor-layout', 0xeae3),\n    emptyWindow: register('empty-window', 0xeae4),\n    exclude: register('exclude', 0xeae5),\n    extensions: register('extensions', 0xeae6),\n    eyeClosed: register('eye-closed', 0xeae7),\n    fileBinary: register('file-binary', 0xeae8),\n    fileCode: register('file-code', 0xeae9),\n    fileMedia: register('file-media', 0xeaea),\n    filePdf: register('file-pdf', 0xeaeb),\n    fileSubmodule: register('file-submodule', 0xeaec),\n    fileSymlinkDirectory: register('file-symlink-directory', 0xeaed),\n    fileSymlinkFile: register('file-symlink-file', 0xeaee),\n    fileZip: register('file-zip', 0xeaef),\n    files: register('files', 0xeaf0),\n    filter: register('filter', 0xeaf1),\n    flame: register('flame', 0xeaf2),\n    foldDown: register('fold-down', 0xeaf3),\n    foldUp: register('fold-up', 0xeaf4),\n    fold: register('fold', 0xeaf5),\n    folderActive: register('folder-active', 0xeaf6),\n    folderOpened: register('folder-opened', 0xeaf7),\n    gear: register('gear', 0xeaf8),\n    gift: register('gift', 0xeaf9),\n    gistSecret: register('gist-secret', 0xeafa),\n    gist: register('gist', 0xeafb),\n    gitCommit: register('git-commit', 0xeafc),\n    gitCompare: register('git-compare', 0xeafd),\n    compareChanges: register('compare-changes', 0xeafd),\n    gitMerge: register('git-merge', 0xeafe),\n    githubAction: register('github-action', 0xeaff),\n    githubAlt: register('github-alt', 0xeb00),\n    globe: register('globe', 0xeb01),\n    grabber: register('grabber', 0xeb02),\n    graph: register('graph', 0xeb03),\n    gripper: register('gripper', 0xeb04),\n    heart: register('heart', 0xeb05),\n    home: register('home', 0xeb06),\n    horizontalRule: register('horizontal-rule', 0xeb07),\n    hubot: register('hubot', 0xeb08),\n    inbox: register('inbox', 0xeb09),\n    issueReopened: register('issue-reopened', 0xeb0b),\n    issues: register('issues', 0xeb0c),\n    italic: register('italic', 0xeb0d),\n    jersey: register('jersey', 0xeb0e),\n    json: register('json', 0xeb0f),\n    kebabVertical: register('kebab-vertical', 0xeb10),\n    key: register('key', 0xeb11),\n    law: register('law', 0xeb12),\n    lightbulbAutofix: register('lightbulb-autofix', 0xeb13),\n    linkExternal: register('link-external', 0xeb14),\n    link: register('link', 0xeb15),\n    listOrdered: register('list-ordered', 0xeb16),\n    listUnordered: register('list-unordered', 0xeb17),\n    liveShare: register('live-share', 0xeb18),\n    loading: register('loading', 0xeb19),\n    location: register('location', 0xeb1a),\n    mailRead: register('mail-read', 0xeb1b),\n    mail: register('mail', 0xeb1c),\n    markdown: register('markdown', 0xeb1d),\n    megaphone: register('megaphone', 0xeb1e),\n    mention: register('mention', 0xeb1f),\n    milestone: register('milestone', 0xeb20),\n    gitPullRequestMilestone: register('git-pull-request-milestone', 0xeb20),\n    mortarBoard: register('mortar-board', 0xeb21),\n    move: register('move', 0xeb22),\n    multipleWindows: register('multiple-windows', 0xeb23),\n    mute: register('mute', 0xeb24),\n    noNewline: register('no-newline', 0xeb25),\n    note: register('note', 0xeb26),\n    octoface: register('octoface', 0xeb27),\n    openPreview: register('open-preview', 0xeb28),\n    package: register('package', 0xeb29),\n    paintcan: register('paintcan', 0xeb2a),\n    pin: register('pin', 0xeb2b),\n    play: register('play', 0xeb2c),\n    run: register('run', 0xeb2c),\n    plug: register('plug', 0xeb2d),\n    preserveCase: register('preserve-case', 0xeb2e),\n    preview: register('preview', 0xeb2f),\n    project: register('project', 0xeb30),\n    pulse: register('pulse', 0xeb31),\n    question: register('question', 0xeb32),\n    quote: register('quote', 0xeb33),\n    radioTower: register('radio-tower', 0xeb34),\n    reactions: register('reactions', 0xeb35),\n    references: register('references', 0xeb36),\n    refresh: register('refresh', 0xeb37),\n    regex: register('regex', 0xeb38),\n    remoteExplorer: register('remote-explorer', 0xeb39),\n    remote: register('remote', 0xeb3a),\n    remove: register('remove', 0xeb3b),\n    replaceAll: register('replace-all', 0xeb3c),\n    replace: register('replace', 0xeb3d),\n    repoClone: register('repo-clone', 0xeb3e),\n    repoForcePush: register('repo-force-push', 0xeb3f),\n    repoPull: register('repo-pull', 0xeb40),\n    repoPush: register('repo-push', 0xeb41),\n    report: register('report', 0xeb42),\n    requestChanges: register('request-changes', 0xeb43),\n    rocket: register('rocket', 0xeb44),\n    rootFolderOpened: register('root-folder-opened', 0xeb45),\n    rootFolder: register('root-folder', 0xeb46),\n    rss: register('rss', 0xeb47),\n    ruby: register('ruby', 0xeb48),\n    saveAll: register('save-all', 0xeb49),\n    saveAs: register('save-as', 0xeb4a),\n    save: register('save', 0xeb4b),\n    screenFull: register('screen-full', 0xeb4c),\n    screenNormal: register('screen-normal', 0xeb4d),\n    searchStop: register('search-stop', 0xeb4e),\n    server: register('server', 0xeb50),\n    settingsGear: register('settings-gear', 0xeb51),\n    settings: register('settings', 0xeb52),\n    shield: register('shield', 0xeb53),\n    smiley: register('smiley', 0xeb54),\n    sortPrecedence: register('sort-precedence', 0xeb55),\n    splitHorizontal: register('split-horizontal', 0xeb56),\n    splitVertical: register('split-vertical', 0xeb57),\n    squirrel: register('squirrel', 0xeb58),\n    starFull: register('star-full', 0xeb59),\n    starHalf: register('star-half', 0xeb5a),\n    symbolClass: register('symbol-class', 0xeb5b),\n    symbolColor: register('symbol-color', 0xeb5c),\n    symbolConstant: register('symbol-constant', 0xeb5d),\n    symbolEnumMember: register('symbol-enum-member', 0xeb5e),\n    symbolField: register('symbol-field', 0xeb5f),\n    symbolFile: register('symbol-file', 0xeb60),\n    symbolInterface: register('symbol-interface', 0xeb61),\n    symbolKeyword: register('symbol-keyword', 0xeb62),\n    symbolMisc: register('symbol-misc', 0xeb63),\n    symbolOperator: register('symbol-operator', 0xeb64),\n    symbolProperty: register('symbol-property', 0xeb65),\n    wrench: register('wrench', 0xeb65),\n    wrenchSubaction: register('wrench-subaction', 0xeb65),\n    symbolSnippet: register('symbol-snippet', 0xeb66),\n    tasklist: register('tasklist', 0xeb67),\n    telescope: register('telescope', 0xeb68),\n    textSize: register('text-size', 0xeb69),\n    threeBars: register('three-bars', 0xeb6a),\n    thumbsdown: register('thumbsdown', 0xeb6b),\n    thumbsup: register('thumbsup', 0xeb6c),\n    tools: register('tools', 0xeb6d),\n    triangleDown: register('triangle-down', 0xeb6e),\n    triangleLeft: register('triangle-left', 0xeb6f),\n    triangleRight: register('triangle-right', 0xeb70),\n    triangleUp: register('triangle-up', 0xeb71),\n    twitter: register('twitter', 0xeb72),\n    unfold: register('unfold', 0xeb73),\n    unlock: register('unlock', 0xeb74),\n    unmute: register('unmute', 0xeb75),\n    unverified: register('unverified', 0xeb76),\n    verified: register('verified', 0xeb77),\n    versions: register('versions', 0xeb78),\n    vmActive: register('vm-active', 0xeb79),\n    vmOutline: register('vm-outline', 0xeb7a),\n    vmRunning: register('vm-running', 0xeb7b),\n    watch: register('watch', 0xeb7c),\n    whitespace: register('whitespace', 0xeb7d),\n    wholeWord: register('whole-word', 0xeb7e),\n    window: register('window', 0xeb7f),\n    wordWrap: register('word-wrap', 0xeb80),\n    zoomIn: register('zoom-in', 0xeb81),\n    zoomOut: register('zoom-out', 0xeb82),\n    listFilter: register('list-filter', 0xeb83),\n    listFlat: register('list-flat', 0xeb84),\n    listSelection: register('list-selection', 0xeb85),\n    selection: register('selection', 0xeb85),\n    listTree: register('list-tree', 0xeb86),\n    debugBreakpointFunctionUnverified: register('debug-breakpoint-function-unverified', 0xeb87),\n    debugBreakpointFunction: register('debug-breakpoint-function', 0xeb88),\n    debugBreakpointFunctionDisabled: register('debug-breakpoint-function-disabled', 0xeb88),\n    debugStackframeActive: register('debug-stackframe-active', 0xeb89),\n    circleSmallFilled: register('circle-small-filled', 0xeb8a),\n    debugStackframeDot: register('debug-stackframe-dot', 0xeb8a),\n    terminalDecorationMark: register('terminal-decoration-mark', 0xeb8a),\n    debugStackframe: register('debug-stackframe', 0xeb8b),\n    debugStackframeFocused: register('debug-stackframe-focused', 0xeb8b),\n    debugBreakpointUnsupported: register('debug-breakpoint-unsupported', 0xeb8c),\n    symbolString: register('symbol-string', 0xeb8d),\n    debugReverseContinue: register('debug-reverse-continue', 0xeb8e),\n    debugStepBack: register('debug-step-back', 0xeb8f),\n    debugRestartFrame: register('debug-restart-frame', 0xeb90),\n    debugAlt: register('debug-alt', 0xeb91),\n    callIncoming: register('call-incoming', 0xeb92),\n    callOutgoing: register('call-outgoing', 0xeb93),\n    menu: register('menu', 0xeb94),\n    expandAll: register('expand-all', 0xeb95),\n    feedback: register('feedback', 0xeb96),\n    gitPullRequestReviewer: register('git-pull-request-reviewer', 0xeb96),\n    groupByRefType: register('group-by-ref-type', 0xeb97),\n    ungroupByRefType: register('ungroup-by-ref-type', 0xeb98),\n    account: register('account', 0xeb99),\n    gitPullRequestAssignee: register('git-pull-request-assignee', 0xeb99),\n    bellDot: register('bell-dot', 0xeb9a),\n    debugConsole: register('debug-console', 0xeb9b),\n    library: register('library', 0xeb9c),\n    output: register('output', 0xeb9d),\n    runAll: register('run-all', 0xeb9e),\n    syncIgnored: register('sync-ignored', 0xeb9f),\n    pinned: register('pinned', 0xeba0),\n    githubInverted: register('github-inverted', 0xeba1),\n    serverProcess: register('server-process', 0xeba2),\n    serverEnvironment: register('server-environment', 0xeba3),\n    pass: register('pass', 0xeba4),\n    issueClosed: register('issue-closed', 0xeba4),\n    stopCircle: register('stop-circle', 0xeba5),\n    playCircle: register('play-circle', 0xeba6),\n    record: register('record', 0xeba7),\n    debugAltSmall: register('debug-alt-small', 0xeba8),\n    vmConnect: register('vm-connect', 0xeba9),\n    cloud: register('cloud', 0xebaa),\n    merge: register('merge', 0xebab),\n    export: register('export', 0xebac),\n    graphLeft: register('graph-left', 0xebad),\n    magnet: register('magnet', 0xebae),\n    notebook: register('notebook', 0xebaf),\n    redo: register('redo', 0xebb0),\n    checkAll: register('check-all', 0xebb1),\n    pinnedDirty: register('pinned-dirty', 0xebb2),\n    passFilled: register('pass-filled', 0xebb3),\n    circleLargeFilled: register('circle-large-filled', 0xebb4),\n    circleLarge: register('circle-large', 0xebb5),\n    circleLargeOutline: register('circle-large-outline', 0xebb5),\n    combine: register('combine', 0xebb6),\n    gather: register('gather', 0xebb6),\n    table: register('table', 0xebb7),\n    variableGroup: register('variable-group', 0xebb8),\n    typeHierarchy: register('type-hierarchy', 0xebb9),\n    typeHierarchySub: register('type-hierarchy-sub', 0xebba),\n    typeHierarchySuper: register('type-hierarchy-super', 0xebbb),\n    gitPullRequestCreate: register('git-pull-request-create', 0xebbc),\n    runAbove: register('run-above', 0xebbd),\n    runBelow: register('run-below', 0xebbe),\n    notebookTemplate: register('notebook-template', 0xebbf),\n    debugRerun: register('debug-rerun', 0xebc0),\n    workspaceTrusted: register('workspace-trusted', 0xebc1),\n    workspaceUntrusted: register('workspace-untrusted', 0xebc2),\n    workspaceUnknown: register('workspace-unknown', 0xebc3),\n    terminalCmd: register('terminal-cmd', 0xebc4),\n    terminalDebian: register('terminal-debian', 0xebc5),\n    terminalLinux: register('terminal-linux', 0xebc6),\n    terminalPowershell: register('terminal-powershell', 0xebc7),\n    terminalTmux: register('terminal-tmux', 0xebc8),\n    terminalUbuntu: register('terminal-ubuntu', 0xebc9),\n    terminalBash: register('terminal-bash', 0xebca),\n    arrowSwap: register('arrow-swap', 0xebcb),\n    copy: register('copy', 0xebcc),\n    personAdd: register('person-add', 0xebcd),\n    filterFilled: register('filter-filled', 0xebce),\n    wand: register('wand', 0xebcf),\n    debugLineByLine: register('debug-line-by-line', 0xebd0),\n    inspect: register('inspect', 0xebd1),\n    layers: register('layers', 0xebd2),\n    layersDot: register('layers-dot', 0xebd3),\n    layersActive: register('layers-active', 0xebd4),\n    compass: register('compass', 0xebd5),\n    compassDot: register('compass-dot', 0xebd6),\n    compassActive: register('compass-active', 0xebd7),\n    azure: register('azure', 0xebd8),\n    issueDraft: register('issue-draft', 0xebd9),\n    gitPullRequestClosed: register('git-pull-request-closed', 0xebda),\n    gitPullRequestDraft: register('git-pull-request-draft', 0xebdb),\n    debugAll: register('debug-all', 0xebdc),\n    debugCoverage: register('debug-coverage', 0xebdd),\n    runErrors: register('run-errors', 0xebde),\n    folderLibrary: register('folder-library', 0xebdf),\n    debugContinueSmall: register('debug-continue-small', 0xebe0),\n    beakerStop: register('beaker-stop', 0xebe1),\n    graphLine: register('graph-line', 0xebe2),\n    graphScatter: register('graph-scatter', 0xebe3),\n    pieChart: register('pie-chart', 0xebe4),\n    bracket: register('bracket', 0xeb0f),\n    bracketDot: register('bracket-dot', 0xebe5),\n    bracketError: register('bracket-error', 0xebe6),\n    lockSmall: register('lock-small', 0xebe7),\n    azureDevops: register('azure-devops', 0xebe8),\n    verifiedFilled: register('verified-filled', 0xebe9),\n    newline: register('newline', 0xebea),\n    layout: register('layout', 0xebeb),\n    layoutActivitybarLeft: register('layout-activitybar-left', 0xebec),\n    layoutActivitybarRight: register('layout-activitybar-right', 0xebed),\n    layoutPanelLeft: register('layout-panel-left', 0xebee),\n    layoutPanelCenter: register('layout-panel-center', 0xebef),\n    layoutPanelJustify: register('layout-panel-justify', 0xebf0),\n    layoutPanelRight: register('layout-panel-right', 0xebf1),\n    layoutPanel: register('layout-panel', 0xebf2),\n    layoutSidebarLeft: register('layout-sidebar-left', 0xebf3),\n    layoutSidebarRight: register('layout-sidebar-right', 0xebf4),\n    layoutStatusbar: register('layout-statusbar', 0xebf5),\n    layoutMenubar: register('layout-menubar', 0xebf6),\n    layoutCentered: register('layout-centered', 0xebf7),\n    target: register('target', 0xebf8),\n    indent: register('indent', 0xebf9),\n    recordSmall: register('record-small', 0xebfa),\n    errorSmall: register('error-small', 0xebfb),\n    terminalDecorationError: register('terminal-decoration-error', 0xebfb),\n    arrowCircleDown: register('arrow-circle-down', 0xebfc),\n    arrowCircleLeft: register('arrow-circle-left', 0xebfd),\n    arrowCircleRight: register('arrow-circle-right', 0xebfe),\n    arrowCircleUp: register('arrow-circle-up', 0xebff),\n    layoutSidebarRightOff: register('layout-sidebar-right-off', 0xec00),\n    layoutPanelOff: register('layout-panel-off', 0xec01),\n    layoutSidebarLeftOff: register('layout-sidebar-left-off', 0xec02),\n    blank: register('blank', 0xec03),\n    heartFilled: register('heart-filled', 0xec04),\n    map: register('map', 0xec05),\n    mapHorizontal: register('map-horizontal', 0xec05),\n    foldHorizontal: register('fold-horizontal', 0xec05),\n    mapFilled: register('map-filled', 0xec06),\n    mapHorizontalFilled: register('map-horizontal-filled', 0xec06),\n    foldHorizontalFilled: register('fold-horizontal-filled', 0xec06),\n    circleSmall: register('circle-small', 0xec07),\n    bellSlash: register('bell-slash', 0xec08),\n    bellSlashDot: register('bell-slash-dot', 0xec09),\n    commentUnresolved: register('comment-unresolved', 0xec0a),\n    gitPullRequestGoToChanges: register('git-pull-request-go-to-changes', 0xec0b),\n    gitPullRequestNewChanges: register('git-pull-request-new-changes', 0xec0c),\n    searchFuzzy: register('search-fuzzy', 0xec0d),\n    commentDraft: register('comment-draft', 0xec0e),\n    send: register('send', 0xec0f),\n    sparkle: register('sparkle', 0xec10),\n    insert: register('insert', 0xec11),\n    mic: register('mic', 0xec12),\n    thumbsdownFilled: register('thumbsdown-filled', 0xec13),\n    thumbsupFilled: register('thumbsup-filled', 0xec14),\n    coffee: register('coffee', 0xec15),\n    snake: register('snake', 0xec16),\n    game: register('game', 0xec17),\n    vr: register('vr', 0xec18),\n    chip: register('chip', 0xec19),\n    piano: register('piano', 0xec1a),\n    music: register('music', 0xec1b),\n    micFilled: register('mic-filled', 0xec1c),\n    repoFetch: register('repo-fetch', 0xec1d),\n    copilot: register('copilot', 0xec1e),\n    lightbulbSparkle: register('lightbulb-sparkle', 0xec1f),\n    robot: register('robot', 0xec20),\n    sparkleFilled: register('sparkle-filled', 0xec21),\n    diffSingle: register('diff-single', 0xec22),\n    diffMultiple: register('diff-multiple', 0xec23),\n    surroundWith: register('surround-with', 0xec24),\n    share: register('share', 0xec25),\n    gitStash: register('git-stash', 0xec26),\n    gitStashApply: register('git-stash-apply', 0xec27),\n    gitStashPop: register('git-stash-pop', 0xec28),\n    vscode: register('vscode', 0xec29),\n    vscodeInsiders: register('vscode-insiders', 0xec2a),\n    codeOss: register('code-oss', 0xec2b),\n    runCoverage: register('run-coverage', 0xec2c),\n    runAllCoverage: register('run-all-coverage', 0xec2d),\n    coverage: register('coverage', 0xec2e),\n    githubProject: register('github-project', 0xec2f),\n    mapVertical: register('map-vertical', 0xec30),\n    foldVertical: register('fold-vertical', 0xec30),\n    mapVerticalFilled: register('map-vertical-filled', 0xec31),\n    foldVerticalFilled: register('fold-vertical-filled', 0xec31),\n    goToSearch: register('go-to-search', 0xec32),\n    percentage: register('percentage', 0xec33),\n    sortPercentage: register('sort-percentage', 0xec33),\n    attach: register('attach', 0xec34),\n};\n","import { register } from './codiconsUtil.js';\nimport { codiconsLibrary } from './codiconsLibrary.js';\n/**\n * Derived icons, that could become separate icons.\n * These mappings should be moved into the mapping file in the vscode-codicons repo at some point.\n */\nexport const codiconsDerived = {\n    dialogError: register('dialog-error', 'error'),\n    dialogWarning: register('dialog-warning', 'warning'),\n    dialogInfo: register('dialog-info', 'info'),\n    dialogClose: register('dialog-close', 'close'),\n    treeItemExpanded: register('tree-item-expanded', 'chevron-down'), // collapsed is done with rotation\n    treeFilterOnTypeOn: register('tree-filter-on-type-on', 'list-filter'),\n    treeFilterOnTypeOff: register('tree-filter-on-type-off', 'list-selection'),\n    treeFilterClear: register('tree-filter-clear', 'close'),\n    treeItemLoading: register('tree-item-loading', 'loading'),\n    menuSelection: register('menu-selection', 'check'),\n    menuSubmenu: register('menu-submenu', 'chevron-right'),\n    menuBarMore: register('menubar-more', 'more'),\n    scrollbarButtonLeft: register('scrollbar-button-left', 'triangle-left'),\n    scrollbarButtonRight: register('scrollbar-button-right', 'triangle-right'),\n    scrollbarButtonUp: register('scrollbar-button-up', 'triangle-up'),\n    scrollbarButtonDown: register('scrollbar-button-down', 'triangle-down'),\n    toolBarMore: register('toolbar-more', 'more'),\n    quickInputBack: register('quick-input-back', 'arrow-left'),\n    dropDownButton: register('drop-down-button', 0xeab4),\n    symbolCustomColor: register('symbol-customcolor', 0xeb5c),\n    exportIcon: register('export', 0xebac),\n    workspaceUnspecified: register('workspace-unspecified', 0xebc3),\n    newLine: register('newline', 0xebea),\n    thumbsDownFilled: register('thumbsdown-filled', 0xec13),\n    thumbsUpFilled: register('thumbsup-filled', 0xec14),\n    gitFetch: register('git-fetch', 0xec1d),\n    lightbulbSparkleAutofix: register('lightbulb-sparkle-autofix', 0xec1f),\n    debugBreakpointPending: register('debug-breakpoint-pending', 0xebd9),\n};\n/**\n * The Codicon library is a set of default icons that are built-in in VS Code.\n *\n * In the product (outside of base) Codicons should only be used as defaults. In order to have all icons in VS Code\n * themeable, component should define new, UI component specific icons using `iconRegistry.registerIcon`.\n * In that call a Codicon can be named as default.\n */\nexport const Codicon = {\n    ...codiconsLibrary,\n    ...codiconsDerived\n};\n","import { isString } from './types.js';\nconst _codiconFontCharacters = Object.create(null);\nexport function register(id, fontCharacter) {\n    if (isString(fontCharacter)) {\n        const val = _codiconFontCharacters[fontCharacter];\n        if (val === undefined) {\n            throw new Error(`${id} references an unknown codicon: ${fontCharacter}`);\n        }\n        fontCharacter = val;\n    }\n    _codiconFontCharacters[id] = fontCharacter;\n    return { id };\n}\n/**\n * Only to be used by the iconRegistry.\n */\nexport function getCodiconFontCharacters() {\n    return _codiconFontCharacters;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport function diffSets(before, after) {\n    const removed = [];\n    const added = [];\n    for (const element of before) {\n        if (!after.has(element)) {\n            removed.push(element);\n        }\n    }\n    for (const element of after) {\n        if (!before.has(element)) {\n            added.push(element);\n        }\n    }\n    return { removed, added };\n}\n/**\n * Computes the intersection of two sets.\n *\n * @param setA - The first set.\n * @param setB - The second iterable.\n * @returns A new set containing the elements that are in both `setA` and `setB`.\n */\nexport function intersection(setA, setB) {\n    const result = new Set();\n    for (const elem of setB) {\n        if (setA.has(elem)) {\n            result.add(elem);\n        }\n    }\n    return result;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nfunction roundFloat(number, decimalPoints) {\n    const decimal = Math.pow(10, decimalPoints);\n    return Math.round(number * decimal) / decimal;\n}\nexport class RGBA {\n    constructor(r, g, b, a = 1) {\n        this._rgbaBrand = undefined;\n        this.r = Math.min(255, Math.max(0, r)) | 0;\n        this.g = Math.min(255, Math.max(0, g)) | 0;\n        this.b = Math.min(255, Math.max(0, b)) | 0;\n        this.a = roundFloat(Math.max(Math.min(1, a), 0), 3);\n    }\n    static equals(a, b) {\n        return a.r === b.r && a.g === b.g && a.b === b.b && a.a === b.a;\n    }\n}\nexport class HSLA {\n    constructor(h, s, l, a) {\n        this._hslaBrand = undefined;\n        this.h = Math.max(Math.min(360, h), 0) | 0;\n        this.s = roundFloat(Math.max(Math.min(1, s), 0), 3);\n        this.l = roundFloat(Math.max(Math.min(1, l), 0), 3);\n        this.a = roundFloat(Math.max(Math.min(1, a), 0), 3);\n    }\n    static equals(a, b) {\n        return a.h === b.h && a.s === b.s && a.l === b.l && a.a === b.a;\n    }\n    /**\n     * Converts an RGB color value to HSL. Conversion formula\n     * adapted from http://en.wikipedia.org/wiki/HSL_color_space.\n     * Assumes r, g, and b are contained in the set [0, 255] and\n     * returns h in the set [0, 360], s, and l in the set [0, 1].\n     */\n    static fromRGBA(rgba) {\n        const r = rgba.r / 255;\n        const g = rgba.g / 255;\n        const b = rgba.b / 255;\n        const a = rgba.a;\n        const max = Math.max(r, g, b);\n        const min = Math.min(r, g, b);\n        let h = 0;\n        let s = 0;\n        const l = (min + max) / 2;\n        const chroma = max - min;\n        if (chroma > 0) {\n            s = Math.min((l <= 0.5 ? chroma / (2 * l) : chroma / (2 - (2 * l))), 1);\n            switch (max) {\n                case r:\n                    h = (g - b) / chroma + (g < b ? 6 : 0);\n                    break;\n                case g:\n                    h = (b - r) / chroma + 2;\n                    break;\n                case b:\n                    h = (r - g) / chroma + 4;\n                    break;\n            }\n            h *= 60;\n            h = Math.round(h);\n        }\n        return new HSLA(h, s, l, a);\n    }\n    static _hue2rgb(p, q, t) {\n        if (t < 0) {\n            t += 1;\n        }\n        if (t > 1) {\n            t -= 1;\n        }\n        if (t < 1 / 6) {\n            return p + (q - p) * 6 * t;\n        }\n        if (t < 1 / 2) {\n            return q;\n        }\n        if (t < 2 / 3) {\n            return p + (q - p) * (2 / 3 - t) * 6;\n        }\n        return p;\n    }\n    /**\n     * Converts an HSL color value to RGB. Conversion formula\n     * adapted from http://en.wikipedia.org/wiki/HSL_color_space.\n     * Assumes h in the set [0, 360] s, and l are contained in the set [0, 1] and\n     * returns r, g, and b in the set [0, 255].\n     */\n    static toRGBA(hsla) {\n        const h = hsla.h / 360;\n        const { s, l, a } = hsla;\n        let r, g, b;\n        if (s === 0) {\n            r = g = b = l; // achromatic\n        }\n        else {\n            const q = l < 0.5 ? l * (1 + s) : l + s - l * s;\n            const p = 2 * l - q;\n            r = HSLA._hue2rgb(p, q, h + 1 / 3);\n            g = HSLA._hue2rgb(p, q, h);\n            b = HSLA._hue2rgb(p, q, h - 1 / 3);\n        }\n        return new RGBA(Math.round(r * 255), Math.round(g * 255), Math.round(b * 255), a);\n    }\n}\nexport class HSVA {\n    constructor(h, s, v, a) {\n        this._hsvaBrand = undefined;\n        this.h = Math.max(Math.min(360, h), 0) | 0;\n        this.s = roundFloat(Math.max(Math.min(1, s), 0), 3);\n        this.v = roundFloat(Math.max(Math.min(1, v), 0), 3);\n        this.a = roundFloat(Math.max(Math.min(1, a), 0), 3);\n    }\n    static equals(a, b) {\n        return a.h === b.h && a.s === b.s && a.v === b.v && a.a === b.a;\n    }\n    // from http://www.rapidtables.com/convert/color/rgb-to-hsv.htm\n    static fromRGBA(rgba) {\n        const r = rgba.r / 255;\n        const g = rgba.g / 255;\n        const b = rgba.b / 255;\n        const cmax = Math.max(r, g, b);\n        const cmin = Math.min(r, g, b);\n        const delta = cmax - cmin;\n        const s = cmax === 0 ? 0 : (delta / cmax);\n        let m;\n        if (delta === 0) {\n            m = 0;\n        }\n        else if (cmax === r) {\n            m = ((((g - b) / delta) % 6) + 6) % 6;\n        }\n        else if (cmax === g) {\n            m = ((b - r) / delta) + 2;\n        }\n        else {\n            m = ((r - g) / delta) + 4;\n        }\n        return new HSVA(Math.round(m * 60), s, cmax, rgba.a);\n    }\n    // from http://www.rapidtables.com/convert/color/hsv-to-rgb.htm\n    static toRGBA(hsva) {\n        const { h, s, v, a } = hsva;\n        const c = v * s;\n        const x = c * (1 - Math.abs((h / 60) % 2 - 1));\n        const m = v - c;\n        let [r, g, b] = [0, 0, 0];\n        if (h < 60) {\n            r = c;\n            g = x;\n        }\n        else if (h < 120) {\n            r = x;\n            g = c;\n        }\n        else if (h < 180) {\n            g = c;\n            b = x;\n        }\n        else if (h < 240) {\n            g = x;\n            b = c;\n        }\n        else if (h < 300) {\n            r = x;\n            b = c;\n        }\n        else if (h <= 360) {\n            r = c;\n            b = x;\n        }\n        r = Math.round((r + m) * 255);\n        g = Math.round((g + m) * 255);\n        b = Math.round((b + m) * 255);\n        return new RGBA(r, g, b, a);\n    }\n}\nexport class Color {\n    static fromHex(hex) {\n        return Color.Format.CSS.parseHex(hex) || Color.red;\n    }\n    static equals(a, b) {\n        if (!a && !b) {\n            return true;\n        }\n        if (!a || !b) {\n            return false;\n        }\n        return a.equals(b);\n    }\n    get hsla() {\n        if (this._hsla) {\n            return this._hsla;\n        }\n        else {\n            return HSLA.fromRGBA(this.rgba);\n        }\n    }\n    get hsva() {\n        if (this._hsva) {\n            return this._hsva;\n        }\n        return HSVA.fromRGBA(this.rgba);\n    }\n    constructor(arg) {\n        if (!arg) {\n            throw new Error('Color needs a value');\n        }\n        else if (arg instanceof RGBA) {\n            this.rgba = arg;\n        }\n        else if (arg instanceof HSLA) {\n            this._hsla = arg;\n            this.rgba = HSLA.toRGBA(arg);\n        }\n        else if (arg instanceof HSVA) {\n            this._hsva = arg;\n            this.rgba = HSVA.toRGBA(arg);\n        }\n        else {\n            throw new Error('Invalid color ctor argument');\n        }\n    }\n    equals(other) {\n        return !!other && RGBA.equals(this.rgba, other.rgba) && HSLA.equals(this.hsla, other.hsla) && HSVA.equals(this.hsva, other.hsva);\n    }\n    /**\n     * http://www.w3.org/TR/WCAG20/#relativeluminancedef\n     * Returns the number in the set [0, 1]. O => Darkest Black. 1 => Lightest white.\n     */\n    getRelativeLuminance() {\n        const R = Color._relativeLuminanceForComponent(this.rgba.r);\n        const G = Color._relativeLuminanceForComponent(this.rgba.g);\n        const B = Color._relativeLuminanceForComponent(this.rgba.b);\n        const luminance = 0.2126 * R + 0.7152 * G + 0.0722 * B;\n        return roundFloat(luminance, 4);\n    }\n    static _relativeLuminanceForComponent(color) {\n        const c = color / 255;\n        return (c <= 0.03928) ? c / 12.92 : Math.pow(((c + 0.055) / 1.055), 2.4);\n    }\n    /**\n     *\thttp://24ways.org/2010/calculating-color-contrast\n     *  Return 'true' if lighter color otherwise 'false'\n     */\n    isLighter() {\n        const yiq = (this.rgba.r * 299 + this.rgba.g * 587 + this.rgba.b * 114) / 1000;\n        return yiq >= 128;\n    }\n    isLighterThan(another) {\n        const lum1 = this.getRelativeLuminance();\n        const lum2 = another.getRelativeLuminance();\n        return lum1 > lum2;\n    }\n    isDarkerThan(another) {\n        const lum1 = this.getRelativeLuminance();\n        const lum2 = another.getRelativeLuminance();\n        return lum1 < lum2;\n    }\n    lighten(factor) {\n        return new Color(new HSLA(this.hsla.h, this.hsla.s, this.hsla.l + this.hsla.l * factor, this.hsla.a));\n    }\n    darken(factor) {\n        return new Color(new HSLA(this.hsla.h, this.hsla.s, this.hsla.l - this.hsla.l * factor, this.hsla.a));\n    }\n    transparent(factor) {\n        const { r, g, b, a } = this.rgba;\n        return new Color(new RGBA(r, g, b, a * factor));\n    }\n    isTransparent() {\n        return this.rgba.a === 0;\n    }\n    isOpaque() {\n        return this.rgba.a === 1;\n    }\n    opposite() {\n        return new Color(new RGBA(255 - this.rgba.r, 255 - this.rgba.g, 255 - this.rgba.b, this.rgba.a));\n    }\n    makeOpaque(opaqueBackground) {\n        if (this.isOpaque() || opaqueBackground.rgba.a !== 1) {\n            // only allow to blend onto a non-opaque color onto a opaque color\n            return this;\n        }\n        const { r, g, b, a } = this.rgba;\n        // https://stackoverflow.com/questions/12228548/finding-equivalent-color-with-opacity\n        return new Color(new RGBA(opaqueBackground.rgba.r - a * (opaqueBackground.rgba.r - r), opaqueBackground.rgba.g - a * (opaqueBackground.rgba.g - g), opaqueBackground.rgba.b - a * (opaqueBackground.rgba.b - b), 1));\n    }\n    toString() {\n        if (!this._toString) {\n            this._toString = Color.Format.CSS.format(this);\n        }\n        return this._toString;\n    }\n    static getLighterColor(of, relative, factor) {\n        if (of.isLighterThan(relative)) {\n            return of;\n        }\n        factor = factor ? factor : 0.5;\n        const lum1 = of.getRelativeLuminance();\n        const lum2 = relative.getRelativeLuminance();\n        factor = factor * (lum2 - lum1) / lum2;\n        return of.lighten(factor);\n    }\n    static getDarkerColor(of, relative, factor) {\n        if (of.isDarkerThan(relative)) {\n            return of;\n        }\n        factor = factor ? factor : 0.5;\n        const lum1 = of.getRelativeLuminance();\n        const lum2 = relative.getRelativeLuminance();\n        factor = factor * (lum1 - lum2) / lum1;\n        return of.darken(factor);\n    }\n}\nColor.white = new Color(new RGBA(255, 255, 255, 1));\nColor.black = new Color(new RGBA(0, 0, 0, 1));\nColor.red = new Color(new RGBA(255, 0, 0, 1));\nColor.blue = new Color(new RGBA(0, 0, 255, 1));\nColor.green = new Color(new RGBA(0, 255, 0, 1));\nColor.cyan = new Color(new RGBA(0, 255, 255, 1));\nColor.lightgrey = new Color(new RGBA(211, 211, 211, 1));\nColor.transparent = new Color(new RGBA(0, 0, 0, 0));\n(function (Color) {\n    let Format;\n    (function (Format) {\n        let CSS;\n        (function (CSS) {\n            function formatRGB(color) {\n                if (color.rgba.a === 1) {\n                    return `rgb(${color.rgba.r}, ${color.rgba.g}, ${color.rgba.b})`;\n                }\n                return Color.Format.CSS.formatRGBA(color);\n            }\n            CSS.formatRGB = formatRGB;\n            function formatRGBA(color) {\n                return `rgba(${color.rgba.r}, ${color.rgba.g}, ${color.rgba.b}, ${+(color.rgba.a).toFixed(2)})`;\n            }\n            CSS.formatRGBA = formatRGBA;\n            function formatHSL(color) {\n                if (color.hsla.a === 1) {\n                    return `hsl(${color.hsla.h}, ${(color.hsla.s * 100).toFixed(2)}%, ${(color.hsla.l * 100).toFixed(2)}%)`;\n                }\n                return Color.Format.CSS.formatHSLA(color);\n            }\n            CSS.formatHSL = formatHSL;\n            function formatHSLA(color) {\n                return `hsla(${color.hsla.h}, ${(color.hsla.s * 100).toFixed(2)}%, ${(color.hsla.l * 100).toFixed(2)}%, ${color.hsla.a.toFixed(2)})`;\n            }\n            CSS.formatHSLA = formatHSLA;\n            function _toTwoDigitHex(n) {\n                const r = n.toString(16);\n                return r.length !== 2 ? '0' + r : r;\n            }\n            /**\n             * Formats the color as #RRGGBB\n             */\n            function formatHex(color) {\n                return `#${_toTwoDigitHex(color.rgba.r)}${_toTwoDigitHex(color.rgba.g)}${_toTwoDigitHex(color.rgba.b)}`;\n            }\n            CSS.formatHex = formatHex;\n            /**\n             * Formats the color as #RRGGBBAA\n             * If 'compact' is set, colors without transparancy will be printed as #RRGGBB\n             */\n            function formatHexA(color, compact = false) {\n                if (compact && color.rgba.a === 1) {\n                    return Color.Format.CSS.formatHex(color);\n                }\n                return `#${_toTwoDigitHex(color.rgba.r)}${_toTwoDigitHex(color.rgba.g)}${_toTwoDigitHex(color.rgba.b)}${_toTwoDigitHex(Math.round(color.rgba.a * 255))}`;\n            }\n            CSS.formatHexA = formatHexA;\n            /**\n             * The default format will use HEX if opaque and RGBA otherwise.\n             */\n            function format(color) {\n                if (color.isOpaque()) {\n                    return Color.Format.CSS.formatHex(color);\n                }\n                return Color.Format.CSS.formatRGBA(color);\n            }\n            CSS.format = format;\n            /**\n             * Converts an Hex color value to a Color.\n             * returns r, g, and b are contained in the set [0, 255]\n             * @param hex string (#RGB, #RGBA, #RRGGBB or #RRGGBBAA).\n             */\n            function parseHex(hex) {\n                const length = hex.length;\n                if (length === 0) {\n                    // Invalid color\n                    return null;\n                }\n                if (hex.charCodeAt(0) !== 35 /* CharCode.Hash */) {\n                    // Does not begin with a #\n                    return null;\n                }\n                if (length === 7) {\n                    // #RRGGBB format\n                    const r = 16 * _parseHexDigit(hex.charCodeAt(1)) + _parseHexDigit(hex.charCodeAt(2));\n                    const g = 16 * _parseHexDigit(hex.charCodeAt(3)) + _parseHexDigit(hex.charCodeAt(4));\n                    const b = 16 * _parseHexDigit(hex.charCodeAt(5)) + _parseHexDigit(hex.charCodeAt(6));\n                    return new Color(new RGBA(r, g, b, 1));\n                }\n                if (length === 9) {\n                    // #RRGGBBAA format\n                    const r = 16 * _parseHexDigit(hex.charCodeAt(1)) + _parseHexDigit(hex.charCodeAt(2));\n                    const g = 16 * _parseHexDigit(hex.charCodeAt(3)) + _parseHexDigit(hex.charCodeAt(4));\n                    const b = 16 * _parseHexDigit(hex.charCodeAt(5)) + _parseHexDigit(hex.charCodeAt(6));\n                    const a = 16 * _parseHexDigit(hex.charCodeAt(7)) + _parseHexDigit(hex.charCodeAt(8));\n                    return new Color(new RGBA(r, g, b, a / 255));\n                }\n                if (length === 4) {\n                    // #RGB format\n                    const r = _parseHexDigit(hex.charCodeAt(1));\n                    const g = _parseHexDigit(hex.charCodeAt(2));\n                    const b = _parseHexDigit(hex.charCodeAt(3));\n                    return new Color(new RGBA(16 * r + r, 16 * g + g, 16 * b + b));\n                }\n                if (length === 5) {\n                    // #RGBA format\n                    const r = _parseHexDigit(hex.charCodeAt(1));\n                    const g = _parseHexDigit(hex.charCodeAt(2));\n                    const b = _parseHexDigit(hex.charCodeAt(3));\n                    const a = _parseHexDigit(hex.charCodeAt(4));\n                    return new Color(new RGBA(16 * r + r, 16 * g + g, 16 * b + b, (16 * a + a) / 255));\n                }\n                // Invalid color\n                return null;\n            }\n            CSS.parseHex = parseHex;\n            function _parseHexDigit(charCode) {\n                switch (charCode) {\n                    case 48 /* CharCode.Digit0 */: return 0;\n                    case 49 /* CharCode.Digit1 */: return 1;\n                    case 50 /* CharCode.Digit2 */: return 2;\n                    case 51 /* CharCode.Digit3 */: return 3;\n                    case 52 /* CharCode.Digit4 */: return 4;\n                    case 53 /* CharCode.Digit5 */: return 5;\n                    case 54 /* CharCode.Digit6 */: return 6;\n                    case 55 /* CharCode.Digit7 */: return 7;\n                    case 56 /* CharCode.Digit8 */: return 8;\n                    case 57 /* CharCode.Digit9 */: return 9;\n                    case 97 /* CharCode.a */: return 10;\n                    case 65 /* CharCode.A */: return 10;\n                    case 98 /* CharCode.b */: return 11;\n                    case 66 /* CharCode.B */: return 11;\n                    case 99 /* CharCode.c */: return 12;\n                    case 67 /* CharCode.C */: return 12;\n                    case 100 /* CharCode.d */: return 13;\n                    case 68 /* CharCode.D */: return 13;\n                    case 101 /* CharCode.e */: return 14;\n                    case 69 /* CharCode.E */: return 14;\n                    case 102 /* CharCode.f */: return 15;\n                    case 70 /* CharCode.F */: return 15;\n                }\n                return 0;\n            }\n        })(CSS = Format.CSS || (Format.CSS = {}));\n    })(Format = Color.Format || (Color.Format = {}));\n})(Color || (Color = {}));\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Lazy } from './lazy.js';\n// When comparing large numbers of strings it's better for performance to create an\n// Intl.Collator object and use the function provided by its compare property\n// than it is to use String.prototype.localeCompare()\n// A collator with numeric sorting enabled, and no sensitivity to case, accents or diacritics.\nconst intlFileNameCollatorBaseNumeric = new Lazy(() => {\n    const collator = new Intl.Collator(undefined, { numeric: true, sensitivity: 'base' });\n    return {\n        collator,\n        collatorIsNumeric: collator.resolvedOptions().numeric\n    };\n});\n// A collator with numeric sorting enabled.\nconst intlFileNameCollatorNumeric = new Lazy(() => {\n    const collator = new Intl.Collator(undefined, { numeric: true });\n    return {\n        collator\n    };\n});\n// A collator with numeric sorting enabled, and sensitivity to accents and diacritics but not case.\nconst intlFileNameCollatorNumericCaseInsensitive = new Lazy(() => {\n    const collator = new Intl.Collator(undefined, { numeric: true, sensitivity: 'accent' });\n    return {\n        collator\n    };\n});\n/** Compares filenames without distinguishing the name from the extension. Disambiguates by unicode comparison. */\nexport function compareFileNames(one, other, caseSensitive = false) {\n    const a = one || '';\n    const b = other || '';\n    const result = intlFileNameCollatorBaseNumeric.value.collator.compare(a, b);\n    // Using the numeric option will make compare(`foo1`, `foo01`) === 0. Disambiguate.\n    if (intlFileNameCollatorBaseNumeric.value.collatorIsNumeric && result === 0 && a !== b) {\n        return a < b ? -1 : 1;\n    }\n    return result;\n}\nexport function compareAnything(one, other, lookFor) {\n    const elementAName = one.toLowerCase();\n    const elementBName = other.toLowerCase();\n    // Sort prefix matches over non prefix matches\n    const prefixCompare = compareByPrefix(one, other, lookFor);\n    if (prefixCompare) {\n        return prefixCompare;\n    }\n    // Sort suffix matches over non suffix matches\n    const elementASuffixMatch = elementAName.endsWith(lookFor);\n    const elementBSuffixMatch = elementBName.endsWith(lookFor);\n    if (elementASuffixMatch !== elementBSuffixMatch) {\n        return elementASuffixMatch ? -1 : 1;\n    }\n    // Understand file names\n    const r = compareFileNames(elementAName, elementBName);\n    if (r !== 0) {\n        return r;\n    }\n    // Compare by name\n    return elementAName.localeCompare(elementBName);\n}\nexport function compareByPrefix(one, other, lookFor) {\n    const elementAName = one.toLowerCase();\n    const elementBName = other.toLowerCase();\n    // Sort prefix matches over non prefix matches\n    const elementAPrefixMatch = elementAName.startsWith(lookFor);\n    const elementBPrefixMatch = elementBName.startsWith(lookFor);\n    if (elementAPrefixMatch !== elementBPrefixMatch) {\n        return elementAPrefixMatch ? -1 : 1;\n    }\n    // Same prefix: Sort shorter matches to the top to have those on top that match more precisely\n    else if (elementAPrefixMatch && elementBPrefixMatch) {\n        if (elementAName.length < elementBName.length) {\n            return -1;\n        }\n        if (elementAName.length > elementBName.length) {\n            return 1;\n        }\n    }\n    return 0;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { distinct } from './arrays.js';\nimport { Iterable } from './iterator.js';\nimport { generateUuid } from './uuid.js';\nexport function createStringDataTransferItem(stringOrPromise) {\n    return {\n        asString: async () => stringOrPromise,\n        asFile: () => undefined,\n        value: typeof stringOrPromise === 'string' ? stringOrPromise : undefined,\n    };\n}\nexport function createFileDataTransferItem(fileName, uri, data) {\n    const file = { id: generateUuid(), name: fileName, uri, data };\n    return {\n        asString: async () => '',\n        asFile: () => file,\n        value: undefined,\n    };\n}\nexport class VSDataTransfer {\n    constructor() {\n        this._entries = new Map();\n    }\n    get size() {\n        let size = 0;\n        for (const _ of this._entries) {\n            size++;\n        }\n        return size;\n    }\n    has(mimeType) {\n        return this._entries.has(this.toKey(mimeType));\n    }\n    matches(pattern) {\n        const mimes = [...this._entries.keys()];\n        if (Iterable.some(this, ([_, item]) => item.asFile())) {\n            mimes.push('files');\n        }\n        return matchesMimeType_normalized(normalizeMimeType(pattern), mimes);\n    }\n    get(mimeType) {\n        var _a;\n        return (_a = this._entries.get(this.toKey(mimeType))) === null || _a === void 0 ? void 0 : _a[0];\n    }\n    /**\n     * Add a new entry to this data transfer.\n     *\n     * This does not replace existing entries for `mimeType`.\n     */\n    append(mimeType, value) {\n        const existing = this._entries.get(mimeType);\n        if (existing) {\n            existing.push(value);\n        }\n        else {\n            this._entries.set(this.toKey(mimeType), [value]);\n        }\n    }\n    /**\n     * Set the entry for a given mime type.\n     *\n     * This replaces all existing entries for `mimeType`.\n     */\n    replace(mimeType, value) {\n        this._entries.set(this.toKey(mimeType), [value]);\n    }\n    /**\n     * Remove all entries for `mimeType`.\n     */\n    delete(mimeType) {\n        this._entries.delete(this.toKey(mimeType));\n    }\n    /**\n     * Iterate over all `[mime, item]` pairs in this data transfer.\n     *\n     * There may be multiple entries for each mime type.\n     */\n    *[Symbol.iterator]() {\n        for (const [mine, items] of this._entries) {\n            for (const item of items) {\n                yield [mine, item];\n            }\n        }\n    }\n    toKey(mimeType) {\n        return normalizeMimeType(mimeType);\n    }\n}\nfunction normalizeMimeType(mimeType) {\n    return mimeType.toLowerCase();\n}\nexport function matchesMimeType(pattern, mimeTypes) {\n    return matchesMimeType_normalized(normalizeMimeType(pattern), mimeTypes.map(normalizeMimeType));\n}\nfunction matchesMimeType_normalized(normalizedPattern, normalizedMimeTypes) {\n    // Anything wildcard\n    if (normalizedPattern === '*/*') {\n        return normalizedMimeTypes.length > 0;\n    }\n    // Exact match\n    if (normalizedMimeTypes.includes(normalizedPattern)) {\n        return true;\n    }\n    // Wildcard, such as `image/*`\n    const wildcard = normalizedPattern.match(/^([a-z]+)\\/([a-z]+|\\*)$/i);\n    if (!wildcard) {\n        return false;\n    }\n    const [_, type, subtype] = wildcard;\n    if (subtype === '*') {\n        return normalizedMimeTypes.some(mime => mime.startsWith(type + '/'));\n    }\n    return false;\n}\nexport const UriList = Object.freeze({\n    // http://amundsen.com/hypermedia/urilist/\n    create: (entries) => {\n        return distinct(entries.map(x => x.toString())).join('\\r\\n');\n    },\n    split: (str) => {\n        return str.split('\\r\\n');\n    },\n    parse: (str) => {\n        return UriList.split(str).filter(value => !value.startsWith('#'));\n    }\n});\n","export function memoize(_target, key, descriptor) {\n    let fnKey = null;\n    let fn = null;\n    if (typeof descriptor.value === 'function') {\n        fnKey = 'value';\n        fn = descriptor.value;\n        if (fn.length !== 0) {\n            console.warn('Memoize should only be used in functions with zero parameters');\n        }\n    }\n    else if (typeof descriptor.get === 'function') {\n        fnKey = 'get';\n        fn = descriptor.get;\n    }\n    if (!fn) {\n        throw new Error('not supported');\n    }\n    const memoizeKey = `$memoize$${key}`;\n    descriptor[fnKey] = function (...args) {\n        if (!this.hasOwnProperty(memoizeKey)) {\n            Object.defineProperty(this, memoizeKey, {\n                configurable: false,\n                enumerable: false,\n                writable: false,\n                value: fn.apply(this, args)\n            });\n        }\n        return this[memoizeKey];\n    };\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n/**\n * Represents information about a specific difference between two sequences.\n */\nexport class DiffChange {\n    /**\n     * Constructs a new DiffChange with the given sequence information\n     * and content.\n     */\n    constructor(originalStart, originalLength, modifiedStart, modifiedLength) {\n        //Debug.Assert(originalLength > 0 || modifiedLength > 0, \"originalLength and modifiedLength cannot both be <= 0\");\n        this.originalStart = originalStart;\n        this.originalLength = originalLength;\n        this.modifiedStart = modifiedStart;\n        this.modifiedLength = modifiedLength;\n    }\n    /**\n     * The end point (exclusive) of the change in the original sequence.\n     */\n    getOriginalEnd() {\n        return this.originalStart + this.originalLength;\n    }\n    /**\n     * The end point (exclusive) of the change in the modified sequence.\n     */\n    getModifiedEnd() {\n        return this.modifiedStart + this.modifiedLength;\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { DiffChange } from './diffChange.js';\nimport { stringHash } from '../hash.js';\nexport class StringDiffSequence {\n    constructor(source) {\n        this.source = source;\n    }\n    getElements() {\n        const source = this.source;\n        const characters = new Int32Array(source.length);\n        for (let i = 0, len = source.length; i < len; i++) {\n            characters[i] = source.charCodeAt(i);\n        }\n        return characters;\n    }\n}\nexport function stringDiff(original, modified, pretty) {\n    return new LcsDiff(new StringDiffSequence(original), new StringDiffSequence(modified)).ComputeDiff(pretty).changes;\n}\n//\n// The code below has been ported from a C# implementation in VS\n//\nclass Debug {\n    static Assert(condition, message) {\n        if (!condition) {\n            throw new Error(message);\n        }\n    }\n}\nclass MyArray {\n    /**\n     * Copies a range of elements from an Array starting at the specified source index and pastes\n     * them to another Array starting at the specified destination index. The length and the indexes\n     * are specified as 64-bit integers.\n     * sourceArray:\n     *\t\tThe Array that contains the data to copy.\n     * sourceIndex:\n     *\t\tA 64-bit integer that represents the index in the sourceArray at which copying begins.\n     * destinationArray:\n     *\t\tThe Array that receives the data.\n     * destinationIndex:\n     *\t\tA 64-bit integer that represents the index in the destinationArray at which storing begins.\n     * length:\n     *\t\tA 64-bit integer that represents the number of elements to copy.\n     */\n    static Copy(sourceArray, sourceIndex, destinationArray, destinationIndex, length) {\n        for (let i = 0; i < length; i++) {\n            destinationArray[destinationIndex + i] = sourceArray[sourceIndex + i];\n        }\n    }\n    static Copy2(sourceArray, sourceIndex, destinationArray, destinationIndex, length) {\n        for (let i = 0; i < length; i++) {\n            destinationArray[destinationIndex + i] = sourceArray[sourceIndex + i];\n        }\n    }\n}\n/**\n * A utility class which helps to create the set of DiffChanges from\n * a difference operation. This class accepts original DiffElements and\n * modified DiffElements that are involved in a particular change. The\n * MarkNextChange() method can be called to mark the separation between\n * distinct changes. At the end, the Changes property can be called to retrieve\n * the constructed changes.\n */\nclass DiffChangeHelper {\n    /**\n     * Constructs a new DiffChangeHelper for the given DiffSequences.\n     */\n    constructor() {\n        this.m_changes = [];\n        this.m_originalStart = 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */;\n        this.m_modifiedStart = 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */;\n        this.m_originalCount = 0;\n        this.m_modifiedCount = 0;\n    }\n    /**\n     * Marks the beginning of the next change in the set of differences.\n     */\n    MarkNextChange() {\n        // Only add to the list if there is something to add\n        if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {\n            // Add the new change to our list\n            this.m_changes.push(new DiffChange(this.m_originalStart, this.m_originalCount, this.m_modifiedStart, this.m_modifiedCount));\n        }\n        // Reset for the next change\n        this.m_originalCount = 0;\n        this.m_modifiedCount = 0;\n        this.m_originalStart = 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */;\n        this.m_modifiedStart = 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */;\n    }\n    /**\n     * Adds the original element at the given position to the elements\n     * affected by the current change. The modified index gives context\n     * to the change position with respect to the original sequence.\n     * @param originalIndex The index of the original element to add.\n     * @param modifiedIndex The index of the modified element that provides corresponding position in the modified sequence.\n     */\n    AddOriginalElement(originalIndex, modifiedIndex) {\n        // The 'true' start index is the smallest of the ones we've seen\n        this.m_originalStart = Math.min(this.m_originalStart, originalIndex);\n        this.m_modifiedStart = Math.min(this.m_modifiedStart, modifiedIndex);\n        this.m_originalCount++;\n    }\n    /**\n     * Adds the modified element at the given position to the elements\n     * affected by the current change. The original index gives context\n     * to the change position with respect to the modified sequence.\n     * @param originalIndex The index of the original element that provides corresponding position in the original sequence.\n     * @param modifiedIndex The index of the modified element to add.\n     */\n    AddModifiedElement(originalIndex, modifiedIndex) {\n        // The 'true' start index is the smallest of the ones we've seen\n        this.m_originalStart = Math.min(this.m_originalStart, originalIndex);\n        this.m_modifiedStart = Math.min(this.m_modifiedStart, modifiedIndex);\n        this.m_modifiedCount++;\n    }\n    /**\n     * Retrieves all of the changes marked by the class.\n     */\n    getChanges() {\n        if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {\n            // Finish up on whatever is left\n            this.MarkNextChange();\n        }\n        return this.m_changes;\n    }\n    /**\n     * Retrieves all of the changes marked by the class in the reverse order\n     */\n    getReverseChanges() {\n        if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {\n            // Finish up on whatever is left\n            this.MarkNextChange();\n        }\n        this.m_changes.reverse();\n        return this.m_changes;\n    }\n}\n/**\n * An implementation of the difference algorithm described in\n * \"An O(ND) Difference Algorithm and its variations\" by Eugene W. Myers\n */\nexport class LcsDiff {\n    /**\n     * Constructs the DiffFinder\n     */\n    constructor(originalSequence, modifiedSequence, continueProcessingPredicate = null) {\n        this.ContinueProcessingPredicate = continueProcessingPredicate;\n        this._originalSequence = originalSequence;\n        this._modifiedSequence = modifiedSequence;\n        const [originalStringElements, originalElementsOrHash, originalHasStrings] = LcsDiff._getElements(originalSequence);\n        const [modifiedStringElements, modifiedElementsOrHash, modifiedHasStrings] = LcsDiff._getElements(modifiedSequence);\n        this._hasStrings = (originalHasStrings && modifiedHasStrings);\n        this._originalStringElements = originalStringElements;\n        this._originalElementsOrHash = originalElementsOrHash;\n        this._modifiedStringElements = modifiedStringElements;\n        this._modifiedElementsOrHash = modifiedElementsOrHash;\n        this.m_forwardHistory = [];\n        this.m_reverseHistory = [];\n    }\n    static _isStringArray(arr) {\n        return (arr.length > 0 && typeof arr[0] === 'string');\n    }\n    static _getElements(sequence) {\n        const elements = sequence.getElements();\n        if (LcsDiff._isStringArray(elements)) {\n            const hashes = new Int32Array(elements.length);\n            for (let i = 0, len = elements.length; i < len; i++) {\n                hashes[i] = stringHash(elements[i], 0);\n            }\n            return [elements, hashes, true];\n        }\n        if (elements instanceof Int32Array) {\n            return [[], elements, false];\n        }\n        return [[], new Int32Array(elements), false];\n    }\n    ElementsAreEqual(originalIndex, newIndex) {\n        if (this._originalElementsOrHash[originalIndex] !== this._modifiedElementsOrHash[newIndex]) {\n            return false;\n        }\n        return (this._hasStrings ? this._originalStringElements[originalIndex] === this._modifiedStringElements[newIndex] : true);\n    }\n    ElementsAreStrictEqual(originalIndex, newIndex) {\n        if (!this.ElementsAreEqual(originalIndex, newIndex)) {\n            return false;\n        }\n        const originalElement = LcsDiff._getStrictElement(this._originalSequence, originalIndex);\n        const modifiedElement = LcsDiff._getStrictElement(this._modifiedSequence, newIndex);\n        return (originalElement === modifiedElement);\n    }\n    static _getStrictElement(sequence, index) {\n        if (typeof sequence.getStrictElement === 'function') {\n            return sequence.getStrictElement(index);\n        }\n        return null;\n    }\n    OriginalElementsAreEqual(index1, index2) {\n        if (this._originalElementsOrHash[index1] !== this._originalElementsOrHash[index2]) {\n            return false;\n        }\n        return (this._hasStrings ? this._originalStringElements[index1] === this._originalStringElements[index2] : true);\n    }\n    ModifiedElementsAreEqual(index1, index2) {\n        if (this._modifiedElementsOrHash[index1] !== this._modifiedElementsOrHash[index2]) {\n            return false;\n        }\n        return (this._hasStrings ? this._modifiedStringElements[index1] === this._modifiedStringElements[index2] : true);\n    }\n    ComputeDiff(pretty) {\n        return this._ComputeDiff(0, this._originalElementsOrHash.length - 1, 0, this._modifiedElementsOrHash.length - 1, pretty);\n    }\n    /**\n     * Computes the differences between the original and modified input\n     * sequences on the bounded range.\n     * @returns An array of the differences between the two input sequences.\n     */\n    _ComputeDiff(originalStart, originalEnd, modifiedStart, modifiedEnd, pretty) {\n        const quitEarlyArr = [false];\n        let changes = this.ComputeDiffRecursive(originalStart, originalEnd, modifiedStart, modifiedEnd, quitEarlyArr);\n        if (pretty) {\n            // We have to clean up the computed diff to be more intuitive\n            // but it turns out this cannot be done correctly until the entire set\n            // of diffs have been computed\n            changes = this.PrettifyChanges(changes);\n        }\n        return {\n            quitEarly: quitEarlyArr[0],\n            changes: changes\n        };\n    }\n    /**\n     * Private helper method which computes the differences on the bounded range\n     * recursively.\n     * @returns An array of the differences between the two input sequences.\n     */\n    ComputeDiffRecursive(originalStart, originalEnd, modifiedStart, modifiedEnd, quitEarlyArr) {\n        quitEarlyArr[0] = false;\n        // Find the start of the differences\n        while (originalStart <= originalEnd && modifiedStart <= modifiedEnd && this.ElementsAreEqual(originalStart, modifiedStart)) {\n            originalStart++;\n            modifiedStart++;\n        }\n        // Find the end of the differences\n        while (originalEnd >= originalStart && modifiedEnd >= modifiedStart && this.ElementsAreEqual(originalEnd, modifiedEnd)) {\n            originalEnd--;\n            modifiedEnd--;\n        }\n        // In the special case where we either have all insertions or all deletions or the sequences are identical\n        if (originalStart > originalEnd || modifiedStart > modifiedEnd) {\n            let changes;\n            if (modifiedStart <= modifiedEnd) {\n                Debug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd');\n                // All insertions\n                changes = [\n                    new DiffChange(originalStart, 0, modifiedStart, modifiedEnd - modifiedStart + 1)\n                ];\n            }\n            else if (originalStart <= originalEnd) {\n                Debug.Assert(modifiedStart === modifiedEnd + 1, 'modifiedStart should only be one more than modifiedEnd');\n                // All deletions\n                changes = [\n                    new DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, 0)\n                ];\n            }\n            else {\n                Debug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd');\n                Debug.Assert(modifiedStart === modifiedEnd + 1, 'modifiedStart should only be one more than modifiedEnd');\n                // Identical sequences - No differences\n                changes = [];\n            }\n            return changes;\n        }\n        // This problem can be solved using the Divide-And-Conquer technique.\n        const midOriginalArr = [0];\n        const midModifiedArr = [0];\n        const result = this.ComputeRecursionPoint(originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr);\n        const midOriginal = midOriginalArr[0];\n        const midModified = midModifiedArr[0];\n        if (result !== null) {\n            // Result is not-null when there was enough memory to compute the changes while\n            // searching for the recursion point\n            return result;\n        }\n        else if (!quitEarlyArr[0]) {\n            // We can break the problem down recursively by finding the changes in the\n            // First Half:   (originalStart, modifiedStart) to (midOriginal, midModified)\n            // Second Half:  (midOriginal + 1, minModified + 1) to (originalEnd, modifiedEnd)\n            // NOTE: ComputeDiff() is inclusive, therefore the second range starts on the next point\n            const leftChanges = this.ComputeDiffRecursive(originalStart, midOriginal, modifiedStart, midModified, quitEarlyArr);\n            let rightChanges = [];\n            if (!quitEarlyArr[0]) {\n                rightChanges = this.ComputeDiffRecursive(midOriginal + 1, originalEnd, midModified + 1, modifiedEnd, quitEarlyArr);\n            }\n            else {\n                // We didn't have time to finish the first half, so we don't have time to compute this half.\n                // Consider the entire rest of the sequence different.\n                rightChanges = [\n                    new DiffChange(midOriginal + 1, originalEnd - (midOriginal + 1) + 1, midModified + 1, modifiedEnd - (midModified + 1) + 1)\n                ];\n            }\n            return this.ConcatenateChanges(leftChanges, rightChanges);\n        }\n        // If we hit here, we quit early, and so can't return anything meaningful\n        return [\n            new DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, modifiedEnd - modifiedStart + 1)\n        ];\n    }\n    WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr) {\n        let forwardChanges = null;\n        let reverseChanges = null;\n        // First, walk backward through the forward diagonals history\n        let changeHelper = new DiffChangeHelper();\n        let diagonalMin = diagonalForwardStart;\n        let diagonalMax = diagonalForwardEnd;\n        let diagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalForwardOffset;\n        let lastOriginalIndex = -1073741824 /* Constants.MIN_SAFE_SMALL_INTEGER */;\n        let historyIndex = this.m_forwardHistory.length - 1;\n        do {\n            // Get the diagonal index from the relative diagonal number\n            const diagonal = diagonalRelative + diagonalForwardBase;\n            // Figure out where we came from\n            if (diagonal === diagonalMin || (diagonal < diagonalMax && forwardPoints[diagonal - 1] < forwardPoints[diagonal + 1])) {\n                // Vertical line (the element is an insert)\n                originalIndex = forwardPoints[diagonal + 1];\n                modifiedIndex = originalIndex - diagonalRelative - diagonalForwardOffset;\n                if (originalIndex < lastOriginalIndex) {\n                    changeHelper.MarkNextChange();\n                }\n                lastOriginalIndex = originalIndex;\n                changeHelper.AddModifiedElement(originalIndex + 1, modifiedIndex);\n                diagonalRelative = (diagonal + 1) - diagonalForwardBase; //Setup for the next iteration\n            }\n            else {\n                // Horizontal line (the element is a deletion)\n                originalIndex = forwardPoints[diagonal - 1] + 1;\n                modifiedIndex = originalIndex - diagonalRelative - diagonalForwardOffset;\n                if (originalIndex < lastOriginalIndex) {\n                    changeHelper.MarkNextChange();\n                }\n                lastOriginalIndex = originalIndex - 1;\n                changeHelper.AddOriginalElement(originalIndex, modifiedIndex + 1);\n                diagonalRelative = (diagonal - 1) - diagonalForwardBase; //Setup for the next iteration\n            }\n            if (historyIndex >= 0) {\n                forwardPoints = this.m_forwardHistory[historyIndex];\n                diagonalForwardBase = forwardPoints[0]; //We stored this in the first spot\n                diagonalMin = 1;\n                diagonalMax = forwardPoints.length - 1;\n            }\n        } while (--historyIndex >= -1);\n        // Ironically, we get the forward changes as the reverse of the\n        // order we added them since we technically added them backwards\n        forwardChanges = changeHelper.getReverseChanges();\n        if (quitEarlyArr[0]) {\n            // TODO: Calculate a partial from the reverse diagonals.\n            //       For now, just assume everything after the midOriginal/midModified point is a diff\n            let originalStartPoint = midOriginalArr[0] + 1;\n            let modifiedStartPoint = midModifiedArr[0] + 1;\n            if (forwardChanges !== null && forwardChanges.length > 0) {\n                const lastForwardChange = forwardChanges[forwardChanges.length - 1];\n                originalStartPoint = Math.max(originalStartPoint, lastForwardChange.getOriginalEnd());\n                modifiedStartPoint = Math.max(modifiedStartPoint, lastForwardChange.getModifiedEnd());\n            }\n            reverseChanges = [\n                new DiffChange(originalStartPoint, originalEnd - originalStartPoint + 1, modifiedStartPoint, modifiedEnd - modifiedStartPoint + 1)\n            ];\n        }\n        else {\n            // Now walk backward through the reverse diagonals history\n            changeHelper = new DiffChangeHelper();\n            diagonalMin = diagonalReverseStart;\n            diagonalMax = diagonalReverseEnd;\n            diagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalReverseOffset;\n            lastOriginalIndex = 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */;\n            historyIndex = (deltaIsEven) ? this.m_reverseHistory.length - 1 : this.m_reverseHistory.length - 2;\n            do {\n                // Get the diagonal index from the relative diagonal number\n                const diagonal = diagonalRelative + diagonalReverseBase;\n                // Figure out where we came from\n                if (diagonal === diagonalMin || (diagonal < diagonalMax && reversePoints[diagonal - 1] >= reversePoints[diagonal + 1])) {\n                    // Horizontal line (the element is a deletion))\n                    originalIndex = reversePoints[diagonal + 1] - 1;\n                    modifiedIndex = originalIndex - diagonalRelative - diagonalReverseOffset;\n                    if (originalIndex > lastOriginalIndex) {\n                        changeHelper.MarkNextChange();\n                    }\n                    lastOriginalIndex = originalIndex + 1;\n                    changeHelper.AddOriginalElement(originalIndex + 1, modifiedIndex + 1);\n                    diagonalRelative = (diagonal + 1) - diagonalReverseBase; //Setup for the next iteration\n                }\n                else {\n                    // Vertical line (the element is an insertion)\n                    originalIndex = reversePoints[diagonal - 1];\n                    modifiedIndex = originalIndex - diagonalRelative - diagonalReverseOffset;\n                    if (originalIndex > lastOriginalIndex) {\n                        changeHelper.MarkNextChange();\n                    }\n                    lastOriginalIndex = originalIndex;\n                    changeHelper.AddModifiedElement(originalIndex + 1, modifiedIndex + 1);\n                    diagonalRelative = (diagonal - 1) - diagonalReverseBase; //Setup for the next iteration\n                }\n                if (historyIndex >= 0) {\n                    reversePoints = this.m_reverseHistory[historyIndex];\n                    diagonalReverseBase = reversePoints[0]; //We stored this in the first spot\n                    diagonalMin = 1;\n                    diagonalMax = reversePoints.length - 1;\n                }\n            } while (--historyIndex >= -1);\n            // There are cases where the reverse history will find diffs that\n            // are correct, but not intuitive, so we need shift them.\n            reverseChanges = changeHelper.getChanges();\n        }\n        return this.ConcatenateChanges(forwardChanges, reverseChanges);\n    }\n    /**\n     * Given the range to compute the diff on, this method finds the point:\n     * (midOriginal, midModified)\n     * that exists in the middle of the LCS of the two sequences and\n     * is the point at which the LCS problem may be broken down recursively.\n     * This method will try to keep the LCS trace in memory. If the LCS recursion\n     * point is calculated and the full trace is available in memory, then this method\n     * will return the change list.\n     * @param originalStart The start bound of the original sequence range\n     * @param originalEnd The end bound of the original sequence range\n     * @param modifiedStart The start bound of the modified sequence range\n     * @param modifiedEnd The end bound of the modified sequence range\n     * @param midOriginal The middle point of the original sequence range\n     * @param midModified The middle point of the modified sequence range\n     * @returns The diff changes, if available, otherwise null\n     */\n    ComputeRecursionPoint(originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr) {\n        let originalIndex = 0, modifiedIndex = 0;\n        let diagonalForwardStart = 0, diagonalForwardEnd = 0;\n        let diagonalReverseStart = 0, diagonalReverseEnd = 0;\n        // To traverse the edit graph and produce the proper LCS, our actual\n        // start position is just outside the given boundary\n        originalStart--;\n        modifiedStart--;\n        // We set these up to make the compiler happy, but they will\n        // be replaced before we return with the actual recursion point\n        midOriginalArr[0] = 0;\n        midModifiedArr[0] = 0;\n        // Clear out the history\n        this.m_forwardHistory = [];\n        this.m_reverseHistory = [];\n        // Each cell in the two arrays corresponds to a diagonal in the edit graph.\n        // The integer value in the cell represents the originalIndex of the furthest\n        // reaching point found so far that ends in that diagonal.\n        // The modifiedIndex can be computed mathematically from the originalIndex and the diagonal number.\n        const maxDifferences = (originalEnd - originalStart) + (modifiedEnd - modifiedStart);\n        const numDiagonals = maxDifferences + 1;\n        const forwardPoints = new Int32Array(numDiagonals);\n        const reversePoints = new Int32Array(numDiagonals);\n        // diagonalForwardBase: Index into forwardPoints of the diagonal which passes through (originalStart, modifiedStart)\n        // diagonalReverseBase: Index into reversePoints of the diagonal which passes through (originalEnd, modifiedEnd)\n        const diagonalForwardBase = (modifiedEnd - modifiedStart);\n        const diagonalReverseBase = (originalEnd - originalStart);\n        // diagonalForwardOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the\n        //    diagonal number (relative to diagonalForwardBase)\n        // diagonalReverseOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the\n        //    diagonal number (relative to diagonalReverseBase)\n        const diagonalForwardOffset = (originalStart - modifiedStart);\n        const diagonalReverseOffset = (originalEnd - modifiedEnd);\n        // delta: The difference between the end diagonal and the start diagonal. This is used to relate diagonal numbers\n        //   relative to the start diagonal with diagonal numbers relative to the end diagonal.\n        // The Even/Oddn-ness of this delta is important for determining when we should check for overlap\n        const delta = diagonalReverseBase - diagonalForwardBase;\n        const deltaIsEven = (delta % 2 === 0);\n        // Here we set up the start and end points as the furthest points found so far\n        // in both the forward and reverse directions, respectively\n        forwardPoints[diagonalForwardBase] = originalStart;\n        reversePoints[diagonalReverseBase] = originalEnd;\n        // Remember if we quit early, and thus need to do a best-effort result instead of a real result.\n        quitEarlyArr[0] = false;\n        // A couple of points:\n        // --With this method, we iterate on the number of differences between the two sequences.\n        //   The more differences there actually are, the longer this will take.\n        // --Also, as the number of differences increases, we have to search on diagonals further\n        //   away from the reference diagonal (which is diagonalForwardBase for forward, diagonalReverseBase for reverse).\n        // --We extend on even diagonals (relative to the reference diagonal) only when numDifferences\n        //   is even and odd diagonals only when numDifferences is odd.\n        for (let numDifferences = 1; numDifferences <= (maxDifferences / 2) + 1; numDifferences++) {\n            let furthestOriginalIndex = 0;\n            let furthestModifiedIndex = 0;\n            // Run the algorithm in the forward direction\n            diagonalForwardStart = this.ClipDiagonalBound(diagonalForwardBase - numDifferences, numDifferences, diagonalForwardBase, numDiagonals);\n            diagonalForwardEnd = this.ClipDiagonalBound(diagonalForwardBase + numDifferences, numDifferences, diagonalForwardBase, numDiagonals);\n            for (let diagonal = diagonalForwardStart; diagonal <= diagonalForwardEnd; diagonal += 2) {\n                // STEP 1: We extend the furthest reaching point in the present diagonal\n                // by looking at the diagonals above and below and picking the one whose point\n                // is further away from the start point (originalStart, modifiedStart)\n                if (diagonal === diagonalForwardStart || (diagonal < diagonalForwardEnd && forwardPoints[diagonal - 1] < forwardPoints[diagonal + 1])) {\n                    originalIndex = forwardPoints[diagonal + 1];\n                }\n                else {\n                    originalIndex = forwardPoints[diagonal - 1] + 1;\n                }\n                modifiedIndex = originalIndex - (diagonal - diagonalForwardBase) - diagonalForwardOffset;\n                // Save the current originalIndex so we can test for false overlap in step 3\n                const tempOriginalIndex = originalIndex;\n                // STEP 2: We can continue to extend the furthest reaching point in the present diagonal\n                // so long as the elements are equal.\n                while (originalIndex < originalEnd && modifiedIndex < modifiedEnd && this.ElementsAreEqual(originalIndex + 1, modifiedIndex + 1)) {\n                    originalIndex++;\n                    modifiedIndex++;\n                }\n                forwardPoints[diagonal] = originalIndex;\n                if (originalIndex + modifiedIndex > furthestOriginalIndex + furthestModifiedIndex) {\n                    furthestOriginalIndex = originalIndex;\n                    furthestModifiedIndex = modifiedIndex;\n                }\n                // STEP 3: If delta is odd (overlap first happens on forward when delta is odd)\n                // and diagonal is in the range of reverse diagonals computed for numDifferences-1\n                // (the previous iteration; we haven't computed reverse diagonals for numDifferences yet)\n                // then check for overlap.\n                if (!deltaIsEven && Math.abs(diagonal - diagonalReverseBase) <= (numDifferences - 1)) {\n                    if (originalIndex >= reversePoints[diagonal]) {\n                        midOriginalArr[0] = originalIndex;\n                        midModifiedArr[0] = modifiedIndex;\n                        if (tempOriginalIndex <= reversePoints[diagonal] && 1447 /* LocalConstants.MaxDifferencesHistory */ > 0 && numDifferences <= (1447 /* LocalConstants.MaxDifferencesHistory */ + 1)) {\n                            // BINGO! We overlapped, and we have the full trace in memory!\n                            return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\n                        }\n                        else {\n                            // Either false overlap, or we didn't have enough memory for the full trace\n                            // Just return the recursion point\n                            return null;\n                        }\n                    }\n                }\n            }\n            // Check to see if we should be quitting early, before moving on to the next iteration.\n            const matchLengthOfLongest = ((furthestOriginalIndex - originalStart) + (furthestModifiedIndex - modifiedStart) - numDifferences) / 2;\n            if (this.ContinueProcessingPredicate !== null && !this.ContinueProcessingPredicate(furthestOriginalIndex, matchLengthOfLongest)) {\n                // We can't finish, so skip ahead to generating a result from what we have.\n                quitEarlyArr[0] = true;\n                // Use the furthest distance we got in the forward direction.\n                midOriginalArr[0] = furthestOriginalIndex;\n                midModifiedArr[0] = furthestModifiedIndex;\n                if (matchLengthOfLongest > 0 && 1447 /* LocalConstants.MaxDifferencesHistory */ > 0 && numDifferences <= (1447 /* LocalConstants.MaxDifferencesHistory */ + 1)) {\n                    // Enough of the history is in memory to walk it backwards\n                    return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\n                }\n                else {\n                    // We didn't actually remember enough of the history.\n                    //Since we are quitting the diff early, we need to shift back the originalStart and modified start\n                    //back into the boundary limits since we decremented their value above beyond the boundary limit.\n                    originalStart++;\n                    modifiedStart++;\n                    return [\n                        new DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, modifiedEnd - modifiedStart + 1)\n                    ];\n                }\n            }\n            // Run the algorithm in the reverse direction\n            diagonalReverseStart = this.ClipDiagonalBound(diagonalReverseBase - numDifferences, numDifferences, diagonalReverseBase, numDiagonals);\n            diagonalReverseEnd = this.ClipDiagonalBound(diagonalReverseBase + numDifferences, numDifferences, diagonalReverseBase, numDiagonals);\n            for (let diagonal = diagonalReverseStart; diagonal <= diagonalReverseEnd; diagonal += 2) {\n                // STEP 1: We extend the furthest reaching point in the present diagonal\n                // by looking at the diagonals above and below and picking the one whose point\n                // is further away from the start point (originalEnd, modifiedEnd)\n                if (diagonal === diagonalReverseStart || (diagonal < diagonalReverseEnd && reversePoints[diagonal - 1] >= reversePoints[diagonal + 1])) {\n                    originalIndex = reversePoints[diagonal + 1] - 1;\n                }\n                else {\n                    originalIndex = reversePoints[diagonal - 1];\n                }\n                modifiedIndex = originalIndex - (diagonal - diagonalReverseBase) - diagonalReverseOffset;\n                // Save the current originalIndex so we can test for false overlap\n                const tempOriginalIndex = originalIndex;\n                // STEP 2: We can continue to extend the furthest reaching point in the present diagonal\n                // as long as the elements are equal.\n                while (originalIndex > originalStart && modifiedIndex > modifiedStart && this.ElementsAreEqual(originalIndex, modifiedIndex)) {\n                    originalIndex--;\n                    modifiedIndex--;\n                }\n                reversePoints[diagonal] = originalIndex;\n                // STEP 4: If delta is even (overlap first happens on reverse when delta is even)\n                // and diagonal is in the range of forward diagonals computed for numDifferences\n                // then check for overlap.\n                if (deltaIsEven && Math.abs(diagonal - diagonalForwardBase) <= numDifferences) {\n                    if (originalIndex <= forwardPoints[diagonal]) {\n                        midOriginalArr[0] = originalIndex;\n                        midModifiedArr[0] = modifiedIndex;\n                        if (tempOriginalIndex >= forwardPoints[diagonal] && 1447 /* LocalConstants.MaxDifferencesHistory */ > 0 && numDifferences <= (1447 /* LocalConstants.MaxDifferencesHistory */ + 1)) {\n                            // BINGO! We overlapped, and we have the full trace in memory!\n                            return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\n                        }\n                        else {\n                            // Either false overlap, or we didn't have enough memory for the full trace\n                            // Just return the recursion point\n                            return null;\n                        }\n                    }\n                }\n            }\n            // Save current vectors to history before the next iteration\n            if (numDifferences <= 1447 /* LocalConstants.MaxDifferencesHistory */) {\n                // We are allocating space for one extra int, which we fill with\n                // the index of the diagonal base index\n                let temp = new Int32Array(diagonalForwardEnd - diagonalForwardStart + 2);\n                temp[0] = diagonalForwardBase - diagonalForwardStart + 1;\n                MyArray.Copy2(forwardPoints, diagonalForwardStart, temp, 1, diagonalForwardEnd - diagonalForwardStart + 1);\n                this.m_forwardHistory.push(temp);\n                temp = new Int32Array(diagonalReverseEnd - diagonalReverseStart + 2);\n                temp[0] = diagonalReverseBase - diagonalReverseStart + 1;\n                MyArray.Copy2(reversePoints, diagonalReverseStart, temp, 1, diagonalReverseEnd - diagonalReverseStart + 1);\n                this.m_reverseHistory.push(temp);\n            }\n        }\n        // If we got here, then we have the full trace in history. We just have to convert it to a change list\n        // NOTE: This part is a bit messy\n        return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\n    }\n    /**\n     * Shifts the given changes to provide a more intuitive diff.\n     * While the first element in a diff matches the first element after the diff,\n     * we shift the diff down.\n     *\n     * @param changes The list of changes to shift\n     * @returns The shifted changes\n     */\n    PrettifyChanges(changes) {\n        // Shift all the changes down first\n        for (let i = 0; i < changes.length; i++) {\n            const change = changes[i];\n            const originalStop = (i < changes.length - 1) ? changes[i + 1].originalStart : this._originalElementsOrHash.length;\n            const modifiedStop = (i < changes.length - 1) ? changes[i + 1].modifiedStart : this._modifiedElementsOrHash.length;\n            const checkOriginal = change.originalLength > 0;\n            const checkModified = change.modifiedLength > 0;\n            while (change.originalStart + change.originalLength < originalStop\n                && change.modifiedStart + change.modifiedLength < modifiedStop\n                && (!checkOriginal || this.OriginalElementsAreEqual(change.originalStart, change.originalStart + change.originalLength))\n                && (!checkModified || this.ModifiedElementsAreEqual(change.modifiedStart, change.modifiedStart + change.modifiedLength))) {\n                const startStrictEqual = this.ElementsAreStrictEqual(change.originalStart, change.modifiedStart);\n                const endStrictEqual = this.ElementsAreStrictEqual(change.originalStart + change.originalLength, change.modifiedStart + change.modifiedLength);\n                if (endStrictEqual && !startStrictEqual) {\n                    // moving the change down would create an equal change, but the elements are not strict equal\n                    break;\n                }\n                change.originalStart++;\n                change.modifiedStart++;\n            }\n            const mergedChangeArr = [null];\n            if (i < changes.length - 1 && this.ChangesOverlap(changes[i], changes[i + 1], mergedChangeArr)) {\n                changes[i] = mergedChangeArr[0];\n                changes.splice(i + 1, 1);\n                i--;\n                continue;\n            }\n        }\n        // Shift changes back up until we hit empty or whitespace-only lines\n        for (let i = changes.length - 1; i >= 0; i--) {\n            const change = changes[i];\n            let originalStop = 0;\n            let modifiedStop = 0;\n            if (i > 0) {\n                const prevChange = changes[i - 1];\n                originalStop = prevChange.originalStart + prevChange.originalLength;\n                modifiedStop = prevChange.modifiedStart + prevChange.modifiedLength;\n            }\n            const checkOriginal = change.originalLength > 0;\n            const checkModified = change.modifiedLength > 0;\n            let bestDelta = 0;\n            let bestScore = this._boundaryScore(change.originalStart, change.originalLength, change.modifiedStart, change.modifiedLength);\n            for (let delta = 1;; delta++) {\n                const originalStart = change.originalStart - delta;\n                const modifiedStart = change.modifiedStart - delta;\n                if (originalStart < originalStop || modifiedStart < modifiedStop) {\n                    break;\n                }\n                if (checkOriginal && !this.OriginalElementsAreEqual(originalStart, originalStart + change.originalLength)) {\n                    break;\n                }\n                if (checkModified && !this.ModifiedElementsAreEqual(modifiedStart, modifiedStart + change.modifiedLength)) {\n                    break;\n                }\n                const touchingPreviousChange = (originalStart === originalStop && modifiedStart === modifiedStop);\n                const score = ((touchingPreviousChange ? 5 : 0)\n                    + this._boundaryScore(originalStart, change.originalLength, modifiedStart, change.modifiedLength));\n                if (score > bestScore) {\n                    bestScore = score;\n                    bestDelta = delta;\n                }\n            }\n            change.originalStart -= bestDelta;\n            change.modifiedStart -= bestDelta;\n            const mergedChangeArr = [null];\n            if (i > 0 && this.ChangesOverlap(changes[i - 1], changes[i], mergedChangeArr)) {\n                changes[i - 1] = mergedChangeArr[0];\n                changes.splice(i, 1);\n                i++;\n                continue;\n            }\n        }\n        // There could be multiple longest common substrings.\n        // Give preference to the ones containing longer lines\n        if (this._hasStrings) {\n            for (let i = 1, len = changes.length; i < len; i++) {\n                const aChange = changes[i - 1];\n                const bChange = changes[i];\n                const matchedLength = bChange.originalStart - aChange.originalStart - aChange.originalLength;\n                const aOriginalStart = aChange.originalStart;\n                const bOriginalEnd = bChange.originalStart + bChange.originalLength;\n                const abOriginalLength = bOriginalEnd - aOriginalStart;\n                const aModifiedStart = aChange.modifiedStart;\n                const bModifiedEnd = bChange.modifiedStart + bChange.modifiedLength;\n                const abModifiedLength = bModifiedEnd - aModifiedStart;\n                // Avoid wasting a lot of time with these searches\n                if (matchedLength < 5 && abOriginalLength < 20 && abModifiedLength < 20) {\n                    const t = this._findBetterContiguousSequence(aOriginalStart, abOriginalLength, aModifiedStart, abModifiedLength, matchedLength);\n                    if (t) {\n                        const [originalMatchStart, modifiedMatchStart] = t;\n                        if (originalMatchStart !== aChange.originalStart + aChange.originalLength || modifiedMatchStart !== aChange.modifiedStart + aChange.modifiedLength) {\n                            // switch to another sequence that has a better score\n                            aChange.originalLength = originalMatchStart - aChange.originalStart;\n                            aChange.modifiedLength = modifiedMatchStart - aChange.modifiedStart;\n                            bChange.originalStart = originalMatchStart + matchedLength;\n                            bChange.modifiedStart = modifiedMatchStart + matchedLength;\n                            bChange.originalLength = bOriginalEnd - bChange.originalStart;\n                            bChange.modifiedLength = bModifiedEnd - bChange.modifiedStart;\n                        }\n                    }\n                }\n            }\n        }\n        return changes;\n    }\n    _findBetterContiguousSequence(originalStart, originalLength, modifiedStart, modifiedLength, desiredLength) {\n        if (originalLength < desiredLength || modifiedLength < desiredLength) {\n            return null;\n        }\n        const originalMax = originalStart + originalLength - desiredLength + 1;\n        const modifiedMax = modifiedStart + modifiedLength - desiredLength + 1;\n        let bestScore = 0;\n        let bestOriginalStart = 0;\n        let bestModifiedStart = 0;\n        for (let i = originalStart; i < originalMax; i++) {\n            for (let j = modifiedStart; j < modifiedMax; j++) {\n                const score = this._contiguousSequenceScore(i, j, desiredLength);\n                if (score > 0 && score > bestScore) {\n                    bestScore = score;\n                    bestOriginalStart = i;\n                    bestModifiedStart = j;\n                }\n            }\n        }\n        if (bestScore > 0) {\n            return [bestOriginalStart, bestModifiedStart];\n        }\n        return null;\n    }\n    _contiguousSequenceScore(originalStart, modifiedStart, length) {\n        let score = 0;\n        for (let l = 0; l < length; l++) {\n            if (!this.ElementsAreEqual(originalStart + l, modifiedStart + l)) {\n                return 0;\n            }\n            score += this._originalStringElements[originalStart + l].length;\n        }\n        return score;\n    }\n    _OriginalIsBoundary(index) {\n        if (index <= 0 || index >= this._originalElementsOrHash.length - 1) {\n            return true;\n        }\n        return (this._hasStrings && /^\\s*$/.test(this._originalStringElements[index]));\n    }\n    _OriginalRegionIsBoundary(originalStart, originalLength) {\n        if (this._OriginalIsBoundary(originalStart) || this._OriginalIsBoundary(originalStart - 1)) {\n            return true;\n        }\n        if (originalLength > 0) {\n            const originalEnd = originalStart + originalLength;\n            if (this._OriginalIsBoundary(originalEnd - 1) || this._OriginalIsBoundary(originalEnd)) {\n                return true;\n            }\n        }\n        return false;\n    }\n    _ModifiedIsBoundary(index) {\n        if (index <= 0 || index >= this._modifiedElementsOrHash.length - 1) {\n            return true;\n        }\n        return (this._hasStrings && /^\\s*$/.test(this._modifiedStringElements[index]));\n    }\n    _ModifiedRegionIsBoundary(modifiedStart, modifiedLength) {\n        if (this._ModifiedIsBoundary(modifiedStart) || this._ModifiedIsBoundary(modifiedStart - 1)) {\n            return true;\n        }\n        if (modifiedLength > 0) {\n            const modifiedEnd = modifiedStart + modifiedLength;\n            if (this._ModifiedIsBoundary(modifiedEnd - 1) || this._ModifiedIsBoundary(modifiedEnd)) {\n                return true;\n            }\n        }\n        return false;\n    }\n    _boundaryScore(originalStart, originalLength, modifiedStart, modifiedLength) {\n        const originalScore = (this._OriginalRegionIsBoundary(originalStart, originalLength) ? 1 : 0);\n        const modifiedScore = (this._ModifiedRegionIsBoundary(modifiedStart, modifiedLength) ? 1 : 0);\n        return (originalScore + modifiedScore);\n    }\n    /**\n     * Concatenates the two input DiffChange lists and returns the resulting\n     * list.\n     * @param The left changes\n     * @param The right changes\n     * @returns The concatenated list\n     */\n    ConcatenateChanges(left, right) {\n        const mergedChangeArr = [];\n        if (left.length === 0 || right.length === 0) {\n            return (right.length > 0) ? right : left;\n        }\n        else if (this.ChangesOverlap(left[left.length - 1], right[0], mergedChangeArr)) {\n            // Since we break the problem down recursively, it is possible that we\n            // might recurse in the middle of a change thereby splitting it into\n            // two changes. Here in the combining stage, we detect and fuse those\n            // changes back together\n            const result = new Array(left.length + right.length - 1);\n            MyArray.Copy(left, 0, result, 0, left.length - 1);\n            result[left.length - 1] = mergedChangeArr[0];\n            MyArray.Copy(right, 1, result, left.length, right.length - 1);\n            return result;\n        }\n        else {\n            const result = new Array(left.length + right.length);\n            MyArray.Copy(left, 0, result, 0, left.length);\n            MyArray.Copy(right, 0, result, left.length, right.length);\n            return result;\n        }\n    }\n    /**\n     * Returns true if the two changes overlap and can be merged into a single\n     * change\n     * @param left The left change\n     * @param right The right change\n     * @param mergedChange The merged change if the two overlap, null otherwise\n     * @returns True if the two changes overlap\n     */\n    ChangesOverlap(left, right, mergedChangeArr) {\n        Debug.Assert(left.originalStart <= right.originalStart, 'Left change is not less than or equal to right change');\n        Debug.Assert(left.modifiedStart <= right.modifiedStart, 'Left change is not less than or equal to right change');\n        if (left.originalStart + left.originalLength >= right.originalStart || left.modifiedStart + left.modifiedLength >= right.modifiedStart) {\n            const originalStart = left.originalStart;\n            let originalLength = left.originalLength;\n            const modifiedStart = left.modifiedStart;\n            let modifiedLength = left.modifiedLength;\n            if (left.originalStart + left.originalLength >= right.originalStart) {\n                originalLength = right.originalStart + right.originalLength - left.originalStart;\n            }\n            if (left.modifiedStart + left.modifiedLength >= right.modifiedStart) {\n                modifiedLength = right.modifiedStart + right.modifiedLength - left.modifiedStart;\n            }\n            mergedChangeArr[0] = new DiffChange(originalStart, originalLength, modifiedStart, modifiedLength);\n            return true;\n        }\n        else {\n            mergedChangeArr[0] = null;\n            return false;\n        }\n    }\n    /**\n     * Helper method used to clip a diagonal index to the range of valid\n     * diagonals. This also decides whether or not the diagonal index,\n     * if it exceeds the boundary, should be clipped to the boundary or clipped\n     * one inside the boundary depending on the Even/Odd status of the boundary\n     * and numDifferences.\n     * @param diagonal The index of the diagonal to clip.\n     * @param numDifferences The current number of differences being iterated upon.\n     * @param diagonalBaseIndex The base reference diagonal.\n     * @param numDiagonals The total number of diagonals.\n     * @returns The clipped diagonal index.\n     */\n    ClipDiagonalBound(diagonal, numDifferences, diagonalBaseIndex, numDiagonals) {\n        if (diagonal >= 0 && diagonal < numDiagonals) {\n            // Nothing to clip, its in range\n            return diagonal;\n        }\n        // diagonalsBelow: The number of diagonals below the reference diagonal\n        // diagonalsAbove: The number of diagonals above the reference diagonal\n        const diagonalsBelow = diagonalBaseIndex;\n        const diagonalsAbove = numDiagonals - diagonalBaseIndex - 1;\n        const diffEven = (numDifferences % 2 === 0);\n        if (diagonal < 0) {\n            const lowerBoundEven = (diagonalsBelow % 2 === 0);\n            return (diffEven === lowerBoundEven) ? 0 : 1;\n        }\n        else {\n            const upperBoundEven = (diagonalsAbove % 2 === 0);\n            return (diffEven === upperBoundEven) ? numDiagonals - 1 : numDiagonals - 2;\n        }\n    }\n}\n"],"names":["Action","constructor","id","label","cssClass","enabled","actionCallback","super","this","_onDidChange","_register","onDidChange","event","_enabled","_id","_label","_cssClass","_actionCallback","value","_setLabel","fire","tooltip","_tooltip","_setTooltip","_setClass","class","_setEnabled","checked","_checked","_setChecked","run","data","ActionRunner","arguments","_onWillRun","onWillRun","_onDidRun","onDidRun","action","context","error","runAction","e","Separator","ID","join","actionLists","out","list","length","SubmenuAction","actions","_actions","undefined","EmptySubmenuAction","toAction","props","_a","_b","async","args","tail","array","n","tail2","arr","Error","slice","equals","one","other","itemEquals","a","b","i","len","removeFastWithoutKeepingOrder","index","last","pop","binarySearch","key","comparator","compareToKey","low","high","mid","comp","binarySearch2","quickSelect","nth","compare","TypeError","pivotValue","Math","floor","random","lower","higher","pivots","val","push","groupBy","result","currentGroup","element","sort","groupAdjacentBy","items","shouldBeGrouped","item","forEachAdjacent","f","forEachWithNeighbors","coalesce","filter","coalesceInPlace","to","isFalsyOrEmpty","obj","Array","isArray","isNonEmptyArray","distinct","keyFn","seen","Set","has","add","firstOrDefault","notFoundValue","range","arg","from","arrayInsert","target","insertIndex","insertArr","before","after","concat","pushToStart","indexOf","splice","unshift","pushToEnd","pushMany","asArray","x","start","deleteCount","newItems","getActualStartIndex","startIdx","originalLength","newItemsLength","insertInto","max","min","CompareResult","compareBy","selector","tieBreakComparators","comparators","item1","item2","isNeitherLessOrGreaterThan","neitherLessOrGreaterThan","isLessThan","isLessThanOrEqual","isGreaterThan","greaterThan","lessThan","numberComparator","booleanComparator","reverseOrder","ArrayQueue","firstIdx","lastIdx","takeWhile","predicate","takeFromEndWhile","endIdx","peek","dequeue","takeCount","count","CallbackIterable","iterate","toArray","cb","map","mapFn","findLast","findLastMaxBy","first","empty","_callback","Permutation","_indexMap","createSortPermutation","compareFn","sortIndices","keys","index1","index2","apply","_","inverse","inverseIndexMap","idx","fromIndex","findLastIdx","findLastMonotonous","findLastIdxMonotonous","endIdxEx","j","k","findFirstMonotonous","findFirstIdxMonotonousOrArrLen","MonotonousArray","_array","_findLastMonotonousLastIdx","assertInvariants","_prevFindLastPredicate","findFirstMax","findLastMax","findFirstMin","findMaxIdx","maxIdx","mapFindFirst","mapped","ok","message","assertNever","softAssert","condition","assertFn","checkAdjacentItems","isThenable","then","createCancelablePromise","callback","source","thenable","token","promise","Promise","resolve","reject","subscription","onCancellationRequested","dispose","err","cancel","onfinally","finally","raceCancellation","defaultValue","ref","Throttler","isDisposed","activePromise","queuedPromise","queuedPromiseFactory","queue","promiseFactory","onComplete","Delayer","defaultDelay","deferred","completionPromise","doResolve","doReject","task","trigger","delay","cancelTimeout","fn","call","scheduled","queueMicrotask","isTriggered","microtaskDeferred","timeout","handle","setTimeout","clearTimeout","timeoutDeferred","ThrottledDelayer","delayer","throttler","millis","disposable","disposableTimeout","handler","store","timer","deleteAndLeak","promiseFactories","shouldStop","t","loop","factory","TimeoutTimer","runner","_isDisposed","_token","setIfNotSet","cancelAndSet","IntervalTimer","interval","globalThis","setInterval","clearInterval","RunOnceScheduler","timeoutToken","timeoutHandler","onTimeout","bind","isScheduled","schedule","doRun","runWhenGlobalIdle","_runWhenIdle","requestIdleCallback","cancelIdleCallback","_targetWindow","disposed","end","Date","now","deadline","didTimeout","timeRemaining","Object","freeze","targetWindow","AbstractIdleValue","executor","_didRun","_executor","_value","_error","_handle","isInitialized","GlobalIdleValue","DeferredPromise","isRejected","outcome","isSettled","p","c","completeCallback","errorCallback","complete","Promises","settled","promises","firstError","all","withAsyncBody","bodyFn","AsyncIterableObject","fromArray","writer","emitMany","fromPromise","emitter","fromPromises","emitOne","merge","iterables","iterable","onReturn","_state","_results","_onReturn","_onStateChanged","Symbol","asyncIterator","next","done","return","filterFn","toPromise","values","EMPTY","CancelableAsyncIterableObject","_source","createCancelableAsyncIterable","innerIterable","isCancellationRequested","hasBuffer","Buffer","Uint8Array","textDecoder","VSBuffer","wrap","actual","isBuffer","buffer","byteOffset","byteLength","toString","TextDecoder","decode","readUInt16LE","offset","writeUInt16LE","destination","readUInt32BE","writeUInt32BE","readUInt8","writeUInt8","identity","LRUCachedFunction","arg1","arg2","lastCache","lastArgKey","_fn","_computeKey","getCacheKey","get","CachedFunction","cachedValues","_map","Map","_map2","set","shortcutEvent","CancellationToken","isCancellationToken","thing","None","Cancelled","MutableToken","_isCancelled","_emitter","CancellationTokenSource","parent","_parentListener","cancelOnDispose","Codicon","plus","gistNew","repoCreate","lightbulb","lightBulb","repo","repoDelete","gistFork","repoForked","gitPullRequest","gitPullRequestAbandoned","recordKeys","keyboard","tag","gitPullRequestLabel","tagAdd","tagRemove","person","personFollow","personOutline","personFilled","gitBranch","gitBranchCreate","gitBranchDelete","sourceControl","mirror","mirrorPublic","star","starAdd","starDelete","starEmpty","comment","commentAdd","alert","warning","search","searchSave","logOut","signOut","logIn","signIn","eye","eyeUnwatch","eyeWatch","circleFilled","primitiveDot","closeDirty","debugBreakpoint","debugBreakpointDisabled","debugHint","terminalDecorationSuccess","primitiveSquare","edit","pencil","info","issueOpened","gistPrivate","gitForkPrivate","lock","mirrorPrivate","close","removeClose","repoSync","sync","clone","desktopDownload","beaker","microscope","vm","deviceDesktop","file","fileText","more","ellipsis","kebabHorizontal","mailReply","reply","organization","organizationFilled","organizationOutline","newFile","fileAdd","newFolder","fileDirectoryCreate","trash","trashcan","history","clock","folder","fileDirectory","symbolFolder","logoGithub","markGithub","github","terminal","console","repl","zap","symbolEvent","stop","variable","symbolVariable","symbolArray","symbolModule","symbolPackage","symbolNamespace","symbolObject","symbolMethod","symbolFunction","symbolConstructor","symbolBoolean","symbolNull","symbolNumeric","symbolNumber","symbolStructure","symbolStruct","symbolParameter","symbolTypeParameter","symbolKey","symbolText","symbolReference","goToFile","symbolEnum","symbolValue","symbolRuler","symbolUnit","activateBreakpoints","archive","arrowBoth","arrowDown","arrowLeft","arrowRight","arrowSmallDown","arrowSmallLeft","arrowSmallRight","arrowSmallUp","arrowUp","bell","bold","book","bookmark","debugBreakpointConditionalUnverified","debugBreakpointConditional","debugBreakpointConditionalDisabled","debugBreakpointDataUnverified","debugBreakpointData","debugBreakpointDataDisabled","debugBreakpointLogUnverified","debugBreakpointLog","debugBreakpointLogDisabled","briefcase","broadcast","browser","bug","calendar","caseSensitive","check","checklist","chevronDown","chevronLeft","chevronRight","chevronUp","chromeClose","chromeMaximize","chromeMinimize","chromeRestore","circleOutline","circle","debugBreakpointUnverified","terminalDecorationIncomplete","circleSlash","circuitBoard","clearAll","clippy","closeAll","cloudDownload","cloudUpload","code","collapseAll","colorMode","commentDiscussion","creditCard","dash","dashboard","database","debugContinue","debugDisconnect","debugPause","debugRestart","debugStart","debugStepInto","debugStepOut","debugStepOver","debugStop","debug","deviceCameraVideo","deviceCamera","deviceMobile","diffAdded","diffIgnored","diffModified","diffRemoved","diffRenamed","diff","diffSidebyside","discard","editorLayout","emptyWindow","exclude","extensions","eyeClosed","fileBinary","fileCode","fileMedia","filePdf","fileSubmodule","fileSymlinkDirectory","fileSymlinkFile","fileZip","files","flame","foldDown","foldUp","fold","folderActive","folderOpened","gear","gift","gistSecret","gist","gitCommit","gitCompare","compareChanges","gitMerge","githubAction","githubAlt","globe","grabber","graph","gripper","heart","home","horizontalRule","hubot","inbox","issueReopened","issues","italic","jersey","json","kebabVertical","law","lightbulbAutofix","linkExternal","link","listOrdered","listUnordered","liveShare","loading","location","mailRead","mail","markdown","megaphone","mention","milestone","gitPullRequestMilestone","mortarBoard","move","multipleWindows","mute","noNewline","note","octoface","openPreview","package","paintcan","pin","play","plug","preserveCase","preview","project","pulse","question","quote","radioTower","reactions","references","refresh","regex","remoteExplorer","remote","remove","replaceAll","replace","repoClone","repoForcePush","repoPull","repoPush","report","requestChanges","rocket","rootFolderOpened","rootFolder","rss","ruby","saveAll","saveAs","save","screenFull","screenNormal","searchStop","server","settingsGear","settings","shield","smiley","sortPrecedence","splitHorizontal","splitVertical","squirrel","starFull","starHalf","symbolClass","symbolColor","symbolConstant","symbolEnumMember","symbolField","symbolFile","symbolInterface","symbolKeyword","symbolMisc","symbolOperator","symbolProperty","wrench","wrenchSubaction","symbolSnippet","tasklist","telescope","textSize","threeBars","thumbsdown","thumbsup","tools","triangleDown","triangleLeft","triangleRight","triangleUp","twitter","unfold","unlock","unmute","unverified","verified","versions","vmActive","vmOutline","vmRunning","watch","whitespace","wholeWord","window","wordWrap","zoomIn","zoomOut","listFilter","listFlat","listSelection","selection","listTree","debugBreakpointFunctionUnverified","debugBreakpointFunction","debugBreakpointFunctionDisabled","debugStackframeActive","circleSmallFilled","debugStackframeDot","terminalDecorationMark","debugStackframe","debugStackframeFocused","debugBreakpointUnsupported","symbolString","debugReverseContinue","debugStepBack","debugRestartFrame","debugAlt","callIncoming","callOutgoing","menu","expandAll","feedback","gitPullRequestReviewer","groupByRefType","ungroupByRefType","account","gitPullRequestAssignee","bellDot","debugConsole","library","output","runAll","syncIgnored","pinned","githubInverted","serverProcess","serverEnvironment","pass","issueClosed","stopCircle","playCircle","record","debugAltSmall","vmConnect","cloud","export","graphLeft","magnet","notebook","redo","checkAll","pinnedDirty","passFilled","circleLargeFilled","circleLarge","circleLargeOutline","combine","gather","table","variableGroup","typeHierarchy","typeHierarchySub","typeHierarchySuper","gitPullRequestCreate","runAbove","runBelow","notebookTemplate","debugRerun","workspaceTrusted","workspaceUntrusted","workspaceUnknown","terminalCmd","terminalDebian","terminalLinux","terminalPowershell","terminalTmux","terminalUbuntu","terminalBash","arrowSwap","copy","personAdd","filterFilled","wand","debugLineByLine","inspect","layers","layersDot","layersActive","compass","compassDot","compassActive","azure","issueDraft","gitPullRequestClosed","gitPullRequestDraft","debugAll","debugCoverage","runErrors","folderLibrary","debugContinueSmall","beakerStop","graphLine","graphScatter","pieChart","bracket","bracketDot","bracketError","lockSmall","azureDevops","verifiedFilled","newline","layout","layoutActivitybarLeft","layoutActivitybarRight","layoutPanelLeft","layoutPanelCenter","layoutPanelJustify","layoutPanelRight","layoutPanel","layoutSidebarLeft","layoutSidebarRight","layoutStatusbar","layoutMenubar","layoutCentered","indent","recordSmall","errorSmall","terminalDecorationError","arrowCircleDown","arrowCircleLeft","arrowCircleRight","arrowCircleUp","layoutSidebarRightOff","layoutPanelOff","layoutSidebarLeftOff","blank","heartFilled","mapHorizontal","foldHorizontal","mapFilled","mapHorizontalFilled","foldHorizontalFilled","circleSmall","bellSlash","bellSlashDot","commentUnresolved","gitPullRequestGoToChanges","gitPullRequestNewChanges","searchFuzzy","commentDraft","send","sparkle","insert","mic","thumbsdownFilled","thumbsupFilled","coffee","snake","game","vr","chip","piano","music","micFilled","repoFetch","copilot","lightbulbSparkle","robot","sparkleFilled","diffSingle","diffMultiple","surroundWith","share","gitStash","gitStashApply","gitStashPop","vscode","vscodeInsiders","codeOss","runCoverage","runAllCoverage","coverage","githubProject","mapVertical","foldVertical","mapVerticalFilled","foldVerticalFilled","goToSearch","percentage","sortPercentage","attach","dialogError","dialogWarning","dialogInfo","dialogClose","treeItemExpanded","treeFilterOnTypeOn","treeFilterOnTypeOff","treeFilterClear","treeItemLoading","menuSelection","menuSubmenu","menuBarMore","scrollbarButtonLeft","scrollbarButtonRight","scrollbarButtonUp","scrollbarButtonDown","toolBarMore","quickInputBack","dropDownButton","symbolCustomColor","exportIcon","workspaceUnspecified","newLine","thumbsDownFilled","thumbsUpFilled","gitFetch","lightbulbSparkleAutofix","debugBreakpointPending","_codiconFontCharacters","create","register","fontCharacter","getCodiconFontCharacters","diffSets","removed","added","intersection","setA","setB","elem","roundFloat","number","decimalPoints","decimal","pow","round","RGBA","r","g","_rgbaBrand","HSLA","h","s","l","_hslaBrand","fromRGBA","rgba","chroma","_hue2rgb","q","toRGBA","hsla","HSVA","v","_hsvaBrand","cmax","delta","m","hsva","abs","Color","fromHex","hex","Format","CSS","parseHex","red","_hsla","_hsva","getRelativeLuminance","_relativeLuminanceForComponent","color","isLighter","isLighterThan","another","isDarkerThan","lighten","factor","darken","transparent","isTransparent","isOpaque","opposite","makeOpaque","opaqueBackground","_toString","format","getLighterColor","of","relative","lum1","lum2","getDarkerColor","white","black","blue","green","cyan","lightgrey","_toTwoDigitHex","_parseHexDigit","charCode","formatRGB","formatRGBA","toFixed","formatHSL","formatHSLA","formatHex","formatHexA","compact","charCodeAt","intlFileNameCollatorBaseNumeric","collator","Intl","Collator","numeric","sensitivity","collatorIsNumeric","resolvedOptions","compareAnything","lookFor","elementAName","toLowerCase","elementBName","prefixCompare","elementAPrefixMatch","startsWith","elementBPrefixMatch","compareByPrefix","elementASuffixMatch","endsWith","compareFileNames","localeCompare","createStringDataTransferItem","stringOrPromise","asString","asFile","createFileDataTransferItem","fileName","uri","name","VSDataTransfer","_entries","size","mimeType","toKey","matches","pattern","mimes","matchesMimeType_normalized","normalizeMimeType","append","existing","delete","iterator","mine","matchesMimeType","mimeTypes","normalizedPattern","normalizedMimeTypes","includes","wildcard","match","type","subtype","some","mime","UriList","entries","split","str","parse","memoize","_target","descriptor","fnKey","warn","memoizeKey","hasOwnProperty","defineProperty","configurable","enumerable","writable","DiffChange","originalStart","modifiedStart","modifiedLength","getOriginalEnd","getModifiedEnd","StringDiffSequence","getElements","characters","Int32Array","stringDiff","original","modified","pretty","LcsDiff","ComputeDiff","changes","Debug","Assert","MyArray","Copy","sourceArray","sourceIndex","destinationArray","destinationIndex","Copy2","DiffChangeHelper","m_changes","m_originalStart","m_modifiedStart","m_originalCount","m_modifiedCount","MarkNextChange","AddOriginalElement","originalIndex","modifiedIndex","AddModifiedElement","getChanges","getReverseChanges","reverse","originalSequence","modifiedSequence","continueProcessingPredicate","ContinueProcessingPredicate","_originalSequence","_modifiedSequence","originalStringElements","originalElementsOrHash","originalHasStrings","_getElements","modifiedStringElements","modifiedElementsOrHash","modifiedHasStrings","_hasStrings","_originalStringElements","_originalElementsOrHash","_modifiedStringElements","_modifiedElementsOrHash","m_forwardHistory","m_reverseHistory","_isStringArray","sequence","elements","hashes","ElementsAreEqual","newIndex","ElementsAreStrictEqual","_getStrictElement","getStrictElement","OriginalElementsAreEqual","ModifiedElementsAreEqual","_ComputeDiff","originalEnd","modifiedEnd","quitEarlyArr","ComputeDiffRecursive","PrettifyChanges","quitEarly","midOriginalArr","midModifiedArr","ComputeRecursionPoint","midOriginal","midModified","leftChanges","rightChanges","ConcatenateChanges","WALKTRACE","diagonalForwardBase","diagonalForwardStart","diagonalForwardEnd","diagonalForwardOffset","diagonalReverseBase","diagonalReverseStart","diagonalReverseEnd","diagonalReverseOffset","forwardPoints","reversePoints","deltaIsEven","forwardChanges","reverseChanges","changeHelper","diagonalMin","diagonalMax","diagonalRelative","lastOriginalIndex","historyIndex","diagonal","originalStartPoint","modifiedStartPoint","lastForwardChange","maxDifferences","numDiagonals","numDifferences","furthestOriginalIndex","furthestModifiedIndex","ClipDiagonalBound","tempOriginalIndex","matchLengthOfLongest","temp","change","originalStop","modifiedStop","checkOriginal","checkModified","startStrictEqual","mergedChangeArr","ChangesOverlap","prevChange","bestDelta","bestScore","_boundaryScore","score","aChange","bChange","matchedLength","aOriginalStart","bOriginalEnd","abOriginalLength","aModifiedStart","bModifiedEnd","abModifiedLength","_findBetterContiguousSequence","originalMatchStart","modifiedMatchStart","desiredLength","originalMax","modifiedMax","bestOriginalStart","bestModifiedStart","_contiguousSequenceScore","_OriginalIsBoundary","test","_OriginalRegionIsBoundary","_ModifiedIsBoundary","_ModifiedRegionIsBoundary","left","right","diagonalBaseIndex","diffEven"],"sourceRoot":""}