@kerebron/tree-sitter 0.4.6

package/esm/deno-tree-sitter/main/tree_sitter/tree.d.ts

@@ -0,0 +1,49 @@
+/** @internal */
+export function getText(tree: any, startIndex: any, endIndex: any, startPosition: any): any;
+/** A tree that represents the syntactic structure of a source code file. */
+export class Tree {
+    /** @internal */
+    constructor(internal: any, address: any, language: any, textCallback: any);
+    /** @internal */
+    0: number;
+    /** @internal */
+    textCallback: any;
+    /** The language that was used to parse the syntax tree. */
+    language: any;
+    /** Create a shallow copy of the syntax tree. This is very fast. */
+    copy(): Tree;
+    /** Delete the syntax tree, freeing its resources. */
+    delete(): void;
+    /** Get the root node of the syntax tree. */
+    get rootNode(): any;
+    /**
+     * Get the root node of the syntax tree, but with its position shifted
+     * forward by the given offset.
+     */
+    rootNodeWithOffset(offsetBytes: any, offsetExtent: any): any;
+    /**
+     * Edit the syntax tree to keep it in sync with source code that has been
+     * edited.
+     *
+     * You must describe the edit both in terms of byte offsets and in terms of
+     * row/column coordinates.
+     */
+    edit(edit: any): void;
+    /** Create a new {@link TreeCursor} starting from the root of the tree. */
+    walk(): any;
+    /**
+     * Compare this old edited syntax tree to a new syntax tree representing
+     * the same document, returning a sequence of ranges whose syntactic
+     * structure has changed.
+     *
+     * For this to work correctly, this syntax tree must have been edited such
+     * that its ranges match up to the new tree. Generally, you'll want to
+     * call this method right after calling one of the [`Parser::parse`]
+     * functions. Call it on the old tree that was passed to parse, and
+     * pass the new tree that was returned from `parse`.
+     */
+    getChangedRanges(other: any): any[];
+    /** Get the included ranges that were used to parse the syntax tree. */
+    getIncludedRanges(): any[];
+}
+//# sourceMappingURL=tree.d.ts.map

package/esm/deno-tree-sitter/main/tree_sitter/tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.d.ts","sourceRoot":"","sources":["../../../../src/deno-tree-sitter/main/tree_sitter/tree.js"],"names":[],"mappings":"AAOA,gBAAgB;AAChB,4FAmBC;AAED,4EAA4E;AAC5E;IAUI,gBAAgB;IAChB,2EAKC;IAfD,gBAAgB;IAChB,UAAO;IAEP,gBAAgB;IAChB,kBAAY;IAEZ,2DAA2D;IAC3D,cAAQ;IAUR,mEAAmE;IACnE,aAGC;IAED,qDAAqD;IACrD,eAGC;IAED,4CAA4C;IAC5C,oBAGC;IAED;;;OAGG;IACH,6DAMC;IAED;;;;;;OAMG;IACH,sBAGC;IAED,0EAA0E;IAC1E,YAEC;IAED;;;;;;;;;;OAUG;IACH,oCAmBC;IAED,uEAAuE;IACvE,2BAeC;CACJ"}

package/esm/deno-tree-sitter/main/tree_sitter/tree.js

@@ -0,0 +1,145 @@
+import { INTERNAL, assertInternal, SIZE_OF_NODE, SIZE_OF_INT, SIZE_OF_RANGE, C } from "./constants.js";
+import { Language } from "./language.js";
+import { Node } from "./node.js";
+import { TreeCursor } from "./tree_cursor.js";
+import { marshalEdit, marshalPoint, unmarshalNode, unmarshalRange } from "./marshal.js";
+import { TRANSFER_BUFFER } from "./parser.js";
+/** @internal */
+export function getText(tree, startIndex, endIndex, startPosition) {
+    const length = endIndex - startIndex;
+    let result = tree.textCallback(startIndex, startPosition);
+    if (result) {
+        startIndex += result.length;
+        while (startIndex < endIndex) {
+            const string = tree.textCallback(startIndex, startPosition);
+            if (string && string.length > 0) {
+                startIndex += string.length;
+                result += string;
+            }
+            else {
+                break;
+            }
+        }
+        if (startIndex > endIndex) {
+            result = result.slice(0, length);
+        }
+    }
+    return result ?? "";
+}
+/** A tree that represents the syntactic structure of a source code file. */
+export class Tree {
+    /** @internal */
+    constructor(internal, address, language, textCallback) {
+        /** @internal */
+        Object.defineProperty(this, 0, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        }); // Internal handle for Wasm
+        /** @internal */
+        Object.defineProperty(this, "textCallback", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** The language that was used to parse the syntax tree. */
+        Object.defineProperty(this, "language", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        assertInternal(internal);
+        this[0] = address;
+        this.language = language;
+        this.textCallback = textCallback;
+    }
+    /** Create a shallow copy of the syntax tree. This is very fast. */
+    copy() {
+        const address = C._ts_tree_copy(this[0]);
+        return new Tree(INTERNAL, address, this.language, this.textCallback);
+    }
+    /** Delete the syntax tree, freeing its resources. */
+    delete() {
+        C._ts_tree_delete(this[0]);
+        this[0] = 0;
+    }
+    /** Get the root node of the syntax tree. */
+    get rootNode() {
+        C._ts_tree_root_node_wasm(this[0]);
+        return unmarshalNode(this);
+    }
+    /**
+     * Get the root node of the syntax tree, but with its position shifted
+     * forward by the given offset.
+     */
+    rootNodeWithOffset(offsetBytes, offsetExtent) {
+        const address = TRANSFER_BUFFER + SIZE_OF_NODE;
+        C.setValue(address, offsetBytes, "i32");
+        marshalPoint(address + SIZE_OF_INT, offsetExtent);
+        C._ts_tree_root_node_with_offset_wasm(this[0]);
+        return unmarshalNode(this);
+    }
+    /**
+     * Edit the syntax tree to keep it in sync with source code that has been
+     * edited.
+     *
+     * You must describe the edit both in terms of byte offsets and in terms of
+     * row/column coordinates.
+     */
+    edit(edit) {
+        marshalEdit(edit);
+        C._ts_tree_edit_wasm(this[0]);
+    }
+    /** Create a new {@link TreeCursor} starting from the root of the tree. */
+    walk() {
+        return this.rootNode.walk();
+    }
+    /**
+     * Compare this old edited syntax tree to a new syntax tree representing
+     * the same document, returning a sequence of ranges whose syntactic
+     * structure has changed.
+     *
+     * For this to work correctly, this syntax tree must have been edited such
+     * that its ranges match up to the new tree. Generally, you'll want to
+     * call this method right after calling one of the [`Parser::parse`]
+     * functions. Call it on the old tree that was passed to parse, and
+     * pass the new tree that was returned from `parse`.
+     */
+    getChangedRanges(other) {
+        if (!(other instanceof Tree)) {
+            throw new TypeError("Argument must be a Tree");
+        }
+        C._ts_tree_get_changed_ranges_wasm(this[0], other[0]);
+        const count = C.getValue(TRANSFER_BUFFER, "i32");
+        const buffer = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
+        const result = new Array(count);
+        if (count > 0) {
+            let address = buffer;
+            for (let i = 0; i < count; i++) {
+                result[i] = unmarshalRange(address);
+                address += SIZE_OF_RANGE;
+            }
+            C._free(buffer);
+        }
+        return result;
+    }
+    /** Get the included ranges that were used to parse the syntax tree. */
+    getIncludedRanges() {
+        C._ts_tree_included_ranges_wasm(this[0]);
+        const count = C.getValue(TRANSFER_BUFFER, "i32");
+        const buffer = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
+        const result = new Array(count);
+        if (count > 0) {
+            let address = buffer;
+            for (let i = 0; i < count; i++) {
+                result[i] = unmarshalRange(address);
+                address += SIZE_OF_RANGE;
+            }
+            C._free(buffer);
+        }
+        return result;
+    }
+}

package/esm/deno-tree-sitter/main/tree_sitter/tree_cursor.d.ts

@@ -0,0 +1,165 @@
+/** A stateful object for walking a syntax {@link Tree} efficiently. */
+export class TreeCursor {
+    /** @internal */
+    constructor(internal: any, tree: any);
+    /** @internal */
+    0: number;
+    /** @internal */
+    1: number;
+    /** @internal */
+    2: number;
+    /** @internal */
+    3: number;
+    /** @internal */
+    tree: any;
+    /** Creates a deep copy of the tree cursor. This allocates new memory. */
+    copy(): TreeCursor;
+    /** Delete the tree cursor, freeing its resources. */
+    delete(): void;
+    /** Get the tree cursor's current {@link Node}. */
+    get currentNode(): any;
+    /**
+     * Get the numerical field id of this tree cursor's current node.
+     *
+     * See also {@link TreeCursor#currentFieldName}.
+     */
+    get currentFieldId(): any;
+    /** Get the field name of this tree cursor's current node. */
+    get currentFieldName(): any;
+    /**
+     * Get the depth of the cursor's current node relative to the original
+     * node that the cursor was constructed with.
+     */
+    get currentDepth(): any;
+    /**
+     * Get the index of the cursor's current node out of all of the
+     * descendants of the original node that the cursor was constructed with.
+     */
+    get currentDescendantIndex(): any;
+    /** Get the type of the cursor's current node. */
+    get nodeType(): any;
+    /** Get the type id of the cursor's current node. */
+    get nodeTypeId(): any;
+    /** Get the state id of the cursor's current node. */
+    get nodeStateId(): any;
+    /** Get the id of the cursor's current node. */
+    get nodeId(): any;
+    /**
+     * Check if the cursor's current node is *named*.
+     *
+     * Named nodes correspond to named rules in the grammar, whereas
+     * *anonymous* nodes correspond to string literals in the grammar.
+     */
+    get nodeIsNamed(): boolean;
+    /**
+     * Check if the cursor's current node is *missing*.
+     *
+     * Missing nodes are inserted by the parser in order to recover from
+     * certain kinds of syntax errors.
+     */
+    get nodeIsMissing(): boolean;
+    /** Get the string content of the cursor's current node. */
+    get nodeText(): any;
+    /** Get the start position of the cursor's current node. */
+    get startPosition(): {
+        row: number;
+        column: number;
+    };
+    /** Get the end position of the cursor's current node. */
+    get endPosition(): {
+        row: number;
+        column: number;
+    };
+    /** Get the start index of the cursor's current node. */
+    get startIndex(): any;
+    /** Get the end index of the cursor's current node. */
+    get endIndex(): any;
+    /**
+     * Move this cursor to the first child of its current node.
+     *
+     * This returns `true` if the cursor successfully moved, and returns
+     * `false` if there were no children.
+     */
+    gotoFirstChild(): boolean;
+    /**
+     * Move this cursor to the last child of its current node.
+     *
+     * This returns `true` if the cursor successfully moved, and returns
+     * `false` if there were no children.
+     *
+     * Note that this function may be slower than
+     * {@link TreeCursor#gotoFirstChild} because it needs to
+     * iterate through all the children to compute the child's position.
+     */
+    gotoLastChild(): boolean;
+    /**
+     * Move this cursor to the parent of its current node.
+     *
+     * This returns `true` if the cursor successfully moved, and returns
+     * `false` if there was no parent node (the cursor was already on the
+     * root node).
+     *
+     * Note that the node the cursor was constructed with is considered the root
+     * of the cursor, and the cursor cannot walk outside this node.
+     */
+    gotoParent(): boolean;
+    /**
+     * Move this cursor to the next sibling of its current node.
+     *
+     * This returns `true` if the cursor successfully moved, and returns
+     * `false` if there was no next sibling node.
+     *
+     * Note that the node the cursor was constructed with is considered the root
+     * of the cursor, and the cursor cannot walk outside this node.
+     */
+    gotoNextSibling(): boolean;
+    /**
+     * Move this cursor to the previous sibling of its current node.
+     *
+     * This returns `true` if the cursor successfully moved, and returns
+     * `false` if there was no previous sibling node.
+     *
+     * Note that this function may be slower than
+     * {@link TreeCursor#gotoNextSibling} due to how node
+     * positions are stored. In the worst case, this will need to iterate
+     * through all the children up to the previous sibling node to recalculate
+     * its position. Also note that the node the cursor was constructed with is
+     * considered the root of the cursor, and the cursor cannot walk outside this node.
+     */
+    gotoPreviousSibling(): boolean;
+    /**
+     * Move the cursor to the node that is the nth descendant of
+     * the original node that the cursor was constructed with, where
+     * zero represents the original node itself.
+     */
+    gotoDescendant(goalDescendantIndex: any): void;
+    /**
+     * Move this cursor to the first child of its current node that contains or
+     * starts after the given byte offset.
+     *
+     * This returns `true` if the cursor successfully moved to a child node, and returns
+     * `false` if no such child was found.
+     */
+    gotoFirstChildForIndex(goalIndex: any): boolean;
+    /**
+     * Move this cursor to the first child of its current node that contains or
+     * starts after the given byte offset.
+     *
+     * This returns the index of the child node if one was found, and returns
+     * `null` if no such child was found.
+     */
+    gotoFirstChildForPosition(goalPosition: any): boolean;
+    /**
+     * Re-initialize this tree cursor to start at the original node that the
+     * cursor was constructed with.
+     */
+    reset(node: any): void;
+    /**
+     * Re-initialize a tree cursor to the same position as another cursor.
+     *
+     * Unlike {@link TreeCursor#reset}, this will not lose parent
+     * information and allows reusing already created cursors.
+     */
+    resetTo(cursor: any): void;
+}
+//# sourceMappingURL=tree_cursor.d.ts.map

package/esm/deno-tree-sitter/main/tree_sitter/tree_cursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree_cursor.d.ts","sourceRoot":"","sources":["../../../../src/deno-tree-sitter/main/tree_sitter/tree_cursor.js"],"names":[],"mappings":"AAMA,uEAAuE;AACvE;IAgBI,gBAAgB;IAChB,sCAIC;IApBD,gBAAgB;IAChB,UAAQ;IAER,gBAAgB;IAChB,UAAQ;IAER,gBAAgB;IAChB,UAAQ;IAER,gBAAgB;IAChB,UAAO;IAEP,gBAAgB;IAChB,UAAI;IASJ,yEAAyE;IACzE,mBAKC;IAED,qDAAqD;IACrD,eAIC;IAED,kDAAkD;IAClD,uBAIC;IAED;;;;OAIG;IACH,0BAGC;IAED,6DAA6D;IAC7D,4BAEC;IAED;;;OAGG;IACH,wBAGC;IAED;;;OAGG;IACH,kCAGC;IAED,iDAAiD;IACjD,oBAEC;IAED,oDAAoD;IACpD,sBAGC;IAED,qDAAqD;IACrD,uBAGC;IAED,+CAA+C;IAC/C,kBAGC;IAED;;;;;OAKG;IACH,2BAGC;IAED;;;;;OAKG;IACH,6BAGC;IAED,2DAA2D;IAC3D,oBAOC;IAED,2DAA2D;IAC3D;;;MAIC;IAED,yDAAyD;IACzD;;;MAIC;IAED,wDAAwD;IACxD,sBAGC;IAED,sDAAsD;IACtD,oBAGC;IAED;;;;;OAKG;IACH,0BAKC;IAED;;;;;;;;;OASG;IACH,yBAKC;IAED;;;;;;;;;OASG;IACH,sBAKC;IAED;;;;;;;;OAQG;IACH,2BAKC;IAED;;;;;;;;;;;;OAYG;IACH,+BAKC;IAED;;;;OAIG;IACH,+CAIC;IAED;;;;;;OAMG;IACH,gDAMC;IAED;;;;;;OAMG;IACH,sDAMC;IAED;;;OAGG;IACH,uBAKC;IAED;;;;;OAKG;IACH,2BAKC;CACJ"}

package/esm/deno-tree-sitter/main/tree_sitter/tree_cursor.js

@@ -0,0 +1,305 @@
+import { INTERNAL, assertInternal, SIZE_OF_NODE, SIZE_OF_CURSOR, C } from "./constants.js";
+import { marshalNode, marshalPoint, marshalTreeCursor, unmarshalNode, unmarshalPoint, unmarshalTreeCursor } from "./marshal.js";
+import { Node } from "./node.js";
+import { TRANSFER_BUFFER } from "./parser.js";
+import { getText, Tree } from "./tree.js";
+/** A stateful object for walking a syntax {@link Tree} efficiently. */
+export class TreeCursor {
+    /** @internal */
+    constructor(internal, tree) {
+        /** @internal */
+        Object.defineProperty(this, 0, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        }); // Internal handle for Wasm
+        /** @internal */
+        Object.defineProperty(this, 1, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        }); // Internal handle for Wasm
+        /** @internal */
+        Object.defineProperty(this, 2, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        }); // Internal handle for Wasm
+        /** @internal */
+        Object.defineProperty(this, 3, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        }); // Internal handle for Wasm
+        /** @internal */
+        Object.defineProperty(this, "tree", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        assertInternal(internal);
+        this.tree = tree;
+        unmarshalTreeCursor(this);
+    }
+    /** Creates a deep copy of the tree cursor. This allocates new memory. */
+    copy() {
+        const copy = new TreeCursor(INTERNAL, this.tree);
+        C._ts_tree_cursor_copy_wasm(this.tree[0]);
+        unmarshalTreeCursor(copy);
+        return copy;
+    }
+    /** Delete the tree cursor, freeing its resources. */
+    delete() {
+        marshalTreeCursor(this);
+        C._ts_tree_cursor_delete_wasm(this.tree[0]);
+        this[0] = this[1] = this[2] = 0;
+    }
+    /** Get the tree cursor's current {@link Node}. */
+    get currentNode() {
+        marshalTreeCursor(this);
+        C._ts_tree_cursor_current_node_wasm(this.tree[0]);
+        return unmarshalNode(this.tree);
+    }
+    /**
+     * Get the numerical field id of this tree cursor's current node.
+     *
+     * See also {@link TreeCursor#currentFieldName}.
+     */
+    get currentFieldId() {
+        marshalTreeCursor(this);
+        return C._ts_tree_cursor_current_field_id_wasm(this.tree[0]);
+    }
+    /** Get the field name of this tree cursor's current node. */
+    get currentFieldName() {
+        return this.tree.language.fields[this.currentFieldId];
+    }
+    /**
+     * Get the depth of the cursor's current node relative to the original
+     * node that the cursor was constructed with.
+     */
+    get currentDepth() {
+        marshalTreeCursor(this);
+        return C._ts_tree_cursor_current_depth_wasm(this.tree[0]);
+    }
+    /**
+     * Get the index of the cursor's current node out of all of the
+     * descendants of the original node that the cursor was constructed with.
+     */
+    get currentDescendantIndex() {
+        marshalTreeCursor(this);
+        return C._ts_tree_cursor_current_descendant_index_wasm(this.tree[0]);
+    }
+    /** Get the type of the cursor's current node. */
+    get nodeType() {
+        return this.tree.language.types[this.nodeTypeId] || "ERROR";
+    }
+    /** Get the type id of the cursor's current node. */
+    get nodeTypeId() {
+        marshalTreeCursor(this);
+        return C._ts_tree_cursor_current_node_type_id_wasm(this.tree[0]);
+    }
+    /** Get the state id of the cursor's current node. */
+    get nodeStateId() {
+        marshalTreeCursor(this);
+        return C._ts_tree_cursor_current_node_state_id_wasm(this.tree[0]);
+    }
+    /** Get the id of the cursor's current node. */
+    get nodeId() {
+        marshalTreeCursor(this);
+        return C._ts_tree_cursor_current_node_id_wasm(this.tree[0]);
+    }
+    /**
+     * Check if the cursor's current node is *named*.
+     *
+     * Named nodes correspond to named rules in the grammar, whereas
+     * *anonymous* nodes correspond to string literals in the grammar.
+     */
+    get nodeIsNamed() {
+        marshalTreeCursor(this);
+        return C._ts_tree_cursor_current_node_is_named_wasm(this.tree[0]) === 1;
+    }
+    /**
+     * Check if the cursor's current node is *missing*.
+     *
+     * Missing nodes are inserted by the parser in order to recover from
+     * certain kinds of syntax errors.
+     */
+    get nodeIsMissing() {
+        marshalTreeCursor(this);
+        return C._ts_tree_cursor_current_node_is_missing_wasm(this.tree[0]) === 1;
+    }
+    /** Get the string content of the cursor's current node. */
+    get nodeText() {
+        marshalTreeCursor(this);
+        const startIndex = C._ts_tree_cursor_start_index_wasm(this.tree[0]);
+        const endIndex = C._ts_tree_cursor_end_index_wasm(this.tree[0]);
+        C._ts_tree_cursor_start_position_wasm(this.tree[0]);
+        const startPosition = unmarshalPoint(TRANSFER_BUFFER);
+        return getText(this.tree, startIndex, endIndex, startPosition);
+    }
+    /** Get the start position of the cursor's current node. */
+    get startPosition() {
+        marshalTreeCursor(this);
+        C._ts_tree_cursor_start_position_wasm(this.tree[0]);
+        return unmarshalPoint(TRANSFER_BUFFER);
+    }
+    /** Get the end position of the cursor's current node. */
+    get endPosition() {
+        marshalTreeCursor(this);
+        C._ts_tree_cursor_end_position_wasm(this.tree[0]);
+        return unmarshalPoint(TRANSFER_BUFFER);
+    }
+    /** Get the start index of the cursor's current node. */
+    get startIndex() {
+        marshalTreeCursor(this);
+        return C._ts_tree_cursor_start_index_wasm(this.tree[0]);
+    }
+    /** Get the end index of the cursor's current node. */
+    get endIndex() {
+        marshalTreeCursor(this);
+        return C._ts_tree_cursor_end_index_wasm(this.tree[0]);
+    }
+    /**
+     * Move this cursor to the first child of its current node.
+     *
+     * This returns `true` if the cursor successfully moved, and returns
+     * `false` if there were no children.
+     */
+    gotoFirstChild() {
+        marshalTreeCursor(this);
+        const result = C._ts_tree_cursor_goto_first_child_wasm(this.tree[0]);
+        unmarshalTreeCursor(this);
+        return result === 1;
+    }
+    /**
+     * Move this cursor to the last child of its current node.
+     *
+     * This returns `true` if the cursor successfully moved, and returns
+     * `false` if there were no children.
+     *
+     * Note that this function may be slower than
+     * {@link TreeCursor#gotoFirstChild} because it needs to
+     * iterate through all the children to compute the child's position.
+     */
+    gotoLastChild() {
+        marshalTreeCursor(this);
+        const result = C._ts_tree_cursor_goto_last_child_wasm(this.tree[0]);
+        unmarshalTreeCursor(this);
+        return result === 1;
+    }
+    /**
+     * Move this cursor to the parent of its current node.
+     *
+     * This returns `true` if the cursor successfully moved, and returns
+     * `false` if there was no parent node (the cursor was already on the
+     * root node).
+     *
+     * Note that the node the cursor was constructed with is considered the root
+     * of the cursor, and the cursor cannot walk outside this node.
+     */
+    gotoParent() {
+        marshalTreeCursor(this);
+        const result = C._ts_tree_cursor_goto_parent_wasm(this.tree[0]);
+        unmarshalTreeCursor(this);
+        return result === 1;
+    }
+    /**
+     * Move this cursor to the next sibling of its current node.
+     *
+     * This returns `true` if the cursor successfully moved, and returns
+     * `false` if there was no next sibling node.
+     *
+     * Note that the node the cursor was constructed with is considered the root
+     * of the cursor, and the cursor cannot walk outside this node.
+     */
+    gotoNextSibling() {
+        marshalTreeCursor(this);
+        const result = C._ts_tree_cursor_goto_next_sibling_wasm(this.tree[0]);
+        unmarshalTreeCursor(this);
+        return result === 1;
+    }
+    /**
+     * Move this cursor to the previous sibling of its current node.
+     *
+     * This returns `true` if the cursor successfully moved, and returns
+     * `false` if there was no previous sibling node.
+     *
+     * Note that this function may be slower than
+     * {@link TreeCursor#gotoNextSibling} due to how node
+     * positions are stored. In the worst case, this will need to iterate
+     * through all the children up to the previous sibling node to recalculate
+     * its position. Also note that the node the cursor was constructed with is
+     * considered the root of the cursor, and the cursor cannot walk outside this node.
+     */
+    gotoPreviousSibling() {
+        marshalTreeCursor(this);
+        const result = C._ts_tree_cursor_goto_previous_sibling_wasm(this.tree[0]);
+        unmarshalTreeCursor(this);
+        return result === 1;
+    }
+    /**
+     * Move the cursor to the node that is the nth descendant of
+     * the original node that the cursor was constructed with, where
+     * zero represents the original node itself.
+     */
+    gotoDescendant(goalDescendantIndex) {
+        marshalTreeCursor(this);
+        C._ts_tree_cursor_goto_descendant_wasm(this.tree[0], goalDescendantIndex);
+        unmarshalTreeCursor(this);
+    }
+    /**
+     * Move this cursor to the first child of its current node that contains or
+     * starts after the given byte offset.
+     *
+     * This returns `true` if the cursor successfully moved to a child node, and returns
+     * `false` if no such child was found.
+     */
+    gotoFirstChildForIndex(goalIndex) {
+        marshalTreeCursor(this);
+        C.setValue(TRANSFER_BUFFER + SIZE_OF_CURSOR, goalIndex, "i32");
+        const result = C._ts_tree_cursor_goto_first_child_for_index_wasm(this.tree[0]);
+        unmarshalTreeCursor(this);
+        return result === 1;
+    }
+    /**
+     * Move this cursor to the first child of its current node that contains or
+     * starts after the given byte offset.
+     *
+     * This returns the index of the child node if one was found, and returns
+     * `null` if no such child was found.
+     */
+    gotoFirstChildForPosition(goalPosition) {
+        marshalTreeCursor(this);
+        marshalPoint(TRANSFER_BUFFER + SIZE_OF_CURSOR, goalPosition);
+        const result = C._ts_tree_cursor_goto_first_child_for_position_wasm(this.tree[0]);
+        unmarshalTreeCursor(this);
+        return result === 1;
+    }
+    /**
+     * Re-initialize this tree cursor to start at the original node that the
+     * cursor was constructed with.
+     */
+    reset(node) {
+        marshalNode(node);
+        marshalTreeCursor(this, TRANSFER_BUFFER + SIZE_OF_NODE);
+        C._ts_tree_cursor_reset_wasm(this.tree[0]);
+        unmarshalTreeCursor(this);
+    }
+    /**
+     * Re-initialize a tree cursor to the same position as another cursor.
+     *
+     * Unlike {@link TreeCursor#reset}, this will not lose parent
+     * information and allows reusing already created cursors.
+     */
+    resetTo(cursor) {
+        marshalTreeCursor(this, TRANSFER_BUFFER);
+        marshalTreeCursor(cursor, TRANSFER_BUFFER + SIZE_OF_CURSOR);
+        C._ts_tree_cursor_reset_to_wasm(this.tree[0], cursor.tree[0]);
+        unmarshalTreeCursor(this);
+    }
+}

package/esm/deno-tree-sitter/main/tree_sitter_wasm.d.ts

@@ -0,0 +1,3 @@
+export default output;
+declare let output: Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=tree_sitter_wasm.d.ts.map

package/esm/deno-tree-sitter/main/tree_sitter_wasm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree_sitter_wasm.d.ts","sourceRoot":"","sources":["../../../src/deno-tree-sitter/main/tree_sitter_wasm.js"],"names":[],"mappings":";AAiEA,4CAm6CoI"}