jderobot-ide-interface 0.3.17 → 0.3.19

package/dist/vendors-node_modules_vscode_diff_dist_index_js.main.js

@@ -0,0 +1,626 @@
+"use strict";
+(this["webpackChunkjderobot_ide_interface"] = this["webpackChunkjderobot_ide_interface"] || []).push([["vendors-node_modules_vscode_diff_dist_index_js"],{
+
+/***/ "./node_modules/@vscode/diff/dist/index.js"
+/*!*************************************************!*\
+  !*** ./node_modules/@vscode/diff/dist/index.js ***!
+  \*************************************************/
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   AnnotatedStringEdit: () => (/* binding */ AnnotatedStringEdit),
+/* harmony export */   AnnotatedStringReplacement: () => (/* binding */ AnnotatedStringReplacement),
+/* harmony export */   DiffAnnotation: () => (/* binding */ DiffAnnotation),
+/* harmony export */   DiffResult: () => (/* binding */ DiffResult),
+/* harmony export */   Move: () => (/* binding */ Move),
+/* harmony export */   OffsetRange: () => (/* reexport safe */ _wire_js__WEBPACK_IMPORTED_MODULE_0__.O),
+/* harmony export */   OffsetRangeMapping: () => (/* binding */ OffsetRangeMapping),
+/* harmony export */   StringEdit: () => (/* binding */ StringEdit),
+/* harmony export */   StringReplacement: () => (/* binding */ StringReplacement),
+/* harmony export */   _DefaultLinesDiffComputer: () => (/* reexport safe */ _wire_js__WEBPACK_IMPORTED_MODULE_0__.D),
+/* harmony export */   _DetailedLineRangeMapping: () => (/* reexport safe */ _wire_js__WEBPACK_IMPORTED_MODULE_0__.b),
+/* harmony export */   _LineRange: () => (/* reexport safe */ _wire_js__WEBPACK_IMPORTED_MODULE_0__.L),
+/* harmony export */   _LineRangeMapping: () => (/* reexport safe */ _wire_js__WEBPACK_IMPORTED_MODULE_0__.d),
+/* harmony export */   _LinesDiff: () => (/* reexport safe */ _wire_js__WEBPACK_IMPORTED_MODULE_0__.c),
+/* harmony export */   _RangeMapping: () => (/* reexport safe */ _wire_js__WEBPACK_IMPORTED_MODULE_0__.R),
+/* harmony export */   _getWasm: () => (/* reexport safe */ _wire_js__WEBPACK_IMPORTED_MODULE_0__.g),
+/* harmony export */   _initWasm: () => (/* reexport safe */ _wire_js__WEBPACK_IMPORTED_MODULE_0__.i),
+/* harmony export */   createDiffComputer: () => (/* binding */ createDiffComputer),
+/* harmony export */   createWorkerDiffComputer: () => (/* binding */ createWorkerDiffComputer)
+/* harmony export */ });
+/* harmony import */ var _wire_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./wire.js */ "./node_modules/@vscode/diff/dist/wire.js");
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+
+
+/**
+ * A pair of ranges, one in `original`, one in `modified`.
+ */
+class OffsetRangeMapping {
+    original;
+    modified;
+    constructor(original, modified) {
+        this.original = original;
+        this.modified = modified;
+    }
+    toString() {
+        return `${this.original} <-> ${this.modified}`;
+    }
+}
+
+/**
+ * A single atomic replacement: replace `range` in the input with `newText`.
+ */
+class StringReplacement {
+    range;
+    newText;
+    constructor(range, newText) {
+        this.range = range;
+        this.newText = newText;
+    }
+    get isEmpty() {
+        return this.range.isEmpty && this.newText.length === 0;
+    }
+    toString() {
+        return `${this.range}->${JSON.stringify(this.newText)}`;
+    }
+}
+/**
+ * A set of replacements applied in parallel to one input string.
+ *
+ * Invariants:
+ *  - replacements are sorted by `range.start`
+ *  - replacements do not overlap (touching is allowed)
+ *  - all ranges live in the same coordinate space (the input passed to `apply`)
+ */
+class StringEdit {
+    replacements;
+    static empty = new StringEdit([]);
+    static single(replacement) {
+        return new StringEdit([replacement]);
+    }
+    /**
+     * Validates that replacements are sorted and non-overlapping.
+     */
+    static of(replacements) {
+        for (let i = 1; i < replacements.length; i++) {
+            const prev = replacements[i - 1];
+            const cur = replacements[i];
+            if (prev.range.endExclusive > cur.range.start) {
+                throw new Error(`StringEdit.of: replacements must be sorted and non-overlapping (` +
+                    `${prev.range} vs ${cur.range})`);
+            }
+        }
+        return new StringEdit(replacements);
+    }
+    constructor(replacements) {
+        this.replacements = replacements;
+    }
+    get isEmpty() {
+        return this.replacements.length === 0;
+    }
+    apply(text) {
+        if (this.replacements.length === 0) {
+            return text;
+        }
+        const parts = [];
+        let cursor = 0;
+        for (const r of this.replacements) {
+            parts.push(text.substring(cursor, r.range.start));
+            parts.push(r.newText);
+            cursor = r.range.endExclusive;
+        }
+        parts.push(text.substring(cursor));
+        return parts.join('');
+    }
+    /**
+     * Returns an edit `E` such that `E.apply(this.apply(input)) === input`.
+     */
+    inverse(input) {
+        const out = [];
+        let delta = 0;
+        for (const r of this.replacements) {
+            const newStart = r.range.start + delta;
+            const newEnd = newStart + r.newText.length;
+            const oldText = input.substring(r.range.start, r.range.endExclusive);
+            out.push(new StringReplacement(new _wire_js__WEBPACK_IMPORTED_MODULE_0__.O(newStart, newEnd), oldText));
+            delta += r.newText.length - r.range.length;
+        }
+        return new StringEdit(out);
+    }
+    /**
+     * Joins touching replacements and drops no-ops.
+     */
+    normalize() {
+        const out = [];
+        for (const r of this.replacements) {
+            if (r.isEmpty) {
+                continue;
+            }
+            const prev = out[out.length - 1];
+            if (prev && prev.range.endExclusive === r.range.start) {
+                out[out.length - 1] = new StringReplacement(new _wire_js__WEBPACK_IMPORTED_MODULE_0__.O(prev.range.start, r.range.endExclusive), prev.newText + r.newText);
+            }
+            else {
+                out.push(r);
+            }
+        }
+        return new StringEdit(out);
+    }
+    toString() {
+        return `StringEdit[${this.replacements.map(r => r.toString()).join(', ')}]`;
+    }
+}
+
+/**
+ * An atomic replacement carrying user-defined metadata.
+ */
+class AnnotatedStringReplacement {
+    range;
+    newText;
+    data;
+    constructor(range, newText, data) {
+        this.range = range;
+        this.newText = newText;
+        this.data = data;
+    }
+    get isEmpty() {
+        return this.range.isEmpty && this.newText.length === 0;
+    }
+    toString() {
+        return `${this.range}->${JSON.stringify(this.newText)}#${this.data}`;
+    }
+}
+/**
+ * A set of annotated replacements applied in parallel.
+ *
+ * Invariants: same as `StringEdit` (sorted by `range.start`, non-overlapping,
+ * shared coordinate space).
+ */
+class AnnotatedStringEdit {
+    replacements;
+    static empty() {
+        return new AnnotatedStringEdit([]);
+    }
+    static single(replacement) {
+        return new AnnotatedStringEdit([replacement]);
+    }
+    static of(replacements) {
+        for (let i = 1; i < replacements.length; i++) {
+            const prev = replacements[i - 1];
+            const cur = replacements[i];
+            if (prev.range.endExclusive > cur.range.start) {
+                throw new Error(`AnnotatedStringEdit.of: replacements must be sorted and non-overlapping (` +
+                    `${prev.range} vs ${cur.range})`);
+            }
+        }
+        return new AnnotatedStringEdit(replacements);
+    }
+    constructor(replacements) {
+        this.replacements = replacements;
+    }
+    get isEmpty() {
+        return this.replacements.length === 0;
+    }
+    apply(text) {
+        if (this.replacements.length === 0) {
+            return text;
+        }
+        const parts = [];
+        let cursor = 0;
+        for (const r of this.replacements) {
+            parts.push(text.substring(cursor, r.range.start));
+            parts.push(r.newText);
+            cursor = r.range.endExclusive;
+        }
+        parts.push(text.substring(cursor));
+        return parts.join('');
+    }
+    inverse(input, invertData) {
+        const out = [];
+        let delta = 0;
+        for (const r of this.replacements) {
+            const newStart = r.range.start + delta;
+            const newEnd = newStart + r.newText.length;
+            const oldText = input.substring(r.range.start, r.range.endExclusive);
+            out.push(new AnnotatedStringReplacement(new _wire_js__WEBPACK_IMPORTED_MODULE_0__.O(newStart, newEnd), oldText, invertData(r.data)));
+            delta += r.newText.length - r.range.length;
+        }
+        return new AnnotatedStringEdit(out);
+    }
+    /**
+     * Joins touching replacements when their annotations join. Drops no-ops.
+     */
+    normalize() {
+        const out = [];
+        for (const r of this.replacements) {
+            if (r.isEmpty) {
+                continue;
+            }
+            const prev = out[out.length - 1];
+            if (prev && prev.range.endExclusive === r.range.start) {
+                const joined = prev.data.join(r.data);
+                if (joined !== undefined) {
+                    out[out.length - 1] = new AnnotatedStringReplacement(new _wire_js__WEBPACK_IMPORTED_MODULE_0__.O(prev.range.start, r.range.endExclusive), prev.newText + r.newText, joined);
+                    continue;
+                }
+            }
+            out.push(r);
+        }
+        return new AnnotatedStringEdit(out);
+    }
+    mapData(f) {
+        return new AnnotatedStringEdit(this.replacements.map(r => new AnnotatedStringReplacement(r.range, r.newText, f(r.data))));
+    }
+    stripData() {
+        return StringEdit.of(this.replacements.map(r => new StringReplacement(r.range, r.newText)));
+    }
+    toString() {
+        return `AnnotatedStringEdit[${this.replacements.map(r => r.toString()).join(', ')}]`;
+    }
+}
+/**
+ * Diff result annotation.
+ *
+ * Carries flags describing the nature of the replacement. For now only
+ * `isFormattingChange` is exposed; more flags (e.g. move source/target,
+ * semantic category) can be added later.
+ */
+class DiffAnnotation {
+    isFormattingChange;
+    static change = new DiffAnnotation(false);
+    static formatting = new DiffAnnotation(true);
+    constructor(
+    /** Whether the replacement is purely a formatting change (whitespace, indentation, etc.). */
+    isFormattingChange) {
+        this.isFormattingChange = isFormattingChange;
+    }
+    join(other) {
+        if (this.isFormattingChange !== other.isFormattingChange) {
+            return undefined;
+        }
+        return this;
+    }
+    toString() {
+        return this.isFormattingChange ? 'formatting' : 'change';
+    }
+}
+
+/**
+ * A block of text that was moved between two locations.
+ *
+ * `range` locates the block in `original` and in `modified` (offsets in the
+ * respective full texts). `innerEdit` describes the changes inside the moved
+ * block, with offsets local to the slice (i.e. `0` is the start of the slice).
+ */
+class Move {
+    range;
+    innerEdit;
+    constructor(range, innerEdit) {
+        this.range = range;
+        this.innerEdit = innerEdit;
+    }
+    toString() {
+        return `Move ${this.range}` + (this.innerEdit.isEmpty ? '' : ` (${this.innerEdit})`);
+    }
+}
+
+/**
+ * Output of a diff computation.
+ */
+class DiffResult {
+    edits;
+    moves;
+    hitTimeout;
+    constructor(
+    /**
+     * Parallel set of replacements transforming `original` into `modified`,
+     * excluding any replacements that are part of a `Move`.
+     *
+     * When no moves are computed: `edits.apply(original) === modified`.
+     */
+    edits, 
+    /**
+     * Detected text moves. Empty unless `DiffOptions.computeMoves` is set.
+     */
+    moves, 
+    /**
+     * `true` if the algorithm aborted because of `maxComputationTimeMs`.
+     * The result is still valid but may be coarser than ideal.
+     */
+    hitTimeout) {
+        this.edits = edits;
+        this.moves = moves;
+        this.hitTimeout = hitTimeout;
+    }
+}
+
+async function createDiffComputer(options = {}) {
+    if (options.useWasm) {
+        await (0,_wire_js__WEBPACK_IMPORTED_MODULE_0__.i)();
+        return new _WasmDiffComputer(options.algorithm);
+    }
+    return new _TsDiffComputer(options.algorithm);
+}
+// ============================================================================
+// TS-backed computer
+// ============================================================================
+class _TsDiffComputer {
+    _algorithm;
+    _impl = new _wire_js__WEBPACK_IMPORTED_MODULE_0__.D();
+    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 = (0,_wire_js__WEBPACK_IMPORTED_MODULE_0__.g)();
+        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 _wire_js__WEBPACK_IMPORTED_MODULE_0__.R(new _wire_js__WEBPACK_IMPORTED_MODULE_0__.a(ic.originalStartLine, ic.originalStartColumn, ic.originalEndLine, ic.originalEndColumn), new _wire_js__WEBPACK_IMPORTED_MODULE_0__.a(ic.modifiedStartLine, ic.modifiedStartColumn, ic.modifiedEndLine, ic.modifiedEndColumn)));
+        return new _wire_js__WEBPACK_IMPORTED_MODULE_0__.b(new _wire_js__WEBPACK_IMPORTED_MODULE_0__.L(c.original.startLineNumber, c.original.endLineNumberExclusive), new _wire_js__WEBPACK_IMPORTED_MODULE_0__.L(c.modified.startLineNumber, c.modified.endLineNumberExclusive), inner);
+    });
+    return new _wire_js__WEBPACK_IMPORTED_MODULE_0__.c(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);
+    }
+    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 _wire_js__WEBPACK_IMPORTED_MODULE_0__.O(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 _wire_js__WEBPACK_IMPORTED_MODULE_0__.O(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 _wire_js__WEBPACK_IMPORTED_MODULE_0__.O(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 _wire_js__WEBPACK_IMPORTED_MODULE_0__.O(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);
+}
+
+/**
+ * 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).
+ */
+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 import */ __webpack_require__.p + __webpack_require__.u("node_modules_vscode_diff_dist_worker_js_esm"), __webpack_require__.b), { type: undefined });
+}
+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'}`));
+        });
+    }
+    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);
+        });
+    }
+    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);
+        });
+    }
+    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;
+        }
+        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));
+            }
+            return;
+        }
+        this._pending.delete(msg.id);
+        if (!msg.ok) {
+            entry.reject(new Error(msg.error));
+            return;
+        }
+        try {
+            const linesDiff = (0,_wire_js__WEBPACK_IMPORTED_MODULE_0__.w)(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)));
+        }
+    }
+    _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;
+        }
+    }
+}
+
+
+//# sourceMappingURL=index.js.map
+
+
+/***/ }
+
+}]);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"vendors-node_modules_vscode_diff_dist_index_js.main.js","mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AACA;AACA;AACA;AAC6N;AAC1K;;AAEnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,eAAe,MAAM,cAAc;AACrD;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,WAAW,IAAI,6BAA6B;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,yBAAyB;AACjD;AACA;AACA;AACA;AACA,uBAAuB,YAAY,KAAK,UAAU;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C,uCAAW;AAC1D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,uCAAW;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,oDAAoD;AACjF;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,WAAW,IAAI,6BAA6B,GAAG,UAAU;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,yBAAyB;AACjD;AACA;AACA;AACA;AACA,uBAAuB,YAAY,KAAK,UAAU;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wDAAwD,uCAAW;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6EAA6E,uCAAW;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,oDAAoD;AAC1F;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,WAAW,wCAAwC,eAAe;AACzF;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,8CAA8C;AAC9C;AACA,cAAc,2CAAQ;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,uCAAwB;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,qBAAqB;AACnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,2CAAO;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,uCAAY,KAAK,uCAAK,8FAA8F,uCAAK;AAC/K,mBAAmB,uCAAwB,KAAK,uCAAS,qEAAqE,uCAAS;AACvI,KAAK;AACL,eAAe,uCAAS;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,uCAAW;AAChE;AACA;AACA;AACA;AACA;AACA,iDAAiD,uCAAW;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,kBAAkB;AACtC,yDAAyD;AACzD;AACA,0EAA0E;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,uCAAW;AAC1B;AACA;AACA;AACA;AACA,eAAe,uCAAW;AAC1B;AACA;AACA,8CAA8C;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,6CAA6C;AAC7C;AACA;AACA;AACA,iDAAiD;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB;AACA,8BAA8B,uIAAgC,KAAK,MAAM,SAAQ,EAAE;AACnF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,qDAAqD,wBAAwB;AAC7E,SAAS;AACT;AACA;AACA;AACA,sBAAsB;AACtB;AACA,kCAAkC;AAClC;AACA,SAAS;AACT;AACA,gDAAgD;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,2CAAe;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEsb;AACtb","sources":["webpack://jderobot-ide-interface/./node_modules/@vscode/diff/dist/index.js"],"sourcesContent":["/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { 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';\nexport { d as _LineRangeMapping } from './wire.js';\n\n/**\n * A pair of ranges, one in `original`, one in `modified`.\n */\nclass OffsetRangeMapping {\n    original;\n    modified;\n    constructor(original, modified) {\n        this.original = original;\n        this.modified = modified;\n    }\n    toString() {\n        return `${this.original} <-> ${this.modified}`;\n    }\n}\n\n/**\n * A single atomic replacement: replace `range` in the input with `newText`.\n */\nclass StringReplacement {\n    range;\n    newText;\n    constructor(range, newText) {\n        this.range = range;\n        this.newText = newText;\n    }\n    get isEmpty() {\n        return this.range.isEmpty && this.newText.length === 0;\n    }\n    toString() {\n        return `${this.range}->${JSON.stringify(this.newText)}`;\n    }\n}\n/**\n * A set of replacements applied in parallel to one input string.\n *\n * Invariants:\n *  - replacements are sorted by `range.start`\n *  - replacements do not overlap (touching is allowed)\n *  - all ranges live in the same coordinate space (the input passed to `apply`)\n */\nclass StringEdit {\n    replacements;\n    static empty = new StringEdit([]);\n    static single(replacement) {\n        return new StringEdit([replacement]);\n    }\n    /**\n     * Validates that replacements are sorted and non-overlapping.\n     */\n    static of(replacements) {\n        for (let i = 1; i < replacements.length; i++) {\n            const prev = replacements[i - 1];\n            const cur = replacements[i];\n            if (prev.range.endExclusive > cur.range.start) {\n                throw new Error(`StringEdit.of: replacements must be sorted and non-overlapping (` +\n                    `${prev.range} vs ${cur.range})`);\n            }\n        }\n        return new StringEdit(replacements);\n    }\n    constructor(replacements) {\n        this.replacements = replacements;\n    }\n    get isEmpty() {\n        return this.replacements.length === 0;\n    }\n    apply(text) {\n        if (this.replacements.length === 0) {\n            return text;\n        }\n        const parts = [];\n        let cursor = 0;\n        for (const r of this.replacements) {\n            parts.push(text.substring(cursor, r.range.start));\n            parts.push(r.newText);\n            cursor = r.range.endExclusive;\n        }\n        parts.push(text.substring(cursor));\n        return parts.join('');\n    }\n    /**\n     * Returns an edit `E` such that `E.apply(this.apply(input)) === input`.\n     */\n    inverse(input) {\n        const out = [];\n        let delta = 0;\n        for (const r of this.replacements) {\n            const newStart = r.range.start + delta;\n            const newEnd = newStart + r.newText.length;\n            const oldText = input.substring(r.range.start, r.range.endExclusive);\n            out.push(new StringReplacement(new OffsetRange(newStart, newEnd), oldText));\n            delta += r.newText.length - r.range.length;\n        }\n        return new StringEdit(out);\n    }\n    /**\n     * Joins touching replacements and drops no-ops.\n     */\n    normalize() {\n        const out = [];\n        for (const r of this.replacements) {\n            if (r.isEmpty) {\n                continue;\n            }\n            const prev = out[out.length - 1];\n            if (prev && prev.range.endExclusive === r.range.start) {\n                out[out.length - 1] = new StringReplacement(new OffsetRange(prev.range.start, r.range.endExclusive), prev.newText + r.newText);\n            }\n            else {\n                out.push(r);\n            }\n        }\n        return new StringEdit(out);\n    }\n    toString() {\n        return `StringEdit[${this.replacements.map(r => r.toString()).join(', ')}]`;\n    }\n}\n\n/**\n * An atomic replacement carrying user-defined metadata.\n */\nclass AnnotatedStringReplacement {\n    range;\n    newText;\n    data;\n    constructor(range, newText, data) {\n        this.range = range;\n        this.newText = newText;\n        this.data = data;\n    }\n    get isEmpty() {\n        return this.range.isEmpty && this.newText.length === 0;\n    }\n    toString() {\n        return `${this.range}->${JSON.stringify(this.newText)}#${this.data}`;\n    }\n}\n/**\n * A set of annotated replacements applied in parallel.\n *\n * Invariants: same as `StringEdit` (sorted by `range.start`, non-overlapping,\n * shared coordinate space).\n */\nclass AnnotatedStringEdit {\n    replacements;\n    static empty() {\n        return new AnnotatedStringEdit([]);\n    }\n    static single(replacement) {\n        return new AnnotatedStringEdit([replacement]);\n    }\n    static of(replacements) {\n        for (let i = 1; i < replacements.length; i++) {\n            const prev = replacements[i - 1];\n            const cur = replacements[i];\n            if (prev.range.endExclusive > cur.range.start) {\n                throw new Error(`AnnotatedStringEdit.of: replacements must be sorted and non-overlapping (` +\n                    `${prev.range} vs ${cur.range})`);\n            }\n        }\n        return new AnnotatedStringEdit(replacements);\n    }\n    constructor(replacements) {\n        this.replacements = replacements;\n    }\n    get isEmpty() {\n        return this.replacements.length === 0;\n    }\n    apply(text) {\n        if (this.replacements.length === 0) {\n            return text;\n        }\n        const parts = [];\n        let cursor = 0;\n        for (const r of this.replacements) {\n            parts.push(text.substring(cursor, r.range.start));\n            parts.push(r.newText);\n            cursor = r.range.endExclusive;\n        }\n        parts.push(text.substring(cursor));\n        return parts.join('');\n    }\n    inverse(input, invertData) {\n        const out = [];\n        let delta = 0;\n        for (const r of this.replacements) {\n            const newStart = r.range.start + delta;\n            const newEnd = newStart + r.newText.length;\n            const oldText = input.substring(r.range.start, r.range.endExclusive);\n            out.push(new AnnotatedStringReplacement(new OffsetRange(newStart, newEnd), oldText, invertData(r.data)));\n            delta += r.newText.length - r.range.length;\n        }\n        return new AnnotatedStringEdit(out);\n    }\n    /**\n     * Joins touching replacements when their annotations join. Drops no-ops.\n     */\n    normalize() {\n        const out = [];\n        for (const r of this.replacements) {\n            if (r.isEmpty) {\n                continue;\n            }\n            const prev = out[out.length - 1];\n            if (prev && prev.range.endExclusive === r.range.start) {\n                const joined = prev.data.join(r.data);\n                if (joined !== undefined) {\n                    out[out.length - 1] = new AnnotatedStringReplacement(new OffsetRange(prev.range.start, r.range.endExclusive), prev.newText + r.newText, joined);\n                    continue;\n                }\n            }\n            out.push(r);\n        }\n        return new AnnotatedStringEdit(out);\n    }\n    mapData(f) {\n        return new AnnotatedStringEdit(this.replacements.map(r => new AnnotatedStringReplacement(r.range, r.newText, f(r.data))));\n    }\n    stripData() {\n        return StringEdit.of(this.replacements.map(r => new StringReplacement(r.range, r.newText)));\n    }\n    toString() {\n        return `AnnotatedStringEdit[${this.replacements.map(r => r.toString()).join(', ')}]`;\n    }\n}\n/**\n * Diff result annotation.\n *\n * Carries flags describing the nature of the replacement. For now only\n * `isFormattingChange` is exposed; more flags (e.g. move source/target,\n * semantic category) can be added later.\n */\nclass DiffAnnotation {\n    isFormattingChange;\n    static change = new DiffAnnotation(false);\n    static formatting = new DiffAnnotation(true);\n    constructor(\n    /** Whether the replacement is purely a formatting change (whitespace, indentation, etc.). */\n    isFormattingChange) {\n        this.isFormattingChange = isFormattingChange;\n    }\n    join(other) {\n        if (this.isFormattingChange !== other.isFormattingChange) {\n            return undefined;\n        }\n        return this;\n    }\n    toString() {\n        return this.isFormattingChange ? 'formatting' : 'change';\n    }\n}\n\n/**\n * A block of text that was moved between two locations.\n *\n * `range` locates the block in `original` and in `modified` (offsets in the\n * respective full texts). `innerEdit` describes the changes inside the moved\n * block, with offsets local to the slice (i.e. `0` is the start of the slice).\n */\nclass Move {\n    range;\n    innerEdit;\n    constructor(range, innerEdit) {\n        this.range = range;\n        this.innerEdit = innerEdit;\n    }\n    toString() {\n        return `Move ${this.range}` + (this.innerEdit.isEmpty ? '' : ` (${this.innerEdit})`);\n    }\n}\n\n/**\n * Output of a diff computation.\n */\nclass DiffResult {\n    edits;\n    moves;\n    hitTimeout;\n    constructor(\n    /**\n     * Parallel set of replacements transforming `original` into `modified`,\n     * excluding any replacements that are part of a `Move`.\n     *\n     * When no moves are computed: `edits.apply(original) === modified`.\n     */\n    edits, \n    /**\n     * Detected text moves. Empty unless `DiffOptions.computeMoves` is set.\n     */\n    moves, \n    /**\n     * `true` if the algorithm aborted because of `maxComputationTimeMs`.\n     * The result is still valid but may be coarser than ideal.\n     */\n    hitTimeout) {\n        this.edits = edits;\n        this.moves = moves;\n        this.hitTimeout = hitTimeout;\n    }\n}\n\nasync function createDiffComputer(options = {}) {\n    if (options.useWasm) {\n        await initWasm();\n        return new _WasmDiffComputer(options.algorithm);\n    }\n    return new _TsDiffComputer(options.algorithm);\n}\n// ============================================================================\n// TS-backed computer\n// ============================================================================\nclass _TsDiffComputer {\n    _algorithm;\n    _impl = new DefaultLinesDiffComputer();\n    constructor(_algorithm) {\n        this._algorithm = _algorithm;\n    }\n    computeDiff(original, modified, options) {\n        const originalLines = original.split('\\n');\n        const modifiedLines = modified.split('\\n');\n        const internal = {\n            maxComputationTimeMs: options?.maxComputationTimeMs ?? 0,\n            ignoreTrimWhitespace: options?.ignoreTrimWhitespace ?? false,\n            computeMoves: options?.computeMoves ?? false,\n            extendToSubwords: options?.extendToSubwords ?? false,\n        };\n        const linesDiff = this._impl.computeDiff(originalLines, modifiedLines, internal);\n        void this._algorithm; // currently a hint; auto-selection lives inside DefaultLinesDiffComputer\n        return _adaptLinesDiff(linesDiff, original, modified, originalLines, modifiedLines);\n    }\n}\n// ============================================================================\n// WASM-backed computer\n// ============================================================================\nclass _WasmDiffComputer {\n    _algorithm;\n    constructor(_algorithm) {\n        this._algorithm = _algorithm;\n    }\n    computeDiff(original, modified, options) {\n        const originalLines = original.split('\\n');\n        const modifiedLines = modified.split('\\n');\n        const wasmOptions = {};\n        if (options?.maxComputationTimeMs !== undefined)\n            wasmOptions.maxComputationTimeMs = options.maxComputationTimeMs;\n        if (options?.ignoreTrimWhitespace !== undefined)\n            wasmOptions.ignoreTrimWhitespace = options.ignoreTrimWhitespace;\n        if (options?.computeMoves !== undefined)\n            wasmOptions.computeMoves = options.computeMoves;\n        if (options?.extendToSubwords !== undefined)\n            wasmOptions.extendToSubwords = options.extendToSubwords;\n        const wasm = getWasm();\n        const wasmResult = wasm.computeDiffLines(originalLines, modifiedLines, wasmOptions);\n        void this._algorithm;\n        const linesDiff = _wasmToLinesDiff(wasmResult);\n        return _adaptLinesDiff(linesDiff, original, modified, originalLines, modifiedLines);\n    }\n}\nfunction _wasmToLinesDiff(wasmResult) {\n    const changes = wasmResult.changes.map((c) => {\n        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)));\n        return new DetailedLineRangeMapping(new LineRange(c.original.startLineNumber, c.original.endLineNumberExclusive), new LineRange(c.modified.startLineNumber, c.modified.endLineNumberExclusive), inner);\n    });\n    return new LinesDiff(changes, [], wasmResult.hitTimeout);\n}\n// ============================================================================\n// LinesDiff -> DiffResult adapter\n// ============================================================================\n/** @internal — exported for the worker-side client. */\nfunction _adaptLinesDiff(linesDiff, original, modified, originalLines, modifiedLines) {\n    const originalLineStarts = _computeLineStarts(originalLines);\n    const modifiedLineStarts = _computeLineStarts(modifiedLines);\n    const replacements = [];\n    for (const change of linesDiff.changes) {\n        _appendChangeReplacements(change, original, modified, originalLines, modifiedLines, originalLineStarts, modifiedLineStarts, replacements);\n    }\n    const edits = AnnotatedStringEdit.of(replacements);\n    const moves = linesDiff.moves.map(m => _adaptMove(m, original, modified, originalLines, modifiedLines, originalLineStarts, modifiedLineStarts));\n    return new DiffResult(edits, moves, linesDiff.hitTimeout);\n}\nfunction _appendChangeReplacements(change, original, modified, originalLines, modifiedLines, originalLineStarts, modifiedLineStarts, out) {\n    if (change.innerChanges && change.innerChanges.length > 0) {\n        for (const ic of change.innerChanges) {\n            const origRange = _rangeToOffsetRange(ic.originalRange, original, originalLines, originalLineStarts);\n            const modRange = _rangeToOffsetRange(ic.modifiedRange, modified, modifiedLines, modifiedLineStarts);\n            const newText = modified.substring(modRange.start, modRange.endExclusive);\n            out.push(new AnnotatedStringReplacement(origRange, newText, DiffAnnotation.change));\n        }\n        return;\n    }\n    // Fallback: no inner detail — replace the whole line range.\n    const origRange = _lineRangeToOffsetRange(change.original.startLineNumber, change.original.endLineNumberExclusive, original, originalLineStarts);\n    const modRange = _lineRangeToOffsetRange(change.modified.startLineNumber, change.modified.endLineNumberExclusive, modified, modifiedLineStarts);\n    const newText = modified.substring(modRange.start, modRange.endExclusive);\n    out.push(new AnnotatedStringReplacement(origRange, newText, DiffAnnotation.change));\n}\nfunction _adaptMove(move, original, modified, originalLines, modifiedLines, originalLineStarts, modifiedLineStarts) {\n    const origRange = _lineRangeToOffsetRange(move.lineRangeMapping.original.startLineNumber, move.lineRangeMapping.original.endLineNumberExclusive, original, originalLineStarts);\n    const modRange = _lineRangeToOffsetRange(move.lineRangeMapping.modified.startLineNumber, move.lineRangeMapping.modified.endLineNumberExclusive, modified, modifiedLineStarts);\n    // Build inner edit with offsets local to the moved slices.\n    const inner = [];\n    for (const change of move.changes) {\n        if (change.innerChanges && change.innerChanges.length > 0) {\n            for (const ic of change.innerChanges) {\n                const globalOrig = _rangeToOffsetRange(ic.originalRange, original, originalLines, originalLineStarts);\n                const globalMod = _rangeToOffsetRange(ic.modifiedRange, modified, modifiedLines, modifiedLineStarts);\n                inner.push(new StringReplacement(new OffsetRange(globalOrig.start - origRange.start, globalOrig.endExclusive - origRange.start), modified.substring(globalMod.start, globalMod.endExclusive)));\n            }\n        }\n        else {\n            const globalOrig = _lineRangeToOffsetRange(change.original.startLineNumber, change.original.endLineNumberExclusive, original, originalLineStarts);\n            const globalMod = _lineRangeToOffsetRange(change.modified.startLineNumber, change.modified.endLineNumberExclusive, modified, modifiedLineStarts);\n            inner.push(new StringReplacement(new OffsetRange(globalOrig.start - origRange.start, globalOrig.endExclusive - origRange.start), modified.substring(globalMod.start, globalMod.endExclusive)));\n        }\n    }\n    return new Move(new OffsetRangeMapping(origRange, modRange), StringEdit.of(inner));\n}\n// ----- offset/line helpers -----\nfunction _computeLineStarts(lines) {\n    // Offsets correspond to `lines.join('\\n')`, which equals the input string\n    // when the input was split by `\\n`.\n    const starts = new Array(lines.length + 1);\n    starts[0] = 0;\n    for (let i = 0; i < lines.length; i++) {\n        starts[i + 1] = starts[i] + lines[i].length + 1; // +1 for the '\\n'\n    }\n    // `starts[lines.length]` is one past the synthetic trailing newline; the\n    // real text ends one earlier when there is no trailing newline (which is\n    // what `split('\\n')` produces for non-newline-terminated input).\n    return starts;\n}\nfunction _lineRangeToOffsetRange(startLineNumber, endLineNumberExclusive, text, lineStarts) {\n    const start = _lineColToOffset(startLineNumber, 1, text, lineStarts);\n    const end = _lineColToOffset(endLineNumberExclusive, 1, text, lineStarts);\n    return new OffsetRange(start, end);\n}\nfunction _rangeToOffsetRange(range, text, lines, lineStarts) {\n    const start = _lineColToOffset(range.startLineNumber, range.startColumn, text, lineStarts);\n    const end = _lineColToOffset(range.endLineNumber, range.endColumn, text, lineStarts);\n    return new OffsetRange(start, end);\n}\nfunction _lineColToOffset(lineNumber, column, text, lineStarts) {\n    // `lineNumber` and `column` are 1-based; `endLineNumberExclusive` can be\n    // `lines.length + 1` (one past the last line).\n    if (lineNumber <= 0) {\n        return 0;\n    }\n    if (lineNumber > lineStarts.length) {\n        return text.length;\n    }\n    const base = lineStarts[lineNumber - 1];\n    const offset = base + (column - 1);\n    return Math.min(Math.max(offset, 0), text.length);\n}\n\n/**\n * Main-thread client for the diff worker. Exposes an async `IAsyncDiffComputer`.\n *\n * Inputs travel as `string[]` via structured-clone postMessage. The response\n * is a small JSON-friendly `WireLinesDiff`; the main thread reconstructs the\n * full `LinesDiff` and runs `_adaptLinesDiff` locally (it already has the\n * input strings).\n */\nasync function createWorkerDiffComputer(opts = {}) {\n    const worker = opts.workerFactory ? opts.workerFactory() : defaultWorkerFactory();\n    const backend = opts.useWasm ? 'wasm' : 'ts';\n    const computer = new _WorkerDiffComputer(worker, backend);\n    await computer.init();\n    return computer;\n}\nfunction defaultWorkerFactory() {\n    // The `?esm` marker is auto-discovered by `@vscode/*-plugin-esm-url`\n    // bundler plugins; they emit `worker.ts` as a sibling `worker.js` bundle\n    // and rewrite this URL accordingly.\n    return new Worker(new URL('worker.js?esm', import.meta.url), { type: 'module' });\n}\nclass _WorkerDiffComputer {\n    _worker;\n    _backend;\n    _nextId = 1;\n    _pending = new Map();\n    _pendingInit = null;\n    _disposed = false;\n    constructor(_worker, _backend) {\n        this._worker = _worker;\n        this._backend = _backend;\n        this._worker.addEventListener('message', (ev) => {\n            this._onMessage(ev.data);\n        });\n        this._worker.addEventListener('error', (ev) => {\n            this._failAll(new Error(`Worker error: ${ev.message ?? 'unknown'}`));\n        });\n    }\n    init() {\n        const id = this._nextId++;\n        const req = { kind: 'init', id, backend: this._backend };\n        return new Promise((resolve, reject) => {\n            this._pendingInit = { resolve, reject };\n            this._worker.postMessage(req);\n        });\n    }\n    computeDiff(original, modified, options = {}) {\n        if (this._disposed) {\n            return Promise.reject(new Error('Worker computer disposed'));\n        }\n        const id = this._nextId++;\n        const originalLines = original.split('\\n');\n        const modifiedLines = modified.split('\\n');\n        const msg = {\n            kind: 'computeDiff',\n            id,\n            backend: this._backend,\n            originalLines,\n            modifiedLines,\n            options,\n        };\n        return new Promise((resolve, reject) => {\n            this._pending.set(id, {\n                resolve,\n                reject,\n                original,\n                modified,\n                originalLines,\n                modifiedLines,\n            });\n            this._worker.postMessage(msg);\n        });\n    }\n    dispose() {\n        if (this._disposed)\n            return;\n        this._disposed = true;\n        this._failAll(new Error('Worker computer disposed'));\n        this._worker.terminate();\n    }\n    _onMessage(msg) {\n        if (msg.kind === 'init') {\n            const pending = this._pendingInit;\n            this._pendingInit = null;\n            pending?.resolve();\n            return;\n        }\n        const entry = this._pending.get(msg.id);\n        if (!entry) {\n            // Init failure is reported on the init id with `kind === 'computeDiff'`\n            // and `ok === false`; route to the init promise if it's still pending.\n            if (!msg.ok && this._pendingInit) {\n                const p = this._pendingInit;\n                this._pendingInit = null;\n                p.reject(new Error(msg.error));\n            }\n            return;\n        }\n        this._pending.delete(msg.id);\n        if (!msg.ok) {\n            entry.reject(new Error(msg.error));\n            return;\n        }\n        try {\n            const linesDiff = wireToLinesDiff(msg.result);\n            const result = _adaptLinesDiff(linesDiff, entry.original, entry.modified, entry.originalLines, entry.modifiedLines);\n            entry.resolve(result);\n        }\n        catch (err) {\n            entry.reject(err instanceof Error ? err : new Error(String(err)));\n        }\n    }\n    _failAll(err) {\n        for (const p of this._pending.values())\n            p.reject(err);\n        this._pending.clear();\n        if (this._pendingInit) {\n            this._pendingInit.reject(err);\n            this._pendingInit = null;\n        }\n    }\n}\n\nexport { 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 };\n//# sourceMappingURL=index.js.map\n"],"names":[],"sourceRoot":""}