@weasel-js/quantity 1.9.3 → 1.10.0

package/dist/index.d.ts

@@ -8,8 +8,9 @@
  * `UnitSystem` at the API boundary. Internals never see units.
  *
  * An entry is affine — `base = value * factor + offset` — so a scale that
- * puts zero somewhere else (degC against K) is expressible. No per-axis
- * units. No mixed-unit arithmetic.
+ * puts zero somewhere else (degC against K) is expressible. Arithmetic
+ * across units is `resolveUnitExpr`; a plane whose axes measure different
+ * things resolves through `resolveAxes`.
  */
 /** A unit name (e.g. `'in'`, `'ft'`, `'mm'`). Looked up in a `UnitSystem`. */
 type Unit = string;
@@ -56,6 +57,25 @@ declare function formatUnit(baseValue: number, displayUnit: Unit, unitSystem: Un
     precision?: number;
     suffix?: boolean;
 }): string;
+/** One of something for each axis of a plane. */
+interface PerAxis<T> {
+    x: T;
+    y: T;
+}
+/** A plane's units: one system for both axes, or one each — a chart whose x
+ *  is time and whose y is a value. */
+type PlaneUnits = UnitSystem | PerAxis<UnitSystem>;
+/** A measure on a plane: one value for both axes, or one each. */
+type PlaneValue = UnitValue | Quantity | PerAxis<UnitValue | Quantity>;
+/** The unit system `units` gives one axis. */
+declare function axisUnits(units: PlaneUnits | undefined, axis: 'x' | 'y'): UnitSystem | undefined;
+/** `v` in base units on each axis, every axis resolved against its own system. */
+declare function resolveAxes(v: PlaneValue, units?: PlaneUnits): PerAxis<number>;
+/** A base-unit point as text, each axis in its own display unit. */
+declare function formatAxes(base: PerAxis<number>, display: Unit | PerAxis<Unit>, units: PlaneUnits, opts?: {
+    precision?: number;
+    suffix?: boolean;
+}): PerAxis<string>;
 /** Imperial unit system with base 'in'. */
 declare const IMPERIAL_INCHES: UnitSystem;
 /** Metric unit system with base 'mm'. */
@@ -321,6 +341,7 @@ declare const CONSTANTS: {
         readonly spoken: "e";
     };
 };
+/** How a `fraction` display picks and writes its fraction. */
 type FractionOptions = {
     /** Default 64. */
     maxDenominator?: number;
@@ -389,14 +410,10 @@ declare function zoom(): ZoomDisplay;
 declare const zoomKind: DisplayKind<ZoomDisplay>;
 
 /**
- * Display-formatter for numbers. Use this anywhere a number is shown to
- * a user. The whole point: negative values get prefixed with the real
- * MINUS SIGN (U+2212) instead of the ASCII HYPHEN-MINUS (U+002D) that
- * `toLocaleString` and template literals produce by default.
- *
- * U+2212 is the same visual width as `+` and reads as a sign rather
- * than a hyphen — columns of signed numbers align cleanly and the
- * glyph doesn't get confused with a bullet or list dash.
+ * The real MINUS SIGN (U+2212), which display formatting uses instead of the
+ * ASCII HYPHEN-MINUS (U+002D) that `toLocaleString` and template literals
+ * produce. It is the same visual width as `+`, so columns of signed numbers
+ * align.
  */
 declare const MINUS_SIGN = "\u2212";
 /**
@@ -525,4 +542,116 @@ declare function ordinal(): OrdinalDisplay;
 /** The built-in `ordinal` kind, to spread into a `registerDisplayKind` replacement. */
 declare const ordinalKind: DisplayKind<OrdinalDisplay>;
 
-export { ANGLE_RADIANS, type BytesDisplay, CONSTANTS, type CompactDisplay, type CurrencyDisplay, type DecimalDisplay, type Display, type DisplayKind, type DurationDisplay, type FormatContext, type FractionDisplay, IMPERIAL_INCHES, type InfinityText, type IntegerDisplay, METRIC_MM, MINUS_SIGN, type MultiplierDisplay, type NamedConstant, type OrdinalDisplay, PIXELS, type Part, type PercentDisplay, type PresentOptions, type Presentation, type Quantity, QuantityView, type RatioDisplay, type RomanDisplay, type Tagged, type Unit, type UnitDisplay, type UnitEntry, type UnitScale, type UnitSystem, type UnitTable, type UnitValue, type ZoomDisplay, amount, bytes, bytesKind, compact, compactKind, currency, currencyKind, decimal, decimalKind, displayKindOf, displayOf, duration, durationKind, endless, entryScale, formatCompact, formatNumber, formatUnit, fraction, fractionKind, fromRoman, integer, integerKind, intlParts, multiplier, multiplierKind, nearestFraction, numberPart, ordinal, ordinalKind, parseAs, parseNumber, parseSignedNumber, partsOf, partsToHtml, percent, percentKind, plural, present, qty, ratio, ratioKind, registerDisplayKind, resolveUnit, retag, roman, romanKind, signed, spokenSign, tag, textOf, toRoman, unit, unitKind, unitOf, unitScale, zoom, zoomKind };
+/**
+ * Arithmetic over values in different units, as plain data: `50% + 2ft`
+ * parses once and resolves against whatever context it is handed, so a stored
+ * expression follows a parent that resizes. `value` nodes are the leaves.
+ */
+type UnitExpr = {
+    op: 'value';
+    value: number;
+    unit?: Unit;
+} | {
+    op: 'neg';
+    of: UnitExpr;
+} | {
+    op: 'add' | 'sub' | 'mul' | 'div';
+    left: UnitExpr;
+    right: UnitExpr;
+};
+/** What a {@link UnitExpr} resolves against. */
+interface UnitExprContext {
+    unitSystem?: UnitSystem;
+    /** What `100%` is, in base units. A `%` term throws without it, unless the
+     *  unit system carries a `%` unit of its own. */
+    percentOf?: number;
+}
+/**
+ * Parse arithmetic over unit-tagged numbers: `+ - * /` (also `− × ÷`),
+ * parentheses, and adjacent terms read as one compound value (`5ft 3in`),
+ * with a leading sign carried across all of them. Throws on text it cannot
+ * read. Unit names are not checked here — resolving does that.
+ */
+declare function parseUnitExpr(text: string): UnitExpr;
+/**
+ * An expression's value in base units. A bare number beside `+` or `-` is
+ * read as base units, as it is everywhere a `UnitValue` goes, and beside `*`
+ * or `/` as a scalar. A measure over a measure is a scalar; a product of two
+ * measures, or a scalar over a measure, throws.
+ */
+declare function resolveUnitExpr(expr: UnitExpr | string, ctx?: UnitExprContext): number;
+
+/**
+ * A unit system nested in another: a sub-assembly drawn in millimeters inside
+ * a scene measured in inches. Values inside are read against `system`, and
+ * `scale` converts at the boundary.
+ */
+interface UnitScope {
+    system: UnitSystem;
+    /** What one of this scope's base units is worth in the enclosing scope's
+     *  base units. Absent is 1, which is also what the outermost scope has. */
+    scale?: UnitEntry;
+}
+/** A measure in the innermost scope's base units, in the outermost's. `scopes` runs outermost first. */
+declare function toRoot(base: number, scopes: readonly UnitScope[]): number;
+/** The inverse of {@link toRoot}: an outermost-scope measure in the innermost scope's base units. */
+declare function fromRoot(rootBase: number, scopes: readonly UnitScope[]): number;
+/**
+ * Resolve `v` where it was written — against the innermost scope's unit
+ * system, so `ft` inside a metric sub-assembly is an error rather than a
+ * silent inch measure — and return it in the outermost scope's base units.
+ */
+declare function resolveScoped(v: UnitValue | Quantity, scopes: readonly UnitScope[]): number;
+/** A measure in the outermost scope's base units, as text in a unit of the innermost scope. */
+declare function formatScoped(rootBase: number, displayUnit: Unit, scopes: readonly UnitScope[], opts?: {
+    precision?: number;
+    suffix?: boolean;
+}): string;
+/** How {@link scopesOf} reads a tree it knows nothing else about. */
+interface ScopeTree<Id> {
+    parentOf(id: Id): Id | null | undefined;
+    /** The scope `id` declares for what it holds, when it declares one. */
+    scopeOf(id: Id): UnitScope | undefined;
+    /** Count `id`'s own scope too — for a value written inside it rather than
+     *  one that places it in its parent. Default false. */
+    inclusive?: boolean;
+}
+/**
+ * The scopes enclosing `id`, outermost first, under `root`: what
+ * {@link resolveScoped} takes for a value that positions or sizes `id`. A
+ * node's own scope covers its children, not itself, unless `inclusive`.
+ */
+declare function scopesOf<Id>(id: Id, root: UnitScope, tree: ScopeTree<Id>): UnitScope[];
+
+/** Options for presenting a range. */
+interface RangeOptions extends PresentOptions {
+    /** What goes between the ends. Default an en dash, spaced when an end is negative. */
+    separator?: string;
+    /** The separator read aloud. Default ` to `. */
+    spokenSeparator?: string;
+}
+/** Options for presenting a vector. */
+interface VectorOptions extends PresentOptions {
+    /** What goes between members. Default `, `. */
+    separator?: string;
+    /** A name before each member, by position: `['x', 'y']`. */
+    labels?: readonly string[];
+}
+/**
+ * A range as one run of parts: both ends under their own display, else
+ * `fallback`, around a `separator` part. A unit or percent sign both ends
+ * share is written once, after the second: `2–5ft`.
+ */
+declare function rangeParts(from: Quantity, to: Quantity, fallback?: Display, options?: RangeOptions): Part[];
+/** A range as text, spoken text, and HTML: a `data-composite="range"` span
+ *  holding a `<data value>` for each end and a `separator` part between. */
+declare function presentRange(from: Quantity, to: Quantity, fallback?: Display, options?: RangeOptions): Presentation;
+/** A vector as one run of parts: every member under its own display, else
+ *  `fallback`, with a `separator` part between and a `label` part before each
+ *  member that has one. */
+declare function vectorParts(members: readonly Quantity[], fallback?: Display, options?: VectorOptions): Part[];
+/** A vector as text, spoken text, and HTML: a `data-composite="vector"` span
+ *  holding a `<data value>` for each member. */
+declare function presentVector(members: readonly Quantity[], fallback?: Display, options?: VectorOptions): Presentation;
+
+export { ANGLE_RADIANS, type BytesDisplay, CONSTANTS, type CompactDisplay, type CurrencyDisplay, type DecimalDisplay, type Display, type DisplayKind, type DurationDisplay, type FormatContext, type FractionDisplay, type FractionOptions, IMPERIAL_INCHES, type InfinityText, type IntegerDisplay, METRIC_MM, MINUS_SIGN, type MultiplierDisplay, type NamedConstant, type OrdinalDisplay, PIXELS, type Part, type PerAxis, type PercentDisplay, type PlaneUnits, type PlaneValue, type PresentOptions, type Presentation, type Quantity, QuantityView, type RangeOptions, type RatioDisplay, type RomanDisplay, type ScopeTree, type Tagged, type Unit, type UnitDisplay, type UnitEntry, type UnitExpr, type UnitExprContext, type UnitScale, type UnitScope, type UnitSystem, type UnitTable, type UnitValue, type VectorOptions, type ZoomDisplay, amount, axisUnits, bytes, bytesKind, compact, compactKind, currency, currencyKind, decimal, decimalKind, displayKindOf, displayOf, duration, durationKind, endless, entryScale, formatAxes, formatCompact, formatNumber, formatScoped, formatUnit, fraction, fractionKind, fromRoman, fromRoot, integer, integerKind, intlParts, multiplier, multiplierKind, nearestFraction, numberPart, ordinal, ordinalKind, parseAs, parseNumber, parseSignedNumber, parseUnitExpr, partsOf, partsToHtml, percent, percentKind, plural, present, presentRange, presentVector, qty, rangeParts, ratio, ratioKind, registerDisplayKind, resolveAxes, resolveScoped, resolveUnit, resolveUnitExpr, retag, roman, romanKind, scopesOf, signed, spokenSign, tag, textOf, toRoman, toRoot, unit, unitKind, unitOf, unitScale, vectorParts, zoom, zoomKind };

package/dist/index.js

@@ -52,11 +52,30 @@ function formatUnit(baseValue, displayUnit, unitSystem, opts) {
   const suffix = opts?.suffix ?? true;
   const display = (baseValue - offset) / factor;
   let s = display.toFixed(precision);
+  if (Number(s) === 0) s = s.replace(/^-/, "");
   if (s.includes(".")) {
     s = s.replace(/0+$/, "").replace(/\.$/, "");
   }
   return suffix ? `${s}${displayUnit}` : s;
 }
+function axisUnits(units, axis) {
+  return units === void 0 || "base" in units ? units : units[axis];
+}
+function resolveAxes(v, units) {
+  const perAxis = typeof v === "object" && "x" in v;
+  const on = (axis) => {
+    try {
+      return resolveUnit(perAxis ? v[axis] : v, axisUnits(units, axis));
+    } catch (e) {
+      throw new Error(`${axis} axis: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  };
+  return { x: on("x"), y: on("y") };
+}
+function formatAxes(base, display, units, opts) {
+  const on = (axis) => formatUnit(base[axis], typeof display === "string" ? display : display[axis], axisUnits(units, axis), opts);
+  return { x: on("x"), y: on("y") };
+}
 function scaleOrThrow(caller, unitSystem, unit2) {
   try {
     return unitScale(unitSystem, unit2);
@@ -84,18 +103,23 @@ var PIXELS = {
 // src/number.ts
 var MINUS_SIGN = "\u2212";
 function formatNumber(value, options) {
-  const formatted = Number.isFinite(value) ? value.toLocaleString(void 0, options) : String(value);
+  const formatted = Number.isFinite(value) ? unsignedZero(value, (n) => n.toLocaleString(void 0, options)) : String(value);
   return formatted.replace(/^-/, MINUS_SIGN);
 }
+function unsignedZero(value, format) {
+  const shown = format(value);
+  return value <= 0 && shown === format(-0) ? format(0) : shown;
+}
 function parseSignedNumber(text) {
   return Number(text.replace(MINUS_SIGN, "-"));
 }
 var TERM_NUMBER = String.raw`\d+(?:\.\d+)?|\.\d+`;
+var DECIMAL_NUMBER = /^[-+]?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?$/i;
 var EXPONENTS = { k: 3, m: 6, b: 9, t: 12 };
 function formatCompact(value, decimals = 0) {
   if (!Number.isFinite(value)) return formatNumber(value);
-  const options = Math.abs(value) < 1e3 ? { useGrouping: false, minimumFractionDigits: decimals, maximumFractionDigits: decimals } : { notation: "compact", minimumSignificantDigits: 3, maximumSignificantDigits: 3 };
-  return value.toLocaleString("en-US", options).replace(/^-/, MINUS_SIGN);
+  const options = Number(Math.abs(value).toFixed(decimals)) < 1e3 ? { useGrouping: false, minimumFractionDigits: decimals, maximumFractionDigits: decimals } : { notation: "compact", minimumSignificantDigits: 3, maximumSignificantDigits: 3 };
+  return unsignedZero(value, (n) => n.toLocaleString("en-US", options)).replace(/^-/, MINUS_SIGN);
 }
 function parseNumber(text, units, locale = "en-US") {
   const n = readNumber(delocalized(text, locale), units);
@@ -116,8 +140,9 @@ function readNumber(text, units) {
   let t = text.trim().replace(MINUS_SIGN, "-");
   const exponent = EXPONENTS[t.slice(-1).toLowerCase()];
   if (exponent !== void 0) t = t.slice(0, -1).trimEnd();
-  if (!/\d/.test(t)) return Number.NaN;
-  return Number(exponent === void 0 ? t : `${t}e${exponent}`);
+  if (!DECIMAL_NUMBER.test(t)) return Number.NaN;
+  const n = Number(exponent === void 0 ? t : `${t}e${exponent}`);
+  return Number.isFinite(n) ? n : Number.NaN;
 }
 var shapes = /* @__PURE__ */ new Map();
 function shapeOf(locale) {
@@ -158,6 +183,14 @@ function latinDigits(text, locale) {
   return digits ? t.replace(digits.pattern, (c) => digits.latin.get(c)) : t;
 }
 var BIDI_MARKS = /[\u061c\u200e\u200f]/g;
+function numberWithin(text, locale) {
+  const t = latinDigits(text, locale);
+  const m = new RegExp(shapeOf(locale).run.source).exec(t);
+  if (!m) return "";
+  const around = t.slice(0, m.index) + t.slice(m.index + m[0].length);
+  const suffix = /^[kmbt](?!\p{L})/iu.exec(t.slice(m.index + m[0].length))?.[0] ?? "";
+  return `${/[-\u2212]/.test(around) ? "-" : ""}${m[0]}${suffix}`;
+}
 var decimalOf = (locale) => shapeOf(locale).decimal;
 var SPELLINGS = [
   ["in", '"', "\u2033", "\u201D"],
@@ -213,11 +246,15 @@ function unitSuffixOf(text, units) {
 }
 
 // src/kind.ts
+var ESCAPES = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" };
+function escapeMarkup(s) {
+  return s.replace(/[&<>"]/g, (c) => ESCAPES[c]);
+}
 function textOf(parts) {
   return parts.map((p) => p.value).join("");
 }
 function numberPart(value, locale, options) {
-  return { type: "number", value: signed(value.toLocaleString(locale, options)) };
+  return { type: "number", value: signed(unsignedZero(value, (n) => n.toLocaleString(locale, options))) };
 }
 function signed(text) {
   return text.replace(/^-/, MINUS_SIGN);
@@ -230,7 +267,9 @@ function plural(value, locale, singular, pluralForm) {
 }
 function intlParts(value, locale, options) {
   const out = [];
-  for (const p of new Intl.NumberFormat(locale, options).formatToParts(value)) {
+  const nf = new Intl.NumberFormat(locale, options);
+  const shown = value <= 0 && nf.format(value) === nf.format(-0) ? 0 : value;
+  for (const p of nf.formatToParts(shown)) {
     const type = DIGIT_RUNS.has(p.type) ? "number" : p.type;
     const v = p.type === "minusSign" ? MINUS_SIGN : p.value;
     const last = out[out.length - 1];
@@ -306,8 +345,12 @@ var percentKind = {
       })
     )
   ),
-  parse: (text, _d, ctx) => parseNumber(text.replace(/^\s*%|%\s*$/, ""), void 0, ctx.locale) / 100
+  parse: (text, _d, ctx) => parseNumber(withoutPercentSign(text, ctx.locale), void 0, ctx.locale) / 100
 };
+function withoutPercentSign(text, locale) {
+  const m = /^\s*([-+\u2212]?)\s*[%٪]?\s*(.*?)\s*[%٪]?\s*$/su.exec(latinDigits(text, locale));
+  return m ? m[1] + m[2] : text;
+}
 function nearestFraction(x, maxDenominator) {
   if (!Number.isFinite(x)) return [x, 1];
   const sign = x < 0 ? -1 : 1;
@@ -421,7 +464,7 @@ var fractionKind = {
     const { negative, whole, num, den, constant } = fractionPieces(value, d);
     const counted = (n) => {
       if (!constant) return `<mn>${n}</mn>`;
-      const mi = `<mi>${constant.symbol}</mi>`;
+      const mi = `<mi>${escapeMarkup(constant.symbol)}</mi>`;
       return n === 1 ? mi : `<mn>${n}</mn>${mi}`;
     };
     const body = [
@@ -466,14 +509,20 @@ var multiplierKind = {
     { type: "symbol", value: d.symbol ?? "\xD7" }
   ],
   speak: (value, d, ctx) => spokenSign(`${numberPart(value, ctx.locale, { maximumFractionDigits: d.places ?? 2 }).value} times`),
-  parse: (text, _d, ctx) => parseNumber(text.replace(/\s*[x×X]\s*$/, ""), void 0, ctx.locale)
+  parse: (text, d, ctx) => {
+    const own = d.symbol !== void 0 && text.trimEnd().endsWith(d.symbol) ? text.trimEnd().slice(0, -d.symbol.length) : text.replace(/\s*[x×X]\s*$/, "");
+    return parseNumber(own, void 0, ctx.locale);
+  }
 };
 function zoom() {
   return { kind: "zoom" };
 }
 function zoomParts(z) {
   if (!Number.isFinite(z)) return [{ type: "number", value: String(z) }];
-  const n = (v, grouping = false) => ({ type: "number", value: v.toLocaleString("en-US", { useGrouping: grouping, maximumFractionDigits: 1 }).replace(/^-/, MINUS_SIGN) });
+  const n = (v, grouping = false) => ({
+    type: "number",
+    value: unsignedZero(v, (x) => x.toLocaleString("en-US", { useGrouping: grouping, maximumFractionDigits: 1 })).replace(/^-/, MINUS_SIGN)
+  });
   if (z <= 2) return [n(Math.round(z * 100)), { type: "percentSign", value: "%" }];
   if (z >= 100) return [n(Math.round(z), true), { type: "symbol", value: "x" }];
   return [n(Math.round(z * 10) / 10), { type: "symbol", value: "x" }];
@@ -570,7 +619,7 @@ var currencyKind = {
   kind: "currency",
   format: (value, d, ctx) => intlParts(value, ctx.locale, currencyOptions(d)),
   speak: (value, d, ctx) => spokenSign(textOf(intlParts(value, ctx.locale, { ...currencyOptions(d), currencyDisplay: "name" }))),
-  parse: (text, _d, ctx) => parseNumber(text.replace(/[^\d.,'’+\-−]/g, ""), void 0, ctx.locale)
+  parse: (text, _d, ctx) => parseNumber(numberWithin(text, ctx.locale), void 0, ctx.locale)
 };
 function duration(options = {}) {
   return { kind: "duration", ...options };
@@ -638,14 +687,21 @@ var BINARY_NAMES = ["byte", "kibibyte", "mebibyte", "gibibyte", "tebibyte", "peb
 function bytes(options = {}) {
   return { kind: "bytes", ...options };
 }
-function byteScale(value, base) {
+function byteScale(d, value) {
+  const base = d.base ?? 1e3;
+  const last = DECIMAL_BYTES.length - 1;
+  const placesAt = (step2) => step2 === 0 ? 0 : d.places ?? 1;
   let step = 0;
   let scaled2 = value;
-  while (Math.abs(scaled2) >= base && step < DECIMAL_BYTES.length - 1) {
+  while (Math.abs(scaled2) >= base && step < last) {
+    scaled2 /= base;
+    step++;
+  }
+  if (step < last && Number(Math.abs(scaled2).toFixed(placesAt(step))) >= base) {
     scaled2 /= base;
     step++;
   }
-  return { scaled: scaled2, step };
+  return { scaled: scaled2, step, places: placesAt(step) };
 }
 var BYTE_UNITS = Object.fromEntries([
   ...DECIMAL_BYTES.map((u, i) => [u, 1e3 ** i]),
@@ -655,20 +711,18 @@ var BYTE_UNITS = Object.fromEntries([
 var bytesKind = {
   kind: "bytes",
   format: (value, d, ctx) => {
-    const base = d.base ?? 1e3;
-    const { scaled: scaled2, step } = byteScale(value, base);
-    const units = base === 1024 ? BINARY_BYTES : DECIMAL_BYTES;
+    const { scaled: scaled2, step, places } = byteScale(d, value);
+    const units = d.base === 1024 ? BINARY_BYTES : DECIMAL_BYTES;
     return [
-      numberPart(scaled2, ctx.locale, { maximumFractionDigits: step === 0 ? 0 : d.places ?? 1 }),
+      numberPart(scaled2, ctx.locale, { maximumFractionDigits: places }),
       { type: "literal", value: " " },
       { type: "unit", value: units[step] }
     ];
   },
   speak: (value, d, ctx) => {
-    const base = d.base ?? 1e3;
-    const { scaled: scaled2, step } = byteScale(value, base);
-    const name = (base === 1024 ? BINARY_NAMES : DECIMAL_NAMES)[step];
-    const number = numberPart(scaled2, ctx.locale, { maximumFractionDigits: step === 0 ? 0 : d.places ?? 1 }).value;
+    const { scaled: scaled2, step, places } = byteScale(d, value);
+    const name = (d.base === 1024 ? BINARY_NAMES : DECIMAL_NAMES)[step];
+    const number = numberPart(scaled2, ctx.locale, { maximumFractionDigits: places }).value;
     return spokenSign(`${number} ${plural(Math.abs(parseNumber(number, void 0, ctx.locale)), ctx.locale, name, `${name}s`)}`);
   },
   parse: (text, _d, ctx) => parseNumber(text, BYTE_UNITS, ctx.locale)
@@ -809,13 +863,9 @@ function contextOf(q, options) {
   const unit2 = unitOf(q);
   return unit2 === void 0 ? { locale: options?.locale ?? "en-US" } : { locale: options?.locale ?? "en-US", unit: unit2 };
 }
-var ESCAPES = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" };
-function escape2(s) {
-  return s.replace(/[&<>"]/g, (c) => ESCAPES[c]);
-}
 function partsToHtml(value, parts) {
-  const body = parts.map((p) => p.type === "literal" ? escape2(p.value) : `<span data-part="${escape2(p.type)}">${escape2(p.value)}</span>`).join("");
-  return `<data value="${escape2(String(value))}">${body}</data>`;
+  const body = parts.map((p) => p.type === "literal" ? escapeMarkup(p.value) : `<span data-part="${escapeMarkup(p.type)}">${escapeMarkup(p.value)}</span>`).join("");
+  return `<data value="${escapeMarkup(String(value))}">${body}</data>`;
 }
 function partsOf(q, fallback, options) {
   const display = displayOf(q, fallback) ?? DEFAULT_DISPLAY;
@@ -915,6 +965,231 @@ function qty(q, fallback, options) {
   return new QuantityView(q, fallback, options);
 }
 
-export { ANGLE_RADIANS, CONSTANTS, IMPERIAL_INCHES, METRIC_MM, MINUS_SIGN, PIXELS, QuantityView, amount, bytes, bytesKind, compact, compactKind, currency, currencyKind, decimal, decimalKind, displayKindOf, displayOf, duration, durationKind, endless, entryScale, formatCompact, formatNumber, formatUnit, fraction, fractionKind, fromRoman, integer, integerKind, intlParts, multiplier, multiplierKind, nearestFraction, numberPart, ordinal, ordinalKind, parseAs, parseNumber, parseSignedNumber, partsOf, partsToHtml, percent, percentKind, plural, present, qty, ratio, ratioKind, registerDisplayKind, resolveUnit, retag, roman, romanKind, signed, spokenSign, tag, textOf, toRoman, unit, unitKind, unitOf, unitScale, zoom, zoomKind };
+// src/unitExpr.ts
+var TOKEN = /\s*(?:(\d+(?:\.\d+)?|\.\d+)\s*([^\s\d.+\-−*×/÷()]+)?|([+\-−*×/÷()]))/y;
+var OPS = { [MINUS_SIGN]: "-", "\xD7": "*", "\xF7": "/" };
+function tokenize(text) {
+  const tokens = [];
+  let at = 0;
+  while (text.slice(at).trim() !== "") {
+    TOKEN.lastIndex = at;
+    const m = TOKEN.exec(text);
+    if (!m) throw new Error(`unitExpr: cannot read '${text.slice(at).trim()}' in '${text}'`);
+    at = TOKEN.lastIndex;
+    if (m[1] === void 0) tokens.push({ kind: "op", op: OPS[m[3]] ?? m[3] });
+    else if (m[2] === void 0) tokens.push({ kind: "value", value: Number(m[1]) });
+    else tokens.push({ kind: "value", value: Number(m[1]), unit: m[2] });
+  }
+  return tokens;
+}
+function parseUnitExpr(text) {
+  const tokens = tokenize(text);
+  let i = 0;
+  const isOp = (op) => {
+    const t = tokens[i];
+    return t !== void 0 && t.kind === "op" && t.op === op;
+  };
+  const fail = () => {
+    throw new Error(`unitExpr: '${text}' is not a complete expression`);
+  };
+  const sum = () => {
+    let left = product();
+    while (isOp("+") || isOp("-")) {
+      const op = isOp("+") ? "add" : "sub";
+      i++;
+      left = { op, left, right: product() };
+    }
+    return left;
+  };
+  const product = () => {
+    let left = unary();
+    while (isOp("*") || isOp("/")) {
+      const op = isOp("*") ? "mul" : "div";
+      i++;
+      left = { op, left, right: unary() };
+    }
+    return left;
+  };
+  const unary = () => {
+    if (isOp("+")) {
+      i++;
+      return unary();
+    }
+    if (!isOp("-")) return primary();
+    i++;
+    const of = unary();
+    return of.op === "value" ? { ...of, value: -of.value } : { op: "neg", of };
+  };
+  const primary = () => {
+    if (isOp("(")) {
+      i++;
+      const inner = sum();
+      if (!isOp(")")) fail();
+      i++;
+      return inner;
+    }
+    let left = literal();
+    while (tokens[i]?.kind === "value") left = { op: "add", left, right: literal() };
+    return left;
+  };
+  const literal = () => {
+    const t = tokens[i];
+    if (t === void 0 || t.kind !== "value") return fail();
+    i++;
+    return t.unit === void 0 ? { op: "value", value: t.value } : { op: "value", value: t.value, unit: t.unit };
+  };
+  const expr = sum();
+  if (i !== tokens.length) fail();
+  return expr;
+}
+function resolveNode(expr, ctx) {
+  if (expr.op === "value") return resolveValue(expr.value, expr.unit, ctx);
+  if (expr.op === "neg") {
+    const of = amountOf(resolveNode(expr.of, ctx));
+    return { ...of, n: -of.n };
+  }
+  const l = amountOf(resolveNode(expr.left, ctx));
+  const r = amountOf(resolveNode(expr.right, ctx));
+  switch (expr.op) {
+    case "add":
+      return { n: l.n + r.n, measure: l.measure || r.measure, offset: false };
+    case "sub":
+      return { n: l.n - r.n, measure: l.measure || r.measure, offset: false };
+    case "mul":
+      if (l.measure && r.measure) throw new Error("unitExpr: cannot multiply two measures");
+      return { n: l.n * r.n, measure: l.measure || r.measure, offset: false };
+    case "div":
+      if (r.measure && !l.measure) throw new Error("unitExpr: cannot divide by a measure");
+      return { n: l.n / r.n, measure: l.measure && !r.measure, offset: false };
+  }
+}
+function amountOf(r) {
+  if (r.offset) {
+    throw new Error("unitExpr: a unit with an offset names a point, and has no place in arithmetic");
+  }
+  return r;
+}
+function resolveValue(value, unit2, ctx) {
+  if (unit2 === void 0) return { n: value, measure: false, offset: false };
+  const units = ctx.unitSystem ? withSpellings(ctx.unitSystem.units) : void 0;
+  if (unit2 === "%" && units?.["%"] === void 0) {
+    if (ctx.percentOf === void 0) {
+      throw new Error(`unitExpr: ${value}% needs a percentOf to resolve against`);
+    }
+    return { n: value / 100 * ctx.percentOf, measure: true, offset: false };
+  }
+  if (!ctx.unitSystem || !units) throw new Error(`unitExpr: ${value}${unit2} requires a UnitSystem`);
+  let scale;
+  try {
+    scale = unitScale({ base: ctx.unitSystem.base, units }, unit2);
+  } catch (e) {
+    throw new Error(`unitExpr: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  return { n: value * scale.factor + scale.offset, measure: true, offset: scale.offset !== 0 };
+}
+function resolveUnitExpr(expr, ctx = {}) {
+  return resolveNode(typeof expr === "string" ? parseUnitExpr(expr) : expr, ctx).n;
+}
+
+// src/scope.ts
+function toRoot(base, scopes) {
+  let n = base;
+  for (let i = scopes.length - 1; i >= 0; i--) {
+    const { factor, offset } = entryScale(scopes[i].scale ?? 1);
+    n = n * factor + offset;
+  }
+  return n;
+}
+function fromRoot(rootBase, scopes) {
+  let n = rootBase;
+  for (const scope of scopes) {
+    const { factor, offset } = entryScale(scope.scale ?? 1);
+    n = (n - offset) / factor;
+  }
+  return n;
+}
+function resolveScoped(v, scopes) {
+  return toRoot(resolveUnit(v, scopes[scopes.length - 1]?.system), scopes);
+}
+function formatScoped(rootBase, displayUnit, scopes, opts) {
+  return formatUnit(fromRoot(rootBase, scopes), displayUnit, scopes[scopes.length - 1].system, opts);
+}
+function scopesOf(id, root, tree) {
+  const inner = [];
+  let at = tree.inclusive ? id : tree.parentOf(id);
+  while (at !== null && at !== void 0) {
+    const scope = tree.scopeOf(at);
+    if (scope) inner.push(scope);
+    at = tree.parentOf(at);
+  }
+  return [root, ...inner.reverse()];
+}
+
+// src/composite.ts
+var SEPARATOR = "separator";
+var MEASURE = /* @__PURE__ */ new Set(["unit", "percentSign"]);
+function measureTail(parts) {
+  let at = parts.length;
+  while (at > 0 && (MEASURE.has(parts[at - 1].type) || parts[at - 1].type === "literal")) at--;
+  const tail = parts.slice(at);
+  return tail.some((p) => MEASURE.has(p.type)) ? tail : [];
+}
+function rangeEnds(from, to, fallback, options) {
+  const a = partsOf(from, fallback, options);
+  const b = partsOf(to, fallback, options);
+  const tail = measureTail(a);
+  const shared = tail.length > 0 && textOf(tail) === textOf(measureTail(b));
+  return [shared ? a.slice(0, a.length - tail.length) : a, b];
+}
+function rangeSeparator(from, to, options) {
+  return options?.separator ?? (amount(from) < 0 || amount(to) < 0 ? " \u2013 " : "\u2013");
+}
+function rangeParts(from, to, fallback, options) {
+  const [a, b] = rangeEnds(from, to, fallback, options);
+  return [...a, { type: SEPARATOR, value: rangeSeparator(from, to, options) }, ...b];
+}
+function presentRange(from, to, fallback, options) {
+  const [a, b] = rangeEnds(from, to, fallback, options);
+  const separator = rangeSeparator(from, to, options);
+  const spoken = [from, to].map((q) => present(q, fallback, options).spoken);
+  return {
+    text: `${textOf(a)}${separator}${textOf(b)}`,
+    spoken: spoken.join(options?.spokenSeparator ?? " to "),
+    html: compositeHtml("range", [partsToHtml(amount(from), a), partsToHtml(amount(to), b)], separator)
+  };
+}
+function vectorParts(members, fallback, options) {
+  const separator = options?.separator ?? ", ";
+  return members.flatMap((q, i) => [
+    ...i > 0 ? [{ type: SEPARATOR, value: separator }] : [],
+    ...labelParts(options?.labels?.[i]),
+    ...partsOf(q, fallback, options)
+  ]);
+}
+function presentVector(members, fallback, options) {
+  const separator = options?.separator ?? ", ";
+  const label = (i) => textOf(labelParts(options?.labels?.[i]));
+  return {
+    text: textOf(vectorParts(members, fallback, options)),
+    spoken: members.map((q, i) => `${label(i)}${present(q, fallback, options).spoken}`).join(separator),
+    html: compositeHtml(
+      "vector",
+      members.map((q, i) => `${partsHtml(labelParts(options?.labels?.[i]))}${present(q, fallback, options).html}`),
+      separator
+    )
+  };
+}
+function labelParts(label) {
+  return label === void 0 ? [] : [{ type: "label", value: label }, { type: "literal", value: " " }];
+}
+function partsHtml(parts) {
+  return parts.map((p) => p.type === "literal" ? escapeMarkup(p.value) : `<span data-part="${escapeMarkup(p.type)}">${escapeMarkup(p.value)}</span>`).join("");
+}
+function compositeHtml(kind, members, separator) {
+  const between = partsHtml([{ type: SEPARATOR, value: separator }]);
+  return `<span data-composite="${kind}">${members.join(between)}</span>`;
+}
+
+export { ANGLE_RADIANS, CONSTANTS, IMPERIAL_INCHES, METRIC_MM, MINUS_SIGN, PIXELS, QuantityView, amount, axisUnits, bytes, bytesKind, compact, compactKind, currency, currencyKind, decimal, decimalKind, displayKindOf, displayOf, duration, durationKind, endless, entryScale, formatAxes, formatCompact, formatNumber, formatScoped, formatUnit, fraction, fractionKind, fromRoman, fromRoot, integer, integerKind, intlParts, multiplier, multiplierKind, nearestFraction, numberPart, ordinal, ordinalKind, parseAs, parseNumber, parseSignedNumber, parseUnitExpr, partsOf, partsToHtml, percent, percentKind, plural, present, presentRange, presentVector, qty, rangeParts, ratio, ratioKind, registerDisplayKind, resolveAxes, resolveScoped, resolveUnit, resolveUnitExpr, retag, roman, romanKind, scopesOf, signed, spokenSign, tag, textOf, toRoman, toRoot, unit, unitKind, unitOf, unitScale, vectorParts, zoom, zoomKind };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map