@mrclrchtr/supi-code-intelligence 1.7.0 → 1.9.0

package/node_modules/@mrclrchtr/supi-tree-sitter/node_modules/web-tree-sitter/web-tree-sitter.d.cts

@@ -1,1025 +0,0 @@
-declare module 'web-tree-sitter' {
-	/**
-	 * A position in a multi-line text document, in terms of rows and columns.
-	 *
-	 * Rows and columns are zero-based.
-	 */
-	export interface Point {
-		/** The zero-based row number. */
-		row: number;
-		/** The zero-based column number. */
-		column: number;
-	}
-	/**
-	 *  A range of positions in a multi-line text document, both in terms of bytes
-	 *  and of rows and columns.
-	 */
-	export interface Range {
-		/** The start position of the range. */
-		startPosition: Point;
-		/** The end position of the range. */
-		endPosition: Point;
-		/** The start index of the range. */
-		startIndex: number;
-		/** The end index of the range. */
-		endIndex: number;
-	}
-	/**
-	 * A callback for parsing that takes an index and point, and should return a string.
-	 */
-	export type ParseCallback = (index: number, position: Point) => string | undefined;
-	/**
-	 * A callback that receives the parse state during parsing.
-	 */
-	export type ProgressCallback = (progress: ParseState) => boolean;
-	/**
-	 * A callback for logging messages.
-	 *
-	 * If `isLex` is `true`, the message is from the lexer, otherwise it's from the parser.
-	 */
-	export type LogCallback = (message: string, isLex: boolean) => void;
-	export class Edit {
-		/** The start position of the change. */
-		startPosition: Point;
-		/** The end position of the change before the edit. */
-		oldEndPosition: Point;
-		/** The end position of the change after the edit. */
-		newEndPosition: Point;
-		/** The start index of the change. */
-		startIndex: number;
-		/** The end index of the change before the edit. */
-		oldEndIndex: number;
-		/** The end index of the change after the edit. */
-		newEndIndex: number;
-		constructor({ startIndex, oldEndIndex, newEndIndex, startPosition, oldEndPosition, newEndPosition, }: {
-			startIndex: number;
-			oldEndIndex: number;
-			newEndIndex: number;
-			startPosition: Point;
-			oldEndPosition: Point;
-			newEndPosition: Point;
-		});
-		/**
-		 * Edit a point and index to keep it in-sync with source code that has been edited.
-		 *
-		 * This function updates a single point's byte offset and row/column position
-		 * based on an edit operation. This is useful for editing points without
-		 * requiring a tree or node instance.
-		 */
-		editPoint(point: Point, index: number): {
-			point: Point;
-			index: number;
-		};
-		/**
-		 * Edit a range to keep it in-sync with source code that has been edited.
-		 *
-		 * This function updates a range's start and end positions based on an edit
-		 * operation. This is useful for editing ranges without requiring a tree
-		 * or node instance.
-		 */
-		editRange(range: Range): Range;
-	}
-	/**
-	 * 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.
-	 */
-	export interface ParseOptions {
-		/**
-		 * An array of {@link Range} objects that
-		 * represent the ranges of text that the parser should include when parsing.
-		 *
-		 * This sets the ranges of text that the parser should include when parsing.
-		 * By default, the parser will always include entire documents. This
-		 * function allows you to parse only a *portion* of a document but
-		 * still return a syntax tree whose ranges match up with the document
-		 * as a whole. You can also pass multiple disjoint ranges.
-		 * If `ranges` is empty, then the entire document will be parsed.
-		 * Otherwise, the given ranges must be ordered from earliest to latest
-		 * in the document, and they must not overlap. That is, the following
-		 * must hold for all `i` < `length - 1`:
-		 * ```text
-		 *     ranges[i].end_byte <= ranges[i + 1].start_byte
-		 * ```
-		 */
-		includedRanges?: Range[];
-		/**
-		 * A function that is called periodically during parsing to check
-		 * whether parsing should be cancelled. If the progress callback returns
-		 * `true`, then parsing will be cancelled. You can also use this to instrument
-		 * parsing and check where the parser is at in the document. The progress callback
-		 * takes a single argument, which is a {@link ParseState} representing the current
-		 * state of the parser.
-		 */
-		progressCallback?: (state: ParseState) => void;
-	}
-	/**
-	 * A stateful object that is passed into the progress callback {@link ParseOptions#progressCallback}
-	 * to provide the current state of the parser.
-	 */
-	export interface ParseState {
-		/** The byte offset in the document that the parser is at. */
-		currentOffset: number;
-		/** Indicates whether the parser has encountered an error during parsing. */
-		hasError: boolean;
-	}
-	/**
-	 * 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: number;
-	/**
-	 * The earliest ABI version that is supported by the current version of the
-	 * library.
-	 */
-	export let MIN_COMPATIBLE_VERSION: number;
-	/**
-	 * A stateful object that is used to produce a {@link Tree} based on some
-	 * source code.
-	 */
-	export class Parser {
-		/** The parser's current language. */
-		language: Language | null;
-		/**
-		 * 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?: Partial<EmscriptenModule>): Promise<void>;
-		/**
-		 * Create a new parser.
-		 */
-		constructor();
-		/** 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: Language | null): this;
-		/**
-		 * Parse a slice of UTF8 text.
-		 *
-		 * @param callback - The UTF8-encoded text to parse or a callback function.
-		 *
-		 * @param 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 options - Options for parsing the text.
-		 *  This can be used to set the included ranges, or a progress callback.
-		 *
-		 * @returns 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 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(): Range[];
-		/** Set the logging callback that a parser should use during parsing. */
-		setLogger(callback: LogCallback | boolean | null): this;
-		/** Get the parser's current logger. */
-		getLogger(): LogCallback | null;
-	}
-	interface LanguageMetadata {
-		readonly major_version: number;
-		readonly minor_version: number;
-		readonly patch_version: number;
-	}
-	/**
-	 * 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 {
-		/**
-		 * A list of all node types in the language. The index of each type in this
-		 * array is its node type id.
-		 */
-		types: string[];
-		/**
-		 * A list of all field names in the language. The index of each field name in
-		 * this array is its field id.
-		 */
-		fields: (string | null)[];
-		/**
-		 * Gets the name of the language.
-		 */
-		get name(): string | null;
-		/**
-		 * Gets the ABI version of the language.
-		 */
-		get abiVersion(): number;
-		/**
-		* 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(): LanguageMetadata | null;
-		/**
-		 * Gets the number of fields in the language.
-		 */
-		get fieldCount(): number;
-		/**
-		 * Gets the number of states in the language.
-		 */
-		get stateCount(): number;
-		/**
-		 * Get the field id for a field name.
-		 */
-		fieldIdForName(fieldName: string): number | null;
-		/**
-		 * Get the field name for a field id.
-		 */
-		fieldNameForId(fieldId: number): string | null;
-		/**
-		 * Get the node type id for a node type name.
-		 */
-		idForNodeType(type: string, named: boolean): number | null;
-		/**
-		 * Gets the number of node types in the language.
-		 */
-		get nodeTypeCount(): number;
-		/**
-		 * Get the node type name for a node type id.
-		 */
-		nodeTypeForId(typeId: number): string | 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: number): boolean;
-		/**
-		 * Check if a node type is visible.
-		 */
-		nodeTypeIsVisible(typeId: number): 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(): number[];
-		/**
-		 * Get the subtype ids for a given supertype node id.
-		 */
-		subtypes(supertype: number): number[];
-		/**
-		 * Get the next state id for a given state id and node type id.
-		 */
-		nextState(stateId: number, typeId: number): number;
-		/**
-		 * 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: number): LookaheadIterator | null;
-		/**
-		 * 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: string | Uint8Array): Promise<Language>;
-	}
-	/** A tree that represents the syntactic structure of a source code file. */
-	export class Tree {
-		/** The language that was used to parse the syntax tree. */
-		language: Language;
-		/** Create a shallow copy of the syntax tree. This is very fast. */
-		copy(): Tree;
-		/** Delete the syntax tree, freeing its resources. */
-		delete(): void;
-		/** Get the root node of the syntax tree. */
-		get rootNode(): Node;
-		/**
-		 * Get the root node of the syntax tree, but with its position shifted
-		 * forward by the given offset.
-		 */
-		rootNodeWithOffset(offsetBytes: number, offsetExtent: Point): Node;
-		/**
-		 * Edit the syntax tree to keep it in sync with source code that has been
-		 * edited.
-		 *
-		 * You must describe the edit both in terms of byte offsets and in terms of
-		 * row/column coordinates.
-		 */
-		edit(edit: Edit): void;
-		/** Create a new {@link TreeCursor} starting from the root of the tree. */
-		walk(): TreeCursor;
-		/**
-		 * Compare this old edited syntax tree to a new syntax tree representing
-		 * the same document, returning a sequence of ranges whose syntactic
-		 * structure has changed.
-		 *
-		 * For this to work correctly, this syntax tree must have been edited such
-		 * that its ranges match up to the new tree. Generally, you'll want to
-		 * call this method right after calling one of the [`Parser::parse`]
-		 * functions. Call it on the old tree that was passed to parse, and
-		 * pass the new tree that was returned from `parse`.
-		 */
-		getChangedRanges(other: Tree): Range[];
-		/** Get the included ranges that were used to parse the syntax tree. */
-		getIncludedRanges(): Range[];
-	}
-	/** A single node within a syntax {@link Tree}. */
-	export class Node {
-		/**
-		 * The numeric id for this node that is unique.
-		 *
-		 * Within a given syntax tree, no two nodes have the same id. However:
-		 *
-		 * * If a new tree is created based on an older tree, and a node from the old tree is reused in
-		 *   the process, then that node will have the same id in both trees.
-		 *
-		 * * A node not marked as having changes does not guarantee it was reused.
-		 *
-		 * * If a node is marked as having changed in the old tree, it will not be reused.
-		 */
-		id: number;
-		/** The byte index where this node starts. */
-		startIndex: number;
-		/** The position where this node starts. */
-		startPosition: Point;
-		/** The tree that this node belongs to. */
-		tree: Tree;
-		/** Get this node's type as a numerical id. */
-		get typeId(): number;
-		/**
-		 * Get the node's type as a numerical id as it appears in the grammar,
-		 * ignoring aliases.
-		 */
-		get grammarId(): number;
-		/** Get this node's type as a string. */
-		get type(): string;
-		/**
-		 * Get this node's symbol name as it appears in the grammar, ignoring
-		 * aliases as a string.
-		 */
-		get grammarType(): string;
-		/**
-		 * Check if this node is *named*.
-		 *
-		 * Named nodes correspond to named rules in the grammar, whereas
-		 * *anonymous* nodes correspond to string literals in the grammar.
-		 */
-		get isNamed(): boolean;
-		/**
-		 * Check if this node is *extra*.
-		 *
-		 * Extra nodes represent things like comments, which are not required
-		 * by the grammar, but can appear anywhere.
-		 */
-		get isExtra(): boolean;
-		/**
-		 * Check if this node represents a syntax error.
-		 *
-		 * Syntax errors represent parts of the code that could not be incorporated
-		 * into a valid syntax tree.
-		 */
-		get isError(): boolean;
-		/**
-		 * Check if this node is *missing*.
-		 *
-		 * Missing nodes are inserted by the parser in order to recover from
-		 * certain kinds of syntax errors.
-		 */
-		get isMissing(): boolean;
-		/** Check if this node has been edited. */
-		get hasChanges(): boolean;
-		/**
-		 * Check if this node represents a syntax error or contains any syntax
-		 * errors anywhere within it.
-		 */
-		get hasError(): boolean;
-		/** Get the byte index where this node ends. */
-		get endIndex(): number;
-		/** Get the position where this node ends. */
-		get endPosition(): Point;
-		/** Get the string content of this node. */
-		get text(): string;
-		/** Get this node's parse state. */
-		get parseState(): number;
-		/** Get the parse state after this node. */
-		get nextParseState(): number;
-		/** Check if this node is equal to another node. */
-		equals(other: Node): boolean;
-		/**
-		 * Get the node's child at the given index, where zero represents the first child.
-		 *
-		 * This method is fairly fast, but its cost is technically log(n), so if
-		 * you might be iterating over a long list of children, you should use
-		 * {@link Node#children} instead.
-		 */
-		child(index: number): Node | null;
-		/**
-		 * Get this node's *named* child at the given index.
-		 *
-		 * See also {@link Node#isNamed}.
-		 * This method is fairly fast, but its cost is technically log(n), so if
-		 * you might be iterating over a long list of children, you should use
-		 * {@link Node#namedChildren} instead.
-		 */
-		namedChild(index: number): Node | null;
-		/**
-		 * Get this node's child with the given numerical field id.
-		 *
-		 * See also {@link Node#childForFieldName}. You can
-		 * convert a field name to an id using {@link Language#fieldIdForName}.
-		 */
-		childForFieldId(fieldId: number): Node | null;
-		/**
-		 * Get the first child with the given field name.
-		 *
-		 * If multiple children may have the same field name, access them using
-		 * {@link Node#childrenForFieldName}.
-		 */
-		childForFieldName(fieldName: string): Node | null;
-		/** Get the field name of this node's child at the given index. */
-		fieldNameForChild(index: number): string | null;
-		/** Get the field name of this node's named child at the given index. */
-		fieldNameForNamedChild(index: number): string | null;
-		/**
-		 * Get an array of this node's children with a given field name.
-		 *
-		 * See also {@link Node#children}.
-		 */
-		childrenForFieldName(fieldName: string): Node[];
-		/**
-		  * Get an array of this node's children with a given field id.
-		  *
-		  * See also {@link Node#childrenForFieldName}.
-		  */
-		childrenForFieldId(fieldId: number): Node[];
-		/** Get the node's first child that contains or starts after the given byte offset. */
-		firstChildForIndex(index: number): Node | null;
-		/** Get the node's first named child that contains or starts after the given byte offset. */
-		firstNamedChildForIndex(index: number): Node | null;
-		/** Get this node's number of children. */
-		get childCount(): number;
-		/**
-		 * Get this node's number of *named* children.
-		 *
-		 * See also {@link Node#isNamed}.
-		 */
-		get namedChildCount(): number;
-		/** Get this node's first child. */
-		get firstChild(): Node | null;
-		/**
-		 * Get this node's first named child.
-		 *
-		 * See also {@link Node#isNamed}.
-		 */
-		get firstNamedChild(): Node | null;
-		/** Get this node's last child. */
-		get lastChild(): Node | null;
-		/**
-		 * Get this node's last named child.
-		 *
-		 * See also {@link Node#isNamed}.
-		 */
-		get lastNamedChild(): Node | null;
-		/**
-		 * Iterate over this node's children.
-		 *
-		 * If you're walking the tree recursively, you may want to use the
-		 * {@link TreeCursor} APIs directly instead.
-		 */
-		get children(): Node[];
-		/**
-		 * Iterate over this node's named children.
-		 *
-		 * See also {@link Node#children}.
-		 */
-		get namedChildren(): Node[];
-		/**
-		 * Get the descendants of this node that are the given type, or in the given types array.
-		 *
-		 * The types array should contain node type strings, which can be retrieved from {@link Language#types}.
-		 *
-		 * Additionally, a `startPosition` and `endPosition` can be passed in to restrict the search to a byte range.
-		 */
-		descendantsOfType(types: string | string[], startPosition?: Point, endPosition?: Point): Node[];
-		/** Get this node's next sibling. */
-		get nextSibling(): Node | null;
-		/** Get this node's previous sibling. */
-		get previousSibling(): Node | null;
-		/**
-		 * Get this node's next *named* sibling.
-		 *
-		 * See also {@link Node#isNamed}.
-		 */
-		get nextNamedSibling(): Node | null;
-		/**
-		 * Get this node's previous *named* sibling.
-		 *
-		 * See also {@link Node#isNamed}.
-		 */
-		get previousNamedSibling(): Node | null;
-		/** Get the node's number of descendants, including one for the node itself. */
-		get descendantCount(): number;
-		/**
-		 * Get this node's immediate parent.
-		 * Prefer {@link Node#childWithDescendant} for iterating over this node's ancestors.
-		 */
-		get parent(): Node | null;
-		/**
-		 * Get the node that contains `descendant`.
-		 *
-		 * Note that this can return `descendant` itself.
-		 */
-		childWithDescendant(descendant: Node): Node | null;
-		/** Get the smallest node within this node that spans the given byte range. */
-		descendantForIndex(start: number, end?: number): Node | null;
-		/** Get the smallest named node within this node that spans the given byte range. */
-		namedDescendantForIndex(start: number, end?: number): Node | null;
-		/** Get the smallest node within this node that spans the given point range. */
-		descendantForPosition(start: Point, end?: Point): Node | null;
-		/** Get the smallest named node within this node that spans the given point range. */
-		namedDescendantForPosition(start: Point, end?: Point): Node | null;
-		/**
-		 * Create a new {@link TreeCursor} starting from this node.
-		 *
-		 * Note that the given node is considered the root of the cursor,
-		 * and the cursor cannot walk outside this node.
-		 */
-		walk(): TreeCursor;
-		/**
-		 * Edit this node to keep it in-sync with source code that has been edited.
-		 *
-		 * This function is only rarely needed. When you edit a syntax tree with
-		 * the {@link Tree#edit} method, all of the nodes that you retrieve from
-		 * the tree afterward will already reflect the edit. You only need to
-		 * use {@link Node#edit} when you have a specific {@link Node} instance that
-		 * you want to keep and continue to use after an edit.
-		 */
-		edit(edit: Edit): void;
-		/** Get the S-expression representation of this node. */
-		toString(): string;
-	}
-	/** A stateful object for walking a syntax {@link Tree} efficiently. */
-	export class TreeCursor {
-		/** Creates a deep copy of the tree cursor. This allocates new memory. */
-		copy(): TreeCursor;
-		/** Delete the tree cursor, freeing its resources. */
-		delete(): void;
-		/** Get the tree cursor's current {@link Node}. */
-		get currentNode(): Node;
-		/**
-		 * Get the numerical field id of this tree cursor's current node.
-		 *
-		 * See also {@link TreeCursor#currentFieldName}.
-		 */
-		get currentFieldId(): number;
-		/** Get the field name of this tree cursor's current node. */
-		get currentFieldName(): string | null;
-		/**
-		 * Get the depth of the cursor's current node relative to the original
-		 * node that the cursor was constructed with.
-		 */
-		get currentDepth(): number;
-		/**
-		 * Get the index of the cursor's current node out of all of the
-		 * descendants of the original node that the cursor was constructed with.
-		 */
-		get currentDescendantIndex(): number;
-		/** Get the type of the cursor's current node. */
-		get nodeType(): string;
-		/** Get the type id of the cursor's current node. */
-		get nodeTypeId(): number;
-		/** Get the state id of the cursor's current node. */
-		get nodeStateId(): number;
-		/** Get the id of the cursor's current node. */
-		get nodeId(): number;
-		/**
-		 * Check if the cursor's current node is *named*.
-		 *
-		 * Named nodes correspond to named rules in the grammar, whereas
-		 * *anonymous* nodes correspond to string literals in the grammar.
-		 */
-		get nodeIsNamed(): boolean;
-		/**
-		 * Check if the cursor's current node is *missing*.
-		 *
-		 * Missing nodes are inserted by the parser in order to recover from
-		 * certain kinds of syntax errors.
-		 */
-		get nodeIsMissing(): boolean;
-		/** Get the string content of the cursor's current node. */
-		get nodeText(): string;
-		/** Get the start position of the cursor's current node. */
-		get startPosition(): Point;
-		/** Get the end position of the cursor's current node. */
-		get endPosition(): Point;
-		/** Get the start index of the cursor's current node. */
-		get startIndex(): number;
-		/** Get the end index of the cursor's current node. */
-		get endIndex(): number;
-		/**
-		 * Move this cursor to the first child of its current node.
-		 *
-		 * This returns `true` if the cursor successfully moved, and returns
-		 * `false` if there were no children.
-		 */
-		gotoFirstChild(): boolean;
-		/**
-		 * Move this cursor to the last child of its current node.
-		 *
-		 * This returns `true` if the cursor successfully moved, and returns
-		 * `false` if there were no children.
-		 *
-		 * Note that this function may be slower than
-		 * {@link TreeCursor#gotoFirstChild} because it needs to
-		 * iterate through all the children to compute the child's position.
-		 */
-		gotoLastChild(): boolean;
-		/**
-		 * Move this cursor to the parent of its current node.
-		 *
-		 * This returns `true` if the cursor successfully moved, and returns
-		 * `false` if there was no parent node (the cursor was already on the
-		 * root node).
-		 *
-		 * Note that the node the cursor was constructed with is considered the root
-		 * of the cursor, and the cursor cannot walk outside this node.
-		 */
-		gotoParent(): boolean;
-		/**
-		 * Move this cursor to the next sibling of its current node.
-		 *
-		 * This returns `true` if the cursor successfully moved, and returns
-		 * `false` if there was no next sibling node.
-		 *
-		 * Note that the node the cursor was constructed with is considered the root
-		 * of the cursor, and the cursor cannot walk outside this node.
-		 */
-		gotoNextSibling(): boolean;
-		/**
-		 * Move this cursor to the previous sibling of its current node.
-		 *
-		 * This returns `true` if the cursor successfully moved, and returns
-		 * `false` if there was no previous sibling node.
-		 *
-		 * Note that this function may be slower than
-		 * {@link TreeCursor#gotoNextSibling} due to how node
-		 * positions are stored. In the worst case, this will need to iterate
-		 * through all the children up to the previous sibling node to recalculate
-		 * its position. Also note that the node the cursor was constructed with is
-		 * considered the root of the cursor, and the cursor cannot walk outside this node.
-		 */
-		gotoPreviousSibling(): boolean;
-		/**
-		 * Move the cursor to the node that is the nth descendant of
-		 * the original node that the cursor was constructed with, where
-		 * zero represents the original node itself.
-		 */
-		gotoDescendant(goalDescendantIndex: number): void;
-		/**
-		 * Move this cursor to the first child of its current node that contains or
-		 * starts after the given byte offset.
-		 *
-		 * This returns `true` if the cursor successfully moved to a child node, and returns
-		 * `false` if no such child was found.
-		 */
-		gotoFirstChildForIndex(goalIndex: number): boolean;
-		/**
-		 * Move this cursor to the first child of its current node that contains or
-		 * starts after the given byte offset.
-		 *
-		 * This returns the index of the child node if one was found, and returns
-		 * `null` if no such child was found.
-		 */
-		gotoFirstChildForPosition(goalPosition: Point): boolean;
-		/**
-		 * Re-initialize this tree cursor to start at the original node that the
-		 * cursor was constructed with.
-		 */
-		reset(node: Node): void;
-		/**
-		 * Re-initialize a tree cursor to the same position as another cursor.
-		 *
-		 * Unlike {@link TreeCursor#reset}, this will not lose parent
-		 * information and allows reusing already created cursors.
-		 */
-		resetTo(cursor: TreeCursor): void;
-	}
-	/**
-	 * Options for query execution
-	 */
-	export interface QueryOptions {
-		/** The start position of the range to query */
-		startPosition?: Point;
-		/** The end position of the range to query */
-		endPosition?: Point;
-		/** The start position of the range to query  Only the matches that are fully
-		 *  contained within provided range will be returned.
-		 **/
-		startContainingPosition?: Point;
-		/** The end position of the range to query  Only the matches that are fully
-		 *  contained within provided range will be returned.
-		 **/
-		endContainingPosition?: Point;
-		/** The start index of the range to query */
-		startIndex?: number;
-		/** The end index of the range to query */
-		endIndex?: number;
-		/** The start index of the range to query  Only the matches that are fully
-		 *  contained within provided range will be returned.
-		 **/
-		startContainingIndex?: number;
-		/** The end index of the range to query  Only the matches that are fully
-		 *  contained within provided range will be returned.
-		 **/
-		endContainingIndex?: number;
-		/**
-		 * The maximum number of in-progress matches for this query.
-		 * The limit must be > 0 and <= 65536.
-		 */
-		matchLimit?: number;
-		/**
-		 * The maximum start depth for a query cursor.
-		 *
-		 * This prevents cursors from exploring children nodes at a certain depth.
-		 * Note if a pattern includes many children, then they will still be
-		 * checked.
-		 *
-		 * The zero max start depth value can be used as a special behavior and
-		 * it helps to destructure a subtree by staying on a node and using
-		 * captures for interested parts. Note that the zero max start depth
-		 * only limit a search depth for a pattern's root node but other nodes
-		 * that are parts of the pattern may be searched at any depth what
-		 * defined by the pattern structure.
-		 *
-		 * Set to `null` to remove the maximum start depth.
-		 */
-		maxStartDepth?: number;
-		/**
-		 * A function that will be called periodically during the execution of the query to check
-		 * if query execution should be cancelled. You can also use this to instrument query execution
-		 * and check where the query is at in the document. The progress callback takes a single argument,
-		 * which is a {@link QueryState} representing the current state of the query.
-		 */
-		progressCallback?: (state: QueryState) => void;
-	}
-	/**
-	 * A stateful object that is passed into the progress callback {@link QueryOptions#progressCallback}
-	 * to provide the current state of the query.
-	 */
-	export interface QueryState {
-		/** The byte offset in the document that the query is at. */
-		currentOffset: number;
-	}
-	/** A record of key-value pairs associated with a particular pattern in a {@link Query}. */
-	export type QueryProperties = Record<string, string | null>;
-	/**
-	 * A predicate that contains an operator and list of operands.
-	 */
-	export interface QueryPredicate {
-		/** The operator of the predicate, like `match?`, `eq?`, `set!`, etc. */
-		operator: string;
-		/** The operands of the predicate, which are either captures or strings. */
-		operands: PredicateStep[];
-	}
-	/**
-	 * A particular {@link Node} that has been captured with a particular name within a
-	 * {@link Query}.
-	 */
-	export interface QueryCapture {
-		/** The index of the pattern that matched. */
-		patternIndex: number;
-		/** The name of the capture */
-		name: string;
-		/** The captured node */
-		node: Node;
-		/** The properties for predicates declared with the operator `set!`. */
-		setProperties?: QueryProperties;
-		/** The properties for predicates declared with the operator `is?`. */
-		assertedProperties?: QueryProperties;
-		/** The properties for predicates declared with the operator `is-not?`. */
-		refutedProperties?: QueryProperties;
-	}
-	/** A match of a {@link Query} to a particular set of {@link Node}s. */
-	export interface QueryMatch {
-		/** The index of the pattern that matched. */
-		patternIndex: number;
-		/** The captures associated with the match. */
-		captures: QueryCapture[];
-		/** The properties for predicates declared with the operator `set!`. */
-		setProperties?: QueryProperties;
-		/** The properties for predicates declared with the operator `is?`. */
-		assertedProperties?: QueryProperties;
-		/** The properties for predicates declared with the operator `is-not?`. */
-		refutedProperties?: QueryProperties;
-	}
-	/** A quantifier for captures */
-	export const CaptureQuantifier: {
-		readonly Zero: 0;
-		readonly ZeroOrOne: 1;
-		readonly ZeroOrMore: 2;
-		readonly One: 3;
-		readonly OneOrMore: 4;
-	};
-	/** A quantifier for captures */
-	export type CaptureQuantifier = typeof CaptureQuantifier[keyof typeof CaptureQuantifier];
-	/**
-	 * Predicates are represented as a single array of steps. There are two
-	 * types of steps, which correspond to the two legal values for
-	 * the `type` field:
-	 *
-	 * - `CapturePredicateStep` - Steps with this type represent names
-	 *    of captures.
-	 *
-	 * - `StringPredicateStep` - Steps with this type represent literal
-	 *    strings.
-	 */
-	export type PredicateStep = CapturePredicateStep | StringPredicateStep;
-	/**
-	 * A step in a predicate that refers to a capture.
-	 *
-	 * The `name` field is the name of the capture.
-	 */
-	interface CapturePredicateStep {
-		type: 'capture';
-		name: string;
-	}
-	/**
-	 * A step in a predicate that refers to a string.
-	 *
-	 * The `value` field is the string value.
-	 */
-	interface StringPredicateStep {
-		type: 'string';
-		value: string;
-	}
-	export class Query {
-		/** The names of the captures used in the query. */
-		readonly captureNames: string[];
-		/** The quantifiers of the captures used in the query. */
-		readonly captureQuantifiers: CaptureQuantifier[][];
-		/**
-		 * 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!`
-		 */
-		readonly predicates: QueryPredicate[][];
-		/** The properties for predicates with the operator `set!`. */
-		readonly setProperties: QueryProperties[];
-		/** The properties for predicates with the operator `is?`. */
-		readonly assertedProperties: QueryProperties[];
-		/** The properties for predicates with the operator `is-not?`. */
-		readonly refutedProperties: QueryProperties[];
-		/** The maximum number of in-progress matches for this cursor. */
-		matchLimit?: number;
-		/**
-		 * 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: Language, source: string);
-		/** 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 - The node to execute the query on.
-		 *
-		 * @param options - Options for query execution.
-		 */
-		matches(node: Node, options?: QueryOptions): QueryMatch[];
-		/**
-		 * 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 - The node to execute the query on.
-		 *
-		 * @param options - Options for query execution.
-		 */
-		captures(node: Node, options?: QueryOptions): QueryCapture[];
-		/** Get the predicates for a given pattern. */
-		predicatesForPattern(patternIndex: number): QueryPredicate[];
-		/**
-		 * 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: string): 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: number): 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: number): number;
-		/** Get the byte offset where the given pattern ends in the query's source. */
-		endIndexForPattern(patternIndex: number): number;
-		/** Get the number of patterns in the query. */
-		patternCount(): number;
-		/** Get the index for a given capture name. */
-		captureIndexForName(captureName: string): number;
-		/** Check if a given pattern within a query has a single root node. */
-		isPatternRooted(patternIndex: number): boolean;
-		/** Check if a given pattern within a query has a single root node. */
-		isPatternNonLocal(patternIndex: number): 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: number): boolean;
-	}
-	export class LookaheadIterator implements Iterable<string> {
-		/** Get the current symbol of the lookahead iterator. */
-		get currentTypeId(): number;
-		/** Get the current symbol name of the lookahead iterator. */
-		get currentType(): string;
-		/** 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: Language, stateId: number): 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: number): 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](): Iterator<string>;
-	}
-
-	export {};
-}
-
-//# sourceMappingURL=web-tree-sitter.d.cts.map