@codingame/monaco-vscode-api 18.4.0 → 19.0.1

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

@@ -1,6 +1,37 @@
 import { OffsetRange } from "../ranges/offsetRange.js";
+import { StringText } from "../text/abstractText.js";
 import { BaseEdit, BaseReplacement } from "./edit.js";
-export declare class StringEdit extends BaseEdit<StringReplacement, StringEdit> {
+export declare abstract class BaseStringEdit<T extends BaseStringReplacement<T> = BaseStringReplacement<any>, TEdit extends BaseStringEdit<T, TEdit> = BaseStringEdit<any, any>> extends BaseEdit<T, TEdit> {
+    get TReplacement(): T;
+    static composeOrUndefined<T extends BaseStringEdit>(edits: readonly T[]): T | undefined;
+    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;
+    normalizeEOL(eol: "\r\n" | "\n"): StringEdit;
+    normalizeOnSource(source: string): StringEdit;
+    removeCommonSuffixAndPrefix(source: string): TEdit;
+    applyOnText(docContents: StringText): StringText;
+    mapData<TData extends IEditData<TData>>(f: (replacement: T) => TData): AnnotatedStringEdit<TData>;
+}
+export declare abstract class BaseStringReplacement<T extends BaseStringReplacement<T> = BaseStringReplacement<any>> extends BaseReplacement<T> {
+    readonly newText: string;
+    constructor(range: OffsetRange, newText: string);
+    getNewLength(): number;
+    toString(): string;
+    replace(str: string): string;
+    isNeutralOn(text: string): boolean;
+    removeCommonSuffixPrefix(originalText: string): StringReplacement;
+    normalizeEOL(eol: "\r\n" | "\n"): StringReplacement;
+    removeCommonSuffixAndPrefix(source: string): T;
+    removeCommonPrefix(source: string): T;
+    removeCommonSuffix(source: string): T;
+    toEdit(): StringEdit;
+}
+export declare class StringEdit extends BaseStringEdit<StringReplacement, StringEdit> {
     static readonly empty: StringEdit;
     static create(replacements: readonly StringReplacement[]): StringEdit;
     static single(replacement: StringReplacement): StringEdit;
@@ -9,15 +40,9 @@ export declare class StringEdit extends BaseEdit<StringReplacement, StringEdit>
     static delete(range: OffsetRange): StringEdit;
     static fromJson(data: ISerializedStringEdit): StringEdit;
     static compose(edits: readonly StringEdit[]): StringEdit;
+    static composeSequentialReplacements(replacements: readonly StringReplacement[]): 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 {
@@ -25,19 +50,41 @@ export interface ISerializedStringReplacement {
     pos: number;
     len: number;
 }
-export declare class StringReplacement extends BaseReplacement<StringReplacement> {
-    readonly newText: string;
+export declare class StringReplacement extends BaseStringReplacement<StringReplacement> {
     static insert(offset: number, text: string): StringReplacement;
     static replace(range: OffsetRange, text: string): StringReplacement;
+    static delete(range: OffsetRange): 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[];
+export interface IEditData<T> {
+    join(other: T): T | undefined;
+}
+export declare class VoidEditData implements IEditData<VoidEditData> {
+    join(other: VoidEditData): VoidEditData | undefined;
+}
+export declare class AnnotatedStringEdit<T extends IEditData<T>> extends BaseStringEdit<AnnotatedStringReplacement<T>, AnnotatedStringEdit<T>> {
+    static readonly empty: AnnotatedStringEdit<never>;
+    static create<T extends IEditData<T>>(replacements: readonly AnnotatedStringReplacement<T>[]): AnnotatedStringEdit<T>;
+    static single<T extends IEditData<T>>(replacement: AnnotatedStringReplacement<T>): AnnotatedStringEdit<T>;
+    static replace<T extends IEditData<T>>(range: OffsetRange, replacement: string, data: T): AnnotatedStringEdit<T>;
+    static insert<T extends IEditData<T>>(offset: number, replacement: string, data: T): AnnotatedStringEdit<T>;
+    static delete<T extends IEditData<T>>(range: OffsetRange, data: T): AnnotatedStringEdit<T>;
+    static compose<T extends IEditData<T>>(edits: readonly AnnotatedStringEdit<T>[]): AnnotatedStringEdit<T>;
+    constructor(replacements: readonly AnnotatedStringReplacement<T>[]);
+    protected _createNew(replacements: readonly AnnotatedStringReplacement<T>[]): AnnotatedStringEdit<T>;
+    toStringEdit(): StringEdit;
+}
+export declare class AnnotatedStringReplacement<T extends IEditData<T>> extends BaseStringReplacement<AnnotatedStringReplacement<T>> {
+    readonly data: T;
+    static insert<T extends IEditData<T>>(offset: number, text: string, data: T): AnnotatedStringReplacement<T>;
+    static replace<T extends IEditData<T>>(range: OffsetRange, text: string, data: T): AnnotatedStringReplacement<T>;
+    static delete<T extends IEditData<T>>(range: OffsetRange, data: T): AnnotatedStringReplacement<T>;
+    constructor(range: OffsetRange, newText: string, data: T);
+    equals(other: AnnotatedStringReplacement<T>): boolean;
+    tryJoinTouching(other: AnnotatedStringReplacement<T>): AnnotatedStringReplacement<T> | undefined;
+    slice(range: OffsetRange, rangeInReplacement?: OffsetRange): AnnotatedStringReplacement<T>;
+}

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

@@ -1,31 +1,16 @@
 
 import { commonPrefixLength, commonSuffixLength } from '../../../../base/common/strings.js';
 import { OffsetRange } from '../ranges/offsetRange.js';
+import { StringText } from '../text/abstractText.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]));
+class BaseStringEdit extends BaseEdit {
+    get TReplacement() {
+        throw ( new Error('TReplacement is not defined for BaseStringEdit'));
     }
-    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) {
+    static composeOrUndefined(edits) {
         if (edits.length === 0) {
-            return StringEdit.empty;
+            return undefined;
         }
         let result = edits[0];
         for (let i = 1; i < edits.length; i++) {
@@ -33,12 +18,6 @@ class StringEdit extends BaseEdit {
         }
         return result;
     }
-    constructor(replacements) {
-        super(replacements);
-    }
-    _createNew(replacements) {
-        return ( new StringEdit(replacements));
-    }
     apply(base) {
         const resultText = [];
         let pos = 0;
@@ -114,34 +93,34 @@ class StringEdit extends BaseEdit {
         }
         return ( new StringEdit(edits));
     }
-}
-class StringReplacement extends BaseReplacement {
-    static insert(offset, text) {
-        return ( new StringReplacement(OffsetRange.emptyAt(offset), text));
+    normalizeEOL(eol) {
+        return ( new StringEdit(( this.replacements.map(edit => edit.normalizeEOL(eol)))));
     }
-    static replace(range, text) {
-        return ( new StringReplacement(range, text));
+    normalizeOnSource(source) {
+        const result = this.apply(source);
+        const edit = StringReplacement.replace(OffsetRange.ofLength(source.length), result);
+        const e = edit.removeCommonSuffixAndPrefix(source);
+        if (e.isEmpty) {
+            return StringEdit.empty;
+        }
+        return e.toEdit();
     }
-    static fromJson(data) {
-        return ( new StringReplacement(OffsetRange.ofStartAndLength(data.pos, data.len), data.txt));
+    removeCommonSuffixAndPrefix(source) {
+        return this._createNew(( this.replacements.map(e => e.removeCommonSuffixAndPrefix(source)))).normalize();
+    }
+    applyOnText(docContents) {
+        return ( new StringText(this.apply(docContents.value)));
     }
+    mapData(f) {
+        return ( new AnnotatedStringEdit(( this.replacements.map(e => ( new AnnotatedStringReplacement(e.replaceRange, e.newText, f(e)))))));
+    }
+}
+class BaseStringReplacement extends BaseReplacement {
     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}"`;
     }
@@ -162,6 +141,111 @@ class StringReplacement extends BaseReplacement {
         const newText = this.newText.substring(prefixLen, this.newText.length - suffixLen);
         return ( new StringReplacement(replaceRange, newText));
     }
+    normalizeEOL(eol) {
+        const newText = this.newText.replace(/\r\n|\n/g, eol);
+        return ( new StringReplacement(this.replaceRange, newText));
+    }
+    removeCommonSuffixAndPrefix(source) {
+        return this.removeCommonSuffix(source).removeCommonPrefix(source);
+    }
+    removeCommonPrefix(source) {
+        const oldText = this.replaceRange.substring(source);
+        const prefixLen = commonPrefixLength(oldText, this.newText);
+        if (prefixLen === 0) {
+            return this;
+        }
+        return this.slice(this.replaceRange.deltaStart(prefixLen), ( new OffsetRange(prefixLen, this.newText.length)));
+    }
+    removeCommonSuffix(source) {
+        const oldText = this.replaceRange.substring(source);
+        const suffixLen = commonSuffixLength(oldText, this.newText);
+        if (suffixLen === 0) {
+            return this;
+        }
+        return this.slice(this.replaceRange.deltaEnd(-suffixLen), ( new OffsetRange(0, this.newText.length - suffixLen)));
+    }
+    toEdit() {
+        return ( new StringEdit([this]));
+    }
+}
+class StringEdit extends BaseStringEdit {
+    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;
+    }
+    static composeSequentialReplacements(replacements) {
+        let edit = StringEdit.empty;
+        let curEditReplacements = [];
+        for (const r of replacements) {
+            const last = curEditReplacements.at(-1);
+            if (!last || r.replaceRange.isBefore(last.replaceRange)) {
+                curEditReplacements.push(r);
+            }
+            else {
+                edit = edit.compose(StringEdit.create(curEditReplacements.reverse()));
+                curEditReplacements = [r];
+            }
+        }
+        edit = edit.compose(StringEdit.create(curEditReplacements.reverse()));
+        return edit;
+    }
+    constructor(replacements) {
+        super(replacements);
+    }
+    _createNew(replacements) {
+        return ( new StringEdit(replacements));
+    }
+}
+class StringReplacement extends BaseStringReplacement {
+    static insert(offset, text) {
+        return ( new StringReplacement(OffsetRange.emptyAt(offset), text));
+    }
+    static replace(range, text) {
+        return ( new StringReplacement(range, text));
+    }
+    static delete(range) {
+        return ( new StringReplacement(range, ''));
+    }
+    static fromJson(data) {
+        return ( new StringReplacement(OffsetRange.ofStartAndLength(data.pos, data.len), data.txt));
+    }
+    equals(other) {
+        return this.replaceRange.equals(other.replaceRange) && this.newText === other.newText;
+    }
+    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)));
+    }
 }
 function applyEditsToRanges(sortedRanges, edit) {
     sortedRanges = sortedRanges.slice();
@@ -211,5 +295,78 @@ function applyEditsToRanges(sortedRanges, edit) {
     }
     return result;
 }
+class AnnotatedStringEdit extends BaseStringEdit {
+    static { this.empty = ( new AnnotatedStringEdit([])); }
+    static create(replacements) {
+        return ( new AnnotatedStringEdit(replacements));
+    }
+    static single(replacement) {
+        return ( new AnnotatedStringEdit([replacement]));
+    }
+    static replace(range, replacement, data) {
+        return ( new AnnotatedStringEdit([( new AnnotatedStringReplacement(range, replacement, data))]));
+    }
+    static insert(offset, replacement, data) {
+        return ( new AnnotatedStringEdit([( new AnnotatedStringReplacement(OffsetRange.emptyAt(offset), replacement, data))]));
+    }
+    static delete(range, data) {
+        return ( new AnnotatedStringEdit([( new AnnotatedStringReplacement(range, '', data))]));
+    }
+    static compose(edits) {
+        if (edits.length === 0) {
+            return AnnotatedStringEdit.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 AnnotatedStringEdit(replacements));
+    }
+    toStringEdit() {
+        return ( new StringEdit(( this.replacements.map(e => ( new StringReplacement(e.replaceRange, e.newText))))));
+    }
+}
+class AnnotatedStringReplacement extends BaseStringReplacement {
+    static insert(offset, text, data) {
+        return ( new AnnotatedStringReplacement(OffsetRange.emptyAt(offset), text, data));
+    }
+    static replace(range, text, data) {
+        return ( new AnnotatedStringReplacement(range, text, data));
+    }
+    static delete(range, data) {
+        return ( new AnnotatedStringReplacement(range, '', data));
+    }
+    constructor(range, newText, data) {
+        super(range, newText);
+        this.data = data;
+    }
+    equals(other) {
+        return this.replaceRange.equals(other.replaceRange) && this.newText === other.newText && this.data === other.data;
+    }
+    tryJoinTouching(other) {
+        const joined = this.data.join(other.data);
+        if (joined === undefined) {
+            return undefined;
+        }
+        return ( new AnnotatedStringReplacement(
+            this.replaceRange.joinRightTouching(other.replaceRange),
+            this.newText + other.newText,
+            joined
+        ));
+    }
+    slice(range, rangeInReplacement) {
+        return ( new AnnotatedStringReplacement(
+            range,
+            rangeInReplacement ? rangeInReplacement.substring(this.newText) : this.newText,
+            this.data
+        ));
+    }
+}
 
-export { StringEdit, StringReplacement, applyEditsToRanges };
+export { AnnotatedStringEdit, AnnotatedStringReplacement, BaseStringEdit, BaseStringReplacement, StringEdit, StringReplacement, applyEditsToRanges };

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

@@ -1,5 +1,5 @@
 import { ISingleEditOperation } from "../editOperation.js";
-import { StringEdit } from "./stringEdit.js";
+import { StringEdit, StringReplacement } from "./stringEdit.js";
 import { Position } from "../position.js";
 import { Range } from "../range.js";
 import { AbstractText } from "../text/abstractText.js";
@@ -7,7 +7,9 @@ export declare class TextEdit {
     readonly replacements: readonly TextReplacement[];
     static fromStringEdit(edit: StringEdit, initialState: AbstractText): TextEdit;
     static replace(originalRange: Range, newText: string): TextEdit;
+    static delete(range: Range): TextEdit;
     static insert(position: Position, newText: string): TextEdit;
+    static fromParallelReplacementsUnsorted(replacements: readonly TextReplacement[]): TextEdit;
     constructor(replacements: readonly TextReplacement[]);
     normalize(): TextEdit;
     mapPosition(position: Position): Position | Range;
@@ -26,6 +28,8 @@ export declare class TextReplacement {
     readonly range: Range;
     readonly text: string;
     static joinReplacements(replacements: TextReplacement[], initialValue: AbstractText): TextReplacement;
+    static fromStringReplacement(replacement: StringReplacement, initialState: AbstractText): TextReplacement;
+    static delete(range: Range): TextReplacement;
     constructor(range: Range, text: string);
     get isEmpty(): boolean;
     static equals(first: TextReplacement, second: TextReplacement): boolean;

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

@@ -1,5 +1,5 @@
 
-import { equals } from '../../../../base/common/arrays.js';
+import { compareBy, 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';
@@ -10,15 +10,22 @@ import { StringText } from '../text/abstractText.js';
 
 class TextEdit {
     static fromStringEdit(edit, initialState) {
-        const edits = ( edit.replacements.map(e => ( new TextReplacement(initialState.getTransformer().getRange(e.replaceRange), e.newText))));
+        const edits = ( edit.replacements.map(e => TextReplacement.fromStringReplacement(e, initialState)));
         return ( new TextEdit(edits));
     }
     static replace(originalRange, newText) {
         return ( new TextEdit([( new TextReplacement(originalRange, newText))]));
     }
+    static delete(range) {
+        return ( new TextEdit([( new TextReplacement(range, ''))]));
+    }
     static insert(position, newText) {
         return ( new TextEdit([( new TextReplacement(Range.fromPositions(position, position), newText))]));
     }
+    static fromParallelReplacementsUnsorted(replacements) {
+        const r = replacements.slice().sort(compareBy(i => i.range, Range.compareRangesUsingStarts));
+        return ( new TextEdit(r));
+    }
     constructor(replacements) {
         this.replacements = replacements;
         assertFn(() => checkAdjacentItems(replacements, (a, b) => a.range.getEndPosition().isBeforeOrEqual(b.range.getStartPosition())));
@@ -233,6 +240,15 @@ class TextReplacement {
         }
         return ( new TextReplacement(Range.fromPositions(startPos, endPos), newText));
     }
+    static fromStringReplacement(replacement, initialState) {
+        return ( new TextReplacement(
+            initialState.getTransformer().getRange(replacement.replaceRange),
+            replacement.newText
+        ));
+    }
+    static delete(range) {
+        return ( new TextReplacement(range, ''));
+    }
     constructor(range, text) {
         this.range = range;
         this.text = text;

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

@@ -1,5 +1,5 @@
 import { Position } from "../position.js";
-import { PositionOffsetTransformer } from "./positionToOffset.js";
+import { PositionOffsetTransformer } from "./positionToOffsetImpl.js";
 import { Range } from "../range.js";
 import { LineRange } from "../ranges/lineRange.js";
 import { TextLength } from "./textLength.js";
@@ -14,6 +14,8 @@ export declare abstract class AbstractText {
     getTransformer(): PositionOffsetTransformer;
     getLineAt(lineNumber: number): string;
     getLines(): string[];
+    getLinesOfRange(range: LineRange): string[];
+    equals(other: AbstractText): boolean;
 }
 export declare class LineBasedText extends AbstractText {
     private readonly _getLineContent;

package/vscode/src/vs/editor/common/core/text/abstractText.js

@@ -2,7 +2,7 @@
 import { assert } from '../../../../base/common/assert.js';
 import { splitLines } from '../../../../base/common/strings.js';
 import { Position } from '../position.js';
-import { PositionOffsetTransformer } from './positionToOffset.js';
+import { PositionOffsetTransformer } from './positionToOffsetImpl.js';
 import { Range } from '../range.js';
 import { TextLength } from './textLength.js';
 
@@ -35,6 +35,15 @@ class AbstractText {
         const value = this.getValue();
         return splitLines(value);
     }
+    getLinesOfRange(range) {
+        return range.mapToLineArray(lineNumber => this.getLineAt(lineNumber));
+    }
+    equals(other) {
+        if (this === other) {
+            return true;
+        }
+        return this.getValue() === other.getValue();
+    }
 }
 class LineBasedText extends AbstractText {
     constructor(_getLineContent, _lineCount) {

package/vscode/src/vs/editor/common/core/text/getPositionOffsetTransformerFromTextModel.js

@@ -1,5 +1,6 @@
 
-import { PositionOffsetTransformerBase } from './positionToOffset.js';
+import './positionToOffset.js';
+import { PositionOffsetTransformerBase } from './positionToOffsetImpl.js';
 
 function getPositionOffsetTransformerFromTextModel(textModel) {
     return ( new PositionOffsetTransformerWithTextModel(textModel));

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

@@ -1,28 +1,2 @@
-import { StringEdit, StringReplacement } from "../edits/stringEdit.js";
-import { OffsetRange } from "../ranges/offsetRange.js";
-import { Position } from "../position.js";
-import { Range } from "../range.js";
-import { TextReplacement, TextEdit } from "../edits/textEdit.js";
-import { TextLength } from "./textLength.js";
-export declare abstract class PositionOffsetTransformerBase {
-    abstract getOffset(position: Position): number;
-    getOffsetRange(range: Range): OffsetRange;
-    abstract getPosition(offset: number): Position;
-    getRange(offsetRange: OffsetRange): Range;
-    getStringEdit(edit: TextEdit): StringEdit;
-    getStringReplacement(edit: TextReplacement): StringReplacement;
-    getSingleTextEdit(edit: StringReplacement): TextReplacement;
-    getTextEdit(edit: StringEdit): TextEdit;
-}
-export declare class PositionOffsetTransformer extends PositionOffsetTransformerBase {
-    readonly text: string;
-    private readonly lineStartOffsetByLineIdx;
-    private readonly lineEndOffsetByLineIdx;
-    constructor(text: string);
-    getOffset(position: Position): number;
-    private _validatePosition;
-    getPosition(offset: number): Position;
-    getTextLength(offsetRange: OffsetRange): TextLength;
-    get textLength(): TextLength;
-    getLineLength(lineNumber: number): number;
-}
+export { PositionOffsetTransformerBase, PositionOffsetTransformer } from "./positionToOffsetImpl.js";
+export declare function ensureDependenciesAreSet(): void;

package/vscode/src/vs/editor/common/core/text/positionToOffset.js

@@ -1,95 +1,14 @@
 
-import { findLastIdxMonotonous } from '../../../../base/common/arraysFind.js';
-import { StringEdit, StringReplacement } from '../edits/stringEdit.js';
-import { OffsetRange } from '../ranges/offsetRange.js';
-import { Position } from '../position.js';
-import { Range } from '../range.js';
-import { TextReplacement, TextEdit } from '../edits/textEdit.js';
+import { StringReplacement, StringEdit } from '../edits/stringEdit.js';
+import { TextEdit, TextReplacement } from '../edits/textEdit.js';
+import { _setPositionOffsetTransformerDependencies } from './positionToOffsetImpl.js';
+export { PositionOffsetTransformer, PositionOffsetTransformerBase } from './positionToOffsetImpl.js';
 import { TextLength } from './textLength.js';
 
-class PositionOffsetTransformerBase {
-    getOffsetRange(range) {
-        return ( new OffsetRange(
-            this.getOffset(range.getStartPosition()),
-            this.getOffset(range.getEndPosition())
-        ));
-    }
-    getRange(offsetRange) {
-        return Range.fromPositions(this.getPosition(offsetRange.start), this.getPosition(offsetRange.endExclusive));
-    }
-    getStringEdit(edit) {
-        const edits = ( edit.replacements.map(e => this.getStringReplacement(e)));
-        return ( new StringEdit(edits));
-    }
-    getStringReplacement(edit) {
-        return ( new StringReplacement(this.getOffsetRange(edit.range), edit.text));
-    }
-    getSingleTextEdit(edit) {
-        return ( new TextReplacement(this.getRange(edit.replaceRange), edit.newText));
-    }
-    getTextEdit(edit) {
-        const edits = ( edit.replacements.map(e => this.getSingleTextEdit(e)));
-        return ( new TextEdit(edits));
-    }
-}
-class PositionOffsetTransformer extends PositionOffsetTransformerBase {
-    constructor(text) {
-        super();
-        this.text = text;
-        this.lineStartOffsetByLineIdx = [];
-        this.lineEndOffsetByLineIdx = [];
-        this.lineStartOffsetByLineIdx.push(0);
-        for (let i = 0; i < text.length; i++) {
-            if (text.charAt(i) === '\n') {
-                this.lineStartOffsetByLineIdx.push(i + 1);
-                if (i > 0 && text.charAt(i - 1) === '\r') {
-                    this.lineEndOffsetByLineIdx.push(i - 1);
-                }
-                else {
-                    this.lineEndOffsetByLineIdx.push(i);
-                }
-            }
-        }
-        this.lineEndOffsetByLineIdx.push(text.length);
-    }
-    getOffset(position) {
-        const valPos = this._validatePosition(position);
-        return this.lineStartOffsetByLineIdx[valPos.lineNumber - 1] + valPos.column - 1;
-    }
-    _validatePosition(position) {
-        if (position.lineNumber < 1) {
-            return ( new Position(1, 1));
-        }
-        const lineCount = this.textLength.lineCount + 1;
-        if (position.lineNumber > lineCount) {
-            const lineLength = this.getLineLength(lineCount);
-            return ( new Position(lineCount, lineLength + 1));
-        }
-        if (position.column < 1) {
-            return ( new Position(position.lineNumber, 1));
-        }
-        const lineLength = this.getLineLength(position.lineNumber);
-        if (position.column - 1 > lineLength) {
-            return ( new Position(position.lineNumber, lineLength + 1));
-        }
-        return position;
-    }
-    getPosition(offset) {
-        const idx = findLastIdxMonotonous(this.lineStartOffsetByLineIdx, i => i <= offset);
-        const lineNumber = idx + 1;
-        const column = offset - this.lineStartOffsetByLineIdx[idx] + 1;
-        return ( new Position(lineNumber, column));
-    }
-    getTextLength(offsetRange) {
-        return TextLength.ofRange(this.getRange(offsetRange));
-    }
-    get textLength() {
-        const lineIdx = this.lineStartOffsetByLineIdx.length - 1;
-        return ( new TextLength(lineIdx, this.text.length - this.lineStartOffsetByLineIdx[lineIdx]));
-    }
-    getLineLength(lineNumber) {
-        return this.lineEndOffsetByLineIdx[lineNumber - 1] - this.lineStartOffsetByLineIdx[lineNumber - 1];
-    }
-}
-
-export { PositionOffsetTransformer, PositionOffsetTransformerBase };
+_setPositionOffsetTransformerDependencies({
+    StringEdit: StringEdit,
+    StringReplacement: StringReplacement,
+    TextReplacement: TextReplacement,
+    TextEdit: TextEdit,
+    TextLength: TextLength,
+});