{"version":3,"file":"static/js/7178_cab515aef22e7846cd7c.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/editor/common/model/mirrorTextModel.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/prefixSumComputer.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/pieceTreeTextBuffer/rbTreeBase.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/pieceTreeTextBuffer/pieceTreeBase.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/pieceTreeTextBuffer/pieceTreeTextBuffer.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/pieceTreeTextBuffer/pieceTreeTextBufferBuilder.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/textModel.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/textModelPart.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/textModelSearch.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/textModelText.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/model/textModelTokens.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 { splitLines } from '../../../base/common/strings.js';\nimport { Position } from '../core/position.js';\nimport { PrefixSumComputer } from './prefixSumComputer.js';\nexport class MirrorTextModel {\n    constructor(uri, lines, eol, versionId) {\n        this._uri = uri;\n        this._lines = lines;\n        this._eol = eol;\n        this._versionId = versionId;\n        this._lineStarts = null;\n        this._cachedTextValue = null;\n    }\n    dispose() {\n        this._lines.length = 0;\n    }\n    get version() {\n        return this._versionId;\n    }\n    getText() {\n        if (this._cachedTextValue === null) {\n            this._cachedTextValue = this._lines.join(this._eol);\n        }\n        return this._cachedTextValue;\n    }\n    onEvents(e) {\n        if (e.eol && e.eol !== this._eol) {\n            this._eol = e.eol;\n            this._lineStarts = null;\n        }\n        // Update my lines\n        const changes = e.changes;\n        for (const change of changes) {\n            this._acceptDeleteRange(change.range);\n            this._acceptInsertText(new Position(change.range.startLineNumber, change.range.startColumn), change.text);\n        }\n        this._versionId = e.versionId;\n        this._cachedTextValue = null;\n    }\n    _ensureLineStarts() {\n        if (!this._lineStarts) {\n            const eolLength = this._eol.length;\n            const linesLength = this._lines.length;\n            const lineStartValues = new Uint32Array(linesLength);\n            for (let i = 0; i < linesLength; i++) {\n                lineStartValues[i] = this._lines[i].length + eolLength;\n            }\n            this._lineStarts = new PrefixSumComputer(lineStartValues);\n        }\n    }\n    /**\n     * All changes to a line's text go through this method\n     */\n    _setLineText(lineIndex, newValue) {\n        this._lines[lineIndex] = newValue;\n        if (this._lineStarts) {\n            // update prefix sum\n            this._lineStarts.setValue(lineIndex, this._lines[lineIndex].length + this._eol.length);\n        }\n    }\n    _acceptDeleteRange(range) {\n        if (range.startLineNumber === range.endLineNumber) {\n            if (range.startColumn === range.endColumn) {\n                // Nothing to delete\n                return;\n            }\n            // Delete text on the affected line\n            this._setLineText(range.startLineNumber - 1, this._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1)\n                + this._lines[range.startLineNumber - 1].substring(range.endColumn - 1));\n            return;\n        }\n        // Take remaining text on last line and append it to remaining text on first line\n        this._setLineText(range.startLineNumber - 1, this._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1)\n            + this._lines[range.endLineNumber - 1].substring(range.endColumn - 1));\n        // Delete middle lines\n        this._lines.splice(range.startLineNumber, range.endLineNumber - range.startLineNumber);\n        if (this._lineStarts) {\n            // update prefix sum\n            this._lineStarts.removeValues(range.startLineNumber, range.endLineNumber - range.startLineNumber);\n        }\n    }\n    _acceptInsertText(position, insertText) {\n        if (insertText.length === 0) {\n            // Nothing to insert\n            return;\n        }\n        const insertLines = splitLines(insertText);\n        if (insertLines.length === 1) {\n            // Inserting text on one line\n            this._setLineText(position.lineNumber - 1, this._lines[position.lineNumber - 1].substring(0, position.column - 1)\n                + insertLines[0]\n                + this._lines[position.lineNumber - 1].substring(position.column - 1));\n            return;\n        }\n        // Append overflowing text from first line to the end of text to insert\n        insertLines[insertLines.length - 1] += this._lines[position.lineNumber - 1].substring(position.column - 1);\n        // Delete overflowing text from first line and insert text on first line\n        this._setLineText(position.lineNumber - 1, this._lines[position.lineNumber - 1].substring(0, position.column - 1)\n            + insertLines[0]);\n        // Insert new lines & store lengths\n        const newLengths = new Uint32Array(insertLines.length - 1);\n        for (let i = 1; i < insertLines.length; i++) {\n            this._lines.splice(position.lineNumber + i - 1, 0, insertLines[i]);\n            newLengths[i - 1] = insertLines[i].length + this._eol.length;\n        }\n        if (this._lineStarts) {\n            // update prefix sum\n            this._lineStarts.insertValues(position.lineNumber, newLengths);\n        }\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 { arrayInsert } from '../../../base/common/arrays.js';\nimport { toUint32 } from '../../../base/common/uint.js';\nexport class PrefixSumComputer {\n    constructor(values) {\n        this.values = values;\n        this.prefixSum = new Uint32Array(values.length);\n        this.prefixSumValidIndex = new Int32Array(1);\n        this.prefixSumValidIndex[0] = -1;\n    }\n    insertValues(insertIndex, insertValues) {\n        insertIndex = toUint32(insertIndex);\n        const oldValues = this.values;\n        const oldPrefixSum = this.prefixSum;\n        const insertValuesLen = insertValues.length;\n        if (insertValuesLen === 0) {\n            return false;\n        }\n        this.values = new Uint32Array(oldValues.length + insertValuesLen);\n        this.values.set(oldValues.subarray(0, insertIndex), 0);\n        this.values.set(oldValues.subarray(insertIndex), insertIndex + insertValuesLen);\n        this.values.set(insertValues, insertIndex);\n        if (insertIndex - 1 < this.prefixSumValidIndex[0]) {\n            this.prefixSumValidIndex[0] = insertIndex - 1;\n        }\n        this.prefixSum = new Uint32Array(this.values.length);\n        if (this.prefixSumValidIndex[0] >= 0) {\n            this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));\n        }\n        return true;\n    }\n    setValue(index, value) {\n        index = toUint32(index);\n        value = toUint32(value);\n        if (this.values[index] === value) {\n            return false;\n        }\n        this.values[index] = value;\n        if (index - 1 < this.prefixSumValidIndex[0]) {\n            this.prefixSumValidIndex[0] = index - 1;\n        }\n        return true;\n    }\n    removeValues(startIndex, count) {\n        startIndex = toUint32(startIndex);\n        count = toUint32(count);\n        const oldValues = this.values;\n        const oldPrefixSum = this.prefixSum;\n        if (startIndex >= oldValues.length) {\n            return false;\n        }\n        const maxCount = oldValues.length - startIndex;\n        if (count >= maxCount) {\n            count = maxCount;\n        }\n        if (count === 0) {\n            return false;\n        }\n        this.values = new Uint32Array(oldValues.length - count);\n        this.values.set(oldValues.subarray(0, startIndex), 0);\n        this.values.set(oldValues.subarray(startIndex + count), startIndex);\n        this.prefixSum = new Uint32Array(this.values.length);\n        if (startIndex - 1 < this.prefixSumValidIndex[0]) {\n            this.prefixSumValidIndex[0] = startIndex - 1;\n        }\n        if (this.prefixSumValidIndex[0] >= 0) {\n            this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));\n        }\n        return true;\n    }\n    getTotalSum() {\n        if (this.values.length === 0) {\n            return 0;\n        }\n        return this._getPrefixSum(this.values.length - 1);\n    }\n    /**\n     * Returns the sum of the first `index + 1` many items.\n     * @returns `SUM(0 <= j <= index, values[j])`.\n     */\n    getPrefixSum(index) {\n        if (index < 0) {\n            return 0;\n        }\n        index = toUint32(index);\n        return this._getPrefixSum(index);\n    }\n    _getPrefixSum(index) {\n        if (index <= this.prefixSumValidIndex[0]) {\n            return this.prefixSum[index];\n        }\n        let startIndex = this.prefixSumValidIndex[0] + 1;\n        if (startIndex === 0) {\n            this.prefixSum[0] = this.values[0];\n            startIndex++;\n        }\n        if (index >= this.values.length) {\n            index = this.values.length - 1;\n        }\n        for (let i = startIndex; i <= index; i++) {\n            this.prefixSum[i] = this.prefixSum[i - 1] + this.values[i];\n        }\n        this.prefixSumValidIndex[0] = Math.max(this.prefixSumValidIndex[0], index);\n        return this.prefixSum[index];\n    }\n    getIndexOf(sum) {\n        sum = Math.floor(sum);\n        // Compute all sums (to get a fully valid prefixSum)\n        this.getTotalSum();\n        let low = 0;\n        let high = this.values.length - 1;\n        let mid = 0;\n        let midStop = 0;\n        let midStart = 0;\n        while (low <= high) {\n            mid = low + ((high - low) / 2) | 0;\n            midStop = this.prefixSum[mid];\n            midStart = midStop - this.values[mid];\n            if (sum < midStart) {\n                high = mid - 1;\n            }\n            else if (sum >= midStop) {\n                low = mid + 1;\n            }\n            else {\n                break;\n            }\n        }\n        return new PrefixSumIndexOfResult(mid, sum - midStart);\n    }\n}\n/**\n * {@link getIndexOf} has an amortized runtime complexity of O(1).\n *\n * ({@link PrefixSumComputer.getIndexOf} is just  O(log n))\n*/\nexport class ConstantTimePrefixSumComputer {\n    constructor(values) {\n        this._values = values;\n        this._isValid = false;\n        this._validEndIndex = -1;\n        this._prefixSum = [];\n        this._indexBySum = [];\n    }\n    /**\n     * @returns SUM(0 <= j < values.length, values[j])\n     */\n    getTotalSum() {\n        this._ensureValid();\n        return this._indexBySum.length;\n    }\n    /**\n     * Returns the sum of the first `count` many items.\n     * @returns `SUM(0 <= j < count, values[j])`.\n     */\n    getPrefixSum(count) {\n        this._ensureValid();\n        if (count === 0) {\n            return 0;\n        }\n        return this._prefixSum[count - 1];\n    }\n    /**\n     * @returns `result`, such that `getPrefixSum(result.index) + result.remainder = sum`\n     */\n    getIndexOf(sum) {\n        this._ensureValid();\n        const idx = this._indexBySum[sum];\n        const viewLinesAbove = idx > 0 ? this._prefixSum[idx - 1] : 0;\n        return new PrefixSumIndexOfResult(idx, sum - viewLinesAbove);\n    }\n    removeValues(start, deleteCount) {\n        this._values.splice(start, deleteCount);\n        this._invalidate(start);\n    }\n    insertValues(insertIndex, insertArr) {\n        this._values = arrayInsert(this._values, insertIndex, insertArr);\n        this._invalidate(insertIndex);\n    }\n    _invalidate(index) {\n        this._isValid = false;\n        this._validEndIndex = Math.min(this._validEndIndex, index - 1);\n    }\n    _ensureValid() {\n        if (this._isValid) {\n            return;\n        }\n        for (let i = this._validEndIndex + 1, len = this._values.length; i < len; i++) {\n            const value = this._values[i];\n            const sumAbove = i > 0 ? this._prefixSum[i - 1] : 0;\n            this._prefixSum[i] = sumAbove + value;\n            for (let j = 0; j < value; j++) {\n                this._indexBySum[sumAbove + j] = i;\n            }\n        }\n        // trim things\n        this._prefixSum.length = this._values.length;\n        this._indexBySum.length = this._prefixSum[this._prefixSum.length - 1];\n        // mark as valid\n        this._isValid = true;\n        this._validEndIndex = this._values.length - 1;\n    }\n    setValue(index, value) {\n        if (this._values[index] === value) {\n            // no change\n            return;\n        }\n        this._values[index] = value;\n        this._invalidate(index);\n    }\n}\nexport class PrefixSumIndexOfResult {\n    constructor(index, remainder) {\n        this.index = index;\n        this.remainder = remainder;\n        this._prefixSumIndexOfResultBrand = undefined;\n        this.index = index;\n        this.remainder = remainder;\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 class TreeNode {\n    constructor(piece, color) {\n        this.piece = piece;\n        this.color = color;\n        this.size_left = 0;\n        this.lf_left = 0;\n        this.parent = this;\n        this.left = this;\n        this.right = this;\n    }\n    next() {\n        if (this.right !== SENTINEL) {\n            return leftest(this.right);\n        }\n        let node = this;\n        while (node.parent !== SENTINEL) {\n            if (node.parent.left === node) {\n                break;\n            }\n            node = node.parent;\n        }\n        if (node.parent === SENTINEL) {\n            return SENTINEL;\n        }\n        else {\n            return node.parent;\n        }\n    }\n    prev() {\n        if (this.left !== SENTINEL) {\n            return righttest(this.left);\n        }\n        let node = this;\n        while (node.parent !== SENTINEL) {\n            if (node.parent.right === node) {\n                break;\n            }\n            node = node.parent;\n        }\n        if (node.parent === SENTINEL) {\n            return SENTINEL;\n        }\n        else {\n            return node.parent;\n        }\n    }\n    detach() {\n        this.parent = null;\n        this.left = null;\n        this.right = null;\n    }\n}\nexport const SENTINEL = new TreeNode(null, 0 /* NodeColor.Black */);\nSENTINEL.parent = SENTINEL;\nSENTINEL.left = SENTINEL;\nSENTINEL.right = SENTINEL;\nSENTINEL.color = 0 /* NodeColor.Black */;\nexport function leftest(node) {\n    while (node.left !== SENTINEL) {\n        node = node.left;\n    }\n    return node;\n}\nexport function righttest(node) {\n    while (node.right !== SENTINEL) {\n        node = node.right;\n    }\n    return node;\n}\nfunction calculateSize(node) {\n    if (node === SENTINEL) {\n        return 0;\n    }\n    return node.size_left + node.piece.length + calculateSize(node.right);\n}\nfunction calculateLF(node) {\n    if (node === SENTINEL) {\n        return 0;\n    }\n    return node.lf_left + node.piece.lineFeedCnt + calculateLF(node.right);\n}\nfunction resetSentinel() {\n    SENTINEL.parent = SENTINEL;\n}\nexport function leftRotate(tree, x) {\n    const y = x.right;\n    // fix size_left\n    y.size_left += x.size_left + (x.piece ? x.piece.length : 0);\n    y.lf_left += x.lf_left + (x.piece ? x.piece.lineFeedCnt : 0);\n    x.right = y.left;\n    if (y.left !== SENTINEL) {\n        y.left.parent = x;\n    }\n    y.parent = x.parent;\n    if (x.parent === SENTINEL) {\n        tree.root = y;\n    }\n    else if (x.parent.left === x) {\n        x.parent.left = y;\n    }\n    else {\n        x.parent.right = y;\n    }\n    y.left = x;\n    x.parent = y;\n}\nexport function rightRotate(tree, y) {\n    const x = y.left;\n    y.left = x.right;\n    if (x.right !== SENTINEL) {\n        x.right.parent = y;\n    }\n    x.parent = y.parent;\n    // fix size_left\n    y.size_left -= x.size_left + (x.piece ? x.piece.length : 0);\n    y.lf_left -= x.lf_left + (x.piece ? x.piece.lineFeedCnt : 0);\n    if (y.parent === SENTINEL) {\n        tree.root = x;\n    }\n    else if (y === y.parent.right) {\n        y.parent.right = x;\n    }\n    else {\n        y.parent.left = x;\n    }\n    x.right = y;\n    y.parent = x;\n}\nexport function rbDelete(tree, z) {\n    let x;\n    let y;\n    if (z.left === SENTINEL) {\n        y = z;\n        x = y.right;\n    }\n    else if (z.right === SENTINEL) {\n        y = z;\n        x = y.left;\n    }\n    else {\n        y = leftest(z.right);\n        x = y.right;\n    }\n    if (y === tree.root) {\n        tree.root = x;\n        // if x is null, we are removing the only node\n        x.color = 0 /* NodeColor.Black */;\n        z.detach();\n        resetSentinel();\n        tree.root.parent = SENTINEL;\n        return;\n    }\n    const yWasRed = (y.color === 1 /* NodeColor.Red */);\n    if (y === y.parent.left) {\n        y.parent.left = x;\n    }\n    else {\n        y.parent.right = x;\n    }\n    if (y === z) {\n        x.parent = y.parent;\n        recomputeTreeMetadata(tree, x);\n    }\n    else {\n        if (y.parent === z) {\n            x.parent = y;\n        }\n        else {\n            x.parent = y.parent;\n        }\n        // as we make changes to x's hierarchy, update size_left of subtree first\n        recomputeTreeMetadata(tree, x);\n        y.left = z.left;\n        y.right = z.right;\n        y.parent = z.parent;\n        y.color = z.color;\n        if (z === tree.root) {\n            tree.root = y;\n        }\n        else {\n            if (z === z.parent.left) {\n                z.parent.left = y;\n            }\n            else {\n                z.parent.right = y;\n            }\n        }\n        if (y.left !== SENTINEL) {\n            y.left.parent = y;\n        }\n        if (y.right !== SENTINEL) {\n            y.right.parent = y;\n        }\n        // update metadata\n        // we replace z with y, so in this sub tree, the length change is z.item.length\n        y.size_left = z.size_left;\n        y.lf_left = z.lf_left;\n        recomputeTreeMetadata(tree, y);\n    }\n    z.detach();\n    if (x.parent.left === x) {\n        const newSizeLeft = calculateSize(x);\n        const newLFLeft = calculateLF(x);\n        if (newSizeLeft !== x.parent.size_left || newLFLeft !== x.parent.lf_left) {\n            const delta = newSizeLeft - x.parent.size_left;\n            const lf_delta = newLFLeft - x.parent.lf_left;\n            x.parent.size_left = newSizeLeft;\n            x.parent.lf_left = newLFLeft;\n            updateTreeMetadata(tree, x.parent, delta, lf_delta);\n        }\n    }\n    recomputeTreeMetadata(tree, x.parent);\n    if (yWasRed) {\n        resetSentinel();\n        return;\n    }\n    // RB-DELETE-FIXUP\n    let w;\n    while (x !== tree.root && x.color === 0 /* NodeColor.Black */) {\n        if (x === x.parent.left) {\n            w = x.parent.right;\n            if (w.color === 1 /* NodeColor.Red */) {\n                w.color = 0 /* NodeColor.Black */;\n                x.parent.color = 1 /* NodeColor.Red */;\n                leftRotate(tree, x.parent);\n                w = x.parent.right;\n            }\n            if (w.left.color === 0 /* NodeColor.Black */ && w.right.color === 0 /* NodeColor.Black */) {\n                w.color = 1 /* NodeColor.Red */;\n                x = x.parent;\n            }\n            else {\n                if (w.right.color === 0 /* NodeColor.Black */) {\n                    w.left.color = 0 /* NodeColor.Black */;\n                    w.color = 1 /* NodeColor.Red */;\n                    rightRotate(tree, w);\n                    w = x.parent.right;\n                }\n                w.color = x.parent.color;\n                x.parent.color = 0 /* NodeColor.Black */;\n                w.right.color = 0 /* NodeColor.Black */;\n                leftRotate(tree, x.parent);\n                x = tree.root;\n            }\n        }\n        else {\n            w = x.parent.left;\n            if (w.color === 1 /* NodeColor.Red */) {\n                w.color = 0 /* NodeColor.Black */;\n                x.parent.color = 1 /* NodeColor.Red */;\n                rightRotate(tree, x.parent);\n                w = x.parent.left;\n            }\n            if (w.left.color === 0 /* NodeColor.Black */ && w.right.color === 0 /* NodeColor.Black */) {\n                w.color = 1 /* NodeColor.Red */;\n                x = x.parent;\n            }\n            else {\n                if (w.left.color === 0 /* NodeColor.Black */) {\n                    w.right.color = 0 /* NodeColor.Black */;\n                    w.color = 1 /* NodeColor.Red */;\n                    leftRotate(tree, w);\n                    w = x.parent.left;\n                }\n                w.color = x.parent.color;\n                x.parent.color = 0 /* NodeColor.Black */;\n                w.left.color = 0 /* NodeColor.Black */;\n                rightRotate(tree, x.parent);\n                x = tree.root;\n            }\n        }\n    }\n    x.color = 0 /* NodeColor.Black */;\n    resetSentinel();\n}\nexport function fixInsert(tree, x) {\n    recomputeTreeMetadata(tree, x);\n    while (x !== tree.root && x.parent.color === 1 /* NodeColor.Red */) {\n        if (x.parent === x.parent.parent.left) {\n            const y = x.parent.parent.right;\n            if (y.color === 1 /* NodeColor.Red */) {\n                x.parent.color = 0 /* NodeColor.Black */;\n                y.color = 0 /* NodeColor.Black */;\n                x.parent.parent.color = 1 /* NodeColor.Red */;\n                x = x.parent.parent;\n            }\n            else {\n                if (x === x.parent.right) {\n                    x = x.parent;\n                    leftRotate(tree, x);\n                }\n                x.parent.color = 0 /* NodeColor.Black */;\n                x.parent.parent.color = 1 /* NodeColor.Red */;\n                rightRotate(tree, x.parent.parent);\n            }\n        }\n        else {\n            const y = x.parent.parent.left;\n            if (y.color === 1 /* NodeColor.Red */) {\n                x.parent.color = 0 /* NodeColor.Black */;\n                y.color = 0 /* NodeColor.Black */;\n                x.parent.parent.color = 1 /* NodeColor.Red */;\n                x = x.parent.parent;\n            }\n            else {\n                if (x === x.parent.left) {\n                    x = x.parent;\n                    rightRotate(tree, x);\n                }\n                x.parent.color = 0 /* NodeColor.Black */;\n                x.parent.parent.color = 1 /* NodeColor.Red */;\n                leftRotate(tree, x.parent.parent);\n            }\n        }\n    }\n    tree.root.color = 0 /* NodeColor.Black */;\n}\nexport function updateTreeMetadata(tree, x, delta, lineFeedCntDelta) {\n    // node length change or line feed count change\n    while (x !== tree.root && x !== SENTINEL) {\n        if (x.parent.left === x) {\n            x.parent.size_left += delta;\n            x.parent.lf_left += lineFeedCntDelta;\n        }\n        x = x.parent;\n    }\n}\nexport function recomputeTreeMetadata(tree, x) {\n    let delta = 0;\n    let lf_delta = 0;\n    if (x === tree.root) {\n        return;\n    }\n    // go upwards till the node whose left subtree is changed.\n    while (x !== tree.root && x === x.parent.right) {\n        x = x.parent;\n    }\n    if (x === tree.root) {\n        // well, it means we add a node to the end (inorder)\n        return;\n    }\n    // x is the node whose right subtree is changed.\n    x = x.parent;\n    delta = calculateSize(x.left) - x.size_left;\n    lf_delta = calculateLF(x.left) - x.lf_left;\n    x.size_left += delta;\n    x.lf_left += lf_delta;\n    // go upwards till root. O(logN)\n    while (x !== tree.root && (delta !== 0 || lf_delta !== 0)) {\n        if (x.parent.left === x) {\n            x.parent.size_left += delta;\n            x.parent.lf_left += lf_delta;\n        }\n        x = x.parent;\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 { Position } from '../../core/position.js';\nimport { Range } from '../../core/range.js';\nimport { FindMatch } from '../../model.js';\nimport { SENTINEL, TreeNode, fixInsert, leftest, rbDelete, righttest, updateTreeMetadata } from './rbTreeBase.js';\nimport { Searcher, createFindMatch, isValidMatch } from '../textModelSearch.js';\n// const lfRegex = new RegExp(/\\r\\n|\\r|\\n/g);\nconst AverageBufferSize = 65535;\nfunction createUintArray(arr) {\n    let r;\n    if (arr[arr.length - 1] < 65536) {\n        r = new Uint16Array(arr.length);\n    }\n    else {\n        r = new Uint32Array(arr.length);\n    }\n    r.set(arr, 0);\n    return r;\n}\nclass LineStarts {\n    constructor(lineStarts, cr, lf, crlf, isBasicASCII) {\n        this.lineStarts = lineStarts;\n        this.cr = cr;\n        this.lf = lf;\n        this.crlf = crlf;\n        this.isBasicASCII = isBasicASCII;\n    }\n}\nexport function createLineStartsFast(str, readonly = true) {\n    const r = [0];\n    let rLength = 1;\n    for (let i = 0, len = str.length; i < len; i++) {\n        const chr = str.charCodeAt(i);\n        if (chr === 13 /* CharCode.CarriageReturn */) {\n            if (i + 1 < len && str.charCodeAt(i + 1) === 10 /* CharCode.LineFeed */) {\n                // \\r\\n... case\n                r[rLength++] = i + 2;\n                i++; // skip \\n\n            }\n            else {\n                // \\r... case\n                r[rLength++] = i + 1;\n            }\n        }\n        else if (chr === 10 /* CharCode.LineFeed */) {\n            r[rLength++] = i + 1;\n        }\n    }\n    if (readonly) {\n        return createUintArray(r);\n    }\n    else {\n        return r;\n    }\n}\nexport function createLineStarts(r, str) {\n    r.length = 0;\n    r[0] = 0;\n    let rLength = 1;\n    let cr = 0, lf = 0, crlf = 0;\n    let isBasicASCII = true;\n    for (let i = 0, len = str.length; i < len; i++) {\n        const chr = str.charCodeAt(i);\n        if (chr === 13 /* CharCode.CarriageReturn */) {\n            if (i + 1 < len && str.charCodeAt(i + 1) === 10 /* CharCode.LineFeed */) {\n                // \\r\\n... case\n                crlf++;\n                r[rLength++] = i + 2;\n                i++; // skip \\n\n            }\n            else {\n                cr++;\n                // \\r... case\n                r[rLength++] = i + 1;\n            }\n        }\n        else if (chr === 10 /* CharCode.LineFeed */) {\n            lf++;\n            r[rLength++] = i + 1;\n        }\n        else {\n            if (isBasicASCII) {\n                if (chr !== 9 /* CharCode.Tab */ && (chr < 32 || chr > 126)) {\n                    isBasicASCII = false;\n                }\n            }\n        }\n    }\n    const result = new LineStarts(createUintArray(r), cr, lf, crlf, isBasicASCII);\n    r.length = 0;\n    return result;\n}\nexport class Piece {\n    constructor(bufferIndex, start, end, lineFeedCnt, length) {\n        this.bufferIndex = bufferIndex;\n        this.start = start;\n        this.end = end;\n        this.lineFeedCnt = lineFeedCnt;\n        this.length = length;\n    }\n}\nexport class StringBuffer {\n    constructor(buffer, lineStarts) {\n        this.buffer = buffer;\n        this.lineStarts = lineStarts;\n    }\n}\n/**\n * Readonly snapshot for piece tree.\n * In a real multiple thread environment, to make snapshot reading always work correctly, we need to\n * 1. Make TreeNode.piece immutable, then reading and writing can run in parallel.\n * 2. TreeNode/Buffers normalization should not happen during snapshot reading.\n */\nclass PieceTreeSnapshot {\n    constructor(tree, BOM) {\n        this._pieces = [];\n        this._tree = tree;\n        this._BOM = BOM;\n        this._index = 0;\n        if (tree.root !== SENTINEL) {\n            tree.iterate(tree.root, node => {\n                if (node !== SENTINEL) {\n                    this._pieces.push(node.piece);\n                }\n                return true;\n            });\n        }\n    }\n    read() {\n        if (this._pieces.length === 0) {\n            if (this._index === 0) {\n                this._index++;\n                return this._BOM;\n            }\n            else {\n                return null;\n            }\n        }\n        if (this._index > this._pieces.length - 1) {\n            return null;\n        }\n        if (this._index === 0) {\n            return this._BOM + this._tree.getPieceContent(this._pieces[this._index++]);\n        }\n        return this._tree.getPieceContent(this._pieces[this._index++]);\n    }\n}\nclass PieceTreeSearchCache {\n    constructor(limit) {\n        this._limit = limit;\n        this._cache = [];\n    }\n    get(offset) {\n        for (let i = this._cache.length - 1; i >= 0; i--) {\n            const nodePos = this._cache[i];\n            if (nodePos.nodeStartOffset <= offset && nodePos.nodeStartOffset + nodePos.node.piece.length >= offset) {\n                return nodePos;\n            }\n        }\n        return null;\n    }\n    get2(lineNumber) {\n        for (let i = this._cache.length - 1; i >= 0; i--) {\n            const nodePos = this._cache[i];\n            if (nodePos.nodeStartLineNumber && nodePos.nodeStartLineNumber < lineNumber && nodePos.nodeStartLineNumber + nodePos.node.piece.lineFeedCnt >= lineNumber) {\n                return nodePos;\n            }\n        }\n        return null;\n    }\n    set(nodePosition) {\n        if (this._cache.length >= this._limit) {\n            this._cache.shift();\n        }\n        this._cache.push(nodePosition);\n    }\n    validate(offset) {\n        let hasInvalidVal = false;\n        const tmp = this._cache;\n        for (let i = 0; i < tmp.length; i++) {\n            const nodePos = tmp[i];\n            if (nodePos.node.parent === null || nodePos.nodeStartOffset >= offset) {\n                tmp[i] = null;\n                hasInvalidVal = true;\n                continue;\n            }\n        }\n        if (hasInvalidVal) {\n            const newArr = [];\n            for (const entry of tmp) {\n                if (entry !== null) {\n                    newArr.push(entry);\n                }\n            }\n            this._cache = newArr;\n        }\n    }\n}\nexport class PieceTreeBase {\n    constructor(chunks, eol, eolNormalized) {\n        this.create(chunks, eol, eolNormalized);\n    }\n    create(chunks, eol, eolNormalized) {\n        this._buffers = [\n            new StringBuffer('', [0])\n        ];\n        this._lastChangeBufferPos = { line: 0, column: 0 };\n        this.root = SENTINEL;\n        this._lineCnt = 1;\n        this._length = 0;\n        this._EOL = eol;\n        this._EOLLength = eol.length;\n        this._EOLNormalized = eolNormalized;\n        let lastNode = null;\n        for (let i = 0, len = chunks.length; i < len; i++) {\n            if (chunks[i].buffer.length > 0) {\n                if (!chunks[i].lineStarts) {\n                    chunks[i].lineStarts = createLineStartsFast(chunks[i].buffer);\n                }\n                const piece = new Piece(i + 1, { line: 0, column: 0 }, { line: chunks[i].lineStarts.length - 1, column: chunks[i].buffer.length - chunks[i].lineStarts[chunks[i].lineStarts.length - 1] }, chunks[i].lineStarts.length - 1, chunks[i].buffer.length);\n                this._buffers.push(chunks[i]);\n                lastNode = this.rbInsertRight(lastNode, piece);\n            }\n        }\n        this._searchCache = new PieceTreeSearchCache(1);\n        this._lastVisitedLine = { lineNumber: 0, value: '' };\n        this.computeBufferMetadata();\n    }\n    normalizeEOL(eol) {\n        const averageBufferSize = AverageBufferSize;\n        const min = averageBufferSize - Math.floor(averageBufferSize / 3);\n        const max = min * 2;\n        let tempChunk = '';\n        let tempChunkLen = 0;\n        const chunks = [];\n        this.iterate(this.root, node => {\n            const str = this.getNodeContent(node);\n            const len = str.length;\n            if (tempChunkLen <= min || tempChunkLen + len < max) {\n                tempChunk += str;\n                tempChunkLen += len;\n                return true;\n            }\n            // flush anyways\n            const text = tempChunk.replace(/\\r\\n|\\r|\\n/g, eol);\n            chunks.push(new StringBuffer(text, createLineStartsFast(text)));\n            tempChunk = str;\n            tempChunkLen = len;\n            return true;\n        });\n        if (tempChunkLen > 0) {\n            const text = tempChunk.replace(/\\r\\n|\\r|\\n/g, eol);\n            chunks.push(new StringBuffer(text, createLineStartsFast(text)));\n        }\n        this.create(chunks, eol, true);\n    }\n    // #region Buffer API\n    getEOL() {\n        return this._EOL;\n    }\n    setEOL(newEOL) {\n        this._EOL = newEOL;\n        this._EOLLength = this._EOL.length;\n        this.normalizeEOL(newEOL);\n    }\n    createSnapshot(BOM) {\n        return new PieceTreeSnapshot(this, BOM);\n    }\n    getOffsetAt(lineNumber, column) {\n        let leftLen = 0; // inorder\n        let x = this.root;\n        while (x !== SENTINEL) {\n            if (x.left !== SENTINEL && x.lf_left + 1 >= lineNumber) {\n                x = x.left;\n            }\n            else if (x.lf_left + x.piece.lineFeedCnt + 1 >= lineNumber) {\n                leftLen += x.size_left;\n                // lineNumber >= 2\n                const accumualtedValInCurrentIndex = this.getAccumulatedValue(x, lineNumber - x.lf_left - 2);\n                return leftLen += accumualtedValInCurrentIndex + column - 1;\n            }\n            else {\n                lineNumber -= x.lf_left + x.piece.lineFeedCnt;\n                leftLen += x.size_left + x.piece.length;\n                x = x.right;\n            }\n        }\n        return leftLen;\n    }\n    getPositionAt(offset) {\n        offset = Math.floor(offset);\n        offset = Math.max(0, offset);\n        let x = this.root;\n        let lfCnt = 0;\n        const originalOffset = offset;\n        while (x !== SENTINEL) {\n            if (x.size_left !== 0 && x.size_left >= offset) {\n                x = x.left;\n            }\n            else if (x.size_left + x.piece.length >= offset) {\n                const out = this.getIndexOf(x, offset - x.size_left);\n                lfCnt += x.lf_left + out.index;\n                if (out.index === 0) {\n                    const lineStartOffset = this.getOffsetAt(lfCnt + 1, 1);\n                    const column = originalOffset - lineStartOffset;\n                    return new Position(lfCnt + 1, column + 1);\n                }\n                return new Position(lfCnt + 1, out.remainder + 1);\n            }\n            else {\n                offset -= x.size_left + x.piece.length;\n                lfCnt += x.lf_left + x.piece.lineFeedCnt;\n                if (x.right === SENTINEL) {\n                    // last node\n                    const lineStartOffset = this.getOffsetAt(lfCnt + 1, 1);\n                    const column = originalOffset - offset - lineStartOffset;\n                    return new Position(lfCnt + 1, column + 1);\n                }\n                else {\n                    x = x.right;\n                }\n            }\n        }\n        return new Position(1, 1);\n    }\n    getValueInRange(range, eol) {\n        if (range.startLineNumber === range.endLineNumber && range.startColumn === range.endColumn) {\n            return '';\n        }\n        const startPosition = this.nodeAt2(range.startLineNumber, range.startColumn);\n        const endPosition = this.nodeAt2(range.endLineNumber, range.endColumn);\n        const value = this.getValueInRange2(startPosition, endPosition);\n        if (eol) {\n            if (eol !== this._EOL || !this._EOLNormalized) {\n                return value.replace(/\\r\\n|\\r|\\n/g, eol);\n            }\n            if (eol === this.getEOL() && this._EOLNormalized) {\n                if (eol === '\\r\\n') {\n                }\n                return value;\n            }\n            return value.replace(/\\r\\n|\\r|\\n/g, eol);\n        }\n        return value;\n    }\n    getValueInRange2(startPosition, endPosition) {\n        if (startPosition.node === endPosition.node) {\n            const node = startPosition.node;\n            const buffer = this._buffers[node.piece.bufferIndex].buffer;\n            const startOffset = this.offsetInBuffer(node.piece.bufferIndex, node.piece.start);\n            return buffer.substring(startOffset + startPosition.remainder, startOffset + endPosition.remainder);\n        }\n        let x = startPosition.node;\n        const buffer = this._buffers[x.piece.bufferIndex].buffer;\n        const startOffset = this.offsetInBuffer(x.piece.bufferIndex, x.piece.start);\n        let ret = buffer.substring(startOffset + startPosition.remainder, startOffset + x.piece.length);\n        x = x.next();\n        while (x !== SENTINEL) {\n            const buffer = this._buffers[x.piece.bufferIndex].buffer;\n            const startOffset = this.offsetInBuffer(x.piece.bufferIndex, x.piece.start);\n            if (x === endPosition.node) {\n                ret += buffer.substring(startOffset, startOffset + endPosition.remainder);\n                break;\n            }\n            else {\n                ret += buffer.substr(startOffset, x.piece.length);\n            }\n            x = x.next();\n        }\n        return ret;\n    }\n    getLinesContent() {\n        const lines = [];\n        let linesLength = 0;\n        let currentLine = '';\n        let danglingCR = false;\n        this.iterate(this.root, node => {\n            if (node === SENTINEL) {\n                return true;\n            }\n            const piece = node.piece;\n            let pieceLength = piece.length;\n            if (pieceLength === 0) {\n                return true;\n            }\n            const buffer = this._buffers[piece.bufferIndex].buffer;\n            const lineStarts = this._buffers[piece.bufferIndex].lineStarts;\n            const pieceStartLine = piece.start.line;\n            const pieceEndLine = piece.end.line;\n            let pieceStartOffset = lineStarts[pieceStartLine] + piece.start.column;\n            if (danglingCR) {\n                if (buffer.charCodeAt(pieceStartOffset) === 10 /* CharCode.LineFeed */) {\n                    // pretend the \\n was in the previous piece..\n                    pieceStartOffset++;\n                    pieceLength--;\n                }\n                lines[linesLength++] = currentLine;\n                currentLine = '';\n                danglingCR = false;\n                if (pieceLength === 0) {\n                    return true;\n                }\n            }\n            if (pieceStartLine === pieceEndLine) {\n                // this piece has no new lines\n                if (!this._EOLNormalized && buffer.charCodeAt(pieceStartOffset + pieceLength - 1) === 13 /* CharCode.CarriageReturn */) {\n                    danglingCR = true;\n                    currentLine += buffer.substr(pieceStartOffset, pieceLength - 1);\n                }\n                else {\n                    currentLine += buffer.substr(pieceStartOffset, pieceLength);\n                }\n                return true;\n            }\n            // add the text before the first line start in this piece\n            currentLine += (this._EOLNormalized\n                ? buffer.substring(pieceStartOffset, Math.max(pieceStartOffset, lineStarts[pieceStartLine + 1] - this._EOLLength))\n                : buffer.substring(pieceStartOffset, lineStarts[pieceStartLine + 1]).replace(/(\\r\\n|\\r|\\n)$/, ''));\n            lines[linesLength++] = currentLine;\n            for (let line = pieceStartLine + 1; line < pieceEndLine; line++) {\n                currentLine = (this._EOLNormalized\n                    ? buffer.substring(lineStarts[line], lineStarts[line + 1] - this._EOLLength)\n                    : buffer.substring(lineStarts[line], lineStarts[line + 1]).replace(/(\\r\\n|\\r|\\n)$/, ''));\n                lines[linesLength++] = currentLine;\n            }\n            if (!this._EOLNormalized && buffer.charCodeAt(lineStarts[pieceEndLine] + piece.end.column - 1) === 13 /* CharCode.CarriageReturn */) {\n                danglingCR = true;\n                if (piece.end.column === 0) {\n                    // The last line ended with a \\r, let's undo the push, it will be pushed by next iteration\n                    linesLength--;\n                }\n                else {\n                    currentLine = buffer.substr(lineStarts[pieceEndLine], piece.end.column - 1);\n                }\n            }\n            else {\n                currentLine = buffer.substr(lineStarts[pieceEndLine], piece.end.column);\n            }\n            return true;\n        });\n        if (danglingCR) {\n            lines[linesLength++] = currentLine;\n            currentLine = '';\n        }\n        lines[linesLength++] = currentLine;\n        return lines;\n    }\n    getLength() {\n        return this._length;\n    }\n    getLineCount() {\n        return this._lineCnt;\n    }\n    getLineContent(lineNumber) {\n        if (this._lastVisitedLine.lineNumber === lineNumber) {\n            return this._lastVisitedLine.value;\n        }\n        this._lastVisitedLine.lineNumber = lineNumber;\n        if (lineNumber === this._lineCnt) {\n            this._lastVisitedLine.value = this.getLineRawContent(lineNumber);\n        }\n        else if (this._EOLNormalized) {\n            this._lastVisitedLine.value = this.getLineRawContent(lineNumber, this._EOLLength);\n        }\n        else {\n            this._lastVisitedLine.value = this.getLineRawContent(lineNumber).replace(/(\\r\\n|\\r|\\n)$/, '');\n        }\n        return this._lastVisitedLine.value;\n    }\n    _getCharCode(nodePos) {\n        if (nodePos.remainder === nodePos.node.piece.length) {\n            // the char we want to fetch is at the head of next node.\n            const matchingNode = nodePos.node.next();\n            if (!matchingNode) {\n                return 0;\n            }\n            const buffer = this._buffers[matchingNode.piece.bufferIndex];\n            const startOffset = this.offsetInBuffer(matchingNode.piece.bufferIndex, matchingNode.piece.start);\n            return buffer.buffer.charCodeAt(startOffset);\n        }\n        else {\n            const buffer = this._buffers[nodePos.node.piece.bufferIndex];\n            const startOffset = this.offsetInBuffer(nodePos.node.piece.bufferIndex, nodePos.node.piece.start);\n            const targetOffset = startOffset + nodePos.remainder;\n            return buffer.buffer.charCodeAt(targetOffset);\n        }\n    }\n    getLineCharCode(lineNumber, index) {\n        const nodePos = this.nodeAt2(lineNumber, index + 1);\n        return this._getCharCode(nodePos);\n    }\n    getLineLength(lineNumber) {\n        if (lineNumber === this.getLineCount()) {\n            const startOffset = this.getOffsetAt(lineNumber, 1);\n            return this.getLength() - startOffset;\n        }\n        return this.getOffsetAt(lineNumber + 1, 1) - this.getOffsetAt(lineNumber, 1) - this._EOLLength;\n    }\n    findMatchesInNode(node, searcher, startLineNumber, startColumn, startCursor, endCursor, searchData, captureMatches, limitResultCount, resultLen, result) {\n        const buffer = this._buffers[node.piece.bufferIndex];\n        const startOffsetInBuffer = this.offsetInBuffer(node.piece.bufferIndex, node.piece.start);\n        const start = this.offsetInBuffer(node.piece.bufferIndex, startCursor);\n        const end = this.offsetInBuffer(node.piece.bufferIndex, endCursor);\n        let m;\n        // Reset regex to search from the beginning\n        const ret = { line: 0, column: 0 };\n        let searchText;\n        let offsetInBuffer;\n        if (searcher._wordSeparators) {\n            searchText = buffer.buffer.substring(start, end);\n            offsetInBuffer = (offset) => offset + start;\n            searcher.reset(0);\n        }\n        else {\n            searchText = buffer.buffer;\n            offsetInBuffer = (offset) => offset;\n            searcher.reset(start);\n        }\n        do {\n            m = searcher.next(searchText);\n            if (m) {\n                if (offsetInBuffer(m.index) >= end) {\n                    return resultLen;\n                }\n                this.positionInBuffer(node, offsetInBuffer(m.index) - startOffsetInBuffer, ret);\n                const lineFeedCnt = this.getLineFeedCnt(node.piece.bufferIndex, startCursor, ret);\n                const retStartColumn = ret.line === startCursor.line ? ret.column - startCursor.column + startColumn : ret.column + 1;\n                const retEndColumn = retStartColumn + m[0].length;\n                result[resultLen++] = createFindMatch(new Range(startLineNumber + lineFeedCnt, retStartColumn, startLineNumber + lineFeedCnt, retEndColumn), m, captureMatches);\n                if (offsetInBuffer(m.index) + m[0].length >= end) {\n                    return resultLen;\n                }\n                if (resultLen >= limitResultCount) {\n                    return resultLen;\n                }\n            }\n        } while (m);\n        return resultLen;\n    }\n    findMatchesLineByLine(searchRange, searchData, captureMatches, limitResultCount) {\n        const result = [];\n        let resultLen = 0;\n        const searcher = new Searcher(searchData.wordSeparators, searchData.regex);\n        let startPosition = this.nodeAt2(searchRange.startLineNumber, searchRange.startColumn);\n        if (startPosition === null) {\n            return [];\n        }\n        const endPosition = this.nodeAt2(searchRange.endLineNumber, searchRange.endColumn);\n        if (endPosition === null) {\n            return [];\n        }\n        let start = this.positionInBuffer(startPosition.node, startPosition.remainder);\n        const end = this.positionInBuffer(endPosition.node, endPosition.remainder);\n        if (startPosition.node === endPosition.node) {\n            this.findMatchesInNode(startPosition.node, searcher, searchRange.startLineNumber, searchRange.startColumn, start, end, searchData, captureMatches, limitResultCount, resultLen, result);\n            return result;\n        }\n        let startLineNumber = searchRange.startLineNumber;\n        let currentNode = startPosition.node;\n        while (currentNode !== endPosition.node) {\n            const lineBreakCnt = this.getLineFeedCnt(currentNode.piece.bufferIndex, start, currentNode.piece.end);\n            if (lineBreakCnt >= 1) {\n                // last line break position\n                const lineStarts = this._buffers[currentNode.piece.bufferIndex].lineStarts;\n                const startOffsetInBuffer = this.offsetInBuffer(currentNode.piece.bufferIndex, currentNode.piece.start);\n                const nextLineStartOffset = lineStarts[start.line + lineBreakCnt];\n                const startColumn = startLineNumber === searchRange.startLineNumber ? searchRange.startColumn : 1;\n                resultLen = this.findMatchesInNode(currentNode, searcher, startLineNumber, startColumn, start, this.positionInBuffer(currentNode, nextLineStartOffset - startOffsetInBuffer), searchData, captureMatches, limitResultCount, resultLen, result);\n                if (resultLen >= limitResultCount) {\n                    return result;\n                }\n                startLineNumber += lineBreakCnt;\n            }\n            const startColumn = startLineNumber === searchRange.startLineNumber ? searchRange.startColumn - 1 : 0;\n            // search for the remaining content\n            if (startLineNumber === searchRange.endLineNumber) {\n                const text = this.getLineContent(startLineNumber).substring(startColumn, searchRange.endColumn - 1);\n                resultLen = this._findMatchesInLine(searchData, searcher, text, searchRange.endLineNumber, startColumn, resultLen, result, captureMatches, limitResultCount);\n                return result;\n            }\n            resultLen = this._findMatchesInLine(searchData, searcher, this.getLineContent(startLineNumber).substr(startColumn), startLineNumber, startColumn, resultLen, result, captureMatches, limitResultCount);\n            if (resultLen >= limitResultCount) {\n                return result;\n            }\n            startLineNumber++;\n            startPosition = this.nodeAt2(startLineNumber, 1);\n            currentNode = startPosition.node;\n            start = this.positionInBuffer(startPosition.node, startPosition.remainder);\n        }\n        if (startLineNumber === searchRange.endLineNumber) {\n            const startColumn = startLineNumber === searchRange.startLineNumber ? searchRange.startColumn - 1 : 0;\n            const text = this.getLineContent(startLineNumber).substring(startColumn, searchRange.endColumn - 1);\n            resultLen = this._findMatchesInLine(searchData, searcher, text, searchRange.endLineNumber, startColumn, resultLen, result, captureMatches, limitResultCount);\n            return result;\n        }\n        const startColumn = startLineNumber === searchRange.startLineNumber ? searchRange.startColumn : 1;\n        resultLen = this.findMatchesInNode(endPosition.node, searcher, startLineNumber, startColumn, start, end, searchData, captureMatches, limitResultCount, resultLen, result);\n        return result;\n    }\n    _findMatchesInLine(searchData, searcher, text, lineNumber, deltaOffset, resultLen, result, captureMatches, limitResultCount) {\n        const wordSeparators = searchData.wordSeparators;\n        if (!captureMatches && searchData.simpleSearch) {\n            const searchString = searchData.simpleSearch;\n            const searchStringLen = searchString.length;\n            const textLength = text.length;\n            let lastMatchIndex = -searchStringLen;\n            while ((lastMatchIndex = text.indexOf(searchString, lastMatchIndex + searchStringLen)) !== -1) {\n                if (!wordSeparators || isValidMatch(wordSeparators, text, textLength, lastMatchIndex, searchStringLen)) {\n                    result[resultLen++] = new FindMatch(new Range(lineNumber, lastMatchIndex + 1 + deltaOffset, lineNumber, lastMatchIndex + 1 + searchStringLen + deltaOffset), null);\n                    if (resultLen >= limitResultCount) {\n                        return resultLen;\n                    }\n                }\n            }\n            return resultLen;\n        }\n        let m;\n        // Reset regex to search from the beginning\n        searcher.reset(0);\n        do {\n            m = searcher.next(text);\n            if (m) {\n                result[resultLen++] = createFindMatch(new Range(lineNumber, m.index + 1 + deltaOffset, lineNumber, m.index + 1 + m[0].length + deltaOffset), m, captureMatches);\n                if (resultLen >= limitResultCount) {\n                    return resultLen;\n                }\n            }\n        } while (m);\n        return resultLen;\n    }\n    // #endregion\n    // #region Piece Table\n    insert(offset, value, eolNormalized = false) {\n        this._EOLNormalized = this._EOLNormalized && eolNormalized;\n        this._lastVisitedLine.lineNumber = 0;\n        this._lastVisitedLine.value = '';\n        if (this.root !== SENTINEL) {\n            const { node, remainder, nodeStartOffset } = this.nodeAt(offset);\n            const piece = node.piece;\n            const bufferIndex = piece.bufferIndex;\n            const insertPosInBuffer = this.positionInBuffer(node, remainder);\n            if (node.piece.bufferIndex === 0 &&\n                piece.end.line === this._lastChangeBufferPos.line &&\n                piece.end.column === this._lastChangeBufferPos.column &&\n                (nodeStartOffset + piece.length === offset) &&\n                value.length < AverageBufferSize) {\n                // changed buffer\n                this.appendToNode(node, value);\n                this.computeBufferMetadata();\n                return;\n            }\n            if (nodeStartOffset === offset) {\n                this.insertContentToNodeLeft(value, node);\n                this._searchCache.validate(offset);\n            }\n            else if (nodeStartOffset + node.piece.length > offset) {\n                // we are inserting into the middle of a node.\n                const nodesToDel = [];\n                let newRightPiece = new Piece(piece.bufferIndex, insertPosInBuffer, piece.end, this.getLineFeedCnt(piece.bufferIndex, insertPosInBuffer, piece.end), this.offsetInBuffer(bufferIndex, piece.end) - this.offsetInBuffer(bufferIndex, insertPosInBuffer));\n                if (this.shouldCheckCRLF() && this.endWithCR(value)) {\n                    const headOfRight = this.nodeCharCodeAt(node, remainder);\n                    if (headOfRight === 10 /** \\n */) {\n                        const newStart = { line: newRightPiece.start.line + 1, column: 0 };\n                        newRightPiece = new Piece(newRightPiece.bufferIndex, newStart, newRightPiece.end, this.getLineFeedCnt(newRightPiece.bufferIndex, newStart, newRightPiece.end), newRightPiece.length - 1);\n                        value += '\\n';\n                    }\n                }\n                // reuse node for content before insertion point.\n                if (this.shouldCheckCRLF() && this.startWithLF(value)) {\n                    const tailOfLeft = this.nodeCharCodeAt(node, remainder - 1);\n                    if (tailOfLeft === 13 /** \\r */) {\n                        const previousPos = this.positionInBuffer(node, remainder - 1);\n                        this.deleteNodeTail(node, previousPos);\n                        value = '\\r' + value;\n                        if (node.piece.length === 0) {\n                            nodesToDel.push(node);\n                        }\n                    }\n                    else {\n                        this.deleteNodeTail(node, insertPosInBuffer);\n                    }\n                }\n                else {\n                    this.deleteNodeTail(node, insertPosInBuffer);\n                }\n                const newPieces = this.createNewPieces(value);\n                if (newRightPiece.length > 0) {\n                    this.rbInsertRight(node, newRightPiece);\n                }\n                let tmpNode = node;\n                for (let k = 0; k < newPieces.length; k++) {\n                    tmpNode = this.rbInsertRight(tmpNode, newPieces[k]);\n                }\n                this.deleteNodes(nodesToDel);\n            }\n            else {\n                this.insertContentToNodeRight(value, node);\n            }\n        }\n        else {\n            // insert new node\n            const pieces = this.createNewPieces(value);\n            let node = this.rbInsertLeft(null, pieces[0]);\n            for (let k = 1; k < pieces.length; k++) {\n                node = this.rbInsertRight(node, pieces[k]);\n            }\n        }\n        // todo, this is too brutal. Total line feed count should be updated the same way as lf_left.\n        this.computeBufferMetadata();\n    }\n    delete(offset, cnt) {\n        this._lastVisitedLine.lineNumber = 0;\n        this._lastVisitedLine.value = '';\n        if (cnt <= 0 || this.root === SENTINEL) {\n            return;\n        }\n        const startPosition = this.nodeAt(offset);\n        const endPosition = this.nodeAt(offset + cnt);\n        const startNode = startPosition.node;\n        const endNode = endPosition.node;\n        if (startNode === endNode) {\n            const startSplitPosInBuffer = this.positionInBuffer(startNode, startPosition.remainder);\n            const endSplitPosInBuffer = this.positionInBuffer(startNode, endPosition.remainder);\n            if (startPosition.nodeStartOffset === offset) {\n                if (cnt === startNode.piece.length) { // delete node\n                    const next = startNode.next();\n                    rbDelete(this, startNode);\n                    this.validateCRLFWithPrevNode(next);\n                    this.computeBufferMetadata();\n                    return;\n                }\n                this.deleteNodeHead(startNode, endSplitPosInBuffer);\n                this._searchCache.validate(offset);\n                this.validateCRLFWithPrevNode(startNode);\n                this.computeBufferMetadata();\n                return;\n            }\n            if (startPosition.nodeStartOffset + startNode.piece.length === offset + cnt) {\n                this.deleteNodeTail(startNode, startSplitPosInBuffer);\n                this.validateCRLFWithNextNode(startNode);\n                this.computeBufferMetadata();\n                return;\n            }\n            // delete content in the middle, this node will be splitted to nodes\n            this.shrinkNode(startNode, startSplitPosInBuffer, endSplitPosInBuffer);\n            this.computeBufferMetadata();\n            return;\n        }\n        const nodesToDel = [];\n        const startSplitPosInBuffer = this.positionInBuffer(startNode, startPosition.remainder);\n        this.deleteNodeTail(startNode, startSplitPosInBuffer);\n        this._searchCache.validate(offset);\n        if (startNode.piece.length === 0) {\n            nodesToDel.push(startNode);\n        }\n        // update last touched node\n        const endSplitPosInBuffer = this.positionInBuffer(endNode, endPosition.remainder);\n        this.deleteNodeHead(endNode, endSplitPosInBuffer);\n        if (endNode.piece.length === 0) {\n            nodesToDel.push(endNode);\n        }\n        // delete nodes in between\n        const secondNode = startNode.next();\n        for (let node = secondNode; node !== SENTINEL && node !== endNode; node = node.next()) {\n            nodesToDel.push(node);\n        }\n        const prev = startNode.piece.length === 0 ? startNode.prev() : startNode;\n        this.deleteNodes(nodesToDel);\n        this.validateCRLFWithNextNode(prev);\n        this.computeBufferMetadata();\n    }\n    insertContentToNodeLeft(value, node) {\n        // we are inserting content to the beginning of node\n        const nodesToDel = [];\n        if (this.shouldCheckCRLF() && this.endWithCR(value) && this.startWithLF(node)) {\n            // move `\\n` to new node.\n            const piece = node.piece;\n            const newStart = { line: piece.start.line + 1, column: 0 };\n            const nPiece = new Piece(piece.bufferIndex, newStart, piece.end, this.getLineFeedCnt(piece.bufferIndex, newStart, piece.end), piece.length - 1);\n            node.piece = nPiece;\n            value += '\\n';\n            updateTreeMetadata(this, node, -1, -1);\n            if (node.piece.length === 0) {\n                nodesToDel.push(node);\n            }\n        }\n        const newPieces = this.createNewPieces(value);\n        let newNode = this.rbInsertLeft(node, newPieces[newPieces.length - 1]);\n        for (let k = newPieces.length - 2; k >= 0; k--) {\n            newNode = this.rbInsertLeft(newNode, newPieces[k]);\n        }\n        this.validateCRLFWithPrevNode(newNode);\n        this.deleteNodes(nodesToDel);\n    }\n    insertContentToNodeRight(value, node) {\n        // we are inserting to the right of this node.\n        if (this.adjustCarriageReturnFromNext(value, node)) {\n            // move \\n to the new node.\n            value += '\\n';\n        }\n        const newPieces = this.createNewPieces(value);\n        const newNode = this.rbInsertRight(node, newPieces[0]);\n        let tmpNode = newNode;\n        for (let k = 1; k < newPieces.length; k++) {\n            tmpNode = this.rbInsertRight(tmpNode, newPieces[k]);\n        }\n        this.validateCRLFWithPrevNode(newNode);\n    }\n    positionInBuffer(node, remainder, ret) {\n        const piece = node.piece;\n        const bufferIndex = node.piece.bufferIndex;\n        const lineStarts = this._buffers[bufferIndex].lineStarts;\n        const startOffset = lineStarts[piece.start.line] + piece.start.column;\n        const offset = startOffset + remainder;\n        // binary search offset between startOffset and endOffset\n        let low = piece.start.line;\n        let high = piece.end.line;\n        let mid = 0;\n        let midStop = 0;\n        let midStart = 0;\n        while (low <= high) {\n            mid = low + ((high - low) / 2) | 0;\n            midStart = lineStarts[mid];\n            if (mid === high) {\n                break;\n            }\n            midStop = lineStarts[mid + 1];\n            if (offset < midStart) {\n                high = mid - 1;\n            }\n            else if (offset >= midStop) {\n                low = mid + 1;\n            }\n            else {\n                break;\n            }\n        }\n        if (ret) {\n            ret.line = mid;\n            ret.column = offset - midStart;\n            return null;\n        }\n        return {\n            line: mid,\n            column: offset - midStart\n        };\n    }\n    getLineFeedCnt(bufferIndex, start, end) {\n        // we don't need to worry about start: abc\\r|\\n, or abc|\\r, or abc|\\n, or abc|\\r\\n doesn't change the fact that, there is one line break after start.\n        // now let's take care of end: abc\\r|\\n, if end is in between \\r and \\n, we need to add line feed count by 1\n        if (end.column === 0) {\n            return end.line - start.line;\n        }\n        const lineStarts = this._buffers[bufferIndex].lineStarts;\n        if (end.line === lineStarts.length - 1) { // it means, there is no \\n after end, otherwise, there will be one more lineStart.\n            return end.line - start.line;\n        }\n        const nextLineStartOffset = lineStarts[end.line + 1];\n        const endOffset = lineStarts[end.line] + end.column;\n        if (nextLineStartOffset > endOffset + 1) { // there are more than 1 character after end, which means it can't be \\n\n            return end.line - start.line;\n        }\n        // endOffset + 1 === nextLineStartOffset\n        // character at endOffset is \\n, so we check the character before first\n        // if character at endOffset is \\r, end.column is 0 and we can't get here.\n        const previousCharOffset = endOffset - 1; // end.column > 0 so it's okay.\n        const buffer = this._buffers[bufferIndex].buffer;\n        if (buffer.charCodeAt(previousCharOffset) === 13) {\n            return end.line - start.line + 1;\n        }\n        else {\n            return end.line - start.line;\n        }\n    }\n    offsetInBuffer(bufferIndex, cursor) {\n        const lineStarts = this._buffers[bufferIndex].lineStarts;\n        return lineStarts[cursor.line] + cursor.column;\n    }\n    deleteNodes(nodes) {\n        for (let i = 0; i < nodes.length; i++) {\n            rbDelete(this, nodes[i]);\n        }\n    }\n    createNewPieces(text) {\n        if (text.length > AverageBufferSize) {\n            // the content is large, operations like substring, charCode becomes slow\n            // so here we split it into smaller chunks, just like what we did for CR/LF normalization\n            const newPieces = [];\n            while (text.length > AverageBufferSize) {\n                const lastChar = text.charCodeAt(AverageBufferSize - 1);\n                let splitText;\n                if (lastChar === 13 /* CharCode.CarriageReturn */ || (lastChar >= 0xD800 && lastChar <= 0xDBFF)) {\n                    // last character is \\r or a high surrogate => keep it back\n                    splitText = text.substring(0, AverageBufferSize - 1);\n                    text = text.substring(AverageBufferSize - 1);\n                }\n                else {\n                    splitText = text.substring(0, AverageBufferSize);\n                    text = text.substring(AverageBufferSize);\n                }\n                const lineStarts = createLineStartsFast(splitText);\n                newPieces.push(new Piece(this._buffers.length, /* buffer index */ { line: 0, column: 0 }, { line: lineStarts.length - 1, column: splitText.length - lineStarts[lineStarts.length - 1] }, lineStarts.length - 1, splitText.length));\n                this._buffers.push(new StringBuffer(splitText, lineStarts));\n            }\n            const lineStarts = createLineStartsFast(text);\n            newPieces.push(new Piece(this._buffers.length, /* buffer index */ { line: 0, column: 0 }, { line: lineStarts.length - 1, column: text.length - lineStarts[lineStarts.length - 1] }, lineStarts.length - 1, text.length));\n            this._buffers.push(new StringBuffer(text, lineStarts));\n            return newPieces;\n        }\n        let startOffset = this._buffers[0].buffer.length;\n        const lineStarts = createLineStartsFast(text, false);\n        let start = this._lastChangeBufferPos;\n        if (this._buffers[0].lineStarts[this._buffers[0].lineStarts.length - 1] === startOffset\n            && startOffset !== 0\n            && this.startWithLF(text)\n            && this.endWithCR(this._buffers[0].buffer) // todo, we can check this._lastChangeBufferPos's column as it's the last one\n        ) {\n            this._lastChangeBufferPos = { line: this._lastChangeBufferPos.line, column: this._lastChangeBufferPos.column + 1 };\n            start = this._lastChangeBufferPos;\n            for (let i = 0; i < lineStarts.length; i++) {\n                lineStarts[i] += startOffset + 1;\n            }\n            this._buffers[0].lineStarts = this._buffers[0].lineStarts.concat(lineStarts.slice(1));\n            this._buffers[0].buffer += '_' + text;\n            startOffset += 1;\n        }\n        else {\n            if (startOffset !== 0) {\n                for (let i = 0; i < lineStarts.length; i++) {\n                    lineStarts[i] += startOffset;\n                }\n            }\n            this._buffers[0].lineStarts = this._buffers[0].lineStarts.concat(lineStarts.slice(1));\n            this._buffers[0].buffer += text;\n        }\n        const endOffset = this._buffers[0].buffer.length;\n        const endIndex = this._buffers[0].lineStarts.length - 1;\n        const endColumn = endOffset - this._buffers[0].lineStarts[endIndex];\n        const endPos = { line: endIndex, column: endColumn };\n        const newPiece = new Piece(0, /** todo@peng */ start, endPos, this.getLineFeedCnt(0, start, endPos), endOffset - startOffset);\n        this._lastChangeBufferPos = endPos;\n        return [newPiece];\n    }\n    getLineRawContent(lineNumber, endOffset = 0) {\n        let x = this.root;\n        let ret = '';\n        const cache = this._searchCache.get2(lineNumber);\n        if (cache) {\n            x = cache.node;\n            const prevAccumulatedValue = this.getAccumulatedValue(x, lineNumber - cache.nodeStartLineNumber - 1);\n            const buffer = this._buffers[x.piece.bufferIndex].buffer;\n            const startOffset = this.offsetInBuffer(x.piece.bufferIndex, x.piece.start);\n            if (cache.nodeStartLineNumber + x.piece.lineFeedCnt === lineNumber) {\n                ret = buffer.substring(startOffset + prevAccumulatedValue, startOffset + x.piece.length);\n            }\n            else {\n                const accumulatedValue = this.getAccumulatedValue(x, lineNumber - cache.nodeStartLineNumber);\n                return buffer.substring(startOffset + prevAccumulatedValue, startOffset + accumulatedValue - endOffset);\n            }\n        }\n        else {\n            let nodeStartOffset = 0;\n            const originalLineNumber = lineNumber;\n            while (x !== SENTINEL) {\n                if (x.left !== SENTINEL && x.lf_left >= lineNumber - 1) {\n                    x = x.left;\n                }\n                else if (x.lf_left + x.piece.lineFeedCnt > lineNumber - 1) {\n                    const prevAccumulatedValue = this.getAccumulatedValue(x, lineNumber - x.lf_left - 2);\n                    const accumulatedValue = this.getAccumulatedValue(x, lineNumber - x.lf_left - 1);\n                    const buffer = this._buffers[x.piece.bufferIndex].buffer;\n                    const startOffset = this.offsetInBuffer(x.piece.bufferIndex, x.piece.start);\n                    nodeStartOffset += x.size_left;\n                    this._searchCache.set({\n                        node: x,\n                        nodeStartOffset,\n                        nodeStartLineNumber: originalLineNumber - (lineNumber - 1 - x.lf_left)\n                    });\n                    return buffer.substring(startOffset + prevAccumulatedValue, startOffset + accumulatedValue - endOffset);\n                }\n                else if (x.lf_left + x.piece.lineFeedCnt === lineNumber - 1) {\n                    const prevAccumulatedValue = this.getAccumulatedValue(x, lineNumber - x.lf_left - 2);\n                    const buffer = this._buffers[x.piece.bufferIndex].buffer;\n                    const startOffset = this.offsetInBuffer(x.piece.bufferIndex, x.piece.start);\n                    ret = buffer.substring(startOffset + prevAccumulatedValue, startOffset + x.piece.length);\n                    break;\n                }\n                else {\n                    lineNumber -= x.lf_left + x.piece.lineFeedCnt;\n                    nodeStartOffset += x.size_left + x.piece.length;\n                    x = x.right;\n                }\n            }\n        }\n        // search in order, to find the node contains end column\n        x = x.next();\n        while (x !== SENTINEL) {\n            const buffer = this._buffers[x.piece.bufferIndex].buffer;\n            if (x.piece.lineFeedCnt > 0) {\n                const accumulatedValue = this.getAccumulatedValue(x, 0);\n                const startOffset = this.offsetInBuffer(x.piece.bufferIndex, x.piece.start);\n                ret += buffer.substring(startOffset, startOffset + accumulatedValue - endOffset);\n                return ret;\n            }\n            else {\n                const startOffset = this.offsetInBuffer(x.piece.bufferIndex, x.piece.start);\n                ret += buffer.substr(startOffset, x.piece.length);\n            }\n            x = x.next();\n        }\n        return ret;\n    }\n    computeBufferMetadata() {\n        let x = this.root;\n        let lfCnt = 1;\n        let len = 0;\n        while (x !== SENTINEL) {\n            lfCnt += x.lf_left + x.piece.lineFeedCnt;\n            len += x.size_left + x.piece.length;\n            x = x.right;\n        }\n        this._lineCnt = lfCnt;\n        this._length = len;\n        this._searchCache.validate(this._length);\n    }\n    // #region node operations\n    getIndexOf(node, accumulatedValue) {\n        const piece = node.piece;\n        const pos = this.positionInBuffer(node, accumulatedValue);\n        const lineCnt = pos.line - piece.start.line;\n        if (this.offsetInBuffer(piece.bufferIndex, piece.end) - this.offsetInBuffer(piece.bufferIndex, piece.start) === accumulatedValue) {\n            // we are checking the end of this node, so a CRLF check is necessary.\n            const realLineCnt = this.getLineFeedCnt(node.piece.bufferIndex, piece.start, pos);\n            if (realLineCnt !== lineCnt) {\n                // aha yes, CRLF\n                return { index: realLineCnt, remainder: 0 };\n            }\n        }\n        return { index: lineCnt, remainder: pos.column };\n    }\n    getAccumulatedValue(node, index) {\n        if (index < 0) {\n            return 0;\n        }\n        const piece = node.piece;\n        const lineStarts = this._buffers[piece.bufferIndex].lineStarts;\n        const expectedLineStartIndex = piece.start.line + index + 1;\n        if (expectedLineStartIndex > piece.end.line) {\n            return lineStarts[piece.end.line] + piece.end.column - lineStarts[piece.start.line] - piece.start.column;\n        }\n        else {\n            return lineStarts[expectedLineStartIndex] - lineStarts[piece.start.line] - piece.start.column;\n        }\n    }\n    deleteNodeTail(node, pos) {\n        const piece = node.piece;\n        const originalLFCnt = piece.lineFeedCnt;\n        const originalEndOffset = this.offsetInBuffer(piece.bufferIndex, piece.end);\n        const newEnd = pos;\n        const newEndOffset = this.offsetInBuffer(piece.bufferIndex, newEnd);\n        const newLineFeedCnt = this.getLineFeedCnt(piece.bufferIndex, piece.start, newEnd);\n        const lf_delta = newLineFeedCnt - originalLFCnt;\n        const size_delta = newEndOffset - originalEndOffset;\n        const newLength = piece.length + size_delta;\n        node.piece = new Piece(piece.bufferIndex, piece.start, newEnd, newLineFeedCnt, newLength);\n        updateTreeMetadata(this, node, size_delta, lf_delta);\n    }\n    deleteNodeHead(node, pos) {\n        const piece = node.piece;\n        const originalLFCnt = piece.lineFeedCnt;\n        const originalStartOffset = this.offsetInBuffer(piece.bufferIndex, piece.start);\n        const newStart = pos;\n        const newLineFeedCnt = this.getLineFeedCnt(piece.bufferIndex, newStart, piece.end);\n        const newStartOffset = this.offsetInBuffer(piece.bufferIndex, newStart);\n        const lf_delta = newLineFeedCnt - originalLFCnt;\n        const size_delta = originalStartOffset - newStartOffset;\n        const newLength = piece.length + size_delta;\n        node.piece = new Piece(piece.bufferIndex, newStart, piece.end, newLineFeedCnt, newLength);\n        updateTreeMetadata(this, node, size_delta, lf_delta);\n    }\n    shrinkNode(node, start, end) {\n        const piece = node.piece;\n        const originalStartPos = piece.start;\n        const originalEndPos = piece.end;\n        // old piece, originalStartPos, start\n        const oldLength = piece.length;\n        const oldLFCnt = piece.lineFeedCnt;\n        const newEnd = start;\n        const newLineFeedCnt = this.getLineFeedCnt(piece.bufferIndex, piece.start, newEnd);\n        const newLength = this.offsetInBuffer(piece.bufferIndex, start) - this.offsetInBuffer(piece.bufferIndex, originalStartPos);\n        node.piece = new Piece(piece.bufferIndex, piece.start, newEnd, newLineFeedCnt, newLength);\n        updateTreeMetadata(this, node, newLength - oldLength, newLineFeedCnt - oldLFCnt);\n        // new right piece, end, originalEndPos\n        const newPiece = new Piece(piece.bufferIndex, end, originalEndPos, this.getLineFeedCnt(piece.bufferIndex, end, originalEndPos), this.offsetInBuffer(piece.bufferIndex, originalEndPos) - this.offsetInBuffer(piece.bufferIndex, end));\n        const newNode = this.rbInsertRight(node, newPiece);\n        this.validateCRLFWithPrevNode(newNode);\n    }\n    appendToNode(node, value) {\n        if (this.adjustCarriageReturnFromNext(value, node)) {\n            value += '\\n';\n        }\n        const hitCRLF = this.shouldCheckCRLF() && this.startWithLF(value) && this.endWithCR(node);\n        const startOffset = this._buffers[0].buffer.length;\n        this._buffers[0].buffer += value;\n        const lineStarts = createLineStartsFast(value, false);\n        for (let i = 0; i < lineStarts.length; i++) {\n            lineStarts[i] += startOffset;\n        }\n        if (hitCRLF) {\n            const prevStartOffset = this._buffers[0].lineStarts[this._buffers[0].lineStarts.length - 2];\n            this._buffers[0].lineStarts.pop();\n            // _lastChangeBufferPos is already wrong\n            this._lastChangeBufferPos = { line: this._lastChangeBufferPos.line - 1, column: startOffset - prevStartOffset };\n        }\n        this._buffers[0].lineStarts = this._buffers[0].lineStarts.concat(lineStarts.slice(1));\n        const endIndex = this._buffers[0].lineStarts.length - 1;\n        const endColumn = this._buffers[0].buffer.length - this._buffers[0].lineStarts[endIndex];\n        const newEnd = { line: endIndex, column: endColumn };\n        const newLength = node.piece.length + value.length;\n        const oldLineFeedCnt = node.piece.lineFeedCnt;\n        const newLineFeedCnt = this.getLineFeedCnt(0, node.piece.start, newEnd);\n        const lf_delta = newLineFeedCnt - oldLineFeedCnt;\n        node.piece = new Piece(node.piece.bufferIndex, node.piece.start, newEnd, newLineFeedCnt, newLength);\n        this._lastChangeBufferPos = newEnd;\n        updateTreeMetadata(this, node, value.length, lf_delta);\n    }\n    nodeAt(offset) {\n        let x = this.root;\n        const cache = this._searchCache.get(offset);\n        if (cache) {\n            return {\n                node: cache.node,\n                nodeStartOffset: cache.nodeStartOffset,\n                remainder: offset - cache.nodeStartOffset\n            };\n        }\n        let nodeStartOffset = 0;\n        while (x !== SENTINEL) {\n            if (x.size_left > offset) {\n                x = x.left;\n            }\n            else if (x.size_left + x.piece.length >= offset) {\n                nodeStartOffset += x.size_left;\n                const ret = {\n                    node: x,\n                    remainder: offset - x.size_left,\n                    nodeStartOffset\n                };\n                this._searchCache.set(ret);\n                return ret;\n            }\n            else {\n                offset -= x.size_left + x.piece.length;\n                nodeStartOffset += x.size_left + x.piece.length;\n                x = x.right;\n            }\n        }\n        return null;\n    }\n    nodeAt2(lineNumber, column) {\n        let x = this.root;\n        let nodeStartOffset = 0;\n        while (x !== SENTINEL) {\n            if (x.left !== SENTINEL && x.lf_left >= lineNumber - 1) {\n                x = x.left;\n            }\n            else if (x.lf_left + x.piece.lineFeedCnt > lineNumber - 1) {\n                const prevAccumualtedValue = this.getAccumulatedValue(x, lineNumber - x.lf_left - 2);\n                const accumulatedValue = this.getAccumulatedValue(x, lineNumber - x.lf_left - 1);\n                nodeStartOffset += x.size_left;\n                return {\n                    node: x,\n                    remainder: Math.min(prevAccumualtedValue + column - 1, accumulatedValue),\n                    nodeStartOffset\n                };\n            }\n            else if (x.lf_left + x.piece.lineFeedCnt === lineNumber - 1) {\n                const prevAccumualtedValue = this.getAccumulatedValue(x, lineNumber - x.lf_left - 2);\n                if (prevAccumualtedValue + column - 1 <= x.piece.length) {\n                    return {\n                        node: x,\n                        remainder: prevAccumualtedValue + column - 1,\n                        nodeStartOffset\n                    };\n                }\n                else {\n                    column -= x.piece.length - prevAccumualtedValue;\n                    break;\n                }\n            }\n            else {\n                lineNumber -= x.lf_left + x.piece.lineFeedCnt;\n                nodeStartOffset += x.size_left + x.piece.length;\n                x = x.right;\n            }\n        }\n        // search in order, to find the node contains position.column\n        x = x.next();\n        while (x !== SENTINEL) {\n            if (x.piece.lineFeedCnt > 0) {\n                const accumulatedValue = this.getAccumulatedValue(x, 0);\n                const nodeStartOffset = this.offsetOfNode(x);\n                return {\n                    node: x,\n                    remainder: Math.min(column - 1, accumulatedValue),\n                    nodeStartOffset\n                };\n            }\n            else {\n                if (x.piece.length >= column - 1) {\n                    const nodeStartOffset = this.offsetOfNode(x);\n                    return {\n                        node: x,\n                        remainder: column - 1,\n                        nodeStartOffset\n                    };\n                }\n                else {\n                    column -= x.piece.length;\n                }\n            }\n            x = x.next();\n        }\n        return null;\n    }\n    nodeCharCodeAt(node, offset) {\n        if (node.piece.lineFeedCnt < 1) {\n            return -1;\n        }\n        const buffer = this._buffers[node.piece.bufferIndex];\n        const newOffset = this.offsetInBuffer(node.piece.bufferIndex, node.piece.start) + offset;\n        return buffer.buffer.charCodeAt(newOffset);\n    }\n    offsetOfNode(node) {\n        if (!node) {\n            return 0;\n        }\n        let pos = node.size_left;\n        while (node !== this.root) {\n            if (node.parent.right === node) {\n                pos += node.parent.size_left + node.parent.piece.length;\n            }\n            node = node.parent;\n        }\n        return pos;\n    }\n    // #endregion\n    // #region CRLF\n    shouldCheckCRLF() {\n        return !(this._EOLNormalized && this._EOL === '\\n');\n    }\n    startWithLF(val) {\n        if (typeof val === 'string') {\n            return val.charCodeAt(0) === 10;\n        }\n        if (val === SENTINEL || val.piece.lineFeedCnt === 0) {\n            return false;\n        }\n        const piece = val.piece;\n        const lineStarts = this._buffers[piece.bufferIndex].lineStarts;\n        const line = piece.start.line;\n        const startOffset = lineStarts[line] + piece.start.column;\n        if (line === lineStarts.length - 1) {\n            // last line, so there is no line feed at the end of this line\n            return false;\n        }\n        const nextLineOffset = lineStarts[line + 1];\n        if (nextLineOffset > startOffset + 1) {\n            return false;\n        }\n        return this._buffers[piece.bufferIndex].buffer.charCodeAt(startOffset) === 10;\n    }\n    endWithCR(val) {\n        if (typeof val === 'string') {\n            return val.charCodeAt(val.length - 1) === 13;\n        }\n        if (val === SENTINEL || val.piece.lineFeedCnt === 0) {\n            return false;\n        }\n        return this.nodeCharCodeAt(val, val.piece.length - 1) === 13;\n    }\n    validateCRLFWithPrevNode(nextNode) {\n        if (this.shouldCheckCRLF() && this.startWithLF(nextNode)) {\n            const node = nextNode.prev();\n            if (this.endWithCR(node)) {\n                this.fixCRLF(node, nextNode);\n            }\n        }\n    }\n    validateCRLFWithNextNode(node) {\n        if (this.shouldCheckCRLF() && this.endWithCR(node)) {\n            const nextNode = node.next();\n            if (this.startWithLF(nextNode)) {\n                this.fixCRLF(node, nextNode);\n            }\n        }\n    }\n    fixCRLF(prev, next) {\n        const nodesToDel = [];\n        // update node\n        const lineStarts = this._buffers[prev.piece.bufferIndex].lineStarts;\n        let newEnd;\n        if (prev.piece.end.column === 0) {\n            // it means, last line ends with \\r, not \\r\\n\n            newEnd = { line: prev.piece.end.line - 1, column: lineStarts[prev.piece.end.line] - lineStarts[prev.piece.end.line - 1] - 1 };\n        }\n        else {\n            // \\r\\n\n            newEnd = { line: prev.piece.end.line, column: prev.piece.end.column - 1 };\n        }\n        const prevNewLength = prev.piece.length - 1;\n        const prevNewLFCnt = prev.piece.lineFeedCnt - 1;\n        prev.piece = new Piece(prev.piece.bufferIndex, prev.piece.start, newEnd, prevNewLFCnt, prevNewLength);\n        updateTreeMetadata(this, prev, -1, -1);\n        if (prev.piece.length === 0) {\n            nodesToDel.push(prev);\n        }\n        // update nextNode\n        const newStart = { line: next.piece.start.line + 1, column: 0 };\n        const newLength = next.piece.length - 1;\n        const newLineFeedCnt = this.getLineFeedCnt(next.piece.bufferIndex, newStart, next.piece.end);\n        next.piece = new Piece(next.piece.bufferIndex, newStart, next.piece.end, newLineFeedCnt, newLength);\n        updateTreeMetadata(this, next, -1, -1);\n        if (next.piece.length === 0) {\n            nodesToDel.push(next);\n        }\n        // create new piece which contains \\r\\n\n        const pieces = this.createNewPieces('\\r\\n');\n        this.rbInsertRight(prev, pieces[0]);\n        // delete empty nodes\n        for (let i = 0; i < nodesToDel.length; i++) {\n            rbDelete(this, nodesToDel[i]);\n        }\n    }\n    adjustCarriageReturnFromNext(value, node) {\n        if (this.shouldCheckCRLF() && this.endWithCR(value)) {\n            const nextNode = node.next();\n            if (this.startWithLF(nextNode)) {\n                // move `\\n` forward\n                value += '\\n';\n                if (nextNode.piece.length === 1) {\n                    rbDelete(this, nextNode);\n                }\n                else {\n                    const piece = nextNode.piece;\n                    const newStart = { line: piece.start.line + 1, column: 0 };\n                    const newLength = piece.length - 1;\n                    const newLineFeedCnt = this.getLineFeedCnt(piece.bufferIndex, newStart, piece.end);\n                    nextNode.piece = new Piece(piece.bufferIndex, newStart, piece.end, newLineFeedCnt, newLength);\n                    updateTreeMetadata(this, nextNode, -1, -1);\n                }\n                return true;\n            }\n        }\n        return false;\n    }\n    // #endregion\n    // #endregion\n    // #region Tree operations\n    iterate(node, callback) {\n        if (node === SENTINEL) {\n            return callback(SENTINEL);\n        }\n        const leftRet = this.iterate(node.left, callback);\n        if (!leftRet) {\n            return leftRet;\n        }\n        return callback(node) && this.iterate(node.right, callback);\n    }\n    getNodeContent(node) {\n        if (node === SENTINEL) {\n            return '';\n        }\n        const buffer = this._buffers[node.piece.bufferIndex];\n        const piece = node.piece;\n        const startOffset = this.offsetInBuffer(piece.bufferIndex, piece.start);\n        const endOffset = this.offsetInBuffer(piece.bufferIndex, piece.end);\n        const currentContent = buffer.buffer.substring(startOffset, endOffset);\n        return currentContent;\n    }\n    getPieceContent(piece) {\n        const buffer = this._buffers[piece.bufferIndex];\n        const startOffset = this.offsetInBuffer(piece.bufferIndex, piece.start);\n        const endOffset = this.offsetInBuffer(piece.bufferIndex, piece.end);\n        const currentContent = buffer.buffer.substring(startOffset, endOffset);\n        return currentContent;\n    }\n    /**\n     *      node              node\n     *     /  \\              /  \\\n     *    a   b    <----   a    b\n     *                         /\n     *                        z\n     */\n    rbInsertRight(node, p) {\n        const z = new TreeNode(p, 1 /* NodeColor.Red */);\n        z.left = SENTINEL;\n        z.right = SENTINEL;\n        z.parent = SENTINEL;\n        z.size_left = 0;\n        z.lf_left = 0;\n        const x = this.root;\n        if (x === SENTINEL) {\n            this.root = z;\n            z.color = 0 /* NodeColor.Black */;\n        }\n        else if (node.right === SENTINEL) {\n            node.right = z;\n            z.parent = node;\n        }\n        else {\n            const nextNode = leftest(node.right);\n            nextNode.left = z;\n            z.parent = nextNode;\n        }\n        fixInsert(this, z);\n        return z;\n    }\n    /**\n     *      node              node\n     *     /  \\              /  \\\n     *    a   b     ---->   a    b\n     *                       \\\n     *                        z\n     */\n    rbInsertLeft(node, p) {\n        const z = new TreeNode(p, 1 /* NodeColor.Red */);\n        z.left = SENTINEL;\n        z.right = SENTINEL;\n        z.parent = SENTINEL;\n        z.size_left = 0;\n        z.lf_left = 0;\n        if (this.root === SENTINEL) {\n            this.root = z;\n            z.color = 0 /* NodeColor.Black */;\n        }\n        else if (node.left === SENTINEL) {\n            node.left = z;\n            z.parent = node;\n        }\n        else {\n            const prevNode = righttest(node.left); // a\n            prevNode.right = z;\n            z.parent = prevNode;\n        }\n        fixInsert(this, z);\n        return z;\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 } from '../../../../base/common/event.js';\nimport * as strings from '../../../../base/common/strings.js';\nimport { Range } from '../../core/range.js';\nimport { ApplyEditsResult } from '../../model.js';\nimport { PieceTreeBase } from './pieceTreeBase.js';\nimport { countEOL } from '../../core/eolCounter.js';\nimport { TextChange } from '../../core/textChange.js';\nimport { Disposable } from '../../../../base/common/lifecycle.js';\nexport class PieceTreeTextBuffer extends Disposable {\n    constructor(chunks, BOM, eol, containsRTL, containsUnusualLineTerminators, isBasicASCII, eolNormalized) {\n        super();\n        this._onDidChangeContent = this._register(new Emitter());\n        this._BOM = BOM;\n        this._mightContainNonBasicASCII = !isBasicASCII;\n        this._mightContainRTL = containsRTL;\n        this._mightContainUnusualLineTerminators = containsUnusualLineTerminators;\n        this._pieceTree = new PieceTreeBase(chunks, eol, eolNormalized);\n    }\n    mightContainRTL() {\n        return this._mightContainRTL;\n    }\n    mightContainUnusualLineTerminators() {\n        return this._mightContainUnusualLineTerminators;\n    }\n    resetMightContainUnusualLineTerminators() {\n        this._mightContainUnusualLineTerminators = false;\n    }\n    mightContainNonBasicASCII() {\n        return this._mightContainNonBasicASCII;\n    }\n    getBOM() {\n        return this._BOM;\n    }\n    getEOL() {\n        return this._pieceTree.getEOL();\n    }\n    createSnapshot(preserveBOM) {\n        return this._pieceTree.createSnapshot(preserveBOM ? this._BOM : '');\n    }\n    getOffsetAt(lineNumber, column) {\n        return this._pieceTree.getOffsetAt(lineNumber, column);\n    }\n    getPositionAt(offset) {\n        return this._pieceTree.getPositionAt(offset);\n    }\n    getRangeAt(start, length) {\n        const end = start + length;\n        const startPosition = this.getPositionAt(start);\n        const endPosition = this.getPositionAt(end);\n        return new Range(startPosition.lineNumber, startPosition.column, endPosition.lineNumber, endPosition.column);\n    }\n    getValueInRange(range, eol = 0 /* EndOfLinePreference.TextDefined */) {\n        if (range.isEmpty()) {\n            return '';\n        }\n        const lineEnding = this._getEndOfLine(eol);\n        return this._pieceTree.getValueInRange(range, lineEnding);\n    }\n    getValueLengthInRange(range, eol = 0 /* EndOfLinePreference.TextDefined */) {\n        if (range.isEmpty()) {\n            return 0;\n        }\n        if (range.startLineNumber === range.endLineNumber) {\n            return (range.endColumn - range.startColumn);\n        }\n        const startOffset = this.getOffsetAt(range.startLineNumber, range.startColumn);\n        const endOffset = this.getOffsetAt(range.endLineNumber, range.endColumn);\n        // offsets use the text EOL, so we need to compensate for length differences\n        // if the requested EOL doesn't match the text EOL\n        let eolOffsetCompensation = 0;\n        const desiredEOL = this._getEndOfLine(eol);\n        const actualEOL = this.getEOL();\n        if (desiredEOL.length !== actualEOL.length) {\n            const delta = desiredEOL.length - actualEOL.length;\n            const eolCount = range.endLineNumber - range.startLineNumber;\n            eolOffsetCompensation = delta * eolCount;\n        }\n        return endOffset - startOffset + eolOffsetCompensation;\n    }\n    getCharacterCountInRange(range, eol = 0 /* EndOfLinePreference.TextDefined */) {\n        if (this._mightContainNonBasicASCII) {\n            // we must count by iterating\n            let result = 0;\n            const fromLineNumber = range.startLineNumber;\n            const toLineNumber = range.endLineNumber;\n            for (let lineNumber = fromLineNumber; lineNumber <= toLineNumber; lineNumber++) {\n                const lineContent = this.getLineContent(lineNumber);\n                const fromOffset = (lineNumber === fromLineNumber ? range.startColumn - 1 : 0);\n                const toOffset = (lineNumber === toLineNumber ? range.endColumn - 1 : lineContent.length);\n                for (let offset = fromOffset; offset < toOffset; offset++) {\n                    if (strings.isHighSurrogate(lineContent.charCodeAt(offset))) {\n                        result = result + 1;\n                        offset = offset + 1;\n                    }\n                    else {\n                        result = result + 1;\n                    }\n                }\n            }\n            result += this._getEndOfLine(eol).length * (toLineNumber - fromLineNumber);\n            return result;\n        }\n        return this.getValueLengthInRange(range, eol);\n    }\n    getLength() {\n        return this._pieceTree.getLength();\n    }\n    getLineCount() {\n        return this._pieceTree.getLineCount();\n    }\n    getLinesContent() {\n        return this._pieceTree.getLinesContent();\n    }\n    getLineContent(lineNumber) {\n        return this._pieceTree.getLineContent(lineNumber);\n    }\n    getLineCharCode(lineNumber, index) {\n        return this._pieceTree.getLineCharCode(lineNumber, index);\n    }\n    getLineLength(lineNumber) {\n        return this._pieceTree.getLineLength(lineNumber);\n    }\n    getLineFirstNonWhitespaceColumn(lineNumber) {\n        const result = strings.firstNonWhitespaceIndex(this.getLineContent(lineNumber));\n        if (result === -1) {\n            return 0;\n        }\n        return result + 1;\n    }\n    getLineLastNonWhitespaceColumn(lineNumber) {\n        const result = strings.lastNonWhitespaceIndex(this.getLineContent(lineNumber));\n        if (result === -1) {\n            return 0;\n        }\n        return result + 2;\n    }\n    _getEndOfLine(eol) {\n        switch (eol) {\n            case 1 /* EndOfLinePreference.LF */:\n                return '\\n';\n            case 2 /* EndOfLinePreference.CRLF */:\n                return '\\r\\n';\n            case 0 /* EndOfLinePreference.TextDefined */:\n                return this.getEOL();\n            default:\n                throw new Error('Unknown EOL preference');\n        }\n    }\n    setEOL(newEOL) {\n        this._pieceTree.setEOL(newEOL);\n    }\n    applyEdits(rawOperations, recordTrimAutoWhitespace, computeUndoEdits) {\n        let mightContainRTL = this._mightContainRTL;\n        let mightContainUnusualLineTerminators = this._mightContainUnusualLineTerminators;\n        let mightContainNonBasicASCII = this._mightContainNonBasicASCII;\n        let canReduceOperations = true;\n        let operations = [];\n        for (let i = 0; i < rawOperations.length; i++) {\n            const op = rawOperations[i];\n            if (canReduceOperations && op._isTracked) {\n                canReduceOperations = false;\n            }\n            const validatedRange = op.range;\n            if (op.text) {\n                let textMightContainNonBasicASCII = true;\n                if (!mightContainNonBasicASCII) {\n                    textMightContainNonBasicASCII = !strings.isBasicASCII(op.text);\n                    mightContainNonBasicASCII = textMightContainNonBasicASCII;\n                }\n                if (!mightContainRTL && textMightContainNonBasicASCII) {\n                    // check if the new inserted text contains RTL\n                    mightContainRTL = strings.containsRTL(op.text);\n                }\n                if (!mightContainUnusualLineTerminators && textMightContainNonBasicASCII) {\n                    // check if the new inserted text contains unusual line terminators\n                    mightContainUnusualLineTerminators = strings.containsUnusualLineTerminators(op.text);\n                }\n            }\n            let validText = '';\n            let eolCount = 0;\n            let firstLineLength = 0;\n            let lastLineLength = 0;\n            if (op.text) {\n                let strEOL;\n                [eolCount, firstLineLength, lastLineLength, strEOL] = countEOL(op.text);\n                const bufferEOL = this.getEOL();\n                const expectedStrEOL = (bufferEOL === '\\r\\n' ? 2 /* StringEOL.CRLF */ : 1 /* StringEOL.LF */);\n                if (strEOL === 0 /* StringEOL.Unknown */ || strEOL === expectedStrEOL) {\n                    validText = op.text;\n                }\n                else {\n                    validText = op.text.replace(/\\r\\n|\\r|\\n/g, bufferEOL);\n                }\n            }\n            operations[i] = {\n                sortIndex: i,\n                identifier: op.identifier || null,\n                range: validatedRange,\n                rangeOffset: this.getOffsetAt(validatedRange.startLineNumber, validatedRange.startColumn),\n                rangeLength: this.getValueLengthInRange(validatedRange),\n                text: validText,\n                eolCount: eolCount,\n                firstLineLength: firstLineLength,\n                lastLineLength: lastLineLength,\n                forceMoveMarkers: Boolean(op.forceMoveMarkers),\n                isAutoWhitespaceEdit: op.isAutoWhitespaceEdit || false\n            };\n        }\n        // Sort operations ascending\n        operations.sort(PieceTreeTextBuffer._sortOpsAscending);\n        let hasTouchingRanges = false;\n        for (let i = 0, count = operations.length - 1; i < count; i++) {\n            const rangeEnd = operations[i].range.getEndPosition();\n            const nextRangeStart = operations[i + 1].range.getStartPosition();\n            if (nextRangeStart.isBeforeOrEqual(rangeEnd)) {\n                if (nextRangeStart.isBefore(rangeEnd)) {\n                    // overlapping ranges\n                    throw new Error('Overlapping ranges are not allowed!');\n                }\n                hasTouchingRanges = true;\n            }\n        }\n        if (canReduceOperations) {\n            operations = this._reduceOperations(operations);\n        }\n        // Delta encode operations\n        const reverseRanges = (computeUndoEdits || recordTrimAutoWhitespace ? PieceTreeTextBuffer._getInverseEditRanges(operations) : []);\n        const newTrimAutoWhitespaceCandidates = [];\n        if (recordTrimAutoWhitespace) {\n            for (let i = 0; i < operations.length; i++) {\n                const op = operations[i];\n                const reverseRange = reverseRanges[i];\n                if (op.isAutoWhitespaceEdit && op.range.isEmpty()) {\n                    // Record already the future line numbers that might be auto whitespace removal candidates on next edit\n                    for (let lineNumber = reverseRange.startLineNumber; lineNumber <= reverseRange.endLineNumber; lineNumber++) {\n                        let currentLineContent = '';\n                        if (lineNumber === reverseRange.startLineNumber) {\n                            currentLineContent = this.getLineContent(op.range.startLineNumber);\n                            if (strings.firstNonWhitespaceIndex(currentLineContent) !== -1) {\n                                continue;\n                            }\n                        }\n                        newTrimAutoWhitespaceCandidates.push({ lineNumber: lineNumber, oldContent: currentLineContent });\n                    }\n                }\n            }\n        }\n        let reverseOperations = null;\n        if (computeUndoEdits) {\n            let reverseRangeDeltaOffset = 0;\n            reverseOperations = [];\n            for (let i = 0; i < operations.length; i++) {\n                const op = operations[i];\n                const reverseRange = reverseRanges[i];\n                const bufferText = this.getValueInRange(op.range);\n                const reverseRangeOffset = op.rangeOffset + reverseRangeDeltaOffset;\n                reverseRangeDeltaOffset += (op.text.length - bufferText.length);\n                reverseOperations[i] = {\n                    sortIndex: op.sortIndex,\n                    identifier: op.identifier,\n                    range: reverseRange,\n                    text: bufferText,\n                    textChange: new TextChange(op.rangeOffset, bufferText, reverseRangeOffset, op.text)\n                };\n            }\n            // Can only sort reverse operations when the order is not significant\n            if (!hasTouchingRanges) {\n                reverseOperations.sort((a, b) => a.sortIndex - b.sortIndex);\n            }\n        }\n        this._mightContainRTL = mightContainRTL;\n        this._mightContainUnusualLineTerminators = mightContainUnusualLineTerminators;\n        this._mightContainNonBasicASCII = mightContainNonBasicASCII;\n        const contentChanges = this._doApplyEdits(operations);\n        let trimAutoWhitespaceLineNumbers = null;\n        if (recordTrimAutoWhitespace && newTrimAutoWhitespaceCandidates.length > 0) {\n            // sort line numbers auto whitespace removal candidates for next edit descending\n            newTrimAutoWhitespaceCandidates.sort((a, b) => b.lineNumber - a.lineNumber);\n            trimAutoWhitespaceLineNumbers = [];\n            for (let i = 0, len = newTrimAutoWhitespaceCandidates.length; i < len; i++) {\n                const lineNumber = newTrimAutoWhitespaceCandidates[i].lineNumber;\n                if (i > 0 && newTrimAutoWhitespaceCandidates[i - 1].lineNumber === lineNumber) {\n                    // Do not have the same line number twice\n                    continue;\n                }\n                const prevContent = newTrimAutoWhitespaceCandidates[i].oldContent;\n                const lineContent = this.getLineContent(lineNumber);\n                if (lineContent.length === 0 || lineContent === prevContent || strings.firstNonWhitespaceIndex(lineContent) !== -1) {\n                    continue;\n                }\n                trimAutoWhitespaceLineNumbers.push(lineNumber);\n            }\n        }\n        this._onDidChangeContent.fire();\n        return new ApplyEditsResult(reverseOperations, contentChanges, trimAutoWhitespaceLineNumbers);\n    }\n    /**\n     * Transform operations such that they represent the same logic edit,\n     * but that they also do not cause OOM crashes.\n     */\n    _reduceOperations(operations) {\n        if (operations.length < 1000) {\n            // We know from empirical testing that a thousand edits work fine regardless of their shape.\n            return operations;\n        }\n        // At one point, due to how events are emitted and how each operation is handled,\n        // some operations can trigger a high amount of temporary string allocations,\n        // that will immediately get edited again.\n        // e.g. a formatter inserting ridiculous ammounts of \\n on a model with a single line\n        // Therefore, the strategy is to collapse all the operations into a huge single edit operation\n        return [this._toSingleEditOperation(operations)];\n    }\n    _toSingleEditOperation(operations) {\n        let forceMoveMarkers = false;\n        const firstEditRange = operations[0].range;\n        const lastEditRange = operations[operations.length - 1].range;\n        const entireEditRange = new Range(firstEditRange.startLineNumber, firstEditRange.startColumn, lastEditRange.endLineNumber, lastEditRange.endColumn);\n        let lastEndLineNumber = firstEditRange.startLineNumber;\n        let lastEndColumn = firstEditRange.startColumn;\n        const result = [];\n        for (let i = 0, len = operations.length; i < len; i++) {\n            const operation = operations[i];\n            const range = operation.range;\n            forceMoveMarkers = forceMoveMarkers || operation.forceMoveMarkers;\n            // (1) -- Push old text\n            result.push(this.getValueInRange(new Range(lastEndLineNumber, lastEndColumn, range.startLineNumber, range.startColumn)));\n            // (2) -- Push new text\n            if (operation.text.length > 0) {\n                result.push(operation.text);\n            }\n            lastEndLineNumber = range.endLineNumber;\n            lastEndColumn = range.endColumn;\n        }\n        const text = result.join('');\n        const [eolCount, firstLineLength, lastLineLength] = countEOL(text);\n        return {\n            sortIndex: 0,\n            identifier: operations[0].identifier,\n            range: entireEditRange,\n            rangeOffset: this.getOffsetAt(entireEditRange.startLineNumber, entireEditRange.startColumn),\n            rangeLength: this.getValueLengthInRange(entireEditRange, 0 /* EndOfLinePreference.TextDefined */),\n            text: text,\n            eolCount: eolCount,\n            firstLineLength: firstLineLength,\n            lastLineLength: lastLineLength,\n            forceMoveMarkers: forceMoveMarkers,\n            isAutoWhitespaceEdit: false\n        };\n    }\n    _doApplyEdits(operations) {\n        operations.sort(PieceTreeTextBuffer._sortOpsDescending);\n        const contentChanges = [];\n        // operations are from bottom to top\n        for (let i = 0; i < operations.length; i++) {\n            const op = operations[i];\n            const startLineNumber = op.range.startLineNumber;\n            const startColumn = op.range.startColumn;\n            const endLineNumber = op.range.endLineNumber;\n            const endColumn = op.range.endColumn;\n            if (startLineNumber === endLineNumber && startColumn === endColumn && op.text.length === 0) {\n                // no-op\n                continue;\n            }\n            if (op.text) {\n                // replacement\n                this._pieceTree.delete(op.rangeOffset, op.rangeLength);\n                this._pieceTree.insert(op.rangeOffset, op.text, true);\n            }\n            else {\n                // deletion\n                this._pieceTree.delete(op.rangeOffset, op.rangeLength);\n            }\n            const contentChangeRange = new Range(startLineNumber, startColumn, endLineNumber, endColumn);\n            contentChanges.push({\n                range: contentChangeRange,\n                rangeLength: op.rangeLength,\n                text: op.text,\n                rangeOffset: op.rangeOffset,\n                forceMoveMarkers: op.forceMoveMarkers\n            });\n        }\n        return contentChanges;\n    }\n    findMatchesLineByLine(searchRange, searchData, captureMatches, limitResultCount) {\n        return this._pieceTree.findMatchesLineByLine(searchRange, searchData, captureMatches, limitResultCount);\n    }\n    /**\n     * Assumes `operations` are validated and sorted ascending\n     */\n    static _getInverseEditRanges(operations) {\n        const result = [];\n        let prevOpEndLineNumber = 0;\n        let prevOpEndColumn = 0;\n        let prevOp = null;\n        for (let i = 0, len = operations.length; i < len; i++) {\n            const op = operations[i];\n            let startLineNumber;\n            let startColumn;\n            if (prevOp) {\n                if (prevOp.range.endLineNumber === op.range.startLineNumber) {\n                    startLineNumber = prevOpEndLineNumber;\n                    startColumn = prevOpEndColumn + (op.range.startColumn - prevOp.range.endColumn);\n                }\n                else {\n                    startLineNumber = prevOpEndLineNumber + (op.range.startLineNumber - prevOp.range.endLineNumber);\n                    startColumn = op.range.startColumn;\n                }\n            }\n            else {\n                startLineNumber = op.range.startLineNumber;\n                startColumn = op.range.startColumn;\n            }\n            let resultRange;\n            if (op.text.length > 0) {\n                // the operation inserts something\n                const lineCount = op.eolCount + 1;\n                if (lineCount === 1) {\n                    // single line insert\n                    resultRange = new Range(startLineNumber, startColumn, startLineNumber, startColumn + op.firstLineLength);\n                }\n                else {\n                    // multi line insert\n                    resultRange = new Range(startLineNumber, startColumn, startLineNumber + lineCount - 1, op.lastLineLength + 1);\n                }\n            }\n            else {\n                // There is nothing to insert\n                resultRange = new Range(startLineNumber, startColumn, startLineNumber, startColumn);\n            }\n            prevOpEndLineNumber = resultRange.endLineNumber;\n            prevOpEndColumn = resultRange.endColumn;\n            result.push(resultRange);\n            prevOp = op;\n        }\n        return result;\n    }\n    static _sortOpsAscending(a, b) {\n        const r = Range.compareRangesUsingEnds(a.range, b.range);\n        if (r === 0) {\n            return a.sortIndex - b.sortIndex;\n        }\n        return r;\n    }\n    static _sortOpsDescending(a, b) {\n        const r = Range.compareRangesUsingEnds(a.range, b.range);\n        if (r === 0) {\n            return b.sortIndex - a.sortIndex;\n        }\n        return -r;\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 * as strings from '../../../../base/common/strings.js';\nimport { StringBuffer, createLineStarts, createLineStartsFast } from './pieceTreeBase.js';\nimport { PieceTreeTextBuffer } from './pieceTreeTextBuffer.js';\nclass PieceTreeTextBufferFactory {\n    constructor(_chunks, _bom, _cr, _lf, _crlf, _containsRTL, _containsUnusualLineTerminators, _isBasicASCII, _normalizeEOL) {\n        this._chunks = _chunks;\n        this._bom = _bom;\n        this._cr = _cr;\n        this._lf = _lf;\n        this._crlf = _crlf;\n        this._containsRTL = _containsRTL;\n        this._containsUnusualLineTerminators = _containsUnusualLineTerminators;\n        this._isBasicASCII = _isBasicASCII;\n        this._normalizeEOL = _normalizeEOL;\n    }\n    _getEOL(defaultEOL) {\n        const totalEOLCount = this._cr + this._lf + this._crlf;\n        const totalCRCount = this._cr + this._crlf;\n        if (totalEOLCount === 0) {\n            // This is an empty file or a file with precisely one line\n            return (defaultEOL === 1 /* DefaultEndOfLine.LF */ ? '\\n' : '\\r\\n');\n        }\n        if (totalCRCount > totalEOLCount / 2) {\n            // More than half of the file contains \\r\\n ending lines\n            return '\\r\\n';\n        }\n        // At least one line more ends in \\n\n        return '\\n';\n    }\n    create(defaultEOL) {\n        const eol = this._getEOL(defaultEOL);\n        const chunks = this._chunks;\n        if (this._normalizeEOL &&\n            ((eol === '\\r\\n' && (this._cr > 0 || this._lf > 0))\n                || (eol === '\\n' && (this._cr > 0 || this._crlf > 0)))) {\n            // Normalize pieces\n            for (let i = 0, len = chunks.length; i < len; i++) {\n                const str = chunks[i].buffer.replace(/\\r\\n|\\r|\\n/g, eol);\n                const newLineStart = createLineStartsFast(str);\n                chunks[i] = new StringBuffer(str, newLineStart);\n            }\n        }\n        const textBuffer = new PieceTreeTextBuffer(chunks, this._bom, eol, this._containsRTL, this._containsUnusualLineTerminators, this._isBasicASCII, this._normalizeEOL);\n        return { textBuffer: textBuffer, disposable: textBuffer };\n    }\n}\nexport class PieceTreeTextBufferBuilder {\n    constructor() {\n        this.chunks = [];\n        this.BOM = '';\n        this._hasPreviousChar = false;\n        this._previousChar = 0;\n        this._tmpLineStarts = [];\n        this.cr = 0;\n        this.lf = 0;\n        this.crlf = 0;\n        this.containsRTL = false;\n        this.containsUnusualLineTerminators = false;\n        this.isBasicASCII = true;\n    }\n    acceptChunk(chunk) {\n        if (chunk.length === 0) {\n            return;\n        }\n        if (this.chunks.length === 0) {\n            if (strings.startsWithUTF8BOM(chunk)) {\n                this.BOM = strings.UTF8_BOM_CHARACTER;\n                chunk = chunk.substr(1);\n            }\n        }\n        const lastChar = chunk.charCodeAt(chunk.length - 1);\n        if (lastChar === 13 /* CharCode.CarriageReturn */ || (lastChar >= 0xD800 && lastChar <= 0xDBFF)) {\n            // last character is \\r or a high surrogate => keep it back\n            this._acceptChunk1(chunk.substr(0, chunk.length - 1), false);\n            this._hasPreviousChar = true;\n            this._previousChar = lastChar;\n        }\n        else {\n            this._acceptChunk1(chunk, false);\n            this._hasPreviousChar = false;\n            this._previousChar = lastChar;\n        }\n    }\n    _acceptChunk1(chunk, allowEmptyStrings) {\n        if (!allowEmptyStrings && chunk.length === 0) {\n            // Nothing to do\n            return;\n        }\n        if (this._hasPreviousChar) {\n            this._acceptChunk2(String.fromCharCode(this._previousChar) + chunk);\n        }\n        else {\n            this._acceptChunk2(chunk);\n        }\n    }\n    _acceptChunk2(chunk) {\n        const lineStarts = createLineStarts(this._tmpLineStarts, chunk);\n        this.chunks.push(new StringBuffer(chunk, lineStarts.lineStarts));\n        this.cr += lineStarts.cr;\n        this.lf += lineStarts.lf;\n        this.crlf += lineStarts.crlf;\n        if (!lineStarts.isBasicASCII) {\n            // this chunk contains non basic ASCII characters\n            this.isBasicASCII = false;\n            if (!this.containsRTL) {\n                this.containsRTL = strings.containsRTL(chunk);\n            }\n            if (!this.containsUnusualLineTerminators) {\n                this.containsUnusualLineTerminators = strings.containsUnusualLineTerminators(chunk);\n            }\n        }\n    }\n    finish(normalizeEOL = true) {\n        this._finish();\n        return new PieceTreeTextBufferFactory(this.chunks, this.BOM, this.cr, this.lf, this.crlf, this.containsRTL, this.containsUnusualLineTerminators, this.isBasicASCII, normalizeEOL);\n    }\n    _finish() {\n        if (this.chunks.length === 0) {\n            this._acceptChunk1('', true);\n        }\n        if (this._hasPreviousChar) {\n            this._hasPreviousChar = false;\n            // recreate last chunk\n            const lastChunk = this.chunks[this.chunks.length - 1];\n            lastChunk.buffer += String.fromCharCode(this._previousChar);\n            const newLineStarts = createLineStartsFast(lastChunk.buffer);\n            lastChunk.lineStarts = newLineStarts;\n            if (this._previousChar === 13 /* CharCode.CarriageReturn */) {\n                this.cr++;\n            }\n        }\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 *--------------------------------------------------------------------------------------------*/\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\n    return function (target, key) { decorator(target, key, paramIndex); }\n};\nvar TextModel_1;\nimport { ArrayQueue, pushMany } from '../../../base/common/arrays.js';\nimport { Color } from '../../../base/common/color.js';\nimport { BugIndicatingError, illegalArgument, onUnexpectedError } from '../../../base/common/errors.js';\nimport { Emitter } from '../../../base/common/event.js';\nimport { Disposable, MutableDisposable, combinedDisposable } from '../../../base/common/lifecycle.js';\nimport * as strings from '../../../base/common/strings.js';\nimport { URI } from '../../../base/common/uri.js';\nimport { countEOL } from '../core/eolCounter.js';\nimport { normalizeIndentation } from '../core/indentation.js';\nimport { LineRange } from '../core/lineRange.js';\nimport { Position } from '../core/position.js';\nimport { Range } from '../core/range.js';\nimport { Selection } from '../core/selection.js';\nimport { EDITOR_MODEL_DEFAULTS } from '../core/textModelDefaults.js';\nimport { ILanguageService } from '../languages/language.js';\nimport { ILanguageConfigurationService } from '../languages/languageConfigurationRegistry.js';\nimport * as model from '../model.js';\nimport { BracketPairsTextModelPart } from './bracketPairsTextModelPart/bracketPairsImpl.js';\nimport { ColorizedBracketPairsDecorationProvider } from './bracketPairsTextModelPart/colorizedBracketPairsDecorationProvider.js';\nimport { EditStack } from './editStack.js';\nimport { GuidesTextModelPart } from './guidesTextModelPart.js';\nimport { guessIndentation } from './indentationGuesser.js';\nimport { IntervalNode, IntervalTree, recomputeMaxEnd } from './intervalTree.js';\nimport { PieceTreeTextBuffer } from './pieceTreeTextBuffer/pieceTreeTextBuffer.js';\nimport { PieceTreeTextBufferBuilder } from './pieceTreeTextBuffer/pieceTreeTextBufferBuilder.js';\nimport { SearchParams, TextModelSearch } from './textModelSearch.js';\nimport { TokenizationTextModelPart } from './tokenizationTextModelPart.js';\nimport { InternalModelContentChangeEvent, LineInjectedText, ModelInjectedTextChangedEvent, ModelRawContentChangedEvent, ModelRawEOLChanged, ModelRawFlush, ModelRawLineChanged, ModelRawLinesDeleted, ModelRawLinesInserted } from '../textModelEvents.js';\nimport { IUndoRedoService } from '../../../platform/undoRedo/common/undoRedo.js';\nexport function createTextBufferFactory(text) {\n    const builder = new PieceTreeTextBufferBuilder();\n    builder.acceptChunk(text);\n    return builder.finish();\n}\nexport function createTextBufferFactoryFromSnapshot(snapshot) {\n    const builder = new PieceTreeTextBufferBuilder();\n    let chunk;\n    while (typeof (chunk = snapshot.read()) === 'string') {\n        builder.acceptChunk(chunk);\n    }\n    return builder.finish();\n}\nexport function createTextBuffer(value, defaultEOL) {\n    let factory;\n    if (typeof value === 'string') {\n        factory = createTextBufferFactory(value);\n    }\n    else if (model.isITextSnapshot(value)) {\n        factory = createTextBufferFactoryFromSnapshot(value);\n    }\n    else {\n        factory = value;\n    }\n    return factory.create(defaultEOL);\n}\nlet MODEL_ID = 0;\nconst LIMIT_FIND_COUNT = 999;\nconst LONG_LINE_BOUNDARY = 10000;\nclass TextModelSnapshot {\n    constructor(source) {\n        this._source = source;\n        this._eos = false;\n    }\n    read() {\n        if (this._eos) {\n            return null;\n        }\n        const result = [];\n        let resultCnt = 0;\n        let resultLength = 0;\n        do {\n            const tmp = this._source.read();\n            if (tmp === null) {\n                // end-of-stream\n                this._eos = true;\n                if (resultCnt === 0) {\n                    return null;\n                }\n                else {\n                    return result.join('');\n                }\n            }\n            if (tmp.length > 0) {\n                result[resultCnt++] = tmp;\n                resultLength += tmp.length;\n            }\n            if (resultLength >= 64 * 1024) {\n                return result.join('');\n            }\n        } while (true);\n    }\n}\nconst invalidFunc = () => { throw new Error(`Invalid change accessor`); };\nlet TextModel = TextModel_1 = class TextModel extends Disposable {\n    static resolveOptions(textBuffer, options) {\n        if (options.detectIndentation) {\n            const guessedIndentation = guessIndentation(textBuffer, options.tabSize, options.insertSpaces);\n            return new model.TextModelResolvedOptions({\n                tabSize: guessedIndentation.tabSize,\n                indentSize: 'tabSize', // TODO@Alex: guess indentSize independent of tabSize\n                insertSpaces: guessedIndentation.insertSpaces,\n                trimAutoWhitespace: options.trimAutoWhitespace,\n                defaultEOL: options.defaultEOL,\n                bracketPairColorizationOptions: options.bracketPairColorizationOptions,\n            });\n        }\n        return new model.TextModelResolvedOptions(options);\n    }\n    get onDidChangeLanguage() { return this._tokenizationTextModelPart.onDidChangeLanguage; }\n    get onDidChangeLanguageConfiguration() { return this._tokenizationTextModelPart.onDidChangeLanguageConfiguration; }\n    get onDidChangeTokens() { return this._tokenizationTextModelPart.onDidChangeTokens; }\n    onDidChangeContent(listener) {\n        return this._eventEmitter.slowEvent((e) => listener(e.contentChangedEvent));\n    }\n    onDidChangeContentOrInjectedText(listener) {\n        return combinedDisposable(this._eventEmitter.fastEvent(e => listener(e)), this._onDidChangeInjectedText.event(e => listener(e)));\n    }\n    _isDisposing() { return this.__isDisposing; }\n    get tokenization() { return this._tokenizationTextModelPart; }\n    get bracketPairs() { return this._bracketPairs; }\n    get guides() { return this._guidesTextModelPart; }\n    constructor(source, languageIdOrSelection, creationOptions, associatedResource = null, _undoRedoService, _languageService, _languageConfigurationService) {\n        super();\n        this._undoRedoService = _undoRedoService;\n        this._languageService = _languageService;\n        this._languageConfigurationService = _languageConfigurationService;\n        //#region Events\n        this._onWillDispose = this._register(new Emitter());\n        this.onWillDispose = this._onWillDispose.event;\n        this._onDidChangeDecorations = this._register(new DidChangeDecorationsEmitter(affectedInjectedTextLines => this.handleBeforeFireDecorationsChangedEvent(affectedInjectedTextLines)));\n        this.onDidChangeDecorations = this._onDidChangeDecorations.event;\n        this._onDidChangeOptions = this._register(new Emitter());\n        this.onDidChangeOptions = this._onDidChangeOptions.event;\n        this._onDidChangeAttached = this._register(new Emitter());\n        this.onDidChangeAttached = this._onDidChangeAttached.event;\n        this._onDidChangeInjectedText = this._register(new Emitter());\n        this._eventEmitter = this._register(new DidChangeContentEmitter());\n        this._languageSelectionListener = this._register(new MutableDisposable());\n        this._deltaDecorationCallCnt = 0;\n        this._attachedViews = new AttachedViews();\n        // Generate a new unique model id\n        MODEL_ID++;\n        this.id = '$model' + MODEL_ID;\n        this.isForSimpleWidget = creationOptions.isForSimpleWidget;\n        if (typeof associatedResource === 'undefined' || associatedResource === null) {\n            this._associatedResource = URI.parse('inmemory://model/' + MODEL_ID);\n        }\n        else {\n            this._associatedResource = associatedResource;\n        }\n        this._attachedEditorCount = 0;\n        const { textBuffer, disposable } = createTextBuffer(source, creationOptions.defaultEOL);\n        this._buffer = textBuffer;\n        this._bufferDisposable = disposable;\n        this._options = TextModel_1.resolveOptions(this._buffer, creationOptions);\n        const languageId = (typeof languageIdOrSelection === 'string' ? languageIdOrSelection : languageIdOrSelection.languageId);\n        if (typeof languageIdOrSelection !== 'string') {\n            this._languageSelectionListener.value = languageIdOrSelection.onDidChange(() => this._setLanguage(languageIdOrSelection.languageId));\n        }\n        this._bracketPairs = this._register(new BracketPairsTextModelPart(this, this._languageConfigurationService));\n        this._guidesTextModelPart = this._register(new GuidesTextModelPart(this, this._languageConfigurationService));\n        this._decorationProvider = this._register(new ColorizedBracketPairsDecorationProvider(this));\n        this._tokenizationTextModelPart = new TokenizationTextModelPart(this._languageService, this._languageConfigurationService, this, this._bracketPairs, languageId, this._attachedViews);\n        const bufferLineCount = this._buffer.getLineCount();\n        const bufferTextLength = this._buffer.getValueLengthInRange(new Range(1, 1, bufferLineCount, this._buffer.getLineLength(bufferLineCount) + 1), 0 /* model.EndOfLinePreference.TextDefined */);\n        // !!! Make a decision in the ctor and permanently respect this decision !!!\n        // If a model is too large at construction time, it will never get tokenized,\n        // under no circumstances.\n        if (creationOptions.largeFileOptimizations) {\n            this._isTooLargeForTokenization = ((bufferTextLength > TextModel_1.LARGE_FILE_SIZE_THRESHOLD)\n                || (bufferLineCount > TextModel_1.LARGE_FILE_LINE_COUNT_THRESHOLD));\n            this._isTooLargeForHeapOperation = bufferTextLength > TextModel_1.LARGE_FILE_HEAP_OPERATION_THRESHOLD;\n        }\n        else {\n            this._isTooLargeForTokenization = false;\n            this._isTooLargeForHeapOperation = false;\n        }\n        this._isTooLargeForSyncing = (bufferTextLength > TextModel_1._MODEL_SYNC_LIMIT);\n        this._versionId = 1;\n        this._alternativeVersionId = 1;\n        this._initialUndoRedoSnapshot = null;\n        this._isDisposed = false;\n        this.__isDisposing = false;\n        this._instanceId = strings.singleLetterHash(MODEL_ID);\n        this._lastDecorationId = 0;\n        this._decorations = Object.create(null);\n        this._decorationsTree = new DecorationsTrees();\n        this._commandManager = new EditStack(this, this._undoRedoService);\n        this._isUndoing = false;\n        this._isRedoing = false;\n        this._trimAutoWhitespaceLines = null;\n        this._register(this._decorationProvider.onDidChange(() => {\n            this._onDidChangeDecorations.beginDeferredEmit();\n            this._onDidChangeDecorations.fire();\n            this._onDidChangeDecorations.endDeferredEmit();\n        }));\n        this._languageService.requestRichLanguageFeatures(languageId);\n    }\n    dispose() {\n        this.__isDisposing = true;\n        this._onWillDispose.fire();\n        this._tokenizationTextModelPart.dispose();\n        this._isDisposed = true;\n        super.dispose();\n        this._bufferDisposable.dispose();\n        this.__isDisposing = false;\n        // Manually release reference to previous text buffer to avoid large leaks\n        // in case someone leaks a TextModel reference\n        const emptyDisposedTextBuffer = new PieceTreeTextBuffer([], '', '\\n', false, false, true, true);\n        emptyDisposedTextBuffer.dispose();\n        this._buffer = emptyDisposedTextBuffer;\n        this._bufferDisposable = Disposable.None;\n    }\n    _assertNotDisposed() {\n        if (this._isDisposed) {\n            throw new Error('Model is disposed!');\n        }\n    }\n    _emitContentChangedEvent(rawChange, change) {\n        if (this.__isDisposing) {\n            // Do not confuse listeners by emitting any event after disposing\n            return;\n        }\n        this._tokenizationTextModelPart.handleDidChangeContent(change);\n        this._bracketPairs.handleDidChangeContent(change);\n        this._eventEmitter.fire(new InternalModelContentChangeEvent(rawChange, change));\n    }\n    setValue(value) {\n        this._assertNotDisposed();\n        if (value === null || value === undefined) {\n            throw illegalArgument();\n        }\n        const { textBuffer, disposable } = createTextBuffer(value, this._options.defaultEOL);\n        this._setValueFromTextBuffer(textBuffer, disposable);\n    }\n    _createContentChanged2(range, rangeOffset, rangeLength, text, isUndoing, isRedoing, isFlush, isEolChange) {\n        return {\n            changes: [{\n                    range: range,\n                    rangeOffset: rangeOffset,\n                    rangeLength: rangeLength,\n                    text: text,\n                }],\n            eol: this._buffer.getEOL(),\n            isEolChange: isEolChange,\n            versionId: this.getVersionId(),\n            isUndoing: isUndoing,\n            isRedoing: isRedoing,\n            isFlush: isFlush\n        };\n    }\n    _setValueFromTextBuffer(textBuffer, textBufferDisposable) {\n        this._assertNotDisposed();\n        const oldFullModelRange = this.getFullModelRange();\n        const oldModelValueLength = this.getValueLengthInRange(oldFullModelRange);\n        const endLineNumber = this.getLineCount();\n        const endColumn = this.getLineMaxColumn(endLineNumber);\n        this._buffer = textBuffer;\n        this._bufferDisposable.dispose();\n        this._bufferDisposable = textBufferDisposable;\n        this._increaseVersionId();\n        // Destroy all my decorations\n        this._decorations = Object.create(null);\n        this._decorationsTree = new DecorationsTrees();\n        // Destroy my edit history and settings\n        this._commandManager.clear();\n        this._trimAutoWhitespaceLines = null;\n        this._emitContentChangedEvent(new ModelRawContentChangedEvent([\n            new ModelRawFlush()\n        ], this._versionId, false, false), this._createContentChanged2(new Range(1, 1, endLineNumber, endColumn), 0, oldModelValueLength, this.getValue(), false, false, true, false));\n    }\n    setEOL(eol) {\n        this._assertNotDisposed();\n        const newEOL = (eol === 1 /* model.EndOfLineSequence.CRLF */ ? '\\r\\n' : '\\n');\n        if (this._buffer.getEOL() === newEOL) {\n            // Nothing to do\n            return;\n        }\n        const oldFullModelRange = this.getFullModelRange();\n        const oldModelValueLength = this.getValueLengthInRange(oldFullModelRange);\n        const endLineNumber = this.getLineCount();\n        const endColumn = this.getLineMaxColumn(endLineNumber);\n        this._onBeforeEOLChange();\n        this._buffer.setEOL(newEOL);\n        this._increaseVersionId();\n        this._onAfterEOLChange();\n        this._emitContentChangedEvent(new ModelRawContentChangedEvent([\n            new ModelRawEOLChanged()\n        ], this._versionId, false, false), this._createContentChanged2(new Range(1, 1, endLineNumber, endColumn), 0, oldModelValueLength, this.getValue(), false, false, false, true));\n    }\n    _onBeforeEOLChange() {\n        // Ensure all decorations get their `range` set.\n        this._decorationsTree.ensureAllNodesHaveRanges(this);\n    }\n    _onAfterEOLChange() {\n        // Transform back `range` to offsets\n        const versionId = this.getVersionId();\n        const allDecorations = this._decorationsTree.collectNodesPostOrder();\n        for (let i = 0, len = allDecorations.length; i < len; i++) {\n            const node = allDecorations[i];\n            const range = node.range; // the range is defined due to `_onBeforeEOLChange`\n            const delta = node.cachedAbsoluteStart - node.start;\n            const startOffset = this._buffer.getOffsetAt(range.startLineNumber, range.startColumn);\n            const endOffset = this._buffer.getOffsetAt(range.endLineNumber, range.endColumn);\n            node.cachedAbsoluteStart = startOffset;\n            node.cachedAbsoluteEnd = endOffset;\n            node.cachedVersionId = versionId;\n            node.start = startOffset - delta;\n            node.end = endOffset - delta;\n            recomputeMaxEnd(node);\n        }\n    }\n    onBeforeAttached() {\n        this._attachedEditorCount++;\n        if (this._attachedEditorCount === 1) {\n            this._tokenizationTextModelPart.handleDidChangeAttached();\n            this._onDidChangeAttached.fire(undefined);\n        }\n        return this._attachedViews.attachView();\n    }\n    onBeforeDetached(view) {\n        this._attachedEditorCount--;\n        if (this._attachedEditorCount === 0) {\n            this._tokenizationTextModelPart.handleDidChangeAttached();\n            this._onDidChangeAttached.fire(undefined);\n        }\n        this._attachedViews.detachView(view);\n    }\n    isAttachedToEditor() {\n        return this._attachedEditorCount > 0;\n    }\n    getAttachedEditorCount() {\n        return this._attachedEditorCount;\n    }\n    isTooLargeForSyncing() {\n        return this._isTooLargeForSyncing;\n    }\n    isTooLargeForTokenization() {\n        return this._isTooLargeForTokenization;\n    }\n    isTooLargeForHeapOperation() {\n        return this._isTooLargeForHeapOperation;\n    }\n    isDisposed() {\n        return this._isDisposed;\n    }\n    isDominatedByLongLines() {\n        this._assertNotDisposed();\n        if (this.isTooLargeForTokenization()) {\n            // Cannot word wrap huge files anyways, so it doesn't really matter\n            return false;\n        }\n        let smallLineCharCount = 0;\n        let longLineCharCount = 0;\n        const lineCount = this._buffer.getLineCount();\n        for (let lineNumber = 1; lineNumber <= lineCount; lineNumber++) {\n            const lineLength = this._buffer.getLineLength(lineNumber);\n            if (lineLength >= LONG_LINE_BOUNDARY) {\n                longLineCharCount += lineLength;\n            }\n            else {\n                smallLineCharCount += lineLength;\n            }\n        }\n        return (longLineCharCount > smallLineCharCount);\n    }\n    get uri() {\n        return this._associatedResource;\n    }\n    //#region Options\n    getOptions() {\n        this._assertNotDisposed();\n        return this._options;\n    }\n    getFormattingOptions() {\n        return {\n            tabSize: this._options.indentSize,\n            insertSpaces: this._options.insertSpaces\n        };\n    }\n    updateOptions(_newOpts) {\n        this._assertNotDisposed();\n        const tabSize = (typeof _newOpts.tabSize !== 'undefined') ? _newOpts.tabSize : this._options.tabSize;\n        const indentSize = (typeof _newOpts.indentSize !== 'undefined') ? _newOpts.indentSize : this._options.originalIndentSize;\n        const insertSpaces = (typeof _newOpts.insertSpaces !== 'undefined') ? _newOpts.insertSpaces : this._options.insertSpaces;\n        const trimAutoWhitespace = (typeof _newOpts.trimAutoWhitespace !== 'undefined') ? _newOpts.trimAutoWhitespace : this._options.trimAutoWhitespace;\n        const bracketPairColorizationOptions = (typeof _newOpts.bracketColorizationOptions !== 'undefined') ? _newOpts.bracketColorizationOptions : this._options.bracketPairColorizationOptions;\n        const newOpts = new model.TextModelResolvedOptions({\n            tabSize: tabSize,\n            indentSize: indentSize,\n            insertSpaces: insertSpaces,\n            defaultEOL: this._options.defaultEOL,\n            trimAutoWhitespace: trimAutoWhitespace,\n            bracketPairColorizationOptions,\n        });\n        if (this._options.equals(newOpts)) {\n            return;\n        }\n        const e = this._options.createChangeEvent(newOpts);\n        this._options = newOpts;\n        this._bracketPairs.handleDidChangeOptions(e);\n        this._decorationProvider.handleDidChangeOptions(e);\n        this._onDidChangeOptions.fire(e);\n    }\n    detectIndentation(defaultInsertSpaces, defaultTabSize) {\n        this._assertNotDisposed();\n        const guessedIndentation = guessIndentation(this._buffer, defaultTabSize, defaultInsertSpaces);\n        this.updateOptions({\n            insertSpaces: guessedIndentation.insertSpaces,\n            tabSize: guessedIndentation.tabSize,\n            indentSize: guessedIndentation.tabSize, // TODO@Alex: guess indentSize independent of tabSize\n        });\n    }\n    normalizeIndentation(str) {\n        this._assertNotDisposed();\n        return normalizeIndentation(str, this._options.indentSize, this._options.insertSpaces);\n    }\n    //#endregion\n    //#region Reading\n    getVersionId() {\n        this._assertNotDisposed();\n        return this._versionId;\n    }\n    mightContainRTL() {\n        return this._buffer.mightContainRTL();\n    }\n    mightContainUnusualLineTerminators() {\n        return this._buffer.mightContainUnusualLineTerminators();\n    }\n    removeUnusualLineTerminators(selections = null) {\n        const matches = this.findMatches(strings.UNUSUAL_LINE_TERMINATORS.source, false, true, false, null, false, 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */);\n        this._buffer.resetMightContainUnusualLineTerminators();\n        this.pushEditOperations(selections, matches.map(m => ({ range: m.range, text: null })), () => null);\n    }\n    mightContainNonBasicASCII() {\n        return this._buffer.mightContainNonBasicASCII();\n    }\n    getAlternativeVersionId() {\n        this._assertNotDisposed();\n        return this._alternativeVersionId;\n    }\n    getInitialUndoRedoSnapshot() {\n        this._assertNotDisposed();\n        return this._initialUndoRedoSnapshot;\n    }\n    getOffsetAt(rawPosition) {\n        this._assertNotDisposed();\n        const position = this._validatePosition(rawPosition.lineNumber, rawPosition.column, 0 /* StringOffsetValidationType.Relaxed */);\n        return this._buffer.getOffsetAt(position.lineNumber, position.column);\n    }\n    getPositionAt(rawOffset) {\n        this._assertNotDisposed();\n        const offset = (Math.min(this._buffer.getLength(), Math.max(0, rawOffset)));\n        return this._buffer.getPositionAt(offset);\n    }\n    _increaseVersionId() {\n        this._versionId = this._versionId + 1;\n        this._alternativeVersionId = this._versionId;\n    }\n    _overwriteVersionId(versionId) {\n        this._versionId = versionId;\n    }\n    _overwriteAlternativeVersionId(newAlternativeVersionId) {\n        this._alternativeVersionId = newAlternativeVersionId;\n    }\n    _overwriteInitialUndoRedoSnapshot(newInitialUndoRedoSnapshot) {\n        this._initialUndoRedoSnapshot = newInitialUndoRedoSnapshot;\n    }\n    getValue(eol, preserveBOM = false) {\n        this._assertNotDisposed();\n        if (this.isTooLargeForHeapOperation()) {\n            throw new BugIndicatingError('Operation would exceed heap memory limits');\n        }\n        const fullModelRange = this.getFullModelRange();\n        const fullModelValue = this.getValueInRange(fullModelRange, eol);\n        if (preserveBOM) {\n            return this._buffer.getBOM() + fullModelValue;\n        }\n        return fullModelValue;\n    }\n    createSnapshot(preserveBOM = false) {\n        return new TextModelSnapshot(this._buffer.createSnapshot(preserveBOM));\n    }\n    getValueLength(eol, preserveBOM = false) {\n        this._assertNotDisposed();\n        const fullModelRange = this.getFullModelRange();\n        const fullModelValue = this.getValueLengthInRange(fullModelRange, eol);\n        if (preserveBOM) {\n            return this._buffer.getBOM().length + fullModelValue;\n        }\n        return fullModelValue;\n    }\n    getValueInRange(rawRange, eol = 0 /* model.EndOfLinePreference.TextDefined */) {\n        this._assertNotDisposed();\n        return this._buffer.getValueInRange(this.validateRange(rawRange), eol);\n    }\n    getValueLengthInRange(rawRange, eol = 0 /* model.EndOfLinePreference.TextDefined */) {\n        this._assertNotDisposed();\n        return this._buffer.getValueLengthInRange(this.validateRange(rawRange), eol);\n    }\n    getCharacterCountInRange(rawRange, eol = 0 /* model.EndOfLinePreference.TextDefined */) {\n        this._assertNotDisposed();\n        return this._buffer.getCharacterCountInRange(this.validateRange(rawRange), eol);\n    }\n    getLineCount() {\n        this._assertNotDisposed();\n        return this._buffer.getLineCount();\n    }\n    getLineContent(lineNumber) {\n        this._assertNotDisposed();\n        if (lineNumber < 1 || lineNumber > this.getLineCount()) {\n            throw new BugIndicatingError('Illegal value for lineNumber');\n        }\n        return this._buffer.getLineContent(lineNumber);\n    }\n    getLineLength(lineNumber) {\n        this._assertNotDisposed();\n        if (lineNumber < 1 || lineNumber > this.getLineCount()) {\n            throw new BugIndicatingError('Illegal value for lineNumber');\n        }\n        return this._buffer.getLineLength(lineNumber);\n    }\n    getLinesContent() {\n        this._assertNotDisposed();\n        if (this.isTooLargeForHeapOperation()) {\n            throw new BugIndicatingError('Operation would exceed heap memory limits');\n        }\n        return this._buffer.getLinesContent();\n    }\n    getEOL() {\n        this._assertNotDisposed();\n        return this._buffer.getEOL();\n    }\n    getEndOfLineSequence() {\n        this._assertNotDisposed();\n        return (this._buffer.getEOL() === '\\n'\n            ? 0 /* model.EndOfLineSequence.LF */\n            : 1 /* model.EndOfLineSequence.CRLF */);\n    }\n    getLineMinColumn(lineNumber) {\n        this._assertNotDisposed();\n        return 1;\n    }\n    getLineMaxColumn(lineNumber) {\n        this._assertNotDisposed();\n        if (lineNumber < 1 || lineNumber > this.getLineCount()) {\n            throw new BugIndicatingError('Illegal value for lineNumber');\n        }\n        return this._buffer.getLineLength(lineNumber) + 1;\n    }\n    getLineFirstNonWhitespaceColumn(lineNumber) {\n        this._assertNotDisposed();\n        if (lineNumber < 1 || lineNumber > this.getLineCount()) {\n            throw new BugIndicatingError('Illegal value for lineNumber');\n        }\n        return this._buffer.getLineFirstNonWhitespaceColumn(lineNumber);\n    }\n    getLineLastNonWhitespaceColumn(lineNumber) {\n        this._assertNotDisposed();\n        if (lineNumber < 1 || lineNumber > this.getLineCount()) {\n            throw new BugIndicatingError('Illegal value for lineNumber');\n        }\n        return this._buffer.getLineLastNonWhitespaceColumn(lineNumber);\n    }\n    /**\n     * Validates `range` is within buffer bounds, but allows it to sit in between surrogate pairs, etc.\n     * Will try to not allocate if possible.\n     */\n    _validateRangeRelaxedNoAllocations(range) {\n        const linesCount = this._buffer.getLineCount();\n        const initialStartLineNumber = range.startLineNumber;\n        const initialStartColumn = range.startColumn;\n        let startLineNumber = Math.floor((typeof initialStartLineNumber === 'number' && !isNaN(initialStartLineNumber)) ? initialStartLineNumber : 1);\n        let startColumn = Math.floor((typeof initialStartColumn === 'number' && !isNaN(initialStartColumn)) ? initialStartColumn : 1);\n        if (startLineNumber < 1) {\n            startLineNumber = 1;\n            startColumn = 1;\n        }\n        else if (startLineNumber > linesCount) {\n            startLineNumber = linesCount;\n            startColumn = this.getLineMaxColumn(startLineNumber);\n        }\n        else {\n            if (startColumn <= 1) {\n                startColumn = 1;\n            }\n            else {\n                const maxColumn = this.getLineMaxColumn(startLineNumber);\n                if (startColumn >= maxColumn) {\n                    startColumn = maxColumn;\n                }\n            }\n        }\n        const initialEndLineNumber = range.endLineNumber;\n        const initialEndColumn = range.endColumn;\n        let endLineNumber = Math.floor((typeof initialEndLineNumber === 'number' && !isNaN(initialEndLineNumber)) ? initialEndLineNumber : 1);\n        let endColumn = Math.floor((typeof initialEndColumn === 'number' && !isNaN(initialEndColumn)) ? initialEndColumn : 1);\n        if (endLineNumber < 1) {\n            endLineNumber = 1;\n            endColumn = 1;\n        }\n        else if (endLineNumber > linesCount) {\n            endLineNumber = linesCount;\n            endColumn = this.getLineMaxColumn(endLineNumber);\n        }\n        else {\n            if (endColumn <= 1) {\n                endColumn = 1;\n            }\n            else {\n                const maxColumn = this.getLineMaxColumn(endLineNumber);\n                if (endColumn >= maxColumn) {\n                    endColumn = maxColumn;\n                }\n            }\n        }\n        if (initialStartLineNumber === startLineNumber\n            && initialStartColumn === startColumn\n            && initialEndLineNumber === endLineNumber\n            && initialEndColumn === endColumn\n            && range instanceof Range\n            && !(range instanceof Selection)) {\n            return range;\n        }\n        return new Range(startLineNumber, startColumn, endLineNumber, endColumn);\n    }\n    _isValidPosition(lineNumber, column, validationType) {\n        if (typeof lineNumber !== 'number' || typeof column !== 'number') {\n            return false;\n        }\n        if (isNaN(lineNumber) || isNaN(column)) {\n            return false;\n        }\n        if (lineNumber < 1 || column < 1) {\n            return false;\n        }\n        if ((lineNumber | 0) !== lineNumber || (column | 0) !== column) {\n            return false;\n        }\n        const lineCount = this._buffer.getLineCount();\n        if (lineNumber > lineCount) {\n            return false;\n        }\n        if (column === 1) {\n            return true;\n        }\n        const maxColumn = this.getLineMaxColumn(lineNumber);\n        if (column > maxColumn) {\n            return false;\n        }\n        if (validationType === 1 /* StringOffsetValidationType.SurrogatePairs */) {\n            // !!At this point, column > 1\n            const charCodeBefore = this._buffer.getLineCharCode(lineNumber, column - 2);\n            if (strings.isHighSurrogate(charCodeBefore)) {\n                return false;\n            }\n        }\n        return true;\n    }\n    _validatePosition(_lineNumber, _column, validationType) {\n        const lineNumber = Math.floor((typeof _lineNumber === 'number' && !isNaN(_lineNumber)) ? _lineNumber : 1);\n        const column = Math.floor((typeof _column === 'number' && !isNaN(_column)) ? _column : 1);\n        const lineCount = this._buffer.getLineCount();\n        if (lineNumber < 1) {\n            return new Position(1, 1);\n        }\n        if (lineNumber > lineCount) {\n            return new Position(lineCount, this.getLineMaxColumn(lineCount));\n        }\n        if (column <= 1) {\n            return new Position(lineNumber, 1);\n        }\n        const maxColumn = this.getLineMaxColumn(lineNumber);\n        if (column >= maxColumn) {\n            return new Position(lineNumber, maxColumn);\n        }\n        if (validationType === 1 /* StringOffsetValidationType.SurrogatePairs */) {\n            // If the position would end up in the middle of a high-low surrogate pair,\n            // we move it to before the pair\n            // !!At this point, column > 1\n            const charCodeBefore = this._buffer.getLineCharCode(lineNumber, column - 2);\n            if (strings.isHighSurrogate(charCodeBefore)) {\n                return new Position(lineNumber, column - 1);\n            }\n        }\n        return new Position(lineNumber, column);\n    }\n    validatePosition(position) {\n        const validationType = 1 /* StringOffsetValidationType.SurrogatePairs */;\n        this._assertNotDisposed();\n        // Avoid object allocation and cover most likely case\n        if (position instanceof Position) {\n            if (this._isValidPosition(position.lineNumber, position.column, validationType)) {\n                return position;\n            }\n        }\n        return this._validatePosition(position.lineNumber, position.column, validationType);\n    }\n    _isValidRange(range, validationType) {\n        const startLineNumber = range.startLineNumber;\n        const startColumn = range.startColumn;\n        const endLineNumber = range.endLineNumber;\n        const endColumn = range.endColumn;\n        if (!this._isValidPosition(startLineNumber, startColumn, 0 /* StringOffsetValidationType.Relaxed */)) {\n            return false;\n        }\n        if (!this._isValidPosition(endLineNumber, endColumn, 0 /* StringOffsetValidationType.Relaxed */)) {\n            return false;\n        }\n        if (validationType === 1 /* StringOffsetValidationType.SurrogatePairs */) {\n            const charCodeBeforeStart = (startColumn > 1 ? this._buffer.getLineCharCode(startLineNumber, startColumn - 2) : 0);\n            const charCodeBeforeEnd = (endColumn > 1 && endColumn <= this._buffer.getLineLength(endLineNumber) ? this._buffer.getLineCharCode(endLineNumber, endColumn - 2) : 0);\n            const startInsideSurrogatePair = strings.isHighSurrogate(charCodeBeforeStart);\n            const endInsideSurrogatePair = strings.isHighSurrogate(charCodeBeforeEnd);\n            if (!startInsideSurrogatePair && !endInsideSurrogatePair) {\n                return true;\n            }\n            return false;\n        }\n        return true;\n    }\n    validateRange(_range) {\n        const validationType = 1 /* StringOffsetValidationType.SurrogatePairs */;\n        this._assertNotDisposed();\n        // Avoid object allocation and cover most likely case\n        if ((_range instanceof Range) && !(_range instanceof Selection)) {\n            if (this._isValidRange(_range, validationType)) {\n                return _range;\n            }\n        }\n        const start = this._validatePosition(_range.startLineNumber, _range.startColumn, 0 /* StringOffsetValidationType.Relaxed */);\n        const end = this._validatePosition(_range.endLineNumber, _range.endColumn, 0 /* StringOffsetValidationType.Relaxed */);\n        const startLineNumber = start.lineNumber;\n        const startColumn = start.column;\n        const endLineNumber = end.lineNumber;\n        const endColumn = end.column;\n        if (validationType === 1 /* StringOffsetValidationType.SurrogatePairs */) {\n            const charCodeBeforeStart = (startColumn > 1 ? this._buffer.getLineCharCode(startLineNumber, startColumn - 2) : 0);\n            const charCodeBeforeEnd = (endColumn > 1 && endColumn <= this._buffer.getLineLength(endLineNumber) ? this._buffer.getLineCharCode(endLineNumber, endColumn - 2) : 0);\n            const startInsideSurrogatePair = strings.isHighSurrogate(charCodeBeforeStart);\n            const endInsideSurrogatePair = strings.isHighSurrogate(charCodeBeforeEnd);\n            if (!startInsideSurrogatePair && !endInsideSurrogatePair) {\n                return new Range(startLineNumber, startColumn, endLineNumber, endColumn);\n            }\n            if (startLineNumber === endLineNumber && startColumn === endColumn) {\n                // do not expand a collapsed range, simply move it to a valid location\n                return new Range(startLineNumber, startColumn - 1, endLineNumber, endColumn - 1);\n            }\n            if (startInsideSurrogatePair && endInsideSurrogatePair) {\n                // expand range at both ends\n                return new Range(startLineNumber, startColumn - 1, endLineNumber, endColumn + 1);\n            }\n            if (startInsideSurrogatePair) {\n                // only expand range at the start\n                return new Range(startLineNumber, startColumn - 1, endLineNumber, endColumn);\n            }\n            // only expand range at the end\n            return new Range(startLineNumber, startColumn, endLineNumber, endColumn + 1);\n        }\n        return new Range(startLineNumber, startColumn, endLineNumber, endColumn);\n    }\n    modifyPosition(rawPosition, offset) {\n        this._assertNotDisposed();\n        const candidate = this.getOffsetAt(rawPosition) + offset;\n        return this.getPositionAt(Math.min(this._buffer.getLength(), Math.max(0, candidate)));\n    }\n    getFullModelRange() {\n        this._assertNotDisposed();\n        const lineCount = this.getLineCount();\n        return new Range(1, 1, lineCount, this.getLineMaxColumn(lineCount));\n    }\n    findMatchesLineByLine(searchRange, searchData, captureMatches, limitResultCount) {\n        return this._buffer.findMatchesLineByLine(searchRange, searchData, captureMatches, limitResultCount);\n    }\n    findMatches(searchString, rawSearchScope, isRegex, matchCase, wordSeparators, captureMatches, limitResultCount = LIMIT_FIND_COUNT) {\n        this._assertNotDisposed();\n        let searchRanges = null;\n        if (rawSearchScope !== null) {\n            if (!Array.isArray(rawSearchScope)) {\n                rawSearchScope = [rawSearchScope];\n            }\n            if (rawSearchScope.every((searchScope) => Range.isIRange(searchScope))) {\n                searchRanges = rawSearchScope.map((searchScope) => this.validateRange(searchScope));\n            }\n        }\n        if (searchRanges === null) {\n            searchRanges = [this.getFullModelRange()];\n        }\n        searchRanges = searchRanges.sort((d1, d2) => d1.startLineNumber - d2.startLineNumber || d1.startColumn - d2.startColumn);\n        const uniqueSearchRanges = [];\n        uniqueSearchRanges.push(searchRanges.reduce((prev, curr) => {\n            if (Range.areIntersecting(prev, curr)) {\n                return prev.plusRange(curr);\n            }\n            uniqueSearchRanges.push(prev);\n            return curr;\n        }));\n        let matchMapper;\n        if (!isRegex && searchString.indexOf('\\n') < 0) {\n            // not regex, not multi line\n            const searchParams = new SearchParams(searchString, isRegex, matchCase, wordSeparators);\n            const searchData = searchParams.parseSearchRequest();\n            if (!searchData) {\n                return [];\n            }\n            matchMapper = (searchRange) => this.findMatchesLineByLine(searchRange, searchData, captureMatches, limitResultCount);\n        }\n        else {\n            matchMapper = (searchRange) => TextModelSearch.findMatches(this, new SearchParams(searchString, isRegex, matchCase, wordSeparators), searchRange, captureMatches, limitResultCount);\n        }\n        return uniqueSearchRanges.map(matchMapper).reduce((arr, matches) => arr.concat(matches), []);\n    }\n    findNextMatch(searchString, rawSearchStart, isRegex, matchCase, wordSeparators, captureMatches) {\n        this._assertNotDisposed();\n        const searchStart = this.validatePosition(rawSearchStart);\n        if (!isRegex && searchString.indexOf('\\n') < 0) {\n            const searchParams = new SearchParams(searchString, isRegex, matchCase, wordSeparators);\n            const searchData = searchParams.parseSearchRequest();\n            if (!searchData) {\n                return null;\n            }\n            const lineCount = this.getLineCount();\n            let searchRange = new Range(searchStart.lineNumber, searchStart.column, lineCount, this.getLineMaxColumn(lineCount));\n            let ret = this.findMatchesLineByLine(searchRange, searchData, captureMatches, 1);\n            TextModelSearch.findNextMatch(this, new SearchParams(searchString, isRegex, matchCase, wordSeparators), searchStart, captureMatches);\n            if (ret.length > 0) {\n                return ret[0];\n            }\n            searchRange = new Range(1, 1, searchStart.lineNumber, this.getLineMaxColumn(searchStart.lineNumber));\n            ret = this.findMatchesLineByLine(searchRange, searchData, captureMatches, 1);\n            if (ret.length > 0) {\n                return ret[0];\n            }\n            return null;\n        }\n        return TextModelSearch.findNextMatch(this, new SearchParams(searchString, isRegex, matchCase, wordSeparators), searchStart, captureMatches);\n    }\n    findPreviousMatch(searchString, rawSearchStart, isRegex, matchCase, wordSeparators, captureMatches) {\n        this._assertNotDisposed();\n        const searchStart = this.validatePosition(rawSearchStart);\n        return TextModelSearch.findPreviousMatch(this, new SearchParams(searchString, isRegex, matchCase, wordSeparators), searchStart, captureMatches);\n    }\n    //#endregion\n    //#region Editing\n    pushStackElement() {\n        this._commandManager.pushStackElement();\n    }\n    popStackElement() {\n        this._commandManager.popStackElement();\n    }\n    pushEOL(eol) {\n        const currentEOL = (this.getEOL() === '\\n' ? 0 /* model.EndOfLineSequence.LF */ : 1 /* model.EndOfLineSequence.CRLF */);\n        if (currentEOL === eol) {\n            return;\n        }\n        try {\n            this._onDidChangeDecorations.beginDeferredEmit();\n            this._eventEmitter.beginDeferredEmit();\n            if (this._initialUndoRedoSnapshot === null) {\n                this._initialUndoRedoSnapshot = this._undoRedoService.createSnapshot(this.uri);\n            }\n            this._commandManager.pushEOL(eol);\n        }\n        finally {\n            this._eventEmitter.endDeferredEmit();\n            this._onDidChangeDecorations.endDeferredEmit();\n        }\n    }\n    _validateEditOperation(rawOperation) {\n        if (rawOperation instanceof model.ValidAnnotatedEditOperation) {\n            return rawOperation;\n        }\n        return new model.ValidAnnotatedEditOperation(rawOperation.identifier || null, this.validateRange(rawOperation.range), rawOperation.text, rawOperation.forceMoveMarkers || false, rawOperation.isAutoWhitespaceEdit || false, rawOperation._isTracked || false);\n    }\n    _validateEditOperations(rawOperations) {\n        const result = [];\n        for (let i = 0, len = rawOperations.length; i < len; i++) {\n            result[i] = this._validateEditOperation(rawOperations[i]);\n        }\n        return result;\n    }\n    pushEditOperations(beforeCursorState, editOperations, cursorStateComputer, group) {\n        try {\n            this._onDidChangeDecorations.beginDeferredEmit();\n            this._eventEmitter.beginDeferredEmit();\n            return this._pushEditOperations(beforeCursorState, this._validateEditOperations(editOperations), cursorStateComputer, group);\n        }\n        finally {\n            this._eventEmitter.endDeferredEmit();\n            this._onDidChangeDecorations.endDeferredEmit();\n        }\n    }\n    _pushEditOperations(beforeCursorState, editOperations, cursorStateComputer, group) {\n        if (this._options.trimAutoWhitespace && this._trimAutoWhitespaceLines) {\n            // Go through each saved line number and insert a trim whitespace edit\n            // if it is safe to do so (no conflicts with other edits).\n            const incomingEdits = editOperations.map((op) => {\n                return {\n                    range: this.validateRange(op.range),\n                    text: op.text\n                };\n            });\n            // Sometimes, auto-formatters change ranges automatically which can cause undesired auto whitespace trimming near the cursor\n            // We'll use the following heuristic: if the edits occur near the cursor, then it's ok to trim auto whitespace\n            let editsAreNearCursors = true;\n            if (beforeCursorState) {\n                for (let i = 0, len = beforeCursorState.length; i < len; i++) {\n                    const sel = beforeCursorState[i];\n                    let foundEditNearSel = false;\n                    for (let j = 0, lenJ = incomingEdits.length; j < lenJ; j++) {\n                        const editRange = incomingEdits[j].range;\n                        const selIsAbove = editRange.startLineNumber > sel.endLineNumber;\n                        const selIsBelow = sel.startLineNumber > editRange.endLineNumber;\n                        if (!selIsAbove && !selIsBelow) {\n                            foundEditNearSel = true;\n                            break;\n                        }\n                    }\n                    if (!foundEditNearSel) {\n                        editsAreNearCursors = false;\n                        break;\n                    }\n                }\n            }\n            if (editsAreNearCursors) {\n                for (let i = 0, len = this._trimAutoWhitespaceLines.length; i < len; i++) {\n                    const trimLineNumber = this._trimAutoWhitespaceLines[i];\n                    const maxLineColumn = this.getLineMaxColumn(trimLineNumber);\n                    let allowTrimLine = true;\n                    for (let j = 0, lenJ = incomingEdits.length; j < lenJ; j++) {\n                        const editRange = incomingEdits[j].range;\n                        const editText = incomingEdits[j].text;\n                        if (trimLineNumber < editRange.startLineNumber || trimLineNumber > editRange.endLineNumber) {\n                            // `trimLine` is completely outside this edit\n                            continue;\n                        }\n                        // At this point:\n                        //   editRange.startLineNumber <= trimLine <= editRange.endLineNumber\n                        if (trimLineNumber === editRange.startLineNumber && editRange.startColumn === maxLineColumn\n                            && editRange.isEmpty() && editText && editText.length > 0 && editText.charAt(0) === '\\n') {\n                            // This edit inserts a new line (and maybe other text) after `trimLine`\n                            continue;\n                        }\n                        if (trimLineNumber === editRange.startLineNumber && editRange.startColumn === 1\n                            && editRange.isEmpty() && editText && editText.length > 0 && editText.charAt(editText.length - 1) === '\\n') {\n                            // This edit inserts a new line (and maybe other text) before `trimLine`\n                            continue;\n                        }\n                        // Looks like we can't trim this line as it would interfere with an incoming edit\n                        allowTrimLine = false;\n                        break;\n                    }\n                    if (allowTrimLine) {\n                        const trimRange = new Range(trimLineNumber, 1, trimLineNumber, maxLineColumn);\n                        editOperations.push(new model.ValidAnnotatedEditOperation(null, trimRange, null, false, false, false));\n                    }\n                }\n            }\n            this._trimAutoWhitespaceLines = null;\n        }\n        if (this._initialUndoRedoSnapshot === null) {\n            this._initialUndoRedoSnapshot = this._undoRedoService.createSnapshot(this.uri);\n        }\n        return this._commandManager.pushEditOperation(beforeCursorState, editOperations, cursorStateComputer, group);\n    }\n    _applyUndo(changes, eol, resultingAlternativeVersionId, resultingSelection) {\n        const edits = changes.map((change) => {\n            const rangeStart = this.getPositionAt(change.newPosition);\n            const rangeEnd = this.getPositionAt(change.newEnd);\n            return {\n                range: new Range(rangeStart.lineNumber, rangeStart.column, rangeEnd.lineNumber, rangeEnd.column),\n                text: change.oldText\n            };\n        });\n        this._applyUndoRedoEdits(edits, eol, true, false, resultingAlternativeVersionId, resultingSelection);\n    }\n    _applyRedo(changes, eol, resultingAlternativeVersionId, resultingSelection) {\n        const edits = changes.map((change) => {\n            const rangeStart = this.getPositionAt(change.oldPosition);\n            const rangeEnd = this.getPositionAt(change.oldEnd);\n            return {\n                range: new Range(rangeStart.lineNumber, rangeStart.column, rangeEnd.lineNumber, rangeEnd.column),\n                text: change.newText\n            };\n        });\n        this._applyUndoRedoEdits(edits, eol, false, true, resultingAlternativeVersionId, resultingSelection);\n    }\n    _applyUndoRedoEdits(edits, eol, isUndoing, isRedoing, resultingAlternativeVersionId, resultingSelection) {\n        try {\n            this._onDidChangeDecorations.beginDeferredEmit();\n            this._eventEmitter.beginDeferredEmit();\n            this._isUndoing = isUndoing;\n            this._isRedoing = isRedoing;\n            this.applyEdits(edits, false);\n            this.setEOL(eol);\n            this._overwriteAlternativeVersionId(resultingAlternativeVersionId);\n        }\n        finally {\n            this._isUndoing = false;\n            this._isRedoing = false;\n            this._eventEmitter.endDeferredEmit(resultingSelection);\n            this._onDidChangeDecorations.endDeferredEmit();\n        }\n    }\n    applyEdits(rawOperations, computeUndoEdits = false) {\n        try {\n            this._onDidChangeDecorations.beginDeferredEmit();\n            this._eventEmitter.beginDeferredEmit();\n            const operations = this._validateEditOperations(rawOperations);\n            return this._doApplyEdits(operations, computeUndoEdits);\n        }\n        finally {\n            this._eventEmitter.endDeferredEmit();\n            this._onDidChangeDecorations.endDeferredEmit();\n        }\n    }\n    _doApplyEdits(rawOperations, computeUndoEdits) {\n        const oldLineCount = this._buffer.getLineCount();\n        const result = this._buffer.applyEdits(rawOperations, this._options.trimAutoWhitespace, computeUndoEdits);\n        const newLineCount = this._buffer.getLineCount();\n        const contentChanges = result.changes;\n        this._trimAutoWhitespaceLines = result.trimAutoWhitespaceLineNumbers;\n        if (contentChanges.length !== 0) {\n            // We do a first pass to update decorations\n            // because we want to read decorations in the second pass\n            // where we will emit content change events\n            // and we want to read the final decorations\n            for (let i = 0, len = contentChanges.length; i < len; i++) {\n                const change = contentChanges[i];\n                this._decorationsTree.acceptReplace(change.rangeOffset, change.rangeLength, change.text.length, change.forceMoveMarkers);\n            }\n            const rawContentChanges = [];\n            this._increaseVersionId();\n            let lineCount = oldLineCount;\n            for (let i = 0, len = contentChanges.length; i < len; i++) {\n                const change = contentChanges[i];\n                const [eolCount] = countEOL(change.text);\n                this._onDidChangeDecorations.fire();\n                const startLineNumber = change.range.startLineNumber;\n                const endLineNumber = change.range.endLineNumber;\n                const deletingLinesCnt = endLineNumber - startLineNumber;\n                const insertingLinesCnt = eolCount;\n                const editingLinesCnt = Math.min(deletingLinesCnt, insertingLinesCnt);\n                const changeLineCountDelta = (insertingLinesCnt - deletingLinesCnt);\n                const currentEditStartLineNumber = newLineCount - lineCount - changeLineCountDelta + startLineNumber;\n                const firstEditLineNumber = currentEditStartLineNumber;\n                const lastInsertedLineNumber = currentEditStartLineNumber + insertingLinesCnt;\n                const decorationsWithInjectedTextInEditedRange = this._decorationsTree.getInjectedTextInInterval(this, this.getOffsetAt(new Position(firstEditLineNumber, 1)), this.getOffsetAt(new Position(lastInsertedLineNumber, this.getLineMaxColumn(lastInsertedLineNumber))), 0);\n                const injectedTextInEditedRange = LineInjectedText.fromDecorations(decorationsWithInjectedTextInEditedRange);\n                const injectedTextInEditedRangeQueue = new ArrayQueue(injectedTextInEditedRange);\n                for (let j = editingLinesCnt; j >= 0; j--) {\n                    const editLineNumber = startLineNumber + j;\n                    const currentEditLineNumber = currentEditStartLineNumber + j;\n                    injectedTextInEditedRangeQueue.takeFromEndWhile(r => r.lineNumber > currentEditLineNumber);\n                    const decorationsInCurrentLine = injectedTextInEditedRangeQueue.takeFromEndWhile(r => r.lineNumber === currentEditLineNumber);\n                    rawContentChanges.push(new ModelRawLineChanged(editLineNumber, this.getLineContent(currentEditLineNumber), decorationsInCurrentLine));\n                }\n                if (editingLinesCnt < deletingLinesCnt) {\n                    // Must delete some lines\n                    const spliceStartLineNumber = startLineNumber + editingLinesCnt;\n                    rawContentChanges.push(new ModelRawLinesDeleted(spliceStartLineNumber + 1, endLineNumber));\n                }\n                if (editingLinesCnt < insertingLinesCnt) {\n                    const injectedTextInEditedRangeQueue = new ArrayQueue(injectedTextInEditedRange);\n                    // Must insert some lines\n                    const spliceLineNumber = startLineNumber + editingLinesCnt;\n                    const cnt = insertingLinesCnt - editingLinesCnt;\n                    const fromLineNumber = newLineCount - lineCount - cnt + spliceLineNumber + 1;\n                    const injectedTexts = [];\n                    const newLines = [];\n                    for (let i = 0; i < cnt; i++) {\n                        const lineNumber = fromLineNumber + i;\n                        newLines[i] = this.getLineContent(lineNumber);\n                        injectedTextInEditedRangeQueue.takeWhile(r => r.lineNumber < lineNumber);\n                        injectedTexts[i] = injectedTextInEditedRangeQueue.takeWhile(r => r.lineNumber === lineNumber);\n                    }\n                    rawContentChanges.push(new ModelRawLinesInserted(spliceLineNumber + 1, startLineNumber + insertingLinesCnt, newLines, injectedTexts));\n                }\n                lineCount += changeLineCountDelta;\n            }\n            this._emitContentChangedEvent(new ModelRawContentChangedEvent(rawContentChanges, this.getVersionId(), this._isUndoing, this._isRedoing), {\n                changes: contentChanges,\n                eol: this._buffer.getEOL(),\n                isEolChange: false,\n                versionId: this.getVersionId(),\n                isUndoing: this._isUndoing,\n                isRedoing: this._isRedoing,\n                isFlush: false\n            });\n        }\n        return (result.reverseEdits === null ? undefined : result.reverseEdits);\n    }\n    undo() {\n        return this._undoRedoService.undo(this.uri);\n    }\n    canUndo() {\n        return this._undoRedoService.canUndo(this.uri);\n    }\n    redo() {\n        return this._undoRedoService.redo(this.uri);\n    }\n    canRedo() {\n        return this._undoRedoService.canRedo(this.uri);\n    }\n    //#endregion\n    //#region Decorations\n    handleBeforeFireDecorationsChangedEvent(affectedInjectedTextLines) {\n        // This is called before the decoration changed event is fired.\n        if (affectedInjectedTextLines === null || affectedInjectedTextLines.size === 0) {\n            return;\n        }\n        const affectedLines = Array.from(affectedInjectedTextLines);\n        const lineChangeEvents = affectedLines.map(lineNumber => new ModelRawLineChanged(lineNumber, this.getLineContent(lineNumber), this._getInjectedTextInLine(lineNumber)));\n        this._onDidChangeInjectedText.fire(new ModelInjectedTextChangedEvent(lineChangeEvents));\n    }\n    changeDecorations(callback, ownerId = 0) {\n        this._assertNotDisposed();\n        try {\n            this._onDidChangeDecorations.beginDeferredEmit();\n            return this._changeDecorations(ownerId, callback);\n        }\n        finally {\n            this._onDidChangeDecorations.endDeferredEmit();\n        }\n    }\n    _changeDecorations(ownerId, callback) {\n        const changeAccessor = {\n            addDecoration: (range, options) => {\n                return this._deltaDecorationsImpl(ownerId, [], [{ range: range, options: options }])[0];\n            },\n            changeDecoration: (id, newRange) => {\n                this._changeDecorationImpl(id, newRange);\n            },\n            changeDecorationOptions: (id, options) => {\n                this._changeDecorationOptionsImpl(id, _normalizeOptions(options));\n            },\n            removeDecoration: (id) => {\n                this._deltaDecorationsImpl(ownerId, [id], []);\n            },\n            deltaDecorations: (oldDecorations, newDecorations) => {\n                if (oldDecorations.length === 0 && newDecorations.length === 0) {\n                    // nothing to do\n                    return [];\n                }\n                return this._deltaDecorationsImpl(ownerId, oldDecorations, newDecorations);\n            }\n        };\n        let result = null;\n        try {\n            result = callback(changeAccessor);\n        }\n        catch (e) {\n            onUnexpectedError(e);\n        }\n        // Invalidate change accessor\n        changeAccessor.addDecoration = invalidFunc;\n        changeAccessor.changeDecoration = invalidFunc;\n        changeAccessor.changeDecorationOptions = invalidFunc;\n        changeAccessor.removeDecoration = invalidFunc;\n        changeAccessor.deltaDecorations = invalidFunc;\n        return result;\n    }\n    deltaDecorations(oldDecorations, newDecorations, ownerId = 0) {\n        this._assertNotDisposed();\n        if (!oldDecorations) {\n            oldDecorations = [];\n        }\n        if (oldDecorations.length === 0 && newDecorations.length === 0) {\n            // nothing to do\n            return [];\n        }\n        try {\n            this._deltaDecorationCallCnt++;\n            if (this._deltaDecorationCallCnt > 1) {\n                console.warn(`Invoking deltaDecorations recursively could lead to leaking decorations.`);\n                onUnexpectedError(new Error(`Invoking deltaDecorations recursively could lead to leaking decorations.`));\n            }\n            this._onDidChangeDecorations.beginDeferredEmit();\n            return this._deltaDecorationsImpl(ownerId, oldDecorations, newDecorations);\n        }\n        finally {\n            this._onDidChangeDecorations.endDeferredEmit();\n            this._deltaDecorationCallCnt--;\n        }\n    }\n    _getTrackedRange(id) {\n        return this.getDecorationRange(id);\n    }\n    _setTrackedRange(id, newRange, newStickiness) {\n        const node = (id ? this._decorations[id] : null);\n        if (!node) {\n            if (!newRange) {\n                // node doesn't exist, the request is to delete => nothing to do\n                return null;\n            }\n            // node doesn't exist, the request is to set => add the tracked range\n            return this._deltaDecorationsImpl(0, [], [{ range: newRange, options: TRACKED_RANGE_OPTIONS[newStickiness] }], true)[0];\n        }\n        if (!newRange) {\n            // node exists, the request is to delete => delete node\n            this._decorationsTree.delete(node);\n            delete this._decorations[node.id];\n            return null;\n        }\n        // node exists, the request is to set => change the tracked range and its options\n        const range = this._validateRangeRelaxedNoAllocations(newRange);\n        const startOffset = this._buffer.getOffsetAt(range.startLineNumber, range.startColumn);\n        const endOffset = this._buffer.getOffsetAt(range.endLineNumber, range.endColumn);\n        this._decorationsTree.delete(node);\n        node.reset(this.getVersionId(), startOffset, endOffset, range);\n        node.setOptions(TRACKED_RANGE_OPTIONS[newStickiness]);\n        this._decorationsTree.insert(node);\n        return node.id;\n    }\n    removeAllDecorationsWithOwnerId(ownerId) {\n        if (this._isDisposed) {\n            return;\n        }\n        const nodes = this._decorationsTree.collectNodesFromOwner(ownerId);\n        for (let i = 0, len = nodes.length; i < len; i++) {\n            const node = nodes[i];\n            this._decorationsTree.delete(node);\n            delete this._decorations[node.id];\n        }\n    }\n    getDecorationOptions(decorationId) {\n        const node = this._decorations[decorationId];\n        if (!node) {\n            return null;\n        }\n        return node.options;\n    }\n    getDecorationRange(decorationId) {\n        const node = this._decorations[decorationId];\n        if (!node) {\n            return null;\n        }\n        return this._decorationsTree.getNodeRange(this, node);\n    }\n    getLineDecorations(lineNumber, ownerId = 0, filterOutValidation = false) {\n        if (lineNumber < 1 || lineNumber > this.getLineCount()) {\n            return [];\n        }\n        return this.getLinesDecorations(lineNumber, lineNumber, ownerId, filterOutValidation);\n    }\n    getLinesDecorations(_startLineNumber, _endLineNumber, ownerId = 0, filterOutValidation = false, onlyMarginDecorations = false) {\n        const lineCount = this.getLineCount();\n        const startLineNumber = Math.min(lineCount, Math.max(1, _startLineNumber));\n        const endLineNumber = Math.min(lineCount, Math.max(1, _endLineNumber));\n        const endColumn = this.getLineMaxColumn(endLineNumber);\n        const range = new Range(startLineNumber, 1, endLineNumber, endColumn);\n        const decorations = this._getDecorationsInRange(range, ownerId, filterOutValidation, onlyMarginDecorations);\n        pushMany(decorations, this._decorationProvider.getDecorationsInRange(range, ownerId, filterOutValidation));\n        return decorations;\n    }\n    getDecorationsInRange(range, ownerId = 0, filterOutValidation = false, onlyMinimapDecorations = false, onlyMarginDecorations = false) {\n        const validatedRange = this.validateRange(range);\n        const decorations = this._getDecorationsInRange(validatedRange, ownerId, filterOutValidation, onlyMarginDecorations);\n        pushMany(decorations, this._decorationProvider.getDecorationsInRange(validatedRange, ownerId, filterOutValidation, onlyMinimapDecorations));\n        return decorations;\n    }\n    getOverviewRulerDecorations(ownerId = 0, filterOutValidation = false) {\n        return this._decorationsTree.getAll(this, ownerId, filterOutValidation, true, false);\n    }\n    getInjectedTextDecorations(ownerId = 0) {\n        return this._decorationsTree.getAllInjectedText(this, ownerId);\n    }\n    _getInjectedTextInLine(lineNumber) {\n        const startOffset = this._buffer.getOffsetAt(lineNumber, 1);\n        const endOffset = startOffset + this._buffer.getLineLength(lineNumber);\n        const result = this._decorationsTree.getInjectedTextInInterval(this, startOffset, endOffset, 0);\n        return LineInjectedText.fromDecorations(result).filter(t => t.lineNumber === lineNumber);\n    }\n    getAllDecorations(ownerId = 0, filterOutValidation = false) {\n        let result = this._decorationsTree.getAll(this, ownerId, filterOutValidation, false, false);\n        result = result.concat(this._decorationProvider.getAllDecorations(ownerId, filterOutValidation));\n        return result;\n    }\n    getAllMarginDecorations(ownerId = 0) {\n        return this._decorationsTree.getAll(this, ownerId, false, false, true);\n    }\n    _getDecorationsInRange(filterRange, filterOwnerId, filterOutValidation, onlyMarginDecorations) {\n        const startOffset = this._buffer.getOffsetAt(filterRange.startLineNumber, filterRange.startColumn);\n        const endOffset = this._buffer.getOffsetAt(filterRange.endLineNumber, filterRange.endColumn);\n        return this._decorationsTree.getAllInInterval(this, startOffset, endOffset, filterOwnerId, filterOutValidation, onlyMarginDecorations);\n    }\n    getRangeAt(start, end) {\n        return this._buffer.getRangeAt(start, end - start);\n    }\n    _changeDecorationImpl(decorationId, _range) {\n        const node = this._decorations[decorationId];\n        if (!node) {\n            return;\n        }\n        if (node.options.after) {\n            const oldRange = this.getDecorationRange(decorationId);\n            this._onDidChangeDecorations.recordLineAffectedByInjectedText(oldRange.endLineNumber);\n        }\n        if (node.options.before) {\n            const oldRange = this.getDecorationRange(decorationId);\n            this._onDidChangeDecorations.recordLineAffectedByInjectedText(oldRange.startLineNumber);\n        }\n        const range = this._validateRangeRelaxedNoAllocations(_range);\n        const startOffset = this._buffer.getOffsetAt(range.startLineNumber, range.startColumn);\n        const endOffset = this._buffer.getOffsetAt(range.endLineNumber, range.endColumn);\n        this._decorationsTree.delete(node);\n        node.reset(this.getVersionId(), startOffset, endOffset, range);\n        this._decorationsTree.insert(node);\n        this._onDidChangeDecorations.checkAffectedAndFire(node.options);\n        if (node.options.after) {\n            this._onDidChangeDecorations.recordLineAffectedByInjectedText(range.endLineNumber);\n        }\n        if (node.options.before) {\n            this._onDidChangeDecorations.recordLineAffectedByInjectedText(range.startLineNumber);\n        }\n    }\n    _changeDecorationOptionsImpl(decorationId, options) {\n        const node = this._decorations[decorationId];\n        if (!node) {\n            return;\n        }\n        const nodeWasInOverviewRuler = (node.options.overviewRuler && node.options.overviewRuler.color ? true : false);\n        const nodeIsInOverviewRuler = (options.overviewRuler && options.overviewRuler.color ? true : false);\n        this._onDidChangeDecorations.checkAffectedAndFire(node.options);\n        this._onDidChangeDecorations.checkAffectedAndFire(options);\n        if (node.options.after || options.after) {\n            const nodeRange = this._decorationsTree.getNodeRange(this, node);\n            this._onDidChangeDecorations.recordLineAffectedByInjectedText(nodeRange.endLineNumber);\n        }\n        if (node.options.before || options.before) {\n            const nodeRange = this._decorationsTree.getNodeRange(this, node);\n            this._onDidChangeDecorations.recordLineAffectedByInjectedText(nodeRange.startLineNumber);\n        }\n        const movedInOverviewRuler = nodeWasInOverviewRuler !== nodeIsInOverviewRuler;\n        const changedWhetherInjectedText = isOptionsInjectedText(options) !== isNodeInjectedText(node);\n        if (movedInOverviewRuler || changedWhetherInjectedText) {\n            this._decorationsTree.delete(node);\n            node.setOptions(options);\n            this._decorationsTree.insert(node);\n        }\n        else {\n            node.setOptions(options);\n        }\n    }\n    _deltaDecorationsImpl(ownerId, oldDecorationsIds, newDecorations, suppressEvents = false) {\n        const versionId = this.getVersionId();\n        const oldDecorationsLen = oldDecorationsIds.length;\n        let oldDecorationIndex = 0;\n        const newDecorationsLen = newDecorations.length;\n        let newDecorationIndex = 0;\n        this._onDidChangeDecorations.beginDeferredEmit();\n        try {\n            const result = new Array(newDecorationsLen);\n            while (oldDecorationIndex < oldDecorationsLen || newDecorationIndex < newDecorationsLen) {\n                let node = null;\n                if (oldDecorationIndex < oldDecorationsLen) {\n                    // (1) get ourselves an old node\n                    do {\n                        node = this._decorations[oldDecorationsIds[oldDecorationIndex++]];\n                    } while (!node && oldDecorationIndex < oldDecorationsLen);\n                    // (2) remove the node from the tree (if it exists)\n                    if (node) {\n                        if (node.options.after) {\n                            const nodeRange = this._decorationsTree.getNodeRange(this, node);\n                            this._onDidChangeDecorations.recordLineAffectedByInjectedText(nodeRange.endLineNumber);\n                        }\n                        if (node.options.before) {\n                            const nodeRange = this._decorationsTree.getNodeRange(this, node);\n                            this._onDidChangeDecorations.recordLineAffectedByInjectedText(nodeRange.startLineNumber);\n                        }\n                        this._decorationsTree.delete(node);\n                        if (!suppressEvents) {\n                            this._onDidChangeDecorations.checkAffectedAndFire(node.options);\n                        }\n                    }\n                }\n                if (newDecorationIndex < newDecorationsLen) {\n                    // (3) create a new node if necessary\n                    if (!node) {\n                        const internalDecorationId = (++this._lastDecorationId);\n                        const decorationId = `${this._instanceId};${internalDecorationId}`;\n                        node = new IntervalNode(decorationId, 0, 0);\n                        this._decorations[decorationId] = node;\n                    }\n                    // (4) initialize node\n                    const newDecoration = newDecorations[newDecorationIndex];\n                    const range = this._validateRangeRelaxedNoAllocations(newDecoration.range);\n                    const options = _normalizeOptions(newDecoration.options);\n                    const startOffset = this._buffer.getOffsetAt(range.startLineNumber, range.startColumn);\n                    const endOffset = this._buffer.getOffsetAt(range.endLineNumber, range.endColumn);\n                    node.ownerId = ownerId;\n                    node.reset(versionId, startOffset, endOffset, range);\n                    node.setOptions(options);\n                    if (node.options.after) {\n                        this._onDidChangeDecorations.recordLineAffectedByInjectedText(range.endLineNumber);\n                    }\n                    if (node.options.before) {\n                        this._onDidChangeDecorations.recordLineAffectedByInjectedText(range.startLineNumber);\n                    }\n                    if (!suppressEvents) {\n                        this._onDidChangeDecorations.checkAffectedAndFire(options);\n                    }\n                    this._decorationsTree.insert(node);\n                    result[newDecorationIndex] = node.id;\n                    newDecorationIndex++;\n                }\n                else {\n                    if (node) {\n                        delete this._decorations[node.id];\n                    }\n                }\n            }\n            return result;\n        }\n        finally {\n            this._onDidChangeDecorations.endDeferredEmit();\n        }\n    }\n    //#endregion\n    //#region Tokenization\n    // TODO move them to the tokenization part.\n    getLanguageId() {\n        return this.tokenization.getLanguageId();\n    }\n    setLanguage(languageIdOrSelection, source) {\n        if (typeof languageIdOrSelection === 'string') {\n            this._languageSelectionListener.clear();\n            this._setLanguage(languageIdOrSelection, source);\n        }\n        else {\n            this._languageSelectionListener.value = languageIdOrSelection.onDidChange(() => this._setLanguage(languageIdOrSelection.languageId, source));\n            this._setLanguage(languageIdOrSelection.languageId, source);\n        }\n    }\n    _setLanguage(languageId, source) {\n        this.tokenization.setLanguageId(languageId, source);\n        this._languageService.requestRichLanguageFeatures(languageId);\n    }\n    getLanguageIdAtPosition(lineNumber, column) {\n        return this.tokenization.getLanguageIdAtPosition(lineNumber, column);\n    }\n    getWordAtPosition(position) {\n        return this._tokenizationTextModelPart.getWordAtPosition(position);\n    }\n    getWordUntilPosition(position) {\n        return this._tokenizationTextModelPart.getWordUntilPosition(position);\n    }\n    //#endregion\n    normalizePosition(position, affinity) {\n        return position;\n    }\n    /**\n     * Gets the column at which indentation stops at a given line.\n     * @internal\n    */\n    getLineIndentColumn(lineNumber) {\n        // Columns start with 1.\n        return indentOfLine(this.getLineContent(lineNumber)) + 1;\n    }\n};\nTextModel._MODEL_SYNC_LIMIT = 50 * 1024 * 1024; // 50 MB,  // used in tests\nTextModel.LARGE_FILE_SIZE_THRESHOLD = 20 * 1024 * 1024; // 20 MB;\nTextModel.LARGE_FILE_LINE_COUNT_THRESHOLD = 300 * 1000; // 300K lines\nTextModel.LARGE_FILE_HEAP_OPERATION_THRESHOLD = 256 * 1024 * 1024; // 256M characters, usually ~> 512MB memory usage\nTextModel.DEFAULT_CREATION_OPTIONS = {\n    isForSimpleWidget: false,\n    tabSize: EDITOR_MODEL_DEFAULTS.tabSize,\n    indentSize: EDITOR_MODEL_DEFAULTS.indentSize,\n    insertSpaces: EDITOR_MODEL_DEFAULTS.insertSpaces,\n    detectIndentation: false,\n    defaultEOL: 1 /* model.DefaultEndOfLine.LF */,\n    trimAutoWhitespace: EDITOR_MODEL_DEFAULTS.trimAutoWhitespace,\n    largeFileOptimizations: EDITOR_MODEL_DEFAULTS.largeFileOptimizations,\n    bracketPairColorizationOptions: EDITOR_MODEL_DEFAULTS.bracketPairColorizationOptions,\n};\nTextModel = TextModel_1 = __decorate([\n    __param(4, IUndoRedoService),\n    __param(5, ILanguageService),\n    __param(6, ILanguageConfigurationService)\n], TextModel);\nexport { TextModel };\nfunction indentOfLine(line) {\n    let indent = 0;\n    for (const c of line) {\n        if (c === ' ' || c === '\\t') {\n            indent++;\n        }\n        else {\n            break;\n        }\n    }\n    return indent;\n}\n//#region Decorations\nfunction isNodeInOverviewRuler(node) {\n    return (node.options.overviewRuler && node.options.overviewRuler.color ? true : false);\n}\nfunction isOptionsInjectedText(options) {\n    return !!options.after || !!options.before;\n}\nfunction isNodeInjectedText(node) {\n    return !!node.options.after || !!node.options.before;\n}\nclass DecorationsTrees {\n    constructor() {\n        this._decorationsTree0 = new IntervalTree();\n        this._decorationsTree1 = new IntervalTree();\n        this._injectedTextDecorationsTree = new IntervalTree();\n    }\n    ensureAllNodesHaveRanges(host) {\n        this.getAll(host, 0, false, false, false);\n    }\n    _ensureNodesHaveRanges(host, nodes) {\n        for (const node of nodes) {\n            if (node.range === null) {\n                node.range = host.getRangeAt(node.cachedAbsoluteStart, node.cachedAbsoluteEnd);\n            }\n        }\n        return nodes;\n    }\n    getAllInInterval(host, start, end, filterOwnerId, filterOutValidation, onlyMarginDecorations) {\n        const versionId = host.getVersionId();\n        const result = this._intervalSearch(start, end, filterOwnerId, filterOutValidation, versionId, onlyMarginDecorations);\n        return this._ensureNodesHaveRanges(host, result);\n    }\n    _intervalSearch(start, end, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations) {\n        const r0 = this._decorationsTree0.intervalSearch(start, end, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);\n        const r1 = this._decorationsTree1.intervalSearch(start, end, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);\n        const r2 = this._injectedTextDecorationsTree.intervalSearch(start, end, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);\n        return r0.concat(r1).concat(r2);\n    }\n    getInjectedTextInInterval(host, start, end, filterOwnerId) {\n        const versionId = host.getVersionId();\n        const result = this._injectedTextDecorationsTree.intervalSearch(start, end, filterOwnerId, false, versionId, false);\n        return this._ensureNodesHaveRanges(host, result).filter((i) => i.options.showIfCollapsed || !i.range.isEmpty());\n    }\n    getAllInjectedText(host, filterOwnerId) {\n        const versionId = host.getVersionId();\n        const result = this._injectedTextDecorationsTree.search(filterOwnerId, false, versionId, false);\n        return this._ensureNodesHaveRanges(host, result).filter((i) => i.options.showIfCollapsed || !i.range.isEmpty());\n    }\n    getAll(host, filterOwnerId, filterOutValidation, overviewRulerOnly, onlyMarginDecorations) {\n        const versionId = host.getVersionId();\n        const result = this._search(filterOwnerId, filterOutValidation, overviewRulerOnly, versionId, onlyMarginDecorations);\n        return this._ensureNodesHaveRanges(host, result);\n    }\n    _search(filterOwnerId, filterOutValidation, overviewRulerOnly, cachedVersionId, onlyMarginDecorations) {\n        if (overviewRulerOnly) {\n            return this._decorationsTree1.search(filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);\n        }\n        else {\n            const r0 = this._decorationsTree0.search(filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);\n            const r1 = this._decorationsTree1.search(filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);\n            const r2 = this._injectedTextDecorationsTree.search(filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);\n            return r0.concat(r1).concat(r2);\n        }\n    }\n    collectNodesFromOwner(ownerId) {\n        const r0 = this._decorationsTree0.collectNodesFromOwner(ownerId);\n        const r1 = this._decorationsTree1.collectNodesFromOwner(ownerId);\n        const r2 = this._injectedTextDecorationsTree.collectNodesFromOwner(ownerId);\n        return r0.concat(r1).concat(r2);\n    }\n    collectNodesPostOrder() {\n        const r0 = this._decorationsTree0.collectNodesPostOrder();\n        const r1 = this._decorationsTree1.collectNodesPostOrder();\n        const r2 = this._injectedTextDecorationsTree.collectNodesPostOrder();\n        return r0.concat(r1).concat(r2);\n    }\n    insert(node) {\n        if (isNodeInjectedText(node)) {\n            this._injectedTextDecorationsTree.insert(node);\n        }\n        else if (isNodeInOverviewRuler(node)) {\n            this._decorationsTree1.insert(node);\n        }\n        else {\n            this._decorationsTree0.insert(node);\n        }\n    }\n    delete(node) {\n        if (isNodeInjectedText(node)) {\n            this._injectedTextDecorationsTree.delete(node);\n        }\n        else if (isNodeInOverviewRuler(node)) {\n            this._decorationsTree1.delete(node);\n        }\n        else {\n            this._decorationsTree0.delete(node);\n        }\n    }\n    getNodeRange(host, node) {\n        const versionId = host.getVersionId();\n        if (node.cachedVersionId !== versionId) {\n            this._resolveNode(node, versionId);\n        }\n        if (node.range === null) {\n            node.range = host.getRangeAt(node.cachedAbsoluteStart, node.cachedAbsoluteEnd);\n        }\n        return node.range;\n    }\n    _resolveNode(node, cachedVersionId) {\n        if (isNodeInjectedText(node)) {\n            this._injectedTextDecorationsTree.resolveNode(node, cachedVersionId);\n        }\n        else if (isNodeInOverviewRuler(node)) {\n            this._decorationsTree1.resolveNode(node, cachedVersionId);\n        }\n        else {\n            this._decorationsTree0.resolveNode(node, cachedVersionId);\n        }\n    }\n    acceptReplace(offset, length, textLength, forceMoveMarkers) {\n        this._decorationsTree0.acceptReplace(offset, length, textLength, forceMoveMarkers);\n        this._decorationsTree1.acceptReplace(offset, length, textLength, forceMoveMarkers);\n        this._injectedTextDecorationsTree.acceptReplace(offset, length, textLength, forceMoveMarkers);\n    }\n}\nfunction cleanClassName(className) {\n    return className.replace(/[^a-z0-9\\-_]/gi, ' ');\n}\nclass DecorationOptions {\n    constructor(options) {\n        this.color = options.color || '';\n        this.darkColor = options.darkColor || '';\n    }\n}\nexport class ModelDecorationOverviewRulerOptions extends DecorationOptions {\n    constructor(options) {\n        super(options);\n        this._resolvedColor = null;\n        this.position = (typeof options.position === 'number' ? options.position : model.OverviewRulerLane.Center);\n    }\n    getColor(theme) {\n        if (!this._resolvedColor) {\n            if (theme.type !== 'light' && this.darkColor) {\n                this._resolvedColor = this._resolveColor(this.darkColor, theme);\n            }\n            else {\n                this._resolvedColor = this._resolveColor(this.color, theme);\n            }\n        }\n        return this._resolvedColor;\n    }\n    invalidateCachedColor() {\n        this._resolvedColor = null;\n    }\n    _resolveColor(color, theme) {\n        if (typeof color === 'string') {\n            return color;\n        }\n        const c = color ? theme.getColor(color.id) : null;\n        if (!c) {\n            return '';\n        }\n        return c.toString();\n    }\n}\nexport class ModelDecorationGlyphMarginOptions {\n    constructor(options) {\n        var _a;\n        this.position = (_a = options === null || options === void 0 ? void 0 : options.position) !== null && _a !== void 0 ? _a : model.GlyphMarginLane.Center;\n        this.persistLane = options === null || options === void 0 ? void 0 : options.persistLane;\n    }\n}\nexport class ModelDecorationMinimapOptions extends DecorationOptions {\n    constructor(options) {\n        var _a, _b;\n        super(options);\n        this.position = options.position;\n        this.sectionHeaderStyle = (_a = options.sectionHeaderStyle) !== null && _a !== void 0 ? _a : null;\n        this.sectionHeaderText = (_b = options.sectionHeaderText) !== null && _b !== void 0 ? _b : null;\n    }\n    getColor(theme) {\n        if (!this._resolvedColor) {\n            if (theme.type !== 'light' && this.darkColor) {\n                this._resolvedColor = this._resolveColor(this.darkColor, theme);\n            }\n            else {\n                this._resolvedColor = this._resolveColor(this.color, theme);\n            }\n        }\n        return this._resolvedColor;\n    }\n    invalidateCachedColor() {\n        this._resolvedColor = undefined;\n    }\n    _resolveColor(color, theme) {\n        if (typeof color === 'string') {\n            return Color.fromHex(color);\n        }\n        return theme.getColor(color.id);\n    }\n}\nexport class ModelDecorationInjectedTextOptions {\n    static from(options) {\n        if (options instanceof ModelDecorationInjectedTextOptions) {\n            return options;\n        }\n        return new ModelDecorationInjectedTextOptions(options);\n    }\n    constructor(options) {\n        this.content = options.content || '';\n        this.inlineClassName = options.inlineClassName || null;\n        this.inlineClassNameAffectsLetterSpacing = options.inlineClassNameAffectsLetterSpacing || false;\n        this.attachedData = options.attachedData || null;\n        this.cursorStops = options.cursorStops || null;\n    }\n}\nexport class ModelDecorationOptions {\n    static register(options) {\n        return new ModelDecorationOptions(options);\n    }\n    static createDynamic(options) {\n        return new ModelDecorationOptions(options);\n    }\n    constructor(options) {\n        var _a, _b, _c, _d, _e, _f;\n        this.description = options.description;\n        this.blockClassName = options.blockClassName ? cleanClassName(options.blockClassName) : null;\n        this.blockDoesNotCollapse = (_a = options.blockDoesNotCollapse) !== null && _a !== void 0 ? _a : null;\n        this.blockIsAfterEnd = (_b = options.blockIsAfterEnd) !== null && _b !== void 0 ? _b : null;\n        this.blockPadding = (_c = options.blockPadding) !== null && _c !== void 0 ? _c : null;\n        this.stickiness = options.stickiness || 0 /* model.TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges */;\n        this.zIndex = options.zIndex || 0;\n        this.className = options.className ? cleanClassName(options.className) : null;\n        this.shouldFillLineOnLineBreak = (_d = options.shouldFillLineOnLineBreak) !== null && _d !== void 0 ? _d : null;\n        this.hoverMessage = options.hoverMessage || null;\n        this.glyphMarginHoverMessage = options.glyphMarginHoverMessage || null;\n        this.lineNumberHoverMessage = options.lineNumberHoverMessage || null;\n        this.isWholeLine = options.isWholeLine || false;\n        this.showIfCollapsed = options.showIfCollapsed || false;\n        this.collapseOnReplaceEdit = options.collapseOnReplaceEdit || false;\n        this.overviewRuler = options.overviewRuler ? new ModelDecorationOverviewRulerOptions(options.overviewRuler) : null;\n        this.minimap = options.minimap ? new ModelDecorationMinimapOptions(options.minimap) : null;\n        this.glyphMargin = options.glyphMarginClassName ? new ModelDecorationGlyphMarginOptions(options.glyphMargin) : null;\n        this.glyphMarginClassName = options.glyphMarginClassName ? cleanClassName(options.glyphMarginClassName) : null;\n        this.linesDecorationsClassName = options.linesDecorationsClassName ? cleanClassName(options.linesDecorationsClassName) : null;\n        this.lineNumberClassName = options.lineNumberClassName ? cleanClassName(options.lineNumberClassName) : null;\n        this.linesDecorationsTooltip = options.linesDecorationsTooltip ? strings.htmlAttributeEncodeValue(options.linesDecorationsTooltip) : null;\n        this.firstLineDecorationClassName = options.firstLineDecorationClassName ? cleanClassName(options.firstLineDecorationClassName) : null;\n        this.marginClassName = options.marginClassName ? cleanClassName(options.marginClassName) : null;\n        this.inlineClassName = options.inlineClassName ? cleanClassName(options.inlineClassName) : null;\n        this.inlineClassNameAffectsLetterSpacing = options.inlineClassNameAffectsLetterSpacing || false;\n        this.beforeContentClassName = options.beforeContentClassName ? cleanClassName(options.beforeContentClassName) : null;\n        this.afterContentClassName = options.afterContentClassName ? cleanClassName(options.afterContentClassName) : null;\n        this.after = options.after ? ModelDecorationInjectedTextOptions.from(options.after) : null;\n        this.before = options.before ? ModelDecorationInjectedTextOptions.from(options.before) : null;\n        this.hideInCommentTokens = (_e = options.hideInCommentTokens) !== null && _e !== void 0 ? _e : false;\n        this.hideInStringTokens = (_f = options.hideInStringTokens) !== null && _f !== void 0 ? _f : false;\n    }\n}\nModelDecorationOptions.EMPTY = ModelDecorationOptions.register({ description: 'empty' });\n/**\n * The order carefully matches the values of the enum.\n */\nconst TRACKED_RANGE_OPTIONS = [\n    ModelDecorationOptions.register({ description: 'tracked-range-always-grows-when-typing-at-edges', stickiness: 0 /* model.TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges */ }),\n    ModelDecorationOptions.register({ description: 'tracked-range-never-grows-when-typing-at-edges', stickiness: 1 /* model.TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges */ }),\n    ModelDecorationOptions.register({ description: 'tracked-range-grows-only-when-typing-before', stickiness: 2 /* model.TrackedRangeStickiness.GrowsOnlyWhenTypingBefore */ }),\n    ModelDecorationOptions.register({ description: 'tracked-range-grows-only-when-typing-after', stickiness: 3 /* model.TrackedRangeStickiness.GrowsOnlyWhenTypingAfter */ }),\n];\nfunction _normalizeOptions(options) {\n    if (options instanceof ModelDecorationOptions) {\n        return options;\n    }\n    return ModelDecorationOptions.createDynamic(options);\n}\nclass DidChangeDecorationsEmitter extends Disposable {\n    constructor(handleBeforeFire) {\n        super();\n        this.handleBeforeFire = handleBeforeFire;\n        this._actual = this._register(new Emitter());\n        this.event = this._actual.event;\n        this._affectedInjectedTextLines = null;\n        this._deferredCnt = 0;\n        this._shouldFireDeferred = false;\n        this._affectsMinimap = false;\n        this._affectsOverviewRuler = false;\n        this._affectsGlyphMargin = false;\n        this._affectsLineNumber = false;\n    }\n    beginDeferredEmit() {\n        this._deferredCnt++;\n    }\n    endDeferredEmit() {\n        var _a;\n        this._deferredCnt--;\n        if (this._deferredCnt === 0) {\n            if (this._shouldFireDeferred) {\n                this.doFire();\n            }\n            (_a = this._affectedInjectedTextLines) === null || _a === void 0 ? void 0 : _a.clear();\n            this._affectedInjectedTextLines = null;\n        }\n    }\n    recordLineAffectedByInjectedText(lineNumber) {\n        if (!this._affectedInjectedTextLines) {\n            this._affectedInjectedTextLines = new Set();\n        }\n        this._affectedInjectedTextLines.add(lineNumber);\n    }\n    checkAffectedAndFire(options) {\n        var _a, _b;\n        this._affectsMinimap || (this._affectsMinimap = !!((_a = options.minimap) === null || _a === void 0 ? void 0 : _a.position));\n        this._affectsOverviewRuler || (this._affectsOverviewRuler = !!((_b = options.overviewRuler) === null || _b === void 0 ? void 0 : _b.color));\n        this._affectsGlyphMargin || (this._affectsGlyphMargin = !!options.glyphMarginClassName);\n        this._affectsLineNumber || (this._affectsLineNumber = !!options.lineNumberClassName);\n        this.tryFire();\n    }\n    fire() {\n        this._affectsMinimap = true;\n        this._affectsOverviewRuler = true;\n        this._affectsGlyphMargin = true;\n        this.tryFire();\n    }\n    tryFire() {\n        if (this._deferredCnt === 0) {\n            this.doFire();\n        }\n        else {\n            this._shouldFireDeferred = true;\n        }\n    }\n    doFire() {\n        this.handleBeforeFire(this._affectedInjectedTextLines);\n        const event = {\n            affectsMinimap: this._affectsMinimap,\n            affectsOverviewRuler: this._affectsOverviewRuler,\n            affectsGlyphMargin: this._affectsGlyphMargin,\n            affectsLineNumber: this._affectsLineNumber,\n        };\n        this._shouldFireDeferred = false;\n        this._affectsMinimap = false;\n        this._affectsOverviewRuler = false;\n        this._affectsGlyphMargin = false;\n        this._actual.fire(event);\n    }\n}\n//#endregion\nclass DidChangeContentEmitter extends Disposable {\n    constructor() {\n        super();\n        /**\n         * Both `fastEvent` and `slowEvent` work the same way and contain the same events, but first we invoke `fastEvent` and then `slowEvent`.\n         */\n        this._fastEmitter = this._register(new Emitter());\n        this.fastEvent = this._fastEmitter.event;\n        this._slowEmitter = this._register(new Emitter());\n        this.slowEvent = this._slowEmitter.event;\n        this._deferredCnt = 0;\n        this._deferredEvent = null;\n    }\n    beginDeferredEmit() {\n        this._deferredCnt++;\n    }\n    endDeferredEmit(resultingSelection = null) {\n        this._deferredCnt--;\n        if (this._deferredCnt === 0) {\n            if (this._deferredEvent !== null) {\n                this._deferredEvent.rawContentChangedEvent.resultingSelection = resultingSelection;\n                const e = this._deferredEvent;\n                this._deferredEvent = null;\n                this._fastEmitter.fire(e);\n                this._slowEmitter.fire(e);\n            }\n        }\n    }\n    fire(e) {\n        if (this._deferredCnt > 0) {\n            if (this._deferredEvent) {\n                this._deferredEvent = this._deferredEvent.merge(e);\n            }\n            else {\n                this._deferredEvent = e;\n            }\n            return;\n        }\n        this._fastEmitter.fire(e);\n        this._slowEmitter.fire(e);\n    }\n}\n/**\n * @internal\n */\nexport class AttachedViews {\n    constructor() {\n        this._onDidChangeVisibleRanges = new Emitter();\n        this.onDidChangeVisibleRanges = this._onDidChangeVisibleRanges.event;\n        this._views = new Set();\n    }\n    attachView() {\n        const view = new AttachedViewImpl((state) => {\n            this._onDidChangeVisibleRanges.fire({ view, state });\n        });\n        this._views.add(view);\n        return view;\n    }\n    detachView(view) {\n        this._views.delete(view);\n        this._onDidChangeVisibleRanges.fire({ view, state: undefined });\n    }\n}\nclass AttachedViewImpl {\n    constructor(handleStateChange) {\n        this.handleStateChange = handleStateChange;\n    }\n    setVisibleLines(visibleLines, stabilized) {\n        const visibleLineRanges = visibleLines.map((line) => new LineRange(line.startLineNumber, line.endLineNumber + 1));\n        this.handleStateChange({ visibleLineRanges, stabilized });\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 { Disposable } from '../../../base/common/lifecycle.js';\nexport class TextModelPart extends Disposable {\n    constructor() {\n        super(...arguments);\n        this._isDisposed = false;\n    }\n    dispose() {\n        super.dispose();\n        this._isDisposed = true;\n    }\n    assertNotDisposed() {\n        if (this._isDisposed) {\n            throw new Error('TextModelPart is disposed!');\n        }\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 * as strings from '../../../base/common/strings.js';\nimport { getMapForWordSeparators } from '../core/wordCharacterClassifier.js';\nimport { Position } from '../core/position.js';\nimport { Range } from '../core/range.js';\nimport { FindMatch, SearchData } from '../model.js';\nconst LIMIT_FIND_COUNT = 999;\nexport class SearchParams {\n    constructor(searchString, isRegex, matchCase, wordSeparators) {\n        this.searchString = searchString;\n        this.isRegex = isRegex;\n        this.matchCase = matchCase;\n        this.wordSeparators = wordSeparators;\n    }\n    parseSearchRequest() {\n        if (this.searchString === '') {\n            return null;\n        }\n        // Try to create a RegExp out of the params\n        let multiline;\n        if (this.isRegex) {\n            multiline = isMultilineRegexSource(this.searchString);\n        }\n        else {\n            multiline = (this.searchString.indexOf('\\n') >= 0);\n        }\n        let regex = null;\n        try {\n            regex = strings.createRegExp(this.searchString, this.isRegex, {\n                matchCase: this.matchCase,\n                wholeWord: false,\n                multiline: multiline,\n                global: true,\n                unicode: true\n            });\n        }\n        catch (err) {\n            return null;\n        }\n        if (!regex) {\n            return null;\n        }\n        let canUseSimpleSearch = (!this.isRegex && !multiline);\n        if (canUseSimpleSearch && this.searchString.toLowerCase() !== this.searchString.toUpperCase()) {\n            // casing might make a difference\n            canUseSimpleSearch = this.matchCase;\n        }\n        return new SearchData(regex, this.wordSeparators ? getMapForWordSeparators(this.wordSeparators, []) : null, canUseSimpleSearch ? this.searchString : null);\n    }\n}\nexport function isMultilineRegexSource(searchString) {\n    if (!searchString || searchString.length === 0) {\n        return false;\n    }\n    for (let i = 0, len = searchString.length; i < len; i++) {\n        const chCode = searchString.charCodeAt(i);\n        if (chCode === 10 /* CharCode.LineFeed */) {\n            return true;\n        }\n        if (chCode === 92 /* CharCode.Backslash */) {\n            // move to next char\n            i++;\n            if (i >= len) {\n                // string ends with a \\\n                break;\n            }\n            const nextChCode = searchString.charCodeAt(i);\n            if (nextChCode === 110 /* CharCode.n */ || nextChCode === 114 /* CharCode.r */ || nextChCode === 87 /* CharCode.W */) {\n                return true;\n            }\n        }\n    }\n    return false;\n}\nexport function createFindMatch(range, rawMatches, captureMatches) {\n    if (!captureMatches) {\n        return new FindMatch(range, null);\n    }\n    const matches = [];\n    for (let i = 0, len = rawMatches.length; i < len; i++) {\n        matches[i] = rawMatches[i];\n    }\n    return new FindMatch(range, matches);\n}\nclass LineFeedCounter {\n    constructor(text) {\n        const lineFeedsOffsets = [];\n        let lineFeedsOffsetsLen = 0;\n        for (let i = 0, textLen = text.length; i < textLen; i++) {\n            if (text.charCodeAt(i) === 10 /* CharCode.LineFeed */) {\n                lineFeedsOffsets[lineFeedsOffsetsLen++] = i;\n            }\n        }\n        this._lineFeedsOffsets = lineFeedsOffsets;\n    }\n    findLineFeedCountBeforeOffset(offset) {\n        const lineFeedsOffsets = this._lineFeedsOffsets;\n        let min = 0;\n        let max = lineFeedsOffsets.length - 1;\n        if (max === -1) {\n            // no line feeds\n            return 0;\n        }\n        if (offset <= lineFeedsOffsets[0]) {\n            // before first line feed\n            return 0;\n        }\n        while (min < max) {\n            const mid = min + ((max - min) / 2 >> 0);\n            if (lineFeedsOffsets[mid] >= offset) {\n                max = mid - 1;\n            }\n            else {\n                if (lineFeedsOffsets[mid + 1] >= offset) {\n                    // bingo!\n                    min = mid;\n                    max = mid;\n                }\n                else {\n                    min = mid + 1;\n                }\n            }\n        }\n        return min + 1;\n    }\n}\nexport class TextModelSearch {\n    static findMatches(model, searchParams, searchRange, captureMatches, limitResultCount) {\n        const searchData = searchParams.parseSearchRequest();\n        if (!searchData) {\n            return [];\n        }\n        if (searchData.regex.multiline) {\n            return this._doFindMatchesMultiline(model, searchRange, new Searcher(searchData.wordSeparators, searchData.regex), captureMatches, limitResultCount);\n        }\n        return this._doFindMatchesLineByLine(model, searchRange, searchData, captureMatches, limitResultCount);\n    }\n    /**\n     * Multiline search always executes on the lines concatenated with \\n.\n     * We must therefore compensate for the count of \\n in case the model is CRLF\n     */\n    static _getMultilineMatchRange(model, deltaOffset, text, lfCounter, matchIndex, match0) {\n        let startOffset;\n        let lineFeedCountBeforeMatch = 0;\n        if (lfCounter) {\n            lineFeedCountBeforeMatch = lfCounter.findLineFeedCountBeforeOffset(matchIndex);\n            startOffset = deltaOffset + matchIndex + lineFeedCountBeforeMatch /* add as many \\r as there were \\n */;\n        }\n        else {\n            startOffset = deltaOffset + matchIndex;\n        }\n        let endOffset;\n        if (lfCounter) {\n            const lineFeedCountBeforeEndOfMatch = lfCounter.findLineFeedCountBeforeOffset(matchIndex + match0.length);\n            const lineFeedCountInMatch = lineFeedCountBeforeEndOfMatch - lineFeedCountBeforeMatch;\n            endOffset = startOffset + match0.length + lineFeedCountInMatch /* add as many \\r as there were \\n */;\n        }\n        else {\n            endOffset = startOffset + match0.length;\n        }\n        const startPosition = model.getPositionAt(startOffset);\n        const endPosition = model.getPositionAt(endOffset);\n        return new Range(startPosition.lineNumber, startPosition.column, endPosition.lineNumber, endPosition.column);\n    }\n    static _doFindMatchesMultiline(model, searchRange, searcher, captureMatches, limitResultCount) {\n        const deltaOffset = model.getOffsetAt(searchRange.getStartPosition());\n        // We always execute multiline search over the lines joined with \\n\n        // This makes it that \\n will match the EOL for both CRLF and LF models\n        // We compensate for offset errors in `_getMultilineMatchRange`\n        const text = model.getValueInRange(searchRange, 1 /* EndOfLinePreference.LF */);\n        const lfCounter = (model.getEOL() === '\\r\\n' ? new LineFeedCounter(text) : null);\n        const result = [];\n        let counter = 0;\n        let m;\n        searcher.reset(0);\n        while ((m = searcher.next(text))) {\n            result[counter++] = createFindMatch(this._getMultilineMatchRange(model, deltaOffset, text, lfCounter, m.index, m[0]), m, captureMatches);\n            if (counter >= limitResultCount) {\n                return result;\n            }\n        }\n        return result;\n    }\n    static _doFindMatchesLineByLine(model, searchRange, searchData, captureMatches, limitResultCount) {\n        const result = [];\n        let resultLen = 0;\n        // Early case for a search range that starts & stops on the same line number\n        if (searchRange.startLineNumber === searchRange.endLineNumber) {\n            const text = model.getLineContent(searchRange.startLineNumber).substring(searchRange.startColumn - 1, searchRange.endColumn - 1);\n            resultLen = this._findMatchesInLine(searchData, text, searchRange.startLineNumber, searchRange.startColumn - 1, resultLen, result, captureMatches, limitResultCount);\n            return result;\n        }\n        // Collect results from first line\n        const text = model.getLineContent(searchRange.startLineNumber).substring(searchRange.startColumn - 1);\n        resultLen = this._findMatchesInLine(searchData, text, searchRange.startLineNumber, searchRange.startColumn - 1, resultLen, result, captureMatches, limitResultCount);\n        // Collect results from middle lines\n        for (let lineNumber = searchRange.startLineNumber + 1; lineNumber < searchRange.endLineNumber && resultLen < limitResultCount; lineNumber++) {\n            resultLen = this._findMatchesInLine(searchData, model.getLineContent(lineNumber), lineNumber, 0, resultLen, result, captureMatches, limitResultCount);\n        }\n        // Collect results from last line\n        if (resultLen < limitResultCount) {\n            const text = model.getLineContent(searchRange.endLineNumber).substring(0, searchRange.endColumn - 1);\n            resultLen = this._findMatchesInLine(searchData, text, searchRange.endLineNumber, 0, resultLen, result, captureMatches, limitResultCount);\n        }\n        return result;\n    }\n    static _findMatchesInLine(searchData, text, lineNumber, deltaOffset, resultLen, result, captureMatches, limitResultCount) {\n        const wordSeparators = searchData.wordSeparators;\n        if (!captureMatches && searchData.simpleSearch) {\n            const searchString = searchData.simpleSearch;\n            const searchStringLen = searchString.length;\n            const textLength = text.length;\n            let lastMatchIndex = -searchStringLen;\n            while ((lastMatchIndex = text.indexOf(searchString, lastMatchIndex + searchStringLen)) !== -1) {\n                if (!wordSeparators || isValidMatch(wordSeparators, text, textLength, lastMatchIndex, searchStringLen)) {\n                    result[resultLen++] = new FindMatch(new Range(lineNumber, lastMatchIndex + 1 + deltaOffset, lineNumber, lastMatchIndex + 1 + searchStringLen + deltaOffset), null);\n                    if (resultLen >= limitResultCount) {\n                        return resultLen;\n                    }\n                }\n            }\n            return resultLen;\n        }\n        const searcher = new Searcher(searchData.wordSeparators, searchData.regex);\n        let m;\n        // Reset regex to search from the beginning\n        searcher.reset(0);\n        do {\n            m = searcher.next(text);\n            if (m) {\n                result[resultLen++] = createFindMatch(new Range(lineNumber, m.index + 1 + deltaOffset, lineNumber, m.index + 1 + m[0].length + deltaOffset), m, captureMatches);\n                if (resultLen >= limitResultCount) {\n                    return resultLen;\n                }\n            }\n        } while (m);\n        return resultLen;\n    }\n    static findNextMatch(model, searchParams, searchStart, captureMatches) {\n        const searchData = searchParams.parseSearchRequest();\n        if (!searchData) {\n            return null;\n        }\n        const searcher = new Searcher(searchData.wordSeparators, searchData.regex);\n        if (searchData.regex.multiline) {\n            return this._doFindNextMatchMultiline(model, searchStart, searcher, captureMatches);\n        }\n        return this._doFindNextMatchLineByLine(model, searchStart, searcher, captureMatches);\n    }\n    static _doFindNextMatchMultiline(model, searchStart, searcher, captureMatches) {\n        const searchTextStart = new Position(searchStart.lineNumber, 1);\n        const deltaOffset = model.getOffsetAt(searchTextStart);\n        const lineCount = model.getLineCount();\n        // We always execute multiline search over the lines joined with \\n\n        // This makes it that \\n will match the EOL for both CRLF and LF models\n        // We compensate for offset errors in `_getMultilineMatchRange`\n        const text = model.getValueInRange(new Range(searchTextStart.lineNumber, searchTextStart.column, lineCount, model.getLineMaxColumn(lineCount)), 1 /* EndOfLinePreference.LF */);\n        const lfCounter = (model.getEOL() === '\\r\\n' ? new LineFeedCounter(text) : null);\n        searcher.reset(searchStart.column - 1);\n        const m = searcher.next(text);\n        if (m) {\n            return createFindMatch(this._getMultilineMatchRange(model, deltaOffset, text, lfCounter, m.index, m[0]), m, captureMatches);\n        }\n        if (searchStart.lineNumber !== 1 || searchStart.column !== 1) {\n            // Try again from the top\n            return this._doFindNextMatchMultiline(model, new Position(1, 1), searcher, captureMatches);\n        }\n        return null;\n    }\n    static _doFindNextMatchLineByLine(model, searchStart, searcher, captureMatches) {\n        const lineCount = model.getLineCount();\n        const startLineNumber = searchStart.lineNumber;\n        // Look in first line\n        const text = model.getLineContent(startLineNumber);\n        const r = this._findFirstMatchInLine(searcher, text, startLineNumber, searchStart.column, captureMatches);\n        if (r) {\n            return r;\n        }\n        for (let i = 1; i <= lineCount; i++) {\n            const lineIndex = (startLineNumber + i - 1) % lineCount;\n            const text = model.getLineContent(lineIndex + 1);\n            const r = this._findFirstMatchInLine(searcher, text, lineIndex + 1, 1, captureMatches);\n            if (r) {\n                return r;\n            }\n        }\n        return null;\n    }\n    static _findFirstMatchInLine(searcher, text, lineNumber, fromColumn, captureMatches) {\n        // Set regex to search from column\n        searcher.reset(fromColumn - 1);\n        const m = searcher.next(text);\n        if (m) {\n            return createFindMatch(new Range(lineNumber, m.index + 1, lineNumber, m.index + 1 + m[0].length), m, captureMatches);\n        }\n        return null;\n    }\n    static findPreviousMatch(model, searchParams, searchStart, captureMatches) {\n        const searchData = searchParams.parseSearchRequest();\n        if (!searchData) {\n            return null;\n        }\n        const searcher = new Searcher(searchData.wordSeparators, searchData.regex);\n        if (searchData.regex.multiline) {\n            return this._doFindPreviousMatchMultiline(model, searchStart, searcher, captureMatches);\n        }\n        return this._doFindPreviousMatchLineByLine(model, searchStart, searcher, captureMatches);\n    }\n    static _doFindPreviousMatchMultiline(model, searchStart, searcher, captureMatches) {\n        const matches = this._doFindMatchesMultiline(model, new Range(1, 1, searchStart.lineNumber, searchStart.column), searcher, captureMatches, 10 * LIMIT_FIND_COUNT);\n        if (matches.length > 0) {\n            return matches[matches.length - 1];\n        }\n        const lineCount = model.getLineCount();\n        if (searchStart.lineNumber !== lineCount || searchStart.column !== model.getLineMaxColumn(lineCount)) {\n            // Try again with all content\n            return this._doFindPreviousMatchMultiline(model, new Position(lineCount, model.getLineMaxColumn(lineCount)), searcher, captureMatches);\n        }\n        return null;\n    }\n    static _doFindPreviousMatchLineByLine(model, searchStart, searcher, captureMatches) {\n        const lineCount = model.getLineCount();\n        const startLineNumber = searchStart.lineNumber;\n        // Look in first line\n        const text = model.getLineContent(startLineNumber).substring(0, searchStart.column - 1);\n        const r = this._findLastMatchInLine(searcher, text, startLineNumber, captureMatches);\n        if (r) {\n            return r;\n        }\n        for (let i = 1; i <= lineCount; i++) {\n            const lineIndex = (lineCount + startLineNumber - i - 1) % lineCount;\n            const text = model.getLineContent(lineIndex + 1);\n            const r = this._findLastMatchInLine(searcher, text, lineIndex + 1, captureMatches);\n            if (r) {\n                return r;\n            }\n        }\n        return null;\n    }\n    static _findLastMatchInLine(searcher, text, lineNumber, captureMatches) {\n        let bestResult = null;\n        let m;\n        searcher.reset(0);\n        while ((m = searcher.next(text))) {\n            bestResult = createFindMatch(new Range(lineNumber, m.index + 1, lineNumber, m.index + 1 + m[0].length), m, captureMatches);\n        }\n        return bestResult;\n    }\n}\nfunction leftIsWordBounday(wordSeparators, text, textLength, matchStartIndex, matchLength) {\n    if (matchStartIndex === 0) {\n        // Match starts at start of string\n        return true;\n    }\n    const charBefore = text.charCodeAt(matchStartIndex - 1);\n    if (wordSeparators.get(charBefore) !== 0 /* WordCharacterClass.Regular */) {\n        // The character before the match is a word separator\n        return true;\n    }\n    if (charBefore === 13 /* CharCode.CarriageReturn */ || charBefore === 10 /* CharCode.LineFeed */) {\n        // The character before the match is line break or carriage return.\n        return true;\n    }\n    if (matchLength > 0) {\n        const firstCharInMatch = text.charCodeAt(matchStartIndex);\n        if (wordSeparators.get(firstCharInMatch) !== 0 /* WordCharacterClass.Regular */) {\n            // The first character inside the match is a word separator\n            return true;\n        }\n    }\n    return false;\n}\nfunction rightIsWordBounday(wordSeparators, text, textLength, matchStartIndex, matchLength) {\n    if (matchStartIndex + matchLength === textLength) {\n        // Match ends at end of string\n        return true;\n    }\n    const charAfter = text.charCodeAt(matchStartIndex + matchLength);\n    if (wordSeparators.get(charAfter) !== 0 /* WordCharacterClass.Regular */) {\n        // The character after the match is a word separator\n        return true;\n    }\n    if (charAfter === 13 /* CharCode.CarriageReturn */ || charAfter === 10 /* CharCode.LineFeed */) {\n        // The character after the match is line break or carriage return.\n        return true;\n    }\n    if (matchLength > 0) {\n        const lastCharInMatch = text.charCodeAt(matchStartIndex + matchLength - 1);\n        if (wordSeparators.get(lastCharInMatch) !== 0 /* WordCharacterClass.Regular */) {\n            // The last character in the match is a word separator\n            return true;\n        }\n    }\n    return false;\n}\nexport function isValidMatch(wordSeparators, text, textLength, matchStartIndex, matchLength) {\n    return (leftIsWordBounday(wordSeparators, text, textLength, matchStartIndex, matchLength)\n        && rightIsWordBounday(wordSeparators, text, textLength, matchStartIndex, matchLength));\n}\nexport class Searcher {\n    constructor(wordSeparators, searchRegex) {\n        this._wordSeparators = wordSeparators;\n        this._searchRegex = searchRegex;\n        this._prevMatchStartIndex = -1;\n        this._prevMatchLength = 0;\n    }\n    reset(lastIndex) {\n        this._searchRegex.lastIndex = lastIndex;\n        this._prevMatchStartIndex = -1;\n        this._prevMatchLength = 0;\n    }\n    next(text) {\n        const textLength = text.length;\n        let m;\n        do {\n            if (this._prevMatchStartIndex + this._prevMatchLength === textLength) {\n                // Reached the end of the line\n                return null;\n            }\n            m = this._searchRegex.exec(text);\n            if (!m) {\n                return null;\n            }\n            const matchStartIndex = m.index;\n            const matchLength = m[0].length;\n            if (matchStartIndex === this._prevMatchStartIndex && matchLength === this._prevMatchLength) {\n                if (matchLength === 0) {\n                    // the search result is an empty string and won't advance `regex.lastIndex`, so `regex.exec` will stuck here\n                    // we attempt to recover from that by advancing by two if surrogate pair found and by one otherwise\n                    if (strings.getNextCodePoint(text, textLength, this._searchRegex.lastIndex) > 0xFFFF) {\n                        this._searchRegex.lastIndex += 2;\n                    }\n                    else {\n                        this._searchRegex.lastIndex += 1;\n                    }\n                    continue;\n                }\n                // Exit early if the regex matches the same range twice\n                return null;\n            }\n            this._prevMatchStartIndex = matchStartIndex;\n            this._prevMatchLength = matchLength;\n            if (!this._wordSeparators || isValidMatch(this._wordSeparators, text, textLength, matchStartIndex, matchLength)) {\n                return m;\n            }\n        } while (m);\n        return null;\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 { AbstractText } from '../core/textEdit.js';\nimport { TextLength } from '../core/textLength.js';\nexport class TextModelText extends AbstractText {\n    constructor(_textModel) {\n        super();\n        this._textModel = _textModel;\n    }\n    getValueOfRange(range) {\n        return this._textModel.getValueInRange(range);\n    }\n    get length() {\n        const lastLineNumber = this._textModel.getLineCount();\n        const lastLineLen = this._textModel.getLineLength(lastLineNumber);\n        return new TextLength(lastLineNumber - 1, lastLineLen);\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 { runWhenGlobalIdle } from '../../../base/common/async.js';\nimport { BugIndicatingError, onUnexpectedError } from '../../../base/common/errors.js';\nimport { setTimeout0 } from '../../../base/common/platform.js';\nimport { StopWatch } from '../../../base/common/stopwatch.js';\nimport { countEOL } from '../core/eolCounter.js';\nimport { LineRange } from '../core/lineRange.js';\nimport { OffsetRange } from '../core/offsetRange.js';\nimport { nullTokenizeEncoded } from '../languages/nullTokenize.js';\nimport { FixedArray } from './fixedArray.js';\nimport { ContiguousMultilineTokensBuilder } from '../tokens/contiguousMultilineTokensBuilder.js';\nimport { LineTokens } from '../tokens/lineTokens.js';\nexport class TokenizerWithStateStore {\n    constructor(lineCount, tokenizationSupport) {\n        this.tokenizationSupport = tokenizationSupport;\n        this.initialState = this.tokenizationSupport.getInitialState();\n        this.store = new TrackingTokenizationStateStore(lineCount);\n    }\n    getStartState(lineNumber) {\n        return this.store.getStartState(lineNumber, this.initialState);\n    }\n    getFirstInvalidLine() {\n        return this.store.getFirstInvalidLine(this.initialState);\n    }\n}\nexport class TokenizerWithStateStoreAndTextModel extends TokenizerWithStateStore {\n    constructor(lineCount, tokenizationSupport, _textModel, _languageIdCodec) {\n        super(lineCount, tokenizationSupport);\n        this._textModel = _textModel;\n        this._languageIdCodec = _languageIdCodec;\n    }\n    updateTokensUntilLine(builder, lineNumber) {\n        const languageId = this._textModel.getLanguageId();\n        while (true) {\n            const lineToTokenize = this.getFirstInvalidLine();\n            if (!lineToTokenize || lineToTokenize.lineNumber > lineNumber) {\n                break;\n            }\n            const text = this._textModel.getLineContent(lineToTokenize.lineNumber);\n            const r = safeTokenize(this._languageIdCodec, languageId, this.tokenizationSupport, text, true, lineToTokenize.startState);\n            builder.add(lineToTokenize.lineNumber, r.tokens);\n            this.store.setEndState(lineToTokenize.lineNumber, r.endState);\n        }\n    }\n    /** assumes state is up to date */\n    getTokenTypeIfInsertingCharacter(position, character) {\n        // TODO@hediet: use tokenizeLineWithEdit\n        const lineStartState = this.getStartState(position.lineNumber);\n        if (!lineStartState) {\n            return 0 /* StandardTokenType.Other */;\n        }\n        const languageId = this._textModel.getLanguageId();\n        const lineContent = this._textModel.getLineContent(position.lineNumber);\n        // Create the text as if `character` was inserted\n        const text = (lineContent.substring(0, position.column - 1)\n            + character\n            + lineContent.substring(position.column - 1));\n        const r = safeTokenize(this._languageIdCodec, languageId, this.tokenizationSupport, text, true, lineStartState);\n        const lineTokens = new LineTokens(r.tokens, text, this._languageIdCodec);\n        if (lineTokens.getCount() === 0) {\n            return 0 /* StandardTokenType.Other */;\n        }\n        const tokenIndex = lineTokens.findTokenIndexAtOffset(position.column - 1);\n        return lineTokens.getStandardTokenType(tokenIndex);\n    }\n    /** assumes state is up to date */\n    tokenizeLineWithEdit(position, length, newText) {\n        const lineNumber = position.lineNumber;\n        const column = position.column;\n        const lineStartState = this.getStartState(lineNumber);\n        if (!lineStartState) {\n            return null;\n        }\n        const curLineContent = this._textModel.getLineContent(lineNumber);\n        const newLineContent = curLineContent.substring(0, column - 1)\n            + newText + curLineContent.substring(column - 1 + length);\n        const languageId = this._textModel.getLanguageIdAtPosition(lineNumber, 0);\n        const result = safeTokenize(this._languageIdCodec, languageId, this.tokenizationSupport, newLineContent, true, lineStartState);\n        const lineTokens = new LineTokens(result.tokens, newLineContent, this._languageIdCodec);\n        return lineTokens;\n    }\n    hasAccurateTokensForLine(lineNumber) {\n        const firstInvalidLineNumber = this.store.getFirstInvalidEndStateLineNumberOrMax();\n        return (lineNumber < firstInvalidLineNumber);\n    }\n    isCheapToTokenize(lineNumber) {\n        const firstInvalidLineNumber = this.store.getFirstInvalidEndStateLineNumberOrMax();\n        if (lineNumber < firstInvalidLineNumber) {\n            return true;\n        }\n        if (lineNumber === firstInvalidLineNumber\n            && this._textModel.getLineLength(lineNumber) < 2048 /* Constants.CHEAP_TOKENIZATION_LENGTH_LIMIT */) {\n            return true;\n        }\n        return false;\n    }\n    /**\n     * The result is not cached.\n     */\n    tokenizeHeuristically(builder, startLineNumber, endLineNumber) {\n        if (endLineNumber <= this.store.getFirstInvalidEndStateLineNumberOrMax()) {\n            // nothing to do\n            return { heuristicTokens: false };\n        }\n        if (startLineNumber <= this.store.getFirstInvalidEndStateLineNumberOrMax()) {\n            // tokenization has reached the viewport start...\n            this.updateTokensUntilLine(builder, endLineNumber);\n            return { heuristicTokens: false };\n        }\n        let state = this.guessStartState(startLineNumber);\n        const languageId = this._textModel.getLanguageId();\n        for (let lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber++) {\n            const text = this._textModel.getLineContent(lineNumber);\n            const r = safeTokenize(this._languageIdCodec, languageId, this.tokenizationSupport, text, true, state);\n            builder.add(lineNumber, r.tokens);\n            state = r.endState;\n        }\n        return { heuristicTokens: true };\n    }\n    guessStartState(lineNumber) {\n        let nonWhitespaceColumn = this._textModel.getLineFirstNonWhitespaceColumn(lineNumber);\n        const likelyRelevantLines = [];\n        let initialState = null;\n        for (let i = lineNumber - 1; nonWhitespaceColumn > 1 && i >= 1; i--) {\n            const newNonWhitespaceIndex = this._textModel.getLineFirstNonWhitespaceColumn(i);\n            // Ignore lines full of whitespace\n            if (newNonWhitespaceIndex === 0) {\n                continue;\n            }\n            if (newNonWhitespaceIndex < nonWhitespaceColumn) {\n                likelyRelevantLines.push(this._textModel.getLineContent(i));\n                nonWhitespaceColumn = newNonWhitespaceIndex;\n                initialState = this.getStartState(i);\n                if (initialState) {\n                    break;\n                }\n            }\n        }\n        if (!initialState) {\n            initialState = this.tokenizationSupport.getInitialState();\n        }\n        likelyRelevantLines.reverse();\n        const languageId = this._textModel.getLanguageId();\n        let state = initialState;\n        for (const line of likelyRelevantLines) {\n            const r = safeTokenize(this._languageIdCodec, languageId, this.tokenizationSupport, line, false, state);\n            state = r.endState;\n        }\n        return state;\n    }\n}\n/**\n * **Invariant:**\n * If the text model is retokenized from line 1 to {@link getFirstInvalidEndStateLineNumber}() - 1,\n * then the recomputed end state for line l will be equal to {@link getEndState}(l).\n */\nexport class TrackingTokenizationStateStore {\n    constructor(lineCount) {\n        this.lineCount = lineCount;\n        this._tokenizationStateStore = new TokenizationStateStore();\n        this._invalidEndStatesLineNumbers = new RangePriorityQueueImpl();\n        this._invalidEndStatesLineNumbers.addRange(new OffsetRange(1, lineCount + 1));\n    }\n    getEndState(lineNumber) {\n        return this._tokenizationStateStore.getEndState(lineNumber);\n    }\n    /**\n     * @returns if the end state has changed.\n     */\n    setEndState(lineNumber, state) {\n        if (!state) {\n            throw new BugIndicatingError('Cannot set null/undefined state');\n        }\n        this._invalidEndStatesLineNumbers.delete(lineNumber);\n        const r = this._tokenizationStateStore.setEndState(lineNumber, state);\n        if (r && lineNumber < this.lineCount) {\n            // because the state changed, we cannot trust the next state anymore and have to invalidate it.\n            this._invalidEndStatesLineNumbers.addRange(new OffsetRange(lineNumber + 1, lineNumber + 2));\n        }\n        return r;\n    }\n    acceptChange(range, newLineCount) {\n        this.lineCount += newLineCount - range.length;\n        this._tokenizationStateStore.acceptChange(range, newLineCount);\n        this._invalidEndStatesLineNumbers.addRangeAndResize(new OffsetRange(range.startLineNumber, range.endLineNumberExclusive), newLineCount);\n    }\n    acceptChanges(changes) {\n        for (const c of changes) {\n            const [eolCount] = countEOL(c.text);\n            this.acceptChange(new LineRange(c.range.startLineNumber, c.range.endLineNumber + 1), eolCount + 1);\n        }\n    }\n    invalidateEndStateRange(range) {\n        this._invalidEndStatesLineNumbers.addRange(new OffsetRange(range.startLineNumber, range.endLineNumberExclusive));\n    }\n    getFirstInvalidEndStateLineNumber() { return this._invalidEndStatesLineNumbers.min; }\n    getFirstInvalidEndStateLineNumberOrMax() {\n        return this.getFirstInvalidEndStateLineNumber() || Number.MAX_SAFE_INTEGER;\n    }\n    allStatesValid() { return this._invalidEndStatesLineNumbers.min === null; }\n    getStartState(lineNumber, initialState) {\n        if (lineNumber === 1) {\n            return initialState;\n        }\n        return this.getEndState(lineNumber - 1);\n    }\n    getFirstInvalidLine(initialState) {\n        const lineNumber = this.getFirstInvalidEndStateLineNumber();\n        if (lineNumber === null) {\n            return null;\n        }\n        const startState = this.getStartState(lineNumber, initialState);\n        if (!startState) {\n            throw new BugIndicatingError('Start state must be defined');\n        }\n        return { lineNumber, startState };\n    }\n}\nexport class TokenizationStateStore {\n    constructor() {\n        this._lineEndStates = new FixedArray(null);\n    }\n    getEndState(lineNumber) {\n        return this._lineEndStates.get(lineNumber);\n    }\n    setEndState(lineNumber, state) {\n        const oldState = this._lineEndStates.get(lineNumber);\n        if (oldState && oldState.equals(state)) {\n            return false;\n        }\n        this._lineEndStates.set(lineNumber, state);\n        return true;\n    }\n    acceptChange(range, newLineCount) {\n        let length = range.length;\n        if (newLineCount > 0 && length > 0) {\n            // Keep the last state, even though it is unrelated.\n            // But if the new state happens to agree with this last state, then we know we can stop tokenizing.\n            length--;\n            newLineCount--;\n        }\n        this._lineEndStates.replace(range.startLineNumber, length, newLineCount);\n    }\n}\nexport class RangePriorityQueueImpl {\n    constructor() {\n        this._ranges = [];\n    }\n    get min() {\n        if (this._ranges.length === 0) {\n            return null;\n        }\n        return this._ranges[0].start;\n    }\n    delete(value) {\n        const idx = this._ranges.findIndex(r => r.contains(value));\n        if (idx !== -1) {\n            const range = this._ranges[idx];\n            if (range.start === value) {\n                if (range.endExclusive === value + 1) {\n                    this._ranges.splice(idx, 1);\n                }\n                else {\n                    this._ranges[idx] = new OffsetRange(value + 1, range.endExclusive);\n                }\n            }\n            else {\n                if (range.endExclusive === value + 1) {\n                    this._ranges[idx] = new OffsetRange(range.start, value);\n                }\n                else {\n                    this._ranges.splice(idx, 1, new OffsetRange(range.start, value), new OffsetRange(value + 1, range.endExclusive));\n                }\n            }\n        }\n    }\n    addRange(range) {\n        OffsetRange.addRange(range, this._ranges);\n    }\n    addRangeAndResize(range, newLength) {\n        let idxFirstMightBeIntersecting = 0;\n        while (!(idxFirstMightBeIntersecting >= this._ranges.length || range.start <= this._ranges[idxFirstMightBeIntersecting].endExclusive)) {\n            idxFirstMightBeIntersecting++;\n        }\n        let idxFirstIsAfter = idxFirstMightBeIntersecting;\n        while (!(idxFirstIsAfter >= this._ranges.length || range.endExclusive < this._ranges[idxFirstIsAfter].start)) {\n            idxFirstIsAfter++;\n        }\n        const delta = newLength - range.length;\n        for (let i = idxFirstIsAfter; i < this._ranges.length; i++) {\n            this._ranges[i] = this._ranges[i].delta(delta);\n        }\n        if (idxFirstMightBeIntersecting === idxFirstIsAfter) {\n            const newRange = new OffsetRange(range.start, range.start + newLength);\n            if (!newRange.isEmpty) {\n                this._ranges.splice(idxFirstMightBeIntersecting, 0, newRange);\n            }\n        }\n        else {\n            const start = Math.min(range.start, this._ranges[idxFirstMightBeIntersecting].start);\n            const endEx = Math.max(range.endExclusive, this._ranges[idxFirstIsAfter - 1].endExclusive);\n            const newRange = new OffsetRange(start, endEx + delta);\n            if (!newRange.isEmpty) {\n                this._ranges.splice(idxFirstMightBeIntersecting, idxFirstIsAfter - idxFirstMightBeIntersecting, newRange);\n            }\n            else {\n                this._ranges.splice(idxFirstMightBeIntersecting, idxFirstIsAfter - idxFirstMightBeIntersecting);\n            }\n        }\n    }\n    toString() {\n        return this._ranges.map(r => r.toString()).join(' + ');\n    }\n}\nfunction safeTokenize(languageIdCodec, languageId, tokenizationSupport, text, hasEOL, state) {\n    let r = null;\n    if (tokenizationSupport) {\n        try {\n            r = tokenizationSupport.tokenizeEncoded(text, hasEOL, state.clone());\n        }\n        catch (e) {\n            onUnexpectedError(e);\n        }\n    }\n    if (!r) {\n        r = nullTokenizeEncoded(languageIdCodec.encodeLanguageId(languageId), state);\n    }\n    LineTokens.convertToEndOffset(r.tokens, text.length);\n    return r;\n}\nexport class DefaultBackgroundTokenizer {\n    constructor(_tokenizerWithStateStore, _backgroundTokenStore) {\n        this._tokenizerWithStateStore = _tokenizerWithStateStore;\n        this._backgroundTokenStore = _backgroundTokenStore;\n        this._isDisposed = false;\n        this._isScheduled = false;\n    }\n    dispose() {\n        this._isDisposed = true;\n    }\n    handleChanges() {\n        this._beginBackgroundTokenization();\n    }\n    _beginBackgroundTokenization() {\n        if (this._isScheduled || !this._tokenizerWithStateStore._textModel.isAttachedToEditor() || !this._hasLinesToTokenize()) {\n            return;\n        }\n        this._isScheduled = true;\n        runWhenGlobalIdle((deadline) => {\n            this._isScheduled = false;\n            this._backgroundTokenizeWithDeadline(deadline);\n        });\n    }\n    /**\n     * Tokenize until the deadline occurs, but try to yield every 1-2ms.\n     */\n    _backgroundTokenizeWithDeadline(deadline) {\n        // Read the time remaining from the `deadline` immediately because it is unclear\n        // if the `deadline` object will be valid after execution leaves this function.\n        const endTime = Date.now() + deadline.timeRemaining();\n        const execute = () => {\n            if (this._isDisposed || !this._tokenizerWithStateStore._textModel.isAttachedToEditor() || !this._hasLinesToTokenize()) {\n                // disposed in the meantime or detached or finished\n                return;\n            }\n            this._backgroundTokenizeForAtLeast1ms();\n            if (Date.now() < endTime) {\n                // There is still time before reaching the deadline, so yield to the browser and then\n                // continue execution\n                setTimeout0(execute);\n            }\n            else {\n                // The deadline has been reached, so schedule a new idle callback if necessary\n                this._beginBackgroundTokenization();\n            }\n        };\n        execute();\n    }\n    /**\n     * Tokenize for at least 1ms.\n     */\n    _backgroundTokenizeForAtLeast1ms() {\n        const lineCount = this._tokenizerWithStateStore._textModel.getLineCount();\n        const builder = new ContiguousMultilineTokensBuilder();\n        const sw = StopWatch.create(false);\n        do {\n            if (sw.elapsed() > 1) {\n                // the comparison is intentionally > 1 and not >= 1 to ensure that\n                // a full millisecond has elapsed, given how microseconds are rounded\n                // to milliseconds\n                break;\n            }\n            const tokenizedLineNumber = this._tokenizeOneInvalidLine(builder);\n            if (tokenizedLineNumber >= lineCount) {\n                break;\n            }\n        } while (this._hasLinesToTokenize());\n        this._backgroundTokenStore.setTokens(builder.finalize());\n        this.checkFinished();\n    }\n    _hasLinesToTokenize() {\n        if (!this._tokenizerWithStateStore) {\n            return false;\n        }\n        return !this._tokenizerWithStateStore.store.allStatesValid();\n    }\n    _tokenizeOneInvalidLine(builder) {\n        var _a;\n        const firstInvalidLine = (_a = this._tokenizerWithStateStore) === null || _a === void 0 ? void 0 : _a.getFirstInvalidLine();\n        if (!firstInvalidLine) {\n            return this._tokenizerWithStateStore._textModel.getLineCount() + 1;\n        }\n        this._tokenizerWithStateStore.updateTokensUntilLine(builder, firstInvalidLine.lineNumber);\n        return firstInvalidLine.lineNumber;\n    }\n    checkFinished() {\n        if (this._isDisposed) {\n            return;\n        }\n        if (this._tokenizerWithStateStore.store.allStatesValid()) {\n            this._backgroundTokenStore.backgroundTokenizationFinished();\n        }\n    }\n    requestTokens(startLineNumber, endLineNumberExclusive) {\n        this._tokenizerWithStateStore.store.invalidateEndStateRange(new LineRange(startLineNumber, endLineNumberExclusive));\n    }\n}\n"],"names":["MirrorTextModel","constructor","uri","lines","eol","versionId","this","_uri","_lines","_eol","_versionId","_lineStarts","_cachedTextValue","dispose","length","version","getText","join","onEvents","e","changes","change","_acceptDeleteRange","range","_acceptInsertText","startLineNumber","startColumn","text","_ensureLineStarts","eolLength","linesLength","lineStartValues","Uint32Array","i","_setLineText","lineIndex","newValue","setValue","endLineNumber","substring","endColumn","splice","removeValues","position","insertText","insertLines","lineNumber","column","newLengths","insertValues","PrefixSumComputer","values","prefixSum","prefixSumValidIndex","Int32Array","insertIndex","oldValues","oldPrefixSum","insertValuesLen","set","subarray","index","value","startIndex","count","maxCount","getTotalSum","_getPrefixSum","getPrefixSum","Math","max","getIndexOf","sum","floor","low","high","mid","midStop","midStart","PrefixSumIndexOfResult","ConstantTimePrefixSumComputer","_values","_isValid","_validEndIndex","_prefixSum","_indexBySum","_ensureValid","idx","viewLinesAbove","start","deleteCount","_invalidate","insertArr","min","len","sumAbove","j","remainder","_prefixSumIndexOfResultBrand","undefined","TreeNode","piece","color","size_left","lf_left","parent","left","right","next","SENTINEL","leftest","node","prev","righttest","detach","calculateSize","calculateLF","lineFeedCnt","resetSentinel","leftRotate","tree","x","y","root","rightRotate","rbDelete","z","yWasRed","recomputeTreeMetadata","newSizeLeft","newLFLeft","delta","lf_delta","updateTreeMetadata","w","fixInsert","lineFeedCntDelta","AverageBufferSize","createUintArray","arr","r","Uint16Array","LineStarts","lineStarts","cr","lf","crlf","isBasicASCII","createLineStartsFast","str","readonly","rLength","chr","charCodeAt","Piece","bufferIndex","end","StringBuffer","buffer","PieceTreeSnapshot","BOM","_pieces","_tree","_BOM","_index","iterate","push","read","getPieceContent","PieceTreeSearchCache","limit","_limit","_cache","get","offset","nodePos","nodeStartOffset","get2","nodeStartLineNumber","nodePosition","shift","validate","hasInvalidVal","tmp","newArr","entry","PieceTreeBase","chunks","eolNormalized","create","_buffers","_lastChangeBufferPos","line","_lineCnt","_length","_EOL","_EOLLength","_EOLNormalized","lastNode","rbInsertRight","_searchCache","_lastVisitedLine","computeBufferMetadata","normalizeEOL","averageBufferSize","tempChunk","tempChunkLen","getNodeContent","replace","getEOL","setEOL","newEOL","createSnapshot","getOffsetAt","leftLen","getAccumulatedValue","getPositionAt","lfCnt","originalOffset","out","getValueInRange","startPosition","nodeAt2","endPosition","getValueInRange2","startOffset","offsetInBuffer","ret","substr","getLinesContent","currentLine","danglingCR","pieceLength","pieceStartLine","pieceEndLine","pieceStartOffset","getLength","getLineCount","getLineContent","getLineRawContent","_getCharCode","matchingNode","targetOffset","getLineCharCode","getLineLength","findMatchesInNode","searcher","startCursor","endCursor","searchData","captureMatches","limitResultCount","resultLen","result","startOffsetInBuffer","m","searchText","_wordSeparators","reset","positionInBuffer","getLineFeedCnt","retStartColumn","retEndColumn","findMatchesLineByLine","searchRange","wordSeparators","regex","currentNode","lineBreakCnt","nextLineStartOffset","_findMatchesInLine","deltaOffset","simpleSearch","searchString","searchStringLen","textLength","lastMatchIndex","indexOf","insert","nodeAt","insertPosInBuffer","appendToNode","insertContentToNodeLeft","nodesToDel","newRightPiece","shouldCheckCRLF","endWithCR","nodeCharCodeAt","newStart","startWithLF","previousPos","deleteNodeTail","newPieces","createNewPieces","tmpNode","k","deleteNodes","insertContentToNodeRight","pieces","rbInsertLeft","cnt","startNode","endNode","startSplitPosInBuffer","endSplitPosInBuffer","validateCRLFWithPrevNode","deleteNodeHead","validateCRLFWithNextNode","shrinkNode","nPiece","newNode","adjustCarriageReturnFromNext","endOffset","previousCharOffset","cursor","nodes","lastChar","splitText","concat","slice","endIndex","endPos","newPiece","cache","prevAccumulatedValue","accumulatedValue","originalLineNumber","pos","lineCnt","realLineCnt","expectedLineStartIndex","originalLFCnt","originalEndOffset","newEnd","newEndOffset","newLineFeedCnt","size_delta","newLength","originalStartOffset","originalStartPos","originalEndPos","oldLength","oldLFCnt","hitCRLF","prevStartOffset","pop","oldLineFeedCnt","prevAccumualtedValue","offsetOfNode","newOffset","val","nextNode","fixCRLF","prevNewLength","prevNewLFCnt","callback","leftRet","p","prevNode","PieceTreeTextBuffer","containsRTL","containsUnusualLineTerminators","super","_onDidChangeContent","_register","_mightContainNonBasicASCII","_mightContainRTL","_mightContainUnusualLineTerminators","_pieceTree","mightContainRTL","mightContainUnusualLineTerminators","resetMightContainUnusualLineTerminators","mightContainNonBasicASCII","getBOM","preserveBOM","getRangeAt","isEmpty","lineEnding","_getEndOfLine","getValueLengthInRange","eolOffsetCompensation","desiredEOL","actualEOL","getCharacterCountInRange","fromLineNumber","toLineNumber","lineContent","fromOffset","toOffset","strings","getLineFirstNonWhitespaceColumn","getLineLastNonWhitespaceColumn","Error","applyEdits","rawOperations","recordTrimAutoWhitespace","computeUndoEdits","canReduceOperations","operations","op","_isTracked","validatedRange","textMightContainNonBasicASCII","validText","eolCount","firstLineLength","lastLineLength","strEOL","bufferEOL","sortIndex","identifier","rangeOffset","rangeLength","forceMoveMarkers","Boolean","isAutoWhitespaceEdit","sort","_sortOpsAscending","hasTouchingRanges","rangeEnd","getEndPosition","nextRangeStart","getStartPosition","isBeforeOrEqual","isBefore","_reduceOperations","reverseRanges","_getInverseEditRanges","newTrimAutoWhitespaceCandidates","reverseRange","currentLineContent","oldContent","reverseOperations","reverseRangeDeltaOffset","bufferText","reverseRangeOffset","textChange","a","b","contentChanges","_doApplyEdits","trimAutoWhitespaceLineNumbers","prevContent","fire","_toSingleEditOperation","firstEditRange","lastEditRange","entireEditRange","lastEndLineNumber","lastEndColumn","operation","_sortOpsDescending","delete","contentChangeRange","prevOpEndLineNumber","prevOpEndColumn","prevOp","resultRange","lineCount","PieceTreeTextBufferFactory","_chunks","_bom","_cr","_lf","_crlf","_containsRTL","_containsUnusualLineTerminators","_isBasicASCII","_normalizeEOL","_getEOL","defaultEOL","totalEOLCount","totalCRCount","newLineStart","textBuffer","disposable","PieceTreeTextBufferBuilder","_hasPreviousChar","_previousChar","_tmpLineStarts","acceptChunk","chunk","_acceptChunk1","allowEmptyStrings","_acceptChunk2","String","fromCharCode","createLineStarts","finish","_finish","lastChunk","newLineStarts","TextModel_1","__decorate","decorators","target","key","desc","d","c","arguments","Object","getOwnPropertyDescriptor","Reflect","decorate","defineProperty","__param","paramIndex","decorator","createTextBuffer","factory","builder","createTextBufferFactory","model","snapshot","createTextBufferFactoryFromSnapshot","MODEL_ID","TextModelSnapshot","source","_source","_eos","resultCnt","resultLength","invalidFunc","TextModel","resolveOptions","options","detectIndentation","guessedIndentation","tabSize","insertSpaces","indentSize","trimAutoWhitespace","bracketPairColorizationOptions","onDidChangeLanguage","_tokenizationTextModelPart","onDidChangeLanguageConfiguration","onDidChangeTokens","onDidChangeContent","listener","_eventEmitter","slowEvent","contentChangedEvent","onDidChangeContentOrInjectedText","fastEvent","_onDidChangeInjectedText","event","_isDisposing","__isDisposing","tokenization","bracketPairs","_bracketPairs","guides","_guidesTextModelPart","languageIdOrSelection","creationOptions","associatedResource","_undoRedoService","_languageService","_languageConfigurationService","_onWillDispose","onWillDispose","_onDidChangeDecorations","DidChangeDecorationsEmitter","affectedInjectedTextLines","handleBeforeFireDecorationsChangedEvent","onDidChangeDecorations","_onDidChangeOptions","onDidChangeOptions","_onDidChangeAttached","onDidChangeAttached","DidChangeContentEmitter","_languageSelectionListener","_deltaDecorationCallCnt","_attachedViews","AttachedViews","id","isForSimpleWidget","_associatedResource","_attachedEditorCount","_buffer","_bufferDisposable","_options","languageId","onDidChange","_setLanguage","_decorationProvider","bufferLineCount","bufferTextLength","largeFileOptimizations","_isTooLargeForTokenization","LARGE_FILE_SIZE_THRESHOLD","LARGE_FILE_LINE_COUNT_THRESHOLD","_isTooLargeForHeapOperation","LARGE_FILE_HEAP_OPERATION_THRESHOLD","_isTooLargeForSyncing","_MODEL_SYNC_LIMIT","_alternativeVersionId","_initialUndoRedoSnapshot","_isDisposed","_instanceId","_lastDecorationId","_decorations","_decorationsTree","DecorationsTrees","_commandManager","_isUndoing","_isRedoing","_trimAutoWhitespaceLines","beginDeferredEmit","endDeferredEmit","requestRichLanguageFeatures","emptyDisposedTextBuffer","_assertNotDisposed","_emitContentChangedEvent","rawChange","handleDidChangeContent","_setValueFromTextBuffer","_createContentChanged2","isUndoing","isRedoing","isFlush","isEolChange","getVersionId","textBufferDisposable","oldFullModelRange","getFullModelRange","oldModelValueLength","getLineMaxColumn","_increaseVersionId","clear","getValue","_onBeforeEOLChange","_onAfterEOLChange","ensureAllNodesHaveRanges","allDecorations","collectNodesPostOrder","cachedAbsoluteStart","cachedAbsoluteEnd","cachedVersionId","onBeforeAttached","handleDidChangeAttached","attachView","onBeforeDetached","view","detachView","isAttachedToEditor","getAttachedEditorCount","isTooLargeForSyncing","isTooLargeForTokenization","isTooLargeForHeapOperation","isDisposed","isDominatedByLongLines","smallLineCharCount","longLineCharCount","lineLength","getOptions","getFormattingOptions","updateOptions","_newOpts","originalIndentSize","bracketColorizationOptions","newOpts","equals","createChangeEvent","handleDidChangeOptions","defaultInsertSpaces","defaultTabSize","normalizeIndentation","removeUnusualLineTerminators","selections","matches","findMatches","pushEditOperations","map","getAlternativeVersionId","getInitialUndoRedoSnapshot","rawPosition","_validatePosition","rawOffset","_overwriteVersionId","_overwriteAlternativeVersionId","newAlternativeVersionId","_overwriteInitialUndoRedoSnapshot","newInitialUndoRedoSnapshot","fullModelRange","fullModelValue","getValueLength","rawRange","validateRange","getEndOfLineSequence","getLineMinColumn","_validateRangeRelaxedNoAllocations","linesCount","initialStartLineNumber","initialStartColumn","isNaN","maxColumn","initialEndLineNumber","initialEndColumn","_isValidPosition","validationType","charCodeBefore","_lineNumber","_column","validatePosition","_isValidRange","charCodeBeforeStart","charCodeBeforeEnd","startInsideSurrogatePair","endInsideSurrogatePair","_range","modifyPosition","candidate","rawSearchScope","isRegex","matchCase","searchRanges","Array","isArray","every","searchScope","d1","d2","uniqueSearchRanges","matchMapper","reduce","curr","plusRange","parseSearchRequest","findNextMatch","rawSearchStart","searchStart","findPreviousMatch","pushStackElement","popStackElement","pushEOL","_validateEditOperation","rawOperation","_validateEditOperations","beforeCursorState","editOperations","cursorStateComputer","group","_pushEditOperations","incomingEdits","editsAreNearCursors","sel","foundEditNearSel","lenJ","editRange","selIsAbove","selIsBelow","trimLineNumber","maxLineColumn","allowTrimLine","editText","charAt","trimRange","pushEditOperation","_applyUndo","resultingAlternativeVersionId","resultingSelection","edits","rangeStart","newPosition","oldText","_applyUndoRedoEdits","_applyRedo","oldPosition","oldEnd","newText","oldLineCount","newLineCount","acceptReplace","rawContentChanges","deletingLinesCnt","insertingLinesCnt","editingLinesCnt","changeLineCountDelta","currentEditStartLineNumber","firstEditLineNumber","lastInsertedLineNumber","decorationsWithInjectedTextInEditedRange","getInjectedTextInInterval","injectedTextInEditedRange","injectedTextInEditedRangeQueue","editLineNumber","currentEditLineNumber","takeFromEndWhile","decorationsInCurrentLine","spliceStartLineNumber","spliceLineNumber","injectedTexts","newLines","takeWhile","reverseEdits","undo","canUndo","redo","canRedo","size","lineChangeEvents","from","_getInjectedTextInLine","changeDecorations","ownerId","_changeDecorations","changeAccessor","addDecoration","_deltaDecorationsImpl","changeDecoration","newRange","_changeDecorationImpl","changeDecorationOptions","_changeDecorationOptionsImpl","_normalizeOptions","removeDecoration","deltaDecorations","oldDecorations","newDecorations","console","warn","_getTrackedRange","getDecorationRange","_setTrackedRange","newStickiness","TRACKED_RANGE_OPTIONS","setOptions","removeAllDecorationsWithOwnerId","collectNodesFromOwner","getDecorationOptions","decorationId","getNodeRange","getLineDecorations","filterOutValidation","getLinesDecorations","_startLineNumber","_endLineNumber","onlyMarginDecorations","decorations","_getDecorationsInRange","getDecorationsInRange","onlyMinimapDecorations","getOverviewRulerDecorations","getAll","getInjectedTextDecorations","getAllInjectedText","filter","t","getAllDecorations","getAllMarginDecorations","filterRange","filterOwnerId","getAllInInterval","after","oldRange","recordLineAffectedByInjectedText","before","checkAffectedAndFire","nodeWasInOverviewRuler","overviewRuler","nodeIsInOverviewRuler","nodeRange","movedInOverviewRuler","changedWhetherInjectedText","isOptionsInjectedText","isNodeInjectedText","oldDecorationsIds","suppressEvents","oldDecorationsLen","oldDecorationIndex","newDecorationsLen","newDecorationIndex","internalDecorationId","newDecoration","getLanguageId","setLanguage","setLanguageId","getLanguageIdAtPosition","getWordAtPosition","getWordUntilPosition","normalizePosition","affinity","getLineIndentColumn","indent","indentOfLine","isNodeInOverviewRuler","DEFAULT_CREATION_OPTIONS","_decorationsTree0","_decorationsTree1","_injectedTextDecorationsTree","host","_ensureNodesHaveRanges","_intervalSearch","r0","intervalSearch","r1","r2","showIfCollapsed","search","overviewRulerOnly","_search","_resolveNode","resolveNode","cleanClassName","className","DecorationOptions","darkColor","ModelDecorationOverviewRulerOptions","_resolvedColor","getColor","theme","type","_resolveColor","invalidateCachedColor","toString","ModelDecorationGlyphMarginOptions","_a","persistLane","ModelDecorationMinimapOptions","_b","sectionHeaderStyle","sectionHeaderText","ModelDecorationInjectedTextOptions","content","inlineClassName","inlineClassNameAffectsLetterSpacing","attachedData","cursorStops","ModelDecorationOptions","register","createDynamic","_c","_d","_e","_f","description","blockClassName","blockDoesNotCollapse","blockIsAfterEnd","blockPadding","stickiness","zIndex","shouldFillLineOnLineBreak","hoverMessage","glyphMarginHoverMessage","lineNumberHoverMessage","isWholeLine","collapseOnReplaceEdit","minimap","glyphMargin","glyphMarginClassName","linesDecorationsClassName","lineNumberClassName","linesDecorationsTooltip","firstLineDecorationClassName","marginClassName","beforeContentClassName","afterContentClassName","hideInCommentTokens","hideInStringTokens","EMPTY","handleBeforeFire","_actual","_affectedInjectedTextLines","_deferredCnt","_shouldFireDeferred","_affectsMinimap","_affectsOverviewRuler","_affectsGlyphMargin","_affectsLineNumber","doFire","Set","add","tryFire","affectsMinimap","affectsOverviewRuler","affectsGlyphMargin","affectsLineNumber","_fastEmitter","_slowEmitter","_deferredEvent","rawContentChangedEvent","merge","_onDidChangeVisibleRanges","onDidChangeVisibleRanges","_views","AttachedViewImpl","state","handleStateChange","setVisibleLines","visibleLines","stabilized","visibleLineRanges","TextModelPart","assertNotDisposed","SearchParams","multiline","chCode","nextChCode","isMultilineRegexSource","wholeWord","global","unicode","err","canUseSimpleSearch","toLowerCase","toUpperCase","createFindMatch","rawMatches","LineFeedCounter","lineFeedsOffsets","lineFeedsOffsetsLen","textLen","_lineFeedsOffsets","findLineFeedCountBeforeOffset","TextModelSearch","searchParams","_doFindMatchesMultiline","Searcher","_doFindMatchesLineByLine","_getMultilineMatchRange","lfCounter","matchIndex","match0","lineFeedCountBeforeMatch","lineFeedCountInMatch","counter","isValidMatch","_doFindNextMatchMultiline","_doFindNextMatchLineByLine","searchTextStart","_findFirstMatchInLine","fromColumn","_doFindPreviousMatchMultiline","_doFindPreviousMatchLineByLine","_findLastMatchInLine","bestResult","matchStartIndex","matchLength","charBefore","firstCharInMatch","leftIsWordBounday","charAfter","lastCharInMatch","rightIsWordBounday","searchRegex","_searchRegex","_prevMatchStartIndex","_prevMatchLength","lastIndex","exec","TextModelText","_textModel","getValueOfRange","lastLineNumber","lastLineLen","TokenizerWithStateStore","tokenizationSupport","initialState","getInitialState","store","TrackingTokenizationStateStore","getStartState","getFirstInvalidLine","TokenizerWithStateStoreAndTextModel","_languageIdCodec","updateTokensUntilLine","lineToTokenize","safeTokenize","startState","tokens","setEndState","endState","getTokenTypeIfInsertingCharacter","character","lineStartState","lineTokens","getCount","tokenIndex","findTokenIndexAtOffset","getStandardTokenType","tokenizeLineWithEdit","curLineContent","newLineContent","hasAccurateTokensForLine","getFirstInvalidEndStateLineNumberOrMax","isCheapToTokenize","firstInvalidLineNumber","tokenizeHeuristically","heuristicTokens","guessStartState","nonWhitespaceColumn","likelyRelevantLines","newNonWhitespaceIndex","reverse","_tokenizationStateStore","TokenizationStateStore","_invalidEndStatesLineNumbers","RangePriorityQueueImpl","addRange","getEndState","acceptChange","addRangeAndResize","endLineNumberExclusive","acceptChanges","invalidateEndStateRange","getFirstInvalidEndStateLineNumber","Number","MAX_SAFE_INTEGER","allStatesValid","_lineEndStates","oldState","_ranges","findIndex","contains","endExclusive","idxFirstMightBeIntersecting","idxFirstIsAfter","endEx","languageIdCodec","hasEOL","tokenizeEncoded","clone","encodeLanguageId","DefaultBackgroundTokenizer","_tokenizerWithStateStore","_backgroundTokenStore","_isScheduled","handleChanges","_beginBackgroundTokenization","_hasLinesToTokenize","deadline","_backgroundTokenizeWithDeadline","endTime","Date","now","timeRemaining","execute","_backgroundTokenizeForAtLeast1ms","sw","elapsed","_tokenizeOneInvalidLine","setTokens","finalize","checkFinished","firstInvalidLine","backgroundTokenizationFinished","requestTokens"],"sourceRoot":""}