@kerebron/tree-sitter 0.4.6

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

@@ -0,0 +1,260 @@
+/** A single node within a syntax {@link Tree}. */
+export class Node {
+    /** @internal */
+    constructor(internal: any, { id, tree, startIndex, startPosition, other }: {
+        id: any;
+        tree: any;
+        startIndex: any;
+        startPosition: any;
+        other: any;
+    });
+    /** @internal */
+    0: number;
+    /** @internal */
+    _children: any;
+    /** @internal */
+    _namedChildren: any;
+    /**
+     * The numeric id for this node that is unique.
+     *
+     * Within a given syntax tree, no two nodes have the same id. However:
+     *
+     * * If a new tree is created based on an older tree, and a node from the old tree is reused in
+     *   the process, then that node will have the same id in both trees.
+     *
+     * * A node not marked as having changes does not guarantee it was reused.
+     *
+     * * If a node is marked as having changed in the old tree, it will not be reused.
+     */
+    id: any;
+    /** The tree that this node belongs to. */
+    tree: any;
+    /** The byte index where this node starts. */
+    startIndex: any;
+    /** The position where this node starts. */
+    startPosition: any;
+    /** Get this node's type as a numerical id. */
+    get typeId(): any;
+    /**
+     * Get the node's type as a numerical id as it appears in the grammar,
+     * ignoring aliases.
+     */
+    get grammarId(): any;
+    /** Get this node's type as a string. */
+    get type(): any;
+    /**
+     * Get this node's symbol name as it appears in the grammar, ignoring
+     * aliases as a string.
+     */
+    get grammarType(): any;
+    /**
+     * Check if this node is *named*.
+     *
+     * Named nodes correspond to named rules in the grammar, whereas
+     * *anonymous* nodes correspond to string literals in the grammar.
+     */
+    get isNamed(): boolean;
+    /**
+     * Check if this node is *extra*.
+     *
+     * Extra nodes represent things like comments, which are not required
+     * by the grammar, but can appear anywhere.
+     */
+    get isExtra(): boolean;
+    /**
+     * Check if this node represents a syntax error.
+     *
+     * Syntax errors represent parts of the code that could not be incorporated
+     * into a valid syntax tree.
+     */
+    get isError(): boolean;
+    /**
+     * Check if this node is *missing*.
+     *
+     * Missing nodes are inserted by the parser in order to recover from
+     * certain kinds of syntax errors.
+     */
+    get isMissing(): boolean;
+    /** Check if this node has been edited. */
+    get hasChanges(): boolean;
+    /**
+     * Check if this node represents a syntax error or contains any syntax
+     * errors anywhere within it.
+     */
+    get hasError(): boolean;
+    /** Get the byte index where this node ends. */
+    get endIndex(): any;
+    /** Get the position where this node ends. */
+    get endPosition(): {
+        row: number;
+        column: number;
+    };
+    /** Get the string content of this node. */
+    get text(): any;
+    /** Get this node's parse state. */
+    get parseState(): any;
+    /** Get the parse state after this node. */
+    get nextParseState(): any;
+    /** Check if this node is equal to another node. */
+    equals(other: any): boolean;
+    /**
+     * Get the node's child at the given index, where zero represents the first child.
+     *
+     * This method is fairly fast, but its cost is technically log(n), so if
+     * you might be iterating over a long list of children, you should use
+     * {@link Node#children} instead.
+     */
+    child(index: any): any;
+    /**
+     * Get this node's *named* child at the given index.
+     *
+     * See also {@link Node#isNamed}.
+     * This method is fairly fast, but its cost is technically log(n), so if
+     * you might be iterating over a long list of children, you should use
+     * {@link Node#namedChildren} instead.
+     */
+    namedChild(index: any): any;
+    /**
+     * Get this node's child with the given numerical field id.
+     *
+     * See also {@link Node#childForFieldName}. You can
+     * convert a field name to an id using {@link Language#fieldIdForName}.
+     */
+    childForFieldId(fieldId: any): any;
+    /**
+     * Get the first child with the given field name.
+     *
+     * If multiple children may have the same field name, access them using
+     * {@link Node#childrenForFieldName}.
+     */
+    childForFieldName(fieldName: any): any;
+    /** Get the field name of this node's child at the given index. */
+    fieldNameForChild(index: any): any;
+    /** Get the field name of this node's named child at the given index. */
+    fieldNameForNamedChild(index: any): any;
+    /**
+     * Get an array of this node's children with a given field name.
+     *
+     * See also {@link Node#children}.
+     */
+    childrenForFieldName(fieldName: any): any[];
+    /**
+     * Get an array of this node's children with a given field id.
+     *
+     * See also {@link Node#childrenForFieldName}.
+     */
+    childrenForFieldId(fieldId: any): any[];
+    /** Get the node's first child that contains or starts after the given byte offset. */
+    firstChildForIndex(index: any): any;
+    /** Get the node's first named child that contains or starts after the given byte offset. */
+    firstNamedChildForIndex(index: any): any;
+    /** Get this node's number of children. */
+    get childCount(): any;
+    /**
+     * Get this node's number of *named* children.
+     *
+     * See also {@link Node#isNamed}.
+     */
+    get namedChildCount(): any;
+    /** Get this node's first child. */
+    get firstChild(): any;
+    /**
+     * Get this node's first named child.
+     *
+     * See also {@link Node#isNamed}.
+     */
+    get firstNamedChild(): any;
+    /** Get this node's last child. */
+    get lastChild(): any;
+    /**
+     * Get this node's last named child.
+     *
+     * See also {@link Node#isNamed}.
+     */
+    get lastNamedChild(): any;
+    /**
+     * Iterate over this node's children.
+     *
+     * If you're walking the tree recursively, you may want to use the
+     * {@link TreeCursor} APIs directly instead.
+     */
+    get children(): any;
+    /**
+     * Iterate over this node's named children.
+     *
+     * See also {@link Node#children}.
+     */
+    get namedChildren(): any;
+    /**
+     * Get the descendants of this node that are the given type, or in the given types array.
+     *
+     * The types array should contain node type strings, which can be retrieved from {@link Language#types}.
+     *
+     * Additionally, a `startPosition` and `endPosition` can be passed in to restrict the search to a byte range.
+     */
+    descendantsOfType(types: any, startPosition?: {
+        row: number;
+        column: number;
+    }, endPosition?: {
+        row: number;
+        column: number;
+    }): any[];
+    /** Get this node's next sibling. */
+    get nextSibling(): any;
+    /** Get this node's previous sibling. */
+    get previousSibling(): any;
+    /**
+     * Get this node's next *named* sibling.
+     *
+     * See also {@link Node#isNamed}.
+     */
+    get nextNamedSibling(): any;
+    /**
+     * Get this node's previous *named* sibling.
+     *
+     * See also {@link Node#isNamed}.
+     */
+    get previousNamedSibling(): any;
+    /** Get the node's number of descendants, including one for the node itself. */
+    get descendantCount(): any;
+    /**
+     * Get this node's immediate parent.
+     * Prefer {@link Node#childWithDescendant} for iterating over this node's ancestors.
+     */
+    get parent(): any;
+    /**
+     * Get the node that contains `descendant`.
+     *
+     * Note that this can return `descendant` itself.
+     */
+    childWithDescendant(descendant: any): any;
+    /** Get the smallest node within this node that spans the given byte range. */
+    descendantForIndex(start: any, end?: any): any;
+    /** Get the smallest named node within this node that spans the given byte range. */
+    namedDescendantForIndex(start: any, end?: any): any;
+    /** Get the smallest node within this node that spans the given point range. */
+    descendantForPosition(start: any, end?: any): any;
+    /** Get the smallest named node within this node that spans the given point range. */
+    namedDescendantForPosition(start: any, end?: any): any;
+    /**
+     * Create a new {@link TreeCursor} starting from this node.
+     *
+     * Note that the given node is considered the root of the cursor,
+     * and the cursor cannot walk outside this node.
+     */
+    walk(): TreeCursor;
+    /**
+     * Edit this node to keep it in-sync with source code that has been edited.
+     *
+     * This function is only rarely needed. When you edit a syntax tree with
+     * the {@link Tree#edit} method, all of the nodes that you retrieve from
+     * the tree afterward will already reflect the edit. You only need to
+     * use {@link Node#edit} when you have a specific {@link Node} instance that
+     * you want to keep and continue to use after an edit.
+     */
+    edit(edit: any): void;
+    /** Get the S-expression representation of this node. */
+    toString(): any;
+}
+import { TreeCursor } from "./tree_cursor.js";
+//# sourceMappingURL=node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../../src/deno-tree-sitter/main/tree_sitter/node.js"],"names":[],"mappings":"AAQA,kDAAkD;AAClD;IAUI,gBAAgB;IAChB;;;;;;OAOC;IAjBD,gBAAgB;IAChB,UAAO;IAEP,gBAAgB;IAChB,eAAS;IAET,gBAAgB;IAChB,oBAAc;IAYd;;;;;;;;;;;OAWG;IACH,QAAE;IAQF,0CAA0C;IAC1C,UAAI;IAPJ,6CAA6C;IAC7C,gBAAU;IAEV,2CAA2C;IAC3C,mBAAa;IAKb,8CAA8C;IAC9C,kBAGC;IAED;;;OAGG;IACH,qBAGC;IAED,wCAAwC;IACxC,gBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;;OAKG;IACH,uBAGC;IAED;;;;;OAKG;IACH,uBAGC;IAED;;;;;OAKG;IACH,uBAGC;IAED;;;;;OAKG;IACH,yBAGC;IAED,0CAA0C;IAC1C,0BAGC;IAED;;;OAGG;IACH,wBAGC;IAED,+CAA+C;IAC/C,oBAGC;IAED,6CAA6C;IAC7C;;;MAIC;IAED,2CAA2C;IAC3C,gBAEC;IAED,mCAAmC;IACnC,sBAGC;IAED,2CAA2C;IAC3C,0BAGC;IAED,mDAAmD;IACnD,4BAEC;IAED;;;;;;OAMG;IACH,uBAIC;IAED;;;;;;;OAOG;IACH,4BAIC;IAED;;;;;OAKG;IACH,mCAIC;IAED;;;;;OAKG;IACH,uCAIC;IAED,kEAAkE;IAClE,mCAKC;IAED,wEAAwE;IACxE,wCAKC;IACD;;;;OAIG;IACH,4CAIC;IAED;;;;OAIG;IACH,wCAgBC;IAED,sFAAsF;IACtF,oCAMC;IAED,4FAA4F;IAC5F,yCAMC;IAED,0CAA0C;IAC1C,sBAGC;IAED;;;;OAIG;IACH,2BAGC;IAED,mCAAmC;IACnC,sBAEC;IAED;;;;OAIG;IACH,2BAEC;IAED,kCAAkC;IAClC,qBAEC;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;;OAKG;IACH,oBAiBC;IAED;;;;OAIG;IACH,yBAiBC;IAED;;;;;;OAMG;IACH;;;;;;cA2CC;IAED,oCAAoC;IACpC,uBAIC;IAED,wCAAwC;IACxC,2BAIC;IAED;;;;OAIG;IACH,4BAIC;IAED;;;;OAIG;IACH,gCAIC;IAED,+EAA+E;IAC/E,2BAGC;IAED;;;OAGG;IACH,kBAIC;IAED;;;;OAIG;IACH,0CAKC;IAED,8EAA8E;IAC9E,+CAWC;IAED,oFAAoF;IACpF,oDAWC;IAED,+EAA+E;IAC/E,kDAWC;IAED,qFAAqF;IACrF,uDAWC;IAED;;;;;OAKG;IACH,mBAIC;IAED;;;;;;;;OAQG;IACH,sBA2BC;IAED,wDAAwD;IACxD,gBAMC;CACJ;2BArmB0B,kBAAkB"}