solve-engine 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/chunk-OFXOTECC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/normalizer/TokenNormalizer.ts","../src/normalizer/PhraseTrie.ts","../src/normalizer/BuiltinNormalizerRules.ts"],"names":[],"mappings":"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","file":"chunk-OFXOTECC.js","sourcesContent":["//#region ─── Module Overview ───────────────────────────────────────────────────\n\n/**\n * TokenNormalizer, post-lexer token normalization pass.\n *\n * ## Purpose\n * Applies domain-specific {@link NormalizerRule | NormalizerRules} to the raw\n * token stream produced by the {@link ExpressionLexer}. This keeps the lexer\n * slim and focused on single-token production, while multi-token pattern\n * matching (phrases, implicit operators, domain merges) lives here.\n *\n * ## What rules can do\n * - **Phrase fusion**: Merge consecutive words into compound tokens\n *   (e.g., `IDENT + ... + IDENT` → `CARET`)\n * - **Implicit operator insertion**: Insert missing operators between tokens\n *   (e.g., `NUMBER IDENT` → `NUMBER STAR IDENT`)\n * - **Domain-specific transformations**: Coalesce item names, currency pairs,\n *   percentage syntax, etc.\n *\n * ## Architecture\n * Providers register NormalizerRules alongside Parselets and OpCode handlers\n * via {@link IEnginePackage.normalizerRules}. The normalizer applies them\n * greedily left-to-right in multiple passes with safety limits.\n *\n * @module TokenNormalizer\n */\n\n//#endregion\n//#region ─── Imports ──────────────────────────────────────────────────────────\n\nimport type { Token } from \"@solve-js/lexer/Token\";\nimport { tokenTypeId } from \"@solve-js/lexer/Token\";\nimport { LexerToken } from \"@solve-js/lexer/ExpressionLexer\";\nimport type { NormalizerRule, TokenFusion } from \"./NormalizerRule\";\nimport { PhraseTrie } from \"./PhraseTrie\";\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\n\n//#endregion\n//#region ─── NormalizerOptions, Configuration ────────────────────────────────\n\n/**\n * Configuration options for the normalization pass.\n *\n * These control safety limits and diagnostic callbacks. The defaults\n * are chosen to be generous enough for any realistic expression while\n * preventing runaway token expansion from recursive rules.\n */\nexport interface NormalizerOptions {\n  /**\n   * Maximum number of full passes over the token stream before bailing out.\n   * Prevents infinite loops from recursive rule chains.\n   * @default 100\n   */\n  maxPasses?: number;\n\n  /**\n   * Maximum number of tokens allowed after normalization.\n   * If exceeded, an Error is thrown rather than passing a bloated stream\n   * to the parser.\n   * @default 10000\n   */\n  maxTokens?: number;\n\n  /**\n   * Callback invoked for each fusion event during normalization.\n   * Used by diagnostic mode to populate {@link NormalizerOutput.fusions}.\n   * When `undefined`, fusions are still tracked internally but no callbacks fire.\n   */\n  onFusion?: (fusion: TokenFusion) => void;\n}\n\n//#endregion\n//#region ─── Default Options ──────────────────────────────────────────────────\n\n/** Sensible defaults that catch infinite loops without limiting real expressions. */\nconst DEFAULT_OPTIONS: Required<NormalizerOptions> = {\n  maxPasses: 100,\n  maxTokens: 10000,\n  onFusion: () => {},\n};\n\n//#endregion\n//#region ─── createFusedToken, Token Factory ──────────────────────────────────\n\n/**\n * Creates a new normalized token from fused source tokens.\n *\n * The fused token inherits position information (offset, line, column)\n * from the first source token, which preserves source-map accuracy\n * for error messages and diagnostic highlighting.\n *\n * It also records where the source text ENDS, on `sourceEnd`. The start alone\n * is not enough to describe the span a fusion covers, because `text` is the\n * replacement rather than the original: `10 frames` fuses into a FRAME_COUNT\n * whose text is `10`, and a timecode fuses into a token whose text is a\n * comma-separated tuple that appears nowhere in the line. Anything painting the\n * line needs both ends, and only this function is in a position to know them.\n *\n * @param type         - The new token type (e.g., \"CARET\", \"TIMES_BY\")\n * @param text         - The combined text representation (e.g., \"to the power of\")\n * @param sourceTokens - The original tokens being fused (at least 2)\n * @returns A new {@link LexerToken} with the fused type and combined text\n */\nexport function createFusedToken(\n  type: string,\n  text: string,\n  sourceTokens: Token[]\n): Token {\n  const first = sourceTokens[0];\n  const last = sourceTokens[sourceTokens.length - 1];\n  const token = new LexerToken(\n    type,\n    tokenTypeId(type),\n    text,\n    text,\n    first.offset,\n    first.lineBreaks ?? 0,\n    first.line,\n    first.col,\n  );\n  token.sourceEnd = last.offset + last.value.length;\n  return token;\n}\n\n/**\n * Record, on a token that replaced several, where its source text ended.\n *\n * Called centrally rather than left to each rule. A rule that builds its\n * replacement by hand rather than through {@link createFusedToken} is doing\n * nothing wrong, and several do: the date-literal rule needs a token whose\n * value is an epoch and whose text is the source, which that factory cannot\n * express. Stamping here means every fusion carries its span, including ones\n * written after this was.\n *\n * Reads `sourceEnd` off the last source token when it has one, so a fusion of\n * a fusion still describes the original text rather than the intermediate.\n *\n * @param fused - The single token the rule produced.\n * @param sourceTokens - The tokens it consumed.\n */\nfunction recordSourceSpan(fused: Token, sourceTokens: Token[]): void {\n  const last = sourceTokens[sourceTokens.length - 1];\n  if (!last) return;\n  fused.sourceEnd = last.sourceEnd ?? last.offset + last.value.length;\n}\n\n//#endregion\n//#region ─── NON_WORD_TOKEN_TYPES, Type-guard skip set ────────────────────────\n\n/**\n * Token types that can NEVER start a multi-word phrase.\n *\n * Used by {@link normalize} to skip the PhraseTrie walk entirely at\n * positions where the token type makes phrase matching impossible.\n * This avoids even the O(1) {@link PhraseTrie.canStart} check.\n *\n * Types NOT in this set (IDENT, KEYWORD, FUNC, UNIT, and any custom\n * types registered by packages) still pass through to the trie for\n * a full match attempt.\n */\n// ── Non-word type ID lookup table (flat Uint8Array, true O(1) array index) ──\n//\n// Index = token typeId, value = 1 if non-word (skip trie), 0 otherwise.\n// Array indexing avoids ALL hashing: no Set.has(), no Map.get(), no string ops.\n//\n// Custom types from packages get IDs beyond the table length, so the bounds\n// check `tid < TABLE.length` safely passes them through to the trie.\n//\n// Arithmetic operators (PLUS, MINUS, STAR, SLASH, CARET, MOD, PERCENT) are\n// intentionally excluded: in keyword locales the lexer maps \"times\"→STAR,\n// \"divide\"→SLASH etc., and those tokens CAN start phrases like \"times by\".\n/**\n * Token type names that can NEVER start a multi-word phrase.\n *\n * Exported for testing only, consumers should use the type-guard behavior\n * of {@link TokenNormalizer.normalize} rather than this list directly.\n */\nexport const NON_WORD_NAMES = [\n\t\"NUMBER\", \"HEX\", \"BIGINT\", \"FLOAT\",\n\t\"LSHIFT\", \"RSHIFT\", \"BIT_AND\", \"BIT_OR\", \"BIT_XOR\",\n\t\"LPAREN\", \"RPAREN\", \"LBRACKET\", \"RBRACKET\",\n\t\"COMMA\", \"COLON\", \"EQUALS\", \"THEREFORE\", \"PIPE\", \"AMPERSAND\", \"AT\",\n\t\"SEMICOLON\", \"QUESTION\", \"EXCLAMATION\",\n\t\"EOF\", \"WS\", \"NEWLINE\",\n] as const;\n\n/**\n * Flat Uint8Array lookup table: index = token typeId, value = 1 if non-word.\n *\n * Exported for testing only, consumers should not depend on the internal\n * table layout, as the set of non-word types may change.\n */\nexport const NON_WORD_TABLE: Uint8Array = (() => {\n\t// Resolve all non-word type names to their numeric IDs\n\tconst ids = NON_WORD_NAMES.map(n => tokenTypeId(n));\n\t// Size the table to cover the largest ID + 1\n\tconst len = Math.max(...ids) + 1;\n\tconst table = new Uint8Array(len);\n\t// Mark non-word type positions\n\tfor (const id of ids) table[id] = 1;\n\treturn table;\n})();\n\n//#endregion\n//#region ─── TokenNormalizer Class ─────────────────────────────────────────────\n\n/**\n * Token normalizer: applies {@link NormalizerRule | NormalizerRules} to a token stream.\n *\n * ## Lifecycle\n * 1. **Registration**: Rules are added via {@link register} and sorted by priority\n * 2. **Normalization**: {@link normalize} applies rules greedily left-to-right\n * 3. **Cleanup**: {@link clear} or {@link unregister} removes rules\n *\n * ## Normalization algorithm\n * The normalizer uses a greedy left-to-right multi-pass algorithm:\n * - At each token position, rules are tried in priority order (highest first)\n * - When a rule matches, matched tokens are consumed and replaced\n * - Processing continues from the replacement position\n * - Multiple passes handle cascading matches (one rule's output triggers another)\n * - Safety limits ({@link NormalizerOptions.maxPasses}) prevent infinite loops\n *\n * @example\n * ```ts\n * const normalizer = new TokenNormalizer();\n * normalizer.register(phraseRule);       // \"to the power of\" → CARET\n * normalizer.register(implicitMultRule); // \"2 x\" → \"2 * x\"\n * const normalized = normalizer.normalize(rawTokens);\n * ```\n */\nexport class TokenNormalizer {\n  /** Registered rules, unsorted, the source of truth. */\n  private rules: NormalizerRule[] = [];\n\n  /**\n   * Priority-sorted copy of {@link rules}, rebuilt lazily on the next\n   * {@link normalize} call after a mutation. Rules are registered once at\n   * engine/package-registration time and essentially never change during a\n   * session, but normalize() runs on every keystroke-driven evaluation, an\n   * earlier version re-sorted a fresh copy of `rules` on every single call,\n   * which meant every keystroke paid for an allocation + sort of a list that\n   * had usually not changed since the last one. `null` means \"stale, rebuild\n   * on next use\"; {@link register}/{@link unregister}/{@link clear} all\n   * invalidate it.\n   */\n  private sortedRulesCache: NormalizerRule[] | null = null;\n\n  /**\n   * Phrase trie for single-pass multi-word phrase fusion.\n   * Tried at each token position BEFORE other rules, the trie walk\n   * is O(depth) vs O(R × W) for separate rule matching.\n   */\n  private phraseTrie = new PhraseTrie();\n\n  /** Merged options with defaults applied. */\n  private options: Required<NormalizerOptions>;\n\n  // ── Constructor ──────────────────────────────────────────────────────────\n\n  /**\n   * @param options - Configuration overrides for safety limits and diagnostic callbacks\n   */\n  constructor(options: NormalizerOptions = {}) {\n    this.options = { ...DEFAULT_OPTIONS, ...options };\n  }\n\n  // ── Rule Management ──────────────────────────────────────────────────────\n\n  /**\n   * Register a normalization rule.\n   *\n   * Rules are sorted by priority (descending) on each {@link normalize} call.\n   * Multiple rules can share the same priority, they are tried in registration\n   * order when priorities are equal.\n   *\n   * @param rule - The rule to register\n   */\n  register(rule: NormalizerRule): void {\n    this.rules.push(rule);\n    this.sortedRulesCache = null;\n  }\n\n  /**\n   * Unregister a normalization rule by its {@link NormalizerRule.name | name}.\n   *\n   * If multiple rules share the same name, all are removed. This is safe to\n   * call with a name that doesn't match any rule, it simply has no effect.\n   *\n   * @param ruleName - The name of the rule to remove\n   */\n  unregister(ruleName: string): void {\n    this.rules = this.rules.filter(r => r.name !== ruleName);\n    this.sortedRulesCache = null;\n  }\n\n  /**\n   * Remove all registered rules, resetting the normalizer to its initial state.\n   * Also clears the phrase trie.\n   */\n  clear(): void {\n    this.rules = [];\n    this.sortedRulesCache = null;\n    this.phraseTrie = new PhraseTrie();\n  }\n\n  /**\n   * Priority-sorted view of {@link rules} (descending priority; registration\n   * order preserved for ties, since {@link Array.prototype.sort} is stable).\n   * Cached until the next mutation. See {@link sortedRulesCache}.\n   */\n  private getSortedRules(): NormalizerRule[] {\n    if (this.sortedRulesCache === null) {\n      this.sortedRulesCache = [...this.rules].sort((a, b) => b.priority - a.priority);\n    }\n    return this.sortedRulesCache;\n  }\n\n  /**\n   * Get the number of currently registered rules (excludes phrase trie entries).\n   */\n  get ruleCount(): number {\n    return this.rules.length;\n  }\n\n  // ── Phrase Registration ────────────────────────────────────────────────\n\n  /**\n   * Register a multi-word phrase for fusion into a single compound token.\n   *\n   * This is the preferred way to add phrase patterns. It inserts into the\n   * internal {@link PhraseTrie}, which collapses all phrase rules into a\n   * single O(depth) trie walk per position, no separate rule scanning.\n   *\n   * @param phrase    - Multi-word phrase (e.g., \"to the power of\", \"abyssal whip\")\n   * @param tokenType - Target token type after fusion (e.g., \"CARET\", \"ITEM\")\n   */\n  addPhrase(phrase: string, tokenType: string): void {\n    this.phraseTrie.addPhrase(phrase, tokenType);\n  }\n\n  /**\n   * Check whether a word can start any registered phrase.\n   *\n   * Used by {@link implicitMultiplyRule} to suppress `*` insertion\n   * before phrase-starting identifiers (e.g., \"2 power of 3\" → `2 ^ 3`,\n   * not `2 * power of 3`). Delegates to {@link PhraseTrie.canStart}.\n   */\n  /**\n   * Get all registered phrases and their target token types.\n   *\n   * Exposes the full phrase trie structure for diagnostic rendering\n   * in the playground's NormalizerTab. Returns ALL registered phrases,\n   * not just the ones that matched in the last evaluation.\n   */\n  getPhrases(): Record<string, string> {\n    return this.phraseTrie.getAllPhrases();\n  }\n\n  canStartPhrase(word: string): boolean {\n    return this.phraseTrie.canStart(word);\n  }\n\n  // ── Normalization ────────────────────────────────────────────────────────\n\n  /**\n   * Normalize a token stream by applying all registered rules.\n   *\n   * ## Algorithm\n   * Applies rules greedily left-to-right in multiple passes:\n   * 1. Sort rules by priority (descending)\n   * 2. Walk the token stream left to right\n   * 3. At each position, try rules in priority order\n   * 4. On match: consume matched tokens, insert replacements, restart from insert point\n   * 5. On no match: pass token through unchanged\n   * 6. Repeat until a full pass produces no changes, or maxPasses is reached\n   *\n   * ## Fusion tracking\n   * When a rule consumes more tokens than it produces, the normalizer calls\n   * `onFusion` with a {@link TokenFusion} record for diagnostic collection.\n   * This populates {@link NormalizerOutput.fusions} in the playground pipeline view.\n   *\n   * ## Safety\n   * If the normalized token count exceeds {@link NormalizerOptions.maxTokens},\n   * an Error is thrown to prevent memory exhaustion from runaway rule expansion.\n   *\n   * @param tokens   - Raw tokens from the lexer\n   * @param onFusion - Optional fusion callback (overrides {@link NormalizerOptions.onFusion})\n   * @returns Normalized tokens ready for parsing\n   * @throws {Error} If the normalized token count exceeds maxTokens\n   */\n  normalize(tokens: Token[], onFusion?: (fusion: TokenFusion) => void): Token[] {\n    // ── Early exit: nothing to normalize ──\n    if (tokens.length === 0) return tokens;\n\n    // ── Priority-sorted rules, cached across calls, see getSortedRules() ──\n    const sorted = this.getSortedRules();\n    const fusionHandler = onFusion ?? this.options.onFusion;\n    const maxPasses = this.options.maxPasses;\n    const maxTokens = this.options.maxTokens;\n\n    let current = tokens;\n    let changed = true;\n    let passCount = 0;\n\n    // Multi-pass loop: rules may trigger cascading matches across passes\n    while (changed && passCount < maxPasses) {\n      changed = false;\n      passCount++;\n\n      const result: Token[] = [];\n      let pos = 0;\n\n      // Single-pass left-to-right greedy walk\n      while (pos < current.length) {\n        let matched = false;\n\n        // ── Fast path: phrase trie (O(depth) single walk vs O(R × W) per rule) ──\n        // O(1) type-guard: skip trie entirely for tokens that can't start phrases.\n        // Flat Uint8Array indexed by typeId, no hashing, no Set lookup, true O(1).\n        const tid = current[pos].typeId;\n        if (tid >= NON_WORD_TABLE.length || NON_WORD_TABLE[tid] === 0) {\n          const trieMatch = this.phraseTrie.matchAt(current, pos);\n          if (trieMatch) {\n            const sourceTokens = current.slice(pos, pos + trieMatch.consumed);\n            for (const rt of trieMatch.replacement) {\n              result.push(rt);\n            }\n            if (trieMatch.consumed > 1 && trieMatch.replacement.length === 1) {\n              recordSourceSpan(trieMatch.replacement[0], sourceTokens);\n              fusionHandler({\n                rule: trieMatch.ruleName ?? \"phrase-trie\",\n                sourceTokens,\n                fusedToken: trieMatch.replacement[0],\n              });\n            }\n            pos += trieMatch.consumed;\n            changed = true;\n            continue; // trie matched — skip other rules at this position (no need to set matched)\n          }\n        }\n\n        // Try every rule in priority order at this position\n        for (const rule of sorted) {\n          const match = rule.match(current, pos);\n          if (match) {\n            // Collect source tokens for fusion tracking\n            const sourceTokens = current.slice(pos, pos + match.consumed);\n\n            // Insert replacement tokens into result\n            for (const rt of match.replacement) {\n              result.push(rt);\n            }\n\n            // Track fusion events for diagnostics:\n            // - Multiple tokens → single token: classic fusion\n            // - Multiple tokens → fewer tokens: partial fusion\n            if (match.consumed > 1 && match.replacement.length === 1) {\n              recordSourceSpan(match.replacement[0], sourceTokens);\n              fusionHandler({\n                rule: rule.name,\n                sourceTokens,\n                fusedToken: match.replacement[0],\n              });\n            } else if (match.consumed > 1 && match.replacement.length < match.consumed) {\n              for (const rt of match.replacement) {\n                fusionHandler({\n                  rule: rule.name,\n                  sourceTokens,\n                  fusedToken: rt,\n                });\n              }\n            }\n\n            // Advance position past consumed tokens\n            pos += match.consumed;\n            changed = true;\n            matched = true;\n            break; // Rule matched — restart at new position with highest-priority rules\n          }\n        }\n\n        if (!matched) {\n          // No rule matched at this position, pass token through unchanged\n          result.push(current[pos]);\n          pos++;\n        }\n      }\n\n      // Safety: bail if token count explodes (runaway rule expansion)\n      if (result.length > maxTokens) {\n        // A raw Error here would bypass ThreeTierEvaluator's DAG-preservation\n        // enrichment on compile failure (it specifically checks for\n        // EngineError). Same reasoning as ExpressionEngineSafety.ts's\n        // complexity/length checks, which this mirrors.\n        throw ErrorFactory.validation(\n          \"NORMALIZED_TOKEN_LIMIT_EXCEEDED\",\n          `Normalized token count (${result.length}) exceeds safety limit (${maxTokens})`,\n          { tokenCount: result.length, maxTokens }\n        );\n      }\n\n      current = result;\n    }\n\n    return current;\n  }\n}\n\n//#endregion\n","//#region ─── Module Overview ───────────────────────────────────────────────────\n\n/**\n * PhraseTrie, optimized word-level trie for multi-word phrase fusion.\n *\n * ## Problem\n * The normalizer previously applied N separate `phraseFusionRule` instances,\n * each scanning forward from the current token position. For R phrase rules\n * and W average phrase length, this cost O(N × R × W) per pass.\n *\n * ## Solution\n * A single trie walk per position collapses all phrase rules into O(D)\n * where D ≤ longest phrase depth (typically ≤ 5 words). The trie tracks\n * the deepest terminal node reached, implementing longest-match-wins\n * without priority sorting.\n *\n * ## Optimizations\n * 1. **Set<string> quick-reject**, the `startWords` set contains the first\n *    word of every registered phrase. At each position, if the token's\n *    lowercase value isn't in the set, we bail in O(1) without touching\n *    the trie. ~80% of tokens (numbers, operators) hit this fast path.\n * 2. **Longest-match-wins**, the `matchAt()` walk continues past terminal\n *    nodes, tracking the deepest one. Shorter overlapping phrases (e.g.,\n *    \"power of\") don't need lower priority, the trie naturally prefers\n *    the longer match.\n * 3. **Map-based children**, `Map<string, TrieNode>` gives O(1) amortized\n *    child lookup per word, faster than array scanning for sparse branches.\n *\n * ## Package integration\n * Packages add phrases via {@link TokenNormalizer.addPhrase} (public API)\n * or the {@link IEnginePackage.phrases} declarative field. Each call to\n * `addPhrase()` inserts the phrase into this trie and updates `startWords`.\n *\n * @module PhraseTrie\n */\n\n//#endregion\n//#region ─── Imports ──────────────────────────────────────────────────────────\n\nimport type { Token } from \"@solve-js/lexer/Token\";\nimport type { NormalizerMatch } from \"./NormalizerRule\";\nimport { createFusedToken } from \"./TokenNormalizer\";\n\n//#endregion\n//#region ─── TrieNode ─────────────────────────────────────────────────────────\n\n/**\n * Internal trie node.\n *\n * Each node represents a matched word in a phrase. The path from root\n * to a node spells out a partial or complete phrase.\n */\ninterface TrieNode {\n\t/** Child nodes keyed by next word (all lowercase). */\n\tchildren: Map<string, TrieNode>;\n\t/**\n\t * If this node completes a phrase, the terminal metadata.\n\t * A node can be both terminal AND have children. This handles\n\t * overlapping phrases like \"power of\" and \"to the power of\".\n\t */\n\tterminal: TrieTerminal | null;\n}\n\n/** Metadata stored at terminal nodes for deferred token creation. */\ninterface TrieTerminal {\n\t/** The target token type after fusion (e.g., \"CARET\", \"TIMES_BY\"). */\n\ttokenType: string;\n\t/** The original phrase string (e.g., \"to the power of\"). */\n\tphrase: string;\n\t/** Number of tokens consumed by this phrase. */\n\tconsumed: number;\n}\n\n//#endregion\n//#region ─── PhraseTrie ─────────────────────────────────────────────────────\n\n/**\n * Word-level trie for single-pass multi-word phrase matching.\n *\n * @example\n * ```ts\n * const trie = new PhraseTrie();\n * trie.addPhrase(\"to the power of\", \"CARET\");\n * trie.addPhrase(\"power of\", \"CARET\");\n * trie.addPhrase(\"abyssal whip\", \"ITEM\");\n *\n * // At position 0 with tokens [\"to\",\"the\",\"power\",\"of\",\"3\"]\n * const match = trie.matchAt(tokens, 0);\n * // → { consumed: 4, replacement: [CARET(\"to the power of\")] }\n * ```\n */\nexport class PhraseTrie {\n\t/**\n\t * First words that can start any registered phrase (all lowercase).\n\t * O(1) quick-reject: if `tokens[pos].value.toLowerCase()` isn't here,\n\t * no phrase can match at this position.\n\t */\n\tprivate startWords = new Set<string>();\n\n\t/**\n\t * Root maps first word → child node.\n\t * Two-level root avoids an unnecessary intermediate TrieNode.\n\t */\n\tprivate root = new Map<string, TrieNode>();\n\n\t// ── Registration ──────────────────────────────────────────────────────\n\n\t/**\n\t * Register a phrase for fusion into a single compound token.\n\t *\n\t * @param phrase    - Multi-word phrase (e.g., \"to the power of\")\n\t * @param tokenType - Target token type after fusion (e.g., \"CARET\")\n\t */\n\taddPhrase(phrase: string, tokenType: string): void {\n\t\tconst words = phrase.toLowerCase().trim().split(/\\s+/);\n\t\tif (words.length === 0 || words[0] === \"\") return;\n\n\t\tthis.startWords.add(words[0]);\n\n\t\tconst firstWord = words[0];\n\t\tlet node: TrieNode;\n\n\t\tif (this.root.has(firstWord)) {\n\t\t\tnode = this.root.get(firstWord)!;\n\t\t} else {\n\t\t\tnode = { children: new Map(), terminal: null };\n\t\t\tthis.root.set(firstWord, node);\n\t\t}\n\n\t\t// Single-word phrase: terminal at root's child\n\t\tif (words.length === 1) {\n\t\t\tnode.terminal = { tokenType, phrase, consumed: 1 };\n\t\t\treturn;\n\t\t}\n\n\t\t// Walk/insert remaining words\n\t\tfor (let i = 1; i < words.length; i++) {\n\t\t\tconst word = words[i];\n\t\t\tif (!node.children.has(word)) {\n\t\t\t\tnode.children.set(word, { children: new Map(), terminal: null });\n\t\t\t}\n\t\t\tnode = node.children.get(word)!;\n\t\t}\n\n\t\tnode.terminal = { tokenType, phrase, consumed: words.length };\n\t}\n\n\t// ── Matching ──────────────────────────────────────────────────────────\n\n\t/**\n\t * Attempt to match a phrase starting at `pos` in the token stream.\n\t *\n\t * Walks the trie one token at a time, tracking the deepest terminal\n\t * node reached. Returns the longest match found, or `null` if no\n\t * phrase starts at this position.\n\t *\n\t * @param tokens - The current token stream\n\t * @param pos    - Position to attempt matching from\n\t * @returns The longest {@link NormalizerMatch}, or `null` on no match\n\t */\n\tmatchAt(tokens: Token[], pos: number): NormalizerMatch | null {\n\t\t// ── Bounds guard ──\n\t\tif (pos >= tokens.length) return null;\n\n\t\t// ── O(1) quick-reject: first word not a phrase starter ──\n\t\tconst firstWord = tokens[pos].value.toLowerCase();\n\t\tif (!this.startWords.has(firstWord)) return null;\n\n\t\t// ── Walk trie, tracking deepest terminal ──\n\t\tlet node: TrieNode | undefined = this.root.get(firstWord);\n\t\tif (!node) return null;\n\n\t\tlet best: NormalizerMatch | null = null;\n\t\tlet depth = 1;\n\n\t\t// Check single-word phrase at first node\n\t\tif (node.terminal) {\n\t\t\tconst sourceTokens = tokens.slice(pos, pos + 1);\n\t\t\tbest = {\n\t\t\t\tconsumed: 1,\n\t\t\t\treplacement: [createFusedToken(node.terminal.tokenType, node.terminal.phrase, sourceTokens)],\n\t\t\t\truleName: node.terminal.phrase,\n\t\t\t};\n\t\t}\n\n\t\t// Walk deeper for multi-word phrases\n\t\tfor (let i = pos + 1; i < tokens.length && node?.children; i++) {\n\t\t\tconst word = tokens[i].value.toLowerCase();\n\t\t\tnode = node.children.get(word);\n\t\t\tif (!node) break; // dead end\n\t\t\tdepth++;\n\n\t\t\tif (node.terminal) {\n\t\t\t\t// Deferred fused-token creation, only on deepest match found\n\t\t\t\tconst sourceTokens = tokens.slice(pos, pos + depth);\n\t\t\t\tbest = {\n\t\t\t\t\tconsumed: depth,\n\t\t\t\t\treplacement: [\n\t\t\t\t\t\tcreateFusedToken(node.terminal.tokenType, node.terminal.phrase, sourceTokens),\n\t\t\t\t\t],\n\t\t\t\t\truleName: node.terminal.phrase,\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\treturn best;\n\t}\n\n\t// ── Introspection ─────────────────────────────────────────────────────\n\n\t/** Number of unique first words (not total phrases). */\n\tget size(): number {\n\t\treturn this.root.size;\n\t}\n\n\t/**\n\t * Return all registered phrases and their target token types.\n\t *\n\t * Used by diagnostic mode to expose the complete trie structure to the\n\t * playground's NormalizerTab for rendering ALL registered phrases\n\t * (not just the ones that matched in this evaluation).\n\t */\n\tgetAllPhrases(): Record<string, string> {\n\t\tconst result: Record<string, string> = {};\n\n\t\tconst collect = (node: TrieNode, path: string[]): void => {\n\t\t\tif (node.terminal) {\n\t\t\t\tresult[path.join(' ')] = node.terminal.tokenType;\n\t\t\t}\n\t\t\tfor (const [word, child] of node.children) {\n\t\t\t\tcollect(child, [...path, word]);\n\t\t\t}\n\t\t};\n\n\t\tfor (const [firstWord, node] of this.root) {\n\t\t\tcollect(node, [firstWord]);\n\t\t}\n\n\t\treturn result;\n\t}\n\n\t/** Check if any phrase starts with this word (case-insensitive). */\n\tcanStart(word: string): boolean {\n\t\treturn this.startWords.has(word.toLowerCase());\n\t}\n}\n\n//#endregion\n","//#region ─── Module Overview ───────────────────────────────────────────────────\n\n/**\n * Built-in normalization rules for the {@link TokenNormalizer}.\n *\n * These rules handle common expression patterns that span multiple tokens.\n * Phrase fusion (e.g., \"to the power of\" → CARET) is handled by the\n * internal {@link PhraseTrie}. See {@link TokenNormalizer.addPhrase}.\n * This module only exports non-phrase rules like {@link implicitMultiplyRule}.\n *\n * @module BuiltinNormalizerRules\n */\n\n//#endregion\n//#region ─── Imports ──────────────────────────────────────────────────────────\n\nimport type { Token } from \"@solve-js/lexer/Token\";\nimport { tokenTypeId } from \"@solve-js/lexer/Token\";\nimport { LexerToken } from \"@solve-js/lexer/ExpressionLexer\";\nimport type { NormalizerRule, NormalizerMatch } from \"./NormalizerRule\";\n\n//#endregion\n//#region ─── PHRASE_START_WORDS, Implicit Multiply Guard ─────────────────────\n\n/**\n * Words that can start multi-word phrases, hardcoded fallback.\n *\n * This is ONLY used as the default fallback in {@link implicitMultiplyRule}\n * when no `canStart` predicate is provided. In the recommended pattern,\n * the {@link PhraseTrie}'s live `canStart()` set is passed instead, keeping\n * the guard in sync with package-registered phrases.\n *\n * @see {@link TokenNormalizer.canStartPhrase}\n */\n/**\n * Words that introduce a rate denominator when a unit follows.\n *\n * Kept next to the implicit-multiplication rule because that is the only\n * thing they change here; the rate itself is built in the uom package.\n */\nconst RATE_DENOMINATOR_WORDS = new Set([\"per\", \"a\", \"an\", \"each\", \"every\"]);\n\nconst PHRASE_START_WORDS = new Set([\n  \"to\", \"power\", \"increase\", \"decrease\", \"times\", \"multiply\", \"divide\", \"by\",\n]);\n\n//#endregion\n//#region ─── implicitMultiplyRule, Implicit Operator Insertion ────────────────\n\n/**\n * Creates a normalization rule that inserts an implicit multiplication operator\n * between adjacent tokens where multiplication is implied.\n *\n * ## When it fires\n * Inserts a STAR token between:\n * - `NUMBER IDENT` (e.g., \"2 x\" → \"2 * x\")\n * - `RPAREN IDENT` (e.g., \"(x+1)y\" → \"(x+1) * y\")\n * - `NUMBER LPAREN` (e.g., \"2(x+1)\" → \"2 * (x+1)\")\n * - `NUMBER PI` / `NUMBER E` (e.g., \"2π\" → \"2 * π\")\n *\n * ## When it doesn't fire\n * - When the following identifier starts a multi-word phrase\n *   (checked against {@link PHRASE_START_WORDS})\n * - When the following token is not an identifier or parenthesized expression\n *\n * ## Priority\n * Default priority is 50, below phrase fusion so phrases match first.\n *\n * @param priority - Rule priority (default 50)\n * @returns A {@link NormalizerRule} that inserts implicit multiply operators\n */\nexport function implicitMultiplyRule(\n\tpriority: number = 50,\n\tcanStart?: (word: string) => boolean\n): NormalizerRule {\n\tconst phraseGuard = canStart ?? ((word: string) => PHRASE_START_WORDS.has(word.toLowerCase()));\n\n\treturn {\n    name: \"implicit:multiply\",\n    priority,\n    match(tokens: Token[], pos: number): NormalizerMatch | null {\n      // ── Need at least one token after the current position ──\n      if (pos + 1 >= tokens.length) return null;\n\n      const t = tokens[pos];\n      const next = tokens[pos + 1];\n\n      // ── Guard: suppress if the next identifier starts a phrase ──\n      // Uses the trie's canStart when available, falls back to hardcoded set.\n      // This prevents \"2 power of 3\" from becoming \"2 * power of 3\".\n      const nextValue = next.value.toLowerCase();\n      if (phraseGuard(nextValue)) return null;\n\n      // ── Guard: a rate denominator, not a multiplication ──\n      // \"99 per week\" is ninety-nine a week, not ninety-nine times something\n      // called per. The trie guard above cannot cover this, because these are\n      // not registered phrases; they are recognised by the uom package's\n      // bare-denominator rule, which runs after this one and then finds its\n      // fused token stranded in operand position. The slash spelling never had\n      // the problem, which is what made it hard to see.\n      if (RATE_DENOMINATOR_WORDS.has(nextValue) && tokens[pos + 2]?.type === \"UNIT\") return null;\n\n      // ── Check trigger conditions ──\n      const triggers =\n        (t.type === \"NUMBER\" || t.type === \"RPAREN\") &&\n        (next.type === \"IDENT\" || next.type === \"LPAREN\" || next.type === \"PI\" || next.type === \"E\");\n\n      if (!triggers) return null;\n\n      // ── Insert a STAR token at the next token's position ──\n      const starToken = new LexerToken(\n        \"STAR\", tokenTypeId(\"STAR\"), \"*\", \"*\",\n        next.offset, 0, next.line, next.col,\n      );\n\n      // consumed = 1: only the current token is replaced with [current, STAR]\n      // The next token is NOT consumed, it stays for the next iteration\n      return { consumed: 1, replacement: [t, starToken] };\n    },\n  };\n}\n\n//#endregion\n//#region ─── isInsideRangeContext, Bracket/Call-Paren Context Guard ───────────\n\n/**\n * Whether token `pos` sits inside a context where a bare `NUMBER:NUMBER`\n * sequence means a Range, not a clock-time/laptime/video-timecode literal:\n * a matrix literal/index/slice (`[1,2,3]`, `a[0:3]`), OR a `map`/`reduce`/\n * `sum`/`prod` call's own argument-list parens (`map(f, 0:3)`, these\n * accept a bare Range argument directly, per the Calca spec's own\n * example). Scans backward from `pos` over the CURRENT pass's token array,\n * tracking `[`/`(` nesting depth, the same \"positional guard via\n * backward scan\" idiom already used elsewhere in this normalizer layer\n * (e.g. `LineRefNormalizerRule`'s previous-token check), generalized to\n * depth-tracking. An `LBRACKET` is unconditionally a range-safe opener; an\n * `LPAREN` is range-safe ONLY when immediately preceded by MAP/REDUCE/\n * SUM_FN/PROD_FN, an ordinary grouping/function-call paren is NOT, so\n * `(9:00) + 5` still means a clock time, not a range.\n *\n * Needed because the clock-time/laptime/video-timecode rules each match a\n * bare `NUMBER COLON NUMBER...` shape with ZERO context-awareness, a real\n * collision discovered when adding Range support, since e.g. \"0:3\" is\n * valid input to BOTH features. These contexts have no legitimate use for\n * a clock-time/laptime/timecode literal, so the carve-out costs the time\n * features nothing.\n *\n * IMPORTANT cross-pass-timing gotcha (a real bug found and fixed here,\n * not a hypothetical): the `LPAREN`-opener check deliberately tests the\n * RAW word text (`prev.value.toLowerCase()`), not `prev.type ===\n * \"MAP\"/\"REDUCE\"/...`. The normalizer's multi-pass loop hands every rule\n * the SAME frozen `tokens` snapshot for an entire pass, a rule scanning\n * a LATER position in that pass cannot see a fusion `mapReduceCallNormalizerRule`\n * performs at an EARLIER position in that SAME pass (fusion results only\n * become visible to other rules starting the NEXT pass). Checking the\n * fused token type here would miss exactly the case that matters most\n * `map(f, 0:3)` on its very first normalization pass, silently letting\n * `0:3` fuse into a clock time before `map(`'s own fusion ever lands.\n * Testing the raw word is immune to this: it's true from the very first\n * pass, regardless of whether `mapReduceCallNormalizerRule` has run yet.\n * (`LBRACKET` above has no equivalent issue, it's a genuine lexer token\n * from the start, never itself the product of a fusion.)\n */\nexport function isInsideRangeContext(tokens: Token[], pos: number): boolean {\n  const safeStack: boolean[] = [];\n  for (let i = 0; i < pos; i++) {\n    const t = tokens[i];\n    if (t.type === \"LBRACKET\") {\n      safeStack.push(true);\n    } else if (t.type === \"LPAREN\") {\n      const prev = tokens[i - 1];\n      const opensMapReduceCall = !!prev && (\n        prev.type === \"MAP\" || prev.type === \"REDUCE\" || prev.type === \"SUM_FN\" || prev.type === \"PROD_FN\" ||\n        (prev.type === \"IDENT\" && (prev.value.toLowerCase() === \"map\" || prev.value.toLowerCase() === \"reduce\" || prev.value.toLowerCase() === \"sum\" || prev.value.toLowerCase() === \"prod\"))\n      );\n      safeStack.push(opensMapReduceCall);\n    } else if (t.type === \"RBRACKET\" || t.type === \"RPAREN\") {\n      safeStack.pop();\n    }\n  }\n  return safeStack.length > 0 && safeStack[safeStack.length - 1];\n}\n\n//#endregion\n//#region ─── createBuiltinNormalizerRules, All Built-in Rules ─────────────────\n\n/**\n * Creates built-in non-phrase normalization rules.\n *\n * Returns implicit multiply insertion (priority 50).\n *\n * **Prefer** calling {@link implicitMultiplyRule} directly with a\n * `canStart` predicate wired to the normalizer's phrase trie:\n * ```ts\n * normalizer.register(implicitMultiplyRule(50, (w) => normalizer.canStartPhrase(w)));\n * ```\n * Without the predicate, this function falls back to a hardcoded\n * {@link PHRASE_START_WORDS} set that won't reflect package-registered phrases.\n *\n * @returns An array of {@link NormalizerRule} instances ready for registration\n */\nexport function createBuiltinNormalizerRules(): NormalizerRule[] {\n  return [\n    // ── Implicit operator insertion (priority 50) ──\n    implicitMultiplyRule(),\n  ];\n}\n\n/**\n * Built-in phrase → tokenType mappings.\n *\n * These are registered into the engine's {@link PhraseTrie} during\n * construction. Tests that create a standalone {@link TokenNormalizer}\n * should register these via {@link TokenNormalizer.addPhrase}.\n */\nexport const BUILTIN_PHRASES: Record<string, string> = {\n\t\"to the power of\": \"CARET\",\n\t\"power of\": \"CARET\",\n\t\"increase by\": \"INCREASE_BY\",\n\t\"decrease by\": \"DECREASE_BY\",\n\t\"times by\": \"TIMES_BY\",\n\t\"multiply by\": \"MULTIPLY_BY\",\n\t\"divide by\": \"DIVIDE_BY\",\n\t// The past-tense spellings, which is how the operation is usually written\n\t// out: \"3 multiplied by 4\". Same tokens, so no new parselets. Both this\n\t// branch and the parity branch added \"multiplied by\" independently; the\n\t// merge kept both copies and the locale table rejected the duplicate key.\n\t\"multiplied by\": \"MULTIPLY_BY\",\n\t\"divided by\": \"DIVIDE_BY\",\n};\n\n//#endregion\n"]}

package/dist/{chunk-3YNVWKR2.cjs → chunk-OUHT5Z36.cjs}

@@ -9,13 +9,16 @@ var enLocale = {
     e: "E",
     plus: "PLUS",
     add: "PLUS",
-    and: "PLUS",
+    and: "AND_CONJ",
+    with: "PLUS",
     minus: "MINUS",
     subtract: "MINUS",
     remove: "MINUS",
     take: "MINUS",
+    without: "MINUS",
     times: "STAR",
     multiply: "STAR",
+    mul: "STAR",
     divide: "SLASH",
     modulo: "MOD",
     mod: "MOD",
@@ -67,6 +70,12 @@ var enLocale = {
     fround: "FUNC",
     hypot: "FUNC",
     imul: "FUNC",
+    sind: "FUNC",
+    cosd: "FUNC",
+    tand: "FUNC",
+    asind: "FUNC",
+    acosd: "FUNC",
+    atand: "FUNC",
     log10: "FUNC",
     log1p: "FUNC",
     log2: "FUNC",
@@ -121,10 +130,15 @@ var enLocale = {
     // sum(/total(/average( fusion), so `:map = [...]`/`:sum = 100`/etc.
     // keep working as ordinary variable names.
     clamp: "CLAMP",
+    // `into` is a third spelling of the conversion operator, alongside `to` and
+    // `in`. It reads better before a unit than either ("300 cm into m"), and
+    // costs nothing: it is not a plausible variable name and has no other
+    // meaning in the grammar.
     convert: "CONVERT",
     to: "TO",
     best: "BEST",
     in: "IN",
+    into: "IN",
     next: "NEXT",
     last: "LAST",
     until: "UNTIL",
@@ -145,6 +159,15 @@ var enLocale = {
     // see Token.ts's OVER/RATE_AT doc comment.
     over: "OVER",
     at: "RATE_AT",
+    // Only "rounded". Bare "round" is already the round(x) function above.
+    rounded: "ROUNDED",
+    is: "IS",
+    // The investment grammar (packages/finance/). See Token.ts.
+    after: "AFTER",
+    for: "FOR_DURATION",
+    compounding: "COMPOUNDING",
+    invested: "INVESTED",
+    returned: "RETURNED",
     by: "BY",
     vec2: "VEC2",
     vec3: "VEC3",
@@ -192,7 +215,7 @@ var deLocale = {
     e: "E",
     plus: "PLUS",
     add: "PLUS",
-    und: "PLUS",
+    und: "AND_CONJ",
     minus: "MINUS",
     subtract: "MINUS",
     entfernen: "MINUS",
@@ -288,7 +311,7 @@ var frLocale = {
     e: "E",
     plus: "PLUS",
     ajouter: "PLUS",
-    et: "PLUS",
+    et: "AND_CONJ",
     moins: "MINUS",
     soustraire: "MINUS",
     enlever: "MINUS",
@@ -366,5 +389,5 @@ function getLocale(code) {
 }
 
 exports.getLocale = getLocale;
-//# sourceMappingURL=chunk-3YNVWKR2.cjs.map
-//# sourceMappingURL=chunk-3YNVWKR2.cjs.map
+//# sourceMappingURL=chunk-OUHT5Z36.cjs.map
+//# sourceMappingURL=chunk-OUHT5Z36.cjs.map

package/dist/chunk-OUHT5Z36.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/constants/locales/en.ts","../src/constants/locales/de.ts","../src/constants/locales/fr.ts","../src/constants/locales/index.ts"],"names":[],"mappings":";;;AAgBO,IAAM,QAAA,GAAoB;AAAA,EAC/B,IAAA,EAAM,IAAA;AAAA,EACN,KAAA,EAAO,SAAA;AAAA,EACP,UAAA,EAAY;AAAA,IACV,EAAA,EAAI,IAAA;AAAA,IAAM,CAAA,EAAG,GAAA;AAAA,IACb,IAAA,EAAM,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA,IAAQ,GAAA,EAAK,UAAA;AAAA,IAAY,IAAA,EAAM,MAAA;AAAA,IAClD,KAAA,EAAO,OAAA;AAAA,IAAS,QAAA,EAAU,OAAA;AAAA,IAAS,MAAA,EAAQ,OAAA;AAAA,IAAS,IAAA,EAAM,OAAA;AAAA,IAC1D,OAAA,EAAS,OAAA;AAAA,IACT,KAAA,EAAO,MAAA;AAAA,IAAQ,QAAA,EAAU,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA,IACtC,MAAA,EAAQ,OAAA;AAAA,IACR,MAAA,EAAQ,KAAA;AAAA,IAAO,GAAA,EAAK,KAAA;AAAA,IACpB,QAAA,EAAU,OAAA;AAAA,IAAS,KAAA,EAAO,OAAA;AAAA,IAC1B,GAAA,EAAK,SAAA;AAAA,IACL,EAAA,EAAI,IAAA;AAAA,IACJ,GAAA,EAAK,KAAA;AAAA,IAAO,KAAA,EAAO,OAAA;AAAA,IAAS,QAAA,EAAU,UAAA;AAAA,IAAY,SAAA,EAAW,WAAA;AAAA,IAC7D,IAAA,EAAM,MAAA;AAAA,IACN,IAAA,EAAM,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA,IAC1D,GAAA,EAAK,MAAA;AAAA,IAAQ,IAAA,EAAM,MAAA;AAAA,IAAQ,KAAA,EAAO,MAAA;AAAA,IAAQ,KAAA,EAAO,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA,IAC3E,IAAA,EAAM,MAAA;AAAA,IAAQ,IAAA,EAAM,MAAA;AAAA,IAAQ,IAAA,EAAM,MAAA;AAAA,IAAQ,KAAA,EAAO,MAAA;AAAA;AAAA;AAAA,IAGjD,MAAA,EAAQ,MAAA;AAAA,IAAQ,MAAA,EAAQ,MAAA;AAAA,IAAQ,MAAA,EAAQ,MAAA;AAAA,IACxC,IAAA,EAAM,MAAA;AAAA,IAAQ,IAAA,EAAM,MAAA;AAAA,IAAQ,IAAA,EAAM,MAAA;AAAA,IAClC,KAAA,EAAO,MAAA;AAAA,IAAQ,KAAA,EAAO,MAAA;AAAA,IAAQ,KAAA,EAAO,MAAA;AAAA,IACrC,IAAA,EAAM,MAAA;AAAA,IAAQ,KAAA,EAAO,MAAA;AAAA,IAAQ,KAAA,EAAO,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA;AAAA;AAAA;AAAA,IAIjD,IAAA,EAAM,MAAA;AAAA,IAAQ,IAAA,EAAM,MAAA;AAAA,IAAQ,SAAA,EAAW,MAAA;AAAA,IACvC,MAAA,EAAQ,MAAA;AAAA,IAAQ,KAAA,EAAO,MAAA;AAAA,IAAQ,IAAA,EAAM,MAAA;AAAA,IACrC,IAAA,EAAM,MAAA;AAAA,IAAQ,IAAA,EAAM,MAAA;AAAA,IAAQ,IAAA,EAAM,MAAA;AAAA,IAClC,KAAA,EAAO,MAAA;AAAA,IAAQ,KAAA,EAAO,MAAA;AAAA,IAAQ,KAAA,EAAO,MAAA;AAAA,IACrC,KAAA,EAAO,MAAA;AAAA,IAAQ,KAAA,EAAO,MAAA;AAAA,IAAQ,IAAA,EAAM,MAAA;AAAA,IACpC,GAAA,EAAK,MAAA;AAAA,IAAQ,MAAA,EAAQ,MAAA;AAAA,IAAQ,IAAA,EAAM,MAAA;AAAA,IAAQ,KAAA,EAAO,MAAA;AAAA,IAClD,QAAA,EAAU,MAAA;AAAA,IAAQ,QAAA,EAAU,MAAA;AAAA,IAC5B,GAAA,EAAK,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA,IAAQ,WAAA,EAAa,MAAA;AAAA,IAAQ,WAAA,EAAa,MAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQ5D,GAAA,EAAK,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAO/B,gBAAA,EAAkB,MAAA;AAAA,IAAQ,cAAA,EAAgB,MAAA;AAAA,IAC1C,oBAAA,EAAsB,MAAA;AAAA,IAAQ,qBAAA,EAAuB,MAAA;AAAA,IACrD,aAAA,EAAe,MAAA;AAAA,IAAQ,YAAA,EAAc,MAAA;AAAA,IAAQ,cAAA,EAAgB,MAAA;AAAA,IAC7D,MAAA,EAAQ,MAAA;AAAA,IAAQ,SAAA,EAAW,MAAA;AAAA;AAAA,IAE3B,eAAA,EAAiB,MAAA;AAAA;AAAA;AAAA;AAAA,IAIjB,SAAA,EAAW,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOlD,KAAA,EAAO,OAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAKP,OAAA,EAAS,SAAA;AAAA,IAAW,EAAA,EAAI,IAAA;AAAA,IAAM,IAAA,EAAM,MAAA;AAAA,IAAQ,EAAA,EAAI,IAAA;AAAA,IAAM,IAAA,EAAM,IAAA;AAAA,IAC5D,IAAA,EAAM,MAAA;AAAA,IAAQ,IAAA,EAAM,MAAA;AAAA,IAAQ,KAAA,EAAO,OAAA;AAAA,IAAS,KAAA,EAAO,OAAA;AAAA,IACnD,MAAA,EAAQ,QAAA;AAAA,IAAU,MAAA,EAAQ,QAAA;AAAA,IAAU,OAAA,EAAS,SAAA;AAAA,IAAW,SAAA,EAAW,WAAA;AAAA,IACnE,QAAA,EAAU,UAAA;AAAA,IAAY,MAAA,EAAQ,QAAA;AAAA,IAAU,QAAA,EAAU,UAAA;AAAA,IAClD,OAAA,EAAS,SAAA;AAAA,IAAW,IAAA,EAAM,MAAA;AAAA,IAC1B,QAAA,EAAU,UAAA;AAAA,IAAY,QAAA,EAAU,UAAA;AAAA;AAAA;AAAA;AAAA,IAIhC,IAAA,EAAM,MAAA;AAAA,IAAQ,EAAA,EAAI,SAAA;AAAA;AAAA,IAElB,OAAA,EAAS,SAAA;AAAA,IACT,EAAA,EAAI,IAAA;AAAA;AAAA,IAEJ,KAAA,EAAO,OAAA;AAAA,IAAS,GAAA,EAAK,cAAA;AAAA,IAAgB,WAAA,EAAa,aAAA;AAAA,IAClD,QAAA,EAAU,UAAA;AAAA,IAAY,QAAA,EAAU,UAAA;AAAA,IAChC,EAAA,EAAI,IAAA;AAAA,IACJ,IAAA,EAAM,MAAA;AAAA,IAAQ,IAAA,EAAM,MAAA;AAAA,IAAQ,IAAA,EAAM,MAAA;AAAA,IACjC,KAAA,EAAO,OAAA;AAAA,IACR,MAAA,EAAQ,QAAA;AAAA,IACR,EAAA,EAAI,IAAA;AAAA,IACJ,IAAA,EAAM,MAAA;AAAA,IAAQ,KAAA,EAAO,OAAA;AAAA,IACrB,EAAA,EAAI,IAAA;AAAA,IAAM,IAAA,EAAM,MAAA;AAAA,IAAQ,IAAA,EAAM,MAAA;AAAA,IAC9B,EAAA,EAAI,IAAA;AAAA,IACJ,OAAA,EAAS,gBAAA;AAAA,IAAkB,UAAA,EAAY,gBAAA;AAAA,IACvC,OAAA,EAAS,gBAAA;AAAA,IAAkB,GAAA,EAAK,gBAAA;AAAA,IAAkB,MAAA,EAAQ,gBAAA;AAAA,IAC1D,QAAA,EAAU,gBAAA;AAAA,IACV,UAAA,EAAY,gBAAA;AAAA,IACZ,GAAA,EAAK,gBAAA;AAAA,IAAkB,UAAA,EAAY,gBAAA;AAAA;AAAA;AAAA,IAGnC,MAAA,EAAQ,gBAAA;AAAA,IACR,KAAA,EAAO,gBAAA;AAAA,IAAkB,GAAA,EAAK;AAAA,GAChC;AAAA,EACA,OAAA,EAAS;AAAA,IACP,YAAA,EAAc,IAAA;AAAA,IACd,UAAA,EAAY,SAAA;AAAA,IACZ,gBAAA,EAAkB,GAAA;AAAA,IAClB,kBAAA,EAAoB,GAAA;AAAA,IACpB,YAAA,EAAc,YAAA;AAAA,IACd,gBAAA,EAAkB;AAAA;AAEtB,CAAA;;;AC9HO,IAAM,QAAA,GAAoB;AAAA,EAC/B,IAAA,EAAM,IAAA;AAAA,EACN,KAAA,EAAO,SAAA;AAAA,EACP,UAAA,EAAY;AAAA,IACV,EAAA,EAAI,IAAA;AAAA,IAAM,CAAA,EAAG,GAAA;AAAA,IACb,IAAA,EAAM,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA,IAAQ,GAAA,EAAK,UAAA;AAAA,IAChC,KAAA,EAAO,OAAA;AAAA,IAAS,QAAA,EAAU,OAAA;AAAA,IAAS,SAAA,EAAW,OAAA;AAAA,IAAS,MAAA,EAAQ,OAAA;AAAA,IAC/D,GAAA,EAAK,MAAA;AAAA,IAAQ,cAAA,EAAgB,MAAA;AAAA,IAC7B,MAAA,EAAQ,OAAA;AAAA,IACR,MAAA,EAAQ,KAAA;AAAA,IAAO,GAAA,EAAK,KAAA;AAAA,IACpB,QAAA,EAAU,OAAA;AAAA,IAAS,MAAA,EAAQ,OAAA;AAAA,IAC3B,GAAA,EAAK,IAAA;AAAA,IACL,KAAA,EAAO,KAAA;AAAA,IAAO,KAAA,EAAO,OAAA;AAAA,IAAS,MAAA,EAAQ,UAAA;AAAA,IAAY,OAAA,EAAS,WAAA;AAAA,IAC3D,MAAA,EAAQ,MAAA;AAAA,IACR,MAAA,EAAQ,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA,IAC5D,GAAA,EAAK,MAAA;AAAA,IAAQ,SAAA,EAAW,MAAA;AAAA,IAAQ,QAAA,EAAU,MAAA;AAAA,IAAQ,MAAA,EAAQ,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA,IACpF,IAAA,EAAM,MAAA;AAAA,IAAQ,IAAA,EAAM,MAAA;AAAA,IAAQ,IAAA,EAAM,MAAA;AAAA,IAAQ,KAAA,EAAO,MAAA;AAAA,IACjD,IAAA,EAAM,MAAA;AAAA,IAAQ,IAAA,EAAM,MAAA;AAAA,IAAQ,IAAA,EAAM,MAAA;AAAA,IAClC,KAAA,EAAO,MAAA;AAAA,IAAQ,KAAA,EAAO,MAAA;AAAA,IAAQ,KAAA,EAAO,MAAA;AAAA,IACrC,WAAA,EAAa,MAAA;AAAA,IAAQ,KAAA,EAAO,MAAA;AAAA,IAAQ,KAAA,EAAO,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA,IACxD,MAAA,EAAQ,MAAA;AAAA,IAAQ,KAAA,EAAO,MAAA;AAAA,IAAQ,IAAA,EAAM,MAAA;AAAA,IACrC,KAAA,EAAO,MAAA;AAAA,IAAQ,KAAA,EAAO,MAAA;AAAA,IAAQ,IAAA,EAAM,MAAA;AAAA,IACpC,GAAA,EAAK,MAAA;AAAA,IAAQ,MAAA,EAAQ,MAAA;AAAA,IAAQ,OAAA,EAAS,MAAA;AAAA,IAAQ,QAAA,EAAU,MAAA;AAAA,IACxD,QAAA,EAAU,MAAA;AAAA,IAAQ,QAAA,EAAU,MAAA;AAAA,IAC5B,YAAA,EAAc,SAAA;AAAA,IAAW,EAAA,EAAI,IAAA;AAAA,IAAM,QAAA,EAAU,MAAA;AAAA,IAC7C,QAAA,EAAU,MAAA;AAAA,IAAQ,MAAA,EAAQ,MAAA;AAAA,IAAQ,GAAA,EAAK,OAAA;AAAA,IAAS,IAAA,EAAM,OAAA;AAAA,IACtD,OAAA,EAAS,QAAA;AAAA,IAAU,MAAA,EAAQ,QAAA;AAAA,IAAU,QAAA,EAAU,SAAA;AAAA,IAAW,QAAA,EAAU,WAAA;AAAA,IACpE,UAAA,EAAY,UAAA;AAAA,IAAY,OAAA,EAAS,QAAA;AAAA,IAAU,OAAA,EAAS,UAAA;AAAA,IACpD,QAAA,EAAU,SAAA;AAAA,IACV,MAAA,EAAQ,MAAA;AAAA,IACR,QAAA,EAAU,UAAA;AAAA,IAAY,UAAA,EAAY,UAAA;AAAA,IAClC,IAAA,EAAM,MAAA;AAAA,IAAQ,IAAA,EAAM,MAAA;AAAA,IAAQ,IAAA,EAAM;AAAA,GACpC;AAAA,EACA,OAAA,EAAS;AAAA,IACP,YAAA,EAAc,IAAA;AAAA,IACd,UAAA,EAAY,SAAA;AAAA,IACZ,gBAAA,EAAkB,GAAA;AAAA,IAClB,kBAAA,EAAoB,GAAA;AAAA,IACpB,YAAA,EAAc,YAAA;AAAA,IACd,gBAAA,EAAkB;AAAA;AAEtB,CAAA;;;AC1BO,IAAM,QAAA,GAAoB;AAAA,EAC/B,IAAA,EAAM,IAAA;AAAA,EACN,KAAA,EAAO,aAAA;AAAA,EACP,UAAA,EAAY;AAAA,IACV,EAAA,EAAI,IAAA;AAAA,IAAM,CAAA,EAAG,GAAA;AAAA,IACb,IAAA,EAAM,MAAA;AAAA,IAAQ,OAAA,EAAS,MAAA;AAAA,IAAQ,EAAA,EAAI,UAAA;AAAA,IACnC,KAAA,EAAO,OAAA;AAAA,IAAS,UAAA,EAAY,OAAA;AAAA,IAAS,OAAA,EAAS,OAAA;AAAA,IAC9C,IAAA,EAAM,MAAA;AAAA,IAAQ,UAAA,EAAY,MAAA;AAAA,IAC1B,OAAA,EAAS,OAAA;AAAA,IACT,MAAA,EAAQ,KAAA;AAAA,IAAO,GAAA,EAAK,KAAA;AAAA,IACpB,QAAA,EAAU,OAAA;AAAA,IAAS,SAAA,EAAW,OAAA;AAAA,IAC9B,GAAA,EAAK,SAAA;AAAA,IACL,UAAA,EAAY,KAAA;AAAA;AAAA;AAAA,IAGZ,UAAA,EAAY,OAAA;AAAA,IACZ,MAAA,EAAQ,UAAA;AAAA,IAAY,IAAA,EAAM,WAAA;AAAA,IAC1B,MAAA,EAAQ,MAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAUR,GAAA,EAAK,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA,IAC5C,GAAA,EAAK,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA,IAAQ,GAAA,EAAK,MAAA;AAAA,IAC/B,SAAA,EAAW,SAAA;AAAA,IACX,QAAA,EAAU,MAAA;AAAA,IAAQ,OAAA,EAAS,MAAA;AAAA,IAC3B,QAAA,EAAU,QAAA;AAAA,IAAU,KAAA,EAAO,QAAA;AAAA,IAAU,KAAA,EAAO,SAAA;AAAA,IAAW,QAAA,EAAU,WAAA;AAAA,IACjE,KAAA,EAAO,UAAA;AAAA,IAAY,QAAA,EAAU,QAAA;AAAA,IAAU,MAAA,EAAQ,UAAA;AAAA,IAC/C,KAAA,EAAO,SAAA;AAAA,IACP,SAAA,EAAW,UAAA;AAAA,IAAY,QAAA,EAAU,UAAA;AAAA,IACjC,IAAA,EAAM,MAAA;AAAA,IAAQ,IAAA,EAAM,MAAA;AAAA,IAAQ,IAAA,EAAM,MAAA;AAAA,IAClC,IAAA,EAAM,MAAA;AAAA,IAAQ,IAAA,EAAM,OAAA;AAAA,IACpB,EAAA,EAAI,IAAA;AAAA,IAAM,KAAA,EAAO,MAAA;AAAA,IAAQ,KAAA,EAAO;AAAA,GAClC;AAAA,EACA,OAAA,EAAS;AAAA,IACP,YAAA,EAAc,IAAA;AAAA,IACd,UAAA,EAAY,SAAA;AAAA,IACZ,gBAAA,EAAkB,GAAA;AAAA,IAClB,kBAAA,EAAoB,GAAA;AAAA,IACpB,YAAA,EAAc,YAAA;AAAA,IACd,gBAAA,EAAkB;AAAA;AAEtB,CAAA;;;AC7DA,IAAM,OAAA,GAAmC;AAAA,EACvC,EAAA,EAAI,QAAA;AAAA,EACJ,EAAA,EAAI,QAAA;AAAA,EACJ,EAAA,EAAI;AACN,CAAA;AAUO,SAAS,UAAU,IAAA,EAAuB;AAC/C,EAAA,OAAO,OAAA,CAAQ,IAAI,CAAA,IAAK,QAAA;AAC1B","file":"chunk-OUHT5Z36.cjs","sourcesContent":["/** What a locale supplies: keywords, units, and number formatting conventions. */\nexport interface ILocale {\n  code: string;\n  label: string;\n  keywordMap: Record<string, string>;\n  display: {\n    resultPrefix: string;\n    dateFormat: string;\n    decimalSeparator: string;\n    thousandsSeparator: string;\n    vectorFormat: string;\n    percentageSuffix: string;\n  };\n}\n\n/** English keywords, units and number formatting. The default and the fallback. */\nexport const enLocale: ILocale = {\n  code: \"en\",\n  label: \"English\",\n  keywordMap: {\n    pi: \"PI\", e: \"E\",\n    plus: \"PLUS\", add: \"PLUS\", and: \"AND_CONJ\", with: \"PLUS\",\n    minus: \"MINUS\", subtract: \"MINUS\", remove: \"MINUS\", take: \"MINUS\",\n    without: \"MINUS\",\n    times: \"STAR\", multiply: \"STAR\", mul: \"STAR\",\n    divide: \"SLASH\",\n    modulo: \"MOD\", mod: \"MOD\",\n    exponent: \"CARET\", prime: \"CARET\",\n    xor: \"BIT_XOR\",\n    of: \"OF\",\n    now: \"NOW\", today: \"TODAY\", tomorrow: \"TOMORROW\", yesterday: \"YESTERDAY\",\n    roll: \"ROLL\",\n    sqrt: \"FUNC\", abs: \"FUNC\", sin: \"FUNC\", cos: \"FUNC\", tan: \"FUNC\",\n    log: \"FUNC\", ceil: \"FUNC\", floor: \"FUNC\", round: \"FUNC\", min: \"FUNC\", max: \"FUNC\",\n    asin: \"FUNC\", acos: \"FUNC\", atan: \"FUNC\", atan2: \"FUNC\",\n    // Long-form aliases for asin/acos/atan (Numi/older-calculator naming\n    // convention). Same FunctionCallParselet indices, not new behavior.\n    arcsin: \"FUNC\", arccos: \"FUNC\", arctan: \"FUNC\",\n    sinh: \"FUNC\", cosh: \"FUNC\", tanh: \"FUNC\",\n    asinh: \"FUNC\", acosh: \"FUNC\", atanh: \"FUNC\",\n    cbrt: \"FUNC\", clz32: \"FUNC\", expm1: \"FUNC\", exp: \"FUNC\",\n    // root(n, x) -- n-th root; fact/factorial(n) -- factorial. Bare FUNC\n    // keywords, matching gcd/lcm/cbrt's precedent above (technical,\n    // call-syntax-only names, not plausible :variableName choices).\n    root: \"FUNC\", fact: \"FUNC\", factorial: \"FUNC\",\n    fround: \"FUNC\", hypot: \"FUNC\", imul: \"FUNC\",\n    sind: \"FUNC\", cosd: \"FUNC\", tand: \"FUNC\",\n    asind: \"FUNC\", acosd: \"FUNC\", atand: \"FUNC\",\n    log10: \"FUNC\", log1p: \"FUNC\", log2: \"FUNC\",\n    pow: \"FUNC\", random: \"FUNC\", sign: \"FUNC\", trunc: \"FUNC\",\n    degtorad: \"FUNC\", radtodeg: \"FUNC\",\n    gcd: \"FUNC\", lcm: \"FUNC\", permutation: \"FUNC\", combination: \"FUNC\",\n    // hex/bin double as CONVERTER_NAME below (\"255 as hex\") AND as FUNC\n    // call-syntax (\"hex(255)\"), a word can only have one lexer token\n    // type, so these win FUNC (removed from the CONVERTER_NAME list\n    // below) and AsConverterParselet.ts's \"as <name>\" check was widened\n    // to also accept a FUNC-typed token, preserving \"as hex\"/\"as bin\"\n    // unchanged. See AsConverterParselet.ts's class doc for the full\n    // reasoning.\n    hex: \"FUNC\", bin: \"FUNC\", int: \"FUNC\",\n    // Finance (packages/finance/) function-call forms. Bare keywords, not\n    // phrase-fused, these are camelCase call-only names (e.g.\n    // \"compoundInterest(...)\"), not natural-language words a user would\n    // plausibly choose as a variable name, so the bare-keyword collision\n    // risk that blocks \"interest\"/\"tax\"/\"principal\" etc. doesn't apply here\n    // (matches \"gcd\"/\"lcm\"/... above, not \"clamp\" below).\n    compoundinterest: \"FUNC\", interestearned: \"FUNC\",\n    compoundinterestrate: \"FUNC\", compoundinterestyears: \"FUNC\",\n    loanrepayment: \"FUNC\", loaninterest: \"FUNC\", monthlypayment: \"FUNC\",\n    taxadd: \"FUNC\", taxremove: \"FUNC\",\n    // Inflation-adjusted value function-call form (packages/finance/).\n    inflationadjust: \"FUNC\",\n    // Matrix (packages/matrix/) function-call forms -- also reachable via\n    // `^T`/`^-1` operator syntax and `|a|` (see FunctionCallParselet.ts's\n    // builtinNameToIndex comment for indices 63-66).\n    transpose: \"FUNC\", det: \"FUNC\", inv: \"FUNC\", dot: \"FUNC\",\n    // map/reduce/sum/prod (packages/mapreduce/) are NOT bare keywordMap\n    // entries. See packages/mapreduce/normalizer/MapReduceCallNormalizerRule.ts\n    // which fuses them ONLY when immediately followed by \"(\" (same\n    // \"conditional-on-LPAREN\" pattern as packages/lines/'s own\n    // sum(/total(/average( fusion), so `:map = [...]`/`:sum = 100`/etc.\n    // keep working as ordinary variable names.\n    clamp: \"CLAMP\",\n    // `into` is a third spelling of the conversion operator, alongside `to` and\n    // `in`. It reads better before a unit than either (\"300 cm into m\"), and\n    // costs nothing: it is not a plausible variable name and has no other\n    // meaning in the grammar.\n    convert: \"CONVERT\", to: \"TO\", best: \"BEST\", in: \"IN\", into: \"IN\",\n    next: \"NEXT\", last: \"LAST\", until: \"UNTIL\", since: \"SINCE\",\n    sunday: \"SUNDAY\", monday: \"MONDAY\", tuesday: \"TUESDAY\", wednesday: \"WEDNESDAY\",\n    thursday: \"THURSDAY\", friday: \"FRIDAY\", saturday: \"SATURDAY\",\n    between: \"BETWEEN\", from: \"FROM\",\n    increase: \"INCREASE\", decrease: \"DECREASE\",\n    // Finance (packages/finance/) phrase-grammar connectors. Bare\n    // prepositions, same accepted-risk category as \"between\"/\"from\" above\n    // see Token.ts's OVER/RATE_AT doc comment.\n    over: \"OVER\", at: \"RATE_AT\",\n    // Only \"rounded\". Bare \"round\" is already the round(x) function above.\n    rounded: \"ROUNDED\",\n    is: \"IS\",\n    // The investment grammar (packages/finance/). See Token.ts.\n    after: \"AFTER\", for: \"FOR_DURATION\", compounding: \"COMPOUNDING\",\n    invested: \"INVESTED\", returned: \"RETURNED\",\n    by: \"BY\",\n    vec2: \"VEC2\", vec3: \"VEC3\", vec4: \"VEC4\",\n     float: \"FLOAT\",\n    global: \"GLOBAL\",\n    or: \"OR\",\n    true: \"TRUE\", false: \"FALSE\",\n    if: \"IF\", then: \"THEN\", else: \"ELSE\",\n    as: \"AS\",\n    percent: \"CONVERTER_NAME\", percentage: \"CONVERTER_NAME\",\n    decimal: \"CONVERTER_NAME\", dec: \"CONVERTER_NAME\", number: \"CONVERTER_NAME\",\n    fraction: \"CONVERTER_NAME\",\n    multiplier: \"CONVERTER_NAME\",\n    sci: \"CONVERTER_NAME\", scientific: \"CONVERTER_NAME\",\n    // hex/bin are FUNC (see above), not CONVERTER_NAME, \"as hex\"/\"as bin\"\n    // still work via AsConverterParselet.ts's widened token-type check.\n    binary: \"CONVERTER_NAME\",\n    octal: \"CONVERTER_NAME\", oct: \"CONVERTER_NAME\",\n  },\n  display: {\n    resultPrefix: \"= \",\n    dateFormat: \"default\",\n    decimalSeparator: \".\",\n    thousandsSeparator: \",\",\n    vectorFormat: \"[{values}]\",\n    percentageSuffix: \"%\",\n  },\n};\n","import { ILocale } from \"./en\";\n\n/** German keywords, units and number formatting. */\nexport const deLocale: ILocale = {\n  code: \"de\",\n  label: \"Deutsch\",\n  keywordMap: {\n    pi: \"PI\", e: \"E\",\n    plus: \"PLUS\", add: \"PLUS\", und: \"AND_CONJ\",\n    minus: \"MINUS\", subtract: \"MINUS\", entfernen: \"MINUS\", nehmen: \"MINUS\",\n    mal: \"STAR\", multiplizieren: \"STAR\",\n    teilen: \"SLASH\",\n    modulo: \"MOD\", mod: \"MOD\",\n    exponent: \"CARET\", potenz: \"CARET\",\n    von: \"OF\",\n    jetzt: \"NOW\", heute: \"TODAY\", morgen: \"TOMORROW\", gestern: \"YESTERDAY\",\n    rollen: \"ROLL\",\n    wurzel: \"FUNC\", abs: \"FUNC\", sin: \"FUNC\", cos: \"FUNC\", tan: \"FUNC\",\n    log: \"FUNC\", aufrunden: \"FUNC\", abrunden: \"FUNC\", runden: \"FUNC\", min: \"FUNC\", max: \"FUNC\",\n    asin: \"FUNC\", acos: \"FUNC\", atan: \"FUNC\", atan2: \"FUNC\",\n    sinh: \"FUNC\", cosh: \"FUNC\", tanh: \"FUNC\",\n    asinh: \"FUNC\", acosh: \"FUNC\", atanh: \"FUNC\",\n    kubikwurzel: \"FUNC\", clz32: \"FUNC\", expm1: \"FUNC\", exp: \"FUNC\",\n    fround: \"FUNC\", hypot: \"FUNC\", imul: \"FUNC\",\n    log10: \"FUNC\", log1p: \"FUNC\", log2: \"FUNC\",\n    pow: \"FUNC\", zufall: \"FUNC\", zeichen: \"FUNC\", ganzzahl: \"FUNC\",\n    degtorad: \"FUNC\", radtodeg: \"FUNC\",\n    konvertieren: \"CONVERT\", in: \"TO\", amBesten: \"BEST\",\n    naechste: \"NEXT\", letzte: \"LAST\", bis: \"UNTIL\", seit: \"SINCE\",\n    sonntag: \"SUNDAY\", montag: \"MONDAY\", dienstag: \"TUESDAY\", mittwoch: \"WEDNESDAY\",\n    donnerstag: \"THURSDAY\", freitag: \"FRIDAY\", samstag: \"SATURDAY\",\n    zwischen: \"BETWEEN\",\n    von_ab: \"FROM\",\n    erhoehen: \"INCREASE\", verringern: \"DECREASE\",\n    vec2: \"VEC2\", vec3: \"VEC3\", vec4: \"VEC4\",\n  },\n  display: {\n    resultPrefix: \"= \",\n    dateFormat: \"default\",\n    decimalSeparator: \",\",\n    thousandsSeparator: \".\",\n    vectorFormat: \"[{values}]\",\n    percentageSuffix: \"%\",\n  },\n};","import { ILocale } from \"./en\";\n\n/**\n * French locale. See GitHub issue #77 (\"Please allow for localized day\n * of the week\"). Matches `de.ts`'s scope, not `en.ts`'s full coverage: a\n * confident, reviewed core set (arithmetic words, date keywords, weekday\n * names, a handful of common functions), not a guess at every FUNC/phrase\n * keyword across every package. Widening this is a good first issue for\n * a native French speaker, PRs welcome, same as this project's existing\n * convention for locale gaps.\n *\n * \"aujourd'hui\" (today) is deliberately spelled without its apostrophe\n * here (`aujourdhui`), `ExpressionLexer`'s identifier reader only\n * accepts `[a-zA-Z_][a-zA-Z0-9_]*` plus Unicode, so the standard spelling\n * can't lex as a single IDENT token at all. This is a real, disclosed\n * limitation, not a translation choice, anyone typing the standard\n * apostrophed spelling won't get a match today.\n */\nexport const frLocale: ILocale = {\n  code: \"fr\",\n  label: \"Français\",\n  keywordMap: {\n    pi: \"PI\", e: \"E\",\n    plus: \"PLUS\", ajouter: \"PLUS\", et: \"AND_CONJ\",\n    moins: \"MINUS\", soustraire: \"MINUS\", enlever: \"MINUS\",\n    fois: \"STAR\", multiplier: \"STAR\",\n    diviser: \"SLASH\",\n    modulo: \"MOD\", mod: \"MOD\",\n    exposant: \"CARET\", puissance: \"CARET\",\n    xor: \"BIT_XOR\",\n    maintenant: \"NOW\",\n    // \"aujourd'hui\". See this file's own doc comment for why the\n    // apostrophe is dropped here.\n    aujourdhui: \"TODAY\",\n    demain: \"TOMORROW\", hier: \"YESTERDAY\",\n    lancer: \"ROLL\",\n    // Same spellings as English on purpose, not a translation gap: the\n    // FUNC token's NAME is looked up in a separate, locale-independent\n    // dispatch table (FunctionCallParselet.ts's builtinNameToIndex) that\n    // only knows English names, \"racine\" (root) would lex fine as a\n    // FUNC token via this keywordMap but then fail at call time with\n    // \"Unknown function\", so it's deliberately left out rather than\n    // shipped half-working. Widening that dispatch table to be\n    // locale-aware is a separate, larger change (it would need the same\n    // fix for German too, \"wurzel\" has this identical problem today).\n    abs: \"FUNC\", sin: \"FUNC\", cos: \"FUNC\", tan: \"FUNC\",\n    log: \"FUNC\", min: \"FUNC\", max: \"FUNC\",\n    convertir: \"CONVERT\",\n    prochain: \"NEXT\", dernier: \"LAST\",\n    dimanche: \"SUNDAY\", lundi: \"MONDAY\", mardi: \"TUESDAY\", mercredi: \"WEDNESDAY\",\n    jeudi: \"THURSDAY\", vendredi: \"FRIDAY\", samedi: \"SATURDAY\",\n    entre: \"BETWEEN\",\n    augmenter: \"INCREASE\", diminuer: \"DECREASE\",\n    vec2: \"VEC2\", vec3: \"VEC3\", vec4: \"VEC4\",\n    vrai: \"TRUE\", faux: \"FALSE\",\n    si: \"IF\", alors: \"THEN\", sinon: \"ELSE\",\n  },\n  display: {\n    resultPrefix: \"= \",\n    dateFormat: \"default\",\n    decimalSeparator: \",\",\n    thousandsSeparator: \" \",\n    vectorFormat: \"[{values}]\",\n    percentageSuffix: \"%\",\n  },\n};\n","import { enLocale, type ILocale } from \"./en\";\nimport { deLocale } from \"./de\";\nimport { frLocale } from \"./fr\";\n\nconst locales: Record<string, ILocale> = {\n  en: enLocale,\n  de: deLocale,\n  fr: frLocale,\n};\n\n/**\n * Look up a locale by code.\n *\n * @param code - Locale code, for example `\"en\"` or `\"de\"`.\n * @returns The locale, or English when the code is unknown. Falling back\n * rather than throwing means an unrecognised code degrades to a working engine\n * instead of a dead one.\n */\nexport function getLocale(code: string): ILocale {\n  return locales[code] || enLocale;\n}\n\n/**\n * Add a locale, or replace one already registered under the same code.\n *\n * @param code - Locale code to register under.\n * @param locale - Keywords, units and formatting for that locale.\n */\nexport function registerLocale(code: string, locale: ILocale): void {\n  locales[code] = locale;\n}\n\nexport { enLocale, deLocale, frLocale, type ILocale };"]}

package/dist/{chunk-EIGTWK5N.js → chunk-OWRHDUJD.js}

@@ -1,7 +1,7 @@
 import { ErrorFactory } from './chunk-6RDSQURE.js';
 
 // package.json
-var version = "1.0.0-beta.2";
+var version = "1.0.0-beta.4";
 
 // src/constants/version.ts
 var ENGINE_VERSION = version;
@@ -163,5 +163,5 @@ var ConfigManager = class {
 };
 
 export { ConfigManager, DEFAULT_CONFIG, ENGINE_VERSION, mergeEngineConfig };
-//# sourceMappingURL=chunk-EIGTWK5N.js.map
-//# sourceMappingURL=chunk-EIGTWK5N.js.map
+//# sourceMappingURL=chunk-OWRHDUJD.js.map
+//# sourceMappingURL=chunk-OWRHDUJD.js.map

package/dist/chunk-OWRHDUJD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../package.json","../src/constants/version.ts","../src/constants/Configuration.ts"],"names":[],"mappings":"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","file":"chunk-OWRHDUJD.js","sourcesContent":["{\n  \"name\": \"solve-engine\",\n  \"version\": \"1.0.0-beta.4\",\n  \"description\": \"The expression evaluation engine behind Solve — lexer, parser, bytecode VM, and an extensible package system.\",\n  \"keywords\": [\n    \"expression-evaluator\",\n    \"calculator\",\n    \"bytecode-vm\",\n    \"parser\",\n    \"lexer\",\n    \"dsl\",\n    \"markdown\",\n    \"obsidian\"\n  ],\n  \"license\": \"MIT\",\n  \"author\": \"Liam Riddell\",\n  \"homepage\": \"https://liamriddell.github.io/solve-engine/\",\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"git+https://github.com/LiamRiddell/solve-engine.git\",\n    \"directory\": \"packages/engine\"\n  },\n  \"bugs\": {\n    \"url\": \"https://github.com/LiamRiddell/solve-engine/issues\"\n  },\n  \"publishConfig\": {\n    \"access\": \"public\"\n  },\n  \"type\": \"module\",\n  \"engines\": {\n    \"node\": \">=22\"\n  },\n  \"files\": [\n    \"dist\",\n    \"LICENSE\"\n  ],\n  \"main\": \"./dist/index.cjs\",\n  \"module\": \"./dist/index.js\",\n  \"types\": \"./dist/index.d.ts\",\n  \"exports\": {\n    \".\": {\n      \"import\": {\n        \"types\": \"./dist/index.d.ts\",\n        \"default\": \"./dist/index.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/index.d.cts\",\n        \"default\": \"./dist/index.cjs\"\n      }\n    },\n    \"./engine\": {\n      \"import\": {\n        \"types\": \"./dist/engine.d.ts\",\n        \"default\": \"./dist/engine.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/engine.d.cts\",\n        \"default\": \"./dist/engine.cjs\"\n      }\n    },\n    \"./vm\": {\n      \"import\": {\n        \"types\": \"./dist/vm.d.ts\",\n        \"default\": \"./dist/vm.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/vm.d.cts\",\n        \"default\": \"./dist/vm.cjs\"\n      }\n    },\n    \"./format\": {\n      \"import\": {\n        \"types\": \"./dist/format.d.ts\",\n        \"default\": \"./dist/format.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/format.d.cts\",\n        \"default\": \"./dist/format.cjs\"\n      }\n    },\n    \"./language\": {\n      \"import\": {\n        \"types\": \"./dist/language.d.ts\",\n        \"default\": \"./dist/language.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/language.d.cts\",\n        \"default\": \"./dist/language.cjs\"\n      }\n    },\n    \"./packages\": {\n      \"import\": {\n        \"types\": \"./dist/packages.d.ts\",\n        \"default\": \"./dist/packages.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/packages.d.cts\",\n        \"default\": \"./dist/packages.cjs\"\n      }\n    },\n    \"./constants\": {\n      \"import\": {\n        \"types\": \"./dist/constants.d.ts\",\n        \"default\": \"./dist/constants.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/constants.d.cts\",\n        \"default\": \"./dist/constants.cjs\"\n      }\n    },\n    \"./lexer\": {\n      \"import\": {\n        \"types\": \"./dist/lexer.d.ts\",\n        \"default\": \"./dist/lexer.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/lexer.d.cts\",\n        \"default\": \"./dist/lexer.cjs\"\n      }\n    },\n    \"./parser\": {\n      \"import\": {\n        \"types\": \"./dist/parser.d.ts\",\n        \"default\": \"./dist/parser.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/parser.d.cts\",\n        \"default\": \"./dist/parser.cjs\"\n      }\n    },\n    \"./normalizer\": {\n      \"import\": {\n        \"types\": \"./dist/normalizer.d.ts\",\n        \"default\": \"./dist/normalizer.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/normalizer.d.cts\",\n        \"default\": \"./dist/normalizer.cjs\"\n      }\n    },\n    \"./variables\": {\n      \"import\": {\n        \"types\": \"./dist/variables.d.ts\",\n        \"default\": \"./dist/variables.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/variables.d.cts\",\n        \"default\": \"./dist/variables.cjs\"\n      }\n    },\n    \"./resolvers\": {\n      \"import\": {\n        \"types\": \"./dist/resolvers.d.ts\",\n        \"default\": \"./dist/resolvers.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/resolvers.d.cts\",\n        \"default\": \"./dist/resolvers.cjs\"\n      }\n    },\n    \"./errors\": {\n      \"import\": {\n        \"types\": \"./dist/errors.d.ts\",\n        \"default\": \"./dist/errors.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/errors.d.cts\",\n        \"default\": \"./dist/errors.cjs\"\n      }\n    },\n    \"./utilities\": {\n      \"import\": {\n        \"types\": \"./dist/utilities.d.ts\",\n        \"default\": \"./dist/utilities.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/utilities.d.cts\",\n        \"default\": \"./dist/utilities.cjs\"\n      }\n    },\n    \"./uom\": {\n      \"import\": {\n        \"types\": \"./dist/uom.d.ts\",\n        \"default\": \"./dist/uom.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/uom.d.cts\",\n        \"default\": \"./dist/uom.cjs\"\n      }\n    },\n    \"./services\": {\n      \"import\": {\n        \"types\": \"./dist/services.d.ts\",\n        \"default\": \"./dist/services.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/services.d.cts\",\n        \"default\": \"./dist/services.cjs\"\n      }\n    }\n  },\n  \"scripts\": {\n    \"build\": \"tsup\",\n    \"prepublishOnly\": \"npm run build && node ../../scripts/assert-publishable.mjs .\",\n    \"dev\": \"tsup --watch\",\n    \"test\": \"jest --config jest.config.cjs --no-coverage\",\n    \"typecheck\": \"tsgo --noEmit --skipLibCheck\",\n    \"typecheck:tsc\": \"tsc --noEmit --skipLibCheck\"\n  },\n  \"dependencies\": {\n    \"@tanstack/query-core\": \"^5.100.10\"\n  },\n  \"devDependencies\": {\n    \"@jest/globals\": \"^30.4.1\",\n    \"@types/node\": \"^26.1.2\",\n    \"@types/semver\": \"^7.5.0\",\n    \"convert\": \"^7.0.0\",\n    \"jest\": \"^30.4.2\",\n    \"semver\": \"^7.6.0\",\n    \"ts-jest\": \"^29.4.12\",\n    \"tsup\": \"8.5.1\",\n    \"typescript\": \"5.9.3\"\n  },\n  \"//sideEffects\": \"Load-bearing claim, not boilerplate. tsup's splitting emits bare chunk imports at the top of dist/index.js, and this field tells Rollup, webpack and Vite they may delete them, which esbuild reports as [ignored-bare-import] once per import during `npm run size`. The engine does have module-level work to lose: registerAllTokenTypes(), _PrecedenceParser.BP_TABLE and its cached token ids, and several process-wide registries. It is safe because every chunk doing that work is also imported for its bindings somewhere, so no bundler can drop it. That is a property of how tsup currently splits the code rather than a design guarantee, so `npm run smoke:bundled` (scripts/check-tree-shaking.mjs) proves it on every run of `npm run verify` instead of assuming it, and its header explains the two fixes if it ever stops holding.\",\n  \"sideEffects\": false\n}\n","/**\n * The running engine's own semver version, sourced directly from this\n * package's package.json so it can never drift from what's actually\n * published. Exists so IEnginePackage.engineVersion range checks\n * (api/EngineVersionCompatibility.ts) have something real to check\n * against.\n */\nimport { version } from \"../../package.json\";\n\n/**\n * The running engine's version, taken from package.json.\n *\n * What a package's `engineVersion` range is checked against at registration.\n * A prerelease is compared by its coerced release version, so a 1.0.0 beta\n * satisfies `^1.0.0`. See `api/EngineVersionCompatibility.ts`.\n */\nexport const ENGINE_VERSION: string = version;\n","/**\n * Configuration Module for solve-js Engine\n * \n * This module provides the **single source of truth** for all engine configuration.\n * Every configurable aspect of the engine, from safety limits and performance\n * budgets to VM constraints and worker pool sizing, is defined here.\n * \n * ### Design principles\n * \n * 1. **Engine owns its config.** The engine defines its own config shape and defaults.\n *    Consumers (e.g., the Obsidian plugin) pass partial overrides; all unspecified\n *    fields fall back to `DEFAULT_CONFIG`.\n * \n * 2. **Self-documenting.** Every interface and field has descriptive JSDoc so the\n *    config is understandable at a glance, whether you're using the engine as an\n *    npm package or reading the source.\n * \n * 3. **Minimal consumer knowledge.** Consumers only need to pass `Partial<EngineConfig>`.\n *    They don't need to replicate the full config shape, just the fields they\n *    want to override.\n * \n * @module Configuration\n */\n\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\n\n/**\n * Date-related configuration.\n * Controls the bounds and formatting for date/time expression evaluation\n * (e.g., `today + 20 days`, `last monday`).\n */\nexport interface DateConfig {\n  /** Default offset in days for relative date calculations when no offset is specified */\n  readonly defaultOffsetDays: number;\n  /** Maximum allowed positive offset in years (safety limit) */\n  readonly maxOffsetYears: number;\n  /** Maximum allowed negative offset in years (safety limit) */\n  readonly minOffsetYears: number;\n  /** Default date string format for display (moment.js format string) */\n  readonly defaultFormat: string;\n}\n\n/**\n * Dice-related configuration.\n * Controls dice expression evaluation (e.g., `roll(1, 100)`, `3d6`).\n */\nexport interface DiceConfig {\n  /** Default number of sides on a die when not specified */\n  readonly defaultSides: number;\n  /** Maximum allowed sides per die (prevents excessive allocation) */\n  readonly maxSides: number;\n  /** Maximum number of dice in a single roll expression */\n  readonly maxDice: number;\n  /** Default number of dice when not specified */\n  readonly defaultDice: number;\n}\n\n/**\n * Performance-related configuration.\n * Controls caching, timeouts, and processing limits to prevent runaway\n * resource consumption on large documents.\n */\nexport interface PerformanceConfig {\n  /**\n   * Maximum number of entries in {@link ExpressionEngine}'s bytecode cache\n   * (per-instance, keyed by expression text) before the oldest entry is\n   * evicted. Raise this for documents with many distinct expressions if\n   * repeated re-evaluation (e.g. scrolling) is re-parsing instead of\n   * hitting cache, bug fix (release hardening pass): this field used to\n   * be read nowhere; the cache size was a hardcoded, unconfigurable\n   * constant. Note this does NOT bound {@link LineCache}, which has no\n   * size limit of its own.\n   */\n  readonly defaultCacheSize: number;\n  /** Maximum number of document lines processed in a single pass */\n  readonly maxDocumentLines: number;\n  /** Maximum time (ms) allowed for parsing a single expression before timeout */\n  readonly parseTimeoutMs: number;\n  /** Maximum time (ms) allowed for executing a single expression before timeout */\n  readonly executionTimeoutMs: number;\n}\n\n/**\n * Validation / safety-limit configuration.\n * Protects against runaway expressions that could cause excessive memory use\n * or stack overflow. These limits are checked during lexing and parsing.\n */\n/** Bounds on untrusted input: expression length and nesting depth. */\nexport interface ValidationConfig {\n  /** Maximum expression length in characters. Prevents excessively long strings from entering the pipeline. */\n  readonly maxExpressionLength: number;\n  /** Maximum expression complexity score (`tokens + functionCalls×5 + nestingDepth×10`). Protects against deeply nested or combinatorially complex expressions. */\n  readonly maxComplexity: number;\n  /** Maximum parentheses nesting depth. Prevents stack overflow in the recursive-descent parser. */\n  readonly maxNestingDepth: number;\n  /**\n   * Auto-balance unmatched parentheses by appending missing closing parens\n   * or prepending missing opening parens. When disabled, unbalanced expressions\n   * cause parse errors instead of being silently corrected.\n   *\n   * Disabled by default for strict parsing. Enable for forgiving user input\n   * (e.g., chat-style calculators where users often omit closing parens).\n   * Has zero overhead when disabled, the O(n) paren-count scan is skipped.\n   */\n  readonly autoBalanceParens: boolean;\n}\n\n/**\n * Worker pool configuration.\n * Controls the parallel execution workers used for batch evaluation.\n */\nexport interface WorkerConfig {\n  /** Maximum number of concurrent Web Workers allowed */\n  readonly maxConcurrentWorkers: number;\n  /** Time (ms) a worker stays alive while idle before being terminated */\n  readonly idleTimeoutMs: number;\n  /** Maximum retry attempts for a failed worker operation */\n  readonly maxRetries: number;\n  /** Base backoff delay (ms) between retries (exponential backoff applied on top) */\n  readonly baseBackoffMs: number;\n}  /**\n   * Diagnostic / telemetry configuration.\n   * Controls the diagnostic event pipeline for profiling and debugging.\n   * All diagnostics are disabled by default for maximum production performance.\n   */\n  export interface DiagnosticConfig {\n    /** Master switch: enable the diagnostic pipeline (collectors receive events for all pipeline stages) */\n    readonly enabled: boolean;\n    /** Enable VM trace mode, emits per-opcode execution events (very verbose; disables some optimizations) */\n    readonly vmTraceEnabled: boolean;\n  }\n\n  /**\n   * Virtual Machine configuration.\n   * Controls the internal bytecode VM that executes compiled expressions.\n   */\n  export interface VMConfig {\n    /** Maximum stack depth (value slots) for VM execution, prevents stack overflow in recursive/pratt-parser generated bytecode */\n    readonly maxStackDepth: number;\n    /** Maximum opcodes executed per expression, halts runaway infinite loops */\n    readonly maxInstructions: number;\n  }\n\n/**\n * Complete engine configuration.\n *\n * Every field has a default in `DEFAULT_CONFIG`. To customize, pass a\n * `Partial<EngineConfig>` when constructing `ExpressionEngine`. Only the\n * sections/fields you supply are overridden; all others use their defaults.\n *\n * @example\n * ```typescript\n * import { ExpressionEngine } from \"solve-js\";\n *\n * const engine = new ExpressionEngine(\"en\", false, {\n *   validation: {\n *     maxExpressionLength: 1000,\n *     maxComplexity: 200,\n *   },\n *   // date, dice, performance, vm, worker, diagnostic all use defaults\n * });\n * ```\n */\nexport interface EngineConfig {\n    /** Date/time expression evaluation bounds and formatting */\n    readonly date: DateConfig;\n    /** Dice roll expression controls */\n    readonly dice: DiceConfig;\n    /** Performance budgets and cache sizing */\n    readonly performance: PerformanceConfig;\n    /** Safety limits for expression complexity */\n    readonly validation: ValidationConfig;\n    /** Internal bytecode VM configuration */\n    readonly vm: VMConfig;\n    /** Parallel worker pool configuration */\n    readonly worker: WorkerConfig;\n    /** Diagnostic pipeline configuration */\n    readonly diagnostic: DiagnosticConfig;\n  }\n\n/**\n * Default configuration values\n */\nexport const DEFAULT_CONFIG: EngineConfig = {\n   date: {\n     defaultOffsetDays: 0,\n     maxOffsetYears: 100,\n     minOffsetYears: -100,\n     defaultFormat: 'YYYY-MM-DD'\n   },\n   dice: {\n     defaultSides: 6,\n     maxSides: 1000,\n     maxDice: 100,\n     defaultDice: 1\n   },\n   performance: {\n     // Preserves the effective cache size the hardcoded (now-removed)\n     // BYTECODE_CACHE_MAX_ENTRIES constant had, so wiring this field up\n     // doesn't silently shrink the default cache for existing consumers.\n     defaultCacheSize: 2000,\n     maxDocumentLines: 10000,\n     parseTimeoutMs: 5000,\n     executionTimeoutMs: 10000\n   },\n    validation: {\n      maxExpressionLength: 2000,\n      maxComplexity: 500,\n      maxNestingDepth: 50,\n      autoBalanceParens: false,\n    },\n    vm: {\n      maxStackDepth: 200,\n      maxInstructions: 50000,\n    },\n    worker: {\n      maxConcurrentWorkers: 4,\n      idleTimeoutMs: 30000,\n      maxRetries: 3,\n      baseBackoffMs: 1000,\n    },\n    diagnostic: {\n      enabled: false,\n      vmTraceEnabled: false,\n    },\n  };\n\n/**\n * Merge a partial config override onto a base `EngineConfig`, section by\n * section, `{ ...base.section, ...override.section }` for each of the 7\n * top-level sections, not a single top-level spread.\n *\n * A shallow `{ ...base, ...override }` at the TOP level replaces an entire\n * section wholesale the moment a caller overrides even one field in it\n * (e.g. `{ performance: { defaultCacheSize: 500 } }` would silently drop\n * every other `performance.*` field back to `undefined`, not to its\n * default). This function exists specifically so every config consumer\n * shares one correct merge instead of each hand-rolling (and risking) its\n * own. `ConfigManager` and `ExpressionEngine` both call this rather than\n * either duplicating the section list or instantiating a whole\n * `ConfigManager` just to reuse its private merge logic.\n */\nexport function mergeEngineConfig(\n  base: EngineConfig,\n  override: Partial<EngineConfig>\n): EngineConfig {\n  return {\n    date: { ...base.date, ...override.date },\n    dice: { ...base.dice, ...override.dice },\n    performance: { ...base.performance, ...override.performance },\n    validation: { ...base.validation, ...override.validation },\n    vm: { ...base.vm, ...override.vm },\n    worker: { ...base.worker, ...override.worker },\n    diagnostic: { ...base.diagnostic, ...override.diagnostic },\n  };\n}\n\n/**\n * Configuration manager for engine settings\n *\n * @example\n * ```typescript\n * const configManager = new ConfigManager();\n * configManager.set('performance.defaultCacheSize', 2000);\n * const cacheSize = configManager.get('performance.defaultCacheSize');\n * ```\n */\nexport class ConfigManager {\n  private config: EngineConfig;\n\n  constructor(config: Partial<EngineConfig> = {}) {\n    this.config = mergeEngineConfig(DEFAULT_CONFIG, config);\n  }\n\n  /**\n   * Get configuration value by path\n   * \n   * @param path - Dot-notation path to config value\n   * @returns Configuration value\n   */\n  get<T>(path: string): T {\n    const keys = path.split('.');\n    let current: unknown = this.config;\n\n    for (const key of keys) {\n      if (current && typeof current === 'object' && key in current) {\n        current = (current as Record<string, unknown>)[key];\n      } else {\n        throw ErrorFactory.config(\n          \"CONFIG_PATH_NOT_FOUND\",\n          `Configuration path not found: ${path}`,\n          { path }\n        );\n      }\n    }\n\n    return current as T;\n  }\n\n  /**\n   * Set configuration value by path\n   * \n   * @param path - Dot-notation path to config value\n   * @param value - New value\n   */\n  set<T>(path: string, value: T): void {\n    const keys = path.split('.');\n    if (keys.length < 2) {\n      throw ErrorFactory.config(\n        \"INVALID_CONFIG_PATH\",\n        `Invalid path: ${path}. Must be in format 'section.property'`,\n        { path }\n      );\n    }\n    \n    const section = keys[0];\n    const property = keys[1];\n    \n    if (!(section in this.config)) {\n      throw ErrorFactory.config(\n        \"CONFIG_SECTION_NOT_FOUND\",\n        `Configuration section not found: ${section}`,\n        { section, path }\n      );\n    }\n    \n    const sectionConfig = this.config[section as keyof EngineConfig];\n    if (sectionConfig && typeof sectionConfig === 'object') {\n      (sectionConfig as unknown as Record<string, unknown>)[property] = value;\n    } else {\n      throw ErrorFactory.config(\n        \"CONFIG_PROPERTY_NOT_FOUND\",\n        `Configuration property not found: ${path}`,\n        { path }\n      );\n    }\n  }\n\n  /**\n   * Get complete configuration\n   */\n  getConfig(): EngineConfig {\n    return { ...this.config };\n  }\n\n  /**\n   * Update multiple configuration values\n   */\n  update(config: Partial<EngineConfig>): void {\n    this.config = mergeEngineConfig(this.config, config);\n  }\n\n  /**\n   * Reset to default configuration\n   */\n  reset(): void {\n    this.config = { ...DEFAULT_CONFIG };\n  }\n\n  /**\n   * Validate configuration values\n   */\n  validate(): ValidationResult {\n    const errors: string[] = [];\n\n    // Validate performance config\n    if (this.config.performance.maxDocumentLines > 100000) {\n      errors.push('maxDocumentLines cannot exceed 100,000');\n    }\n\n    // Validate date config\n    if (this.config.date.maxOffsetYears > 1000) {\n      errors.push('maxOffsetYears cannot exceed 1000');\n    }\n\n    // Validate dice config\n    if (this.config.dice.maxSides > 10000) {\n      errors.push('maxSides cannot exceed 10,000');\n    }\n\n    return {\n      valid: errors.length === 0,\n      error: errors.join('; '),\n      warnings: []\n    };\n  }\n}\n\n/**\n * Result type for {@link ConfigManager.validate}.\n */\nexport interface ValidationResult {\n  valid: boolean;\n  error?: string;\n  warnings?: string[];\n}\n\n"]}

package/dist/{chunk-4MG4XKO2.js → chunk-PCPX42KL.js}

@@ -1636,9 +1636,44 @@ var EXTENDED_UNITS = {
   ppb: { measure: "partsPer", toBase: 1e-9 },
   ppt: { measure: "partsPer", toBase: 1e-12 },
   // parts per trillion (chemistry/environmental convention)
-  permille: { measure: "partsPer", toBase: 1e-3 }
+  permille: { measure: "partsPer", toBase: 1e-3 },
+  // ── Length, extending the base table rather than replacing it ─────────
+  //
+  // These share the `length` measure with the generated table, so they convert
+  // against metres and everything derived from them. Ratios are the exact
+  // international definitions, all of which are whole multiples of the inch
+  // (0.0254 m exactly) except the mil, which is a thousandth of one.
+  mil: { measure: "length", toBase: 254e-7 },
+  mils: { measure: "length", toBase: 254e-7 },
+  hand: { measure: "length", toBase: 0.1016 },
+  // 4 in
+  hands: { measure: "length", toBase: 0.1016 },
+  rod: { measure: "length", toBase: 5.0292 },
+  // 16.5 ft
+  rods: { measure: "length", toBase: 5.0292 },
+  chain: { measure: "length", toBase: 20.1168 },
+  // 66 ft, 4 rods
+  chains: { measure: "length", toBase: 20.1168 },
+  furlong: { measure: "length", toBase: 201.168 },
+  // 10 chains
+  furlongs: { measure: "length", toBase: 201.168 },
+  cable: { measure: "length", toBase: 185.2 },
+  // a tenth of a nautical mile
+  cables: { measure: "length", toBase: 185.2 },
+  league: { measure: "length", toBase: 4828.032 },
+  // 3 miles
+  leagues: { measure: "length", toBase: 4828.032 },
+  // ── Mass ──────────────────────────────────────────────────────────────
+  // The metric carat is exactly 200 mg by definition, not the older and
+  // variable gemstone carat, and not the karat that measures gold purity.
+  carat: { measure: "mass", toBase: 0.2 },
+  carats: { measure: "mass", toBase: 0.2 },
+  // The metric centner, 100 kg, as used across continental Europe. The
+  // Imperial hundredweight is a different quantity and is already `cwt`.
+  centner: { measure: "mass", toBase: 1e5 },
+  centners: { measure: "mass", toBase: 1e5 }
 };
 
 export { BEST_UNITS_METRIC, EXTENDED_UNITS, MEASURE_KIND_NAMES, MEASURE_SYMBOLS, UNIT_DIFFERENCES, UNIT_TABLE };
-//# sourceMappingURL=chunk-4MG4XKO2.js.map
-//# sourceMappingURL=chunk-4MG4XKO2.js.map
+//# sourceMappingURL=chunk-PCPX42KL.js.map
+//# sourceMappingURL=chunk-PCPX42KL.js.map