@kerebron/tree-sitter 0.5.4 → 0.6.0

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

@@ -1,32 +0,0 @@
-import { BaseNode } from "./base_node.js"
-
-// HardNode extends BaseNode as well (indirectly)
-export class SoftNode extends BaseNode {
-    children = []
-    constructor(data) {
-        super(data)
-    }
-    
-    // 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/src/deno-tree-sitter/main/extended/soft_text_node.js

@@ -1,11 +0,0 @@
-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/src/deno-tree-sitter/main/extended/whitespace_node.js

@@ -1,11 +0,0 @@
-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/src/deno-tree-sitter/main/extras/misc.js

@@ -1,12 +0,0 @@
-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/src/deno-tree-sitter/main/tree_sitter/bindings.js

@@ -1,26 +0,0 @@
-import createModule from "../wasm_loader_with_defaults.js"
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-import {} from "./parser.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/src/deno-tree-sitter/main/tree_sitter/constants.js

@@ -1,79 +0,0 @@
-import {} from "../wasm_loader_with_defaults.js"
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-import {} from "./parser.js"
-
-/**
- * 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/src/deno-tree-sitter/main/tree_sitter/language.js

@@ -1,289 +0,0 @@
-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 {
-    major_version
-    minor_version
-    patch_version
-}
-
-/**
- * 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 */
-    [0] = 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.
-     */
-    types
-
-    /**
-     * A list of all field names in the language. The index of each field name in
-     * this array is its field id.
-     */
-    fields
-
-    /** @internal */
-    constructor(internal, address) {
-        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/src/deno-tree-sitter/main/tree_sitter/lookahead_iterator.js

@@ -1,74 +0,0 @@
-import { C, assertInternal } from "./constants.js"
-import { Language } from "./language.js"
-
-export class LookaheadIterator {
-    /** @internal */
-    [0] = 0 // Internal handle for Wasm
-
-    /** @internal */
-    language
-
-    /** @internal */
-    constructor(internal, address, language) {
-        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: "" }
-            },
-        }
-    }
-}