@codingame/monaco-vscode-treesitter-service-override 17.2.1 → 18.0.1

package/vscode/src/vs/editor/common/model/tokenStore.js

@@ -1,412 +0,0 @@
-
-
-class ListNode {
-    get children() { return this._children; }
-    get length() { return this._length; }
-    constructor(height) {
-        this.height = height;
-        this._children = [];
-        this._length = 0;
-    }
-    static create(node1, node2) {
-        const list = ( new ListNode(node1.height + 1));
-        list.appendChild(node1);
-        list.appendChild(node2);
-        return list;
-    }
-    canAppendChild() {
-        return this._children.length < 3;
-    }
-    appendChild(node) {
-        if (!this.canAppendChild()) {
-            throw ( new Error('Cannot insert more than 3 children in a ListNode'));
-        }
-        this._children.push(node);
-        this._length += node.length;
-        this._updateParentLength(node.length);
-        if (!isLeaf(node)) {
-            node.parent = this;
-        }
-    }
-    _updateParentLength(delta) {
-        let updateParent = this.parent;
-        while (updateParent) {
-            updateParent._length += delta;
-            updateParent = updateParent.parent;
-        }
-    }
-    unappendChild() {
-        const child = this._children.pop();
-        this._length -= child.length;
-        this._updateParentLength(-child.length);
-        return child;
-    }
-    prependChild(node) {
-        if (this._children.length >= 3) {
-            throw ( new Error('Cannot prepend more than 3 children in a ListNode'));
-        }
-        this._children.unshift(node);
-        this._length += node.length;
-        this._updateParentLength(node.length);
-        if (!isLeaf(node)) {
-            node.parent = this;
-        }
-    }
-    unprependChild() {
-        const child = this._children.shift();
-        this._length -= child.length;
-        this._updateParentLength(-child.length);
-        return child;
-    }
-    lastChild() {
-        return this._children[this._children.length - 1];
-    }
-    dispose() {
-        this._children.splice(0, this._children.length);
-    }
-}
-var TokenQuality;
-(function (TokenQuality) {
-    TokenQuality[TokenQuality["None"] = 0] = "None";
-    TokenQuality[TokenQuality["ViewportGuess"] = 1] = "ViewportGuess";
-    TokenQuality[TokenQuality["EditGuess"] = 2] = "EditGuess";
-    TokenQuality[TokenQuality["Accurate"] = 3] = "Accurate";
-})(TokenQuality || (TokenQuality = {}));
-function isLeaf(node) {
-    return node.token !== undefined;
-}
-function append(node, nodeToAppend) {
-    let curNode = node;
-    const parents = [];
-    let nodeToAppendOfCorrectHeight;
-    while (true) {
-        if (nodeToAppend.height === curNode.height) {
-            nodeToAppendOfCorrectHeight = nodeToAppend;
-            break;
-        }
-        if (isLeaf(curNode)) {
-            throw ( new Error('unexpected'));
-        }
-        parents.push(curNode);
-        curNode = curNode.lastChild();
-    }
-    for (let i = parents.length - 1; i >= 0; i--) {
-        const parent = parents[i];
-        if (nodeToAppendOfCorrectHeight) {
-            if (parent.children.length >= 3) {
-                const newList = ListNode.create(parent.unappendChild(), nodeToAppendOfCorrectHeight);
-                nodeToAppendOfCorrectHeight = newList;
-            }
-            else {
-                parent.appendChild(nodeToAppendOfCorrectHeight);
-                nodeToAppendOfCorrectHeight = undefined;
-            }
-        }
-    }
-    if (nodeToAppendOfCorrectHeight) {
-        const newList = ( new ListNode(nodeToAppendOfCorrectHeight.height + 1));
-        newList.appendChild(node);
-        newList.appendChild(nodeToAppendOfCorrectHeight);
-        return newList;
-    }
-    else {
-        return node;
-    }
-}
-function prepend(list, nodeToAppend) {
-    let curNode = list;
-    const parents = [];
-    while (nodeToAppend.height !== curNode.height) {
-        if (isLeaf(curNode)) {
-            throw ( new Error('unexpected'));
-        }
-        parents.push(curNode);
-        curNode = curNode.children[0];
-    }
-    let nodeToPrependOfCorrectHeight = nodeToAppend;
-    for (let i = parents.length - 1; i >= 0; i--) {
-        const parent = parents[i];
-        if (nodeToPrependOfCorrectHeight) {
-            if (parent.children.length >= 3) {
-                nodeToPrependOfCorrectHeight = ListNode.create(nodeToPrependOfCorrectHeight, parent.unprependChild());
-            }
-            else {
-                parent.prependChild(nodeToPrependOfCorrectHeight);
-                nodeToPrependOfCorrectHeight = undefined;
-            }
-        }
-    }
-    if (nodeToPrependOfCorrectHeight) {
-        return ListNode.create(nodeToPrependOfCorrectHeight, list);
-    }
-    else {
-        return list;
-    }
-}
-function concat(node1, node2) {
-    if (node1.height === node2.height) {
-        return ListNode.create(node1, node2);
-    }
-    else if (node1.height > node2.height) {
-        return append(node1, node2);
-    }
-    else {
-        return prepend(node2, node1);
-    }
-}
-class TokenStore {
-    get root() {
-        return this._root;
-    }
-    constructor(_textModel) {
-        this._textModel = _textModel;
-        this._root = this.createEmptyRoot();
-    }
-    createEmptyRoot() {
-        return {
-            length: this._textModel.getValueLength(),
-            token: 0,
-            height: 0,
-            tokenQuality: TokenQuality.None
-        };
-    }
-    buildStore(tokens, tokenQuality) {
-        this._root = this.createFromUpdates(tokens, tokenQuality);
-    }
-    createFromUpdates(tokens, tokenQuality) {
-        if (tokens.length === 0) {
-            return this.createEmptyRoot();
-        }
-        let newRoot = {
-            length: tokens[0].length,
-            token: tokens[0].token,
-            height: 0,
-            tokenQuality
-        };
-        for (let j = 1; j < tokens.length; j++) {
-            newRoot = append(newRoot, { length: tokens[j].length, token: tokens[j].token, height: 0, tokenQuality });
-        }
-        return newRoot;
-    }
-    update(length, tokens, tokenQuality) {
-        if (tokens.length === 0) {
-            return;
-        }
-        this.replace(length, tokens[0].startOffsetInclusive, tokens, tokenQuality);
-    }
-    delete(length, startOffset) {
-        this.replace(length, startOffset, [], TokenQuality.EditGuess);
-    }
-    replace(length, updateOffsetStart, tokens, tokenQuality) {
-        const firstUnchangedOffsetAfterUpdate = updateOffsetStart + length;
-        const precedingNodes = [];
-        const postcedingNodes = [];
-        const stack = [{ node: this._root, offset: 0 }];
-        while (stack.length > 0) {
-            const node = stack.pop();
-            const currentOffset = node.offset;
-            if (currentOffset < updateOffsetStart && currentOffset + node.node.length <= updateOffsetStart) {
-                if (!isLeaf(node.node)) {
-                    node.node.parent = undefined;
-                }
-                precedingNodes.push(node.node);
-                continue;
-            }
-            else if (isLeaf(node.node) && (currentOffset < updateOffsetStart)) {
-                precedingNodes.push({ length: updateOffsetStart - currentOffset, token: node.node.token, height: 0, tokenQuality: node.node.tokenQuality });
-            }
-            if ((updateOffsetStart <= currentOffset) && (currentOffset + node.node.length <= firstUnchangedOffsetAfterUpdate)) {
-                continue;
-            }
-            if (currentOffset >= firstUnchangedOffsetAfterUpdate) {
-                if (!isLeaf(node.node)) {
-                    node.node.parent = undefined;
-                }
-                postcedingNodes.push(node.node);
-                continue;
-            }
-            else if (isLeaf(node.node) && (currentOffset + node.node.length > firstUnchangedOffsetAfterUpdate)) {
-                postcedingNodes.push({ length: currentOffset + node.node.length - firstUnchangedOffsetAfterUpdate, token: node.node.token, height: 0, tokenQuality: node.node.tokenQuality });
-                continue;
-            }
-            if (!isLeaf(node.node)) {
-                let childOffset = currentOffset + node.node.length;
-                for (let i = node.node.children.length - 1; i >= 0; i--) {
-                    childOffset -= node.node.children[i].length;
-                    stack.push({ node: node.node.children[i], offset: childOffset });
-                }
-            }
-        }
-        let allNodes;
-        if (tokens.length > 0) {
-            allNodes = precedingNodes.concat(this.createFromUpdates(tokens, tokenQuality), postcedingNodes);
-        }
-        else {
-            allNodes = precedingNodes.concat(postcedingNodes);
-        }
-        let newRoot = allNodes[0];
-        for (let i = 1; i < allNodes.length; i++) {
-            newRoot = concat(newRoot, allNodes[i]);
-        }
-        this._root = newRoot ?? this.createEmptyRoot();
-    }
-    traverseInOrderInRange(startOffsetInclusive, endOffsetExclusive, visitor) {
-        const stack = [{ node: this._root, offset: 0 }];
-        while (stack.length > 0) {
-            const { node, offset } = stack.pop();
-            const nodeEnd = offset + node.length;
-            if (nodeEnd <= startOffsetInclusive || offset >= endOffsetExclusive) {
-                continue;
-            }
-            if (visitor(node, offset)) {
-                return;
-            }
-            if (!isLeaf(node)) {
-                let childOffset = offset + node.length;
-                for (let i = node.children.length - 1; i >= 0; i--) {
-                    childOffset -= node.children[i].length;
-                    stack.push({ node: node.children[i], offset: childOffset });
-                }
-            }
-        }
-    }
-    getTokenAt(offset) {
-        let result;
-        this.traverseInOrderInRange(offset, this._root.length, (node, offset) => {
-            if (isLeaf(node)) {
-                result = { token: node.token, startOffsetInclusive: offset, length: node.length };
-                return true;
-            }
-            return false;
-        });
-        return result;
-    }
-    getTokensInRange(startOffsetInclusive, endOffsetExclusive) {
-        const result = [];
-        this.traverseInOrderInRange(startOffsetInclusive, endOffsetExclusive, (node, offset) => {
-            if (isLeaf(node)) {
-                let clippedLength = node.length;
-                let clippedOffset = offset;
-                if ((offset < startOffsetInclusive) && (offset + node.length > endOffsetExclusive)) {
-                    clippedOffset = startOffsetInclusive;
-                    clippedLength = endOffsetExclusive - startOffsetInclusive;
-                }
-                else if (offset < startOffsetInclusive) {
-                    clippedLength -= (startOffsetInclusive - offset);
-                    clippedOffset = startOffsetInclusive;
-                }
-                else if (offset + node.length > endOffsetExclusive) {
-                    clippedLength -= (offset + node.length - endOffsetExclusive);
-                }
-                result.push({ token: node.token, startOffsetInclusive: clippedOffset, length: clippedLength });
-            }
-            return false;
-        });
-        return result;
-    }
-    markForRefresh(startOffsetInclusive, endOffsetExclusive) {
-        this.traverseInOrderInRange(startOffsetInclusive, endOffsetExclusive, (node) => {
-            if (isLeaf(node)) {
-                node.tokenQuality = TokenQuality.None;
-            }
-            return false;
-        });
-    }
-    rangeHasTokens(startOffsetInclusive, endOffsetExclusive, minimumTokenQuality) {
-        let hasAny = true;
-        this.traverseInOrderInRange(startOffsetInclusive, endOffsetExclusive, (node) => {
-            if (isLeaf(node) && (node.tokenQuality < minimumTokenQuality)) {
-                hasAny = false;
-            }
-            return false;
-        });
-        return hasAny;
-    }
-    rangeNeedsRefresh(startOffsetInclusive, endOffsetExclusive) {
-        let needsRefresh = false;
-        this.traverseInOrderInRange(startOffsetInclusive, endOffsetExclusive, (node) => {
-            if (isLeaf(node) && (node.tokenQuality !== TokenQuality.Accurate)) {
-                needsRefresh = true;
-            }
-            return false;
-        });
-        return needsRefresh;
-    }
-    getNeedsRefresh() {
-        const result = [];
-        this.traverseInOrderInRange(0, this._textModel.getValueLength(), (node, offset) => {
-            if (isLeaf(node) && (node.tokenQuality !== TokenQuality.Accurate)) {
-                if ((result.length > 0) && (result[result.length - 1].endOffset === offset)) {
-                    result[result.length - 1].endOffset += node.length;
-                }
-                else {
-                    result.push({ startOffset: offset, endOffset: offset + node.length });
-                }
-            }
-            return false;
-        });
-        return result;
-    }
-    deepCopy() {
-        const newStore = ( new TokenStore(this._textModel));
-        newStore._root = this._copyNodeIterative(this._root);
-        return newStore;
-    }
-    _copyNodeIterative(root) {
-        const newRoot = isLeaf(root)
-            ? { length: root.length, token: root.token, tokenQuality: root.tokenQuality, height: root.height }
-            : ( new ListNode(root.height));
-        const stack = [[root, newRoot]];
-        while (stack.length > 0) {
-            const [oldNode, clonedNode] = stack.pop();
-            if (!isLeaf(oldNode)) {
-                for (const child of oldNode.children) {
-                    const childCopy = isLeaf(child)
-                        ? { length: child.length, token: child.token, tokenQuality: child.tokenQuality, height: child.height }
-                        : ( new ListNode(child.height));
-                    clonedNode.appendChild(childCopy);
-                    stack.push([child, childCopy]);
-                }
-            }
-        }
-        return newRoot;
-    }
-    printTree(root = this._root) {
-        const result = [];
-        const stack = [[root, 0]];
-        while (stack.length > 0) {
-            const [node, depth] = stack.pop();
-            const indent = '  '.repeat(depth);
-            if (isLeaf(node)) {
-                result.push(`${indent}Leaf(length: ${node.length}, token: ${node.token}, refresh: ${node.tokenQuality})\n`);
-            }
-            else {
-                result.push(`${indent}List(length: ${node.length})\n`);
-                for (let i = node.children.length - 1; i >= 0; i--) {
-                    stack.push([node.children[i], depth + 1]);
-                }
-            }
-        }
-        return result.join('');
-    }
-    dispose() {
-        const stack = [[this._root, false]];
-        while (stack.length > 0) {
-            const [node, visited] = stack.pop();
-            if (isLeaf(node)) ;
-            else if (!visited) {
-                stack.push([node, true]);
-                for (let i = node.children.length - 1; i >= 0; i--) {
-                    stack.push([node.children[i], false]);
-                }
-            }
-            else {
-                node.dispose();
-                node.parent = undefined;
-            }
-        }
-        this._root = undefined;
-    }
-}
-
-export { TokenQuality, TokenStore };

package/vscode/src/vs/editor/common/model/treeSitterTokenStoreService.d.ts

@@ -1,32 +0,0 @@
-import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
-import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
-import { TokenQuality, TokenUpdate } from "./tokenStore.js";
-import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { IModelContentChangedEvent } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/textModelEvents";
-import { ITreeSitterTokenizationStoreService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model/treeSitterTokenStoreService.service";
-export interface TokenInformation {
-    tokens: Uint32Array;
-    needsRefresh?: boolean;
-}
-export declare class TreeSitterTokenizationStoreService implements ITreeSitterTokenizationStoreService, IDisposable {
-    readonly _serviceBrand: undefined;
-    private readonly tokens;
-    constructor();
-    setTokens(model: ITextModel, tokens: TokenUpdate[], tokenQuality: TokenQuality): void;
-    handleContentChanged(model: ITextModel, e: IModelContentChangedEvent): void;
-    rangeHasTokens(model: ITextModel, range: Range, minimumTokenQuality: TokenQuality): boolean;
-    hasTokens(model: ITextModel, accurateForRange?: Range): boolean;
-    getTokens(model: ITextModel, line: number): Uint32Array | undefined;
-    updateTokens(model: ITextModel, version: number, updates: {
-        oldRangeLength?: number;
-        newTokens: TokenUpdate[];
-    }[], tokenQuality: TokenQuality): void;
-    markForRefresh(model: ITextModel, range: Range): void;
-    getNeedsRefresh(model: ITextModel): {
-        range: Range;
-        startOffset: number;
-        endOffset: number;
-    }[];
-    delete(model: ITextModel): void;
-    dispose(): void;
-}

package/vscode/src/vs/editor/common/model/treeSitterTokenStoreService.js

@@ -1,135 +0,0 @@
-
-import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
-import { TokenStore, TokenQuality } from './tokenStore.js';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
-import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
-
-class TreeSitterTokenizationStoreService {
-    constructor() {
-        this.tokens = ( new Map());
-    }
-    setTokens(model, tokens, tokenQuality) {
-        const disposables = ( new DisposableStore());
-        const store = disposables.add(( new TokenStore(model)));
-        this.tokens.set(model, { store: store, accurateVersion: model.getVersionId(), disposables, guessVersion: model.getVersionId() });
-        store.buildStore(tokens, tokenQuality);
-        disposables.add(model.onWillDispose(() => {
-            const storeInfo = this.tokens.get(model);
-            if (storeInfo) {
-                storeInfo.disposables.dispose();
-                this.tokens.delete(model);
-            }
-        }));
-    }
-    handleContentChanged(model, e) {
-        const storeInfo = this.tokens.get(model);
-        if (!storeInfo) {
-            return;
-        }
-        storeInfo.guessVersion = e.versionId;
-        for (const change of e.changes) {
-            if (change.text.length > change.rangeLength) {
-                const offset = change.rangeOffset > 0 ? change.rangeOffset - 1 : change.rangeOffset;
-                const oldToken = storeInfo.store.getTokenAt(offset);
-                let newToken;
-                if (oldToken) {
-                    newToken = { startOffsetInclusive: oldToken.startOffsetInclusive, length: oldToken.length + change.text.length - change.rangeLength, token: oldToken.token };
-                    storeInfo.store.markForRefresh(offset, change.rangeOffset + (change.text.length > change.rangeLength ? change.text.length : change.rangeLength));
-                }
-                else {
-                    newToken = { startOffsetInclusive: offset, length: change.text.length, token: 0 };
-                }
-                storeInfo.store.update(oldToken?.length ?? 0, [newToken], TokenQuality.EditGuess);
-            }
-            else if (change.text.length < change.rangeLength) {
-                const deletedCharCount = change.rangeLength - change.text.length;
-                storeInfo.store.delete(deletedCharCount, change.rangeOffset);
-            }
-        }
-    }
-    rangeHasTokens(model, range, minimumTokenQuality) {
-        const tokens = this.tokens.get(model);
-        if (!tokens) {
-            return false;
-        }
-        return tokens.store.rangeHasTokens(model.getOffsetAt(range.getStartPosition()), model.getOffsetAt(range.getEndPosition()), minimumTokenQuality);
-    }
-    hasTokens(model, accurateForRange) {
-        const tokens = this.tokens.get(model);
-        if (!tokens) {
-            return false;
-        }
-        if (!accurateForRange || (tokens.guessVersion === tokens.accurateVersion)) {
-            return true;
-        }
-        return !tokens.store.rangeNeedsRefresh(model.getOffsetAt(accurateForRange.getStartPosition()), model.getOffsetAt(accurateForRange.getEndPosition()));
-    }
-    getTokens(model, line) {
-        const tokens = this.tokens.get(model)?.store;
-        if (!tokens) {
-            return undefined;
-        }
-        const lineStartOffset = model.getOffsetAt({ lineNumber: line, column: 1 });
-        const lineTokens = tokens.getTokensInRange(lineStartOffset, model.getOffsetAt({ lineNumber: line, column: model.getLineLength(line) }) + 1);
-        const result = ( new Uint32Array(lineTokens.length * 2));
-        for (let i = 0; i < lineTokens.length; i++) {
-            result[i * 2] = lineTokens[i].startOffsetInclusive - lineStartOffset + lineTokens[i].length;
-            result[i * 2 + 1] = lineTokens[i].token;
-        }
-        return result;
-    }
-    updateTokens(model, version, updates, tokenQuality) {
-        const existingTokens = this.tokens.get(model);
-        if (!existingTokens) {
-            return;
-        }
-        existingTokens.accurateVersion = version;
-        for (const update of updates) {
-            const lastToken = update.newTokens.length > 0 ? update.newTokens[update.newTokens.length - 1] : undefined;
-            let oldRangeLength;
-            if (lastToken && (existingTokens.guessVersion >= version)) {
-                oldRangeLength = lastToken.startOffsetInclusive + lastToken.length - update.newTokens[0].startOffsetInclusive;
-            }
-            else if (update.oldRangeLength) {
-                oldRangeLength = update.oldRangeLength;
-            }
-            else {
-                oldRangeLength = 0;
-            }
-            existingTokens.store.update(oldRangeLength, update.newTokens, tokenQuality);
-        }
-    }
-    markForRefresh(model, range) {
-        const tree = this.tokens.get(model)?.store;
-        if (!tree) {
-            return;
-        }
-        tree.markForRefresh(model.getOffsetAt(range.getStartPosition()), model.getOffsetAt(range.getEndPosition()));
-    }
-    getNeedsRefresh(model) {
-        const needsRefreshOffsetRanges = this.tokens.get(model)?.store.getNeedsRefresh();
-        if (!needsRefreshOffsetRanges) {
-            return [];
-        }
-        return ( needsRefreshOffsetRanges.map(range => ({
-            range: Range.fromPositions(model.getPositionAt(range.startOffset), model.getPositionAt(range.endOffset)),
-            startOffset: range.startOffset,
-            endOffset: range.endOffset
-        })));
-    }
-    delete(model) {
-        const storeInfo = this.tokens.get(model);
-        if (storeInfo) {
-            storeInfo.disposables.dispose();
-            this.tokens.delete(model);
-        }
-    }
-    dispose() {
-        for (const [, value] of this.tokens) {
-            value.disposables.dispose();
-        }
-    }
-}
-
-export { TreeSitterTokenizationStoreService };

package/vscode/src/vs/editor/common/services/treeSitter/cursorUtils.d.ts

@@ -1,6 +0,0 @@
-import type * as Parser from "@vscode/tree-sitter-wasm";
-export declare function gotoNextSibling(newCursor: Parser.TreeCursor, oldCursor: Parser.TreeCursor): boolean;
-export declare function gotoParent(newCursor: Parser.TreeCursor, oldCursor: Parser.TreeCursor): boolean;
-export declare function gotoNthChild(newCursor: Parser.TreeCursor, oldCursor: Parser.TreeCursor, index: number): boolean;
-export declare function nextSiblingOrParentSibling(newCursor: Parser.TreeCursor, oldCursor: Parser.TreeCursor): boolean;
-export declare function getClosestPreviousNodes(cursor: Parser.TreeCursor, tree: Parser.Tree): Parser.Node | undefined;

package/vscode/src/vs/editor/common/services/treeSitter/cursorUtils.js

@@ -1,76 +0,0 @@
-
-
-function gotoNextSibling(newCursor, oldCursor) {
-    const n = newCursor.gotoNextSibling();
-    const o = oldCursor.gotoNextSibling();
-    if (n !== o) {
-        throw ( new Error('Trees are out of sync'));
-    }
-    return n && o;
-}
-function gotoParent(newCursor, oldCursor) {
-    const n = newCursor.gotoParent();
-    const o = oldCursor.gotoParent();
-    if (n !== o) {
-        throw ( new Error('Trees are out of sync'));
-    }
-    return n && o;
-}
-function gotoNthChild(newCursor, oldCursor, index) {
-    const n = newCursor.gotoFirstChild();
-    const o = oldCursor.gotoFirstChild();
-    if (n !== o) {
-        throw ( new Error('Trees are out of sync'));
-    }
-    if (index === 0) {
-        return n && o;
-    }
-    for (let i = 1; i <= index; i++) {
-        const nn = newCursor.gotoNextSibling();
-        const oo = oldCursor.gotoNextSibling();
-        if (nn !== oo) {
-            throw ( new Error('Trees are out of sync'));
-        }
-        if (!nn || !oo) {
-            return false;
-        }
-    }
-    return n && o;
-}
-function nextSiblingOrParentSibling(newCursor, oldCursor) {
-    do {
-        if (newCursor.currentNode.nextSibling) {
-            return gotoNextSibling(newCursor, oldCursor);
-        }
-        if (newCursor.currentNode.parent) {
-            gotoParent(newCursor, oldCursor);
-        }
-    } while (newCursor.currentNode.nextSibling || newCursor.currentNode.parent);
-    return false;
-}
-function getClosestPreviousNodes(cursor, tree) {
-    const findPrev = tree.walk();
-    findPrev.resetTo(cursor);
-    const startingNode = cursor.currentNode;
-    do {
-        if (findPrev.currentNode.previousSibling && ((findPrev.currentNode.endIndex - findPrev.currentNode.startIndex) !== 0)) {
-            findPrev.gotoPreviousSibling();
-        }
-        else {
-            while (!findPrev.currentNode.previousSibling && findPrev.currentNode.parent) {
-                findPrev.gotoParent();
-            }
-            findPrev.gotoPreviousSibling();
-        }
-    } while ((findPrev.currentNode.endIndex > startingNode.startIndex)
-        && (findPrev.currentNode.parent || findPrev.currentNode.previousSibling)
-        && (findPrev.currentNode.id !== startingNode.id));
-    if ((findPrev.currentNode.id !== startingNode.id) && findPrev.currentNode.endIndex <= startingNode.startIndex) {
-        return findPrev.currentNode;
-    }
-    else {
-        return undefined;
-    }
-}
-
-export { getClosestPreviousNodes, gotoNextSibling, gotoNthChild, gotoParent, nextSiblingOrParentSibling };