@kerebron/tree-sitter 0.4.6

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

@@ -0,0 +1,124 @@
+/**
+ * Options for parsing
+ *
+ * The `includedRanges` property is an array of {@link Range} objects that
+ * represent the ranges of text that the parser should include when parsing.
+ *
+ * The `progressCallback` property is a function that is called periodically
+ * during parsing to check whether parsing should be cancelled.
+ *
+ * See {@link Parser#parse} for more information.
+ */
+/**
+ * A stateful object that is passed into the progress callback {@link ParseOptions#progressCallback}
+ * to provide the current state of the parser.
+ */
+/**
+ * @internal
+ *
+ * Global variable for transferring data across the FFI boundary
+ */
+export let TRANSFER_BUFFER: any;
+/**
+ * The latest ABI version that is supported by the current version of the
+ * library.
+ *
+ * When Languages are generated by the Tree-sitter CLI, they are
+ * assigned an ABI version number that corresponds to the current CLI version.
+ * The Tree-sitter library is generally backwards-compatible with languages
+ * generated using older CLI versions, but is not forwards-compatible.
+ */
+export let LANGUAGE_VERSION: any;
+/**
+ * The earliest ABI version that is supported by the current version of the
+ * library.
+ */
+export let MIN_COMPATIBLE_VERSION: any;
+/**
+ * A stateful object that is used to produce a {@link Tree} based on some
+ * source code.
+ */
+export class Parser {
+    /**
+     * This must always be called before creating a Parser.
+     *
+     * You can optionally pass in options to configure the Wasm module, the most common
+     * one being `locateFile` to help the module find the `.wasm` file.
+     */
+    static init(moduleOptions: any): Promise<void>;
+    /** @internal */
+    0: number;
+    /** @internal */
+    1: number;
+    /** @internal */
+    logCallback: null;
+    /** The parser's current language. */
+    language: null;
+    /** @internal */
+    initialize(): void;
+    /** Delete the parser, freeing its resources. */
+    delete(): void;
+    /**
+     * Set the language that the parser should use for parsing.
+     *
+     * If the language was not successfully assigned, an error will be thrown.
+     * This happens if the language was generated with an incompatible
+     * version of the Tree-sitter CLI. Check the language's version using
+     * {@link Language#version} and compare it to this library's
+     * {@link LANGUAGE_VERSION} and {@link MIN_COMPATIBLE_VERSION} constants.
+     */
+    setLanguage(language: any): this;
+    /**
+     * Parse a slice of UTF8 text.
+     *
+     * @param {string | ParseCallback} callback - The UTF8-encoded text to parse or a callback function.
+     *
+     * @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 {Tree | 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(callback: string | ParseCallback, oldTree?: Tree | null, options?: ParseOptions): Tree | null;
+    /**
+     * Instruct the parser to start the next parse from the beginning.
+     *
+     * If the parser previously failed because of a timeout, cancellation,
+     * or callback, then by default, it will resume where it left off on the
+     * next call to {@link Parser#parse} or other parsing functions.
+     * If you don't want to resume, and instead intend to use this parser to
+     * parse some other document, you must call `reset` first.
+     */
+    reset(): void;
+    /** Get the ranges of text that the parser will include when parsing. */
+    getIncludedRanges(): any[];
+    /**
+     * @deprecated since version 0.25.0, prefer passing a progress callback to {@link Parser#parse}
+     *
+     * Get the duration in microseconds that parsing is allowed to take.
+     *
+     * This is set via {@link Parser#setTimeoutMicros}.
+     */
+    getTimeoutMicros(): any;
+    /**
+     * @deprecated since version 0.25.0, prefer passing a progress callback to {@link Parser#parse}
+     *
+     * Set the maximum duration in microseconds that parsing should be allowed
+     * to take before halting.
+     *
+     * If parsing takes longer than this, it will halt early, returning `null`.
+     * See {@link Parser#parse} for more information.
+     */
+    setTimeoutMicros(timeout: any): void;
+    /** Set the logging callback that a parser should use during parsing. */
+    setLogger(callback: any): this;
+    /** Get the parser's current logger. */
+    getLogger(): null;
+}
+import { Tree } from "./tree.js";
+//# sourceMappingURL=parser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../../src/deno-tree-sitter/main/tree_sitter/parser.js"],"names":[],"mappings":"AAMA;;;;;;;;;;GAUG;AACH;;;GAGG;AACH;;;;GAIG;AACH,gCAA0B;AAE1B;;;;;;;;GAQG;AACH,iCAA2B;AAE3B;;;GAGG;AACH,uCAAiC;AAEjC;;;GAGG;AACH;IAaI;;;;;OAKG;IACH,+CAKC;IAvBD,gBAAgB;IAChB,UAAQ;IAER,gBAAgB;IAChB,UAAO;IAEP,gBAAgB;IAChB,kBAAkB;IAElB,qCAAqC;IACrC,eAAe;IAsBf,gBAAgB;IAChB,mBAOC;IAED,gDAAgD;IAChD,eAKC;IAED;;;;;;;;OAQG;IACH,iCAkBC;IAED;;;;;;;;;;;;;;;OAeG;IACH,gBAbW,MAAM,GAAG,aAAa,YAEtB,IAAI,GAAG,IAAI,YAIX,YAAY,GAGV,IAAI,GAAG,IAAI,CAyDvB;IAED;;;;;;;;OAQG;IACH,cAEC;IAED,wEAAwE;IACxE,2BAgBC;IAED;;;;;;OAMG;IACH,wBAEC;IAED;;;;;;;;OAQG;IACH,qCAEC;IAED,wEAAwE;IACxE,+BASC;IAED,uCAAuC;IACvC,kBAEC;CACJ;qBA5QoB,WAAW"}

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

@@ -0,0 +1,272 @@
+import { C, INTERNAL, SIZE_OF_INT, SIZE_OF_RANGE, setModule } from "./constants.js";
+import { Language } from "./language.js";
+import { marshalRange, unmarshalRange } from "./marshal.js";
+import { checkModule, initializeBinding } from "./bindings.js";
+import { Tree } from "./tree.js";
+/**
+ * Options for parsing
+ *
+ * The `includedRanges` property is an array of {@link Range} objects that
+ * represent the ranges of text that the parser should include when parsing.
+ *
+ * The `progressCallback` property is a function that is called periodically
+ * during parsing to check whether parsing should be cancelled.
+ *
+ * See {@link Parser#parse} for more information.
+ */
+/**
+ * A stateful object that is passed into the progress callback {@link ParseOptions#progressCallback}
+ * to provide the current state of the parser.
+ */
+/**
+ * @internal
+ *
+ * Global variable for transferring data across the FFI boundary
+ */
+export let TRANSFER_BUFFER;
+/**
+ * The latest ABI version that is supported by the current version of the
+ * library.
+ *
+ * When Languages are generated by the Tree-sitter CLI, they are
+ * assigned an ABI version number that corresponds to the current CLI version.
+ * The Tree-sitter library is generally backwards-compatible with languages
+ * generated using older CLI versions, but is not forwards-compatible.
+ */
+export let LANGUAGE_VERSION;
+/**
+ * The earliest ABI version that is supported by the current version of the
+ * library.
+ */
+export let MIN_COMPATIBLE_VERSION;
+/**
+ * A stateful object that is used to produce a {@link Tree} based on some
+ * source code.
+ */
+export class Parser {
+    /**
+     * This must always be called before creating a Parser.
+     *
+     * You can optionally pass in options to configure the Wasm module, the most common
+     * one being `locateFile` to help the module find the `.wasm` file.
+     */
+    static async init(moduleOptions) {
+        setModule(await initializeBinding(moduleOptions));
+        TRANSFER_BUFFER = C._ts_init();
+        LANGUAGE_VERSION = C.getValue(TRANSFER_BUFFER, "i32");
+        MIN_COMPATIBLE_VERSION = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
+    }
+    /**
+     * Create a new parser.
+     */
+    constructor() {
+        /** @internal */
+        Object.defineProperty(this, 0, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        }); // Internal handle for Wasm
+        /** @internal */
+        Object.defineProperty(this, 1, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        }); // Internal handle for Wasm
+        /** @internal */
+        Object.defineProperty(this, "logCallback", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        /** The parser's current language. */
+        Object.defineProperty(this, "language", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        this.initialize();
+    }
+    /** @internal */
+    initialize() {
+        if (!checkModule()) {
+            throw new Error("cannot construct a Parser before calling `init()`");
+        }
+        C._ts_parser_new_wasm();
+        this[0] = C.getValue(TRANSFER_BUFFER, "i32");
+        this[1] = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
+    }
+    /** Delete the parser, freeing its resources. */
+    delete() {
+        C._ts_parser_delete(this[0]);
+        C._free(this[1]);
+        this[0] = 0;
+        this[1] = 0;
+    }
+    /**
+     * Set the language that the parser should use for parsing.
+     *
+     * If the language was not successfully assigned, an error will be thrown.
+     * This happens if the language was generated with an incompatible
+     * version of the Tree-sitter CLI. Check the language's version using
+     * {@link Language#version} and compare it to this library's
+     * {@link LANGUAGE_VERSION} and {@link MIN_COMPATIBLE_VERSION} constants.
+     */
+    setLanguage(language) {
+        let address;
+        if (!language) {
+            address = 0;
+            this.language = null;
+        }
+        else if (language.constructor === Language) {
+            address = language[0];
+            const version = C._ts_language_version(address);
+            if (version < MIN_COMPATIBLE_VERSION || LANGUAGE_VERSION < version) {
+                throw new Error(`Incompatible language version ${version}. ` + `Compatibility range ${MIN_COMPATIBLE_VERSION} through ${LANGUAGE_VERSION}.`);
+            }
+            this.language = language;
+        }
+        else {
+            throw new Error("Argument must be a Language");
+        }
+        C._ts_parser_set_language(this[0], address);
+        return this;
+    }
+    /**
+     * Parse a slice of UTF8 text.
+     *
+     * @param {string | ParseCallback} callback - The UTF8-encoded text to parse or a callback function.
+     *
+     * @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 {Tree | 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(callback, oldTree, options) {
+        if (typeof callback === "string") {
+            C.currentParseCallback = (index) => callback.slice(index);
+        }
+        else if (typeof callback === "function") {
+            C.currentParseCallback = callback;
+        }
+        else {
+            throw new Error("Argument must be a string or a function");
+        }
+        if (options?.progressCallback) {
+            C.currentProgressCallback = options.progressCallback;
+        }
+        else {
+            C.currentProgressCallback = null;
+        }
+        if (this.logCallback) {
+            C.currentLogCallback = this.logCallback;
+            C._ts_parser_enable_logger_wasm(this[0], 1);
+        }
+        else {
+            C.currentLogCallback = null;
+            C._ts_parser_enable_logger_wasm(this[0], 0);
+        }
+        let rangeCount = 0;
+        let rangeAddress = 0;
+        if (options?.includedRanges) {
+            rangeCount = options.includedRanges.length;
+            rangeAddress = C._calloc(rangeCount, SIZE_OF_RANGE);
+            let address = rangeAddress;
+            for (let i = 0; i < rangeCount; i++) {
+                marshalRange(address, options.includedRanges[i]);
+                address += SIZE_OF_RANGE;
+            }
+        }
+        const treeAddress = C._ts_parser_parse_wasm(this[0], this[1], oldTree ? oldTree[0] : 0, rangeAddress, rangeCount);
+        if (!treeAddress) {
+            C.currentParseCallback = null;
+            C.currentLogCallback = null;
+            C.currentProgressCallback = null;
+            return null;
+        }
+        if (!this.language) {
+            throw new Error("Parser must have a language to parse");
+        }
+        const result = new Tree(INTERNAL, treeAddress, this.language, C.currentParseCallback);
+        C.currentParseCallback = null;
+        C.currentLogCallback = null;
+        C.currentProgressCallback = null;
+        return result;
+    }
+    /**
+     * Instruct the parser to start the next parse from the beginning.
+     *
+     * If the parser previously failed because of a timeout, cancellation,
+     * or callback, then by default, it will resume where it left off on the
+     * next call to {@link Parser#parse} or other parsing functions.
+     * If you don't want to resume, and instead intend to use this parser to
+     * parse some other document, you must call `reset` first.
+     */
+    reset() {
+        C._ts_parser_reset(this[0]);
+    }
+    /** Get the ranges of text that the parser will include when parsing. */
+    getIncludedRanges() {
+        C._ts_parser_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;
+    }
+    /**
+     * @deprecated since version 0.25.0, prefer passing a progress callback to {@link Parser#parse}
+     *
+     * Get the duration in microseconds that parsing is allowed to take.
+     *
+     * This is set via {@link Parser#setTimeoutMicros}.
+     */
+    getTimeoutMicros() {
+        return C._ts_parser_timeout_micros(this[0]);
+    }
+    /**
+     * @deprecated since version 0.25.0, prefer passing a progress callback to {@link Parser#parse}
+     *
+     * Set the maximum duration in microseconds that parsing should be allowed
+     * to take before halting.
+     *
+     * If parsing takes longer than this, it will halt early, returning `null`.
+     * See {@link Parser#parse} for more information.
+     */
+    setTimeoutMicros(timeout) {
+        C._ts_parser_set_timeout_micros(this[0], 0, timeout);
+    }
+    /** Set the logging callback that a parser should use during parsing. */
+    setLogger(callback) {
+        if (!callback) {
+            this.logCallback = null;
+        }
+        else if (typeof callback !== "function") {
+            throw new Error("Logger callback must be a function");
+        }
+        else {
+            this.logCallback = callback;
+        }
+        return this;
+    }
+    /** Get the parser's current logger. */
+    getLogger() {
+        return this.logCallback;
+    }
+}

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

@@ -0,0 +1,134 @@
+export namespace CaptureQuantifier {
+    let Zero: number;
+    let ZeroOrOne: number;
+    let ZeroOrMore: number;
+    let One: number;
+    let OneOrMore: number;
+}
+export namespace QueryErrorKind {
+    let Syntax: number;
+    let NodeName: number;
+    let FieldName: number;
+    let CaptureName: number;
+    let PatternStructure: number;
+}
+/** An error that occurred while parsing a query string. */
+/** Information about a {@link QueryError}. */
+/** Error thrown when parsing a tree-sitter query fails */
+export class QueryError extends Error {
+    /** Formats an error message based on the error kind and info */
+    static formatMessage(kind: any, info: any): string | undefined;
+    constructor(kind: any, info: any, index: any, length: any);
+}
+export class Query {
+    /**
+     * 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}
+     */
+    constructor(language: any, source: any);
+    /** @internal */
+    0: number;
+    /** @internal */
+    exceededMatchLimit: boolean;
+    /** @internal */
+    textPredicates: any[];
+    /** The names of the captures used in the query. */
+    captureNames: any[];
+    /** The quantifiers of the captures used in the query. */
+    captureQuantifiers: any[];
+    /**
+     * The other user-defined predicates associated with the given index.
+     *
+     * This includes predicates with operators other than:
+     * - `match?`
+     * - `eq?` and `not-eq?`
+     * - `any-of?` and `not-any-of?`
+     * - `is?` and `is-not?`
+     * - `set!`
+     */
+    predicates: any[];
+    /** The properties for predicates with the operator `set!`. */
+    setProperties: any[];
+    /** The properties for predicates with the operator `is?`. */
+    assertedProperties: any[];
+    /** The properties for predicates with the operator `is-not?`. */
+    refutedProperties: any[];
+    /** The maximum number of in-progress matches for this cursor. */
+    matchLimit: any;
+    /** Delete the query, freeing its resources. */
+    delete(): void;
+    /**
+     * Iterate over all of the matches in the order that they were found.
+     *
+     * Each match contains the index of the pattern that matched, and a list of
+     * captures. Because multiple patterns can match the same set of nodes,
+     * one match may contain captures that appear *before* some of the
+     * captures from a previous match.
+     *
+     * @param {Node} node - The node to execute the query on.
+     *
+     * @param {QueryOptions} options - Options for query execution.
+     */
+    matches(node: Node, options?: QueryOptions): any[];
+    /**
+     * Iterate over all of the individual captures in the order that they
+     * appear.
+     *
+     * This is useful if you don't care about which pattern matched, and just
+     * want a single, ordered sequence of captures.
+     *
+     * @param {Node} node - The node to execute the query on.
+     *
+     * @param {QueryOptions} options - Options for query execution.
+     */
+    captures(node: Node, options?: QueryOptions): any[];
+    /** Get the predicates for a given pattern. */
+    predicatesForPattern(patternIndex: any): any;
+    /**
+     * Disable a certain capture within a query.
+     *
+     * This prevents the capture from being returned in matches, and also
+     * avoids any resource usage associated with recording the capture.
+     */
+    disableCapture(captureName: any): void;
+    /**
+     * Disable a certain pattern within a query.
+     *
+     * This prevents the pattern from matching, and also avoids any resource
+     * usage associated with the pattern. This throws an error if the pattern
+     * index is out of bounds.
+     */
+    disablePattern(patternIndex: any): void;
+    /**
+     * Check if, on its last execution, this cursor exceeded its maximum number
+     * of in-progress matches.
+     */
+    didExceedMatchLimit(): boolean;
+    /** Get the byte offset where the given pattern starts in the query's source. */
+    startIndexForPattern(patternIndex: any): any;
+    /** Get the byte offset where the given pattern ends in the query's source. */
+    endIndexForPattern(patternIndex: any): any;
+    /** Get the number of patterns in the query. */
+    patternCount(): any;
+    /** Get the index for a given capture name. */
+    captureIndexForName(captureName: any): number;
+    /** Check if a given pattern within a query has a single root node. */
+    isPatternRooted(patternIndex: any): boolean;
+    /** Check if a given pattern within a query has a single root node. */
+    isPatternNonLocal(patternIndex: any): boolean;
+    /**
+     * Check if a given step in a query is 'definite'.
+     *
+     * A query step is 'definite' if its parent pattern will be guaranteed to
+     * match successfully once it reaches the step.
+     */
+    isPatternGuaranteedAtStep(byteIndex: any): boolean;
+}
+import { Node } from "./node.js";
+//# sourceMappingURL=query.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../../src/deno-tree-sitter/main/tree_sitter/query.js"],"names":[],"mappings":";;;;;;;;;;;;;;AA+EA,2DAA2D;AAC3D,8CAA8C;AAC9C,0DAA0D;AAC1D;IAMI,gEAAgE;IAChE,+DAaC;IAnBD,2DAGC;CAiBJ;AAqMD;IAwCI;;;;;;;;;OASG;IACH,wCAwGC;IAzJD,gBAAgB;IAChB,UAAO;IAEP,gBAAgB;IAChB,4BAAkB;IAElB,gBAAgB;IAChB,sBAAc;IAEd,mDAAmD;IACnD,oBAAY;IAEZ,yDAAyD;IACzD,0BAAkB;IAElB;;;;;;;;;OASG;IACH,kBAAU;IAEV,8DAA8D;IAC9D,qBAAa;IAEb,6DAA6D;IAC7D,0BAAkB;IAElB,iEAAiE;IACjE,yBAAiB;IAEjB,iEAAiE;IACjE,gBAAU;IAsHV,+CAA+C;IAC/C,eAGC;IAED;;;;;;;;;;;OAWG;IACH,cAJW,IAAI,YAEJ,YAAY,SAkEtB;IAED;;;;;;;;;;OAUG;IACH,eAJW,IAAI,YAEJ,YAAY,SAmEtB;IAED,8CAA8C;IAC9C,6CAEC;IAED;;;;;OAKG;IACH,uCAMC;IAED;;;;;;OAMG;IACH,wCAKC;IAED;;;OAGG;IACH,+BAEC;IAED,gFAAgF;IAChF,6CAKC;IAED,8EAA8E;IAC9E,2CAKC;IAED,+CAA+C;IAC/C,oBAEC;IAED,8CAA8C;IAC9C,8CAEC;IAED,sEAAsE;IACtE,4CAEC;IAED,sEAAsE;IACtE,8CAEC;IAED;;;;;OAKG;IACH,mDAEC;CACJ;qBA/rBoB,WAAW"}