@borgar/fx 4.13.0 → 5.0.0

package/dist/index-BMr6cTgc.d.cts

@@ -0,0 +1,1444 @@
+/**
+ * A formula language token.
+ */
+type Token = Record<string, unknown> & {
+    /** The type of the token */
+    type: string;
+    /** The value of the token */
+    value: string;
+    /** Signifies an unterminated string token */
+    unterminated?: boolean;
+    /** Source position offsets to the token */
+    loc?: number[];
+};
+/**
+ * A token with extra meta data.
+ */
+type TokenEnhanced = Token & {
+    /** A zero based position in a token list */
+    index: number;
+    /** The ID of a group which this token belongs (e.g. matching parens) */
+    groupId?: string;
+    /** This token's level of nesting inside parentheses */
+    depth?: number;
+    /** Token is of unknown type or a paren without a match */
+    error?: boolean;
+};
+/**
+ * A range in R1C1 style coordinates.
+ */
+type RangeR1C1 = {
+    /** Top row of the range */
+    r0?: number | null;
+    /** Bottom row of the range */
+    r1?: number | null;
+    /** Left column of the range */
+    c0?: number | null;
+    /** Right column of the range */
+    c1?: number | null;
+    /** Signifies that r0 is an absolute value */
+    $r0?: boolean | null;
+    /** Signifies that r1 is an absolute value */
+    $r1?: boolean | null;
+    /** Signifies that c0 is an absolute value */
+    $c0?: boolean | null;
+    /** Signifies that c1 is an absolute value */
+    $c1?: boolean | null;
+    /** Should empty rows and columns at the top/left or bottom/right be discarded when range is read? */
+    trim?: 'head' | 'tail' | 'both' | null;
+};
+/**
+ * A range in A1 style coordinates.
+ */
+type RangeA1 = {
+    /** Top row of the range */
+    top: number | null;
+    /** Left column of the range */
+    left: number | null;
+    /** Bottom row of the range */
+    bottom?: number | null;
+    /** Right column of the range */
+    right?: number | null;
+    /** Signifies that top is a "locked" value */
+    $top?: boolean | null;
+    /** Signifies that bottom is a "locked" value */
+    $bottom?: boolean | null;
+    /** Signifies that left is a "locked" value */
+    $left?: boolean | null;
+    /** Signifies that right is a "locked" value */
+    $right?: boolean | null;
+    /** Should empty rows and columns at the top/left or bottom/right be discarded when range is read? */
+    trim?: 'head' | 'tail' | 'both' | null;
+};
+/**
+ * A reference containing an A1 style range. See [Prefixes.md](Prefixes.md) for
+ * documentation on how scopes work in Fx.
+ */
+type ReferenceA1 = {
+    /** A collection of scopes for the reference */
+    context?: string[];
+    /** The reference's range */
+    range: RangeA1;
+};
+/**
+ * A reference containing an A1 style range. See [Prefixes.md] for
+ * documentation on how scopes work in Fx.
+ */
+type ReferenceA1Xlsx = {
+    /** A context workbook scope */
+    workbookName?: string;
+    /** A context sheet scope */
+    sheetName?: string;
+    /** The reference's range */
+    range: RangeA1;
+};
+/**
+ * A reference containing a name. See [Prefixes.md] for
+ * documentation on how scopes work in Fx.
+ */
+type ReferenceName = {
+    /** A collection of scopes for the reference */
+    context?: string[];
+    /** The reference's name */
+    name: string;
+};
+/**
+ * A reference containing a name. See [Prefixes.md] for
+ * documentation on how scopes work in Fx.
+ */
+type ReferenceNameXlsx = {
+    /** A context workbook scope */
+    workbookName?: string;
+    /** A context sheet scope */
+    sheetName?: string;
+    /** The reference's name */
+    name: string;
+};
+/**
+ * A reference containing a R1C1 style range. See [Prefixes.md] for
+ * documentation on how scopes work in Fx.
+ */
+type ReferenceR1C1 = {
+    /** A collection of scopes for the reference */
+    context?: string[];
+    /** The reference's range */
+    range: RangeR1C1;
+};
+/**
+ * A reference containing a R1C1 style range. See [Prefixes.md] for
+ * documentation on how scopes work in Fx.
+ */
+type ReferenceR1C1Xlsx = {
+    /** A context workbook scope */
+    workbookName?: string;
+    /** A context sheet scope */
+    sheetName?: string;
+    /** The reference's range */
+    range: RangeR1C1;
+};
+/**
+ * A reference containing a table slice definition. See [Prefixes.md] for
+ * documentation on how scopes work in Fx.
+ */
+type ReferenceStruct = {
+    /** A collection of scopes for the reference */
+    context?: string[];
+    /** The sections this reference targets */
+    sections?: string[];
+    /** The sections this reference targets */
+    columns?: string[];
+    /** The table this reference targets */
+    table?: string;
+};
+/**
+ * A reference containing a table slice definition. See [Prefixes.md] for
+ * documentation on how scopes work in Fx.
+ */
+type ReferenceStructXlsx = {
+    /** A context workbook scope */
+    workbookName?: string;
+    /** A context sheet scope */
+    sheetName?: string;
+    /** The sections this reference targets */
+    sections?: string[];
+    /** The sections this reference targets */
+    columns?: string[];
+    /** The table this reference targets */
+    table?: string;
+};
+
+/**
+ * Options for {@link tokenize}.
+ */
+type OptsTokenize = {
+    /**
+     * Nodes will include source position offsets to the tokens: `{ loc: [ start, end ] }`
+     * @defaultValue true
+     */
+    withLocation?: boolean;
+    /**
+     * Should ranges be returned as whole references (`Sheet1!A1:B2`) or as separate tokens for each
+     * part: (`Sheet1`,`!`,`A1`,`:`,`B2`). This is the same as calling [`mergeRefTokens`](#mergeRefTokens)
+     * @defaultValue true
+     */
+    mergeRefs?: boolean;
+    /**
+     * Merges unary minuses with their immediately following number tokens (`-`,`1`) => `-1`
+     * (alternatively these will be unary operations in the tree).
+     * @defaultValue true
+     */
+    negativeNumbers?: boolean;
+    /**
+     * Enables the recognition of ternary ranges in the style of `A1:A` or `A1:1`. These are supported
+     * by Google Sheets but not Excel. See: [References.md](./References.md).
+     * @defaultValue false
+     */
+    allowTernary?: boolean;
+    /**
+     * Ranges are expected to be in the R1C1 style format rather than the more popular A1 style.
+     * @defaultValue false
+     */
+    r1c1?: boolean;
+};
+/**
+ * Breaks a string formula into a list of tokens.
+ *
+ * The returned output will be an array of objects representing the tokens:
+ *
+ * ```js
+ * [
+ *   { type: FX_PREFIX, value: '=' },
+ *   { type: FUNCTION, value: 'SUM' },
+ *   { type: OPERATOR, value: '(' },
+ *   { type: REF_RANGE, value: 'A1:B2' },
+ *   { type: OPERATOR, value: ')' }
+ * ]
+ * ```
+ *
+ * A collection of token types may be found as an object as the {@link tokenTypes}
+ * export on the package.
+ *
+ * _Warning:_ To support syntax highlighting as you type, `STRING` tokens are allowed to be
+ * "unterminated". For example, the incomplete formula `="Hello world` would be
+ * tokenized as:
+ *
+ * ```js
+ * [
+ *   { type: FX_PREFIX, value: '=' },
+ *   { type: STRING, value: '"Hello world', unterminated: true },
+ * ]
+ * ```
+ *
+ * Parsers will need to handle this.
+ *
+ * @see {@link OptsTokenize}
+ * @see {@link tokenTypes}
+ * @param formula An Excel formula string (an Excel expression).
+ * @param [options]  Options
+ * @returns An array of Tokens
+ */
+declare function tokenize(formula: string, options?: OptsTokenize): Token[];
+/**
+ * Breaks a string formula into a list of tokens.
+ *
+ * The returned output will be an array of objects representing the tokens:
+ *
+ * ```js
+ * [
+ *   { type: FX_PREFIX, value: '=' },
+ *   { type: FUNCTION, value: 'SUM' },
+ *   { type: OPERATOR, value: '(' },
+ *   { type: REF_RANGE, value: 'A1:B2' },
+ *   { type: OPERATOR, value: ')' }
+ * ]
+ * ```
+ *
+ * A collection of token types may be found as an object as the {@link tokenTypes}
+ * export on the package.
+ *
+ * _Warning:_ To support syntax highlighting as you type, `STRING` tokens are allowed to be
+ * "unterminated". For example, the incomplete formula `="Hello world` would be
+ * tokenized as:
+ *
+ * ```js
+ * [
+ *   { type: FX_PREFIX, value: '=' },
+ *   { type: STRING, value: '"Hello world', unterminated: true },
+ * ]
+ * ```
+ *
+ * @see {@link OptsTokenize}
+ * @see {@link tokenTypes}
+ * @param formula An Excel formula string (an Excel expression).
+ * @param [options]  Options
+ * @returns An array of Tokens
+ */
+declare function tokenizeXlsx(formula: string, options?: OptsTokenize): Token[];
+
+/**
+ * Represents the source location information of the node.
+ * If the node contains no information about the source location, the field is `null`;
+ * otherwise it is an array consisting of a two numbers: A start offset (the position of
+ * the first character of the parsed source region) and an end offset (the position of
+ * the first character after the parsed source region).
+ */
+type SourceLocation = number[];
+/**
+ * All AST nodes are represented by `Node` objects.
+ * They may have any prototype inheritance but implement the same basic interface.
+ *
+ * The `type` field is a string representing the AST variant type.
+ * Each subtype of Node is documented below with the specific string of its `type` field.
+ * You can use this field to determine which interface a node implements.
+ */
+type Node = {
+    /** The type of this AST node. */
+    type: string;
+    /** The original source position of the node. */
+    loc?: SourceLocation;
+};
+/**
+ * An identifier. These appear on `CallExpression`, `LambdaExpression`, and `LetExpression`
+ * and will always be a static string representing the name of a function call or parameter.
+ */
+type Identifier = {
+    /** The type of this AST node. */
+    type: 'Identifier';
+    /** The original source position of the node. */
+    loc?: SourceLocation;
+    /** The identifying name. */
+    name: string;
+} & Node;
+/**
+ * An identifier for a range or a name.
+ */
+type ReferenceIdentifier = {
+    /** The type of this AST node. */
+    type: 'ReferenceIdentifier';
+    /** The original source position of the node. */
+    loc?: SourceLocation;
+    /** The untouched reference value. */
+    value: string;
+    /** The kind of reference the value holds. */
+    kind: 'name' | 'range' | 'beam' | 'table';
+} & Node;
+/**
+ * A literal token. Captures numbers, strings, and booleans.
+ * Literal errors have their own variant type.
+ */
+type Literal = {
+    /** The type of this AST node. */
+    type: 'Literal';
+    /** The original source position of the node. */
+    loc?: SourceLocation;
+    /** The untouched literal source. */
+    raw: string;
+    /** The value of the literal. */
+    value: string | number | boolean;
+} & Node;
+/**
+ * An Error expression.
+ */
+type ErrorLiteral = {
+    /** The type of this AST node. */
+    type: 'ErrorLiteral';
+    /** The original source position of the node. */
+    loc?: SourceLocation;
+    /** The untouched literal source. */
+    raw: string;
+    /** The value of the error. */
+    value: string;
+} & Node;
+/**
+ * A unary operator expression.
+ */
+type UnaryExpression = {
+    /** The type of this AST node. */
+    type: 'UnaryExpression';
+    /** The original source position of the node. */
+    loc?: SourceLocation;
+    /** The expression's operator. */
+    operator: UnaryOperator;
+    /** The arguments for the operator. */
+    arguments: AstExpression[];
+} & Node;
+/**
+ * A unary operator token.
+ */
+type UnaryOperator = ('+' | '-' | '%' | '#' | '@');
+/**
+ * A binary operator expression.
+ */
+type BinaryExpression = {
+    /** The type of this AST node. */
+    type: 'BinaryExpression';
+    /** The original source position of the node. */
+    loc?: SourceLocation;
+    /** The expression's operator. */
+    operator: BinaryOperator;
+    /** The arguments for the operator. */
+    arguments: AstExpression[];
+} & Node;
+/**
+ * A binary operator token.
+ *
+ * Note that Excels union operator is whitespace so a parser must take care to normalize this to
+ * a single space.
+ */
+type BinaryOperator = ('=' | '<' | '>' | '<=' | '>=' | '<>' | '-' | '+' | '*' | '/' | '^' | ':' | ' ' | ',' | '&');
+/**
+ * A function call expression.
+ */
+type CallExpression = {
+    /** The type of this AST node. */
+    type: 'CallExpression';
+    /** The original source position of the node. */
+    loc?: SourceLocation;
+    /** The function being called. */
+    callee: Identifier;
+    /** The arguments for the function. */
+    arguments: AstExpression[];
+} & Node;
+/**
+ * An array expression. Excel does not have empty or sparse arrays and restricts array elements to
+ * literals. Google Sheets allows `ReferenceIdentifier`s and `CallExpression`s as elements of
+ * arrays, the fx parser has options for this but they are off by default.
+ */
+type ArrayExpression = {
+    /** The type of this AST node. */
+    type: 'ArrayExpression';
+    /** The original source position of the node. */
+    loc?: SourceLocation;
+    /** The elements of the array. */
+    elements: (ReferenceIdentifier | Literal | ErrorLiteral | CallExpression)[][];
+} & Node;
+/**
+ * A LAMBDA expression.
+ */
+type LambdaExpression = {
+    /** The type of this AST node. */
+    type: 'LambdaExpression';
+    /** The original source position of the node. */
+    loc?: SourceLocation;
+    /** The LAMBDA's parameters. */
+    params: Identifier[];
+    /** The LAMBDA's expression. */
+    body: AstExpression | null;
+} & Node;
+/**
+ * A LET expression.
+ */
+type LetExpression = {
+    /** The type of this AST node. */
+    type: 'LetExpression';
+    /** The original source position of the node. */
+    loc?: SourceLocation;
+    /** The LET's variable declarations. */
+    declarations: LetDeclarator[];
+    /** The LET's scoped expression. */
+    body: AstExpression | null;
+} & Node;
+/**
+ * A LET parameter declaration.
+ */
+type LetDeclarator = {
+    /** The type of this AST node. */
+    type: 'LetDeclarator';
+    /** The original source position of the node. */
+    loc?: SourceLocation;
+    /** The name of the variable. */
+    id: Identifier;
+    /** The variable's initializing expression. */
+    init: AstExpression | null;
+} & Node;
+/**
+ * Represents an evaluate-able expression.
+ */
+type AstExpression = ReferenceIdentifier | Literal | ErrorLiteral | UnaryExpression | BinaryExpression | CallExpression | ArrayExpression | LambdaExpression | LetExpression;
+
+/**
+ * Options for {@link parse}.
+ */
+type OptsParse = {
+    /**
+     * Ranges are allowed as elements of arrays. This is a feature in Google Sheets while Excel
+     * does not allow it.
+     * @defaultValue false
+     */
+    permitArrayRanges?: boolean;
+    /**
+     * Function calls are allowed as elements of arrays. This is a feature in Google Sheets
+     * while Excel does not allow it.
+     * @defaultValue false
+     */
+    permitArrayCalls?: boolean;
+    /**
+     * Permits any function call where otherwise only functions that return references would
+     * be permitted.
+     * @defaultValue false
+     */
+    looseRefCalls?: boolean;
+};
+/**
+ * Parses a string formula or list of tokens into an AST.
+ *
+ * The parser assumes `mergeRefs` and `negativeNumbers` were `true` when the tokens were generated.
+ * It does not yet recognize reference context tokens or know how to deal with unary minuses in
+ * arrays.
+ *
+ * The AST Abstract Syntax Tree's format is documented in
+ * [AST_format.md](./AST_format.md).
+ *
+ * @see {@link OptsParse}
+ * @see {@link nodeTypes}
+ * @see {@link tokenize}
+ * @param tokenlist An array of tokens.
+ * @param options Options for the parsers behavior.
+ * @returns An AST of nodes.
+ */
+declare function parse(tokenlist: Token[], options?: OptsParse): AstExpression;
+
+/**
+ * Options for {@link translateFormulaToR1C1}.
+ */
+type OptsTranslateToR1C1 = {
+    /**
+     * Enables the recognition of ternary ranges in the style of `A1:A` or `A1:1`.
+     * These are supported by Google Sheets but not Excel.
+     * See: [References.md](./References.md).
+     * @defaultValue true
+     */
+    allowTernary?: boolean;
+};
+/**
+ * Translates ranges in a list of tokens from absolute A1 syntax to relative R1C1 syntax.
+ *
+ * ```js
+ * translateFormulaToR1C1("=SUM(E10,$E$2,Sheet!$E$3)", "D10");
+ * // => "=SUM(RC[1],R2C5,Sheet!R3C5)");
+ * ```
+ *
+ * @param tokens A token list that should be adjusted.
+ * @param anchorCell A simple string reference to an A1 cell ID (`AF123` or`$C$5`).
+ * @returns A token list.
+ */
+declare function translateTokensToR1C1(tokens: Token[], anchorCell: string): Token[];
+/**
+ * Translates ranges in a formula from absolute A1 syntax to relative R1C1 syntax.
+ *
+ * ```js
+ * translateFormulaToR1C1("=SUM(E10,$E$2,Sheet!$E$3)", "D10");
+ * // => "=SUM(RC[1],R2C5,Sheet!R3C5)");
+ * ```
+ *
+ * @see {@link OptsTranslateToR1C1}
+ * @param formula An Excel formula that should be adjusted.
+ * @param anchorCell A simple string reference to an A1 cell ID (`AF123` or`$C$5`).
+ * @param [options={}] The options
+ * @returns A formula string.
+ */
+declare function translateFormulaToR1C1(formula: string, anchorCell: string, options?: OptsTranslateToR1C1): string;
+
+/**
+ * Options for {@link translateTokensToA1}
+ */
+type OptsTranslateTokensToA1 = {
+    /**
+    * Wrap out-of-bounds ranges around sheet edges rather than turning them to #REF! errors.
+    * @defaultValue true
+    */
+    wrapEdges?: boolean;
+};
+/**
+ * Translates ranges in a list of tokens from relative R1C1 syntax to absolute A1 syntax.
+ *
+ * ```js
+ * translateToA1("=SUM(RC[1],R2C5,Sheet!R3C5)", "D10");
+ * // => "=SUM(E10,$E$2,Sheet!$E$3)");
+ * ```
+ *
+ * If an input range is -1,-1 relative rows/columns and the anchor is A1, the
+ * resulting range will (by default) wrap around to the bottom of the sheet
+ * resulting in the range XFD1048576. This may not be what you want so may set
+ * `{ wrapEdges }` to false which will instead turn the range into a `#REF!` error.
+ *
+ * ```js
+ * translateToA1("=R[-1]C[-1]", "A1");
+ * // => "=XFD1048576");
+ *
+ * translateToA1("=R[-1]C[-1]", "A1", { wrapEdges: false });
+ * // => "=#REF!");
+ * ```
+ *
+ * Note that if you are passing in a list of tokens that was not created using
+ * `mergeRefs` and you disable edge wrapping (or you simply set both options
+ * to false), you can end up with a formula such as `=#REF!:B2` or
+ * `=Sheet3!#REF!:F3`. These are valid formulas in the Excel formula language
+ * and Excel will accept them, but they are not supported in Google Sheets.
+ *
+ * @see {@link OptsTranslateTokensToA1}
+ * @param tokens A token list that should be adjusted.
+ * @param anchorCell A simple string reference to an A1 cell ID (`AF123` or`$C$5`).
+ * @param options Translation options.
+ * @returns A token list.
+ */
+declare function translateTokensToA1(tokens: Token[], anchorCell: string, options?: OptsTranslateTokensToA1): Token[];
+/**
+ * Options for {@link translateFormulaToA1}.
+ */
+type OptsTranslateFormulaToA1 = {
+    /**
+    * Wrap out-of-bounds ranges around sheet edges rather than turning them to #REF! errors.
+    * @defaultValue true
+    */
+    wrapEdges?: boolean;
+    /**
+    * Should ranges be treated as whole references (`Sheet1!A1:B2`) or as separate tokens
+    * for each part: (`Sheet1`,`!`,`A1`,`:`,`B2`).
+    * @defaultValue true
+    */
+    mergeRefs?: boolean;
+    /**
+    * Enables the recognition of ternary ranges in the style of `A1:A` or `A1:1`.
+    * These are supported by Google Sheets but not Excel. See: References.md.
+    * @defaultValue true
+    */
+    allowTernary?: boolean;
+};
+/**
+ * Translates ranges in a formula from relative R1C1 syntax to absolute A1 syntax.
+ *
+ * ```js
+ * translateToA1("=SUM(RC[1],R2C5,Sheet!R3C5)", "D10");
+ * // => "=SUM(E10,$E$2,Sheet!$E$3)");
+ * ```
+ *
+ * If an input range is -1,-1 relative rows/columns and the anchor is A1, the
+ * resulting range will (by default) wrap around to the bottom of the sheet
+ * resulting in the range XFD1048576. This may not be what you want so you can set
+ * `{ wrapEdges }` to false which will instead turn the range into a `#REF!` error.
+ *
+ * ```js
+ * translateToA1("=R[-1]C[-1]", "A1");
+ * // => "=XFD1048576");
+ *
+ * translateToA1("=R[-1]C[-1]", "A1", { wrapEdges: false });
+ * // => "=#REF!");
+ * ```
+ *
+ * @see {@link OptsTranslateFormulaToA1}
+ * @param formula An Excel formula string that should be adjusted.
+ * @param anchorCell A simple string reference to an A1 cell ID (`AF123` or`$C$5`).
+ * @param options Translation options.
+ * @returns A formula string.
+ */
+declare function translateFormulaToA1(formula: string, anchorCell: string, options?: OptsTranslateFormulaToA1): string;
+
+/** The maximum number of columns a spreadsheet reference may hold (16383). */
+declare const MAX_COLS: number;
+/** The maximum number of rows a spreadsheet reference may hold (1048575). */
+declare const MAX_ROWS: number;
+
+/**
+ * Merges context with reference tokens as possible in a list of tokens.
+ *
+ * When given a tokenlist, this function returns a new list with ranges returned
+ * as whole references (`Sheet1!A1:B2`) rather than separate tokens for each
+ * part: (`Sheet1`,`!`,`A1`,`:`,`B2`).
+ *
+ * @param tokenlist An array of tokens.
+ * @returns A new list of tokens with range parts merged.
+ */
+declare function mergeRefTokens(tokenlist: Token[]): Token[];
+
+/**
+ * Options for {@link fixTokenRanges} and {@link fixFormulaRanges}.
+ */
+type OptsFixRanges = {
+    /**
+     * Fill in any undefined bounds of range objects. Top to 0, bottom to 1048575, left to 0, and right to 16383.
+     * @defaultValue false
+     */
+    addBounds?: boolean;
+    /**
+     * Enforces using the `[#This Row]` instead of the `@` shorthand when serializing structured ranges.
+     * @defaultValue false
+     */
+    thisRow?: boolean;
+};
+/**
+ * Normalizes A1 style ranges and structured references in a list of tokens.
+ *
+ * It ensures that that the top and left coordinates of an A1 range are on the
+ * left-hand side of a colon operator:
+ *
+ * ```
+ * B2:A1 → A1:B2
+ * 1:A1 → A1:1
+ * A:A1 → A1:A
+ * B:A → A:B
+ * 2:1 → 1:2
+ * A1:A1 → A1
+ * ```
+ *
+ * When `{ addBounds }` option is set to true, the missing bounds are also added.
+ * This can be done to ensure Excel compatible ranges. The fixes then additionally include:
+ *
+ * ```
+ * 1:A1 → A1:1 → 1:1
+ * A:A1 → A1:A → A:A
+ * A1:A → A:A
+ * A1:1 → A:1
+ * B2:B → B2:1048576
+ * B2:2 → B2:XFD2
+ * ```
+ *
+ * Structured ranges are normalized to have consistent order and capitalization
+ * of sections as well as removing redundant ones.
+ *
+ * Returns a new array of tokens with values and position data updated.
+ *
+ * @see {@link OptsFixRanges}
+ * @param tokens A list of tokens to be adjusted.
+ * @param [options]  Options.
+ * @returns A token list with ranges adjusted.
+ */
+declare function fixTokenRanges(tokens: Token[], options?: OptsFixRanges): Token[];
+/**
+ * Normalizes A1 style ranges and structured references in a list of tokens.
+ *
+ * It ensures that that the top and left coordinates of an A1 range are on the
+ * left-hand side of a colon operator:
+ *
+ * ```
+ * B2:A1 → A1:B2
+ * 1:A1 → A1:1
+ * A:A1 → A1:A
+ * B:A → A:B
+ * 2:1 → 1:2
+ * A1:A1 → A1
+ * ```
+ *
+ * When `{ addBounds }` option is set to true, the missing bounds are also added.
+ * This can be done to ensure Excel compatible ranges. The fixes then additionally include:
+ *
+ * ```
+ * 1:A1 → A1:1 → 1:1
+ * A:A1 → A1:A → A:A
+ * A1:A → A:A
+ * A1:1 → A:1
+ * B2:B → B2:1048576
+ * B2:2 → B2:XFD2
+ * ```
+ *
+ * Structured ranges are normalized to have consistent order and capitalization
+ * of sections as well as removing redundant ones.
+ *
+ * Returns a new array of tokens with values and position data updated.
+ *
+ * @see {@link OptsFixRanges}
+ * @param tokens A list of tokens to be adjusted.
+ * @param [options]  Options.
+ * @returns A token list with ranges adjusted.
+ */
+declare function fixTokenRangesXlsx(tokens: Token[], options?: OptsFixRanges): Token[];
+/**
+ * Normalizes A1 style ranges and structured references in a formula.
+ *
+ * Internally it uses {@link fixTokenRanges} so see it's documentation for details.
+ *
+ * Returns the same formula with the ranges updated. If an array of tokens was
+ * supplied, then a new array is returned.
+ *
+ * @see {@link OptsFixRanges} & {@link OptsTokenize}
+ * @param formula A string (an Excel formula) or a token list that should be adjusted.
+ * @param [options]  Options
+ * @returns A formula string with ranges adjusted
+ */
+declare function fixFormulaRanges(formula: string, options?: OptsFixRanges & OptsTokenize): string;
+/**
+ * Normalizes A1 style ranges and structured references in a formula.
+ *
+ * Internally it uses {@link fixTokenRanges} so see it's documentation for details.
+ *
+ * Returns the same formula with the ranges updated. If an array of tokens was
+ * supplied, then a new array is returned.
+ *
+ * @see {@link OptsFixRanges} & {@link OptsTokenize}
+ * @param formula A string (an Excel formula) or a token list that should be adjusted.
+ * @param [options]  Options
+ * @returns A formula string with ranges adjusted
+ */
+declare function fixFormulaRangesXlsx(formula: string, options?: OptsFixRanges & OptsTokenize): string;
+
+/**
+ * Determines whether the specified token is a range.
+ *
+ * Returns `true` if the input is a token that has a type of either REF_RANGE
+ * (`A1` or `A1:B2`), REF_TERNARY (`A1:A`, `A1:1`, `1:A1`, or `A:A1`), or
+ * REF_BEAM (`A:A` or `1:1`). In all other cases `false` is returned.
+ *
+ * @param token A token
+ * @returns True if the specified token is range, False otherwise.
+ */
+declare function isRange(token?: Pick<Token, 'type'> | null): boolean;
+/**
+ * Determines whether the specified token is a reference.
+ *
+ * Returns `true` if the input is a token of type REF_RANGE (`A1` or `A1:B2`),
+ * REF_TERNARY (`A1:A`, `A1:1`, `1:A1`, or `A:A1`), REF_BEAM (`A:A` or `1:1`),
+ * or REF_NAMED (`myrange`). In all other cases `false` is returned.
+ *
+ * @param token The token
+ * @returns True if the specified token is reference, False otherwise.
+ */
+declare function isReference(token?: Pick<Token, 'type'> | null): boolean;
+/**
+ * Determines whether the specified token is a literal.
+ *
+ * Returns `true` if the input is a token of type BOOLEAN (`TRUE` or `FALSE`),
+ * ERROR (`#VALUE!`), NUMBER (123.4), or STRING (`"lorem ipsum"`). In all other
+ * cases `false` is returned.
+ *
+ * @param token The token
+ * @returns True if the specified token is literal, False otherwise.
+ */
+declare function isLiteral(token?: Pick<Token, 'type'> | null): boolean;
+/**
+ * Determines whether the specified token is an error.
+ *
+ * Returns `true` if the input is a token of type ERROR (`#VALUE!`). In all
+ * other cases `false` is returned.
+ *
+ * @param token The token
+ * @returns True if the specified token is error, False otherwise.
+ */
+declare function isError(token?: Pick<Token, 'type'> | null): boolean;
+/**
+ * Determines whether the specified token is whitespace.
+ *
+ * Returns `true` if the input is a token of type WHITESPACE (` `) or
+ * NEWLINE (`\n`). In all other cases `false` is returned.
+ *
+ * @param token The token
+ * @returns True if the specified token is whitespace, False otherwise.
+ */
+declare function isWhitespace(token?: Pick<Token, 'type'> | null): boolean;
+/**
+ * Determines whether the specified token is a function.
+ *
+ * Returns `true` if the input is a token of type FUNCTION.
+ * In all other cases `false` is returned.
+ *
+ * @param token The token
+ * @returns True if the specified token is function, False otherwise.
+ */
+declare function isFunction(token?: Pick<Token, 'type'> | null): boolean;
+/**
+ * Returns `true` if the input is a token of type FX_PREFIX (leading `=` in
+ * formula). In all other cases `false` is returned.
+ *
+ * @param token The token
+ * @returns True if the specified token is effects prefix, False otherwise.
+ */
+declare function isFxPrefix(token?: Pick<Token, 'type'> | null): boolean;
+/**
+ * Determines whether the specified token is an operator.
+ *
+ * Returns `true` if the input is a token of type OPERATOR (`+` or `:`). In all
+ * other cases `false` is returned.
+ *
+ * @param token The token
+ * @returns True if the specified token is operator, False otherwise.
+ */
+declare function isOperator(token?: Pick<Token, 'type'> | null): boolean;
+
+/**
+ * Determines whether the specified node is an Identifier.
+ * @param node An AST node.
+ * @returns True if the specified token is an Identifier, False otherwise.
+ */
+declare function isIdentifierNode(node?: Node | null): node is Identifier;
+/**
+ * Determines whether the specified node is a ReferenceIdentifier.
+ * @param node An AST node.
+ * @returns True if the specified token is a ReferenceIdentifier, False otherwise.
+ */
+declare function isReferenceNode(node?: Node | null): node is ReferenceIdentifier;
+/**
+ * Determines whether the specified node is a Literal.
+ * @param node An AST node.
+ * @returns True if the specified token is a Literal, False otherwise.
+ */
+declare function isLiteralNode(node?: Node | null): node is Literal;
+/**
+ * Determines whether the specified node is an ErrorLiteral.
+ * @param node An AST node.
+ * @returns True if the specified token is an ErrorLiteral, False otherwise.
+ */
+declare function isErrorNode(node?: Node | null): node is ErrorLiteral;
+/**
+ * Determines whether the specified node is a UnaryExpression.
+ * @param node An AST node.
+ * @returns True if the specified token is a UnaryExpression, False otherwise.
+ */
+declare function isUnaryNode(node?: Node | null): node is UnaryExpression;
+/**
+ * Determines whether the specified node is a BinaryExpression.
+ * @param node An AST node.
+ * @returns True if the specified token is a BinaryExpression, False otherwise.
+ */
+declare function isBinaryNode(node?: Node | null): node is BinaryExpression;
+/**
+ * Determines whether the specified node is a CallExpression.
+ * @param node An AST node.
+ * @returns True if the specified token is a CallExpression, False otherwise.
+ */
+declare function isCallNode(node?: Node | null): node is CallExpression;
+/**
+ * Determines whether the specified node is a ArrayExpression.
+ * @param node An AST node.
+ * @returns True if the specified token is a ArrayExpression, False otherwise.
+ */
+declare function isArrayNode(node?: Node | null): node is ArrayExpression;
+/**
+ * Determines whether the specified node is a LambdaExpression.
+ * @param node An AST node.
+ * @returns True if the specified token is a LambdaExpression, False otherwise.
+ */
+declare function isLambdaNode(node?: Node | null): node is LambdaExpression;
+/**
+ * Determines whether the specified node is a LetExpression.
+ * @param node An AST node.
+ * @returns True if the specified token is a LetExpression, False otherwise.
+ */
+declare function isLetNode(node?: Node | null): node is LetExpression;
+/**
+ * Determines whether the specified node is a LetDeclarator.
+ * @param node An AST node.
+ * @returns True if the specified token is a LetDeclarator, False otherwise.
+ */
+declare function isLetDeclaratorNode(node?: Node | null): node is LetDeclarator;
+/**
+ * Determines whether the specified node is a AstExpression.
+ * @param node An AST node.
+ * @returns True if the specified token is a AstExpression, False otherwise.
+ */
+declare function isExpressionNode(node?: Node | null): node is AstExpression;
+
+/**
+ * Fill the any missing bounds in range objects. Top will be set to 0, bottom to
+ * 1048575, left to 0, and right to 16383, if they are `null` or `undefined`.
+ *
+ * ```js
+ * addA1RangeBounds({
+ *   top: 0,
+ *   left: 0,
+ *   bottom: 1,
+ *   $top: true,
+ *   $left: false,
+ *   $bottom: false,
+ * });
+ * // => {
+ * //   top: 0,
+ * //   left: 0,
+ * //   bottom: 1,
+ * //   right: 16383,  // ← Added
+ * //   $top: true,
+ * //   $left: false,
+ * //   $bottom: false,
+ * //   $right: false  // ← Added
+ * // }
+ * ```
+ *
+ * @param range The range part of a reference object.
+ * @returns The same range with missing bounds filled in.
+ */
+declare function addA1RangeBounds(range: RangeA1): RangeA1;
+
+/**
+ * Convert a 0 based offset number to a column string
+ * representation (`0` = `"A"`, `2` = `"C"`).
+ *
+ * The method expects a number between 0 and 16383. Other input will
+ * return garbage.
+ *
+ * @param columnIndex Zero based column index number
+ * @returns The column string identifier
+ */
+declare function toCol(columnIndex: number): string;
+
+/**
+ * Convert a column string representation to a 0 based
+ * offset number (`"C"` = `2`).
+ *
+ * The method expects a valid column identifier made up of _only_
+ * A-Z letters, which may be either upper or lower case. Other input will
+ * return garbage.
+ *
+ * @param {string} columnString  The column string identifier
+ * @returns {number}  Zero based column index number
+ */
+declare function fromCol(columnString: string): number;
+
+/**
+ * Parse A1-style range string into a RangeA1 object.
+ *
+ * @param rangeString A1-style range string.
+ * @param [allowTernary] Permit ternary ranges like A2:A or B2:2.
+ * @return A reference object.
+ */
+declare function parseA1Range(rangeString: string, allowTernary?: boolean): RangeA1 | undefined;
+
+/**
+ * Options for {@link parseA1Ref}.
+ */
+type OptsParseA1Ref = {
+    /**
+     * Enable parsing names as well as ranges.
+     * @defaultValue true
+     */
+    allowNamed?: boolean;
+    /**
+     * Enables the recognition of ternary ranges in the style of `A1:A` or `A1:1`.
+     * These are supported by Google Sheets but not Excel. See: [References.md](./References.md).
+     * @defaultValue false
+     */
+    allowTernary?: boolean;
+};
+/**
+ * Parse a string reference into an object representing it.
+ *
+ * ```js
+ * parseA1Ref('Sheet1!A$1:$B2');
+ * // => {
+ * //   context: [ 'Sheet1' ],
+ * //   range: {
+ * //     top: 0,
+ * //     left: 0,
+ * //     bottom: 1,
+ * //     right: 1
+ * //     $top: true,
+ * //     $left: false,
+ * //     $bottom: false,
+ * //     $right: true
+ * //   }
+ * // }
+ * ```
+ *
+ * For A:A or A1:A style ranges, `null` will be used for any dimensions that the
+ * syntax does not specify.
+ *
+ * @see {@link OptsParseA1Ref}
+ * @param refString An A1-style reference string.
+ * @param options Options.
+ * @returns An object representing a valid reference or `undefined` if it is invalid.
+ */
+declare function parseA1Ref(refString: string, { allowNamed, allowTernary }?: OptsParseA1Ref): ReferenceA1 | ReferenceName | undefined;
+/**
+ * Parse a string reference into an object representing it.
+ *
+ * ```js
+ * parseA1Ref('Sheet1!A$1:$B2');
+ * // => {
+ * //   workbookName: '',
+ * //   sheetName: 'Sheet1',
+ * //   range: {
+ * //     top: 0,
+ * //     left: 0,
+ * //     bottom: 1,
+ * //     right: 1
+ * //     $top: true,
+ * //     $left: false,
+ * //     $bottom: false,
+ * //     $right: true
+ * //   }
+ * // }
+ * ```
+ *
+ * For A:A or A1:A style ranges, `null` will be used for any dimensions that the
+ * syntax does not specify.
+ *
+ * @see {@link OptsParseA1Ref}
+ * @param refString An A1-style reference string.
+ * @param options Options.
+ * @returns An object representing a valid reference or `undefined` if it is invalid.
+ */
+declare function parseA1RefXlsx(refString: string, { allowNamed, allowTernary }?: OptsParseA1Ref): ReferenceA1Xlsx | ReferenceNameXlsx | undefined;
+
+/**
+ * Parse R1C1-style range string into a RangeR1C1 object.
+ *
+ * @param rangeString R1C1-style range string.
+ * @return A reference object.
+ */
+declare function parseR1C1Range(rangeString: string): RangeR1C1 | null;
+
+/**
+ * Options for {@link parseR1C1Ref}.
+ */
+type OptsParseR1C1Ref = {
+    /**
+     * Enable parsing names as well as ranges.
+     * @defaultValue true
+     */
+    allowNamed?: boolean;
+    /**
+     * Enables the recognition of ternary ranges in the style of `A1:A` or `A1:1`.
+     * These are supported by Google Sheets but not Excel.
+     * See: [References.md](./References.md).
+     * @defaultValue false
+     */
+    allowTernary?: boolean;
+};
+/**
+ * Parse a string reference into an object representing it.
+ *
+ * ```js
+ * parseR1C1Ref('Sheet1!R[9]C9:R[9]C9');
+ * // => {
+ * //   context: [ 'Sheet1' ],
+ * //   range: {
+ * //     r0: 9,
+ * //     c0: 8,
+ * //     r1: 9,
+ * //     c1: 8,
+ * //     $c0: true,
+ * //     $c1: true
+ * //     $r0: false,
+ * //     $r1: false
+ * //   }
+ * // }
+ * ```
+ *
+ * @see {@link OptsParseR1C1Ref}
+ * @param refString An R1C1-style reference string.
+ * @param [options] Options.
+ * @returns An object representing a valid reference or `undefined` if it is invalid.
+ */
+declare function parseR1C1Ref(refString: string, options?: OptsParseR1C1Ref): ReferenceR1C1 | ReferenceName | undefined;
+/**
+ * Parse a string reference into an object representing it.
+ *
+ * ```js
+ * parseR1C1Ref('Sheet1!R[9]C9:R[9]C9');
+ * // => {
+ * //   context: [ 'Sheet1' ],
+ * //   range: {
+ * //     r0: 9,
+ * //     c0: 8,
+ * //     r1: 9,
+ * //     c1: 8,
+ * //     $c0: true,
+ * //     $c1: true
+ * //     $r0: false,
+ * //     $r1: false
+ * //   }
+ * // }
+ * ```
+ *
+ * @see {@link OptsParseR1C1Ref}
+ * @param refString An R1C1-style reference string.
+ * @param [options] Options.
+ * @returns An object representing a valid reference or `undefined` if it is invalid.
+ */
+declare function parseR1C1RefXlsx(refString: string, options?: OptsParseR1C1Ref): ReferenceR1C1Xlsx | ReferenceNameXlsx | undefined;
+
+/**
+ * Parse a structured reference string into an object representing it.
+ *
+ * ```js
+ * parseStructRef('workbook.xlsx!tableName[[#Data],[Column1]:[Column2]]');
+ * // => {
+ * //   context: [ 'workbook.xlsx' ],
+ * //   sections: [ 'data' ],
+ * //   columns: [ 'my column', '@foo' ],
+ * //   table: 'tableName',
+ * // }
+ * ```
+ *
+ * For A:A or A1:A style ranges, `null` will be used for any dimensions that the
+ * syntax does not specify:
+ *
+ * See [References.md](./References.md).
+ *
+ * @param ref A structured reference string
+ * @returns An object representing a valid reference or `undefined` if it is invalid.
+ */
+declare function parseStructRef(ref: string): ReferenceStruct | undefined;
+/**
+ * Parse a structured reference string into an object representing it.
+ *
+ * ```js
+ * parseStructRef('[workbook.xlsx]!tableName[[#Data],[Column1]:[Column2]]');
+ * // => {
+ * //   workbookName: 'workbook.xlsx',
+ * //   sections: [ 'data' ],
+ * //   columns: [ 'my column', '@foo' ],
+ * //   table: 'tableName',
+ * // }
+ * ```
+ *
+ * For A:A or A1:A style ranges, `null` will be used for any dimensions that the
+ * syntax does not specify:
+ *
+ * See [References.md](./References.md).
+ *
+ * @param ref A structured reference string
+ * @returns An object representing a valid reference or null if it is invalid.
+ */
+declare function parseStructRefXlsx(ref: string): ReferenceStructXlsx | undefined;
+
+/**
+ * Get an A1-style string representation of a reference object.
+ *
+ * ```js
+ * stringifyA1Ref({
+ *   context: [ 'Sheet1' ],
+ *   range: {
+ *     top: 0,
+ *     left: 0,
+ *     bottom: 1,
+ *     right: 1,
+ *     $top: true,
+ *     $left: false,
+ *     $bottom: false,
+ *     $right: true
+ *   }
+ * });
+ * // => 'Sheet1!A$1:$B2'
+ * ```
+ *
+ * @param refObject A reference object.
+ * @returns The reference in A1-style string format.
+ */
+declare function stringifyA1Ref(refObject: ReferenceA1 | ReferenceName): string;
+/**
+ * Get an A1-style string representation of a reference object.
+ *
+ * ```js
+ * stringifyA1Ref({
+ *   sheetName: 'Sheet1',
+ *   range: {
+ *     top: 0,
+ *     left: 0,
+ *     bottom: 1,
+ *     right: 1,
+ *     $top: true,
+ *     $left: false,
+ *     $bottom: false,
+ *     $right: true
+ *   }
+ * });
+ * // => 'Sheet1!A$1:$B2'
+ * ```
+ *
+ * @param refObject A reference object.
+ * @returns The reference in A1-style string format.
+ */
+declare function stringifyA1RefXlsx(refObject: ReferenceA1Xlsx | ReferenceNameXlsx): string;
+
+/**
+ * Get an R1C1-style string representation of a reference object.
+ *
+ * ```js
+ * stringifyR1C1Ref({
+ *   context: [ 'Sheet1' ],
+ *   range: {
+ *     r0: 9,
+ *     c0: 8,
+ *     r1: 9,
+ *     c1: 8,
+ *     $c0: true,
+ *     $c1: true
+ *     $r0: false,
+ *     $r1: false
+ *   }
+ * });
+ * // => 'Sheet1!R[9]C9:R[9]C9'
+ * ```
+ *
+ * @param refObject A reference object.
+ * @returns The reference in R1C1-style string format.
+ */
+declare function stringifyR1C1Ref(refObject: ReferenceR1C1 | ReferenceName): string;
+/**
+ * Get an R1C1-style string representation of a reference object.
+ *
+ * ```js
+ * stringifyR1C1Ref({
+ *   sheetName: 'Sheet1',
+ *   range: {
+ *     r0: 9,
+ *     c0: 8,
+ *     r1: 9,
+ *     c1: 8,
+ *     $c0: true,
+ *     $c1: true
+ *     $r0: false,
+ *     $r1: false
+ *   }
+ * });
+ * // => 'Sheet1!R[9]C9:R[9]C9'
+ * ```
+ *
+ * @param refObject A reference object.
+ * @returns The reference in R1C1-style string format.
+ */
+declare function stringifyR1C1RefXlsx(refObject: ReferenceR1C1Xlsx | ReferenceNameXlsx): string;
+
+/**
+ * Options for {@link stringifyStructRef}
+ */
+type OptsStringifyStructRef = {
+    /**
+     * Enforces using the `[#This Row]` instead of the `@` shorthand when serializing structured ranges.
+     * @defaultValue false
+     */
+    thisRow?: boolean;
+};
+/**
+ * Returns a string representation of a structured reference object.
+ *
+ * ```js
+ * stringifyStructRef({
+ *   context: [ 'workbook.xlsx' ],
+ *   sections: [ 'data' ],
+ *   columns: [ 'my column', '@foo' ],
+ *   table: 'tableName',
+ * });
+ * // => 'workbook.xlsx!tableName[[#Data],[Column1]:[Column2]]'
+ * ```
+ *
+ * @see {@link OptsStringifyStructRef}
+ * @param refObject A structured reference object.
+ * @param [options={}] Options.
+ * @returns The given structured reference in string format.
+ */
+declare function stringifyStructRef(refObject: ReferenceStruct, options?: OptsStringifyStructRef): string;
+/**
+ * Returns a string representation of a structured reference object.
+ *
+ * ```js
+ * stringifyStructRef({
+ *   workbookName: 'workbook.xlsx',
+ *   sheetName: '',
+ *   sections: [ 'data' ],
+ *   columns: [ 'my column', '@foo' ],
+ *   table: 'tableName',
+ * });
+ * // => 'workbook.xlsx!tableName[[#Data],[Column1]:[Column2]]'
+ * ```
+ *
+ * @param refObject A structured reference object.
+ * @param [options] Options.
+ * @returns The given structured reference in string format.
+ */
+declare function stringifyStructRefXlsx(refObject: ReferenceStructXlsx, options?: OptsStringifyStructRef): string;
+
+/**
+ * Collapses a list of tokens into a formula string.
+ *
+ * @param tokens A list of tokens.
+ * @returns A formula string.
+ */
+declare function stringifyTokens(tokens: Token[]): string;
+
+/**
+ * A dictionary of the types used to identify token variants.
+ * @prop OPERATOR - Unary or binary operator (`+`, `%`)
+ * @prop BOOLEAN - Boolean literal (`TRUE`)
+ * @prop ERROR - Error literal (`#VALUE!`)
+ * @prop NUMBER - Number literal (`123.4`, `-1.5e+2`)
+ * @prop FUNCTION - Function name (`SUM`)
+ * @prop NEWLINE - Newline character (`\n`)
+ * @prop WHITESPACE - Whitespace character sequence (` `)
+ * @prop STRING - String literal (`"Lorem ipsum"`)
+ * @prop CONTEXT - Reference context ([Workbook.xlsx]Sheet1)
+ * @prop CONTEXT_QUOTE - Quoted reference context (`'[My workbook.xlsx]Sheet1'`)
+ * @prop REF_RANGE - A range identifier (`A1`)
+ * @prop REF_BEAM - A range "beam" identifier (`A:A` or `1:1`)
+ * @prop REF_TERNARY - A ternary range identifier (`B2:B`)
+ * @prop REF_NAMED - A name / named range identifier (`income`)
+ * @prop REF_STRUCT - A structured reference identifier (`table[[Column1]:[Column2]]`)
+ * @prop FX_PREFIX - A leading equals sign at the start of a formula (`=`)
+ * @prop UNKNOWN - Any unidentifiable range of characters.
+ */
+declare const tokenTypes: Readonly<{
+    /** Unary or binary operator (`+`, `%`) */
+    OPERATOR: "operator";
+    /** Boolean literal (`TRUE`) */
+    BOOLEAN: "bool";
+    /** Error literal (`#VALUE!`) */
+    ERROR: "error";
+    /** Number literal (`123.4`, `-1.5e+2`) */
+    NUMBER: "number";
+    /** Function name (`SUM`) */
+    FUNCTION: "func";
+    /** Newline character (`\n`) */
+    NEWLINE: "newline";
+    /** Whitespace character sequence (` `) */
+    WHITESPACE: "whitespace";
+    /** String literal (`"Lorem ipsum"`) */
+    STRING: "string";
+    /** Reference context ([Workbook.xlsx]Sheet1) */
+    CONTEXT: "context";
+    /** Quoted reference context (`'[My workbook.xlsx]Sheet1'`) */
+    CONTEXT_QUOTE: "context_quote";
+    /** A range identifier (`A1`) */
+    REF_RANGE: "range";
+    /** A range "beam" identifier (`A:A` or `1:1`) */
+    REF_BEAM: "range_beam";
+    /** A ternary range identifier (`B2:B`) */
+    REF_TERNARY: "range_ternary";
+    /** A name / named range identifier (`income`) */
+    REF_NAMED: "range_named";
+    /** A structured reference identifier (`table[[Column1]:[Column2]]`) */
+    REF_STRUCT: "structured";
+    /** A leading equals sign at the start of a formula (`=`) */
+    FX_PREFIX: "fx_prefix";
+    /** Any unidentifiable range of characters. */
+    UNKNOWN: "unknown";
+}>;
+
+/**
+ * A dictionary of the types used to identify AST node variants.
+ *
+ * @prop UNARY - A unary operation (`10%`)
+ * @prop BINARY - A binary operation (`10+10`)
+ * @prop REFERENCE - A range identifier (`A1`)
+ * @prop LITERAL - A literal (number, string, or boolean) (`123`, `"foo"`, `false`)
+ * @prop ERROR - An error literal (`#VALUE!`)
+ * @prop CALL - A function call expression (`SUM(1,2)`)
+ * @prop ARRAY - An array expression (`{1,2;3,4}`)
+ * @prop IDENTIFIER - A function name identifier (`SUM`)
+ * @prop LAMBDA - A LAMBDA expression (`LAMBDA(x,y,x*y)``)
+ * @prop LET - A LET expression (`LET(a,A1*10,b,SUM(F:F),a*b)`)
+ * @prop LET_DECL - A LET declaration (LET(`a,A1*10`...)
+ */
+declare const nodeTypes: Readonly<{
+    /** A unary operation (`10%`) */
+    UNARY: "UnaryExpression";
+    /** A binary operation (`10+10`) */
+    BINARY: "BinaryExpression";
+    /** A range identifier (`A1`) */
+    REFERENCE: "ReferenceIdentifier";
+    /** A literal (number, string, or boolean) (`123`, `"foo"`, `false`) */
+    LITERAL: "Literal";
+    /** An error literal (`#VALUE!`) */
+    ERROR: "ErrorLiteral";
+    /** A function call expression (`SUM(1,2)`) */
+    CALL: "CallExpression";
+    /** An array expression (`{1,2;3,4}`) */
+    ARRAY: "ArrayExpression";
+    /** A function name identifier (`SUM`) */
+    IDENTIFIER: "Identifier";
+    /** A LAMBDA expression (`LAMBDA(x,y,x*y)``) */
+    LAMBDA: "LambdaExpression";
+    /** A LET expression (`LET(a,A1*10,b,SUM(F:F),a*b)`) */
+    LET: "LetExpression";
+    /** A LET declaration (LET(`a,A1*10`...)*/
+    LET_DECL: "LetDeclarator";
+}>;
+
+export { stringifyTokens as $, isOperator as A, isRange as B, isReference as C, isWhitespace as D, isArrayNode as E, isBinaryNode as F, isCallNode as G, isErrorNode as H, isExpressionNode as I, isIdentifierNode as J, isLambdaNode as K, isLetDeclaratorNode as L, MAX_COLS as M, isLetNode as N, type OptsTokenize as O, isLiteralNode as P, isReferenceNode as Q, isUnaryNode as R, addA1RangeBounds as S, type Token as T, toCol as U, fromCol as V, parseA1Range as W, type OptsParseA1Ref as X, parseR1C1Range as Y, type OptsParseR1C1Ref as Z, type OptsStringifyStructRef as _, type TokenEnhanced as a, type RangeA1 as a0, type RangeR1C1 as a1, type ReferenceA1 as a2, type ReferenceA1Xlsx as a3, type ReferenceR1C1 as a4, type ReferenceR1C1Xlsx as a5, type ReferenceStruct as a6, type ReferenceStructXlsx as a7, type ReferenceName as a8, type ReferenceNameXlsx as a9, stringifyStructRef as aA, tokenTypes as aa, nodeTypes as ab, type SourceLocation as ac, type Node as ad, type Identifier as ae, type ReferenceIdentifier as af, type Literal as ag, type ErrorLiteral as ah, type UnaryExpression as ai, type UnaryOperator as aj, type BinaryExpression as ak, type BinaryOperator as al, type CallExpression as am, type ArrayExpression as an, type LambdaExpression as ao, type LetExpression as ap, type LetDeclarator as aq, type AstExpression as ar, tokenize as as, fixTokenRanges as at, fixFormulaRanges as au, parseA1Ref as av, parseR1C1Ref as aw, parseStructRef as ax, stringifyA1Ref as ay, stringifyR1C1Ref as az, fixFormulaRangesXlsx as b, parseR1C1RefXlsx as c, parseStructRefXlsx as d, stringifyR1C1RefXlsx as e, fixTokenRangesXlsx as f, stringifyStructRefXlsx as g, parse as h, type OptsParse as i, translateFormulaToR1C1 as j, translateTokensToR1C1 as k, type OptsTranslateToR1C1 as l, translateFormulaToA1 as m, type OptsTranslateFormulaToA1 as n, translateTokensToA1 as o, parseA1RefXlsx as p, type OptsTranslateTokensToA1 as q, MAX_ROWS as r, stringifyA1RefXlsx as s, tokenizeXlsx as t, mergeRefTokens as u, type OptsFixRanges as v, isError as w, isFunction as x, isFxPrefix as y, isLiteral as z };