@codingame/monaco-vscode-api 1.85.5 → 2.0.0-rework-ci.1

package/vscode/src/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/bracketPairsTree.js

@@ -0,0 +1,341 @@
+import { Emitter } from '../../../../../base/common/event.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+import { BracketInfo, BracketPairWithMinIndentationInfo } from '../../../textModelBracketPairs.js';
+import { TextEditInfo } from './beforeEditPositionMapper.js';
+import { LanguageAgnosticBracketTokens } from './brackets.js';
+import { positionToLength, lengthLessThan, lengthLessThanEqual, lengthGreaterThanEqual, lengthAdd, lengthsToRange, toLength, lengthZero } from './length.js';
+import { parseDocument } from './parser.js';
+import { DenseKeyProvider } from './smallImmutableSet.js';
+import { FastTokenizer, TextBufferTokenizer } from './tokenizer.js';
+import { CallbackIterable } from '../../../../../base/common/arrays.js';
+import { combineTextEditInfos } from './combineTextEditInfos.js';
+class BracketPairsTree extends Disposable {
+    didLanguageChange(languageId) {
+        return this.brackets.didLanguageChange(languageId);
+    }
+    constructor(textModel, getLanguageConfiguration) {
+        super();
+        this.textModel = textModel;
+        this.getLanguageConfiguration = getLanguageConfiguration;
+        this.didChangeEmitter = ( new Emitter());
+        this.denseKeyProvider = ( new DenseKeyProvider());
+        this.brackets = ( new LanguageAgnosticBracketTokens(this.denseKeyProvider, this.getLanguageConfiguration));
+        this.onDidChange = this.didChangeEmitter.event;
+        this.queuedTextEditsForInitialAstWithoutTokens = [];
+        this.queuedTextEdits = [];
+        if (!textModel.tokenization.hasTokens) {
+            const brackets = this.brackets.getSingleLanguageBracketTokens(this.textModel.getLanguageId());
+            const tokenizer = ( new FastTokenizer(this.textModel.getValue(), brackets));
+            this.initialAstWithoutTokens = parseDocument(tokenizer, [], undefined, true);
+            this.astWithTokens = this.initialAstWithoutTokens;
+        }
+        else if (textModel.tokenization.backgroundTokenizationState === 2 ) {
+            this.initialAstWithoutTokens = undefined;
+            this.astWithTokens = this.parseDocumentFromTextBuffer([], undefined, false);
+        }
+        else {
+            this.initialAstWithoutTokens = this.parseDocumentFromTextBuffer([], undefined, true);
+            this.astWithTokens = this.initialAstWithoutTokens;
+        }
+    }
+    handleDidChangeBackgroundTokenizationState() {
+        if (this.textModel.tokenization.backgroundTokenizationState === 2 ) {
+            const wasUndefined = this.initialAstWithoutTokens === undefined;
+            this.initialAstWithoutTokens = undefined;
+            if (!wasUndefined) {
+                this.didChangeEmitter.fire();
+            }
+        }
+    }
+    handleDidChangeTokens({ ranges }) {
+        const edits = ( ranges.map(r => ( new TextEditInfo(
+            toLength(r.fromLineNumber - 1, 0),
+            toLength(r.toLineNumber, 0),
+            toLength(r.toLineNumber - r.fromLineNumber + 1, 0)
+        ))));
+        this.handleEdits(edits, true);
+        if (!this.initialAstWithoutTokens) {
+            this.didChangeEmitter.fire();
+        }
+    }
+    handleContentChanged(change) {
+        const edits = TextEditInfo.fromModelContentChanges(change.changes);
+        this.handleEdits(edits, false);
+    }
+    handleEdits(edits, tokenChange) {
+        const result = combineTextEditInfos(this.queuedTextEdits, edits);
+        this.queuedTextEdits = result;
+        if (this.initialAstWithoutTokens && !tokenChange) {
+            this.queuedTextEditsForInitialAstWithoutTokens = combineTextEditInfos(this.queuedTextEditsForInitialAstWithoutTokens, edits);
+        }
+    }
+    flushQueue() {
+        if (this.queuedTextEdits.length > 0) {
+            this.astWithTokens = this.parseDocumentFromTextBuffer(this.queuedTextEdits, this.astWithTokens, false);
+            this.queuedTextEdits = [];
+        }
+        if (this.queuedTextEditsForInitialAstWithoutTokens.length > 0) {
+            if (this.initialAstWithoutTokens) {
+                this.initialAstWithoutTokens = this.parseDocumentFromTextBuffer(this.queuedTextEditsForInitialAstWithoutTokens, this.initialAstWithoutTokens, false);
+            }
+            this.queuedTextEditsForInitialAstWithoutTokens = [];
+        }
+    }
+    parseDocumentFromTextBuffer(edits, previousAst, immutable) {
+        const previousAstClone = previousAst;
+        const tokenizer = ( new TextBufferTokenizer(this.textModel, this.brackets));
+        const result = parseDocument(tokenizer, edits, previousAstClone, immutable);
+        return result;
+    }
+    getBracketsInRange(range, onlyColorizedBrackets) {
+        this.flushQueue();
+        const startOffset = toLength(range.startLineNumber - 1, range.startColumn - 1);
+        const endOffset = toLength(range.endLineNumber - 1, range.endColumn - 1);
+        return ( new CallbackIterable(cb => {
+            const node = this.initialAstWithoutTokens || this.astWithTokens;
+            collectBrackets(node, lengthZero, node.length, startOffset, endOffset, cb, 0, 0, ( new Map()), onlyColorizedBrackets);
+        }));
+    }
+    getBracketPairsInRange(range, includeMinIndentation) {
+        this.flushQueue();
+        const startLength = positionToLength(range.getStartPosition());
+        const endLength = positionToLength(range.getEndPosition());
+        return ( new CallbackIterable(cb => {
+            const node = this.initialAstWithoutTokens || this.astWithTokens;
+            const context = ( new CollectBracketPairsContext(cb, includeMinIndentation, this.textModel));
+            collectBracketPairs(node, lengthZero, node.length, startLength, endLength, context, 0, ( new Map()));
+        }));
+    }
+    getFirstBracketAfter(position) {
+        this.flushQueue();
+        const node = this.initialAstWithoutTokens || this.astWithTokens;
+        return getFirstBracketAfter(node, lengthZero, node.length, positionToLength(position));
+    }
+    getFirstBracketBefore(position) {
+        this.flushQueue();
+        const node = this.initialAstWithoutTokens || this.astWithTokens;
+        return getFirstBracketBefore(node, lengthZero, node.length, positionToLength(position));
+    }
+}
+function getFirstBracketBefore(node, nodeOffsetStart, nodeOffsetEnd, position) {
+    if (node.kind === 4  || node.kind === 2 ) {
+        const lengths = [];
+        for (const child of node.children) {
+            nodeOffsetEnd = lengthAdd(nodeOffsetStart, child.length);
+            lengths.push({ nodeOffsetStart, nodeOffsetEnd });
+            nodeOffsetStart = nodeOffsetEnd;
+        }
+        for (let i = lengths.length - 1; i >= 0; i--) {
+            const { nodeOffsetStart, nodeOffsetEnd } = lengths[i];
+            if (lengthLessThan(nodeOffsetStart, position)) {
+                const result = getFirstBracketBefore(node.children[i], nodeOffsetStart, nodeOffsetEnd, position);
+                if (result) {
+                    return result;
+                }
+            }
+        }
+        return null;
+    }
+    else if (node.kind === 3 ) {
+        return null;
+    }
+    else if (node.kind === 1 ) {
+        const range = lengthsToRange(nodeOffsetStart, nodeOffsetEnd);
+        return {
+            bracketInfo: node.bracketInfo,
+            range
+        };
+    }
+    return null;
+}
+function getFirstBracketAfter(node, nodeOffsetStart, nodeOffsetEnd, position) {
+    if (node.kind === 4  || node.kind === 2 ) {
+        for (const child of node.children) {
+            nodeOffsetEnd = lengthAdd(nodeOffsetStart, child.length);
+            if (lengthLessThan(position, nodeOffsetEnd)) {
+                const result = getFirstBracketAfter(child, nodeOffsetStart, nodeOffsetEnd, position);
+                if (result) {
+                    return result;
+                }
+            }
+            nodeOffsetStart = nodeOffsetEnd;
+        }
+        return null;
+    }
+    else if (node.kind === 3 ) {
+        return null;
+    }
+    else if (node.kind === 1 ) {
+        const range = lengthsToRange(nodeOffsetStart, nodeOffsetEnd);
+        return {
+            bracketInfo: node.bracketInfo,
+            range
+        };
+    }
+    return null;
+}
+function collectBrackets(node, nodeOffsetStart, nodeOffsetEnd, startOffset, endOffset, push, level, nestingLevelOfEqualBracketType, levelPerBracketType, onlyColorizedBrackets, parentPairIsIncomplete = false) {
+    if (level > 200) {
+        return true;
+    }
+    whileLoop: while (true) {
+        switch (node.kind) {
+            case 4 : {
+                const childCount = node.childrenLength;
+                for (let i = 0; i < childCount; i++) {
+                    const child = node.getChild(i);
+                    if (!child) {
+                        continue;
+                    }
+                    nodeOffsetEnd = lengthAdd(nodeOffsetStart, child.length);
+                    if (lengthLessThanEqual(nodeOffsetStart, endOffset) &&
+                        lengthGreaterThanEqual(nodeOffsetEnd, startOffset)) {
+                        const childEndsAfterEnd = lengthGreaterThanEqual(nodeOffsetEnd, endOffset);
+                        if (childEndsAfterEnd) {
+                            node = child;
+                            continue whileLoop;
+                        }
+                        const shouldContinue = collectBrackets(child, nodeOffsetStart, nodeOffsetEnd, startOffset, endOffset, push, level, 0, levelPerBracketType, onlyColorizedBrackets);
+                        if (!shouldContinue) {
+                            return false;
+                        }
+                    }
+                    nodeOffsetStart = nodeOffsetEnd;
+                }
+                return true;
+            }
+            case 2 : {
+                const colorize = !onlyColorizedBrackets || !node.closingBracket || node.closingBracket.bracketInfo.closesColorized(node.openingBracket.bracketInfo);
+                let levelPerBracket = 0;
+                if (levelPerBracketType) {
+                    let existing = levelPerBracketType.get(node.openingBracket.text);
+                    if (existing === undefined) {
+                        existing = 0;
+                    }
+                    levelPerBracket = existing;
+                    if (colorize) {
+                        existing++;
+                        levelPerBracketType.set(node.openingBracket.text, existing);
+                    }
+                }
+                const childCount = node.childrenLength;
+                for (let i = 0; i < childCount; i++) {
+                    const child = node.getChild(i);
+                    if (!child) {
+                        continue;
+                    }
+                    nodeOffsetEnd = lengthAdd(nodeOffsetStart, child.length);
+                    if (lengthLessThanEqual(nodeOffsetStart, endOffset) &&
+                        lengthGreaterThanEqual(nodeOffsetEnd, startOffset)) {
+                        const childEndsAfterEnd = lengthGreaterThanEqual(nodeOffsetEnd, endOffset);
+                        if (childEndsAfterEnd && child.kind !== 1 ) {
+                            node = child;
+                            if (colorize) {
+                                level++;
+                                nestingLevelOfEqualBracketType = levelPerBracket + 1;
+                            }
+                            else {
+                                nestingLevelOfEqualBracketType = levelPerBracket;
+                            }
+                            continue whileLoop;
+                        }
+                        if (colorize || child.kind !== 1  || !node.closingBracket) {
+                            const shouldContinue = collectBrackets(child, nodeOffsetStart, nodeOffsetEnd, startOffset, endOffset, push, colorize ? level + 1 : level, colorize ? levelPerBracket + 1 : levelPerBracket, levelPerBracketType, onlyColorizedBrackets, !node.closingBracket);
+                            if (!shouldContinue) {
+                                return false;
+                            }
+                        }
+                    }
+                    nodeOffsetStart = nodeOffsetEnd;
+                }
+                levelPerBracketType?.set(node.openingBracket.text, levelPerBracket);
+                return true;
+            }
+            case 3 : {
+                const range = lengthsToRange(nodeOffsetStart, nodeOffsetEnd);
+                return push(( new BracketInfo(range, level - 1, 0, true)));
+            }
+            case 1 : {
+                const range = lengthsToRange(nodeOffsetStart, nodeOffsetEnd);
+                return push(( new BracketInfo(
+                    range,
+                    level - 1,
+                    nestingLevelOfEqualBracketType - 1,
+                    parentPairIsIncomplete
+                )));
+            }
+            case 0 :
+                return true;
+        }
+    }
+}
+class CollectBracketPairsContext {
+    constructor(push, includeMinIndentation, textModel) {
+        this.push = push;
+        this.includeMinIndentation = includeMinIndentation;
+        this.textModel = textModel;
+    }
+}
+function collectBracketPairs(node, nodeOffsetStart, nodeOffsetEnd, startOffset, endOffset, context, level, levelPerBracketType) {
+    if (level > 200) {
+        return true;
+    }
+    let shouldContinue = true;
+    if (node.kind === 2 ) {
+        let levelPerBracket = 0;
+        if (levelPerBracketType) {
+            let existing = levelPerBracketType.get(node.openingBracket.text);
+            if (existing === undefined) {
+                existing = 0;
+            }
+            levelPerBracket = existing;
+            existing++;
+            levelPerBracketType.set(node.openingBracket.text, existing);
+        }
+        const openingBracketEnd = lengthAdd(nodeOffsetStart, node.openingBracket.length);
+        let minIndentation = -1;
+        if (context.includeMinIndentation) {
+            minIndentation = node.computeMinIndentation(nodeOffsetStart, context.textModel);
+        }
+        shouldContinue = context.push(( new BracketPairWithMinIndentationInfo(
+            lengthsToRange(nodeOffsetStart, nodeOffsetEnd),
+            lengthsToRange(nodeOffsetStart, openingBracketEnd),
+            node.closingBracket
+                ? lengthsToRange(lengthAdd(openingBracketEnd, node.child?.length || lengthZero), nodeOffsetEnd)
+                : undefined,
+            level,
+            levelPerBracket,
+            node,
+            minIndentation
+        )));
+        nodeOffsetStart = openingBracketEnd;
+        if (shouldContinue && node.child) {
+            const child = node.child;
+            nodeOffsetEnd = lengthAdd(nodeOffsetStart, child.length);
+            if (lengthLessThanEqual(nodeOffsetStart, endOffset) &&
+                lengthGreaterThanEqual(nodeOffsetEnd, startOffset)) {
+                shouldContinue = collectBracketPairs(child, nodeOffsetStart, nodeOffsetEnd, startOffset, endOffset, context, level + 1, levelPerBracketType);
+                if (!shouldContinue) {
+                    return false;
+                }
+            }
+        }
+        levelPerBracketType?.set(node.openingBracket.text, levelPerBracket);
+    }
+    else {
+        let curOffset = nodeOffsetStart;
+        for (const child of node.children) {
+            const childOffset = curOffset;
+            curOffset = lengthAdd(curOffset, child.length);
+            if (lengthLessThanEqual(childOffset, endOffset) &&
+                lengthLessThanEqual(startOffset, curOffset)) {
+                shouldContinue = collectBracketPairs(child, childOffset, curOffset, startOffset, endOffset, context, level, levelPerBracketType);
+                if (!shouldContinue) {
+                    return false;
+                }
+            }
+        }
+    }
+    return shouldContinue;
+}
+export { BracketPairsTree };

package/vscode/src/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/brackets.js

@@ -0,0 +1,112 @@
+import { escapeRegExpCharacters } from '../../../../../base/common/strings.js';
+import { BracketAstNode } from './ast.js';
+import { toLength } from './length.js';
+import { SmallImmutableSet, identityKeyProvider } from './smallImmutableSet.js';
+import { Token } from './tokenizer.js';
+class BracketTokens {
+    static createFromLanguage(configuration, denseKeyProvider) {
+        function getId(bracketInfo) {
+            return denseKeyProvider.getKey(`${bracketInfo.languageId}:::${bracketInfo.bracketText}`);
+        }
+        const map = ( new Map());
+        for (const openingBracket of configuration.bracketsNew.openingBrackets) {
+            const length = toLength(0, openingBracket.bracketText.length);
+            const openingTextId = getId(openingBracket);
+            const bracketIds = SmallImmutableSet.getEmpty().add(openingTextId, identityKeyProvider);
+            map.set(openingBracket.bracketText, ( new Token(
+                length,
+                1 ,
+                openingTextId,
+                bracketIds,
+                BracketAstNode.create(length, openingBracket, bracketIds)
+            )));
+        }
+        for (const closingBracket of configuration.bracketsNew.closingBrackets) {
+            const length = toLength(0, closingBracket.bracketText.length);
+            let bracketIds = SmallImmutableSet.getEmpty();
+            const closingBrackets = closingBracket.getOpeningBrackets();
+            for (const bracket of closingBrackets) {
+                bracketIds = bracketIds.add(getId(bracket), identityKeyProvider);
+            }
+            map.set(closingBracket.bracketText, ( new Token(
+                length,
+                2 ,
+                getId(closingBrackets[0]),
+                bracketIds,
+                BracketAstNode.create(length, closingBracket, bracketIds)
+            )));
+        }
+        return ( new BracketTokens(map));
+    }
+    constructor(map) {
+        this.map = map;
+        this.hasRegExp = false;
+        this._regExpGlobal = null;
+    }
+    getRegExpStr() {
+        if (this.isEmpty) {
+            return null;
+        }
+        else {
+            const keys = [...( this.map.keys())];
+            keys.sort();
+            keys.reverse();
+            return ( keys.map(k => prepareBracketForRegExp(k))).join('|');
+        }
+    }
+    get regExpGlobal() {
+        if (!this.hasRegExp) {
+            const regExpStr = this.getRegExpStr();
+            this._regExpGlobal = regExpStr ? ( new RegExp(regExpStr, 'gi')) : null;
+            this.hasRegExp = true;
+        }
+        return this._regExpGlobal;
+    }
+    getToken(value) {
+        return this.map.get(value.toLowerCase());
+    }
+    findClosingTokenText(openingBracketIds) {
+        for (const [closingText, info] of this.map) {
+            if (info.kind === 2  && info.bracketIds.intersects(openingBracketIds)) {
+                return closingText;
+            }
+        }
+        return undefined;
+    }
+    get isEmpty() {
+        return this.map.size === 0;
+    }
+}
+function prepareBracketForRegExp(str) {
+    let escaped = escapeRegExpCharacters(str);
+    if (/^[\w ]+/.test(str)) {
+        escaped = `\\b${escaped}`;
+    }
+    if (/[\w ]+$/.test(str)) {
+        escaped = `${escaped}\\b`;
+    }
+    return escaped;
+}
+class LanguageAgnosticBracketTokens {
+    constructor(denseKeyProvider, getLanguageConfiguration) {
+        this.denseKeyProvider = denseKeyProvider;
+        this.getLanguageConfiguration = getLanguageConfiguration;
+        this.languageIdToBracketTokens = ( new Map());
+    }
+    didLanguageChange(languageId) {
+        return ( this.languageIdToBracketTokens.has(languageId));
+    }
+    getSingleLanguageBracketTokens(languageId) {
+        let singleLanguageBracketTokens = this.languageIdToBracketTokens.get(languageId);
+        if (!singleLanguageBracketTokens) {
+            singleLanguageBracketTokens = BracketTokens.createFromLanguage(this.getLanguageConfiguration(languageId), this.denseKeyProvider);
+            this.languageIdToBracketTokens.set(languageId, singleLanguageBracketTokens);
+        }
+        return singleLanguageBracketTokens;
+    }
+    getToken(value, languageId) {
+        const singleLanguageBracketTokens = this.getSingleLanguageBracketTokens(languageId);
+        return singleLanguageBracketTokens.getToken(value);
+    }
+}
+export { BracketTokens, LanguageAgnosticBracketTokens };

package/vscode/src/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/combineTextEditInfos.js

@@ -0,0 +1,113 @@
+import { ArrayQueue } from '../../../../../base/common/arrays.js';
+import { TextEditInfo } from './beforeEditPositionMapper.js';
+import { sumLengths, lengthAdd, lengthIsZero, lengthDiffNonNegative, lengthEquals, lengthZero, lengthToObj } from './length.js';
+function combineTextEditInfos(textEditInfoFirst, textEditInfoSecond) {
+    if (textEditInfoFirst.length === 0) {
+        return textEditInfoSecond;
+    }
+    if (textEditInfoSecond.length === 0) {
+        return textEditInfoFirst;
+    }
+    const s0ToS1Map = ( new ArrayQueue(toLengthMapping(textEditInfoFirst)));
+    const s1ToS2Map = toLengthMapping(textEditInfoSecond);
+    s1ToS2Map.push({ modified: false, lengthBefore: undefined, lengthAfter: undefined });
+    let curItem = s0ToS1Map.dequeue();
+    function nextS0ToS1MapWithS1LengthOf(s1Length) {
+        if (s1Length === undefined) {
+            const arr = s0ToS1Map.takeWhile(v => true) || [];
+            if (curItem) {
+                arr.unshift(curItem);
+            }
+            return arr;
+        }
+        const result = [];
+        while (curItem && !lengthIsZero(s1Length)) {
+            const [item, remainingItem] = curItem.splitAt(s1Length);
+            result.push(item);
+            s1Length = lengthDiffNonNegative(item.lengthAfter, s1Length);
+            curItem = remainingItem ?? s0ToS1Map.dequeue();
+        }
+        if (!lengthIsZero(s1Length)) {
+            result.push(( new LengthMapping(false, s1Length, s1Length)));
+        }
+        return result;
+    }
+    const result = [];
+    function pushEdit(startOffset, endOffset, newLength) {
+        if (result.length > 0 && lengthEquals(result[result.length - 1].endOffset, startOffset)) {
+            const lastResult = result[result.length - 1];
+            result[result.length - 1] = ( new TextEditInfo(
+                lastResult.startOffset,
+                endOffset,
+                lengthAdd(lastResult.newLength, newLength)
+            ));
+        }
+        else {
+            result.push({ startOffset, endOffset, newLength });
+        }
+    }
+    let s0offset = lengthZero;
+    for (const s1ToS2 of s1ToS2Map) {
+        const s0ToS1Map = nextS0ToS1MapWithS1LengthOf(s1ToS2.lengthBefore);
+        if (s1ToS2.modified) {
+            const s0Length = sumLengths(s0ToS1Map, s => s.lengthBefore);
+            const s0EndOffset = lengthAdd(s0offset, s0Length);
+            pushEdit(s0offset, s0EndOffset, s1ToS2.lengthAfter);
+            s0offset = s0EndOffset;
+        }
+        else {
+            for (const s1 of s0ToS1Map) {
+                const s0startOffset = s0offset;
+                s0offset = lengthAdd(s0offset, s1.lengthBefore);
+                if (s1.modified) {
+                    pushEdit(s0startOffset, s0offset, s1.lengthAfter);
+                }
+            }
+        }
+    }
+    return result;
+}
+class LengthMapping {
+    constructor(
+    modified, lengthBefore, lengthAfter) {
+        this.modified = modified;
+        this.lengthBefore = lengthBefore;
+        this.lengthAfter = lengthAfter;
+    }
+    splitAt(lengthAfter) {
+        const remainingLengthAfter = lengthDiffNonNegative(lengthAfter, this.lengthAfter);
+        if (lengthEquals(remainingLengthAfter, lengthZero)) {
+            return [this, undefined];
+        }
+        else if (this.modified) {
+            return [
+                ( new LengthMapping(this.modified, this.lengthBefore, lengthAfter)),
+                ( new LengthMapping(this.modified, lengthZero, remainingLengthAfter))
+            ];
+        }
+        else {
+            return [
+                ( new LengthMapping(this.modified, lengthAfter, lengthAfter)),
+                ( new LengthMapping(this.modified, remainingLengthAfter, remainingLengthAfter))
+            ];
+        }
+    }
+    toString() {
+        return `${this.modified ? 'M' : 'U'}:${lengthToObj(this.lengthBefore)} -> ${lengthToObj(this.lengthAfter)}`;
+    }
+}
+function toLengthMapping(textEditInfos) {
+    const result = [];
+    let lastOffset = lengthZero;
+    for (const textEditInfo of textEditInfos) {
+        const spaceLength = lengthDiffNonNegative(lastOffset, textEditInfo.startOffset);
+        if (!lengthIsZero(spaceLength)) {
+            result.push(( new LengthMapping(false, spaceLength, spaceLength)));
+        }
+        const lengthBefore = lengthDiffNonNegative(textEditInfo.startOffset, textEditInfo.endOffset);
+        result.push(( new LengthMapping(true, lengthBefore, textEditInfo.newLength)));
+        lastOffset = textEditInfo.endOffset;
+    }
+    return result;
+}
+export { combineTextEditInfos };