@kerebron/tree-sitter 0.4.6

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

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../../src/deno-tree-sitter/main/extended/parser.js"],"names":[],"mappings":"AAiDA;;;;;;;;;GASG;AACH,uDALW,UAAU,GAAC,MAAM,wCAEzB;IAA0B,gBAAgB;CAC1C,GAAU,OAAO,CAAC,cAAc,CAAC,CA6BnC;AA5DD;IACI;;;;;;;;;;;;;;;OAeG;IACH,kCAXW,IAAI,GAAG,IAAI,YAIX,YAAY,GAGV,YAAY,GAAG,IAAI,CAK/B;CACJ;uBA3CsB,0BAA0B;qBAD5B,wBAAwB;6BAIkB,oBAAoB"}

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

@@ -0,0 +1,86 @@
+import { Node } from "../tree_sitter/node.js";
+import { Tree } from "../tree_sitter/tree.js";
+import { Parser } from "../tree_sitter/parser.js";
+import { Language } from "../tree_sitter/language.js";
+import "./node_extended.js"; // note: redundant but might not be redundant in the future
+import { HardNode, ExtendedTree, _childrenWithSoftNodes } from "./node_extended.js";
+const realParseFunction = Parser.prototype.parse;
+Parser.prototype.parse = function (code, oldTree, options) {
+    if (typeof code == "function") {
+        console.warn("When calling .parse() the source code was a function instead of a string. The original tree sitter supports giving a function as a means of supporting edits (see: https://github.com/tree-sitter/tree-sitter/discussions/2553 ).\nHowever, this library supports edits directly (use node.replaceInnards(``))\nThe downside of making edits easy is that .parse() doesn't really accept a function argument. I'm just going to evaluate that function to grab the string once at the beginning. Use tree.codeString if you want to get the full string after a .replaceInnards() call.");
+        code = code(0);
+    }
+    let tree;
+    tree = realParseFunction.apply(this, [
+        (index) => (tree?.codeString ?? code).slice(index),
+        oldTree,
+        options
+    ]);
+    tree.codeString = code;
+    code = null;
+    tree._enableSoftNodes = !this.disableSoftNodes;
+    return tree;
+};
+// this only exists to help with type hints
+class ExtendedParser extends Parser {
+    /**
+     * Parse a slice of UTF8 text.
+     *
+     * @param {string | ParseCallback} callback - Source code to parse
+     *
+     * @param {Tree | null} [oldTree] - A previous syntax tree parsed from the same document. If the text of the
+     *   document has changed since `oldTree` was created, then you must edit `oldTree` to match
+     *   the new text using {@link Tree#edit}.
+     *
+     * @param {ParseOptions} [options] - Options for parsing the text.
+     *  This can be used to set the included ranges, or a progress callback.
+     *
+     * @returns {ExtendedTree | null} A {@link Tree} if parsing succeeded, or `null` if:
+     *  - The parser has not yet had a language assigned with {@link Parser#setLanguage}.
+     *  - The progress callback returned true.
+     */
+    parse(inputString, oldTree, options) {
+    }
+}
+const langCache = new Map();
+let hasBeenLoaded = false;
+/**
+ * Creates and returns a new parser instance, loading a language from a WebAssembly binary or file path.
+ * Optionally, the parser can be configured to disable soft nodes.
+ *
+ * @async
+ * @param {Uint8Array|string} wasmUint8ArrayOrFilePath - The WebAssembly binary as a `Uint8Array` or a file path to load the language.
+ * @param {Object} [options] - Optional configuration options.
+ * @param {boolean} [options.disableSoftNodes=false] - Whether to disable soft nodes in the parser (default is `false`).
+ * @returns {Promise<ExtendedParser>} A promise that resolves to the created parser instance.
+ */
+export async function createParser(wasmUint8ArrayOrFilePath, { disableSoftNodes = false, moduleOptions } = {}) {
+    // download if given a url
+    if (typeof wasmUint8ArrayOrFilePath == "string" && wasmUint8ArrayOrFilePath.match(/^https?:\/\//)) {
+        wasmUint8ArrayOrFilePath = await fetch(wasmUint8ArrayOrFilePath).then(async (r) => new Uint8Array(await r.arrayBuffer()));
+    }
+    if (!hasBeenLoaded) {
+        hasBeenLoaded = true;
+        await Parser.init(moduleOptions);
+    }
+    // this is a workaround for the a bug in the loader where loading the same language twice causes a freeze
+    // see: "WebAssembly.instantiate(binary, info).then" inside wasm_loader.js
+    let language;
+    if (wasmUint8ArrayOrFilePath instanceof Uint8Array) {
+        const hashString = Array.from(new Uint8Array(await crypto.subtle.digest("SHA-256", wasmUint8ArrayOrFilePath))).map((b) => b.toString(16).padStart(2, "0")).join("");
+        if (langCache.has(hashString)) {
+            language = langCache.get(hashString);
+        }
+        else {
+            language = await Language.load(wasmUint8ArrayOrFilePath);
+            langCache.set(hashString, language);
+        }
+    }
+    else {
+        language = await Language.load(wasmUint8ArrayOrFilePath);
+    }
+    const parser = new Parser();
+    parser.setLanguage(language);
+    parser.disableSoftNodes = disableSoftNodes;
+    return parser;
+}

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

@@ -0,0 +1,15 @@
+export class SoftNode extends BaseNode {
+    children: any[];
+    get startIndex(): any;
+    get startPosition(): {
+        row: any;
+        column: any;
+    };
+    get endIndex(): any;
+    get endPosition(): {
+        row: any;
+        column: any;
+    };
+}
+import { BaseNode } from "./base_node.js";
+//# sourceMappingURL=soft_node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"soft_node.d.ts","sourceRoot":"","sources":["../../../../src/deno-tree-sitter/main/extended/soft_node.js"],"names":[],"mappings":"AAGA;IACI,gBAAa;IAMb,sBAEC;IAED;;;MAKC;IAED,oBAEC;IAED;;;MAKC;CACJ;yBA/BwB,gBAAgB"}

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

@@ -0,0 +1,32 @@
+import { BaseNode } from "./base_node.js";
+// HardNode extends BaseNode as well (indirectly)
+export class SoftNode extends BaseNode {
+    constructor(data) {
+        super(data);
+        Object.defineProperty(this, "children", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    // these are getters because when calling .replaceInnards() on a node the indices of hardNodes shift, these getters piggyback on that shift (otherwise they'd be wrong)
+    get startIndex() {
+        return this._startIndexOffset + this.getReferencePoint().index;
+    }
+    get startPosition() {
+        return {
+            row: this._startRowOffset + this.getReferencePoint().position.row,
+            column: this._startColOffset + this.getReferencePoint().position.column,
+        };
+    }
+    get endIndex() {
+        return this._endIndexOffset + this.getReferencePoint().index;
+    }
+    get endPosition() {
+        return {
+            row: this._endRowOffset + this.getReferencePoint().position.row,
+            column: this._endColOffset + this.getReferencePoint().position.column,
+        };
+    }
+}

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

@@ -0,0 +1,10 @@
+export class SoftTextNode extends SoftNode {
+    constructor({ parent, ...data }: {
+        [x: string]: any;
+        parent: any;
+    });
+    _parent: any;
+    get parent(): any;
+}
+import { SoftNode } from "./soft_node.js";
+//# sourceMappingURL=soft_text_node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"soft_text_node.d.ts","sourceRoot":"","sources":["../../../../src/deno-tree-sitter/main/extended/soft_text_node.js"],"names":[],"mappings":"AAEA;IACI;;;OAGC;IADG,aAAqB;IAEzB,kBAEC;CACJ;yBAVwB,gBAAgB"}

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

@@ -0,0 +1,10 @@
+import { SoftNode } from "./soft_node.js";
+export class SoftTextNode extends SoftNode {
+    constructor({ parent, ...data }) {
+        super({ ...data, type: "text", typeId: -2 });
+        this._parent = parent;
+    }
+    get parent() {
+        return this._parent;
+    }
+}

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

@@ -0,0 +1,10 @@
+export class WhitespaceNode extends SoftNode {
+    constructor({ parent, ...data }: {
+        [x: string]: any;
+        parent: any;
+    });
+    _parent: any;
+    get parent(): any;
+}
+import { SoftNode } from "./soft_node.js";
+//# sourceMappingURL=whitespace_node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"whitespace_node.d.ts","sourceRoot":"","sources":["../../../../src/deno-tree-sitter/main/extended/whitespace_node.js"],"names":[],"mappings":"AAEA;IACI;;;OAGC;IADG,aAAqB;IAEzB,kBAEC;CACJ;yBAVwB,gBAAgB"}

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

@@ -0,0 +1,10 @@
+import { SoftNode } from "./soft_node.js";
+export class WhitespaceNode extends SoftNode {
+    constructor({ parent, ...data }) {
+        super({ ...data, type: "whitespace", typeId: -1 });
+        this._parent = parent;
+    }
+    get parent() {
+        return this._parent;
+    }
+}

package/esm/deno-tree-sitter/main/extras/misc.d.ts

@@ -0,0 +1,2 @@
+export function _getQueryCaptureTargets(queryString: any): any;
+//# sourceMappingURL=misc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"misc.d.ts","sourceRoot":"","sources":["../../../../src/deno-tree-sitter/main/extras/misc.js"],"names":[],"mappings":"AAAA,+DAWC"}

package/esm/deno-tree-sitter/main/extras/misc.js

@@ -0,0 +1,13 @@
+export function _getQueryCaptureTargets(queryString) {
+    if (!queryString.includes("@")) {
+        return [];
+    }
+    else { // need a rigorous check
+        // remove all strings from within the query (the only place a false capture target could appear)
+        // NOTE: this is based exactly on the language spec, its not a hack: https://github.com/tree-sitter-grammars/tree-sitter-query/blob/3a9808b22742d5bd906ef5d1a562f2f1ae57406d/src/grammar.json#L140
+        const safeSearchableQuery = queryString.replace(/"(?:\\(?:[^xu0-7]|[0-7]{1,3}|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4}|u{[0-9a-fA-F]+})|[^\"\\])*"/g, "");
+        // now check if there is a capture target
+        // NOTE: also based on the language spec: https://github.com/tree-sitter-grammars/tree-sitter-query/blob/3a9808b22742d5bd906ef5d1a562f2f1ae57406d/src/grammar.json#L204
+        return safeSearchableQuery.match(/(?<=@)([a-zA-Z0-9.\-_\$]+)/g);
+    }
+}

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

@@ -0,0 +1,14 @@
+/**
+ * @internal
+ *
+ * Initialize the Tree-sitter Wasm module. This should only be called by the {@link Parser} class via {@link Parser.init}.
+ */
+export function initializeBinding(moduleOptions: any): Promise<null>;
+/**
+ * @internal
+ *
+ * Checks if the Tree-sitter Wasm module has been initialized.
+ */
+export function checkModule(): boolean;
+export let Module: null;
+//# sourceMappingURL=bindings.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bindings.d.ts","sourceRoot":"","sources":["../../../../src/deno-tree-sitter/main/tree_sitter/bindings.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,qEAKC;AAED;;;;GAIG;AACH,uCAEC;AArBD,wBAAwB"}

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

@@ -0,0 +1,21 @@
+import createModule from "../wasm_loader_with_defaults.js";
+export let Module = null;
+/**
+ * @internal
+ *
+ * Initialize the Tree-sitter Wasm module. This should only be called by the {@link Parser} class via {@link Parser.init}.
+ */
+export async function initializeBinding(moduleOptions) {
+    if (!Module) {
+        Module = await createModule(moduleOptions);
+    }
+    return Module;
+}
+/**
+ * @internal
+ *
+ * Checks if the Tree-sitter Wasm module has been initialized.
+ */
+export function checkModule() {
+    return !!Module;
+}

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

@@ -0,0 +1,60 @@
+/** @internal */
+/** @internal */
+export function assertInternal(x: any): void;
+/** @internal */
+export function isPoint(point: any): boolean;
+/**
+ * @internal
+ *
+ * Sets the Tree-sitter Wasm module. This should only be called by the {@link Parser} class via {@link Parser.init}.
+ */
+export function setModule(module: any): void;
+/**
+ * A position in a multi-line text document, in terms of rows and columns.
+ *
+ * Rows and columns are zero-based.
+ */
+/**
+ *  A range of positions in a multi-line text document, both in terms of bytes
+ *  and of rows and columns.
+ */
+/**
+ * A summary of a change to a text document.
+ */
+/** @internal */
+export const SIZE_OF_SHORT: 2;
+/** @internal */
+export const SIZE_OF_INT: 4;
+/** @internal */
+export const SIZE_OF_CURSOR: number;
+/** @internal */
+export const SIZE_OF_NODE: number;
+/** @internal */
+export const SIZE_OF_POINT: number;
+/** @internal */
+export const SIZE_OF_RANGE: number;
+export namespace ZERO_POINT {
+    let row: number;
+    let column: number;
+}
+/**
+ * A callback for parsing that takes an index and point, and should return a string.
+ */
+/**
+ * A callback that receives the parse state during parsing.
+ */
+/**
+ * A callback for logging messages.
+ *
+ * If `isLex` is `true`, the message is from the lexer, otherwise it's from the parser.
+ */
+/** @internal */
+export const INTERNAL: unique symbol;
+/**
+ * @internal
+ *
+ * `C` is a convenient shorthand for the Tree-sitter Wasm module,
+ * which allows us to call all of the exported functions.
+ */
+export let C: any;
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/deno-tree-sitter/main/tree_sitter/constants.js"],"names":[],"mappings":"AAmDA,gBAAgB;AAEhB,gBAAgB;AAChB,6CAEC;AAED,gBAAgB;AAChB,6CAEC;AAED;;;;GAIG;AACH,6CAEC;AAlED;;;;GAIG;AACH;;;GAGG;AACH;;GAEG;AACH,gBAAgB;AAChB,4BAA6B,CAAC,CAAA;AAE9B,gBAAgB;AAChB,0BAA2B,CAAC,CAAA;AAE5B,gBAAgB;AAChB,oCAA6C;AAE7C,gBAAgB;AAChB,kCAA2C;AAE3C,gBAAgB;AAChB,mCAA4C;AAE5C,gBAAgB;AAChB,mCAAgE;;;;;AAKhE;;GAEG;AACH;;GAEG;AACH;;;;GAIG;AAEH,gBAAgB;AAChB,qCAA0C;AAsB1C;;;;;GAKG;AACH,kBAAY"}

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

@@ -0,0 +1,66 @@
+/**
+ * A position in a multi-line text document, in terms of rows and columns.
+ *
+ * Rows and columns are zero-based.
+ */
+/**
+ *  A range of positions in a multi-line text document, both in terms of bytes
+ *  and of rows and columns.
+ */
+/**
+ * A summary of a change to a text document.
+ */
+/** @internal */
+export const SIZE_OF_SHORT = 2;
+/** @internal */
+export const SIZE_OF_INT = 4;
+/** @internal */
+export const SIZE_OF_CURSOR = 4 * SIZE_OF_INT;
+/** @internal */
+export const SIZE_OF_NODE = 5 * SIZE_OF_INT;
+/** @internal */
+export const SIZE_OF_POINT = 2 * SIZE_OF_INT;
+/** @internal */
+export const SIZE_OF_RANGE = 2 * SIZE_OF_INT + 2 * SIZE_OF_POINT;
+/** @internal */
+export const ZERO_POINT = { row: 0, column: 0 };
+/**
+ * A callback for parsing that takes an index and point, and should return a string.
+ */
+/**
+ * A callback that receives the parse state during parsing.
+ */
+/**
+ * A callback for logging messages.
+ *
+ * If `isLex` is `true`, the message is from the lexer, otherwise it's from the parser.
+ */
+// Helper type for internal use
+/** @internal */
+export const INTERNAL = Symbol("INTERNAL");
+/** @internal */
+// Helper functions for type checking
+/** @internal */
+export function assertInternal(x) {
+    if (x !== INTERNAL)
+        throw new Error("Illegal constructor");
+}
+/** @internal */
+export function isPoint(point) {
+    return !!point && typeof point.row === "number" && typeof point.column === "number";
+}
+/**
+ * @internal
+ *
+ * Sets the Tree-sitter Wasm module. This should only be called by the {@link Parser} class via {@link Parser.init}.
+ */
+export function setModule(module) {
+    C = module;
+}
+/**
+ * @internal
+ *
+ * `C` is a convenient shorthand for the Tree-sitter Wasm module,
+ * which allows us to call all of the exported functions.
+ */
+export let C;

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

@@ -0,0 +1,137 @@
+export class LanguageMetadata {
+    major_version: any;
+    minor_version: any;
+    patch_version: any;
+}
+/**
+ * An opaque object that defines how to parse a particular language.
+ * The code for each `Language` is generated by the Tree-sitter CLI.
+ */
+export class Language {
+    /**
+     * Load a language from a WebAssembly module.
+     * The module can be provided as a path to a file or as a buffer.
+     */
+    static load(input: any): Promise<Language>;
+    /** @internal */
+    constructor(internal: any, address: any);
+    /** @internal */
+    0: number;
+    /**
+     * A list of all node types in the language. The index of each type in this
+     * array is its node type id.
+     */
+    types: any[];
+    /**
+     * A list of all field names in the language. The index of each field name in
+     * this array is its field id.
+     */
+    fields: any[];
+    /**
+     * Gets the name of the language.
+     */
+    get name(): any;
+    /**
+     * @deprecated since version 0.25.0, use {@link Language#abiVersion} instead
+     * Gets the version of the language.
+     */
+    get version(): any;
+    /**
+     * Gets the ABI version of the language.
+     */
+    get abiVersion(): any;
+    /**
+     * Get the metadata for this language. This information is generated by the
+     * CLI, and relies on the language author providing the correct metadata in
+     * the language's `tree-sitter.json` file.
+     */
+    get metadata(): {
+        major_version: any;
+        minor_version: any;
+        field_count: any;
+    } | null;
+    /**
+     * Gets the number of fields in the language.
+     */
+    get fieldCount(): number;
+    /**
+     * Gets the number of states in the language.
+     */
+    get stateCount(): any;
+    /**
+     * Get the field id for a field name.
+     */
+    fieldIdForName(fieldName: any): number | null;
+    /**
+     * Get the field name for a field id.
+     */
+    fieldNameForId(fieldId: any): any;
+    /**
+     * Get the node type id for a node type name.
+     */
+    idForNodeType(type: any, named: any): any;
+    /**
+     * Gets the number of node types in the language.
+     */
+    get nodeTypeCount(): any;
+    /**
+     * Get the node type name for a node type id.
+     */
+    nodeTypeForId(typeId: any): any;
+    /**
+     * Check if a node type is named.
+     *
+     * @see {@link https://tree-sitter.github.io/tree-sitter/using-parsers/2-basic-parsing.html#named-vs-anonymous-nodes}
+     */
+    nodeTypeIsNamed(typeId: any): boolean;
+    /**
+     * Check if a node type is visible.
+     */
+    nodeTypeIsVisible(typeId: any): boolean;
+    /**
+     * Get the supertypes ids of this language.
+     *
+     * @see {@link https://tree-sitter.github.io/tree-sitter/using-parsers/6-static-node-types.html?highlight=supertype#supertype-nodes}
+     */
+    get supertypes(): any[];
+    /**
+     * Get the subtype ids for a given supertype node id.
+     */
+    subtypes(supertype: any): any[];
+    /**
+     * Get the next state id for a given state id and node type id.
+     */
+    nextState(stateId: any, typeId: any): any;
+    /**
+     * Create a new lookahead iterator for this language and parse state.
+     *
+     * This returns `null` if state is invalid for this language.
+     *
+     * Iterating {@link LookaheadIterator} will yield valid symbols in the given
+     * parse state. Newly created lookahead iterators will return the `ERROR`
+     * symbol from {@link LookaheadIterator#currentType}.
+     *
+     * Lookahead iterators can be useful for generating suggestions and improving
+     * syntax error diagnostics. To get symbols valid in an `ERROR` node, use the
+     * lookahead iterator on its first leaf node state. For `MISSING` nodes, a
+     * lookahead iterator created on the previous non-extra leaf node may be
+     * appropriate.
+     */
+    lookaheadIterator(stateId: any): LookaheadIterator | null;
+    /**
+     * @deprecated since version 0.25.0, call `new` on a {@link Query} instead
+     *
+     * Create a new query from a string containing one or more S-expression
+     * patterns.
+     *
+     * The query is associated with a particular language, and can only be run
+     * on syntax nodes parsed with that language. References to Queries can be
+     * shared between multiple threads.
+     *
+     * @link {@see https://tree-sitter.github.io/tree-sitter/using-parsers/queries}
+     */
+    query(source: any): Query;
+}
+import { LookaheadIterator } from "./lookahead_iterator.js";
+import { Query } from "./query.js";
+//# sourceMappingURL=language.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"language.d.ts","sourceRoot":"","sources":["../../../../src/deno-tree-sitter/main/tree_sitter/language.js"],"names":[],"mappings":"AAQA;IACI,mBAAa;IACb,mBAAa;IACb,mBAAa;CAChB;AAED;;;GAGG;AACH;IAyOI;;;OAGG;IACH,2CAgCC;IA7PD,gBAAgB;IAChB,yCAkBC;IAlCD,gBAAgB;IAChB,UAAO;IAEP;;;OAGG;IACH,aAAK;IAEL;;;OAGG;IACH,cAAM;IAuBN;;OAEG;IACH,gBAIC;IAED;;;OAGG;IACH,mBAEC;IAED;;OAEG;IACH,sBAEC;IAED;;;;OAIG;IACH;;;;aAMC;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,sBAEC;IAED;;OAEG;IACH,8CAGC;IAED;;OAEG;IACH,kCAEC;IAED;;OAEG;IACH,0CAOC;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,gCAGC;IAED;;;;OAIG;IACH,sCAEC;IAED;;OAEG;IACH,wCAEC;IAED;;;;OAIG;IACH,wBAeC;IAED;;OAEG;IACH,gCAeC;IAED;;OAEG;IACH,0CAEC;IAED;;;;;;;;;;;;;;OAcG;IACH,0DAIC;IAED;;;;;;;;;;;OAWG;IACH,0BAGC;CAuCJ;kCA/RiC,yBAAyB;sBAGrC,YAAY"}