@sheetxl/sdk 0.7.21 → 0.7.23-beta.2

package/types/src/calculation/compiler/FormulaParser.d.ts

@@ -0,0 +1,270 @@
+import { EmbeddedActionsParser, IToken, TokenType as ParseTokenType, IParserConfig } from 'chevrotain';
+import { TokenType } from '../TokenType';
+import { ASTNode, ParseResult } from './ASTTypes';
+import { FormulaLexer, FormulaLexerOptions } from './FormulaLexer';
+import { CompilerLocale } from './CompilerLocale';
+import { SRParser } from './SRParser';
+import { ICalculation } from '../ICalculation';
+declare module 'chevrotain' {
+    interface EmbeddedActionsParser {
+        getLexerPosition(): number;
+    }
+}
+/**
+ * Diagnostic for an expression with nothing in it — `FormulaCompiler` sees the empty string,
+ * this parser sees the whitespace-only case (spaces lex to zero tokens). A sentence like every
+ * other parse diagnostic, because `createFormula` shows these to the formula editor.
+ */
+export declare const EMPTY_EXPRESSION = "A formula must not be empty";
+/**
+ * The diagnostic for text over {@link ICalculation.MAX_EXPRESSION_LENGTH}. Reports the actual
+ * length: the limit alone leaves a user guessing how far over they are, and the overage is
+ * usually enormous rather than marginal (a rule's applies-to reaching millions of characters).
+ */
+export declare const EXPRESSION_TOO_LONG: (length: number, max: number) => string;
+/**
+ * Extends Chevrotain's EmbeddedActionsParser options with expanded options.
+ */
+export interface FormulaParseOptions extends Partial<IParserConfig> {
+    /**
+     * Provides a lexer
+     */
+    lexer?: FormulaLexer;
+    /**
+     * Options used to construct the default {@link FormulaLexer} when no `lexer` is supplied — the
+     * locale separators and boolean literals. Ignored if `lexer` is given (that lexer's own
+     * separators win).
+     */
+    lexerOptions?: FormulaLexerOptions;
+    /**
+     * Provides a structured reference parser.
+     */
+    srParser?: SRParser;
+}
+export declare class FormulaParser extends EmbeddedActionsParser {
+    protected rowIndex: number;
+    protected colIndex: number;
+    protected _inputText: string;
+    protected _inputTextLength: number;
+    private _astErrors;
+    protected _tokenMap: Map<ASTNode, {
+        tokenIndex?: number;
+        tokenIndexClose?: number;
+    }>;
+    protected _lexer: FormulaLexer;
+    /**
+     * The locale this parser's actions map through — read from the lexer so lexing and parsing always
+     * agree. Passed to the `ParserUtils.create*` builders to turn typed booleans/errors/numbers into
+     * canonical AST values (and, later, SR specifiers).
+     */
+    protected _locale: CompilerLocale;
+    /** Token vocabulary from the injected FormulaLexer; set in constructor after super(). */
+    protected _vocab: Record<string, ParseTokenType>;
+    protected _srParser: SRParser;
+    /** Cached alternatives array for _ruleInfixOp (Chevrotain performance pattern). */
+    protected _c1: any;
+    /** Cached alternatives array for _ruleRangeOp (Chevrotain performance pattern). */
+    protected _c2: any;
+    constructor(options?: FormulaParseOptions);
+    /**
+     * The lexer this parser tokenizes with. Exposed so the compiler's editing-mode recovery can re-lex
+     * tolerantly (find token boundaries in an expression whose full parse failed) without re-creating one.
+     */
+    getLexer(): FormulaLexer;
+    /**
+     * Parse a formula expression and return a ParseResult with the root ASTNode and any errors.
+     *
+     * @param formulaTransform An optional structural transform applied to the parsed tree
+     * (pre-link, so node values are the typed display text). This is the READ half of the
+     * dialect hook — a format reader (io-xlsx) supplies its legacy unwrap here; typed text gets
+     * none, so `=_xlfn.SUM(A1)` typed is an unknown name, as in Excel. Runs where the hardcoded
+     * legacy visit used to run — no extra parse.
+     */
+    parse(rowIndex: number, colIndex: number, expression: string, formulaTransform?: ICalculation.FormulaTransform): ParseResult;
+    /**
+     * Parses a flat sequence of infix-operator / operand pairs, then folds them into a
+     * left-associative AST using the precedence table in `ParserUtils.binaryOperatorsPrecedence`.
+     * Handles arithmetic, comparison, and concatenation operators. The range operators (`:`, `.:`, `:.`,
+     * `.:.`) are NOT here — they bind tighter than the unary prefixes and are folded by `_ruleRangeOp`
+     * (the leaf of the operand chain), so `-A1:B2` parses as `-(A1:B2)` rather than `(-A1):B2`.
+     */
+    protected _ruleInfixOp: import('chevrotain').ParserMethod<[], ASTNode<TokenType, any>>;
+    /** Matches a single `+` or `-` token. Used as a helper by `_rulePrefixOp` and `_ruleLiteralForArray`. */
+    protected _rulePlusMinusOp: import('chevrotain').ParserMethod<[], IToken>;
+    /**
+     * Applies zero or more postfix operators (`%` percent, `#` spill anchor) to the node
+     * produced by `_rulePrefixOp`, building a right-growing postfix AST chain.
+     */
+    protected _rulePostfixOp: import('chevrotain').ParserMethod<[], ASTNode<TokenType, any>>;
+    /**
+     * Applies zero or more leading prefix operators (`+`, `-`, `@` implicit-intersect) to the
+     * node produced by `_ruleRangeOp`, wrapping from innermost outward (right-to-left application).
+     *
+     * The operand is `_ruleRangeOp` (not the bare `_ruleFormula` leaf) so the range operator binds
+     * TIGHTER than the prefix — `-A1:B2` becomes `-(A1:B2)`, matching Excel (reference operators are the
+     * highest precedence). Were the operand the leaf, `-` would grab `A1` first and leave a stray `:`.
+     */
+    protected _rulePrefixOp: import('chevrotain').ParserMethod<[], ASTNode<TokenType, any>>;
+    /**
+     * Folds the range operators (`:` range, `.:.` / `.:` / `:.` range-trim) — Excel's highest-precedence
+     * operators, binding tighter than the unary prefixes (`_rulePrefixOp`). Left-associative, single level
+     * (`A1:B2:C3` = `(A1:B2):C3`); every operator produces a reference infix node (`isRange = true`) so the
+     * whole span resolves to one reference. This rule sits just above the `_ruleCallOp` leaf.
+     */
+    protected _ruleRangeOp: import('chevrotain').ParserMethod<[], ASTNode<TokenType, any>>;
+    /**
+     * Function application — `LAMBDA(a,b,a+b)(1,2)`, and the general form it is one instance of: any
+     * expression followed by an argument list. Zero or more suffixes, so a curried lambda
+     * (`LAMBDA(x,LAMBDA(y,x+y))(1)(2)` = `3` in Excel) folds left-associatively.
+     *
+     * This is the tightest-binding construct in the grammar — tighter than the range operators above
+     * it, which is why it sits BELOW `_ruleRangeOp`: `LAMBDA(r,r)(A1:B2):C3` is `(call):C3`. Measured
+     * against Excel 16.0 for `-`, `*`, `%`, `#` and `:` alike
+     * (`spreadsheetbench/formula-tests/probe-lambda-call.ps1`).
+     *
+     * ── The GATE is the whole design ────────────────────────────────────────────────────────────
+     *
+     * The `(` binds as a call ONLY when it touches the callee's last token. Excel refuses
+     * `=LAMBDA(x,x+1) (3)` at entry over a single space, and that adjacency is the ONLY thing
+     * separating application from implicit intersection:
+     *
+     * | typed | Excel |
+     * | --- | --- |
+     * | `A1:B3 (A2:C2)` | `4` — intersection |
+     * | `A1:B3(A2:C2)` | `#REF!` — a CALL whose callee is a range |
+     *
+     * So this gate is the exact complement of `_ruleIntersectOp`'s: that one fires on
+     * `startOffset > endOffset + 1`, this one on `startOffset === endOffset + 1`. No input satisfies
+     * both, and none falls between them. Without it, a greedy call suffix would swallow the second
+     * operand of every parenthesized intersection before `_ruleIntersectOp` ever saw it.
+     *
+     * The callee is deliberately unrestricted. Excel's own restriction is not syntactic — it is a
+     * shallow check on the callee's DECLARED return type, which is why `=IF(TRUE,1,2)(3)` is accepted
+     * (and answers `#VALUE!`) while `=SUM(2)(3)` is refused. That belongs with the sibling check for
+     * intersection operands (`CompilerUtils.findNonReferenceIntersectionOperand`), not here.
+     * See DESIGN-FORMULA-APPLICATION.md.
+     */
+    protected _ruleCallOp: import('chevrotain').ParserMethod<[], ASTNode<TokenType, any>>;
+    /**
+     * Implements the implicit intersection operator: two adjacent reference expressions
+     * separated by whitespace (e.g. `A1:A10 B1:B10`). Uses a lookahead GATE that fires
+     * only when a gap exists between the previous and next token's offsets.
+     */
+    protected _ruleIntersectOp: import('chevrotain').ParserMethod<[], ASTNode<TokenType, any>>;
+    /**
+     * Central dispatch rule. Tries each formula alternative in order:
+     * literal → reference → function → paren → table reference → bracketed string → literal array.
+     * This is the leaf of the operator-precedence chain (called by `_rulePrefixOp`).
+     */
+    protected _ruleFormula: import('chevrotain').ParserMethod<[], ASTNode<TokenType, any>>;
+    /**
+     * Parses zero or more additional comma-separated expressions within a parenthesized context.
+     * Called by `_processParen` after the first expression is already consumed; returns only the
+     * tail items so the caller can assemble the full argument list.
+     */
+    protected _ruleGroup: import('chevrotain').ParserMethod<[], ASTNode<TokenType, any>[]>;
+    /** Parses a parenthesized expression `(expr)` or tuple `(a, b, c)` by delegating to `_processParen`. */
+    protected _ruleParen: import('chevrotain').ParserMethod<[], ASTNode<TokenType, any>>;
+    /**
+     * Parses a literal array constant `{v1,v2;v3,v4}` where `,` separates columns and `;`
+     * starts a new row. Delegates to `_ruleLiteralForArray` for each element.
+     */
+    protected _ruleLiteralArray: import('chevrotain').ParserMethod<[], ASTNode<TokenType, any>>;
+    /**
+     * Like `_ruleLiteral` but treats a leading `+` or `-` as part of the numeric literal
+     * rather than a unary operator. Also accepts `#REF!` error values, which `_ruleLiteral`
+     * does not (ref errors inside arrays are valid in Excel).
+     */
+    protected _ruleLiteralForArray: import('chevrotain').ParserMethod<[], ASTNode<TokenType, any>>;
+    /**
+     * Parses a scalar literal value: number, string, boolean, literal error constant (e.g. `#N/A`),
+     * or `#REF!`. Leading sign is not handled here — use `_ruleLiteralForArray` inside array literals.
+     */
+    protected _ruleLiteral: import('chevrotain').ParserMethod<[], ASTNode<TokenType, any>>;
+    /**
+     * Parses a function call: a `FunctionToken` (the NAME — lexed only when a `(` immediately
+     * follows) then that `OpenParen`, an argument list from `_ruleFunctionArguments`, then an
+     * optional closing `)`. Records a syntax error on the node if the close paren is missing.
+     */
+    protected _ruleFunction: import('chevrotain').ParserMethod<[], ASTNode<TokenType, any>>;
+    /**
+     * Parses the argument list inside a function call. Supports empty/omitted arguments:
+     * consecutive commas produce `Empty` nodes, so `FUNC(,A1,)` yields `[empty, A1, empty]`.
+     * Empty is detected by a 1-token lookahead; the gate skips the entire rule for `FUNC()`.
+     */
+    protected _ruleFunctionArguments: import('chevrotain').ParserMethod<[], ASTNode<TokenType, any>[]>;
+    /**
+     * Parses a bracketed string token (`[Workbook.xlsx]Sheet1!A1` style external references).
+     * Delegates to `_srParser` for full interpretation; any errors are forwarded to `_astErrors`.
+     */
+    protected _ruleBracketedString: import('chevrotain').ParserMethod<[], ASTNode<TokenType, any>>;
+    /**
+     * Parses a structured table reference token (`Table1[Column]` style). Delegates to
+     * `_srParser` for interpretation; any errors are forwarded to `_astErrors`.
+     */
+    protected _ruleTableReference: import('chevrotain').ParserMethod<[], ASTNode<TokenType, any>>;
+    /**
+     * Parses any cell/range reference: cell address (`A1`, `$B$2`), named range, column-only
+     * (`A:A`), row-only (`1:1`), `#REF!` error, or a bracketed/table sub-reference. Optionally
+     * prefixed by a sheet name (via `_rulePrefixSheetName`). The `@` implicit-intersect prefix
+     * is handled upstream by `_rulePrefixOp` and never reaches this rule.
+     * A lookahead GATE prevents consuming sheet-like tokens that belong to a later expression.
+     */
+    protected _ruleReference: import('chevrotain').ParserMethod<[], ASTNode<TokenType, any>>;
+    /**
+     * Parses the sheet-name prefix before a reference: either a quoted form (`'Sheet 1'!`) or
+     * an unquoted form (`Sheet1!` or `[1]Sheet1!`), including a colon for 3-D range syntax
+     * (`Sheet1:Sheet2!`). Returns the resolved sheet `name` (quotes and `!` stripped) AND the raw
+     * consumed `image` (exactly as typed, `!` included) — editing-mode tokens need the latter to
+     * reproduce the source.
+     */
+    protected _rulePrefixSheetName: import('chevrotain').ParserMethod<[], {
+        name: string;
+        image: string;
+    }>;
+    /** Matches any numeric token: a standard decimal number, a scientific-notation digit, or a plain integer digit. */
+    protected _ruleNumber: import('chevrotain').ParserMethod<[], IToken>;
+    /**
+     * Top-level grammar entry point. Parses one or more comma-separated `_ruleIntersectOp`
+     * expressions. A single expression is returned as-is; multiple expressions are wrapped in
+     * a `List` node (used for multi-value formula contexts such as array formulas).
+     */
+    protected _ruleRoot: import('chevrotain').ParserMethod<[], ASTNode<TokenType, any>>;
+    /**
+     * Shared implementation for parenthesized parsing. Consumes `open`, parses an expression
+     * plus optional comma-separated group via `_ruleGroup`, then consumes `close`. The resulting
+     * node is typed by the `type` parameter, allowing reuse for different paren kinds.
+     */
+    protected _processParen(type: TokenType, open: ParseTokenType, close: ParseTokenType): ASTNode;
+    /**
+     * Marks `node.error = true` and pushes a structured error entry to `_astErrors`. The entry
+     * references the token at `indexToken` (defaults to the current lexer position) so callers
+     * can provide accurate source location for errors detected after the offending token.
+     */
+    protected _reportError(node: ASTNode, message: string, indexToken?: number | undefined, name?: string): void;
+    /**
+     * Records the token index that anchors a node's leading whitespace (and trailing
+     * for leaf nodes). Also sets `node.image` from the token if not already set.
+     *
+     * For container nodes (function, paren, array) call `_tagClose` after consuming
+     * the close token to set the trailing anchor independently.
+     */
+    protected _tag(node: ASTNode, index: number): ASTNode;
+    /**
+     * Overwrites the trailing whitespace anchor for a container node after its close
+     * token is consumed (CloseParen, CloseCurlyParen, etc.).
+     */
+    protected _tagClose(node: ASTNode, index: number): ASTNode;
+    /**
+     * Reads the token-map entry for a single node and computes `wsBefore` / `wsAfter` from
+     * the character gaps between adjacent tokens in `this.input`. Called per-node by
+     * `_bindAllWhitespace` during the post-parse whitespace pass.
+     */
+    protected _bindNodeWhitespace(node: ASTNode): void;
+    /**
+     * Single post-parse pass: bind whitespace to every node in the AST.
+     * Covers standard `inputs` children and array-literal internals stored in `value`.
+     */
+    protected _bindAllWhitespace(node: ASTNode): void;
+}
+//# sourceMappingURL=FormulaParser.d.ts.map

package/types/src/calculation/compiler/FormulaParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormulaParser.d.ts","sourceRoot":"","sources":["../../../../../src/calculation/compiler/FormulaParser.ts"],"names":[],"mappings":"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"}

package/types/src/calculation/compiler/FormulaSeparators.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Formula separator sets and the locale → separators mapping.
+ *
+ * @remarks
+ * This module is intentionally dependency-free (no chevrotain) so it can be imported eagerly by the
+ * calculation engine to derive lexer options from the workbook locale, while the heavy
+ * {@link FormulaLexer} stays lazy-loaded.
+ */
+/**
+ * The four formula separators, fully resolved (no `undefined`). The parser reads `separatorDecimal`
+ * to normalize number images (`1,5` → `1.5`); the emit path reads all four to re-image for display.
+ */
+export interface FormulaSeparators {
+    separatorFunction: ',' | ';';
+    separatorColumn: ',' | ';';
+    separatorRow: ';' | '|';
+    separatorDecimal: '.' | ',';
+}
+/**
+ * The canonical (English / storage) separators — `,` args, `,` array columns, `;` array rows,
+ * `.` decimal. The default lexer uses these, and every persisted/API formula is emitted with them
+ * (I18N-DESIGN.md golden rule).
+ */
+export declare const CANONICAL_SEPARATORS: FormulaSeparators;
+/**
+ * Map a locale's decimal separator to the formula separators a user of that locale types, the way
+ * Excel does: when the decimal is a comma the argument separator becomes `;` (a `,` would be
+ * ambiguous with the decimal), array columns follow the argument separator, and array rows take the
+ * one remaining distinct character. An `en`-shaped locale (decimal `.`) yields the canonical set, so
+ * this is identity for storage-shaped locales.
+ *
+ * @param decimal The locale's decimal separator (`LocaleProfile.decimal`).
+ */
+export declare function formulaSeparatorsForDecimal(decimal: string): FormulaSeparators;
+//# sourceMappingURL=FormulaSeparators.d.ts.map

package/types/src/calculation/compiler/FormulaSeparators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormulaSeparators.d.ts","sourceRoot":"","sources":["../../../../../src/calculation/compiler/FormulaSeparators.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,iBAAiB,EAAE,GAAG,GAAG,GAAG,CAAC;IAC7B,eAAe,EAAE,GAAG,GAAG,GAAG,CAAC;IAC3B,YAAY,EAAE,GAAG,GAAG,GAAG,CAAC;IACxB,gBAAgB,EAAE,GAAG,GAAG,GAAG,CAAC;CAC7B;AAED;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,EAAE,iBAKlC,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,CAQ9E"}

package/types/src/calculation/compiler/LiteTransform.d.ts

@@ -0,0 +1,15 @@
+import { ICalculation } from '../ICalculation';
+import { ISymbolRegistry } from '../symbol';
+import { ASTNode } from './ASTTypes';
+/**
+ * Applies a public {@link ICalculation.FormulaTransform} to an internal AST.
+ *
+ * @param root The internal AST root (may be `null`/absent for an unparsed formula — returned as-is).
+ * @param transform The visitor (children before parents; the root last, with no parent).
+ * @param symbols The registry the AST was linked against, or `null` for a pre-link AST
+ * (the parse-side hook) whose values are already display text.
+ * @returns A new root, or the SAME root when the transform changed nothing — the caller uses
+ * that identity to skip recompilation.
+ */
+export declare function applyTransformToAST(root: ASTNode, transform: ICalculation.FormulaTransform, symbols?: ISymbolRegistry | null): ASTNode;
+//# sourceMappingURL=LiteTransform.d.ts.map

package/types/src/calculation/compiler/LiteTransform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LiteTransform.d.ts","sourceRoot":"","sources":["../../../../../src/calculation/compiler/LiteTransform.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD,OAAO,EAAE,KAAK,eAAe,EAAc,MAAM,WAAW,CAAC;AAG7D,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,YAAY,CAAC;AAuQ1C;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,OAAO,EACb,SAAS,EAAE,YAAY,CAAC,gBAAgB,EACxC,OAAO,CAAC,EAAE,eAAe,GAAG,IAAI,GAC/B,OAAO,CAMT"}

package/types/src/calculation/compiler/ParserUtils.d.ts

@@ -0,0 +1,167 @@
+import { FormulaError, IRange } from '@sheetxl/primitives';
+import { CompilerLocale } from './CompilerLocale';
+import { ASTNode, ASTVisitor, CellNode, FunctionNode } from './ASTTypes';
+/**
+ * Convert column string to column name.
+ */
+export declare function columnNameToNumber(columnName: string): number;
+/**
+ * Parse the cell address only.
+ */
+export declare function createCellAddress(address: string, row: number, column: number): CellNode;
+export declare function createCell(coords: IRange.FixableCellCoords): CellNode;
+export declare function createCol(address: string, column: number): CellNode;
+export declare function createRow(address: string, row: number): CellNode;
+export declare function createFunction(value: string, inputs: any[] | null | undefined): FunctionNode;
+/**
+ * Application of an expression `callee` to `args` — `LAMBDA(a,b,a+b)(1,2)`.
+ *
+ * The callee goes in `inputs[0]` rather than `value` because **`visitAST` descends `inputs` and
+ * never `value`** (see its `walk`). A callee parked in `value` is invisible to every pass built on
+ * it, and each of those is a silent wrong answer rather than a crash:
+ *
+ * - the post-parse visit in `FormulaParser.parse` — `_xlfn.LAMBDA(…)(1,2)` read back from disk
+ *   would keep its prefix, because the strip never reaches the callee;
+ * - `bindSymbols` — the callee's function name never binds to a stableId;
+ * - `translateCellNodes` — a cell inside the callee does not shift on copy/paste or row insert;
+ * - precedent collection — `=IF(A1,LAMBDA(x,x),LAMBDA(x,x+1))(2)` never registers `A1` as a
+ *   precedent, so editing `A1` leaves a stale value. That one is the decisive case.
+ *
+ * `value` is also uniformly the node's *scalar* identity everywhere else (a name, an operator, a
+ * number, a coords object); a node there breaks that for anything comparing or serializing it.
+ *
+ * The cost is that argument `i` is `inputs[i + 1]`, unlike {@link createFunction} — use
+ * {@link calleeOf} / {@link argsOf} rather than open-coding the offset.
+ *
+ * Excel models this the same way: its AST has a single `App { head, args }` node and its engine
+ * implements immediate invocation as an internal `APPLY` function taking the callee as argument 0
+ * (DESIGN-FORMULA-APPLICATION.md §8.1).
+ */
+export declare function createCall(callee: ASTNode, args: ASTNode[] | null | undefined): ASTNode;
+/** The callee of a {@link createCall} node. */
+export declare function calleeOf(node: ASTNode): ASTNode | undefined;
+/** The arguments of a {@link createCall} node, without the callee. Never `null`. */
+export declare function argsOf(node: ASTNode): ASTNode[];
+export declare function createTableReference(value: string, inputs: any[]): ASTNode;
+/**
+ * @param image The specifier as typed — `[#All]`/`#All` or localized `[#Alle]`/`#Alle`. `value` is the
+ * canonical `#All` form either way (storage stays canonical); `locale.parseSpecifier` maps the localized
+ * word → canonical. Display re-imaging (`tokensToString`) re-localizes for a localized target.
+ */
+export declare function createTableSpecifier(image: string, locale?: CompilerLocale): ASTNode;
+export declare function createTableColumn(image: string): ASTNode;
+export declare function createInfix(operator: string, left: ASTNode, right: ASTNode, isReference?: boolean): ASTNode;
+export declare function createPostfix(operator: string, input: ASTNode | null | undefined, isReference?: boolean): ASTNode;
+export declare function createPrefix(operator: string, input: ASTNode | null | undefined, isReference?: boolean): ASTNode;
+/**
+ * Used within literals
+ */
+export declare function createPrefixLiteral(operator: string, node: ASTNode): ASTNode;
+/**
+ * @param image The name of the named range.
+ */
+export declare function createNamed(image: string): ASTNode;
+/**
+ * @param image Converts text to number.
+ * @param locale The locale the image was lexed with. Its `separators.separatorDecimal` is used to
+ * normalize the image: when it is not `.` (e.g. a German `1,5`) the image is rewritten to a
+ * JS-parseable form before `Number()`. The raw `image` is retained on the node so editing-mode
+ * round-trip reproduces exactly what was typed and display re-imaging (`tokensToString`) can
+ * re-localize; `value` is always the canonical JS number.
+ */
+export declare function createNumber(image: string, locale?: CompilerLocale): ASTNode;
+export declare function createString(image: string): ASTNode;
+export declare function createLiteralArray(row: any): ASTNode;
+export declare function createLiteralRow(): ASTNode;
+/**
+ * @param image Converts text to boolean.
+ * @param locale The locale the image was lexed with. `locale.parseBoolean` accepts the canonical
+ * English `TRUE`/`FALSE` always (Excel parity — imported/pasted formulas never break) plus the
+ * locale's own words (e.g. `WAHR`/`FALSCH`). The raw `image` is kept so editing-mode round-trip and
+ * display re-imaging can reproduce/re-localize the literal; `value` is the canonical JS boolean.
+ */
+export declare function createBoolean(image: string, locale?: CompilerLocale): ASTNode;
+/**
+ * @param image The error label as typed — canonical (`#VALUE!`) or localized (`#WERT!`). `value` is
+ * the canonical {@link FormulaError} either way (storage stays canonical); the raw `image` is kept so
+ * editing round-trip and display re-imaging reproduce/re-localize the label. `locale.parseError`
+ * accepts canonical ALWAYS plus the locale's labels.
+ */
+export declare function createLiteralError(image: string, locale?: CompilerLocale): ASTNode;
+/**
+ * Reference error is different from a literal error in that it's a reference.
+ *
+ * @param image The error label (canonical or localized).
+ * @param locale The locale the image was lexed with; `locale.parseError` maps localized → canonical.
+ * @param scope The sheet qualifier the dead reference carried (`Data!#REF!`) — a sheet stableId once
+ * linked, a raw sheet name before. Omit for a bare `#REF!`.
+ *
+ * @remarks
+ * The single choke point for BOTH sides: the parser builds one from typed text, and every rewrite
+ * that kills a reference (`FormulaBlock.setReferenceAt`) builds one from the dying reference's own
+ * scope — so the qualifier is authored the same way it is read.
+ */
+export declare function createRefError(image?: string, locale?: CompilerLocale, scope?: string | null): ASTNode;
+/**
+ * Unresolved name error
+ */
+export declare function createNameError(): ASTNode;
+/**
+ * The plain error behind an `error` node/token value, whichever shape it is: an error REFERENCE
+ * carries an {@link ICalculation.ErrorRef} (qualifier and all), an error LITERAL the bare
+ * {@link FormulaError}. Evaluation and precedent resolution want the error itself either way — an
+ * `ErrorRef` never escapes the reference layer into a cell value.
+ */
+export declare function errorOfValue(value: unknown): FormulaError.Known;
+/**
+ * Does an error token's `text` already carry its sheet qualifier (`Data!#REF!`)?
+ *
+ * @remarks
+ * The Cell/Named emit paths answer this with "does the text contain a `!`" — a bare `A1`/`MyName`
+ * image never does, so one means the typed prefix is already there. An error label ENDS in `!`
+ * (`#REF!`), so that test reads true for every error token and the qualifier gets dropped. A
+ * qualifier can only PRECEDE the label, so what settles it is whether anything comes before the `#`.
+ */
+export declare function isQualifiedErrorText(text: string): boolean;
+/**
+ * Used for empty arguments ',,'
+ */
+export declare function createEmpty(): ASTNode;
+/**
+ * Visits the AST node depth first and call the visitor function. This will replace
+ * the tree with a new tree if any visitor calls return a new value.
+ *
+ * @param root The root AST node to start traversing from
+ * @param visitor The visitor function to apply to each node
+ * @returns The potentially modified AST
+ *
+ * @remarks
+ *   • Children are visited **before** their parent (post-order).
+ *   • If the visitor returns a node, that node replaces the current one.
+ *   • Child changes are applied using a cheap *copy-on-write* strategy, so the
+ *     original tree is never mutated; unchanged sub-trees are kept by
+ *     reference.
+ */
+export declare function visitAST(root: ASTNode, visitor: ASTVisitor): ASTNode;
+/**
+ * Format a parse / lex error into a concise, UI-friendly message: the underlying error text prefixed
+ * by its position.
+ *
+ * The offending source is intentionally **not echoed** and no caret is drawn — the editor already
+ * shows the formula, so a re-print of it (plus a `^` pointing into that re-print) is noise. The exact
+ * coordinates still live on the error's `errorLocation` / `details`, so any surface that wants to draw
+ * a caret can. The line number is omitted for a single-line `source` (a bare column reads cleaner);
+ * multi-line keeps `line:column`.
+ *
+ * @param rawMessage The underlying error text (e.g. `Missing closing parenthesis ')'`).
+ * @param line 1-based line of the error.
+ * @param column 1-based column of the error.
+ * @param source The full expression being compiled — used only to detect single- vs multi-line.
+ */
+export declare function formatParseErrorMessage(rawMessage: string, line: number, column: number, source: string): string;
+export declare function copyTrivia(target: ASTNode, source: ASTNode): ASTNode;
+export declare const binaryOperatorsPrecedence: readonly string[][];
+export declare const rangeSpanOperators: readonly string[];
+export declare const rangedOperators: readonly string[];
+export declare const rangesOperators: readonly string[];
+//# sourceMappingURL=ParserUtils.d.ts.map

package/types/src/calculation/compiler/ParserUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParserUtils.d.ts","sourceRoot":"","sources":["../../../../../src/calculation/compiler/ParserUtils.ts"],"names":[],"mappings":"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"}

package/types/src/calculation/compiler/SRLexer.d.ts

@@ -0,0 +1,19 @@
+import { TokenType as CTokenType, ILexingResult } from 'chevrotain';
+import { CompilerLocale } from './CompilerLocale';
+/**
+ * Tokenizer for structured-reference inner content. Configurable (mirrors {@link FormulaLexer}): the
+ * constructor takes a {@link CompilerLocale} and builds the `TableSpecifier`/`BareSpecifier` patterns
+ * with the locale's specifier words as alternatives alongside the canonical set. Was previously a
+ * module-level singleton with English-only patterns — the static form could not accept `[#Alle]`.
+ */
+export declare class SRLexer {
+    private readonly _lexer;
+    /** The token vocabulary passed to the {@link SRParser}. */
+    private readonly _vocabulary;
+    constructor(locale?: CompilerLocale);
+    /** The token vocabulary, which maps token names to Chevrotain token types. */
+    getVocabulary(): Record<string, CTokenType>;
+    /** Break structured-reference inner content into tokens. */
+    tokenize(input: string): ILexingResult;
+}
+//# sourceMappingURL=SRLexer.d.ts.map

package/types/src/calculation/compiler/SRLexer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SRLexer.d.ts","sourceRoot":"","sources":["../../../../../src/calculation/compiler/SRLexer.ts"],"names":[],"mappings":"AAAA,OAAO,EACe,KAAK,SAAS,IAAI,UAAU,EAAE,KAAK,aAAa,EACrE,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,KAAK,cAAc,EAAuC,MAAM,kBAAkB,CAAC;AAwB5F;;;;;GAKG;AACH,qBAAa,OAAO;IAClB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAC/B,2DAA2D;IAC3D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA6B;gBAE7C,MAAM,GAAE,cAAiC;IA8DrD,8EAA8E;IAC9E,aAAa,IAAI,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC;IAI3C,4DAA4D;IAC5D,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa;CAGvC"}

package/types/src/calculation/compiler/SRParser.d.ts

@@ -0,0 +1,38 @@
+import { EmbeddedActionsParser } from 'chevrotain';
+import { ParseResult } from './ASTTypes';
+import { CompilerLocale } from './CompilerLocale';
+/**
+ * Parser for structured reference inner content.
+ *
+ * Handles the specifier list forms that start with '[' or '#'.
+ * The '@' form and bare column names are pre-routed in parseSRContent before
+ * this parser is invoked.
+ *
+ * Grammar:
+ *   content       → item (',' item)*
+ *   item          → specifier | columnOrRange
+ *   specifier     → SRTableSpecifier | SRBareSpecifier
+ *   columnOrRange → SRBracketedColumn (':' SRBracketedColumn)?
+ */
+export declare class SRParser extends EmbeddedActionsParser {
+    /** The configured lexer this parser tokenizes SR content with (built from the locale). */
+    private readonly _lexer;
+    constructor(locale?: CompilerLocale);
+    private _parseInner;
+    /**
+     * Routes the inner bracket content to the appropriate node builder.
+     *
+     * Uses `inner` (untrimmed) for bare column names to preserve edge whitespace,
+     * e.g. '[ Column1 ]' has inner=' Column1 ' which must round-trip as ' Column1 '.
+     */
+    private _parseContent;
+    /**
+     * Parses a complete structured reference and returns a ParseResult.
+     *
+     * Accepts the full token image in either form:
+     *   '[Column1]'                 — no table name (BracketedString token)
+     *   'Table1[#Headers,[Col1]]'   — with table name (TableReference token)
+     */
+    parse(rowIndex: number, colIndex: number, expression: string): ParseResult;
+}
+//# sourceMappingURL=SRParser.d.ts.map

package/types/src/calculation/compiler/SRParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SRParser.d.ts","sourceRoot":"","sources":["../../../../../src/calculation/compiler/SRParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAe,MAAM,YAAY,CAAC;AAEhE,OAAO,EAAgB,KAAK,WAAW,EAAE,MAAM,YAAY,CAAC;AAG5D,OAAO,EAAE,KAAK,cAAc,EAAoB,MAAM,kBAAkB,CAAC;AAGzE;;;;;;;;;;;;GAYG;AACH,qBAAa,QAAS,SAAQ,qBAAqB;IACjD,0FAA0F;IAC1F,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAU;gBAErB,MAAM,GAAE,cAAiC;IA+FrD,OAAO,CAAC,WAAW;IAQnB;;;;;OAKG;IACH,OAAO,CAAC,aAAa;IAiCrB;;;;;;OAMG;IACH,KAAK,CACH,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,GACjB,WAAW;CAgBf"}