solve-engine 1.0.1 → 1.1.0

package/dist/{chunk-R3PY4G7J.js → chunk-MVTOCRV2.js}

@@ -162,7 +162,52 @@ function getBestUnit(value, unit) {
     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 = 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 = 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;
+}
 
-export { canConvert, convertUnit, getBestUnit, getConvertiblePossibilities, getMeasure, isConvertibleUnit, isWorkdayUnit, resolveUnit };
-//# sourceMappingURL=chunk-R3PY4G7J.js.map
-//# sourceMappingURL=chunk-R3PY4G7J.js.map
+export { canConvert, convertRate, convertUnit, getBestUnit, getConvertiblePossibilities, getMeasure, isConvertibleUnit, isWorkdayUnit, resolveUnit };
+//# sourceMappingURL=chunk-MVTOCRV2.js.map
+//# sourceMappingURL=chunk-MVTOCRV2.js.map

package/dist/chunk-MVTOCRV2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/uom/UnitConversion.ts","../src/uom/UomConverter.ts"],"names":[],"mappings":"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","file":"chunk-MVTOCRV2.js","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"]}

package/dist/{chunk-Y7FT4IQT.js → chunk-NKW7LKYU.js}

@@ -1,10 +1,10 @@
 import { VariableResolver } from './chunk-GCM5JHMX.js';
-import { sharedCurrencyExchange } from './chunk-TMA4RCEN.js';
-import { powNode, callNode, simplifySymbolic, sameShape, cancelSymbolic, complexNode, complex, RATIONAL_ZERO, rationalFromNumber, freeVariables, symbolicToEntry, rowMajorToColumnMajor, expandSymbolic, matrixMultiply, inverse, determinant, transpose, matrixPower, constNode, rationalToNumber, toPolynomial, polyDegree, polyCoefficients, rationalNeg, substitute, rationalDiv, isRationalZero, varNode, isRationalOne, RATIONAL_ONE, polyUnivariateVar, rationalMul, fromPolynomial, coefficientGcd, polynomialDivide, isZeroPolynomial, rationalCompare, rationalSub, exactIntegerSqrt, rationalAdd, surdNode, compareMonomials, COMPLEX_I, squareFreePart, exactRationalSqrt, symbolicKey, monomialFromKey, monomialToKey, signedSurdNode, exactIntegerCbrt } from './chunk-O3ANBHSA.js';
-import { faultedOperand, errorValue, symbolicValue, numberValue, bigIntValue, uomValue, matrixValue, percentageValue, stringValue, hexValue } from './chunk-GQCOSXMG.js';
-import { getMeasure, convertUnit } from './chunk-R3PY4G7J.js';
+import { sharedCurrencyExchange } from './chunk-Z7XGGLI2.js';
+import { decimalFromInteger, toPolynomial, polyDegree, polyCoefficients, fromPolynomial, constNode, rationalDiv, rationalNeg, powNode, callNode, decimalCompare, isRationalZero, rationalMul, rationalSub, rationalAdd, rationalToNumber, rationalCompare, simplifySymbolic, sameShape, decimalFromNumberIfExact, decimalMultiply, decimalToNumber, decimalAdd, decimalNegate, cancelSymbolic, complexNode, complex, RATIONAL_ZERO, rationalFromNumber, freeVariables, symbolicToEntry, rowMajorToColumnMajor, expandSymbolic, matrixMultiply, inverse, determinant, transpose, matrixPower, exactIntegerSqrt, surdNode, rational, decimalIsZero, decimalDivide, decimalSubtract, decimalFromLiteral, decimalRound, substitute, varNode, isRationalOne, RATIONAL_ONE, polyUnivariateVar, COMPLEX_I, squareFreePart, coefficientGcd, polynomialDivide, isZeroPolynomial, exactRationalSqrt, symbolicKey, compareMonomials, signedSurdNode, monomialFromKey, monomialToKey, exactIntegerCbrt } from './chunk-NNQ2TYDF.js';
+import { faultedOperand, errorValue, numberValueRational, numberValueUncertain, symbolicValue, numberValue, bigIntValue, uomValue, matrixValue, uomValueExact, percentageValue, stringValue, hexValue } from './chunk-267JPOTF.js';
+import { getMeasure, convertUnit } from './chunk-MVTOCRV2.js';
 import { UNIT_TABLE } from './chunk-V4XG5QF6.js';
-import { ErrorFactory } from './chunk-3D7V24DG.js';
+import { ErrorFactory } from './chunk-ERCOHGXD.js';
 
 // src/symbolic/MultivariateFactor.ts
 function exactRoot(value, degree) {
@@ -1134,15 +1134,59 @@ function largestFiniteMagnitude(a, b, c) {
 function compareUom(l, r) {
   const { lv, rv, sameMeasure } = unifyUom(l, r);
   if (!sameMeasure) return { lv, rv, equal: false, sameMeasure: false };
+  if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */ && l.unit !== void 0 && l.unit === r.unit && l.exact !== void 0 && r.exact !== void 0 && sharedCurrencyExchange.isCurrency(l.unit)) {
+    return { lv, rv, equal: decimalCompare(l.exact, r.exact) === 0, sameMeasure: true };
+  }
   if (lv === rv) return { lv, rv, equal: true, sameMeasure: true };
   if (!Number.isFinite(lv) || !Number.isFinite(rv)) return { lv, rv, equal: false, sameMeasure: true };
   const scale2 = largestFiniteMagnitude(lv, rv, r.toNumber());
   return { lv, rv, equal: Math.abs(lv - rv) <= scale2 * UNIFIED_COMPARISON_TOLERANCE, sameMeasure: true };
 }
+var MEASURE_NOUNS = {
+  time: "duration",
+  luminousIntensity: "luminous intensity"
+};
+var UNCOUNTABLE_MEASURES = /* @__PURE__ */ new Set(["money", "data"]);
+var COMBINE_VERBS = {
+  add: "added",
+  sub: "subtracted",
+  mul: "multiplied",
+  div: "divided"
+};
+function describeMeasure(unit) {
+  if (sharedCurrencyExchange.isCurrency(unit)) return "money";
+  const measure = getMeasure(unit);
+  if (measure === void 0) return void 0;
+  return MEASURE_NOUNS[measure] ?? measure;
+}
+function withMeasureArticle(noun) {
+  if (UNCOUNTABLE_MEASURES.has(noun)) return noun;
+  return /^[aeiou]/.test(noun) ? `an ${noun}` : `a ${noun}`;
+}
+function describeMeasureMismatch(lUnit, rUnit, verb) {
+  const left = lUnit === void 0 ? void 0 : describeMeasure(lUnit);
+  const right = rUnit === void 0 ? void 0 : describeMeasure(rUnit);
+  if (left !== void 0 && right !== void 0 && left !== right) {
+    return `${left} and ${right} cannot be ${verb}`;
+  }
+  return void 0;
+}
+function combineVerb(op) {
+  return op !== void 0 ? COMBINE_VERBS[op] ?? "combined" : "combined";
+}
+function describeConversionMismatch(fromUnit, toUnit) {
+  const from = describeMeasure(fromUnit);
+  const to = describeMeasure(toUnit);
+  if (from !== void 0 && to !== void 0 && from !== to) {
+    return `${withMeasureArticle(from)} cannot be converted to ${withMeasureArticle(to)}`;
+  }
+  return void 0;
+}
 function incomparableUnitsError(l, r) {
   const lUnit = l.type === 6 /* Uom */ ? l.unit : void 0;
   const rUnit = r.type === 6 /* Uom */ ? r.unit : void 0;
-  return errorValue("INCOMPATIBLE_UNITS", `Cannot compare incompatible units: ${lUnit ?? "?"} and ${rUnit ?? "?"}`);
+  const named = describeMeasureMismatch(lUnit, rUnit, "compared");
+  return errorValue("INCOMPATIBLE_UNITS", named ?? `Cannot compare incompatible units: ${lUnit ?? "?"} and ${rUnit ?? "?"}`);
 }
 function toBigIntOperand(v) {
   if (v.type === 2 /* BigInt */) return v.value;
@@ -1182,6 +1226,121 @@ function power(base, exponent) {
   if (base === -1 && !Number.isNaN(exponent)) return 1;
   return Math.pow(base, exponent);
 }
+function operandExactDecimal(v) {
+  if (v.exact !== void 0) return v.exact;
+  return decimalFromNumberIfExact(v.toNumber());
+}
+function exactMoneyOp(l, r, op) {
+  const lMoney = l.type === 6 /* Uom */ && l.unit !== void 0 && l.exact !== void 0 && sharedCurrencyExchange.isCurrency(l.unit);
+  const rMoney = r.type === 6 /* Uom */ && r.unit !== void 0 && r.exact !== void 0 && sharedCurrencyExchange.isCurrency(r.unit);
+  if (!lMoney && !rMoney) return null;
+  let ld;
+  let rd;
+  let unit;
+  if (lMoney && rMoney) {
+    if (l.unit !== r.unit || op === "div") return null;
+    ld = l.exact;
+    rd = r.exact;
+    unit = l.unit;
+  } else if (lMoney && r.type !== 6 /* Uom */) {
+    ld = l.exact;
+    unit = l.unit;
+    rd = operandExactDecimal(r);
+  } else if (rMoney && l.type !== 6 /* Uom */) {
+    rd = r.exact;
+    unit = r.unit;
+    ld = operandExactDecimal(l);
+  } else {
+    return null;
+  }
+  if (ld === null || rd === null) return null;
+  let result;
+  switch (op) {
+    case "add":
+      result = decimalAdd(ld, rd);
+      break;
+    case "sub":
+      result = decimalSubtract(ld, rd);
+      break;
+    case "mul":
+      result = decimalMultiply(ld, rd);
+      break;
+    case "div":
+      if (decimalIsZero(rd)) return null;
+      result = decimalDivide(ld, rd);
+      break;
+  }
+  return uomValueExact(decimalToNumber(result), unit, result);
+}
+function operandRational(v) {
+  if (v.rational !== void 0) return v.rational;
+  if ((v.type === 0 /* Number */ || v.type === 1 /* Hex */) && typeof v.value === "number" && Number.isInteger(v.value)) {
+    return rational(BigInt(v.value));
+  }
+  return null;
+}
+function exactRationalOp(l, r, op) {
+  const lr = operandRational(l);
+  if (lr === null) return null;
+  const rr = operandRational(r);
+  if (rr === null) return null;
+  if (op === "div" && isRationalZero(rr)) return null;
+  let result;
+  try {
+    switch (op) {
+      case "add":
+        result = rationalAdd(lr, rr);
+        break;
+      case "sub":
+        result = rationalSub(lr, rr);
+        break;
+      case "mul":
+        result = rationalMul(lr, rr);
+        break;
+      case "div":
+        result = rationalDiv(lr, rr);
+        break;
+    }
+  } catch {
+    return null;
+  }
+  return numberValueRational(rationalToNumber(result), result);
+}
+function uncertainOp(l, r, op) {
+  if (l.type !== 0 /* Number */ || r.type !== 0 /* Number */) return null;
+  const a = l.value;
+  const b = r.value;
+  const sa = l.uncertainty ?? 0;
+  const sb = r.uncertainty ?? 0;
+  let center;
+  let sigma;
+  switch (op) {
+    case "add":
+      center = a + b;
+      sigma = Math.hypot(sa, sb);
+      break;
+    case "sub":
+      center = a - b;
+      sigma = Math.hypot(sa, sb);
+      break;
+    case "mul":
+      center = a * b;
+      sigma = Math.hypot(b * sa, a * sb);
+      break;
+    case "div":
+      center = a / b;
+      sigma = Math.hypot(sa / b, a * sb / (b * b));
+      break;
+  }
+  return numberValueUncertain(center, sigma);
+}
+function compareRationalOperands(l, r) {
+  const lr = operandRational(l);
+  if (lr === null) return null;
+  const rr = operandRational(r);
+  if (rr === null) return null;
+  return rationalCompare(lr, rr);
+}
 function binaryOp(l, r, op, bigOp, symbolicOp) {
   if (l.type === 13 /* Error */) return l;
   if (r.type === 13 /* Error */) return r;
@@ -1209,11 +1368,16 @@ function binaryOp(l, r, op, bigOp, symbolicOp) {
     return bigIntValue(lb + rb);
   }
   if (l.type === 6 /* Uom */ || r.type === 6 /* Uom */) {
+    if (symbolicOp) {
+      const exactMoney = exactMoneyOp(l, r, symbolicOp);
+      if (exactMoney) return exactMoney;
+    }
     const { lv, rv, unit, sameMeasure } = unifyUom(l, r);
     if (!sameMeasure) {
       const lUnit = l.type === 6 /* Uom */ ? l.unit : void 0;
       const rUnit = r.type === 6 /* Uom */ ? r.unit : void 0;
-      return errorValue("INCOMPATIBLE_UNITS", `Cannot combine incompatible units: ${lUnit ?? "?"} and ${rUnit ?? "?"}`);
+      const named = describeMeasureMismatch(lUnit, rUnit, combineVerb(symbolicOp));
+      return errorValue("INCOMPATIBLE_UNITS", named ?? `Cannot combine incompatible units: ${lUnit ?? "?"} and ${rUnit ?? "?"}`);
     }
     return uomValue(op(lv, rv), unit);
   }
@@ -1288,6 +1452,57 @@ var OpRegistry = class {
 };
 var sharedOpRegistry = new OpRegistry();
 
+// src/vm/MoneyExact.ts
+var ONE_DECIMAL = decimalFromInteger(1);
+function moneyExactMagnitude(operand, unit) {
+  if (!sharedCurrencyExchange.isCurrency(unit)) return null;
+  return operand.exact ?? decimalFromNumberIfExact(operand.toNumber());
+}
+function decimalFromShortDecimal(n) {
+  if (!Number.isFinite(n)) return null;
+  if (Number.isInteger(n)) return decimalFromInteger(BigInt(n));
+  const s = String(n);
+  if (!/^-?\d+\.\d+$/.test(s)) return null;
+  return decimalFromLiteral(s);
+}
+function scaleMoneyExact(amount, factor, unit) {
+  const base = moneyExactMagnitude(amount, unit);
+  const factorDecimal = decimalFromShortDecimal(factor);
+  if (base !== null && factorDecimal !== null) {
+    const result = decimalMultiply(base, factorDecimal);
+    return uomValueExact(decimalToNumber(result), unit, result);
+  }
+  return uomValue(amount.toNumber() * factor, unit);
+}
+function scaleMoneyByPercent(money, unit, percent, sign) {
+  const base = moneyExactMagnitude(money, unit);
+  const percentDecimal = decimalFromShortDecimal(percent);
+  if (base !== null && percentDecimal !== null) {
+    const factor = decimalAdd(ONE_DECIMAL, sign === 1 ? percentDecimal : decimalNegate(percentDecimal));
+    const result = decimalMultiply(base, factor);
+    return uomValueExact(decimalToNumber(result), unit, result);
+  }
+  return uomValue(money.toNumber() * (1 + sign * percent), unit);
+}
+function onePlusRateDecimal(rate) {
+  const rateDecimal = decimalFromShortDecimal(rate);
+  return rateDecimal === null ? null : decimalAdd(ONE_DECIMAL, rateDecimal);
+}
+function removeTaxExact(money, unit, rate) {
+  const base = moneyExactMagnitude(money, unit);
+  const divisor = onePlusRateDecimal(rate);
+  if (base === null || divisor === null || decimalIsZero(divisor)) return null;
+  const quotient = decimalDivide(base, divisor);
+  return uomValueExact(decimalToNumber(quotient), unit, quotient);
+}
+function taxInExact(money, unit, rate) {
+  const base = moneyExactMagnitude(money, unit);
+  const divisor = onePlusRateDecimal(rate);
+  if (base === null || divisor === null || decimalIsZero(divisor)) return null;
+  const tax = decimalSubtract(base, decimalDivide(base, divisor));
+  return uomValueExact(decimalToNumber(tax), unit, tax);
+}
+
 // src/symbolic/PartialFractions.ts
 var APART_MAX_DEGREE = 12;
 function multiply2(a, b) {
@@ -1958,9 +2173,10 @@ function extremum(args, wantLargest) {
     if (!sameMeasure) {
       const bestUnit = best.type === 6 /* Uom */ ? best.unit : void 0;
       const otherUnit = a.type === 6 /* Uom */ ? a.unit : void 0;
+      const named = describeMeasureMismatch(bestUnit, otherUnit, "compared");
       return errorValue(
         "INCOMPATIBLE_UNITS",
-        `Cannot compare incompatible units: ${bestUnit ?? "?"} and ${otherUnit ?? "?"}`
+        named ?? `Cannot compare incompatible units: ${bestUnit ?? "?"} and ${otherUnit ?? "?"}`
       );
     }
     if (wantLargest ? rv > lv : rv < lv) best = a;
@@ -1973,6 +2189,25 @@ function keepUnit(operand, magnitude2) {
   if (operand.type === 6 /* Uom */ && operand.unit !== void 0) return uomValue(magnitude2, operand.unit);
   return numberValue(magnitude2);
 }
+function roundToPlaces(source, places) {
+  const p = Number.isFinite(places) ? Math.min(100, Math.max(0, Math.trunc(places))) : 0;
+  if (source.exact !== void 0) {
+    const rounded = decimalRound(source.exact, p);
+    return withPlaces(source, decimalToNumber(rounded), p, rounded);
+  }
+  const value = source.toNumber();
+  if (!Number.isFinite(value)) return withPlaces(source, value, p);
+  const scale2 = Math.pow(10, p);
+  const scaled = value * scale2;
+  if (!Number.isFinite(scaled) || Math.abs(scaled) > Number.MAX_SAFE_INTEGER) return withPlaces(source, value, p);
+  return withPlaces(source, Math.round(scaled) / scale2, p);
+}
+function withPlaces(source, magnitude2, places, exact) {
+  const result = source.type === 6 /* Uom */ && source.unit !== void 0 ? uomValue(magnitude2, source.unit) : numberValue(magnitude2);
+  result.decimalPlaces = places;
+  if (exact !== void 0) result.exact = exact;
+  return result;
+}
 function nonFiniteEuclidOperand(a, b, name) {
   if (Number.isFinite(a) && Number.isFinite(b)) return null;
   const culprit = Number.isFinite(a) ? b : a;
@@ -2013,7 +2248,13 @@ var builtinFunctions = {
   // round/ceil/floor keep a unit for the same reason abs does; see keepUnit().
   6: (args) => keepUnit(args[0], Math.ceil(args[0].toNumber())),
   7: (args) => keepUnit(args[0], Math.floor(args[0].toNumber())),
-  8: (args) => keepUnit(args[0], Math.round(args[0].toNumber())),
+  8: (args) => args.length >= 2 ? (
+    // round(x, n): round to n decimal places and display at that precision.
+    roundToPlaces(args[0], args[1].toNumber())
+  ) : (
+    // round(x): nearest whole number, the way it always was.
+    keepUnit(args[0], Math.round(args[0].toNumber()))
+  ),
   // min/max: see extremum() for why the winner is carried around as a Value
   // rather than as a running number.
   9: (args) => extremum(args, false),
@@ -2357,8 +2598,8 @@ var builtinFunctions = {
   58: (args) => {
     const amount = args[0].toNumber();
     const rate = args[1].toNumber();
-    const result = amount * (1 + rate);
-    return args[0].type === 6 /* Uom */ ? uomValue(result, args[0].unit) : numberValue(result);
+    if (args[0].type === 6 /* Uom */) return scaleMoneyByPercent(args[0], args[0].unit, rate, 1);
+    return numberValue(amount * (1 + rate));
   },
   // taxRemove(amount, rate) -> amount / (1 + rate), extracts the
   // pre-tax amount from a tax-INCLUSIVE total. Backs "tax off $X at R%" /
@@ -2369,7 +2610,10 @@ var builtinFunctions = {
     if (1 + rate <= 0) {
       return errorValue("INVALID_RATE", `taxRemove: rate ${rate} makes (1 + rate) non-positive`);
     }
-    return args[0].type === 6 /* Uom */ ? uomValue(amount / (1 + rate), args[0].unit) : numberValue(amount / (1 + rate));
+    if (args[0].type === 6 /* Uom */) {
+      return removeTaxExact(args[0], args[0].unit, rate) ?? uomValue(amount / (1 + rate), args[0].unit);
+    }
+    return numberValue(amount / (1 + rate));
   },
   // inflationAdjust(amount, fromYear, toYear) -- CPI-based inflation
   // adjustment between two arbitrary years, using the bundled CPI-U
@@ -2580,7 +2824,10 @@ var builtinFunctions = {
       return errorValue("INVALID_RATE", `taxIn: rate ${rate} makes (1 + rate) non-positive`);
     }
     const tax = amount - amount / (1 + rate);
-    return args[0].type === 6 /* Uom */ ? uomValue(tax, args[0].unit) : numberValue(tax);
+    if (args[0].type === 6 /* Uom */) {
+      return taxInExact(args[0], args[0].unit, rate) ?? uomValue(tax, args[0].unit);
+    }
+    return numberValue(tax);
   },
   // taxOn(amount, rate) -> amount * rate, the tax itself.
   //
@@ -2592,8 +2839,8 @@ var builtinFunctions = {
   86: (args) => {
     const amount = args[0].toNumber();
     const rate = args[1].toNumber();
-    const tax = amount * rate;
-    return args[0].type === 6 /* Uom */ ? uomValue(tax, args[0].unit) : numberValue(tax);
+    if (args[0].type === 6 /* Uom */) return scaleMoneyExact(args[0], rate, args[0].unit);
+    return numberValue(amount * rate);
   },
   // ── Degree-taking trig (sind/cosd/tand and the inverses) ──────────────
   // The "d" spellings take and return degrees rather than radians, which is
@@ -2783,16 +3030,7 @@ var builtinFunctions = {
   // fractional part to round at all, and the round trip through 1e23 was
   // pure loss. Asking for fewer decimal places than a number has cannot
   // change it, so a value that is already whole is returned untouched.
-  97: (args) => {
-    const source = args[0];
-    const value = source.toNumber();
-    const places = args[1].toNumber();
-    if (!Number.isFinite(value) || Number.isInteger(value)) return keepUnit(source, value);
-    const scale2 = Math.pow(10, places);
-    const scaled = value * scale2;
-    if (!Number.isFinite(scaled) || Math.abs(scaled) > Number.MAX_SAFE_INTEGER) return keepUnit(source, value);
-    return keepUnit(source, Math.round(scaled) / scale2);
-  }
+  97: (args) => roundToPlaces(args[0], args[1].toNumber())
 };
 function applyComplexAccessor(name, value) {
   const node = valueToSymbolic(value);
@@ -2942,6 +3180,6 @@ function globalDagKey(name) {
   return `global:${name}`;
 }
 
-export { CPI_MAX_YEAR, CPI_MIN_YEAR, OpRegistry, SYMBOLIC_NATIVE_BUILTINS, adjustForInflation, allocatePluginFunctionIndex, asConverterRegistry, bigIntDivisionByZero, binaryOp, builtinFunctions, compareBigIntOperands, compareUom, createEngineContext, defaultEngineContext, globalDagKey, incomparableUnitsError, pluginFunctionRegistry, power, registerAsConverter, sharedGlobalVariableStore, sharedOpRegistry, solveEquationValues, symbolicBuiltin, symbolicNeg, symbolicPow, toBigIntOperand, unifyUom, unregisterAsConverter };
-//# sourceMappingURL=chunk-Y7FT4IQT.js.map
-//# sourceMappingURL=chunk-Y7FT4IQT.js.map
+export { CPI_MAX_YEAR, CPI_MIN_YEAR, OpRegistry, SYMBOLIC_NATIVE_BUILTINS, adjustForInflation, allocatePluginFunctionIndex, asConverterRegistry, bigIntDivisionByZero, binaryOp, builtinFunctions, compareBigIntOperands, compareRationalOperands, compareUom, createEngineContext, defaultEngineContext, describeConversionMismatch, exactRationalOp, globalDagKey, incomparableUnitsError, moneyExactMagnitude, pluginFunctionRegistry, power, registerAsConverter, scaleMoneyByPercent, scaleMoneyExact, sharedGlobalVariableStore, sharedOpRegistry, solveEquationValues, solveForVariable, symbolicBuiltin, symbolicNeg, symbolicPow, toBigIntOperand, uncertainOp, unifyUom, unregisterAsConverter };
+//# sourceMappingURL=chunk-NKW7LKYU.js.map
+//# sourceMappingURL=chunk-NKW7LKYU.js.map