@codingame/monaco-vscode-api 17.2.1 → 18.0.1

package/vscode/src/vs/editor/common/core/edits/lengthEdit.js

@@ -0,0 +1,92 @@
+
+import { OffsetRange } from '../ranges/offsetRange.js';
+import { BaseEdit, BaseReplacement } from './edit.js';
+
+class LengthEdit extends BaseEdit {
+    static { this.empty = ( new LengthEdit([])); }
+    static fromEdit(edit) {
+        return ( new LengthEdit(( edit.replacements.map(r => ( new LengthReplacement(r.replaceRange, r.getNewLength()))))));
+    }
+    static create(replacements) {
+        return ( new LengthEdit(replacements));
+    }
+    static single(replacement) {
+        return ( new LengthEdit([replacement]));
+    }
+    static replace(range, newLength) {
+        return ( new LengthEdit([( new LengthReplacement(range, newLength))]));
+    }
+    static insert(offset, newLength) {
+        return ( new LengthEdit([( new LengthReplacement(OffsetRange.emptyAt(offset), newLength))]));
+    }
+    static delete(range) {
+        return ( new LengthEdit([( new LengthReplacement(range, 0))]));
+    }
+    static compose(edits) {
+        let e = LengthEdit.empty;
+        for (const edit of edits) {
+            e = e.compose(edit);
+        }
+        return e;
+    }
+    inverse() {
+        const edits = [];
+        let offset = 0;
+        for (const e of this.replacements) {
+            edits.push(( new LengthReplacement(
+                OffsetRange.ofStartAndLength(e.replaceRange.start + offset, e.newLength),
+                e.replaceRange.length
+            )));
+            offset += e.newLength - e.replaceRange.length;
+        }
+        return ( new LengthEdit(edits));
+    }
+    _createNew(replacements) {
+        return ( new LengthEdit(replacements));
+    }
+    applyArray(arr, fillItem) {
+        const newArr = ( new Array(this.getNewDataLength(arr.length)));
+        let srcPos = 0;
+        let dstPos = 0;
+        for (const replacement of this.replacements) {
+            for (let i = srcPos; i < replacement.replaceRange.start; i++) {
+                newArr[dstPos++] = arr[i];
+            }
+            srcPos = replacement.replaceRange.endExclusive;
+            for (let i = 0; i < replacement.newLength; i++) {
+                newArr[dstPos++] = fillItem;
+            }
+        }
+        while (srcPos < arr.length) {
+            newArr[dstPos++] = arr[srcPos++];
+        }
+        return newArr;
+    }
+}
+class LengthReplacement extends BaseReplacement {
+    static create(startOffset, endOffsetExclusive, newLength) {
+        return ( new LengthReplacement(( new OffsetRange(startOffset, endOffsetExclusive)), newLength));
+    }
+    constructor(range, newLength) {
+        super(range);
+        this.newLength = newLength;
+    }
+    equals(other) {
+        return this.replaceRange.equals(other.replaceRange) && this.newLength === other.newLength;
+    }
+    getNewLength() { return this.newLength; }
+    tryJoinTouching(other) {
+        return ( new LengthReplacement(
+            this.replaceRange.joinRightTouching(other.replaceRange),
+            this.newLength + other.newLength
+        ));
+    }
+    slice(range, rangeInReplacement) {
+        return ( new LengthReplacement(range, rangeInReplacement.length));
+    }
+    toString() {
+        return `[${this.replaceRange.start}, +${this.replaceRange.length}) -> +${this.newLength}}`;
+    }
+}
+
+export { LengthEdit, LengthReplacement };

package/vscode/src/vs/editor/common/core/{lineEdit.d.ts → edits/lineEdit.d.ts}

@@ -1,15 +1,16 @@
-import { LineRange } from "./lineRange.js";
-import { OffsetEdit, SingleOffsetEdit } from "./offsetEdit.js";
-import { AbstractText, SingleTextEdit, TextEdit } from "./textEdit.js";
+import { LineRange } from "../ranges/lineRange.js";
+import { StringEdit, StringReplacement } from "./stringEdit.js";
+import { TextReplacement, TextEdit } from "./textEdit.js";
+import { AbstractText } from "../text/abstractText.js";
 export declare class LineEdit {
     readonly edits: readonly SingleLineEdit[];
     static readonly empty: LineEdit;
     static deserialize(data: SerializedLineEdit): LineEdit;
-    static fromEdit(edit: OffsetEdit, initialValue: AbstractText): LineEdit;
+    static fromEdit(edit: StringEdit, initialValue: AbstractText): LineEdit;
     static fromTextEdit(edit: TextEdit, initialValue: AbstractText): LineEdit;
     static createFromUnsorted(edits: readonly SingleLineEdit[]): LineEdit;
     constructor(edits: readonly SingleLineEdit[]);
-    toEdit(initialValue: AbstractText): OffsetEdit;
+    toEdit(initialValue: AbstractText): StringEdit;
     toString(): string;
     serialize(): SerializedLineEdit;
     getNewLineRanges(): LineRange[];
@@ -24,10 +25,10 @@ export declare class SingleLineEdit {
     readonly lineRange: LineRange;
     readonly newLines: readonly string[];
     static deserialize(e: SerializedSingleLineEdit): SingleLineEdit;
-    static fromSingleTextEdit(edit: SingleTextEdit, initialValue: AbstractText): SingleLineEdit;
+    static fromSingleTextEdit(edit: TextReplacement, initialValue: AbstractText): SingleLineEdit;
     constructor(lineRange: LineRange, newLines: readonly string[]);
-    toSingleTextEdit(initialValue: AbstractText): SingleTextEdit;
-    toSingleEdit(initialValue: AbstractText): SingleOffsetEdit;
+    toSingleTextEdit(initialValue: AbstractText): TextReplacement;
+    toSingleEdit(initialValue: AbstractText): StringReplacement;
     toString(): string;
     serialize(): SerializedSingleLineEdit;
     removeCommonSuffixPrefixLines(initialValue: AbstractText): SingleLineEdit;

package/vscode/src/vs/editor/common/core/{lineEdit.js → edits/lineEdit.js}

@@ -1,12 +1,12 @@
 
-import { compareBy, numberComparator, groupAdjacentBy } from '../../../base/common/arrays.js';
-import { assert, checkAdjacentItems } from '../../../base/common/assert.js';
-import { splitLines } from '../../../base/common/strings.js';
-import { LineRange } from './lineRange.js';
-import { OffsetEdit, SingleOffsetEdit } from './offsetEdit.js';
-import { Position } from './position.js';
-import { Range } from './range.js';
-import { TextEdit, SingleTextEdit } from './textEdit.js';
+import { compareBy, numberComparator, groupAdjacentBy } from '../../../../base/common/arrays.js';
+import { assert, checkAdjacentItems } from '../../../../base/common/assert.js';
+import { splitLines } from '../../../../base/common/strings.js';
+import { LineRange } from '../ranges/lineRange.js';
+import { StringEdit, StringReplacement } from './stringEdit.js';
+import { Position } from '../position.js';
+import { Range } from '../range.js';
+import { TextEdit, TextReplacement } from './textEdit.js';
 
 class LineEdit {
     static { this.empty = ( new LineEdit([])); }
@@ -14,11 +14,11 @@ class LineEdit {
         return ( new LineEdit(( data.map(e => SingleLineEdit.deserialize(e)))));
     }
     static fromEdit(edit, initialValue) {
-        const textEdit = TextEdit.fromOffsetEdit(edit, initialValue);
+        const textEdit = TextEdit.fromStringEdit(edit, initialValue);
         return LineEdit.fromTextEdit(textEdit, initialValue);
     }
     static fromTextEdit(edit, initialValue) {
-        const edits = edit.edits;
+        const edits = edit.replacements;
         const result = [];
         const currentEdits = [];
         for (let i = 0; i < edits.length; i++) {
@@ -28,7 +28,7 @@ class LineEdit {
             if (nextEditRange && nextEditRange.range.startLineNumber === edit.range.endLineNumber) {
                 continue;
             }
-            const singleEdit = SingleTextEdit.joinEdits(currentEdits, initialValue);
+            const singleEdit = TextReplacement.joinReplacements(currentEdits, initialValue);
             currentEdits.length = 0;
             const singleLineEdit = SingleLineEdit.fromSingleTextEdit(singleEdit, initialValue);
             result.push(singleLineEdit);
@@ -51,7 +51,7 @@ class LineEdit {
             const singleEdit = edit.toSingleEdit(initialValue);
             edits.push(singleEdit);
         }
-        return ( new OffsetEdit(edits));
+        return ( new StringEdit(edits));
     }
     toString() {
         return ( this.edits.map(e => ( e.toString()))).join(',');
@@ -199,10 +199,10 @@ class SingleLineEdit {
                     startPos = ( new Position(1, 1));
                 }
                 const lastPosition = textLen.addToPosition(( new Position(1, 1)));
-                return ( new SingleTextEdit(Range.fromPositions(startPos, lastPosition), ''));
+                return ( new TextReplacement(Range.fromPositions(startPos, lastPosition), ''));
             }
             else {
-                return ( new SingleTextEdit(( new Range(
+                return ( new TextReplacement(( new Range(
                     this.lineRange.startLineNumber,
                     1,
                     this.lineRange.endLineNumberExclusive,
@@ -225,20 +225,20 @@ class SingleLineEdit {
                 column = 1;
                 text = ( this.newLines.map(l => l + '\n')).join('');
             }
-            return ( new SingleTextEdit(Range.fromPositions(( new Position(endLineNumber, column))), text));
+            return ( new TextReplacement(Range.fromPositions(( new Position(endLineNumber, column))), text));
         }
         else {
             const endLineNumber = this.lineRange.endLineNumberExclusive - 1;
             const endLineNumberMaxColumn = initialValue.getTransformer().getLineLength(endLineNumber) + 1;
             const range = ( new Range(this.lineRange.startLineNumber, 1, endLineNumber, endLineNumberMaxColumn));
             const text = this.newLines.join('\n');
-            return ( new SingleTextEdit(range, text));
+            return ( new TextReplacement(range, text));
         }
     }
     toSingleEdit(initialValue) {
         const textEdit = this.toSingleTextEdit(initialValue);
         const range = initialValue.getTransformer().getOffsetRange(textEdit.range);
-        return ( new SingleOffsetEdit(range, textEdit.text));
+        return ( new StringReplacement(range, textEdit.text));
     }
     toString() {
         return `${this.lineRange}->${JSON.stringify(this.newLines)}`;

package/vscode/src/vs/editor/common/core/edits/stringEdit.d.ts

@@ -0,0 +1,43 @@
+import { OffsetRange } from "../ranges/offsetRange.js";
+import { BaseEdit, BaseReplacement } from "./edit.js";
+export declare class StringEdit extends BaseEdit<StringReplacement, StringEdit> {
+    static readonly empty: StringEdit;
+    static create(replacements: readonly StringReplacement[]): StringEdit;
+    static single(replacement: StringReplacement): StringEdit;
+    static replace(range: OffsetRange, replacement: string): StringEdit;
+    static insert(offset: number, replacement: string): StringEdit;
+    static delete(range: OffsetRange): StringEdit;
+    static fromJson(data: ISerializedStringEdit): StringEdit;
+    static compose(edits: readonly StringEdit[]): StringEdit;
+    constructor(replacements: readonly StringReplacement[]);
+    protected _createNew(replacements: readonly StringReplacement[]): StringEdit;
+    apply(base: string): string;
+    inverse(baseStr: string): StringEdit;
+    tryRebase(base: StringEdit): StringEdit;
+    tryRebase(base: StringEdit, noOverlap: true): StringEdit | undefined;
+    toJson(): ISerializedStringEdit;
+    isNeutralOn(text: string): boolean;
+    removeCommonSuffixPrefix(originalText: string): StringEdit;
+}
+export type ISerializedStringEdit = ISerializedStringReplacement[];
+export interface ISerializedStringReplacement {
+    txt: string;
+    pos: number;
+    len: number;
+}
+export declare class StringReplacement extends BaseReplacement<StringReplacement> {
+    readonly newText: string;
+    static insert(offset: number, text: string): StringReplacement;
+    static replace(range: OffsetRange, text: string): StringReplacement;
+    static fromJson(data: ISerializedStringReplacement): StringReplacement;
+    constructor(range: OffsetRange, newText: string);
+    equals(other: StringReplacement): boolean;
+    getNewLength(): number;
+    tryJoinTouching(other: StringReplacement): StringReplacement | undefined;
+    slice(range: OffsetRange, rangeInReplacement: OffsetRange): StringReplacement;
+    toString(): string;
+    replace(str: string): string;
+    isNeutralOn(text: string): boolean;
+    removeCommonSuffixPrefix(originalText: string): StringReplacement;
+}
+export declare function applyEditsToRanges(sortedRanges: OffsetRange[], edit: StringEdit): OffsetRange[];

package/vscode/src/vs/editor/common/core/edits/stringEdit.js

@@ -0,0 +1,215 @@
+
+import { commonPrefixLength, commonSuffixLength } from '../../../../base/common/strings.js';
+import { OffsetRange } from '../ranges/offsetRange.js';
+import { BaseEdit, BaseReplacement } from './edit.js';
+
+class StringEdit extends BaseEdit {
+    static { this.empty = ( new StringEdit([])); }
+    static create(replacements) {
+        return ( new StringEdit(replacements));
+    }
+    static single(replacement) {
+        return ( new StringEdit([replacement]));
+    }
+    static replace(range, replacement) {
+        return ( new StringEdit([( new StringReplacement(range, replacement))]));
+    }
+    static insert(offset, replacement) {
+        return ( new StringEdit([( new StringReplacement(OffsetRange.emptyAt(offset), replacement))]));
+    }
+    static delete(range) {
+        return ( new StringEdit([( new StringReplacement(range, ''))]));
+    }
+    static fromJson(data) {
+        return ( new StringEdit(( data.map(StringReplacement.fromJson))));
+    }
+    static compose(edits) {
+        if (edits.length === 0) {
+            return StringEdit.empty;
+        }
+        let result = edits[0];
+        for (let i = 1; i < edits.length; i++) {
+            result = result.compose(edits[i]);
+        }
+        return result;
+    }
+    constructor(replacements) {
+        super(replacements);
+    }
+    _createNew(replacements) {
+        return ( new StringEdit(replacements));
+    }
+    apply(base) {
+        const resultText = [];
+        let pos = 0;
+        for (const edit of this.replacements) {
+            resultText.push(base.substring(pos, edit.replaceRange.start));
+            resultText.push(edit.newText);
+            pos = edit.replaceRange.endExclusive;
+        }
+        resultText.push(base.substring(pos));
+        return resultText.join('');
+    }
+    inverse(baseStr) {
+        const edits = [];
+        let offset = 0;
+        for (const e of this.replacements) {
+            edits.push(( new StringReplacement(
+                OffsetRange.ofStartAndLength(e.replaceRange.start + offset, e.newText.length),
+                baseStr.substring(e.replaceRange.start, e.replaceRange.endExclusive)
+            )));
+            offset += e.newText.length - e.replaceRange.length;
+        }
+        return ( new StringEdit(edits));
+    }
+    tryRebase(base, noOverlap) {
+        const newEdits = [];
+        let baseIdx = 0;
+        let ourIdx = 0;
+        let offset = 0;
+        while (ourIdx < this.replacements.length || baseIdx < base.replacements.length) {
+            const baseEdit = base.replacements[baseIdx];
+            const ourEdit = this.replacements[ourIdx];
+            if (!ourEdit) {
+                break;
+            }
+            else if (!baseEdit) {
+                newEdits.push(( new StringReplacement(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 StringReplacement(ourEdit.replaceRange.delta(offset), ourEdit.newText)));
+                ourIdx++;
+            }
+            else {
+                baseIdx++;
+                offset += baseEdit.newText.length - baseEdit.replaceRange.length;
+            }
+        }
+        return ( new StringEdit(newEdits));
+    }
+    toJson() {
+        return ( this.replacements.map(e => ({
+            txt: e.newText,
+            pos: e.replaceRange.start,
+            len: e.replaceRange.length,
+        })));
+    }
+    isNeutralOn(text) {
+        return this.replacements.every(e => e.isNeutralOn(text));
+    }
+    removeCommonSuffixPrefix(originalText) {
+        const edits = [];
+        for (const e of this.replacements) {
+            const edit = e.removeCommonSuffixPrefix(originalText);
+            if (!edit.isEmpty) {
+                edits.push(edit);
+            }
+        }
+        return ( new StringEdit(edits));
+    }
+}
+class StringReplacement extends BaseReplacement {
+    static insert(offset, text) {
+        return ( new StringReplacement(OffsetRange.emptyAt(offset), text));
+    }
+    static replace(range, text) {
+        return ( new StringReplacement(range, text));
+    }
+    static fromJson(data) {
+        return ( new StringReplacement(OffsetRange.ofStartAndLength(data.pos, data.len), data.txt));
+    }
+    constructor(range, newText) {
+        super(range);
+        this.newText = newText;
+    }
+    equals(other) {
+        return this.replaceRange.equals(other.replaceRange) && this.newText === other.newText;
+    }
+    getNewLength() { return this.newText.length; }
+    tryJoinTouching(other) {
+        return ( new StringReplacement(
+            this.replaceRange.joinRightTouching(other.replaceRange),
+            this.newText + other.newText
+        ));
+    }
+    slice(range, rangeInReplacement) {
+        return ( new StringReplacement(range, rangeInReplacement.substring(this.newText)));
+    }
+    toString() {
+        return `${this.replaceRange} -> "${this.newText}"`;
+    }
+    replace(str) {
+        return str.substring(0, this.replaceRange.start) + this.newText + str.substring(this.replaceRange.endExclusive);
+    }
+    isNeutralOn(text) {
+        return this.newText === text.substring(this.replaceRange.start, this.replaceRange.endExclusive);
+    }
+    removeCommonSuffixPrefix(originalText) {
+        const oldText = originalText.substring(this.replaceRange.start, this.replaceRange.endExclusive);
+        const prefixLen = commonPrefixLength(oldText, this.newText);
+        const suffixLen = Math.min(oldText.length - prefixLen, this.newText.length - prefixLen, commonSuffixLength(oldText, this.newText));
+        const replaceRange = ( new OffsetRange(
+            this.replaceRange.start + prefixLen,
+            this.replaceRange.endExclusive - suffixLen
+        ));
+        const newText = this.newText.substring(prefixLen, this.newText.length - suffixLen);
+        return ( new StringReplacement(replaceRange, newText));
+    }
+}
+function applyEditsToRanges(sortedRanges, edit) {
+    sortedRanges = sortedRanges.slice();
+    const result = [];
+    let offset = 0;
+    for (const e of edit.replacements) {
+        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 { StringEdit, StringReplacement, applyEditsToRanges };

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

@@ -0,0 +1,39 @@
+import { ISingleEditOperation } from "../editOperation.js";
+import { StringEdit } from "./stringEdit.js";
+import { Position } from "../position.js";
+import { Range } from "../range.js";
+import { AbstractText } from "../text/abstractText.js";
+export declare class TextEdit {
+    readonly replacements: readonly TextReplacement[];
+    static fromStringEdit(edit: StringEdit, initialState: AbstractText): TextEdit;
+    static replace(originalRange: Range, newText: string): TextEdit;
+    static insert(position: Position, newText: string): TextEdit;
+    constructor(replacements: readonly TextReplacement[]);
+    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[];
+    toReplacement(text: AbstractText): TextReplacement;
+    equals(other: TextEdit): boolean;
+    toString(text: AbstractText | string | undefined): string;
+}
+export declare class TextReplacement {
+    readonly range: Range;
+    readonly text: string;
+    static joinReplacements(replacements: TextReplacement[], initialValue: AbstractText): TextReplacement;
+    constructor(range: Range, text: string);
+    get isEmpty(): boolean;
+    static equals(first: TextReplacement, second: TextReplacement): boolean;
+    toSingleEditOperation(): ISingleEditOperation;
+    toEdit(): TextEdit;
+    equals(other: TextReplacement): boolean;
+    extendToCoverRange(range: Range, initialValue: AbstractText): TextReplacement;
+    extendToFullLine(initialValue: AbstractText): TextReplacement;
+    removeCommonPrefix(text: AbstractText): TextReplacement;
+    isEffectiveDeletion(text: AbstractText): boolean;
+}