@kerebron/tree-sitter 0.5.4 → 0.6.0

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

@@ -1,145 +0,0 @@
-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 */
-    [0] = 0 // Internal handle for Wasm
-
-    /** @internal */
-    textCallback
-
-    /** The language that was used to parse the syntax tree. */
-    language
-
-    /** @internal */
-    constructor(internal, address, language, textCallback) {
-        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/src/deno-tree-sitter/main/tree_sitter/tree_cursor.js

@@ -1,314 +0,0 @@
-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 */
-    [0] = 0; // Internal handle for Wasm
-
-    /** @internal */
-    [1] = 0; // Internal handle for Wasm
-
-    /** @internal */
-    [2] = 0; // Internal handle for Wasm
-
-    /** @internal */
-    [3] = 0 // Internal handle for Wasm
-
-    /** @internal */
-    tree
-
-    /** @internal */
-    constructor(internal, tree) {
-        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)
-    }
-}