@codingame/monaco-vscode-api 17.2.1 → 18.0.1

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

@@ -0,0 +1,412 @@
+
+
+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/tokens/treeSitter/treeSitterSyntaxTokenBackend.d.ts

@@ -0,0 +1,40 @@
+import type * as TreeSitter from "@vscode/tree-sitter-wasm";
+import { Emitter, Event } from "../../../../../base/common/event.js";
+import { StandardTokenType } from "../../../encodedTokenAttributes.js";
+import { ILanguageIdCodec } from "../../../languages.js";
+import { IModelContentChangedEvent } from "../../../textModelEvents.js";
+import { BackgroundTokenizationState } from "../../../tokenizationTextModelPart.js";
+import { LineTokens } from "../../../tokens/lineTokens.js";
+import { TextModel } from "../../textModel.js";
+import { AbstractSyntaxTokenBackend } from "../abstractSyntaxTokenBackend.js";
+import { IObservable } from "../../../../../base/common/observable.js";
+import { TreeSitterTree } from "./treeSitterTree.js";
+import { IInstantiationService } from "../../../../../platform/instantiation/common/instantiation.js";
+import { TreeSitterTokenizationImpl } from "./treeSitterTokenizationImpl.js";
+import { ITreeSitterLibraryService } from "../../../services/treeSitter/treeSitterLibraryService.service.js";
+import { LineRange } from "../../../core/ranges/lineRange.js";
+export declare class TreeSitterSyntaxTokenBackend extends AbstractSyntaxTokenBackend {
+    private readonly _languageIdObs;
+    private readonly _treeSitterLibraryService;
+    private readonly _instantiationService;
+    protected _backgroundTokenizationState: BackgroundTokenizationState;
+    protected readonly _onDidChangeBackgroundTokenizationState: Emitter<void>;
+    readonly onDidChangeBackgroundTokenizationState: Event<void>;
+    private readonly _tree;
+    private readonly _tokenizationImpl;
+    constructor(_languageIdObs: IObservable<string>, languageIdCodec: ILanguageIdCodec, textModel: TextModel, visibleLineRanges: IObservable<readonly LineRange[]>, _treeSitterLibraryService: ITreeSitterLibraryService, _instantiationService: IInstantiationService);
+    get tree(): IObservable<TreeSitterTree | undefined>;
+    get tokenizationImpl(): IObservable<TreeSitterTokenizationImpl | undefined>;
+    getLineTokens(lineNumber: number): LineTokens;
+    todo_resetTokenization(fireTokenChangeEvent?: boolean): void;
+    handleDidChangeAttached(): void;
+    handleDidChangeContent(e: IModelContentChangedEvent): void;
+    forceTokenization(lineNumber: number): void;
+    hasAccurateTokensForLine(lineNumber: number): boolean;
+    isCheapToTokenize(lineNumber: number): boolean;
+    getTokenTypeIfInsertingCharacter(lineNumber: number, column: number, character: string): StandardTokenType;
+    tokenizeLinesAt(lineNumber: number, lines: string[]): LineTokens[] | null;
+    get hasTokens(): boolean;
+}
+export declare function rangesEqual(a: TreeSitter.Range, b: TreeSitter.Range): boolean;
+export declare function rangesIntersect(a: TreeSitter.Range, b: TreeSitter.Range): boolean;

package/vscode/src/vs/editor/common/model/tokens/treeSitter/treeSitterSyntaxTokenBackend.js

@@ -0,0 +1,172 @@
+
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from '../../../../../base/common/event.js';
+import { toDisposable } from '../../../../../base/common/lifecycle.js';
+import { StandardTokenType } from '../../../encodedTokenAttributes.js';
+import { BackgroundTokenizationState } from '../../../tokenizationTextModelPart.js';
+import { LineTokens } from '../../../tokens/lineTokens.js';
+import { AbstractSyntaxTokenBackend } from '../abstractSyntaxTokenBackend.js';
+import '../../../../../base/common/observableInternal/index.js';
+import { TreeSitterTree } from './treeSitterTree.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { TreeSitterTokenizationImpl } from './treeSitterTokenizationImpl.js';
+import { ITreeSitterLibraryService } from '../../../services/treeSitter/treeSitterLibraryService.service.js';
+import { ObservablePromise } from '../../../../../base/common/observableInternal/utils/promise.js';
+import { derived } from '../../../../../base/common/observableInternal/observables/derived.js';
+import { autorun } from '../../../../../base/common/observableInternal/reactions/autorun.js';
+
+let TreeSitterSyntaxTokenBackend = class TreeSitterSyntaxTokenBackend extends AbstractSyntaxTokenBackend {
+    constructor(_languageIdObs, languageIdCodec, textModel, visibleLineRanges, _treeSitterLibraryService, _instantiationService) {
+        super(languageIdCodec, textModel);
+        this._languageIdObs = _languageIdObs;
+        this._treeSitterLibraryService = _treeSitterLibraryService;
+        this._instantiationService = _instantiationService;
+        this._backgroundTokenizationState = BackgroundTokenizationState.InProgress;
+        this._onDidChangeBackgroundTokenizationState = this._register(( new Emitter()));
+        this.onDidChangeBackgroundTokenizationState = this._onDidChangeBackgroundTokenizationState.event;
+        const parserClassPromise = ( new ObservablePromise(this._treeSitterLibraryService.getParserClass()));
+        const parserClassObs = derived(this, reader => {
+            const parser = parserClassPromise.promiseResult?.read(reader)?.getDataOrThrow();
+            return parser;
+        });
+        this._tree = derived(this, reader => {
+            const parserClass = parserClassObs.read(reader);
+            if (!parserClass) {
+                return undefined;
+            }
+            const currentLanguage = this._languageIdObs.read(reader);
+            const treeSitterLang = this._treeSitterLibraryService.getLanguage(currentLanguage, reader);
+            if (!treeSitterLang) {
+                return undefined;
+            }
+            const parser = ( new parserClass());
+            reader.store.add(toDisposable(() => {
+                parser.delete();
+            }));
+            parser.setLanguage(treeSitterLang);
+            const queries = this._treeSitterLibraryService.getInjectionQueries(currentLanguage, reader);
+            if (queries === undefined) {
+                return undefined;
+            }
+            return reader.store.add(this._instantiationService.createInstance(TreeSitterTree, currentLanguage, undefined, parser, parserClass,  this._textModel));
+        });
+        this._tokenizationImpl = derived(this, reader => {
+            const treeModel = this._tree.read(reader);
+            if (!treeModel) {
+                return undefined;
+            }
+            const queries = this._treeSitterLibraryService.getHighlightingQueries(treeModel.languageId, reader);
+            if (!queries) {
+                return undefined;
+            }
+            return reader.store.add(this._instantiationService.createInstance(TreeSitterTokenizationImpl, treeModel, queries, this._languageIdCodec, visibleLineRanges));
+        });
+        this._register(autorun(reader => {
+            const tokModel = this._tokenizationImpl.read(reader);
+            if (!tokModel) {
+                return;
+            }
+            reader.store.add(tokModel.onDidChangeTokens((e) => {
+                this._onDidChangeTokens.fire(e.changes);
+            }));
+            reader.store.add(tokModel.onDidChangeBackgroundTokenization(e => {
+                this._backgroundTokenizationState = BackgroundTokenizationState.Completed;
+                this._onDidChangeBackgroundTokenizationState.fire();
+            }));
+        }));
+    }
+    get tree() {
+        return this._tree;
+    }
+    get tokenizationImpl() {
+        return this._tokenizationImpl;
+    }
+    getLineTokens(lineNumber) {
+        const model = this._tokenizationImpl.get();
+        if (!model) {
+            const content = this._textModel.getLineContent(lineNumber);
+            return LineTokens.createEmpty(content, this._languageIdCodec);
+        }
+        return model.getLineTokens(lineNumber);
+    }
+    todo_resetTokenization(fireTokenChangeEvent = true) {
+        if (fireTokenChangeEvent) {
+            this._onDidChangeTokens.fire({
+                semanticTokensApplied: false,
+                ranges: [
+                    {
+                        fromLineNumber: 1,
+                        toLineNumber: this._textModel.getLineCount(),
+                    },
+                ],
+            });
+        }
+    }
+    handleDidChangeAttached() {
+    }
+    handleDidChangeContent(e) {
+        if (e.isFlush) {
+            this.todo_resetTokenization(false);
+        }
+        else {
+            const model = this._tokenizationImpl.get();
+            model?.handleContentChanged(e);
+        }
+        const treeModel = this._tree.get();
+        treeModel?.handleContentChange(e);
+    }
+    forceTokenization(lineNumber) {
+        const model = this._tokenizationImpl.get();
+        if (!model) {
+            return;
+        }
+        if (!model.hasAccurateTokensForLine(lineNumber)) {
+            model.tokenizeEncoded(lineNumber);
+        }
+    }
+    hasAccurateTokensForLine(lineNumber) {
+        const model = this._tokenizationImpl.get();
+        if (!model) {
+            return false;
+        }
+        return model.hasAccurateTokensForLine(lineNumber);
+    }
+    isCheapToTokenize(lineNumber) {
+        return true;
+    }
+    getTokenTypeIfInsertingCharacter(lineNumber, column, character) {
+        return StandardTokenType.Other;
+    }
+    tokenizeLinesAt(lineNumber, lines) {
+        const model = this._tokenizationImpl.get();
+        if (!model) {
+            return null;
+        }
+        return model.tokenizeLinesAt(lineNumber, lines);
+    }
+    get hasTokens() {
+        const model = this._tokenizationImpl.get();
+        if (!model) {
+            return false;
+        }
+        return model.hasTokens();
+    }
+};
+TreeSitterSyntaxTokenBackend = ( __decorate([
+    ( __param(4, ITreeSitterLibraryService)),
+    ( __param(5, IInstantiationService))
+], TreeSitterSyntaxTokenBackend));
+function rangesEqual(a, b) {
+    return (a.startPosition.row === b.startPosition.row)
+        && (a.startPosition.column === b.startPosition.column)
+        && (a.endPosition.row === b.endPosition.row)
+        && (a.endPosition.column === b.endPosition.column)
+        && (a.startIndex === b.startIndex)
+        && (a.endIndex === b.endIndex);
+}
+function rangesIntersect(a, b) {
+    return (a.startIndex <= b.startIndex && a.endIndex >= b.startIndex) ||
+        (b.startIndex <= a.startIndex && b.endIndex >= a.startIndex);
+}
+
+export { TreeSitterSyntaxTokenBackend, rangesEqual, rangesIntersect };