@codingame/monaco-vscode-api 17.2.1 → 18.0.1

package/vscode/src/vs/editor/common/core/offsetEdit.js

@@ -1,335 +0,0 @@
-
-import { BugIndicatingError } from '../../../base/common/errors.js';
-import { OffsetRange } from './offsetRange.js';
-
-class OffsetEdit {
-    static join(edits) {
-        if (edits.length === 0) {
-            return OffsetEdit.empty;
-        }
-        let result = edits[0];
-        for (let i = 1; i < edits.length; i++) {
-            result = result.compose(edits[i]);
-        }
-        return result;
-    }
-    static { this.empty = ( new OffsetEdit([])); }
-    static fromJson(data) {
-        return ( new OffsetEdit(( data.map(SingleOffsetEdit.fromJson))));
-    }
-    static replace(range, newText) {
-        return ( new OffsetEdit([( new SingleOffsetEdit(range, newText))]));
-    }
-    static insert(offset, insertText) {
-        return OffsetEdit.replace(OffsetRange.emptyAt(offset), insertText);
-    }
-    constructor(edits) {
-        this.edits = edits;
-        let lastEndEx = -1;
-        for (const edit of edits) {
-            if (!(edit.replaceRange.start >= lastEndEx)) {
-                throw ( new BugIndicatingError(`Edits must be disjoint and sorted. Found ${edit} after ${lastEndEx}`));
-            }
-            lastEndEx = edit.replaceRange.endExclusive;
-        }
-    }
-    normalize() {
-        const edits = [];
-        let lastEdit;
-        for (const edit of this.edits) {
-            if (edit.newText.length === 0 && edit.replaceRange.length === 0) {
-                continue;
-            }
-            if (lastEdit && lastEdit.replaceRange.endExclusive === edit.replaceRange.start) {
-                lastEdit = ( new SingleOffsetEdit(
-                    lastEdit.replaceRange.join(edit.replaceRange),
-                    lastEdit.newText + edit.newText
-                ));
-            }
-            else {
-                if (lastEdit) {
-                    edits.push(lastEdit);
-                }
-                lastEdit = edit;
-            }
-        }
-        if (lastEdit) {
-            edits.push(lastEdit);
-        }
-        return ( new OffsetEdit(edits));
-    }
-    toString() {
-        const edits = ( this.edits.map(e => ( e.toString()))).join(', ');
-        return `[${edits}]`;
-    }
-    apply(str) {
-        const resultText = [];
-        let pos = 0;
-        for (const edit of this.edits) {
-            resultText.push(str.substring(pos, edit.replaceRange.start));
-            resultText.push(edit.newText);
-            pos = edit.replaceRange.endExclusive;
-        }
-        resultText.push(str.substring(pos));
-        return resultText.join('');
-    }
-    compose(other) {
-        return joinEdits(this, other);
-    }
-    inverse(originalStr) {
-        const edits = [];
-        let offset = 0;
-        for (const e of this.edits) {
-            edits.push(( new SingleOffsetEdit(
-                OffsetRange.ofStartAndLength(e.replaceRange.start + offset, e.newText.length),
-                originalStr.substring(e.replaceRange.start, e.replaceRange.endExclusive)
-            )));
-            offset += e.newText.length - e.replaceRange.length;
-        }
-        return ( new OffsetEdit(edits));
-    }
-    getNewTextRanges() {
-        const ranges = [];
-        let offset = 0;
-        for (const e of this.edits) {
-            ranges.push(OffsetRange.ofStartAndLength(e.replaceRange.start + offset, e.newText.length));
-            offset += e.newText.length - e.replaceRange.length;
-        }
-        return ranges;
-    }
-    get isEmpty() {
-        return this.edits.length === 0;
-    }
-    tryRebase(base, noOverlap) {
-        const newEdits = [];
-        let baseIdx = 0;
-        let ourIdx = 0;
-        let offset = 0;
-        while (ourIdx < this.edits.length || baseIdx < base.edits.length) {
-            const baseEdit = base.edits[baseIdx];
-            const ourEdit = this.edits[ourIdx];
-            if (!ourEdit) {
-                break;
-            }
-            else if (!baseEdit) {
-                newEdits.push(( new SingleOffsetEdit(ourEdit.replaceRange.delta(offset), ourEdit.newText)));
-                ourIdx++;
-            }
-            else if (ourEdit.replaceRange.intersectsOrTouches(baseEdit.replaceRange)) {
-                ourIdx++;
-                if (noOverlap) {
-                    return undefined;
-                }
-            }
-            else if (ourEdit.replaceRange.start < baseEdit.replaceRange.start) {
-                newEdits.push(( new SingleOffsetEdit(ourEdit.replaceRange.delta(offset), ourEdit.newText)));
-                ourIdx++;
-            }
-            else {
-                baseIdx++;
-                offset += baseEdit.newText.length - baseEdit.replaceRange.length;
-            }
-        }
-        return ( new OffsetEdit(newEdits));
-    }
-    applyToOffset(originalOffset) {
-        let accumulatedDelta = 0;
-        for (const edit of this.edits) {
-            if (edit.replaceRange.start <= originalOffset) {
-                if (originalOffset < edit.replaceRange.endExclusive) {
-                    return edit.replaceRange.start + accumulatedDelta;
-                }
-                accumulatedDelta += edit.newText.length - edit.replaceRange.length;
-            }
-            else {
-                break;
-            }
-        }
-        return originalOffset + accumulatedDelta;
-    }
-    applyToOffsetRange(originalRange) {
-        return ( new OffsetRange(
-            this.applyToOffset(originalRange.start),
-            this.applyToOffset(originalRange.endExclusive)
-        ));
-    }
-    applyInverseToOffset(postEditsOffset) {
-        let accumulatedDelta = 0;
-        for (const edit of this.edits) {
-            const editLength = edit.newText.length;
-            if (edit.replaceRange.start <= postEditsOffset - accumulatedDelta) {
-                if (postEditsOffset - accumulatedDelta < edit.replaceRange.start + editLength) {
-                    return edit.replaceRange.start;
-                }
-                accumulatedDelta += editLength - edit.replaceRange.length;
-            }
-            else {
-                break;
-            }
-        }
-        return postEditsOffset - accumulatedDelta;
-    }
-    equals(other) {
-        if (this.edits.length !== other.edits.length) {
-            return false;
-        }
-        for (let i = 0; i < this.edits.length; i++) {
-            if (!this.edits[i].equals(other.edits[i])) {
-                return false;
-            }
-        }
-        return true;
-    }
-}
-class SingleOffsetEdit {
-    static fromJson(data) {
-        return ( new SingleOffsetEdit(OffsetRange.ofStartAndLength(data.pos, data.len), data.txt));
-    }
-    static insert(offset, text) {
-        return ( new SingleOffsetEdit(OffsetRange.emptyAt(offset), text));
-    }
-    static replace(range, text) {
-        return ( new SingleOffsetEdit(range, text));
-    }
-    constructor(replaceRange, newText) {
-        this.replaceRange = replaceRange;
-        this.newText = newText;
-    }
-    toString() {
-        return `${this.replaceRange} -> "${this.newText}"`;
-    }
-    get isEmpty() {
-        return this.newText.length === 0 && this.replaceRange.length === 0;
-    }
-    apply(str) {
-        return str.substring(0, this.replaceRange.start) + this.newText + str.substring(this.replaceRange.endExclusive);
-    }
-    getRangeAfterApply() {
-        return ( new OffsetRange(this.replaceRange.start, this.replaceRange.start + this.newText.length));
-    }
-    equals(other) {
-        return this.replaceRange.equals(other.replaceRange) && this.newText === other.newText;
-    }
-}
-function joinEdits(edits1, edits2) {
-    edits1 = edits1.normalize();
-    edits2 = edits2.normalize();
-    if (edits1.isEmpty) {
-        return edits2;
-    }
-    if (edits2.isEmpty) {
-        return edits1;
-    }
-    const edit1Queue = [...edits1.edits];
-    const result = [];
-    let edit1ToEdit2 = 0;
-    for (const edit2 of edits2.edits) {
-        while (true) {
-            const edit1 = edit1Queue[0];
-            if (!edit1 || edit1.replaceRange.start + edit1ToEdit2 + edit1.newText.length >= edit2.replaceRange.start) {
-                break;
-            }
-            edit1Queue.shift();
-            result.push(edit1);
-            edit1ToEdit2 += edit1.newText.length - edit1.replaceRange.length;
-        }
-        const firstEdit1ToEdit2 = edit1ToEdit2;
-        let firstIntersecting;
-        let lastIntersecting;
-        while (true) {
-            const edit1 = edit1Queue[0];
-            if (!edit1 || edit1.replaceRange.start + edit1ToEdit2 > edit2.replaceRange.endExclusive) {
-                break;
-            }
-            if (!firstIntersecting) {
-                firstIntersecting = edit1;
-            }
-            lastIntersecting = edit1;
-            edit1Queue.shift();
-            edit1ToEdit2 += edit1.newText.length - edit1.replaceRange.length;
-        }
-        if (!firstIntersecting) {
-            result.push(( new SingleOffsetEdit(edit2.replaceRange.delta(-edit1ToEdit2), edit2.newText)));
-        }
-        else {
-            let prefix = '';
-            const prefixLength = edit2.replaceRange.start - (firstIntersecting.replaceRange.start + firstEdit1ToEdit2);
-            if (prefixLength > 0) {
-                prefix = firstIntersecting.newText.slice(0, prefixLength);
-            }
-            const suffixLength = (lastIntersecting.replaceRange.endExclusive + edit1ToEdit2) - edit2.replaceRange.endExclusive;
-            if (suffixLength > 0) {
-                const e = ( new SingleOffsetEdit(
-                    OffsetRange.ofStartAndLength(lastIntersecting.replaceRange.endExclusive, 0),
-                    lastIntersecting.newText.slice(-suffixLength)
-                ));
-                edit1Queue.unshift(e);
-                edit1ToEdit2 -= e.newText.length - e.replaceRange.length;
-            }
-            const newText = prefix + edit2.newText;
-            const newReplaceRange = ( new OffsetRange(
-                Math.min(firstIntersecting.replaceRange.start, edit2.replaceRange.start - firstEdit1ToEdit2),
-                edit2.replaceRange.endExclusive - edit1ToEdit2
-            ));
-            result.push(( new SingleOffsetEdit(newReplaceRange, newText)));
-        }
-    }
-    while (true) {
-        const item = edit1Queue.shift();
-        if (!item) {
-            break;
-        }
-        result.push(item);
-    }
-    return ( new OffsetEdit(result)).normalize();
-}
-function applyEditsToRanges(sortedRanges, edits) {
-    sortedRanges = sortedRanges.slice();
-    const result = [];
-    let offset = 0;
-    for (const e of edits.edits) {
-        while (true) {
-            const r = sortedRanges[0];
-            if (!r || r.endExclusive >= e.replaceRange.start) {
-                break;
-            }
-            sortedRanges.shift();
-            result.push(r.delta(offset));
-        }
-        const intersecting = [];
-        while (true) {
-            const r = sortedRanges[0];
-            if (!r || !r.intersectsOrTouches(e.replaceRange)) {
-                break;
-            }
-            sortedRanges.shift();
-            intersecting.push(r);
-        }
-        for (let i = intersecting.length - 1; i >= 0; i--) {
-            let r = intersecting[i];
-            const overlap = r.intersect(e.replaceRange).length;
-            r = r.deltaEnd(-overlap + (i === 0 ? e.newText.length : 0));
-            const rangeAheadOfReplaceRange = r.start - e.replaceRange.start;
-            if (rangeAheadOfReplaceRange > 0) {
-                r = r.delta(-rangeAheadOfReplaceRange);
-            }
-            if (i !== 0) {
-                r = r.delta(e.newText.length);
-            }
-            r = r.delta(-(e.newText.length - e.replaceRange.length));
-            sortedRanges.unshift(r);
-        }
-        offset += e.newText.length - e.replaceRange.length;
-    }
-    while (true) {
-        const r = sortedRanges[0];
-        if (!r) {
-            break;
-        }
-        sortedRanges.shift();
-        result.push(r.delta(offset));
-    }
-    return result;
-}
-
-export { OffsetEdit, SingleOffsetEdit, applyEditsToRanges };

package/vscode/src/vs/editor/common/core/textEdit.d.ts

@@ -1,71 +0,0 @@
-import { ISingleEditOperation } from "./editOperation.js";
-import { LineRange } from "./lineRange.js";
-import { OffsetEdit } from "./offsetEdit.js";
-import { Position } from "./position.js";
-import { PositionOffsetTransformer } from "./positionToOffset.js";
-import { Range } from "./range.js";
-import { TextLength } from "./textLength.js";
-export declare class TextEdit {
-    readonly edits: readonly SingleTextEdit[];
-    static fromOffsetEdit(edit: OffsetEdit, initialState: AbstractText): TextEdit;
-    static single(originalRange: Range, newText: string): TextEdit;
-    static insert(position: Position, newText: string): TextEdit;
-    constructor(edits: readonly SingleTextEdit[]);
-    normalize(): TextEdit;
-    mapPosition(position: Position): Position | Range;
-    mapRange(range: Range): Range;
-    inverseMapPosition(positionAfterEdit: Position, doc: AbstractText): Position | Range;
-    inverseMapRange(range: Range, doc: AbstractText): Range;
-    apply(text: AbstractText): string;
-    applyToString(str: string): string;
-    inverse(doc: AbstractText): TextEdit;
-    getNewRanges(): Range[];
-    toSingle(text: AbstractText): SingleTextEdit;
-    equals(other: TextEdit): boolean;
-    toString(text: AbstractText | string | undefined): string;
-}
-export declare class SingleTextEdit {
-    readonly range: Range;
-    readonly text: string;
-    static joinEdits(edits: SingleTextEdit[], initialValue: AbstractText): SingleTextEdit;
-    constructor(range: Range, text: string);
-    get isEmpty(): boolean;
-    static equals(first: SingleTextEdit, second: SingleTextEdit): boolean;
-    toSingleEditOperation(): ISingleEditOperation;
-    toEdit(): TextEdit;
-    equals(other: SingleTextEdit): boolean;
-    extendToCoverRange(range: Range, initialValue: AbstractText): SingleTextEdit;
-    extendToFullLine(initialValue: AbstractText): SingleTextEdit;
-    removeCommonPrefix(text: AbstractText): SingleTextEdit;
-    isEffectiveDeletion(text: AbstractText): boolean;
-}
-export declare abstract class AbstractText {
-    abstract getValueOfRange(range: Range): string;
-    abstract readonly length: TextLength;
-    get endPositionExclusive(): Position;
-    get lineRange(): LineRange;
-    getValue(): string;
-    getLineLength(lineNumber: number): number;
-    private _transformer;
-    getTransformer(): PositionOffsetTransformer;
-    getLineAt(lineNumber: number): string;
-    getLines(): string[];
-}
-export declare class LineBasedText extends AbstractText {
-    private readonly _getLineContent;
-    private readonly _lineCount;
-    constructor(_getLineContent: (lineNumber: number) => string, _lineCount: number);
-    getValueOfRange(range: Range): string;
-    getLineLength(lineNumber: number): number;
-    get length(): TextLength;
-}
-export declare class ArrayText extends LineBasedText {
-    constructor(lines: string[]);
-}
-export declare class StringText extends AbstractText {
-    readonly value: string;
-    private readonly _t;
-    constructor(value: string);
-    getValueOfRange(range: Range): string;
-    get length(): TextLength;
-}

package/vscode/src/vs/editor/common/model/textModelOffsetEdit.d.ts

@@ -1,10 +0,0 @@
-import { OffsetEdit } from "../core/offsetEdit.js";
-import { DetailedLineRangeMapping } from "../diff/rangeMapping.js";
-import { ITextModel, IIdentifiedSingleEditOperation } from "../model.js";
-import { IModelContentChange } from "../textModelEvents.js";
-export declare abstract class OffsetEdits {
-    private constructor();
-    static asEditOperations(offsetEdit: OffsetEdit, doc: ITextModel): IIdentifiedSingleEditOperation[];
-    static fromContentChanges(contentChanges: readonly IModelContentChange[]): OffsetEdit;
-    static fromLineRangeMapping(original: ITextModel, modified: ITextModel, changes: readonly DetailedLineRangeMapping[]): OffsetEdit;
-}

package/vscode/src/vs/editor/common/model/textModelOffsetEdit.js

@@ -1,39 +0,0 @@
-
-import { EditOperation } from '../core/editOperation.js';
-import { Range } from '../core/range.js';
-import { SingleOffsetEdit, OffsetEdit } from '../core/offsetEdit.js';
-import { OffsetRange } from '../core/offsetRange.js';
-
-class OffsetEdits {
-    constructor() {
-    }
-    static asEditOperations(offsetEdit, doc) {
-        const edits = [];
-        for (const singleEdit of offsetEdit.edits) {
-            const range = Range.fromPositions(doc.getPositionAt(singleEdit.replaceRange.start), doc.getPositionAt(singleEdit.replaceRange.start + singleEdit.replaceRange.length));
-            edits.push(EditOperation.replace(range, singleEdit.newText));
-        }
-        return edits;
-    }
-    static fromContentChanges(contentChanges) {
-        const editsArr = ( contentChanges.map(c => ( new SingleOffsetEdit(OffsetRange.ofStartAndLength(c.rangeOffset, c.rangeLength), c.text))));
-        editsArr.reverse();
-        const edits = ( new OffsetEdit(editsArr));
-        return edits;
-    }
-    static fromLineRangeMapping(original, modified, changes) {
-        const edits = [];
-        for (const c of changes) {
-            for (const i of c.innerChanges ?? []) {
-                const newText = modified.getValueInRange(i.modifiedRange);
-                const startOrig = original.getOffsetAt(i.originalRange.getStartPosition());
-                const endExOrig = original.getOffsetAt(i.originalRange.getEndPosition());
-                const origRange = ( new OffsetRange(startOrig, endExOrig));
-                edits.push(( new SingleOffsetEdit(origRange, newText)));
-            }
-        }
-        return ( new OffsetEdit(edits));
-    }
-}
-
-export { OffsetEdits };