solve-engine 1.2.0 → 2.1.0

package/dist/chunk-CSDQMDU2.js

@@ -1,204 +0,0 @@
-import { ErrorFactory } from './chunk-N7OA4WPJ.js';
-
-// package.json
-var version = "1.2.0";
-
-// src/constants/version.ts
-var ENGINE_VERSION = version;
-
-// src/constants/Configuration.ts
-var DEFAULT_CONFIG = {
-  date: {
-    // A century of workdays is about 26,000 steps, which is microseconds,
-    // and past any offset a person means. The walk is what these bound; see
-    // DateConfig above for why no other date offset needs a ceiling.
-    maxOffsetYears: 100,
-    minOffsetYears: -100,
-    defaultFormat: "YYYY-MM-DD"
-  },
-  performance: {
-    // Preserves the effective cache size the hardcoded (now-removed)
-    // BYTECODE_CACHE_MAX_ENTRIES constant had, so wiring this field up
-    // doesn't silently shrink the default cache for existing consumers.
-    defaultCacheSize: 2e3,
-    // Raised from the 10,000 this field was declared with, which was never
-    // enforced and turned out to be under what this engine already supports:
-    // its paging design is tested against a 20,000-line document
-    // (`engine/PageManager.ts` and its spec) and its throughput benchmark
-    // parses a 50,000-line one. Twice the largest of those, and the same
-    // number `ConfigManager.validate()` already refuses to go above.
-    //
-    // Measured under a 256MB heap: setting a 100,000-line document costs
-    // 64MB, evaluating every line of a 20,000-line one costs 106MB, and
-    // 200,000 lines aborts the process before a single expression is looked
-    // at. A host with a small heap should lower this; the ceiling is here to
-    // stop the size that cannot work anywhere.
-    maxDocumentLines: 1e5
-  },
-  validation: {
-    maxExpressionLength: 2e3,
-    maxComplexity: 500,
-    maxNestingDepth: 50,
-    autoBalanceParens: false
-  },
-  vm: {
-    maxStackDepth: 200,
-    maxInstructions: 5e4,
-    // Two orders of magnitude above anything a person types by hand (the
-    // longest range in the test suite is 1000 elements) and small enough
-    // that expanding it is measured in milliseconds rather than in whether
-    // the host survives.
-    maxCollectionSize: 1e5,
-    // Twenty times the single-collection ceiling above, so an expression may
-    // legitimately handle a number of large collections, and two hundred
-    // times below the allocation that took the process down.
-    maxAllocatedElements: 2e6,
-    // Six hundred times the largest call count any test or example makes
-    // (five levels of composition is sixteen calls), and small enough that
-    // the calls it does allow cost single-digit megabytes rather than the
-    // heap. A document that needs more than ten thousand calls on one line
-    // is doing something a calculator was not built for.
-    maxFunctionCalls: 1e4,
-    // A hundred bisection steps resolve an input to one part in 2^100, far
-    // finer than any document needs and a firm stop for an untrusted one. A
-    // continuous, monotonic relationship converges in tens of steps, well
-    // under this; hitting it means the target is unreachable or the
-    // relationship is not the smooth one goal seek assumes.
-    maxGoalSeekIterations: 100
-  },
-  worker: {
-    maxConcurrentWorkers: 4,
-    idleTimeoutMs: 3e4,
-    maxRetries: 3,
-    baseBackoffMs: 1e3
-  },
-  diagnostic: {
-    enabled: false,
-    vmTraceEnabled: false
-  }
-};
-function mergeEngineConfig(base, override) {
-  return {
-    date: { ...base.date, ...override.date },
-    performance: { ...base.performance, ...override.performance },
-    validation: { ...base.validation, ...override.validation },
-    vm: { ...base.vm, ...override.vm },
-    worker: { ...base.worker, ...override.worker },
-    diagnostic: { ...base.diagnostic, ...override.diagnostic }
-  };
-}
-var ConfigManager = class {
-  constructor(config = {}) {
-    this.config = mergeEngineConfig(DEFAULT_CONFIG, config);
-  }
-  /**
-   * Get configuration value by path
-   * 
-   * @param path - Dot-notation path to config value
-   * @returns Configuration value
-   */
-  get(path) {
-    const keys = path.split(".");
-    let current = this.config;
-    for (const key of keys) {
-      if (current && typeof current === "object" && key in current) {
-        current = current[key];
-      } else {
-        throw ErrorFactory.config(
-          "CONFIG_PATH_NOT_FOUND",
-          `Configuration path not found: ${path}`,
-          { path }
-        );
-      }
-    }
-    return current;
-  }
-  /**
-   * Set configuration value by path
-   * 
-   * @param path - Dot-notation path to config value
-   * @param value - New value
-   */
-  set(path, value) {
-    const keys = path.split(".");
-    if (keys.length < 2) {
-      throw ErrorFactory.config(
-        "INVALID_CONFIG_PATH",
-        `Invalid path: ${path}. Must be in format 'section.property'`,
-        { path }
-      );
-    }
-    const section = keys[0];
-    const property = keys[1];
-    if (!(section in this.config)) {
-      throw ErrorFactory.config(
-        "CONFIG_SECTION_NOT_FOUND",
-        `Configuration section not found: ${section}`,
-        { section, path }
-      );
-    }
-    const sectionConfig = this.config[section];
-    if (sectionConfig && typeof sectionConfig === "object") {
-      sectionConfig[property] = value;
-    } else {
-      throw ErrorFactory.config(
-        "CONFIG_PROPERTY_NOT_FOUND",
-        `Configuration property not found: ${path}`,
-        { path }
-      );
-    }
-  }
-  /**
-   * Get complete configuration.
-   *
-   * A detached copy, section objects included. A top-level spread would hand
-   * the caller this manager's own section objects, so `getConfig().vm.x = 1`
-   * would be an undeclared back door into {@link set}, bypassing its path
-   * validation and reaching every later {@link get}.
-   */
-  getConfig() {
-    return mergeEngineConfig(this.config, {});
-  }
-  /**
-   * Update multiple configuration values
-   */
-  update(config) {
-    this.config = mergeEngineConfig(this.config, config);
-  }
-  /**
-   * Reset to default configuration.
-   *
-   * Goes through {@link mergeEngineConfig} for the same reason the constructor
-   * does. A top-level `{ ...DEFAULT_CONFIG }` copies the six section
-   * references, not the sections, so after a reset this manager's
-   * `performance` object WAS `DEFAULT_CONFIG.performance` and the next
-   * `set('performance.x', ...)` wrote into the module constant. That constant
-   * is what every `ExpressionEngine` is built from, so one manager's reset
-   * could change the cache size, instruction ceiling or allocation budget of
-   * every engine constructed later in the process.
-   */
-  reset() {
-    this.config = mergeEngineConfig(DEFAULT_CONFIG, {});
-  }
-  /**
-   * Validate configuration values
-   */
-  validate() {
-    const errors = [];
-    if (this.config.performance.maxDocumentLines > 1e5) {
-      errors.push("maxDocumentLines cannot exceed 100,000");
-    }
-    if (this.config.date.maxOffsetYears > 1e3) {
-      errors.push("maxOffsetYears cannot exceed 1000");
-    }
-    return {
-      valid: errors.length === 0,
-      error: errors.join("; "),
-      warnings: []
-    };
-  }
-};
-
-export { ConfigManager, DEFAULT_CONFIG, ENGINE_VERSION, mergeEngineConfig };
-//# sourceMappingURL=chunk-CSDQMDU2.js.map
-//# sourceMappingURL=chunk-CSDQMDU2.js.map

package/dist/chunk-CSDQMDU2.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../package.json","../src/constants/version.ts","../src/constants/Configuration.ts"],"names":[],"mappings":"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","file":"chunk-CSDQMDU2.js","sourcesContent":["{\n  \"name\": \"solve-engine\",\n  \"version\": \"1.2.0\",\n  \"description\": \"An embeddable expression engine for natural-language calculations: units, currencies, percentages, dates and matrices, with the parsing and evaluation plumbing already built.\",\n  \"keywords\": [\n    \"expression-evaluator\",\n    \"calculator\",\n    \"bytecode-vm\",\n    \"parser\",\n    \"lexer\",\n    \"dsl\",\n    \"markdown\",\n    \"obsidian\"\n  ],\n  \"license\": \"MIT\",\n  \"author\": \"Liam Riddell\",\n  \"homepage\": \"https://liamriddell.github.io/solve-engine/\",\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"git+https://github.com/LiamRiddell/solve-engine.git\",\n    \"directory\": \"packages/engine\"\n  },\n  \"bugs\": {\n    \"url\": \"https://github.com/LiamRiddell/solve-engine/issues\"\n  },\n  \"publishConfig\": {\n    \"access\": \"public\"\n  },\n  \"type\": \"module\",\n  \"engines\": {\n    \"node\": \">=22\"\n  },\n  \"files\": [\n    \"dist\",\n    \"LICENSE\"\n  ],\n  \"main\": \"./dist/index.cjs\",\n  \"module\": \"./dist/index.js\",\n  \"types\": \"./dist/index.d.ts\",\n  \"exports\": {\n    \".\": {\n      \"import\": {\n        \"types\": \"./dist/index.d.ts\",\n        \"default\": \"./dist/index.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/index.d.cts\",\n        \"default\": \"./dist/index.cjs\"\n      }\n    },\n    \"./engine\": {\n      \"import\": {\n        \"types\": \"./dist/engine.d.ts\",\n        \"default\": \"./dist/engine.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/engine.d.cts\",\n        \"default\": \"./dist/engine.cjs\"\n      }\n    },\n    \"./vm\": {\n      \"import\": {\n        \"types\": \"./dist/vm.d.ts\",\n        \"default\": \"./dist/vm.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/vm.d.cts\",\n        \"default\": \"./dist/vm.cjs\"\n      }\n    },\n    \"./format\": {\n      \"import\": {\n        \"types\": \"./dist/format.d.ts\",\n        \"default\": \"./dist/format.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/format.d.cts\",\n        \"default\": \"./dist/format.cjs\"\n      }\n    },\n    \"./language\": {\n      \"import\": {\n        \"types\": \"./dist/language.d.ts\",\n        \"default\": \"./dist/language.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/language.d.cts\",\n        \"default\": \"./dist/language.cjs\"\n      }\n    },\n    \"./packages\": {\n      \"import\": {\n        \"types\": \"./dist/packages.d.ts\",\n        \"default\": \"./dist/packages.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/packages.d.cts\",\n        \"default\": \"./dist/packages.cjs\"\n      }\n    },\n    \"./constants\": {\n      \"import\": {\n        \"types\": \"./dist/constants.d.ts\",\n        \"default\": \"./dist/constants.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/constants.d.cts\",\n        \"default\": \"./dist/constants.cjs\"\n      }\n    },\n    \"./lexer\": {\n      \"import\": {\n        \"types\": \"./dist/lexer.d.ts\",\n        \"default\": \"./dist/lexer.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/lexer.d.cts\",\n        \"default\": \"./dist/lexer.cjs\"\n      }\n    },\n    \"./parser\": {\n      \"import\": {\n        \"types\": \"./dist/parser.d.ts\",\n        \"default\": \"./dist/parser.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/parser.d.cts\",\n        \"default\": \"./dist/parser.cjs\"\n      }\n    },\n    \"./normalizer\": {\n      \"import\": {\n        \"types\": \"./dist/normalizer.d.ts\",\n        \"default\": \"./dist/normalizer.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/normalizer.d.cts\",\n        \"default\": \"./dist/normalizer.cjs\"\n      }\n    },\n    \"./variables\": {\n      \"import\": {\n        \"types\": \"./dist/variables.d.ts\",\n        \"default\": \"./dist/variables.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/variables.d.cts\",\n        \"default\": \"./dist/variables.cjs\"\n      }\n    },\n    \"./resolvers\": {\n      \"import\": {\n        \"types\": \"./dist/resolvers.d.ts\",\n        \"default\": \"./dist/resolvers.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/resolvers.d.cts\",\n        \"default\": \"./dist/resolvers.cjs\"\n      }\n    },\n    \"./errors\": {\n      \"import\": {\n        \"types\": \"./dist/errors.d.ts\",\n        \"default\": \"./dist/errors.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/errors.d.cts\",\n        \"default\": \"./dist/errors.cjs\"\n      }\n    },\n    \"./utilities\": {\n      \"import\": {\n        \"types\": \"./dist/utilities.d.ts\",\n        \"default\": \"./dist/utilities.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/utilities.d.cts\",\n        \"default\": \"./dist/utilities.cjs\"\n      }\n    },\n    \"./uom\": {\n      \"import\": {\n        \"types\": \"./dist/uom.d.ts\",\n        \"default\": \"./dist/uom.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/uom.d.cts\",\n        \"default\": \"./dist/uom.cjs\"\n      }\n    },\n    \"./services\": {\n      \"import\": {\n        \"types\": \"./dist/services.d.ts\",\n        \"default\": \"./dist/services.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/services.d.cts\",\n        \"default\": \"./dist/services.cjs\"\n      }\n    },\n    \"./worker\": {\n      \"import\": {\n        \"types\": \"./dist/worker.d.ts\",\n        \"default\": \"./dist/worker.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/worker.d.cts\",\n        \"default\": \"./dist/worker.cjs\"\n      }\n    },\n    \"./testing\": {\n      \"import\": {\n        \"types\": \"./dist/testing.d.ts\",\n        \"default\": \"./dist/testing.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/testing.d.cts\",\n        \"default\": \"./dist/testing.cjs\"\n      }\n    }\n  },\n  \"scripts\": {\n    \"build\": \"tsup\",\n    \"prepublishOnly\": \"npm run build && node ../../scripts/assert-publishable.mjs .\",\n    \"dev\": \"tsup --watch\",\n    \"test\": \"jest --config jest.config.cjs --no-coverage\",\n    \"typecheck\": \"tsgo --noEmit --skipLibCheck\",\n    \"typecheck:tsc\": \"tsc --noEmit --skipLibCheck\"\n  },\n  \"dependencies\": {\n    \"@tanstack/query-core\": \"^5.100.10\"\n  },\n  \"devDependencies\": {\n    \"@jest/globals\": \"^30.4.1\",\n    \"@types/node\": \"^26.2.0\",\n    \"@types/semver\": \"^7.5.0\",\n    \"convert\": \"^7.0.0\",\n    \"jest\": \"^30.4.2\",\n    \"semver\": \"^7.6.0\",\n    \"ts-jest\": \"^29.4.12\",\n    \"tsup\": \"8.5.1\",\n    \"typescript\": \"5.9.3\"\n  },\n  \"//sideEffects\": \"Load-bearing claim, not boilerplate. tsup's splitting emits bare chunk imports at the top of dist/index.js, and this field tells Rollup, webpack and Vite they may delete them, which esbuild reports as [ignored-bare-import] once per import during `npm run size`. The engine does have module-level work to lose: registerAllTokenTypes(), _PrecedenceParser.BP_TABLE and its cached token ids, and several process-wide registries. It is safe because every chunk doing that work is also imported for its bindings somewhere, so no bundler can drop it. That is a property of how tsup currently splits the code rather than a design guarantee, so `npm run smoke:bundled` (scripts/check-tree-shaking.mjs) proves it on every run of `npm run verify` instead of assuming it, and its header explains the two fixes if it ever stops holding.\",\n  \"sideEffects\": false\n}\n","/**\n * The running engine's own semver version, sourced directly from this\n * package's package.json so it can never drift from what's actually\n * published. Exists so IEnginePackage.engineVersion range checks\n * (api/EngineVersionCompatibility.ts) have something real to check\n * against.\n */\nimport { version } from \"../../package.json\";\n\n/**\n * The running engine's version, taken from package.json.\n *\n * What a package's `engineVersion` range is checked against at registration.\n * A prerelease is compared by its coerced release version, so a 1.0.0 beta\n * satisfies `^1.0.0`. See `api/EngineVersionCompatibility.ts`.\n */\nexport const ENGINE_VERSION: string = version;\n","/**\n * Configuration Module for solve-js Engine\n * \n * This module provides the **single source of truth** for all engine configuration.\n * Every configurable aspect of the engine, from safety limits and performance\n * budgets to VM constraints and worker pool sizing, is defined here.\n * \n * ### Design principles\n * \n * 1. **Engine owns its config.** The engine defines its own config shape and defaults.\n *    Consumers (e.g., the Obsidian plugin) pass partial overrides; all unspecified\n *    fields fall back to `DEFAULT_CONFIG`.\n * \n * 2. **Self-documenting.** Every interface and field has descriptive JSDoc so the\n *    config is understandable at a glance, whether you're using the engine as an\n *    npm package or reading the source.\n * \n * 3. **Minimal consumer knowledge.** Consumers only need to pass `Partial<EngineConfig>`.\n *    They don't need to replicate the full config shape, just the fields they\n *    want to override.\n * \n * @module Configuration\n */\n\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\n\n/**\n * A host's test for whether a calendar date is a public holiday, given the\n * `Date` for that day at local midnight. Return `true` to exclude it from\n * working-day arithmetic.\n */\nexport type HolidayPredicate = (date: Date) => boolean;\n\n/**\n * The host-supplied public-holiday calendar, in the same \"bring your own data\"\n * shape the stocks and weather packages already use for a host callback (see\n * `packages/stocks/StocksPackage.ts`): weekends are decidable from the date\n * alone, holidays are not, so they come from the host or not at all.\n *\n * Either a {@link HolidayPredicate}, for a host that computes holidays itself\n * (an existing library, a region rule), or an iterable of specific dates as\n * `YYYY-MM-DD` strings, epoch-millisecond numbers or `Date` objects, for a host\n * that just has a list. Resolved to one internal predicate by\n * `vm/HolidayCalendar.ts`'s `resolveHolidayPredicate()`.\n *\n * Left unset, working-day arithmetic skips weekends only, which is the honest\n * default: the engine excludes exactly the days it can prove are non-working.\n */\nexport type HolidayCalendar = HolidayPredicate | Iterable<string | number | Date>;\n\n/**\n * Date-related configuration.\n * Controls the bounds and formatting for date/time expression evaluation\n * (e.g., `today + 20 days`, `last monday`).\n */\nexport interface DateConfig {\n  /**\n   * How far forward a date offset whose COST grows with the offset may reach,\n   * in years. Enforced by `vm/VM.ts`'s `addBusinessDays()`.\n   *\n   * Bounds the walk, not the calendar. Every other date offset in the engine\n   * is arithmetic on a Date field, so `today + 100000 days` costs exactly what\n   * one day costs and needs no ceiling; workdays are the one offset that has\n   * to step day by day, because which days are skipped depends on where each\n   * step lands. `today + 100000000 workdays` therefore froze the host for\n   * thirteen seconds inside a single ADD opcode (where `vm.maxInstructions`\n   * cannot see it) and then answered \"Invalid Date\", and a trillion never\n   * returned at all.\n   *\n   * Release hardening: this field was declared, documented as a \"safety\n   * limit\", and read nowhere, so it bounded nothing. A limit a host can\n   * configure and the engine ignores is worse than no limit, because it reads\n   * as protection that is not there.\n   */\n  readonly maxOffsetYears: number;\n  /** How far BACK the same walk may reach, in years, as a negative number. See {@link maxOffsetYears}. */\n  readonly minOffsetYears: number;\n  /** Default date string format for display (moment.js format string) */\n  readonly defaultFormat: string;\n  /**\n   * Public-holiday calendar for working-day arithmetic (`N working days after\n   * <date>`, `working days between <date> and <date>`, `<date> + N workdays`).\n   * See {@link HolidayCalendar}.\n   *\n   * Optional and unset by default: with no calendar, working-day arithmetic\n   * skips weekends only. A host that wants holidays excluded too supplies one\n   * here (`new ExpressionEngine(\"en\", false, { date: { holidays } })`), the\n   * same way stocks and weather take a host data source. Threaded into the VM\n   * by `engine/ExpressionEngine.ts` exactly as {@link maxOffsetYears} is,\n   * because working-day math is a VM operation several grammar forms share, so\n   * the calendar has to be one source the VM owns rather than per-package state\n   * the VM cannot see.\n   */\n  readonly holidays?: HolidayCalendar;\n}\n\n/**\n * Performance-related configuration.\n * Controls caching, timeouts, and processing limits to prevent runaway\n * resource consumption on large documents.\n */\nexport interface PerformanceConfig {\n  /**\n   * Maximum number of entries in {@link ExpressionEngine}'s bytecode cache\n   * (per-instance, keyed by expression text) before the oldest entry is\n   * evicted. Raise this for documents with many distinct expressions if\n   * repeated re-evaluation (e.g. scrolling) is re-parsing instead of\n   * hitting cache, bug fix (release hardening pass): this field used to\n   * be read nowhere; the cache size was a hardcoded, unconfigurable\n   * constant. Note this does NOT bound {@link LineCache}, which has no\n   * size limit of its own.\n   */\n  readonly defaultCacheSize: number;\n  /**\n   * Maximum lines a document may have for the engine to process it in one\n   * pass. Enforced by `ExpressionEngine.parseDocument()` and by\n   * `engine/DocumentModel.ts`'s `setDocument()`, the two entry points that\n   * take a whole document.\n   *\n   * A document costs memory per line whatever each line says: a parsed line\n   * record, a cache entry, a dependency-graph node. Two hundred thousand\n   * lines of `1 + 1` therefore exhausted the heap and aborted the process\n   * before any per-line limit had anything to object to, which is the same\n   * shape of hole as an unbounded expression and needs the same kind of\n   * ceiling. Refusing the document names the limit; a host that genuinely has\n   * a larger one raises this field.\n   *\n   * Release hardening: declared and read nowhere until now.\n   */\n  readonly maxDocumentLines: number;\n}\n\n/**\n * Validation / safety-limit configuration.\n * Protects against runaway expressions that could cause excessive memory use\n * or stack overflow. These limits are checked during lexing and parsing.\n */\n/** Bounds on untrusted input: expression length and nesting depth. */\nexport interface ValidationConfig {\n  /** Maximum expression length in characters. Prevents excessively long strings from entering the pipeline. */\n  readonly maxExpressionLength: number;\n  /** Maximum expression complexity score (`tokens + functionCalls×5 + nestingDepth×10`). Protects against deeply nested or combinatorially complex expressions. */\n  readonly maxComplexity: number;\n  /** Maximum parentheses nesting depth. Prevents stack overflow in the recursive-descent parser. */\n  readonly maxNestingDepth: number;\n  /**\n   * Auto-balance unmatched parentheses by appending missing closing parens\n   * or prepending missing opening parens. When disabled, unbalanced expressions\n   * cause parse errors instead of being silently corrected.\n   *\n   * Disabled by default for strict parsing. Enable for forgiving user input\n   * (e.g., chat-style calculators where users often omit closing parens).\n   * Has zero overhead when disabled, the O(n) paren-count scan is skipped.\n   */\n  readonly autoBalanceParens: boolean;\n}\n\n/**\n * Worker pool configuration.\n * Controls the parallel execution workers used for batch evaluation.\n */\nexport interface WorkerConfig {\n  /** Maximum number of concurrent Web Workers allowed */\n  readonly maxConcurrentWorkers: number;\n  /** Time (ms) a worker stays alive while idle before being terminated */\n  readonly idleTimeoutMs: number;\n  /** Maximum retry attempts for a failed worker operation */\n  readonly maxRetries: number;\n  /** Base backoff delay (ms) between retries (exponential backoff applied on top) */\n  readonly baseBackoffMs: number;\n}  /**\n   * Diagnostic / telemetry configuration.\n   * Controls the diagnostic event pipeline for profiling and debugging.\n   * All diagnostics are disabled by default for maximum production performance.\n   */\n  export interface DiagnosticConfig {\n    /** Master switch: enable the diagnostic pipeline (collectors receive events for all pipeline stages) */\n    readonly enabled: boolean;\n    /** Enable VM trace mode, emits per-opcode execution events (very verbose; disables some optimizations) */\n    readonly vmTraceEnabled: boolean;\n  }\n\n  /**\n   * Virtual Machine configuration.\n   * Controls the internal bytecode VM that executes compiled expressions.\n   */\n  export interface VMConfig {\n    /** Maximum stack depth (value slots) for VM execution, prevents stack overflow in recursive/pratt-parser generated bytecode */\n    readonly maxStackDepth: number;\n    /** Maximum opcodes executed per expression, halts runaway infinite loops */\n    readonly maxInstructions: number;\n    /**\n     * Maximum elements a collection may be expanded to before `map`/`reduce`/\n     * `sum`/`prod` will iterate it.\n     *\n     * A Range is stored as its two bounds and costs nothing until something\n     * materializes it, at which point it becomes one Value per element. Twenty\n     * characters (`sum(x, 1:100000000)`) therefore asked for a hundred million\n     * of them, and neither `maxInstructions` nor `maxStackDepth` could see it:\n     * the expansion happens inside a single opcode, so the instruction counter\n     * is never consulted while it runs, and the elements never reach the value\n     * stack. V8 aborted the whole process with \"Reached heap limit\", which a\n     * host embedding the engine cannot catch.\n     */\n    readonly maxCollectionSize: number;\n    /**\n     * Maximum elements (collection Values, matrix cells) one evaluation may\n     * materialize in total.\n     *\n     * `maxCollectionSize` above bounds a single collection. This bounds the sum\n     * of everything an expression asks for, which is a different question and\n     * the one that actually protects the host: two collections that are\n     * individually legal are legal together, and an operation whose result is\n     * the PRODUCT of two legal operands is bounded by neither of them. A matrix\n     * multiply is exactly that shape, so three lines within every other limit\n     * (`:a = map(1*x, 0:20000)`, `:b = transpose(a)`, `b * a`) asked for four\n     * hundred million cells and aborted the process.\n     *\n     * Counted in elements rather than bytes, because a count is what a call\n     * site has before it allocates. An element is 8 bytes as a numeric matrix\n     * cell and closer to a hundred as a full Value, so the default is worth\n     * roughly 16 MB of matrix or 200 MB of expanded collection: far past any\n     * document and far short of what an editor cannot survive.\n     */\n    readonly maxAllocatedElements: number;\n    /**\n     * Maximum user-defined-function calls one evaluation may make in TOTAL,\n     * however deeply or widely they nest.\n     *\n     * `maxFunctionRecursionDepth` bounds how DEEP calls nest and cannot see\n     * how MANY there are, and those are different numbers. Twenty-two lines of\n     * `f(n)(v) = f(n-1)(v) + f(n-1)(v)` reach a depth of only 22 against a\n     * limit of 50, and make 2,097,152 calls doing it: a fatal heap abort in\n     * under a second. `maxInstructions` cannot bound it either, because\n     * `executeBytecode()` re-enters itself per call and each reentrant call\n     * gets its OWN instruction count, so recursion refreshes its allowance on\n     * the way in. This is the tally that does not refresh; see\n     * `vm/AllocationBudget.ts`, which holds it for the same reason it holds\n     * the element tally.\n     *\n     * Counted in calls rather than in the instructions they run, because the\n     * call is the thing that multiplies: every call allocates a frame, its\n     * arguments and its result whatever its body says.\n     */\n    readonly maxFunctionCalls: number;\n    /**\n     * Hard ceiling on how many bisection steps goal seek (`solve line N for\n     * <var> = <target>`, see `packages/goalseek/`) may take before it gives up\n     * with a structured error rather than continuing.\n     *\n     * Goal seek re-evaluates the target line's expression once per step while\n     * narrowing an interval, and an untrusted document must never be able to\n     * make that loop spin. `maxInstructions` bounds each individual\n     * re-evaluation, but not how many of them the search performs, so this is\n     * the tally that bounds the search itself, the same reason `maxFunctionCalls`\n     * exists alongside `maxInstructions`. Bisection halves the interval every\n     * step, so a hundred steps resolves an input to roughly one part in 2^100:\n     * far past any precision a document needs, and a definite stop either way.\n     */\n    readonly maxGoalSeekIterations: number;\n  }\n\n/**\n * Complete engine configuration.\n *\n * Every field has a default in `DEFAULT_CONFIG`. To customize, pass a\n * `Partial<EngineConfig>` when constructing `ExpressionEngine`. Only the\n * sections/fields you supply are overridden; all others use their defaults.\n *\n * @example\n * ```typescript\n * import { ExpressionEngine } from \"solve-js\";\n *\n * const engine = new ExpressionEngine(\"en\", false, {\n *   validation: {\n *     maxExpressionLength: 1000,\n *     maxComplexity: 200,\n *   },\n *   // date, performance, vm, worker, diagnostic all use defaults\n * });\n * ```\n */\nexport interface EngineConfig {\n    /** Date/time expression evaluation bounds and formatting */\n    readonly date: DateConfig;\n    /** Performance budgets and cache sizing */\n    readonly performance: PerformanceConfig;\n    /** Safety limits for expression complexity */\n    readonly validation: ValidationConfig;\n    /** Internal bytecode VM configuration */\n    readonly vm: VMConfig;\n    /** Parallel worker pool configuration */\n    readonly worker: WorkerConfig;\n    /** Diagnostic pipeline configuration */\n    readonly diagnostic: DiagnosticConfig;\n  }\n\n/**\n * Default configuration values\n */\nexport const DEFAULT_CONFIG: EngineConfig = {\n   date: {\n     // A century of workdays is about 26,000 steps, which is microseconds,\n     // and past any offset a person means. The walk is what these bound; see\n     // DateConfig above for why no other date offset needs a ceiling.\n     maxOffsetYears: 100,\n     minOffsetYears: -100,\n     defaultFormat: 'YYYY-MM-DD'\n   },\n   performance: {\n     // Preserves the effective cache size the hardcoded (now-removed)\n     // BYTECODE_CACHE_MAX_ENTRIES constant had, so wiring this field up\n     // doesn't silently shrink the default cache for existing consumers.\n     defaultCacheSize: 2000,\n     // Raised from the 10,000 this field was declared with, which was never\n     // enforced and turned out to be under what this engine already supports:\n     // its paging design is tested against a 20,000-line document\n     // (`engine/PageManager.ts` and its spec) and its throughput benchmark\n     // parses a 50,000-line one. Twice the largest of those, and the same\n     // number `ConfigManager.validate()` already refuses to go above.\n     //\n     // Measured under a 256MB heap: setting a 100,000-line document costs\n     // 64MB, evaluating every line of a 20,000-line one costs 106MB, and\n     // 200,000 lines aborts the process before a single expression is looked\n     // at. A host with a small heap should lower this; the ceiling is here to\n     // stop the size that cannot work anywhere.\n     maxDocumentLines: 100000,\n   },\n    validation: {\n      maxExpressionLength: 2000,\n      maxComplexity: 500,\n      maxNestingDepth: 50,\n      autoBalanceParens: false,\n    },\n    vm: {\n      maxStackDepth: 200,\n      maxInstructions: 50000,\n      // Two orders of magnitude above anything a person types by hand (the\n      // longest range in the test suite is 1000 elements) and small enough\n      // that expanding it is measured in milliseconds rather than in whether\n      // the host survives.\n      maxCollectionSize: 100000,\n      // Twenty times the single-collection ceiling above, so an expression may\n      // legitimately handle a number of large collections, and two hundred\n      // times below the allocation that took the process down.\n      maxAllocatedElements: 2000000,\n      // Six hundred times the largest call count any test or example makes\n      // (five levels of composition is sixteen calls), and small enough that\n      // the calls it does allow cost single-digit megabytes rather than the\n      // heap. A document that needs more than ten thousand calls on one line\n      // is doing something a calculator was not built for.\n      maxFunctionCalls: 10000,\n      // A hundred bisection steps resolve an input to one part in 2^100, far\n      // finer than any document needs and a firm stop for an untrusted one. A\n      // continuous, monotonic relationship converges in tens of steps, well\n      // under this; hitting it means the target is unreachable or the\n      // relationship is not the smooth one goal seek assumes.\n      maxGoalSeekIterations: 100,\n    },\n    worker: {\n      maxConcurrentWorkers: 4,\n      idleTimeoutMs: 30000,\n      maxRetries: 3,\n      baseBackoffMs: 1000,\n    },\n    diagnostic: {\n      enabled: false,\n      vmTraceEnabled: false,\n    },\n  };\n\n/**\n * Merge a partial config override onto a base `EngineConfig`, section by\n * section, `{ ...base.section, ...override.section }` for each of the 7\n * top-level sections, not a single top-level spread.\n *\n * A shallow `{ ...base, ...override }` at the TOP level replaces an entire\n * section wholesale the moment a caller overrides even one field in it\n * (e.g. `{ performance: { defaultCacheSize: 500 } }` would silently drop\n * every other `performance.*` field back to `undefined`, not to its\n * default). This function exists specifically so every config consumer\n * shares one correct merge instead of each hand-rolling (and risking) its\n * own. `ConfigManager` and `ExpressionEngine` both call this rather than\n * either duplicating the section list or instantiating a whole\n * `ConfigManager` just to reuse its private merge logic.\n */\nexport function mergeEngineConfig(\n  base: EngineConfig,\n  override: Partial<EngineConfig>\n): EngineConfig {\n  return {\n    date: { ...base.date, ...override.date },\n    performance: { ...base.performance, ...override.performance },\n    validation: { ...base.validation, ...override.validation },\n    vm: { ...base.vm, ...override.vm },\n    worker: { ...base.worker, ...override.worker },\n    diagnostic: { ...base.diagnostic, ...override.diagnostic },\n  };\n}\n\n/**\n * Configuration manager for engine settings\n *\n * @example\n * ```typescript\n * const configManager = new ConfigManager();\n * configManager.set('performance.defaultCacheSize', 2000);\n * const cacheSize = configManager.get('performance.defaultCacheSize');\n * ```\n */\nexport class ConfigManager {\n  private config: EngineConfig;\n\n  constructor(config: Partial<EngineConfig> = {}) {\n    this.config = mergeEngineConfig(DEFAULT_CONFIG, config);\n  }\n\n  /**\n   * Get configuration value by path\n   * \n   * @param path - Dot-notation path to config value\n   * @returns Configuration value\n   */\n  get<T>(path: string): T {\n    const keys = path.split('.');\n    let current: unknown = this.config;\n\n    for (const key of keys) {\n      if (current && typeof current === 'object' && key in current) {\n        current = (current as Record<string, unknown>)[key];\n      } else {\n        throw ErrorFactory.config(\n          \"CONFIG_PATH_NOT_FOUND\",\n          `Configuration path not found: ${path}`,\n          { path }\n        );\n      }\n    }\n\n    return current as T;\n  }\n\n  /**\n   * Set configuration value by path\n   * \n   * @param path - Dot-notation path to config value\n   * @param value - New value\n   */\n  set<T>(path: string, value: T): void {\n    const keys = path.split('.');\n    if (keys.length < 2) {\n      throw ErrorFactory.config(\n        \"INVALID_CONFIG_PATH\",\n        `Invalid path: ${path}. Must be in format 'section.property'`,\n        { path }\n      );\n    }\n    \n    const section = keys[0];\n    const property = keys[1];\n    \n    if (!(section in this.config)) {\n      throw ErrorFactory.config(\n        \"CONFIG_SECTION_NOT_FOUND\",\n        `Configuration section not found: ${section}`,\n        { section, path }\n      );\n    }\n    \n    const sectionConfig = this.config[section as keyof EngineConfig];\n    if (sectionConfig && typeof sectionConfig === 'object') {\n      (sectionConfig as unknown as Record<string, unknown>)[property] = value;\n    } else {\n      throw ErrorFactory.config(\n        \"CONFIG_PROPERTY_NOT_FOUND\",\n        `Configuration property not found: ${path}`,\n        { path }\n      );\n    }\n  }\n\n  /**\n   * Get complete configuration.\n   *\n   * A detached copy, section objects included. A top-level spread would hand\n   * the caller this manager's own section objects, so `getConfig().vm.x = 1`\n   * would be an undeclared back door into {@link set}, bypassing its path\n   * validation and reaching every later {@link get}.\n   */\n  getConfig(): EngineConfig {\n    return mergeEngineConfig(this.config, {});\n  }\n\n  /**\n   * Update multiple configuration values\n   */\n  update(config: Partial<EngineConfig>): void {\n    this.config = mergeEngineConfig(this.config, config);\n  }\n\n  /**\n   * Reset to default configuration.\n   *\n   * Goes through {@link mergeEngineConfig} for the same reason the constructor\n   * does. A top-level `{ ...DEFAULT_CONFIG }` copies the six section\n   * references, not the sections, so after a reset this manager's\n   * `performance` object WAS `DEFAULT_CONFIG.performance` and the next\n   * `set('performance.x', ...)` wrote into the module constant. That constant\n   * is what every `ExpressionEngine` is built from, so one manager's reset\n   * could change the cache size, instruction ceiling or allocation budget of\n   * every engine constructed later in the process.\n   */\n  reset(): void {\n    this.config = mergeEngineConfig(DEFAULT_CONFIG, {});\n  }\n\n  /**\n   * Validate configuration values\n   */\n  validate(): ValidationResult {\n    const errors: string[] = [];\n\n    // Validate performance config\n    if (this.config.performance.maxDocumentLines > 100000) {\n      errors.push('maxDocumentLines cannot exceed 100,000');\n    }\n\n    // Validate date config\n    if (this.config.date.maxOffsetYears > 1000) {\n      errors.push('maxOffsetYears cannot exceed 1000');\n    }\n\n    return {\n      valid: errors.length === 0,\n      error: errors.join('; '),\n      warnings: []\n    };\n  }\n}\n\n/**\n * Result type for {@link ConfigManager.validate}.\n */\nexport interface ValidationResult {\n  valid: boolean;\n  error?: string;\n  warnings?: string[];\n}\n\n"]}

package/dist/chunk-EJ3ILXX6.cjs

@@ -1,223 +0,0 @@
-'use strict';
-
-var chunkAMOJYLG2_cjs = require('./chunk-AMOJYLG2.cjs');
-
-// src/uom/UnitConversion.ts
-var UNIT_LOOKUP = new Map(Object.entries(chunkAMOJYLG2_cjs.UNIT_TABLE));
-var DIFFERENCE_LOOKUP = new Map(Object.entries(chunkAMOJYLG2_cjs.UNIT_DIFFERENCES));
-function lookupUnit(unit) {
-  return UNIT_LOOKUP.get(unit);
-}
-function convertRaw(quantity, from, to) {
-  const parsedFrom = UNIT_LOOKUP.get(from);
-  if (parsedFrom === void 0) {
-    throw new RangeError(`${from} is not a valid unit`);
-  }
-  const parsedTo = UNIT_LOOKUP.get(to);
-  if (parsedTo === void 0) {
-    throw new RangeError(`${to} is not a valid unit`);
-  }
-  return convertResolved(quantity, from, to, parsedFrom, parsedTo);
-}
-function convertResolved(quantity, from, to, fromEntry, toEntry) {
-  const parsedFrom = fromEntry;
-  const parsedTo = toEntry;
-  if (parsedFrom[0] !== parsedTo[0]) {
-    throw new RangeError(`Cannot convert between different measures: ${from} and ${to}`);
-  }
-  const fromRatio = parsedFrom[1];
-  const toRatio = parsedTo[1];
-  const fromDifference = DIFFERENCE_LOOKUP.get(from);
-  const toDifference = DIFFERENCE_LOOKUP.get(to);
-  if (fromDifference !== void 0) {
-    if (toDifference !== void 0) {
-      return (quantity + fromDifference) * (fromRatio / toRatio) - toDifference;
-    }
-    return (quantity + fromDifference) * (fromRatio / toRatio);
-  }
-  if (toDifference !== void 0) {
-    return quantity * (fromRatio / toRatio) - toDifference;
-  }
-  return quantity * (fromRatio / toRatio);
-}
-function convertToBestMetric(quantity, from) {
-  const parsedFrom = UNIT_LOOKUP.get(from);
-  if (parsedFrom === void 0) {
-    throw new RangeError(`${from} is not a valid unit`);
-  }
-  const best = chunkAMOJYLG2_cjs.BEST_UNITS_METRIC[parsedFrom[0]];
-  const smallestUnit = best[0][0];
-  let bestUnit = smallestUnit;
-  const baseQuantity = convertRaw(quantity, from, smallestUnit);
-  const absQuantity = baseQuantity < 0 ? -baseQuantity : baseQuantity;
-  for (let i = 0; i < best.length; i++) {
-    const bestEntry = best[i];
-    if (absQuantity >= bestEntry[1]) {
-      bestUnit = bestEntry[0];
-    } else {
-      break;
-    }
-  }
-  return { quantity: convertRaw(quantity, from, bestUnit), unit: bestUnit };
-}
-
-// src/uom/UomConverter.ts
-var WORKDAY_UNIT_NAMES = /* @__PURE__ */ new Set(["workday", "workdays"]);
-var WORKDAY_TO_DAY_FACTOR = 7 / 5;
-function isWorkdayUnit(unit) {
-  return typeof unit === "string" && WORKDAY_UNIT_NAMES.has(unit);
-}
-function resolveUnit(unit) {
-  return unit;
-}
-function getMeasure(unit) {
-  if (isWorkdayUnit(unit)) return getMeasure("day");
-  const extended = chunkAMOJYLG2_cjs.EXTENDED_UNITS[unit];
-  if (extended) return extended.measure;
-  const entry = lookupUnit(unit);
-  if (entry === void 0) return void 0;
-  return chunkAMOJYLG2_cjs.MEASURE_KIND_NAMES[entry[0]];
-}
-function canConvert(from, to) {
-  if (from === to) return true;
-  if (isWorkdayUnit(from) || isWorkdayUnit(to)) {
-    const fromMeasure = getMeasure(from);
-    const toMeasure = getMeasure(to);
-    return !!fromMeasure && fromMeasure === toMeasure;
-  }
-  const fromEntry = lookupUnit(from);
-  const toEntry = lookupUnit(to);
-  if (fromEntry !== void 0 && toEntry !== void 0) {
-    return fromEntry[0] === toEntry[0];
-  }
-  const fromExtended = chunkAMOJYLG2_cjs.EXTENDED_UNITS[from];
-  const toExtended = chunkAMOJYLG2_cjs.EXTENDED_UNITS[to];
-  if (fromExtended !== void 0 && toExtended !== void 0) {
-    return fromExtended.measure === toExtended.measure;
-  }
-  return bridgesToBaseMeasure(from, to) || bridgesToBaseMeasure(to, from);
-}
-function bridgesToBaseMeasure(extendedUnit, baseUnit) {
-  const extended = chunkAMOJYLG2_cjs.EXTENDED_UNITS[extendedUnit];
-  if (extended === void 0) return false;
-  const base = lookupUnit(resolveUnit(baseUnit));
-  if (base === void 0) return false;
-  return chunkAMOJYLG2_cjs.MEASURE_KIND_NAMES[base[0]] === extended.measure;
-}
-function convertUnit(value, from, to) {
-  if (from === to) return value;
-  const fromEntry = lookupUnit(from);
-  const toEntry = lookupUnit(to);
-  if (fromEntry !== void 0 && toEntry !== void 0) {
-    return convertResolved(value, from, to, fromEntry, toEntry);
-  }
-  if (isWorkdayUnit(from) && isWorkdayUnit(to)) return value;
-  if (isWorkdayUnit(from)) {
-    const days = value * WORKDAY_TO_DAY_FACTOR;
-    return to === "day" ? days : convertUnit(days, "day", to);
-  }
-  if (isWorkdayUnit(to)) {
-    const days = from === "day" ? value : convertUnit(value, from, "day");
-    return days / WORKDAY_TO_DAY_FACTOR;
-  }
-  const fExt = chunkAMOJYLG2_cjs.EXTENDED_UNITS[from];
-  const tExt = chunkAMOJYLG2_cjs.EXTENDED_UNITS[to];
-  if (fExt !== void 0 && tExt !== void 0) {
-    return value * (fExt.toBase / tExt.toBase);
-  }
-  if (fExt !== void 0 && bridgesToBaseMeasure(from, to)) {
-    return convertRaw(value * fExt.toBase, baseUnitFor(to), to);
-  }
-  if (tExt !== void 0 && bridgesToBaseMeasure(to, from)) {
-    return convertRaw(value, from, baseUnitFor(from)) / tExt.toBase;
-  }
-  return convertRaw(value, from, to);
-}
-function baseUnitFor(unit) {
-  const entry = lookupUnit(resolveUnit(unit));
-  if (entry === void 0) return unit;
-  for (const symbol of Object.keys(chunkAMOJYLG2_cjs.UNIT_TABLE)) {
-    const candidate = chunkAMOJYLG2_cjs.UNIT_TABLE[symbol];
-    if (candidate[0] === entry[0] && candidate[1] === 1) return symbol;
-  }
-  return unit;
-}
-function getConvertiblePossibilities(unit) {
-  const resolved = resolveUnit(unit);
-  const entry = lookupUnit(resolved);
-  if (entry === void 0) return [];
-  const symbols = chunkAMOJYLG2_cjs.MEASURE_SYMBOLS[entry[0]];
-  if (!symbols) return [];
-  return symbols.filter((s) => s !== resolved);
-}
-function isConvertibleUnit(unit) {
-  if (isWorkdayUnit(unit)) return true;
-  if (chunkAMOJYLG2_cjs.EXTENDED_UNITS[unit]) return true;
-  return lookupUnit(resolveUnit(unit)) !== void 0;
-}
-function getBestUnit(value, unit) {
-  const u = resolveUnit(unit);
-  try {
-    const result = convertToBestMetric(value, u);
-    return { value: result.quantity, unit: result.unit };
-  } catch {
-    return { value, unit: u };
-  }
-}
-function expandUnitToRate(value, unit) {
-  const slash = unit.indexOf("/");
-  if (slash >= 0) {
-    return { value, numerator: unit.slice(0, slash), denominator: unit.slice(slash + 1) };
-  }
-  const ext = chunkAMOJYLG2_cjs.EXTENDED_UNITS[unit];
-  if (ext !== void 0 && ext.measure === "speed") {
-    return { value: value * ext.toBase, numerator: "m", denominator: "s" };
-  }
-  return null;
-}
-function rateAxisFactor(from, to) {
-  if (from === to) return 1;
-  if (from === "" || to === "") return null;
-  const fromMeasure = getMeasure(from);
-  const toMeasure = getMeasure(to);
-  if (fromMeasure === void 0 || toMeasure === void 0 || fromMeasure !== toMeasure) {
-    return null;
-  }
-  return convertUnit(1, from, to);
-}
-function convertRate(value, from, to) {
-  const source = expandUnitToRate(value, from);
-  if (source === null) return null;
-  let targetNumerator;
-  let targetDenominator;
-  let targetScale;
-  const slash = to.indexOf("/");
-  if (slash >= 0) {
-    targetNumerator = to.slice(0, slash);
-    targetDenominator = to.slice(slash + 1);
-    targetScale = 1;
-  } else {
-    const ext = chunkAMOJYLG2_cjs.EXTENDED_UNITS[to];
-    if (ext === void 0 || ext.measure !== "speed") return null;
-    targetNumerator = "m";
-    targetDenominator = "s";
-    targetScale = ext.toBase;
-  }
-  const numeratorFactor = rateAxisFactor(source.numerator, targetNumerator);
-  if (numeratorFactor === null) return null;
-  const denominatorFactor = rateAxisFactor(source.denominator, targetDenominator);
-  if (denominatorFactor === null) return null;
-  return source.value * numeratorFactor / denominatorFactor / targetScale;
-}
-
-exports.canConvert = canConvert;
-exports.convertRate = convertRate;
-exports.convertUnit = convertUnit;
-exports.getBestUnit = getBestUnit;
-exports.getConvertiblePossibilities = getConvertiblePossibilities;
-exports.getMeasure = getMeasure;
-exports.isConvertibleUnit = isConvertibleUnit;
-exports.isWorkdayUnit = isWorkdayUnit;
-exports.resolveUnit = resolveUnit;
-//# sourceMappingURL=chunk-EJ3ILXX6.cjs.map
-//# sourceMappingURL=chunk-EJ3ILXX6.cjs.map

package/dist/chunk-EJ3ILXX6.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/uom/UnitConversion.ts","../src/uom/UomConverter.ts"],"names":["UNIT_TABLE","UNIT_DIFFERENCES","BEST_UNITS_METRIC","EXTENDED_UNITS","MEASURE_KIND_NAMES","MEASURE_SYMBOLS"],"mappings":"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","file":"chunk-EJ3ILXX6.cjs","sourcesContent":["/**\n * The unit conversion algorithm, ported from the `convert` npm package v7.0.2\n * alongside its tables (see `generated/UnitTable.generated.ts` and\n * THIRD-PARTY-NOTICES.md).\n *\n * Transliterated expression for expression rather than rewritten. Floating\n * point is not associative, so `(q + d) * (a / b) - d2` and any algebraically\n * equal rearrangement disagree in the last bits. Those bits are observable:\n * `0.5 l` best-converts to `500.00000000000006 mL` today, and the test suite\n * pins several conversions to ten decimal places.\n *\n * This module is deliberately unaware of the engine's own additions. Workdays,\n * extended units, currency and the caches all live in `UomConverter.ts`, which\n * layers them on top of these three functions.\n */\n\nimport {\n  UNIT_TABLE,\n  UNIT_DIFFERENCES,\n  BEST_UNITS_METRIC,\n  type UnitEntry,\n} from \"./generated/UnitTable.generated\";\n\n/**\n * The generated tables re-keyed into Maps once at module load.\n *\n * Not a micro-optimization. A 1456-key object literal lands in V8's dictionary\n * mode, and guarding a read on it against inherited names (`constructor`,\n * `toString`) costs about 123ns per call with either `hasOwnProperty.call` or\n * `Object.hasOwn`, measured. `Map.get` is about 6ns and needs no guard at all,\n * because a Map has no prototype chain to fall through to. That is a 20x\n * difference on the single hottest operation in the unit system: `convertRaw`\n * performs two of these per call, and `LanguageService` sweeps all 1456 keys\n * to build completions.\n */\nconst UNIT_LOOKUP: ReadonlyMap<string, UnitEntry> = new Map(Object.entries(UNIT_TABLE));\n\n/**\n * Temperature offsets, as a Map for the same reason.\n *\n * Also removes a latent hazard: the upstream code tests membership with `in`,\n * and `\"toString\" in UNIT_DIFFERENCES` is true, so an inherited name reaching\n * that branch would add a function to a number.\n */\nconst DIFFERENCE_LOOKUP: ReadonlyMap<string, number> = new Map(Object.entries(UNIT_DIFFERENCES));\n\n/**\n * Looks up a unit spelling.\n *\n * @returns its `[kind, ratio]` entry, or `undefined` if the spelling is not a\n * unit. Case-sensitive: no normalization or aliasing happens anywhere in this\n * module.\n *\n * The one deliberate deviation from upstream. `convert` tests membership with\n * `in` and reads the property directly, so inherited names like \"constructor\"\n * and \"toString\" reach its measure comparison and fail there with \"Cannot\n * convert between different measures\" instead of \"is not a valid unit\". Both\n * throw a RangeError and both report no measure, so nothing downstream can\n * tell the difference, and naming the real problem is the better message.\n */\nexport function lookupUnit(unit: string): UnitEntry | undefined {\n  return UNIT_LOOKUP.get(unit);\n}\n\n/**\n * Converts `quantity` from one unit to another.\n *\n * THROWS a `RangeError` for an unknown unit or a pair in different measures.\n * Callers depend on that: `VM.ts`'s `extractDurationMs()` calls this with an\n * arbitrary unit inside a bare try/catch and treats the throw as \"not a\n * duration, contribute zero\". Returning NaN or the input unchanged instead\n * would turn `<date> + 5 kg` into an Invalid Date rather than a no-op.\n */\nexport function convertRaw(quantity: number, from: string, to: string): number {\n  const parsedFrom = UNIT_LOOKUP.get(from);\n  if (parsedFrom === undefined) {\n    throw new RangeError(`${from} is not a valid unit`);\n  }\n\n  const parsedTo = UNIT_LOOKUP.get(to);\n  if (parsedTo === undefined) {\n    throw new RangeError(`${to} is not a valid unit`);\n  }\n\n  return convertResolved(quantity, from, to, parsedFrom, parsedTo);\n}\n\n/**\n * The conversion arithmetic, for callers that have already looked both units\n * up and want to skip doing it twice.\n *\n * Split out for `UomConverter.convertUnit()`, which has to check whether\n * either side is a workday or an extended unit before it can dispatch, and\n * would otherwise resolve each unit once to decide and again to convert. The\n * entries MUST be the ones this module returned for these exact spellings.\n */\nexport function convertResolved(\n  quantity: number,\n  from: string,\n  to: string,\n  fromEntry: UnitEntry,\n  toEntry: UnitEntry\n): number {\n  const parsedFrom = fromEntry;\n  const parsedTo = toEntry;\n\n  if (parsedFrom[0] !== parsedTo[0]) {\n    // DELIBERATE DEVIATION from the ported original, which silently reinterpreted\n    // \"m\" as minutes whenever the other side was a time unit. That is a guess,\n    // and this project's stated position is that refusing to guess is the safer\n    // default for a tool doing arithmetic on someone's real numbers (see\n    // docs/architecture/design-decisions.md). The guess was not harmless: it\n    // reached `<date> + <duration>` through VM.ts's extractDurationMs(), where\n    // `today + 5 m` silently added five MINUTES for someone who wrote metres.\n    //\n    // Minutes are spelled \"min\", \"minute\" or \"minutes\", all of which the table\n    // has always accepted.\n    throw new RangeError(`Cannot convert between different measures: ${from} and ${to}`);\n  }\n\n  const fromRatio = parsedFrom[1];\n  const toRatio = parsedTo[1];\n\n  // Only six units in the whole table carry an offset, so the common path is\n  // both misses. Reading the Map once per side and reusing the value beats\n  // testing membership and then reading it again.\n  const fromDifference = DIFFERENCE_LOOKUP.get(from);\n  const toDifference = DIFFERENCE_LOOKUP.get(to);\n\n  // Scales that do not share an origin (temperature) need the offset applied\n  // around the ratio. Do not refactor the four branches into one expression:\n  // the grouping is what makes the result bit-identical to the original.\n  if (fromDifference !== undefined) {\n    if (toDifference !== undefined) {\n      return (quantity + fromDifference) * (fromRatio / toRatio) - toDifference;\n    }\n    return (quantity + fromDifference) * (fromRatio / toRatio);\n  }\n\n  if (toDifference !== undefined) {\n    return quantity * (fromRatio / toRatio) - toDifference;\n  }\n\n  return quantity * (fromRatio / toRatio);\n}\n\n/**\n * Picks the most readable metric unit for a magnitude and converts to it.\n *\n * Only the metric lists are ported; nothing has ever requested the imperial\n * ones. Note the final conversion goes from the ORIGINAL unit to the chosen\n * one directly rather than via the smallest unit, which is what keeps the\n * result exact.\n */\nexport function convertToBestMetric(\n  quantity: number,\n  from: string\n): { quantity: number; unit: string } {\n  const parsedFrom = UNIT_LOOKUP.get(from);\n  if (parsedFrom === undefined) {\n    throw new RangeError(`${from} is not a valid unit`);\n  }\n\n  const best = BEST_UNITS_METRIC[parsedFrom[0]];\n  const smallestUnit = best[0][0];\n  let bestUnit = smallestUnit;\n\n  const baseQuantity = convertRaw(quantity, from, smallestUnit);\n  const absQuantity = baseQuantity < 0 ? -baseQuantity : baseQuantity;\n\n  // Thresholds are expressed in the smallest unit and ascend, so the last one\n  // the magnitude reaches wins. Breaking early rather than scanning the whole\n  // list matters for zero and for negatives, which stay on the smallest unit.\n  for (let i = 0; i < best.length; i++) {\n    const bestEntry = best[i];\n    if (absQuantity >= bestEntry[1]) {\n      bestUnit = bestEntry[0];\n    } else {\n      break;\n    }\n  }\n\n  return { quantity: convertRaw(quantity, from, bestUnit), unit: bestUnit };\n}\n","/**\n * UoM Converter, built on the in-house unit tables in `UnitConversion.ts` and\n * `generated/UnitTable.generated.ts` (ported from the `convert` npm package\n * v7.0.2 so the engine ships with no runtime dependencies).\n *\n * Units are strictly case-sensitive and are looked up without aliasing. No unit\n * remapping, what you type is what you get.\n * e.g. 'C' = Celsius, 'c' = cup; 'MB' = megabytes, 'mb' = millibits.\n *\n * This file owns everything the base tables do not: the workday shim, the\n * extended (custom-measure) units, and the two caches.\n */\n\nimport { lookupUnit, convertRaw, convertResolved, convertToBestMetric } from \"@solve-js/uom/UnitConversion\";\nimport { MEASURE_KIND_NAMES, MEASURE_SYMBOLS, UNIT_TABLE } from \"@solve-js/uom/generated/UnitTable.generated\";\nimport { EXTENDED_UNITS } from \"@solve-js/uom/ExtendedUnits\";\n\n// ── \"workday\", a synthetic unit with no entry in the base table ───────────\n//\n// A business day (Mon-Fri) backing the datetime package's `<date> + N\n// workdays` arithmetic and `$X/workday` Rate literals\n// (packages/datetime/). NOT a real physical unit, a business day has no\n// fixed duration, since it depends on which calendar dates are weekends\n// so the ported base table has no concept of it and can't be\n// taught one without monkey-patching its internal unit table.\n//\n// For RATE-MATH purposes only (e.g. \"$500/workday x 4 weeks\" needs a\n// workday count to multiply by), a workday is treated as a FIXED 7/5 of a\n// calendar day: 5 workdays span exactly 7 calendar days in a whole week,\n// so this ratio is exact for whole-week spans and a reasonable linear\n// approximation otherwise. This is deliberately NOT the same\n// calendar-aware, weekend-skipping logic real \"<date> + N workdays\" date\n// arithmetic needs (see vm/VM.ts's addBusinessDays()), that can't be\n// reduced to a fixed ratio, since the exact skip pattern depends on which\n// day of the week the calculation actually starts from.\n//\n// Handled here as a thin pre/post layer in front of the normal\n// base-table path (rather than inside the tables themselves) so every\n// caller of getMeasure()/convertUnit()/canConvert() automatically gets\n// workday support for free.\nconst WORKDAY_UNIT_NAMES = new Set([\"workday\", \"workdays\"]);\nconst WORKDAY_TO_DAY_FACTOR = 7 / 5; // 1 workday == 1.4 calendar days\n\n/** Whether `unit` is the synthetic \"workday\" unit (see module note above). */\nexport function isWorkdayUnit(unit: string | undefined): unit is string {\n  return typeof unit === \"string\" && WORKDAY_UNIT_NAMES.has(unit);\n}\n\n/**\n * Validate `unit` against the known unit table.\n *\n * @returns `unit` unchanged in all cases. This does NOT normalize casing\n *   or aliasing (units are strictly case-sensitive, see the module note\n *   above). A unit the table doesn't recognize is still\n *   returned as-is (not thrown), so callers must not assume a returned\n *   string is actually convertible, check with {@link isConvertibleUnit}\n *   or {@link canConvert} first if that matters.\n *\n * Kept as an identity function purely for API compatibility. It used to guard\n * a validity cache, which existed because validating a unit meant a\n * throw/catch round trip through the old dependency. Validation is now a Map\n * lookup, so the cache cost more than it saved: worse, it was capped at 1000\n * entries against a 1456-unit table, so any sweep over the full vocabulary\n * (which is exactly what LanguageService does to build completions) evicted\n * on almost every call. That one change took the full-table sweep from 7.7ms\n * to under 20us.\n */\nexport function resolveUnit(unit: string): string {\n  return unit;\n}\n\n// MEASURE_KIND_NAMES now comes from the generated table (it is derived data,\n// so the generator emits it rather than it being retyped here). The reason it\n// is a module-level constant has not changed: getMeasure() runs at least twice\n// per conversion, and this used to be reallocated on every call.\n\n/**\n * Get the measure/dimension kind for `unit` (e.g. `\"length\"`, `\"mass\"`,\n * `\"temperature\"`), used to check whether two units are even in the same\n * dimension before attempting a conversion.\n *\n * @returns `undefined` if `unit` isn't recognized, rather than throwing.\n */\nexport function getMeasure(unit: string): string | undefined {\n  // Workday is a Time-measure unit by convention (see isWorkdayUnit's doc\n  // comment) and is not in the base table, so resolve its measure via \"day\"\n  // instead of attempting the real lookup below.\n  if (isWorkdayUnit(unit)) return getMeasure(\"day\");\n\n  // Extended (custom) categories the base table has no measure kind for,\n  // see ExtendedUnits.ts.\n  const extended = EXTENDED_UNITS[unit];\n  if (extended) return extended.measure;\n\n  const entry = lookupUnit(unit);\n  if (entry === undefined) return undefined;\n\n  return MEASURE_KIND_NAMES[entry[0]];\n}\n\n/**\n * Check whether `from` can be converted to `to`. Same unit, or same\n * measure kind (length, mass, ...) and the underlying tables accept the pair.\n * Never throws; returns `false` on any failure.\n */\nexport function canConvert(from: string, to: string): boolean {\n  if (from === to) return true;\n  if (isWorkdayUnit(from) || isWorkdayUnit(to)) {\n    const fromMeasure = getMeasure(from);\n    const toMeasure = getMeasure(to);\n    return !!fromMeasure && fromMeasure === toMeasure;\n  }\n  // One table read per side, comparing numeric kind ids. The old shape called\n  // getMeasure() on each side (two more reads) purely to compare the resulting\n  // STRINGS, then did a throwaway conversion to confirm what the kind check had\n  // already established.\n  const fromEntry = lookupUnit(from);\n  const toEntry = lookupUnit(to);\n  if (fromEntry !== undefined && toEntry !== undefined) {\n    return fromEntry[0] === toEntry[0];\n  }\n\n  // Extended (custom) categories aren't in the base table at all, so they are\n  // compared on their own measure names instead.\n  const fromExtended = EXTENDED_UNITS[from];\n  const toExtended = EXTENDED_UNITS[to];\n  if (fromExtended !== undefined && toExtended !== undefined) {\n    return fromExtended.measure === toExtended.measure;\n  }\n\n  // Mixed: one side is in the base table and the other is extended. That used\n  // to be refused outright, on the grounds that the two measure spaces are\n  // disjoint. They are not, once an extended unit names a measure the base\n  // table also has: `furlong` is a length and so is `m`, and the ratio between\n  // them is exactly what both tables already record.\n  return bridgesToBaseMeasure(from, to) || bridgesToBaseMeasure(to, from);\n}\n\n/**\n * Whether `extendedUnit` extends a measure the base table also knows, so a\n * value in it can reach `baseUnit`.\n *\n * The bridge works because both tables express a unit as a ratio to the same\n * physical base: the generated table's length ratios are metres and its mass\n * ratios are grams, and an extended unit declaring `measure: \"length\"` states\n * its `toBase` in the same metres. Composing the two ratios is then ordinary\n * arithmetic rather than a second conversion system.\n *\n * A measure the base table has no concept of, such as pace, still fails here,\n * which is the behaviour this replaced and the reason the check is by measure\n * name rather than by presence in the extended table.\n */\nfunction bridgesToBaseMeasure(extendedUnit: string, baseUnit: string): boolean {\n  const extended = EXTENDED_UNITS[extendedUnit];\n  if (extended === undefined) return false;\n\n  const base = lookupUnit(resolveUnit(baseUnit));\n  if (base === undefined) return false;\n\n  return MEASURE_KIND_NAMES[base[0]] === extended.measure;\n}\n\n/**\n * Convert `value` from unit `from` to unit `to`.\n *\n * Does not validate that the conversion is possible, callers should check\n * with {@link canConvert} first if `from`/`to` aren't already known-good.\n *\n * THROWS a RangeError for an unknown unit or a cross-measure pair. `VM.ts`'s\n * `extractDurationMs()` depends on that, see {@link convertRaw}.\n *\n * This used to memoize a per-pair conversion factor in an LFU cache. The cache\n * is gone: computing the factor is now two Map reads, while the cache cost a\n * template-string key allocation on every call plus the LFU's own frequency\n * bookkeeping, so it was slower than the work it avoided. Removing it is\n * bit-exact, not merely close: the cache stored `convertRaw(1, f, t)`, which is\n * exactly `fromRatio / toRatio`, and then multiplied, which is the identical\n * expression `convertRaw(value, f, t)` evaluates. It also deleted the special\n * case that existed only to keep offset-based temperature pairs out of a\n * factor cache.\n */\nexport function convertUnit(value: number, from: string, to: string): number {\n  if (from === to) return value;\n\n  // Fast path first: two ordinary units, which is nearly every call. Resolving\n  // both here and handing the entries to convertResolved() avoids looking them\n  // up again inside convertRaw(). Neither workdays nor extended units appear in\n  // the base table, so they always fall through to the branches below and this\n  // ordering cannot steal a case from them. UnitVocabulary.spec.ts pins that\n  // the two vocabularies stay disjoint.\n  const fromEntry = lookupUnit(from);\n  const toEntry = lookupUnit(to);\n  if (fromEntry !== undefined && toEntry !== undefined) {\n    return convertResolved(value, from, to, fromEntry, toEntry);\n  }\n\n  // Workday <-> any other Time-measure unit: pivot through \"day\" using the\n  // fixed 7/5 ratio (see isWorkdayUnit's doc comment above).\n  if (isWorkdayUnit(from) && isWorkdayUnit(to)) return value; // \"workday\" <-> \"workdays\" alias\n  if (isWorkdayUnit(from)) {\n    const days = value * WORKDAY_TO_DAY_FACTOR;\n    return to === \"day\" ? days : convertUnit(days, \"day\", to);\n  }\n  if (isWorkdayUnit(to)) {\n    const days = from === \"day\" ? value : convertUnit(value, from, \"day\");\n    return days / WORKDAY_TO_DAY_FACTOR;\n  }\n\n  // Extended (custom) categories the base table has no measure kind for\n  // (see ExtendedUnits.ts), compute the ratio directly from each unit's\n  // factor-to-base value instead of calling convertRaw(), which would throw\n  // on an unrecognized unit string. Every extended category is a pure linear\n  // ratio scale (no Temperature-style offset), so this is always safe.\n  const fExt = EXTENDED_UNITS[from];\n  const tExt = EXTENDED_UNITS[to];\n  if (fExt !== undefined && tExt !== undefined) {\n    return value * (fExt.toBase / tExt.toBase);\n  }\n\n  // One side extended, the other in the base table, sharing a measure. Convert\n  // through the measure's base unit, which both tables state their ratios\n  // against: an extended length declares its `toBase` in metres, and the\n  // generated table's length ratios are metres too.\n  if (fExt !== undefined && bridgesToBaseMeasure(from, to)) {\n    return convertRaw(value * fExt.toBase, baseUnitFor(to), to);\n  }\n  if (tExt !== undefined && bridgesToBaseMeasure(to, from)) {\n    return convertRaw(value, from, baseUnitFor(from)) / tExt.toBase;\n  }\n\n  // Offsets, cross-measure rejection and the unknown-unit throw all live in\n  // convertRaw. Nothing is layered on top here any more.\n  return convertRaw(value, from, to);\n}\n\n/**\n * The unit a measure states its ratios against, found from any unit in it.\n *\n * Read out of the table rather than hard-coded, so it cannot drift from the\n * ratios it has to agree with: the base is whichever unit of that measure has\n * a ratio of exactly one.\n */\nfunction baseUnitFor(unit: string): string {\n  const entry = lookupUnit(resolveUnit(unit));\n  if (entry === undefined) return unit;\n\n  for (const symbol of Object.keys(UNIT_TABLE)) {\n    const candidate = UNIT_TABLE[symbol];\n    if (candidate[0] === entry[0] && candidate[1] === 1) return symbol;\n  }\n  return unit;\n}\n\n/**\n * List every unit symbol in the same measure/dimension as `unit` (wiki:\n * Units-Of-Measurement, \"Conversion Possibilities\", `sourceUnit to ?`\n * e.g. `cm to ?\"` → every Length unit). Excludes `unit` itself.\n *\n * Reads MEASURE_SYMBOLS, which is a curated symbols-only vocabulary and\n * deliberately NOT the keys of the unit table filtered by kind. The two\n * differ: Volume's symbols include `c` and `pt` but not `cup`/`cups`, and\n * Time's include `wk` and `mo` but not `week`/`month`. Deriving this list\n * from the unit table instead would roughly quadruple every answer.\n *\n * @returns `[]` if `unit` isn't recognized, rather than throwing.\n */\nexport function getConvertiblePossibilities(unit: string): string[] {\n  const resolved = resolveUnit(unit);\n  const entry = lookupUnit(resolved);\n  if (entry === undefined) return [];\n  const symbols = MEASURE_SYMBOLS[entry[0]];\n  if (!symbols) return [];\n  return symbols.filter((s) => s !== resolved);\n}\n\n/** Check whether `unit` is a unit the conversion tables recognize. Never throws. */\nexport function isConvertibleUnit(unit: string): boolean {\n  if (isWorkdayUnit(unit)) return true;\n  if (EXTENDED_UNITS[unit]) return true;\n  return lookupUnit(resolveUnit(unit)) !== undefined;\n}\n\n/**\n * Convert `value` (in `unit`) to whichever unit of the same measure gives\n * the most human-readable magnitude, e.g. 1500 metres becomes 1.5 km. Falls\n * back to returning `value`/`unit` unchanged if `unit` isn't recognized,\n * which is what every extended unit and workday does.\n *\n * Note the chosen unit is drawn from the best-unit lists, which are not\n * restricted to spellings the lexer accepts: 0.5 l reports \"mL\".\n */\nexport function getBestUnit(value: number, unit: string): { value: number; unit: string } {\n  const u = resolveUnit(unit);\n  try {\n    const result = convertToBestMetric(value, u);\n    return { value: result.quantity, unit: result.unit };\n  } catch {\n    return { value, unit: u };\n  }\n}\n\n// ── Rate and derived-unit conversion ───────────────────────────────────────\n//\n// A rate value carries a compound unit spelled \"numerator/denominator\" (e.g.\n// \"km/h\", \"m/s\"), see vm/Value.ts's rateValue(). Plain convertUnit() cannot\n// touch one, because neither half is the whole unit and getMeasure(\"km/h\") is\n// undefined. This section converts a rate to another rate, and bridges a rate\n// to the single-token speed spellings (mph, kph, mps, ...) that ExtendedUnits.ts\n// already carries, so \"100 km/h in mph\" and \"60 mph in km/h\" resolve instead of\n// reporting incompatible units.\n\n/** A rate reduced to a numerator unit over a denominator unit. */\ninterface RateForm {\n  /** Magnitude, scaled so `value numerator/denominator` is the physical quantity. */\n  value: number;\n  /** Numerator unit spelling, or `\"\"` for a countless rate such as `30/week`. */\n  numerator: string;\n  /** Denominator unit spelling. */\n  denominator: string;\n}\n\n/**\n * Express `value unit` as a numerator/denominator rate, or `null` when `unit`\n * is neither a compound rate spelling nor a single-token speed alias.\n *\n * A speed alias (mph, kph, ...) is one unit standing for a length/time rate, so\n * it expands to the base pair `m`/`s` with its value scaled by the alias's\n * metres-per-second factor. That collapses both inputs to one shape, so a\n * single routine handles rate/rate and rate/alias without a second code path.\n */\nfunction expandUnitToRate(value: number, unit: string): RateForm | null {\n  const slash = unit.indexOf(\"/\");\n  if (slash >= 0) {\n    return { value, numerator: unit.slice(0, slash), denominator: unit.slice(slash + 1) };\n  }\n  const ext = EXTENDED_UNITS[unit];\n  if (ext !== undefined && ext.measure === \"speed\") {\n    // 1 alias == ext.toBase m/s, so `value alias` is `value * toBase` m/s.\n    return { value: value * ext.toBase, numerator: \"m\", denominator: \"s\" };\n  }\n  return null;\n}\n\n/**\n * The factor that turns one `from` into `to` along a single rate axis, or\n * `null` when the two cannot line up.\n *\n * Same spelling needs no conversion. A countless axis (`\"\"`) only lines up with\n * another countless one, never with a real unit. Otherwise both sides must name\n * the same measure, which is what keeps a length numerator from pairing with a\n * mass one.\n */\nfunction rateAxisFactor(from: string, to: string): number | null {\n  if (from === to) return 1;\n  if (from === \"\" || to === \"\") return null;\n  const fromMeasure = getMeasure(from);\n  const toMeasure = getMeasure(to);\n  if (fromMeasure === undefined || toMeasure === undefined || fromMeasure !== toMeasure) {\n    return null;\n  }\n  return convertUnit(1, from, to);\n}\n\n/**\n * Convert `value` from a rate/speed unit `from` to a rate/speed unit `to`,\n * returning the converted magnitude, or `null` when the pair is not\n * rate-convertible (so the caller falls back to its own incompatible-units\n * handling).\n *\n * Handles rate to rate (`10 m/s in km/h`), rate to speed alias\n * (`100 km/h in mph`) and speed alias to rate (`60 mph in km/h`). Plain\n * same-measure pairs (`kph in mph`, `km in miles`) never reach here, they are\n * resolved by {@link convertUnit} first.\n *\n * The rule is the ordinary one for a quotient of quantities: convert the\n * numerator and the denominator each on their own, so `A/B -> C/D` scales by\n * `(A->C) / (B->D)`.\n */\nexport function convertRate(value: number, from: string, to: string): number | null {\n  const source = expandUnitToRate(value, from);\n  if (source === null) return null;\n\n  // The target is either a rate spelling or a single-token speed alias. An\n  // alias expands to the base m/s pair, and `targetScale` is what the base-form\n  // magnitude is divided by to read out in the alias itself.\n  let targetNumerator: string;\n  let targetDenominator: string;\n  let targetScale: number;\n  const slash = to.indexOf(\"/\");\n  if (slash >= 0) {\n    targetNumerator = to.slice(0, slash);\n    targetDenominator = to.slice(slash + 1);\n    targetScale = 1;\n  } else {\n    const ext = EXTENDED_UNITS[to];\n    if (ext === undefined || ext.measure !== \"speed\") return null;\n    targetNumerator = \"m\";\n    targetDenominator = \"s\";\n    targetScale = ext.toBase;\n  }\n\n  const numeratorFactor = rateAxisFactor(source.numerator, targetNumerator);\n  if (numeratorFactor === null) return null;\n  const denominatorFactor = rateAxisFactor(source.denominator, targetDenominator);\n  if (denominatorFactor === null) return null;\n\n  return (source.value * numeratorFactor) / denominatorFactor / targetScale;\n}\n"]}