monaco-editor11 1.1.1 → 1.1.2

package/dist/workers/computeGhostText.js

@@ -0,0 +1,182 @@
+import { LcsDiff } from '../../../../../base/common/diff/diff.js';
+import { getLeadingWhitespace } from '../../../../../base/common/strings.js';
+import { Range } from '../../../../common/core/range.js';
+import { TextReplacement } from '../../../../common/core/edits/textEdit.js';
+import { GhostTextPart, GhostText } from './ghostText.js';
+import { singleTextRemoveCommonPrefix } from './singleTextEditHelpers.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * @param previewSuffixLength Sets where to split `inlineCompletion.text`.
+ * 	If the text is `hello` and the suffix length is 2, the non-preview part is `hel` and the preview-part is `lo`.
+*/
+function computeGhostText(edit, model, mode, cursorPosition, previewSuffixLength = 0) {
+    let e = singleTextRemoveCommonPrefix(edit, model);
+    if (e.range.endLineNumber !== e.range.startLineNumber) {
+        // This edit might span multiple lines, but the first lines must be a common prefix.
+        return undefined;
+    }
+    const sourceLine = model.getLineContent(e.range.startLineNumber);
+    const sourceIndentationLength = getLeadingWhitespace(sourceLine).length;
+    const suggestionTouchesIndentation = e.range.startColumn - 1 <= sourceIndentationLength;
+    if (suggestionTouchesIndentation) {
+        // source:      ··········[······abc]
+        //                         ^^^^^^^^^ inlineCompletion.range
+        //              ^^^^^^^^^^ ^^^^^^ sourceIndentationLength
+        //                         ^^^^^^ replacedIndentation.length
+        //                               ^^^ rangeThatDoesNotReplaceIndentation
+        // inlineCompletion.text: '··foo'
+        //                         ^^ suggestionAddedIndentationLength
+        const suggestionAddedIndentationLength = getLeadingWhitespace(e.text).length;
+        const replacedIndentation = sourceLine.substring(e.range.startColumn - 1, sourceIndentationLength);
+        const [startPosition, endPosition] = [e.range.getStartPosition(), e.range.getEndPosition()];
+        const newStartPosition = startPosition.column + replacedIndentation.length <= endPosition.column
+            ? startPosition.delta(0, replacedIndentation.length)
+            : endPosition;
+        const rangeThatDoesNotReplaceIndentation = Range.fromPositions(newStartPosition, endPosition);
+        const suggestionWithoutIndentationChange = e.text.startsWith(replacedIndentation)
+            // Adds more indentation without changing existing indentation: We can add ghost text for this
+            ? e.text.substring(replacedIndentation.length)
+            // Changes or removes existing indentation. Only add ghost text for the non-indentation part.
+            : e.text.substring(suggestionAddedIndentationLength);
+        e = new TextReplacement(rangeThatDoesNotReplaceIndentation, suggestionWithoutIndentationChange);
+    }
+    // This is a single line string
+    const valueToBeReplaced = model.getValueInRange(e.range);
+    const changes = cachingDiff(valueToBeReplaced, e.text);
+    if (!changes) {
+        // No ghost text in case the diff would be too slow to compute
+        return undefined;
+    }
+    const lineNumber = e.range.startLineNumber;
+    const parts = new Array();
+    if (mode === 'prefix') {
+        const filteredChanges = changes.filter(c => c.originalLength === 0);
+        if (filteredChanges.length > 1 || filteredChanges.length === 1 && filteredChanges[0].originalStart !== valueToBeReplaced.length) {
+            // Prefixes only have a single change.
+            return undefined;
+        }
+    }
+    const previewStartInCompletionText = e.text.length - previewSuffixLength;
+    for (const c of changes) {
+        const insertColumn = e.range.startColumn + c.originalStart + c.originalLength;
+        if (mode === 'subwordSmart' && cursorPosition && cursorPosition.lineNumber === e.range.startLineNumber && insertColumn < cursorPosition.column) {
+            // No ghost text before cursor
+            return undefined;
+        }
+        if (c.originalLength > 0) {
+            return undefined;
+        }
+        if (c.modifiedLength === 0) {
+            continue;
+        }
+        const modifiedEnd = c.modifiedStart + c.modifiedLength;
+        const nonPreviewTextEnd = Math.max(c.modifiedStart, Math.min(modifiedEnd, previewStartInCompletionText));
+        const nonPreviewText = e.text.substring(c.modifiedStart, nonPreviewTextEnd);
+        const italicText = e.text.substring(nonPreviewTextEnd, Math.max(c.modifiedStart, modifiedEnd));
+        if (nonPreviewText.length > 0) {
+            parts.push(new GhostTextPart(insertColumn, nonPreviewText, false));
+        }
+        if (italicText.length > 0) {
+            parts.push(new GhostTextPart(insertColumn, italicText, true));
+        }
+    }
+    return new GhostText(lineNumber, parts);
+}
+let lastRequest = undefined;
+function cachingDiff(originalValue, newValue) {
+    if (lastRequest?.originalValue === originalValue && lastRequest?.newValue === newValue) {
+        return lastRequest?.changes;
+    }
+    else {
+        let changes = smartDiff(originalValue, newValue, true);
+        if (changes) {
+            const deletedChars = deletedCharacters(changes);
+            if (deletedChars > 0) {
+                // For performance reasons, don't compute diff if there is nothing to improve
+                const newChanges = smartDiff(originalValue, newValue, false);
+                if (newChanges && deletedCharacters(newChanges) < deletedChars) {
+                    // Disabling smartness seems to be better here
+                    changes = newChanges;
+                }
+            }
+        }
+        lastRequest = {
+            originalValue,
+            newValue,
+            changes
+        };
+        return changes;
+    }
+}
+function deletedCharacters(changes) {
+    let sum = 0;
+    for (const c of changes) {
+        sum += c.originalLength;
+    }
+    return sum;
+}
+/**
+ * When matching `if ()` with `if (f() = 1) { g(); }`,
+ * align it like this:        `if (       )`
+ * Not like this:			  `if (  )`
+ * Also not like this:		  `if (             )`.
+ *
+ * The parenthesis are preprocessed to ensure that they match correctly.
+ */
+function smartDiff(originalValue, newValue, smartBracketMatching) {
+    if (originalValue.length > 5000 || newValue.length > 5000) {
+        // We don't want to work on strings that are too big
+        return undefined;
+    }
+    function getMaxCharCode(val) {
+        let maxCharCode = 0;
+        for (let i = 0, len = val.length; i < len; i++) {
+            const charCode = val.charCodeAt(i);
+            if (charCode > maxCharCode) {
+                maxCharCode = charCode;
+            }
+        }
+        return maxCharCode;
+    }
+    const maxCharCode = Math.max(getMaxCharCode(originalValue), getMaxCharCode(newValue));
+    function getUniqueCharCode(id) {
+        if (id < 0) {
+            throw new Error('unexpected');
+        }
+        return maxCharCode + id + 1;
+    }
+    function getElements(source) {
+        let level = 0;
+        let group = 0;
+        const characters = new Int32Array(source.length);
+        for (let i = 0, len = source.length; i < len; i++) {
+            // TODO support more brackets
+            if (smartBracketMatching && source[i] === '(') {
+                const id = group * 100 + level;
+                characters[i] = getUniqueCharCode(2 * id);
+                level++;
+            }
+            else if (smartBracketMatching && source[i] === ')') {
+                level = Math.max(level - 1, 0);
+                const id = group * 100 + level;
+                characters[i] = getUniqueCharCode(2 * id + 1);
+                if (level === 0) {
+                    group++;
+                }
+            }
+            else {
+                characters[i] = source.charCodeAt(i);
+            }
+        }
+        return characters;
+    }
+    const elements1 = getElements(originalValue);
+    const elements2 = getElements(newValue);
+    return new LcsDiff({ getElements: () => elements1 }, { getElements: () => elements2 }).ComputeDiff(false).changes;
+}
+
+export { computeGhostText, smartDiff };

package/dist/workers/computeMovedLines.js

@@ -0,0 +1,249 @@
+import { SequenceDiff } from './algorithms/diffAlgorithm.js';
+import { LineRangeMapping } from '../rangeMapping.js';
+import { pushMany, compareBy, numberComparator, reverseOrder } from '../../../../base/common/arrays.js';
+import { MonotonousArray, findLastMonotonous } from '../../../../base/common/arraysFind.js';
+import { SetMap } from '../../../../base/common/map.js';
+import { LineRange, LineRangeSet } from '../../core/ranges/lineRange.js';
+import { LinesSliceCharSequence } from './linesSliceCharSequence.js';
+import { LineRangeFragment, isSpace } from './utils.js';
+import { MyersDiffAlgorithm } from './algorithms/myersDiffAlgorithm.js';
+import { Range } from '../../core/range.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+function computeMovedLines(changes, originalLines, modifiedLines, hashedOriginalLines, hashedModifiedLines, timeout) {
+    let { moves, excludedChanges } = computeMovesFromSimpleDeletionsToSimpleInsertions(changes, originalLines, modifiedLines, timeout);
+    if (!timeout.isValid()) {
+        return [];
+    }
+    const filteredChanges = changes.filter(c => !excludedChanges.has(c));
+    const unchangedMoves = computeUnchangedMoves(filteredChanges, hashedOriginalLines, hashedModifiedLines, originalLines, modifiedLines, timeout);
+    pushMany(moves, unchangedMoves);
+    moves = joinCloseConsecutiveMoves(moves);
+    // Ignore too short moves
+    moves = moves.filter(current => {
+        const lines = current.original.toOffsetRange().slice(originalLines).map(l => l.trim());
+        const originalText = lines.join('\n');
+        return originalText.length >= 15 && countWhere(lines, l => l.length >= 2) >= 2;
+    });
+    moves = removeMovesInSameDiff(changes, moves);
+    return moves;
+}
+function countWhere(arr, predicate) {
+    let count = 0;
+    for (const t of arr) {
+        if (predicate(t)) {
+            count++;
+        }
+    }
+    return count;
+}
+function computeMovesFromSimpleDeletionsToSimpleInsertions(changes, originalLines, modifiedLines, timeout) {
+    const moves = [];
+    const deletions = changes
+        .filter(c => c.modified.isEmpty && c.original.length >= 3)
+        .map(d => new LineRangeFragment(d.original, originalLines, d));
+    const insertions = new Set(changes
+        .filter(c => c.original.isEmpty && c.modified.length >= 3)
+        .map(d => new LineRangeFragment(d.modified, modifiedLines, d)));
+    const excludedChanges = new Set();
+    for (const deletion of deletions) {
+        let highestSimilarity = -1;
+        let best;
+        for (const insertion of insertions) {
+            const similarity = deletion.computeSimilarity(insertion);
+            if (similarity > highestSimilarity) {
+                highestSimilarity = similarity;
+                best = insertion;
+            }
+        }
+        if (highestSimilarity > 0.90 && best) {
+            insertions.delete(best);
+            moves.push(new LineRangeMapping(deletion.range, best.range));
+            excludedChanges.add(deletion.source);
+            excludedChanges.add(best.source);
+        }
+        if (!timeout.isValid()) {
+            return { moves, excludedChanges };
+        }
+    }
+    return { moves, excludedChanges };
+}
+function computeUnchangedMoves(changes, hashedOriginalLines, hashedModifiedLines, originalLines, modifiedLines, timeout) {
+    const moves = [];
+    const original3LineHashes = new SetMap();
+    for (const change of changes) {
+        for (let i = change.original.startLineNumber; i < change.original.endLineNumberExclusive - 2; i++) {
+            const key = `${hashedOriginalLines[i - 1]}:${hashedOriginalLines[i + 1 - 1]}:${hashedOriginalLines[i + 2 - 1]}`;
+            original3LineHashes.add(key, { range: new LineRange(i, i + 3) });
+        }
+    }
+    const possibleMappings = [];
+    changes.sort(compareBy(c => c.modified.startLineNumber, numberComparator));
+    for (const change of changes) {
+        let lastMappings = [];
+        for (let i = change.modified.startLineNumber; i < change.modified.endLineNumberExclusive - 2; i++) {
+            const key = `${hashedModifiedLines[i - 1]}:${hashedModifiedLines[i + 1 - 1]}:${hashedModifiedLines[i + 2 - 1]}`;
+            const currentModifiedRange = new LineRange(i, i + 3);
+            const nextMappings = [];
+            original3LineHashes.forEach(key, ({ range }) => {
+                for (const lastMapping of lastMappings) {
+                    // does this match extend some last match?
+                    if (lastMapping.originalLineRange.endLineNumberExclusive + 1 === range.endLineNumberExclusive &&
+                        lastMapping.modifiedLineRange.endLineNumberExclusive + 1 === currentModifiedRange.endLineNumberExclusive) {
+                        lastMapping.originalLineRange = new LineRange(lastMapping.originalLineRange.startLineNumber, range.endLineNumberExclusive);
+                        lastMapping.modifiedLineRange = new LineRange(lastMapping.modifiedLineRange.startLineNumber, currentModifiedRange.endLineNumberExclusive);
+                        nextMappings.push(lastMapping);
+                        return;
+                    }
+                }
+                const mapping = {
+                    modifiedLineRange: currentModifiedRange,
+                    originalLineRange: range,
+                };
+                possibleMappings.push(mapping);
+                nextMappings.push(mapping);
+            });
+            lastMappings = nextMappings;
+        }
+        if (!timeout.isValid()) {
+            return [];
+        }
+    }
+    possibleMappings.sort(reverseOrder(compareBy(m => m.modifiedLineRange.length, numberComparator)));
+    const modifiedSet = new LineRangeSet();
+    const originalSet = new LineRangeSet();
+    for (const mapping of possibleMappings) {
+        const diffOrigToMod = mapping.modifiedLineRange.startLineNumber - mapping.originalLineRange.startLineNumber;
+        const modifiedSections = modifiedSet.subtractFrom(mapping.modifiedLineRange);
+        const originalTranslatedSections = originalSet.subtractFrom(mapping.originalLineRange).getWithDelta(diffOrigToMod);
+        const modifiedIntersectedSections = modifiedSections.getIntersection(originalTranslatedSections);
+        for (const s of modifiedIntersectedSections.ranges) {
+            if (s.length < 3) {
+                continue;
+            }
+            const modifiedLineRange = s;
+            const originalLineRange = s.delta(-diffOrigToMod);
+            moves.push(new LineRangeMapping(originalLineRange, modifiedLineRange));
+            modifiedSet.addRange(modifiedLineRange);
+            originalSet.addRange(originalLineRange);
+        }
+    }
+    moves.sort(compareBy(m => m.original.startLineNumber, numberComparator));
+    const monotonousChanges = new MonotonousArray(changes);
+    for (let i = 0; i < moves.length; i++) {
+        const move = moves[i];
+        const firstTouchingChangeOrig = monotonousChanges.findLastMonotonous(c => c.original.startLineNumber <= move.original.startLineNumber);
+        const firstTouchingChangeMod = findLastMonotonous(changes, c => c.modified.startLineNumber <= move.modified.startLineNumber);
+        const linesAbove = Math.max(move.original.startLineNumber - firstTouchingChangeOrig.original.startLineNumber, move.modified.startLineNumber - firstTouchingChangeMod.modified.startLineNumber);
+        const lastTouchingChangeOrig = monotonousChanges.findLastMonotonous(c => c.original.startLineNumber < move.original.endLineNumberExclusive);
+        const lastTouchingChangeMod = findLastMonotonous(changes, c => c.modified.startLineNumber < move.modified.endLineNumberExclusive);
+        const linesBelow = Math.max(lastTouchingChangeOrig.original.endLineNumberExclusive - move.original.endLineNumberExclusive, lastTouchingChangeMod.modified.endLineNumberExclusive - move.modified.endLineNumberExclusive);
+        let extendToTop;
+        for (extendToTop = 0; extendToTop < linesAbove; extendToTop++) {
+            const origLine = move.original.startLineNumber - extendToTop - 1;
+            const modLine = move.modified.startLineNumber - extendToTop - 1;
+            if (origLine > originalLines.length || modLine > modifiedLines.length) {
+                break;
+            }
+            if (modifiedSet.contains(modLine) || originalSet.contains(origLine)) {
+                break;
+            }
+            if (!areLinesSimilar(originalLines[origLine - 1], modifiedLines[modLine - 1], timeout)) {
+                break;
+            }
+        }
+        if (extendToTop > 0) {
+            originalSet.addRange(new LineRange(move.original.startLineNumber - extendToTop, move.original.startLineNumber));
+            modifiedSet.addRange(new LineRange(move.modified.startLineNumber - extendToTop, move.modified.startLineNumber));
+        }
+        let extendToBottom;
+        for (extendToBottom = 0; extendToBottom < linesBelow; extendToBottom++) {
+            const origLine = move.original.endLineNumberExclusive + extendToBottom;
+            const modLine = move.modified.endLineNumberExclusive + extendToBottom;
+            if (origLine > originalLines.length || modLine > modifiedLines.length) {
+                break;
+            }
+            if (modifiedSet.contains(modLine) || originalSet.contains(origLine)) {
+                break;
+            }
+            if (!areLinesSimilar(originalLines[origLine - 1], modifiedLines[modLine - 1], timeout)) {
+                break;
+            }
+        }
+        if (extendToBottom > 0) {
+            originalSet.addRange(new LineRange(move.original.endLineNumberExclusive, move.original.endLineNumberExclusive + extendToBottom));
+            modifiedSet.addRange(new LineRange(move.modified.endLineNumberExclusive, move.modified.endLineNumberExclusive + extendToBottom));
+        }
+        if (extendToTop > 0 || extendToBottom > 0) {
+            moves[i] = new LineRangeMapping(new LineRange(move.original.startLineNumber - extendToTop, move.original.endLineNumberExclusive + extendToBottom), new LineRange(move.modified.startLineNumber - extendToTop, move.modified.endLineNumberExclusive + extendToBottom));
+        }
+    }
+    return moves;
+}
+function areLinesSimilar(line1, line2, timeout) {
+    if (line1.trim() === line2.trim()) {
+        return true;
+    }
+    if (line1.length > 300 && line2.length > 300) {
+        return false;
+    }
+    const myersDiffingAlgorithm = new MyersDiffAlgorithm();
+    const result = myersDiffingAlgorithm.compute(new LinesSliceCharSequence([line1], new Range(1, 1, 1, line1.length), false), new LinesSliceCharSequence([line2], new Range(1, 1, 1, line2.length), false), timeout);
+    let commonNonSpaceCharCount = 0;
+    const inverted = SequenceDiff.invert(result.diffs, line1.length);
+    for (const seq of inverted) {
+        seq.seq1Range.forEach(idx => {
+            if (!isSpace(line1.charCodeAt(idx))) {
+                commonNonSpaceCharCount++;
+            }
+        });
+    }
+    function countNonWsChars(str) {
+        let count = 0;
+        for (let i = 0; i < line1.length; i++) {
+            if (!isSpace(str.charCodeAt(i))) {
+                count++;
+            }
+        }
+        return count;
+    }
+    const longerLineLength = countNonWsChars(line1.length > line2.length ? line1 : line2);
+    const r = commonNonSpaceCharCount / longerLineLength > 0.6 && longerLineLength > 10;
+    return r;
+}
+function joinCloseConsecutiveMoves(moves) {
+    if (moves.length === 0) {
+        return moves;
+    }
+    moves.sort(compareBy(m => m.original.startLineNumber, numberComparator));
+    const result = [moves[0]];
+    for (let i = 1; i < moves.length; i++) {
+        const last = result[result.length - 1];
+        const current = moves[i];
+        const originalDist = current.original.startLineNumber - last.original.endLineNumberExclusive;
+        const modifiedDist = current.modified.startLineNumber - last.modified.endLineNumberExclusive;
+        const currentMoveAfterLast = originalDist >= 0 && modifiedDist >= 0;
+        if (currentMoveAfterLast && originalDist + modifiedDist <= 2) {
+            result[result.length - 1] = last.join(current);
+            continue;
+        }
+        result.push(current);
+    }
+    return result;
+}
+function removeMovesInSameDiff(changes, moves) {
+    const changesMonotonous = new MonotonousArray(changes);
+    moves = moves.filter(m => {
+        const diffBeforeEndOfMoveOriginal = changesMonotonous.findLastMonotonous(c => c.original.startLineNumber < m.original.endLineNumberExclusive)
+            || new LineRangeMapping(new LineRange(1, 1), new LineRange(1, 1));
+        const diffBeforeEndOfMoveModified = findLastMonotonous(changes, c => c.modified.startLineNumber < m.modified.endLineNumberExclusive);
+        const differentDiffs = diffBeforeEndOfMoveOriginal !== diffBeforeEndOfMoveModified;
+        return differentDiffs;
+    });
+    return moves;
+}
+
+export { computeMovedLines };

package/dist/workers/concat23Trees.js

@@ -0,0 +1,192 @@
+import { ListAstNode } from './ast.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Concatenates a list of (2,3) AstNode's into a single (2,3) AstNode.
+ * This mutates the items of the input array!
+ * If all items have the same height, this method has runtime O(items.length).
+ * Otherwise, it has runtime O(items.length * max(log(items.length), items.max(i => i.height))).
+*/
+function concat23Trees(items) {
+    if (items.length === 0) {
+        return null;
+    }
+    if (items.length === 1) {
+        return items[0];
+    }
+    let i = 0;
+    /**
+     * Reads nodes of same height and concatenates them to a single node.
+    */
+    function readNode() {
+        if (i >= items.length) {
+            return null;
+        }
+        const start = i;
+        const height = items[start].listHeight;
+        i++;
+        while (i < items.length && items[i].listHeight === height) {
+            i++;
+        }
+        if (i - start >= 2) {
+            return concat23TreesOfSameHeight(start === 0 && i === items.length ? items : items.slice(start, i), false);
+        }
+        else {
+            return items[start];
+        }
+    }
+    // The items might not have the same height.
+    // We merge all items by using a binary concat operator.
+    let first = readNode(); // There must be a first item
+    let second = readNode();
+    if (!second) {
+        return first;
+    }
+    for (let item = readNode(); item; item = readNode()) {
+        // Prefer concatenating smaller trees, as the runtime of concat depends on the tree height.
+        if (heightDiff(first, second) <= heightDiff(second, item)) {
+            first = concat(first, second);
+            second = item;
+        }
+        else {
+            second = concat(second, item);
+        }
+    }
+    const result = concat(first, second);
+    return result;
+}
+function concat23TreesOfSameHeight(items, createImmutableLists = false) {
+    if (items.length === 0) {
+        return null;
+    }
+    if (items.length === 1) {
+        return items[0];
+    }
+    let length = items.length;
+    // All trees have same height, just create parent nodes.
+    while (length > 3) {
+        const newLength = length >> 1;
+        for (let i = 0; i < newLength; i++) {
+            const j = i << 1;
+            items[i] = ListAstNode.create23(items[j], items[j + 1], j + 3 === length ? items[j + 2] : null, createImmutableLists);
+        }
+        length = newLength;
+    }
+    return ListAstNode.create23(items[0], items[1], length >= 3 ? items[2] : null, createImmutableLists);
+}
+function heightDiff(node1, node2) {
+    return Math.abs(node1.listHeight - node2.listHeight);
+}
+function concat(node1, node2) {
+    if (node1.listHeight === node2.listHeight) {
+        return ListAstNode.create23(node1, node2, null, false);
+    }
+    else if (node1.listHeight > node2.listHeight) {
+        // node1 is the tree we want to insert into
+        return append(node1, node2);
+    }
+    else {
+        return prepend(node2, node1);
+    }
+}
+/**
+ * Appends the given node to the end of this (2,3) tree.
+ * Returns the new root.
+*/
+function append(list, nodeToAppend) {
+    list = list.toMutable();
+    let curNode = list;
+    const parents = [];
+    let nodeToAppendOfCorrectHeight;
+    while (true) {
+        // assert nodeToInsert.listHeight <= curNode.listHeight
+        if (nodeToAppend.listHeight === curNode.listHeight) {
+            nodeToAppendOfCorrectHeight = nodeToAppend;
+            break;
+        }
+        // assert 0 <= nodeToInsert.listHeight < curNode.listHeight
+        if (curNode.kind !== 4 /* AstNodeKind.List */) {
+            throw new Error('unexpected');
+        }
+        parents.push(curNode);
+        // assert 2 <= curNode.childrenLength <= 3
+        curNode = curNode.makeLastElementMutable();
+    }
+    // assert nodeToAppendOfCorrectHeight!.listHeight === curNode.listHeight
+    for (let i = parents.length - 1; i >= 0; i--) {
+        const parent = parents[i];
+        if (nodeToAppendOfCorrectHeight) {
+            // Can we take the element?
+            if (parent.childrenLength >= 3) {
+                // assert parent.childrenLength === 3 && parent.listHeight === nodeToAppendOfCorrectHeight.listHeight + 1
+                // we need to split to maintain (2,3)-tree property.
+                // Send the third element + the new element to the parent.
+                nodeToAppendOfCorrectHeight = ListAstNode.create23(parent.unappendChild(), nodeToAppendOfCorrectHeight, null, false);
+            }
+            else {
+                parent.appendChildOfSameHeight(nodeToAppendOfCorrectHeight);
+                nodeToAppendOfCorrectHeight = undefined;
+            }
+        }
+        else {
+            parent.handleChildrenChanged();
+        }
+    }
+    if (nodeToAppendOfCorrectHeight) {
+        return ListAstNode.create23(list, nodeToAppendOfCorrectHeight, null, false);
+    }
+    else {
+        return list;
+    }
+}
+/**
+ * Prepends the given node to the end of this (2,3) tree.
+ * Returns the new root.
+*/
+function prepend(list, nodeToAppend) {
+    list = list.toMutable();
+    let curNode = list;
+    const parents = [];
+    // assert nodeToInsert.listHeight <= curNode.listHeight
+    while (nodeToAppend.listHeight !== curNode.listHeight) {
+        // assert 0 <= nodeToInsert.listHeight < curNode.listHeight
+        if (curNode.kind !== 4 /* AstNodeKind.List */) {
+            throw new Error('unexpected');
+        }
+        parents.push(curNode);
+        // assert 2 <= curNode.childrenFast.length <= 3
+        curNode = curNode.makeFirstElementMutable();
+    }
+    let nodeToPrependOfCorrectHeight = nodeToAppend;
+    // assert nodeToAppendOfCorrectHeight!.listHeight === curNode.listHeight
+    for (let i = parents.length - 1; i >= 0; i--) {
+        const parent = parents[i];
+        if (nodeToPrependOfCorrectHeight) {
+            // Can we take the element?
+            if (parent.childrenLength >= 3) {
+                // assert parent.childrenLength === 3 && parent.listHeight === nodeToAppendOfCorrectHeight.listHeight + 1
+                // we need to split to maintain (2,3)-tree property.
+                // Send the third element + the new element to the parent.
+                nodeToPrependOfCorrectHeight = ListAstNode.create23(nodeToPrependOfCorrectHeight, parent.unprependChild(), null, false);
+            }
+            else {
+                parent.prependChildOfSameHeight(nodeToPrependOfCorrectHeight);
+                nodeToPrependOfCorrectHeight = undefined;
+            }
+        }
+        else {
+            parent.handleChildrenChanged();
+        }
+    }
+    if (nodeToPrependOfCorrectHeight) {
+        return ListAstNode.create23(nodeToPrependOfCorrectHeight, list, null, false);
+    }
+    else {
+        return list;
+    }
+}
+
+export { concat23Trees, concat23TreesOfSameHeight };