@vscode/diff 0.0.2-0 → 0.0.2-2

package/dist/index.js

@@ -2,77 +2,8 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-/**
- * A range of offsets (0-based).
- */
-class OffsetRange {
-    start;
-    endExclusive;
-    static ofLength(length) {
-        return new OffsetRange(0, length);
-    }
-    static ofStartAndLength(start, length) {
-        return new OffsetRange(start, start + length);
-    }
-    constructor(start, endExclusive) {
-        this.start = start;
-        this.endExclusive = endExclusive;
-        if (start > endExclusive) {
-            throw new Error(`Invalid range: [${start}, ${endExclusive})`);
-        }
-    }
-    get isEmpty() {
-        return this.start === this.endExclusive;
-    }
-    get length() {
-        return this.endExclusive - this.start;
-    }
-    delta(offset) {
-        return new OffsetRange(this.start + offset, this.endExclusive + offset);
-    }
-    deltaStart(offset) {
-        return new OffsetRange(this.start + offset, this.endExclusive);
-    }
-    deltaEnd(offset) {
-        return new OffsetRange(this.start, this.endExclusive + offset);
-    }
-    equals(other) {
-        return this.start === other.start && this.endExclusive === other.endExclusive;
-    }
-    containsRange(other) {
-        return this.start <= other.start && other.endExclusive <= this.endExclusive;
-    }
-    contains(offset) {
-        return this.start <= offset && offset < this.endExclusive;
-    }
-    join(other) {
-        return new OffsetRange(Math.min(this.start, other.start), Math.max(this.endExclusive, other.endExclusive));
-    }
-    intersect(other) {
-        const start = Math.max(this.start, other.start);
-        const end = Math.min(this.endExclusive, other.endExclusive);
-        if (start <= end) {
-            return new OffsetRange(start, end);
-        }
-        return undefined;
-    }
-    intersects(other) {
-        const start = Math.max(this.start, other.start);
-        const end = Math.min(this.endExclusive, other.endExclusive);
-        return start < end;
-    }
-    intersectsOrTouches(other) {
-        const start = Math.max(this.start, other.start);
-        const end = Math.min(this.endExclusive, other.endExclusive);
-        return start <= end;
-    }
-    slice(arr) {
-        return arr.slice(this.start, this.endExclusive);
-    }
-    toString() {
-        return `[${this.start}, ${this.endExclusive})`;
-    }
-}
+import { O as OffsetRange, i as initWasm, g as getWasm, D as DefaultLinesDiffComputer, R as RangeMapping, a as Range, b as DetailedLineRangeMapping, L as LineRange, c as LinesDiff, w as wireToLinesDiff } from './wire.js';
+export { d as _LineRangeMapping } from './wire.js';
 
 /**
  * A pair of ranges, one in `original`, one in `modified`.
@@ -376,2208 +307,282 @@ class DiffResult {
     }
 }
 
-class InfiniteTimeout {
-    static instance = new InfiniteTimeout();
-    isValid() {
-        return true;
+async function createDiffComputer(options = {}) {
+    if (options.useWasm) {
+        await initWasm();
+        return new _WasmDiffComputer(options.algorithm);
     }
+    return new _TsDiffComputer(options.algorithm);
 }
-class DateTimeout {
-    timeout;
-    startTime = Date.now();
-    valid = true;
-    constructor(timeout) {
-        this.timeout = timeout;
-        if (timeout <= 0) {
-            throw new Error('timeout must be positive');
-        }
+// ============================================================================
+// TS-backed computer
+// ============================================================================
+class _TsDiffComputer {
+    _algorithm;
+    _impl = new DefaultLinesDiffComputer();
+    constructor(_algorithm) {
+        this._algorithm = _algorithm;
     }
-    isValid() {
-        const valid = Date.now() - this.startTime < this.timeout;
-        if (!valid && this.valid) {
-            this.valid = false;
-        }
-        return this.valid;
+    computeDiff(original, modified, options) {
+        const originalLines = original.split('\n');
+        const modifiedLines = modified.split('\n');
+        const internal = {
+            maxComputationTimeMs: options?.maxComputationTimeMs ?? 0,
+            ignoreTrimWhitespace: options?.ignoreTrimWhitespace ?? false,
+            computeMoves: options?.computeMoves ?? false,
+            extendToSubwords: options?.extendToSubwords ?? false,
+        };
+        const linesDiff = this._impl.computeDiff(originalLines, modifiedLines, internal);
+        void this._algorithm; // currently a hint; auto-selection lives inside DefaultLinesDiffComputer
+        return _adaptLinesDiff(linesDiff, original, modified, originalLines, modifiedLines);
     }
 }
-/**
- * Represents an offset pair for two sequences.
- */
-class OffsetPair {
-    offset1;
-    offset2;
-    static zero = new OffsetPair(0, 0);
-    static max = new OffsetPair(Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
-    constructor(offset1, offset2) {
-        this.offset1 = offset1;
-        this.offset2 = offset2;
-    }
-    toString() {
-        return `${this.offset1} <-> ${this.offset2}`;
-    }
-    delta(offset) {
-        if (offset === 0) {
-            return this;
-        }
-        return new OffsetPair(this.offset1 + offset, this.offset2 + offset);
+// ============================================================================
+// WASM-backed computer
+// ============================================================================
+class _WasmDiffComputer {
+    _algorithm;
+    constructor(_algorithm) {
+        this._algorithm = _algorithm;
     }
-    equals(other) {
-        return this.offset1 === other.offset1 && this.offset2 === other.offset2;
+    computeDiff(original, modified, options) {
+        const originalLines = original.split('\n');
+        const modifiedLines = modified.split('\n');
+        const wasmOptions = {};
+        if (options?.maxComputationTimeMs !== undefined)
+            wasmOptions.maxComputationTimeMs = options.maxComputationTimeMs;
+        if (options?.ignoreTrimWhitespace !== undefined)
+            wasmOptions.ignoreTrimWhitespace = options.ignoreTrimWhitespace;
+        if (options?.computeMoves !== undefined)
+            wasmOptions.computeMoves = options.computeMoves;
+        if (options?.extendToSubwords !== undefined)
+            wasmOptions.extendToSubwords = options.extendToSubwords;
+        const wasm = getWasm();
+        const wasmResult = wasm.computeDiffLines(originalLines, modifiedLines, wasmOptions);
+        void this._algorithm;
+        const linesDiff = _wasmToLinesDiff(wasmResult);
+        return _adaptLinesDiff(linesDiff, original, modified, originalLines, modifiedLines);
     }
 }
-/**
- * Represents a diff between two sequences.
- */
-class SequenceDiff {
-    seq1Range;
-    seq2Range;
-    static invert(sequenceDiffs, doc1Length) {
-        const result = [];
-        forEachAdjacent(sequenceDiffs, (a, b) => {
-            result.push(SequenceDiff.fromOffsetPairs(a ? a.getEndExclusives() : OffsetPair.zero, b ? b.getStarts() : new OffsetPair(doc1Length, (a ? a.seq2Range.endExclusive - a.seq1Range.endExclusive : 0) + doc1Length)));
-        });
-        return result;
-    }
-    static fromOffsetPairs(start, endExclusive) {
-        return new SequenceDiff(new OffsetRange(start.offset1, endExclusive.offset1), new OffsetRange(start.offset2, endExclusive.offset2));
-    }
-    static assertSorted(sequenceDiffs) {
-        let last = undefined;
-        for (const cur of sequenceDiffs) {
-            if (last) {
-                if (!(last.seq1Range.endExclusive <= cur.seq1Range.start && last.seq2Range.endExclusive <= cur.seq2Range.start)) {
-                    throw new Error('Sequence diffs must be sorted');
-                }
-            }
-            last = cur;
-        }
-    }
-    constructor(seq1Range, seq2Range) {
-        this.seq1Range = seq1Range;
-        this.seq2Range = seq2Range;
-    }
-    swap() {
-        return new SequenceDiff(this.seq2Range, this.seq1Range);
-    }
-    toString() {
-        return `${this.seq1Range} <-> ${this.seq2Range}`;
-    }
-    join(other) {
-        return new SequenceDiff(this.seq1Range.join(other.seq1Range), this.seq2Range.join(other.seq2Range));
-    }
-    delta(offset) {
-        if (offset === 0) {
-            return this;
-        }
-        return new SequenceDiff(this.seq1Range.delta(offset), this.seq2Range.delta(offset));
+function _wasmToLinesDiff(wasmResult) {
+    const changes = wasmResult.changes.map((c) => {
+        const inner = c.innerChanges?.map((ic) => new RangeMapping(new Range(ic.originalStartLine, ic.originalStartColumn, ic.originalEndLine, ic.originalEndColumn), new Range(ic.modifiedStartLine, ic.modifiedStartColumn, ic.modifiedEndLine, ic.modifiedEndColumn)));
+        return new DetailedLineRangeMapping(new LineRange(c.original.startLineNumber, c.original.endLineNumberExclusive), new LineRange(c.modified.startLineNumber, c.modified.endLineNumberExclusive), inner);
+    });
+    return new LinesDiff(changes, [], wasmResult.hitTimeout);
+}
+// ============================================================================
+// LinesDiff -> DiffResult adapter
+// ============================================================================
+/** @internal — exported for the worker-side client. */
+function _adaptLinesDiff(linesDiff, original, modified, originalLines, modifiedLines) {
+    const originalLineStarts = _computeLineStarts(originalLines);
+    const modifiedLineStarts = _computeLineStarts(modifiedLines);
+    const replacements = [];
+    for (const change of linesDiff.changes) {
+        _appendChangeReplacements(change, original, modified, originalLines, modifiedLines, originalLineStarts, modifiedLineStarts, replacements);
     }
-    deltaStart(offset) {
-        if (offset === 0) {
-            return this;
+    const edits = AnnotatedStringEdit.of(replacements);
+    const moves = linesDiff.moves.map(m => _adaptMove(m, original, modified, originalLines, modifiedLines, originalLineStarts, modifiedLineStarts));
+    return new DiffResult(edits, moves, linesDiff.hitTimeout);
+}
+function _appendChangeReplacements(change, original, modified, originalLines, modifiedLines, originalLineStarts, modifiedLineStarts, out) {
+    if (change.innerChanges && change.innerChanges.length > 0) {
+        for (const ic of change.innerChanges) {
+            const origRange = _rangeToOffsetRange(ic.originalRange, original, originalLines, originalLineStarts);
+            const modRange = _rangeToOffsetRange(ic.modifiedRange, modified, modifiedLines, modifiedLineStarts);
+            const newText = modified.substring(modRange.start, modRange.endExclusive);
+            out.push(new AnnotatedStringReplacement(origRange, newText, DiffAnnotation.change));
         }
-        return new SequenceDiff(this.seq1Range.deltaStart(offset), this.seq2Range.deltaStart(offset));
+        return;
     }
-    deltaEnd(offset) {
-        if (offset === 0) {
-            return this;
+    // Fallback: no inner detail — replace the whole line range.
+    const origRange = _lineRangeToOffsetRange(change.original.startLineNumber, change.original.endLineNumberExclusive, original, originalLineStarts);
+    const modRange = _lineRangeToOffsetRange(change.modified.startLineNumber, change.modified.endLineNumberExclusive, modified, modifiedLineStarts);
+    const newText = modified.substring(modRange.start, modRange.endExclusive);
+    out.push(new AnnotatedStringReplacement(origRange, newText, DiffAnnotation.change));
+}
+function _adaptMove(move, original, modified, originalLines, modifiedLines, originalLineStarts, modifiedLineStarts) {
+    const origRange = _lineRangeToOffsetRange(move.lineRangeMapping.original.startLineNumber, move.lineRangeMapping.original.endLineNumberExclusive, original, originalLineStarts);
+    const modRange = _lineRangeToOffsetRange(move.lineRangeMapping.modified.startLineNumber, move.lineRangeMapping.modified.endLineNumberExclusive, modified, modifiedLineStarts);
+    // Build inner edit with offsets local to the moved slices.
+    const inner = [];
+    for (const change of move.changes) {
+        if (change.innerChanges && change.innerChanges.length > 0) {
+            for (const ic of change.innerChanges) {
+                const globalOrig = _rangeToOffsetRange(ic.originalRange, original, originalLines, originalLineStarts);
+                const globalMod = _rangeToOffsetRange(ic.modifiedRange, modified, modifiedLines, modifiedLineStarts);
+                inner.push(new StringReplacement(new OffsetRange(globalOrig.start - origRange.start, globalOrig.endExclusive - origRange.start), modified.substring(globalMod.start, globalMod.endExclusive)));
+            }
         }
-        return new SequenceDiff(this.seq1Range.deltaEnd(offset), this.seq2Range.deltaEnd(offset));
-    }
-    intersectsOrTouches(other) {
-        return this.seq1Range.intersectsOrTouches(other.seq1Range) || this.seq2Range.intersectsOrTouches(other.seq2Range);
-    }
-    intersect(other) {
-        const i1 = this.seq1Range.intersect(other.seq1Range);
-        const i2 = this.seq2Range.intersect(other.seq2Range);
-        if (!i1 || !i2) {
-            return undefined;
+        else {
+            const globalOrig = _lineRangeToOffsetRange(change.original.startLineNumber, change.original.endLineNumberExclusive, original, originalLineStarts);
+            const globalMod = _lineRangeToOffsetRange(change.modified.startLineNumber, change.modified.endLineNumberExclusive, modified, modifiedLineStarts);
+            inner.push(new StringReplacement(new OffsetRange(globalOrig.start - origRange.start, globalOrig.endExclusive - origRange.start), modified.substring(globalMod.start, globalMod.endExclusive)));
         }
-        return new SequenceDiff(i1, i2);
-    }
-    getStarts() {
-        return new OffsetPair(this.seq1Range.start, this.seq2Range.start);
-    }
-    getEndExclusives() {
-        return new OffsetPair(this.seq1Range.endExclusive, this.seq2Range.endExclusive);
     }
+    return new Move(new OffsetRangeMapping(origRange, modRange), StringEdit.of(inner));
 }
-/**
- * Result of a diff algorithm computation.
- */
-class DiffAlgorithmResult {
-    diffs;
-    hitTimeout;
-    static trivial(seq1, seq2) {
-        return new DiffAlgorithmResult([new SequenceDiff(OffsetRange.ofLength(seq1.length), OffsetRange.ofLength(seq2.length))], false);
-    }
-    static trivialTimedOut(seq1, seq2) {
-        return new DiffAlgorithmResult([new SequenceDiff(OffsetRange.ofLength(seq1.length), OffsetRange.ofLength(seq2.length))], true);
-    }
-    constructor(diffs, hitTimeout) {
-        this.diffs = diffs;
-        this.hitTimeout = hitTimeout;
+// ----- offset/line helpers -----
+function _computeLineStarts(lines) {
+    // Offsets correspond to `lines.join('\n')`, which equals the input string
+    // when the input was split by `\n`.
+    const starts = new Array(lines.length + 1);
+    starts[0] = 0;
+    for (let i = 0; i < lines.length; i++) {
+        starts[i + 1] = starts[i] + lines[i].length + 1; // +1 for the '\n'
     }
+    // `starts[lines.length]` is one past the synthetic trailing newline; the
+    // real text ends one earlier when there is no trailing newline (which is
+    // what `split('\n')` produces for non-newline-terminated input).
+    return starts;
 }
-// Helper function for iterating with neighbors
-function forEachAdjacent(items, callback) {
-    let prev = undefined;
-    for (const item of items) {
-        callback(prev, item);
-        prev = item;
-    }
-    callback(prev, undefined);
+function _lineRangeToOffsetRange(startLineNumber, endLineNumberExclusive, text, lineStarts) {
+    const start = _lineColToOffset(startLineNumber, 1, text, lineStarts);
+    const end = _lineColToOffset(endLineNumberExclusive, 1, text, lineStarts);
+    return new OffsetRange(start, end);
 }
-
-/**
- * A 2D array implementation.
- */
-class Array2D {
-    width;
-    height;
-    array = [];
-    constructor(width, height) {
-        this.width = width;
-        this.height = height;
-        this.array = new Array(width * height);
-    }
-    get(x, y) {
-        return this.array[x + y * this.width];
-    }
-    set(x, y, value) {
-        this.array[x + y * this.width] = value;
-    }
+function _rangeToOffsetRange(range, text, lines, lineStarts) {
+    const start = _lineColToOffset(range.startLineNumber, range.startColumn, text, lineStarts);
+    const end = _lineColToOffset(range.endLineNumber, range.endColumn, text, lineStarts);
+    return new OffsetRange(start, end);
 }
-/**
- * A O(MN) diffing algorithm that supports a score function.
- * The algorithm can be improved by processing the 2d array diagonally.
- */
-class DynamicProgrammingDiffing {
-    compute(sequence1, sequence2, timeout = InfiniteTimeout.instance, equalityScore) {
-        if (sequence1.length === 0 || sequence2.length === 0) {
-            return DiffAlgorithmResult.trivial(sequence1, sequence2);
-        }
-        /**
-         * lcsLengths.get(i, j): Length of the longest common subsequence of
-         * sequence1.substring(0, i + 1) and sequence2.substring(0, j + 1).
-         */
-        const lcsLengths = new Array2D(sequence1.length, sequence2.length);
-        const directions = new Array2D(sequence1.length, sequence2.length);
-        const lengths = new Array2D(sequence1.length, sequence2.length);
-        // Initialize lcsLengths
-        for (let s1 = 0; s1 < sequence1.length; s1++) {
-            for (let s2 = 0; s2 < sequence2.length; s2++) {
-                if (!timeout.isValid()) {
-                    return DiffAlgorithmResult.trivialTimedOut(sequence1, sequence2);
-                }
-                const horizontalLen = s1 === 0 ? 0 : lcsLengths.get(s1 - 1, s2);
-                const verticalLen = s2 === 0 ? 0 : lcsLengths.get(s1, s2 - 1);
-                let extendedSeqScore;
-                if (sequence1.getElement(s1) === sequence2.getElement(s2)) {
-                    if (s1 === 0 || s2 === 0) {
-                        extendedSeqScore = 0;
-                    }
-                    else {
-                        extendedSeqScore = lcsLengths.get(s1 - 1, s2 - 1);
-                    }
-                    if (s1 > 0 && s2 > 0 && directions.get(s1 - 1, s2 - 1) === 3) {
-                        // Prefer consecutive diagonals
-                        extendedSeqScore += lengths.get(s1 - 1, s2 - 1);
-                    }
-                    extendedSeqScore += (equalityScore ? equalityScore(s1, s2) : 1);
-                }
-                else {
-                    extendedSeqScore = -1;
-                }
-                const newValue = Math.max(horizontalLen, verticalLen, extendedSeqScore);
-                if (newValue === extendedSeqScore) {
-                    // Prefer diagonals
-                    const prevLen = s1 > 0 && s2 > 0 ? lengths.get(s1 - 1, s2 - 1) : 0;
-                    lengths.set(s1, s2, prevLen + 1);
-                    directions.set(s1, s2, 3);
-                }
-                else if (newValue === horizontalLen) {
-                    lengths.set(s1, s2, 0);
-                    directions.set(s1, s2, 1);
-                }
-                else if (newValue === verticalLen) {
-                    lengths.set(s1, s2, 0);
-                    directions.set(s1, s2, 2);
-                }
-                lcsLengths.set(s1, s2, newValue);
-            }
-        }
-        // Backtracking
-        const result = [];
-        let lastAligningPosS1 = sequence1.length;
-        let lastAligningPosS2 = sequence2.length;
-        function reportDecreasingAligningPositions(s1, s2) {
-            if (s1 + 1 !== lastAligningPosS1 || s2 + 1 !== lastAligningPosS2) {
-                result.push(new SequenceDiff(new OffsetRange(s1 + 1, lastAligningPosS1), new OffsetRange(s2 + 1, lastAligningPosS2)));
-            }
-            lastAligningPosS1 = s1;
-            lastAligningPosS2 = s2;
-        }
-        let s1 = sequence1.length - 1;
-        let s2 = sequence2.length - 1;
-        while (s1 >= 0 && s2 >= 0) {
-            if (directions.get(s1, s2) === 3) {
-                reportDecreasingAligningPositions(s1, s2);
-                s1--;
-                s2--;
-            }
-            else {
-                if (directions.get(s1, s2) === 1) {
-                    s1--;
-                }
-                else {
-                    s2--;
-                }
-            }
-        }
-        reportDecreasingAligningPositions(-1, -1);
-        result.reverse();
-        return new DiffAlgorithmResult(result, false);
+function _lineColToOffset(lineNumber, column, text, lineStarts) {
+    // `lineNumber` and `column` are 1-based; `endLineNumberExclusive` can be
+    // `lines.length + 1` (one past the last line).
+    if (lineNumber <= 0) {
+        return 0;
+    }
+    if (lineNumber > lineStarts.length) {
+        return text.length;
     }
+    const base = lineStarts[lineNumber - 1];
+    const offset = base + (column - 1);
+    return Math.min(Math.max(offset, 0), text.length);
 }
 
 /**
- * An O(ND) diff algorithm that has a quadratic space worst-case complexity.
+ * Main-thread client for the diff worker. Exposes an async `IAsyncDiffComputer`.
+ *
+ * Inputs travel as `string[]` via structured-clone postMessage. The response
+ * is a small JSON-friendly `WireLinesDiff`; the main thread reconstructs the
+ * full `LinesDiff` and runs `_adaptLinesDiff` locally (it already has the
+ * input strings).
  */
-class MyersDiffAlgorithm {
-    compute(seq1, seq2, timeout = InfiniteTimeout.instance) {
-        // Common special cases - early return improves performance dramatically
-        if (seq1.length === 0 || seq2.length === 0) {
-            return DiffAlgorithmResult.trivial(seq1, seq2);
-        }
-        const seqX = seq1; // Text on the x axis
-        const seqY = seq2; // Text on the y axis
-        function getXAfterSnake(x, y) {
-            while (x < seqX.length && y < seqY.length && seqX.getElement(x) === seqY.getElement(y)) {
-                x++;
-                y++;
-            }
-            return x;
-        }
-        let d = 0;
-        // V[k]: X value of longest d-line that ends in diagonal k.
-        // d-line: path from (0,0) to (x,y) that uses exactly d non-diagonals.
-        // diagonal k: Set of points (x,y) with x-y = k.
-        const V = new FastInt32Array();
-        V.set(0, getXAfterSnake(0, 0));
-        const paths = new FastArrayNegativeIndices();
-        paths.set(0, V.get(0) === 0 ? null : new SnakePath(null, 0, 0, V.get(0)));
-        let k = 0;
-        loop: while (true) {
-            d++;
-            if (!timeout.isValid()) {
-                return DiffAlgorithmResult.trivialTimedOut(seqX, seqY);
-            }
-            // The paper has `for (k = -d; k <= d; k += 2)`, but we can ignore diagonals that cannot influence the result.
-            const lowerBound = -Math.min(d, seqY.length + (d % 2));
-            const upperBound = Math.min(d, seqX.length + (d % 2));
-            for (k = lowerBound; k <= upperBound; k += 2) {
-                // We can use the X values of (d-1)-lines to compute X value of the longest d-lines.
-                const maxXofDLineTop = k === upperBound ? -1 : V.get(k + 1); // Vertical non-diagonal (add symbol in seqX)
-                const maxXofDLineLeft = k === lowerBound ? -1 : V.get(k - 1) + 1; // Horizontal non-diagonal (delete symbol in seqX)
-                const x = Math.min(Math.max(maxXofDLineTop, maxXofDLineLeft), seqX.length);
-                const y = x - k;
-                if (x > seqX.length || y > seqY.length) {
-                    continue;
-                }
-                const newMaxX = getXAfterSnake(x, y);
-                V.set(k, newMaxX);
-                const lastPath = x === maxXofDLineTop ? paths.get(k + 1) : paths.get(k - 1);
-                paths.set(k, newMaxX !== x ? new SnakePath(lastPath, x, y, newMaxX - x) : lastPath);
-                if (V.get(k) === seqX.length && V.get(k) - k === seqY.length) {
-                    break loop;
-                }
-            }
-        }
-        let path = paths.get(k);
-        const result = [];
-        let lastAligningPosS1 = seqX.length;
-        let lastAligningPosS2 = seqY.length;
-        while (true) {
-            const endX = path ? path.x + path.length : 0;
-            const endY = path ? path.y + path.length : 0;
-            if (endX !== lastAligningPosS1 || endY !== lastAligningPosS2) {
-                result.push(new SequenceDiff(new OffsetRange(endX, lastAligningPosS1), new OffsetRange(endY, lastAligningPosS2)));
-            }
-            if (!path) {
-                break;
-            }
-            lastAligningPosS1 = path.x;
-            lastAligningPosS2 = path.y;
-            path = path.prev;
-        }
-        result.reverse();
-        return new DiffAlgorithmResult(result, false);
+async function createWorkerDiffComputer(opts = {}) {
+    const worker = opts.workerFactory ? opts.workerFactory() : defaultWorkerFactory();
+    const backend = opts.useWasm ? 'wasm' : 'ts';
+    const computer = new _WorkerDiffComputer(worker, backend);
+    await computer.init();
+    return computer;
+}
+function defaultWorkerFactory() {
+    // The `?esm` marker is auto-discovered by `@vscode/*-plugin-esm-url`
+    // bundler plugins; they emit `worker.ts` as a sibling `worker.js` bundle
+    // and rewrite this URL accordingly.
+    return new Worker(new URL('worker.js?esm', import.meta.url), { type: 'module' });
+}
+class _WorkerDiffComputer {
+    _worker;
+    _backend;
+    _nextId = 1;
+    _pending = new Map();
+    _pendingInit = null;
+    _disposed = false;
+    constructor(_worker, _backend) {
+        this._worker = _worker;
+        this._backend = _backend;
+        this._worker.addEventListener('message', (ev) => {
+            this._onMessage(ev.data);
+        });
+        this._worker.addEventListener('error', (ev) => {
+            this._failAll(new Error(`Worker error: ${ev.message ?? 'unknown'}`));
+        });
     }
-}
-class SnakePath {
-    prev;
-    x;
-    y;
-    length;
-    constructor(prev, x, y, length) {
-        this.prev = prev;
-        this.x = x;
-        this.y = y;
-        this.length = length;
+    init() {
+        const id = this._nextId++;
+        const req = { kind: 'init', id, backend: this._backend };
+        return new Promise((resolve, reject) => {
+            this._pendingInit = { resolve, reject };
+            this._worker.postMessage(req);
+        });
     }
-}
-/**
- * An array that supports fast negative indices.
- */
-class FastInt32Array {
-    positiveArr = new Int32Array(10);
-    negativeArr = new Int32Array(10);
-    get(idx) {
-        if (idx < 0) {
-            idx = -idx - 1;
-            return this.negativeArr[idx];
-        }
-        else {
-            return this.positiveArr[idx];
+    computeDiff(original, modified, options = {}) {
+        if (this._disposed) {
+            return Promise.reject(new Error('Worker computer disposed'));
         }
+        const id = this._nextId++;
+        const originalLines = original.split('\n');
+        const modifiedLines = modified.split('\n');
+        const msg = {
+            kind: 'computeDiff',
+            id,
+            backend: this._backend,
+            originalLines,
+            modifiedLines,
+            options,
+        };
+        return new Promise((resolve, reject) => {
+            this._pending.set(id, {
+                resolve,
+                reject,
+                original,
+                modified,
+                originalLines,
+                modifiedLines,
+            });
+            this._worker.postMessage(msg);
+        });
     }
-    set(idx, value) {
-        if (idx < 0) {
-            idx = -idx - 1;
-            if (idx >= this.negativeArr.length) {
-                const arr = this.negativeArr;
-                this.negativeArr = new Int32Array(arr.length * 2);
-                this.negativeArr.set(arr);
-            }
-            this.negativeArr[idx] = value;
+    dispose() {
+        if (this._disposed)
+            return;
+        this._disposed = true;
+        this._failAll(new Error('Worker computer disposed'));
+        this._worker.terminate();
+    }
+    _onMessage(msg) {
+        if (msg.kind === 'init') {
+            const pending = this._pendingInit;
+            this._pendingInit = null;
+            pending?.resolve();
+            return;
         }
-        else {
-            if (idx >= this.positiveArr.length) {
-                const arr = this.positiveArr;
-                this.positiveArr = new Int32Array(arr.length * 2);
-                this.positiveArr.set(arr);
+        const entry = this._pending.get(msg.id);
+        if (!entry) {
+            // Init failure is reported on the init id with `kind === 'computeDiff'`
+            // and `ok === false`; route to the init promise if it's still pending.
+            if (!msg.ok && this._pendingInit) {
+                const p = this._pendingInit;
+                this._pendingInit = null;
+                p.reject(new Error(msg.error));
             }
-            this.positiveArr[idx] = value;
+            return;
         }
-    }
-}
-/**
- * An array that supports fast negative indices for objects.
- */
-class FastArrayNegativeIndices {
-    positiveArr = [];
-    negativeArr = [];
-    get(idx) {
-        if (idx < 0) {
-            idx = -idx - 1;
-            return this.negativeArr[idx];
+        this._pending.delete(msg.id);
+        if (!msg.ok) {
+            entry.reject(new Error(msg.error));
+            return;
         }
-        else {
-            return this.positiveArr[idx];
+        try {
+            const linesDiff = wireToLinesDiff(msg.result);
+            const result = _adaptLinesDiff(linesDiff, entry.original, entry.modified, entry.originalLines, entry.modifiedLines);
+            entry.resolve(result);
+        }
+        catch (err) {
+            entry.reject(err instanceof Error ? err : new Error(String(err)));
         }
     }
-    set(idx, value) {
-        if (idx < 0) {
-            idx = -idx - 1;
-            this.negativeArr[idx] = value;
+    _failAll(err) {
+        for (const p of this._pending.values())
+            p.reject(err);
+        this._pending.clear();
+        if (this._pendingInit) {
+            this._pendingInit.reject(err);
+            this._pendingInit = null;
         }
-        else {
-            this.positiveArr[idx] = value;
-        }
-    }
-}
-
-function log(msg) {
-}
-function optimizeSequenceDiffs(sequence1, sequence2, sequenceDiffs) {
-    let result = sequenceDiffs;
-    result = joinSequenceDiffsByShifting(sequence1, sequence2, result);
-    // Sometimes, calling this function twice improves the result.
-    result = joinSequenceDiffsByShifting(sequence1, sequence2, result);
-    result = shiftSequenceDiffs(sequence1, sequence2, result);
-    return result;
-}
-/**
- * This function fixes issues like this:
- * ```
- * import { Baz, Bar } from "foo";
- * ```
- * <->
- * ```
- * import { Baz, Bar, Foo } from "foo";
- * ```
- * Computed diff: [ {Add "," after Bar}, {Add "Foo " after space} }
- * Improved diff: [{Add ", Foo" after Bar}]
- */
-function joinSequenceDiffsByShifting(sequence1, sequence2, sequenceDiffs) {
-    if (sequenceDiffs.length === 0) {
-        return sequenceDiffs;
-    }
-    const result = [];
-    result.push(sequenceDiffs[0]);
-    // First move them all to the left as much as possible and join them if possible
-    for (let i = 1; i < sequenceDiffs.length; i++) {
-        const prevResult = result[result.length - 1];
-        let cur = sequenceDiffs[i];
-        if (cur.seq1Range.isEmpty || cur.seq2Range.isEmpty) {
-            const length = cur.seq1Range.start - prevResult.seq1Range.endExclusive;
-            let d;
-            for (d = 1; d <= length; d++) {
-                if (sequence1.getElement(cur.seq1Range.start - d) !== sequence1.getElement(cur.seq1Range.endExclusive - d) ||
-                    sequence2.getElement(cur.seq2Range.start - d) !== sequence2.getElement(cur.seq2Range.endExclusive - d)) {
-                    break;
-                }
-            }
-            d--;
-            if (d === length) {
-                // Merge previous and current diff
-                result[result.length - 1] = new SequenceDiff(new OffsetRange(prevResult.seq1Range.start, cur.seq1Range.endExclusive - length), new OffsetRange(prevResult.seq2Range.start, cur.seq2Range.endExclusive - length));
-                continue;
-            }
-            cur = cur.delta(-d);
-        }
-        result.push(cur);
-    }
-    const result2 = [];
-    // Then move them all to the right and join them again if possible
-    for (let i = 0; i < result.length - 1; i++) {
-        const nextResult = result[i + 1];
-        let cur = result[i];
-        if (cur.seq1Range.isEmpty || cur.seq2Range.isEmpty) {
-            const length = nextResult.seq1Range.start - cur.seq1Range.endExclusive;
-            let d;
-            for (d = 0; d < length; d++) {
-                if (!sequence1.isStronglyEqual(cur.seq1Range.start + d, cur.seq1Range.endExclusive + d) ||
-                    !sequence2.isStronglyEqual(cur.seq2Range.start + d, cur.seq2Range.endExclusive + d)) {
-                    break;
-                }
-            }
-            if (d === length) {
-                // Merge previous and current diff
-                result[i + 1] = new SequenceDiff(new OffsetRange(cur.seq1Range.start + length, nextResult.seq1Range.endExclusive), new OffsetRange(cur.seq2Range.start + length, nextResult.seq2Range.endExclusive));
-                continue;
-            }
-            if (d > 0) {
-                cur = cur.delta(d);
-            }
-        }
-        result2.push(cur);
-    }
-    if (result.length > 0) {
-        result2.push(result[result.length - 1]);
-    }
-    return result2;
-}
-function shiftSequenceDiffs(sequence1, sequence2, sequenceDiffs) {
-    if (!sequence1.getBoundaryScore || !sequence2.getBoundaryScore) {
-        return sequenceDiffs;
-    }
-    for (let i = 0; i < sequenceDiffs.length; i++) {
-        const prevDiff = (i > 0 ? sequenceDiffs[i - 1] : undefined);
-        const diff = sequenceDiffs[i];
-        const nextDiff = (i + 1 < sequenceDiffs.length ? sequenceDiffs[i + 1] : undefined);
-        const seq1ValidRange = new OffsetRange(prevDiff ? prevDiff.seq1Range.endExclusive + 1 : 0, nextDiff ? nextDiff.seq1Range.start - 1 : sequence1.length);
-        const seq2ValidRange = new OffsetRange(prevDiff ? prevDiff.seq2Range.endExclusive + 1 : 0, nextDiff ? nextDiff.seq2Range.start - 1 : sequence2.length);
-        if (diff.seq1Range.isEmpty) {
-            sequenceDiffs[i] = shiftDiffToBetterPosition(diff, sequence1, sequence2, seq1ValidRange, seq2ValidRange);
-        }
-        else if (diff.seq2Range.isEmpty) {
-            sequenceDiffs[i] = shiftDiffToBetterPosition(diff.swap(), sequence2, sequence1, seq2ValidRange, seq1ValidRange).swap();
-        }
-    }
-    return sequenceDiffs;
-}
-function shiftDiffToBetterPosition(diff, sequence1, sequence2, seq1ValidRange, seq2ValidRange) {
-    const maxShiftLimit = 100; // To prevent performance issues
-    let deltaBefore = 1;
-    while (diff.seq1Range.start - deltaBefore >= seq1ValidRange.start &&
-        diff.seq2Range.start - deltaBefore >= seq2ValidRange.start &&
-        sequence2.isStronglyEqual(diff.seq2Range.start - deltaBefore, diff.seq2Range.endExclusive - deltaBefore) && deltaBefore < maxShiftLimit) {
-        deltaBefore++;
-    }
-    deltaBefore--;
-    let deltaAfter = 0;
-    while (diff.seq1Range.start + deltaAfter < seq1ValidRange.endExclusive &&
-        diff.seq2Range.endExclusive + deltaAfter < seq2ValidRange.endExclusive &&
-        sequence2.isStronglyEqual(diff.seq2Range.start + deltaAfter, diff.seq2Range.endExclusive + deltaAfter) && deltaAfter < maxShiftLimit) {
-        deltaAfter++;
-    }
-    if (deltaBefore === 0 && deltaAfter === 0) {
-        return diff;
-    }
-    let bestDelta = 0;
-    let bestScore = -1;
-    // Find best scored delta
-    for (let delta = -deltaBefore; delta <= deltaAfter; delta++) {
-        const seq2OffsetStart = diff.seq2Range.start + delta;
-        const seq2OffsetEndExclusive = diff.seq2Range.endExclusive + delta;
-        const seq1Offset = diff.seq1Range.start + delta;
-        const score = sequence1.getBoundaryScore(seq1Offset) + sequence2.getBoundaryScore(seq2OffsetStart) + sequence2.getBoundaryScore(seq2OffsetEndExclusive);
-        if (score > bestScore) {
-            bestScore = score;
-            bestDelta = delta;
-        }
-    }
-    return diff.delta(bestDelta);
-}
-function removeShortMatches(sequence1, sequence2, sequenceDiffs) {
-    const result = [];
-    for (const s of sequenceDiffs) {
-        const last = result[result.length - 1];
-        if (!last) {
-            result.push(s);
-            continue;
-        }
-        if (s.seq1Range.start - last.seq1Range.endExclusive <= 2 || s.seq2Range.start - last.seq2Range.endExclusive <= 2) {
-            result[result.length - 1] = new SequenceDiff(last.seq1Range.join(s.seq1Range), last.seq2Range.join(s.seq2Range));
-        }
-        else {
-            result.push(s);
-        }
-    }
-    return result;
-}
-function extendDiffsToEntireWordIfAppropriate(sequence1, sequence2, sequenceDiffs, findParent, force = false) {
-    const equalMappings = SequenceDiff.invert(sequenceDiffs, sequence1.length);
-    const additional = [];
-    let lastPoint = new OffsetPair(0, 0);
-    function scanWord(pair, equalMapping) {
-        if (pair.offset1 < lastPoint.offset1 || pair.offset2 < lastPoint.offset2) {
-            return;
-        }
-        const w1 = findParent(sequence1, pair.offset1);
-        const w2 = findParent(sequence2, pair.offset2);
-        if (!w1 || !w2) {
-            return;
-        }
-        let w = new SequenceDiff(w1, w2);
-        const equalPart = w.intersect(equalMapping);
-        let equalChars1 = equalPart.seq1Range.length;
-        let equalChars2 = equalPart.seq2Range.length;
-        while (equalMappings.length > 0) {
-            const next = equalMappings[0];
-            const intersects = next.seq1Range.intersects(w.seq1Range) || next.seq2Range.intersects(w.seq2Range);
-            if (!intersects) {
-                break;
-            }
-            const v1 = findParent(sequence1, next.seq1Range.start);
-            const v2 = findParent(sequence2, next.seq2Range.start);
-            const v = new SequenceDiff(v1, v2);
-            const equalPartV = v.intersect(next);
-            equalChars1 += equalPartV.seq1Range.length;
-            equalChars2 += equalPartV.seq2Range.length;
-            w = w.join(v);
-            if (w.seq1Range.endExclusive >= next.seq1Range.endExclusive) {
-                equalMappings.shift();
-            }
-            else {
-                break;
-            }
-        }
-        if ((force && equalChars1 + equalChars2 < w.seq1Range.length + w.seq2Range.length) || equalChars1 + equalChars2 < (w.seq1Range.length + w.seq2Range.length) * 2 / 3) {
-            additional.push(w);
-        }
-        lastPoint = w.getEndExclusives();
-    }
-    while (equalMappings.length > 0) {
-        const next = equalMappings.shift();
-        if (next.seq1Range.isEmpty) {
-            continue;
-        }
-        scanWord(next.getStarts(), next);
-        scanWord(next.getEndExclusives().delta(-1), next);
-    }
-    const merged = mergeSequenceDiffs(sequenceDiffs, additional);
-    return merged;
-}
-function mergeSequenceDiffs(sequenceDiffs1, sequenceDiffs2) {
-    const result = [];
-    while (sequenceDiffs1.length > 0 || sequenceDiffs2.length > 0) {
-        const sd1 = sequenceDiffs1[0];
-        const sd2 = sequenceDiffs2[0];
-        let next;
-        if (sd1 && (!sd2 || sd1.seq1Range.start < sd2.seq1Range.start)) {
-            next = sequenceDiffs1.shift();
-        }
-        else {
-            next = sequenceDiffs2.shift();
-        }
-        if (result.length > 0 && result[result.length - 1].seq1Range.endExclusive >= next.seq1Range.start) {
-            result[result.length - 1] = result[result.length - 1].join(next);
-        }
-        else {
-            result.push(next);
-        }
-    }
-    return result;
-}
-function removeVeryShortMatchingLinesBetweenDiffs(sequence1, _sequence2, sequenceDiffs) {
-    let diffs = sequenceDiffs;
-    if (diffs.length === 0) {
-        return diffs;
-    }
-    let counter = 0;
-    let shouldRepeat;
-    do {
-        shouldRepeat = false;
-        const result = [diffs[0]];
-        for (let i = 1; i < diffs.length; i++) {
-            const cur = diffs[i];
-            const lastResult = result[result.length - 1];
-            function shouldJoinDiffs(before, after) {
-                const unchangedRange = new OffsetRange(lastResult.seq1Range.endExclusive, cur.seq1Range.start);
-                const unchangedText = sequence1.getText(unchangedRange);
-                const unchangedTextWithoutWs = unchangedText.replace(/\s/g, '');
-                if (unchangedTextWithoutWs.length <= 4
-                    && (before.seq1Range.length + before.seq2Range.length > 5 || after.seq1Range.length + after.seq2Range.length > 5)) {
-                    return true;
-                }
-                return false;
-            }
-            const shouldJoin = shouldJoinDiffs(lastResult, cur);
-            if (shouldJoin) {
-                shouldRepeat = true;
-                result[result.length - 1] = result[result.length - 1].join(cur);
-            }
-            else {
-                result.push(cur);
-            }
-        }
-        diffs = result;
-    } while (counter++ < 10 && shouldRepeat);
-    return diffs;
-}
-function removeVeryShortMatchingTextBetweenLongDiffs(sequence1, sequence2, sequenceDiffs) {
-    log(`[removeVeryShortMatchingTextBetweenLongDiffs] input diffs: ${JSON.stringify(sequenceDiffs.map(d => d.toString()))}`);
-    let diffs = sequenceDiffs;
-    if (diffs.length === 0) {
-        return diffs;
-    }
-    let counter = 0;
-    let shouldRepeat;
-    do {
-        shouldRepeat = false;
-        const result = [diffs[0]];
-        for (let i = 1; i < diffs.length; i++) {
-            const cur = diffs[i];
-            const lastResult = result[result.length - 1];
-            function shouldJoinDiffs(before, after) {
-                const unchangedRange = new OffsetRange(lastResult.seq1Range.endExclusive, cur.seq1Range.start);
-                const unchangedLineCount = sequence1.countLinesIn(unchangedRange);
-                if (unchangedLineCount > 5 || unchangedRange.length > 500) {
-                    return false;
-                }
-                const unchangedText = sequence1.getText(unchangedRange).trim();
-                if (unchangedText.length > 20 || unchangedText.split(/\r\n|\r|\n/).length > 1) {
-                    return false;
-                }
-                const beforeLineCount1 = sequence1.countLinesIn(before.seq1Range);
-                const beforeSeq1Length = before.seq1Range.length;
-                const beforeLineCount2 = sequence2.countLinesIn(before.seq2Range);
-                const beforeSeq2Length = before.seq2Range.length;
-                const afterLineCount1 = sequence1.countLinesIn(after.seq1Range);
-                const afterSeq1Length = after.seq1Range.length;
-                const afterLineCount2 = sequence2.countLinesIn(after.seq2Range);
-                const afterSeq2Length = after.seq2Range.length;
-                const max = 2 * 40 + 50;
-                function cap(v) {
-                    return Math.min(v, max);
-                }
-                if (Math.pow(Math.pow(cap(beforeLineCount1 * 40 + beforeSeq1Length), 1.5) + Math.pow(cap(beforeLineCount2 * 40 + beforeSeq2Length), 1.5), 1.5)
-                    + 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) {
-                    return true;
-                }
-                return false;
-            }
-            const shouldJoin = shouldJoinDiffs(lastResult, cur);
-            if (shouldJoin) {
-                shouldRepeat = true;
-                result[result.length - 1] = result[result.length - 1].join(cur);
-            }
-            else {
-                result.push(cur);
-            }
-        }
-        diffs = result;
-    } while (counter++ < 10 && shouldRepeat);
-    log(`[removeVeryShortMatchingTextBetweenLongDiffs] after join loop, diffs: ${JSON.stringify(diffs.map(d => d.toString()))}`);
-    const newDiffs = [];
-    // Remove short suffixes/prefixes
-    forEachWithNeighbors(diffs, (prev, cur, next) => {
-        log(`[forEachWithNeighbors] cur: ${cur.toString()}, prev: ${prev?.toString()}, next: ${next?.toString()}`);
-        let newDiff = cur;
-        function shouldMarkAsChanged(text) {
-            return text.length > 0 && text.trim().length <= 3 && cur.seq1Range.length + cur.seq2Range.length > 100;
-        }
-        const fullRange1 = sequence1.extendToFullLines(cur.seq1Range);
-        log(`[fullRange1] ${fullRange1.toString()} for cur.seq1Range: ${cur.seq1Range.toString()}`);
-        const prefix = sequence1.getText(new OffsetRange(fullRange1.start, cur.seq1Range.start));
-        log(`[prefix] "${prefix}" len=${prefix.length}, shouldMark=${prefix.length > 0 && prefix.trim().length <= 3 && cur.seq1Range.length + cur.seq2Range.length > 100}`);
-        if (shouldMarkAsChanged(prefix)) {
-            log(`[deltaStart] before: ${newDiff.toString()}, delta: ${-prefix.length}`);
-            newDiff = newDiff.deltaStart(-prefix.length);
-            log(`[deltaStart] after: ${newDiff.toString()}`);
-        }
-        const suffix = sequence1.getText(new OffsetRange(cur.seq1Range.endExclusive, fullRange1.endExclusive));
-        log(`[suffix] "${suffix}" len=${suffix.length}, shouldMark=${suffix.length > 0 && suffix.trim().length <= 3 && cur.seq1Range.length + cur.seq2Range.length > 100}`);
-        if (shouldMarkAsChanged(suffix)) {
-            log(`[deltaEnd] before: ${newDiff.toString()}, delta: ${suffix.length}`);
-            newDiff = newDiff.deltaEnd(suffix.length);
-            log(`[deltaEnd] after: ${newDiff.toString()}`);
-        }
-        const availableSpace = SequenceDiff.fromOffsetPairs(prev ? prev.getEndExclusives() : OffsetPair.zero, next ? next.getStarts() : OffsetPair.max);
-        log(`[availableSpace] ${availableSpace.toString()}, newDiff before intersect: ${newDiff.toString()}`);
-        const intersected = newDiff.intersect(availableSpace);
-        log(`[intersected] ${intersected?.toString()}`);
-        if (newDiffs.length > 0 && intersected.getStarts().equals(newDiffs[newDiffs.length - 1].getEndExclusives())) {
-            newDiffs[newDiffs.length - 1] = newDiffs[newDiffs.length - 1].join(intersected);
-        }
-        else {
-            newDiffs.push(intersected);
-        }
-    });
-    return newDiffs;
-}
-function forEachWithNeighbors(items, callback) {
-    for (let i = 0; i < items.length; i++) {
-        callback(items[i - 1], items[i], items[i + 1]);
-    }
-}
-
-const CharCode$1 = {
-    Space: 32,
-    Tab: 9,
-};
-class LineSequence {
-    trimmedHash;
-    lines;
-    constructor(trimmedHash, lines) {
-        this.trimmedHash = trimmedHash;
-        this.lines = lines;
-    }
-    getElement(offset) {
-        return this.trimmedHash[offset];
-    }
-    get length() {
-        return this.trimmedHash.length;
-    }
-    getBoundaryScore(length) {
-        const indentationBefore = length === 0 ? 0 : getIndentation(this.lines[length - 1]);
-        const indentationAfter = length === this.lines.length ? 0 : getIndentation(this.lines[length]);
-        return 1000 - (indentationBefore + indentationAfter);
-    }
-    getText(range) {
-        return this.lines.slice(range.start, range.endExclusive).join('\n');
-    }
-    isStronglyEqual(offset1, offset2) {
-        return this.lines[offset1] === this.lines[offset2];
-    }
-}
-function getIndentation(str) {
-    let i = 0;
-    while (i < str.length && (str.charCodeAt(i) === CharCode$1.Space || str.charCodeAt(i) === CharCode$1.Tab)) {
-        i++;
-    }
-    return i;
-}
-
-const CharCode = {
-    LineFeed: 10,
-    CarriageReturn: 13,
-    Space: 32,
-    Tab: 9,
-    a: 97,
-    z: 122,
-    A: 65,
-    Z: 90,
-    Digit0: 48,
-    Digit9: 57,
-    Comma: 44,
-    Semicolon: 59,
-};
-function isSpace(charCode) {
-    return charCode === CharCode.Space || charCode === CharCode.Tab;
-}
-class Range {
-    startLineNumber;
-    startColumn;
-    endLineNumber;
-    endColumn;
-    constructor(startLineNumber, startColumn, endLineNumber, endColumn) {
-        this.startLineNumber = startLineNumber;
-        this.startColumn = startColumn;
-        this.endLineNumber = endLineNumber;
-        this.endColumn = endColumn;
-    }
-    static fromPositions(start, end) {
-        return new Range(start.lineNumber, start.column, end.lineNumber, end.column);
-    }
-}
-class Position {
-    lineNumber;
-    column;
-    constructor(lineNumber, column) {
-        this.lineNumber = lineNumber;
-        this.column = column;
-    }
-    isBefore(other) {
-        if (this.lineNumber < other.lineNumber) {
-            return true;
-        }
-        if (other.lineNumber < this.lineNumber) {
-            return false;
-        }
-        return this.column < other.column;
-    }
-}
-class LinesSliceCharSequence {
-    lines;
-    considerWhitespaceChanges;
-    elements = [];
-    firstElementOffsetByLineIdx = [];
-    lineStartOffsets = [];
-    trimmedWsLengthsByLineIdx = [];
-    _range;
-    constructor(lines, range, considerWhitespaceChanges) {
-        this.lines = lines;
-        this.considerWhitespaceChanges = considerWhitespaceChanges;
-        this._range = range;
-        this.firstElementOffsetByLineIdx.push(0);
-        for (let lineNumber = this._range.startLineNumber; lineNumber <= this._range.endLineNumber; lineNumber++) {
-            let line = lines[lineNumber - 1];
-            let lineStartOffset = 0;
-            if (lineNumber === this._range.startLineNumber && this._range.startColumn > 1) {
-                lineStartOffset = this._range.startColumn - 1;
-                line = line.substring(lineStartOffset);
-            }
-            this.lineStartOffsets.push(lineStartOffset);
-            let trimmedWsLength = 0;
-            if (!considerWhitespaceChanges) {
-                const trimmedStartLine = line.trimStart();
-                trimmedWsLength = line.length - trimmedStartLine.length;
-                line = trimmedStartLine.trimEnd();
-            }
-            this.trimmedWsLengthsByLineIdx.push(trimmedWsLength);
-            const lineLength = lineNumber === this._range.endLineNumber ? Math.min(this._range.endColumn - 1 - lineStartOffset - trimmedWsLength, line.length) : line.length;
-            for (let i = 0; i < lineLength; i++) {
-                this.elements.push(line.charCodeAt(i));
-            }
-            if (lineNumber < this._range.endLineNumber) {
-                this.elements.push('\n'.charCodeAt(0));
-                this.firstElementOffsetByLineIdx.push(this.elements.length);
-            }
-        }
-    }
-    toString() {
-        return `Slice: "${this.text}"`;
-    }
-    get text() {
-        return this.getText(new OffsetRange(0, this.length));
-    }
-    getText(range) {
-        return this.elements.slice(range.start, range.endExclusive).map(e => String.fromCharCode(e)).join('');
-    }
-    getElement(offset) {
-        return this.elements[offset];
-    }
-    get length() {
-        return this.elements.length;
-    }
-    getBoundaryScore(length) {
-        const prevCategory = getCategory(length > 0 ? this.elements[length - 1] : -1);
-        const nextCategory = getCategory(length < this.elements.length ? this.elements[length] : -1);
-        if (prevCategory === 7 /* CharBoundaryCategory.LineBreakCR */ && nextCategory === 8 /* CharBoundaryCategory.LineBreakLF */) {
-            // don't break between \r and \n
-            return 0;
-        }
-        if (prevCategory === 8 /* CharBoundaryCategory.LineBreakLF */) {
-            // prefer the linebreak before the change
-            return 150;
-        }
-        let score = 0;
-        if (prevCategory !== nextCategory) {
-            score += 10;
-            if (prevCategory === 0 /* CharBoundaryCategory.WordLower */ && nextCategory === 1 /* CharBoundaryCategory.WordUpper */) {
-                score += 1;
-            }
-        }
-        score += getCategoryBoundaryScore(prevCategory);
-        score += getCategoryBoundaryScore(nextCategory);
-        return score;
-    }
-    translateOffset(offset, preference = 'right') {
-        const i = findLastIdxMonotonous(this.firstElementOffsetByLineIdx, (value) => value <= offset);
-        const lineOffset = offset - this.firstElementOffsetByLineIdx[i];
-        return new Position(this._range.startLineNumber + i, 1 + this.lineStartOffsets[i] + lineOffset + ((lineOffset === 0 && preference === 'left') ? 0 : this.trimmedWsLengthsByLineIdx[i]));
-    }
-    translateRange(range) {
-        const pos1 = this.translateOffset(range.start, 'right');
-        const pos2 = this.translateOffset(range.endExclusive, 'left');
-        if (pos2.isBefore(pos1)) {
-            return Range.fromPositions(pos2, pos2);
-        }
-        return Range.fromPositions(pos1, pos2);
-    }
-    /**
-     * Finds the word that contains the character at the given offset
-     */
-    findWordContaining(offset) {
-        if (offset < 0 || offset >= this.elements.length) {
-            return undefined;
-        }
-        if (!isWordChar(this.elements[offset])) {
-            return undefined;
-        }
-        // find start
-        let start = offset;
-        while (start > 0 && isWordChar(this.elements[start - 1])) {
-            start--;
-        }
-        // find end
-        let end = offset;
-        while (end < this.elements.length && isWordChar(this.elements[end])) {
-            end++;
-        }
-        return new OffsetRange(start, end);
-    }
-    /** fooBar has the two sub-words foo and bar */
-    findSubWordContaining(offset) {
-        if (offset < 0 || offset >= this.elements.length) {
-            return undefined;
-        }
-        if (!isWordChar(this.elements[offset])) {
-            return undefined;
-        }
-        // find start
-        let start = offset;
-        while (start > 0 && isWordChar(this.elements[start - 1]) && !isUpperCase(this.elements[start])) {
-            start--;
-        }
-        // find end
-        let end = offset;
-        while (end < this.elements.length && isWordChar(this.elements[end]) && !isUpperCase(this.elements[end])) {
-            end++;
-        }
-        return new OffsetRange(start, end);
-    }
-    countLinesIn(range) {
-        return this.translateOffset(range.endExclusive).lineNumber - this.translateOffset(range.start).lineNumber;
-    }
-    isStronglyEqual(offset1, offset2) {
-        return this.elements[offset1] === this.elements[offset2];
-    }
-    extendToFullLines(range) {
-        const start = findLastMonotonous(this.firstElementOffsetByLineIdx, x => x <= range.start) ?? 0;
-        const end = findFirstMonotonous(this.firstElementOffsetByLineIdx, x => range.endExclusive <= x) ?? this.elements.length;
-        return new OffsetRange(start, end);
-    }
-}
-function isWordChar(charCode) {
-    return charCode >= CharCode.a && charCode <= CharCode.z
-        || charCode >= CharCode.A && charCode <= CharCode.Z
-        || charCode >= CharCode.Digit0 && charCode <= CharCode.Digit9;
-}
-function isUpperCase(charCode) {
-    return charCode >= CharCode.A && charCode <= CharCode.Z;
-}
-const categoryScore = {
-    [0 /* CharBoundaryCategory.WordLower */]: 0,
-    [1 /* CharBoundaryCategory.WordUpper */]: 0,
-    [2 /* CharBoundaryCategory.WordNumber */]: 0,
-    [3 /* CharBoundaryCategory.End */]: 10,
-    [4 /* CharBoundaryCategory.Other */]: 2,
-    [5 /* CharBoundaryCategory.Separator */]: 30,
-    [6 /* CharBoundaryCategory.Space */]: 3,
-    [7 /* CharBoundaryCategory.LineBreakCR */]: 10,
-    [8 /* CharBoundaryCategory.LineBreakLF */]: 10,
-};
-function getCategoryBoundaryScore(category) {
-    return categoryScore[category];
-}
-function getCategory(charCode) {
-    if (charCode === CharCode.LineFeed) {
-        return 8 /* CharBoundaryCategory.LineBreakLF */;
-    }
-    else if (charCode === CharCode.CarriageReturn) {
-        return 7 /* CharBoundaryCategory.LineBreakCR */;
-    }
-    else if (isSpace(charCode)) {
-        return 6 /* CharBoundaryCategory.Space */;
-    }
-    else if (charCode >= CharCode.a && charCode <= CharCode.z) {
-        return 0 /* CharBoundaryCategory.WordLower */;
-    }
-    else if (charCode >= CharCode.A && charCode <= CharCode.Z) {
-        return 1 /* CharBoundaryCategory.WordUpper */;
-    }
-    else if (charCode >= CharCode.Digit0 && charCode <= CharCode.Digit9) {
-        return 2 /* CharBoundaryCategory.WordNumber */;
-    }
-    else if (charCode === -1) {
-        return 3 /* CharBoundaryCategory.End */;
-    }
-    else if (charCode === CharCode.Comma || charCode === CharCode.Semicolon) {
-        return 5 /* CharBoundaryCategory.Separator */;
-    }
-    else {
-        return 4 /* CharBoundaryCategory.Other */;
-    }
-}
-// Binary search helpers
-function findLastIdxMonotonous(array, predicate) {
-    let low = 0;
-    let high = array.length - 1;
-    while (low <= high) {
-        const mid = Math.floor((low + high) / 2);
-        if (predicate(array[mid])) {
-            low = mid + 1;
-        }
-        else {
-            high = mid - 1;
-        }
-    }
-    return high;
-}
-function findLastMonotonous(array, predicate) {
-    const idx = findLastIdxMonotonous(array, predicate);
-    return idx >= 0 ? array[idx] : undefined;
-}
-function findFirstMonotonous(array, predicate) {
-    let low = 0;
-    let high = array.length - 1;
-    while (low <= high) {
-        const mid = Math.floor((low + high) / 2);
-        if (predicate(array[mid])) {
-            high = mid - 1;
-        }
-        else {
-            low = mid + 1;
-        }
-    }
-    return low < array.length ? array[low] : undefined;
-}
-
-/**
- * A range of lines (1-based, end is exclusive).
- */
-class LineRange {
-    startLineNumber;
-    endLineNumberExclusive;
-    constructor(startLineNumber, endLineNumberExclusive) {
-        this.startLineNumber = startLineNumber;
-        this.endLineNumberExclusive = endLineNumberExclusive;
-        if (startLineNumber > endLineNumberExclusive) {
-            throw new Error(`Invalid range: ${startLineNumber} > ${endLineNumberExclusive}`);
-        }
-    }
-    get isEmpty() {
-        return this.startLineNumber === this.endLineNumberExclusive;
-    }
-    get length() {
-        return this.endLineNumberExclusive - this.startLineNumber;
-    }
-    join(other) {
-        return new LineRange(Math.min(this.startLineNumber, other.startLineNumber), Math.max(this.endLineNumberExclusive, other.endLineNumberExclusive));
-    }
-    intersectsOrTouches(other) {
-        return this.startLineNumber <= other.endLineNumberExclusive
-            && other.startLineNumber <= this.endLineNumberExclusive;
-    }
-    toOffsetRange() {
-        return new OffsetRange(this.startLineNumber - 1, this.endLineNumberExclusive - 1);
-    }
-    toString() {
-        return `[${this.startLineNumber}, ${this.endLineNumberExclusive})`;
-    }
-}
-/**
- * A mapping between two ranges.
- */
-class RangeMapping {
-    originalRange;
-    modifiedRange;
-    constructor(originalRange, modifiedRange) {
-        this.originalRange = originalRange;
-        this.modifiedRange = modifiedRange;
-    }
-    toString() {
-        return `${rangeToString(this.originalRange)} <-> ${rangeToString(this.modifiedRange)}`;
-    }
-    static assertSorted(rangeMappings) {
-        for (let i = 1; i < rangeMappings.length; i++) {
-            const prev = rangeMappings[i - 1];
-            const cur = rangeMappings[i];
-            if (!(prev.originalRange.endLineNumber <= cur.originalRange.startLineNumber ||
-                (prev.originalRange.endLineNumber === cur.originalRange.startLineNumber && prev.originalRange.endColumn <= cur.originalRange.startColumn))) {
-                throw new Error('RangeMappings must be sorted');
-            }
-        }
-    }
-}
-function rangeToString(range) {
-    return `(${range.startLineNumber}:${range.startColumn})-(${range.endLineNumber}:${range.endColumn})`;
-}
-/**
- * A mapping between two line ranges.
- */
-class LineRangeMapping {
-    original;
-    modified;
-    constructor(original, modified) {
-        this.original = original;
-        this.modified = modified;
-    }
-    toString() {
-        return `${this.original} <-> ${this.modified}`;
-    }
-    /**
-     * This method assumes that the LineRangeMapping describes a valid diff!
-     * I.e. if one range is empty, the other range cannot be the entire document.
-     * It avoids various problems when the line range points to non-existing line-numbers.
-    */
-    toRangeMapping2(originalLines, modifiedLines) {
-        const isValidLineNumber = (lineNumber, lines) => {
-            return lineNumber >= 1 && lineNumber <= lines.length;
-        };
-        const normalizePosition = (lineNumber, column, lines) => {
-            if (lineNumber < 1) {
-                return new Position(1, 1);
-            }
-            if (lineNumber > lines.length) {
-                return new Position(lines.length, lines[lines.length - 1].length + 1);
-            }
-            const line = lines[lineNumber - 1];
-            if (column > line.length + 1) {
-                return new Position(lineNumber, line.length + 1);
-            }
-            return new Position(lineNumber, column);
-        };
-        if (isValidLineNumber(this.original.endLineNumberExclusive, originalLines)
-            && isValidLineNumber(this.modified.endLineNumberExclusive, modifiedLines)) {
-            return new RangeMapping(new Range(this.original.startLineNumber, 1, this.original.endLineNumberExclusive, 1), new Range(this.modified.startLineNumber, 1, this.modified.endLineNumberExclusive, 1));
-        }
-        if (!this.original.isEmpty && !this.modified.isEmpty) {
-            return new RangeMapping(Range.fromPositions(new Position(this.original.startLineNumber, 1), normalizePosition(this.original.endLineNumberExclusive - 1, Number.MAX_SAFE_INTEGER, originalLines)), Range.fromPositions(new Position(this.modified.startLineNumber, 1), normalizePosition(this.modified.endLineNumberExclusive - 1, Number.MAX_SAFE_INTEGER, modifiedLines)));
-        }
-        if (this.original.startLineNumber > 1 && this.modified.startLineNumber > 1) {
-            return new RangeMapping(Range.fromPositions(normalizePosition(this.original.startLineNumber - 1, Number.MAX_SAFE_INTEGER, originalLines), normalizePosition(this.original.endLineNumberExclusive - 1, Number.MAX_SAFE_INTEGER, originalLines)), Range.fromPositions(normalizePosition(this.modified.startLineNumber - 1, Number.MAX_SAFE_INTEGER, modifiedLines), normalizePosition(this.modified.endLineNumberExclusive - 1, Number.MAX_SAFE_INTEGER, modifiedLines)));
-        }
-        // Situation now: one range is empty and one range touches the last line and one range starts at line 1.
-        // This shouldn't happen for valid diffs.
-        throw new Error('Invalid diff: cannot convert to range mapping');
-    }
-}
-/**
- * A detailed mapping between two line ranges, including inner changes.
- */
-class DetailedLineRangeMapping extends LineRangeMapping {
-    innerChanges;
-    constructor(original, modified, innerChanges) {
-        super(original, modified);
-        this.innerChanges = innerChanges;
-    }
-}
-/**
- * Result of a lines diff computation.
- */
-class LinesDiff {
-    changes;
-    moves;
-    hitTimeout;
-    constructor(changes, moves, hitTimeout) {
-        this.changes = changes;
-        this.moves = moves;
-        this.hitTimeout = hitTimeout;
-    }
-}
-/**
- * Helper to convert from range mappings to line range mappings.
- */
-function lineRangeMappingFromRangeMappings(alignments, originalLines, modifiedLines, dontAssertStartLine = false) {
-    const changes = [];
-    for (const g of groupAdjacentBy(alignments.map(a => getLineRangeMapping(a, originalLines, modifiedLines)), (a1, a2) => a1.original.intersectsOrTouches(a2.original)
-        || a1.modified.intersectsOrTouches(a2.modified))) {
-        const first = g[0];
-        const last = g[g.length - 1];
-        changes.push(new DetailedLineRangeMapping(first.original.join(last.original), first.modified.join(last.modified), g.map(a => a.innerChanges[0])));
-    }
-    if (!dontAssertStartLine) {
-        // Assert that the changes are sorted and non-overlapping (but don't throw - just log in debug)
-        for (let i = 1; i < changes.length; i++) {
-            const prev = changes[i - 1];
-            const cur = changes[i];
-            if (prev.original.endLineNumberExclusive > cur.original.startLineNumber ||
-                prev.modified.endLineNumberExclusive > cur.modified.startLineNumber) {
-                // Silently skip validation issue - may be expected in some edge cases
-                break;
-            }
-        }
-    }
-    return changes;
-}
-function getLineRangeMapping(rangeMapping, originalLines, modifiedLines) {
-    let lineStartDelta = 0;
-    let lineEndDelta = 0;
-    // rangeMapping describes the edit that replaces `rangeMapping.originalRange` with `newText := getText(modifiedLines, rangeMapping.modifiedRange)`.
-    // original: ]xxx \n <- this line is not modified
-    // modified: ]xx  \n
-    if (rangeMapping.modifiedRange.endColumn === 1 && rangeMapping.originalRange.endColumn === 1
-        && rangeMapping.originalRange.startLineNumber + lineStartDelta <= rangeMapping.originalRange.endLineNumber
-        && rangeMapping.modifiedRange.startLineNumber + lineStartDelta <= rangeMapping.modifiedRange.endLineNumber) {
-        // We can only do this if the range is not empty yet
-        lineEndDelta = -1;
-    }
-    // original: xxx[ \n <- this line is not modified
-    // modified: xxx[ \n
-    if (rangeMapping.modifiedRange.startColumn - 1 >= (modifiedLines[rangeMapping.modifiedRange.startLineNumber - 1]?.length ?? 0)
-        && rangeMapping.originalRange.startColumn - 1 >= (originalLines[rangeMapping.originalRange.startLineNumber - 1]?.length ?? 0)
-        && rangeMapping.originalRange.startLineNumber <= rangeMapping.originalRange.endLineNumber + lineEndDelta
-        && rangeMapping.modifiedRange.startLineNumber <= rangeMapping.modifiedRange.endLineNumber + lineEndDelta) {
-        // We can only do this if the range is not empty yet
-        lineStartDelta = 1;
-    }
-    const originalLineRange = new LineRange(rangeMapping.originalRange.startLineNumber + lineStartDelta, rangeMapping.originalRange.endLineNumber + 1 + lineEndDelta);
-    const modifiedLineRange = new LineRange(rangeMapping.modifiedRange.startLineNumber + lineStartDelta, rangeMapping.modifiedRange.endLineNumber + 1 + lineEndDelta);
-    return new DetailedLineRangeMapping(originalLineRange, modifiedLineRange, [rangeMapping]);
-}
-function* groupAdjacentBy(items, shouldBeGrouped) {
-    let currentGroup;
-    let last;
-    for (const item of items) {
-        if (last !== undefined && shouldBeGrouped(last, item)) {
-            currentGroup.push(item);
-        }
-        else {
-            if (currentGroup) {
-                yield currentGroup;
-            }
-            currentGroup = [item];
-        }
-        last = item;
-    }
-    if (currentGroup) {
-        yield currentGroup;
-    }
-}
-class ArrayText {
-    lines;
-    constructor(lines) {
-        this.lines = lines;
-    }
-    get lineCount() {
-        return this.lines.length;
-    }
-    getLineContent(lineNumber) {
-        return this.lines[lineNumber - 1];
-    }
-}
-
-/**
- * The main diff computer that computes detailed line diffs.
- */
-class DefaultLinesDiffComputer {
-    _dynamicProgrammingDiffing = new DynamicProgrammingDiffing();
-    _myersDiffingAlgorithm = new MyersDiffAlgorithm();
-    computeDiff(originalLines, modifiedLines, options) {
-        // Handle identical single line
-        if (originalLines.length <= 1 && arraysEqual(originalLines, modifiedLines)) {
-            return new LinesDiff([], [], false);
-        }
-        // Handle empty single line - treat as full replacement
-        if (originalLines.length === 1 && originalLines[0].length === 0 || modifiedLines.length === 1 && modifiedLines[0].length === 0) {
-            return new LinesDiff([
-                new DetailedLineRangeMapping(new LineRange(1, originalLines.length + 1), new LineRange(1, modifiedLines.length + 1), [
-                    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))
-                ])
-            ], [], false);
-        }
-        const timeout = options.maxComputationTimeMs === 0 ? InfiniteTimeout.instance : new DateTimeout(options.maxComputationTimeMs);
-        const considerWhitespaceChanges = !options.ignoreTrimWhitespace;
-        // Create perfect hash for lines (trimmed)
-        const perfectHashes = new Map();
-        function getOrCreateHash(text) {
-            let hash = perfectHashes.get(text);
-            if (hash === undefined) {
-                hash = perfectHashes.size;
-                perfectHashes.set(text, hash);
-            }
-            return hash;
-        }
-        const originalLinesHashes = originalLines.map((l) => getOrCreateHash(l.trim()));
-        const modifiedLinesHashes = modifiedLines.map((l) => getOrCreateHash(l.trim()));
-        const sequence1 = new LineSequence(originalLinesHashes, originalLines);
-        const sequence2 = new LineSequence(modifiedLinesHashes, modifiedLines);
-        // Choose algorithm based on size
-        const lineAlignmentResult = (() => {
-            if (sequence1.length + sequence2.length < 1700) {
-                // Use the improved algorithm for small files
-                return this._dynamicProgrammingDiffing.compute(sequence1, sequence2, timeout, (offset1, offset2) => originalLines[offset1] === modifiedLines[offset2]
-                    ? modifiedLines[offset2].length === 0
-                        ? 0.1
-                        : 1 + Math.log(1 + modifiedLines[offset2].length)
-                    : 0.99);
-            }
-            return this._myersDiffingAlgorithm.compute(sequence1, sequence2, timeout);
-        })();
-        let lineAlignments = lineAlignmentResult.diffs;
-        let hitTimeout = lineAlignmentResult.hitTimeout;
-        // Apply heuristics
-        lineAlignments = optimizeSequenceDiffs(sequence1, sequence2, lineAlignments);
-        lineAlignments = removeVeryShortMatchingLinesBetweenDiffs(sequence1, sequence2, lineAlignments);
-        const alignments = [];
-        const scanForWhitespaceChanges = (equalLinesCount) => {
-            if (!considerWhitespaceChanges) {
-                return;
-            }
-            for (let i = 0; i < equalLinesCount; i++) {
-                const seq1Offset = seq1LastStart + i;
-                const seq2Offset = seq2LastStart + i;
-                if (originalLines[seq1Offset] !== modifiedLines[seq2Offset]) {
-                    // This is because of whitespace changes, diff these lines
-                    const characterDiffs = this._refineDiff(originalLines, modifiedLines, new SequenceDiff(new OffsetRange(seq1Offset, seq1Offset + 1), new OffsetRange(seq2Offset, seq2Offset + 1)), timeout, considerWhitespaceChanges, options);
-                    for (const a of characterDiffs.mappings) {
-                        alignments.push(a);
-                    }
-                    if (characterDiffs.hitTimeout) {
-                        hitTimeout = true;
-                    }
-                }
-            }
-        };
-        let seq1LastStart = 0;
-        let seq2LastStart = 0;
-        for (const diff of lineAlignments) {
-            const equalLinesCount = diff.seq1Range.start - seq1LastStart;
-            scanForWhitespaceChanges(equalLinesCount);
-            seq1LastStart = diff.seq1Range.endExclusive;
-            seq2LastStart = diff.seq2Range.endExclusive;
-            const characterDiffs = this._refineDiff(originalLines, modifiedLines, diff, timeout, considerWhitespaceChanges, options);
-            if (characterDiffs.hitTimeout) {
-                hitTimeout = true;
-            }
-            for (const a of characterDiffs.mappings) {
-                alignments.push(a);
-            }
-        }
-        scanForWhitespaceChanges(originalLines.length - seq1LastStart);
-        const original = new ArrayText(originalLines);
-        const modified = new ArrayText(modifiedLines);
-        const changes = lineRangeMappingFromRangeMappings(alignments, original.lines, modified.lines);
-        // TODO: Compute moves if options.computeMoves is true
-        const moves = [];
-        return new LinesDiff(changes, moves, hitTimeout);
-    }
-    _refineDiff(originalLines, modifiedLines, diff, timeout, considerWhitespaceChanges, options) {
-        const lineRangeMapping = toLineRangeMapping(diff);
-        const rangeMapping = lineRangeMapping.toRangeMapping2(originalLines, modifiedLines);
-        const slice1 = new LinesSliceCharSequence(originalLines, rangeMapping.originalRange, considerWhitespaceChanges);
-        const slice2 = new LinesSliceCharSequence(modifiedLines, rangeMapping.modifiedRange, considerWhitespaceChanges);
-        const diffResult = slice1.length + slice2.length < 500
-            ? this._dynamicProgrammingDiffing.compute(slice1, slice2, timeout)
-            : this._myersDiffingAlgorithm.compute(slice1, slice2, timeout);
-        let diffs = diffResult.diffs;
-        diffs = optimizeSequenceDiffs(slice1, slice2, diffs);
-        diffs = extendDiffsToEntireWordIfAppropriate(slice1, slice2, diffs, (seq, idx) => seq.findWordContaining(idx));
-        if (options.extendToSubwords) {
-            diffs = extendDiffsToEntireWordIfAppropriate(slice1, slice2, diffs, (seq, idx) => seq.findSubWordContaining(idx), true);
-        }
-        diffs = removeShortMatches(slice1, slice2, diffs);
-        diffs = removeVeryShortMatchingTextBetweenLongDiffs(slice1, slice2, diffs);
-        const result = diffs.map((d) => new RangeMapping(slice1.translateRange(d.seq1Range), slice2.translateRange(d.seq2Range)));
-        return {
-            mappings: result,
-            hitTimeout: diffResult.hitTimeout,
-        };
-    }
-}
-function toLineRangeMapping(sequenceDiff) {
-    return new LineRangeMapping(new LineRange(sequenceDiff.seq1Range.start + 1, sequenceDiff.seq1Range.endExclusive + 1), new LineRange(sequenceDiff.seq2Range.start + 1, sequenceDiff.seq2Range.endExclusive + 1));
-}
-function arraysEqual(a, b) {
-    if (a.length !== b.length) {
-        return false;
-    }
-    for (let i = 0; i < a.length; i++) {
-        if (a[i] !== b[i]) {
-            return false;
-        }
-    }
-    return true;
-}
-
-/* @ts-self-types="./diff_wasm.d.ts" */
-
-/**
- * Compute a diff between two texts.
- *
- * # Arguments
- * * `original` - The original text (lines separated by newlines)
- * * `modified` - The modified text (lines separated by newlines)
- * * `options` - Optional diff options (as a JavaScript object)
- *
- * # Returns
- * A `WasmLinesDiff` object containing the changes.
- * @param {string} original
- * @param {string} modified
- * @param {any} options
- * @returns {any}
- */
-function computeDiff(original, modified, options) {
-    const ptr0 = passStringToWasm0(original, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passStringToWasm0(modified, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.computeDiff(ptr0, len0, ptr1, len1, options);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
-}
-
-/**
- * Compute a diff between two arrays of lines.
- *
- * # Arguments
- * * `original_lines` - The original lines (as a JavaScript array of strings)
- * * `modified_lines` - The modified lines (as a JavaScript array of strings)
- * * `options` - Optional diff options (as a JavaScript object)
- *
- * # Returns
- * A `WasmLinesDiff` object containing the changes.
- * @param {any} original_lines
- * @param {any} modified_lines
- * @param {any} options
- * @returns {any}
- */
-function computeDiffLines(original_lines, modified_lines, options) {
-    const ret = wasm.computeDiffLines(original_lines, modified_lines, options);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
-}
-
-/**
- * Initialize panic hook for better error messages in the browser console.
- */
-function init() {
-    wasm.init();
-}
-function __wbg_get_imports() {
-    const import0 = {
-        __proto__: null,
-        __wbg_Error_bce6d499ff0a4aff: function(arg0, arg1) {
-            const ret = Error(getStringFromWasm0(arg0, arg1));
-            return ret;
-        },
-        __wbg_Number_b7972a139bfbfdf0: function(arg0) {
-            const ret = Number(arg0);
-            return ret;
-        },
-        __wbg_String_8564e559799eccda: function(arg0, arg1) {
-            const ret = String(arg1);
-            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len1 = WASM_VECTOR_LEN;
-            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-        },
-        __wbg___wbindgen_bigint_get_as_i64_410e28c7b761ad83: function(arg0, arg1) {
-            const v = arg1;
-            const ret = typeof(v) === 'bigint' ? v : undefined;
-            getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
-            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
-        },
-        __wbg___wbindgen_boolean_get_2304fb8c853028c8: function(arg0) {
-            const v = arg0;
-            const ret = typeof(v) === 'boolean' ? v : undefined;
-            return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
-        },
-        __wbg___wbindgen_debug_string_edece8177ad01481: function(arg0, arg1) {
-            const ret = debugString(arg1);
-            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len1 = WASM_VECTOR_LEN;
-            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-        },
-        __wbg___wbindgen_in_07056af4f902c445: function(arg0, arg1) {
-            const ret = arg0 in arg1;
-            return ret;
-        },
-        __wbg___wbindgen_is_bigint_aeae3893f30ed54e: function(arg0) {
-            const ret = typeof(arg0) === 'bigint';
-            return ret;
-        },
-        __wbg___wbindgen_is_function_5cd60d5cf78b4eef: function(arg0) {
-            const ret = typeof(arg0) === 'function';
-            return ret;
-        },
-        __wbg___wbindgen_is_null_2042690d351e14f0: function(arg0) {
-            const ret = arg0 === null;
-            return ret;
-        },
-        __wbg___wbindgen_is_object_b4593df85baada48: function(arg0) {
-            const val = arg0;
-            const ret = typeof(val) === 'object' && val !== null;
-            return ret;
-        },
-        __wbg___wbindgen_is_undefined_35bb9f4c7fd651d5: function(arg0) {
-            const ret = arg0 === undefined;
-            return ret;
-        },
-        __wbg___wbindgen_jsval_eq_c0ed08b3e0f393b9: function(arg0, arg1) {
-            const ret = arg0 === arg1;
-            return ret;
-        },
-        __wbg___wbindgen_jsval_loose_eq_0ad77b7717db155c: function(arg0, arg1) {
-            const ret = arg0 == arg1;
-            return ret;
-        },
-        __wbg___wbindgen_number_get_f73a1244370fcc2c: function(arg0, arg1) {
-            const obj = arg1;
-            const ret = typeof(obj) === 'number' ? obj : undefined;
-            getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
-            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
-        },
-        __wbg___wbindgen_string_get_d109740c0d18f4d7: function(arg0, arg1) {
-            const obj = arg1;
-            const ret = typeof(obj) === 'string' ? obj : undefined;
-            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            var len1 = WASM_VECTOR_LEN;
-            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-        },
-        __wbg___wbindgen_throw_9c31b086c2b26051: function(arg0, arg1) {
-            throw new Error(getStringFromWasm0(arg0, arg1));
-        },
-        __wbg_call_13665d9f14390edc: function() { return handleError(function (arg0, arg1) {
-            const ret = arg0.call(arg1);
-            return ret;
-        }, arguments); },
-        __wbg_done_54b8da57023b7ed2: function(arg0) {
-            const ret = arg0.done;
-            return ret;
-        },
-        __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
-            let deferred0_0;
-            let deferred0_1;
-            try {
-                deferred0_0 = arg0;
-                deferred0_1 = arg1;
-                console.error(getStringFromWasm0(arg0, arg1));
-            } finally {
-                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
-            }
-        },
-        __wbg_get_3e9a707ab7d352eb: function() { return handleError(function (arg0, arg1) {
-            const ret = Reflect.get(arg0, arg1);
-            return ret;
-        }, arguments); },
-        __wbg_get_unchecked_1dfe6d05ad91d9b7: function(arg0, arg1) {
-            const ret = arg0[arg1 >>> 0];
-            return ret;
-        },
-        __wbg_get_with_ref_key_6412cf3094599694: function(arg0, arg1) {
-            const ret = arg0[arg1];
-            return ret;
-        },
-        __wbg_instanceof_ArrayBuffer_53db37b06f6b9afe: function(arg0) {
-            let result;
-            try {
-                result = arg0 instanceof ArrayBuffer;
-            } catch (_) {
-                result = false;
-            }
-            const ret = result;
-            return ret;
-        },
-        __wbg_instanceof_Uint8Array_abd07d4bd221d50b: function(arg0) {
-            let result;
-            try {
-                result = arg0 instanceof Uint8Array;
-            } catch (_) {
-                result = false;
-            }
-            const ret = result;
-            return ret;
-        },
-        __wbg_isArray_94898ed3aad6947b: function(arg0) {
-            const ret = Array.isArray(arg0);
-            return ret;
-        },
-        __wbg_isSafeInteger_01e964d144ad3a55: function(arg0) {
-            const ret = Number.isSafeInteger(arg0);
-            return ret;
-        },
-        __wbg_iterator_1441b47f341dc34f: function() {
-            const ret = Symbol.iterator;
-            return ret;
-        },
-        __wbg_length_2591a0f4f659a55c: function(arg0) {
-            const ret = arg0.length;
-            return ret;
-        },
-        __wbg_length_56fcd3e2b7e0299d: function(arg0) {
-            const ret = arg0.length;
-            return ret;
-        },
-        __wbg_new_02d162bc6cf02f60: function() {
-            const ret = new Object();
-            return ret;
-        },
-        __wbg_new_227d7c05414eb861: function() {
-            const ret = new Error();
-            return ret;
-        },
-        __wbg_new_310879b66b6e95e1: function() {
-            const ret = new Array();
-            return ret;
-        },
-        __wbg_new_7ddec6de44ff8f5d: function(arg0) {
-            const ret = new Uint8Array(arg0);
-            return ret;
-        },
-        __wbg_next_2a4e19f4f5083b0f: function(arg0) {
-            const ret = arg0.next;
-            return ret;
-        },
-        __wbg_next_6429a146bf756f93: function() { return handleError(function (arg0) {
-            const ret = arg0.next();
-            return ret;
-        }, arguments); },
-        __wbg_prototypesetcall_5f9bdc8d75e07276: function(arg0, arg1, arg2) {
-            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
-        },
-        __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
-            arg0[arg1] = arg2;
-        },
-        __wbg_set_78ea6a19f4818587: function(arg0, arg1, arg2) {
-            arg0[arg1 >>> 0] = arg2;
-        },
-        __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
-            const ret = arg1.stack;
-            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len1 = WASM_VECTOR_LEN;
-            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-        },
-        __wbg_value_9cc0518af87a489c: function(arg0) {
-            const ret = arg0.value;
-            return ret;
-        },
-        __wbindgen_cast_0000000000000001: function(arg0) {
-            // Cast intrinsic for `F64 -> Externref`.
-            const ret = arg0;
-            return ret;
-        },
-        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Ref(String) -> Externref`.
-            const ret = getStringFromWasm0(arg0, arg1);
-            return ret;
-        },
-        __wbindgen_cast_0000000000000003: function(arg0) {
-            // Cast intrinsic for `U64 -> Externref`.
-            const ret = BigInt.asUintN(64, arg0);
-            return ret;
-        },
-        __wbindgen_init_externref_table: function() {
-            const table = wasm.__wbindgen_externrefs;
-            const offset = table.grow(4);
-            table.set(0, undefined);
-            table.set(offset + 0, undefined);
-            table.set(offset + 1, null);
-            table.set(offset + 2, true);
-            table.set(offset + 3, false);
-        },
-    };
-    return {
-        __proto__: null,
-        "./diff_wasm_bg.js": import0,
-    };
-}
-
-function addToExternrefTable0(obj) {
-    const idx = wasm.__externref_table_alloc();
-    wasm.__wbindgen_externrefs.set(idx, obj);
-    return idx;
-}
-
-function debugString(val) {
-    // primitive types
-    const type = typeof val;
-    if (type == 'number' || type == 'boolean' || val == null) {
-        return  `${val}`;
     }
-    if (type == 'string') {
-        return `"${val}"`;
-    }
-    if (type == 'symbol') {
-        const description = val.description;
-        if (description == null) {
-            return 'Symbol';
-        } else {
-            return `Symbol(${description})`;
-        }
-    }
-    if (type == 'function') {
-        const name = val.name;
-        if (typeof name == 'string' && name.length > 0) {
-            return `Function(${name})`;
-        } else {
-            return 'Function';
-        }
-    }
-    // objects
-    if (Array.isArray(val)) {
-        const length = val.length;
-        let debug = '[';
-        if (length > 0) {
-            debug += debugString(val[0]);
-        }
-        for(let i = 1; i < length; i++) {
-            debug += ', ' + debugString(val[i]);
-        }
-        debug += ']';
-        return debug;
-    }
-    // Test for built-in
-    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
-    let className;
-    if (builtInMatches && builtInMatches.length > 1) {
-        className = builtInMatches[1];
-    } else {
-        // Failed to match the standard '[object ClassName]'
-        return toString.call(val);
-    }
-    if (className == 'Object') {
-        // we're a user defined class or Object
-        // JSON.stringify avoids problems with cycles, and is generally much
-        // easier than looping through ownProperties of `val`.
-        try {
-            return 'Object(' + JSON.stringify(val) + ')';
-        } catch (_) {
-            return 'Object';
-        }
-    }
-    // errors
-    if (val instanceof Error) {
-        return `${val.name}: ${val.message}\n${val.stack}`;
-    }
-    // TODO we could test for more things here, like `Set`s and `Map`s.
-    return className;
-}
-
-function getArrayU8FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
-}
-
-let cachedDataViewMemory0 = null;
-function getDataViewMemory0() {
-    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
-        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
-    }
-    return cachedDataViewMemory0;
-}
-
-function getStringFromWasm0(ptr, len) {
-    return decodeText(ptr >>> 0, len);
-}
-
-let cachedUint8ArrayMemory0 = null;
-function getUint8ArrayMemory0() {
-    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
-        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachedUint8ArrayMemory0;
-}
-
-function handleError(f, args) {
-    try {
-        return f.apply(this, args);
-    } catch (e) {
-        const idx = addToExternrefTable0(e);
-        wasm.__wbindgen_exn_store(idx);
-    }
-}
-
-function isLikeNone(x) {
-    return x === undefined || x === null;
-}
-
-function passStringToWasm0(arg, malloc, realloc) {
-    if (realloc === undefined) {
-        const buf = cachedTextEncoder.encode(arg);
-        const ptr = malloc(buf.length, 1) >>> 0;
-        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
-        WASM_VECTOR_LEN = buf.length;
-        return ptr;
-    }
-
-    let len = arg.length;
-    let ptr = malloc(len, 1) >>> 0;
-
-    const mem = getUint8ArrayMemory0();
-
-    let offset = 0;
-
-    for (; offset < len; offset++) {
-        const code = arg.charCodeAt(offset);
-        if (code > 0x7F) break;
-        mem[ptr + offset] = code;
-    }
-    if (offset !== len) {
-        if (offset !== 0) {
-            arg = arg.slice(offset);
-        }
-        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
-        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
-        const ret = cachedTextEncoder.encodeInto(arg, view);
-
-        offset += ret.written;
-        ptr = realloc(ptr, len, offset, 1) >>> 0;
-    }
-
-    WASM_VECTOR_LEN = offset;
-    return ptr;
-}
-
-function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_externrefs.get(idx);
-    wasm.__externref_table_dealloc(idx);
-    return value;
-}
-
-let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-cachedTextDecoder.decode();
-const MAX_SAFARI_DECODE_BYTES = 2146435072;
-let numBytesDecoded = 0;
-function decodeText(ptr, len) {
-    numBytesDecoded += len;
-    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
-        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-        cachedTextDecoder.decode();
-        numBytesDecoded = len;
-    }
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
-}
-
-const cachedTextEncoder = new TextEncoder();
-
-if (!('encodeInto' in cachedTextEncoder)) {
-    cachedTextEncoder.encodeInto = function (arg, view) {
-        const buf = cachedTextEncoder.encode(arg);
-        view.set(buf);
-        return {
-            read: arg.length,
-            written: buf.length
-        };
-    };
-}
-
-let WASM_VECTOR_LEN = 0;
-
-let wasm;
-function __wbg_finalize_init(instance, module) {
-    wasm = instance.exports;
-    cachedDataViewMemory0 = null;
-    cachedUint8ArrayMemory0 = null;
-    wasm.__wbindgen_start();
-    return wasm;
-}
-
-async function __wbg_load(module, imports) {
-    if (typeof Response === 'function' && module instanceof Response) {
-        if (typeof WebAssembly.instantiateStreaming === 'function') {
-            try {
-                return await WebAssembly.instantiateStreaming(module, imports);
-            } catch (e) {
-                const validResponse = module.ok && expectedResponseType(module.type);
-
-                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
-                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
-
-                } else { throw e; }
-            }
-        }
-
-        const bytes = await module.arrayBuffer();
-        return await WebAssembly.instantiate(bytes, imports);
-    } else {
-        const instance = await WebAssembly.instantiate(module, imports);
-
-        if (instance instanceof WebAssembly.Instance) {
-            return { instance, module };
-        } else {
-            return instance;
-        }
-    }
-
-    function expectedResponseType(type) {
-        switch (type) {
-            case 'basic': case 'cors': case 'default': return true;
-        }
-        return false;
-    }
-}
-
-function initSync(module) {
-    if (wasm !== undefined) return wasm;
-
-
-    if (module !== undefined) {
-        if (Object.getPrototypeOf(module) === Object.prototype) {
-            ({module} = module);
-        } else {
-            console.warn('using deprecated parameters for `initSync()`; pass a single object instead');
-        }
-    }
-
-    const imports = __wbg_get_imports();
-    if (!(module instanceof WebAssembly.Module)) {
-        module = new WebAssembly.Module(module);
-    }
-    const instance = new WebAssembly.Instance(module, imports);
-    return __wbg_finalize_init(instance);
-}
-
-async function __wbg_init(module_or_path) {
-    if (wasm !== undefined) return wasm;
-
-
-    if (module_or_path !== undefined) {
-        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
-            ({module_or_path} = module_or_path);
-        } else {
-            console.warn('using deprecated parameters for the initialization function; pass a single object instead');
-        }
-    }
-
-    if (module_or_path === undefined) {
-        module_or_path = new URL(new URL('diff_wasm_bg-BNcsPO7p.wasm', import.meta.url).href);
-    }
-    const imports = __wbg_get_imports();
-
-    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
-        module_or_path = fetch(module_or_path);
-    }
-
-    const { instance, module } = await __wbg_load(await module_or_path, imports);
-
-    return __wbg_finalize_init(instance);
-}
-
-var wasm$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    computeDiff: computeDiff,
-    computeDiffLines: computeDiffLines,
-    default: __wbg_init,
-    init: init,
-    initSync: initSync
-});
-
-/**
- * WASM module loader.
- *
- * Handles async initialization of the WASM module.
- */
-// @ts-ignore -- generated at build time by `npm run build:wasm` (wasm-pack --target web).
-let wasmModule = null;
-let initPromise = null;
-/**
- * Initialize the WASM module.
- *
- * This must be called before using any WASM-based diff functions.
- * It's safe to call multiple times — subsequent calls are no-ops.
- *
- * @returns Promise that resolves when WASM is ready
- */
-async function initWasm() {
-    if (wasmModule) {
-        return wasmModule;
-    }
-    if (initPromise) {
-        return initPromise;
-    }
-    initPromise = (async () => {
-        const wasmUrl = new URL(new URL('diff_wasm_bg-BNcsPO7p.wasm', import.meta.url).href);
-        // Node's undici fetch does not support file:// URLs, so read bytes ourselves.
-        let source = wasmUrl;
-        if (typeof process !== 'undefined' && process.versions?.node) {
-            const { readFile } = await import('node:fs/promises');
-            source = await readFile(wasmUrl);
-        }
-        await __wbg_init({ module_or_path: source });
-        init();
-        wasmModule = wasm$1;
-        return wasmModule;
-    })();
-    return initPromise;
-}
-/**
- * Get the WASM module synchronously.
- *
- * @throws Error if WASM hasn't been initialized yet
- * @returns The WASM module
- */
-function getWasm() {
-    if (!wasmModule) {
-        throw new Error('WASM not initialized. Call initWasm() first and await it.');
-    }
-    return wasmModule;
-}
-
-async function createDiffComputer(options = {}) {
-    if (options.useWasm) {
-        await initWasm();
-        return new _WasmDiffComputer(options.algorithm);
-    }
-    return new _TsDiffComputer(options.algorithm);
-}
-// ============================================================================
-// TS-backed computer
-// ============================================================================
-class _TsDiffComputer {
-    _algorithm;
-    _impl = new DefaultLinesDiffComputer();
-    constructor(_algorithm) {
-        this._algorithm = _algorithm;
-    }
-    computeDiff(original, modified, options) {
-        const originalLines = original.split('\n');
-        const modifiedLines = modified.split('\n');
-        const internal = {
-            maxComputationTimeMs: options?.maxComputationTimeMs ?? 0,
-            ignoreTrimWhitespace: options?.ignoreTrimWhitespace ?? false,
-            computeMoves: options?.computeMoves ?? false,
-            extendToSubwords: options?.extendToSubwords ?? false,
-        };
-        const linesDiff = this._impl.computeDiff(originalLines, modifiedLines, internal);
-        void this._algorithm; // currently a hint; auto-selection lives inside DefaultLinesDiffComputer
-        return _adaptLinesDiff(linesDiff, original, modified, originalLines, modifiedLines);
-    }
-}
-// ============================================================================
-// WASM-backed computer
-// ============================================================================
-class _WasmDiffComputer {
-    _algorithm;
-    constructor(_algorithm) {
-        this._algorithm = _algorithm;
-    }
-    computeDiff(original, modified, options) {
-        const originalLines = original.split('\n');
-        const modifiedLines = modified.split('\n');
-        const wasmOptions = {};
-        if (options?.maxComputationTimeMs !== undefined)
-            wasmOptions.maxComputationTimeMs = options.maxComputationTimeMs;
-        if (options?.ignoreTrimWhitespace !== undefined)
-            wasmOptions.ignoreTrimWhitespace = options.ignoreTrimWhitespace;
-        if (options?.computeMoves !== undefined)
-            wasmOptions.computeMoves = options.computeMoves;
-        if (options?.extendToSubwords !== undefined)
-            wasmOptions.extendToSubwords = options.extendToSubwords;
-        const wasm = getWasm();
-        const wasmResult = wasm.computeDiffLines(originalLines, modifiedLines, wasmOptions);
-        void this._algorithm;
-        const linesDiff = _wasmToLinesDiff(wasmResult);
-        return _adaptLinesDiff(linesDiff, original, modified, originalLines, modifiedLines);
-    }
-}
-function _wasmToLinesDiff(wasmResult) {
-    const changes = wasmResult.changes.map((c) => {
-        const inner = c.innerChanges?.map((ic) => new RangeMapping(new Range(ic.originalStartLine, ic.originalStartColumn, ic.originalEndLine, ic.originalEndColumn), new Range(ic.modifiedStartLine, ic.modifiedStartColumn, ic.modifiedEndLine, ic.modifiedEndColumn)));
-        return new DetailedLineRangeMapping(new LineRange(c.original.startLineNumber, c.original.endLineNumberExclusive), new LineRange(c.modified.startLineNumber, c.modified.endLineNumberExclusive), inner);
-    });
-    return new LinesDiff(changes, [], wasmResult.hitTimeout);
-}
-// ============================================================================
-// LinesDiff -> DiffResult adapter
-// ============================================================================
-function _adaptLinesDiff(linesDiff, original, modified, originalLines, modifiedLines) {
-    const originalLineStarts = _computeLineStarts(originalLines);
-    const modifiedLineStarts = _computeLineStarts(modifiedLines);
-    const replacements = [];
-    for (const change of linesDiff.changes) {
-        _appendChangeReplacements(change, original, modified, originalLines, modifiedLines, originalLineStarts, modifiedLineStarts, replacements);
-    }
-    const edits = AnnotatedStringEdit.of(replacements);
-    const moves = linesDiff.moves.map(m => _adaptMove(m, original, modified, originalLines, modifiedLines, originalLineStarts, modifiedLineStarts));
-    return new DiffResult(edits, moves, linesDiff.hitTimeout);
-}
-function _appendChangeReplacements(change, original, modified, originalLines, modifiedLines, originalLineStarts, modifiedLineStarts, out) {
-    if (change.innerChanges && change.innerChanges.length > 0) {
-        for (const ic of change.innerChanges) {
-            const origRange = _rangeToOffsetRange(ic.originalRange, original, originalLines, originalLineStarts);
-            const modRange = _rangeToOffsetRange(ic.modifiedRange, modified, modifiedLines, modifiedLineStarts);
-            const newText = modified.substring(modRange.start, modRange.endExclusive);
-            out.push(new AnnotatedStringReplacement(origRange, newText, DiffAnnotation.change));
-        }
-        return;
-    }
-    // Fallback: no inner detail — replace the whole line range.
-    const origRange = _lineRangeToOffsetRange(change.original.startLineNumber, change.original.endLineNumberExclusive, original, originalLineStarts);
-    const modRange = _lineRangeToOffsetRange(change.modified.startLineNumber, change.modified.endLineNumberExclusive, modified, modifiedLineStarts);
-    const newText = modified.substring(modRange.start, modRange.endExclusive);
-    out.push(new AnnotatedStringReplacement(origRange, newText, DiffAnnotation.change));
-}
-function _adaptMove(move, original, modified, originalLines, modifiedLines, originalLineStarts, modifiedLineStarts) {
-    const origRange = _lineRangeToOffsetRange(move.lineRangeMapping.original.startLineNumber, move.lineRangeMapping.original.endLineNumberExclusive, original, originalLineStarts);
-    const modRange = _lineRangeToOffsetRange(move.lineRangeMapping.modified.startLineNumber, move.lineRangeMapping.modified.endLineNumberExclusive, modified, modifiedLineStarts);
-    // Build inner edit with offsets local to the moved slices.
-    const inner = [];
-    for (const change of move.changes) {
-        if (change.innerChanges && change.innerChanges.length > 0) {
-            for (const ic of change.innerChanges) {
-                const globalOrig = _rangeToOffsetRange(ic.originalRange, original, originalLines, originalLineStarts);
-                const globalMod = _rangeToOffsetRange(ic.modifiedRange, modified, modifiedLines, modifiedLineStarts);
-                inner.push(new StringReplacement(new OffsetRange(globalOrig.start - origRange.start, globalOrig.endExclusive - origRange.start), modified.substring(globalMod.start, globalMod.endExclusive)));
-            }
-        }
-        else {
-            const globalOrig = _lineRangeToOffsetRange(change.original.startLineNumber, change.original.endLineNumberExclusive, original, originalLineStarts);
-            const globalMod = _lineRangeToOffsetRange(change.modified.startLineNumber, change.modified.endLineNumberExclusive, modified, modifiedLineStarts);
-            inner.push(new StringReplacement(new OffsetRange(globalOrig.start - origRange.start, globalOrig.endExclusive - origRange.start), modified.substring(globalMod.start, globalMod.endExclusive)));
-        }
-    }
-    return new Move(new OffsetRangeMapping(origRange, modRange), StringEdit.of(inner));
-}
-// ----- offset/line helpers -----
-function _computeLineStarts(lines) {
-    // Offsets correspond to `lines.join('\n')`, which equals the input string
-    // when the input was split by `\n`.
-    const starts = new Array(lines.length + 1);
-    starts[0] = 0;
-    for (let i = 0; i < lines.length; i++) {
-        starts[i + 1] = starts[i] + lines[i].length + 1; // +1 for the '\n'
-    }
-    // `starts[lines.length]` is one past the synthetic trailing newline; the
-    // real text ends one earlier when there is no trailing newline (which is
-    // what `split('\n')` produces for non-newline-terminated input).
-    return starts;
-}
-function _lineRangeToOffsetRange(startLineNumber, endLineNumberExclusive, text, lineStarts) {
-    const start = _lineColToOffset(startLineNumber, 1, text, lineStarts);
-    const end = _lineColToOffset(endLineNumberExclusive, 1, text, lineStarts);
-    return new OffsetRange(start, end);
-}
-function _rangeToOffsetRange(range, text, lines, lineStarts) {
-    const start = _lineColToOffset(range.startLineNumber, range.startColumn, text, lineStarts);
-    const end = _lineColToOffset(range.endLineNumber, range.endColumn, text, lineStarts);
-    return new OffsetRange(start, end);
-}
-function _lineColToOffset(lineNumber, column, text, lineStarts) {
-    // `lineNumber` and `column` are 1-based; `endLineNumberExclusive` can be
-    // `lines.length + 1` (one past the last line).
-    if (lineNumber <= 0) {
-        return 0;
-    }
-    if (lineNumber > lineStarts.length) {
-        return text.length;
-    }
-    const base = lineStarts[lineNumber - 1];
-    const offset = base + (column - 1);
-    return Math.min(Math.max(offset, 0), text.length);
 }
 
-export { AnnotatedStringEdit, AnnotatedStringReplacement, DiffAnnotation, DiffResult, Move, OffsetRange, OffsetRangeMapping, StringEdit, StringReplacement, createDiffComputer };
+export { AnnotatedStringEdit, AnnotatedStringReplacement, DiffAnnotation, DiffResult, Move, OffsetRange, OffsetRangeMapping, StringEdit, StringReplacement, DefaultLinesDiffComputer as _DefaultLinesDiffComputer, DetailedLineRangeMapping as _DetailedLineRangeMapping, LineRange as _LineRange, LinesDiff as _LinesDiff, RangeMapping as _RangeMapping, getWasm as _getWasm, initWasm as _initWasm, createDiffComputer, createWorkerDiffComputer };
 //# sourceMappingURL=index.js.map