@let-value/translate-extract-static 1.1.0 → 1.1.1-beta.2

package/dist/src/index.d.cts

@@ -1,2 +1,1474 @@
-export * from "@let-value/translate-extract/core";
-export * from "@let-value/translate-extract/static";
+//#region ../translate/dist/index.d.ts
+
+//#region src/locales.d.ts
+type PluralFormsLocale = "ach" | "af" | "ak" | "am" | "an" | "ar" | "arn" | "ast" | "ay" | "az" | "be" | "bg" | "bn" | "bo" | "br" | "brx" | "bs" | "ca" | "cgg" | "cs" | "csb" | "cy" | "da" | "de" | "doi" | "dz" | "el" | "en" | "eo" | "es" | "et" | "eu" | "fa" | "ff" | "fi" | "fil" | "fo" | "fr" | "fur" | "fy" | "ga" | "gd" | "gl" | "gu" | "gun" | "ha" | "he" | "hi" | "hne" | "hr" | "hu" | "hy" | "id" | "is" | "it" | "ja" | "jbo" | "jv" | "ka" | "kab" | "kk" | "km" | "kn" | "ko" | "ku" | "kw" | "ky" | "lb" | "ln" | "lo" | "lt" | "lv" | "mai" | "mfe" | "mg" | "mi" | "mk" | "ml" | "mn" | "mni" | "mnk" | "mr" | "ms" | "mt" | "my" | "nah" | "nap" | "nb" | "ne" | "nl" | "nn" | "no" | "nso" | "oc" | "or" | "pa" | "pap" | "pl" | "pms" | "ps" | "pt" | "rm" | "ro" | "ru" | "rw" | "sah" | "sat" | "sco" | "sd" | "se" | "si" | "sk" | "sl" | "so" | "son" | "sq" | "sr" | "su" | "sv" | "sw" | "ta" | "te" | "tg" | "th" | "ti" | "tk" | "tr" | "tt" | "ug" | "uk" | "ur" | "uz" | "vi" | "wa" | "wo" | "yo" | "zh";
+//#endregion
+//#region src/config.d.ts
+//#endregion
+//#region ../node_modules/loglevel/index.d.ts
+// Originally from Definitely Typed, see:
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/b4683d7/types/loglevel/index.d.ts
+// Original definitions by: Stefan Profanter <https://github.com/Pro>
+//                          Gabor Szmetanko <https://github.com/szmeti>
+//                          Christian Rackerseder <https://github.com/screendriver>
+
+declare const log: log.RootLogger;
+declare namespace log {
+  /**
+   * Log levels
+   */
+  interface LogLevel {
+    TRACE: 0;
+    DEBUG: 1;
+    INFO: 2;
+    WARN: 3;
+    ERROR: 4;
+    SILENT: 5;
+  }
+
+  /**
+   * Possible log level numbers.
+   */
+  type LogLevelNumbers = LogLevel[keyof LogLevel];
+
+  /**
+   * Possible log level descriptors, may be string, lower or upper case, or number.
+   */
+  type LogLevelDesc = LogLevelNumbers | LogLevelNames | 'silent' | keyof LogLevel;
+  type LogLevelNames = 'trace' | 'debug' | 'info' | 'warn' | 'error';
+  type LoggingMethod = (...message: any[]) => void;
+  type MethodFactory = (methodName: LogLevelNames, level: LogLevelNumbers, loggerName: string | symbol) => LoggingMethod;
+  interface RootLogger extends Logger {
+    /**
+     * If you're using another JavaScript library that exposes a 'log' global, you can run into conflicts with loglevel.
+     * Similarly to jQuery, you can solve this by putting loglevel into no-conflict mode immediately after it is loaded
+     * onto the page. This resets to 'log' global to its value before loglevel was loaded (typically undefined), and
+     * returns the loglevel object, which you can then bind to another name yourself.
+     */
+    noConflict(): any;
+
+    /**
+     * This gets you a new logger object that works exactly like the root log object, but can have its level and
+     * logging methods set independently. All loggers must have a name (which is a non-empty string or a symbol)
+     * Calling * getLogger() multiple times with the same name will return an identical logger object.
+     * In large applications, it can be incredibly useful to turn logging on and off for particular modules as you are
+     * working with them. Using the getLogger() method lets you create a separate logger for each part of your
+     * application with its own logging level. Likewise, for small, independent modules, using a named logger instead
+     * of the default root logger allows developers using your module to selectively turn on deep, trace-level logging
+     * when trying to debug problems, while logging only errors or silencing logging altogether under normal
+     * circumstances.
+     * @param name The name of the produced logger
+     */
+    getLogger(name: string | symbol): Logger;
+
+    /**
+     * This will return you the dictionary of all loggers created with getLogger, keyed off of their names.
+     */
+    getLoggers(): {
+      [name: string]: Logger;
+    };
+
+    /**
+     * A .default property for ES6 default import compatibility
+     */
+    default: RootLogger;
+  }
+  interface Logger {
+    /**
+     * Available log levels.
+     */
+    readonly levels: LogLevel;
+
+    /**
+     * Plugin API entry point. This will be called for each enabled method each time the level is set
+     * (including initially), and should return a MethodFactory to be used for the given log method, at the given level,
+     * for a logger with the given name. If you'd like to retain all the reliability and features of loglevel, it's
+     * recommended that this wraps the initially provided value of log.methodFactory
+     */
+    methodFactory: MethodFactory;
+
+    /**
+     * Output trace message to console.
+     * This will also include a full stack trace
+     *
+     * @param msg any data to log to the console
+     */
+    trace(...msg: any[]): void;
+
+    /**
+     * Output debug message to console including appropriate icons
+     *
+     * @param msg any data to log to the console
+     */
+    debug(...msg: any[]): void;
+
+    /**
+     * Output debug message to console including appropriate icons
+     *
+     * @param msg any data to log to the console
+     */
+    log(...msg: any[]): void;
+
+    /**
+     * Output info message to console including appropriate icons
+     *
+     * @param msg any data to log to the console
+     */
+    info(...msg: any[]): void;
+
+    /**
+     * Output warn message to console including appropriate icons
+     *
+     * @param msg any data to log to the console
+     */
+    warn(...msg: any[]): void;
+
+    /**
+     * Output error message to console including appropriate icons
+     *
+     * @param msg any data to log to the console
+     */
+    error(...msg: any[]): void;
+
+    /**
+     * This disables all logging below the given level, so that after a log.setLevel("warn") call log.warn("something")
+     * or log.error("something") will output messages, but log.info("something") will not.
+     *
+     * @param level as a string, like 'error' (case-insensitive) or as a number from 0 to 5 (or as log.levels. values)
+     * @param persist Where possible the log level will be persisted. LocalStorage will be used if available, falling
+     *     back to cookies if not. If neither is available in the current environment (i.e. in Node), or if you pass
+     *     false as the optional 'persist' second argument, persistence will be skipped.
+     */
+    setLevel(level: LogLevelDesc, persist?: boolean): void;
+
+    /**
+     * Returns the current logging level, as a value from LogLevel.
+     * It's very unlikely you'll need to use this for normal application logging; it's provided partly to help plugin
+     * development, and partly to let you optimize logging code as below, where debug data is only generated if the
+     * level is set such that it'll actually be logged. This probably doesn't affect you, unless you've run profiling
+     * on your code and you have hard numbers telling you that your log data generation is a real performance problem.
+     */
+    getLevel(): LogLevel[keyof LogLevel];
+
+    /**
+     * This sets the current log level only if one has not been persisted and can’t be loaded. This is useful when
+     * initializing scripts; if a developer or user has previously called setLevel(), this won’t alter their settings.
+     * For example, your application might set the log level to error in a production environment, but when debugging
+     * an issue, you might call setLevel("trace") on the console to see all the logs. If that error setting was set
+     * using setDefaultLevel(), it will still say as trace on subsequent page loads and refreshes instead of resetting
+     * to error.
+     *
+     * The level argument takes is the same values that you might pass to setLevel(). Levels set using
+     * setDefaultLevel() never persist to subsequent page loads.
+     *
+     * @param level as a string, like 'error' (case-insensitive) or as a number from 0 to 5 (or as log.levels. values)
+     */
+    setDefaultLevel(level: LogLevelDesc): void;
+
+    /**
+     * This resets the current log level to the default level (or `warn` if no explicit default was set) and clears
+     * the persisted level if one was previously persisted.
+     */
+    resetLevel(): void;
+
+    /**
+     * This enables all log messages, and is equivalent to log.setLevel("trace").
+     *
+     * @param persist Where possible the log level will be persisted. LocalStorage will be used if available, falling
+     *     back to cookies if not. If neither is available in the current environment (i.e. in Node), or if you pass
+     *     false as the optional 'persist' second argument, persistence will be skipped.
+     */
+    enableAll(persist?: boolean): void;
+
+    /**
+     * This disables all log messages, and is equivalent to log.setLevel("silent").
+     *
+     * @param persist Where possible the log level will be persisted. LocalStorage will be used if available, falling
+     *     back to cookies if not. If neither is available in the current environment (i.e. in Node), or if you pass
+     *     false as the optional 'persist' second argument, persistence will be skipped.
+     */
+    disableAll(persist?: boolean): void;
+
+    /**
+     * Rebuild the logging methods on this logger and its child loggers.
+     *
+     * This is mostly intended for plugin developers, but can be useful if you update a logger's `methodFactory` or
+     * if you want to apply the root logger’s level to any *pre-existing* child loggers (this updates the level on
+     * any child logger that hasn't used `setLevel()` or `setDefaultLevel()`).
+     */
+    rebuild(): void;
+  }
+}
+//#endregion
+//#region ../extract/src/logger.d.ts
+type Logger$1 = log.Logger;
+type LogLevelNames$1 = log.LogLevelNames;
+type LogLevel$1 = LogLevelNames$1;
+//#endregion
+//#region ../extract/src/plugins/cleanup/cleanup.d.ts
+declare function cleanup$1(): Plugin;
+//#endregion
+//#region ../node_modules/@keqingmoe/tree-sitter/tree-sitter.d.ts
+/** @module */
+declare module "@keqingmoe/tree-sitter" {
+  class Parser {
+    /**
+     * Parse UTF8 text into a syntax tree.
+     *
+     * @param input - The text to parse, either as a string or a custom input function
+     * that provides text chunks. If providing a function, it should return text chunks
+     * based on byte index and position.
+     *
+     * @param oldTree - An optional previous syntax tree from the same document.
+     * If provided and the document has changed, you must first edit this tree using
+     * {@link Parser.Tree.edit} to match the new text.
+     *
+     * @param options - Optional parsing settings:
+     * - bufferSize: Size of internal parsing buffer
+     * - includedRanges: Array of ranges to parse within the input
+     *
+     * @returns A syntax tree representing the parsed text
+     *
+     * @throws May return null or fail if:
+     * - No language has been set via {@link Parser.setLanguage}
+     * - The parsing timeout (set via {@link Parser.setTimeoutMicros}) was reached
+     * - Parsing was cancelled via cancellation flag
+     */
+    parse(input: string | Parser.Input, oldTree?: Parser.Tree | null, options?: Parser.Options): Parser.Tree;
+
+    /**
+     * Get the ranges of text that the parser will include when parsing.
+     *
+     * @returns An array of ranges that will be included in parsing
+     */
+    getIncludedRanges(): Parser.Range[];
+
+    /**
+     * Get the duration in microseconds that parsing is allowed to take.
+     *
+     * This timeout can be set via {@link Parser.setTimeoutMicros}.
+     *
+     * @returns The parsing timeout in microseconds
+     */
+    getTimeoutMicros(): number;
+
+    /**
+     * Set the maximum duration that parsing is allowed to take before halting.
+     *
+     * If parsing takes longer than this, it will halt early, returning null.
+     *
+     * @param timeout - The maximum parsing duration in microseconds
+     */
+    setTimeoutMicros(timeout: number): void;
+
+    /**
+     * Instruct the parser to start the next parse from the beginning.
+     *
+     * If the parser previously failed because of a timeout or cancellation,
+     * it will resume where it left off on the next parse by default.
+     * Call this method if you want to parse a different document instead
+     * of resuming.
+     */
+    reset(): void;
+
+    /**
+     * Get the parser's current language
+     */
+    getLanguage(): Parser.Language;
+
+    /**
+     * Set the language that the parser should use for parsing.
+     *
+     * The language must be compatible with the version of tree-sitter
+     * being used. A version mismatch will prevent the language from
+     * being assigned successfully.
+     *
+     * @param language - The language to use for parsing
+     */
+    setLanguage(language?: Parser.Language): void;
+
+    /**
+     * Get the parser's current logger
+     *
+     * @returns The current logging callback
+     */
+    getLogger(): Parser.Logger;
+
+    /**
+     * Set the logging callback that the parser should use during parsing.
+     *
+     * @param logFunc - The logging callback to use, or null/false to disable logging
+     */
+    setLogger(logFunc?: Parser.Logger | string | false | null): void;
+
+    /**
+     * Set the destination to which the parser should write debugging graphs during parsing.
+     *
+     * The graphs are formatted in the DOT language. You may want to pipe these graphs
+     * directly to a 'dot' process to generate SVG output.
+     *
+     * @param enabled - Whether to enable or disable graph output
+     * @param fd - Optional file descriptor for the output
+     */
+    printDotGraphs(enabled?: boolean, fd?: number): void;
+  }
+  namespace Parser {
+    /** Configuration options for parsing */
+    export type Options = {
+      /** Size of the internal parsing buffer */
+      bufferSize?: number;
+
+      /** Array of ranges to include when parsing the input */
+      includedRanges?: Range[];
+    };
+
+    /**
+     * A position in a multi-line text document, in terms of rows and columns.
+     * Both values are zero-based.
+     */
+    export type Point = {
+      /** Zero-based row number */
+      row: number;
+
+      /** Zero-based column number */
+      column: number;
+    };
+
+    /**
+     * A range of positions in a multi-line text document, specified both in
+     * terms of byte offsets and row/column positions.
+     */
+    export type Range = {
+      /** The byte offset of the start of the range */
+      startIndex: number;
+
+      /** The byte offset of the end of the range */
+      endIndex: number;
+
+      /** The row and column where the range starts */
+      startPosition: Point;
+
+      /** The row and column where the range ends */
+      endPosition: Point;
+    };
+
+    /**
+     * A summary of a change to a text document
+     */
+    export type Edit = {
+      /** The byte offset where the edit starts */
+      startIndex: number;
+
+      /** The byte offset where the edit ends in the old document */
+      oldEndIndex: number;
+
+      /** The byte offset where the edit ends in the new document */
+      newEndIndex: number;
+
+      /** The row and column where the edit starts */
+      startPosition: Point;
+
+      /** The row and column where the edit ends in the old document */
+      oldEndPosition: Point;
+
+      /** The row and column where the edit ends in the new document */
+      newEndPosition: Point;
+    };
+
+    /**
+     * A callback that receives log messages during parser.
+     *
+     * @param message - The log message
+     * @param params - Parameters associated with the log message
+     * @param type - The type of log message
+     */
+    export type Logger = (message: string, params: {
+      [param: string]: string;
+    }, type: "parse" | "lex") => void;
+
+    /** A function that provides text content for parsing based on byte index and position */
+    export interface Input {
+      /**
+       * Get a chunk of text at the given byte offset.
+       *
+       * @param index - The byte index into the text
+       * @param position - Optional position in the text as {row, column}
+       * @returns A string chunk, or null/undefined if no text at this index
+       */
+      (index: number, position?: Point): string | null | undefined | {};
+    }
+
+    /** The syntax tree that contains this node */
+    export interface SyntaxNode {
+      /** The syntax tree that contains this node */
+      tree: Tree;
+
+      /**
+       * A unique numeric identifier for this node.
+       * Within a given syntax tree, no two nodes have the same id.
+       * If a new tree is created based on an older tree and reuses
+       * a node, that node will have the same id in both trees.
+       */
+      id: number;
+
+      /**
+       * This node's type as a numeric id
+       */
+      typeId: number;
+
+      /**
+       * This node's type as a numeric id as it appears in the grammar,
+       * ignoring aliases
+       */
+      grammarId: number;
+
+      /**
+       * This node's type as a string
+       */
+      type: string;
+
+      /**
+        * This node's symbol name as it appears in the grammar,
+        * ignoring aliases
+        */
+      grammarType: string;
+
+      /**
+       * Whether this node is named.
+       * Named nodes correspond to named rules in the grammar,
+       * whereas anonymous nodes correspond to string literals in the grammar.
+       */
+      isNamed: boolean;
+
+      /**
+       * Whether this node is missing.
+       * Missing nodes are inserted by the parser in order to
+       * recover from certain kinds of syntax errors.
+       */
+      isMissing: boolean;
+
+      /**
+        * Whether this node is extra.
+        * Extra nodes represent things like comments, which are not
+        * required by the grammar but can appear anywhere.
+        */
+      isExtra: boolean;
+
+      /**
+       * Whether this node has been edited
+       */
+      hasChanges: boolean;
+
+      /**
+       * Whether this node represents a syntax error or contains
+       * any syntax errors within it
+       */
+      hasError: boolean;
+
+      /**
+       * Whether this node represents a syntax error.
+       * Syntax errors represent parts of the code that could not
+       * be incorporated into a valid syntax tree.
+       */
+      isError: boolean;
+
+      /** The text content for this node from the source code */
+      text: string;
+
+      /** The parse state of this node */
+      parseState: number;
+
+      /** The parse state that follows this node */
+      nextParseState: number;
+
+      /** The position where this node starts in terms of rows and columns */
+      startPosition: Point;
+
+      /** The position where this node ends in terms of rows and columns */
+      endPosition: Point;
+
+      /** The byte offset where this node starts */
+      startIndex: number;
+
+      /** The byte offset where this node ends */
+      endIndex: number;
+
+      /**
+       * This node's immediate parent.
+       * For iterating over ancestors, prefer using {@link childWithDescendant}
+       */
+      parent: SyntaxNode | null;
+
+      /** Array of all child nodes */
+      children: Array<SyntaxNode>;
+
+      /** Array of all named child nodes */
+      namedChildren: Array<SyntaxNode>;
+
+      /** The number of children this node has */
+      childCount: number;
+
+      /**
+       * The number of named children this node has.
+       * @see {@link isNamed}
+       */
+      namedChildCount: number;
+
+      /** The first child of this node */
+      firstChild: SyntaxNode | null;
+
+      /** The first named child of this node */
+      firstNamedChild: SyntaxNode | null;
+
+      /** The last child of this node */
+      lastChild: SyntaxNode | null;
+
+      /** The last child of this node */
+      lastNamedChild: SyntaxNode | null;
+
+      /** This node's next sibling */
+      nextSibling: SyntaxNode | null;
+
+      /** This node's next named sibling */
+      nextNamedSibling: SyntaxNode | null;
+
+      /** This node's previous sibling */
+      previousSibling: SyntaxNode | null;
+
+      /** This node's previous named sibling */
+      previousNamedSibling: SyntaxNode | null;
+
+      /**
+       * The number of descendants this node has, including itself
+       */
+      descendantCount: number;
+
+      /**
+       * Convert this node to its string representation
+       */
+      toString(): string;
+
+      /**
+       * Get the node's child at the given index, where zero represents the first child.
+       *
+       * Note: While fairly fast, this method's cost is technically log(i).
+       * For iterating over many children, prefer using the children array.
+       *
+       * @param index - Zero-based index of the child to retrieve
+       * @returns The child node, or null if none exists at the given index
+       */
+      child(index: number): SyntaxNode | null;
+
+      /**
+       * Get this node's named child at the given index.
+       *
+       * Note: While fairly fast, this method's cost is technically log(i).
+       * For iterating over many children, prefer using the namedChildren array.
+       *
+       * @param index - Zero-based index of the named child to retrieve
+       * @returns The named child node, or null if none exists at the given index
+       */
+      namedChild(index: number): SyntaxNode | null;
+
+      /**
+       * Get the first child with the given field name.
+       *
+       * For fields that may have multiple children, use childrenForFieldName instead.
+       *
+       * @param fieldName - The field name to search for
+       * @returns The child node, or null if no child has the given field name
+       */
+      childForFieldName(fieldName: string): SyntaxNode | null;
+
+      /**
+       * Get this node's child with the given numerical field id.
+       *
+       * Field IDs can be obtained from field names using the parser's language object.
+       *
+       * @param fieldId - The field ID to search for
+       * @returns The child node, or null if no child has the given field ID
+       */
+      childForFieldId(fieldId: number): SyntaxNode | null;
+
+      /**
+       * Get the field name of the child at the given index
+       *
+       * @param childIndex - Zero-based index of the child
+       * @returns The field name, or null if the child has no field name
+       */
+      fieldNameForChild(childIndex: number): string | null;
+
+      /**
+       * Get the field name of the named child at the given index
+       *
+       * @param namedChildIndex - Zero-based index of the named child
+       * @returns The field name, or null if the named child has no field name
+       */
+      fieldNameForNamedChild(namedChildIndex: number): string | null;
+
+      /**
+       * Get all children that have the given field name
+       *
+       * @param fieldName - The field name to search for
+       * @returns Array of child nodes with the given field name
+       */
+      childrenForFieldName(fieldName: string): Array<SyntaxNode>;
+
+      /**
+       * Get all children that have the given field ID
+       *
+       * @param fieldId - The field ID to search for
+       * @returns Array of child nodes with the given field ID
+       */
+      childrenForFieldId(fieldId: number): Array<SyntaxNode>;
+
+      /**
+       * Get the node's first child that extends beyond the given byte offset
+       *
+       * @param index - The byte offset to search from
+       * @returns The first child extending beyond the offset, or null if none found
+       */
+      firstChildForIndex(index: number): SyntaxNode | null;
+
+      /**
+       * Get the node's first named child that extends beyond the given byte offset
+       *
+       * @param index - The byte offset to search from
+       * @returns The first named child extending beyond the offset, or null if none found
+       */
+      firstNamedChildForIndex(index: number): SyntaxNode | null;
+
+      /**
+       * Get the immediate child that contains the given descendant node.
+       * Note that this can return the descendant itself if it is an immediate child.
+       *
+       * @param descendant - The descendant node to find the parent of
+       * @returns The child containing the descendant, or null if not found
+       */
+      childWithDescendant(descendant: SyntaxNode): SyntaxNode | null;
+
+      /**
+       * Get the smallest node within this node that spans the given byte offset.
+       *
+       * @param index - The byte offset to search for
+       * @returns The smallest node spanning the offset
+       */
+      descendantForIndex(index: number): SyntaxNode;
+
+      /**
+       * Get the smallest node within this node that spans the given byte range.
+       *
+       * @param startIndex - The starting byte offset
+       * @param endIndex - The ending byte offset
+       * @returns The smallest node spanning the range
+       */
+      descendantForIndex(startIndex: number, endIndex: number): SyntaxNode;
+
+      /**
+       * Get the smallest named node within this node that spans the given byte offset.
+       *
+       * @param index - The byte offset to search for
+       * @returns The smallest named node spanning the offset
+       */
+      namedDescendantForIndex(index: number): SyntaxNode;
+
+      /**
+       * Get the smallest named node within this node that spans the given byte range.
+       *
+       * @param startIndex - The starting byte offset
+       * @param endIndex - The ending byte offset
+       * @returns The smallest named node spanning the range
+       */
+      namedDescendantForIndex(startIndex: number, endIndex: number): SyntaxNode;
+
+      /**
+       * Get the smallest node within this node that spans the given position.
+       * When only one position is provided, it's used as both start and end.
+       *
+       * @param position - The point to search for
+       * @returns The smallest node spanning the position
+       */
+      descendantForPosition(position: Point): SyntaxNode;
+
+      /**
+       * Get the smallest node within this node that spans the given position range.
+       *
+       * @param startPosition - The starting position
+       * @param endPosition - The ending position
+       * @returns The smallest node spanning the range
+       */
+      descendantForPosition(startPosition: Point, endPosition: Point): SyntaxNode;
+
+      /**
+       * Get the smallest named node within this node that spans the given position.
+       * When only one position is provided, it's used as both start and end.
+       *
+       * @param position - The point to search for
+       * @returns The smallest named node spanning the position
+       */
+      namedDescendantForPosition(position: Point): SyntaxNode;
+
+      /**
+       * Get the smallest named node within this node that spans the given position range.
+       *
+       * @param startPosition - The starting position
+       * @param endPosition - The ending position
+       * @returns The smallest named node spanning the range
+       */
+      namedDescendantForPosition(startPosition: Point, endPosition: Point): SyntaxNode;
+
+      /**
+       * Get all descendants of this node that have the given type(s)
+       *
+       * @param types - A string or array of strings of node types to find
+       * @param startPosition - Optional starting position to search from
+       * @param endPosition - Optional ending position to search to
+       * @returns Array of descendant nodes matching the given types
+       */
+      descendantsOfType(types: String | Array<String>, startPosition?: Point, endPosition?: Point): Array<SyntaxNode>;
+
+      /**
+       * Find the closest ancestor of the current node that matches the given type(s).
+       *
+       * Starting from the node's parent, walks up the tree until it finds a node
+       * whose type matches any of the given types.
+       *
+       * @example
+       * const property = tree.rootNode.descendantForIndex(5);
+       * // Find closest unary expression ancestor
+       * const unary = property.closest('unary_expression');
+       * // Find closest binary or call expression ancestor
+       * const expr = property.closest(['binary_expression', 'call_expression']);
+       *
+       * @param types - A string or array of strings representing the node types to search for
+       * @returns The closest matching ancestor node, or null if none found
+       * @throws If the argument is not a string or array of strings
+       */
+      closest(types: String | Array<String>): SyntaxNode | null;
+
+      /**
+       * Create a new TreeCursor starting from this node.
+       *
+       * @returns A new cursor positioned at this node
+       */
+      walk(): TreeCursor;
+    }
+
+    /** A stateful object for walking a syntax {@link Tree} efficiently */
+    export interface TreeCursor {
+      /** The type of the current node as a string */
+      nodeType: string;
+
+      /** The type of the current node as a numeric ID */
+      nodeTypeId: number;
+
+      /** The parse state of the current node */
+      nodeStateId: number;
+
+      /** The text of the current node */
+      nodeText: string;
+
+      /** Whether the current node is named */
+      nodeIsNamed: boolean;
+
+      /** Whether the current node is missing from the source code */
+      nodeIsMissing: boolean;
+
+      /** The start position of the current node */
+      startPosition: Point;
+
+      /** The end position of the current node */
+      endPosition: Point;
+
+      /** The start byte index of the current node */
+      startIndex: number;
+
+      /** The end byte index of the current node */
+      endIndex: number;
+
+      /** The current node that the cursor is pointing to */
+      readonly currentNode: SyntaxNode;
+
+      /** The field name of the current node */
+      readonly currentFieldName: string;
+
+      /** The numerical field ID of the current node */
+      readonly currentFieldId: number;
+
+      /** The depth of the current node relative to the node where the cursor was created */
+      readonly currentDepth: number;
+
+      /** The index of the current node among all descendants of the original node */
+      readonly currentDescendantIndex: number;
+
+      /**
+       * Re-initialize this cursor to start at a new node
+       *
+       * @param node - The node to start from
+       */
+      reset(node: SyntaxNode): void;
+
+      /**
+       * Re-initialize this cursor to the same position as another cursor.
+       * Unlike reset(), this will not lose parent information and allows
+       * reusing already created cursors.
+       *
+       * @param cursor - The cursor to copy the position from
+       */
+      resetTo(cursor: TreeCursor): void;
+
+      /**
+       * Move this cursor to the parent of its current node.
+       *
+       * @returns true if cursor successfully moved, false if there was no parent
+       * (cursor was already at the root node)
+       */
+      gotoParent(): boolean;
+
+      /**
+       * Move this cursor to the first child of its current node.
+       *
+       * @returns true if cursor successfully moved, false if there were no children
+       */
+      gotoFirstChild(): boolean;
+
+      /**
+       * Move this cursor to the last child of its current node.
+       * Note: This may be slower than gotoFirstChild() as it needs to iterate 
+       * through all children to compute the position.
+       *
+       * @returns true if cursor successfully moved, false if there were no children
+       */
+      gotoLastChild(): boolean;
+
+      /**
+       * Move this cursor to the first child that extends beyond the given byte offset
+       *
+       * @param goalIndex - The byte offset to search for
+       * @returns true if a child was found and cursor moved, false otherwise
+       */
+      gotoFirstChildForIndex(goalIndex: number): boolean;
+
+      /**
+       * Move this cursor to the first child that extends beyond the given position
+       *
+       * @param goalPosition - The position to search for
+       * @returns true if a child was found and cursor moved, false otherwise
+       */
+      gotoFirstChildForPosition(goalPosition: Point): boolean;
+
+      /**
+       * Move this cursor to the next sibling of its current node
+       *
+       * @returns true if cursor successfully moved, false if there was no next sibling
+       */
+      gotoNextSibling(): boolean;
+
+      /**
+       * Move this cursor to the previous sibling of its current node.
+       * Note: This may be slower than gotoNextSibling() due to how node positions
+       * are stored. In the worst case, it will need to iterate through all previous
+       * siblings to recalculate positions.
+       *
+       * @returns true if cursor successfully moved, false if there was no previous sibling
+       */
+      gotoPreviousSibling(): boolean;
+
+      /**
+       * Move the cursor to the descendant node at the given index, where zero
+       * represents the original node the cursor was created with.
+       *
+       * @param goalDescendantIndex - The index of the descendant to move to
+       */
+      gotoDescendant(goalDescendantIndex: number): void;
+    }
+
+    /**
+     * A tree that represents the syntactic structure of a source code file.
+     */
+    export interface Tree {
+      /**
+       * The root node of the syntax tree
+       */
+      readonly rootNode: SyntaxNode;
+
+      /**
+       * Get the root node of the syntax tree, but with its position shifted
+       * forward by the given offset.
+       *
+       * @param offsetBytes - The number of bytes to shift by
+       * @param offsetExtent - The number of rows/columns to shift by
+       * @returns The root node with its position offset
+       */
+      rootNodeWithOffset(offsetBytes: number, offsetExtent: Point): SyntaxNode;
+
+      /**
+       * Edit the syntax tree to keep it in sync with source code that has been edited.
+       * The edit must be described both in terms of byte offsets and in terms of 
+       * row/column coordinates.
+       *
+       * @param edit - The edit to apply to the tree
+       * @returns The edited tree
+       */
+      edit(edit: Edit): Tree;
+
+      /**
+       * Create a new TreeCursor starting from the root of the tree.
+       *
+       * @returns A new cursor positioned at the root node
+       */
+      walk(): TreeCursor;
+
+      /**
+       * Get the text for a node within this tree
+       *
+       * @param node - The syntax node to get text for
+       * @returns The source text for the node
+       */
+      getText(node: SyntaxNode): string;
+
+      /**
+       * Compare this edited syntax tree to a new syntax tree representing the 
+       * same document, returning ranges whose syntactic structure has changed.
+       *
+       * For this to work correctly, this tree must have been edited to match
+       * the new tree's ranges. Generally, you'll want to call this right after 
+       * parsing, using the old tree that was passed to parse and the new tree
+       * that was returned.
+       *
+       * @param other - The new tree to compare against
+       * @returns Array of ranges that have changed
+       */
+      getChangedRanges(other: Tree): Range[];
+
+      /**
+       * Get the ranges that were included when parsing this syntax tree
+       *
+       * @returns Array of included ranges
+       */
+      getIncludedRanges(): Range[];
+
+      /**
+       * Get the range that was edited in this tree
+       *
+       * @returns The edited range
+       */
+      getEditedRange(): Range;
+
+      /**
+       * Print a graph of the tree in the DOT language.
+       * You may want to pipe this to a 'dot' process to generate SVG output.
+       *
+       * @param fd - Optional file descriptor for the output
+       */
+      printDotGraph(fd?: number): void;
+    }
+
+    /**
+     * A particular syntax node that was captured by a named pattern in a query.
+     */
+    export interface QueryCapture {
+      /** The name that was used to capture the node in the query */
+      name: string;
+
+      /** The captured syntax node */
+      node: SyntaxNode;
+    }
+
+    /**
+     * A match of a {@link Query} to a particular set of {@link SyntaxNode}s.
+     */
+    export interface QueryMatch {
+      /** 
+       * The index of the pattern that was matched.
+       * Each pattern in a query is assigned a numeric index in sequence.
+       */
+      pattern: number;
+
+      /** Array of nodes that were captured in the pattern match */
+      captures: QueryCapture[];
+    }
+    export type QueryOptions = {
+      /** The starting row/column position in which the query will be executed. */
+      startPosition?: Point;
+
+      /** The ending row/column position in which the query will be executed. */
+      endPosition?: Point;
+
+      /** The starting byte offset in which the query will be executed. */
+      startIndex?: number;
+
+      /** The ending byte offset in which the query will be executed. */
+      endIndex?: number;
+
+      /** The maximum number of in-progress matches for this cursor. 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.
+       */
+      maxStartDepth?: number;
+
+      /**
+       * The maximum duration in microseconds that query execution should be allowed to
+       * take before halting.
+       *
+       * If query execution takes longer than this, it will halt early, returning None.
+       */
+      timeoutMicros?: number;
+    };
+    export class Query {
+      /** The maximum number of in-progress matches for this cursor. */
+      readonly 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.
+       */
+      constructor(language: Language, source: string | Buffer);
+
+      /**
+       * 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 syntax node to query
+       * @param options - Optional query options
+       *
+       * @returns An array of captures
+       */
+      captures(node: SyntaxNode, options?: QueryOptions): QueryCapture[];
+
+      /**
+       * 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 syntax node to query
+       * @param options - Optional query options
+       *
+       * @returns An array of matches
+       */
+      matches(node: SyntaxNode, options?: QueryOptions): QueryMatch[];
+
+      /**
+       * 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.
+       *
+       * @param captureName - The name of the capture to disable
+       */
+      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.
+       *
+       * @param patternIndex - The index of the pattern to disable
+       */
+      disablePattern(patternIndex: number): void;
+
+      /**
+       * 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.
+       *
+       * @param byteOffset - The byte offset of the step to check
+       */
+      isPatternGuaranteedAtStep(byteOffset: number): boolean;
+
+      /**
+       * Check if a given pattern within a query has a single root node.
+       *
+       * @param patternIndex - The index of the pattern to check
+       */
+      isPatternRooted(patternIndex: number): boolean;
+
+      /**
+       * Check if a given pattern within a query has a single root node.
+       *
+       * @param patternIndex - The index of the pattern to check
+       */
+      isPatternNonLocal(patternIndex: number): boolean;
+
+      /**
+       * Get the byte offset where the given pattern starts in the query's
+       * source.
+       *
+       * @param patternIndex - The index of the pattern to check
+       *
+       * @returns The byte offset where the pattern starts
+       */
+      startIndexForPattern(patternIndex: number): number;
+
+      /**
+       * Get the byte offset where the given pattern ends in the query's
+       * source.
+       *
+       * @param patternIndex - The index of the pattern to check
+       *
+       * @returns The byte offset where the pattern ends
+       */
+      endIndexForPattern(patternIndex: number): number;
+
+      /**
+       * Check if, on its last execution, this cursor exceeded its maximum number
+       * of in-progress matches.
+       *
+       * @returns true if the cursor exceeded its match limit
+       */
+      didExceedMatchLimit(): boolean;
+    }
+    export class LookaheadIterator {
+      /** The current symbol of the lookahead iterator. */
+      readonly currentTypeId: number;
+      /** The current symbol name of the lookahead iterator. */
+      readonly currentType: string;
+
+      /**
+       * Create a new lookahead iterator for this language and parse state.
+       *
+       * This returns `null` if the state is invalid for this language.
+       *
+       * Iterating {@link LookaheadIterator} will yield valid symbols in the given
+       * parse state. Newly created lookahead iterators will have {@link currentType} 
+       * populated with the `ERROR` symbol.
+       *
+       * Lookahead iterators can be useful to generate suggestions and improve
+       * 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.
+       *
+       * @param language - The language to use for the lookahead iterator
+       * @param state - The parse state to use for the lookahead iterator
+       */
+      constructor(language: Language, state: number);
+
+      /**
+       * Reset the lookahead iterator.
+       *
+       * This returns `true` if the language was set successfully and `false`
+       * otherwise.
+       *
+       * @param language - The language to use for the lookahead iterator
+       * @param stateId - The parse state to use for the lookahead iterator
+       */
+      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.
+       *
+       * @param stateId - The parse state to reset the lookahead iterator to
+       */
+      resetState(stateId: number): boolean;
+
+      /**
+       * Get an iterator for the lookahead iterator.
+       *
+       * This allows the lookahead iterator to be used in a for-of loop,
+       * iterating over the valid symbols in the current parse state.
+       *
+       * @returns An iterator over the symbol names
+       */
+      [Symbol.iterator](): Iterator<string>;
+    }
+
+    /** The base node type */
+    type BaseNode = {
+      /** The node's type */
+      type: string;
+      /** Whether the node is named */
+      named: boolean;
+    };
+
+    /** A child within a node */
+    type ChildNode = {
+      /** Whether the child is repeated */
+      multiple: boolean;
+      /** Whether the child is required */
+      required: boolean;
+      /** The child's type */
+      types: BaseNode[];
+    };
+
+    /** Information about a language's node types */
+    type NodeInfo = (BaseNode & {
+      /** The subtypes of this node if it's a supertype */
+      subtypes: BaseNode[];
+    }) | (BaseNode & {
+      /** The fields within this node */
+      fields: {
+        [name: string]: ChildNode;
+      };
+      /** The child nodes of this node */
+      children: ChildNode[];
+    });
+
+    /** Information about a language */
+    interface Language {
+      /** The inner language object */
+      language: unknown;
+      /** The node type information of the language */
+      nodeTypeInfo: NodeInfo[];
+    }
+  }
+  export = Parser;
+}
+//#endregion
+//#region ../extract/src/plugins/core/queries/types.d.ts
+interface Comments {
+  translator?: string;
+  reference?: string;
+  extracted?: string;
+  flag?: string;
+  previous?: string;
+}
+interface Translation {
+  context?: string;
+  id: string;
+  plural?: string;
+  message: string[];
+  comments?: Comments;
+  obsolete?: boolean;
+}
+//#endregion
+//#region ../extract/src/plugins/core/core.d.ts
+declare function core$1(): Plugin<string, Translation[]>;
+//#endregion
+//#region ../extract/src/plugins/po/po.d.ts
+declare function po$1(): Plugin;
+//#endregion
+//#region ../extract/src/plugins/react/react.d.ts
+declare function react$1(): Plugin<string, Translation[]>;
+//#endregion
+//#region ../extract/src/static.d.ts
+declare function core(...props: Parameters<typeof core$1>): {
+  readonly static: {
+    readonly name: "core";
+    readonly props: [];
+  };
+};
+declare function react(...props: Parameters<typeof react$1>): {
+  readonly static: {
+    readonly name: "react";
+    readonly props: [];
+  };
+};
+declare function po(...props: Parameters<typeof po$1>): {
+  readonly static: {
+    readonly name: "po";
+    readonly props: [];
+  };
+};
+declare function cleanup(...props: Parameters<typeof cleanup$1>): {
+  readonly static: {
+    readonly name: "cleanup";
+    readonly props: [];
+  };
+};
+type StaticPlugin = ReturnType<typeof core> | ReturnType<typeof react> | ReturnType<typeof po> | ReturnType<typeof cleanup>;
+//#endregion
+//#region ../extract/src/plugin.d.ts
+type MaybePromise<T> = T | Promise<T>;
+interface Context {
+  config: ResolvedConfig;
+  generatedAt: Date;
+  logger?: Logger$1;
+}
+interface ResolveArgs<TInput = unknown> {
+  entrypoint: string;
+  path: string;
+  namespace: string;
+  data?: TInput;
+}
+interface ResolveResult<TInput = unknown> {
+  entrypoint: string;
+  path: string;
+  namespace: string;
+  data?: TInput;
+}
+interface LoadArgs<TInput = unknown> {
+  entrypoint: string;
+  path: string;
+  namespace: string;
+  data?: TInput;
+}
+interface LoadResult<TInput = unknown> {
+  entrypoint: string;
+  path: string;
+  namespace: string;
+  data: TInput;
+}
+interface ProcessArgs<TInput = unknown> {
+  entrypoint: string;
+  path: string;
+  namespace: string;
+  data: TInput;
+}
+interface ProcessResult<TOutput = unknown> {
+  entrypoint: string;
+  path: string;
+  namespace: string;
+  data: TOutput;
+}
+type Filter = {
+  filter: RegExp;
+  namespace?: string;
+};
+type ResolveHook<TInput = unknown> = (args: ResolveArgs<TInput>) => MaybePromise<ResolveResult<TInput> | undefined>;
+type LoadHook<TInput = unknown> = (args: LoadArgs<TInput>) => MaybePromise<LoadResult<TInput> | undefined>;
+type ProcessHook<TInput = unknown, TOutput = unknown> = (args: ProcessArgs<TInput>) => MaybePromise<ProcessResult<TOutput> | undefined>;
+interface Build<TInput = unknown, TOutput = unknown> {
+  context: Context;
+  resolve(args: ResolveArgs<unknown>): void;
+  load(args: LoadArgs<unknown>): void;
+  process(args: ProcessArgs<unknown>): void;
+  defer(namespace: string): Promise<void>;
+  onResolve(options: Filter, hook: ResolveHook<TInput>): void;
+  onLoad(options: Filter, hook: LoadHook<TInput>): void;
+  onProcess(options: Filter, hook: ProcessHook<TInput, TOutput>): void;
+}
+interface Plugin<TInput = unknown, TOutput = unknown> {
+  name: string;
+  setup(build: Build<TInput, TOutput>): void;
+}
+type UniversalPlugin = Plugin | StaticPlugin;
+//#endregion
+//#region ../extract/src/configuration.d.ts
+type DestinationFn = (args: {
+  locale: string;
+  entrypoint: string;
+  path: string;
+}) => string;
+type ExcludeFn = (args: {
+  entrypoint: string;
+  path: string;
+}) => boolean;
+type Exclude = RegExp | ExcludeFn;
+declare const defaultPlugins: {
+  core: typeof core;
+  po: typeof po;
+  cleanup: typeof cleanup;
+};
+type DefaultPlugins = typeof defaultPlugins;
+/**
+ * Strategy to handle obsolete translations in existing locale files:
+ * - "mark": keep obsolete entries in the locale file but mark them as obsolete
+ * - "remove": remove obsolete entries from the locale file
+ */
+type ObsoleteStrategy = "mark" | "remove";
+interface EntrypointConfig {
+  entrypoint: string;
+  destination?: DestinationFn;
+  obsolete?: ObsoleteStrategy;
+  walk?: boolean;
+  exclude?: Exclude | Exclude[];
+}
+interface UserConfig {
+  /**
+   * Default locale to use as the base for extraction
+   * @default "en"
+   * @see {@link PluralFormsLocale} for available locales
+   */
+  defaultLocale?: PluralFormsLocale;
+  /**
+   * Array of locales to extract translations for
+   * @default [defaultLocale]
+   * @see {@link PluralFormsLocale} for available locales
+   */
+  locales?: PluralFormsLocale[];
+  /**
+   * Array of plugins to use or a function to override the default plugins
+   * @default DefaultPlugins
+   * @see {@link DefaultPlugins} for available plugins
+   */
+  plugins?: UniversalPlugin[] | ((defaultPlugins: DefaultPlugins) => UniversalPlugin[]);
+  /**
+   * One or more entrypoints to extract translations from, could be:
+   * - file path, will be treated as a single file entrypoint
+   * - glob pattern will be expanded to match files, each treated as a separate entrypoint
+   * - configuration object with options for the entrypoint
+   * @see {@link EntrypointConfig} for configuration options
+   */
+  entrypoints: string | EntrypointConfig | Array<string | EntrypointConfig>;
+  /**
+   * Function to determine the destination path for each extracted locale file
+   * @default `./translations/entrypoint.locale.po`
+   * @see {@link DestinationFn}
+   * @see Can be overridden per entrypoint via `destination` in {@link EntrypointConfig
+   */
+  destination?: DestinationFn;
+  /**
+   * Strategy to handle obsolete translations in existing locale files
+   * @default "mark"
+   * @see {@link ObsoleteStrategy} for available strategies
+   * @see Can be overridden per entrypoint via `obsolete` in {@link EntrypointConfig
+   */
+  obsolete?: ObsoleteStrategy;
+  /**
+   * Whether to recursively walk dependencies of the entrypoints
+   * @default true
+   * @see Can be overridden per entrypoint via `walk` in {@link EntrypointConfig}.
+   */
+  walk?: boolean;
+  /**
+   * Paths or patterns to exclude from extraction, applied to all entrypoints
+   * @default [/node_modules/, /dist/, /build/]
+   * @see Can be overridden per entrypoint via `exclude` in {@link EntrypointConfig}.
+   */
+  exclude?: Exclude | Exclude[];
+  /**
+   * Log level for the extraction process
+   * @default "info"
+   */
+  logLevel?: LogLevel$1;
+}
+interface ResolvedEntrypoint extends Omit<EntrypointConfig, "exclude"> {
+  exclude?: Exclude[];
+}
+interface ResolvedConfig {
+  plugins: UniversalPlugin[];
+  entrypoints: ResolvedEntrypoint[];
+  defaultLocale: string;
+  locales: string[];
+  destination: DestinationFn;
+  obsolete: ObsoleteStrategy;
+  walk: boolean;
+  logLevel: LogLevel$1;
+  exclude: Exclude[];
+}
+/**
+ * Type helper to make it easier to use translate.config.ts
+ * @param config - {@link UserConfig}.
+ */
+declare function defineConfig(config: UserConfig): ResolvedConfig;
+//#endregion
+export { Build, Context, DestinationFn, EntrypointConfig, Exclude, ExcludeFn, Filter, LoadArgs, LoadHook, LoadResult, ObsoleteStrategy, Plugin, ProcessArgs, ProcessHook, ProcessResult, ResolveArgs, ResolveHook, ResolveResult, ResolvedConfig, ResolvedEntrypoint, StaticPlugin, UniversalPlugin, UserConfig, cleanup, core, defineConfig, po, react };