@kerebron/tree-sitter 0.4.25 → 0.4.27

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

@@ -1,130 +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/esm/deno-tree-sitter/main/tree_sitter/tree_cursor.d.ts

@@ -1,165 +0,0 @@
-/** 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

@@ -1 +0,0 @@
-{"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

@@ -1,280 +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);
-    }
-}

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

@@ -1,3 +0,0 @@
-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

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

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

@@ -1,29 +0,0 @@
-export default function _default(Module: any, ...args: any[]): Promise<any>;
-export namespace defaults {
-    let arguments: never[];
-    let dynamicLibraries: never[];
-    let thisProgram: string;
-    let INITIAL_MEMORY: number;
-    let wasmBinary: null;
-    let wasmBinaryFilePath: null;
-    let noExitRuntime: boolean;
-    let noInitialRun: boolean;
-    let monitorRunDependencies: null;
-    let onRuntimeInitialized: null;
-    let preRun: null;
-    let preInit: null;
-    let onAbort: null;
-    let onExit: null;
-    let postRun: null;
-    let setStatus: null;
-    let defaultWasmPath: string;
-    function quit(status: any, toThrow: any): never;
-    function locateFile(relativePath: any): any;
-    function readAsync(path: any): Promise<void>;
-    function readBinary(path: any): void;
-    let print: null;
-    let printErr: null;
-    let instantiateWasm: null;
-    let fetch: typeof globalThis.fetch;
-}
-//# sourceMappingURL=wasm_loader.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"wasm_loader.d.ts","sourceRoot":"","sources":["../../../src/deno-tree-sitter/main/wasm_loader.js"],"names":[],"mappings":"AA6CA,4EAwnDC;;;;;;;;;;;;;;;;;;;IA7oDa,gDAEL;IACW,4CAEX;IACU,6CAAgB;IACf,qCAAU"}