solve-engine 1.1.1 → 2.0.0

package/dist/chunk-APN442VD.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/normalizer/TokenNormalizer.ts","../src/normalizer/PhraseTrie.ts","../src/normalizer/BuiltinNormalizerRules.ts"],"names":["DEFAULT_OPTIONS","createFusedToken","type","text","sourceTokens","first","last","token","LexerToken","tokenTypeId","recordSourceSpan","fused","NON_WORD_NAMES","NON_WORD_TABLE","ids","n","len","table","id","TokenNormalizer","options","PhraseTrie","rule","ruleName","r","a","b","phrase","tokenType","word","tokens","onFusion","sorted","fusionHandler","maxPasses","maxTokens","current","changed","passCount","result","pos","matched","tid","trieMatch","rt","match","ErrorFactory","words","firstWord","node","i","best","depth","collect","path","child","RATE_DENOMINATOR_WORDS","PHRASE_START_WORDS","implicitMultiplyRule","priority","canStart","phraseGuard","t","next","nextValue","starToken","isInsideRangeContext","safeStack","prev","opensMapReduceCall","createBuiltinNormalizerRules","BUILTIN_PHRASES"],"mappings":"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","file":"chunk-APN442VD.cjs","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  // `text`, not `value`: this is where the SOURCE ended, and the two differ\n  // for a string literal, whose value is the payload without its quotes.\n  token.sourceEnd = last.sourceEnd ?? last.offset + last.text.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.text.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-AXMQG5TS.cjs

@@ -0,0 +1,2 @@
+'use strict';var a=class{constructor(){this.collectors=[];}register(t){this.collectors.push(t);}unregister(t){let e=this.collectors.indexOf(t);e!==-1&&this.collectors.splice(e,1);}clear(){this.collectors=[];}get hasCollectors(){return this.collectors.length>0}get collectorCount(){return this.collectors.length}firePipelineStart(t){if(this.collectors.length!==0)for(let e of this.collectors)e.onPipelineStart?.(t);}fireTokenEmitted(t){if(this.collectors.length!==0)for(let e of this.collectors)e.onTokenEmitted?.(t);}fireNormalizerStart(t){if(this.collectors.length!==0)for(let e of this.collectors)e.onNormalizerStart?.(t);}fireTokenFused(t){if(this.collectors.length!==0)for(let e of this.collectors)e.onTokenFused?.(t);}fireNormalizerEnd(t){if(this.collectors.length!==0)for(let e of this.collectors)e.onNormalizerEnd?.(t);}fireParseletMatched(t){if(this.collectors.length!==0)for(let e of this.collectors)e.onParseletMatched?.(t);}fireBytecodeBuilt(t){if(this.collectors.length!==0)for(let e of this.collectors)e.onBytecodeBuilt?.(t);}fireVmStep(t){if(this.collectors.length!==0)for(let e of this.collectors)e.onVmStep?.(t);}fireVmHalt(t){if(this.collectors.length!==0)for(let e of this.collectors)e.onVmHalt?.(t);}fireCacheHit(t){if(this.collectors.length!==0)for(let e of this.collectors)e.onCacheHit?.(t);}fireCacheMiss(t){if(this.collectors.length!==0)for(let e of this.collectors)e.onCacheMiss?.(t);}firePipelineEnd(t){if(this.collectors.length!==0)for(let e of this.collectors)e.onPipelineEnd?.(t);}collectReports(){let t=[];for(let e of this.collectors){let n=e.getReport();n&&t.push(n);}return t}reset(){for(let t of this.collectors)t.reset();}};var s=class{onPipelineStart(t){}onTokenEmitted(t){}onNormalizerStart(t){}onTokenFused(t){}onNormalizerEnd(t){}onParseletMatched(t){}onBytecodeBuilt(t){}onVmStep(t){}onVmHalt(t){}onCacheHit(t){}onCacheMiss(t){}onPipelineEnd(t){}};var i=class extends s{constructor(){super(...arguments);this.events=[];this.startNs=0;this.parseletEntries=new Map;this.totalTokens=0;this.cacheHitSeen=false;this.vmStepSeen=false;this.hasBytecodeBuilt=false;this.firstBytecodeOpcodesLength=0;this.parseletMatches=[];this.lastExpression="";this.lastInputType="";}get parseletMatchCount(){return this.parseletMatches.length}reset(){this.events=[],this.parseletEntries.clear(),this.startNs=0,this.totalTokens=0,this.cacheHitSeen=false,this.vmStepSeen=false,this.hasBytecodeBuilt=false,this.firstBytecodeOpcodesLength=0,this.parseletMatches=[],this.lastExpression="",this.lastInputType="";}stamp(e){let n=this.startNs!==0?performance.now()*1e6-this.startNs:0;return {...e,elapsedNs:n}}onPipelineStart(e){this.startNs===0&&(this.startNs=performance.now()*1e6),this.lastExpression=e.expression,this.lastInputType=e.inputType,this.events.push(this.stamp(e));}onTokenEmitted(e){this.events.push(this.stamp(e)),this.totalTokens++;}onNormalizerStart(e){this.events.push(this.stamp(e));}onTokenFused(e){this.events.push(this.stamp(e));}onNormalizerEnd(e){this.events.push(this.stamp(e));}onParseletMatched(e){this.events.push(this.stamp(e));let n=this.parseletEntries.get(e.parseletCategory);n?n.count++:this.parseletEntries.set(e.parseletCategory,{category:e.parseletCategory,count:1}),this.parseletMatches.push({tokenType:e.tokenType,tokenValue:e.tokenValue,parseletCategory:e.parseletCategory,parseletType:e.parseletType,isPrefix:e.isPrefix,bindingPower:e.bindingPower,tokenOffset:e.tokenOffset});}onBytecodeBuilt(e){this.events.push(this.stamp(e)),this.hasBytecodeBuilt||(this.hasBytecodeBuilt=true,this.firstBytecodeOpcodesLength=e.opcodesLength);}onVmStep(e){this.events.push(this.stamp(e)),this.vmStepSeen=true;}onVmHalt(e){this.events.push(this.stamp(e));}onCacheHit(e){this.events.push(this.stamp(e)),this.cacheHitSeen=true;}onCacheMiss(e){this.events.push(this.stamp(e));}onPipelineEnd(e){this.events.push(this.stamp(e));}getReport(){if(this.events.length===0)return;let e=performance.now()*1e6-this.startNs,n=new Map;for(let[,r]of this.parseletEntries)n.set(r.category,r.count);let c=this.firstBytecodeOpcodesLength,p=this.cacheHitSeen,d=this.totalTokens,o={events:this.events,parselets:this.parseletMatches.map(r=>({...r})),summary:{totalTokens:d,totalParselets:n.size,totalOpcodes:c,cacheHit:p,elapsedNs:e,parseCategories:n},metadata:{expression:this.lastExpression,inputType:this.lastInputType,timestamp:Date.now(),vmTraceEnabled:this.vmStepSeen},toJSON(){return {events:o.events,parselets:o.parselets,summary:{totalTokens:o.summary.totalTokens,totalParselets:o.summary.totalParselets,totalOpcodes:o.summary.totalOpcodes,cacheHit:o.summary.cacheHit,elapsedNs:o.summary.elapsedNs,parseCategories:Object.fromEntries(o.summary.parseCategories)},metadata:{...o.metadata}}}};return o}};var y={TokenEmitted:"token_emitted",NormalizerStart:"normalizer_start",TokenFused:"token_fused",NormalizerEnd:"normalizer_end",ParseletMatched:"parselet_matched",BytecodeBuilt:"bytecode_built",VmStep:"vm_step",VmHalt:"vm_halt",CacheHit:"cache_hit",CacheMiss:"cache_miss",PipelineStart:"pipeline_start",PipelineEnd:"pipeline_end"};exports.a=a;exports.b=i;exports.c=y;//# sourceMappingURL=chunk-AXMQG5TS.cjs.map
+//# sourceMappingURL=chunk-AXMQG5TS.cjs.map

package/dist/chunk-AXMQG5TS.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/diagnostics/pipeline.ts","../src/diagnostics/collector.ts","../src/diagnostics/timeline-collector.ts","../src/diagnostics/events.ts"],"names":["DiagnosticPipeline","collector","idx","event","c","reports","report","DiagnosticCollector","_event","TimelineDiagnosticCollector","elapsedNs","entry","parseCategories","totalOpcodes","cacheHit","totalTokens","e","DiagnosticEventType"],"mappings":"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","file":"chunk-AXMQG5TS.cjs","sourcesContent":["import { DiagnosticCollector } from \"./collector\";\nimport { DiagnosticEvent } from \"./events\";\nimport { DiagnosticReport } from \"./events\";\n\n/**\n * Dispatches diagnostic events to all registered collectors.\n *\n * Performance guarantee: when no collectors are registered (production mode),\n * every dispatch method is a branch on `this.collectors.length === 0` which\n * modern JS engines will predict and eliminate. The overhead is a single\n * comparison per call, effectively zero.\n */\nexport class DiagnosticPipeline {\n  private collectors: DiagnosticCollector[] = [];\n\n  register(collector: DiagnosticCollector): void {\n    this.collectors.push(collector);\n  }\n\n  unregister(collector: DiagnosticCollector): void {\n    const idx = this.collectors.indexOf(collector);\n    if (idx !== -1) this.collectors.splice(idx, 1);\n  }\n\n  clear(): void {\n    this.collectors = [];\n  }\n\n  get hasCollectors(): boolean {\n    return this.collectors.length > 0;\n  }\n\n  get collectorCount(): number {\n    return this.collectors.length;\n  }\n\n  // Inline-optimized dispatchers, each checks length once then loops.\n  // When collectors.length === 0, the JIT eliminates the entire method body.\n\n  firePipelineStart(event: DiagnosticEvent & { type: \"pipeline_start\" }): void {\n    if (this.collectors.length === 0) return;\n    for (const c of this.collectors) c.onPipelineStart?.(event);\n  }\n\n  fireTokenEmitted(event: DiagnosticEvent & { type: \"token_emitted\" }): void {\n    if (this.collectors.length === 0) return;\n    for (const c of this.collectors) c.onTokenEmitted?.(event);\n  }\n\n  fireNormalizerStart(event: DiagnosticEvent & { type: \"normalizer_start\" }): void {\n    if (this.collectors.length === 0) return;\n    for (const c of this.collectors) c.onNormalizerStart?.(event);\n  }\n\n  fireTokenFused(event: DiagnosticEvent & { type: \"token_fused\" }): void {\n    if (this.collectors.length === 0) return;\n    for (const c of this.collectors) c.onTokenFused?.(event);\n  }\n\n  fireNormalizerEnd(event: DiagnosticEvent & { type: \"normalizer_end\" }): void {\n    if (this.collectors.length === 0) return;\n    for (const c of this.collectors) c.onNormalizerEnd?.(event);\n  }\n\n  fireParseletMatched(event: DiagnosticEvent & { type: \"parselet_matched\" }): void {\n    if (this.collectors.length === 0) return;\n    for (const c of this.collectors) c.onParseletMatched?.(event);\n  }\n\n  fireBytecodeBuilt(event: DiagnosticEvent & { type: \"bytecode_built\" }): void {\n    if (this.collectors.length === 0) return;\n    for (const c of this.collectors) c.onBytecodeBuilt?.(event);\n  }\n\n  fireVmStep(event: DiagnosticEvent & { type: \"vm_step\" }): void {\n    if (this.collectors.length === 0) return;\n    for (const c of this.collectors) c.onVmStep?.(event);\n  }\n\n  fireVmHalt(event: DiagnosticEvent & { type: \"vm_halt\" }): void {\n    if (this.collectors.length === 0) return;\n    for (const c of this.collectors) c.onVmHalt?.(event);\n  }\n\n  fireCacheHit(event: DiagnosticEvent & { type: \"cache_hit\" }): void {\n    if (this.collectors.length === 0) return;\n    for (const c of this.collectors) c.onCacheHit?.(event);\n  }\n\n  fireCacheMiss(event: DiagnosticEvent & { type: \"cache_miss\" }): void {\n    if (this.collectors.length === 0) return;\n    for (const c of this.collectors) c.onCacheMiss?.(event);\n  }\n\n  firePipelineEnd(event: DiagnosticEvent & { type: \"pipeline_end\" }): void {\n    if (this.collectors.length === 0) return;\n    for (const c of this.collectors) c.onPipelineEnd?.(event);\n  }\n\n  collectReports(): DiagnosticReport[] {\n    const reports: DiagnosticReport[] = [];\n    for (const c of this.collectors) {\n      const report = c.getReport();\n      if (report) reports.push(report);\n    }\n    return reports;\n  }\n\n  reset(): void {\n    for (const c of this.collectors) c.reset();\n  }\n}","import { DiagnosticEvent } from \"./events\";\nimport { DiagnosticReport } from \"./events\";\n\n/**\n * Interface for collecting diagnostic data during pipeline execution.\n *\n * All methods are implemented as concrete no-ops so subclasses only\n * need to override the ones they care about. This avoids optional\n * method issues with TypeScript's strict mode.\n *\n * The parameters are named `_event` because these base implementations\n * deliberately ignore them. Overrides are free to name theirs `event` and use\n * it; TypeScript does not match parameter names when checking overrides.\n */\nexport abstract class DiagnosticCollector {\n  onPipelineStart(_event: DiagnosticEvent & { type: \"pipeline_start\" }): void {}\n  onTokenEmitted(_event: DiagnosticEvent & { type: \"token_emitted\" }): void {}\n  onNormalizerStart(_event: DiagnosticEvent & { type: \"normalizer_start\" }): void {}\n  onTokenFused(_event: DiagnosticEvent & { type: \"token_fused\" }): void {}\n  onNormalizerEnd(_event: DiagnosticEvent & { type: \"normalizer_end\" }): void {}\n  onParseletMatched(_event: DiagnosticEvent & { type: \"parselet_matched\" }): void {}\n  onBytecodeBuilt(_event: DiagnosticEvent & { type: \"bytecode_built\" }): void {}\n  onVmStep(_event: DiagnosticEvent & { type: \"vm_step\" }): void {}\n  onVmHalt(_event: DiagnosticEvent & { type: \"vm_halt\" }): void {}\n  onCacheHit(_event: DiagnosticEvent & { type: \"cache_hit\" }): void {}\n  onCacheMiss(_event: DiagnosticEvent & { type: \"cache_miss\" }): void {}\n  onPipelineEnd(_event: DiagnosticEvent & { type: \"pipeline_end\" }): void {}\n\n  abstract getReport(): DiagnosticReport | undefined;\n  abstract reset(): void;\n}","import { DiagnosticCollector } from \"./collector\";\nimport { DiagnosticReport, DiagnosticReportJSON, DiagnosticEvent, CategorizedParselet } from \"./events\";\n\n/**\n * Collects all pipeline events with high-resolution timestamps.\n *\n * Overrides the zero-filled `elapsedNs` on every incoming event with a\n * real `performance.now()` delta from `onPipelineStart`. This enables\n * per-stage timing extraction from the event timeline (lexer/parser/\n * compiler/VM breakdown) rather than relying on a single total elapsed.\n *\n * Produces a complete DiagnosticReport at the end of evaluation.\n */\nexport class TimelineDiagnosticCollector extends DiagnosticCollector {\n  private events: DiagnosticEvent[] = [];\n  private startNs: number = 0;\n  private parseletEntries: Map<string, { category: string; count: number }> = new Map();\n\n  // Incrementally-maintained summary state. See getReport()'s doc comment\n  // for why these exist. Each mirrors exactly what getReport() used to\n  // recompute by rescanning the full `events` array on every call.\n  private totalTokens = 0;\n  private cacheHitSeen = false;\n  private vmStepSeen = false;\n  private hasBytecodeBuilt = false;\n  private firstBytecodeOpcodesLength = 0;\n  private parseletMatches: CategorizedParselet[] = [];\n  private lastExpression = \"\";\n  private lastInputType = \"\";\n\n  /**\n   * Current cumulative count of `parselet_matched` events seen since\n   * construction (or the last `reset()`), a cheap peek that doesn't build\n   * the full report (`getReport()` copies the whole `parseletMatches`\n   * array). Used by `ExpressionEngine.evaluateExpressionWithDiagnostic()`\n   * to capture a \"before\" baseline per line, since `parseletMatches` itself\n   * is deliberately cumulative across an entire document pass (see\n   * `onPipelineStart`'s doc comment) rather than reset per line.\n   */\n  get parseletMatchCount(): number {\n    return this.parseletMatches.length;\n  }\n\n  reset(): void {\n    this.events = [];\n    this.parseletEntries.clear();\n    this.startNs = 0;\n    this.totalTokens = 0;\n    this.cacheHitSeen = false;\n    this.vmStepSeen = false;\n    this.hasBytecodeBuilt = false;\n    this.firstBytecodeOpcodesLength = 0;\n    this.parseletMatches = [];\n    this.lastExpression = \"\";\n    this.lastInputType = \"\";\n  }\n\n  /** Stamp the real wall-clock `elapsedNs` onto an event before storing it. */\n  private stamp<T extends DiagnosticEvent>(event: T): T {\n    const elapsedNs = this.startNs !== 0\n      ? performance.now() * 1e6 - this.startNs\n      : 0;\n    return { ...event, elapsedNs } as T;\n  }\n\n  onPipelineStart(event: DiagnosticEvent & { type: \"pipeline_start\" }): void {\n    // Set once per collector lifetime (until an explicit reset()), not on\n    // every pipeline, a multi-line evaluation pass fires pipeline_start\n    // once per line, all appending to the SAME `events` array (see\n    // buildLineStats() in the playground, which relies on that shared,\n    // ever-growing array to slice out each line's own events via\n    // cumulative-length diffing). Resetting the origin on every line meant\n    // every individual line's own timestamps were self-consistent, but\n    // nothing tied one line's clock to another's, any code trying to\n    // compare or span timestamps ACROSS lines (e.g. \"how far into this\n    // pass are we\") had no stable reference point to do it with.\n    if (this.startNs === 0) {\n      this.startNs = performance.now() * 1e6;\n    }\n    // Tracked incrementally (most-recent wins) so getReport()'s `metadata`\n    // describes the line THIS report is actually about, reading\n    // `events[0]` instead (the old code) froze `expression`/`inputType` on\n    // the very first line ever evaluated in the session, forever, which is\n    // wrong regardless of whether a field is meant to be cumulative or\n    // per-line: nothing downstream ever wanted \"line 1's expression\" once\n    // the document had moved on to line 50.\n    this.lastExpression = event.expression;\n    this.lastInputType = event.inputType;\n    this.events.push(this.stamp(event));\n  }\n\n  onTokenEmitted(event: DiagnosticEvent & { type: \"token_emitted\" }): void {\n    this.events.push(this.stamp(event));\n    this.totalTokens++;\n  }\n\n  onNormalizerStart(event: DiagnosticEvent & { type: \"normalizer_start\" }): void {\n    this.events.push(this.stamp(event));\n  }\n\n  onTokenFused(event: DiagnosticEvent & { type: \"token_fused\" }): void {\n    this.events.push(this.stamp(event));\n  }\n\n  onNormalizerEnd(event: DiagnosticEvent & { type: \"normalizer_end\" }): void {\n    this.events.push(this.stamp(event));\n  }\n\n  onParseletMatched(event: DiagnosticEvent & { type: \"parselet_matched\" }): void {\n    this.events.push(this.stamp(event));\n\n    const entry = this.parseletEntries.get(event.parseletCategory);\n    if (entry) {\n      entry.count++;\n    } else {\n      this.parseletEntries.set(event.parseletCategory, {\n        category: event.parseletCategory,\n        count: 1,\n      });\n    }\n\n    this.parseletMatches.push({\n      tokenType: event.tokenType,\n      tokenValue: event.tokenValue,\n      parseletCategory: event.parseletCategory,\n      parseletType: event.parseletType,\n      isPrefix: event.isPrefix,\n      bindingPower: event.bindingPower,\n      tokenOffset: event.tokenOffset,\n    });\n  }\n\n  onBytecodeBuilt(event: DiagnosticEvent & { type: \"bytecode_built\" }): void {\n    this.events.push(this.stamp(event));\n    // Matches getReport()'s original behavior: the FIRST bytecode_built\n    // event ever seen (not the most recent) wins, preserved as-is here\n    // this rewrite only changes HOW that value is computed, not what it is.\n    if (!this.hasBytecodeBuilt) {\n      this.hasBytecodeBuilt = true;\n      this.firstBytecodeOpcodesLength = event.opcodesLength;\n    }\n  }\n\n  onVmStep(event: DiagnosticEvent & { type: \"vm_step\" }): void {\n    this.events.push(this.stamp(event));\n    this.vmStepSeen = true;\n  }\n\n  onVmHalt(event: DiagnosticEvent & { type: \"vm_halt\" }): void {\n    this.events.push(this.stamp(event));\n  }\n\n  onCacheHit(event: DiagnosticEvent & { type: \"cache_hit\" }): void {\n    this.events.push(this.stamp(event));\n    this.cacheHitSeen = true;\n  }\n\n  onCacheMiss(event: DiagnosticEvent & { type: \"cache_miss\" }): void {\n    this.events.push(this.stamp(event));\n  }\n\n  onPipelineEnd(event: DiagnosticEvent & { type: \"pipeline_end\" }): void {\n    this.events.push(this.stamp(event));\n  }\n\n/**\n * Build the summary/metadata/parselets report from this collector's\n * running state.\n *\n * These fields used to be recomputed by rescanning the FULL `events`\n * array on every single call (`.some()`/`.filter()`/a manual scan), since\n * `events` is never cleared except by an explicit `reset()` (which nothing\n * in `ExpressionEngine` currently calls, the cumulative-across-the-whole-\n * document design is deliberate, see `onPipelineStart`'s comment and the\n * playground's `buildLineStats()`, which slices per-line events out of\n * this ever-growing array via cumulative-length diffing), that meant\n * per-call cost grew linearly with total prior calls: O(n²) diagnostic-mode\n * evaluation over a document's lifetime. Fixed by maintaining each of these\n * incrementally as events arrive (see the `on*` handlers above), the same\n * pattern already used for `parseletEntries`. Every value produced here is\n * identical to what the old rescanning code produced, including its\n * existing \"first bytecode_built event wins\" quirk. This is a performance\n * fix, not a behavior change.\n */\ngetReport(): DiagnosticReport | undefined {\n     if (this.events.length === 0) return undefined;\n\n     const elapsedNs = performance.now() * 1e6 - this.startNs;\n\n     const parseCategories = new Map<string, number>();\n     for (const [, entry] of this.parseletEntries) {\n       parseCategories.set(entry.category, entry.count);\n     }\n\n     const totalOpcodes = this.firstBytecodeOpcodesLength;\n     const cacheHit = this.cacheHitSeen;\n     const totalTokens = this.totalTokens;\n\n     const report: DiagnosticReport = {\n       events: this.events,\n       parselets: this.parseletMatches.map((e) => ({ ...e })),\n       summary: {\n         totalTokens,\n         totalParselets: parseCategories.size,\n         totalOpcodes,\n         cacheHit,\n         elapsedNs,\n         parseCategories,\n       },\n       metadata: {\n         expression: this.lastExpression,\n         inputType: this.lastInputType,\n         timestamp: Date.now(),\n         vmTraceEnabled: this.vmStepSeen,\n       },\n       toJSON(): DiagnosticReportJSON {\n         return {\n           events: report.events,\n           parselets: report.parselets,\n           summary: {\n             totalTokens: report.summary.totalTokens,\n             totalParselets: report.summary.totalParselets,\n             totalOpcodes: report.summary.totalOpcodes,\n             cacheHit: report.summary.cacheHit,\n             elapsedNs: report.summary.elapsedNs,\n             parseCategories: Object.fromEntries(report.summary.parseCategories),\n           },\n           metadata: { ...report.metadata },\n         };\n       },\n     };\n\n     return report;\n   }\n}","\n\nimport type { MatrixData, RangeData, ColourData, SplitData } from \"@solve-js/vm/Value\";\nimport type { SymbolicNode } from \"@solve-js/symbolic\";\n\n/**\n * Diagnostic event types as string constants (not const enum, for cross-module compatibility with isolatedModules)\n */\nexport const DiagnosticEventType = {\n  TokenEmitted: \"token_emitted\",\n  NormalizerStart: \"normalizer_start\",\n  TokenFused: \"token_fused\",\n  NormalizerEnd: \"normalizer_end\",\n  ParseletMatched: \"parselet_matched\",\n  BytecodeBuilt: \"bytecode_built\",\n  VmStep: \"vm_step\",\n  VmHalt: \"vm_halt\",\n  CacheHit: \"cache_hit\",\n  CacheMiss: \"cache_miss\",\n  PipelineStart: \"pipeline_start\",\n  PipelineEnd: \"pipeline_end\",\n} as const;\n\n/** Discriminator naming which pipeline event a diagnostic record describes. */\nexport type EventType = (typeof DiagnosticEventType)[keyof typeof DiagnosticEventType];\n\n/** Base event, all events include a timestamp relative to pipeline start */\nexport interface BaseEvent {\n  readonly type: string;\n  readonly elapsedNs: number;\n  readonly expression: string;\n}\n\n/** Emitted after each token is produced by the lexer */\nexport interface TokenEmittedEvent extends BaseEvent {\n  readonly type: \"token_emitted\";\n  readonly token: {\n    readonly type: string;\n    readonly value: string;\n    readonly offset: number;\n    readonly line: number;\n    readonly col: number;\n  };\n}\n\n/** Emitted when the parser resolves a parselet for a token */\nexport interface ParseletMatchedEvent extends BaseEvent {\n  readonly type: \"parselet_matched\";\n  readonly tokenType: string;\n  readonly tokenValue: string;\n  readonly parseletCategory: string;\n  readonly parseletType: string;\n  readonly isPrefix: boolean;\n  readonly bindingPower?: number;\n  readonly tokenOffset: number;\n}\n\n/** Emitted after bytecode is built */\nexport interface BytecodeBuiltEvent extends BaseEvent {\n  readonly type: \"bytecode_built\";\n  readonly opcodesLength: number;\n  readonly numbersLength: number;\n  readonly stringsLength: number;\n  readonly isCached: boolean;\n}\n\n/** Emitted after each VM opcode execution (only when vmTrace is enabled) */\nexport interface VmStepEvent extends BaseEvent {\n  readonly type: \"vm_step\";\n  readonly opcode: number;\n  readonly opcodeName: string;\n  readonly ip: number;\n  readonly stackDepth: number;\n  readonly instructionNumber: number;\n  readonly stack: ReadonlyArray<{\n    readonly type: number;\n    readonly value: number | bigint | string | boolean | MatrixData | RangeData | ColourData | SplitData | SymbolicNode;\n    readonly unit?: string;\n  }>;\n}\n\n/** Emitted when the VM halts with a result */\nexport interface VmHaltEvent extends BaseEvent {\n  readonly type: \"vm_halt\";\n  readonly result?: {\n    readonly type: number;\n    readonly value: number | bigint | string | boolean | MatrixData | RangeData | ColourData | SplitData | SymbolicNode;\n    readonly unit?: string;\n  };\n}\n\n/** Emitted on cache hit */\nexport interface CacheHitEvent extends BaseEvent {\n  readonly type: \"cache_hit\";\n  readonly cache: \"bytecode\" | \"line\";\n  readonly key: string;\n}\n\n/** Emitted on cache miss */\nexport interface CacheMissEvent extends BaseEvent {\n  readonly type: \"cache_miss\";\n  readonly cache: \"bytecode\" | \"line\";\n  readonly key: string;\n}\n\n/** Emitted when a pipeline evaluation begins */\nexport interface PipelineStartEvent extends BaseEvent {\n  readonly type: \"pipeline_start\";\n  readonly inputType: string;\n}\n\n/** Emitted when a pipeline evaluation completes */\nexport interface PipelineEndEvent extends BaseEvent {\n  readonly type: \"pipeline_end\";\n  readonly success: boolean;\n  readonly error?: string;\n  readonly totalTokens: number;\n  readonly totalOpcodes: number;\n}\n\n/** Emitted when the normalizer begins its pass */\nexport interface NormalizerStartEvent extends BaseEvent {\n  readonly type: \"normalizer_start\";\n  readonly inputTokenCount: number;\n}\n\n/** Emitted when the normalizer fuses tokens */\nexport interface TokenFusedEvent extends BaseEvent {\n  readonly type: \"token_fused\";\n  readonly ruleName: string;\n  readonly sourceTokenCount: number;\n  readonly fusedTokenType: string;\n  readonly fusedTokenValue: string;\n}\n\n/** Emitted when the normalizer completes its pass */\nexport interface NormalizerEndEvent extends BaseEvent {\n  readonly type: \"normalizer_end\";\n  readonly outputTokenCount: number;\n  readonly fusionsCount: number;\n}\n\n/** Union of all event types */\nexport type DiagnosticEvent =\n  | TokenEmittedEvent\n  | NormalizerStartEvent\n  | TokenFusedEvent\n  | NormalizerEndEvent\n  | ParseletMatchedEvent\n  | BytecodeBuiltEvent\n  | VmStepEvent\n  | VmHaltEvent\n  | CacheHitEvent\n  | CacheMissEvent\n  | PipelineStartEvent\n  | PipelineEndEvent;\n\n/** Categorized parselet info */\nexport interface CategorizedParselet {\n  readonly tokenType: string;\n  readonly tokenValue: string;\n  readonly parseletCategory: string;\n  readonly parseletType: string;\n  readonly isPrefix: boolean;\n  readonly bindingPower?: number;\n  readonly tokenOffset: number;\n}\n\n/** JSON-serializable representation of a DiagnosticReport */\nexport interface DiagnosticReportJSON {\n   readonly events: readonly DiagnosticEvent[];\n   readonly parselets: readonly CategorizedParselet[];\n   readonly summary: {\n     readonly totalTokens: number;\n     readonly totalParselets: number;\n     readonly totalOpcodes: number;\n     readonly cacheHit: boolean;\n     readonly elapsedNs: number;\n     readonly parseCategories: Record<string, number>;\n   };\n   readonly metadata: {\n     readonly expression: string;\n     readonly inputType: string;\n     readonly timestamp: number;\n     readonly vmTraceEnabled: boolean;\n   };\n}\n\n/** Structured diagnostic report */\nexport interface DiagnosticReport {\n   readonly events: readonly DiagnosticEvent[];\n   readonly parselets: readonly CategorizedParselet[];\n   readonly summary: {\n     readonly totalTokens: number;\n     readonly totalParselets: number;\n     readonly totalOpcodes: number;\n     readonly cacheHit: boolean;\n     readonly elapsedNs: number;\n     readonly parseCategories: ReadonlyMap<string, number>;\n   };\n   readonly metadata: {\n     readonly expression: string;\n     readonly inputType: string;\n     readonly timestamp: number;\n     readonly vmTraceEnabled: boolean;\n   };\n\n   /** Serialize to a JSON-safe plain object */\n   toJSON(): DiagnosticReportJSON;\n}\n\n/** JSON-serializable representation of a DiagnosticReport */\nexport interface DiagnosticReportJSON {\n   readonly events: readonly DiagnosticEvent[];\n   readonly parselets: readonly CategorizedParselet[];\n   readonly summary: {\n     readonly totalTokens: number;\n     readonly totalParselets: number;\n     readonly totalOpcodes: number;\n     readonly cacheHit: boolean;\n     readonly elapsedNs: number;\n     readonly parseCategories: Record<string, number>;\n   };\n   readonly metadata: {\n     readonly expression: string;\n     readonly inputType: string;\n     readonly timestamp: number;\n     readonly vmTraceEnabled: boolean;\n   };\n}"]}

package/dist/chunk-CIQOK7Q4.cjs

@@ -0,0 +1,2 @@
+'use strict';var o=`0|1|radian,radians,rad,rads,r;0|6.283185307179586|turn,turns;0|0.017453292519943295|degree,degrees,deg,degs,\xB0;0|0.015707963267948967|gradian,gradians,gon,gons,grad,grads,grade,grades;0|0.0002908882086657216|arcminute,arcminutes,minutes of arc,arcmin,arcmins;0|0.00000484813681109536|arcsecond,arcseconds,seconds of arc,arcsec,arcsecs;1|1|square meter,square meters,square metre,square metres,m\xB2,m2,centiare,centiares,ca;1|1e+30|square petameter,square petametre,square petameters,square petametres,Pm\xB2,Pm2;1|1e+24|square terameter,square terametre,square terameters,square terametres,Tm\xB2,Tm2;1|1000000000000000000|square gigameter,square gigametre,square gigameters,square gigametres,Gm\xB2,Gm2;1|1000000000000|square megameter,square megametre,square megameters,square megametres,Mm\xB2,Mm2;1|1000000|square kilometer,square kilometre,square kilometers,square kilometres,km\xB2,km2;1|10000|square hectometer,square hectometre,square hectometers,square hectometres,hm\xB2,hm2,hectare,hectares,ha;1|100|square decameter,square decametre,square decameters,square decametres,dam\xB2,dam2,are,ares;1|0.01|square decimeter,square decimetre,square decimeters,square decimetres,dm\xB2,dm2;1|0.0001|square centimeter,square centimetre,square centimeters,square centimetres,cm\xB2,cm2;1|0.000001|square millimeter,square millimetre,square millimeters,square millimetres,mm\xB2,mm2;1|1e-12|square micrometer,square micrometre,square micrometers,square micrometres,\u03BCm\xB2,\xB5m\xB2,\u03BCm2,\xB5m2;1|1e-18|square nanometer,square nanometre,square nanometers,square nanometres,nm\xB2,nm2;1|1e-24|square picometer,square picometre,square picometers,square picometres,pm\xB2,pm2;1|1e-30|square femtometer,square femtometre,square femtometers,square femtometres,fm\xB2,fm2;1|4046.8564224|acre,acres,ac;1|10|deciare,deciares,da;1|1000|decare,decares,daa;1|0.09290304|square foot,square feet,sq ft,ft\xB2,ft2;1|0.00064516|square inch,square inches,sq in,in\xB2,in2;1|0.83612736|square yard,square yards,sq yd,yd\xB2,yd2;1|2589988.110336|square mile,square miles,sq mi,mi\xB2,mi2;1|666.6666666666666|m\u01D4,mu;2|1|bit,bits,b;2|1125899906842624|pebibit,pebibits,Pib;2|1099511627776|tebibit,tebibits,Tib;2|1073741824|gibibit,gibibits,Gib;2|1048576|mebibit,mebibits,Mib;2|1024|kibibit,kibibits,Kib;2|1000|Kb,kilobit,kilobits,kb;2|8000|KB,kilobyte,kilobytes,kB;2|1000000000000000|petabit,petabits,Pb;2|1000000000000|terabit,terabits,Tb;2|1000000000|gigabit,gigabits,Gb;2|1000000|megabit,megabits,Mb;2|100|hectobit,hectobits,hb;2|10|decabit,decabits,dab;2|0.1|decibit,decibits,db;2|0.01|centibit,centibits,cb;2|0.001|millibit,millibits,mb;2|0.000001|microbit,microbits,\u03BCb,\xB5b;2|1e-9|nanobit,nanobits,nb;2|1e-12|picobit,picobits,pb;2|1e-15|femtobit,femtobits,fb;2|4|nibble,nibbles,semioctet,semioctets,halfbyte,halfbytes;2|8|byte,bytes,octect,octects,B;2|9007199254740992|pebibyte,pebibytes,PiB;2|8796093022208|tebibyte,tebibytes,TiB;2|8589934592|gibibyte,gibibytes,GiB;2|8388608|mebibyte,mebibytes,MiB;2|8192|kibibyte,kibibytes,KiB;2|8000000000000000|petabyte,petabytes,PB;2|8000000000000|terabyte,terabytes,TB;2|8000000000|gigabyte,gigabytes,GB;2|8000000|megabyte,megabytes,MB;2|800|hectobyte,hectobytes,hB;2|80|decabyte,decabytes,daB;2|0.8|decibyte,decibytes,dB;2|0.08|centibyte,centibytes,cB;2|0.008|millibyte,millibytes,mB;2|0.000008|microbyte,microbytes,\u03BCB,\xB5B;2|8e-9|nanobyte,nanobytes,nB;2|8e-12|picobyte,picobytes,pB;2|8e-15|femtobyte,femtobytes,fB;2|16|hextet,hextets;3|1|joule,joules,J;3|1000000000000000|petajoule,petajoules,PJ;3|1000000000000|terajoule,terajoules,TJ;3|1000000000|gigajoule,gigajoules,GJ;3|1000000|megajoule,megajoules,MJ;3|1000|kilojoule,kilojoules,kJ;3|100|hectojoule,hectojoules,hJ;3|10|decajoule,decajoules,daJ;3|0.1|decijoule,decijoules,dJ;3|0.01|centijoule,centijoules,cJ;3|0.001|millijoule,millijoules,mJ;3|0.000001|microjoule,microjoules,\u03BCJ,\xB5J;3|1e-9|nanojoule,nanojoules,nJ;3|1e-12|picojoule,picojoules,pJ;3|1e-15|femtojoule,femtojoules,fJ;3|3600|watt-hour,W\u22C5h,W h,Wh;3|3600000000000000000|petawatt-hour,petawatt-hours,PW\u22C5h,PW h,PWh;3|3600000000000000|terawatt-hour,terawatt-hours,TW\u22C5h,TW h,TWh;3|3600000000000|gigawatt-hour,gigawatt-hours,GW\u22C5h,GW h,GWh;3|3600000000|megawatt-hour,megawatt-hours,MW\u22C5h,MW h,MWh;3|3600000|kilowatt-hour,kilowatt-hours,kW\u22C5h,kW h,kWh;3|360000|hectowatt-hour,hectowatt-hours,hW\u22C5h,hW h,hWh;3|36000|decawatt-hour,decawatt-hours,daW\u22C5h,daW h,daWh;3|360|deciwatt-hour,deciwatt-hours,dW\u22C5h,dW h,dWh;3|36|centiwatt-hour,centiwatt-hours,cW\u22C5h,cW h,cWh;3|3.6|milliwatt-hour,milliwatt-hours,mW\u22C5h,mW h,mWh;3|0.0036|microwatt-hour,microwatt-hours,\u03BCW\u22C5h,\xB5W\u22C5h,\u03BCW h,\xB5W h,\u03BCWh,\xB5Wh;3|0.0000036|nanowatt-hour,nanowatt-hours,nW\u22C5h,nW h,nWh;3|3.6e-9|picowatt-hour,picowatt-hours,pW\u22C5h,pW h,pWh;3|3.6e-12|femtowatt-hour,femtowatt-hours,fW\u22C5h,fW h,fWh;4|1|newton,newtons,N;4|1000000000000000|petanewton,petanewtons,PN;4|1000000000000|teranewton,teranewtons,TN;4|1000000000|giganewton,giganewtons,GN;4|1000000|meganewton,meganewtons,MN;4|1000|kilonewton,kilonewtons,kN;4|100|hectonewton,hectonewtons,hN;4|10|decanewton,decanewtons,daN;4|0.1|decinewton,decinewtons,dN;4|0.01|centinewton,centinewtons,cN;4|0.001|millinewton,millinewtons,mN;4|0.000001|micronewton,micronewtons,\u03BCN,\xB5N;4|1e-9|nanonewton,nanonewtons,nN;4|1e-12|piconewton,piconewtons,pN;4|1e-15|femtonewton,femtonewtons,fN;4|0.00001|dyne,dynes,dyn;4|4.448222|pound of force,pound-force,lbf;4|4448.2216|kip,klb,kipf,klbf;4|0.138255|poundal,poundals,pdl;4|9.80665|kilogram-force,kilopond,kiloponds,kgf,kp;4|9806.65|tonne-force,metric ton-force,megagram-force,megapond,tf,Mp;5|1|hertz,Hz;5|1000000000000000|petahertz,PHz;5|1000000000000|terahertz,THz;5|1000000000|gigahertz,GHz;5|1000000|megahertz,MHz;5|1000|kilohertz,kHz;5|100|hectohertz,hHz;5|10|decahertz,daHz;5|0.1|decihertz,dHz;5|0.01|centihertz,cHz;5|0.001|millihertz,mHz;5|0.000001|microhertz,\u03BCHz,\xB5Hz;5|1e-9|nanohertz,nHz;5|1e-12|picohertz,pHz;5|1e-15|femtohertz,fHz;6|1|lux,lx,lumen per square meter,lm/m2,lm/m\xB2;6|1000000000000000|petalux,Plx;6|1000000000000|teralux,Tlx;6|1000000000|gigalux,Glx;6|1000000|megalux,Mlx;6|1000|kilolux,klx;6|100|hectolux,hlx;6|10|decalux,dalx;6|0.1|decilux,dlx;6|0.01|centilux,clx;6|0.001|millilux,mlx;6|0.000001|microlux,\u03BClx,\xB5lx;6|1e-9|nanolux,nlx;6|1e-12|picolux,plx;6|1e-15|femtolux,flx;6|10.764|foot-candle,foot candle,fc,ft-c;6|10000|phot,ph;7|1|meter,meters,metre,metres,m;7|1000000000000000|petameter,petametre,petameters,petametres,Pm;7|1000000000000|terameter,terametre,terameters,terametres,Tm;7|1000000000|gigameter,gigametre,gigameters,gigametres,Gm;7|1000000|megameter,megametre,megameters,megametres,Mm;7|1000|kilometer,kilometre,kilometers,kilometres,km;7|100|hectometer,hectometre,hectometers,hectometres,hm;7|10|decameter,decametre,decameters,decametres,dam;7|0.1|decimeter,decimetre,decimeters,decimetres,dm;7|0.01|centimeter,centimetre,centimeters,centimetres,cm;7|0.001|millimeter,millimetre,millimeters,millimetres,mm;7|0.000001|micrometer,micrometre,micrometers,micrometres,\u03BCm,\xB5m;7|1e-9|nanometer,nanometre,nanometers,nanometres,nm;7|1e-12|picometer,picometre,picometers,picometres,pm;7|1e-15|femtometer,femtometre,femtometers,femtometres,fm;7|0.3048|foot,feet,ft,';7|0.3048006096012192|US survey foot,US survey feet,U.S. survey foot,U.S. survey feet;7|0.0254|inch,inches,in,";7|0.9144|yard,yards,yd;7|1609.344|mile,miles,mi;7|1852|nautical mile,nautical miles,M,NM,nmi;7|9460730472580800|light-year,light-years,ly;7|30856775814913670|parsec,parsecs,pc;7|0.0042333|pica,picas;7|0.0003528|point,points;8|1|candela per square meter,candelas per square meter,candela per square metre,candelas per square metre,cd/m2,cd/m\xB2,nit,nits,nt;8|1000000000000000|petacandela per square meter,petacandelas per square meter,petacandela per square metre,petacandelas per square metre,Pcd/m2,Pcd/m\xB2;8|1000000000000|teracandela per square meter,teracandelas per square meter,teracandela per square metre,teracandelas per square metre,Tcd/m2,Tcd/m\xB2;8|1000000000|gigacandela per square meter,gigacandelas per square meter,gigacandela per square metre,gigacandelas per square metre,Gcd/m2,Gcd/m\xB2;8|1000000|megacandela per square meter,megacandelas per square meter,megacandela per square metre,megacandelas per square metre,Mcd/m2,Mcd/m\xB2;8|1000|kilocandela per square meter,kilocandelas per square meter,kilocandela per square metre,kilocandelas per square metre,kcd/m2,kcd/m\xB2;8|100|hectocandela per square meter,hectocandelas per square meter,hectocandela per square metre,hectocandelas per square metre,hcd/m2,hcd/m\xB2;8|10|decacandela per square meter,decacandelas per square meter,decacandela per square metre,decacandelas per square metre,dacd/m2,dacd/m\xB2;8|0.1|decicandela per square meter,decicandelas per square meter,decicandela per square metre,decicandelas per square metre,dcd/m2,dcd/m\xB2;8|0.01|centicandela per square meter,centicandelas per square meter,centicandela per square metre,centicandelas per square metre,ccd/m2,ccd/m\xB2;8|0.001|millicandela per square meter,millicandelas per square meter,millicandela per square metre,millicandelas per square metre,mcd/m2,mcd/m\xB2;8|0.000001|microcandela per square meter,microcandelas per square meter,microcandela per square metre,microcandelas per square metre,\u03BCcd/m2,\xB5cd/m2,\u03BCcd/m\xB2,\xB5cd/m\xB2;8|1e-9|nanocandela per square meter,nanocandelas per square meter,nanocandela per square metre,nanocandelas per square metre,ncd/m2,ncd/m\xB2;8|1e-12|picocandela per square meter,picocandelas per square meter,picocandela per square metre,picocandelas per square metre,pcd/m2,pcd/m\xB2;8|1e-15|femtocandela per square meter,femtocandelas per square meter,femtocandela per square metre,femtocandelas per square metre,fcd/m2,fcd/m\xB2;9|1|candela,cd,candlepower,cp,CP;9|1000000000000000|petacandela,Pcd;9|1000000000000|teracandela,Tcd;9|1000000000|gigacandela,Gcd;9|1000000|megacandela,Mcd;9|1000|kilocandela,kcd;9|100|hectocandela,hcd;9|10|decacandela,dacd;9|0.1|decicandela,dcd;9|0.01|centicandela,ccd;9|0.001|millicandela,mcd;9|0.000001|microcandela,\u03BCcd,\xB5cd;9|1e-9|nanocandela,ncd;9|1e-12|picocandela,pcd;9|1e-15|femtocandela,fcd;9|0.92|hefnerkerze,HK;10|1|gram,grams,g;10|1000000000000000|petagram,petagrams,Pg,gigatonne,gigatonnes,Gt;10|1000000000000|teragram,teragrams,Tg,megatonne,megatonnes,Mt;10|1000000000|gigagram,gigagrams,Gg,kilotonne,kilotonnes,kt;10|1000000|megagram,megagrams,Mg,tonne,tonnes,metric ton,metric tons,t;10|1000|kilogram,kilograms,kg;10|100|hectogram,hectograms,hg;10|10|decagram,decagrams,dag;10|0.1|decigram,decigrams,dg;10|0.01|centigram,centigrams,cg;10|0.001|milligram,milligrams,mg;10|0.000001|microgram,micrograms,\u03BCg,\xB5g,mcg;10|1e-9|nanogram,nanograms,ng;10|1e-12|picogram,picograms,pg;10|1e-15|femtogram,femtograms,fg;10|453.59237|pound,pounds,lb,lbs;10|0.06479891|grain,grains,gr;10|6350.29318|stone,stones,st;10|28.349523125|ounce,ounces,oz;10|45360|short hundredweight,cental;10|50800|long hundredweight,imperial hundredweight,cwt;10|907184.74|short ton,short tons,US ton,US tons;10|1016046.9088|long ton,long tons,imperial ton,imperial tons,displacement ton,displacement tons;10|31.1034768|troy ounce,oz t,toz;11|1|watt,watts,W;11|1000000000000000|petawatt,petawatts,PW;11|1000000000000|terawatt,terawatts,TW;11|1000000000|gigawatt,gigawatts,GW;11|1000000|megawatt,megawatts,MW;11|1000|kilowatt,kilowatts,kW;11|100|hectowatt,hectowatts,hW;11|10|decawatt,decawatts,daW;11|0.1|deciwatt,deciwatts,dW;11|0.01|centiwatt,centiwatts,cW;11|0.001|milliwatt,milliwatts,mW;11|0.000001|microwatt,microwatts,\u03BCW,\xB5W;11|1e-9|nanowatt,nanowatts,nW;11|1e-12|picowatt,picowatts,pW;11|1e-15|femtowatt,femtowatts,fW;11|745.699872|horsepower,mechanical horsepower,hp;12|1|pascal,pascals,Pa;12|1000000000000000|petapascal,petapascals,PPa;12|1000000000000|terapascal,terapascals,TPa;12|1000000000|gigapascal,gigapascals,GPa;12|1000000|megapascal,megapascals,MPa,decabar,decabars,dabar;12|1000|kilopascal,kilopascals,kPa,centibar,centibars,cbar;12|100|hectopascal,hectopascals,hPa,millibar,millibars,mbar;12|10|decapascal,decapascals,daPa;12|0.1|decipascal,decipascals,dPa,microbar,microbars,\u03BCbar,\xB5bar;12|0.01|centipascal,centipascals,cPa;12|0.001|millipascal,millipascals,mPa;12|0.000001|micropascal,micropascals,\u03BCPa,\xB5Pa;12|1e-9|nanopascal,nanopascals,nPa;12|1e-12|picopascal,picopascals,pPa;12|1e-15|femtopascal,femtopascals,fPa;12|100000|bar,bars;12|100000000000000000000|petabar,petabars,Pbar;12|100000000000000000|terabar,terabars,Tbar;12|100000000000000|gigabar,gigabars,Gbar;12|100000000000|megabar,megabars,Mbar;12|100000000|kilobar,kilobars,kbar;12|10000000|hectobar,hectobars,hbar;12|10000|decibar,decibars,dbar;12|0.0001|nanobar,nanobars,nbar;12|1e-7|picobar,picobars,pbar;12|1e-10|femtobar,femtobars,fbar;12|133.32236842105263|torr,torrs,Torr;12|0.13332236842105263|millitorr,mTorr;12|101325|atmosphere,atmospheres,atm;12|6894.757|pound per square inch,pounds per square inch,psi,lbf/in2,lbf/in\xB2;12|249.0889|inch of water,inches of water,inAq,Aq;12|3386.389|inch of mercury,inches of mercury,inHg,Hg;13|1|kelvin,kelvins,K,celsius,C,\xB0C;13|1000000000000000|petakelvin,petakelvins,PK;13|1000000000000|terakelvin,terakelvins,TK;13|1000000000|gigakelvin,gigakelvins,GK;13|1000000|megakelvin,megakelvins,MK;13|1000|kilokelvin,kilokelvins,kK;13|100|hectokelvin,hectokelvins,hK;13|10|decakelvin,decakelvins,daK;13|0.1|decikelvin,decikelvins,dK;13|0.01|centikelvin,centikelvins,cK;13|0.001|millikelvin,millikelvins,mK;13|0.000001|microkelvin,microkelvins,\u03BCK,\xB5K;13|1e-9|nanokelvin,nanokelvins,nK;13|1e-12|picokelvin,picokelvins,pK;13|1e-15|femtokelvin,femtokelvins,fK;13|0.5555555555555556|fahrenheit,F,\xB0F,rankine,R;14|1|second,seconds,s;14|1000000000000000|petasecond,petaseconds,Ps;14|1000000000000|terasecond,teraseconds,Ts;14|1000000000|gigasecond,gigaseconds,Gs;14|1000000|megasecond,megaseconds,Ms;14|1000|kilosecond,kiloseconds,ks;14|100|hectosecond,hectoseconds,hs;14|10|decasecond,decaseconds,das;14|0.1|decisecond,deciseconds,ds;14|0.01|centisecond,centiseconds,cs;14|0.001|millisecond,milliseconds,ms;14|0.000001|microsecond,microseconds,\u03BCs,\xB5s;14|1e-9|nanosecond,nanoseconds,ns;14|1e-12|picosecond,picoseconds,ps;14|1e-15|femtosecond,femtoseconds,fs;14|60|minute,minutes,min;14|3600|hour,hours,h;14|86.4|milliday,millidays,md;14|86400|day,days,d;14|604800|week,weeks,wk;14|1209600|fortnight,fortnights,fn;14|2592000|month,months,mo;14|31536000|year,years,a,y,yr;14|315360000|decade,decades,dec;14|3153600000|century,centuries;14|31536000000|millennium,millennia;14|90|moment,moments;14|1e-8|shake,shakes;14|0.001024|time unit,TU;14|1e-13|svedberg,svedbergs,S;15|1|cubic meter,cubic meters,cubic metre,cubic metres,stere,steres,m\xB3,m3,kiloliter,kiloliters,kilolitre,kilolitres,kl,kL;15|1e+45|cubic petameter,cubic petameters,Pm3,Pm\xB3;15|1e+36|cubic terameter,cubic terameters,Tm3,Tm\xB3;15|1e+27|cubic gigameter,cubic gigameters,Gm3,Gm\xB3;15|1000000000000000000|cubic megameter,cubic megameters,Mm3,Mm\xB3;15|1000000000|cubic kilometer,cubic kilometers,km3,km\xB3,teraliter,teraliters,teralitre,teralitres,Tl,TL;15|1000000|cubic hectometer,cubic hectometers,hm3,hm\xB3,gigaliter,gigaliters,gigalitre,gigalitres,Gl,GL;15|1000|cubic decameter,cubic decameters,dam3,dam\xB3,megaliter,megaliters,megalitre,megalitres,Ml,ML;15|0.001|cubic decimeter,cubic decimeters,dm3,dm\xB3,liter,liters,litre,litres,l,L;15|0.000001|cubic centimeter,cubic centimeters,cm3,cm\xB3,milliliter,milliliters,millilitre,millilitres,ml,mL;15|1e-9|cubic millimeter,cubic millimeters,mm3,mm\xB3,microliter,microliters,microlitre,microlitres,\u03BCl,\xB5l,\u03BCL,\xB5L;15|1e-18|cubic micrometer,cubic micrometers,\u03BCm3,\xB5m3,\u03BCm\xB3,\xB5m\xB3,femtoliter,femtoliters,femtolitre,femtolitres,fl,fL;15|1e-27|cubic nanometer,cubic nanometers,nm3,nm\xB3;15|1e-36|cubic picometer,cubic picometers,pm3,pm\xB3;15|1e-45|cubic femtometer,cubic femtometers,fm3,fm\xB3;15|1000000000000|petaliter,petaliters,petalitre,petalitres,Pl,PL;15|0.1|hectoliter,hectoliters,hectolitre,hectolitres,hl,hL;15|0.01|decaliter,decaliters,decalitre,decalitres,dal,daL;15|0.0001|deciliter,deciliters,decilitre,decilitres,dl,dL;15|0.00001|centiliter,centiliters,centilitre,centilitres,cl,cL;15|1e-12|nanoliter,nanoliters,nanolitre,nanolitres,nl,nL;15|1e-15|picoliter,picoliters,picolitre,picolitres,pl,pL;15|4168181825.4405794|cubic mile,cubic miles,cu mi,mi3,mi\xB3;15|1233.48183754752|acre-foot,acre-feet,ac\u22C5ft,ac ft;15|0.764554857984|cubic yard,cubic yards,cu yd,yd3,yd\xB3;15|0.028316846592|cubic foot,cubic feet,cu ft,ft3,ft\xB3;15|0.002359737|board foot,board feet;15|0.000016387064|cubic inch,cubic inches,cu in,in3,in\xB3;15|1.133|measurement ton,measurement tons,MTON;15|0.16365924|imperial barrel,imperial barrels,imp bbl;15|0.03636872|imperial bushel,imperial bushels,imp bsh,imp bu;15|0.00909218|imperial peck,imperial pecks,pk,imp pk;15|0.00454609|imperial gallon,imperial gallons,imp gal;15|0.0011365225|imperial quart,imperial quarts,imp qt;15|0.00056826125|imperial pint,imperial pints,imp pt;15|0.0000284130625|imperial fluid ounce,imperial fluid ounces,imp fl oz;15|0.00000492892159375|teaspoon,teaspoons,US teaspoon,US teaspoons,tsp;15|0.00001478676478125|tablespoon,tablespoons,US tablespoon,US tablespoons,tbsp;15|0.0000295735295625|US fluid ounce,US fluid ounces,fl oz,fl. oz.,oz. fl.;15|0.0002365882365|cup,cups,c;15|0.00024|US legal cup,US legal cups,US lc;15|0.000473176473|pint,pints,US liquid pint,US liquid pints,pt,p;15|0.000946352946|quart,quarts,US liquid quart,US liquid quarts,qt;15|0.003785411784|gallon,gallons,US liquid gallon,US liquid gallons,gal;15|0.03523907016688|US bushel,US bushels,US bsh,US bu;15|0.00880976754172|US peck,US pk;15|0.00440488377086|US dry gallon,US dry gal;15|0.1156|US dry barrel,US dry barrels,US dry bbl;15|0.001101220942715|US dry quart,US dry qt;15|0.0005506104713575|US dry pint,US dry pt`;function l(m){let t={};for(let e of m.split(";")){let a=e.indexOf("|"),r=e.indexOf("|",a+1),s=Number(e.slice(0,a)),i=Number(e.slice(a+1,r)),c=[s,i];for(let n of e.slice(r+1).split(","))t[n]=c;}return t}var d=l(o),u={fahrenheit:459.67,F:459.67,"\xB0F":459.67,celsius:273.15,C:273.15,"\xB0C":273.15},p={0:[["deg",1]],1:[["mm2",1],["cm2",100],["m2",1e6],["km2",1e12]],2:[["bits",1],["B",8],["KB",8e3],["MB",8e6],["GB",8e9],["TB",8e12],["PB",8e15]],3:[["J",1],["Wh",3600],["kWh",36e5],["MWh",36e8],["GWh",36e11]],4:[["N",1]],5:[["Hz",1],["kHz",1e3],["MHz",1e6],["GHz",1e9],["THz",1e12],["PHz",1e15]],6:[["lux",1],["klx",1e3]],7:[["mm",1],["cm",10],["m",1e3],["km",1e6]],8:[["cd/m\xB2",1]],9:[["cd",1]],10:[["mg",1],["g",1e3],["kg",1e6]],11:[["W",1],["kW",1e3],["MW",1e6],["GW",1e9],["TW",1e12],["PW",1e15]],12:[["Pa",1]],13:[["C",1]],14:[["fs",1],["ps",1e3],["ns",1e6],["\xB5s",1e9],["ms",1e12],["s",1e15],["min",6e16],["h",36e17],["d",864e17],["y",31536e18]],15:[["mL",1],["L",1e3]]},h={0:["rad","rads","r","deg","degs","\xB0","gon","gons","grad","grads","grade","grades","arcmin","arcmins","arcsec","arcsecs"],1:["m\xB2","m2","Pm\xB2","Pm2","Tm\xB2","Tm2","Gm\xB2","Gm2","Mm\xB2","Mm2","km\xB2","km2","hm\xB2","hm2","dam\xB2","dam2","dm\xB2","dm2","cm\xB2","cm2","mm\xB2","mm2","\u03BCm\xB2","\xB5m\xB2","\u03BCm2","\xB5m2","nm\xB2","nm2","pm\xB2","pm2","fm\xB2","fm2","ac","ca","da","daa","ha","sq ft","ft\xB2","ft2","sq in","in\xB2","in2","sq yd","yd\xB2","yd2","sq mi","mi\xB2","mi2"],2:["b","Pib","Tib","Gib","Mib","Kib","Kb","KB","Pb","Tb","Gb","Mb","kb","hb","dab","db","cb","mb","\u03BCb","\xB5b","nb","pb","fb","B","PiB","TiB","GiB","MiB","KiB","PB","TB","GB","MB","kB","hB","daB","dB","cB","mB","\u03BCB","\xB5B","nB","pB","fB"],3:["J","PJ","TJ","GJ","MJ","kJ","hJ","daJ","dJ","cJ","mJ","\u03BCJ","\xB5J","nJ","pJ","fJ","W\u22C5h","W h","Wh","PW\u22C5h","PW h","PWh","TW\u22C5h","TW h","TWh","GW\u22C5h","GW h","GWh","MW\u22C5h","MW h","MWh","kW\u22C5h","kW h","kWh","hW\u22C5h","hW h","hWh","daW\u22C5h","daW h","daWh","dW\u22C5h","dW h","dWh","cW\u22C5h","cW h","cWh","mW\u22C5h","mW h","mWh","\u03BCW\u22C5h","\xB5W\u22C5h","\u03BCW h","\xB5W h","\u03BCWh","\xB5Wh","nW\u22C5h","nW h","nWh","pW\u22C5h","pW h","pWh","fW\u22C5h","fW h","fWh"],4:["N","PN","TN","GN","MN","kN","hN","daN","dN","cN","mN","\u03BCN","\xB5N","nN","pN","fN","dyn","lbf","klb","kipf","klbf","pdl","kgf","kp","tf","Mp"],5:["Hz","PHz","THz","GHz","MHz","kHz","hHz","daHz","dHz","cHz","mHz","\u03BCHz","\xB5Hz","nHz","pHz","fHz"],6:["lx","Plx","Tlx","Glx","Mlx","klx","hlx","dalx","dlx","clx","mlx","\u03BClx","\xB5lx","nlx","plx","flx","lm/m2","lm/m\xB2","fc","ft-c","ph"],7:["m","Pm","Tm","Gm","Mm","km","hm","dam","dm","cm","mm","\u03BCm","\xB5m","nm","pm","fm","ft","'","in",'"',"yd","mi","M","NM","nmi","ly","pc"],8:["cd/m2","cd/m\xB2","Pcd/m2","Pcd/m\xB2","Tcd/m2","Tcd/m\xB2","Gcd/m2","Gcd/m\xB2","Mcd/m2","Mcd/m\xB2","kcd/m2","kcd/m\xB2","hcd/m2","hcd/m\xB2","dacd/m2","dacd/m\xB2","dcd/m2","dcd/m\xB2","ccd/m2","ccd/m\xB2","mcd/m2","mcd/m\xB2","\u03BCcd/m2","\xB5cd/m2","\u03BCcd/m\xB2","\xB5cd/m\xB2","ncd/m2","ncd/m\xB2","pcd/m2","pcd/m\xB2","fcd/m2","fcd/m\xB2","nt"],9:["cd","Pcd","Tcd","Gcd","Mcd","kcd","hcd","dacd","dcd","ccd","mcd","\u03BCcd","\xB5cd","ncd","pcd","fcd","cp","CP","HK"],10:["g","Pg","Tg","Gg","Mg","kg","hg","dag","dg","cg","mg","\u03BCg","\xB5g","ng","pg","fg","mcg","t","kt","Mt","Gt","lb","lbs","gr","st","oz","cwt","oz t","toz"],11:["W","PW","TW","GW","MW","kW","hW","daW","dW","cW","mW","\u03BCW","\xB5W","nW","pW","fW","hp"],12:["Pa","PPa","TPa","GPa","MPa","kPa","hPa","daPa","dPa","cPa","mPa","\u03BCPa","\xB5Pa","nPa","pPa","fPa","bar","Pbar","Tbar","Gbar","Mbar","kbar","hbar","dabar","dbar","cbar","mbar","\u03BCbar","\xB5bar","nbar","pbar","fbar","Torr","mTorr","atm","psi","lbf/in2","lbf/in\xB2","inAq","Aq","inHg","Hg"],13:["K","PK","TK","GK","MK","kK","hK","daK","dK","cK","mK","\u03BCK","\xB5K","nK","pK","fK","F","\xB0F","C","\xB0C","R"],14:["s","Ps","Ts","Gs","Ms","ks","hs","das","ds","cs","ms","\u03BCs","\xB5s","ns","ps","fs","min","h","md","d","wk","fn","mo","a","y","yr","dec","TU","S"],15:["m\xB3","m3","Pm3","Pm\xB3","Tm3","Tm\xB3","Gm3","Gm\xB3","Mm3","Mm\xB3","km3","km\xB3","hm3","hm\xB3","dam3","dam\xB3","dm3","dm\xB3","cm3","cm\xB3","mm3","mm\xB3","\u03BCm3","\xB5m3","\u03BCm\xB3","\xB5m\xB3","nm3","nm\xB3","pm3","pm\xB3","fm3","fm\xB3","l","L","Pl","PL","Tl","TL","Gl","GL","Ml","ML","kl","kL","hl","hL","dal","daL","dl","dL","cl","cL","ml","mL","\u03BCl","\xB5l","\u03BCL","\xB5L","nl","nL","pl","pL","fl","fL","cu mi","mi3","mi\xB3","ac\u22C5ft","ac ft","cu yd","yd3","yd\xB3","cu ft","ft3","ft\xB3","cu in","in3","in\xB3","MTON","imp bbl","imp bsh","imp bu","pk","imp pk","imp gal","imp qt","imp pt","imp fl oz","tsp","tbsp","fl oz","fl. oz.","oz. fl.","c","US lc","pt","p","qt","gal","US bsh","US bu","US pk","US dry gal","US dry bbl","US dry qt","US dry pt"]},b={0:"angle",1:"area",2:"data",3:"energy",4:"force",5:"frequency",6:"illuminance",7:"length",8:"luminance",9:"luminousIntensity",10:"mass",11:"power",12:"pressure",13:"temperature",14:"time",15:"volume"};var f={mps:{measure:"speed",toBase:1},kph:{measure:"speed",toBase:.2777777777777778},mph:{measure:"speed",toBase:.44704},kn:{measure:"speed",toBase:.5144444444444445},ft_s:{measure:"speed",toBase:.3048},min_km:{measure:"pace",toBase:.06},min_mi:{measure:"pace",toBase:.03728227153424004},mV:{measure:"voltage",toBase:.001},kV:{measure:"voltage",toBase:1e3},mA:{measure:"current",toBase:.001},A:{measure:"current",toBase:1},kA:{measure:"current",toBase:1e3},VA:{measure:"apparentPower",toBase:1},kVA:{measure:"apparentPower",toBase:1e3},MVA:{measure:"apparentPower",toBase:1e6},kvar:{measure:"reactivePower",toBase:1e3},Mvar:{measure:"reactivePower",toBase:1e6},varh:{measure:"reactiveEnergy",toBase:1},kvarh:{measure:"reactiveEnergy",toBase:1e3},Mvarh:{measure:"reactiveEnergy",toBase:1e6},m3s:{measure:"volumeFlowRate",toBase:1},m3h:{measure:"volumeFlowRate",toBase:.0002777777777777778},lps:{measure:"volumeFlowRate",toBase:.001},lpm:{measure:"volumeFlowRate",toBase:16666666666666667e-21},gpm:{measure:"volumeFlowRate",toBase:630901964e-13},cfs:{measure:"volumeFlowRate",toBase:.028316846592},ppm:{measure:"partsPer",toBase:1e-6},ppb:{measure:"partsPer",toBase:1e-9},ppt:{measure:"partsPer",toBase:1e-12},permille:{measure:"partsPer",toBase:.001},mil:{measure:"length",toBase:254e-7},mils:{measure:"length",toBase:254e-7},hand:{measure:"length",toBase:.1016},hands:{measure:"length",toBase:.1016},rod:{measure:"length",toBase:5.0292},rods:{measure:"length",toBase:5.0292},chain:{measure:"length",toBase:20.1168},chains:{measure:"length",toBase:20.1168},furlong:{measure:"length",toBase:201.168},furlongs:{measure:"length",toBase:201.168},cable:{measure:"length",toBase:185.2},cables:{measure:"length",toBase:185.2},league:{measure:"length",toBase:4828.032},leagues:{measure:"length",toBase:4828.032},carat:{measure:"mass",toBase:.2},carats:{measure:"mass",toBase:.2},centner:{measure:"mass",toBase:1e5},centners:{measure:"mass",toBase:1e5}};exports.a=d;exports.b=u;exports.c=p;exports.d=h;exports.e=b;exports.f=f;//# sourceMappingURL=chunk-CIQOK7Q4.cjs.map
+//# sourceMappingURL=chunk-CIQOK7Q4.cjs.map

package/dist/chunk-CIQOK7Q4.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/uom/generated/UnitTable.generated.ts","../src/uom/ExtendedUnits.ts"],"names":["PACKED_UNIT_TABLE","unpackUnitTable","packed","table","record","firstBar","secondBar","kind","ratio","entry","alias","UNIT_TABLE","UNIT_DIFFERENCES","BEST_UNITS_METRIC","MEASURE_SYMBOLS","MEASURE_KIND_NAMES","EXTENDED_UNITS"],"mappings":"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","file":"chunk-CIQOK7Q4.cjs","sourcesContent":["/**\n * Unit conversion tables, ported from the `convert` npm package v7.0.2.\n *\n * DO NOT EDIT BY HAND. Regenerate with:\n *   node scripts/generate-unit-table.mjs\n *\n * Ported rather than depended on so the engine ships with no runtime\n * dependencies. See scripts/generate-unit-table.mjs for why the tables are\n * mirrored verbatim rather than hand-authored or recomputed from SI\n * definitions, and THIRD-PARTY-NOTICES.md for the upstream licence.\n *\n * Mirrored verbatim EXCEPT where upstream is arithmetically wrong. Those few\n * entries are marked \"corrected\" below and each one is justified in\n * UPSTREAM_UNIT_CORRECTIONS / UPSTREAM_BEST_UNIT_CORRECTIONS in the generator.\n * They are corrections of an upstream error, never a local preference.\n *\n * Upstream: https://github.com/citycide/convert (MIT, Copyright (c) Jonah Snider)\n */\n\n/** A unit's measure kind and its ratio to that measure's base unit. */\nexport type UnitEntry = readonly [kind: number, ratio: number];\n\n/**\n * Source for {@link UNIT_TABLE}, packed. Each `;`-separated record is\n * `kind|ratio|alias1,alias2,...`, so the 378 distinct `[kind, ratio]` pairs\n * spell each ratio once rather than once per alias. See {@link UNIT_TABLE}.\n *\n * Corrected vs upstream: \"dm2\", \"dm²\", \"square decimeter\", \"square decimeters\", \"square decimetre\", \"square decimetres\".\n */\nconst PACKED_UNIT_TABLE =\n  \"0|1|radian,radians,rad,rads,r;0|6.283185307179586|turn,turns;0|0.017453292519943295|degree,degrees,deg,degs,°;0|0.015707963267948967|gradian,gradians,gon,gons,grad,grads,grade,grades;0|0.0002908882086657216|arcminute,arcminutes,minutes of arc,arcmin,arcmins;0|0.00000484813681109536|arcsecond,arcseconds,seconds of arc,arcsec,arcsecs;1|1|square meter,square meters,square metre,square metres,m²,m2,centiare,centiares,ca;1|1e+30|square petameter,square petametre,square petameters,square petametres,Pm²,Pm2;1|1e+24|square terameter,square terametre,square terameters,square terametres,Tm²,Tm2;1|1000000000000000000|square gigameter,square gigametre,square gigameters,square gigametres,Gm²,Gm2;1|1000000000000|square megameter,square megametre,square megameters,square megametres,Mm²,Mm2;1|1000000|square kilometer,square kilometre,square kilometers,square kilometres,km²,km2;1|10000|square hectometer,square hectometre,square hectometers,square hectometres,hm²,hm2,hectare,hectares,ha;1|100|square decameter,square decametre,square decameters,square decametres,dam²,dam2,are,ares;1|0.01|square decimeter,square decimetre,square decimeters,square decimetres,dm²,dm2;1|0.0001|square centimeter,square centimetre,square centimeters,square centimetres,cm²,cm2;1|0.000001|square millimeter,square millimetre,square millimeters,square millimetres,mm²,mm2;1|1e-12|square micrometer,square micrometre,square micrometers,square micrometres,μm²,µm²,μm2,µm2;1|1e-18|square nanometer,square nanometre,square nanometers,square nanometres,nm²,nm2;1|1e-24|square picometer,square picometre,square picometers,square picometres,pm²,pm2;1|1e-30|square femtometer,square femtometre,square femtometers,square femtometres,fm²,fm2;1|4046.8564224|acre,acres,ac;1|10|deciare,deciares,da;1|1000|decare,decares,daa;1|0.09290304|square foot,square feet,sq ft,ft²,ft2;1|0.00064516|square inch,square inches,sq in,in²,in2;1|0.83612736|square yard,square yards,sq yd,yd²,yd2;1|2589988.110336|square mile,square miles,sq mi,mi²,mi2;1|666.6666666666666|mǔ,mu;2|1|bit,bits,b;2|1125899906842624|pebibit,pebibits,Pib;2|1099511627776|tebibit,tebibits,Tib;2|1073741824|gibibit,gibibits,Gib;2|1048576|mebibit,mebibits,Mib;2|1024|kibibit,kibibits,Kib;2|1000|Kb,kilobit,kilobits,kb;2|8000|KB,kilobyte,kilobytes,kB;2|1000000000000000|petabit,petabits,Pb;2|1000000000000|terabit,terabits,Tb;2|1000000000|gigabit,gigabits,Gb;2|1000000|megabit,megabits,Mb;2|100|hectobit,hectobits,hb;2|10|decabit,decabits,dab;2|0.1|decibit,decibits,db;2|0.01|centibit,centibits,cb;2|0.001|millibit,millibits,mb;2|0.000001|microbit,microbits,μb,µb;2|1e-9|nanobit,nanobits,nb;2|1e-12|picobit,picobits,pb;2|1e-15|femtobit,femtobits,fb;2|4|nibble,nibbles,semioctet,semioctets,halfbyte,halfbytes;2|8|byte,bytes,octect,octects,B;2|9007199254740992|pebibyte,pebibytes,PiB;2|8796093022208|tebibyte,tebibytes,TiB;2|8589934592|gibibyte,gibibytes,GiB;2|8388608|mebibyte,mebibytes,MiB;2|8192|kibibyte,kibibytes,KiB;2|8000000000000000|petabyte,petabytes,PB;2|8000000000000|terabyte,terabytes,TB;2|8000000000|gigabyte,gigabytes,GB;2|8000000|megabyte,megabytes,MB;2|800|hectobyte,hectobytes,hB;2|80|decabyte,decabytes,daB;2|0.8|decibyte,decibytes,dB;2|0.08|centibyte,centibytes,cB;2|0.008|millibyte,millibytes,mB;2|0.000008|microbyte,microbytes,μB,µB;2|8e-9|nanobyte,nanobytes,nB;2|8e-12|picobyte,picobytes,pB;2|8e-15|femtobyte,femtobytes,fB;2|16|hextet,hextets;3|1|joule,joules,J;3|1000000000000000|petajoule,petajoules,PJ;3|1000000000000|terajoule,terajoules,TJ;3|1000000000|gigajoule,gigajoules,GJ;3|1000000|megajoule,megajoules,MJ;3|1000|kilojoule,kilojoules,kJ;3|100|hectojoule,hectojoules,hJ;3|10|decajoule,decajoules,daJ;3|0.1|decijoule,decijoules,dJ;3|0.01|centijoule,centijoules,cJ;3|0.001|millijoule,millijoules,mJ;3|0.000001|microjoule,microjoules,μJ,µJ;3|1e-9|nanojoule,nanojoules,nJ;3|1e-12|picojoule,picojoules,pJ;3|1e-15|femtojoule,femtojoules,fJ;3|3600|watt-hour,W⋅h,W h,Wh;3|3600000000000000000|petawatt-hour,petawatt-hours,PW⋅h,PW h,PWh;3|3600000000000000|terawatt-hour,terawatt-hours,TW⋅h,TW h,TWh;3|3600000000000|gigawatt-hour,gigawatt-hours,GW⋅h,GW h,GWh;3|3600000000|megawatt-hour,megawatt-hours,MW⋅h,MW h,MWh;3|3600000|kilowatt-hour,kilowatt-hours,kW⋅h,kW h,kWh;3|360000|hectowatt-hour,hectowatt-hours,hW⋅h,hW h,hWh;3|36000|decawatt-hour,decawatt-hours,daW⋅h,daW h,daWh;3|360|deciwatt-hour,deciwatt-hours,dW⋅h,dW h,dWh;3|36|centiwatt-hour,centiwatt-hours,cW⋅h,cW h,cWh;3|3.6|milliwatt-hour,milliwatt-hours,mW⋅h,mW h,mWh;3|0.0036|microwatt-hour,microwatt-hours,μW⋅h,µW⋅h,μW h,µW h,μWh,µWh;3|0.0000036|nanowatt-hour,nanowatt-hours,nW⋅h,nW h,nWh;3|3.6e-9|picowatt-hour,picowatt-hours,pW⋅h,pW h,pWh;3|3.6e-12|femtowatt-hour,femtowatt-hours,fW⋅h,fW h,fWh;4|1|newton,newtons,N;4|1000000000000000|petanewton,petanewtons,PN;4|1000000000000|teranewton,teranewtons,TN;4|1000000000|giganewton,giganewtons,GN;4|1000000|meganewton,meganewtons,MN;4|1000|kilonewton,kilonewtons,kN;4|100|hectonewton,hectonewtons,hN;4|10|decanewton,decanewtons,daN;4|0.1|decinewton,decinewtons,dN;4|0.01|centinewton,centinewtons,cN;4|0.001|millinewton,millinewtons,mN;4|0.000001|micronewton,micronewtons,μN,µN;4|1e-9|nanonewton,nanonewtons,nN;4|1e-12|piconewton,piconewtons,pN;4|1e-15|femtonewton,femtonewtons,fN;4|0.00001|dyne,dynes,dyn;4|4.448222|pound of force,pound-force,lbf;4|4448.2216|kip,klb,kipf,klbf;4|0.138255|poundal,poundals,pdl;4|9.80665|kilogram-force,kilopond,kiloponds,kgf,kp;4|9806.65|tonne-force,metric ton-force,megagram-force,megapond,tf,Mp;5|1|hertz,Hz;5|1000000000000000|petahertz,PHz;5|1000000000000|terahertz,THz;5|1000000000|gigahertz,GHz;5|1000000|megahertz,MHz;5|1000|kilohertz,kHz;5|100|hectohertz,hHz;5|10|decahertz,daHz;5|0.1|decihertz,dHz;5|0.01|centihertz,cHz;5|0.001|millihertz,mHz;5|0.000001|microhertz,μHz,µHz;5|1e-9|nanohertz,nHz;5|1e-12|picohertz,pHz;5|1e-15|femtohertz,fHz;6|1|lux,lx,lumen per square meter,lm/m2,lm/m²;6|1000000000000000|petalux,Plx;6|1000000000000|teralux,Tlx;6|1000000000|gigalux,Glx;6|1000000|megalux,Mlx;6|1000|kilolux,klx;6|100|hectolux,hlx;6|10|decalux,dalx;6|0.1|decilux,dlx;6|0.01|centilux,clx;6|0.001|millilux,mlx;6|0.000001|microlux,μlx,µlx;6|1e-9|nanolux,nlx;6|1e-12|picolux,plx;6|1e-15|femtolux,flx;6|10.764|foot-candle,foot candle,fc,ft-c;6|10000|phot,ph;7|1|meter,meters,metre,metres,m;7|1000000000000000|petameter,petametre,petameters,petametres,Pm;7|1000000000000|terameter,terametre,terameters,terametres,Tm;7|1000000000|gigameter,gigametre,gigameters,gigametres,Gm;7|1000000|megameter,megametre,megameters,megametres,Mm;7|1000|kilometer,kilometre,kilometers,kilometres,km;7|100|hectometer,hectometre,hectometers,hectometres,hm;7|10|decameter,decametre,decameters,decametres,dam;7|0.1|decimeter,decimetre,decimeters,decimetres,dm;7|0.01|centimeter,centimetre,centimeters,centimetres,cm;7|0.001|millimeter,millimetre,millimeters,millimetres,mm;7|0.000001|micrometer,micrometre,micrometers,micrometres,μm,µm;7|1e-9|nanometer,nanometre,nanometers,nanometres,nm;7|1e-12|picometer,picometre,picometers,picometres,pm;7|1e-15|femtometer,femtometre,femtometers,femtometres,fm;7|0.3048|foot,feet,ft,';7|0.3048006096012192|US survey foot,US survey feet,U.S. survey foot,U.S. survey feet;7|0.0254|inch,inches,in,\\\";7|0.9144|yard,yards,yd;7|1609.344|mile,miles,mi;7|1852|nautical mile,nautical miles,M,NM,nmi;7|9460730472580800|light-year,light-years,ly;7|30856775814913670|parsec,parsecs,pc;7|0.0042333|pica,picas;7|0.0003528|point,points;8|1|candela per square meter,candelas per square meter,candela per square metre,candelas per square metre,cd/m2,cd/m²,nit,nits,nt;8|1000000000000000|petacandela per square meter,petacandelas per square meter,petacandela per square metre,petacandelas per square metre,Pcd/m2,Pcd/m²;8|1000000000000|teracandela per square meter,teracandelas per square meter,teracandela per square metre,teracandelas per square metre,Tcd/m2,Tcd/m²;8|1000000000|gigacandela per square meter,gigacandelas per square meter,gigacandela per square metre,gigacandelas per square metre,Gcd/m2,Gcd/m²;8|1000000|megacandela per square meter,megacandelas per square meter,megacandela per square metre,megacandelas per square metre,Mcd/m2,Mcd/m²;8|1000|kilocandela per square meter,kilocandelas per square meter,kilocandela per square metre,kilocandelas per square metre,kcd/m2,kcd/m²;8|100|hectocandela per square meter,hectocandelas per square meter,hectocandela per square metre,hectocandelas per square metre,hcd/m2,hcd/m²;8|10|decacandela per square meter,decacandelas per square meter,decacandela per square metre,decacandelas per square metre,dacd/m2,dacd/m²;8|0.1|decicandela per square meter,decicandelas per square meter,decicandela per square metre,decicandelas per square metre,dcd/m2,dcd/m²;8|0.01|centicandela per square meter,centicandelas per square meter,centicandela per square metre,centicandelas per square metre,ccd/m2,ccd/m²;8|0.001|millicandela per square meter,millicandelas per square meter,millicandela per square metre,millicandelas per square metre,mcd/m2,mcd/m²;8|0.000001|microcandela per square meter,microcandelas per square meter,microcandela per square metre,microcandelas per square metre,μcd/m2,µcd/m2,μcd/m²,µcd/m²;8|1e-9|nanocandela per square meter,nanocandelas per square meter,nanocandela per square metre,nanocandelas per square metre,ncd/m2,ncd/m²;8|1e-12|picocandela per square meter,picocandelas per square meter,picocandela per square metre,picocandelas per square metre,pcd/m2,pcd/m²;8|1e-15|femtocandela per square meter,femtocandelas per square meter,femtocandela per square metre,femtocandelas per square metre,fcd/m2,fcd/m²;9|1|candela,cd,candlepower,cp,CP;9|1000000000000000|petacandela,Pcd;9|1000000000000|teracandela,Tcd;9|1000000000|gigacandela,Gcd;9|1000000|megacandela,Mcd;9|1000|kilocandela,kcd;9|100|hectocandela,hcd;9|10|decacandela,dacd;9|0.1|decicandela,dcd;9|0.01|centicandela,ccd;9|0.001|millicandela,mcd;9|0.000001|microcandela,μcd,µcd;9|1e-9|nanocandela,ncd;9|1e-12|picocandela,pcd;9|1e-15|femtocandela,fcd;9|0.92|hefnerkerze,HK;10|1|gram,grams,g;10|1000000000000000|petagram,petagrams,Pg,gigatonne,gigatonnes,Gt;10|1000000000000|teragram,teragrams,Tg,megatonne,megatonnes,Mt;10|1000000000|gigagram,gigagrams,Gg,kilotonne,kilotonnes,kt;10|1000000|megagram,megagrams,Mg,tonne,tonnes,metric ton,metric tons,t;10|1000|kilogram,kilograms,kg;10|100|hectogram,hectograms,hg;10|10|decagram,decagrams,dag;10|0.1|decigram,decigrams,dg;10|0.01|centigram,centigrams,cg;10|0.001|milligram,milligrams,mg;10|0.000001|microgram,micrograms,μg,µg,mcg;10|1e-9|nanogram,nanograms,ng;10|1e-12|picogram,picograms,pg;10|1e-15|femtogram,femtograms,fg;10|453.59237|pound,pounds,lb,lbs;10|0.06479891|grain,grains,gr;10|6350.29318|stone,stones,st;10|28.349523125|ounce,ounces,oz;10|45360|short hundredweight,cental;10|50800|long hundredweight,imperial hundredweight,cwt;10|907184.74|short ton,short tons,US ton,US tons;10|1016046.9088|long ton,long tons,imperial ton,imperial tons,displacement ton,displacement tons;10|31.1034768|troy ounce,oz t,toz;11|1|watt,watts,W;11|1000000000000000|petawatt,petawatts,PW;11|1000000000000|terawatt,terawatts,TW;11|1000000000|gigawatt,gigawatts,GW;11|1000000|megawatt,megawatts,MW;11|1000|kilowatt,kilowatts,kW;11|100|hectowatt,hectowatts,hW;11|10|decawatt,decawatts,daW;11|0.1|deciwatt,deciwatts,dW;11|0.01|centiwatt,centiwatts,cW;11|0.001|milliwatt,milliwatts,mW;11|0.000001|microwatt,microwatts,μW,µW;11|1e-9|nanowatt,nanowatts,nW;11|1e-12|picowatt,picowatts,pW;11|1e-15|femtowatt,femtowatts,fW;11|745.699872|horsepower,mechanical horsepower,hp;12|1|pascal,pascals,Pa;12|1000000000000000|petapascal,petapascals,PPa;12|1000000000000|terapascal,terapascals,TPa;12|1000000000|gigapascal,gigapascals,GPa;12|1000000|megapascal,megapascals,MPa,decabar,decabars,dabar;12|1000|kilopascal,kilopascals,kPa,centibar,centibars,cbar;12|100|hectopascal,hectopascals,hPa,millibar,millibars,mbar;12|10|decapascal,decapascals,daPa;12|0.1|decipascal,decipascals,dPa,microbar,microbars,μbar,µbar;12|0.01|centipascal,centipascals,cPa;12|0.001|millipascal,millipascals,mPa;12|0.000001|micropascal,micropascals,μPa,µPa;12|1e-9|nanopascal,nanopascals,nPa;12|1e-12|picopascal,picopascals,pPa;12|1e-15|femtopascal,femtopascals,fPa;12|100000|bar,bars;12|100000000000000000000|petabar,petabars,Pbar;12|100000000000000000|terabar,terabars,Tbar;12|100000000000000|gigabar,gigabars,Gbar;12|100000000000|megabar,megabars,Mbar;12|100000000|kilobar,kilobars,kbar;12|10000000|hectobar,hectobars,hbar;12|10000|decibar,decibars,dbar;12|0.0001|nanobar,nanobars,nbar;12|1e-7|picobar,picobars,pbar;12|1e-10|femtobar,femtobars,fbar;12|133.32236842105263|torr,torrs,Torr;12|0.13332236842105263|millitorr,mTorr;12|101325|atmosphere,atmospheres,atm;12|6894.757|pound per square inch,pounds per square inch,psi,lbf/in2,lbf/in²;12|249.0889|inch of water,inches of water,inAq,Aq;12|3386.389|inch of mercury,inches of mercury,inHg,Hg;13|1|kelvin,kelvins,K,celsius,C,°C;13|1000000000000000|petakelvin,petakelvins,PK;13|1000000000000|terakelvin,terakelvins,TK;13|1000000000|gigakelvin,gigakelvins,GK;13|1000000|megakelvin,megakelvins,MK;13|1000|kilokelvin,kilokelvins,kK;13|100|hectokelvin,hectokelvins,hK;13|10|decakelvin,decakelvins,daK;13|0.1|decikelvin,decikelvins,dK;13|0.01|centikelvin,centikelvins,cK;13|0.001|millikelvin,millikelvins,mK;13|0.000001|microkelvin,microkelvins,μK,µK;13|1e-9|nanokelvin,nanokelvins,nK;13|1e-12|picokelvin,picokelvins,pK;13|1e-15|femtokelvin,femtokelvins,fK;13|0.5555555555555556|fahrenheit,F,°F,rankine,R;14|1|second,seconds,s;14|1000000000000000|petasecond,petaseconds,Ps;14|1000000000000|terasecond,teraseconds,Ts;14|1000000000|gigasecond,gigaseconds,Gs;14|1000000|megasecond,megaseconds,Ms;14|1000|kilosecond,kiloseconds,ks;14|100|hectosecond,hectoseconds,hs;14|10|decasecond,decaseconds,das;14|0.1|decisecond,deciseconds,ds;14|0.01|centisecond,centiseconds,cs;14|0.001|millisecond,milliseconds,ms;14|0.000001|microsecond,microseconds,μs,µs;14|1e-9|nanosecond,nanoseconds,ns;14|1e-12|picosecond,picoseconds,ps;14|1e-15|femtosecond,femtoseconds,fs;14|60|minute,minutes,min;14|3600|hour,hours,h;14|86.4|milliday,millidays,md;14|86400|day,days,d;14|604800|week,weeks,wk;14|1209600|fortnight,fortnights,fn;14|2592000|month,months,mo;14|31536000|year,years,a,y,yr;14|315360000|decade,decades,dec;14|3153600000|century,centuries;14|31536000000|millennium,millennia;14|90|moment,moments;14|1e-8|shake,shakes;14|0.001024|time unit,TU;14|1e-13|svedberg,svedbergs,S;15|1|cubic meter,cubic meters,cubic metre,cubic metres,stere,steres,m³,m3,kiloliter,kiloliters,kilolitre,kilolitres,kl,kL;15|1e+45|cubic petameter,cubic petameters,Pm3,Pm³;15|1e+36|cubic terameter,cubic terameters,Tm3,Tm³;15|1e+27|cubic gigameter,cubic gigameters,Gm3,Gm³;15|1000000000000000000|cubic megameter,cubic megameters,Mm3,Mm³;15|1000000000|cubic kilometer,cubic kilometers,km3,km³,teraliter,teraliters,teralitre,teralitres,Tl,TL;15|1000000|cubic hectometer,cubic hectometers,hm3,hm³,gigaliter,gigaliters,gigalitre,gigalitres,Gl,GL;15|1000|cubic decameter,cubic decameters,dam3,dam³,megaliter,megaliters,megalitre,megalitres,Ml,ML;15|0.001|cubic decimeter,cubic decimeters,dm3,dm³,liter,liters,litre,litres,l,L;15|0.000001|cubic centimeter,cubic centimeters,cm3,cm³,milliliter,milliliters,millilitre,millilitres,ml,mL;15|1e-9|cubic millimeter,cubic millimeters,mm3,mm³,microliter,microliters,microlitre,microlitres,μl,µl,μL,µL;15|1e-18|cubic micrometer,cubic micrometers,μm3,µm3,μm³,µm³,femtoliter,femtoliters,femtolitre,femtolitres,fl,fL;15|1e-27|cubic nanometer,cubic nanometers,nm3,nm³;15|1e-36|cubic picometer,cubic picometers,pm3,pm³;15|1e-45|cubic femtometer,cubic femtometers,fm3,fm³;15|1000000000000|petaliter,petaliters,petalitre,petalitres,Pl,PL;15|0.1|hectoliter,hectoliters,hectolitre,hectolitres,hl,hL;15|0.01|decaliter,decaliters,decalitre,decalitres,dal,daL;15|0.0001|deciliter,deciliters,decilitre,decilitres,dl,dL;15|0.00001|centiliter,centiliters,centilitre,centilitres,cl,cL;15|1e-12|nanoliter,nanoliters,nanolitre,nanolitres,nl,nL;15|1e-15|picoliter,picoliters,picolitre,picolitres,pl,pL;15|4168181825.4405794|cubic mile,cubic miles,cu mi,mi3,mi³;15|1233.48183754752|acre-foot,acre-feet,ac⋅ft,ac ft;15|0.764554857984|cubic yard,cubic yards,cu yd,yd3,yd³;15|0.028316846592|cubic foot,cubic feet,cu ft,ft3,ft³;15|0.002359737|board foot,board feet;15|0.000016387064|cubic inch,cubic inches,cu in,in3,in³;15|1.133|measurement ton,measurement tons,MTON;15|0.16365924|imperial barrel,imperial barrels,imp bbl;15|0.03636872|imperial bushel,imperial bushels,imp bsh,imp bu;15|0.00909218|imperial peck,imperial pecks,pk,imp pk;15|0.00454609|imperial gallon,imperial gallons,imp gal;15|0.0011365225|imperial quart,imperial quarts,imp qt;15|0.00056826125|imperial pint,imperial pints,imp pt;15|0.0000284130625|imperial fluid ounce,imperial fluid ounces,imp fl oz;15|0.00000492892159375|teaspoon,teaspoons,US teaspoon,US teaspoons,tsp;15|0.00001478676478125|tablespoon,tablespoons,US tablespoon,US tablespoons,tbsp;15|0.0000295735295625|US fluid ounce,US fluid ounces,fl oz,fl. oz.,oz. fl.;15|0.0002365882365|cup,cups,c;15|0.00024|US legal cup,US legal cups,US lc;15|0.000473176473|pint,pints,US liquid pint,US liquid pints,pt,p;15|0.000946352946|quart,quarts,US liquid quart,US liquid quarts,qt;15|0.003785411784|gallon,gallons,US liquid gallon,US liquid gallons,gal;15|0.03523907016688|US bushel,US bushels,US bsh,US bu;15|0.00880976754172|US peck,US pk;15|0.00440488377086|US dry gallon,US dry gal;15|0.1156|US dry barrel,US dry barrels,US dry bbl;15|0.001101220942715|US dry quart,US dry qt;15|0.0005506104713575|US dry pint,US dry pt\";\n\n/**\n * Decodes {@link PACKED_UNIT_TABLE} into the {@link UNIT_TABLE} record. The\n * aliases in one record share a single `[kind, ratio]` tuple, safe since the\n * table is read-only by type.\n */\nfunction unpackUnitTable(packed: string): Record<string, UnitEntry> {\n  const table: Record<string, UnitEntry> = {};\n  for (const record of packed.split(\";\")) {\n    const firstBar = record.indexOf(\"|\");\n    const secondBar = record.indexOf(\"|\", firstBar + 1);\n    const kind = Number(record.slice(0, firstBar));\n    const ratio = Number(record.slice(firstBar + 1, secondBar));\n    const entry: UnitEntry = [kind, ratio];\n    for (const alias of record.slice(secondBar + 1).split(\",\")) {\n      table[alias] = entry;\n    }\n  }\n  return table;\n}\n\n/**\n * Every unit spelling the engine can resolve, to `[measureKind, ratioToBase]`.\n *\n * Keys are case-sensitive and are never normalized or aliased: `C` is Celsius\n * and `c` is a cup, `MB` is megabytes and `mb` is millibits. Multi-word\n * spellings are present here and resolve through the conversion API even though\n * the lexer cannot tokenize them.\n *\n * Stored packed (see {@link PACKED_UNIT_TABLE}) and decoded once at load: 1456\n * spellings share 378 distinct pairs, so each ratio parses once per pair rather\n * than once per alias. The generator asserts the packed form decodes to exactly\n * the source table.\n */\nexport const UNIT_TABLE: Readonly<Record<string, UnitEntry>> = unpackUnitTable(PACKED_UNIT_TABLE);\n\n/**\n * Additive offsets applied around the ratio, for measures whose scales do not\n * share an origin. Temperature only.\n */\nexport const UNIT_DIFFERENCES: Readonly<Record<string, number>> = {\n  \"fahrenheit\": 459.67,\n  \"F\": 459.67,\n  \"°F\": 459.67,\n  \"celsius\": 273.15,\n  \"C\": 273.15,\n  \"°C\": 273.15,\n};\n\n/**\n * Ordered `[symbol, threshold]` pairs per measure kind, used to pick the most\n * readable unit for a magnitude. Thresholds are expressed in the list's FIRST\n * unit, which is therefore also its smallest, and the last entry whose\n * threshold the absolute value reaches wins.\n *\n * The two properties are load-bearing together: `convertToBestMetric` converts\n * the magnitude into the first unit and then walks forwards, breaking at the\n * first threshold it does not reach. A list that does not ascend runs off the\n * end of the sensible units rather than merely picking a poor one, and moving a\n * different unit to the front silently changes what every threshold means.\n *\n * Metric only. The imperial lists exist upstream but nothing here has ever\n * requested them, so they are not ported.\n */\nexport const BEST_UNITS_METRIC: Readonly<\n  Record<number, readonly (readonly [symbol: string, threshold: number])[]>\n> = {\n  0: [[\"deg\", 1]], // angle\n  1: [[\"mm2\", 1], [\"cm2\", 100], [\"m2\", 1000000], [\"km2\", 1000000000000]], // area\n  2: [[\"bits\", 1], [\"B\", 8], [\"KB\", 8000], [\"MB\", 8000000], [\"GB\", 8000000000], [\"TB\", 8000000000000], [\"PB\", 8000000000000000]], // data\n  3: [[\"J\", 1], [\"Wh\", 3600], [\"kWh\", 3600000], [\"MWh\", 3600000000], [\"GWh\", 3600000000000]], // energy\n  4: [[\"N\", 1]], // force\n  5: [[\"Hz\", 1], [\"kHz\", 1000], [\"MHz\", 1000000], [\"GHz\", 1000000000], [\"THz\", 1000000000000], [\"PHz\", 1000000000000000]], // frequency\n  6: [[\"lux\", 1], [\"klx\", 1000]], // illuminance, corrected\n  7: [[\"mm\", 1], [\"cm\", 10], [\"m\", 1000], [\"km\", 1000000]], // length\n  8: [[\"cd/m²\", 1]], // luminance\n  9: [[\"cd\", 1]], // luminousIntensity\n  10: [[\"mg\", 1], [\"g\", 1000], [\"kg\", 1000000]], // mass\n  11: [[\"W\", 1], [\"kW\", 1000], [\"MW\", 1000000], [\"GW\", 1000000000], [\"TW\", 1000000000000], [\"PW\", 1000000000000000]], // power\n  12: [[\"Pa\", 1]], // pressure\n  13: [[\"C\", 1]], // temperature\n  14: [[\"fs\", 1], [\"ps\", 1000], [\"ns\", 1000000], [\"µs\", 1000000000], [\"ms\", 1000000000000], [\"s\", 1000000000000000], [\"min\", 60000000000000000], [\"h\", 3600000000000000000], [\"d\", 86400000000000000000], [\"y\", 3.1536e+22]], // time\n  15: [[\"mL\", 1], [\"L\", 1000]], // volume\n};\n\n/**\n * The symbols offered for a measure by `<value> <unit> to ?`.\n *\n * A separate, curated vocabulary rather than the keys of UNIT_TABLE filtered by\n * kind: upstream publishes a shorter symbols-only list per unit, and the two\n * genuinely differ. Volume's symbols include `c`, `US lc` and `pt` but not\n * `cup`/`cups`; Time's include `wk` and `mo` but not `week`/`month`.\n * Deriving this from UNIT_TABLE would roughly quadruple every list.\n */\nexport const MEASURE_SYMBOLS: Readonly<Record<number, readonly string[]>> = {\n  0: [\"rad\", \"rads\", \"r\", \"deg\", \"degs\", \"°\", \"gon\", \"gons\", \"grad\", \"grads\", \"grade\", \"grades\", \"arcmin\", \"arcmins\", \"arcsec\", \"arcsecs\"], // angle\n  1: [\"m²\", \"m2\", \"Pm²\", \"Pm2\", \"Tm²\", \"Tm2\", \"Gm²\", \"Gm2\", \"Mm²\", \"Mm2\", \"km²\", \"km2\", \"hm²\", \"hm2\", \"dam²\", \"dam2\", \"dm²\", \"dm2\", \"cm²\", \"cm2\", \"mm²\", \"mm2\", \"μm²\", \"µm²\", \"μm2\", \"µm2\", \"nm²\", \"nm2\", \"pm²\", \"pm2\", \"fm²\", \"fm2\", \"ac\", \"ca\", \"da\", \"daa\", \"ha\", \"sq ft\", \"ft²\", \"ft2\", \"sq in\", \"in²\", \"in2\", \"sq yd\", \"yd²\", \"yd2\", \"sq mi\", \"mi²\", \"mi2\"], // area\n  2: [\"b\", \"Pib\", \"Tib\", \"Gib\", \"Mib\", \"Kib\", \"Kb\", \"KB\", \"Pb\", \"Tb\", \"Gb\", \"Mb\", \"kb\", \"hb\", \"dab\", \"db\", \"cb\", \"mb\", \"μb\", \"µb\", \"nb\", \"pb\", \"fb\", \"B\", \"PiB\", \"TiB\", \"GiB\", \"MiB\", \"KiB\", \"PB\", \"TB\", \"GB\", \"MB\", \"kB\", \"hB\", \"daB\", \"dB\", \"cB\", \"mB\", \"μB\", \"µB\", \"nB\", \"pB\", \"fB\"], // data\n  3: [\"J\", \"PJ\", \"TJ\", \"GJ\", \"MJ\", \"kJ\", \"hJ\", \"daJ\", \"dJ\", \"cJ\", \"mJ\", \"μJ\", \"µJ\", \"nJ\", \"pJ\", \"fJ\", \"W⋅h\", \"W h\", \"Wh\", \"PW⋅h\", \"PW h\", \"PWh\", \"TW⋅h\", \"TW h\", \"TWh\", \"GW⋅h\", \"GW h\", \"GWh\", \"MW⋅h\", \"MW h\", \"MWh\", \"kW⋅h\", \"kW h\", \"kWh\", \"hW⋅h\", \"hW h\", \"hWh\", \"daW⋅h\", \"daW h\", \"daWh\", \"dW⋅h\", \"dW h\", \"dWh\", \"cW⋅h\", \"cW h\", \"cWh\", \"mW⋅h\", \"mW h\", \"mWh\", \"μW⋅h\", \"µW⋅h\", \"μW h\", \"µW h\", \"μWh\", \"µWh\", \"nW⋅h\", \"nW h\", \"nWh\", \"pW⋅h\", \"pW h\", \"pWh\", \"fW⋅h\", \"fW h\", \"fWh\"], // energy\n  4: [\"N\", \"PN\", \"TN\", \"GN\", \"MN\", \"kN\", \"hN\", \"daN\", \"dN\", \"cN\", \"mN\", \"μN\", \"µN\", \"nN\", \"pN\", \"fN\", \"dyn\", \"lbf\", \"klb\", \"kipf\", \"klbf\", \"pdl\", \"kgf\", \"kp\", \"tf\", \"Mp\"], // force\n  5: [\"Hz\", \"PHz\", \"THz\", \"GHz\", \"MHz\", \"kHz\", \"hHz\", \"daHz\", \"dHz\", \"cHz\", \"mHz\", \"μHz\", \"µHz\", \"nHz\", \"pHz\", \"fHz\"], // frequency\n  6: [\"lx\", \"Plx\", \"Tlx\", \"Glx\", \"Mlx\", \"klx\", \"hlx\", \"dalx\", \"dlx\", \"clx\", \"mlx\", \"μlx\", \"µlx\", \"nlx\", \"plx\", \"flx\", \"lm/m2\", \"lm/m²\", \"fc\", \"ft-c\", \"ph\"], // illuminance\n  7: [\"m\", \"Pm\", \"Tm\", \"Gm\", \"Mm\", \"km\", \"hm\", \"dam\", \"dm\", \"cm\", \"mm\", \"μm\", \"µm\", \"nm\", \"pm\", \"fm\", \"ft\", \"'\", \"in\", \"\\\"\", \"yd\", \"mi\", \"M\", \"NM\", \"nmi\", \"ly\", \"pc\"], // length\n  8: [\"cd/m2\", \"cd/m²\", \"Pcd/m2\", \"Pcd/m²\", \"Tcd/m2\", \"Tcd/m²\", \"Gcd/m2\", \"Gcd/m²\", \"Mcd/m2\", \"Mcd/m²\", \"kcd/m2\", \"kcd/m²\", \"hcd/m2\", \"hcd/m²\", \"dacd/m2\", \"dacd/m²\", \"dcd/m2\", \"dcd/m²\", \"ccd/m2\", \"ccd/m²\", \"mcd/m2\", \"mcd/m²\", \"μcd/m2\", \"µcd/m2\", \"μcd/m²\", \"µcd/m²\", \"ncd/m2\", \"ncd/m²\", \"pcd/m2\", \"pcd/m²\", \"fcd/m2\", \"fcd/m²\", \"nt\"], // luminance\n  9: [\"cd\", \"Pcd\", \"Tcd\", \"Gcd\", \"Mcd\", \"kcd\", \"hcd\", \"dacd\", \"dcd\", \"ccd\", \"mcd\", \"μcd\", \"µcd\", \"ncd\", \"pcd\", \"fcd\", \"cp\", \"CP\", \"HK\"], // luminousIntensity\n  10: [\"g\", \"Pg\", \"Tg\", \"Gg\", \"Mg\", \"kg\", \"hg\", \"dag\", \"dg\", \"cg\", \"mg\", \"μg\", \"µg\", \"ng\", \"pg\", \"fg\", \"mcg\", \"t\", \"kt\", \"Mt\", \"Gt\", \"lb\", \"lbs\", \"gr\", \"st\", \"oz\", \"cwt\", \"oz t\", \"toz\"], // mass\n  11: [\"W\", \"PW\", \"TW\", \"GW\", \"MW\", \"kW\", \"hW\", \"daW\", \"dW\", \"cW\", \"mW\", \"μW\", \"µW\", \"nW\", \"pW\", \"fW\", \"hp\"], // power\n  12: [\"Pa\", \"PPa\", \"TPa\", \"GPa\", \"MPa\", \"kPa\", \"hPa\", \"daPa\", \"dPa\", \"cPa\", \"mPa\", \"μPa\", \"µPa\", \"nPa\", \"pPa\", \"fPa\", \"bar\", \"Pbar\", \"Tbar\", \"Gbar\", \"Mbar\", \"kbar\", \"hbar\", \"dabar\", \"dbar\", \"cbar\", \"mbar\", \"μbar\", \"µbar\", \"nbar\", \"pbar\", \"fbar\", \"Torr\", \"mTorr\", \"atm\", \"psi\", \"lbf/in2\", \"lbf/in²\", \"inAq\", \"Aq\", \"inHg\", \"Hg\"], // pressure\n  13: [\"K\", \"PK\", \"TK\", \"GK\", \"MK\", \"kK\", \"hK\", \"daK\", \"dK\", \"cK\", \"mK\", \"μK\", \"µK\", \"nK\", \"pK\", \"fK\", \"F\", \"°F\", \"C\", \"°C\", \"R\"], // temperature\n  14: [\"s\", \"Ps\", \"Ts\", \"Gs\", \"Ms\", \"ks\", \"hs\", \"das\", \"ds\", \"cs\", \"ms\", \"μs\", \"µs\", \"ns\", \"ps\", \"fs\", \"min\", \"h\", \"md\", \"d\", \"wk\", \"fn\", \"mo\", \"a\", \"y\", \"yr\", \"dec\", \"TU\", \"S\"], // time\n  15: [\"m³\", \"m3\", \"Pm3\", \"Pm³\", \"Tm3\", \"Tm³\", \"Gm3\", \"Gm³\", \"Mm3\", \"Mm³\", \"km3\", \"km³\", \"hm3\", \"hm³\", \"dam3\", \"dam³\", \"dm3\", \"dm³\", \"cm3\", \"cm³\", \"mm3\", \"mm³\", \"μm3\", \"µm3\", \"μm³\", \"µm³\", \"nm3\", \"nm³\", \"pm3\", \"pm³\", \"fm3\", \"fm³\", \"l\", \"L\", \"Pl\", \"PL\", \"Tl\", \"TL\", \"Gl\", \"GL\", \"Ml\", \"ML\", \"kl\", \"kL\", \"hl\", \"hL\", \"dal\", \"daL\", \"dl\", \"dL\", \"cl\", \"cL\", \"ml\", \"mL\", \"μl\", \"µl\", \"μL\", \"µL\", \"nl\", \"nL\", \"pl\", \"pL\", \"fl\", \"fL\", \"cu mi\", \"mi3\", \"mi³\", \"ac⋅ft\", \"ac ft\", \"cu yd\", \"yd3\", \"yd³\", \"cu ft\", \"ft3\", \"ft³\", \"cu in\", \"in3\", \"in³\", \"MTON\", \"imp bbl\", \"imp bsh\", \"imp bu\", \"pk\", \"imp pk\", \"imp gal\", \"imp qt\", \"imp pt\", \"imp fl oz\", \"tsp\", \"tbsp\", \"fl oz\", \"fl. oz.\", \"oz. fl.\", \"c\", \"US lc\", \"pt\", \"p\", \"qt\", \"gal\", \"US bsh\", \"US bu\", \"US pk\", \"US dry gal\", \"US dry bbl\", \"US dry qt\", \"US dry pt\"], // volume\n};\n\n/**\n * Measure kind id to the name `getMeasure()` reports. Two units are\n * convertible only when these strings match, so a typo here silently breaks\n * conversion for one whole measure.\n */\nexport const MEASURE_KIND_NAMES: Readonly<Record<number, string>> = {\n  0: \"angle\",\n  1: \"area\",\n  2: \"data\",\n  3: \"energy\",\n  4: \"force\",\n  5: \"frequency\",\n  6: \"illuminance\",\n  7: \"length\",\n  8: \"luminance\",\n  9: \"luminousIntensity\",\n  10: \"mass\",\n  11: \"power\",\n  12: \"pressure\",\n  13: \"temperature\",\n  14: \"time\",\n  15: \"volume\",\n};\n","/**\n * Extended unit categories not supported by the `convert` npm package (v7.0.0).\n *\n * `convert` only ships 16 measure kinds (Angle, Area, Data, Energy, Force,\n * Frequency, Illuminance, Length, Luminance, LuminousIntensity, Mass, Power,\n * Pressure, Temperature, Time, Volume. See MEASURE_KIND_NAMES in\n * UomConverter.ts). The project's own wiki documents several more\n * (Volume Flow Rate, Speed, Pace, Voltage, Current, Apparent Power,\n * Reactive Power, Reactive Energy, Parts-Per) that the library has no\n * concept of at all.\n *\n * A hand-rolled table is deliberately used instead of pulling in a bigger\n * unit-conversion library (e.g. js-quantities, convert-units, mathjs's unit\n * system): every category here is a pure linear ratio scale (no\n * Temperature-style offset formula needed), so the whole extension is a\n * `{ measure, toBase }` lookup plus a couple of arithmetic call sites in\n * UomConverter.ts. Pulling in a heavier dependency for ~30 extra unit\n * symbols would undo the earlier deliberate migration to `convert` for its\n * small size, and would reintroduce the aliasing/normalization behavior\n * this project explicitly moved away from (units here are case-sensitive,\n * no aliasing, matching UomConverter.ts's existing design).\n *\n * Unit symbols are restricted to what the lexer can tokenize as a single\n * UNIT token: `tokenizeIdentifier()` (ExpressionLexer.ts) only reads\n * `[a-zA-Z0-9_]` (plus Unicode), no `/`, no `-`. That rules out\n * slash-notation like \"km/h\" or \"min/km\" as literal unit text. Every\n * category below uses a plain-letters abbreviation where a standard one\n * exists (mph, kn, gpm, cfs, ...); Pace has no standard non-slash\n * abbreviation, so it uses an underscore instead (\"min_km\", \"min_mi\")\n * the one place in this table where that's necessary.\n */\n\nexport interface ExtendedUnitDef {\n  /** Category name, matching the style of UomConverter.ts's MEASURE_KIND_NAMES (lowerCamelCase). */\n  measure: string;\n  /** Multiply a value in this unit by this factor to get the value in the category's base unit. */\n  toBase: number;\n}\n\n/** Units beyond the base set, added to whatever the locale already recognises. */\nexport const EXTENDED_UNITS: Record<string, ExtendedUnitDef> = {\n  // ── Speed (base: mps, meters per second) ──────────────────────────────\n  mps: { measure: \"speed\", toBase: 1 },\n  kph: { measure: \"speed\", toBase: 1000 / 3600 },\n  mph: { measure: \"speed\", toBase: 0.44704 }, // 1 mile (1609.344m) / 3600s\n  kn: { measure: \"speed\", toBase: 1852 / 3600 }, // 1 nautical mile = 1852m exactly\n  // \"fps\" (feet per second) deliberately NOT used, confirmed via a real\n  // regression (20 failures in VideoTimecode.spec.ts) that it collides with\n  // the Time package's \"fps\" (frames per second), which FpsRateNormalizerRule\n  // requires to lex as a plain IDENT token. \"ft_s\" avoids the collision,\n  // following the same underscore convention as Pace below.\n  ft_s: { measure: \"speed\", toBase: 0.3048 }, // 1 ft = 0.3048m exactly\n\n  // ── Pace (base: seconds per meter, time/distance, the reciprocal of speed) ──\n  // Pace and Speed are deliberately separate measures: converting between them\n  // is a reciprocal (1/x) relationship, not a linear scale, so they can't share\n  // this table's plain factor-ratio conversion.\n  min_km: { measure: \"pace\", toBase: 60 / 1000 },\n  min_mi: { measure: \"pace\", toBase: 60 / 1609.344 },\n\n  // ── Voltage (base: V, expressed in mV/kV only) ─────────────────────────\n  // The bare symbol \"V\" is deliberately NOT registered, it collides with\n  // \"V\" the stock ticker (Visa) in packages/stocks/MajorTickers.ts, whose\n  // StockTickerNormalizerRule also requires an IDENT token (same class of\n  // issue as \"var\"/\"fps\" above; not currently test-covered since bare-ticker\n  // recognition is opt-in, but a real latent conflict). \"mV\"/\"kV\" don't\n  // collide with anything and cover the practically useful range.\n  mV: { measure: \"voltage\", toBase: 0.001 },\n  kV: { measure: \"voltage\", toBase: 1000 },\n\n  // ── Current (base: A) ───────────────────────────────────────────────\n  mA: { measure: \"current\", toBase: 0.001 },\n  A: { measure: \"current\", toBase: 1 },\n  kA: { measure: \"current\", toBase: 1000 },\n\n  // ── Apparent Power (base: VA), S = V × I, not real power ─────────────\n  VA: { measure: \"apparentPower\", toBase: 1 },\n  kVA: { measure: \"apparentPower\", toBase: 1000 },\n  MVA: { measure: \"apparentPower\", toBase: 1_000_000 },\n\n  // ── Reactive Power (base: var, expressed in kvar/Mvar only) ────────────\n  // The bare IEC symbol \"var\" is deliberately NOT registered as a unit\n  // confirmed via a real regression (ExpressionLexer.identifiers-keywords.spec.ts's\n  // \"$var\" test) that it collides with \"var\" as an extremely common variable\n  // name (and former JS keyword). \"kvar\"/\"Mvar\" don't collide with anything\n  // and cover the practically useful range.\n  kvar: { measure: \"reactivePower\", toBase: 1000 },\n  Mvar: { measure: \"reactivePower\", toBase: 1_000_000 },\n\n  // ── Reactive Energy (base: varh), IEC standard symbol \"varh\" ─────────\n  varh: { measure: \"reactiveEnergy\", toBase: 1 },\n  kvarh: { measure: \"reactiveEnergy\", toBase: 1000 },\n  Mvarh: { measure: \"reactiveEnergy\", toBase: 1_000_000 },\n\n  // ── Volume Flow Rate (base: m3s, cubic meters per second) ─────────────\n  m3s: { measure: \"volumeFlowRate\", toBase: 1 },\n  m3h: { measure: \"volumeFlowRate\", toBase: 1 / 3600 },\n  lps: { measure: \"volumeFlowRate\", toBase: 0.001 }, // 1 L/s = 0.001 m3/s\n  lpm: { measure: \"volumeFlowRate\", toBase: 0.001 / 60 },\n  gpm: { measure: \"volumeFlowRate\", toBase: 0.003785411784 / 60 }, // US gallon = 3.785411784 L exactly\n  cfs: { measure: \"volumeFlowRate\", toBase: 0.028316846592 }, // 1 ft3 = 0.028316846592 m3 exactly\n\n  // ── Parts-Per (base: dimensionless fraction, 1 = whole) ───────────────\n  // \"%\" is intentionally excluded, it's owned by the project's dedicated\n  // Percentage provider, not the UoM system.\n  ppm: { measure: \"partsPer\", toBase: 1e-6 },\n  ppb: { measure: \"partsPer\", toBase: 1e-9 },\n  ppt: { measure: \"partsPer\", toBase: 1e-12 }, // parts per trillion (chemistry/environmental convention)\n  permille: { measure: \"partsPer\", toBase: 1e-3 },\n  // ── Length, extending the base table rather than replacing it ─────────\n  //\n  // These share the `length` measure with the generated table, so they convert\n  // against metres and everything derived from them. Ratios are the exact\n  // international definitions, all of which are whole multiples of the inch\n  // (0.0254 m exactly) except the mil, which is a thousandth of one.\n  mil: { measure: \"length\", toBase: 0.0000254 },\n  mils: { measure: \"length\", toBase: 0.0000254 },\n  hand: { measure: \"length\", toBase: 0.1016 }, // 4 in\n  hands: { measure: \"length\", toBase: 0.1016 },\n  rod: { measure: \"length\", toBase: 5.0292 }, // 16.5 ft\n  rods: { measure: \"length\", toBase: 5.0292 },\n  chain: { measure: \"length\", toBase: 20.1168 }, // 66 ft, 4 rods\n  chains: { measure: \"length\", toBase: 20.1168 },\n  furlong: { measure: \"length\", toBase: 201.168 }, // 10 chains\n  furlongs: { measure: \"length\", toBase: 201.168 },\n  cable: { measure: \"length\", toBase: 185.2 }, // a tenth of a nautical mile\n  cables: { measure: \"length\", toBase: 185.2 },\n  league: { measure: \"length\", toBase: 4828.032 }, // 3 miles\n  leagues: { measure: \"length\", toBase: 4828.032 },\n\n  // ── Mass ──────────────────────────────────────────────────────────────\n  // The metric carat is exactly 200 mg by definition, not the older and\n  // variable gemstone carat, and not the karat that measures gold purity.\n  carat: { measure: \"mass\", toBase: 0.2 },\n  carats: { measure: \"mass\", toBase: 0.2 },\n  // The metric centner, 100 kg, as used across continental Europe. The\n  // Imperial hundredweight is a different quantity and is already `cwt`.\n  centner: { measure: \"mass\", toBase: 100000 },\n  centners: { measure: \"mass\", toBase: 100000 },\n\n};\n"]}

package/dist/chunk-E6Z4NQAS.js

@@ -0,0 +1,2 @@
+var A=(_=>(_[_.NOP=0]="NOP",_[_.HALT=1]="HALT",_[_.SWAP=2]="SWAP",_[_.DUP=3]="DUP",_[_.PUSH_NUMBER=10]="PUSH_NUMBER",_[_.PUSH_BIGINT=11]="PUSH_BIGINT",_[_.PUSH_HEX=12]="PUSH_HEX",_[_.PUSH_STRING=13]="PUSH_STRING",_[_.PUSH_BOOLEAN=14]="PUSH_BOOLEAN",_[_.PUSH_VARIABLE=15]="PUSH_VARIABLE",_[_.PUSH_DECIMAL=16]="PUSH_DECIMAL",_[_.ADD=20]="ADD",_[_.SUB=21]="SUB",_[_.MUL=22]="MUL",_[_.DIV=23]="DIV",_[_.MOD=24]="MOD",_[_.EXP=25]="EXP",_[_.NEG=26]="NEG",_[_.POS=27]="POS",_[_.MAKE_UNCERTAIN=28]="MAKE_UNCERTAIN",_[_.LSHIFT=30]="LSHIFT",_[_.RSHIFT=31]="RSHIFT",_[_.URSHIFT=32]="URSHIFT",_[_.BIT_AND=33]="BIT_AND",_[_.BIT_OR=34]="BIT_OR",_[_.BIT_XOR=35]="BIT_XOR",_[_.BIT_NOT=36]="BIT_NOT",_[_.EQ=40]="EQ",_[_.NEQ=41]="NEQ",_[_.LT=42]="LT",_[_.LTE=43]="LTE",_[_.GT=44]="GT",_[_.GTE=45]="GTE",_[_.CALL_PLUGIN=50]="CALL_PLUGIN",_[_.CALL_BUILTIN=51]="CALL_BUILTIN",_[_.RETURN=52]="RETURN",_[_.LOAD_VAR=60]="LOAD_VAR",_[_.STORE_VAR=61]="STORE_VAR",_[_.LOAD_GLOBAL_VAR=62]="LOAD_GLOBAL_VAR",_[_.STORE_GLOBAL_VAR=63]="STORE_GLOBAL_VAR",_[_.TO_NUMBER=70]="TO_NUMBER",_[_.TO_HEX=71]="TO_HEX",_[_.TO_PERCENTAGE=74]="TO_PERCENTAGE",_[_.UOM_CONVERT=80]="UOM_CONVERT",_[_.UOM_CONVERT_TO=81]="UOM_CONVERT_TO",_[_.UOM_GET_VALUE=82]="UOM_GET_VALUE",_[_.UOM_BEST=83]="UOM_BEST",_[_.UOM_CONVERT_IN=84]="UOM_CONVERT_IN",_[_.UOM_POSSIBILITIES=85]="UOM_POSSIBILITIES",_[_.DATE_NOW=90]="DATE_NOW",_[_.DATE_ADD=91]="DATE_ADD",_[_.DATE_SUB=92]="DATE_SUB",_[_.DATE_NEXT_WEEKDAY=93]="DATE_NEXT_WEEKDAY",_[_.DATE_LAST_WEEKDAY=94]="DATE_LAST_WEEKDAY",_[_.DATE_LITERAL=95]="DATE_LITERAL",_[_.DATE_WORKDAY_OFFSET=96]="DATE_WORKDAY_OFFSET",_[_.DATE_WORKDAYS_BETWEEN=97]="DATE_WORKDAYS_BETWEEN",_[_.RATE_DIV=110]="RATE_DIV",_[_.RATE_MUL=111]="RATE_MUL",_[_.RATE_CONVERT=112]="RATE_CONVERT",_[_.CLOCK_TIME_TODAY=120]="CLOCK_TIME_TODAY",_[_.LOGICAL_AND=130]="LOGICAL_AND",_[_.LOGICAL_OR=131]="LOGICAL_OR",_[_.SELECT=132]="SELECT",_[_.TO_FRACTION=140]="TO_FRACTION",_[_.TO_MULTIPLIER=141]="TO_MULTIPLIER",_[_.TO_SCI=142]="TO_SCI",_[_.TO_BINARY=143]="TO_BINARY",_[_.TO_OCTAL=144]="TO_OCTAL",_[_.CALL_AS_CONVERTER=145]="CALL_AS_CONVERTER",_[_.DEFINE_USER_FUNCTION=150]="DEFINE_USER_FUNCTION",_[_.CALL_USER_FUNCTION=151]="CALL_USER_FUNCTION",_[_.MAT_NEW=152]="MAT_NEW",_[_.MAT_INDEX1=153]="MAT_INDEX1",_[_.MAT_INDEX2=154]="MAT_INDEX2",_[_.MAT_SLICE=155]="MAT_SLICE",_[_.RANGE_NEW=156]="RANGE_NEW",_[_.MAP_INVOKE=157]="MAP_INVOKE",_[_.REDUCE_INVOKE=158]="REDUCE_INVOKE",_[_.BIND_UNKNOWN=159]="BIND_UNKNOWN",_))(A||{}),I=(()=>{let E=new Map;for(let[N,T]of Object.entries(A))typeof T=="number"&&E.set(T,N);return E})();function L(E){return I.get(E)??`UNKNOWN_${E}`}export{A as a,L as b};//# sourceMappingURL=chunk-E6Z4NQAS.js.map
+//# sourceMappingURL=chunk-E6Z4NQAS.js.map

package/dist/chunk-E6Z4NQAS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/parser/OpCode.ts"],"names":["OpCode","OP_CODE_NAMES","map","key","value","getOpCodeName","op"],"mappings":"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","file":"chunk-E6Z4NQAS.js","sourcesContent":["/**\n * The VM's bytecode instruction set.\n *\n * Emitted by parselets (via {@link BytecodeBuilder}) during parsing and\n * consumed by the VM's dispatch loop during execution. Values are grouped\n * into numeric bands by category (0-9 stack ops, 10-19 push-literal, 20-29\n * arithmetic, ...) purely for readability, the VM dispatches on the exact\n * numeric value, not the band.\n *\n * Third-party packages emit `CALL_PLUGIN` (with a plugin-function index\n * from {@link allocatePluginFunctionIndex}) to invoke their own logic\n * see `IEnginePackage.pluginFunctions`. The other opcodes are used\n * internally by the built-in packages' parselets.\n */\nexport enum OpCode {\n\t// Stack operations\n\tNOP = 0,\n\tHALT = 1,\n\tSWAP = 2,\n\tDUP = 3,\n\n\t// Push literals\n\tPUSH_NUMBER = 10,\n\tPUSH_BIGINT = 11,\n\tPUSH_HEX = 12,\n\tPUSH_STRING = 13,\n\tPUSH_BOOLEAN = 14,\n\tPUSH_VARIABLE = 15,\n\t// A decimal-point literal, pushed with the exact base-ten value it was\n\t// written as alongside the nearest double. The operand is a string-pool\n\t// index holding the normalized \".\" decimal text (thousands grouping already\n\t// stripped), read back into a Number-typed Value whose `exact` sidecar makes\n\t// money that combines with it exact. See vm/Value.ts's numberValueExact().\n\tPUSH_DECIMAL = 16,\n\n\t// Arithmetic (BinaryOperator)\n\tADD = 20,\n\tSUB = 21,\n\tMUL = 22,\n\tDIV = 23,\n\tMOD = 24,\n\tEXP = 25,\n\tNEG = 26,\n\tPOS = 27,\n\t// `a ± b` (or the ASCII `a +/- b`): pops the spread then the center off the\n\t// stack and pushes a Number carrying a one-sigma uncertainty (`vm/Value.ts`'s\n\t// numberValueUncertain). Takes no operand byte, like the other arithmetic\n\t// ops. See packages/uncertainty/ for the parselet that emits it and\n\t// vm/VMConversion.ts's uncertainOp for how the four arithmetic ops propagate.\n\tMAKE_UNCERTAIN = 28,\n\n\t// Bitwise\n\tLSHIFT = 30,\n\tRSHIFT = 31,\n\tURSHIFT = 32,\n\tBIT_AND = 33,\n\tBIT_OR = 34,\n\tBIT_XOR = 35,\n\tBIT_NOT = 36,\n\n\t// Comparison\n\tEQ = 40,\n\tNEQ = 41,\n\tLT = 42,\n\tLTE = 43,\n\tGT = 44,\n\tGTE = 45,\n\n\t// Functions\n\tCALL_PLUGIN = 50,     // Plugin-registered functions (may be async — pre-resolved by orchestrator)\n\tCALL_BUILTIN = 51,    // Sync built-in functions (sqrt, sin, diceRoll, matmul)\n\tRETURN = 52,          // Reserved for future user-defined functions\n\n\t// Variables\n\tLOAD_VAR = 60,\n\tSTORE_VAR = 61,\n\tLOAD_GLOBAL_VAR = 62,   // Reads from the process-wide GlobalVariableStore, not the VM's local scope\n\tSTORE_GLOBAL_VAR = 63,  // Writes to the process-wide GlobalVariableStore, visible to every document\n\n\t// Type conversion\n\tTO_NUMBER = 70,\n\tTO_HEX = 71,\n\tTO_PERCENTAGE = 74,\n\n\t// UoM\n\tUOM_CONVERT = 80,\n\tUOM_CONVERT_TO = 81,\n\tUOM_GET_VALUE = 82,\n\tUOM_BEST = 83,\n\tUOM_CONVERT_IN = 84,\n\tUOM_POSSIBILITIES = 85,  // \"sourceUnit to ?\" — list units convertible from sourceUnit\n\n\t// Datetime\n\tDATE_NOW = 90,\n\tDATE_ADD = 91,\n\tDATE_SUB = 92,\n\tDATE_NEXT_WEEKDAY = 93,  // \"next <Weekday>\" — the next occurrence strictly after now\n\tDATE_LAST_WEEKDAY = 94,  // \"last <Weekday>\" — the previous occurrence strictly before now\n\tDATE_LITERAL = 95,       // Push a datetime literal whose epoch-ms was already resolved at parse time (see DateLiteralParselet)\n\tDATE_WORKDAY_OFFSET = 96,   // \"N working days after/before/from <date>\" — a business-day walk from the anchor date. One operand byte: 0 forward, 1 backward. Same walk as `<date> + N workdays` (vm/VM.ts's addBusinessDays). See WorkdayOffsetParselet.\n\tDATE_WORKDAYS_BETWEEN = 97, // \"working days between <date> and <date>\" — the count of working days in the inclusive span. See WorkdaysBetweenParselet and vm/BusinessDays.ts's countBusinessDaysBetween.\n\n\t// Rate, \"quantity per unit of something\" ($99/week, 30 fps). See\n\t// vm/Value.ts's rateValue()/isRateUnit()/splitRateUnit() for the\n\t// representation these opcodes operate on.\n\tRATE_DIV = 110,      // Uom ÷ Uom (different measures) -> Rate — the construction op\n\tRATE_MUL = 111,      // Rate × Uom (same measure as denominator) -> plain Uom (denominator cancels)\n\tRATE_CONVERT = 112,  // Rate -> Rate with a rescaled denominator unit (keeps the same real-world rate)\n\n\t// Time, clock-time-of-day, lap times, video timecode (distinct from\n\t// the Datetime band's calendar-date arithmetic).\n\tCLOCK_TIME_TODAY = 120,  // minutes-since-midnight -> Datetime anchored to today's calendar date\n\n\t// Conditionals, boolean logic and eager-evaluated ternary selection.\n\t// EQ/NEQ/LT/LTE/GT/GTE (40-45, above) already existed as dead opcodes\n\t// before this band was wired up; see vm/VM.ts for their handlers.\n\tLOGICAL_AND = 130,  // Boolean && Boolean -> Boolean\n\tLOGICAL_OR = 131,   // Boolean || Boolean -> Boolean\n\tSELECT = 132,       // (thenVal, elseVal, condition) -> thenVal if condition else elseVal — EAGER (both\n\t                    // branches already evaluated by the time this runs; no real branching/short-circuit,\n\t                    // a deliberate simplification for a side-effect-free expression language, see\n\t                    // packages/conditionals/parselets/IfThenElseParselet.ts)\n\n\t// Converters, the general \"as <type>\" mechanism. TO_NUMBER/TO_HEX/\n\t// TO_PERCENTAGE (70/71/74, above) cover the simplest cases; these cover\n\t// the ones with no existing opcode. CALL_AS_CONVERTER is the SDK\n\t// extension point. See IEnginePackage.asConverters and\n\t// vm/VMBuiltins.ts's asConverterRegistry.\n\tTO_FRACTION = 140,       // Number -> String, simplified fraction (\"0.5\" -> \"1/2\")\n\tTO_MULTIPLIER = 141,     // Number -> String, \"1 + n\" growth multiplier (\"0.5\" -> \"1.5x\")\n\tTO_SCI = 142,            // Number -> String, scientific notation (\"1500000\" -> \"1.5e+6\")\n\tTO_BINARY = 143,         // Number -> String, base-2 display (\"10\" -> \"0b1010\")\n\tTO_OCTAL = 144,          // Number -> String, base-8 display (\"10\" -> \"0o12\")\n\tCALL_AS_CONVERTER = 145, // (value, name) -> runtime asConverterRegistry lookup + call\n\n\t// User-defined, parameterized, reusable functions (f(x) = expr, then\n\t// f(5). See parser/PrecedenceParser.ts's IDENT_ID case\n\t// parser/BytecodeBuilder.ts's UserFunctionDef/emitUserFunctionBody, and\n\t// vm/VM.ts's VM.userFunctions/callFrames). Parameter references inside a\n\t// function body are ORDINARY LOAD_VAR opcodes, not a dedicated\n\t// parameter-load opcode, CALL_USER_FUNCTION binds arguments into a\n\t// name-keyed call frame at runtime, and LOAD_VAR checks the innermost\n\t// call frame before the flat variable store (see VM.getVar()).\n\tDEFINE_USER_FUNCTION = 150, // (operand = index into bytecode.userFunctionBodies) -> register name/params/program into vm.userFunctions. Registration happens at VM-EXECUTION time, not parse time, so a diagnostic/lookahead parse that compiles but never executes a definition line has no side effect on the shared registry.\n\tCALL_USER_FUNCTION = 151,   // (N arg values already on stack) -> pop N args, bind by NAME into a new call frame, execute the named function's stored body (reentrant executeBytecode), push its result\n\n\t// Matrix (Calca-parity, replaces the old ARR_* vector-only opcodes\n\t// which were never emitted by any registered parselet; see\n\t// vm/MatrixOps.ts for the shared column-major storage helpers this band\n\t// operates on, and vm/Value.ts's MatrixData for the representation).\n\tMAT_NEW = 152,      // (rows, cols operands; rows*cols values already on stack, ROW-MAJOR push order) -> pop rows*cols values, transpose to column-major, push a Matrix\n\tMAT_INDEX1 = 153,   // (matrix, index already on stack) -> column-major single-index read `a[i]`\n\tMAT_INDEX2 = 154,   // (matrix, row, col already on stack) -> `a[row, col]` read\n\tMAT_SLICE = 155,    // (matrix, rowRange, colRange already on stack) -> sub-matrix via two Range values\n\tRANGE_NEW = 156,    // (min, max already on stack) -> push a Range value `min:max`\n\tMAP_INVOKE = 157,   // map(...) — see parser/BytecodeBuilder.ts's `anonymousBodies` side-table\n\tREDUCE_INVOKE = 158, // reduce(...) — same anonymousBodies mechanism as MAP_INVOKE\n\t// An algebra verb's expression argument, evaluated with the verb's own\n\t// named unknown bound to itself (`der(x^2, x)` reads `x` as the unknown\n\t// even where the document also has a value for it). Operand = an index\n\t// into `anonymousBodies`, whose `params[0]` carries the name to bind, the\n\t// same side-table and the same call-frame shadowing MAP_INVOKE uses for a\n\t// transform body's parameters. See vm/VM.ts's handler.\n\tBIND_UNKNOWN = 159,\n\t// 159 and 160 were THEREFORE_SOLVE and STORE_EQUATION_OR_ASSIGNMENT, declared\n\t// but never emitted by any parselet nor handled in the VM switch. Both shapes\n\t// have effects (a stored equation, a direct vm.setVar()) that a cached\n\t// bytecode program cannot represent, so engine/ExpressionEngine.ts intercepts\n\t// them before compilation and always will. 159 has since been reused above;\n\t// 160 is still free.\n}\n\n// Reverse lookup built once at module load, getOpCodeName() is called once\n// per VM instruction whenever a diagnostic collector is attached (VM.ts's\n// trace path), so a per-call linear scan of every enum entry (TS numeric\n// enums are bidirectional at runtime, so Object.entries(OpCode) yields both\n// \"NOP\" -> 0 and \"0\" -> \"NOP\" style entries) would otherwise redo the same\n// scan every single traced instruction. Only the numeric-valued entries are\n// kept, the string-valued reverse entries TS also generates aren't needed\n// here.\nconst OP_CODE_NAMES: ReadonlyMap<number, string> = (() => {\n\tconst map = new Map<number, string>();\n\tfor (const [key, value] of Object.entries(OpCode)) {\n\t\tif (typeof value === \"number\") map.set(value, key);\n\t}\n\treturn map;\n})();\n\n/**\n * Gets the name of an OpCode as a string.\n * @param op The OpCode value\n * @returns The enum name as a string, or \"UNKNOWN_<value>\" if not found\n */\nexport function getOpCodeName(op: number): string {\n\treturn OP_CODE_NAMES.get(op) ?? `UNKNOWN_${op}`;\n}\n"]}

package/dist/chunk-EFJCC6FJ.cjs

@@ -0,0 +1,2 @@
+'use strict';function r(n){let e=5381;for(let t=0;t<n.length;t++)e=(e<<5)+e+n.charCodeAt(t)|0;return e>>>0}exports.a=r;//# sourceMappingURL=chunk-EFJCC6FJ.cjs.map
+//# sourceMappingURL=chunk-EFJCC6FJ.cjs.map

package/dist/chunk-EFJCC6FJ.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utilities/Hash.ts"],"names":["djb2Hash","str","hash","i"],"mappings":"aAYO,SAASA,CAAAA,CAASC,CAAAA,CAAqB,CAC7C,IAAIC,CAAAA,CAAO,KACX,IAAA,IAASC,CAAAA,CAAI,CAAA,CAAGA,CAAAA,CAAIF,CAAAA,CAAI,MAAA,CAAQE,IAC/BD,CAAAA,CAAAA,CAASA,CAAAA,EAAQ,CAAA,EAAKA,CAAAA,CAAOD,CAAAA,CAAI,UAAA,CAAWE,CAAC,CAAA,CAAK,CAAA,CAEnD,OAAOD,CAAAA,GAAS,CACjB","file":"chunk-EFJCC6FJ.cjs","sourcesContent":["/**\n * Fast, non-cryptographic string hashing utilities.\n *\n * djb2 is chosen for its speed, simplicity, and excellent distribution\n * for short strings (typical line lengths in markdown documents).\n * It produces a 32-bit unsigned integer hash.\n */\n\n/**\n * djb2 string hash, fast, simple, good distribution.\n * Used for O(1) line text change detection in DocumentModel.\n */\nexport function djb2Hash(str: string): number {\n\tlet hash = 5381;\n\tfor (let i = 0; i < str.length; i++) {\n\t\thash = ((hash << 5) + hash + str.charCodeAt(i)) | 0;\n\t}\n\treturn hash >>> 0; // unsigned 32-bit\n}\n"]}

package/dist/chunk-ESUN2THE.cjs

@@ -0,0 +1,2 @@
+'use strict';var w={aliceblue:[240,248,255],antiquewhite:[250,235,215],aqua:[0,255,255],aquamarine:[127,255,212],azure:[240,255,255],beige:[245,245,220],bisque:[255,228,196],black:[0,0,0],blanchedalmond:[255,235,205],blue:[0,0,255],blueviolet:[138,43,226],brown:[165,42,42],burlywood:[222,184,135],cadetblue:[95,158,160],chartreuse:[127,255,0],chocolate:[210,105,30],coral:[255,127,80],cornflowerblue:[100,149,237],cornsilk:[255,248,220],crimson:[220,20,60],cyan:[0,255,255],darkblue:[0,0,139],darkcyan:[0,139,139],darkgoldenrod:[184,134,11],darkgray:[169,169,169],darkgreen:[0,100,0],darkgrey:[169,169,169],darkkhaki:[189,183,107],darkmagenta:[139,0,139],darkolivegreen:[85,107,47],darkorange:[255,140,0],darkorchid:[153,50,204],darkred:[139,0,0],darksalmon:[233,150,122],darkseagreen:[143,188,143],darkslateblue:[72,61,139],darkslategray:[47,79,79],darkslategrey:[47,79,79],darkturquoise:[0,206,209],darkviolet:[148,0,211],deeppink:[255,20,147],deepskyblue:[0,191,255],dimgray:[105,105,105],dimgrey:[105,105,105],dodgerblue:[30,144,255],firebrick:[178,34,34],floralwhite:[255,250,240],forestgreen:[34,139,34],fuchsia:[255,0,255],gainsboro:[220,220,220],ghostwhite:[248,248,255],gold:[255,215,0],goldenrod:[218,165,32],gray:[128,128,128],green:[0,128,0],greenyellow:[173,255,47],grey:[128,128,128],honeydew:[240,255,240],hotpink:[255,105,180],indianred:[205,92,92],indigo:[75,0,130],ivory:[255,255,240],khaki:[240,230,140],lavender:[230,230,250],lavenderblush:[255,240,245],lawngreen:[124,252,0],lemonchiffon:[255,250,205],lightblue:[173,216,230],lightcoral:[240,128,128],lightcyan:[224,255,255],lightgoldenrodyellow:[250,250,210],lightgray:[211,211,211],lightgreen:[144,238,144],lightgrey:[211,211,211],lightpink:[255,182,193],lightsalmon:[255,160,122],lightseagreen:[32,178,170],lightskyblue:[135,206,250],lightslategray:[119,136,153],lightslategrey:[119,136,153],lightsteelblue:[176,196,222],lightyellow:[255,255,224],lime:[0,255,0],limegreen:[50,205,50],linen:[250,240,230],magenta:[255,0,255],maroon:[128,0,0],mediumaquamarine:[102,205,170],mediumblue:[0,0,205],mediumorchid:[186,85,211],mediumpurple:[147,112,219],mediumseagreen:[60,179,113],mediumslateblue:[123,104,238],mediumspringgreen:[0,250,154],mediumturquoise:[72,209,204],mediumvioletred:[199,21,133],midnightblue:[25,25,112],mintcream:[245,255,250],mistyrose:[255,228,225],moccasin:[255,228,181],navajowhite:[255,222,173],navy:[0,0,128],oldlace:[253,245,230],olive:[128,128,0],olivedrab:[107,142,35],orange:[255,165,0],orangered:[255,69,0],orchid:[218,112,214],palegoldenrod:[238,232,170],palegreen:[152,251,152],paleturquoise:[175,238,238],palevioletred:[219,112,147],papayawhip:[255,239,213],peachpuff:[255,218,185],peru:[205,133,63],pink:[255,192,203],plum:[221,160,221],powderblue:[176,224,230],purple:[128,0,128],rebeccapurple:[102,51,153],red:[255,0,0],rosybrown:[188,143,143],royalblue:[65,105,225],saddlebrown:[139,69,19],salmon:[250,128,114],sandybrown:[244,164,96],seagreen:[46,139,87],seashell:[255,245,238],sienna:[160,82,45],silver:[192,192,192],skyblue:[135,206,235],slateblue:[106,90,205],slategray:[112,128,144],slategrey:[112,128,144],snow:[255,250,250],springgreen:[0,255,127],steelblue:[70,130,180],tan:[210,180,140],teal:[0,128,128],thistle:[216,191,216],tomato:[255,99,71],turquoise:[64,224,208],violet:[238,130,238],wheat:[245,222,179],white:[255,255,255],whitesmoke:[245,245,245],yellow:[255,255,0],yellowgreen:[154,205,50]};function s(r){return Math.min(255,Math.max(0,Math.round(r)))}function b(r){return Math.min(1,Math.max(0,r))}function h(r){return s(r).toString(16).padStart(2,"0")}function v(r){return String(Number(r.toFixed(3)))}function S(r){let e=r.startsWith("#")?r.slice(1):r;if(!/^[0-9a-fA-F]+$/.test(e))return null;let t=a=>parseInt(a+a,16),n=a=>parseInt(a,16);switch(e.length){case 3:return {r:t(e[0]),g:t(e[1]),b:t(e[2]),a:1,format:"hex"};case 4:return {r:t(e[0]),g:t(e[1]),b:t(e[2]),a:t(e[3])/255,format:"hex"};case 6:return {r:n(e.slice(0,2)),g:n(e.slice(2,4)),b:n(e.slice(4,6)),a:1,format:"hex"};case 8:return {r:n(e.slice(0,2)),g:n(e.slice(2,4)),b:n(e.slice(4,6)),a:n(e.slice(6,8))/255,format:"hex"};default:return null}}function q(r){let e=r.trim().toLowerCase();if(e==="transparent")return {r:0,g:0,b:0,a:0,format:"named",name:"transparent"};let t=w[e];return t?{r:t[0],g:t[1],b:t[2],a:1,format:"named",name:e}:null}function _(r){let e=r.trim();if(e.startsWith("#")||/^[0-9a-fA-F]{3,8}$/.test(e)){let t=S(e);if(t)return t}return q(e)}function p(r,e,t){let n=r/255,a=e/255,u=t/255,l=Math.max(n,a,u),o=Math.min(n,a,u),i=(l+o)/2;if(l===o)return {h:0,s:0,l:i};let m=l-o,L=i>.5?m/(2-l-o):m/(l+o),c;return l===n?c=(a-u)/m+(a<u?6:0):l===a?c=(u-n)/m+2:c=(n-a)/m+4,{h:c*60,s:L,l:i}}function M(r,e,t){if(e===0){let o=s(t*255);return {r:o,g:o,b:o}}let n=t<.5?t*(1+e):t+e-t*e,a=2*t-n,u=(r%360+360)%360/360,l=o=>{let i=o;return i<0&&(i+=1),i>1&&(i-=1),i<1/6?a+(n-a)*6*i:i<1/2?n:i<2/3?a+(n-a)*(2/3-i)*6:a};return {r:s(l(u+1/3)*255),g:s(l(u)*255),b:s(l(u-1/3)*255)}}function A(r){let e=`#${h(r.r)}${h(r.g)}${h(r.b)}`;return r.a<1?`${e}${h(r.a*255)}`:e}function E(r){switch(r.format){case "rgb":return `rgb(${r.r}, ${r.g}, ${r.b})`;case "rgba":return `rgba(${r.r}, ${r.g}, ${r.b}, ${v(r.a)})`;case "hsl":{let{h:e,s:t,l:n}=p(r.r,r.g,r.b);return `hsl(${Math.round(e)}, ${Math.round(t*100)}%, ${Math.round(n*100)}%)`}case "hsla":{let{h:e,s:t,l:n}=p(r.r,r.g,r.b);return `hsla(${Math.round(e)}, ${Math.round(t*100)}%, ${Math.round(n*100)}%, ${v(r.a)})`}case "named":return r.name??A(r);default:return A(r)}}function d(r){let e=r/255;return e<=.03928?e/12.92:Math.pow((e+.055)/1.055,2.4)}function $(r){return .2126*d(r.r)+.7152*d(r.g)+.0722*d(r.b)}function C(r,e){let t=$(r)+.05,n=$(e)+.05;return t>n?t/n:n/t}function D(r,e){let t=r.format==="named"?"hex":r.format;return {r:e.r??r.r,g:e.g??r.g,b:e.b??r.b,a:e.a??r.a,format:t}}function g(r,e){let t=p(r.r,r.g,r.b);e(t);let{r:n,g:a,b:u}=M(t.h,t.s,t.l);return D(r,{r:n,g:a,b:u})}function O(r,e){return g(r,t=>t.l=b(t.l+e))}function I(r,e){return g(r,t=>t.l=b(t.l-e))}function j(r,e){return g(r,t=>t.s=b(t.s+e))}function N(r,e){return g(r,t=>t.s=b(t.s-e))}function R(r,e){return g(r,t=>t.h=((t.h+e)%360+360)%360)}function B(r){return R(r,180)}function G(r){let e=s(.299*r.r+.587*r.g+.114*r.b);return D(r,{r:e,g:e,b:e})}function U(r,e=1){let t=b(e);return D(r,{r:s(r.r+(255-2*r.r)*t),g:s(r.g+(255-2*r.g)*t),b:s(r.b+(255-2*r.b)*t)})}function x(r,e,t=.5){let n=b(t),a=(l,o)=>l*(1-n)+o*n,u=r.format==="named"?"hex":r.format;return {r:s(a(r.r,e.r)),g:s(a(r.g,e.g)),b:s(a(r.b,e.b)),a:b(a(r.a,e.a)),format:u}}function z(r,e){let t=b(e),n=r.format;return t<1&&(n==="rgb"?n="rgba":n==="hsl"?n="hsla":n==="named"&&(n="hex")),{r:r.r,g:r.g,b:r.b,a:t,format:n}}var y={r:255,g:255,b:255,a:1,format:"hex"},k={r:0,g:0,b:0,a:1,format:"hex"},F={r:128,g:128,b:128,a:1};function K(r,e,t){let n=(r%360+360)%360/60,a=t*e,u=a*(1-Math.abs(n%2-1)),l=t-a,o=0,i=0,m=0;return n<1?[o,i,m]=[a,u,0]:n<2?[o,i,m]=[u,a,0]:n<3?[o,i,m]=[0,a,u]:n<4?[o,i,m]=[0,u,a]:n<5?[o,i,m]=[u,0,a]:[o,i,m]=[a,0,u],{r:s((o+l)*255),g:s((i+l)*255),b:s((m+l)*255)}}function V(r,e,t){let n=b(e),a=b(t);if(n+a>=1){let o=s(n/(n+a)*255);return {r:o,g:o,b:o}}let u=M(r,1,.5),l=o=>s(o*(1-n-a)+n*255);return {r:l(u.r),g:l(u.g),b:l(u.b)}}function Y(r,e){return x(r,y,e)}function J(r,e){return x(r,k,e)}function P(r,e){return x(r,F,e)}function H(r){return C(r,y)>=C(r,k)}function Q(r){return H(r)?y:k}var f={aa:4.5,aaa:7,aaLarge:3,aaaLarge:4.5};function X(r,e){let t=C(r,e);return t>=f.aaa?"AAA":t>=f.aa?"AA":t>=f.aaLarge?"AA Large":"Fail"}exports.A=f;exports.B=X;exports.a=s;exports.b=b;exports.c=_;exports.d=p;exports.e=M;exports.f=A;exports.g=E;exports.h=$;exports.i=C;exports.j=O;exports.k=I;exports.l=j;exports.m=N;exports.n=R;exports.o=B;exports.p=G;exports.q=U;exports.r=x;exports.s=z;exports.t=K;exports.u=V;exports.v=Y;exports.w=J;exports.x=P;exports.y=H;exports.z=Q;//# sourceMappingURL=chunk-ESUN2THE.cjs.map
+//# sourceMappingURL=chunk-ESUN2THE.cjs.map