@runtime-type-inspector/transpiler 4.0.5 → 5.0.0

package/types.d.ts

@@ -0,0 +1,970 @@
+type Stat$1 = {
+    /**
+     * - How often assertions were added to this kind of node.
+     */
+    checked: number;
+    /**
+     * - How often no assertions were added to this kind of node.
+     */
+    unchecked: number;
+};
+
+type Node$1 = any;
+/**
+ * @typedef {import("@babel/types").Node} Node
+ */
+declare class Stringifier {
+    forceCurly: boolean;
+    /** @type {Node[]} */
+    parents: Node$1[];
+    /**
+     * @param {Node} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    toSource(node: any): string;
+    /**
+     * @param {Node} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    toSource_(node: any): string;
+    parentProvidesSpaces(reverseIndex: any): boolean;
+    lastCommentBlockIndex: number;
+    /**
+     * @param {import("@babel/types").CommentBlock} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    CommentBlock(node: any): string;
+    lastCommentLineIndex: number;
+    /**
+     * @param {import("@babel/types").CommentLine} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    CommentLine(node: any): string;
+    leadingCommentsToSource(leadingComments: any): any;
+    trailingCommentsToSource(trailingComments: any): string;
+    /**
+     * @param {*} comment - The comment "node" (not a real Babel Node node though, hence this special treatment)
+     * @param {'leading'|'trailing'} pos - The position, either 'leading' or 'trailing'.
+     * @returns {string} The comment "node" as a string.
+     */
+    commentToSource(comment: any, pos: 'leading' | 'trailing'): string;
+    /**
+     * Only add { and } when requested (e.g. for Asserter).
+     * showAST("if (true) 2;") vs showAST("if (true) {2}")
+     * @param {Node} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    toSourceCurly(node: any): string;
+    get parent(): any;
+    get parentType(): any;
+    get needSpaces(): boolean;
+    /**
+     * @param {Node[]} arr - Array of nodes to convert.
+     * @returns {string[]} Array of strings for each node.
+     */
+    mapToSource(arr: Node$1[]): string[];
+    /**
+     * Generates a string representing type checks for a given Babel AST node.
+     *
+     * Note: This method serves as a stub and should be overridden in subclasses.
+     * The actual implementation is expected to be provided in Asserter.mjs, where
+     * it would create runtime type assertions based on the AST node provided.
+     *
+     * @param {Node} node - The Babel AST node for which to generate type checks.
+     * @returns {string} A placeholder string, as this stub implementation does nothing; expected to be overridden.
+     */
+    generateTypeChecks(node: any): string;
+    numSpaces: number;
+    /**
+     * @returns {string} A string of two spaces per indentation.
+     */
+    get spaces(): string;
+    debugSpaces(): string;
+    /**
+     * > await something();
+     *
+     * @param {import("@babel/types").AwaitExpression} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    AwaitExpression(node: any): string;
+    /**
+     * @param {import("@babel/types").ClassBody} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ClassBody(node: any): string;
+    /**
+     * @param {import("@babel/types").ClassMethod} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ClassMethod(node: any): string;
+    /**
+     * @param {import("@babel/types").ClassExpression} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ClassExpression(node: any): string;
+    /**
+     * @param {import("@babel/types").ClassDeclaration} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ClassDeclaration(node: any): string;
+    /**
+     * @param {import("@babel/types").ClassPrivateMethod} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ClassPrivateMethod(node: any): string;
+    /**
+     * > asd;
+     * > asd = 1;
+     * > static asd;
+     * > static asd = 1;
+     *
+     * @param {import("@babel/types").ClassProperty} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ClassProperty(node: any): string;
+    /**
+     * @param {import("@babel/types").ContinueStatement} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ContinueStatement(node: any): string;
+    /**
+     * Converts an array of Babel AST nodes representing function parameters into a comma-separated string.
+     *
+     * Each parameter node is converted to its source representation and combined into a single
+     * string suitable for inserting into a function declaration's parentheses.
+     *
+     * @param {Node[]} params - An array of Babel AST nodes representing the function parameters to be stringified.
+     * @returns {string} A string representing the serialized parameters, enclosed in parentheses.
+     */
+    FunctionDeclarationParams(params: Node$1[]): string;
+    /**
+     * @param {import("@babel/types").FunctionDeclaration} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    FunctionDeclaration(node: any): string;
+    /**
+     * @param {import("@babel/types").FunctionExpression} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    FunctionExpression(node: any): string;
+    /**
+     * @param {import("@babel/types").ArrowFunctionExpression} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ArrowFunctionExpression(node: any): string;
+    /**
+     * @param {import("@babel/types").BigIntLiteral} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    BigIntLiteral(node: any): string;
+    /**
+     * @param {import("@babel/types").BlockStatement} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    BlockStatement(node: any): string;
+    /**
+     * > 'use strict';
+     *
+     * @param {import("@babel/types").Directive} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    Directive(node: any): string;
+    /**
+     * > 'use strict';
+     *
+     * @param {import("@babel/types").DirectiveLiteral} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    DirectiveLiteral(node: any): string;
+    /**
+     * @param {import("@babel/types").ReturnStatement} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ReturnStatement(node: any): string;
+    /**
+     * @param {import("@babel/types").Identifier} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    Identifier(node: any): string;
+    /**
+     * @param {import("@babel/types").IfStatement} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    IfStatement(node: any): string;
+    /**
+     * @param {import("@babel/types").LabeledStatement} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    LabeledStatement(node: any): string;
+    /**
+     * @example
+     * ts = require("typescript");
+     * ts.createSourceFile("repl.ts", "a = 1", ts.ScriptTarget.Latest);
+     * ts.createSourceFile("repl.ts", "!!(a = 1 + 2)", ts.ScriptTarget.Latest);
+     * showAST('!!(a = 1)');
+     * @param {import("@babel/types").UnaryExpression} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    UnaryExpression(node: any): string;
+    /**
+     * @param {import("@babel/types").MemberExpression} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    MemberExpression(node: any): string;
+    /**
+     * @param {import("@babel/types").MetaProperty} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    MetaProperty(node: any): string;
+    /**
+     * @param {import("@babel/types").ExpressionStatement} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ExpressionStatement(node: any): string;
+    /**
+     * @param {import("@babel/types").CallExpression} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    CallExpression(node: any, ...args: any[]): string;
+    /**
+     * We replicate the exact AST for validation:
+     * x = 1;
+     * y = {x,}
+     * z = {y};
+     * @param {import("@babel/types").ObjectExpression} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ObjectExpression(node: any): string;
+    /**
+     * @param {import("@babel/types").ObjectProperty} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ObjectProperty(node: any): string;
+    /**
+     * @param {import("@babel/types").BooleanLiteral} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    BooleanLiteral(node: any): string;
+    /**
+     * @param {import("@babel/types").AssignmentExpression} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    AssignmentExpression(node: any): string;
+    /**
+     * @param {import("@babel/types").BinaryExpression} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    BinaryExpression(node: any): string;
+    /**
+     * @param {import("@babel/types").ThisExpression} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ThisExpression(node: any): string;
+    /**
+     * @param {import("@babel/types").ArrayExpression} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ArrayExpression(node: any): string;
+    /**
+     * @param {import("@babel/types").VariableDeclaration} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    VariableDeclaration(node: any): string;
+    /**
+     * @param {import("@babel/types").VariableDeclarator} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    VariableDeclarator(node: any): string;
+    /**
+     * @param {import("@babel/types").ConditionalExpression} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ConditionalExpression(node: any): string;
+    /**
+     * if (...)
+     *
+     * @param {import("@babel/types").LogicalExpression} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    LogicalExpression(node: any): string;
+    /**
+     * TODO TEST: can init be undefined in for(;;)
+     *
+     * @param {import("@babel/types").ForStatement} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ForStatement(node: any): string;
+    /**
+     * showAST("++i")
+     *
+     * @param {import("@babel/types").UpdateExpression} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    UpdateExpression(node: any): string;
+    /**
+     * @param {import("@babel/types").NewExpression} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    NewExpression(node: any, ...args: any[]): string;
+    /**
+     * @example
+     * console.log(ast2json(parseSync("`${1} b ${2+3}c`").program.body[0]));
+     * @param {import("@babel/types").TemplateLiteral} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    TemplateLiteral(node: any): string;
+    /**
+     * @param {import("@babel/types").TemplateElement} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    TemplateElement(node: any): string;
+    /**
+     * @param {import("@babel/types").PrivateName} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    PrivateName(node: any): string;
+    /**
+     * @param {import("@babel/types").ExportAllDeclaration} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ExportAllDeclaration(node: any): string;
+    /**
+     * @param {import("@babel/types").ExportNamedDeclaration} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ExportNamedDeclaration(node: any): string;
+    /**
+     * @param {import("@babel/types").ExportDefaultDeclaration} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ExportDefaultDeclaration(node: any): string;
+    /**
+     * @param {import("@babel/types").ExportSpecifier} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ExportSpecifier(node: any): string;
+    /**
+     * @param {import("@babel/types").Super} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    Super(node: any): string;
+    /**
+     * @param {import("@babel/types").ForInStatement} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ForInStatement(node: any): string;
+    /**
+     * @param {import("@babel/types").ThrowStatement} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ThrowStatement(node: any): string;
+    /**
+     * @param {import("@babel/types").WhileStatement} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    WhileStatement(node: any): string;
+    /**
+     * @param {import("@babel/types").BreakStatement} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    BreakStatement(node: any): string;
+    /**
+     * @param {import("@babel/types").ForOfStatement} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ForOfStatement(node: any): string;
+    /**
+     * for (const [a, b] in c)
+     * --> [a, b] is the array pattern
+     *
+     * @param {import("@babel/types").ArrayPattern} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ArrayPattern(node: any): string;
+    /**
+     * @param {import("@babel/types").SwitchStatement} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    SwitchStatement(node: any): string;
+    /**
+     * @param {import("@babel/types").SwitchCase} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    SwitchCase(node: any): string;
+    /**
+     * @param {import("@babel/types").RegExpLiteral} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    RegExpLiteral(node: any): string;
+    /**
+     * for (var i=0, n=arr.length; i<n; i++)
+     * sequence expression: var i=0, n=arr.length
+     *
+     * @param {import("@babel/types").SequenceExpression} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    SequenceExpression(node: any): string;
+    /**
+     * showAST("if (true);");
+     *
+     * @param {import("@babel/types").EmptyStatement} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    EmptyStatement(node: any): string;
+    /**
+     * @param {import("@babel/types").SpreadElement} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    SpreadElement(node: any): string;
+    /**
+     * @param {import("@babel/types").ObjectMethod} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ObjectMethod(node: any): string;
+    /**
+     * E.g. function testComma({x,y,z,}) {}
+     * @param {import("@babel/types").ObjectPattern} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ObjectPattern(node: any): string;
+    /**
+     * > x?.y
+     * > x?.y.z
+     * > x[y?.z]
+     * > x?.[y?.z]
+     * > b?.file?.variants[variant]
+     *
+     * @param {import("@babel/types").OptionalMemberExpression} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    OptionalMemberExpression(node: any): string;
+    /**
+     * > version?.indexOf('$');
+     * > version?.indexOf?.('$');
+     * > this.passEncoder?.pushDebugGroup(name);
+     *
+     * @param {import("@babel/types").OptionalCallExpression} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    OptionalCallExpression(node: any, ...args: any[]): string;
+    /**
+     * @param {import("@babel/types").DoWhileStatement} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    DoWhileStatement(node: any): string;
+    /**
+     * @param {import("@babel/types").TryStatement} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    TryStatement(node: any): string;
+    /**
+     * @param {import("@babel/types").CatchClause} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    CatchClause(node: any): string;
+    /**
+     * @param {import("@babel/types").RestElement} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    RestElement(node: any): string;
+    /**
+     * @param {import("@babel/types").DebuggerStatement} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    DebuggerStatement(node: any): string;
+    /**
+     * @param {import("@babel/types").Import} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    Import(node: any): string;
+    /**
+     * @param {import("@babel/types").ImportDeclaration} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ImportDeclaration(node: any): string;
+    /**
+     * @param {import("@babel/types").ImportSpecifier} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ImportSpecifier(node: any): string;
+    /**
+     * @param {import("@babel/types").ImportDefaultSpecifier} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ImportDefaultSpecifier(node: any): string;
+    /**
+     * @param {import("@babel/types").ImportNamespaceSpecifier} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    ImportNamespaceSpecifier(node: any): string;
+    /**
+     * @param {import("@babel/types").File} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    File(node: any): string;
+    /**
+     * @param {import("@babel/types").Program} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    Program(node: any): string;
+    /**
+     * @param {import("@babel/types").StringLiteral} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    StringLiteral(node: any): string;
+    /**
+     * @param {import("@babel/types").NumericLiteral} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    NumericLiteral(node: any): string;
+    /**
+     * @param {import("@babel/types").AssignmentPattern} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    AssignmentPattern(node: any): string;
+    /**
+     * @param {import("@babel/types").NullLiteral} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    NullLiteral(node: any): string;
+    /**
+     * @param {import("@babel/types").TaggedTemplateExpression} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    TaggedTemplateExpression(node: any): string;
+    /**
+     * @param {import("@babel/types").YieldExpression} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    YieldExpression(node: any): string;
+}
+
+type Node = any;
+type ClassMethod = any;
+type ClassPrivateMethod = any;
+type Stat = Stat$1;
+type Options = {
+    /**
+     * - Determines whether curly braces are enforced in Stringifier.
+     */
+    forceCurly?: boolean;
+    /**
+     * - Indicates whether division operations should be validated.
+     */
+    validateDivision?: boolean;
+    /**
+     * - A function that expands shorthand types into full descriptions.
+     */
+    expandType?: Function;
+    /**
+     * - The name of a file to which the instance pertains.
+     */
+    filename?: string;
+};
+/** @typedef {import('@babel/types').Node              } Node               */
+/** @typedef {import("@babel/types").ClassMethod       } ClassMethod        */
+/** @typedef {import("@babel/types").ClassPrivateMethod} ClassPrivateMethod */
+/** @typedef {import('./stat.mjs').Stat                } Stat               */
+/**
+ * @typedef {object} Options
+ * @property {boolean} [forceCurly] - Determines whether curly braces are enforced in Stringifier.
+ * @property {boolean} [validateDivision] - Indicates whether division operations should be validated.
+ * @property {Function} [expandType] - A function that expands shorthand types into full descriptions.
+ * @property {string} [filename] - The name of a file to which the instance pertains.
+ */
+declare class Asserter extends Stringifier {
+    /**
+     * @param {Options} [options] - The options.
+     */
+    constructor({ forceCurly, validateDivision, expandType, filename }?: Options);
+    validateDivision: boolean;
+    expandType: Function;
+    filename: string;
+    /** @type {Record<string, Stat>} */
+    stats: Record<string, Stat>;
+    /**
+     * Finds the closest ancestor of the given node that matches the specified type.
+     *
+     * @param {Node} node - The starting node to search from.
+     * @param {string} type - The type of the node to search for.
+     * @returns {Node|undefined} The first ancestor node of the specified type, or undefined if none is found.
+     */
+    findParentOfType(node: any, type: string): Node | undefined;
+    /**
+     * Retrieves the node associated with the leading comments for an arrow function expression.
+     *
+     * This method travels up the syntax tree from the given node to find a parent node with leading comments.
+     * This search is bounded by function boundaries or a 'CallExpression' node, as per the logic defined within the loop.
+     * @param {Node} node - The node representing the arrow function expression for which to find the leading comments node.
+     * @returns {Node|undefined} The node that contains the leading comments, or `undefined`
+     * if none is found before reaching a different function or 'CallExpression'.
+     */
+    getLeadingCommentsNodeForArrowFunctionExpression(node: any): Node | undefined;
+    /**
+     * Emits a warning message to the console, optionally prefixed with the instance's filename.
+     * @param {...any} args - A list of arguments to be passed to the console.warn function.
+     */
+    warn(...args: any[]): void;
+    /**
+     * @param {Node} node - The Babel AST node.
+     * @returns {undefined | {}} The return value of `parseJSDoc`.
+     */
+    getJSDoc(node: any): undefined | {};
+    /**
+     * Retrieves the name of a parameter from a Babel AST node.
+     *
+     * This function expects a node representing a function parameter and attempts to extract
+     * the parameter's name directly or from an AssignmentPattern.
+     *
+     * @param {Node} param - The AST node representing the function parameter from which to extract the name.
+     * @returns {string} The name of the parameter as a string, or the parameter's source code if the extraction fails.
+     */
+    getNameOfParam(param: any): string;
+    statsReset(): void;
+    statsPrint(): void;
+    /**
+     * Retrieves statistical information for a given Babel AST node of this instance.
+     *
+     * @param {Node} node - The Babel AST node for which the statistical data is retrieved.
+     * @returns {Stat} An object containing the statistical data for the specified node. If the
+     * node type is unhandled, defaults to returning a dummy object with 'checked' and 'unchecked'
+     * properties both set to 0.
+     */
+    getStatsForNode(node: any): Stat;
+    /**
+     * Checks if a provided Babel AST node has a parameter with the given name.
+     *
+     * This function will look at the node's parameters if available and determine whether
+     * one of them matches the provided name. Supports various parameter types such as Identifiers
+     * and AssignmentPatterns.
+     *
+     * @param {Node} node - The Babel AST node to inspect. If it's a BlockStatement, the parent node is used instead.
+     * @param {string} name - The name of the parameter to look for within the node's parameters.
+     * @returns {boolean} True if the node has a parameter with the given name; false otherwise.
+     */
+    nodeHasParamName(node: any, name: string): boolean;
+    /**
+     * @param {Node} node - The Babel AST node.
+     * @returns {string} Stringification of the node.
+     */
+    getName(node: any): string;
+    /** @type {Record<string, object>} */
+    typedefs: Record<string, object>;
+}
+
+/**
+ * Simple facade which does all the processing. Processes the input
+ * source string, adding runtime type checks based on JSDoc comments.
+ *
+ * This function takes JavaScript source code as input, parses it to an AST, traverses the
+ * AST to find type annotations in JSDoc comments, and generates appropriate runtime type
+ * assertions. These are then inserted into the source, producing a new version of the code
+ * that includes runtime type checking based on the original JSDoc annotations.
+ *
+ * @param {string} src - The input source code containing JSDoc comments to be processed
+ * for type checks.
+ * @param {import('./Asserter.mjs').Options} [options] - Configuration options that dictate
+ * how the processing is performed.
+ * @returns {string} The transformed source code with inserted runtime type checks, or the
+ * original source code commented with an error if processing fails.
+ */
+declare function addTypeChecks(src: string, options?: Options): string;
+
+/**
+ * @param {object} ast - The Babel AST.
+ * @returns {string} String representation in JSON format for debugging/inspecting the AST.
+ */
+declare function ast2json(ast: object): string;
+
+/**
+ * @example
+ * setRight(ast2jsonForComparison(parseSync("/** *"))); // Close comment with / after last *
+ * @param {object} ast - The Babel AST.
+ * @returns {string} String representation in JSON format for debugging/inspecting the AST.
+ */
+declare function ast2jsonForComparison(ast: object): string;
+
+/**
+ * A roundtrip between code -> AST -> code to validate Stringifier.
+ * @param {string} code - The code.
+ * @returns {string | undefined} The new and once parsed and stringified code.
+ */
+declare function code2ast2code(code: string): string | undefined;
+
+/**
+ * @param {string} left - Left source code.
+ * @param {string} right - Right source code.
+ * @returns {boolean} Whether source codes are identical on the AST level.
+ */
+declare function compareAST(left: string, right: string): boolean;
+
+type TypeScriptType = {
+    /**
+     * - The type arguments.
+     */
+    typeArguments: object[] | undefined;
+    /**
+     * - The type name.
+     */
+    typeName: any;
+    /**
+     * - The kind for `ts.SyntaxKind[kind]`.
+     */
+    kind: number;
+};
+/**
+ * Transforms a type string into a structured type representation.
+ *
+ * This function parses a given type string and converts it into a TypeScript
+ * Abstract Syntax Tree (AST), then uses that AST to return a structured type
+ * representation that can be further utilized or interpreted.
+ *
+ * @todo Better handling of weird case: Array<>
+ * @todo implement TypeQuery, e.g. for expandType('typeof Number');
+ * @example
+ * const { expandType } = await import("./src-transpiler/expandType.mjs");
+ * expandType('[string, Array|AnyTypedArray, number[]]|[ONNXTensor]');
+ * expandType('(123)                    '); // Outputs: '123'
+ * expandType('  ( ( 123 ) )            '); // Outputs: '123'
+ * expandType('Array<number>            '); // Outputs: {type: 'array', elementType: 'number'}
+ * expandType('Array<(123) >            '); // Outputs: {type: 'array', elementType: '123'}
+ * expandType('Array<"abc" | 123>       '); // Outputs: {type: 'array', elementType: { type: 'union', members: [ '"abc"', '123' ]}}
+ * expandType('  (string ) |(number )   '); // Outputs: {type: 'union', members: [ 'string', 'number']}
+ * expandType(' "apples" | ( "bananas") '); // Outputs: {type: 'union', members: [ '"apples"', '"bananas"']}
+ * expandType('123?                     '); // Outputs: {"type":"union","members":["123","null"]}
+ * expandType('123|null                 '); // Outputs: {"type":"union","members":["123","null"]}
+ * expandType('Map<string, any>');
+ * @param {string} type - The type string to be expanded into a structured representation.
+ * @todo Share type with expandTypeBabelTS and expandTypeDepFree
+ * @returns {string | {type: string, [key: string]: any} | undefined} The structured type
+ * representation obtained from parsing and converting the provided type string.
+ */
+declare function expandType(type: string): string | {
+    [key: string]: any;
+    type: string;
+};
+/**
+ * @todo I want to use for example: import('typescript').Node
+ * But the TS types make no sense to me so far ... need to investigate more.
+ * @typedef TypeScriptType
+ * @property {object[]|undefined} typeArguments - The type arguments.
+ * @property {import('typescript').Node} typeName - The type name.
+ * @property {number} kind - The kind for `ts.SyntaxKind[kind]`.
+ */
+/**
+ * @param {string} str - The type string.
+ * @returns {TypeScriptType} - The node containing all the information about the input type string.
+ */
+declare function parseType(str: string): TypeScriptType;
+/**
+ * Converts a TypeScript AST node to a source string representation or to an intermediate object describing the type.
+ *
+ * This function handles various TypeScript AST node types and converts them into a string
+ * or an object representing the type.
+ *
+ * @param {TypeScriptType} node - The TypeScript AST node to convert.
+ * @returns {string | {type: string, [key: string]: any} | undefined} The source string or an object with type information based on the node,
+ * or `undefined` if the node kind is not handled.
+ */
+declare function toSourceTS(node: TypeScriptType): string | {
+    [key: string]: any;
+    type: string;
+};
+
+/**
+ * @todo Better handling of weird case: Array<>
+ * @todo implement TypeQuery, e.g. for expandTypeBabelTS('typeof Number');
+ * @example
+ * const { expandTypeBabelTS } = await import("./src-transpiler/expandTypeBabelTS.mjs");
+ * expandTypeBabelTS('[string, Array|AnyTypedArray, number[]]|[ONNXTensor]');
+ * expandTypeBabelTS('(123)                    '); // Outputs: '123'
+ * expandTypeBabelTS('  ( ( 123 ) )            '); // Outputs: '123'
+ * expandTypeBabelTS('Array<number>            '); // Outputs: {type: 'array', elementType: 'number'}
+ * expandTypeBabelTS('Array<(123) >            '); // Outputs: {type: 'array', elementType: '123'}
+ * expandTypeBabelTS('Array<"abc" | 123>       '); // Outputs: {type: 'array', elementType: { type: 'union', members: [ '"abc"', '123' ]}}
+ * expandTypeBabelTS('  (string ) |(number )   '); // Outputs: {type: 'union', members: [ 'string', 'number']}
+ * expandTypeBabelTS(' "apples" | ( "bananas") '); // Outputs: {type: 'union', members: [ '"apples"', '"bananas"']}
+ * expandTypeBabelTS('123?                     '); // Outputs: {"type":"union","members":["123","null"]}
+ * expandTypeBabelTS('123|null                 '); // Outputs: {"type":"union","members":["123","null"]}
+ * expandTypeBabelTS('Map<string, any>');
+ * expandTypeBabelTS("(a: number, b: number) => number")
+ * @param {string} type - The input type.
+ * @returns {string|object|undefined} - See `toSourceBabelTS`.
+ */
+declare function expandTypeBabelTS(type: string): string | object | undefined;
+/**
+ * @param {string} str - The type string.
+ * @returns {import('@babel/types').Node} - The node containing all the information about the input type string.
+ */
+declare function parseTypeBabelTS(str: string): any;
+/**
+ * Converts a Babel AST node to its source string representation or structured type object.
+ *
+ * This function handles a variety of node types provided by Babel and converts them into a string
+ * or an intermediate object representing the type, depending on the complexity of the type described by the node.
+ *
+ * @param {import('@babel/types').Node} node - The Babel AST node to convert.
+ * @returns {string|object|undefined} - A string, object representing a structured type, or `undefined` for unhandled types.
+ * Depending on the node, it may return a simple type string (e.g., `"string"` for `TSStringKeyword`),
+ * a structured type object (e.g., a record type for `TSTypeReference` with type arguments),
+ * or `undefined` if the encountered type is not handled. Unhandled types trigger a warning and enter a debugger statement.
+ */
+declare function toSourceBabelTS(node: any): string | object | undefined;
+
+type ExpandTypeReturnValue = {
+    /**
+     * - The type.
+     */
+    type: 'array' | 'union' | 'record' | 'tuple' | 'object';
+    /**
+     * - For Array.
+     */
+    elementType?: object | string;
+    /**
+     * - For Record<key, val>
+     */
+    key?: object | string;
+    /**
+     * - For Record<key, val>
+     */
+    val?: object | string;
+    /**
+     * - For unions.
+     */
+    members?: (object | string)[];
+    /**
+     * - For objects.
+     */
+    properties?: object | string;
+    /**
+     * - For tuples.
+     */
+    elements?: (object | string)[];
+};
+/**
+ * @todo expandTypeDepFree doesn't support "complicated" types.
+ * For actual builds, we use expandType() anyway (which is based on TypeScript).
+ * But since TypeScript is a huge dependency, I'm looking into BabelFlow/BabelTypescript parser.
+ * Comparing AST's like this usually helps to find bugs or potential issues,
+ * while we can benchmark for best performance too.
+ * @example
+ * const tooComplex = 'Array<string|{chunks?: undefined|Array<{language: string|null, timestamp: Array<number|null>, text: string}>}>';
+ * console.log(expandTypeDepFree(tooComplex));
+ */
+/**
+ * @typedef {object} ExpandTypeReturnValue
+ * @property {'array' | 'union' | 'record' | 'tuple' | 'object'} type - The type.
+ * @property {object | string} [elementType] - For Array.
+ * @property {object | string} [key] - For Record<key, val>
+ * @property {object | string} [val] - For Record<key, val>
+ * @property {(object | string)[]} [members] - For unions.
+ * @property {object | string} [properties] - For objects.
+ * @property {(object | string)[]} [elements] - For tuples.
+ */
+/**
+ * 'DepFree' refers to the fact that this function has no dependencies,
+ * while `expandType` depends on TypeScript itself for maximum compatibility.
+ * @example
+ * expandTypeDepFree('(123)                   '); // Outputs: '123'
+ * expandTypeDepFree('Array<number>           '); // Outputs: { type: 'array', elementType: 'number' }
+ * expandTypeDepFree('Array<(123) >           '); // Outputs: { type: 'array', elementType: '123' }
+ * expandTypeDepFree('  ( ( 123 ) )           '); // Outputs: '123'
+ * expandTypeDepFree('  (string ) |(number )  '); // Outputs: { type: 'union', members: ['string', 'number'] }
+ * expandTypeDepFree(' ((  Object  ) )        '); // Outputs: { type: 'object', properties: {} }
+ * @param {string} type - The input type to expand.
+ * @returns {string | ExpandTypeReturnValue} Object containing parsed information from type string.
+ */
+declare function expandTypeDepFree(type: string): string | ExpandTypeReturnValue;
+
+/**
+ * Extracts the parameter name and its optionality from a JSDoc parameter string.
+ *
+ * This function takes a rest parameter string from a JSDoc comment, trims it, and determines the parameter's
+ * name and whether it is optional. The optionality is inferred based on the presence of square brackets around
+ * the parameter name.
+ *
+ * @param {string} rest - The rest part of a JSDoc parameter string to parse.
+ * @returns {[string, boolean]} A tuple where the first element is the name of the parameter,
+ * and the second element is a boolean indicating if the parameter is optional.
+ */
+declare function extractNameAndOptionality(rest: string): [string, boolean];
+
+type Function$1 = any;
+/** @typedef {import('@babel/types').Node} Node */
+/** @typedef {import('@babel/types').Function} Function */
+/**
+ * Checks if the provided node is a function-like structure.
+ *
+ * @param {Node} node - The Babel AST node to be tested.
+ * @returns {node is Function} - `true` if the node is a function-like structure, otherwise `false`.
+ */
+declare function nodeIsFunction(node: any): node is globalThis.Function;
+
+/**
+ * Parses JSDoc comments to extract parameter type information.
+ *
+ * @param {string} src - The JSDoc comment string to parse.
+ * @param {Function} [expandType] - An optional function to process the types found in the JSDoc.
+ * @returns {Record<string, any> | undefined} An object mapping parameter names to their parsed types, or undefined if no parameters are found.
+ */
+declare function parseJSDoc(src: string, expandType?: Function): Record<string, any> | undefined;
+
+/**
+ * @param {string} src - JSDoc comment of the setter.
+ * @param {Function} expandType - The expandType function.
+ * @returns {string | DocType | undefined} The parsed and possibly expanded type from
+ * the JSDoc comment, or undefined if parsing fails to find `@type`.
+ */
+declare function parseJSDocSetter(src: string, expandType?: Function): string | DocType | undefined;
+
+/**
+ * Extracts the content of a string that is delimited by curly braces.
+ * @example
+ * extractCurlyContent('{ {inner} }'); // Returns: {content: ' {inner} ', nextIndex: 11}
+ * @param {string} line - The string to extract from.
+ * @returns {{content: string, nextIndex: number}} An object containing the extracted content,
+ * and the index of the character immediately following the closing curly brace.
+ */
+declare function extractCurlyContent(line: string): {
+    content: string;
+    nextIndex: number;
+};
+/**
+ * Parses JSDoc comments to extract and expand typedefs and their associated properties.
+ *
+ * It iterates through the lines of a `CommentBlock` from the Babel AST, looking for `@typedef` and `@property`
+ * annotations. When it finds a typedef, it stores it in the `typedefs` record. When it finds a property,
+ * it adds it to the last found typedef if it is an object type.
+ * @param {Record<string, object>} typedefs - An object to store typedefs, mapping type names to their expanded definitions.
+ * @param {Console["warn"]} warn - A warn function used for emitting warnings about non-extensible types.
+ * @param {import("@babel/types").Comment} comment - A comment extracted from Babel's AST, expected to be a CommentBlock containing type definitions.
+ * @param {Function} expandType - A function that takes a type expression as a string and returns a structured representation of the type.
+ */
+declare function parseJSDocTypedef(typedefs: Record<string, object>, warn: Console["warn"], comment: any, expandType: Function): void;
+
+type DocType$1 = {
+    /**
+     * - Type is optional.
+     */
+    optional: boolean;
+};
+/**
+ * @typedef DocType
+ * @property {boolean} optional - Type is optional.
+ */
+/**
+ * @param {string | DocType} type - The type.
+ * @param {boolean} optional - Optionality
+ * @returns {string | DocType} The simplified type.
+ */
+declare function simplifyType(type: string | DocType$1, optional: boolean): string | DocType$1;
+
+/**
+ * @example
+ * trimEndSpaces('test   \n   '); // Returns: 'test   \n'
+ * @param {string} str - The input string.
+ * @returns {string} Output string without spaces at the end.
+ */
+declare function trimEndSpaces(str: string): string;
+
+export { Asserter, type ClassMethod, type ClassPrivateMethod, type DocType$1 as DocType, type ExpandTypeReturnValue, type Function$1 as Function, type Options, type Stat, Stringifier, type TypeScriptType, addTypeChecks, ast2json, ast2jsonForComparison, code2ast2code, compareAST, expandType, expandTypeBabelTS, expandTypeDepFree, extractCurlyContent, extractNameAndOptionality, nodeIsFunction, parseJSDoc, parseJSDocSetter, parseJSDocTypedef, parseType, parseTypeBabelTS, simplifyType, toSourceBabelTS, toSourceTS, trimEndSpaces };