@kerebron/tree-sitter 0.4.6

package/esm/deno-tree-sitter/main/extended/node_extended.d.ts

@@ -0,0 +1,237 @@
+export class ExtendedTree extends Tree {
+    /** @type {HardNode} */
+    rootNode: HardNode;
+}
+export class HardNode extends BaseNode {
+    /** @internal */
+    _children: any;
+    /** @internal */
+    _fields: any;
+    /** @type {number} */
+    id: number;
+    /** @type {number} */
+    startIndex: number;
+    /** @type {Position} */
+    startPosition: Position;
+    /** @type {ExtendedTree} */
+    tree: ExtendedTree;
+    /** @type {string} */
+    type: string;
+    /** @type {Boolean} */
+    isExtra: boolean;
+    /** @type {Boolean} */
+    isError: boolean;
+    /** @type {Boolean} */
+    isMissing: boolean;
+    /** @type {Boolean} */
+    hasChanges: boolean;
+    /** @type {Boolean} */
+    hasError: boolean;
+    /**
+     * @param {HardNode} other -
+     * @returns {Boolean} output -
+     */
+    equals: ((other: any) => boolean) | undefined;
+    /** @type {HardNode} */
+    get parent(): HardNode;
+    /** @type {string} */
+    get text(): string;
+    /** @type {Number} */
+    get endIndex(): number;
+    /** @type {Position} */
+    get endPosition(): Position;
+    set children(value: Array<HardNode | SoftNode>);
+    /** @type {Array<HardNode|SoftNode>} */
+    get children(): Array<HardNode | SoftNode>;
+    /**
+    * Yields each child
+    *
+    * @generator
+    * @yields {HardNode} The current child or grandchild in the structure.
+    */
+    traverse(arg?: {
+        _parentNodes: never[];
+    }): Generator<any, void, unknown>;
+    /**
+    * A generator function that flattens the hierarchical structure of `children` and their descendants.
+    * It yields each child and their flattened descendants recursively.
+    *
+    * @param {Function} opts.filter - A function to filter the flattened elements.
+    * @param {Boolean} opts.includeSelf -
+    * @generator
+    * @yields {HardNode} The current child or grandchild in the structure.
+    */
+    iterFlattened({ filter, includeSelf }?: Function): Generator<any, void, unknown>;
+    /** @internal */
+    iterFlatten(): void;
+    /**
+    * Flattens the structure of `children` using the provided filter function.
+    * This method returns an array containing the flattened elements.
+    *
+    * @param {Function} opts.filter - A function to filter the flattened elements.
+    * @param {Boolean} opts.includeSelf -
+    * @returns {Array} An array containing the flattened elements that pass the filter.
+    */
+    flattened({ filter, includeSelf }?: Function): any[];
+    /** @internal */
+    flatten(): void;
+    /**
+    * Query
+    *
+    * @example
+    * ```js
+    * import { createParser } from "https://deno.land/x/deno_tree_sitter/main/main.js"
+    * import javascript from "https://github.com/jeff-hykin/common_tree_sitter_languages/raw/4d8a6d34d7f6263ff570f333cdcf5ded6be89e3d/main/javascript.js"
+    * const parser = await createParser(javascript) // path or Uint8Array
+    * const tree = parser.parse('let a = 1;let b = 1;let c = 1;')
+    *
+    * tree.rootNode.query(`(identifier) @blahBlahBlah`, {matchLimit: 2})
+    * // returns:
+    * [
+    *   {
+    *     pattern: 0,
+    *     captures: [
+    *       {
+    *         name: "blahBlahBlah",
+    *         node: {
+    *           type: "identifier",
+    *           typeId: 1,
+    *           startPosition: { row: 0, column: 4 },
+    *           startIndex: 4,
+    *           endPosition: { row: 0, column: 5 },
+    *           endIndex: 5,
+    *           indent: undefined,
+    *           hasChildren: false,
+    *           children: []
+    *         }
+    *       }
+    *     ]
+    *   },
+    *   {
+    *     pattern: 0,
+    *     captures: [
+    *       {
+    *         name: "blahBlahBlah",
+    *         node: {
+    *           type: "identifier",
+    *           typeId: 1,
+    *           startPosition: { row: 0, column: 14 },
+    *           startIndex: 14,
+    *           endPosition: { row: 0, column: 15 },
+    *           endIndex: 15,
+    *           indent: undefined,
+    *           hasChildren: false,
+    *           children: []
+    *         }
+    *       }
+    *     ]
+    *   },
+    *   {
+    *     pattern: 0,
+    *     captures: [
+    *       {
+    *         name: "blahBlahBlah",
+    *         node: {
+    *           type: "identifier",
+    *           typeId: 1,
+    *           startPosition: { row: 0, column: 24 },
+    *           startIndex: 24,
+    *           endPosition: { row: 0, column: 25 },
+    *           endIndex: 25,
+    *           indent: undefined,
+    *           hasChildren: false,
+    *           children: []
+    *         }
+    *       }
+    *     ]
+    *   }
+    * ]
+    * ```
+    *
+    * @param {String} queryString - see https://tree-sitter.github.io/tree-sitter/using-parsers#query-syntax
+    * @param options.matchLimit - max number of results
+    * @param options.startPosition - {row: Number, column: number}
+    * @param options.endPosition - {row: Number, column: number}
+    * @param options.maxResultDepth - depth relative to the current node (1 = direct children, 2 = grandchildren, etc)
+    * @returns {[Object]} output
+    *
+    */
+    query(queryString: string, options: any): [Object];
+    /**
+    * quickQuery
+    *
+    * @example
+    * ```js
+    * import { createParser } from "https://deno.land/x/deno_tree_sitter/main/main.js"
+    * import javascript from "https://github.com/jeff-hykin/common_tree_sitter_languages/raw/676ffa3b93768b8ac628fd5c61656f7dc41ba413/main/javascript.js"
+    * const parser = await createParser(javascript) // path or Uint8Array
+    * const tree = parser.parse('let a = 1;let b = 1;let c = 1;')
+    * // ex1: no capture names
+    * const nodes = tree.rootNode.quickQuery(
+    *     `(identifier)`, {matchLimit: 2}
+    * )
+    * // ex2: with capture names
+    * const groups = tree.rootNode.quickQuery(
+    *     `'(binding (attrpath) @myKey (list_expression) @myList ("\\"")? @optionalThing )`
+    * )
+    * groups[0].myKey // node
+    * groups[0].myList // node
+    * groups[0].optionalThing // node or null
+    * groups[0][0] // node (the whole match)
+    * ```
+    *
+    * @param {String} queryString - see https://tree-sitter.github.io/tree-sitter/using-parsers#query-syntax
+    * @param options.matchLimit - max number of results
+    * @param options.startPosition - {row: Number, column: number}
+    * @param options.endPosition - {row: Number, column: number}
+    * @param options.maxResultDepth - depth relative to the current node (1 = direct children, 2 = grandchildren, etc)
+    * @returns {Array<HardNode|Record<any, HardNode>>} nodesOrObjsOfNodes
+    */
+    quickQuery(queryString: string, options: any): Array<HardNode | Record<any, HardNode>>;
+    /**
+    * quickQueryFirst
+    *
+    * @example
+    * ```js
+    * import { createParser } from "https://deno.land/x/deno_tree_sitter/main/main.js"
+    * import javascript from "https://github.com/jeff-hykin/common_tree_sitter_languages/raw/4d8a6d34d7f6263ff570f333cdcf5ded6be89e3d/main/javascript.js"
+    * const parser = await createParser(javascript) // path or Uint8Array
+    * const tree = parser.parse('let a = 1;let b = 1;let c = 1;')
+    *
+    * // ex1: no capture names
+    * const node = tree.rootNode.quickQueryFirst(`(identifier)`)
+    *
+    * // ex2: with capture names
+    * const { myKey, myList, optionalThing } = tree.rootNode.quickQueryFirst(
+    *     `'(binding (attrpath) @myKey (list_expression) @myList ("\\"")? @optionalThing )`
+    * )
+    * myKey // node
+    * myList // node
+    * optionalThing // node or null
+    * ```
+    *
+    * @param {String} queryString - see https://tree-sitter.github.io/tree-sitter/using-parsers#query-syntax
+    * @param options.startPosition - {row: Number, column: number}
+    * @param options.endPosition - {row: Number, column: number}
+    * @param options.maxResultDepth - depth relative to the current node (1 = direct children, 2 = grandchildren, etc)
+    * @returns {HardNode|Record<any,HardNode>|null} nodeOrObjOfNodes
+    */
+    quickQueryFirst(queryString: string, options: any): HardNode | Record<any, HardNode> | null;
+    get fields(): any;
+    get fieldNames(): string[];
+    getQueryForSelf(): string;
+    /** @returns {string} */
+    asLispString(): string;
+}
+export { Node };
+export function _childrenWithSoftNodes(node: any, children: any, string: any): any[] | undefined;
+import { Tree } from "../tree_sitter/tree.js";
+import { BaseNode } from "./base_node.js";
+declare class Position {
+    /** @type {number} */
+    row: number;
+    /** @type {number} */
+    column: number;
+}
+import { Node } from "../tree_sitter/node.js";
+//# sourceMappingURL=node_extended.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"node_extended.d.ts","sourceRoot":"","sources":["../../../../src/deno-tree-sitter/main/extended/node_extended.js"],"names":[],"mappings":"AA2DA;IACI,uBAAuB;IACvB,UADW,QAAQ,CACX;CACX;AAmBD;IACI,gBAAgB;IAChB,eAAS;IACT,gBAAgB;IAChB,aAAO;IAIP,qBAAqB;IACrB,IADW,MAAM,CACf;IACF,qBAAqB;IACrB,YADW,MAAM,CACP;IACV,uBAAuB;IACvB,eADW,QAAQ,CACN;IACb,2BAA2B;IAC3B,MADW,YAAY,CACnB;IACJ,qBAAqB;IACrB,MADW,MAAM,CACb;IACJ,sBAAsB;IACtB,iBAAO;IACP,sBAAsB;IACtB,iBAAO;IACP,sBAAsB;IACtB,mBAAS;IACT,sBAAsB;IACtB,oBAAU;IACV,sBAAsB;IACtB,kBAAQ;IACR;;;OAGG;IACH,8CAAuB;IAEvB,uBAAuB;IACvB,cADW,QAAQ,CAIlB;IAED,qBAAqB;IACrB,YADW,MAAM,CAGhB;IAED,qBAAqB;IACrB,uBAKC;IAED,uBAAuB;IACvB,mBADW,QAAQ,CAQlB;IAeD,oBAbW,KAAK,CAAC,QAAQ,GAAC,QAAQ,CAAC,EAelC;IAfD,uCAAuC;IACvC,gBADW,KAAK,CAAC,QAAQ,GAAC,QAAQ,CAAC,CAWlC;IAMD;;;;;MAKE;IACF;;sCAkBC;IAED;;;;;;;;MAQE;IACF,iFAqBC;IAED,gBAAgB;IAChB,oBAEC;IAED;;;;;;;MAOE;IACF,qDAEC;IACD,gBAAgB;IAChB,gBAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgFE;IACF,0CAHY,CAAC,MAAM,CAAC,CAyBnB;IACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA6BE;IACF,+CAFY,KAAK,CAAC,QAAQ,GAAC,MAAM,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,CA6BhD;IACD;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2BE;IACF,oDAFY,QAAQ,GAAC,MAAM,CAAC,GAAG,EAAC,QAAQ,CAAC,GAAC,IAAI,CAI7C;IACD,kBAiBC;IACD,2BAEC;IAED,0BAmBC;IAED,wBAAwB;IACxB,gBADc,MAAM,CAGnB;CACJ;;AAcM,iGA6FN;qBApkBoB,wBAAwB;yBALV,gBAAgB;AA+DnD;IACI,qBAAqB;IACrB,KADW,MAAM,CACd;IACH,qBAAqB;IACrB,QADW,MAAM,CACX;CACT;qBAtEoB,wBAAwB"}