@weasel-js/quantity 1.6.1

package/dist/index.js

@@ -0,0 +1,765 @@
+// src/quantity.ts
+function amount(q) {
+  return typeof q === "number" ? q : q.value;
+}
+function retag(q, next) {
+  return typeof q === "number" ? next : { ...q, value: next };
+}
+function tag(value, display, unit2) {
+  const t = { value };
+  if (unit2 !== void 0) t.unit = unit2;
+  if (display !== void 0) t.display = display;
+  return t;
+}
+function displayOf(q, fallback) {
+  return (typeof q === "number" ? void 0 : q.display) ?? fallback;
+}
+function unitOf(q) {
+  return typeof q === "number" ? void 0 : q.unit;
+}
+
+// src/units.ts
+function unitScale(unitSystem, unit2) {
+  const entry = unitSystem.units[unit2];
+  if (entry === void 0) {
+    const known = Object.keys(unitSystem.units).join(", ") || "(none)";
+    throw new Error(
+      `unknown unit '${unit2}' (system base: '${unitSystem.base}', known units: ${known})`
+    );
+  }
+  return entryScale(entry);
+}
+function entryScale(entry) {
+  return typeof entry === "number" ? { factor: entry, offset: 0 } : { factor: entry.factor, offset: entry.offset ?? 0 };
+}
+function resolveUnit(v, unitSystem) {
+  if (typeof v === "number") return v;
+  if (v.unit === void 0) return v.value;
+  if (!unitSystem) {
+    throw new Error(
+      `resolveUnit: tagged value { value: ${v.value}, unit: '${v.unit}' } requires a UnitSystem`
+    );
+  }
+  const { factor, offset } = scaleOrThrow("resolveUnit", unitSystem, v.unit);
+  return v.value * factor + offset;
+}
+function formatUnit(baseValue, displayUnit, unitSystem, opts) {
+  const { factor, offset } = scaleOrThrow("formatUnit", unitSystem, displayUnit);
+  const precision = opts?.precision ?? 2;
+  const suffix = opts?.suffix ?? true;
+  const display = (baseValue - offset) / factor;
+  let s = display.toFixed(precision);
+  if (s.includes(".")) {
+    s = s.replace(/0+$/, "").replace(/\.$/, "");
+  }
+  return suffix ? `${s}${displayUnit}` : s;
+}
+function scaleOrThrow(caller, unitSystem, unit2) {
+  try {
+    return unitScale(unitSystem, unit2);
+  } catch (e) {
+    throw new Error(`${caller}: ${e instanceof Error ? e.message : String(e)}`);
+  }
+}
+var IMPERIAL_INCHES = {
+  base: "in",
+  units: { in: 1, ft: 12, yd: 36, mi: 63360 }
+};
+var METRIC_MM = {
+  base: "mm",
+  units: { mm: 1, cm: 10, m: 1e3, km: 1e6 }
+};
+var ANGLE_RADIANS = {
+  base: "rad",
+  units: { rad: 1, deg: Math.PI / 180, turn: Math.PI * 2 }
+};
+var PIXELS = {
+  base: "px",
+  units: { px: 1 }
+};
+
+// src/number.ts
+var MINUS_SIGN = "\u2212";
+function formatNumber(value, options) {
+  const formatted = Number.isFinite(value) ? value.toLocaleString(void 0, options) : String(value);
+  return formatted.replace(/^-/, MINUS_SIGN);
+}
+function parseSignedNumber(text) {
+  return Number(text.replace(MINUS_SIGN, "-"));
+}
+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);
+}
+function parseNumber(text, units) {
+  if (units) {
+    const trimmed = text.trim();
+    const name = unitSuffixOf(trimmed, units);
+    if (name !== void 0) {
+      const terms = compoundTermsOf(trimmed, units);
+      if (terms !== void 0 && terms.length > 1) return compoundValue(terms, trimmed, units);
+      const { factor, offset } = entryScale(units[name]);
+      return scaled(parseNumber(trimmed.slice(0, -name.length)), factor) + offset;
+    }
+  }
+  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{1,3}(,\d{3})+(\.\d*)?$/.test(t)) t = t.replace(/,/g, "");
+  if (!/\d/.test(t)) return Number.NaN;
+  return Number(exponent === void 0 ? t : `${t}e${exponent}`);
+}
+function scaled(n, factor) {
+  return factor < 1 ? n / (1 / factor) : n * factor;
+}
+function compoundTermsOf(text, units) {
+  const names = [];
+  let rest = text.trimEnd();
+  while (rest !== "") {
+    const name = unitSuffixOf(rest, units);
+    if (name === void 0) return void 0;
+    names.push(name);
+    const before = rest.slice(0, -name.length);
+    const m = /(\d+(?:\.\d+)?|\.\d+)\s*$/.exec(before);
+    if (!m) return void 0;
+    rest = before.slice(0, m.index).trimEnd();
+    if (rest === "-" || rest === "+" || rest === MINUS_SIGN) rest = "";
+  }
+  return names.length === 0 ? void 0 : names.reverse();
+}
+function compoundValue(names, text, units) {
+  const digits = text.match(/\d+(?:\.\d+)?|\.\d+/g);
+  if (!digits || digits.length !== names.length) return Number.NaN;
+  const sign = /^\s*[-\u2212]/.test(text) ? -1 : 1;
+  let total = 0;
+  for (const [i, name] of names.entries()) {
+    const { factor, offset } = entryScale(units[name]);
+    if (offset !== 0) return Number.NaN;
+    total += scaled(Number(digits[i]), factor);
+  }
+  return sign * total;
+}
+function unitSuffixOf(text, units) {
+  const names = Object.keys(units).filter((n) => n !== "").sort((a, b) => b.length - a.length);
+  const lower = text.toLowerCase();
+  return names.find((n) => text.endsWith(n)) ?? names.find((n) => lower.endsWith(n.toLowerCase()));
+}
+
+// src/kind.ts
+function textOf(parts) {
+  return parts.map((p) => p.value).join("");
+}
+function numberPart(value, locale, options) {
+  return { type: "number", value: signed(value.toLocaleString(locale, options)) };
+}
+function signed(text) {
+  return text.replace(/^-/, MINUS_SIGN);
+}
+function spokenSign(text) {
+  return text.replace(/^[-−]/, "minus ");
+}
+function plural(value, locale, singular, pluralForm) {
+  return new Intl.PluralRules(locale).select(value) === "one" ? singular : pluralForm;
+}
+function intlParts(value, locale, options) {
+  const out = [];
+  for (const p of new Intl.NumberFormat(locale, options).formatToParts(value)) {
+    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];
+    if (type === "number" && last?.type === "number") last.value += v;
+    else out.push({ type, value: v });
+  }
+  return out;
+}
+var DIGIT_RUNS = /* @__PURE__ */ new Set(["minusSign", "plusSign", "integer", "group", "decimal", "fraction"]);
+
+// src/kinds/plain.ts
+function decimal(options = {}) {
+  return { kind: "decimal", ...options };
+}
+var decimalKind = {
+  kind: "decimal",
+  format: (value, d, ctx) => intlParts(value, ctx.locale, decimalOptions(d)),
+  speak: (value, d, ctx) => spokenSign(textOf(intlParts(value, ctx.locale, decimalOptions(d)))),
+  parse: (text) => parseNumber(text)
+};
+function decimalOptions(d) {
+  const grouping = d.grouping ?? true;
+  return d.places === void 0 ? { maximumFractionDigits: d.maxPlaces ?? 3, useGrouping: grouping } : { minimumFractionDigits: d.places, maximumFractionDigits: d.places, useGrouping: grouping };
+}
+function integer(options = {}) {
+  return { kind: "integer", ...options };
+}
+var integerKind = {
+  kind: "integer",
+  format: (value, d, ctx) => intlParts(value, ctx.locale, { maximumFractionDigits: 0, useGrouping: d.grouping ?? true }),
+  speak: (value, d, ctx) => spokenSign(textOf(integerKind.format(value, d, ctx))),
+  parse: (text) => Math.round(parseNumber(text))
+};
+function compact(options = {}) {
+  return { kind: "compact", ...options };
+}
+var compactKind = {
+  kind: "compact",
+  format: (value, d) => {
+    const text = formatCompact(value, d.places ?? 0);
+    const m = /^(.*?\d)([A-Za-z]+)$/.exec(text);
+    return m ? [
+      { type: "number", value: m[1] },
+      { type: "compact", value: m[2] }
+    ] : [{ type: "number", value: text }];
+  },
+  speak: (value, d, ctx) => spokenSign(
+    textOf(
+      Math.abs(value) < 1e3 ? compactKind.format(value, d, ctx) : intlParts(value, ctx.locale, {
+        notation: "compact",
+        compactDisplay: "long",
+        maximumSignificantDigits: 3
+      })
+    )
+  ),
+  parse: (text) => parseNumber(text)
+};
+
+// src/kinds/proportion.ts
+function percent(options = {}) {
+  return { kind: "percent", ...options };
+}
+var percentKind = {
+  kind: "percent",
+  format: (value, d, ctx) => intlParts(value, ctx.locale, { style: "percent", maximumFractionDigits: d.places ?? 0 }),
+  speak: (value, d, ctx) => spokenSign(
+    textOf(
+      intlParts(value * 100, ctx.locale, {
+        style: "unit",
+        unit: "percent",
+        unitDisplay: "long",
+        maximumFractionDigits: d.places ?? 0
+      })
+    )
+  ),
+  parse: (text) => parseNumber(text.replace(/%\s*$/, "")) / 100
+};
+function nearestFraction(x, maxDenominator) {
+  if (!Number.isFinite(x)) return [x, 1];
+  const sign = x < 0 ? -1 : 1;
+  const target = Math.abs(x);
+  let [h0, h1, k0, k1] = [0, 1, 1, 0];
+  let y = target;
+  for (let i = 0; i < 64; i++) {
+    const a = Math.floor(y);
+    const k2 = a * k1 + k0;
+    if (k2 > maxDenominator) {
+      const t = Math.floor((maxDenominator - k0) / k1);
+      const [hs, ks] = [t * h1 + h0, t * k1 + k0];
+      if (Math.abs(hs / ks - target) < Math.abs(h1 / k1 - target)) [h1, k1] = [hs, ks];
+      break;
+    }
+    [h0, h1, k0, k1] = [h1, a * h1 + h0, k1, k2];
+    const rest = y - a;
+    if (rest < 1e-12 || Math.abs(h1 / k1 - target) < 1e-15) break;
+    y = 1 / rest;
+  }
+  return [sign * h1, k1];
+}
+function fraction(options = {}) {
+  return { kind: "fraction", ...options };
+}
+function fractionPieces(value, d) {
+  const [n, den] = nearestFraction(value, d.maxDenominator ?? 64);
+  const negative = n < 0;
+  const abs = Math.abs(n);
+  const whole = d.mixed || den === 1 ? Math.floor(abs / den) : 0;
+  return { negative, whole, num: abs - whole * den, den };
+}
+var fractionKind = {
+  kind: "fraction",
+  format: (value, d) => {
+    if (!Number.isFinite(value)) return [{ type: "number", value: String(value) }];
+    const { negative, whole, num, den } = fractionPieces(value, d);
+    const parts = [];
+    if (negative) parts.push({ type: "sign", value: MINUS_SIGN });
+    if (whole > 0 || num === 0) parts.push({ type: "whole", value: String(whole) });
+    if (num > 0) {
+      if (whole > 0) parts.push({ type: "literal", value: " " });
+      parts.push(
+        { type: "numerator", value: String(num) },
+        { type: "literal", value: "/" },
+        { type: "denominator", value: String(den) }
+      );
+    }
+    return parts;
+  },
+  speak: (value, d) => {
+    if (!Number.isFinite(value)) return String(value);
+    const { negative, whole, num, den } = fractionPieces(value, d);
+    const words = [
+      whole > 0 || num === 0 ? String(whole) : "",
+      whole > 0 && num > 0 ? "and" : "",
+      num > 0 ? `${num} over ${den}` : ""
+    ].filter(Boolean);
+    return `${negative ? "minus " : ""}${words.join(" ")}`;
+  },
+  parse: (text) => {
+    const m = /^\s*([-−+]?)\s*(?:(\d+)\s+)?(\d+)\s*[/⁄]\s*(\d+)\s*$/.exec(text);
+    if (!m) return parseNumber(text);
+    const magnitude = Number(m[2] ?? 0) + Number(m[3]) / Number(m[4]);
+    return m[1] === "-" || m[1] === MINUS_SIGN ? -magnitude : magnitude;
+  },
+  mathml: (value, d) => {
+    if (!Number.isFinite(value)) return void 0;
+    const { negative, whole, num, den } = fractionPieces(value, d);
+    const body = [
+      negative ? `<mo>${MINUS_SIGN}</mo>` : "",
+      whole > 0 || num === 0 ? `<mn>${whole}</mn>` : "",
+      num > 0 ? `<mfrac><mn>${num}</mn><mn>${den}</mn></mfrac>` : ""
+    ].join("");
+    return `<math>${body}</math>`;
+  }
+};
+function ratio(options = {}) {
+  return { kind: "ratio", ...options };
+}
+var ratioKind = {
+  kind: "ratio",
+  format: (value, d) => {
+    if (!Number.isFinite(value)) return [{ type: "number", value: String(value) }];
+    const [n, den] = nearestFraction(value, d.maxDenominator ?? 64);
+    return [
+      { type: "antecedent", value: String(n).replace(/^-/, MINUS_SIGN) },
+      { type: "literal", value: ":" },
+      { type: "consequent", value: String(den) }
+    ];
+  },
+  speak: (value, d) => {
+    if (!Number.isFinite(value)) return String(value);
+    const [n, den] = nearestFraction(value, d.maxDenominator ?? 64);
+    return spokenSign(`${String(n).replace(/^-/, MINUS_SIGN)} to ${den}`);
+  },
+  parse: (text) => {
+    const m = /^\s*(.+?)\s*:\s*(.+?)\s*$/.exec(text);
+    return m ? parseNumber(m[1]) / parseNumber(m[2]) : parseNumber(text);
+  }
+};
+function multiplier(options = {}) {
+  return { kind: "multiplier", ...options };
+}
+var multiplierKind = {
+  kind: "multiplier",
+  format: (value, d, ctx) => [
+    numberPart(value, ctx.locale, { maximumFractionDigits: d.places ?? 2 }),
+    { type: "symbol", value: d.symbol ?? "\xD7" }
+  ],
+  speak: (value, d, ctx) => spokenSign(`${numberPart(value, ctx.locale, { maximumFractionDigits: d.places ?? 2 }).value} times`),
+  parse: (text) => parseNumber(text.replace(/\s*[x×X]\s*$/, ""))
+};
+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) });
+  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" }];
+}
+var zoomKind = {
+  kind: "zoom",
+  format: (value) => zoomParts(value),
+  speak: (value) => spokenSign(
+    zoomParts(value).map((p) => p.type === "percentSign" ? " percent" : p.type === "symbol" ? " times" : p.value).join("")
+  ),
+  parse: (text) => {
+    const t = text.trim();
+    if (/[x×X]$/.test(t)) return parseNumber(t.slice(0, -1));
+    return parseNumber(t.replace(/%$/, "")) / 100;
+  }
+};
+
+// src/kinds/measure.ts
+var INTL_UNITS = {
+  mm: "millimeter",
+  cm: "centimeter",
+  m: "meter",
+  km: "kilometer",
+  in: "inch",
+  ft: "foot",
+  yd: "yard",
+  mi: "mile",
+  deg: "degree",
+  "\xB0": "degree",
+  ms: "millisecond",
+  s: "second",
+  min: "minute",
+  h: "hour",
+  g: "gram",
+  kg: "kilogram",
+  L: "liter",
+  "%": "percent"
+};
+var OWN_UNITS = {
+  px: ["pixel", "pixels"],
+  pt: ["point", "points"],
+  rad: ["radian", "radians"],
+  turn: ["turn", "turns"]
+};
+function unit(name, options = {}) {
+  return name === void 0 ? { kind: "unit", ...options } : { kind: "unit", unit: name, ...options };
+}
+var unitKind = {
+  kind: "unit",
+  format: (value, d, ctx) => {
+    const parts = [numberPart(value, ctx.locale, { maximumFractionDigits: d.places ?? 2, useGrouping: false })];
+    const name = d.unit ?? ctx.unit;
+    if (name) {
+      if (d.space) parts.push({ type: "literal", value: " " });
+      parts.push({ type: "unit", value: name });
+    }
+    return parts;
+  },
+  speak: (value, d, ctx) => {
+    const places = d.places ?? 2;
+    const name = d.unit ?? ctx.unit;
+    const intl = name === void 0 ? void 0 : INTL_UNITS[name];
+    if (intl !== void 0 && d.spoken === void 0) {
+      return spokenSign(
+        textOf(intlParts(value, ctx.locale, { style: "unit", unit: intl, unitDisplay: "long", maximumFractionDigits: places }))
+      );
+    }
+    const number = numberPart(value, ctx.locale, { maximumFractionDigits: places, useGrouping: false }).value;
+    const names = d.spoken ?? (name === void 0 ? void 0 : OWN_UNITS[name]);
+    const word = names ? plural(value, ctx.locale, names[0], names[1]) : name;
+    return spokenSign(word ? `${number} ${word}` : number);
+  },
+  parse: (text, d, ctx) => {
+    const name = d.unit ?? ctx.unit;
+    return parseNumber(text, d.accepts ?? (name ? { [name]: 1 } : void 0));
+  }
+};
+function currency(code, options = {}) {
+  return { kind: "currency", currency: code, ...options };
+}
+function currencyOptions(d) {
+  const options = { style: "currency", currency: d.currency };
+  if (d.places !== void 0) {
+    options.minimumFractionDigits = d.places;
+    options.maximumFractionDigits = d.places;
+  }
+  return options;
+}
+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) => parseNumber(text.replace(/[^\d.,+\-−]/g, ""))
+};
+function duration(options = {}) {
+  return { kind: "duration", ...options };
+}
+function hms(value, places) {
+  const scale = 10 ** places;
+  const total = Math.round(Math.abs(value) * scale) / scale;
+  const h = Math.floor(total / 3600);
+  const m = Math.floor((total - h * 3600) / 60);
+  const s = Math.round((total - h * 3600 - m * 60) * scale) / scale;
+  return { negative: value < 0 && total > 0, h, m, s };
+}
+var DURATION_UNITS = { h: 3600, m: 60, min: 60, s: 1, ms: 1e-3 };
+var durationKind = {
+  kind: "duration",
+  format: (value, d) => {
+    if (!Number.isFinite(value)) return [{ type: "number", value: String(value) }];
+    const places = d.places ?? 0;
+    const { negative, h, m, s } = hms(value, places);
+    const sec = s.toFixed(places);
+    const parts = negative ? [{ type: "sign", value: "\u2212" }] : [];
+    if (d.style === "units") {
+      const terms = [];
+      if (h > 0) terms.push([{ type: "hours", value: String(h) }, { type: "unit", value: "h" }]);
+      if (m > 0) terms.push([{ type: "minutes", value: String(m) }, { type: "unit", value: "m" }]);
+      if (s > 0 || terms.length === 0) terms.push([{ type: "seconds", value: sec }, { type: "unit", value: "s" }]);
+      terms.forEach((t, i) => parts.push(...i > 0 ? [{ type: "literal", value: " " }] : [], ...t));
+      return parts;
+    }
+    const pad = (n) => n.split(".")[0].length < 2 ? `0${n}` : n;
+    if (h > 0) {
+      parts.push(
+        { type: "hours", value: String(h) },
+        { type: "literal", value: ":" },
+        { type: "minutes", value: pad(String(m)) }
+      );
+    } else {
+      parts.push({ type: "minutes", value: String(m) });
+    }
+    parts.push({ type: "literal", value: ":" }, { type: "seconds", value: pad(sec) });
+    return parts;
+  },
+  speak: (value, d, ctx) => {
+    if (!Number.isFinite(value)) return String(value);
+    const { negative, h, m, s } = hms(value, d.places ?? 0);
+    const terms = [];
+    if (h > 0) terms.push(`${h} ${plural(h, ctx.locale, "hour", "hours")}`);
+    if (m > 0) terms.push(`${m} ${plural(m, ctx.locale, "minute", "minutes")}`);
+    if (s > 0 || terms.length === 0) terms.push(`${s} ${plural(s, ctx.locale, "second", "seconds")}`);
+    return `${negative ? "minus " : ""}${terms.join(", ")}`;
+  },
+  parse: (text) => {
+    const m = /^\s*([-−+]?)\s*(?:(\d+):)?(\d+):(\d+(?:\.\d+)?)\s*$/.exec(text);
+    if (!m) return parseNumber(text, DURATION_UNITS);
+    const total = Number(m[2] ?? 0) * 3600 + Number(m[3]) * 60 + Number(m[4]);
+    return m[1] === "-" || m[1] === "\u2212" ? -total : total;
+  }
+};
+var DECIMAL_BYTES = ["B", "kB", "MB", "GB", "TB", "PB"];
+var BINARY_BYTES = ["B", "KiB", "MiB", "GiB", "TiB", "PiB"];
+var DECIMAL_NAMES = ["byte", "kilobyte", "megabyte", "gigabyte", "terabyte", "petabyte"];
+var BINARY_NAMES = ["byte", "kibibyte", "mebibyte", "gibibyte", "tebibyte", "pebibyte"];
+function bytes(options = {}) {
+  return { kind: "bytes", ...options };
+}
+function byteScale(value, base) {
+  let step = 0;
+  let scaled2 = value;
+  while (Math.abs(scaled2) >= base && step < DECIMAL_BYTES.length - 1) {
+    scaled2 /= base;
+    step++;
+  }
+  return { scaled: scaled2, step };
+}
+var BYTE_UNITS = Object.fromEntries([
+  ...DECIMAL_BYTES.map((u, i) => [u, 1e3 ** i]),
+  ["KB", 1e3],
+  ...BINARY_BYTES.slice(1).map((u, i) => [u, 1024 ** (i + 1)])
+]);
+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;
+    return [
+      numberPart(scaled2, ctx.locale, { maximumFractionDigits: step === 0 ? 0 : d.places ?? 1 }),
+      { 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;
+    return spokenSign(`${number} ${plural(Number(number.replace(/[^\d.]/g, "")), ctx.locale, name, `${name}s`)}`);
+  },
+  parse: (text) => parseNumber(text, BYTE_UNITS)
+};
+
+// src/kinds/numeral.ts
+function roman(options = {}) {
+  return { kind: "roman", ...options };
+}
+var NUMERALS = [
+  [1e3, "M"],
+  [900, "CM"],
+  [500, "D"],
+  [400, "CD"],
+  [100, "C"],
+  [90, "XC"],
+  [50, "L"],
+  [40, "XL"],
+  [10, "X"],
+  [9, "IX"],
+  [5, "V"],
+  [4, "IV"],
+  [1, "I"]
+];
+function toRoman(n) {
+  let rest = Math.round(n);
+  if (!(rest >= 1 && rest <= 3999)) return void 0;
+  let out = "";
+  for (const [v, s] of NUMERALS) {
+    while (rest >= v) {
+      out += s;
+      rest -= v;
+    }
+  }
+  return out;
+}
+function fromRoman(text) {
+  const t = text.trim().toUpperCase();
+  if (!/^[MDCLXVI]+$/.test(t)) return Number.NaN;
+  let total = 0;
+  let i = 0;
+  for (const [v, s] of NUMERALS) {
+    while (t.startsWith(s, i)) {
+      total += v;
+      i += s.length;
+    }
+  }
+  return i === t.length && toRoman(total) === t ? total : Number.NaN;
+}
+var romanKind = {
+  kind: "roman",
+  format: (value, d, ctx) => {
+    const r = toRoman(value);
+    if (r === void 0) return [numberPart(value, ctx.locale, { maximumFractionDigits: 0 })];
+    return [{ type: "numeral", value: d.lower ? r.toLowerCase() : r }];
+  },
+  speak: (value, _d, ctx) => spokenSign(numberPart(Math.round(value), ctx.locale, { maximumFractionDigits: 0, useGrouping: false }).value),
+  parse: (text) => {
+    const r = fromRoman(text);
+    return Number.isNaN(r) ? parseNumber(text) : r;
+  }
+};
+function ordinal() {
+  return { kind: "ordinal" };
+}
+var SUFFIXES = { one: "st", two: "nd", few: "rd", other: "th" };
+var ordinalKind = {
+  kind: "ordinal",
+  format: (value, _d, ctx) => {
+    const n = Math.round(value);
+    const number = numberPart(n, ctx.locale, { maximumFractionDigits: 0 });
+    if (!Number.isFinite(n) || !ctx.locale.startsWith("en")) return [number];
+    const rule = new Intl.PluralRules("en-US", { type: "ordinal" }).select(n);
+    return [number, { type: "ordinal", value: SUFFIXES[rule] ?? "th" }];
+  },
+  parse: (text) => Math.round(parseNumber(text.replace(/(st|nd|rd|th)\s*$/i, "")))
+};
+
+// src/present.ts
+var BUILTIN = Object.fromEntries(
+  [
+    decimalKind,
+    integerKind,
+    compactKind,
+    percentKind,
+    fractionKind,
+    ratioKind,
+    multiplierKind,
+    zoomKind,
+    unitKind,
+    currencyKind,
+    durationKind,
+    bytesKind,
+    romanKind,
+    ordinalKind
+  ].map((k) => [k.kind, k])
+);
+var registered = /* @__PURE__ */ new Map();
+function registerDisplayKind(kind) {
+  const entry = kind;
+  registered.set(kind.kind, entry);
+  return () => {
+    if (registered.get(kind.kind) === entry) registered.delete(kind.kind);
+  };
+}
+function displayKindOf(display) {
+  const kind = display === void 0 ? void 0 : registered.get(display.kind) ?? BUILTIN[display.kind];
+  return kind ?? decimalKind;
+}
+var DEFAULT_DISPLAY = { kind: "decimal" };
+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 escape(s) {
+  return s.replace(/[&<>"]/g, (c) => ESCAPES[c]);
+}
+function partsToHtml(value, parts) {
+  const body = parts.map((p) => p.type === "literal" ? escape(p.value) : `<span data-part="${escape(p.type)}">${escape(p.value)}</span>`).join("");
+  return `<data value="${escape(String(value))}">${body}</data>`;
+}
+function partsOf(q, fallback, options) {
+  const display = displayOf(q, fallback) ?? DEFAULT_DISPLAY;
+  return displayKindOf(display).format(amount(q), display, contextOf(q, options));
+}
+function present(q, fallback, options) {
+  const display = displayOf(q, fallback) ?? DEFAULT_DISPLAY;
+  const kind = displayKindOf(display);
+  const value = amount(q);
+  const ctx = contextOf(q, options);
+  const parts = kind.format(value, display, ctx);
+  const text = textOf(parts);
+  const out = {
+    text,
+    spoken: kind.speak ? kind.speak(value, display, ctx) : text,
+    html: partsToHtml(value, parts)
+  };
+  const mathml = kind.mathml?.(value, display, ctx);
+  if (mathml !== void 0) out.mathml = mathml;
+  return out;
+}
+function parseAs(text, display, options) {
+  const d = display ?? DEFAULT_DISPLAY;
+  const kind = displayKindOf(d);
+  const ctx = { locale: options?.locale ?? "en-US" };
+  if (options?.unit !== void 0) ctx.unit = options.unit;
+  return kind.parse ? kind.parse(text, d, ctx) : parseNumber(text);
+}
+var QuantityView = class _QuantityView {
+  constructor(raw, fallback, options) {
+    this.raw = raw;
+    this.fallback = fallback;
+    this.options = options;
+  }
+  raw;
+  fallback;
+  options;
+  get value() {
+    return amount(this.raw);
+  }
+  get unit() {
+    return unitOf(this.raw);
+  }
+  /** The display in effect: the value's own, else the fallback. */
+  get display() {
+    return displayOf(this.raw, this.fallback);
+  }
+  get parts() {
+    return partsOf(this.raw, this.fallback, this.options);
+  }
+  get text() {
+    return textOf(this.parts);
+  }
+  get spoken() {
+    return present(this.raw, this.fallback, this.options).spoken;
+  }
+  get html() {
+    return partsToHtml(this.value, this.parts);
+  }
+  get mathml() {
+    return present(this.raw, this.fallback, this.options).mathml;
+  }
+  /** `next` in this quantity's shape — see {@link retag}. */
+  with(next) {
+    return new _QuantityView(retag(this.raw, next), this.fallback, this.options);
+  }
+  /** Typed text read through this quantity's display; NaN when it does not read. */
+  parse(text) {
+    const unit2 = this.unit;
+    return parseAs(text, this.display, unit2 === void 0 ? this.options : { ...this.options, unit: unit2 });
+  }
+  /** The same amount in `target`, converted through `system`, tagged with it. */
+  to(target, system) {
+    const from = unitScale(system, this.unit ?? system.base);
+    const to = unitScale(system, target);
+    const base = this.value * from.factor + from.offset;
+    const value = (base - to.offset) / to.factor;
+    const raw = typeof this.raw === "number" ? tag(value, void 0, target) : { ...this.raw, value, unit: target };
+    return new _QuantityView(raw, this.fallback, this.options);
+  }
+  toJSON() {
+    return this.raw;
+  }
+};
+function qty(q, fallback, options) {
+  return new QuantityView(q, fallback, options);
+}
+
+export { ANGLE_RADIANS, IMPERIAL_INCHES, METRIC_MM, MINUS_SIGN, PIXELS, QuantityView, amount, bytes, bytesKind, compact, compactKind, currency, currencyKind, decimal, decimalKind, displayKindOf, displayOf, duration, durationKind, 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 };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map