@codingame/monaco-vscode-api 17.2.1 → 18.0.1

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

@@ -1,52 +1,52 @@
 
-import { equals } from '../../../base/common/arrays.js';
-import { assertFn, checkAdjacentItems, assert } from '../../../base/common/assert.js';
-import { BugIndicatingError } from '../../../base/common/errors.js';
-import { commonPrefixLength, commonSuffixLength, splitLines } from '../../../base/common/strings.js';
-import { Position } from './position.js';
-import { PositionOffsetTransformer } from './positionToOffset.js';
-import { Range } from './range.js';
-import { TextLength } from './textLength.js';
+import { equals } from '../../../../base/common/arrays.js';
+import { assertFn, checkAdjacentItems } from '../../../../base/common/assert.js';
+import { BugIndicatingError } from '../../../../base/common/errors.js';
+import { commonPrefixLength, commonSuffixLength } from '../../../../base/common/strings.js';
+import { Position } from '../position.js';
+import { Range } from '../range.js';
+import { TextLength } from '../text/textLength.js';
+import { StringText } from '../text/abstractText.js';
 
 class TextEdit {
-    static fromOffsetEdit(edit, initialState) {
-        const edits = ( edit.edits.map(e => ( new SingleTextEdit(initialState.getTransformer().getRange(e.replaceRange), e.newText))));
+    static fromStringEdit(edit, initialState) {
+        const edits = ( edit.replacements.map(e => ( new TextReplacement(initialState.getTransformer().getRange(e.replaceRange), e.newText))));
         return ( new TextEdit(edits));
     }
-    static single(originalRange, newText) {
-        return ( new TextEdit([( new SingleTextEdit(originalRange, newText))]));
+    static replace(originalRange, newText) {
+        return ( new TextEdit([( new TextReplacement(originalRange, newText))]));
     }
     static insert(position, newText) {
-        return ( new TextEdit([( new SingleTextEdit(Range.fromPositions(position, position), newText))]));
+        return ( new TextEdit([( new TextReplacement(Range.fromPositions(position, position), newText))]));
     }
-    constructor(edits) {
-        this.edits = edits;
-        assertFn(() => checkAdjacentItems(edits, (a, b) => a.range.getEndPosition().isBeforeOrEqual(b.range.getStartPosition())));
+    constructor(replacements) {
+        this.replacements = replacements;
+        assertFn(() => checkAdjacentItems(replacements, (a, b) => a.range.getEndPosition().isBeforeOrEqual(b.range.getStartPosition())));
     }
     normalize() {
-        const edits = [];
-        for (const edit of this.edits) {
-            if (edits.length > 0 && edits[edits.length - 1].range.getEndPosition().equals(edit.range.getStartPosition())) {
-                const last = edits[edits.length - 1];
-                edits[edits.length - 1] = ( new SingleTextEdit(last.range.plusRange(edit.range), last.text + edit.text));
+        const replacements = [];
+        for (const r of this.replacements) {
+            if (replacements.length > 0 && replacements[replacements.length - 1].range.getEndPosition().equals(r.range.getStartPosition())) {
+                const last = replacements[replacements.length - 1];
+                replacements[replacements.length - 1] = ( new TextReplacement(last.range.plusRange(r.range), last.text + r.text));
             }
-            else if (!edit.isEmpty) {
-                edits.push(edit);
+            else if (!r.isEmpty) {
+                replacements.push(r);
             }
         }
-        return ( new TextEdit(edits));
+        return ( new TextEdit(replacements));
     }
     mapPosition(position) {
         let lineDelta = 0;
         let curLine = 0;
         let columnDeltaInCurLine = 0;
-        for (const edit of this.edits) {
-            const start = edit.range.getStartPosition();
+        for (const replacement of this.replacements) {
+            const start = replacement.range.getStartPosition();
             if (position.isBeforeOrEqual(start)) {
                 break;
             }
-            const end = edit.range.getEndPosition();
-            const len = TextLength.ofText(edit.text);
+            const end = replacement.range.getEndPosition();
+            const len = TextLength.ofText(replacement.text);
             if (position.isBefore(end)) {
                 const startPos = ( new Position(
                     start.lineNumber + lineDelta,
@@ -58,7 +58,7 @@ class TextEdit {
             if (start.lineNumber + lineDelta !== curLine) {
                 columnDeltaInCurLine = 0;
             }
-            lineDelta += len.lineCount - (edit.range.endLineNumber - edit.range.startLineNumber);
+            lineDelta += len.lineCount - (replacement.range.endLineNumber - replacement.range.startLineNumber);
             if (len.lineCount === 0) {
                 if (end.lineNumber !== start.lineNumber) {
                     columnDeltaInCurLine += len.columnCount - (end.column - 1);
@@ -99,15 +99,15 @@ class TextEdit {
     apply(text) {
         let result = '';
         let lastEditEnd = ( new Position(1, 1));
-        for (const edit of this.edits) {
-            const editRange = edit.range;
+        for (const replacement of this.replacements) {
+            const editRange = replacement.range;
             const editStart = editRange.getStartPosition();
             const editEnd = editRange.getEndPosition();
             const r = rangeFromPositions(lastEditEnd, editStart);
             if (!r.isEmpty()) {
                 result += text.getValueOfRange(r);
             }
-            result += edit.text;
+            result += replacement.text;
             lastEditEnd = editEnd;
         }
         const r = rangeFromPositions(lastEditEnd, text.endPositionExclusive);
@@ -122,71 +122,71 @@ class TextEdit {
     }
     inverse(doc) {
         const ranges = this.getNewRanges();
-        return ( new TextEdit(( this.edits.map((e, idx) => ( new SingleTextEdit(ranges[idx], doc.getValueOfRange(e.range)))))));
+        return ( new TextEdit(( this.replacements.map((e, idx) => ( new TextReplacement(ranges[idx], doc.getValueOfRange(e.range)))))));
     }
     getNewRanges() {
         const newRanges = [];
         let previousEditEndLineNumber = 0;
         let lineOffset = 0;
         let columnOffset = 0;
-        for (const edit of this.edits) {
-            const textLength = TextLength.ofText(edit.text);
+        for (const replacement of this.replacements) {
+            const textLength = TextLength.ofText(replacement.text);
             const newRangeStart = Position.lift({
-                lineNumber: edit.range.startLineNumber + lineOffset,
-                column: edit.range.startColumn + (edit.range.startLineNumber === previousEditEndLineNumber ? columnOffset : 0)
+                lineNumber: replacement.range.startLineNumber + lineOffset,
+                column: replacement.range.startColumn + (replacement.range.startLineNumber === previousEditEndLineNumber ? columnOffset : 0)
             });
             const newRange = textLength.createRange(newRangeStart);
             newRanges.push(newRange);
-            lineOffset = newRange.endLineNumber - edit.range.endLineNumber;
-            columnOffset = newRange.endColumn - edit.range.endColumn;
-            previousEditEndLineNumber = edit.range.endLineNumber;
+            lineOffset = newRange.endLineNumber - replacement.range.endLineNumber;
+            columnOffset = newRange.endColumn - replacement.range.endColumn;
+            previousEditEndLineNumber = replacement.range.endLineNumber;
         }
         return newRanges;
     }
-    toSingle(text) {
-        if (this.edits.length === 0) {
+    toReplacement(text) {
+        if (this.replacements.length === 0) {
             throw ( new BugIndicatingError());
         }
-        if (this.edits.length === 1) {
-            return this.edits[0];
+        if (this.replacements.length === 1) {
+            return this.replacements[0];
         }
-        const startPos = this.edits[0].range.getStartPosition();
-        const endPos = this.edits[this.edits.length - 1].range.getEndPosition();
+        const startPos = this.replacements[0].range.getStartPosition();
+        const endPos = this.replacements[this.replacements.length - 1].range.getEndPosition();
         let newText = '';
-        for (let i = 0; i < this.edits.length; i++) {
-            const curEdit = this.edits[i];
+        for (let i = 0; i < this.replacements.length; i++) {
+            const curEdit = this.replacements[i];
             newText += curEdit.text;
-            if (i < this.edits.length - 1) {
-                const nextEdit = this.edits[i + 1];
+            if (i < this.replacements.length - 1) {
+                const nextEdit = this.replacements[i + 1];
                 const gapRange = Range.fromPositions(curEdit.range.getEndPosition(), nextEdit.range.getStartPosition());
                 const gapText = text.getValueOfRange(gapRange);
                 newText += gapText;
             }
         }
-        return ( new SingleTextEdit(Range.fromPositions(startPos, endPos), newText));
+        return ( new TextReplacement(Range.fromPositions(startPos, endPos), newText));
     }
     equals(other) {
-        return equals(this.edits, other.edits, (a, b) => a.equals(b));
+        return equals(this.replacements, other.replacements, (a, b) => a.equals(b));
     }
     toString(text) {
         if (text === undefined) {
-            return ( this.edits.map(edit => ( edit.toString()))).join('\n');
+            return ( this.replacements.map(edit => ( edit.toString()))).join('\n');
         }
         if (typeof text === 'string') {
             return ( this.toString(( new StringText(text))));
         }
-        if (this.edits.length === 0) {
+        if (this.replacements.length === 0) {
             return '';
         }
-        return ( this.edits.map(edit => {
+        return ( this.replacements.map(r => {
             const maxLength = 10;
-            const originalText = text.getValueOfRange(edit.range);
-            const beforeRange = Range.fromPositions(( new Position(Math.max(1, edit.range.startLineNumber - 1), 1)), edit.range.getStartPosition());
+            const originalText = text.getValueOfRange(r.range);
+            const beforeRange = Range.fromPositions(( new Position(Math.max(1, r.range.startLineNumber - 1), 1)), r.range.getStartPosition());
             let beforeText = text.getValueOfRange(beforeRange);
             if (beforeText.length > maxLength) {
                 beforeText = '...' + beforeText.substring(beforeText.length - maxLength);
             }
-            const afterRange = Range.fromPositions(edit.range.getEndPosition(), ( new Position(edit.range.endLineNumber + 1, 1)));
+            const afterRange = Range.fromPositions(r.range.getEndPosition(), ( new Position(r.range.endLineNumber + 1, 1)));
             let afterText = text.getValueOfRange(afterRange);
             if (afterText.length > maxLength) {
                 afterText = afterText.substring(0, maxLength) + '...';
@@ -197,7 +197,7 @@ class TextEdit {
                 replacedText = replacedText.substring(0, halfMax) + '...' +
                     replacedText.substring(replacedText.length - halfMax);
             }
-            let newText = edit.text;
+            let newText = r.text;
             if (newText.length > maxLength) {
                 const halfMax = Math.floor(maxLength / 2);
                 newText = newText.substring(0, halfMax) + '...' +
@@ -210,28 +210,28 @@ class TextEdit {
         })).join('\n');
     }
 }
-class SingleTextEdit {
-    static joinEdits(edits, initialValue) {
-        if (edits.length === 0) {
+class TextReplacement {
+    static joinReplacements(replacements, initialValue) {
+        if (replacements.length === 0) {
             throw ( new BugIndicatingError());
         }
-        if (edits.length === 1) {
-            return edits[0];
+        if (replacements.length === 1) {
+            return replacements[0];
         }
-        const startPos = edits[0].range.getStartPosition();
-        const endPos = edits[edits.length - 1].range.getEndPosition();
+        const startPos = replacements[0].range.getStartPosition();
+        const endPos = replacements[replacements.length - 1].range.getEndPosition();
         let newText = '';
-        for (let i = 0; i < edits.length; i++) {
-            const curEdit = edits[i];
+        for (let i = 0; i < replacements.length; i++) {
+            const curEdit = replacements[i];
             newText += curEdit.text;
-            if (i < edits.length - 1) {
-                const nextEdit = edits[i + 1];
+            if (i < replacements.length - 1) {
+                const nextEdit = replacements[i + 1];
                 const gapRange = Range.fromPositions(curEdit.range.getEndPosition(), nextEdit.range.getStartPosition());
                 const gapText = initialValue.getValueOfRange(gapRange);
                 newText += gapText;
             }
         }
-        return ( new SingleTextEdit(Range.fromPositions(startPos, endPos), newText));
+        return ( new TextReplacement(Range.fromPositions(startPos, endPos), newText));
     }
     constructor(range, text) {
         this.range = range;
@@ -253,7 +253,7 @@ class SingleTextEdit {
         return ( new TextEdit([this]));
     }
     equals(other) {
-        return SingleTextEdit.equals(this, other);
+        return TextReplacement.equals(this, other);
     }
     extendToCoverRange(range, initialValue) {
         if (this.range.containsRange(range)) {
@@ -263,7 +263,7 @@ class SingleTextEdit {
         const textBefore = initialValue.getValueOfRange(Range.fromPositions(newRange.getStartPosition(), this.range.getStartPosition()));
         const textAfter = initialValue.getValueOfRange(Range.fromPositions(this.range.getEndPosition(), newRange.getEndPosition()));
         const newText = textBefore + this.text + textAfter;
-        return ( new SingleTextEdit(newRange, newText));
+        return ( new TextReplacement(newRange, newText));
     }
     extendToFullLine(initialValue) {
         const newRange = ( new Range(
@@ -282,7 +282,7 @@ class SingleTextEdit {
             .addToPosition(this.range.getStartPosition());
         const newText = normalizedModifiedText.substring(commonPrefixLen);
         const range = Range.fromPositions(start, this.range.getEndPosition());
-        return ( new SingleTextEdit(range, newText));
+        return ( new TextReplacement(range, newText));
     }
     isEffectiveDeletion(text) {
         let newText = this.text.replaceAll('\r\n', '\n');
@@ -305,79 +305,5 @@ function rangeFromPositions(start, end) {
     }
     return ( new Range(start.lineNumber, start.column, end.lineNumber, end.column));
 }
-class AbstractText {
-    constructor() {
-        this._transformer = undefined;
-    }
-    get endPositionExclusive() {
-        return this.length.addToPosition(( new Position(1, 1)));
-    }
-    get lineRange() {
-        return this.length.toLineRange();
-    }
-    getValue() {
-        return this.getValueOfRange(this.length.toRange());
-    }
-    getLineLength(lineNumber) {
-        return this.getValueOfRange(( new Range(lineNumber, 1, lineNumber, Number.MAX_SAFE_INTEGER))).length;
-    }
-    getTransformer() {
-        if (!this._transformer) {
-            this._transformer = ( new PositionOffsetTransformer(this.getValue()));
-        }
-        return this._transformer;
-    }
-    getLineAt(lineNumber) {
-        return this.getValueOfRange(( new Range(lineNumber, 1, lineNumber, Number.MAX_SAFE_INTEGER)));
-    }
-    getLines() {
-        const value = this.getValue();
-        return splitLines(value);
-    }
-}
-class LineBasedText extends AbstractText {
-    constructor(_getLineContent, _lineCount) {
-        assert(_lineCount >= 1);
-        super();
-        this._getLineContent = _getLineContent;
-        this._lineCount = _lineCount;
-    }
-    getValueOfRange(range) {
-        if (range.startLineNumber === range.endLineNumber) {
-            return this._getLineContent(range.startLineNumber).substring(range.startColumn - 1, range.endColumn - 1);
-        }
-        let result = this._getLineContent(range.startLineNumber).substring(range.startColumn - 1);
-        for (let i = range.startLineNumber + 1; i < range.endLineNumber; i++) {
-            result += '\n' + this._getLineContent(i);
-        }
-        result += '\n' + this._getLineContent(range.endLineNumber).substring(0, range.endColumn - 1);
-        return result;
-    }
-    getLineLength(lineNumber) {
-        return this._getLineContent(lineNumber).length;
-    }
-    get length() {
-        const lastLine = this._getLineContent(this._lineCount);
-        return ( new TextLength(this._lineCount - 1, lastLine.length));
-    }
-}
-class ArrayText extends LineBasedText {
-    constructor(lines) {
-        super(lineNumber => lines[lineNumber - 1], lines.length);
-    }
-}
-class StringText extends AbstractText {
-    constructor(value) {
-        super();
-        this.value = value;
-        this._t = ( new PositionOffsetTransformer(this.value));
-    }
-    getValueOfRange(range) {
-        return this._t.getOffsetRange(range).substring(this.value);
-    }
-    get length() {
-        return this._t.textLength;
-    }
-}
 
-export { AbstractText, ArrayText, LineBasedText, SingleTextEdit, StringText, TextEdit };
+export { TextEdit, TextReplacement };

package/vscode/src/vs/editor/common/core/{eolCounter.js → misc/eolCounter.js}

@@ -1,5 +1,5 @@
 
-import { CharCode } from '../../../base/common/charCode.js';
+import { CharCode } from '../../../../base/common/charCode.js';
 
 var StringEOL;
 (function (StringEOL) {

package/vscode/src/vs/editor/common/core/{indentation.js → misc/indentation.js}

@@ -1,6 +1,6 @@
 
-import { firstNonWhitespaceIndex } from '../../../base/common/strings.js';
-import { CursorColumns } from './cursorColumns.js';
+import { firstNonWhitespaceIndex } from '../../../../base/common/strings.js';
+import { CursorColumns } from '../cursorColumns.js';
 
 function _normalizeIndentationFromWhitespace(str, indentSize, insertSpaces) {
     let spacesCnt = 0;

package/vscode/src/vs/editor/common/core/{columnRange.d.ts → ranges/columnRange.d.ts}

@@ -1,5 +1,5 @@
 import { OffsetRange } from "./offsetRange.js";
-import { Range } from "./range.js";
+import { Range } from "../range.js";
 export declare class ColumnRange {
     readonly startColumn: number;
     readonly endColumnExclusive: number;

package/vscode/src/vs/editor/common/core/{columnRange.js → ranges/columnRange.js}

@@ -1,7 +1,7 @@
 
-import { BugIndicatingError } from '../../../base/common/errors.js';
+import { BugIndicatingError } from '../../../../base/common/errors.js';
 import { OffsetRange } from './offsetRange.js';
-import { Range } from './range.js';
+import { Range } from '../range.js';
 
 class ColumnRange {
     static fromOffsetRange(offsetRange) {

package/vscode/src/vs/editor/common/core/{lineRange.d.ts → ranges/lineRange.d.ts}

@@ -1,17 +1,20 @@
 import { OffsetRange } from "./offsetRange.js";
-import { Range } from "./range.js";
+import { Range } from "../range.js";
+import { Comparator } from "../../../../base/common/arrays.js";
 export declare class LineRange {
+    static ofLength(startLineNumber: number, length: number): LineRange;
     static fromRange(range: Range): LineRange;
     static fromRangeInclusive(range: Range): LineRange;
+    static readonly compareByStart: Comparator<LineRange>;
     static subtract(a: LineRange, b: LineRange | undefined): LineRange[];
     static joinMany(lineRanges: readonly (readonly LineRange[])[]): readonly LineRange[];
     static join(lineRanges: LineRange[]): LineRange;
-    static ofLength(startLineNumber: number, length: number): LineRange;
     static deserialize(lineRange: ISerializedLineRange): LineRange;
     readonly startLineNumber: number;
     readonly endLineNumberExclusive: number;
     constructor(startLineNumber: number, endLineNumberExclusive: number);
     contains(lineNumber: number): boolean;
+    containsRange(range: LineRange): boolean;
     get isEmpty(): boolean;
     delta(offset: number): LineRange;
     deltaLength(offset: number): LineRange;
@@ -20,14 +23,13 @@ export declare class LineRange {
     toString(): string;
     intersect(other: LineRange): LineRange | undefined;
     intersectsStrict(other: LineRange): boolean;
-    overlapOrTouch(other: LineRange): boolean;
+    intersectsOrTouches(other: LineRange): boolean;
     equals(b: LineRange): boolean;
     toInclusiveRange(): Range | null;
     toExclusiveRange(): Range;
     mapToLineArray<T>(f: (lineNumber: number) => T): T[];
     forEach(f: (lineNumber: number) => void): void;
     serialize(): ISerializedLineRange;
-    includes(lineNumber: number): boolean;
     toOffsetRange(): OffsetRange;
     distanceToRange(other: LineRange): number;
     distanceToLine(lineNumber: number): number;

package/vscode/src/vs/editor/common/core/{lineRange.js → ranges/lineRange.js}

@@ -1,16 +1,21 @@
 
-import { BugIndicatingError } from '../../../base/common/errors.js';
+import { BugIndicatingError } from '../../../../base/common/errors.js';
 import { OffsetRange } from './offsetRange.js';
-import { Range } from './range.js';
-import { findFirstIdxMonotonousOrArrLen, findLastIdxMonotonous, findLastMonotonous } from '../../../base/common/arraysFind.js';
+import { Range } from '../range.js';
+import { findFirstIdxMonotonousOrArrLen, findLastIdxMonotonous, findLastMonotonous } from '../../../../base/common/arraysFind.js';
+import { compareBy, numberComparator } from '../../../../base/common/arrays.js';
 
 class LineRange {
+    static ofLength(startLineNumber, length) {
+        return ( new LineRange(startLineNumber, startLineNumber + length));
+    }
     static fromRange(range) {
         return ( new LineRange(range.startLineNumber, range.endLineNumber));
     }
     static fromRangeInclusive(range) {
         return ( new LineRange(range.startLineNumber, range.endLineNumber + 1));
     }
+    static { this.compareByStart = compareBy(l => l.startLineNumber, numberComparator); }
     static subtract(a, b) {
         if (!b) {
             return [a];
@@ -56,9 +61,6 @@ class LineRange {
         }
         return ( new LineRange(startLineNumber, endLineNumberExclusive));
     }
-    static ofLength(startLineNumber, length) {
-        return ( new LineRange(startLineNumber, startLineNumber + length));
-    }
     static deserialize(lineRange) {
         return ( new LineRange(lineRange[0], lineRange[1]));
     }
@@ -74,6 +76,9 @@ class LineRange {
     contains(lineNumber) {
         return this.startLineNumber <= lineNumber && lineNumber < this.endLineNumberExclusive;
     }
+    containsRange(range) {
+        return this.startLineNumber <= range.startLineNumber && range.endLineNumberExclusive <= this.endLineNumberExclusive;
+    }
     get isEmpty() {
         return this.startLineNumber === this.endLineNumberExclusive;
     }
@@ -106,7 +111,7 @@ class LineRange {
     intersectsStrict(other) {
         return this.startLineNumber < other.endLineNumberExclusive && other.startLineNumber < this.endLineNumberExclusive;
     }
-    overlapOrTouch(other) {
+    intersectsOrTouches(other) {
         return this.startLineNumber <= other.endLineNumberExclusive && other.startLineNumber <= this.endLineNumberExclusive;
     }
     equals(b) {
@@ -141,9 +146,6 @@ class LineRange {
     serialize() {
         return [this.startLineNumber, this.endLineNumberExclusive];
     }
-    includes(lineNumber) {
-        return this.startLineNumber <= lineNumber && lineNumber < this.endLineNumberExclusive;
-    }
     toOffsetRange() {
         return ( new OffsetRange(this.startLineNumber - 1, this.endLineNumberExclusive - 1));
     }

package/vscode/src/vs/editor/common/core/{offsetRange.d.ts → ranges/offsetRange.d.ts}

@@ -28,12 +28,13 @@ export declare class OffsetRange implements IOffsetRange {
     intersectsOrTouches(other: OffsetRange): boolean;
     isBefore(other: OffsetRange): boolean;
     isAfter(other: OffsetRange): boolean;
-    slice<T>(arr: T[]): T[];
+    slice<T>(arr: readonly T[]): T[];
     substring(str: string): string;
     clip(value: number): number;
     clipCyclic(value: number): number;
     map<T>(f: (offset: number) => T): T[];
     forEach(f: (offset: number) => void): void;
+    joinRightTouching(range: OffsetRange): OffsetRange;
 }
 export declare class OffsetRangeSet {
     private readonly _sortedRanges;

package/vscode/src/vs/editor/common/core/{offsetRange.js → ranges/offsetRange.js}

@@ -1,5 +1,5 @@
 
-import { BugIndicatingError } from '../../../base/common/errors.js';
+import { BugIndicatingError } from '../../../../base/common/errors.js';
 
 class OffsetRange {
     static fromTo(start, endExclusive) {
@@ -143,6 +143,12 @@ class OffsetRange {
             f(i);
         }
     }
+    joinRightTouching(range) {
+        if (this.endExclusive !== range.start) {
+            throw ( new BugIndicatingError(`Invalid join: ${( this.toString())} and ${( range.toString())}`));
+        }
+        return ( new OffsetRange(this.start, range.endExclusive));
+    }
 }
 class OffsetRangeSet {
     constructor() {

package/vscode/src/vs/editor/common/core/{rangeSingleLine.d.ts → ranges/rangeSingleLine.d.ts}

@@ -1,5 +1,5 @@
 import { ColumnRange } from "./columnRange.js";
-import { Range } from "./range.js";
+import { Range } from "../range.js";
 export declare class RangeSingleLine {
     readonly lineNumber: number;
     readonly columnRange: ColumnRange;

package/vscode/src/vs/editor/common/core/{rangeSingleLine.js → ranges/rangeSingleLine.js}

@@ -1,6 +1,6 @@
 
 import { ColumnRange } from './columnRange.js';
-import { Range } from './range.js';
+import { Range } from '../range.js';
 
 class RangeSingleLine {
     static fromRange(range) {

package/vscode/src/vs/editor/common/core/text/abstractText.d.ts

@@ -0,0 +1,35 @@
+import { Position } from "../position.js";
+import { PositionOffsetTransformer } from "./positionToOffset.js";
+import { Range } from "../range.js";
+import { LineRange } from "../ranges/lineRange.js";
+import { TextLength } from "./textLength.js";
+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;
+}