@kerebron/tree-sitter 0.4.6

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

@@ -0,0 +1,296 @@
+import { C, INTERNAL, assertInternal, SIZE_OF_INT, SIZE_OF_SHORT } from "./constants.js";
+import { LookaheadIterator } from "./lookahead_iterator.js";
+import { unmarshalLanguageMetadata } from "./marshal.js";
+import { TRANSFER_BUFFER } from "./parser.js";
+import { Query } from "./query.js";
+const LANGUAGE_FUNCTION_REGEX = /^tree_sitter_\w+$/;
+export class LanguageMetadata {
+    constructor() {
+        Object.defineProperty(this, "major_version", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "minor_version", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "patch_version", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+    }
+}
+/**
+ * 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 {
+    /** @internal */
+    constructor(internal, address) {
+        /** @internal */
+        Object.defineProperty(this, 0, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        }); // Internal handle for Wasm
+        /**
+         * A list of all node types in the language. The index of each type in this
+         * array is its node type id.
+         */
+        Object.defineProperty(this, "types", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * A list of all field names in the language. The index of each field name in
+         * this array is its field id.
+         */
+        Object.defineProperty(this, "fields", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        assertInternal(internal);
+        this[0] = address;
+        this.types = new Array(C._ts_language_symbol_count(this[0]));
+        for (let i = 0, n = this.types.length; i < n; i++) {
+            if (C._ts_language_symbol_type(this[0], i) < 2) {
+                this.types[i] = C.UTF8ToString(C._ts_language_symbol_name(this[0], i));
+            }
+        }
+        this.fields = new Array(C._ts_language_field_count(this[0]) + 1);
+        for (let i = 0, n = this.fields.length; i < n; i++) {
+            const fieldName = C._ts_language_field_name_for_id(this[0], i);
+            if (fieldName !== 0) {
+                this.fields[i] = C.UTF8ToString(fieldName);
+            }
+            else {
+                this.fields[i] = null;
+            }
+        }
+    }
+    /**
+     * Gets the name of the language.
+     */
+    get name() {
+        const ptr = C._ts_language_name(this[0]);
+        if (ptr === 0)
+            return null;
+        return C.UTF8ToString(ptr);
+    }
+    /**
+     * @deprecated since version 0.25.0, use {@link Language#abiVersion} instead
+     * Gets the version of the language.
+     */
+    get version() {
+        return C._ts_language_version(this[0]);
+    }
+    /**
+     * Gets the ABI version of the language.
+     */
+    get abiVersion() {
+        return C._ts_language_abi_version(this[0]);
+    }
+    /**
+     * 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() {
+        C._ts_language_metadata(this[0]);
+        const length = C.getValue(TRANSFER_BUFFER, "i32");
+        const address = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
+        if (length === 0)
+            return null;
+        return unmarshalLanguageMetadata(address);
+    }
+    /**
+     * Gets the number of fields in the language.
+     */
+    get fieldCount() {
+        return this.fields.length - 1;
+    }
+    /**
+     * Gets the number of states in the language.
+     */
+    get stateCount() {
+        return C._ts_language_state_count(this[0]);
+    }
+    /**
+     * Get the field id for a field name.
+     */
+    fieldIdForName(fieldName) {
+        const result = this.fields.indexOf(fieldName);
+        return result !== -1 ? result : null;
+    }
+    /**
+     * Get the field name for a field id.
+     */
+    fieldNameForId(fieldId) {
+        return this.fields[fieldId] ?? null;
+    }
+    /**
+     * Get the node type id for a node type name.
+     */
+    idForNodeType(type, named) {
+        const typeLength = C.lengthBytesUTF8(type);
+        const typeAddress = C._malloc(typeLength + 1);
+        C.stringToUTF8(type, typeAddress, typeLength + 1);
+        const result = C._ts_language_symbol_for_name(this[0], typeAddress, typeLength, named ? 1 : 0);
+        C._free(typeAddress);
+        return result || null;
+    }
+    /**
+     * Gets the number of node types in the language.
+     */
+    get nodeTypeCount() {
+        return C._ts_language_symbol_count(this[0]);
+    }
+    /**
+     * Get the node type name for a node type id.
+     */
+    nodeTypeForId(typeId) {
+        const name = C._ts_language_symbol_name(this[0], typeId);
+        return name ? C.UTF8ToString(name) : null;
+    }
+    /**
+     * 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) {
+        return C._ts_language_type_is_named_wasm(this[0], typeId) ? true : false;
+    }
+    /**
+     * Check if a node type is visible.
+     */
+    nodeTypeIsVisible(typeId) {
+        return C._ts_language_type_is_visible_wasm(this[0], typeId) ? true : false;
+    }
+    /**
+     * 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() {
+        C._ts_language_supertypes_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] = C.getValue(address, "i16");
+                address += SIZE_OF_SHORT;
+            }
+        }
+        return result;
+    }
+    /**
+     * Get the subtype ids for a given supertype node id.
+     */
+    subtypes(supertype) {
+        C._ts_language_subtypes_wasm(this[0], supertype);
+        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] = C.getValue(address, "i16");
+                address += SIZE_OF_SHORT;
+            }
+        }
+        return result;
+    }
+    /**
+     * Get the next state id for a given state id and node type id.
+     */
+    nextState(stateId, typeId) {
+        return C._ts_language_next_state(this[0], stateId, typeId);
+    }
+    /**
+     * 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) {
+        const address = C._ts_lookahead_iterator_new(this[0], stateId);
+        if (address)
+            return new LookaheadIterator(INTERNAL, address, this);
+        return 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) {
+        console.warn("Language.query is deprecated. Use new Query(language, source) instead.");
+        return new Query(this, source);
+    }
+    /**
+     * Load a language from a WebAssembly module.
+     * The module can be provided as a path to a file or as a buffer.
+     */
+    static async load(input) {
+        let bytes;
+        if (input instanceof Uint8Array) {
+            bytes = Promise.resolve(input);
+        }
+        else {
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (globalThis.process?.versions.node) {
+                const fs = await import("node:fs/promises");
+                bytes = fs.readFile(input);
+            }
+            else {
+                bytes = fetch(input).then((response) => response.arrayBuffer().then((buffer) => {
+                    if (response.ok) {
+                        return new Uint8Array(buffer);
+                    }
+                    else {
+                        const body = new TextDecoder("utf-8").decode(buffer);
+                        throw new Error(`Language.load failed with status ${response.status}.\n\n${body}`);
+                    }
+                }));
+            }
+        }
+        const mod = await C.loadWebAssemblyModule(await bytes, { loadAsync: true });
+        const symbolNames = Object.keys(mod);
+        const functionName = symbolNames.find((key) => LANGUAGE_FUNCTION_REGEX.test(key) && !key.includes("external_scanner_"));
+        if (!functionName) {
+            console.log(`Couldn't find language function in Wasm file. Symbols:\n${JSON.stringify(symbolNames, null, 2)}`);
+            throw new Error("Language.load failed: no language function found in Wasm file");
+        }
+        const languageAddress = mod[functionName]();
+        return new Language(INTERNAL, languageAddress);
+    }
+}

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

@@ -0,0 +1,41 @@
+export class LookaheadIterator {
+    /** @internal */
+    constructor(internal: any, address: any, language: any);
+    /** @internal */
+    0: number;
+    /** @internal */
+    language: any;
+    /** Get the current symbol of the lookahead iterator. */
+    get currentTypeId(): any;
+    /** Get the current symbol name of the lookahead iterator. */
+    get currentType(): any;
+    /** Delete the lookahead iterator, freeing its resources. */
+    delete(): void;
+    /**
+     * Reset the lookahead iterator.
+     *
+     * This returns `true` if the language was set successfully and `false`
+     * otherwise.
+     */
+    reset(language: any, stateId: any): boolean;
+    /**
+     * Reset the lookahead iterator to another state.
+     *
+     * This returns `true` if the iterator was reset to the given state and
+     * `false` otherwise.
+     */
+    resetState(stateId: any): boolean;
+    /**
+     * Returns an iterator that iterates over the symbols of the lookahead iterator.
+     *
+     * The iterator will yield the current symbol name as a string for each step
+     * until there are no more symbols to iterate over.
+     */
+    [Symbol.iterator](): {
+        next: () => {
+            done: boolean;
+            value: any;
+        };
+    };
+}
+//# sourceMappingURL=lookahead_iterator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lookahead_iterator.d.ts","sourceRoot":"","sources":["../../../../src/deno-tree-sitter/main/tree_sitter/lookahead_iterator.js"],"names":[],"mappings":"AAGA;IAOI,gBAAgB;IAChB,wDAIC;IAXD,gBAAgB;IAChB,UAAO;IAEP,gBAAgB;IAChB,cAAQ;IASR,wDAAwD;IACxD,yBAEC;IAED,6DAA6D;IAC7D,uBAEC;IAED,4DAA4D;IAC5D,eAGC;IAED;;;;;OAKG;IACH,4CAMC;IAED;;;;;OAKG;IACH,kCAEC;IAED;;;;;OAKG;IACH;;;;;MASC;CACJ"}

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

@@ -0,0 +1,75 @@
+import { C, assertInternal } from "./constants.js";
+import { Language } from "./language.js";
+export class LookaheadIterator {
+    /** @internal */
+    constructor(internal, address, language) {
+        /** @internal */
+        Object.defineProperty(this, 0, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        }); // Internal handle for Wasm
+        /** @internal */
+        Object.defineProperty(this, "language", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        assertInternal(internal);
+        this[0] = address;
+        this.language = language;
+    }
+    /** Get the current symbol of the lookahead iterator. */
+    get currentTypeId() {
+        return C._ts_lookahead_iterator_current_symbol(this[0]);
+    }
+    /** Get the current symbol name of the lookahead iterator. */
+    get currentType() {
+        return this.language.types[this.currentTypeId] || "ERROR";
+    }
+    /** Delete the lookahead iterator, freeing its resources. */
+    delete() {
+        C._ts_lookahead_iterator_delete(this[0]);
+        this[0] = 0;
+    }
+    /**
+     * Reset the lookahead iterator.
+     *
+     * This returns `true` if the language was set successfully and `false`
+     * otherwise.
+     */
+    reset(language, stateId) {
+        if (C._ts_lookahead_iterator_reset(this[0], language[0], stateId)) {
+            this.language = language;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Reset the lookahead iterator to another state.
+     *
+     * This returns `true` if the iterator was reset to the given state and
+     * `false` otherwise.
+     */
+    resetState(stateId) {
+        return Boolean(C._ts_lookahead_iterator_reset_state(this[0], stateId));
+    }
+    /**
+     * Returns an iterator that iterates over the symbols of the lookahead iterator.
+     *
+     * The iterator will yield the current symbol name as a string for each step
+     * until there are no more symbols to iterate over.
+     */
+    [Symbol.iterator]() {
+        return {
+            next: () => {
+                if (C._ts_lookahead_iterator_next(this[0])) {
+                    return { done: false, value: this.currentType };
+                }
+                return { done: true, value: "" };
+            },
+        };
+    }
+}

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

@@ -0,0 +1,85 @@
+/**
+ * @internal
+ *
+ * Unmarshals a {@link QueryMatch} to the transfer buffer.
+ */
+export function unmarshalCaptures(query: any, tree: any, address: any, patternIndex: any, result: any): any;
+/**
+ * @internal
+ *
+ * Marshals a {@link Node} to the transfer buffer.
+ */
+export function marshalNode(node: any, index?: number): void;
+/**
+ * @internal
+ *
+ * Unmarshals a {@link Node} from the transfer buffer.
+ */
+export function unmarshalNode(tree: any, address?: any): any;
+/**
+ * @internal
+ *
+ * Marshals a {@link TreeCursor} to the transfer buffer.
+ */
+export function marshalTreeCursor(cursor: any, address?: any): void;
+/**
+ * @internal
+ *
+ * Unmarshals a {@link TreeCursor} from the transfer buffer.
+ */
+export function unmarshalTreeCursor(cursor: any): void;
+/**
+ * @internal
+ *
+ * Marshals a {@link Point} to the transfer buffer.
+ */
+export function marshalPoint(address: any, point: any): void;
+/**
+ * @internal
+ *
+ * Unmarshals a {@link Point} from the transfer buffer.
+ */
+export function unmarshalPoint(address: any): {
+    row: number;
+    column: number;
+};
+/**
+ * @internal
+ *
+ * Marshals a {@link Range} to the transfer buffer.
+ */
+export function marshalRange(address: any, range: any): void;
+/**
+ * @internal
+ *
+ * Unmarshals a {@link Range} from the transfer buffer.
+ */
+export function unmarshalRange(address: any): {
+    startPosition: {
+        row: number;
+        column: number;
+    };
+    endPosition: {
+        row: number;
+        column: number;
+    };
+    startIndex: number;
+    endIndex: number;
+};
+/**
+ * @internal
+ *
+ * Marshals an {@link Edit} to the transfer buffer.
+ */
+export function marshalEdit(edit: any, address?: any): void;
+/**
+ * @internal
+ *
+ * Unmarshals a {@link LanguageMetadata} from the transfer buffer.
+ */
+export function unmarshalLanguageMetadata(address: any): {
+    major_version: any;
+    minor_version: any;
+    field_count: any;
+};
+//# sourceMappingURL=marshal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"marshal.d.ts","sourceRoot":"","sources":["../../../../src/deno-tree-sitter/main/tree_sitter/marshal.js"],"names":[],"mappings":"AASA;;;;GAIG;AACH,4GASC;AAED;;;;GAIG;AACH,6DAWC;AAED;;;;GAIG;AACH,6DAsBC;AAED;;;;GAIG;AACH,oEAKC;AAED;;;;GAIG;AACH,uDAKC;AAED;;;;GAIG;AACH,6DAGC;AAED;;;;GAIG;AACH;;;EAMC;AAED;;;;GAIG;AACH,6DASC;AAED;;;;GAIG;AACH;;;;;;;;;;;EAUC;AAED;;;;GAIG;AACH,4DAaC;AAED;;;;GAIG;AACH;;;;EAQC"}

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

@@ -0,0 +1,173 @@
+import { INTERNAL, SIZE_OF_INT, SIZE_OF_NODE, SIZE_OF_POINT, C } from "./constants.js";
+import { Node } from "./node.js";
+import { Tree } from "./tree.js";
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import { Query } from "./query.js";
+import { TreeCursor } from "./tree_cursor.js";
+import { TRANSFER_BUFFER } from "./parser.js";
+import { LanguageMetadata } from "./language.js";
+/**
+ * @internal
+ *
+ * Unmarshals a {@link QueryMatch} to the transfer buffer.
+ */
+export function unmarshalCaptures(query, tree, address, patternIndex, result) {
+    for (let i = 0, n = result.length; i < n; i++) {
+        const captureIndex = C.getValue(address, "i32");
+        address += SIZE_OF_INT;
+        const node = unmarshalNode(tree, address);
+        address += SIZE_OF_NODE;
+        result[i] = { patternIndex, name: query.captureNames[captureIndex], node };
+    }
+    return address;
+}
+/**
+ * @internal
+ *
+ * Marshals a {@link Node} to the transfer buffer.
+ */
+export function marshalNode(node, index = 0) {
+    let address = TRANSFER_BUFFER + index * SIZE_OF_NODE;
+    C.setValue(address, node.id, "i32");
+    address += SIZE_OF_INT;
+    C.setValue(address, node.startIndex, "i32");
+    address += SIZE_OF_INT;
+    C.setValue(address, node.startPosition.row, "i32");
+    address += SIZE_OF_INT;
+    C.setValue(address, node.startPosition.column, "i32");
+    address += SIZE_OF_INT;
+    C.setValue(address, node[0], "i32");
+}
+/**
+ * @internal
+ *
+ * Unmarshals a {@link Node} from the transfer buffer.
+ */
+export function unmarshalNode(tree, address = TRANSFER_BUFFER) {
+    const id = C.getValue(address, "i32");
+    address += SIZE_OF_INT;
+    if (id === 0)
+        return null;
+    const index = C.getValue(address, "i32");
+    address += SIZE_OF_INT;
+    const row = C.getValue(address, "i32");
+    address += SIZE_OF_INT;
+    const column = C.getValue(address, "i32");
+    address += SIZE_OF_INT;
+    const other = C.getValue(address, "i32");
+    const result = new Node(INTERNAL, {
+        id,
+        tree,
+        startIndex: index,
+        startPosition: { row, column },
+        other,
+    });
+    return result;
+}
+/**
+ * @internal
+ *
+ * Marshals a {@link TreeCursor} to the transfer buffer.
+ */
+export function marshalTreeCursor(cursor, address = TRANSFER_BUFFER) {
+    C.setValue(address + 0 * SIZE_OF_INT, cursor[0], "i32");
+    C.setValue(address + 1 * SIZE_OF_INT, cursor[1], "i32");
+    C.setValue(address + 2 * SIZE_OF_INT, cursor[2], "i32");
+    C.setValue(address + 3 * SIZE_OF_INT, cursor[3], "i32");
+}
+/**
+ * @internal
+ *
+ * Unmarshals a {@link TreeCursor} from the transfer buffer.
+ */
+export function unmarshalTreeCursor(cursor) {
+    cursor[0] = C.getValue(TRANSFER_BUFFER + 0 * SIZE_OF_INT, "i32");
+    cursor[1] = C.getValue(TRANSFER_BUFFER + 1 * SIZE_OF_INT, "i32");
+    cursor[2] = C.getValue(TRANSFER_BUFFER + 2 * SIZE_OF_INT, "i32");
+    cursor[3] = C.getValue(TRANSFER_BUFFER + 3 * SIZE_OF_INT, "i32");
+}
+/**
+ * @internal
+ *
+ * Marshals a {@link Point} to the transfer buffer.
+ */
+export function marshalPoint(address, point) {
+    C.setValue(address, point.row, "i32");
+    C.setValue(address + SIZE_OF_INT, point.column, "i32");
+}
+/**
+ * @internal
+ *
+ * Unmarshals a {@link Point} from the transfer buffer.
+ */
+export function unmarshalPoint(address) {
+    const result = {
+        row: C.getValue(address, "i32") >>> 0,
+        column: C.getValue(address + SIZE_OF_INT, "i32") >>> 0,
+    };
+    return result;
+}
+/**
+ * @internal
+ *
+ * Marshals a {@link Range} to the transfer buffer.
+ */
+export function marshalRange(address, range) {
+    marshalPoint(address, range.startPosition);
+    address += SIZE_OF_POINT;
+    marshalPoint(address, range.endPosition);
+    address += SIZE_OF_POINT;
+    C.setValue(address, range.startIndex, "i32");
+    address += SIZE_OF_INT;
+    C.setValue(address, range.endIndex, "i32");
+    address += SIZE_OF_INT;
+}
+/**
+ * @internal
+ *
+ * Unmarshals a {@link Range} from the transfer buffer.
+ */
+export function unmarshalRange(address) {
+    const result = {};
+    result.startPosition = unmarshalPoint(address);
+    address += SIZE_OF_POINT;
+    result.endPosition = unmarshalPoint(address);
+    address += SIZE_OF_POINT;
+    result.startIndex = C.getValue(address, "i32") >>> 0;
+    address += SIZE_OF_INT;
+    result.endIndex = C.getValue(address, "i32") >>> 0;
+    return result;
+}
+/**
+ * @internal
+ *
+ * Marshals an {@link Edit} to the transfer buffer.
+ */
+export function marshalEdit(edit, address = TRANSFER_BUFFER) {
+    marshalPoint(address, edit.startPosition);
+    address += SIZE_OF_POINT;
+    marshalPoint(address, edit.oldEndPosition);
+    address += SIZE_OF_POINT;
+    marshalPoint(address, edit.newEndPosition);
+    address += SIZE_OF_POINT;
+    C.setValue(address, edit.startIndex, "i32");
+    address += SIZE_OF_INT;
+    C.setValue(address, edit.oldEndIndex, "i32");
+    address += SIZE_OF_INT;
+    C.setValue(address, edit.newEndIndex, "i32");
+    address += SIZE_OF_INT;
+}
+/**
+ * @internal
+ *
+ * Unmarshals a {@link LanguageMetadata} from the transfer buffer.
+ */
+export function unmarshalLanguageMetadata(address) {
+    const result = {};
+    result.major_version = C.getValue(address, "i32");
+    address += SIZE_OF_INT;
+    result.minor_version = C.getValue(address, "i32");
+    address += SIZE_OF_INT;
+    result.field_count = C.getValue(address, "i32");
+    return result;
+}