solve-engine 1.0.2 → 1.1.1

package/dist/testing.js

@@ -0,0 +1,470 @@
+import { ExpressionEngine, checkPackageCompatibility, checkEngineVersionCompatibility } from './chunk-NNZAEUDW.js';
+import './chunk-I4GAWIPW.js';
+import './chunk-2RWAXT6O.js';
+import './chunk-3VGDNEE3.js';
+import './chunk-FD5ZZHEU.js';
+import './chunk-WXEHD6TT.js';
+import './chunk-CCBZZQAE.js';
+import './chunk-3OWCDIPN.js';
+import './chunk-UKQHXPGW.js';
+import { BUILTIN_PACKAGES } from './chunk-4HQKTMWG.js';
+import './chunk-ENKKJYD3.js';
+import './chunk-BYJBUL7U.js';
+import './chunk-3BOK2LDK.js';
+import './chunk-7KYSUDQO.js';
+import './chunk-NLNDMWZC.js';
+import './chunk-NKW7LKYU.js';
+import './chunk-GCM5JHMX.js';
+import './chunk-Z7XGGLI2.js';
+import './chunk-BLI4NIQY.js';
+import './chunk-Z4X2RWOF.js';
+import './chunk-5HRB36DK.js';
+import './chunk-NNQ2TYDF.js';
+import { Value } from './chunk-267JPOTF.js';
+import './chunk-MVTOCRV2.js';
+import { ENGINE_VERSION } from './chunk-GLA4JXBO.js';
+import './chunk-DLEBSLF4.js';
+import './chunk-UO6BUV6K.js';
+import './chunk-JG6ZJ2WU.js';
+import './chunk-4D6NIHE2.js';
+import './chunk-XBTEO4OB.js';
+import './chunk-SBUFNJVE.js';
+import './chunk-V4XG5QF6.js';
+import { EngineError } from './chunk-ERCOHGXD.js';
+import './chunk-YLJ4XMA6.js';
+
+// src/testing/index.ts
+var ExpectationError = class _ExpectationError extends Error {
+  constructor(init) {
+    super(init.message);
+    this.name = "ExpectationError";
+    this.code = init.code;
+    this.expected = init.expected;
+    this.actual = init.actual;
+    Object.setPrototypeOf(this, _ExpectationError.prototype);
+  }
+};
+function createTestEngine(packages = [], options = {}) {
+  const { locale = "en", includeBuiltins = true } = options;
+  const engine = new ExpressionEngine(locale, false, void 0, void 0, includeBuiltins ? BUILTIN_PACKAGES : []);
+  for (const pkg of packages) {
+    engine.registerPackage(pkg);
+  }
+  return engine;
+}
+function evaluate(engine, expression) {
+  try {
+    const [value] = engine.evaluateExpression(expression);
+    if (value === void 0) {
+      return {
+        status: "error",
+        code: "NO_RESULT",
+        message: "Evaluation returned no value.",
+        source: new Value(13 /* Error */, "NO_RESULT", "Evaluation returned no value.")
+      };
+    }
+    if (value.type === 13 /* Error */) {
+      return {
+        status: "error",
+        code: String(value.value),
+        message: typeof value.unit === "string" ? value.unit : "",
+        source: value
+      };
+    }
+    if (value.type === 12 /* Pending */) {
+      return { status: "pending", value };
+    }
+    return { status: "value", value };
+  } catch (error) {
+    if (error instanceof EngineError) {
+      return { status: "error", code: error.code, message: error.message, source: error };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      status: "error",
+      code: "UNKNOWN_ERROR",
+      message,
+      source: new Value(13 /* Error */, "UNKNOWN_ERROR", message)
+    };
+  }
+}
+function numbersEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (!Number.isFinite(a) || !Number.isFinite(b)) return false;
+  const epsilon = 1e-9 * Math.max(1, Math.abs(a), Math.abs(b));
+  return Math.abs(a - b) <= epsilon;
+}
+function describeValue(value) {
+  if (value.type === 3 /* String */) return JSON.stringify(value.value);
+  if (value.type === 6 /* Uom */ && typeof value.unit === "string") {
+    return `${String(value.value)} ${value.unit}`;
+  }
+  return String(value.value);
+}
+function describeOutcome(outcome) {
+  switch (outcome.status) {
+    case "value":
+      return describeValue(outcome.value);
+    case "pending":
+      return "a pending async value";
+    case "error":
+      return `an error (${outcome.code}: ${outcome.message})`;
+  }
+}
+var ExpressionAssertion = class {
+  constructor(expression, outcome) {
+    this.expression = expression;
+    this.outcome = outcome;
+  }
+  /** The raw resolved {@link Value}, for an assertion the matchers do not cover. Throws if the expression failed. */
+  get value() {
+    if (this.outcome.status === "error") {
+      throw new ExpectationError({
+        code: "EXPECTED_VALUE",
+        message: `Expected "${this.expression}" to evaluate, but it failed with ${describeOutcome(this.outcome)}.`,
+        expected: "a resolved value",
+        actual: describeOutcome(this.outcome)
+      });
+    }
+    return this.outcome.value;
+  }
+  /**
+   * Assert the expression evaluated to a value (not an error, not a pending
+   * async result). Says nothing about what the value is.
+   */
+  toEvaluate() {
+    if (this.outcome.status !== "value") {
+      throw new ExpectationError({
+        code: "EXPECTED_EVALUATE",
+        message: `Expected "${this.expression}" to evaluate to a value, but got ${describeOutcome(this.outcome)}.`,
+        expected: "a resolved value",
+        actual: describeOutcome(this.outcome)
+      });
+    }
+    return this;
+  }
+  /**
+   * Assert the expression evaluated to `expected`, and, when `unit` is given,
+   * that the result carries exactly that unit. A number compares against the
+   * value's numeric magnitude within a small floating-point tolerance; a
+   * string compares against the value's own string; a boolean against its
+   * boolean reading. Omitting `unit` leaves the unit unchecked, so
+   * `toEqual(5)` passes for both `5` and `5 gp`.
+   */
+  toEqual(expected, unit) {
+    if (this.outcome.status !== "value") {
+      throw new ExpectationError({
+        code: "EXPECTED_EQUAL",
+        message: `Expected "${this.expression}" to equal ${describeExpected(expected, unit)}, but got ${describeOutcome(this.outcome)}.`,
+        expected: describeExpected(expected, unit),
+        actual: describeOutcome(this.outcome)
+      });
+    }
+    const value = this.outcome.value;
+    let matches;
+    if (typeof expected === "number") {
+      matches = numbersEqual(value.toNumber(), expected);
+    } else if (typeof expected === "boolean") {
+      matches = value.type === 10 /* Boolean */ && value.value === expected;
+    } else {
+      matches = valueToComparableString(value) === expected;
+    }
+    if (!matches) {
+      throw new ExpectationError({
+        code: "EXPECTED_EQUAL",
+        message: `Expected "${this.expression}" to equal ${describeExpected(expected, unit)}, but it was ${describeValue(value)}.`,
+        expected: describeExpected(expected, unit),
+        actual: describeValue(value)
+      });
+    }
+    if (unit !== void 0 && value.unit !== unit) {
+      throw new ExpectationError({
+        code: "EXPECTED_UNIT",
+        message: `Expected "${this.expression}" to carry the unit "${unit}", but it was ${value.unit === void 0 ? "unitless" : `"${value.unit}"`}.`,
+        expected: `unit "${unit}"`,
+        actual: value.unit === void 0 ? "no unit" : `unit "${value.unit}"`
+      });
+    }
+    return this;
+  }
+  /** Assert the expression failed (a thrown engine error or a plugin-raised error value). Says nothing about the code. */
+  toBeError() {
+    if (this.outcome.status !== "error") {
+      throw new ExpectationError({
+        code: "EXPECTED_ERROR",
+        message: `Expected "${this.expression}" to fail, but it produced ${describeOutcome(this.outcome)}.`,
+        expected: "an error",
+        actual: describeOutcome(this.outcome)
+      });
+    }
+    return this;
+  }
+  /**
+   * Assert the expression failed with exactly `code`, the error catalog code
+   * (e.g. `"UNDEFINED_VARIABLE"`, or a package's own code). Reports the code
+   * it actually got when they differ, so a near-miss is obvious.
+   */
+  toFailWith(code) {
+    if (this.outcome.status !== "error") {
+      throw new ExpectationError({
+        code: "EXPECTED_FAIL_WITH",
+        message: `Expected "${this.expression}" to fail with "${code}", but it produced ${describeOutcome(this.outcome)}.`,
+        expected: `error code "${code}"`,
+        actual: describeOutcome(this.outcome)
+      });
+    }
+    if (this.outcome.code !== code) {
+      throw new ExpectationError({
+        code: "EXPECTED_FAIL_WITH",
+        message: `Expected "${this.expression}" to fail with "${code}", but it failed with "${this.outcome.code}" (${this.outcome.message}).`,
+        expected: `error code "${code}"`,
+        actual: `error code "${this.outcome.code}"`
+      });
+    }
+    return this;
+  }
+  /**
+   * Assert the expression returned a value still resolving asynchronously.
+   * The kit evaluates synchronously, so a package whose result comes from an
+   * async resolver reports pending on first evaluation, this is how a test
+   * confirms the async path was taken without resolving it.
+   */
+  toBePending() {
+    if (this.outcome.status !== "pending") {
+      throw new ExpectationError({
+        code: "EXPECTED_PENDING",
+        message: `Expected "${this.expression}" to be pending, but got ${describeOutcome(this.outcome)}.`,
+        expected: "a pending async value",
+        actual: describeOutcome(this.outcome)
+      });
+    }
+    return this;
+  }
+};
+function describeExpected(expected, unit) {
+  const base = typeof expected === "string" ? JSON.stringify(expected) : String(expected);
+  return unit === void 0 ? base : `${base} ${unit}`;
+}
+function valueToComparableString(value) {
+  return String(value.value);
+}
+function expectExpression(engine, expression) {
+  return new ExpressionAssertion(expression, evaluate(engine, expression));
+}
+var COMMON_PROSE_WORDS = [
+  "a",
+  "an",
+  "and",
+  "or",
+  "but",
+  "if",
+  "then",
+  "the",
+  "this",
+  "that",
+  "these",
+  "those",
+  "in",
+  "on",
+  "at",
+  "to",
+  "of",
+  "for",
+  "from",
+  "with",
+  "by",
+  "as",
+  "per",
+  "into",
+  "over",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "do",
+  "does",
+  "did",
+  "have",
+  "has",
+  "had",
+  "will",
+  "would",
+  "can",
+  "could",
+  "should",
+  "may",
+  "might",
+  "must",
+  "price",
+  "cost",
+  "value",
+  "total",
+  "sum",
+  "count",
+  "rate",
+  "amount",
+  "number",
+  "time",
+  "date",
+  "day",
+  "week",
+  "month",
+  "year",
+  "hour",
+  "minute",
+  "second",
+  "add",
+  "buy",
+  "sell",
+  "hold",
+  "make",
+  "take",
+  "give",
+  "get",
+  "set",
+  "run",
+  "up",
+  "down",
+  "out",
+  "off",
+  "all",
+  "some",
+  "any",
+  "no",
+  "not",
+  "more",
+  "less",
+  "one",
+  "two",
+  "three",
+  "first",
+  "last",
+  "next",
+  "each",
+  "every",
+  "here",
+  "there"
+];
+var SEVERITY_ORDER = ["error", "warning", "info"];
+function claimedWords(pkg) {
+  const claimed = [];
+  const vocab = pkg.lexerVocabulary;
+  if (vocab?.keywords) {
+    for (const [word, tokenType] of Object.entries(vocab.keywords)) {
+      claimed.push({ word, via: "keyword", tokenType });
+    }
+  }
+  if (vocab?.units) {
+    for (const word of vocab.units) {
+      claimed.push({ word, via: "unit" });
+    }
+  }
+  if (vocab?.operators) {
+    for (const [word, tokenType] of Object.entries(vocab.operators)) {
+      claimed.push({ word, via: "operator", tokenType });
+    }
+  }
+  if (pkg.phrases) {
+    for (const [phrase, tokenType] of Object.entries(pkg.phrases)) {
+      if (!phrase.includes(" ")) {
+        claimed.push({ word: phrase, via: "phrase", tokenType });
+      }
+    }
+  }
+  return claimed;
+}
+var PackageAssertion = class {
+  constructor(pkg) {
+    this.pkg = pkg;
+  }
+  /**
+   * Assert none of the package's claimed words shadow a prose word.
+   *
+   * A trigger word that is also an ordinary word turns a line of prose into
+   * arithmetic, the single most common package mistake and the subject of the
+   * trigger-words guide. This checks the words the package declares
+   * (lexer keywords, units, operators, and single-word phrases) against
+   * `words` (defaulting to {@link COMMON_PROSE_WORDS}), case-insensitively.
+   *
+   * @returns the shadowed words, empty when the package is clean, for a test
+   * that wants to inspect rather than assert.
+   */
+  notToShadow(words = COMMON_PROSE_WORDS) {
+    const prose = new Set(words.map((w) => w.toLowerCase()));
+    const shadowed = claimedWords(this.pkg).filter((c) => prose.has(c.word.toLowerCase()));
+    if (shadowed.length > 0) {
+      const list = shadowed.map((s) => `"${s.word}" (${s.via})`).join(", ");
+      throw new ExpectationError({
+        code: "PACKAGE_SHADOWS_PROSE",
+        message: `Package "${this.pkg.name}" claims prose word(s) as syntax: ${list}. A word that is also ordinary English turns prose into arithmetic; prefer a multi-word phrase or a form that requires a parenthesis.`,
+        expected: "no prose words claimed as syntax",
+        actual: list
+      });
+    }
+    return shadowed;
+  }
+  /**
+   * Assert the package does not collide with any of `others` in a way that
+   * would silently break one of them (two packages claiming the same lexer
+   * keyword, plugin-function index, async-resolver namespace, and so on).
+   *
+   * `strictness` sets which severities fail the assertion: `"error"` (the
+   * default) fails only on the collisions that always break something,
+   * `"warning"` also fails on the ones that silently pick a winner, `"info"`
+   * fails on cosmetic overlaps too.
+   *
+   * @returns the full compatibility report, so a test can inspect every
+   * conflict, including ones below the strictness threshold.
+   */
+  notToCollideWith(others, strictness = "error") {
+    const report = checkPackageCompatibility(this.pkg, others);
+    const threshold = SEVERITY_ORDER.indexOf(strictness);
+    const failing = report.conflicts.filter(
+      (c) => SEVERITY_ORDER.indexOf(c.severity) <= threshold
+    );
+    if (failing.length > 0) {
+      const list = failing.map((c) => `[${c.severity}] ${c.detail}`).join("\n");
+      throw new ExpectationError({
+        code: "PACKAGE_VOCABULARY_COLLISION",
+        message: `Package "${this.pkg.name}" collides with another package:
+${list}`,
+        expected: `no conflicts at or above "${strictness}" severity`,
+        actual: `${failing.length} conflict(s)`
+      });
+    }
+    return report;
+  }
+  /**
+   * Assert the package's declared `engineVersion` range is satisfied by the
+   * running engine (or by `engineVersion` when given).
+   *
+   * A package that declares a range and never checks it resolves is the third
+   * mistake the issue names: it looks fine until the one engine version it
+   * cannot run against, where the range either fails to match or turns out to
+   * be a malformed string. A package with no declared range passes (no
+   * constraint is always compatible).
+   */
+  toDeclareCompatibleEngineVersion(engineVersion = ENGINE_VERSION) {
+    const result = checkEngineVersionCompatibility(this.pkg, engineVersion);
+    if (!result.compatible) {
+      const detail = result.reason === "invalid-range" ? `its range "${result.declaredRange}" is not valid semver` : `its range "${result.declaredRange}" is not satisfied by engine version "${result.engineVersion}"`;
+      throw new ExpectationError({
+        code: "PACKAGE_ENGINE_VERSION_INCOMPATIBLE",
+        message: `Package "${this.pkg.name}" declares an engineVersion that will be rejected at registration: ${detail}.`,
+        expected: `an engineVersion satisfied by "${engineVersion}"`,
+        actual: `"${result.declaredRange}"`
+      });
+    }
+    return this;
+  }
+};
+function expectPackage(pkg) {
+  return new PackageAssertion(pkg);
+}
+
+export { COMMON_PROSE_WORDS, ExpectationError, ExpressionAssertion, PackageAssertion, createTestEngine, expectExpression, expectPackage };
+//# sourceMappingURL=testing.js.map
+//# sourceMappingURL=testing.js.map

package/dist/testing.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/testing/index.ts"],"names":[],"mappings":"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","file":"testing.js","sourcesContent":["/**\n * A test kit for package authors, the supported way to test a package by the\n * expressions it enables rather than by the opcodes it emits.\n *\n * Before this entry point a package author had two options, both bad: reach\n * into engine internals, or assert on whatever bytecode a parselet happened to\n * emit. The first is unstable across engine versions, the second pins the\n * implementation instead of the behaviour, so a refactor that keeps every\n * answer correct still breaks the tests. This module is a thin, dependency-free\n * layer over the same public surface a host uses: it constructs an\n * {@link ExpressionEngine} with the given packages and evaluates strings.\n *\n * It speaks in expressions. {@link expectExpression} evaluates a string and\n * asserts on the result or the failure code; {@link expectPackage} asserts on\n * the three mistakes a package actually makes (shadowing prose, colliding with\n * another package's vocabulary, and declaring an `engineVersion` range that the\n * running engine does not satisfy).\n *\n * Framework-agnostic on purpose. Nothing here imports jest, vitest or any\n * runner: an assertion that fails throws an {@link ExpectationError}, and one\n * that passes returns, so the kit drops into whatever runner the author already\n * has (or into a plain script, or `node:assert`). Runtime dependency-free and\n * side-effect free, so `solve-engine/testing` stays honest under the package's\n * `\"sideEffects\": false` contract.\n *\n * @example\n * ```ts\n * import { createTestEngine, expectExpression } from \"solve-engine/testing\";\n *\n * const engine = createTestEngine([myPackage]);\n * expectExpression(engine, \"2 gp + 3 gp\").toEqual(5, \"gp\");\n * expectExpression(engine, \"gp\").toFailWith(\"UNDEFINED_VARIABLE\");\n * ```\n */\n\nimport { ExpressionEngine } from \"@solve-js/engine/ExpressionEngine\";\nimport { BUILTIN_PACKAGES } from \"@solve-js/packages/builtins\";\nimport type { IEnginePackage } from \"@solve-js/api/PackageRegistry\";\nimport { Value, ValueType } from \"@solve-js/vm/Value\";\nimport { EngineError } from \"@solve-js/errors/EngineError\";\nimport {\n\tcheckPackageCompatibility,\n\ttype CompatibilityReport,\n\ttype CompatibilityConflict,\n\ttype CompatibilitySeverity,\n} from \"@solve-js/api/PackageCompatibility\";\nimport { checkEngineVersionCompatibility } from \"@solve-js/api/EngineVersionCompatibility\";\nimport { ENGINE_VERSION } from \"@solve-js/constants/version\";\n\n//#region Errors\n\n/**\n * The failure a matcher throws when an expectation is not met.\n *\n * A dedicated `Error` subclass rather than a bare `throw new Error`, so a\n * caller (or a reporter) can tell a kit assertion failure apart from an\n * unrelated exception with `instanceof`, and so the structured `expected` and\n * `actual` fields survive alongside the human-readable message. This is NOT an\n * {@link EngineError}: that type classifies pipeline-stage failures inside the\n * engine, whereas this classifies a test-assertion mismatch, a different\n * concern that would be miscategorised under any of `EngineError`'s categories.\n */\nexport class ExpectationError extends Error {\n\t/** A short, machine-readable label for which expectation failed. */\n\treadonly code: string;\n\t/** What the matcher was told to expect, in plain words. */\n\treadonly expected?: string;\n\t/** What it found instead. */\n\treadonly actual?: string;\n\n\tconstructor(init: { code: string; message: string; expected?: string; actual?: string }) {\n\t\tsuper(init.message);\n\t\tthis.name = \"ExpectationError\";\n\t\tthis.code = init.code;\n\t\tthis.expected = init.expected;\n\t\tthis.actual = init.actual;\n\t\t// Restore the prototype chain across the ES5 `Error` transpile target,\n\t\t// so `instanceof ExpectationError` holds for callers.\n\t\tObject.setPrototypeOf(this, ExpectationError.prototype);\n\t}\n}\n\n//#endregion\n\n//#region createTestEngine\n\n/** Options for {@link createTestEngine}. */\nexport interface TestEngineOptions {\n\t/** Locale passed to the engine. Defaults to `\"en\"`. */\n\tlocale?: string;\n\t/**\n\t * Whether to load the engine's built-in packages (arithmetic, units, dates,\n\t * and the rest) before the packages under test. Defaults to `true`, because\n\t * almost every package builds on arithmetic and most authors want a\n\t * realistic engine. Set `false` to test a package in isolation.\n\t */\n\tincludeBuiltins?: boolean;\n}\n\n/**\n * Build an {@link ExpressionEngine} loaded with the packages under test.\n *\n * The built-in packages load first (unless {@link TestEngineOptions.includeBuiltins}\n * is `false`), then each package in `packages` is registered in order, exactly\n * as a host would. Registration is honest: a package whose declared\n * `engineVersion` the running engine does not satisfy, or whose lexer keyword\n * collides with a built-in, throws here rather than being swallowed. That is\n * deliberately different from passing packages straight to the\n * `ExpressionEngine` constructor, which contains a bad package by logging and\n * continuing, useful in production, wrong for a test that needs to know the\n * package it is testing actually loaded.\n *\n * Call {@link ExpressionEngine.clear} when a test is finished with the engine\n * if the test creates many, see the engine's own lifecycle note.\n *\n * @example\n * ```ts\n * const engine = createTestEngine([myPackage]);\n * const engineOnly = createTestEngine([myPackage], { includeBuiltins: false });\n * ```\n */\nexport function createTestEngine(\n\tpackages: IEnginePackage[] = [],\n\toptions: TestEngineOptions = {},\n): ExpressionEngine {\n\tconst { locale = \"en\", includeBuiltins = true } = options;\n\n\t// Built-ins go through the constructor (their own containment applies);\n\t// the packages under test go through registerPackage() afterwards so their\n\t// failures surface as thrown errors instead of being logged and skipped.\n\tconst engine = new ExpressionEngine(locale, false, undefined, undefined, includeBuiltins ? BUILTIN_PACKAGES : []);\n\tfor (const pkg of packages) {\n\t\tengine.registerPackage(pkg);\n\t}\n\treturn engine;\n}\n\n//#endregion\n\n//#region expectExpression\n\n/**\n * The normalised outcome of evaluating one expression, computed once when\n * {@link expectExpression} runs and read by every matcher on the result.\n *\n * The engine surfaces a failure two different ways, and a package author should\n * not have to know which: a parse/eval error is THROWN as an\n * {@link EngineError} (with a `.code`), while a plugin-raised error is RETURNED\n * as a {@link Value} of {@link ValueType.Error} (its `value` is the code, its\n * `unit` is the message). Both collapse to the `\"error\"` status here. A value\n * still resolving asynchronously is its own `\"pending\"` status, since the kit\n * evaluates synchronously and cannot report a final number for it.\n */\ntype Outcome =\n\t| { status: \"value\"; value: Value }\n\t| { status: \"pending\"; value: Value }\n\t| { status: \"error\"; code: string; message: string; source: EngineError | Value };\n\n/** Evaluate `expression` on `engine` and collapse both failure shapes to one outcome. */\nfunction evaluate(engine: ExpressionEngine, expression: string): Outcome {\n\ttry {\n\t\tconst [value] = engine.evaluateExpression(expression);\n\t\tif (value === undefined) {\n\t\t\t// evaluateExpression() always returns a single-element array; an\n\t\t\t// empty one would be an engine invariant break, reported as such\n\t\t\t// rather than as a silent pass.\n\t\t\treturn {\n\t\t\t\tstatus: \"error\",\n\t\t\t\tcode: \"NO_RESULT\",\n\t\t\t\tmessage: \"Evaluation returned no value.\",\n\t\t\t\tsource: new Value(ValueType.Error, \"NO_RESULT\", \"Evaluation returned no value.\"),\n\t\t\t};\n\t\t}\n\t\tif (value.type === ValueType.Error) {\n\t\t\treturn {\n\t\t\t\tstatus: \"error\",\n\t\t\t\tcode: String(value.value),\n\t\t\t\tmessage: typeof value.unit === \"string\" ? value.unit : \"\",\n\t\t\t\tsource: value,\n\t\t\t};\n\t\t}\n\t\tif (value.type === ValueType.Pending) {\n\t\t\treturn { status: \"pending\", value };\n\t\t}\n\t\treturn { status: \"value\", value };\n\t} catch (error) {\n\t\tif (error instanceof EngineError) {\n\t\t\treturn { status: \"error\", code: error.code, message: error.message, source: error };\n\t\t}\n\t\t// Anything else thrown (a bug in a plugin handler, say) is still a\n\t\t// failure, wrapped so the matcher has a code and message to report.\n\t\tconst message = error instanceof Error ? error.message : String(error);\n\t\treturn {\n\t\t\tstatus: \"error\",\n\t\t\tcode: \"UNKNOWN_ERROR\",\n\t\t\tmessage,\n\t\t\tsource: new Value(ValueType.Error, \"UNKNOWN_ERROR\", message),\n\t\t};\n\t}\n}\n\n/** Whether two numbers are equal within a small tolerance scaled to their magnitude. */\nfunction numbersEqual(a: number, b: number): boolean {\n\tif (Object.is(a, b)) return true;\n\tif (!Number.isFinite(a) || !Number.isFinite(b)) return false;\n\tconst epsilon = 1e-9 * Math.max(1, Math.abs(a), Math.abs(b));\n\treturn Math.abs(a - b) <= epsilon;\n}\n\n/** A short, readable rendering of a value for an assertion message, e.g. `5 gp` or `\"abc\"`. */\nfunction describeValue(value: Value): string {\n\tif (value.type === ValueType.String) return JSON.stringify(value.value);\n\tif (value.type === ValueType.Uom && typeof value.unit === \"string\") {\n\t\treturn `${String(value.value)} ${value.unit}`;\n\t}\n\treturn String(value.value);\n}\n\n/** A short, readable rendering of an outcome for an assertion message. */\nfunction describeOutcome(outcome: Outcome): string {\n\tswitch (outcome.status) {\n\t\tcase \"value\":\n\t\t\treturn describeValue(outcome.value);\n\t\tcase \"pending\":\n\t\t\treturn \"a pending async value\";\n\t\tcase \"error\":\n\t\t\treturn `an error (${outcome.code}: ${outcome.message})`;\n\t}\n}\n\n/**\n * Assertions about the result of one evaluated expression, returned by\n * {@link expectExpression}. Every matcher returns `this`, so assertions chain,\n * and throws an {@link ExpectationError} when it fails.\n */\nexport class ExpressionAssertion {\n\tconstructor(\n\t\tprivate readonly expression: string,\n\t\tprivate readonly outcome: Outcome,\n\t) {}\n\n\t/** The raw resolved {@link Value}, for an assertion the matchers do not cover. Throws if the expression failed. */\n\tget value(): Value {\n\t\tif (this.outcome.status === \"error\") {\n\t\t\tthrow new ExpectationError({\n\t\t\t\tcode: \"EXPECTED_VALUE\",\n\t\t\t\tmessage: `Expected \"${this.expression}\" to evaluate, but it failed with ${describeOutcome(this.outcome)}.`,\n\t\t\t\texpected: \"a resolved value\",\n\t\t\t\tactual: describeOutcome(this.outcome),\n\t\t\t});\n\t\t}\n\t\treturn this.outcome.value;\n\t}\n\n\t/**\n\t * Assert the expression evaluated to a value (not an error, not a pending\n\t * async result). Says nothing about what the value is.\n\t */\n\ttoEvaluate(): this {\n\t\tif (this.outcome.status !== \"value\") {\n\t\t\tthrow new ExpectationError({\n\t\t\t\tcode: \"EXPECTED_EVALUATE\",\n\t\t\t\tmessage: `Expected \"${this.expression}\" to evaluate to a value, but got ${describeOutcome(this.outcome)}.`,\n\t\t\t\texpected: \"a resolved value\",\n\t\t\t\tactual: describeOutcome(this.outcome),\n\t\t\t});\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Assert the expression evaluated to `expected`, and, when `unit` is given,\n\t * that the result carries exactly that unit. A number compares against the\n\t * value's numeric magnitude within a small floating-point tolerance; a\n\t * string compares against the value's own string; a boolean against its\n\t * boolean reading. Omitting `unit` leaves the unit unchecked, so\n\t * `toEqual(5)` passes for both `5` and `5 gp`.\n\t */\n\ttoEqual(expected: number | string | boolean, unit?: string): this {\n\t\tif (this.outcome.status !== \"value\") {\n\t\t\tthrow new ExpectationError({\n\t\t\t\tcode: \"EXPECTED_EQUAL\",\n\t\t\t\tmessage: `Expected \"${this.expression}\" to equal ${describeExpected(expected, unit)}, but got ${describeOutcome(this.outcome)}.`,\n\t\t\t\texpected: describeExpected(expected, unit),\n\t\t\t\tactual: describeOutcome(this.outcome),\n\t\t\t});\n\t\t}\n\n\t\tconst value = this.outcome.value;\n\t\tlet matches: boolean;\n\t\tif (typeof expected === \"number\") {\n\t\t\tmatches = numbersEqual(value.toNumber(), expected);\n\t\t} else if (typeof expected === \"boolean\") {\n\t\t\t// A Boolean value stores the primitive directly; anything else can\n\t\t\t// never equal a boolean, so a mismatch reports the real value.\n\t\t\tmatches = value.type === ValueType.Boolean && value.value === expected;\n\t\t} else {\n\t\t\tmatches = valueToComparableString(value) === expected;\n\t\t}\n\n\t\tif (!matches) {\n\t\t\tthrow new ExpectationError({\n\t\t\t\tcode: \"EXPECTED_EQUAL\",\n\t\t\t\tmessage: `Expected \"${this.expression}\" to equal ${describeExpected(expected, unit)}, but it was ${describeValue(value)}.`,\n\t\t\t\texpected: describeExpected(expected, unit),\n\t\t\t\tactual: describeValue(value),\n\t\t\t});\n\t\t}\n\n\t\tif (unit !== undefined && value.unit !== unit) {\n\t\t\tthrow new ExpectationError({\n\t\t\t\tcode: \"EXPECTED_UNIT\",\n\t\t\t\tmessage: `Expected \"${this.expression}\" to carry the unit \"${unit}\", but it was ${value.unit === undefined ? \"unitless\" : `\"${value.unit}\"`}.`,\n\t\t\t\texpected: `unit \"${unit}\"`,\n\t\t\t\tactual: value.unit === undefined ? \"no unit\" : `unit \"${value.unit}\"`,\n\t\t\t});\n\t\t}\n\n\t\treturn this;\n\t}\n\n\t/** Assert the expression failed (a thrown engine error or a plugin-raised error value). Says nothing about the code. */\n\ttoBeError(): this {\n\t\tif (this.outcome.status !== \"error\") {\n\t\t\tthrow new ExpectationError({\n\t\t\t\tcode: \"EXPECTED_ERROR\",\n\t\t\t\tmessage: `Expected \"${this.expression}\" to fail, but it produced ${describeOutcome(this.outcome)}.`,\n\t\t\t\texpected: \"an error\",\n\t\t\t\tactual: describeOutcome(this.outcome),\n\t\t\t});\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Assert the expression failed with exactly `code`, the error catalog code\n\t * (e.g. `\"UNDEFINED_VARIABLE\"`, or a package's own code). Reports the code\n\t * it actually got when they differ, so a near-miss is obvious.\n\t */\n\ttoFailWith(code: string): this {\n\t\tif (this.outcome.status !== \"error\") {\n\t\t\tthrow new ExpectationError({\n\t\t\t\tcode: \"EXPECTED_FAIL_WITH\",\n\t\t\t\tmessage: `Expected \"${this.expression}\" to fail with \"${code}\", but it produced ${describeOutcome(this.outcome)}.`,\n\t\t\t\texpected: `error code \"${code}\"`,\n\t\t\t\tactual: describeOutcome(this.outcome),\n\t\t\t});\n\t\t}\n\t\tif (this.outcome.code !== code) {\n\t\t\tthrow new ExpectationError({\n\t\t\t\tcode: \"EXPECTED_FAIL_WITH\",\n\t\t\t\tmessage: `Expected \"${this.expression}\" to fail with \"${code}\", but it failed with \"${this.outcome.code}\" (${this.outcome.message}).`,\n\t\t\t\texpected: `error code \"${code}\"`,\n\t\t\t\tactual: `error code \"${this.outcome.code}\"`,\n\t\t\t});\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Assert the expression returned a value still resolving asynchronously.\n\t * The kit evaluates synchronously, so a package whose result comes from an\n\t * async resolver reports pending on first evaluation, this is how a test\n\t * confirms the async path was taken without resolving it.\n\t */\n\ttoBePending(): this {\n\t\tif (this.outcome.status !== \"pending\") {\n\t\t\tthrow new ExpectationError({\n\t\t\t\tcode: \"EXPECTED_PENDING\",\n\t\t\t\tmessage: `Expected \"${this.expression}\" to be pending, but got ${describeOutcome(this.outcome)}.`,\n\t\t\t\texpected: \"a pending async value\",\n\t\t\t\tactual: describeOutcome(this.outcome),\n\t\t\t});\n\t\t}\n\t\treturn this;\n\t}\n}\n\n/** Render an expected value (with optional unit) for an assertion message. */\nfunction describeExpected(expected: number | string | boolean, unit?: string): string {\n\tconst base = typeof expected === \"string\" ? JSON.stringify(expected) : String(expected);\n\treturn unit === undefined ? base : `${base} ${unit}`;\n}\n\n/** The string a non-numeric value compares against in {@link ExpressionAssertion.toEqual}. */\nfunction valueToComparableString(value: Value): string {\n\t// The stored primitive stringified. For a String value this is the string\n\t// itself; for a Hex value, its `0x...` text, which is what an author writes\n\t// in a `toEqual(\"0xff\")` assertion.\n\treturn String(value.value);\n}\n\n/**\n * Evaluate `expression` on `engine` and return an assertion object.\n *\n * The expression is evaluated once, immediately, and every matcher reads that\n * one outcome, so calling several matchers on the same result does not\n * re-evaluate.\n *\n * @example\n * ```ts\n * expectExpression(engine, \"2 gp + 3 gp\").toEqual(5, \"gp\");\n * expectExpression(engine, \"gp\").toFailWith(\"UNDEFINED_VARIABLE\");\n * ```\n */\nexport function expectExpression(engine: ExpressionEngine, expression: string): ExpressionAssertion {\n\treturn new ExpressionAssertion(expression, evaluate(engine, expression));\n}\n\n//#endregion\n\n//#region expectPackage\n\n/**\n * A modest set of everyday English words a package's keywords should not claim.\n *\n * A starting point for {@link PackageAssertion.notToShadow}, not an exhaustive\n * dictionary: it leans on the function words and common nouns/verbs a package\n * is most tempted to grab as a trigger (`price`, `of`, `per`, `sum`, `total`).\n * Pass your own list to check against the specific prose your package sits in.\n */\nexport const COMMON_PROSE_WORDS: readonly string[] = [\n\t\"a\", \"an\", \"and\", \"or\", \"but\", \"if\", \"then\", \"the\", \"this\", \"that\", \"these\", \"those\",\n\t\"in\", \"on\", \"at\", \"to\", \"of\", \"for\", \"from\", \"with\", \"by\", \"as\", \"per\", \"into\", \"over\",\n\t\"is\", \"are\", \"was\", \"were\", \"be\", \"been\", \"being\", \"do\", \"does\", \"did\", \"have\", \"has\", \"had\",\n\t\"will\", \"would\", \"can\", \"could\", \"should\", \"may\", \"might\", \"must\",\n\t\"price\", \"cost\", \"value\", \"total\", \"sum\", \"count\", \"rate\", \"amount\", \"number\",\n\t\"time\", \"date\", \"day\", \"week\", \"month\", \"year\", \"hour\", \"minute\", \"second\",\n\t\"add\", \"buy\", \"sell\", \"hold\", \"make\", \"take\", \"give\", \"get\", \"set\", \"run\",\n\t\"up\", \"down\", \"out\", \"off\", \"all\", \"some\", \"any\", \"no\", \"not\", \"more\", \"less\",\n\t\"one\", \"two\", \"three\", \"first\", \"last\", \"next\", \"each\", \"every\", \"here\", \"there\",\n];\n\n/** How strict {@link PackageAssertion.notToCollideWith} is about the conflicts it will accept. */\nexport type CollisionStrictness = \"error\" | \"warning\" | \"info\";\n\n/** One shadowed word found by {@link PackageAssertion.notToShadow}: the prose word and how the package claims it. */\nexport interface ShadowedWord {\n\t/** The prose word the package claims. */\n\tword: string;\n\t/** Which descriptor field claims it. */\n\tvia: \"keyword\" | \"unit\" | \"operator\" | \"phrase\";\n\t/** The token type the word becomes, when the field maps to one. */\n\ttokenType?: string;\n}\n\n/** Severities at or above the strictness threshold, ordered most to least severe. */\nconst SEVERITY_ORDER: CompatibilitySeverity[] = [\"error\", \"warning\", \"info\"];\n\n/** Gather the single words a package claims through its declared vocabulary, which is where prose shadowing comes from. */\nfunction claimedWords(pkg: IEnginePackage): ShadowedWord[] {\n\tconst claimed: ShadowedWord[] = [];\n\tconst vocab = pkg.lexerVocabulary;\n\tif (vocab?.keywords) {\n\t\tfor (const [word, tokenType] of Object.entries(vocab.keywords)) {\n\t\t\tclaimed.push({ word, via: \"keyword\", tokenType });\n\t\t}\n\t}\n\tif (vocab?.units) {\n\t\tfor (const word of vocab.units) {\n\t\t\tclaimed.push({ word, via: \"unit\" });\n\t\t}\n\t}\n\tif (vocab?.operators) {\n\t\tfor (const [word, tokenType] of Object.entries(vocab.operators)) {\n\t\t\tclaimed.push({ word, via: \"operator\", tokenType });\n\t\t}\n\t}\n\tif (pkg.phrases) {\n\t\tfor (const [phrase, tokenType] of Object.entries(pkg.phrases)) {\n\t\t\t// A multi-word phrase is the SAFE pattern the trigger-words guide\n\t\t\t// recommends (`next friday` reserves neither word), so only a\n\t\t\t// single-word phrase can shadow a prose word.\n\t\t\tif (!phrase.includes(\" \")) {\n\t\t\t\tclaimed.push({ word: phrase, via: \"phrase\", tokenType });\n\t\t\t}\n\t\t}\n\t}\n\treturn claimed;\n}\n\n/**\n * Assertions about a package's declared descriptor, returned by\n * {@link expectPackage}. These catch the three mistakes the issue calls out,\n * before the package is ever registered. Every matcher returns `this` and\n * throws an {@link ExpectationError} when it fails.\n */\nexport class PackageAssertion {\n\tconstructor(private readonly pkg: IEnginePackage) {}\n\n\t/**\n\t * Assert none of the package's claimed words shadow a prose word.\n\t *\n\t * A trigger word that is also an ordinary word turns a line of prose into\n\t * arithmetic, the single most common package mistake and the subject of the\n\t * trigger-words guide. This checks the words the package declares\n\t * (lexer keywords, units, operators, and single-word phrases) against\n\t * `words` (defaulting to {@link COMMON_PROSE_WORDS}), case-insensitively.\n\t *\n\t * @returns the shadowed words, empty when the package is clean, for a test\n\t * that wants to inspect rather than assert.\n\t */\n\tnotToShadow(words: readonly string[] = COMMON_PROSE_WORDS): ShadowedWord[] {\n\t\tconst prose = new Set(words.map((w) => w.toLowerCase()));\n\t\tconst shadowed = claimedWords(this.pkg).filter((c) => prose.has(c.word.toLowerCase()));\n\t\tif (shadowed.length > 0) {\n\t\t\tconst list = shadowed.map((s) => `\"${s.word}\" (${s.via})`).join(\", \");\n\t\t\tthrow new ExpectationError({\n\t\t\t\tcode: \"PACKAGE_SHADOWS_PROSE\",\n\t\t\t\tmessage: `Package \"${this.pkg.name}\" claims prose word(s) as syntax: ${list}. A word that is also ordinary English turns prose into arithmetic; prefer a multi-word phrase or a form that requires a parenthesis.`,\n\t\t\t\texpected: \"no prose words claimed as syntax\",\n\t\t\t\tactual: list,\n\t\t\t});\n\t\t}\n\t\treturn shadowed;\n\t}\n\n\t/**\n\t * Assert the package does not collide with any of `others` in a way that\n\t * would silently break one of them (two packages claiming the same lexer\n\t * keyword, plugin-function index, async-resolver namespace, and so on).\n\t *\n\t * `strictness` sets which severities fail the assertion: `\"error\"` (the\n\t * default) fails only on the collisions that always break something,\n\t * `\"warning\"` also fails on the ones that silently pick a winner, `\"info\"`\n\t * fails on cosmetic overlaps too.\n\t *\n\t * @returns the full compatibility report, so a test can inspect every\n\t * conflict, including ones below the strictness threshold.\n\t */\n\tnotToCollideWith(\n\t\tothers: IEnginePackage[],\n\t\tstrictness: CollisionStrictness = \"error\",\n\t): CompatibilityReport {\n\t\tconst report = checkPackageCompatibility(this.pkg, others);\n\t\tconst threshold = SEVERITY_ORDER.indexOf(strictness);\n\t\tconst failing = report.conflicts.filter(\n\t\t\t(c: CompatibilityConflict) => SEVERITY_ORDER.indexOf(c.severity) <= threshold,\n\t\t);\n\t\tif (failing.length > 0) {\n\t\t\tconst list = failing.map((c) => `[${c.severity}] ${c.detail}`).join(\"\\n\");\n\t\t\tthrow new ExpectationError({\n\t\t\t\tcode: \"PACKAGE_VOCABULARY_COLLISION\",\n\t\t\t\tmessage: `Package \"${this.pkg.name}\" collides with another package:\\n${list}`,\n\t\t\t\texpected: `no conflicts at or above \"${strictness}\" severity`,\n\t\t\t\tactual: `${failing.length} conflict(s)`,\n\t\t\t});\n\t\t}\n\t\treturn report;\n\t}\n\n\t/**\n\t * Assert the package's declared `engineVersion` range is satisfied by the\n\t * running engine (or by `engineVersion` when given).\n\t *\n\t * A package that declares a range and never checks it resolves is the third\n\t * mistake the issue names: it looks fine until the one engine version it\n\t * cannot run against, where the range either fails to match or turns out to\n\t * be a malformed string. A package with no declared range passes (no\n\t * constraint is always compatible).\n\t */\n\ttoDeclareCompatibleEngineVersion(engineVersion: string = ENGINE_VERSION): this {\n\t\tconst result = checkEngineVersionCompatibility(this.pkg, engineVersion);\n\t\tif (!result.compatible) {\n\t\t\tconst detail =\n\t\t\t\tresult.reason === \"invalid-range\"\n\t\t\t\t\t? `its range \"${result.declaredRange}\" is not valid semver`\n\t\t\t\t\t: `its range \"${result.declaredRange}\" is not satisfied by engine version \"${result.engineVersion}\"`;\n\t\t\tthrow new ExpectationError({\n\t\t\t\tcode: \"PACKAGE_ENGINE_VERSION_INCOMPATIBLE\",\n\t\t\t\tmessage: `Package \"${this.pkg.name}\" declares an engineVersion that will be rejected at registration: ${detail}.`,\n\t\t\t\texpected: `an engineVersion satisfied by \"${engineVersion}\"`,\n\t\t\t\tactual: `\"${result.declaredRange}\"`,\n\t\t\t});\n\t\t}\n\t\treturn this;\n\t}\n}\n\n/**\n * Begin an assertion about a package's declared descriptor.\n *\n * @example\n * ```ts\n * expectPackage(myPackage).notToShadow([\"price\", \"in\", \"of\"]);\n * expectPackage(myPackage).notToCollideWith(BUILTIN_PACKAGES);\n * expectPackage(myPackage).toDeclareCompatibleEngineVersion();\n * ```\n */\nexport function expectPackage(pkg: IEnginePackage): PackageAssertion {\n\treturn new PackageAssertion(pkg);\n}\n\n//#endregion\n"]}

package/dist/uom.cjs

@@ -1,56 +1,56 @@
 'use strict';
 
-var chunk4B2CNWQU_cjs = require('./chunk-4B2CNWQU.cjs');
-var chunkA2N2GFCG_cjs = require('./chunk-A2N2GFCG.cjs');
-require('./chunk-6KFYJ6TD.cjs');
+var chunkSSV46KFA_cjs = require('./chunk-SSV46KFA.cjs');
+var chunkZVTWQLK4_cjs = require('./chunk-ZVTWQLK4.cjs');
+require('./chunk-XIYYHA65.cjs');
 require('./chunk-VEKIWQ3F.cjs');
-require('./chunk-JMXUNXQS.cjs');
-var chunkPFUESQTW_cjs = require('./chunk-PFUESQTW.cjs');
+require('./chunk-2TZKENDH.cjs');
+var chunkEJ3ILXX6_cjs = require('./chunk-EJ3ILXX6.cjs');
 require('./chunk-AMOJYLG2.cjs');
-require('./chunk-5KMIY374.cjs');
+require('./chunk-B4HBEFTB.cjs');
 require('./chunk-B7LXJ6LC.cjs');
 
 
 
 Object.defineProperty(exports, "CurrencyAsyncResolver", {
   enumerable: true,
-  get: function () { return chunk4B2CNWQU_cjs.CurrencyAsyncResolver; }
+  get: function () { return chunkSSV46KFA_cjs.CurrencyAsyncResolver; }
 });
 Object.defineProperty(exports, "CurrencyExchangeService", {
   enumerable: true,
-  get: function () { return chunkA2N2GFCG_cjs.CurrencyExchangeService; }
+  get: function () { return chunkZVTWQLK4_cjs.CurrencyExchangeService; }
 });
 Object.defineProperty(exports, "currencyExchangeService", {
   enumerable: true,
-  get: function () { return chunkA2N2GFCG_cjs.currencyExchangeService; }
+  get: function () { return chunkZVTWQLK4_cjs.currencyExchangeService; }
 });
 Object.defineProperty(exports, "sharedCurrencyExchange", {
   enumerable: true,
-  get: function () { return chunkA2N2GFCG_cjs.sharedCurrencyExchange; }
+  get: function () { return chunkZVTWQLK4_cjs.sharedCurrencyExchange; }
 });
 Object.defineProperty(exports, "canConvert", {
   enumerable: true,
-  get: function () { return chunkPFUESQTW_cjs.canConvert; }
+  get: function () { return chunkEJ3ILXX6_cjs.canConvert; }
 });
 Object.defineProperty(exports, "convertUnit", {
   enumerable: true,
-  get: function () { return chunkPFUESQTW_cjs.convertUnit; }
+  get: function () { return chunkEJ3ILXX6_cjs.convertUnit; }
 });
 Object.defineProperty(exports, "getBestUnit", {
   enumerable: true,
-  get: function () { return chunkPFUESQTW_cjs.getBestUnit; }
+  get: function () { return chunkEJ3ILXX6_cjs.getBestUnit; }
 });
 Object.defineProperty(exports, "getMeasure", {
   enumerable: true,
-  get: function () { return chunkPFUESQTW_cjs.getMeasure; }
+  get: function () { return chunkEJ3ILXX6_cjs.getMeasure; }
 });
 Object.defineProperty(exports, "isConvertibleUnit", {
   enumerable: true,
-  get: function () { return chunkPFUESQTW_cjs.isConvertibleUnit; }
+  get: function () { return chunkEJ3ILXX6_cjs.isConvertibleUnit; }
 });
 Object.defineProperty(exports, "resolveUnit", {
   enumerable: true,
-  get: function () { return chunkPFUESQTW_cjs.resolveUnit; }
+  get: function () { return chunkEJ3ILXX6_cjs.resolveUnit; }
 });
 //# sourceMappingURL=uom.cjs.map
 //# sourceMappingURL=uom.cjs.map

package/dist/uom.d.cts

@@ -1,8 +1,8 @@
 import { QueryClient } from '@tanstack/query-core';
-import { T as Token } from './Token-BzG5G4ja.cjs';
-import { a as BytecodeProgram } from './BytecodeBuilder-B0xskcv5.cjs';
+import { T as Token } from './Token-B1hdkedD.cjs';
+import { a as BytecodeProgram } from './BytecodeBuilder-Bp9xeTmX.cjs';
 import { IAsyncResolver, AsyncCheckResult } from './resolvers.cjs';
-import './Value-CXJqDH9J.cjs';
+import './Value-BUi1RA3S.cjs';
 
 /**
  * Caches exchange rates fetched from an external source.

package/dist/uom.d.ts

@@ -1,8 +1,8 @@
 import { QueryClient } from '@tanstack/query-core';
-import { T as Token } from './Token-BzG5G4ja.js';
-import { a as BytecodeProgram } from './BytecodeBuilder-B0xskcv5.js';
+import { T as Token } from './Token-B1hdkedD.js';
+import { a as BytecodeProgram } from './BytecodeBuilder-Bp9xeTmX.js';
 import { IAsyncResolver, AsyncCheckResult } from './resolvers.js';
-import './Value-CXJqDH9J.js';
+import './Value-BUi1RA3S.js';
 
 /**
  * Caches exchange rates fetched from an external source.