{"version":3,"file":"static/js/387_09da2c3a5aec091a65f2.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/diff/defaultLinesDiffComputer/algorithms/diffAlgorithm.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/diff/defaultLinesDiffComputer/utils.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/diff/defaultLinesDiffComputer/algorithms/dynamicProgrammingDiffing.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/diff/defaultLinesDiffComputer/algorithms/myersDiffAlgorithm.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/diff/defaultLinesDiffComputer/linesSliceCharSequence.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/diff/defaultLinesDiffComputer/computeMovedLines.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/diff/defaultLinesDiffComputer/lineSequence.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/diff/defaultLinesDiffComputer/defaultLinesDiffComputer.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/diff/defaultLinesDiffComputer/heuristicSequenceOptimizations.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/diff/linesDiffComputer.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/diff/legacyLinesDiffComputer.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/diff/linesDiffComputers.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/diff/rangeMapping.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/editorAction.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/editorCommon.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/editorContextKeys.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/editorFeatures.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/editorTheme.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 { forEachAdjacent } from '../../../../../base/common/arrays.js';\nimport { BugIndicatingError } from '../../../../../base/common/errors.js';\nimport { OffsetRange } from '../../../core/offsetRange.js';\nexport class DiffAlgorithmResult {\n    static trivial(seq1, seq2) {\n        return new DiffAlgorithmResult([new SequenceDiff(OffsetRange.ofLength(seq1.length), OffsetRange.ofLength(seq2.length))], false);\n    }\n    static trivialTimedOut(seq1, seq2) {\n        return new DiffAlgorithmResult([new SequenceDiff(OffsetRange.ofLength(seq1.length), OffsetRange.ofLength(seq2.length))], true);\n    }\n    constructor(diffs, \n    /**\n     * Indicates if the time out was reached.\n     * In that case, the diffs might be an approximation and the user should be asked to rerun the diff with more time.\n     */\n    hitTimeout) {\n        this.diffs = diffs;\n        this.hitTimeout = hitTimeout;\n    }\n}\nexport class SequenceDiff {\n    static invert(sequenceDiffs, doc1Length) {\n        const result = [];\n        forEachAdjacent(sequenceDiffs, (a, b) => {\n            result.push(SequenceDiff.fromOffsetPairs(a ? a.getEndExclusives() : OffsetPair.zero, b ? b.getStarts() : new OffsetPair(doc1Length, (a ? a.seq2Range.endExclusive - a.seq1Range.endExclusive : 0) + doc1Length)));\n        });\n        return result;\n    }\n    static fromOffsetPairs(start, endExclusive) {\n        return new SequenceDiff(new OffsetRange(start.offset1, endExclusive.offset1), new OffsetRange(start.offset2, endExclusive.offset2));\n    }\n    constructor(seq1Range, seq2Range) {\n        this.seq1Range = seq1Range;\n        this.seq2Range = seq2Range;\n    }\n    swap() {\n        return new SequenceDiff(this.seq2Range, this.seq1Range);\n    }\n    toString() {\n        return `${this.seq1Range} <-> ${this.seq2Range}`;\n    }\n    join(other) {\n        return new SequenceDiff(this.seq1Range.join(other.seq1Range), this.seq2Range.join(other.seq2Range));\n    }\n    delta(offset) {\n        if (offset === 0) {\n            return this;\n        }\n        return new SequenceDiff(this.seq1Range.delta(offset), this.seq2Range.delta(offset));\n    }\n    deltaStart(offset) {\n        if (offset === 0) {\n            return this;\n        }\n        return new SequenceDiff(this.seq1Range.deltaStart(offset), this.seq2Range.deltaStart(offset));\n    }\n    deltaEnd(offset) {\n        if (offset === 0) {\n            return this;\n        }\n        return new SequenceDiff(this.seq1Range.deltaEnd(offset), this.seq2Range.deltaEnd(offset));\n    }\n    intersect(other) {\n        const i1 = this.seq1Range.intersect(other.seq1Range);\n        const i2 = this.seq2Range.intersect(other.seq2Range);\n        if (!i1 || !i2) {\n            return undefined;\n        }\n        return new SequenceDiff(i1, i2);\n    }\n    getStarts() {\n        return new OffsetPair(this.seq1Range.start, this.seq2Range.start);\n    }\n    getEndExclusives() {\n        return new OffsetPair(this.seq1Range.endExclusive, this.seq2Range.endExclusive);\n    }\n}\nexport class OffsetPair {\n    constructor(offset1, offset2) {\n        this.offset1 = offset1;\n        this.offset2 = offset2;\n    }\n    toString() {\n        return `${this.offset1} <-> ${this.offset2}`;\n    }\n    delta(offset) {\n        if (offset === 0) {\n            return this;\n        }\n        return new OffsetPair(this.offset1 + offset, this.offset2 + offset);\n    }\n    equals(other) {\n        return this.offset1 === other.offset1 && this.offset2 === other.offset2;\n    }\n}\nOffsetPair.zero = new OffsetPair(0, 0);\nOffsetPair.max = new OffsetPair(Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);\nexport class InfiniteTimeout {\n    isValid() {\n        return true;\n    }\n}\nInfiniteTimeout.instance = new InfiniteTimeout();\nexport class DateTimeout {\n    constructor(timeout) {\n        this.timeout = timeout;\n        this.startTime = Date.now();\n        this.valid = true;\n        if (timeout <= 0) {\n            throw new BugIndicatingError('timeout must be positive');\n        }\n    }\n    // Recommendation: Set a log-point `{this.disable()}` in the body\n    isValid() {\n        const valid = Date.now() - this.startTime < this.timeout;\n        if (!valid && this.valid) {\n            this.valid = false; // timeout reached\n            // eslint-disable-next-line no-debugger\n            debugger; // WARNING: Most likely debugging caused the timeout. Call `this.disable()` to continue without timing out.\n        }\n        return this.valid;\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 Array2D {\n    constructor(width, height) {\n        this.width = width;\n        this.height = height;\n        this.array = [];\n        this.array = new Array(width * height);\n    }\n    get(x, y) {\n        return this.array[x + y * this.width];\n    }\n    set(x, y, value) {\n        this.array[x + y * this.width] = value;\n    }\n}\nexport function isSpace(charCode) {\n    return charCode === 32 /* CharCode.Space */ || charCode === 9 /* CharCode.Tab */;\n}\nexport class LineRangeFragment {\n    static getKey(chr) {\n        let key = this.chrKeys.get(chr);\n        if (key === undefined) {\n            key = this.chrKeys.size;\n            this.chrKeys.set(chr, key);\n        }\n        return key;\n    }\n    constructor(range, lines, source) {\n        this.range = range;\n        this.lines = lines;\n        this.source = source;\n        this.histogram = [];\n        let counter = 0;\n        for (let i = range.startLineNumber - 1; i < range.endLineNumberExclusive - 1; i++) {\n            const line = lines[i];\n            for (let j = 0; j < line.length; j++) {\n                counter++;\n                const chr = line[j];\n                const key = LineRangeFragment.getKey(chr);\n                this.histogram[key] = (this.histogram[key] || 0) + 1;\n            }\n            counter++;\n            const key = LineRangeFragment.getKey('\\n');\n            this.histogram[key] = (this.histogram[key] || 0) + 1;\n        }\n        this.totalCount = counter;\n    }\n    computeSimilarity(other) {\n        var _a, _b;\n        let sumDifferences = 0;\n        const maxLength = Math.max(this.histogram.length, other.histogram.length);\n        for (let i = 0; i < maxLength; i++) {\n            sumDifferences += Math.abs(((_a = this.histogram[i]) !== null && _a !== void 0 ? _a : 0) - ((_b = other.histogram[i]) !== null && _b !== void 0 ? _b : 0));\n        }\n        return 1 - (sumDifferences / (this.totalCount + other.totalCount));\n    }\n}\nLineRangeFragment.chrKeys = new Map();\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 { OffsetRange } from '../../../core/offsetRange.js';\nimport { SequenceDiff, InfiniteTimeout, DiffAlgorithmResult } from './diffAlgorithm.js';\nimport { Array2D } from '../utils.js';\n/**\n * A O(MN) diffing algorithm that supports a score function.\n * The algorithm can be improved by processing the 2d array diagonally.\n*/\nexport class DynamicProgrammingDiffing {\n    compute(sequence1, sequence2, timeout = InfiniteTimeout.instance, equalityScore) {\n        if (sequence1.length === 0 || sequence2.length === 0) {\n            return DiffAlgorithmResult.trivial(sequence1, sequence2);\n        }\n        /**\n         * lcsLengths.get(i, j): Length of the longest common subsequence of sequence1.substring(0, i + 1) and sequence2.substring(0, j + 1).\n         */\n        const lcsLengths = new Array2D(sequence1.length, sequence2.length);\n        const directions = new Array2D(sequence1.length, sequence2.length);\n        const lengths = new Array2D(sequence1.length, sequence2.length);\n        // ==== Initializing lcsLengths ====\n        for (let s1 = 0; s1 < sequence1.length; s1++) {\n            for (let s2 = 0; s2 < sequence2.length; s2++) {\n                if (!timeout.isValid()) {\n                    return DiffAlgorithmResult.trivialTimedOut(sequence1, sequence2);\n                }\n                const horizontalLen = s1 === 0 ? 0 : lcsLengths.get(s1 - 1, s2);\n                const verticalLen = s2 === 0 ? 0 : lcsLengths.get(s1, s2 - 1);\n                let extendedSeqScore;\n                if (sequence1.getElement(s1) === sequence2.getElement(s2)) {\n                    if (s1 === 0 || s2 === 0) {\n                        extendedSeqScore = 0;\n                    }\n                    else {\n                        extendedSeqScore = lcsLengths.get(s1 - 1, s2 - 1);\n                    }\n                    if (s1 > 0 && s2 > 0 && directions.get(s1 - 1, s2 - 1) === 3) {\n                        // Prefer consecutive diagonals\n                        extendedSeqScore += lengths.get(s1 - 1, s2 - 1);\n                    }\n                    extendedSeqScore += (equalityScore ? equalityScore(s1, s2) : 1);\n                }\n                else {\n                    extendedSeqScore = -1;\n                }\n                const newValue = Math.max(horizontalLen, verticalLen, extendedSeqScore);\n                if (newValue === extendedSeqScore) {\n                    // Prefer diagonals\n                    const prevLen = s1 > 0 && s2 > 0 ? lengths.get(s1 - 1, s2 - 1) : 0;\n                    lengths.set(s1, s2, prevLen + 1);\n                    directions.set(s1, s2, 3);\n                }\n                else if (newValue === horizontalLen) {\n                    lengths.set(s1, s2, 0);\n                    directions.set(s1, s2, 1);\n                }\n                else if (newValue === verticalLen) {\n                    lengths.set(s1, s2, 0);\n                    directions.set(s1, s2, 2);\n                }\n                lcsLengths.set(s1, s2, newValue);\n            }\n        }\n        // ==== Backtracking ====\n        const result = [];\n        let lastAligningPosS1 = sequence1.length;\n        let lastAligningPosS2 = sequence2.length;\n        function reportDecreasingAligningPositions(s1, s2) {\n            if (s1 + 1 !== lastAligningPosS1 || s2 + 1 !== lastAligningPosS2) {\n                result.push(new SequenceDiff(new OffsetRange(s1 + 1, lastAligningPosS1), new OffsetRange(s2 + 1, lastAligningPosS2)));\n            }\n            lastAligningPosS1 = s1;\n            lastAligningPosS2 = s2;\n        }\n        let s1 = sequence1.length - 1;\n        let s2 = sequence2.length - 1;\n        while (s1 >= 0 && s2 >= 0) {\n            if (directions.get(s1, s2) === 3) {\n                reportDecreasingAligningPositions(s1, s2);\n                s1--;\n                s2--;\n            }\n            else {\n                if (directions.get(s1, s2) === 1) {\n                    s1--;\n                }\n                else {\n                    s2--;\n                }\n            }\n        }\n        reportDecreasingAligningPositions(-1, -1);\n        result.reverse();\n        return new DiffAlgorithmResult(result, false);\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 { OffsetRange } from '../../../core/offsetRange.js';\nimport { DiffAlgorithmResult, InfiniteTimeout, SequenceDiff } from './diffAlgorithm.js';\n/**\n * An O(ND) diff algorithm that has a quadratic space worst-case complexity.\n*/\nexport class MyersDiffAlgorithm {\n    compute(seq1, seq2, timeout = InfiniteTimeout.instance) {\n        // These are common special cases.\n        // The early return improves performance dramatically.\n        if (seq1.length === 0 || seq2.length === 0) {\n            return DiffAlgorithmResult.trivial(seq1, seq2);\n        }\n        const seqX = seq1; // Text on the x axis\n        const seqY = seq2; // Text on the y axis\n        function getXAfterSnake(x, y) {\n            while (x < seqX.length && y < seqY.length && seqX.getElement(x) === seqY.getElement(y)) {\n                x++;\n                y++;\n            }\n            return x;\n        }\n        let d = 0;\n        // V[k]: X value of longest d-line that ends in diagonal k.\n        // d-line: path from (0,0) to (x,y) that uses exactly d non-diagonals.\n        // diagonal k: Set of points (x,y) with x-y = k.\n        // k=1 -> (1,0),(2,1)\n        const V = new FastInt32Array();\n        V.set(0, getXAfterSnake(0, 0));\n        const paths = new FastArrayNegativeIndices();\n        paths.set(0, V.get(0) === 0 ? null : new SnakePath(null, 0, 0, V.get(0)));\n        let k = 0;\n        loop: while (true) {\n            d++;\n            if (!timeout.isValid()) {\n                return DiffAlgorithmResult.trivialTimedOut(seqX, seqY);\n            }\n            // The paper has `for (k = -d; k <= d; k += 2)`, but we can ignore diagonals that cannot influence the result.\n            const lowerBound = -Math.min(d, seqY.length + (d % 2));\n            const upperBound = Math.min(d, seqX.length + (d % 2));\n            for (k = lowerBound; k <= upperBound; k += 2) {\n                let step = 0;\n                // We can use the X values of (d-1)-lines to compute X value of the longest d-lines.\n                const maxXofDLineTop = k === upperBound ? -1 : V.get(k + 1); // We take a vertical non-diagonal (add a symbol in seqX)\n                const maxXofDLineLeft = k === lowerBound ? -1 : V.get(k - 1) + 1; // We take a horizontal non-diagonal (+1 x) (delete a symbol in seqX)\n                step++;\n                const x = Math.min(Math.max(maxXofDLineTop, maxXofDLineLeft), seqX.length);\n                const y = x - k;\n                step++;\n                if (x > seqX.length || y > seqY.length) {\n                    // This diagonal is irrelevant for the result.\n                    // TODO: Don't pay the cost for this in the next iteration.\n                    continue;\n                }\n                const newMaxX = getXAfterSnake(x, y);\n                V.set(k, newMaxX);\n                const lastPath = x === maxXofDLineTop ? paths.get(k + 1) : paths.get(k - 1);\n                paths.set(k, newMaxX !== x ? new SnakePath(lastPath, x, y, newMaxX - x) : lastPath);\n                if (V.get(k) === seqX.length && V.get(k) - k === seqY.length) {\n                    break loop;\n                }\n            }\n        }\n        let path = paths.get(k);\n        const result = [];\n        let lastAligningPosS1 = seqX.length;\n        let lastAligningPosS2 = seqY.length;\n        while (true) {\n            const endX = path ? path.x + path.length : 0;\n            const endY = path ? path.y + path.length : 0;\n            if (endX !== lastAligningPosS1 || endY !== lastAligningPosS2) {\n                result.push(new SequenceDiff(new OffsetRange(endX, lastAligningPosS1), new OffsetRange(endY, lastAligningPosS2)));\n            }\n            if (!path) {\n                break;\n            }\n            lastAligningPosS1 = path.x;\n            lastAligningPosS2 = path.y;\n            path = path.prev;\n        }\n        result.reverse();\n        return new DiffAlgorithmResult(result, false);\n    }\n}\nclass SnakePath {\n    constructor(prev, x, y, length) {\n        this.prev = prev;\n        this.x = x;\n        this.y = y;\n        this.length = length;\n    }\n}\n/**\n * An array that supports fast negative indices.\n*/\nclass FastInt32Array {\n    constructor() {\n        this.positiveArr = new Int32Array(10);\n        this.negativeArr = new Int32Array(10);\n    }\n    get(idx) {\n        if (idx < 0) {\n            idx = -idx - 1;\n            return this.negativeArr[idx];\n        }\n        else {\n            return this.positiveArr[idx];\n        }\n    }\n    set(idx, value) {\n        if (idx < 0) {\n            idx = -idx - 1;\n            if (idx >= this.negativeArr.length) {\n                const arr = this.negativeArr;\n                this.negativeArr = new Int32Array(arr.length * 2);\n                this.negativeArr.set(arr);\n            }\n            this.negativeArr[idx] = value;\n        }\n        else {\n            if (idx >= this.positiveArr.length) {\n                const arr = this.positiveArr;\n                this.positiveArr = new Int32Array(arr.length * 2);\n                this.positiveArr.set(arr);\n            }\n            this.positiveArr[idx] = value;\n        }\n    }\n}\n/**\n * An array that supports fast negative indices.\n*/\nclass FastArrayNegativeIndices {\n    constructor() {\n        this.positiveArr = [];\n        this.negativeArr = [];\n    }\n    get(idx) {\n        if (idx < 0) {\n            idx = -idx - 1;\n            return this.negativeArr[idx];\n        }\n        else {\n            return this.positiveArr[idx];\n        }\n    }\n    set(idx, value) {\n        if (idx < 0) {\n            idx = -idx - 1;\n            this.negativeArr[idx] = value;\n        }\n        else {\n            this.positiveArr[idx] = value;\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 { findLastIdxMonotonous, findLastMonotonous, findFirstMonotonous } from '../../../../base/common/arraysFind.js';\nimport { OffsetRange } from '../../core/offsetRange.js';\nimport { Position } from '../../core/position.js';\nimport { Range } from '../../core/range.js';\nimport { isSpace } from './utils.js';\nexport class LinesSliceCharSequence {\n    constructor(lines, lineRange, considerWhitespaceChanges) {\n        // This slice has to have lineRange.length many \\n! (otherwise diffing against an empty slice will be problematic)\n        // (Unless it covers the entire document, in that case the other slice also has to cover the entire document ands it's okay)\n        this.lines = lines;\n        this.considerWhitespaceChanges = considerWhitespaceChanges;\n        this.elements = [];\n        this.firstCharOffsetByLine = [];\n        // To account for trimming\n        this.additionalOffsetByLine = [];\n        // If the slice covers the end, but does not start at the beginning, we include just the \\n of the previous line.\n        let trimFirstLineFully = false;\n        if (lineRange.start > 0 && lineRange.endExclusive >= lines.length) {\n            lineRange = new OffsetRange(lineRange.start - 1, lineRange.endExclusive);\n            trimFirstLineFully = true;\n        }\n        this.lineRange = lineRange;\n        this.firstCharOffsetByLine[0] = 0;\n        for (let i = this.lineRange.start; i < this.lineRange.endExclusive; i++) {\n            let line = lines[i];\n            let offset = 0;\n            if (trimFirstLineFully) {\n                offset = line.length;\n                line = '';\n                trimFirstLineFully = false;\n            }\n            else if (!considerWhitespaceChanges) {\n                const trimmedStartLine = line.trimStart();\n                offset = line.length - trimmedStartLine.length;\n                line = trimmedStartLine.trimEnd();\n            }\n            this.additionalOffsetByLine.push(offset);\n            for (let i = 0; i < line.length; i++) {\n                this.elements.push(line.charCodeAt(i));\n            }\n            // Don't add an \\n that does not exist in the document.\n            if (i < lines.length - 1) {\n                this.elements.push('\\n'.charCodeAt(0));\n                this.firstCharOffsetByLine[i - this.lineRange.start + 1] = this.elements.length;\n            }\n        }\n        // To account for the last line\n        this.additionalOffsetByLine.push(0);\n    }\n    toString() {\n        return `Slice: \"${this.text}\"`;\n    }\n    get text() {\n        return this.getText(new OffsetRange(0, this.length));\n    }\n    getText(range) {\n        return this.elements.slice(range.start, range.endExclusive).map(e => String.fromCharCode(e)).join('');\n    }\n    getElement(offset) {\n        return this.elements[offset];\n    }\n    get length() {\n        return this.elements.length;\n    }\n    getBoundaryScore(length) {\n        //   a   b   c   ,           d   e   f\n        // 11  0   0   12  15  6   13  0   0   11\n        const prevCategory = getCategory(length > 0 ? this.elements[length - 1] : -1);\n        const nextCategory = getCategory(length < this.elements.length ? this.elements[length] : -1);\n        if (prevCategory === 7 /* CharBoundaryCategory.LineBreakCR */ && nextCategory === 8 /* CharBoundaryCategory.LineBreakLF */) {\n            // don't break between \\r and \\n\n            return 0;\n        }\n        if (prevCategory === 8 /* CharBoundaryCategory.LineBreakLF */) {\n            // prefer the linebreak before the change\n            return 150;\n        }\n        let score = 0;\n        if (prevCategory !== nextCategory) {\n            score += 10;\n            if (prevCategory === 0 /* CharBoundaryCategory.WordLower */ && nextCategory === 1 /* CharBoundaryCategory.WordUpper */) {\n                score += 1;\n            }\n        }\n        score += getCategoryBoundaryScore(prevCategory);\n        score += getCategoryBoundaryScore(nextCategory);\n        return score;\n    }\n    translateOffset(offset) {\n        // find smallest i, so that lineBreakOffsets[i] <= offset using binary search\n        if (this.lineRange.isEmpty) {\n            return new Position(this.lineRange.start + 1, 1);\n        }\n        const i = findLastIdxMonotonous(this.firstCharOffsetByLine, (value) => value <= offset);\n        return new Position(this.lineRange.start + i + 1, offset - this.firstCharOffsetByLine[i] + this.additionalOffsetByLine[i] + 1);\n    }\n    translateRange(range) {\n        return Range.fromPositions(this.translateOffset(range.start), this.translateOffset(range.endExclusive));\n    }\n    /**\n     * Finds the word that contains the character at the given offset\n     */\n    findWordContaining(offset) {\n        if (offset < 0 || offset >= this.elements.length) {\n            return undefined;\n        }\n        if (!isWordChar(this.elements[offset])) {\n            return undefined;\n        }\n        // find start\n        let start = offset;\n        while (start > 0 && isWordChar(this.elements[start - 1])) {\n            start--;\n        }\n        // find end\n        let end = offset;\n        while (end < this.elements.length && isWordChar(this.elements[end])) {\n            end++;\n        }\n        return new OffsetRange(start, end);\n    }\n    countLinesIn(range) {\n        return this.translateOffset(range.endExclusive).lineNumber - this.translateOffset(range.start).lineNumber;\n    }\n    isStronglyEqual(offset1, offset2) {\n        return this.elements[offset1] === this.elements[offset2];\n    }\n    extendToFullLines(range) {\n        var _a, _b;\n        const start = (_a = findLastMonotonous(this.firstCharOffsetByLine, x => x <= range.start)) !== null && _a !== void 0 ? _a : 0;\n        const end = (_b = findFirstMonotonous(this.firstCharOffsetByLine, x => range.endExclusive <= x)) !== null && _b !== void 0 ? _b : this.elements.length;\n        return new OffsetRange(start, end);\n    }\n}\nfunction isWordChar(charCode) {\n    return charCode >= 97 /* CharCode.a */ && charCode <= 122 /* CharCode.z */\n        || charCode >= 65 /* CharCode.A */ && charCode <= 90 /* CharCode.Z */\n        || charCode >= 48 /* CharCode.Digit0 */ && charCode <= 57 /* CharCode.Digit9 */;\n}\nconst score = {\n    [0 /* CharBoundaryCategory.WordLower */]: 0,\n    [1 /* CharBoundaryCategory.WordUpper */]: 0,\n    [2 /* CharBoundaryCategory.WordNumber */]: 0,\n    [3 /* CharBoundaryCategory.End */]: 10,\n    [4 /* CharBoundaryCategory.Other */]: 2,\n    [5 /* CharBoundaryCategory.Separator */]: 30,\n    [6 /* CharBoundaryCategory.Space */]: 3,\n    [7 /* CharBoundaryCategory.LineBreakCR */]: 10,\n    [8 /* CharBoundaryCategory.LineBreakLF */]: 10,\n};\nfunction getCategoryBoundaryScore(category) {\n    return score[category];\n}\nfunction getCategory(charCode) {\n    if (charCode === 10 /* CharCode.LineFeed */) {\n        return 8 /* CharBoundaryCategory.LineBreakLF */;\n    }\n    else if (charCode === 13 /* CharCode.CarriageReturn */) {\n        return 7 /* CharBoundaryCategory.LineBreakCR */;\n    }\n    else if (isSpace(charCode)) {\n        return 6 /* CharBoundaryCategory.Space */;\n    }\n    else if (charCode >= 97 /* CharCode.a */ && charCode <= 122 /* CharCode.z */) {\n        return 0 /* CharBoundaryCategory.WordLower */;\n    }\n    else if (charCode >= 65 /* CharCode.A */ && charCode <= 90 /* CharCode.Z */) {\n        return 1 /* CharBoundaryCategory.WordUpper */;\n    }\n    else if (charCode >= 48 /* CharCode.Digit0 */ && charCode <= 57 /* CharCode.Digit9 */) {\n        return 2 /* CharBoundaryCategory.WordNumber */;\n    }\n    else if (charCode === -1) {\n        return 3 /* CharBoundaryCategory.End */;\n    }\n    else if (charCode === 44 /* CharCode.Comma */ || charCode === 59 /* CharCode.Semicolon */) {\n        return 5 /* CharBoundaryCategory.Separator */;\n    }\n    else {\n        return 4 /* CharBoundaryCategory.Other */;\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 { SequenceDiff } from './algorithms/diffAlgorithm.js';\nimport { LineRangeMapping } from '../rangeMapping.js';\nimport { pushMany, compareBy, numberComparator, reverseOrder } from '../../../../base/common/arrays.js';\nimport { MonotonousArray, findLastMonotonous } from '../../../../base/common/arraysFind.js';\nimport { SetMap } from '../../../../base/common/map.js';\nimport { LineRange, LineRangeSet } from '../../core/lineRange.js';\nimport { OffsetRange } from '../../core/offsetRange.js';\nimport { LinesSliceCharSequence } from './linesSliceCharSequence.js';\nimport { LineRangeFragment, isSpace } from './utils.js';\nimport { MyersDiffAlgorithm } from './algorithms/myersDiffAlgorithm.js';\nexport function computeMovedLines(changes, originalLines, modifiedLines, hashedOriginalLines, hashedModifiedLines, timeout) {\n    let { moves, excludedChanges } = computeMovesFromSimpleDeletionsToSimpleInsertions(changes, originalLines, modifiedLines, timeout);\n    if (!timeout.isValid()) {\n        return [];\n    }\n    const filteredChanges = changes.filter(c => !excludedChanges.has(c));\n    const unchangedMoves = computeUnchangedMoves(filteredChanges, hashedOriginalLines, hashedModifiedLines, originalLines, modifiedLines, timeout);\n    pushMany(moves, unchangedMoves);\n    moves = joinCloseConsecutiveMoves(moves);\n    // Ignore too short moves\n    moves = moves.filter(current => {\n        const lines = current.original.toOffsetRange().slice(originalLines).map(l => l.trim());\n        const originalText = lines.join('\\n');\n        return originalText.length >= 15 && countWhere(lines, l => l.length >= 2) >= 2;\n    });\n    moves = removeMovesInSameDiff(changes, moves);\n    return moves;\n}\nfunction countWhere(arr, predicate) {\n    let count = 0;\n    for (const t of arr) {\n        if (predicate(t)) {\n            count++;\n        }\n    }\n    return count;\n}\nfunction computeMovesFromSimpleDeletionsToSimpleInsertions(changes, originalLines, modifiedLines, timeout) {\n    const moves = [];\n    const deletions = changes\n        .filter(c => c.modified.isEmpty && c.original.length >= 3)\n        .map(d => new LineRangeFragment(d.original, originalLines, d));\n    const insertions = new Set(changes\n        .filter(c => c.original.isEmpty && c.modified.length >= 3)\n        .map(d => new LineRangeFragment(d.modified, modifiedLines, d)));\n    const excludedChanges = new Set();\n    for (const deletion of deletions) {\n        let highestSimilarity = -1;\n        let best;\n        for (const insertion of insertions) {\n            const similarity = deletion.computeSimilarity(insertion);\n            if (similarity > highestSimilarity) {\n                highestSimilarity = similarity;\n                best = insertion;\n            }\n        }\n        if (highestSimilarity > 0.90 && best) {\n            insertions.delete(best);\n            moves.push(new LineRangeMapping(deletion.range, best.range));\n            excludedChanges.add(deletion.source);\n            excludedChanges.add(best.source);\n        }\n        if (!timeout.isValid()) {\n            return { moves, excludedChanges };\n        }\n    }\n    return { moves, excludedChanges };\n}\nfunction computeUnchangedMoves(changes, hashedOriginalLines, hashedModifiedLines, originalLines, modifiedLines, timeout) {\n    const moves = [];\n    const original3LineHashes = new SetMap();\n    for (const change of changes) {\n        for (let i = change.original.startLineNumber; i < change.original.endLineNumberExclusive - 2; i++) {\n            const key = `${hashedOriginalLines[i - 1]}:${hashedOriginalLines[i + 1 - 1]}:${hashedOriginalLines[i + 2 - 1]}`;\n            original3LineHashes.add(key, { range: new LineRange(i, i + 3) });\n        }\n    }\n    const possibleMappings = [];\n    changes.sort(compareBy(c => c.modified.startLineNumber, numberComparator));\n    for (const change of changes) {\n        let lastMappings = [];\n        for (let i = change.modified.startLineNumber; i < change.modified.endLineNumberExclusive - 2; i++) {\n            const key = `${hashedModifiedLines[i - 1]}:${hashedModifiedLines[i + 1 - 1]}:${hashedModifiedLines[i + 2 - 1]}`;\n            const currentModifiedRange = new LineRange(i, i + 3);\n            const nextMappings = [];\n            original3LineHashes.forEach(key, ({ range }) => {\n                for (const lastMapping of lastMappings) {\n                    // does this match extend some last match?\n                    if (lastMapping.originalLineRange.endLineNumberExclusive + 1 === range.endLineNumberExclusive &&\n                        lastMapping.modifiedLineRange.endLineNumberExclusive + 1 === currentModifiedRange.endLineNumberExclusive) {\n                        lastMapping.originalLineRange = new LineRange(lastMapping.originalLineRange.startLineNumber, range.endLineNumberExclusive);\n                        lastMapping.modifiedLineRange = new LineRange(lastMapping.modifiedLineRange.startLineNumber, currentModifiedRange.endLineNumberExclusive);\n                        nextMappings.push(lastMapping);\n                        return;\n                    }\n                }\n                const mapping = {\n                    modifiedLineRange: currentModifiedRange,\n                    originalLineRange: range,\n                };\n                possibleMappings.push(mapping);\n                nextMappings.push(mapping);\n            });\n            lastMappings = nextMappings;\n        }\n        if (!timeout.isValid()) {\n            return [];\n        }\n    }\n    possibleMappings.sort(reverseOrder(compareBy(m => m.modifiedLineRange.length, numberComparator)));\n    const modifiedSet = new LineRangeSet();\n    const originalSet = new LineRangeSet();\n    for (const mapping of possibleMappings) {\n        const diffOrigToMod = mapping.modifiedLineRange.startLineNumber - mapping.originalLineRange.startLineNumber;\n        const modifiedSections = modifiedSet.subtractFrom(mapping.modifiedLineRange);\n        const originalTranslatedSections = originalSet.subtractFrom(mapping.originalLineRange).getWithDelta(diffOrigToMod);\n        const modifiedIntersectedSections = modifiedSections.getIntersection(originalTranslatedSections);\n        for (const s of modifiedIntersectedSections.ranges) {\n            if (s.length < 3) {\n                continue;\n            }\n            const modifiedLineRange = s;\n            const originalLineRange = s.delta(-diffOrigToMod);\n            moves.push(new LineRangeMapping(originalLineRange, modifiedLineRange));\n            modifiedSet.addRange(modifiedLineRange);\n            originalSet.addRange(originalLineRange);\n        }\n    }\n    moves.sort(compareBy(m => m.original.startLineNumber, numberComparator));\n    const monotonousChanges = new MonotonousArray(changes);\n    for (let i = 0; i < moves.length; i++) {\n        const move = moves[i];\n        const firstTouchingChangeOrig = monotonousChanges.findLastMonotonous(c => c.original.startLineNumber <= move.original.startLineNumber);\n        const firstTouchingChangeMod = findLastMonotonous(changes, c => c.modified.startLineNumber <= move.modified.startLineNumber);\n        const linesAbove = Math.max(move.original.startLineNumber - firstTouchingChangeOrig.original.startLineNumber, move.modified.startLineNumber - firstTouchingChangeMod.modified.startLineNumber);\n        const lastTouchingChangeOrig = monotonousChanges.findLastMonotonous(c => c.original.startLineNumber < move.original.endLineNumberExclusive);\n        const lastTouchingChangeMod = findLastMonotonous(changes, c => c.modified.startLineNumber < move.modified.endLineNumberExclusive);\n        const linesBelow = Math.max(lastTouchingChangeOrig.original.endLineNumberExclusive - move.original.endLineNumberExclusive, lastTouchingChangeMod.modified.endLineNumberExclusive - move.modified.endLineNumberExclusive);\n        let extendToTop;\n        for (extendToTop = 0; extendToTop < linesAbove; extendToTop++) {\n            const origLine = move.original.startLineNumber - extendToTop - 1;\n            const modLine = move.modified.startLineNumber - extendToTop - 1;\n            if (origLine > originalLines.length || modLine > modifiedLines.length) {\n                break;\n            }\n            if (modifiedSet.contains(modLine) || originalSet.contains(origLine)) {\n                break;\n            }\n            if (!areLinesSimilar(originalLines[origLine - 1], modifiedLines[modLine - 1], timeout)) {\n                break;\n            }\n        }\n        if (extendToTop > 0) {\n            originalSet.addRange(new LineRange(move.original.startLineNumber - extendToTop, move.original.startLineNumber));\n            modifiedSet.addRange(new LineRange(move.modified.startLineNumber - extendToTop, move.modified.startLineNumber));\n        }\n        let extendToBottom;\n        for (extendToBottom = 0; extendToBottom < linesBelow; extendToBottom++) {\n            const origLine = move.original.endLineNumberExclusive + extendToBottom;\n            const modLine = move.modified.endLineNumberExclusive + extendToBottom;\n            if (origLine > originalLines.length || modLine > modifiedLines.length) {\n                break;\n            }\n            if (modifiedSet.contains(modLine) || originalSet.contains(origLine)) {\n                break;\n            }\n            if (!areLinesSimilar(originalLines[origLine - 1], modifiedLines[modLine - 1], timeout)) {\n                break;\n            }\n        }\n        if (extendToBottom > 0) {\n            originalSet.addRange(new LineRange(move.original.endLineNumberExclusive, move.original.endLineNumberExclusive + extendToBottom));\n            modifiedSet.addRange(new LineRange(move.modified.endLineNumberExclusive, move.modified.endLineNumberExclusive + extendToBottom));\n        }\n        if (extendToTop > 0 || extendToBottom > 0) {\n            moves[i] = new LineRangeMapping(new LineRange(move.original.startLineNumber - extendToTop, move.original.endLineNumberExclusive + extendToBottom), new LineRange(move.modified.startLineNumber - extendToTop, move.modified.endLineNumberExclusive + extendToBottom));\n        }\n    }\n    return moves;\n}\nfunction areLinesSimilar(line1, line2, timeout) {\n    if (line1.trim() === line2.trim()) {\n        return true;\n    }\n    if (line1.length > 300 && line2.length > 300) {\n        return false;\n    }\n    const myersDiffingAlgorithm = new MyersDiffAlgorithm();\n    const result = myersDiffingAlgorithm.compute(new LinesSliceCharSequence([line1], new OffsetRange(0, 1), false), new LinesSliceCharSequence([line2], new OffsetRange(0, 1), false), timeout);\n    let commonNonSpaceCharCount = 0;\n    const inverted = SequenceDiff.invert(result.diffs, line1.length);\n    for (const seq of inverted) {\n        seq.seq1Range.forEach(idx => {\n            if (!isSpace(line1.charCodeAt(idx))) {\n                commonNonSpaceCharCount++;\n            }\n        });\n    }\n    function countNonWsChars(str) {\n        let count = 0;\n        for (let i = 0; i < line1.length; i++) {\n            if (!isSpace(str.charCodeAt(i))) {\n                count++;\n            }\n        }\n        return count;\n    }\n    const longerLineLength = countNonWsChars(line1.length > line2.length ? line1 : line2);\n    const r = commonNonSpaceCharCount / longerLineLength > 0.6 && longerLineLength > 10;\n    return r;\n}\nfunction joinCloseConsecutiveMoves(moves) {\n    if (moves.length === 0) {\n        return moves;\n    }\n    moves.sort(compareBy(m => m.original.startLineNumber, numberComparator));\n    const result = [moves[0]];\n    for (let i = 1; i < moves.length; i++) {\n        const last = result[result.length - 1];\n        const current = moves[i];\n        const originalDist = current.original.startLineNumber - last.original.endLineNumberExclusive;\n        const modifiedDist = current.modified.startLineNumber - last.modified.endLineNumberExclusive;\n        const currentMoveAfterLast = originalDist >= 0 && modifiedDist >= 0;\n        if (currentMoveAfterLast && originalDist + modifiedDist <= 2) {\n            result[result.length - 1] = last.join(current);\n            continue;\n        }\n        result.push(current);\n    }\n    return result;\n}\nfunction removeMovesInSameDiff(changes, moves) {\n    const changesMonotonous = new MonotonousArray(changes);\n    moves = moves.filter(m => {\n        const diffBeforeEndOfMoveOriginal = changesMonotonous.findLastMonotonous(c => c.original.startLineNumber < m.original.endLineNumberExclusive)\n            || new LineRangeMapping(new LineRange(1, 1), new LineRange(1, 1));\n        const diffBeforeEndOfMoveModified = findLastMonotonous(changes, c => c.modified.startLineNumber < m.modified.endLineNumberExclusive);\n        const differentDiffs = diffBeforeEndOfMoveOriginal !== diffBeforeEndOfMoveModified;\n        return differentDiffs;\n    });\n    return moves;\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 LineSequence {\n    constructor(trimmedHash, lines) {\n        this.trimmedHash = trimmedHash;\n        this.lines = lines;\n    }\n    getElement(offset) {\n        return this.trimmedHash[offset];\n    }\n    get length() {\n        return this.trimmedHash.length;\n    }\n    getBoundaryScore(length) {\n        const indentationBefore = length === 0 ? 0 : getIndentation(this.lines[length - 1]);\n        const indentationAfter = length === this.lines.length ? 0 : getIndentation(this.lines[length]);\n        return 1000 - (indentationBefore + indentationAfter);\n    }\n    getText(range) {\n        return this.lines.slice(range.start, range.endExclusive).join('\\n');\n    }\n    isStronglyEqual(offset1, offset2) {\n        return this.lines[offset1] === this.lines[offset2];\n    }\n}\nfunction getIndentation(str) {\n    let i = 0;\n    while (i < str.length && (str.charCodeAt(i) === 32 /* CharCode.Space */ || str.charCodeAt(i) === 9 /* CharCode.Tab */)) {\n        i++;\n    }\n    return i;\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 { equals, groupAdjacentBy } from '../../../../base/common/arrays.js';\nimport { assertFn, checkAdjacentItems } from '../../../../base/common/assert.js';\nimport { LineRange } from '../../core/lineRange.js';\nimport { OffsetRange } from '../../core/offsetRange.js';\nimport { Range } from '../../core/range.js';\nimport { DateTimeout, InfiniteTimeout, SequenceDiff } from './algorithms/diffAlgorithm.js';\nimport { DynamicProgrammingDiffing } from './algorithms/dynamicProgrammingDiffing.js';\nimport { MyersDiffAlgorithm } from './algorithms/myersDiffAlgorithm.js';\nimport { computeMovedLines } from './computeMovedLines.js';\nimport { extendDiffsToEntireWordIfAppropriate, optimizeSequenceDiffs, removeShortMatches, removeVeryShortMatchingLinesBetweenDiffs, removeVeryShortMatchingTextBetweenLongDiffs } from './heuristicSequenceOptimizations.js';\nimport { LineSequence } from './lineSequence.js';\nimport { LinesSliceCharSequence } from './linesSliceCharSequence.js';\nimport { LinesDiff, MovedText } from '../linesDiffComputer.js';\nimport { DetailedLineRangeMapping, RangeMapping } from '../rangeMapping.js';\nexport class DefaultLinesDiffComputer {\n    constructor() {\n        this.dynamicProgrammingDiffing = new DynamicProgrammingDiffing();\n        this.myersDiffingAlgorithm = new MyersDiffAlgorithm();\n    }\n    computeDiff(originalLines, modifiedLines, options) {\n        if (originalLines.length <= 1 && equals(originalLines, modifiedLines, (a, b) => a === b)) {\n            return new LinesDiff([], [], false);\n        }\n        if (originalLines.length === 1 && originalLines[0].length === 0 || modifiedLines.length === 1 && modifiedLines[0].length === 0) {\n            return new LinesDiff([\n                new DetailedLineRangeMapping(new LineRange(1, originalLines.length + 1), new LineRange(1, modifiedLines.length + 1), [\n                    new RangeMapping(new Range(1, 1, originalLines.length, originalLines[originalLines.length - 1].length + 1), new Range(1, 1, modifiedLines.length, modifiedLines[modifiedLines.length - 1].length + 1))\n                ])\n            ], [], false);\n        }\n        const timeout = options.maxComputationTimeMs === 0 ? InfiniteTimeout.instance : new DateTimeout(options.maxComputationTimeMs);\n        const considerWhitespaceChanges = !options.ignoreTrimWhitespace;\n        const perfectHashes = new Map();\n        function getOrCreateHash(text) {\n            let hash = perfectHashes.get(text);\n            if (hash === undefined) {\n                hash = perfectHashes.size;\n                perfectHashes.set(text, hash);\n            }\n            return hash;\n        }\n        const originalLinesHashes = originalLines.map((l) => getOrCreateHash(l.trim()));\n        const modifiedLinesHashes = modifiedLines.map((l) => getOrCreateHash(l.trim()));\n        const sequence1 = new LineSequence(originalLinesHashes, originalLines);\n        const sequence2 = new LineSequence(modifiedLinesHashes, modifiedLines);\n        const lineAlignmentResult = (() => {\n            if (sequence1.length + sequence2.length < 1700) {\n                // Use the improved algorithm for small files\n                return this.dynamicProgrammingDiffing.compute(sequence1, sequence2, timeout, (offset1, offset2) => originalLines[offset1] === modifiedLines[offset2]\n                    ? modifiedLines[offset2].length === 0\n                        ? 0.1\n                        : 1 + Math.log(1 + modifiedLines[offset2].length)\n                    : 0.99);\n            }\n            return this.myersDiffingAlgorithm.compute(sequence1, sequence2, timeout);\n        })();\n        let lineAlignments = lineAlignmentResult.diffs;\n        let hitTimeout = lineAlignmentResult.hitTimeout;\n        lineAlignments = optimizeSequenceDiffs(sequence1, sequence2, lineAlignments);\n        lineAlignments = removeVeryShortMatchingLinesBetweenDiffs(sequence1, sequence2, lineAlignments);\n        const alignments = [];\n        const scanForWhitespaceChanges = (equalLinesCount) => {\n            if (!considerWhitespaceChanges) {\n                return;\n            }\n            for (let i = 0; i < equalLinesCount; i++) {\n                const seq1Offset = seq1LastStart + i;\n                const seq2Offset = seq2LastStart + i;\n                if (originalLines[seq1Offset] !== modifiedLines[seq2Offset]) {\n                    // This is because of whitespace changes, diff these lines\n                    const characterDiffs = this.refineDiff(originalLines, modifiedLines, new SequenceDiff(new OffsetRange(seq1Offset, seq1Offset + 1), new OffsetRange(seq2Offset, seq2Offset + 1)), timeout, considerWhitespaceChanges);\n                    for (const a of characterDiffs.mappings) {\n                        alignments.push(a);\n                    }\n                    if (characterDiffs.hitTimeout) {\n                        hitTimeout = true;\n                    }\n                }\n            }\n        };\n        let seq1LastStart = 0;\n        let seq2LastStart = 0;\n        for (const diff of lineAlignments) {\n            assertFn(() => diff.seq1Range.start - seq1LastStart === diff.seq2Range.start - seq2LastStart);\n            const equalLinesCount = diff.seq1Range.start - seq1LastStart;\n            scanForWhitespaceChanges(equalLinesCount);\n            seq1LastStart = diff.seq1Range.endExclusive;\n            seq2LastStart = diff.seq2Range.endExclusive;\n            const characterDiffs = this.refineDiff(originalLines, modifiedLines, diff, timeout, considerWhitespaceChanges);\n            if (characterDiffs.hitTimeout) {\n                hitTimeout = true;\n            }\n            for (const a of characterDiffs.mappings) {\n                alignments.push(a);\n            }\n        }\n        scanForWhitespaceChanges(originalLines.length - seq1LastStart);\n        const changes = lineRangeMappingFromRangeMappings(alignments, originalLines, modifiedLines);\n        let moves = [];\n        if (options.computeMoves) {\n            moves = this.computeMoves(changes, originalLines, modifiedLines, originalLinesHashes, modifiedLinesHashes, timeout, considerWhitespaceChanges);\n        }\n        // Make sure all ranges are valid\n        assertFn(() => {\n            function validatePosition(pos, lines) {\n                if (pos.lineNumber < 1 || pos.lineNumber > lines.length) {\n                    return false;\n                }\n                const line = lines[pos.lineNumber - 1];\n                if (pos.column < 1 || pos.column > line.length + 1) {\n                    return false;\n                }\n                return true;\n            }\n            function validateRange(range, lines) {\n                if (range.startLineNumber < 1 || range.startLineNumber > lines.length + 1) {\n                    return false;\n                }\n                if (range.endLineNumberExclusive < 1 || range.endLineNumberExclusive > lines.length + 1) {\n                    return false;\n                }\n                return true;\n            }\n            for (const c of changes) {\n                if (!c.innerChanges) {\n                    return false;\n                }\n                for (const ic of c.innerChanges) {\n                    const valid = validatePosition(ic.modifiedRange.getStartPosition(), modifiedLines) && validatePosition(ic.modifiedRange.getEndPosition(), modifiedLines) &&\n                        validatePosition(ic.originalRange.getStartPosition(), originalLines) && validatePosition(ic.originalRange.getEndPosition(), originalLines);\n                    if (!valid) {\n                        return false;\n                    }\n                }\n                if (!validateRange(c.modified, modifiedLines) || !validateRange(c.original, originalLines)) {\n                    return false;\n                }\n            }\n            return true;\n        });\n        return new LinesDiff(changes, moves, hitTimeout);\n    }\n    computeMoves(changes, originalLines, modifiedLines, hashedOriginalLines, hashedModifiedLines, timeout, considerWhitespaceChanges) {\n        const moves = computeMovedLines(changes, originalLines, modifiedLines, hashedOriginalLines, hashedModifiedLines, timeout);\n        const movesWithDiffs = moves.map(m => {\n            const moveChanges = this.refineDiff(originalLines, modifiedLines, new SequenceDiff(m.original.toOffsetRange(), m.modified.toOffsetRange()), timeout, considerWhitespaceChanges);\n            const mappings = lineRangeMappingFromRangeMappings(moveChanges.mappings, originalLines, modifiedLines, true);\n            return new MovedText(m, mappings);\n        });\n        return movesWithDiffs;\n    }\n    refineDiff(originalLines, modifiedLines, diff, timeout, considerWhitespaceChanges) {\n        const slice1 = new LinesSliceCharSequence(originalLines, diff.seq1Range, considerWhitespaceChanges);\n        const slice2 = new LinesSliceCharSequence(modifiedLines, diff.seq2Range, considerWhitespaceChanges);\n        const diffResult = slice1.length + slice2.length < 500\n            ? this.dynamicProgrammingDiffing.compute(slice1, slice2, timeout)\n            : this.myersDiffingAlgorithm.compute(slice1, slice2, timeout);\n        let diffs = diffResult.diffs;\n        diffs = optimizeSequenceDiffs(slice1, slice2, diffs);\n        diffs = extendDiffsToEntireWordIfAppropriate(slice1, slice2, diffs);\n        diffs = removeShortMatches(slice1, slice2, diffs);\n        diffs = removeVeryShortMatchingTextBetweenLongDiffs(slice1, slice2, diffs);\n        const result = diffs.map((d) => new RangeMapping(slice1.translateRange(d.seq1Range), slice2.translateRange(d.seq2Range)));\n        // Assert: result applied on original should be the same as diff applied to original\n        return {\n            mappings: result,\n            hitTimeout: diffResult.hitTimeout,\n        };\n    }\n}\nexport function lineRangeMappingFromRangeMappings(alignments, originalLines, modifiedLines, dontAssertStartLine = false) {\n    const changes = [];\n    for (const g of groupAdjacentBy(alignments.map(a => getLineRangeMapping(a, originalLines, modifiedLines)), (a1, a2) => a1.original.overlapOrTouch(a2.original)\n        || a1.modified.overlapOrTouch(a2.modified))) {\n        const first = g[0];\n        const last = g[g.length - 1];\n        changes.push(new DetailedLineRangeMapping(first.original.join(last.original), first.modified.join(last.modified), g.map(a => a.innerChanges[0])));\n    }\n    assertFn(() => {\n        if (!dontAssertStartLine && changes.length > 0) {\n            if (changes[0].modified.startLineNumber !== changes[0].original.startLineNumber) {\n                return false;\n            }\n            if (modifiedLines.length - changes[changes.length - 1].modified.endLineNumberExclusive !== originalLines.length - changes[changes.length - 1].original.endLineNumberExclusive) {\n                return false;\n            }\n        }\n        return checkAdjacentItems(changes, (m1, m2) => m2.original.startLineNumber - m1.original.endLineNumberExclusive === m2.modified.startLineNumber - m1.modified.endLineNumberExclusive &&\n            // There has to be an unchanged line in between (otherwise both diffs should have been joined)\n            m1.original.endLineNumberExclusive < m2.original.startLineNumber &&\n            m1.modified.endLineNumberExclusive < m2.modified.startLineNumber);\n    });\n    return changes;\n}\nexport function getLineRangeMapping(rangeMapping, originalLines, modifiedLines) {\n    let lineStartDelta = 0;\n    let lineEndDelta = 0;\n    // rangeMapping describes the edit that replaces `rangeMapping.originalRange` with `newText := getText(modifiedLines, rangeMapping.modifiedRange)`.\n    // original: ]xxx \\n <- this line is not modified\n    // modified: ]xx  \\n\n    if (rangeMapping.modifiedRange.endColumn === 1 && rangeMapping.originalRange.endColumn === 1\n        && rangeMapping.originalRange.startLineNumber + lineStartDelta <= rangeMapping.originalRange.endLineNumber\n        && rangeMapping.modifiedRange.startLineNumber + lineStartDelta <= rangeMapping.modifiedRange.endLineNumber) {\n        // We can only do this if the range is not empty yet\n        lineEndDelta = -1;\n    }\n    // original: xxx[ \\n <- this line is not modified\n    // modified: xxx[ \\n\n    if (rangeMapping.modifiedRange.startColumn - 1 >= modifiedLines[rangeMapping.modifiedRange.startLineNumber - 1].length\n        && rangeMapping.originalRange.startColumn - 1 >= originalLines[rangeMapping.originalRange.startLineNumber - 1].length\n        && rangeMapping.originalRange.startLineNumber <= rangeMapping.originalRange.endLineNumber + lineEndDelta\n        && rangeMapping.modifiedRange.startLineNumber <= rangeMapping.modifiedRange.endLineNumber + lineEndDelta) {\n        // We can only do this if the range is not empty yet\n        lineStartDelta = 1;\n    }\n    const originalLineRange = new LineRange(rangeMapping.originalRange.startLineNumber + lineStartDelta, rangeMapping.originalRange.endLineNumber + 1 + lineEndDelta);\n    const modifiedLineRange = new LineRange(rangeMapping.modifiedRange.startLineNumber + lineStartDelta, rangeMapping.modifiedRange.endLineNumber + 1 + lineEndDelta);\n    return new DetailedLineRangeMapping(originalLineRange, modifiedLineRange, [rangeMapping]);\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 { forEachWithNeighbors } from '../../../../base/common/arrays.js';\nimport { OffsetRange } from '../../core/offsetRange.js';\nimport { OffsetPair, SequenceDiff } from './algorithms/diffAlgorithm.js';\nexport function optimizeSequenceDiffs(sequence1, sequence2, sequenceDiffs) {\n    let result = sequenceDiffs;\n    result = joinSequenceDiffsByShifting(sequence1, sequence2, result);\n    // Sometimes, calling this function twice improves the result.\n    // Uncomment the second invocation and run the tests to see the difference.\n    result = joinSequenceDiffsByShifting(sequence1, sequence2, result);\n    result = shiftSequenceDiffs(sequence1, sequence2, result);\n    return result;\n}\n/**\n * This function fixes issues like this:\n * ```\n * import { Baz, Bar } from \"foo\";\n * ```\n * <->\n * ```\n * import { Baz, Bar, Foo } from \"foo\";\n * ```\n * Computed diff: [ {Add \",\" after Bar}, {Add \"Foo \" after space} }\n * Improved diff: [{Add \", Foo\" after Bar}]\n */\nfunction joinSequenceDiffsByShifting(sequence1, sequence2, sequenceDiffs) {\n    if (sequenceDiffs.length === 0) {\n        return sequenceDiffs;\n    }\n    const result = [];\n    result.push(sequenceDiffs[0]);\n    // First move them all to the left as much as possible and join them if possible\n    for (let i = 1; i < sequenceDiffs.length; i++) {\n        const prevResult = result[result.length - 1];\n        let cur = sequenceDiffs[i];\n        if (cur.seq1Range.isEmpty || cur.seq2Range.isEmpty) {\n            const length = cur.seq1Range.start - prevResult.seq1Range.endExclusive;\n            let d;\n            for (d = 1; d <= length; d++) {\n                if (sequence1.getElement(cur.seq1Range.start - d) !== sequence1.getElement(cur.seq1Range.endExclusive - d) ||\n                    sequence2.getElement(cur.seq2Range.start - d) !== sequence2.getElement(cur.seq2Range.endExclusive - d)) {\n                    break;\n                }\n            }\n            d--;\n            if (d === length) {\n                // Merge previous and current diff\n                result[result.length - 1] = new SequenceDiff(new OffsetRange(prevResult.seq1Range.start, cur.seq1Range.endExclusive - length), new OffsetRange(prevResult.seq2Range.start, cur.seq2Range.endExclusive - length));\n                continue;\n            }\n            cur = cur.delta(-d);\n        }\n        result.push(cur);\n    }\n    const result2 = [];\n    // Then move them all to the right and join them again if possible\n    for (let i = 0; i < result.length - 1; i++) {\n        const nextResult = result[i + 1];\n        let cur = result[i];\n        if (cur.seq1Range.isEmpty || cur.seq2Range.isEmpty) {\n            const length = nextResult.seq1Range.start - cur.seq1Range.endExclusive;\n            let d;\n            for (d = 0; d < length; d++) {\n                if (!sequence1.isStronglyEqual(cur.seq1Range.start + d, cur.seq1Range.endExclusive + d) ||\n                    !sequence2.isStronglyEqual(cur.seq2Range.start + d, cur.seq2Range.endExclusive + d)) {\n                    break;\n                }\n            }\n            if (d === length) {\n                // Merge previous and current diff, write to result!\n                result[i + 1] = new SequenceDiff(new OffsetRange(cur.seq1Range.start + length, nextResult.seq1Range.endExclusive), new OffsetRange(cur.seq2Range.start + length, nextResult.seq2Range.endExclusive));\n                continue;\n            }\n            if (d > 0) {\n                cur = cur.delta(d);\n            }\n        }\n        result2.push(cur);\n    }\n    if (result.length > 0) {\n        result2.push(result[result.length - 1]);\n    }\n    return result2;\n}\n// align character level diffs at whitespace characters\n// import { IBar } from \"foo\";\n// import { I[Arr, I]Bar } from \"foo\";\n// ->\n// import { [IArr, ]IBar } from \"foo\";\n// import { ITransaction, observableValue, transaction } from 'vs/base/common/observable';\n// import { ITransaction, observable[FromEvent, observable]Value, transaction } from 'vs/base/common/observable';\n// ->\n// import { ITransaction, [observableFromEvent, ]observableValue, transaction } from 'vs/base/common/observable';\n// collectBrackets(level + 1, levelPerBracketType);\n// collectBrackets(level + 1, levelPerBracket[ + 1, levelPerBracket]Type);\n// ->\n// collectBrackets(level + 1, [levelPerBracket + 1, ]levelPerBracketType);\nfunction shiftSequenceDiffs(sequence1, sequence2, sequenceDiffs) {\n    if (!sequence1.getBoundaryScore || !sequence2.getBoundaryScore) {\n        return sequenceDiffs;\n    }\n    for (let i = 0; i < sequenceDiffs.length; i++) {\n        const prevDiff = (i > 0 ? sequenceDiffs[i - 1] : undefined);\n        const diff = sequenceDiffs[i];\n        const nextDiff = (i + 1 < sequenceDiffs.length ? sequenceDiffs[i + 1] : undefined);\n        const seq1ValidRange = new OffsetRange(prevDiff ? prevDiff.seq1Range.endExclusive + 1 : 0, nextDiff ? nextDiff.seq1Range.start - 1 : sequence1.length);\n        const seq2ValidRange = new OffsetRange(prevDiff ? prevDiff.seq2Range.endExclusive + 1 : 0, nextDiff ? nextDiff.seq2Range.start - 1 : sequence2.length);\n        if (diff.seq1Range.isEmpty) {\n            sequenceDiffs[i] = shiftDiffToBetterPosition(diff, sequence1, sequence2, seq1ValidRange, seq2ValidRange);\n        }\n        else if (diff.seq2Range.isEmpty) {\n            sequenceDiffs[i] = shiftDiffToBetterPosition(diff.swap(), sequence2, sequence1, seq2ValidRange, seq1ValidRange).swap();\n        }\n    }\n    return sequenceDiffs;\n}\nfunction shiftDiffToBetterPosition(diff, sequence1, sequence2, seq1ValidRange, seq2ValidRange) {\n    const maxShiftLimit = 100; // To prevent performance issues\n    // don't touch previous or next!\n    let deltaBefore = 1;\n    while (diff.seq1Range.start - deltaBefore >= seq1ValidRange.start &&\n        diff.seq2Range.start - deltaBefore >= seq2ValidRange.start &&\n        sequence2.isStronglyEqual(diff.seq2Range.start - deltaBefore, diff.seq2Range.endExclusive - deltaBefore) && deltaBefore < maxShiftLimit) {\n        deltaBefore++;\n    }\n    deltaBefore--;\n    let deltaAfter = 0;\n    while (diff.seq1Range.start + deltaAfter < seq1ValidRange.endExclusive &&\n        diff.seq2Range.endExclusive + deltaAfter < seq2ValidRange.endExclusive &&\n        sequence2.isStronglyEqual(diff.seq2Range.start + deltaAfter, diff.seq2Range.endExclusive + deltaAfter) && deltaAfter < maxShiftLimit) {\n        deltaAfter++;\n    }\n    if (deltaBefore === 0 && deltaAfter === 0) {\n        return diff;\n    }\n    // Visualize `[sequence1.text, diff.seq1Range.start + deltaAfter]`\n    // and `[sequence2.text, diff.seq2Range.start + deltaAfter, diff.seq2Range.endExclusive + deltaAfter]`\n    let bestDelta = 0;\n    let bestScore = -1;\n    // find best scored delta\n    for (let delta = -deltaBefore; delta <= deltaAfter; delta++) {\n        const seq2OffsetStart = diff.seq2Range.start + delta;\n        const seq2OffsetEndExclusive = diff.seq2Range.endExclusive + delta;\n        const seq1Offset = diff.seq1Range.start + delta;\n        const score = sequence1.getBoundaryScore(seq1Offset) + sequence2.getBoundaryScore(seq2OffsetStart) + sequence2.getBoundaryScore(seq2OffsetEndExclusive);\n        if (score > bestScore) {\n            bestScore = score;\n            bestDelta = delta;\n        }\n    }\n    return diff.delta(bestDelta);\n}\nexport function removeShortMatches(sequence1, sequence2, sequenceDiffs) {\n    const result = [];\n    for (const s of sequenceDiffs) {\n        const last = result[result.length - 1];\n        if (!last) {\n            result.push(s);\n            continue;\n        }\n        if (s.seq1Range.start - last.seq1Range.endExclusive <= 2 || s.seq2Range.start - last.seq2Range.endExclusive <= 2) {\n            result[result.length - 1] = new SequenceDiff(last.seq1Range.join(s.seq1Range), last.seq2Range.join(s.seq2Range));\n        }\n        else {\n            result.push(s);\n        }\n    }\n    return result;\n}\nexport function extendDiffsToEntireWordIfAppropriate(sequence1, sequence2, sequenceDiffs) {\n    const equalMappings = SequenceDiff.invert(sequenceDiffs, sequence1.length);\n    const additional = [];\n    let lastPoint = new OffsetPair(0, 0);\n    function scanWord(pair, equalMapping) {\n        if (pair.offset1 < lastPoint.offset1 || pair.offset2 < lastPoint.offset2) {\n            return;\n        }\n        const w1 = sequence1.findWordContaining(pair.offset1);\n        const w2 = sequence2.findWordContaining(pair.offset2);\n        if (!w1 || !w2) {\n            return;\n        }\n        let w = new SequenceDiff(w1, w2);\n        const equalPart = w.intersect(equalMapping);\n        let equalChars1 = equalPart.seq1Range.length;\n        let equalChars2 = equalPart.seq2Range.length;\n        // The words do not touch previous equals mappings, as we would have processed them already.\n        // But they might touch the next ones.\n        while (equalMappings.length > 0) {\n            const next = equalMappings[0];\n            const intersects = next.seq1Range.intersects(w.seq1Range) || next.seq2Range.intersects(w.seq2Range);\n            if (!intersects) {\n                break;\n            }\n            const v1 = sequence1.findWordContaining(next.seq1Range.start);\n            const v2 = sequence2.findWordContaining(next.seq2Range.start);\n            // Because there is an intersection, we know that the words are not empty.\n            const v = new SequenceDiff(v1, v2);\n            const equalPart = v.intersect(next);\n            equalChars1 += equalPart.seq1Range.length;\n            equalChars2 += equalPart.seq2Range.length;\n            w = w.join(v);\n            if (w.seq1Range.endExclusive >= next.seq1Range.endExclusive) {\n                // The word extends beyond the next equal mapping.\n                equalMappings.shift();\n            }\n            else {\n                break;\n            }\n        }\n        if (equalChars1 + equalChars2 < (w.seq1Range.length + w.seq2Range.length) * 2 / 3) {\n            additional.push(w);\n        }\n        lastPoint = w.getEndExclusives();\n    }\n    while (equalMappings.length > 0) {\n        const next = equalMappings.shift();\n        if (next.seq1Range.isEmpty) {\n            continue;\n        }\n        scanWord(next.getStarts(), next);\n        // The equal parts are not empty, so -1 gives us a character that is equal in both parts.\n        scanWord(next.getEndExclusives().delta(-1), next);\n    }\n    const merged = mergeSequenceDiffs(sequenceDiffs, additional);\n    return merged;\n}\nfunction mergeSequenceDiffs(sequenceDiffs1, sequenceDiffs2) {\n    const result = [];\n    while (sequenceDiffs1.length > 0 || sequenceDiffs2.length > 0) {\n        const sd1 = sequenceDiffs1[0];\n        const sd2 = sequenceDiffs2[0];\n        let next;\n        if (sd1 && (!sd2 || sd1.seq1Range.start < sd2.seq1Range.start)) {\n            next = sequenceDiffs1.shift();\n        }\n        else {\n            next = sequenceDiffs2.shift();\n        }\n        if (result.length > 0 && result[result.length - 1].seq1Range.endExclusive >= next.seq1Range.start) {\n            result[result.length - 1] = result[result.length - 1].join(next);\n        }\n        else {\n            result.push(next);\n        }\n    }\n    return result;\n}\nexport function removeVeryShortMatchingLinesBetweenDiffs(sequence1, _sequence2, sequenceDiffs) {\n    let diffs = sequenceDiffs;\n    if (diffs.length === 0) {\n        return diffs;\n    }\n    let counter = 0;\n    let shouldRepeat;\n    do {\n        shouldRepeat = false;\n        const result = [\n            diffs[0]\n        ];\n        for (let i = 1; i < diffs.length; i++) {\n            const cur = diffs[i];\n            const lastResult = result[result.length - 1];\n            function shouldJoinDiffs(before, after) {\n                const unchangedRange = new OffsetRange(lastResult.seq1Range.endExclusive, cur.seq1Range.start);\n                const unchangedText = sequence1.getText(unchangedRange);\n                const unchangedTextWithoutWs = unchangedText.replace(/\\s/g, '');\n                if (unchangedTextWithoutWs.length <= 4\n                    && (before.seq1Range.length + before.seq2Range.length > 5 || after.seq1Range.length + after.seq2Range.length > 5)) {\n                    return true;\n                }\n                return false;\n            }\n            const shouldJoin = shouldJoinDiffs(lastResult, cur);\n            if (shouldJoin) {\n                shouldRepeat = true;\n                result[result.length - 1] = result[result.length - 1].join(cur);\n            }\n            else {\n                result.push(cur);\n            }\n        }\n        diffs = result;\n    } while (counter++ < 10 && shouldRepeat);\n    return diffs;\n}\nexport function removeVeryShortMatchingTextBetweenLongDiffs(sequence1, sequence2, sequenceDiffs) {\n    let diffs = sequenceDiffs;\n    if (diffs.length === 0) {\n        return diffs;\n    }\n    let counter = 0;\n    let shouldRepeat;\n    do {\n        shouldRepeat = false;\n        const result = [\n            diffs[0]\n        ];\n        for (let i = 1; i < diffs.length; i++) {\n            const cur = diffs[i];\n            const lastResult = result[result.length - 1];\n            function shouldJoinDiffs(before, after) {\n                const unchangedRange = new OffsetRange(lastResult.seq1Range.endExclusive, cur.seq1Range.start);\n                const unchangedLineCount = sequence1.countLinesIn(unchangedRange);\n                if (unchangedLineCount > 5 || unchangedRange.length > 500) {\n                    return false;\n                }\n                const unchangedText = sequence1.getText(unchangedRange).trim();\n                if (unchangedText.length > 20 || unchangedText.split(/\\r\\n|\\r|\\n/).length > 1) {\n                    return false;\n                }\n                const beforeLineCount1 = sequence1.countLinesIn(before.seq1Range);\n                const beforeSeq1Length = before.seq1Range.length;\n                const beforeLineCount2 = sequence2.countLinesIn(before.seq2Range);\n                const beforeSeq2Length = before.seq2Range.length;\n                const afterLineCount1 = sequence1.countLinesIn(after.seq1Range);\n                const afterSeq1Length = after.seq1Range.length;\n                const afterLineCount2 = sequence2.countLinesIn(after.seq2Range);\n                const afterSeq2Length = after.seq2Range.length;\n                // TODO: Maybe a neural net can be used to derive the result from these numbers\n                const max = 2 * 40 + 50;\n                function cap(v) {\n                    return Math.min(v, max);\n                }\n                if (Math.pow(Math.pow(cap(beforeLineCount1 * 40 + beforeSeq1Length), 1.5) + Math.pow(cap(beforeLineCount2 * 40 + beforeSeq2Length), 1.5), 1.5)\n                    + Math.pow(Math.pow(cap(afterLineCount1 * 40 + afterSeq1Length), 1.5) + Math.pow(cap(afterLineCount2 * 40 + afterSeq2Length), 1.5), 1.5) > ((max ** 1.5) ** 1.5) * 1.3) {\n                    return true;\n                }\n                return false;\n            }\n            const shouldJoin = shouldJoinDiffs(lastResult, cur);\n            if (shouldJoin) {\n                shouldRepeat = true;\n                result[result.length - 1] = result[result.length - 1].join(cur);\n            }\n            else {\n                result.push(cur);\n            }\n        }\n        diffs = result;\n    } while (counter++ < 10 && shouldRepeat);\n    const newDiffs = [];\n    // Remove short suffixes/prefixes\n    forEachWithNeighbors(diffs, (prev, cur, next) => {\n        let newDiff = cur;\n        function shouldMarkAsChanged(text) {\n            return text.length > 0 && text.trim().length <= 3 && cur.seq1Range.length + cur.seq2Range.length > 100;\n        }\n        const fullRange1 = sequence1.extendToFullLines(cur.seq1Range);\n        const prefix = sequence1.getText(new OffsetRange(fullRange1.start, cur.seq1Range.start));\n        if (shouldMarkAsChanged(prefix)) {\n            newDiff = newDiff.deltaStart(-prefix.length);\n        }\n        const suffix = sequence1.getText(new OffsetRange(cur.seq1Range.endExclusive, fullRange1.endExclusive));\n        if (shouldMarkAsChanged(suffix)) {\n            newDiff = newDiff.deltaEnd(suffix.length);\n        }\n        const availableSpace = SequenceDiff.fromOffsetPairs(prev ? prev.getEndExclusives() : OffsetPair.zero, next ? next.getStarts() : OffsetPair.max);\n        const result = newDiff.intersect(availableSpace);\n        if (newDiffs.length > 0 && result.getStarts().equals(newDiffs[newDiffs.length - 1].getEndExclusives())) {\n            newDiffs[newDiffs.length - 1] = newDiffs[newDiffs.length - 1].join(result);\n        }\n        else {\n            newDiffs.push(result);\n        }\n    });\n    return newDiffs;\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 LinesDiff {\n    constructor(changes, \n    /**\n     * Sorted by original line ranges.\n     * The original line ranges and the modified line ranges must be disjoint (but can be touching).\n     */\n    moves, \n    /**\n     * Indicates if the time out was reached.\n     * In that case, the diffs might be an approximation and the user should be asked to rerun the diff with more time.\n     */\n    hitTimeout) {\n        this.changes = changes;\n        this.moves = moves;\n        this.hitTimeout = hitTimeout;\n    }\n}\nexport class MovedText {\n    constructor(lineRangeMapping, changes) {\n        this.lineRangeMapping = lineRangeMapping;\n        this.changes = changes;\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 { LcsDiff } from '../../../base/common/diff/diff.js';\nimport { LinesDiff } from './linesDiffComputer.js';\nimport { RangeMapping, DetailedLineRangeMapping } from './rangeMapping.js';\nimport * as strings from '../../../base/common/strings.js';\nimport { Range } from '../core/range.js';\nimport { assertFn, checkAdjacentItems } from '../../../base/common/assert.js';\nimport { LineRange } from '../core/lineRange.js';\nconst MINIMUM_MATCHING_CHARACTER_LENGTH = 3;\nexport class LegacyLinesDiffComputer {\n    computeDiff(originalLines, modifiedLines, options) {\n        var _a;\n        const diffComputer = new DiffComputer(originalLines, modifiedLines, {\n            maxComputationTime: options.maxComputationTimeMs,\n            shouldIgnoreTrimWhitespace: options.ignoreTrimWhitespace,\n            shouldComputeCharChanges: true,\n            shouldMakePrettyDiff: true,\n            shouldPostProcessCharChanges: true,\n        });\n        const result = diffComputer.computeDiff();\n        const changes = [];\n        let lastChange = null;\n        for (const c of result.changes) {\n            let originalRange;\n            if (c.originalEndLineNumber === 0) {\n                // Insertion\n                originalRange = new LineRange(c.originalStartLineNumber + 1, c.originalStartLineNumber + 1);\n            }\n            else {\n                originalRange = new LineRange(c.originalStartLineNumber, c.originalEndLineNumber + 1);\n            }\n            let modifiedRange;\n            if (c.modifiedEndLineNumber === 0) {\n                // Deletion\n                modifiedRange = new LineRange(c.modifiedStartLineNumber + 1, c.modifiedStartLineNumber + 1);\n            }\n            else {\n                modifiedRange = new LineRange(c.modifiedStartLineNumber, c.modifiedEndLineNumber + 1);\n            }\n            let change = new DetailedLineRangeMapping(originalRange, modifiedRange, (_a = c.charChanges) === null || _a === void 0 ? void 0 : _a.map(c => new RangeMapping(new Range(c.originalStartLineNumber, c.originalStartColumn, c.originalEndLineNumber, c.originalEndColumn), new Range(c.modifiedStartLineNumber, c.modifiedStartColumn, c.modifiedEndLineNumber, c.modifiedEndColumn))));\n            if (lastChange) {\n                if (lastChange.modified.endLineNumberExclusive === change.modified.startLineNumber\n                    || lastChange.original.endLineNumberExclusive === change.original.startLineNumber) {\n                    // join touching diffs. Probably moving diffs up/down in the algorithm causes touching diffs.\n                    change = new DetailedLineRangeMapping(lastChange.original.join(change.original), lastChange.modified.join(change.modified), lastChange.innerChanges && change.innerChanges ?\n                        lastChange.innerChanges.concat(change.innerChanges) : undefined);\n                    changes.pop();\n                }\n            }\n            changes.push(change);\n            lastChange = change;\n        }\n        assertFn(() => {\n            return checkAdjacentItems(changes, (m1, m2) => m2.original.startLineNumber - m1.original.endLineNumberExclusive === m2.modified.startLineNumber - m1.modified.endLineNumberExclusive &&\n                // There has to be an unchanged line in between (otherwise both diffs should have been joined)\n                m1.original.endLineNumberExclusive < m2.original.startLineNumber &&\n                m1.modified.endLineNumberExclusive < m2.modified.startLineNumber);\n        });\n        return new LinesDiff(changes, [], result.quitEarly);\n    }\n}\nfunction computeDiff(originalSequence, modifiedSequence, continueProcessingPredicate, pretty) {\n    const diffAlgo = new LcsDiff(originalSequence, modifiedSequence, continueProcessingPredicate);\n    return diffAlgo.ComputeDiff(pretty);\n}\nclass LineSequence {\n    constructor(lines) {\n        const startColumns = [];\n        const endColumns = [];\n        for (let i = 0, length = lines.length; i < length; i++) {\n            startColumns[i] = getFirstNonBlankColumn(lines[i], 1);\n            endColumns[i] = getLastNonBlankColumn(lines[i], 1);\n        }\n        this.lines = lines;\n        this._startColumns = startColumns;\n        this._endColumns = endColumns;\n    }\n    getElements() {\n        const elements = [];\n        for (let i = 0, len = this.lines.length; i < len; i++) {\n            elements[i] = this.lines[i].substring(this._startColumns[i] - 1, this._endColumns[i] - 1);\n        }\n        return elements;\n    }\n    getStrictElement(index) {\n        return this.lines[index];\n    }\n    getStartLineNumber(i) {\n        return i + 1;\n    }\n    getEndLineNumber(i) {\n        return i + 1;\n    }\n    createCharSequence(shouldIgnoreTrimWhitespace, startIndex, endIndex) {\n        const charCodes = [];\n        const lineNumbers = [];\n        const columns = [];\n        let len = 0;\n        for (let index = startIndex; index <= endIndex; index++) {\n            const lineContent = this.lines[index];\n            const startColumn = (shouldIgnoreTrimWhitespace ? this._startColumns[index] : 1);\n            const endColumn = (shouldIgnoreTrimWhitespace ? this._endColumns[index] : lineContent.length + 1);\n            for (let col = startColumn; col < endColumn; col++) {\n                charCodes[len] = lineContent.charCodeAt(col - 1);\n                lineNumbers[len] = index + 1;\n                columns[len] = col;\n                len++;\n            }\n            if (!shouldIgnoreTrimWhitespace && index < endIndex) {\n                // Add \\n if trim whitespace is not ignored\n                charCodes[len] = 10 /* CharCode.LineFeed */;\n                lineNumbers[len] = index + 1;\n                columns[len] = lineContent.length + 1;\n                len++;\n            }\n        }\n        return new CharSequence(charCodes, lineNumbers, columns);\n    }\n}\nclass CharSequence {\n    constructor(charCodes, lineNumbers, columns) {\n        this._charCodes = charCodes;\n        this._lineNumbers = lineNumbers;\n        this._columns = columns;\n    }\n    toString() {\n        return ('[' + this._charCodes.map((s, idx) => (s === 10 /* CharCode.LineFeed */ ? '\\\\n' : String.fromCharCode(s)) + `-(${this._lineNumbers[idx]},${this._columns[idx]})`).join(', ') + ']');\n    }\n    _assertIndex(index, arr) {\n        if (index < 0 || index >= arr.length) {\n            throw new Error(`Illegal index`);\n        }\n    }\n    getElements() {\n        return this._charCodes;\n    }\n    getStartLineNumber(i) {\n        if (i > 0 && i === this._lineNumbers.length) {\n            // the start line number of the element after the last element\n            // is the end line number of the last element\n            return this.getEndLineNumber(i - 1);\n        }\n        this._assertIndex(i, this._lineNumbers);\n        return this._lineNumbers[i];\n    }\n    getEndLineNumber(i) {\n        if (i === -1) {\n            // the end line number of the element before the first element\n            // is the start line number of the first element\n            return this.getStartLineNumber(i + 1);\n        }\n        this._assertIndex(i, this._lineNumbers);\n        if (this._charCodes[i] === 10 /* CharCode.LineFeed */) {\n            return this._lineNumbers[i] + 1;\n        }\n        return this._lineNumbers[i];\n    }\n    getStartColumn(i) {\n        if (i > 0 && i === this._columns.length) {\n            // the start column of the element after the last element\n            // is the end column of the last element\n            return this.getEndColumn(i - 1);\n        }\n        this._assertIndex(i, this._columns);\n        return this._columns[i];\n    }\n    getEndColumn(i) {\n        if (i === -1) {\n            // the end column of the element before the first element\n            // is the start column of the first element\n            return this.getStartColumn(i + 1);\n        }\n        this._assertIndex(i, this._columns);\n        if (this._charCodes[i] === 10 /* CharCode.LineFeed */) {\n            return 1;\n        }\n        return this._columns[i] + 1;\n    }\n}\nclass CharChange {\n    constructor(originalStartLineNumber, originalStartColumn, originalEndLineNumber, originalEndColumn, modifiedStartLineNumber, modifiedStartColumn, modifiedEndLineNumber, modifiedEndColumn) {\n        this.originalStartLineNumber = originalStartLineNumber;\n        this.originalStartColumn = originalStartColumn;\n        this.originalEndLineNumber = originalEndLineNumber;\n        this.originalEndColumn = originalEndColumn;\n        this.modifiedStartLineNumber = modifiedStartLineNumber;\n        this.modifiedStartColumn = modifiedStartColumn;\n        this.modifiedEndLineNumber = modifiedEndLineNumber;\n        this.modifiedEndColumn = modifiedEndColumn;\n    }\n    static createFromDiffChange(diffChange, originalCharSequence, modifiedCharSequence) {\n        const originalStartLineNumber = originalCharSequence.getStartLineNumber(diffChange.originalStart);\n        const originalStartColumn = originalCharSequence.getStartColumn(diffChange.originalStart);\n        const originalEndLineNumber = originalCharSequence.getEndLineNumber(diffChange.originalStart + diffChange.originalLength - 1);\n        const originalEndColumn = originalCharSequence.getEndColumn(diffChange.originalStart + diffChange.originalLength - 1);\n        const modifiedStartLineNumber = modifiedCharSequence.getStartLineNumber(diffChange.modifiedStart);\n        const modifiedStartColumn = modifiedCharSequence.getStartColumn(diffChange.modifiedStart);\n        const modifiedEndLineNumber = modifiedCharSequence.getEndLineNumber(diffChange.modifiedStart + diffChange.modifiedLength - 1);\n        const modifiedEndColumn = modifiedCharSequence.getEndColumn(diffChange.modifiedStart + diffChange.modifiedLength - 1);\n        return new CharChange(originalStartLineNumber, originalStartColumn, originalEndLineNumber, originalEndColumn, modifiedStartLineNumber, modifiedStartColumn, modifiedEndLineNumber, modifiedEndColumn);\n    }\n}\nfunction postProcessCharChanges(rawChanges) {\n    if (rawChanges.length <= 1) {\n        return rawChanges;\n    }\n    const result = [rawChanges[0]];\n    let prevChange = result[0];\n    for (let i = 1, len = rawChanges.length; i < len; i++) {\n        const currChange = rawChanges[i];\n        const originalMatchingLength = currChange.originalStart - (prevChange.originalStart + prevChange.originalLength);\n        const modifiedMatchingLength = currChange.modifiedStart - (prevChange.modifiedStart + prevChange.modifiedLength);\n        // Both of the above should be equal, but the continueProcessingPredicate may prevent this from being true\n        const matchingLength = Math.min(originalMatchingLength, modifiedMatchingLength);\n        if (matchingLength < MINIMUM_MATCHING_CHARACTER_LENGTH) {\n            // Merge the current change into the previous one\n            prevChange.originalLength = (currChange.originalStart + currChange.originalLength) - prevChange.originalStart;\n            prevChange.modifiedLength = (currChange.modifiedStart + currChange.modifiedLength) - prevChange.modifiedStart;\n        }\n        else {\n            // Add the current change\n            result.push(currChange);\n            prevChange = currChange;\n        }\n    }\n    return result;\n}\nclass LineChange {\n    constructor(originalStartLineNumber, originalEndLineNumber, modifiedStartLineNumber, modifiedEndLineNumber, charChanges) {\n        this.originalStartLineNumber = originalStartLineNumber;\n        this.originalEndLineNumber = originalEndLineNumber;\n        this.modifiedStartLineNumber = modifiedStartLineNumber;\n        this.modifiedEndLineNumber = modifiedEndLineNumber;\n        this.charChanges = charChanges;\n    }\n    static createFromDiffResult(shouldIgnoreTrimWhitespace, diffChange, originalLineSequence, modifiedLineSequence, continueCharDiff, shouldComputeCharChanges, shouldPostProcessCharChanges) {\n        let originalStartLineNumber;\n        let originalEndLineNumber;\n        let modifiedStartLineNumber;\n        let modifiedEndLineNumber;\n        let charChanges = undefined;\n        if (diffChange.originalLength === 0) {\n            originalStartLineNumber = originalLineSequence.getStartLineNumber(diffChange.originalStart) - 1;\n            originalEndLineNumber = 0;\n        }\n        else {\n            originalStartLineNumber = originalLineSequence.getStartLineNumber(diffChange.originalStart);\n            originalEndLineNumber = originalLineSequence.getEndLineNumber(diffChange.originalStart + diffChange.originalLength - 1);\n        }\n        if (diffChange.modifiedLength === 0) {\n            modifiedStartLineNumber = modifiedLineSequence.getStartLineNumber(diffChange.modifiedStart) - 1;\n            modifiedEndLineNumber = 0;\n        }\n        else {\n            modifiedStartLineNumber = modifiedLineSequence.getStartLineNumber(diffChange.modifiedStart);\n            modifiedEndLineNumber = modifiedLineSequence.getEndLineNumber(diffChange.modifiedStart + diffChange.modifiedLength - 1);\n        }\n        if (shouldComputeCharChanges && diffChange.originalLength > 0 && diffChange.originalLength < 20 && diffChange.modifiedLength > 0 && diffChange.modifiedLength < 20 && continueCharDiff()) {\n            // Compute character changes for diff chunks of at most 20 lines...\n            const originalCharSequence = originalLineSequence.createCharSequence(shouldIgnoreTrimWhitespace, diffChange.originalStart, diffChange.originalStart + diffChange.originalLength - 1);\n            const modifiedCharSequence = modifiedLineSequence.createCharSequence(shouldIgnoreTrimWhitespace, diffChange.modifiedStart, diffChange.modifiedStart + diffChange.modifiedLength - 1);\n            if (originalCharSequence.getElements().length > 0 && modifiedCharSequence.getElements().length > 0) {\n                let rawChanges = computeDiff(originalCharSequence, modifiedCharSequence, continueCharDiff, true).changes;\n                if (shouldPostProcessCharChanges) {\n                    rawChanges = postProcessCharChanges(rawChanges);\n                }\n                charChanges = [];\n                for (let i = 0, length = rawChanges.length; i < length; i++) {\n                    charChanges.push(CharChange.createFromDiffChange(rawChanges[i], originalCharSequence, modifiedCharSequence));\n                }\n            }\n        }\n        return new LineChange(originalStartLineNumber, originalEndLineNumber, modifiedStartLineNumber, modifiedEndLineNumber, charChanges);\n    }\n}\nexport class DiffComputer {\n    constructor(originalLines, modifiedLines, opts) {\n        this.shouldComputeCharChanges = opts.shouldComputeCharChanges;\n        this.shouldPostProcessCharChanges = opts.shouldPostProcessCharChanges;\n        this.shouldIgnoreTrimWhitespace = opts.shouldIgnoreTrimWhitespace;\n        this.shouldMakePrettyDiff = opts.shouldMakePrettyDiff;\n        this.originalLines = originalLines;\n        this.modifiedLines = modifiedLines;\n        this.original = new LineSequence(originalLines);\n        this.modified = new LineSequence(modifiedLines);\n        this.continueLineDiff = createContinueProcessingPredicate(opts.maxComputationTime);\n        this.continueCharDiff = createContinueProcessingPredicate(opts.maxComputationTime === 0 ? 0 : Math.min(opts.maxComputationTime, 5000)); // never run after 5s for character changes...\n    }\n    computeDiff() {\n        if (this.original.lines.length === 1 && this.original.lines[0].length === 0) {\n            // empty original => fast path\n            if (this.modified.lines.length === 1 && this.modified.lines[0].length === 0) {\n                return {\n                    quitEarly: false,\n                    changes: []\n                };\n            }\n            return {\n                quitEarly: false,\n                changes: [{\n                        originalStartLineNumber: 1,\n                        originalEndLineNumber: 1,\n                        modifiedStartLineNumber: 1,\n                        modifiedEndLineNumber: this.modified.lines.length,\n                        charChanges: undefined\n                    }]\n            };\n        }\n        if (this.modified.lines.length === 1 && this.modified.lines[0].length === 0) {\n            // empty modified => fast path\n            return {\n                quitEarly: false,\n                changes: [{\n                        originalStartLineNumber: 1,\n                        originalEndLineNumber: this.original.lines.length,\n                        modifiedStartLineNumber: 1,\n                        modifiedEndLineNumber: 1,\n                        charChanges: undefined\n                    }]\n            };\n        }\n        const diffResult = computeDiff(this.original, this.modified, this.continueLineDiff, this.shouldMakePrettyDiff);\n        const rawChanges = diffResult.changes;\n        const quitEarly = diffResult.quitEarly;\n        // The diff is always computed with ignoring trim whitespace\n        // This ensures we get the prettiest diff\n        if (this.shouldIgnoreTrimWhitespace) {\n            const lineChanges = [];\n            for (let i = 0, length = rawChanges.length; i < length; i++) {\n                lineChanges.push(LineChange.createFromDiffResult(this.shouldIgnoreTrimWhitespace, rawChanges[i], this.original, this.modified, this.continueCharDiff, this.shouldComputeCharChanges, this.shouldPostProcessCharChanges));\n            }\n            return {\n                quitEarly: quitEarly,\n                changes: lineChanges\n            };\n        }\n        // Need to post-process and introduce changes where the trim whitespace is different\n        // Note that we are looping starting at -1 to also cover the lines before the first change\n        const result = [];\n        let originalLineIndex = 0;\n        let modifiedLineIndex = 0;\n        for (let i = -1 /* !!!! */, len = rawChanges.length; i < len; i++) {\n            const nextChange = (i + 1 < len ? rawChanges[i + 1] : null);\n            const originalStop = (nextChange ? nextChange.originalStart : this.originalLines.length);\n            const modifiedStop = (nextChange ? nextChange.modifiedStart : this.modifiedLines.length);\n            while (originalLineIndex < originalStop && modifiedLineIndex < modifiedStop) {\n                const originalLine = this.originalLines[originalLineIndex];\n                const modifiedLine = this.modifiedLines[modifiedLineIndex];\n                if (originalLine !== modifiedLine) {\n                    // These lines differ only in trim whitespace\n                    // Check the leading whitespace\n                    {\n                        let originalStartColumn = getFirstNonBlankColumn(originalLine, 1);\n                        let modifiedStartColumn = getFirstNonBlankColumn(modifiedLine, 1);\n                        while (originalStartColumn > 1 && modifiedStartColumn > 1) {\n                            const originalChar = originalLine.charCodeAt(originalStartColumn - 2);\n                            const modifiedChar = modifiedLine.charCodeAt(modifiedStartColumn - 2);\n                            if (originalChar !== modifiedChar) {\n                                break;\n                            }\n                            originalStartColumn--;\n                            modifiedStartColumn--;\n                        }\n                        if (originalStartColumn > 1 || modifiedStartColumn > 1) {\n                            this._pushTrimWhitespaceCharChange(result, originalLineIndex + 1, 1, originalStartColumn, modifiedLineIndex + 1, 1, modifiedStartColumn);\n                        }\n                    }\n                    // Check the trailing whitespace\n                    {\n                        let originalEndColumn = getLastNonBlankColumn(originalLine, 1);\n                        let modifiedEndColumn = getLastNonBlankColumn(modifiedLine, 1);\n                        const originalMaxColumn = originalLine.length + 1;\n                        const modifiedMaxColumn = modifiedLine.length + 1;\n                        while (originalEndColumn < originalMaxColumn && modifiedEndColumn < modifiedMaxColumn) {\n                            const originalChar = originalLine.charCodeAt(originalEndColumn - 1);\n                            const modifiedChar = originalLine.charCodeAt(modifiedEndColumn - 1);\n                            if (originalChar !== modifiedChar) {\n                                break;\n                            }\n                            originalEndColumn++;\n                            modifiedEndColumn++;\n                        }\n                        if (originalEndColumn < originalMaxColumn || modifiedEndColumn < modifiedMaxColumn) {\n                            this._pushTrimWhitespaceCharChange(result, originalLineIndex + 1, originalEndColumn, originalMaxColumn, modifiedLineIndex + 1, modifiedEndColumn, modifiedMaxColumn);\n                        }\n                    }\n                }\n                originalLineIndex++;\n                modifiedLineIndex++;\n            }\n            if (nextChange) {\n                // Emit the actual change\n                result.push(LineChange.createFromDiffResult(this.shouldIgnoreTrimWhitespace, nextChange, this.original, this.modified, this.continueCharDiff, this.shouldComputeCharChanges, this.shouldPostProcessCharChanges));\n                originalLineIndex += nextChange.originalLength;\n                modifiedLineIndex += nextChange.modifiedLength;\n            }\n        }\n        return {\n            quitEarly: quitEarly,\n            changes: result\n        };\n    }\n    _pushTrimWhitespaceCharChange(result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn) {\n        if (this._mergeTrimWhitespaceCharChange(result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn)) {\n            // Merged into previous\n            return;\n        }\n        let charChanges = undefined;\n        if (this.shouldComputeCharChanges) {\n            charChanges = [new CharChange(originalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn)];\n        }\n        result.push(new LineChange(originalLineNumber, originalLineNumber, modifiedLineNumber, modifiedLineNumber, charChanges));\n    }\n    _mergeTrimWhitespaceCharChange(result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn) {\n        const len = result.length;\n        if (len === 0) {\n            return false;\n        }\n        const prevChange = result[len - 1];\n        if (prevChange.originalEndLineNumber === 0 || prevChange.modifiedEndLineNumber === 0) {\n            // Don't merge with inserts/deletes\n            return false;\n        }\n        if (prevChange.originalEndLineNumber === originalLineNumber && prevChange.modifiedEndLineNumber === modifiedLineNumber) {\n            if (this.shouldComputeCharChanges && prevChange.charChanges) {\n                prevChange.charChanges.push(new CharChange(originalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn));\n            }\n            return true;\n        }\n        if (prevChange.originalEndLineNumber + 1 === originalLineNumber && prevChange.modifiedEndLineNumber + 1 === modifiedLineNumber) {\n            prevChange.originalEndLineNumber = originalLineNumber;\n            prevChange.modifiedEndLineNumber = modifiedLineNumber;\n            if (this.shouldComputeCharChanges && prevChange.charChanges) {\n                prevChange.charChanges.push(new CharChange(originalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn));\n            }\n            return true;\n        }\n        return false;\n    }\n}\nfunction getFirstNonBlankColumn(txt, defaultValue) {\n    const r = strings.firstNonWhitespaceIndex(txt);\n    if (r === -1) {\n        return defaultValue;\n    }\n    return r + 1;\n}\nfunction getLastNonBlankColumn(txt, defaultValue) {\n    const r = strings.lastNonWhitespaceIndex(txt);\n    if (r === -1) {\n        return defaultValue;\n    }\n    return r + 2;\n}\nfunction createContinueProcessingPredicate(maximumRuntime) {\n    if (maximumRuntime === 0) {\n        return () => true;\n    }\n    const startTime = Date.now();\n    return () => {\n        return Date.now() - startTime < maximumRuntime;\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 { LegacyLinesDiffComputer } from './legacyLinesDiffComputer.js';\nimport { DefaultLinesDiffComputer } from './defaultLinesDiffComputer/defaultLinesDiffComputer.js';\nexport const linesDiffComputers = {\n    getLegacy: () => new LegacyLinesDiffComputer(),\n    getDefault: () => new DefaultLinesDiffComputer(),\n};\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { BugIndicatingError } from '../../../base/common/errors.js';\nimport { LineRange } from '../core/lineRange.js';\nimport { Range } from '../core/range.js';\nimport { SingleTextEdit } from '../core/textEdit.js';\n/**\n * Maps a line range in the original text model to a line range in the modified text model.\n */\nexport class LineRangeMapping {\n    static inverse(mapping, originalLineCount, modifiedLineCount) {\n        const result = [];\n        let lastOriginalEndLineNumber = 1;\n        let lastModifiedEndLineNumber = 1;\n        for (const m of mapping) {\n            const r = new LineRangeMapping(new LineRange(lastOriginalEndLineNumber, m.original.startLineNumber), new LineRange(lastModifiedEndLineNumber, m.modified.startLineNumber));\n            if (!r.modified.isEmpty) {\n                result.push(r);\n            }\n            lastOriginalEndLineNumber = m.original.endLineNumberExclusive;\n            lastModifiedEndLineNumber = m.modified.endLineNumberExclusive;\n        }\n        const r = new LineRangeMapping(new LineRange(lastOriginalEndLineNumber, originalLineCount + 1), new LineRange(lastModifiedEndLineNumber, modifiedLineCount + 1));\n        if (!r.modified.isEmpty) {\n            result.push(r);\n        }\n        return result;\n    }\n    static clip(mapping, originalRange, modifiedRange) {\n        const result = [];\n        for (const m of mapping) {\n            const original = m.original.intersect(originalRange);\n            const modified = m.modified.intersect(modifiedRange);\n            if (original && !original.isEmpty && modified && !modified.isEmpty) {\n                result.push(new LineRangeMapping(original, modified));\n            }\n        }\n        return result;\n    }\n    constructor(originalRange, modifiedRange) {\n        this.original = originalRange;\n        this.modified = modifiedRange;\n    }\n    toString() {\n        return `{${this.original.toString()}->${this.modified.toString()}}`;\n    }\n    flip() {\n        return new LineRangeMapping(this.modified, this.original);\n    }\n    join(other) {\n        return new LineRangeMapping(this.original.join(other.original), this.modified.join(other.modified));\n    }\n    /**\n     * This method assumes that the LineRangeMapping describes a valid diff!\n     * I.e. if one range is empty, the other range cannot be the entire document.\n     * It avoids various problems when the line range points to non-existing line-numbers.\n    */\n    toRangeMapping() {\n        const origInclusiveRange = this.original.toInclusiveRange();\n        const modInclusiveRange = this.modified.toInclusiveRange();\n        if (origInclusiveRange && modInclusiveRange) {\n            return new RangeMapping(origInclusiveRange, modInclusiveRange);\n        }\n        else if (this.original.startLineNumber === 1 || this.modified.startLineNumber === 1) {\n            if (!(this.modified.startLineNumber === 1 && this.original.startLineNumber === 1)) {\n                // If one line range starts at 1, the other one must start at 1 as well.\n                throw new BugIndicatingError('not a valid diff');\n            }\n            // Because one range is empty and both ranges start at line 1, none of the ranges can cover all lines.\n            // Thus, `endLineNumberExclusive` is a valid line number.\n            return new RangeMapping(new Range(this.original.startLineNumber, 1, this.original.endLineNumberExclusive, 1), new Range(this.modified.startLineNumber, 1, this.modified.endLineNumberExclusive, 1));\n        }\n        else {\n            // We can assume here that both startLineNumbers are greater than 1.\n            return new RangeMapping(new Range(this.original.startLineNumber - 1, Number.MAX_SAFE_INTEGER, this.original.endLineNumberExclusive - 1, Number.MAX_SAFE_INTEGER), new Range(this.modified.startLineNumber - 1, Number.MAX_SAFE_INTEGER, this.modified.endLineNumberExclusive - 1, Number.MAX_SAFE_INTEGER));\n        }\n    }\n}\n/**\n * Maps a line range in the original text model to a line range in the modified text model.\n * Also contains inner range mappings.\n */\nexport class DetailedLineRangeMapping extends LineRangeMapping {\n    static fromRangeMappings(rangeMappings) {\n        const originalRange = LineRange.join(rangeMappings.map(r => LineRange.fromRangeInclusive(r.originalRange)));\n        const modifiedRange = LineRange.join(rangeMappings.map(r => LineRange.fromRangeInclusive(r.modifiedRange)));\n        return new DetailedLineRangeMapping(originalRange, modifiedRange, rangeMappings);\n    }\n    constructor(originalRange, modifiedRange, innerChanges) {\n        super(originalRange, modifiedRange);\n        this.innerChanges = innerChanges;\n    }\n    flip() {\n        var _a;\n        return new DetailedLineRangeMapping(this.modified, this.original, (_a = this.innerChanges) === null || _a === void 0 ? void 0 : _a.map(c => c.flip()));\n    }\n    withInnerChangesFromLineRanges() {\n        return new DetailedLineRangeMapping(this.original, this.modified, [this.toRangeMapping()]);\n    }\n}\n/**\n * Maps a range in the original text model to a range in the modified text model.\n */\nexport class RangeMapping {\n    constructor(originalRange, modifiedRange) {\n        this.originalRange = originalRange;\n        this.modifiedRange = modifiedRange;\n    }\n    toString() {\n        return `{${this.originalRange.toString()}->${this.modifiedRange.toString()}}`;\n    }\n    flip() {\n        return new RangeMapping(this.modifiedRange, this.originalRange);\n    }\n    /**\n     * Creates a single text edit that describes the change from the original to the modified text.\n    */\n    toTextEdit(modified) {\n        const newText = modified.getValueOfRange(this.modifiedRange);\n        return new SingleTextEdit(this.originalRange, newText);\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 InternalEditorAction {\n    constructor(id, label, alias, metadata, _precondition, _run, _contextKeyService) {\n        this.id = id;\n        this.label = label;\n        this.alias = alias;\n        this.metadata = metadata;\n        this._precondition = _precondition;\n        this._run = _run;\n        this._contextKeyService = _contextKeyService;\n    }\n    isSupported() {\n        return this._contextKeyService.contextMatchesRules(this._precondition);\n    }\n    run(args) {\n        if (!this.isSupported()) {\n            return Promise.resolve(undefined);\n        }\n        return this._run(args);\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n/**\n * The type of the `IEditor`.\n */\nexport const EditorType = {\n    ICodeEditor: 'vs.editor.ICodeEditor',\n    IDiffEditor: 'vs.editor.IDiffEditor'\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 nls from '../../nls.js';\nimport { RawContextKey } from '../../platform/contextkey/common/contextkey.js';\nexport var EditorContextKeys;\n(function (EditorContextKeys) {\n    EditorContextKeys.editorSimpleInput = new RawContextKey('editorSimpleInput', false, true);\n    /**\n     * A context key that is set when the editor's text has focus (cursor is blinking).\n     * Is false when focus is in simple editor widgets (repl input, scm commit input).\n     */\n    EditorContextKeys.editorTextFocus = new RawContextKey('editorTextFocus', false, nls.localize('editorTextFocus', \"Whether the editor text has focus (cursor is blinking)\"));\n    /**\n     * A context key that is set when the editor's text or an editor's widget has focus.\n     */\n    EditorContextKeys.focus = new RawContextKey('editorFocus', false, nls.localize('editorFocus', \"Whether the editor or an editor widget has focus (e.g. focus is in the find widget)\"));\n    /**\n     * A context key that is set when any editor input has focus (regular editor, repl input...).\n     */\n    EditorContextKeys.textInputFocus = new RawContextKey('textInputFocus', false, nls.localize('textInputFocus', \"Whether an editor or a rich text input has focus (cursor is blinking)\"));\n    EditorContextKeys.readOnly = new RawContextKey('editorReadonly', false, nls.localize('editorReadonly', \"Whether the editor is read-only\"));\n    EditorContextKeys.inDiffEditor = new RawContextKey('inDiffEditor', false, nls.localize('inDiffEditor', \"Whether the context is a diff editor\"));\n    EditorContextKeys.isEmbeddedDiffEditor = new RawContextKey('isEmbeddedDiffEditor', false, nls.localize('isEmbeddedDiffEditor', \"Whether the context is an embedded diff editor\"));\n    EditorContextKeys.inMultiDiffEditor = new RawContextKey('inMultiDiffEditor', false, nls.localize('inMultiDiffEditor', \"Whether the context is a multi diff editor\"));\n    EditorContextKeys.multiDiffEditorAllCollapsed = new RawContextKey('multiDiffEditorAllCollapsed', undefined, nls.localize('multiDiffEditorAllCollapsed', \"Whether all files in multi diff editor are collapsed\"));\n    EditorContextKeys.hasChanges = new RawContextKey('diffEditorHasChanges', false, nls.localize('diffEditorHasChanges', \"Whether the diff editor has changes\"));\n    EditorContextKeys.comparingMovedCode = new RawContextKey('comparingMovedCode', false, nls.localize('comparingMovedCode', \"Whether a moved code block is selected for comparison\"));\n    EditorContextKeys.accessibleDiffViewerVisible = new RawContextKey('accessibleDiffViewerVisible', false, nls.localize('accessibleDiffViewerVisible', \"Whether the accessible diff viewer is visible\"));\n    EditorContextKeys.diffEditorRenderSideBySideInlineBreakpointReached = new RawContextKey('diffEditorRenderSideBySideInlineBreakpointReached', false, nls.localize('diffEditorRenderSideBySideInlineBreakpointReached', \"Whether the diff editor render side by side inline breakpoint is reached\"));\n    EditorContextKeys.diffEditorInlineMode = new RawContextKey('diffEditorInlineMode', false, nls.localize('diffEditorInlineMode', \"Whether inline mode is active\"));\n    EditorContextKeys.diffEditorOriginalWritable = new RawContextKey('diffEditorOriginalWritable', false, nls.localize('diffEditorOriginalWritable', \"Whether modified is writable in the diff editor\"));\n    EditorContextKeys.diffEditorModifiedWritable = new RawContextKey('diffEditorModifiedWritable', false, nls.localize('diffEditorModifiedWritable', \"Whether modified is writable in the diff editor\"));\n    EditorContextKeys.diffEditorOriginalUri = new RawContextKey('diffEditorOriginalUri', '', nls.localize('diffEditorOriginalUri', \"The uri of the original document\"));\n    EditorContextKeys.diffEditorModifiedUri = new RawContextKey('diffEditorModifiedUri', '', nls.localize('diffEditorModifiedUri', \"The uri of the modified document\"));\n    EditorContextKeys.columnSelection = new RawContextKey('editorColumnSelection', false, nls.localize('editorColumnSelection', \"Whether `editor.columnSelection` is enabled\"));\n    EditorContextKeys.writable = EditorContextKeys.readOnly.toNegated();\n    EditorContextKeys.hasNonEmptySelection = new RawContextKey('editorHasSelection', false, nls.localize('editorHasSelection', \"Whether the editor has text selected\"));\n    EditorContextKeys.hasOnlyEmptySelection = EditorContextKeys.hasNonEmptySelection.toNegated();\n    EditorContextKeys.hasMultipleSelections = new RawContextKey('editorHasMultipleSelections', false, nls.localize('editorHasMultipleSelections', \"Whether the editor has multiple selections\"));\n    EditorContextKeys.hasSingleSelection = EditorContextKeys.hasMultipleSelections.toNegated();\n    EditorContextKeys.tabMovesFocus = new RawContextKey('editorTabMovesFocus', false, nls.localize('editorTabMovesFocus', \"Whether `Tab` will move focus out of the editor\"));\n    EditorContextKeys.tabDoesNotMoveFocus = EditorContextKeys.tabMovesFocus.toNegated();\n    EditorContextKeys.isInEmbeddedEditor = new RawContextKey('isInEmbeddedEditor', false, true);\n    EditorContextKeys.canUndo = new RawContextKey('canUndo', false, true);\n    EditorContextKeys.canRedo = new RawContextKey('canRedo', false, true);\n    EditorContextKeys.hoverVisible = new RawContextKey('editorHoverVisible', false, nls.localize('editorHoverVisible', \"Whether the editor hover is visible\"));\n    EditorContextKeys.hoverFocused = new RawContextKey('editorHoverFocused', false, nls.localize('editorHoverFocused', \"Whether the editor hover is focused\"));\n    EditorContextKeys.stickyScrollFocused = new RawContextKey('stickyScrollFocused', false, nls.localize('stickyScrollFocused', \"Whether the sticky scroll is focused\"));\n    EditorContextKeys.stickyScrollVisible = new RawContextKey('stickyScrollVisible', false, nls.localize('stickyScrollVisible', \"Whether the sticky scroll is visible\"));\n    EditorContextKeys.standaloneColorPickerVisible = new RawContextKey('standaloneColorPickerVisible', false, nls.localize('standaloneColorPickerVisible', \"Whether the standalone color picker is visible\"));\n    EditorContextKeys.standaloneColorPickerFocused = new RawContextKey('standaloneColorPickerFocused', false, nls.localize('standaloneColorPickerFocused', \"Whether the standalone color picker is focused\"));\n    /**\n     * A context key that is set when an editor is part of a larger editor, like notebooks or\n     * (future) a diff editor\n     */\n    EditorContextKeys.inCompositeEditor = new RawContextKey('inCompositeEditor', undefined, nls.localize('inCompositeEditor', \"Whether the editor is part of a larger editor (e.g. notebooks)\"));\n    EditorContextKeys.notInCompositeEditor = EditorContextKeys.inCompositeEditor.toNegated();\n    // -- mode context keys\n    EditorContextKeys.languageId = new RawContextKey('editorLangId', '', nls.localize('editorLangId', \"The language identifier of the editor\"));\n    EditorContextKeys.hasCompletionItemProvider = new RawContextKey('editorHasCompletionItemProvider', false, nls.localize('editorHasCompletionItemProvider', \"Whether the editor has a completion item provider\"));\n    EditorContextKeys.hasCodeActionsProvider = new RawContextKey('editorHasCodeActionsProvider', false, nls.localize('editorHasCodeActionsProvider', \"Whether the editor has a code actions provider\"));\n    EditorContextKeys.hasCodeLensProvider = new RawContextKey('editorHasCodeLensProvider', false, nls.localize('editorHasCodeLensProvider', \"Whether the editor has a code lens provider\"));\n    EditorContextKeys.hasDefinitionProvider = new RawContextKey('editorHasDefinitionProvider', false, nls.localize('editorHasDefinitionProvider', \"Whether the editor has a definition provider\"));\n    EditorContextKeys.hasDeclarationProvider = new RawContextKey('editorHasDeclarationProvider', false, nls.localize('editorHasDeclarationProvider', \"Whether the editor has a declaration provider\"));\n    EditorContextKeys.hasImplementationProvider = new RawContextKey('editorHasImplementationProvider', false, nls.localize('editorHasImplementationProvider', \"Whether the editor has an implementation provider\"));\n    EditorContextKeys.hasTypeDefinitionProvider = new RawContextKey('editorHasTypeDefinitionProvider', false, nls.localize('editorHasTypeDefinitionProvider', \"Whether the editor has a type definition provider\"));\n    EditorContextKeys.hasHoverProvider = new RawContextKey('editorHasHoverProvider', false, nls.localize('editorHasHoverProvider', \"Whether the editor has a hover provider\"));\n    EditorContextKeys.hasDocumentHighlightProvider = new RawContextKey('editorHasDocumentHighlightProvider', false, nls.localize('editorHasDocumentHighlightProvider', \"Whether the editor has a document highlight provider\"));\n    EditorContextKeys.hasDocumentSymbolProvider = new RawContextKey('editorHasDocumentSymbolProvider', false, nls.localize('editorHasDocumentSymbolProvider', \"Whether the editor has a document symbol provider\"));\n    EditorContextKeys.hasReferenceProvider = new RawContextKey('editorHasReferenceProvider', false, nls.localize('editorHasReferenceProvider', \"Whether the editor has a reference provider\"));\n    EditorContextKeys.hasRenameProvider = new RawContextKey('editorHasRenameProvider', false, nls.localize('editorHasRenameProvider', \"Whether the editor has a rename provider\"));\n    EditorContextKeys.hasSignatureHelpProvider = new RawContextKey('editorHasSignatureHelpProvider', false, nls.localize('editorHasSignatureHelpProvider', \"Whether the editor has a signature help provider\"));\n    EditorContextKeys.hasInlayHintsProvider = new RawContextKey('editorHasInlayHintsProvider', false, nls.localize('editorHasInlayHintsProvider', \"Whether the editor has an inline hints provider\"));\n    // -- mode context keys: formatting\n    EditorContextKeys.hasDocumentFormattingProvider = new RawContextKey('editorHasDocumentFormattingProvider', false, nls.localize('editorHasDocumentFormattingProvider', \"Whether the editor has a document formatting provider\"));\n    EditorContextKeys.hasDocumentSelectionFormattingProvider = new RawContextKey('editorHasDocumentSelectionFormattingProvider', false, nls.localize('editorHasDocumentSelectionFormattingProvider', \"Whether the editor has a document selection formatting provider\"));\n    EditorContextKeys.hasMultipleDocumentFormattingProvider = new RawContextKey('editorHasMultipleDocumentFormattingProvider', false, nls.localize('editorHasMultipleDocumentFormattingProvider', \"Whether the editor has multiple document formatting providers\"));\n    EditorContextKeys.hasMultipleDocumentSelectionFormattingProvider = new RawContextKey('editorHasMultipleDocumentSelectionFormattingProvider', false, nls.localize('editorHasMultipleDocumentSelectionFormattingProvider', \"Whether the editor has multiple document selection formatting providers\"));\n})(EditorContextKeys || (EditorContextKeys = {}));\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 *--------------------------------------------------------------------------------------------*/\nconst editorFeatures = [];\n/**\n * Registers an editor feature. Editor features will be instantiated only once, as soon as\n * the first code editor is instantiated.\n */\nexport function registerEditorFeature(ctor) {\n    editorFeatures.push(ctor);\n}\nexport function getEditorFeatures() {\n    return editorFeatures.slice(0);\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport class EditorTheme {\n    get type() {\n        return this._theme.type;\n    }\n    get value() {\n        return this._theme;\n    }\n    constructor(theme) {\n        this._theme = theme;\n    }\n    update(theme) {\n        this._theme = theme;\n    }\n    getColor(color) {\n        return this._theme.getColor(color);\n    }\n}\n"],"names":["DiffAlgorithmResult","trivial","seq1","seq2","SequenceDiff","length","trivialTimedOut","constructor","diffs","hitTimeout","this","invert","sequenceDiffs","doc1Length","result","a","b","push","fromOffsetPairs","getEndExclusives","OffsetPair","zero","getStarts","seq2Range","endExclusive","seq1Range","start","offset1","offset2","swap","toString","join","other","delta","offset","deltaStart","deltaEnd","intersect","i1","i2","equals","max","Number","MAX_SAFE_INTEGER","InfiniteTimeout","isValid","instance","DateTimeout","timeout","startTime","Date","now","valid","Array2D","width","height","array","Array","get","x","y","set","value","isSpace","charCode","LineRangeFragment","getKey","chr","key","chrKeys","undefined","size","range","lines","source","histogram","counter","i","startLineNumber","endLineNumberExclusive","line","j","totalCount","computeSimilarity","_a","_b","sumDifferences","maxLength","Math","abs","Map","DynamicProgrammingDiffing","compute","sequence1","sequence2","equalityScore","lcsLengths","directions","lengths","s1","s2","horizontalLen","verticalLen","extendedSeqScore","getElement","newValue","prevLen","lastAligningPosS1","lastAligningPosS2","reportDecreasingAligningPositions","reverse","MyersDiffAlgorithm","seqX","seqY","getXAfterSnake","d","V","FastInt32Array","paths","FastArrayNegativeIndices","SnakePath","k","loop","lowerBound","min","upperBound","step","maxXofDLineTop","maxXofDLineLeft","newMaxX","lastPath","path","endX","endY","prev","positiveArr","Int32Array","negativeArr","idx","arr","LinesSliceCharSequence","lineRange","considerWhitespaceChanges","elements","firstCharOffsetByLine","additionalOffsetByLine","trimFirstLineFully","trimmedStartLine","trimStart","trimEnd","charCodeAt","text","getText","slice","map","e","String","fromCharCode","getBoundaryScore","prevCategory","getCategory","nextCategory","score","getCategoryBoundaryScore","translateOffset","isEmpty","translateRange","findWordContaining","isWordChar","end","countLinesIn","lineNumber","isStronglyEqual","extendToFullLines","category","computeMovedLines","changes","originalLines","modifiedLines","hashedOriginalLines","hashedModifiedLines","moves","excludedChanges","deletions","filter","c","modified","original","insertions","Set","deletion","best","highestSimilarity","insertion","similarity","delete","add","computeMovesFromSimpleDeletionsToSimpleInsertions","unchangedMoves","original3LineHashes","change","possibleMappings","sort","lastMappings","currentModifiedRange","nextMappings","forEach","lastMapping","originalLineRange","modifiedLineRange","mapping","m","modifiedSet","originalSet","diffOrigToMod","modifiedSections","subtractFrom","originalTranslatedSections","getWithDelta","modifiedIntersectedSections","getIntersection","s","ranges","addRange","monotonousChanges","move","firstTouchingChangeOrig","findLastMonotonous","firstTouchingChangeMod","linesAbove","lastTouchingChangeOrig","lastTouchingChangeMod","linesBelow","extendToTop","extendToBottom","origLine","modLine","contains","areLinesSimilar","computeUnchangedMoves","has","last","current","originalDist","modifiedDist","joinCloseConsecutiveMoves","toOffsetRange","l","trim","predicate","count","t","countWhere","changesMonotonous","removeMovesInSameDiff","line1","line2","commonNonSpaceCharCount","inverted","seq","longerLineLength","str","countNonWsChars","LineSequence","trimmedHash","getIndentation","DefaultLinesDiffComputer","dynamicProgrammingDiffing","myersDiffingAlgorithm","computeDiff","options","maxComputationTimeMs","ignoreTrimWhitespace","perfectHashes","getOrCreateHash","hash","originalLinesHashes","modifiedLinesHashes","lineAlignmentResult","log","lineAlignments","alignments","scanForWhitespaceChanges","equalLinesCount","seq1Offset","seq1LastStart","seq2Offset","seq2LastStart","characterDiffs","refineDiff","mappings","diff","assert","lineRangeMappingFromRangeMappings","computeMoves","validatePosition","pos","column","validateRange","innerChanges","ic","modifiedRange","getStartPosition","getEndPosition","originalRange","slice1","slice2","diffResult","dontAssertStartLine","g","rangeMapping","lineStartDelta","lineEndDelta","endColumn","endLineNumber","startColumn","getLineRangeMapping","a1","a2","overlapOrTouch","first","m1","m2","optimizeSequenceDiffs","joinSequenceDiffsByShifting","prevDiff","nextDiff","seq1ValidRange","seq2ValidRange","shiftDiffToBetterPosition","shiftSequenceDiffs","prevResult","cur","result2","nextResult","deltaBefore","deltaAfter","bestDelta","bestScore","seq2OffsetStart","seq2OffsetEndExclusive","removeShortMatches","extendDiffsToEntireWordIfAppropriate","equalMappings","additional","lastPoint","scanWord","pair","equalMapping","w1","w2","w","equalPart","equalChars1","equalChars2","next","intersects","v1","v2","v","shift","sequenceDiffs1","sequenceDiffs2","sd1","sd2","mergeSequenceDiffs","removeVeryShortMatchingLinesBetweenDiffs","_sequence2","shouldRepeat","lastResult","shouldJoinDiffs","before","after","unchangedRange","replace","removeVeryShortMatchingTextBetweenLongDiffs","unchangedText","split","beforeLineCount1","beforeSeq1Length","beforeLineCount2","beforeSeq2Length","afterLineCount1","afterSeq1Length","afterLineCount2","afterSeq2Length","cap","pow","newDiffs","newDiff","shouldMarkAsChanged","fullRange1","prefix","suffix","availableSpace","LinesDiff","MovedText","lineRangeMapping","LegacyLinesDiffComputer","DiffComputer","maxComputationTime","shouldIgnoreTrimWhitespace","shouldComputeCharChanges","shouldMakePrettyDiff","shouldPostProcessCharChanges","lastChange","originalEndLineNumber","originalStartLineNumber","modifiedEndLineNumber","modifiedStartLineNumber","charChanges","originalStartColumn","originalEndColumn","modifiedStartColumn","modifiedEndColumn","concat","pop","quitEarly","originalSequence","modifiedSequence","continueProcessingPredicate","pretty","ComputeDiff","startColumns","endColumns","getFirstNonBlankColumn","getLastNonBlankColumn","_startColumns","_endColumns","getElements","len","substring","getStrictElement","index","getStartLineNumber","getEndLineNumber","createCharSequence","startIndex","endIndex","charCodes","lineNumbers","columns","lineContent","col","CharSequence","_charCodes","_lineNumbers","_columns","_assertIndex","Error","getStartColumn","getEndColumn","CharChange","createFromDiffChange","diffChange","originalCharSequence","modifiedCharSequence","originalStart","originalLength","modifiedStart","modifiedLength","LineChange","createFromDiffResult","originalLineSequence","modifiedLineSequence","continueCharDiff","rawChanges","prevChange","currChange","originalMatchingLength","modifiedMatchingLength","postProcessCharChanges","opts","continueLineDiff","createContinueProcessingPredicate","lineChanges","originalLineIndex","modifiedLineIndex","nextChange","originalStop","modifiedStop","originalLine","modifiedLine","_pushTrimWhitespaceCharChange","originalMaxColumn","modifiedMaxColumn","originalLineNumber","modifiedLineNumber","_mergeTrimWhitespaceCharChange","txt","defaultValue","r","strings","maximumRuntime","linesDiffComputers","getLegacy","getDefault","LineRangeMapping","inverse","originalLineCount","modifiedLineCount","lastOriginalEndLineNumber","lastModifiedEndLineNumber","clip","flip","toRangeMapping","origInclusiveRange","toInclusiveRange","modInclusiveRange","RangeMapping","DetailedLineRangeMapping","fromRangeMappings","rangeMappings","super","withInnerChangesFromLineRanges","toTextEdit","newText","getValueOfRange","InternalEditorAction","id","label","alias","metadata","_precondition","_run","_contextKeyService","isSupported","contextMatchesRules","run","args","Promise","resolve","EditorType","ICodeEditor","IDiffEditor","EditorContextKeys","editorSimpleInput","editorTextFocus","focus","textInputFocus","readOnly","inDiffEditor","isEmbeddedDiffEditor","inMultiDiffEditor","multiDiffEditorAllCollapsed","hasChanges","comparingMovedCode","accessibleDiffViewerVisible","diffEditorRenderSideBySideInlineBreakpointReached","diffEditorInlineMode","diffEditorOriginalWritable","diffEditorModifiedWritable","diffEditorOriginalUri","diffEditorModifiedUri","columnSelection","writable","toNegated","hasNonEmptySelection","hasOnlyEmptySelection","hasMultipleSelections","hasSingleSelection","tabMovesFocus","tabDoesNotMoveFocus","isInEmbeddedEditor","canUndo","canRedo","hoverVisible","hoverFocused","stickyScrollFocused","stickyScrollVisible","standaloneColorPickerVisible","standaloneColorPickerFocused","inCompositeEditor","notInCompositeEditor","languageId","hasCompletionItemProvider","hasCodeActionsProvider","hasCodeLensProvider","hasDefinitionProvider","hasDeclarationProvider","hasImplementationProvider","hasTypeDefinitionProvider","hasHoverProvider","hasDocumentHighlightProvider","hasDocumentSymbolProvider","hasReferenceProvider","hasRenameProvider","hasSignatureHelpProvider","hasInlayHintsProvider","hasDocumentFormattingProvider","hasDocumentSelectionFormattingProvider","hasMultipleDocumentFormattingProvider","hasMultipleDocumentSelectionFormattingProvider","editorFeatures","registerEditorFeature","ctor","getEditorFeatures","EditorTheme","type","_theme","theme","update","getColor","color"],"sourceRoot":""}