@kerebron/tree-sitter 0.4.27 → 0.4.28

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

@@ -0,0 +1,48 @@
+export const _shadows: {};
+export class BaseNode {
+    constructor(data: any);
+    /** @type {number} */
+    get depth(): number;
+    _depth: any;
+    /** @type {number} */
+    get length(): number;
+    get hasChildren(): boolean;
+    get hardChildren(): any;
+    get fields(): {};
+    get fieldNames(): never[];
+    /** @type {string} */
+    get indent(): string;
+    /** @type {Object} */
+    toJSON(): {
+        children: any;
+        type: any;
+        typeId: any;
+        fieldNames: never[];
+        startPosition: any;
+        startIndex: any;
+        endPosition: any;
+        endIndex: any;
+        indent: string;
+    } | {
+        text: any;
+        children: never[];
+        type: any;
+        typeId: any;
+        fieldNames: never[];
+        startPosition: any;
+        startIndex: any;
+        endPosition: any;
+        endIndex: any;
+        indent: string;
+    };
+    iterFlattened(): Generator<never, void, unknown>;
+    flattened(): never[];
+    /**
+     * Destroy the children of this node and replace the .text of this node with the given string.
+     *
+     * @param {string} replacement - description
+     */
+    replaceInnards(replacement: string): void;
+    [Symbol.iterator](): Generator<any, void, any>;
+}
+//# sourceMappingURL=base_node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"base_node.d.ts","sourceRoot":"","sources":["../../../../src/deno-tree-sitter/main/extended/base_node.js"],"names":[],"mappings":"AAEA,0BAA0B;AAC1B;IAUI,uBAEC;IAED,qBAAqB;IACrB,aADW,MAAM,CAUhB;IANW,YAAe;IAQ3B,qBAAqB;IACrB,cADW,MAAM,CAGhB;IAMD,2BAEC;IAED,wBAEC;IAED,iBAEC;IAED,0BAEC;IAED,qBAAqB;IACrB,cADW,MAAM,CAKhB;IAED,qBAAqB;IACrB;;;;;;;;;;;;;;;;;;;;;MAgCC;IAgCD,iDAEC;IACD,qBAEC;IAED;;;;OAIG;IACH,4BAFW,MAAM,QAoChB;IA1ID,+CAEC;CAyIJ"}

package/esm/deno-tree-sitter/main/extended/base_node.js

@@ -0,0 +1,154 @@
+import { Node } from "../tree_sitter/node.js";
+export const _shadows = {};
+export class BaseNode {
+    // type = ""
+    // typeId = 0
+    // startPosition = 0
+    // startIndex = 0
+    // endPosition = 0
+    // startIndex = 0
+    // endIndex = 0
+    // indent = ""
+    constructor(data) {
+        Object.assign(this, data);
+    }
+    /** @type {number} */
+    get depth() {
+        if (this._depth == null) {
+            if (this.parent == null) {
+                this._depth = 0;
+            }
+            else {
+                this._depth = this.parent.depth + 1;
+            }
+        }
+        return this._depth;
+    }
+    /** @type {number} */
+    get length() {
+        return this.children?.length || 0;
+    }
+    *[Symbol.iterator]() {
+        yield* this.children || [];
+    }
+    get hasChildren() {
+        return (this.children?.length || 0) > 0;
+    }
+    get hardChildren() {
+        return (this.children || []).filter(each => each instanceof Node);
+    }
+    get fields() {
+        return {};
+    }
+    get fieldNames() {
+        return [];
+    }
+    /** @type {string} */
+    get indent() {
+        return this.tree.codeString.match(new RegExp(`^(?:.*\\r?\\n){${this.startPosition.row}}(\\s*)`))[1];
+        // equivalent but usually faster than:
+        // return this.tree.codeString.split("\n")[this.startPosition.row].match(/^\s*/)[0]
+    }
+    /** @type {Object} */
+    toJSON() {
+        const optionalData = {};
+        if (this.children?.length) {
+            return {
+                type: this.type,
+                typeId: this.typeId,
+                fieldNames: this.fieldNames,
+                startPosition: this.startPosition,
+                startIndex: this.startIndex,
+                endPosition: this.endPosition,
+                startIndex: this.startIndex,
+                endIndex: this.endIndex,
+                indent: this.indent,
+                ...optionalData,
+                children: this.children.map(each => each.toJSON()),
+            };
+        }
+        else {
+            return {
+                type: this.type,
+                typeId: this.typeId,
+                fieldNames: this.fieldNames,
+                startPosition: this.startPosition,
+                startIndex: this.startIndex,
+                endPosition: this.endPosition,
+                startIndex: this.startIndex,
+                endIndex: this.endIndex,
+                indent: this.indent,
+                ...optionalData,
+                text: this.text,
+                children: [],
+            };
+        }
+    }
+    [Symbol.for("Deno.customInspect")](inspect, options) {
+        const optional = {};
+        let text;
+        try {
+            text = this.text;
+        }
+        catch (error) {
+            text = undefined;
+        }
+        if (text == undefined) {
+            return this;
+        }
+        return inspect({
+            '': text.length < 60 ? text : text.slice(0, 30) + "..." + text.slice(-27),
+            type: this.type,
+            typeId: this.typeId,
+            fieldNames: this.fieldNames,
+            startPosition: this.startPosition,
+            startIndex: this.startIndex,
+            endPosition: this.endPosition,
+            startIndex: this.startIndex,
+            endIndex: this.endIndex,
+            indent: this.indent,
+            ...optional,
+            hasChildren: this.hasChildren,
+            children: [...(this.children || [])],
+        }, options);
+    }
+    *iterFlattened() {
+    }
+    flattened() {
+        return [];
+    }
+    /**
+     * Destroy the children of this node and replace the .text of this node with the given string.
+     *
+     * @param {string} replacement - description
+     */
+    replaceInnards(replacement) {
+        const tree = this.tree;
+        const sourceCode = this.tree.codeString;
+        const node = _shadows[this.id] || this;
+        // clear out children (innards) because of replacement
+        node._children = [];
+        node._fields = {};
+        // get the node position info
+        const { startPosition: originalStart, endPosition: originalEnd, startIndex: originalStartIndex, endIndex: originalEndIndex, } = node;
+        // compute what the new row-column will be
+        const newNumberOfLines = replacement.match(/\n/g)?.length || 0;
+        let newEndCol = originalStart.column;
+        if (newNumberOfLines == 0) {
+            newEndCol = originalStart.column + replacement.length;
+        }
+        else {
+            newEndCol = replacement.split("\n").slice(-1)[0].length;
+        }
+        // updates all the indices of all the nodes
+        tree.edit({
+            startIndex: originalStartIndex,
+            oldEndIndex: originalEndIndex,
+            newEndIndex: originalStartIndex + replacement.length,
+            startPosition: originalStart,
+            oldEndPosition: originalEnd,
+            newEndPosition: { row: originalStart.row + newNumberOfLines, column: newEndCol },
+        });
+        this.tree.codeString = sourceCode.slice(0, originalStartIndex) + replacement + sourceCode.slice(originalEndIndex);
+    }
+}

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"}