@danielsimonjr/mathts-core 0.16.0 → 0.18.0

package/dist/{chunk-MBKU4LYX.js → chunk-UEBMU6EV.js}

@@ -2148,7 +2148,867 @@ var DimensionMismatchError = class extends Error {
   }
 };
 
+// src/types/unit/exact-scale.ts
+var NAMED_IRRATIONALS = Object.freeze({
+  pi: "3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647",
+  ln2: "0.693147180559945309417232121458176568075500134360255254120680009493393621969694715605863326996418687542001481020570685733"
+});
+function isIrrationalName(name2) {
+  return Object.prototype.hasOwnProperty.call(NAMED_IRRATIONALS, name2);
+}
+function irrationalPower(s, name2) {
+  return s.irrationals[name2] ?? 0;
+}
+function isRationalScale(s) {
+  return Object.keys(s.irrationals).length === 0;
+}
+var NO_IRRATIONALS = Object.freeze({});
+function combinePowers(a, b, sign2) {
+  if (Object.keys(b).length === 0) return a;
+  const out = {};
+  let any = false;
+  for (const name2 of Object.keys(NAMED_IRRATIONALS)) {
+    const k = (a[name2] ?? 0) + sign2 * (b[name2] ?? 0);
+    if (k !== 0) {
+      out[name2] = k;
+      any = true;
+    }
+  }
+  return any ? Object.freeze(out) : NO_IRRATIONALS;
+}
+function scalePowers(a, n) {
+  if (n === 0) return NO_IRRATIONALS;
+  if (n === 1 || Object.keys(a).length === 0) return a;
+  const out = {};
+  for (const name2 of Object.keys(a)) out[name2] = a[name2] * n;
+  return Object.freeze(out);
+}
+function powersEqual(a, b) {
+  for (const name2 of Object.keys(NAMED_IRRATIONALS)) {
+    if ((a[name2] ?? 0) !== (b[name2] ?? 0)) return false;
+  }
+  return true;
+}
+var SAFE_GCD = 1n << 53n;
+function gcd(a, b) {
+  let x = a < 0n ? -a : a;
+  let y = b < 0n ? -b : b;
+  if (x <= SAFE_GCD && y <= SAFE_GCD) {
+    let p = Number(x);
+    let q = Number(y);
+    while (q !== 0) [p, q] = [q, p % q];
+    return BigInt(p);
+  }
+  while (y !== 0n) [x, y] = [y, x % y];
+  return x;
+}
+function isOne(s) {
+  return s.num === 1n && s.den === 1n && isRationalScale(s);
+}
+function make(num, den, irrationals) {
+  if (den === 0n) throw new RangeError("exact scale: zero denominator");
+  if (den < 0n) {
+    num = -num;
+    den = -den;
+  }
+  const g = gcd(num, den);
+  return g > 1n ? { num: num / g, den: den / g, irrationals } : { num, den, irrationals };
+}
+var UNIT_EXACT_SCALE = Object.freeze({
+  num: 1n,
+  den: 1n,
+  irrationals: NO_IRRATIONALS
+});
+function namedIrrationalScale(name2) {
+  return Object.freeze({ num: 1n, den: 1n, irrationals: Object.freeze({ [name2]: 1 }) });
+}
+var PI_EXACT_SCALE = namedIrrationalScale("pi");
+var LN2_EXACT_SCALE = namedIrrationalScale("ln2");
+var DECIMAL = /^([+-]?)(\d*)(?:\.(\d*))?(?:[eE]([+-]?\d+))?$/;
+function decimalExactScale(text) {
+  const m = DECIMAL.exec(text.trim());
+  if (m === null) return null;
+  const whole = m[2] ?? "";
+  const fraction = m[3] ?? "";
+  if (whole === "" && fraction === "") return null;
+  const exponent = Number(m[4] ?? "0") - fraction.length;
+  if (!Number.isSafeInteger(exponent) || Math.abs(exponent) > 1e4) return null;
+  let num = BigInt(whole + fraction);
+  if (m[1] === "-") num = -num;
+  return exponent >= 0 ? make(num * 10n ** BigInt(exponent), 1n, NO_IRRATIONALS) : make(num, 10n ** BigInt(-exponent), NO_IRRATIONALS);
+}
+function exactScaleOf(x) {
+  if (!Number.isFinite(x)) throw new RangeError(`exact scale: ${x} is not finite`);
+  if (Number.isSafeInteger(x)) return make(BigInt(x), 1n, NO_IRRATIONALS);
+  return decimalExactScale(String(x));
+}
+function binaryExactScale(x) {
+  if (!Number.isFinite(x)) throw new RangeError(`exact scale: ${x} is not finite`);
+  if (x === 0) return make(0n, 1n, NO_IRRATIONALS);
+  const view = new DataView(new ArrayBuffer(8));
+  view.setFloat64(0, x);
+  const bits = view.getBigUint64(0);
+  const negative = bits >> 63n === 1n;
+  const biased = Number(bits >> 52n & 0x7ffn);
+  const fraction = bits & (1n << 52n) - 1n;
+  const mantissa = biased === 0 ? fraction : fraction | 1n << 52n;
+  const exponent = (biased === 0 ? 1 : biased) - 1075;
+  const num = negative ? -mantissa : mantissa;
+  return exponent >= 0 ? make(num << BigInt(exponent), 1n, NO_IRRATIONALS) : make(num, 1n << BigInt(-exponent), NO_IRRATIONALS);
+}
+function ratioExactScale(num, den = 1n) {
+  return make(BigInt(num), BigInt(den), NO_IRRATIONALS);
+}
+function multiplyExactScales(...factors) {
+  if (factors.length === 2) {
+    if (isOne(factors[1])) return factors[0];
+    if (isOne(factors[0])) return factors[1];
+  }
+  let num = 1n;
+  let den = 1n;
+  let irrationals = NO_IRRATIONALS;
+  for (const f of factors) {
+    num *= f.num;
+    den *= f.den;
+    irrationals = combinePowers(irrationals, f.irrationals, 1);
+  }
+  return make(num, den, irrationals);
+}
+function divideExactScales(a, b) {
+  if (b.num === 0n) throw new RangeError("exact scale: division by zero");
+  if (isOne(b)) return a;
+  return make(a.num * b.den, a.den * b.num, combinePowers(a.irrationals, b.irrationals, -1));
+}
+function powerExactScale(a, n) {
+  if (!Number.isInteger(n)) throw new RangeError(`exact scale: power ${n} is not an integer`);
+  const k = BigInt(Math.abs(n));
+  const up = make(a.num ** k, a.den ** k, scalePowers(a.irrationals, Math.abs(n)));
+  return n >= 0 ? up : divideExactScales(UNIT_EXACT_SCALE, up);
+}
+function exactScalesEqual(a, b) {
+  return a.num === b.num && a.den === b.den && (a.num === 0n || powersEqual(a.irrationals, b.irrationals));
+}
+function addExactScales(a, b) {
+  if (a.num === 0n) return b;
+  if (b.num === 0n) return a;
+  if (!powersEqual(a.irrationals, b.irrationals)) return null;
+  return make(a.num * b.den + b.num * a.den, a.den * b.den, a.irrationals);
+}
+var IRRATIONAL_RATIONALS = Object.freeze(
+  Object.fromEntries(
+    Object.keys(NAMED_IRRATIONALS).map((name2) => [
+      name2,
+      decimalExactScale(NAMED_IRRATIONALS[name2])
+    ])
+  )
+);
+var SAFE_OPERAND = 1n << 53n;
+function bitLength(x) {
+  if (x === 0n) return 0;
+  const hex = x.toString(16);
+  return (hex.length - 1) * 4 + (32 - Math.clz32(parseInt(hex[0], 16)));
+}
+function rationalToNumber(num, den) {
+  if (num === 0n) return 0;
+  const negative = num < 0n;
+  const a = negative ? -num : num;
+  if (a <= SAFE_OPERAND && den <= SAFE_OPERAND) {
+    const q = Number(a) / Number(den);
+    return negative ? -q : q;
+  }
+  const e = bitLength(a) - bitLength(den);
+  if (e > 1025) return negative ? -Infinity : Infinity;
+  if (e < -1080) return negative ? -0 : 0;
+  let shift = 52 - e;
+  const quotient = (k) => k >= 0 ? (a << BigInt(k)) / den : a / (den << BigInt(-k));
+  if (quotient(shift) < 1n << 52n) shift += 1;
+  if (shift > 1074) shift = 1074;
+  const n = shift >= 0 ? a << BigInt(shift) : a;
+  const d = shift >= 0 ? den : den << BigInt(-shift);
+  let m = n / d;
+  const twice = 2n * (n % d);
+  if (twice > d || twice === d && m % 2n === 1n) m += 1n;
+  if (m === 1n << 53n) {
+    m >>= 1n;
+    shift -= 1;
+  }
+  if (52 - shift > 1023) return negative ? -Infinity : Infinity;
+  const value = Number(m) * 2 ** -shift;
+  if (!Number.isFinite(value)) return negative ? -Infinity : Infinity;
+  return negative ? -value : value;
+}
+function scaleToRational(s) {
+  let num = s.num;
+  let den = s.den;
+  for (const name2 of Object.keys(s.irrationals)) {
+    const power = s.irrationals[name2];
+    const c = IRRATIONAL_RATIONALS[name2];
+    const k = BigInt(Math.abs(power));
+    if (power > 0) {
+      num *= c.num ** k;
+      den *= c.den ** k;
+    } else {
+      num *= c.den ** k;
+      den *= c.num ** k;
+    }
+  }
+  return { num, den };
+}
+var EXACT_SCALE_NUMBER_CACHE_LIMIT = 4096;
+var numberCache = /* @__PURE__ */ new Map();
+var roundedByIdentity = /* @__PURE__ */ new WeakMap();
+function roundExactScale(s) {
+  let value = roundedByIdentity.get(s);
+  if (value === void 0) {
+    const { num, den } = scaleToRational(s);
+    value = rationalToNumber(num, den);
+    roundedByIdentity.set(s, value);
+  }
+  return value;
+}
+function powersKey(p) {
+  let key = "";
+  for (const name2 of Object.keys(p)) key += `|${name2}^${p[name2]}`;
+  return key;
+}
+function cacheKey(s) {
+  return `${s.num}/${s.den}${powersKey(s.irrationals)}`;
+}
+function clearExactScaleNumberCache() {
+  numberCache.clear();
+}
+function exactScaleNumberCacheSize() {
+  return numberCache.size;
+}
+function exactScaleToNumber(s) {
+  const key = cacheKey(s);
+  const cached = numberCache.get(key);
+  if (cached !== void 0) {
+    numberCache.delete(key);
+    numberCache.set(key, cached);
+    return cached;
+  }
+  const value = roundExactScale(s);
+  numberCache.set(key, value);
+  if (numberCache.size > EXACT_SCALE_NUMBER_CACHE_LIMIT) {
+    numberCache.delete(numberCache.keys().next().value);
+  }
+  return value;
+}
+function formatExactScale(s) {
+  const rational = s.den === 1n ? `${s.num}` : `${s.num}/${s.den}`;
+  const parts = [rational];
+  for (const name2 of Object.keys(s.irrationals)) {
+    const k = s.irrationals[name2];
+    parts.push(k === 1 ? name2 : `${name2}^${k}`);
+  }
+  return parts.join("*");
+}
+var TOKEN = /\s*(?:([()*/])|\^\s*([+-]?\d+)|([^\s*/^()]+))/y;
+function tokenize(text) {
+  const tokens = [];
+  TOKEN.lastIndex = 0;
+  let at = 0;
+  while (at < text.length) {
+    if (/^\s*$/.test(text.slice(at))) break;
+    TOKEN.lastIndex = at;
+    const m = TOKEN.exec(text);
+    if (m === null) throw new RangeError(`exact scale: '${text}' is not a product of factors`);
+    if (m[1] !== void 0) tokens.push({ kind: "op", op: m[1] });
+    else if (m[2] !== void 0) tokens.push({ kind: "pow", n: Number(m[2]) });
+    else tokens.push({ kind: "atom", text: m[3] });
+    at = TOKEN.lastIndex;
+  }
+  return tokens;
+}
+function readScaleExpression(text, resolve = () => void 0) {
+  const tokens = tokenize(text);
+  let i = 0;
+  const fail = () => {
+    throw new RangeError(`exact scale: '${text}' is not a product of factors`);
+  };
+  const isOp = (op) => {
+    const t = tokens[i];
+    return t !== void 0 && t.kind === "op" && t.op === op;
+  };
+  const factor = () => {
+    const t = tokens[i++];
+    let base;
+    if (t === void 0) return fail();
+    if (t.kind === "op" && t.op === "(") {
+      base = expression();
+      if (!isOp(")")) fail();
+      i++;
+    } else if (t.kind === "atom") {
+      base = decimalExactScale(t.text) ?? (isIrrationalName(t.text) ? namedIrrationalScale(t.text) : resolve(t.text));
+      if (base === void 0) {
+        throw new RangeError(
+          `exact scale: '${text}' names '${t.text}', which is not a known scale`
+        );
+      }
+    } else {
+      return fail();
+    }
+    const p = tokens[i];
+    if (p !== void 0 && p.kind === "pow") {
+      i++;
+      return powerExactScale(base, p.n);
+    }
+    return base;
+  };
+  const product = (denominator) => {
+    let scale = factor();
+    while (isOp("*") || denominator && isOp("/")) {
+      i++;
+      scale = multiplyExactScales(scale, factor());
+    }
+    return scale;
+  };
+  const expression = () => {
+    const top = product(false);
+    if (!isOp("/")) return top;
+    i++;
+    return divideExactScales(top, product(true));
+  };
+  const result = expression();
+  if (i !== tokens.length) fail();
+  return result;
+}
+
+// src/types/unit/unit-table.ts
+var SI_PREFIX_LIST = [
+  ["da", "deca", 1, false],
+  ["h", "hecto", 2, false],
+  ["k", "kilo", 3, true],
+  ["M", "mega", 6, true],
+  ["G", "giga", 9, true],
+  ["T", "tera", 12, true],
+  ["P", "peta", 15, true],
+  ["E", "exa", 18, true],
+  ["Z", "zetta", 21, true],
+  ["Y", "yotta", 24, true],
+  ["R", "ronna", 27, true],
+  ["Q", "quetta", 30, true],
+  ["d", "deci", -1, false],
+  ["c", "centi", -2, false],
+  ["m", "milli", -3, true],
+  ["u", "micro", -6, true],
+  ["n", "nano", -9, true],
+  ["p", "pico", -12, true],
+  ["f", "femto", -15, true],
+  ["a", "atto", -18, true],
+  ["z", "zepto", -21, true],
+  ["y", "yocto", -24, true],
+  ["r", "ronto", -27, true],
+  ["q", "quecto", -30, true]
+];
+var IEC_PREFIX_LIST = [
+  ["Ki", "kibi", 1],
+  ["Mi", "mebi", 2],
+  ["Gi", "gibi", 3],
+  ["Ti", "tebi", 4],
+  ["Pi", "pebi", 5],
+  ["Ei", "exi", 6],
+  ["Zi", "zebi", 7],
+  ["Yi", "yobi", 8]
+];
+function prefixSet(entries) {
+  const set2 = { "": { radix: 10, power: 0, scientific: true } };
+  for (const [name2, power, scientific, radix] of entries) {
+    set2[name2] = Object.freeze({ radix: radix ?? 10, power, scientific });
+  }
+  return Object.freeze(set2);
+}
+var siShort = (scale, keep = () => true) => prefixSet(
+  SI_PREFIX_LIST.filter(([, , p]) => keep(p)).map(
+    ([short, , p, sci]) => [short, p * scale, sci]
+  )
+);
+var siLong = (keep = () => true) => prefixSet(
+  SI_PREFIX_LIST.filter(([, , p]) => keep(p)).map(([, long, p, sci]) => [long, p, sci])
+);
+var upToYotta = (p) => p >= 3 && p <= 24;
+var UNIT_PREFIX_SETS = Object.freeze({
+  NONE: prefixSet([]),
+  SHORT: siShort(1),
+  LONG: siLong(),
+  SHORTLONG: Object.freeze({ ...siShort(1), ...siLong() }),
+  SQUARED: siShort(2),
+  CUBIC: siShort(3),
+  BINARY_SHORT: Object.freeze({
+    ...siShort(1, upToYotta),
+    ...prefixSet(IEC_PREFIX_LIST.map(([short, , p]) => [short, p, true, 1024]))
+  }),
+  BINARY_LONG: Object.freeze({
+    ...siLong(upToYotta),
+    ...prefixSet(IEC_PREFIX_LIST.map(([, long, p]) => [long, p, true, 1024]))
+  }),
+  BTU: prefixSet([["MM", 6, true]]),
+  SHORT_UP_ONLY: siShort(1, (p) => p >= 3)
+});
+function unitPrefixExactScale(prefix) {
+  return powerExactScale(ratioExactScale(prefix.radix), prefix.power);
+}
+function getUnitPrefix(unit, name2) {
+  const row = getUnitRow(unit);
+  if (row === void 0) return void 0;
+  const set2 = UNIT_PREFIX_SETS[row.prefixes];
+  return Object.prototype.hasOwnProperty.call(set2, name2) ? set2[name2] : void 0;
+}
+var NAMED_SCALES = Object.freeze({
+  /** International inch, International Yard and Pound Agreement (1959). */
+  inch: "0.0254",
+  foot: "12*inch",
+  yard: "3*foot",
+  mile: "5280*foot",
+  /** International avoirdupois pound, International Yard and Pound Agreement (1959). */
+  pound: "0.45359237",
+  /** Standard acceleration of gravity, 3rd CGPM (1901). */
+  standard_gravity: "9.80665",
+  /** Pound-force: one pound times standard gravity. */
+  lbf: "pound*standard_gravity",
+  /** US gallon: 231 cubic inches. */
+  us_gallon: "231*inch^3",
+  us_fluid_ounce: "us_gallon/128",
+  /** Julian year, 365.25 days (IAU). */
+  julian_year: "365.25*86400",
+  /** Speed of light in vacuum, exact in the SI. */
+  speed_of_light: "299792458",
+  /** Astronomical unit, IAU 2012 Resolution B2. */
+  astronomical_unit: "149597870700",
+  /** Standard atmosphere, 10th CGPM (1954). */
+  standard_atmosphere: "101325",
+  /** International Table calorie (1956). */
+  calorie_IT: "4.1868"
+});
+var UNIT_ROWS = Object.freeze({
+  meter: { base: "LENGTH", prefixes: "LONG", scale: "1" },
+  inch: { base: "LENGTH", prefixes: "NONE", scale: "inch" },
+  foot: { base: "LENGTH", prefixes: "NONE", scale: "foot" },
+  yard: { base: "LENGTH", prefixes: "NONE", scale: "yard" },
+  mile: { base: "LENGTH", prefixes: "NONE", scale: "mile" },
+  link: { base: "LENGTH", prefixes: "NONE", scale: "0.66*foot" },
+  // Gunter link, 0.66 ft (international foot)
+  rod: { base: "LENGTH", prefixes: "NONE", scale: "16.5*foot" },
+  // 16.5 ft (international foot)
+  chain: { base: "LENGTH", prefixes: "NONE", scale: "66*foot" },
+  // 66 ft (international foot)
+  angstrom: { base: "LENGTH", prefixes: "NONE", scale: "1e-10" },
+  astronomicalUnit: { base: "LENGTH", prefixes: "NONE", scale: "astronomical_unit" },
+  // IAU 2012 Resolution B2
+  lightyear: { base: "LENGTH", prefixes: "NONE", scale: "speed_of_light*julian_year" },
+  // c × Julian year (IAU)
+  ly: { base: "LENGTH", prefixes: "SHORT_UP_ONLY", scale: "speed_of_light*julian_year" },
+  // c × Julian year (IAU)
+  parsec: { base: "LENGTH", prefixes: "LONG", scale: "648000*astronomical_unit/pi" },
+  // IAU 2015 Resolution B2: 648000/π au
+  pc: { base: "LENGTH", prefixes: "SHORT_UP_ONLY", scale: "648000*astronomical_unit/pi" },
+  // IAU 2015 Resolution B2: 648000/π au
+  nauticalMile: { base: "LENGTH", prefixes: "NONE", scale: "1852" },
+  fathom: { base: "LENGTH", prefixes: "NONE", scale: "6*foot" },
+  // 6 ft
+  furlong: { base: "LENGTH", prefixes: "NONE", scale: "660*foot" },
+  // 660 ft (1/8 mile)
+  point: { base: "LENGTH", prefixes: "NONE", scale: "inch/72" },
+  // 1/72 inch (PostScript point)
+  pica: { base: "LENGTH", prefixes: "NONE", scale: "inch/6" },
+  // 12 points = 1/6 inch
+  m: { base: "LENGTH", prefixes: "SHORT", scale: "1" },
+  in: { base: "LENGTH", prefixes: "NONE", scale: "inch" },
+  ft: { base: "LENGTH", prefixes: "NONE", scale: "foot" },
+  yd: { base: "LENGTH", prefixes: "NONE", scale: "yard" },
+  mi: { base: "LENGTH", prefixes: "NONE", scale: "mile" },
+  li: { base: "LENGTH", prefixes: "NONE", scale: "0.66*foot" },
+  rd: { base: "LENGTH", prefixes: "NONE", scale: "16.5*foot" },
+  // 16.5 ft (international foot)
+  ch: { base: "LENGTH", prefixes: "NONE", scale: "66*foot" },
+  // 66 ft
+  mil: { base: "LENGTH", prefixes: "NONE", scale: "0.001*inch" },
+  // 1/1000 inch
+  m2: { base: "SURFACE", prefixes: "SQUARED", scale: "1" },
+  sqin: { base: "SURFACE", prefixes: "NONE", scale: "inch^2" },
+  sqft: { base: "SURFACE", prefixes: "NONE", scale: "foot^2" },
+  sqyd: { base: "SURFACE", prefixes: "NONE", scale: "yard^2" },
+  sqmi: { base: "SURFACE", prefixes: "NONE", scale: "mile^2" },
+  sqrd: { base: "SURFACE", prefixes: "NONE", scale: "272.25*foot^2" },
+  // (16.5 ft)^2
+  sqch: { base: "SURFACE", prefixes: "NONE", scale: "4356*foot^2" },
+  // (66 ft)^2
+  sqmil: { base: "SURFACE", prefixes: "NONE", scale: "1e-6*inch^2" },
+  acre: { base: "SURFACE", prefixes: "NONE", scale: "43560*foot^2" },
+  // 43 560 ft^2 (international acre)
+  hectare: { base: "SURFACE", prefixes: "NONE", scale: "1e4" },
+  m3: { base: "VOLUME", prefixes: "CUBIC", scale: "1" },
+  L: { base: "VOLUME", prefixes: "SHORT", scale: "1e-3" },
+  l: { base: "VOLUME", prefixes: "SHORT", scale: "1e-3" },
+  litre: { base: "VOLUME", prefixes: "LONG", scale: "1e-3" },
+  cuin: { base: "VOLUME", prefixes: "NONE", scale: "inch^3" },
+  cuft: { base: "VOLUME", prefixes: "NONE", scale: "foot^3" },
+  cuyd: { base: "VOLUME", prefixes: "NONE", scale: "yard^3" },
+  teaspoon: { base: "VOLUME", prefixes: "NONE", scale: "5e-6" },
+  // metric teaspoon, 5 mL (not the US customary 4.93 mL)
+  tablespoon: { base: "VOLUME", prefixes: "NONE", scale: "15e-6" },
+  // metric tablespoon, 15 mL (not the US customary 14.79 mL)
+  drop: { base: "VOLUME", prefixes: "NONE", scale: "5e-8" },
+  // 0.05 mL (medical convention)
+  gtt: { base: "VOLUME", prefixes: "NONE", scale: "5e-8" },
+  // 0.05 mL (medical convention)
+  minim: { base: "VOLUME", prefixes: "NONE", scale: "us_fluid_ounce/480" },
+  // 1/480 US fl oz
+  fluiddram: { base: "VOLUME", prefixes: "NONE", scale: "us_fluid_ounce/8" },
+  // 1/8 US fl oz
+  fluidounce: { base: "VOLUME", prefixes: "NONE", scale: "us_fluid_ounce" },
+  gill: { base: "VOLUME", prefixes: "NONE", scale: "4*us_fluid_ounce" },
+  // 4 US fl oz
+  cc: { base: "VOLUME", prefixes: "NONE", scale: "1e-6" },
+  cup: { base: "VOLUME", prefixes: "NONE", scale: "8*us_fluid_ounce" },
+  // US customary cup, 8 US fl oz
+  pint: { base: "VOLUME", prefixes: "NONE", scale: "16*us_fluid_ounce" },
+  // US liquid pint
+  quart: { base: "VOLUME", prefixes: "NONE", scale: "32*us_fluid_ounce" },
+  // US liquid quart
+  gallon: { base: "VOLUME", prefixes: "NONE", scale: "us_gallon" },
+  // US gallon, 231 in^3
+  beerbarrel: { base: "VOLUME", prefixes: "NONE", scale: "31*us_gallon" },
+  // 31 US gal
+  oilbarrel: { base: "VOLUME", prefixes: "NONE", scale: "42*us_gallon" },
+  // 42 US gal
+  hogshead: { base: "VOLUME", prefixes: "NONE", scale: "63*us_gallon" },
+  // 63 US gal
+  g: { base: "MASS", prefixes: "SHORT", scale: "1e-3" },
+  gram: { base: "MASS", prefixes: "LONG", scale: "1e-3" },
+  ton: { base: "MASS", prefixes: "SHORT", scale: "2000*pound" },
+  // US short ton, 2000 lb
+  t: { base: "MASS", prefixes: "SHORT", scale: "1000" },
+  tonne: { base: "MASS", prefixes: "LONG", scale: "1000" },
+  grain: { base: "MASS", prefixes: "NONE", scale: "pound/7000" },
+  // 1/7000 lb
+  dram: { base: "MASS", prefixes: "NONE", scale: "pound/256" },
+  // avoirdupois dram, 1/256 lb
+  ounce: { base: "MASS", prefixes: "NONE", scale: "pound/16" },
+  // avoirdupois ounce
+  poundmass: { base: "MASS", prefixes: "NONE", scale: "pound" },
+  hundredweight: { base: "MASS", prefixes: "NONE", scale: "100*pound" },
+  // US short hundredweight, 100 lb
+  stick: { base: "MASS", prefixes: "NONE", scale: "0.115" },
+  // butter stick (as in mathjs)
+  stone: { base: "MASS", prefixes: "NONE", scale: "14*pound" },
+  // 14 lb
+  gr: { base: "MASS", prefixes: "NONE", scale: "pound/7000" },
+  dr: { base: "MASS", prefixes: "NONE", scale: "pound/256" },
+  oz: { base: "MASS", prefixes: "NONE", scale: "pound/16" },
+  lbm: { base: "MASS", prefixes: "NONE", scale: "pound" },
+  cwt: { base: "MASS", prefixes: "NONE", scale: "100*pound" },
+  s: { base: "TIME", prefixes: "SHORT", scale: "1" },
+  min: { base: "TIME", prefixes: "NONE", scale: "60" },
+  h: { base: "TIME", prefixes: "NONE", scale: "3600" },
+  second: { base: "TIME", prefixes: "LONG", scale: "1" },
+  sec: { base: "TIME", prefixes: "LONG", scale: "1" },
+  minute: { base: "TIME", prefixes: "NONE", scale: "60" },
+  hour: { base: "TIME", prefixes: "NONE", scale: "3600" },
+  day: { base: "TIME", prefixes: "NONE", scale: "86400" },
+  week: { base: "TIME", prefixes: "NONE", scale: "7*86400" },
+  month: { base: "TIME", prefixes: "NONE", scale: "julian_year/12" },
+  // 1/12 Julian year
+  year: { base: "TIME", prefixes: "NONE", scale: "julian_year" },
+  // Julian year
+  decade: { base: "TIME", prefixes: "NONE", scale: "10*julian_year" },
+  // 10 Julian years
+  century: { base: "TIME", prefixes: "NONE", scale: "100*julian_year" },
+  // 100 Julian years
+  millennium: { base: "TIME", prefixes: "NONE", scale: "1000*julian_year" },
+  // 1000 Julian years
+  hertz: { base: "FREQUENCY", prefixes: "LONG", scale: "1", name: "Hertz", reciprocal: true },
+  Hz: { base: "FREQUENCY", prefixes: "SHORT", scale: "1", reciprocal: true },
+  rad: { base: "ANGLE", prefixes: "SHORT", scale: "1" },
+  radian: { base: "ANGLE", prefixes: "LONG", scale: "1" },
+  deg: { base: "ANGLE", prefixes: "SHORT", scale: "pi/180" },
+  degree: { base: "ANGLE", prefixes: "LONG", scale: "pi/180" },
+  grad: { base: "ANGLE", prefixes: "SHORT", scale: "pi/200" },
+  gradian: { base: "ANGLE", prefixes: "LONG", scale: "pi/200" },
+  cycle: { base: "ANGLE", prefixes: "NONE", scale: "2*pi" },
+  // one turn, 2π rad
+  arcsec: { base: "ANGLE", prefixes: "NONE", scale: "pi/648000" },
+  arcmin: { base: "ANGLE", prefixes: "NONE", scale: "pi/10800" },
+  A: { base: "CURRENT", prefixes: "SHORT", scale: "1" },
+  ampere: { base: "CURRENT", prefixes: "LONG", scale: "1" },
+  K: { base: "TEMPERATURE", prefixes: "SHORT", scale: "1" },
+  degC: { base: "TEMPERATURE", prefixes: "SHORT", scale: "1", offset: "273.15" },
+  // K = °C + 273.15
+  degF: { base: "TEMPERATURE", prefixes: "SHORT", scale: "5/9", offset: "459.67" },
+  // K = (°F + 459.67) × 5/9
+  degR: { base: "TEMPERATURE", prefixes: "SHORT", scale: "5/9" },
+  // K = °R × 5/9
+  kelvin: { base: "TEMPERATURE", prefixes: "LONG", scale: "1" },
+  celsius: { base: "TEMPERATURE", prefixes: "LONG", scale: "1", offset: "273.15" },
+  fahrenheit: { base: "TEMPERATURE", prefixes: "LONG", scale: "5/9", offset: "459.67" },
+  rankine: { base: "TEMPERATURE", prefixes: "LONG", scale: "5/9" },
+  mol: { base: "AMOUNT_OF_SUBSTANCE", prefixes: "SHORT", scale: "1" },
+  mole: { base: "AMOUNT_OF_SUBSTANCE", prefixes: "LONG", scale: "1" },
+  cd: { base: "LUMINOUS_INTENSITY", prefixes: "SHORT", scale: "1" },
+  candela: { base: "LUMINOUS_INTENSITY", prefixes: "LONG", scale: "1" },
+  sr: { base: "SOLID_ANGLE", prefixes: "NONE", scale: "1" },
+  steradian: { base: "SOLID_ANGLE", prefixes: "LONG", scale: "1" },
+  N: { base: "FORCE", prefixes: "SHORT", scale: "1" },
+  newton: { base: "FORCE", prefixes: "LONG", scale: "1" },
+  dyn: { base: "FORCE", prefixes: "SHORT", scale: "1e-5" },
+  dyne: { base: "FORCE", prefixes: "LONG", scale: "1e-5" },
+  lbf: { base: "FORCE", prefixes: "NONE", scale: "lbf" },
+  poundforce: { base: "FORCE", prefixes: "NONE", scale: "lbf" },
+  kip: { base: "FORCE", prefixes: "LONG", scale: "1000*lbf" },
+  // 1000 lbf
+  kilogramforce: { base: "FORCE", prefixes: "NONE", scale: "standard_gravity" },
+  // standard gravity × 1 kg
+  J: { base: "ENERGY", prefixes: "SHORT", scale: "1" },
+  joule: { base: "ENERGY", prefixes: "LONG", scale: "1" },
+  erg: { base: "ENERGY", prefixes: "SHORTLONG", scale: "1e-7" },
+  Wh: { base: "ENERGY", prefixes: "SHORT", scale: "3600" },
+  cal: { base: "ENERGY", prefixes: "SHORT", scale: "4.184" },
+  // thermochemical calorie, 4.184 J exactly (NIST SP 811). Not cal_IT = 4.1868 J
+  calorie: { base: "ENERGY", prefixes: "LONG", scale: "4.184" },
+  // thermochemical calorie
+  BTU: { base: "ENERGY", prefixes: "BTU", scale: "1000*calorie_IT*pound/1.8" },
+  // International Table BTU: cal_IT × (lb/g) / 1.8
+  eV: { base: "ENERGY", prefixes: "SHORT", scale: "1.602176634e-19" },
+  // e × 1 V, exact since the 2019 SI
+  electronvolt: { base: "ENERGY", prefixes: "LONG", scale: "1.602176634e-19" },
+  W: { base: "POWER", prefixes: "SHORT", scale: "1" },
+  watt: { base: "POWER", prefixes: "LONG", scale: "1" },
+  hp: { base: "POWER", prefixes: "NONE", scale: "550*foot*lbf" },
+  // mechanical horsepower, 550 ft·lbf/s
+  VAR: { base: "POWER", prefixes: "SHORT", scale: "1", imaginary: true },
+  // reactive power: the value is the imaginary unit times this scale
+  VA: { base: "POWER", prefixes: "SHORT", scale: "1" },
+  Pa: { base: "PRESSURE", prefixes: "SHORT", scale: "1" },
+  psi: { base: "PRESSURE", prefixes: "NONE", scale: "lbf/inch^2" },
+  // lbf/in^2
+  atm: { base: "PRESSURE", prefixes: "NONE", scale: "standard_atmosphere" },
+  // standard atmosphere
+  bar: { base: "PRESSURE", prefixes: "SHORTLONG", scale: "1e5" },
+  torr: { base: "PRESSURE", prefixes: "NONE", scale: "standard_atmosphere/760" },
+  // 1/760 atm (exact)
+  mmHg: { base: "PRESSURE", prefixes: "NONE", scale: "13.5951*standard_gravity" },
+  // conventional mmHg: 13.5951 g/cm^3 × g_n × 1 mm = 133.322387415 Pa (NIST SP 811). Not the torr
+  mmH2O: { base: "PRESSURE", prefixes: "NONE", scale: "standard_gravity" },
+  // conventional: 1000 kg/m^3 × g_n × 1 mm
+  cmH2O: { base: "PRESSURE", prefixes: "NONE", scale: "10*standard_gravity" },
+  // conventional: 1000 kg/m^3 × g_n × 1 cm
+  coulomb: { base: "ELECTRIC_CHARGE", prefixes: "LONG", scale: "1" },
+  C: { base: "ELECTRIC_CHARGE", prefixes: "SHORT", scale: "1" },
+  farad: { base: "ELECTRIC_CAPACITANCE", prefixes: "LONG", scale: "1" },
+  F: { base: "ELECTRIC_CAPACITANCE", prefixes: "SHORT", scale: "1" },
+  volt: { base: "ELECTRIC_POTENTIAL", prefixes: "LONG", scale: "1" },
+  V: { base: "ELECTRIC_POTENTIAL", prefixes: "SHORT", scale: "1" },
+  ohm: { base: "ELECTRIC_RESISTANCE", prefixes: "SHORTLONG", scale: "1" },
+  henry: { base: "ELECTRIC_INDUCTANCE", prefixes: "LONG", scale: "1" },
+  H: { base: "ELECTRIC_INDUCTANCE", prefixes: "SHORT", scale: "1" },
+  siemens: { base: "ELECTRIC_CONDUCTANCE", prefixes: "LONG", scale: "1" },
+  S: { base: "ELECTRIC_CONDUCTANCE", prefixes: "SHORT", scale: "1" },
+  weber: { base: "MAGNETIC_FLUX", prefixes: "LONG", scale: "1" },
+  Wb: { base: "MAGNETIC_FLUX", prefixes: "SHORT", scale: "1" },
+  tesla: { base: "MAGNETIC_FLUX_DENSITY", prefixes: "LONG", scale: "1" },
+  T: { base: "MAGNETIC_FLUX_DENSITY", prefixes: "SHORT", scale: "1" },
+  b: { base: "BIT", prefixes: "BINARY_SHORT", scale: "1" },
+  // bit: its own BIT dimension (storage), not ln 2 nat
+  bits: { base: "BIT", prefixes: "BINARY_LONG", scale: "1" },
+  B: { base: "BIT", prefixes: "BINARY_SHORT", scale: "8" },
+  // byte, 8 bits
+  bytes: { base: "BIT", prefixes: "BINARY_LONG", scale: "8" }
+});
+var UNIT_ROW_ALIASES = Object.freeze({
+  meters: "meter",
+  // Astronomical / nautical / typography aliases (B-5 port). Lowercase
+  // 'au' is deliberately ABSENT: it collides with the atomic unit of
+  // length (Bohr radius, ~5.29e-11 m), 21 orders of magnitude smaller.
+  AU: "astronomicalUnit",
+  astronomicalUnits: "astronomicalUnit",
+  lightyears: "lightyear",
+  parsecs: "parsec",
+  nmi: "nauticalMile",
+  nauticalMiles: "nauticalMile",
+  fathoms: "fathom",
+  furlongs: "furlong",
+  points: "point",
+  picas: "pica",
+  inches: "inch",
+  feet: "foot",
+  yards: "yard",
+  miles: "mile",
+  links: "link",
+  rods: "rod",
+  chains: "chain",
+  angstroms: "angstrom",
+  lt: "l",
+  litres: "litre",
+  liter: "litre",
+  liters: "litre",
+  teaspoons: "teaspoon",
+  tablespoons: "tablespoon",
+  minims: "minim",
+  fldr: "fluiddram",
+  fluiddrams: "fluiddram",
+  floz: "fluidounce",
+  fluidounces: "fluidounce",
+  gi: "gill",
+  gills: "gill",
+  cp: "cup",
+  cups: "cup",
+  pt: "pint",
+  pints: "pint",
+  qt: "quart",
+  quarts: "quart",
+  gal: "gallon",
+  gallons: "gallon",
+  bbl: "beerbarrel",
+  beerbarrels: "beerbarrel",
+  obl: "oilbarrel",
+  oilbarrels: "oilbarrel",
+  hogsheads: "hogshead",
+  gtts: "gtt",
+  grams: "gram",
+  tons: "ton",
+  tonnes: "tonne",
+  grains: "grain",
+  drams: "dram",
+  ounces: "ounce",
+  poundmasses: "poundmass",
+  hundredweights: "hundredweight",
+  sticks: "stick",
+  lb: "lbm",
+  lbs: "lbm",
+  kips: "kip",
+  kgf: "kilogramforce",
+  acres: "acre",
+  hectares: "hectare",
+  sqfeet: "sqft",
+  sqyard: "sqyd",
+  sqmile: "sqmi",
+  sqmiles: "sqmi",
+  mmhg: "mmHg",
+  mmh2o: "mmH2O",
+  cmh2o: "cmH2O",
+  seconds: "second",
+  secs: "second",
+  minutes: "minute",
+  mins: "minute",
+  hours: "hour",
+  hr: "hour",
+  hrs: "hour",
+  days: "day",
+  weeks: "week",
+  months: "month",
+  years: "year",
+  decades: "decade",
+  centuries: "century",
+  millennia: "millennium",
+  hertz: "hertz",
+  radians: "radian",
+  degrees: "degree",
+  gradians: "gradian",
+  cycles: "cycle",
+  arcsecond: "arcsec",
+  arcseconds: "arcsec",
+  arcminute: "arcmin",
+  arcminutes: "arcmin",
+  BTUs: "BTU",
+  watts: "watt",
+  joules: "joule",
+  amperes: "ampere",
+  amps: "ampere",
+  amp: "ampere",
+  coulombs: "coulomb",
+  volts: "volt",
+  ohms: "ohm",
+  farads: "farad",
+  webers: "weber",
+  teslas: "tesla",
+  electronvolts: "electronvolt",
+  moles: "mole",
+  bit: "bits",
+  byte: "bytes",
+  calories: "calorie"
+});
+var namedCache = /* @__PURE__ */ new Map();
+function namedExactScale(name2) {
+  const cached = namedCache.get(name2);
+  if (cached !== void 0) return cached;
+  if (!Object.prototype.hasOwnProperty.call(NAMED_SCALES, name2)) return void 0;
+  const scale = readScaleExpression(NAMED_SCALES[name2], namedExactScale);
+  namedCache.set(name2, scale);
+  return scale;
+}
+function readUnitScale(expression) {
+  return readScaleExpression(expression, namedExactScale);
+}
+function getUnitRow(name2) {
+  const own = Object.prototype.hasOwnProperty;
+  if (own.call(UNIT_ROWS, name2)) return UNIT_ROWS[name2];
+  if (own.call(UNIT_ROW_ALIASES, name2)) return UNIT_ROWS[UNIT_ROW_ALIASES[name2]];
+  return void 0;
+}
+function unitRowExactScale(name2) {
+  const row = getUnitRow(name2);
+  return row === void 0 ? void 0 : readUnitScale(row.scale);
+}
+function unitRowValue(name2) {
+  const scale = unitRowExactScale(name2);
+  return scale === void 0 ? void 0 : exactScaleToNumber(scale);
+}
+function unitRowExactOffset(name2) {
+  const row = getUnitRow(name2);
+  if (row === void 0) return void 0;
+  return row.offset === void 0 ? ratioExactScale(0) : readUnitScale(row.offset);
+}
+
 // src/types/unit/Unit.ts
+var UNIT_ZERO_SCALE = ratioExactScale(0);
+function exactOffsetShift(from, to) {
+  if (from.exact === void 0 || to.exact === void 0) return null;
+  return addExactScales(
+    multiplyExactScales(from.exact, from.exactOffset ?? UNIT_ZERO_SCALE),
+    multiplyExactScales(ratioExactScale(-1), to.exact, to.exactOffset ?? UNIT_ZERO_SCALE)
+  );
+}
+function attachExactScale(def, exact, exactOffset) {
+  Object.defineProperty(def, "exact", {
+    value: exact,
+    enumerable: false,
+    writable: true,
+    configurable: true
+  });
+  Object.defineProperty(def, "exactOffset", {
+    value: exactOffset,
+    enumerable: false,
+    writable: true,
+    configurable: true
+  });
+}
+function liveExactSI(unit) {
+  const exact = unit._exactSI;
+  if (exact === void 0 || typeof unit.value !== "number") return void 0;
+  return unit.value === roundExactScale(exact) ? exact : void 0;
+}
+var prefixScales = /* @__PURE__ */ new WeakMap();
+function prefixExactScale(prefix) {
+  let scale = prefixScales.get(prefix);
+  if (scale === void 0) {
+    scale = Number.isFinite(prefix.value) ? exactScaleOf(prefix.value) : null;
+    prefixScales.set(prefix, scale);
+  }
+  return scale;
+}
+var definitionIds = /* @__PURE__ */ new WeakMap();
+var nextDefinitionId = 0;
+function identityOf(def) {
+  let id = definitionIds.get(def);
+  if (id === void 0) {
+    id = nextDefinitionId++;
+    definitionIds.set(def, id);
+  }
+  return id;
+}
+var UNIT_LIST_SCALE_CACHE_LIMIT = 1024;
+var unitListScales = /* @__PURE__ */ new Map();
 function normalizeDegreeSymbols(s) {
   return s.replace(/°C/g, "degC").replace(/°F/g, "degF").replace(/°/g, "deg");
 }
@@ -2197,6 +3057,72 @@ var createUnitClass = /* @__PURE__ */ factory(
     const toNumber = number2;
     const fixPrefixDefault = false;
     const skipAutomaticSimplificationDefault = true;
+    function bigNumberFromText(text2) {
+      const parse = BigNumber2.parse;
+      return typeof parse === "function" ? parse.call(BigNumber2, text2) : new BigNumber2(text2);
+    }
+    function exactToBigNumber(scale) {
+      const powerOfPi = irrationalPower(scale, "pi");
+      if (Object.keys(scale.irrationals).length !== (powerOfPi === 0 ? 0 : 1)) return void 0;
+      let v = bigNumberFromText(scale.num.toString()).div(bigNumberFromText(scale.den.toString()));
+      const pi = BIGNUMBER_PI;
+      for (let k = 0; k < Math.abs(powerOfPi); k++) v = powerOfPi > 0 ? v.times(pi) : v.div(pi);
+      return v;
+    }
+    function simplestReading(value, scale) {
+      if (value === 0) return void 0;
+      const start = applyExactScale(value, scale, true);
+      if (typeof start !== "number" || !Number.isFinite(start) || start === 0) return void 0;
+      const view = new DataView(new ArrayBuffer(8));
+      view.setFloat64(0, start);
+      const bits = view.getBigInt64(0);
+      let best;
+      let bestLength = Infinity;
+      for (const step of [0n, -1n, 1n, -2n, 2n, -3n, 3n, -4n, 4n]) {
+        view.setBigInt64(0, bits + step);
+        const r = view.getFloat64(0);
+        if (!Number.isFinite(r) || Math.sign(r) !== Math.sign(start)) continue;
+        if (roundExactScale(multiplyExactScales(exactScaleOf(r), scale)) !== value) continue;
+        const length = String(r).length;
+        if (length < bestLength) {
+          best = r;
+          bestLength = length;
+        }
+      }
+      return best;
+    }
+    function addExactShift(unit, value, shift) {
+      if (typeof value === "number") {
+        if (!Number.isFinite(value)) return void 0;
+        let normalized = binaryExactScale(value);
+        const scale = unit.exactScale();
+        const reading = scale === null ? void 0 : simplestReading(value, scale);
+        if (reading !== void 0) normalized = multiplyExactScales(exactScaleOf(reading), scale);
+        const sum = addExactScales(normalized, shift);
+        return sum === null ? void 0 : roundExactScale(sum);
+      }
+      const s = exactAs(shift, typeOf(value));
+      return s === void 0 ? void 0 : addScalar2(value, s);
+    }
+    function exactAs(scale, type) {
+      if (type === "Fraction") {
+        return isRationalScale(scale) ? new Fraction2(scale.num, scale.den) : void 0;
+      }
+      if (type === "BigNumber") return exactToBigNumber(scale);
+      return void 0;
+    }
+    function applyExactScale(value, scale, divide) {
+      if (typeof value === "number") {
+        if (!Number.isFinite(value) || value === 0) return void 0;
+        const x = divide ? binaryExactScale(value) : exactScaleOf(value);
+        return roundExactScale(
+          divide ? divideExactScales(x, scale) : multiplyExactScales(x, scale)
+        );
+      }
+      const factor = exactAs(scale, typeOf(value));
+      if (factor === void 0) return void 0;
+      return divide ? divideScalar2(value, factor) : multiplyScalar2(value, factor);
+    }
     const Unit2 = function(value, valuelessUnit) {
       if (!(this instanceof Unit2)) {
         throw new Error("Constructor must be called with the new operator");
@@ -2225,7 +3151,14 @@ var createUnitClass = /* @__PURE__ */ factory(
           "Second parameter in Unit constructor must be a string or valueless Unit"
         );
       }
-      this.value = this._normalize(value);
+      this._exactSI = void 0;
+      const scale = typeof value === "number" && Number.isFinite(value) && value !== 0 && this.units.length > 0 ? this.exactScale() : null;
+      if (scale !== null) {
+        this._exactSI = multiplyExactScales(exactScaleOf(value), scale);
+        this.value = roundExactScale(this._exactSI);
+      } else {
+        this.value = this._normalize(value);
+      }
     };
     Object.defineProperty(Unit2, "name", { value: "Unit" });
     Unit2.prototype.constructor = Unit2;
@@ -2463,6 +3396,7 @@ var createUnitClass = /* @__PURE__ */ factory(
       unit.fixPrefix = this.fixPrefix;
       unit.skipAutomaticSimplification = this.skipAutomaticSimplification;
       unit.value = clone(this.value);
+      unit._exactSI = this._exactSI;
       unit.dimensions = this.dimensions.slice(0);
       unit.units = [];
       for (let i = 0; i < this.units.length; i++) {
@@ -2486,10 +3420,47 @@ var createUnitClass = /* @__PURE__ */ factory(
       }
       return this.units.length > 1 || Math.abs(this.units[0].power - 1) > 1e-15;
     };
+    Unit2.prototype.exactScale = function() {
+      let key = "";
+      for (const component of this.units) {
+        key += `${identityOf(component.unit)}:${identityOf(component.prefix)}^${component.power};`;
+      }
+      const cached = unitListScales.get(key);
+      if (cached !== void 0) return cached;
+      const scale = unitListExactScale(this);
+      unitListScales.set(key, scale);
+      if (unitListScales.size > UNIT_LIST_SCALE_CACHE_LIMIT) {
+        unitListScales.delete(unitListScales.keys().next().value);
+      }
+      return scale;
+    };
+    function unitListExactScale(unit) {
+      let scale = UNIT_EXACT_SCALE;
+      for (const component of unit.units) {
+        const unitScale = component.unit.exact;
+        const prefixScale = prefixExactScale(component.prefix);
+        if (unitScale === void 0 || prefixScale === null || !Number.isInteger(component.power)) {
+          return null;
+        }
+        scale = multiplyExactScales(
+          scale,
+          powerExactScale(multiplyExactScales(unitScale, prefixScale), component.power)
+        );
+      }
+      return scale;
+    }
+    Unit2.exactScale = function(valuelessUnit) {
+      return Unit2.parse(valuelessUnit).exactScale();
+    };
     Unit2.prototype._normalize = function(value) {
       if (value === null || value === void 0 || this.units.length === 0) {
         return value ?? null;
       }
+      const scale = this.exactScale();
+      if (scale !== null) {
+        const exact = applyExactScale(value, scale, false);
+        if (exact !== void 0) return exact;
+      }
       let res = value;
       const convert = Unit2._getNumberConverter(typeOf(value));
       for (let i = 0; i < this.units.length; i++) {
@@ -2504,6 +3475,18 @@ var createUnitClass = /* @__PURE__ */ factory(
       if (value === null || value === void 0 || this.units.length === 0) {
         return value ?? null;
       }
+      const scale = this.exactScale();
+      if (scale !== null) {
+        if (this._exactSI !== void 0 && this._exactSI !== null) {
+          const exactSiNumber = roundExactScale(this._exactSI);
+          if (typeof value === "number" && value === exactSiNumber) {
+            return roundExactScale(divideExactScales(this._exactSI, scale));
+          }
+          this._exactSI = void 0;
+        }
+        const exact = applyExactScale(value, scale, true);
+        if (exact !== void 0) return exact;
+      }
       let res = value;
       const convert = Unit2._getNumberConverter(typeOf(value));
       for (let i = 0; i < this.units.length; i++) {
@@ -2583,8 +3566,10 @@ var createUnitClass = /* @__PURE__ */ factory(
         const valThis = this.value === null ? this._normalize(one(other.value)) : this.value;
         const valOther = other.value === null ? other._normalize(one(this.value)) : other.value;
         res.value = multiplyScalar2(valThis, valOther);
+        res._exactSI = void 0;
       } else {
         res.value = null;
+        res._exactSI = void 0;
       }
       if (isUnit(_other)) {
         res.skipAutomaticSimplification = false;
@@ -2614,8 +3599,10 @@ var createUnitClass = /* @__PURE__ */ factory(
         const valThis = this.value === null ? this._normalize(one(other.value)) : this.value;
         const valOther = other.value === null ? other._normalize(one(this.value)) : other.value;
         res.value = divideScalar2(valThis, valOther);
+        res._exactSI = void 0;
       } else {
         res.value = null;
+        res._exactSI = void 0;
       }
       if (isUnit(_other)) {
         res.skipAutomaticSimplification = false;
@@ -2635,8 +3622,10 @@ var createUnitClass = /* @__PURE__ */ factory(
       }
       if (res.value !== null) {
         res.value = pow2(res.value, p);
+        res._exactSI = void 0;
       } else {
         res.value = null;
+        res._exactSI = void 0;
       }
       res.skipAutomaticSimplification = false;
       return getNumericIfUnitless(res);
@@ -2726,9 +3715,10 @@ var createUnitClass = /* @__PURE__ */ factory(
           ret.value = abs2(ret.value);
         } else {
           const convert = ret._numberConverter();
-          const unitValue = convert(ret.units[0].unit.value);
-          const nominalOffset = convert(ret.units[0].unit.offset);
-          const unitOffset = multiplyScalar2(unitValue, nominalOffset);
+          const def = ret.units[0].unit;
+          const exactOffset = def.exact === void 0 ? void 0 : multiplyExactScales(def.exact, def.exactOffset ?? UNIT_ZERO_SCALE);
+          const valueType = typeOf(ret.value);
+          const unitOffset = exactOffset === void 0 ? multiplyScalar2(convert(def.value), convert(def.offset)) : valueType === "number" ? roundExactScale(exactOffset) : exactAs(exactOffset, valueType) ?? multiplyScalar2(convert(def.value), convert(def.offset));
           ret.value = subtractScalar3(abs2(addScalar2(ret.value, unitOffset)), unitOffset);
         }
       }
@@ -2760,7 +3750,28 @@ var createUnitClass = /* @__PURE__ */ factory(
       }
       if (this.value === null || this._isDerived() || this.units.length === 0 || other.units.length === 0 || this.units[0].unit.offset === other.units[0].unit.offset) {
         other.value = clone(value);
+        other._exactSI = liveExactSI(this);
       } else {
+        const shift = exactOffsetShift(this.units[0].unit, other.units[0].unit);
+        const exactSI = liveExactSI(this);
+        if (shift !== null && exactSI) {
+          const sum = addExactScales(exactSI, shift);
+          if (sum !== null) {
+            other._exactSI = sum;
+            other.value = roundExactScale(sum);
+            other.fixPrefix = true;
+            other.skipAutomaticSimplification = true;
+            return other;
+          }
+        }
+        const shifted = shift === null ? void 0 : addExactShift(this, value, shift);
+        if (shifted !== void 0) {
+          other.value = shifted;
+          other._exactSI = void 0;
+          other.fixPrefix = true;
+          other.skipAutomaticSimplification = true;
+          return other;
+        }
         const convert = Unit2._getNumberConverter(typeOf(value));
         const thisUnitValue = this.units[0].unit.value;
         const thisNominalOffset = this.units[0].unit.offset;
@@ -3092,183 +4103,30 @@ var createUnitClass = /* @__PURE__ */ factory(
       ret.push(x);
       return ret;
     };
-    const PREFIXES = {
-      NONE: {
-        "": { name: "", value: 1, scientific: true }
-      },
-      SHORT: {
-        "": { name: "", value: 1, scientific: true },
-        da: { name: "da", value: 10, scientific: false },
-        h: { name: "h", value: 100, scientific: false },
-        k: { name: "k", value: 1e3, scientific: true },
-        M: { name: "M", value: 1e6, scientific: true },
-        G: { name: "G", value: 1e9, scientific: true },
-        T: { name: "T", value: 1e12, scientific: true },
-        P: { name: "P", value: 1e15, scientific: true },
-        E: { name: "E", value: 1e18, scientific: true },
-        Z: { name: "Z", value: 1e21, scientific: true },
-        Y: { name: "Y", value: 1e24, scientific: true },
-        R: { name: "R", value: 1e27, scientific: true },
-        Q: { name: "Q", value: 1e30, scientific: true },
-        d: { name: "d", value: 0.1, scientific: false },
-        c: { name: "c", value: 0.01, scientific: false },
-        m: { name: "m", value: 1e-3, scientific: true },
-        u: { name: "u", value: 1e-6, scientific: true },
-        n: { name: "n", value: 1e-9, scientific: true },
-        p: { name: "p", value: 1e-12, scientific: true },
-        f: { name: "f", value: 1e-15, scientific: true },
-        a: { name: "a", value: 1e-18, scientific: true },
-        z: { name: "z", value: 1e-21, scientific: true },
-        y: { name: "y", value: 1e-24, scientific: true },
-        r: { name: "r", value: 1e-27, scientific: true },
-        q: { name: "q", value: 1e-30, scientific: true }
-      },
-      LONG: {
-        "": { name: "", value: 1, scientific: true },
-        deca: { name: "deca", value: 10, scientific: false },
-        hecto: { name: "hecto", value: 100, scientific: false },
-        kilo: { name: "kilo", value: 1e3, scientific: true },
-        mega: { name: "mega", value: 1e6, scientific: true },
-        giga: { name: "giga", value: 1e9, scientific: true },
-        tera: { name: "tera", value: 1e12, scientific: true },
-        peta: { name: "peta", value: 1e15, scientific: true },
-        exa: { name: "exa", value: 1e18, scientific: true },
-        zetta: { name: "zetta", value: 1e21, scientific: true },
-        yotta: { name: "yotta", value: 1e24, scientific: true },
-        ronna: { name: "ronna", value: 1e27, scientific: true },
-        quetta: { name: "quetta", value: 1e30, scientific: true },
-        deci: { name: "deci", value: 0.1, scientific: false },
-        centi: { name: "centi", value: 0.01, scientific: false },
-        milli: { name: "milli", value: 1e-3, scientific: true },
-        micro: { name: "micro", value: 1e-6, scientific: true },
-        nano: { name: "nano", value: 1e-9, scientific: true },
-        pico: { name: "pico", value: 1e-12, scientific: true },
-        femto: { name: "femto", value: 1e-15, scientific: true },
-        atto: { name: "atto", value: 1e-18, scientific: true },
-        zepto: { name: "zepto", value: 1e-21, scientific: true },
-        yocto: { name: "yocto", value: 1e-24, scientific: true },
-        ronto: { name: "ronto", value: 1e-27, scientific: true },
-        quecto: { name: "quecto", value: 1e-30, scientific: true }
-      },
-      SQUARED: {
-        "": { name: "", value: 1, scientific: true },
-        da: { name: "da", value: 100, scientific: false },
-        h: { name: "h", value: 1e4, scientific: false },
-        k: { name: "k", value: 1e6, scientific: true },
-        M: { name: "M", value: 1e12, scientific: true },
-        G: { name: "G", value: 1e18, scientific: true },
-        T: { name: "T", value: 1e24, scientific: true },
-        P: { name: "P", value: 1e30, scientific: true },
-        E: { name: "E", value: 1e36, scientific: true },
-        Z: { name: "Z", value: 1e42, scientific: true },
-        Y: { name: "Y", value: 1e48, scientific: true },
-        R: { name: "R", value: 1e54, scientific: true },
-        Q: { name: "Q", value: 1e60, scientific: true },
-        d: { name: "d", value: 0.01, scientific: false },
-        c: { name: "c", value: 1e-4, scientific: false },
-        m: { name: "m", value: 1e-6, scientific: true },
-        u: { name: "u", value: 1e-12, scientific: true },
-        n: { name: "n", value: 1e-18, scientific: true },
-        p: { name: "p", value: 1e-24, scientific: true },
-        f: { name: "f", value: 1e-30, scientific: true },
-        a: { name: "a", value: 1e-36, scientific: true },
-        z: { name: "z", value: 1e-42, scientific: true },
-        y: { name: "y", value: 1e-48, scientific: true },
-        r: { name: "r", value: 1e-54, scientific: true },
-        q: { name: "q", value: 1e-60, scientific: true }
-      },
-      CUBIC: {
-        "": { name: "", value: 1, scientific: true },
-        da: { name: "da", value: 1e3, scientific: false },
-        h: { name: "h", value: 1e6, scientific: false },
-        k: { name: "k", value: 1e9, scientific: true },
-        M: { name: "M", value: 1e18, scientific: true },
-        G: { name: "G", value: 1e27, scientific: true },
-        T: { name: "T", value: 1e36, scientific: true },
-        P: { name: "P", value: 1e45, scientific: true },
-        E: { name: "E", value: 1e54, scientific: true },
-        Z: { name: "Z", value: 1e63, scientific: true },
-        Y: { name: "Y", value: 1e72, scientific: true },
-        R: { name: "R", value: 1e81, scientific: true },
-        Q: { name: "Q", value: 1e90, scientific: true },
-        d: { name: "d", value: 1e-3, scientific: false },
-        c: { name: "c", value: 1e-6, scientific: false },
-        m: { name: "m", value: 1e-9, scientific: true },
-        u: { name: "u", value: 1e-18, scientific: true },
-        n: { name: "n", value: 1e-27, scientific: true },
-        p: { name: "p", value: 1e-36, scientific: true },
-        f: { name: "f", value: 1e-45, scientific: true },
-        a: { name: "a", value: 1e-54, scientific: true },
-        z: { name: "z", value: 1e-63, scientific: true },
-        y: { name: "y", value: 1e-72, scientific: true },
-        r: { name: "r", value: 1e-81, scientific: true },
-        q: { name: "q", value: 1e-90, scientific: true }
-      },
-      BINARY_SHORT_SI: {
-        "": { name: "", value: 1, scientific: true },
-        k: { name: "k", value: 1e3, scientific: true },
-        M: { name: "M", value: 1e6, scientific: true },
-        G: { name: "G", value: 1e9, scientific: true },
-        T: { name: "T", value: 1e12, scientific: true },
-        P: { name: "P", value: 1e15, scientific: true },
-        E: { name: "E", value: 1e18, scientific: true },
-        Z: { name: "Z", value: 1e21, scientific: true },
-        Y: { name: "Y", value: 1e24, scientific: true }
-      },
-      BINARY_SHORT_IEC: {
-        "": { name: "", value: 1, scientific: true },
-        Ki: { name: "Ki", value: 1024, scientific: true },
-        Mi: { name: "Mi", value: Math.pow(1024, 2), scientific: true },
-        Gi: { name: "Gi", value: Math.pow(1024, 3), scientific: true },
-        Ti: { name: "Ti", value: Math.pow(1024, 4), scientific: true },
-        Pi: { name: "Pi", value: Math.pow(1024, 5), scientific: true },
-        Ei: { name: "Ei", value: Math.pow(1024, 6), scientific: true },
-        Zi: { name: "Zi", value: Math.pow(1024, 7), scientific: true },
-        Yi: { name: "Yi", value: Math.pow(1024, 8), scientific: true }
-      },
-      BINARY_LONG_SI: {
-        "": { name: "", value: 1, scientific: true },
-        kilo: { name: "kilo", value: 1e3, scientific: true },
-        mega: { name: "mega", value: 1e6, scientific: true },
-        giga: { name: "giga", value: 1e9, scientific: true },
-        tera: { name: "tera", value: 1e12, scientific: true },
-        peta: { name: "peta", value: 1e15, scientific: true },
-        exa: { name: "exa", value: 1e18, scientific: true },
-        zetta: { name: "zetta", value: 1e21, scientific: true },
-        yotta: { name: "yotta", value: 1e24, scientific: true }
-      },
-      BINARY_LONG_IEC: {
-        "": { name: "", value: 1, scientific: true },
-        kibi: { name: "kibi", value: 1024, scientific: true },
-        mebi: { name: "mebi", value: Math.pow(1024, 2), scientific: true },
-        gibi: { name: "gibi", value: Math.pow(1024, 3), scientific: true },
-        tebi: { name: "tebi", value: Math.pow(1024, 4), scientific: true },
-        pebi: { name: "pebi", value: Math.pow(1024, 5), scientific: true },
-        exi: { name: "exi", value: Math.pow(1024, 6), scientific: true },
-        zebi: { name: "zebi", value: Math.pow(1024, 7), scientific: true },
-        yobi: { name: "yobi", value: Math.pow(1024, 8), scientific: true }
-      },
-      BTU: {
-        "": { name: "", value: 1, scientific: true },
-        MM: { name: "MM", value: 1e6, scientific: true }
+    const PREFIXES = {};
+    const prefixTable = (set2, keep = () => true) => {
+      const table = {};
+      for (const name2 of Object.keys(set2)) {
+        const prefix = set2[name2];
+        if (name2 !== "" && !keep(prefix, name2)) continue;
+        const exact = unitPrefixExactScale(prefix);
+        const def = {
+          name: name2,
+          value: roundExactScale(exact),
+          scientific: prefix.scientific
+        };
+        prefixScales.set(def, exact);
+        table[name2] = def;
       }
+      return table;
     };
-    PREFIXES.SHORTLONG = Object.assign({}, PREFIXES.SHORT, PREFIXES.LONG);
-    PREFIXES.BINARY_SHORT = Object.assign({}, PREFIXES.BINARY_SHORT_SI, PREFIXES.BINARY_SHORT_IEC);
-    PREFIXES.BINARY_LONG = Object.assign({}, PREFIXES.BINARY_LONG_SI, PREFIXES.BINARY_LONG_IEC);
-    PREFIXES.SHORT_UP_ONLY = {
-      "": { name: "", value: 1, scientific: true },
-      k: { name: "k", value: 1e3, scientific: true },
-      M: { name: "M", value: 1e6, scientific: true },
-      G: { name: "G", value: 1e9, scientific: true },
-      T: { name: "T", value: 1e12, scientific: true },
-      P: { name: "P", value: 1e15, scientific: true },
-      E: { name: "E", value: 1e18, scientific: true },
-      Z: { name: "Z", value: 1e21, scientific: true },
-      Y: { name: "Y", value: 1e24, scientific: true },
-      R: { name: "R", value: 1e27, scientific: true },
-      Q: { name: "Q", value: 1e30, scientific: true }
-    };
+    for (const key of Object.keys(UNIT_PREFIX_SETS)) {
+      PREFIXES[key] = prefixTable(UNIT_PREFIX_SETS[key]);
+    }
+    PREFIXES.BINARY_SHORT_SI = prefixTable(UNIT_PREFIX_SETS.BINARY_SHORT, (p) => p.radix === 10);
+    PREFIXES.BINARY_SHORT_IEC = prefixTable(UNIT_PREFIX_SETS.BINARY_SHORT, (p) => p.radix === 1024);
+    PREFIXES.BINARY_LONG_SI = prefixTable(UNIT_PREFIX_SETS.BINARY_LONG, (p) => p.radix === 10);
+    PREFIXES.BINARY_LONG_IEC = prefixTable(UNIT_PREFIX_SETS.BINARY_LONG, (p) => p.radix === 1024);
     const BASE_DIMENSIONS = [
       "MASS",
       "LENGTH",
@@ -3374,1410 +4232,35 @@ var createUnitClass = /* @__PURE__ */ factory(
       offset: 0,
       dimensions: BASE_DIMENSIONS.map((_x) => 0)
     };
-    const UNITS = {
-      // length
-      meter: {
-        name: "meter",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.LONG,
-        value: 1,
-        offset: 0
-      },
-      inch: {
-        name: "inch",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.NONE,
-        value: 0.0254,
-        offset: 0
-      },
-      foot: {
-        name: "foot",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.NONE,
-        value: 0.3048,
-        offset: 0
-      },
-      yard: {
-        name: "yard",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.NONE,
-        value: 0.9144,
-        offset: 0
-      },
-      mile: {
-        name: "mile",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.NONE,
-        value: 1609.344,
-        offset: 0
-      },
-      link: {
-        name: "link",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.NONE,
-        value: 0.201168,
-        offset: 0
-      },
-      rod: {
-        name: "rod",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.NONE,
-        value: 5.0292,
-        offset: 0
-      },
-      chain: {
-        name: "chain",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.NONE,
-        value: 20.1168,
-        offset: 0
-      },
-      angstrom: {
-        name: "angstrom",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.NONE,
-        value: 1e-10,
-        offset: 0
-      },
-      // Astronomical / nautical / typography length units (ported from
-      // upstream mathjs ece1aab0f + 5f360326b — B-5). `ly` and `pc` are
-      // first-class UNITS with SHORT_UP_ONLY prefixes so kpc/Mpc/Mly/Gly
-      // resolve through the prefix system while sub-multiples throw.
-      astronomicalUnit: {
-        name: "astronomicalUnit",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.NONE,
-        value: 149597870700,
-        // IAU 2012 exact definition
-        offset: 0
-      },
-      lightyear: {
-        name: "lightyear",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.NONE,
-        value: 9460730472580800,
-        // Julian year × c (exact)
-        offset: 0
-      },
-      ly: {
-        name: "ly",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.SHORT_UP_ONLY,
-        value: 9460730472580800,
-        offset: 0
-      },
-      parsec: {
-        name: "parsec",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.LONG,
-        // kiloparsec, megaparsec, gigaparsec
-        value: 30856775814913700,
-        // IAU 2015 exact definition
-        offset: 0
-      },
-      pc: {
-        name: "pc",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.SHORT_UP_ONLY,
-        value: 30856775814913700,
-        offset: 0
-      },
-      nauticalMile: {
-        name: "nauticalMile",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.NONE,
-        value: 1852,
-        // exact
-        offset: 0
-      },
-      fathom: {
-        name: "fathom",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.NONE,
-        value: 1.8288,
-        // 6 ft exactly
-        offset: 0
-      },
-      furlong: {
-        name: "furlong",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.NONE,
-        value: 201.168,
-        // 1/8 mile exactly
-        offset: 0
-      },
-      point: {
-        name: "point",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.NONE,
-        value: 0.0254 / 72,
-        // 1/72 inch (PostScript), exact
-        offset: 0
-      },
-      pica: {
-        name: "pica",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.NONE,
-        value: 0.0254 / 6,
-        // 1/6 inch (12 points), exact
-        offset: 0
-      },
-      m: {
-        name: "m",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.SHORT,
-        value: 1,
-        offset: 0
-      },
-      in: {
-        name: "in",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.NONE,
-        value: 0.0254,
-        offset: 0
-      },
-      ft: {
-        name: "ft",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.NONE,
-        value: 0.3048,
-        offset: 0
-      },
-      yd: {
-        name: "yd",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.NONE,
-        value: 0.9144,
-        offset: 0
-      },
-      mi: {
-        name: "mi",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.NONE,
-        value: 1609.344,
-        offset: 0
-      },
-      li: {
-        name: "li",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.NONE,
-        value: 0.201168,
-        offset: 0
-      },
-      rd: {
-        name: "rd",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.NONE,
-        value: 5.02921,
-        offset: 0
-      },
-      ch: {
-        name: "ch",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.NONE,
-        value: 20.1168,
-        offset: 0
-      },
-      mil: {
-        name: "mil",
-        base: BASE_UNITS.LENGTH,
-        prefixes: PREFIXES.NONE,
-        value: 254e-7,
-        offset: 0
-      },
-      // 1/1000 inch
-      // Surface
-      m2: {
-        name: "m2",
-        base: BASE_UNITS.SURFACE,
-        prefixes: PREFIXES.SQUARED,
-        value: 1,
-        offset: 0
-      },
-      sqin: {
-        name: "sqin",
-        base: BASE_UNITS.SURFACE,
-        prefixes: PREFIXES.NONE,
-        value: 64516e-8,
-        offset: 0
-      },
-      // 645.16 mm2
-      sqft: {
-        name: "sqft",
-        base: BASE_UNITS.SURFACE,
-        prefixes: PREFIXES.NONE,
-        value: 0.09290304,
-        offset: 0
-      },
-      // 0.09290304 m2
-      sqyd: {
-        name: "sqyd",
-        base: BASE_UNITS.SURFACE,
-        prefixes: PREFIXES.NONE,
-        value: 0.83612736,
-        offset: 0
-      },
-      // 0.83612736 m2
-      sqmi: {
-        name: "sqmi",
-        base: BASE_UNITS.SURFACE,
-        prefixes: PREFIXES.NONE,
-        value: 2589988110336e-6,
-        offset: 0
-      },
-      // 2.589988110336 km2
-      sqrd: {
-        name: "sqrd",
-        base: BASE_UNITS.SURFACE,
-        prefixes: PREFIXES.NONE,
-        value: 25.29295,
-        offset: 0
-      },
-      // 25.29295 m2
-      sqch: {
-        name: "sqch",
-        base: BASE_UNITS.SURFACE,
-        prefixes: PREFIXES.NONE,
-        value: 404.6873,
-        offset: 0
-      },
-      // 404.6873 m2
-      sqmil: {
-        name: "sqmil",
-        base: BASE_UNITS.SURFACE,
-        prefixes: PREFIXES.NONE,
-        value: 64516e-14,
-        offset: 0
-      },
-      // 6.4516 * 10^-10 m2
-      acre: {
-        name: "acre",
-        base: BASE_UNITS.SURFACE,
-        prefixes: PREFIXES.NONE,
-        value: 4046.86,
-        offset: 0
-      },
-      // 4046.86 m2
-      hectare: {
-        name: "hectare",
-        base: BASE_UNITS.SURFACE,
-        prefixes: PREFIXES.NONE,
-        value: 1e4,
-        offset: 0
-      },
-      // 10000 m2
-      // Volume
-      m3: {
-        name: "m3",
-        base: BASE_UNITS.VOLUME,
-        prefixes: PREFIXES.CUBIC,
-        value: 1,
-        offset: 0
-      },
-      L: {
-        name: "L",
-        base: BASE_UNITS.VOLUME,
-        prefixes: PREFIXES.SHORT,
-        value: 1e-3,
-        offset: 0
-      },
-      // litre
-      l: {
-        name: "l",
-        base: BASE_UNITS.VOLUME,
-        prefixes: PREFIXES.SHORT,
-        value: 1e-3,
-        offset: 0
-      },
-      // litre
-      litre: {
-        name: "litre",
-        base: BASE_UNITS.VOLUME,
-        prefixes: PREFIXES.LONG,
-        value: 1e-3,
-        offset: 0
-      },
-      cuin: {
-        name: "cuin",
-        base: BASE_UNITS.VOLUME,
-        prefixes: PREFIXES.NONE,
-        value: 16387064e-12,
-        offset: 0
-      },
-      // 1.6387064e-5 m3
-      cuft: {
-        name: "cuft",
-        base: BASE_UNITS.VOLUME,
-        prefixes: PREFIXES.NONE,
-        value: 0.028316846592,
-        offset: 0
-      },
-      // 28.316 846 592 L
-      cuyd: {
-        name: "cuyd",
-        base: BASE_UNITS.VOLUME,
-        prefixes: PREFIXES.NONE,
-        value: 0.764554857984,
-        offset: 0
-      },
-      // 764.554 857 984 L
-      teaspoon: {
-        name: "teaspoon",
-        base: BASE_UNITS.VOLUME,
-        prefixes: PREFIXES.NONE,
-        value: 5e-6,
-        offset: 0
-      },
-      // 5 mL
-      tablespoon: {
-        name: "tablespoon",
-        base: BASE_UNITS.VOLUME,
-        prefixes: PREFIXES.NONE,
-        value: 15e-6,
-        offset: 0
-      },
-      // 15 mL
-      // {name: 'cup', base: BASE_UNITS.VOLUME, prefixes: PREFIXES.NONE, value: 0.000240, offset: 0}, // 240 mL  // not possible, we have already another cup
-      drop: {
-        name: "drop",
-        base: BASE_UNITS.VOLUME,
-        prefixes: PREFIXES.NONE,
-        value: 5e-8,
-        offset: 0
-      },
-      // 0.05 mL = 5e-8 m3
-      gtt: {
-        name: "gtt",
-        base: BASE_UNITS.VOLUME,
-        prefixes: PREFIXES.NONE,
-        value: 5e-8,
-        offset: 0
-      },
-      // 0.05 mL = 5e-8 m3
-      // Liquid volume
-      minim: {
-        name: "minim",
-        base: BASE_UNITS.VOLUME,
-        prefixes: PREFIXES.NONE,
-        value: 61611519921875e-21,
-        offset: 0
-      },
-      // 1/61440 gallons
-      fluiddram: {
-        name: "fluiddram",
-        base: BASE_UNITS.VOLUME,
-        prefixes: PREFIXES.NONE,
-        value: 36966911953125e-19,
-        offset: 0
-      },
-      // 1/1024 gallons
-      fluidounce: {
-        name: "fluidounce",
-        base: BASE_UNITS.VOLUME,
-        prefixes: PREFIXES.NONE,
-        value: 295735295625e-16,
-        offset: 0
-      },
-      // 1/128 gallons
-      gill: {
-        name: "gill",
-        base: BASE_UNITS.VOLUME,
-        prefixes: PREFIXES.NONE,
-        value: 11829411825e-14,
-        offset: 0
-      },
-      // 1/32 gallons
-      cc: {
-        name: "cc",
-        base: BASE_UNITS.VOLUME,
-        prefixes: PREFIXES.NONE,
-        value: 1e-6,
-        offset: 0
-      },
-      // 1e-6 L
-      cup: {
-        name: "cup",
-        base: BASE_UNITS.VOLUME,
-        prefixes: PREFIXES.NONE,
-        value: 2365882365e-13,
-        offset: 0
-      },
-      // 1/16 gallons
-      pint: {
-        name: "pint",
-        base: BASE_UNITS.VOLUME,
-        prefixes: PREFIXES.NONE,
-        value: 473176473e-12,
-        offset: 0
-      },
-      // 1/8 gallons
-      quart: {
-        name: "quart",
-        base: BASE_UNITS.VOLUME,
-        prefixes: PREFIXES.NONE,
-        value: 946352946e-12,
-        offset: 0
-      },
-      // 1/4 gallons
-      gallon: {
-        name: "gallon",
-        base: BASE_UNITS.VOLUME,
-        prefixes: PREFIXES.NONE,
-        value: 0.003785411784,
-        offset: 0
-      },
-      // 3.785411784 L
-      beerbarrel: {
-        name: "beerbarrel",
-        base: BASE_UNITS.VOLUME,
-        prefixes: PREFIXES.NONE,
-        value: 0.117347765304,
-        offset: 0
-      },
-      // 31 gallons
-      oilbarrel: {
-        name: "oilbarrel",
-        base: BASE_UNITS.VOLUME,
-        prefixes: PREFIXES.NONE,
-        value: 0.158987294928,
-        offset: 0
-      },
-      // 42 gallons
-      hogshead: {
-        name: "hogshead",
-        base: BASE_UNITS.VOLUME,
-        prefixes: PREFIXES.NONE,
-        value: 0.238480942392,
-        offset: 0
-      },
-      // 63 gallons
-      // Mass
-      g: {
-        name: "g",
-        base: BASE_UNITS.MASS,
-        prefixes: PREFIXES.SHORT,
-        value: 1e-3,
-        offset: 0
-      },
-      gram: {
-        name: "gram",
-        base: BASE_UNITS.MASS,
-        prefixes: PREFIXES.LONG,
-        value: 1e-3,
-        offset: 0
-      },
-      ton: {
-        name: "ton",
-        base: BASE_UNITS.MASS,
-        prefixes: PREFIXES.SHORT,
-        value: 907.18474,
-        offset: 0
-      },
-      t: {
-        name: "t",
-        base: BASE_UNITS.MASS,
-        prefixes: PREFIXES.SHORT,
-        value: 1e3,
-        offset: 0
-      },
-      tonne: {
-        name: "tonne",
-        base: BASE_UNITS.MASS,
-        prefixes: PREFIXES.LONG,
-        value: 1e3,
-        offset: 0
-      },
-      grain: {
-        name: "grain",
-        base: BASE_UNITS.MASS,
-        prefixes: PREFIXES.NONE,
-        value: 6479891e-11,
-        offset: 0
-      },
-      dram: {
-        name: "dram",
-        base: BASE_UNITS.MASS,
-        prefixes: PREFIXES.NONE,
-        value: 0.0017718451953125,
-        offset: 0
-      },
-      ounce: {
-        name: "ounce",
-        base: BASE_UNITS.MASS,
-        prefixes: PREFIXES.NONE,
-        value: 0.028349523125,
-        offset: 0
-      },
-      poundmass: {
-        name: "poundmass",
-        base: BASE_UNITS.MASS,
-        prefixes: PREFIXES.NONE,
-        value: 0.45359237,
-        offset: 0
-      },
-      hundredweight: {
-        name: "hundredweight",
-        base: BASE_UNITS.MASS,
-        prefixes: PREFIXES.NONE,
-        value: 45.359237,
-        offset: 0
-      },
-      stick: {
-        name: "stick",
-        base: BASE_UNITS.MASS,
-        prefixes: PREFIXES.NONE,
-        value: 0.115,
-        offset: 0
-      },
-      stone: {
-        name: "stone",
-        base: BASE_UNITS.MASS,
-        prefixes: PREFIXES.NONE,
-        value: 6.35029318,
-        offset: 0
-      },
-      gr: {
-        name: "gr",
-        base: BASE_UNITS.MASS,
-        prefixes: PREFIXES.NONE,
-        value: 6479891e-11,
-        offset: 0
-      },
-      dr: {
-        name: "dr",
-        base: BASE_UNITS.MASS,
-        prefixes: PREFIXES.NONE,
-        value: 0.0017718451953125,
-        offset: 0
-      },
-      oz: {
-        name: "oz",
-        base: BASE_UNITS.MASS,
-        prefixes: PREFIXES.NONE,
-        value: 0.028349523125,
-        offset: 0
-      },
-      lbm: {
-        name: "lbm",
-        base: BASE_UNITS.MASS,
-        prefixes: PREFIXES.NONE,
-        value: 0.45359237,
-        offset: 0
-      },
-      cwt: {
-        name: "cwt",
-        base: BASE_UNITS.MASS,
-        prefixes: PREFIXES.NONE,
-        value: 45.359237,
-        offset: 0
-      },
-      // Time
-      s: {
-        name: "s",
-        base: BASE_UNITS.TIME,
-        prefixes: PREFIXES.SHORT,
-        value: 1,
-        offset: 0
-      },
-      min: {
-        name: "min",
-        base: BASE_UNITS.TIME,
-        prefixes: PREFIXES.NONE,
-        value: 60,
-        offset: 0
-      },
-      h: {
-        name: "h",
-        base: BASE_UNITS.TIME,
-        prefixes: PREFIXES.NONE,
-        value: 3600,
-        offset: 0
-      },
-      second: {
-        name: "second",
-        base: BASE_UNITS.TIME,
-        prefixes: PREFIXES.LONG,
-        value: 1,
-        offset: 0
-      },
-      sec: {
-        name: "sec",
-        base: BASE_UNITS.TIME,
-        prefixes: PREFIXES.LONG,
-        value: 1,
-        offset: 0
-      },
-      minute: {
-        name: "minute",
-        base: BASE_UNITS.TIME,
-        prefixes: PREFIXES.NONE,
-        value: 60,
-        offset: 0
-      },
-      hour: {
-        name: "hour",
-        base: BASE_UNITS.TIME,
-        prefixes: PREFIXES.NONE,
-        value: 3600,
-        offset: 0
-      },
-      day: {
-        name: "day",
-        base: BASE_UNITS.TIME,
-        prefixes: PREFIXES.NONE,
-        value: 86400,
-        offset: 0
-      },
-      week: {
-        name: "week",
-        base: BASE_UNITS.TIME,
-        prefixes: PREFIXES.NONE,
-        value: 7 * 86400,
-        offset: 0
-      },
-      month: {
-        name: "month",
-        base: BASE_UNITS.TIME,
-        prefixes: PREFIXES.NONE,
-        value: 2629800,
-        // 1/12th of Julian year
-        offset: 0
-      },
-      year: {
-        name: "year",
-        base: BASE_UNITS.TIME,
-        prefixes: PREFIXES.NONE,
-        value: 31557600,
-        // Julian year
-        offset: 0
-      },
-      decade: {
-        name: "decade",
-        base: BASE_UNITS.TIME,
-        prefixes: PREFIXES.NONE,
-        value: 315576e3,
-        // Julian decade
-        offset: 0
-      },
-      century: {
-        name: "century",
-        base: BASE_UNITS.TIME,
-        prefixes: PREFIXES.NONE,
-        value: 315576e4,
-        // Julian century
-        offset: 0
-      },
-      millennium: {
-        name: "millennium",
-        base: BASE_UNITS.TIME,
-        prefixes: PREFIXES.NONE,
-        value: 315576e5,
-        // Julian millennium
-        offset: 0
-      },
-      // Frequency
-      hertz: {
-        name: "Hertz",
-        base: BASE_UNITS.FREQUENCY,
-        prefixes: PREFIXES.LONG,
-        value: 1,
-        offset: 0,
-        reciprocal: true
-      },
-      Hz: {
-        name: "Hz",
-        base: BASE_UNITS.FREQUENCY,
-        prefixes: PREFIXES.SHORT,
-        value: 1,
-        offset: 0,
-        reciprocal: true
-      },
-      // Angle
-      rad: {
-        name: "rad",
-        base: BASE_UNITS.ANGLE,
-        prefixes: PREFIXES.SHORT,
-        value: 1,
-        offset: 0
-      },
-      radian: {
-        name: "radian",
-        base: BASE_UNITS.ANGLE,
-        prefixes: PREFIXES.LONG,
-        value: 1,
-        offset: 0
-      },
-      // deg = rad / (2*pi) * 360 = rad / 0.017453292519943295769236907684888
-      deg: {
-        name: "deg",
-        base: BASE_UNITS.ANGLE,
-        prefixes: PREFIXES.SHORT,
-        value: null,
-        // will be filled in by calculateAngleValues()
-        offset: 0
-      },
-      degree: {
-        name: "degree",
-        base: BASE_UNITS.ANGLE,
-        prefixes: PREFIXES.LONG,
-        value: null,
-        // will be filled in by calculateAngleValues()
-        offset: 0
-      },
-      // grad = rad / (2*pi) * 400  = rad / 0.015707963267948966192313216916399
-      grad: {
-        name: "grad",
-        base: BASE_UNITS.ANGLE,
-        prefixes: PREFIXES.SHORT,
-        value: null,
-        // will be filled in by calculateAngleValues()
-        offset: 0
-      },
-      gradian: {
-        name: "gradian",
-        base: BASE_UNITS.ANGLE,
-        prefixes: PREFIXES.LONG,
-        value: null,
-        // will be filled in by calculateAngleValues()
-        offset: 0
-      },
-      // cycle = rad / (2*pi) = rad / 6.2831853071795864769252867665793
-      cycle: {
-        name: "cycle",
-        base: BASE_UNITS.ANGLE,
-        prefixes: PREFIXES.NONE,
-        value: null,
-        // will be filled in by calculateAngleValues()
-        offset: 0
-      },
-      // arcsec = rad / (3600 * (360 / 2 * pi)) = rad / 0.0000048481368110953599358991410235795
-      arcsec: {
-        name: "arcsec",
-        base: BASE_UNITS.ANGLE,
-        prefixes: PREFIXES.NONE,
-        value: null,
-        // will be filled in by calculateAngleValues()
-        offset: 0
-      },
-      // arcmin = rad / (60 * (360 / 2 * pi)) = rad / 0.00029088820866572159615394846141477
-      arcmin: {
-        name: "arcmin",
-        base: BASE_UNITS.ANGLE,
-        prefixes: PREFIXES.NONE,
-        value: null,
-        // will be filled in by calculateAngleValues()
-        offset: 0
-      },
-      // Electric current
-      A: {
-        name: "A",
-        base: BASE_UNITS.CURRENT,
-        prefixes: PREFIXES.SHORT,
-        value: 1,
-        offset: 0
-      },
-      ampere: {
-        name: "ampere",
-        base: BASE_UNITS.CURRENT,
-        prefixes: PREFIXES.LONG,
-        value: 1,
-        offset: 0
-      },
-      // Temperature
-      // K(C) = °C + 273.15
-      // K(F) = (°F + 459.67) * (5 / 9)
-      // K(R) = °R * (5 / 9)
-      K: {
-        name: "K",
-        base: BASE_UNITS.TEMPERATURE,
-        prefixes: PREFIXES.SHORT,
-        value: 1,
-        offset: 0
-      },
-      degC: {
-        name: "degC",
-        base: BASE_UNITS.TEMPERATURE,
-        prefixes: PREFIXES.SHORT,
-        value: 1,
-        offset: 273.15
-      },
-      degF: {
-        name: "degF",
-        base: BASE_UNITS.TEMPERATURE,
-        prefixes: PREFIXES.SHORT,
-        value: new Fraction2(5, 9),
-        offset: 459.67
-      },
-      degR: {
-        name: "degR",
-        base: BASE_UNITS.TEMPERATURE,
-        prefixes: PREFIXES.SHORT,
-        value: new Fraction2(5, 9),
-        offset: 0
-      },
-      kelvin: {
-        name: "kelvin",
-        base: BASE_UNITS.TEMPERATURE,
-        prefixes: PREFIXES.LONG,
-        value: 1,
-        offset: 0
-      },
-      celsius: {
-        name: "celsius",
-        base: BASE_UNITS.TEMPERATURE,
-        prefixes: PREFIXES.LONG,
-        value: 1,
-        offset: 273.15
-      },
-      fahrenheit: {
-        name: "fahrenheit",
-        base: BASE_UNITS.TEMPERATURE,
-        prefixes: PREFIXES.LONG,
-        value: new Fraction2(5, 9),
-        offset: 459.67
-      },
-      rankine: {
-        name: "rankine",
-        base: BASE_UNITS.TEMPERATURE,
-        prefixes: PREFIXES.LONG,
-        value: new Fraction2(5, 9),
-        offset: 0
-      },
-      // amount of substance
-      mol: {
-        name: "mol",
-        base: BASE_UNITS.AMOUNT_OF_SUBSTANCE,
-        prefixes: PREFIXES.SHORT,
-        value: 1,
-        offset: 0
-      },
-      mole: {
-        name: "mole",
-        base: BASE_UNITS.AMOUNT_OF_SUBSTANCE,
-        prefixes: PREFIXES.LONG,
-        value: 1,
-        offset: 0
-      },
-      // luminous intensity
-      cd: {
-        name: "cd",
-        base: BASE_UNITS.LUMINOUS_INTENSITY,
-        prefixes: PREFIXES.SHORT,
-        value: 1,
-        offset: 0
-      },
-      candela: {
-        name: "candela",
-        base: BASE_UNITS.LUMINOUS_INTENSITY,
-        prefixes: PREFIXES.LONG,
-        value: 1,
-        offset: 0
-      },
-      // Solid angle
-      sr: {
-        name: "sr",
-        base: BASE_UNITS.SOLID_ANGLE,
-        prefixes: PREFIXES.NONE,
-        value: 1,
-        offset: 0
-      },
-      steradian: {
-        name: "steradian",
-        base: BASE_UNITS.SOLID_ANGLE,
-        prefixes: PREFIXES.LONG,
-        value: 1,
-        offset: 0
-      },
-      // Force
-      N: {
-        name: "N",
-        base: BASE_UNITS.FORCE,
-        prefixes: PREFIXES.SHORT,
-        value: 1,
-        offset: 0
-      },
-      newton: {
-        name: "newton",
-        base: BASE_UNITS.FORCE,
-        prefixes: PREFIXES.LONG,
-        value: 1,
-        offset: 0
-      },
-      dyn: {
-        name: "dyn",
-        base: BASE_UNITS.FORCE,
-        prefixes: PREFIXES.SHORT,
-        value: 1e-5,
-        offset: 0
-      },
-      dyne: {
-        name: "dyne",
-        base: BASE_UNITS.FORCE,
-        prefixes: PREFIXES.LONG,
-        value: 1e-5,
-        offset: 0
-      },
-      lbf: {
-        name: "lbf",
-        base: BASE_UNITS.FORCE,
-        prefixes: PREFIXES.NONE,
-        value: 4.4482216152605,
-        offset: 0
-      },
-      poundforce: {
-        name: "poundforce",
-        base: BASE_UNITS.FORCE,
-        prefixes: PREFIXES.NONE,
-        value: 4.4482216152605,
-        offset: 0
-      },
-      kip: {
-        name: "kip",
-        base: BASE_UNITS.FORCE,
-        prefixes: PREFIXES.LONG,
-        value: 4448.2216,
-        offset: 0
-      },
-      kilogramforce: {
-        name: "kilogramforce",
-        base: BASE_UNITS.FORCE,
-        prefixes: PREFIXES.NONE,
-        value: 9.80665,
-        offset: 0
-      },
-      // Energy
-      J: {
-        name: "J",
-        base: BASE_UNITS.ENERGY,
-        prefixes: PREFIXES.SHORT,
-        value: 1,
-        offset: 0
-      },
-      joule: {
-        name: "joule",
-        base: BASE_UNITS.ENERGY,
-        prefixes: PREFIXES.LONG,
-        value: 1,
-        offset: 0
-      },
-      erg: {
-        name: "erg",
-        base: BASE_UNITS.ENERGY,
-        prefixes: PREFIXES.SHORTLONG,
-        // Both kiloerg and kerg are acceptable
-        value: 1e-7,
-        offset: 0
-      },
-      Wh: {
-        name: "Wh",
-        base: BASE_UNITS.ENERGY,
-        prefixes: PREFIXES.SHORT,
-        value: 3600,
-        offset: 0
-      },
-      BTU: {
-        name: "BTU",
-        base: BASE_UNITS.ENERGY,
-        prefixes: PREFIXES.BTU,
-        value: 1055.05585262,
-        offset: 0
-      },
-      eV: {
-        name: "eV",
-        base: BASE_UNITS.ENERGY,
-        prefixes: PREFIXES.SHORT,
-        value: 1602176634e-28,
-        offset: 0
-      },
-      electronvolt: {
-        name: "electronvolt",
-        base: BASE_UNITS.ENERGY,
-        prefixes: PREFIXES.LONG,
-        value: 1602176634e-28,
-        offset: 0
-      },
-      // Power
-      W: {
-        name: "W",
-        base: BASE_UNITS.POWER,
-        prefixes: PREFIXES.SHORT,
-        value: 1,
-        offset: 0
-      },
-      watt: {
-        name: "watt",
-        base: BASE_UNITS.POWER,
-        prefixes: PREFIXES.LONG,
-        value: 1,
-        offset: 0
-      },
-      hp: {
-        name: "hp",
-        base: BASE_UNITS.POWER,
-        prefixes: PREFIXES.NONE,
-        value: 745.6998715386,
-        offset: 0
-      },
-      // Electrical power units
-      VAR: {
-        name: "VAR",
-        base: BASE_UNITS.POWER,
-        prefixes: PREFIXES.SHORT,
-        value: Complex2.I,
-        offset: 0
-      },
-      VA: {
-        name: "VA",
-        base: BASE_UNITS.POWER,
-        prefixes: PREFIXES.SHORT,
-        value: 1,
-        offset: 0
-      },
-      // Pressure
-      Pa: {
-        name: "Pa",
-        base: BASE_UNITS.PRESSURE,
-        prefixes: PREFIXES.SHORT,
-        value: 1,
-        offset: 0
-      },
-      psi: {
-        name: "psi",
-        base: BASE_UNITS.PRESSURE,
-        prefixes: PREFIXES.NONE,
-        value: 6894.75729276459,
-        offset: 0
-      },
-      atm: {
-        name: "atm",
-        base: BASE_UNITS.PRESSURE,
-        prefixes: PREFIXES.NONE,
-        value: 101325,
-        offset: 0
-      },
-      bar: {
-        name: "bar",
-        base: BASE_UNITS.PRESSURE,
-        prefixes: PREFIXES.SHORTLONG,
-        value: 1e5,
-        offset: 0
-      },
-      torr: {
-        name: "torr",
-        base: BASE_UNITS.PRESSURE,
-        prefixes: PREFIXES.NONE,
-        value: 133.322,
-        offset: 0
-      },
-      mmHg: {
-        name: "mmHg",
-        base: BASE_UNITS.PRESSURE,
-        prefixes: PREFIXES.NONE,
-        value: 133.322,
-        offset: 0
-      },
-      mmH2O: {
-        name: "mmH2O",
-        base: BASE_UNITS.PRESSURE,
-        prefixes: PREFIXES.NONE,
-        value: 9.80665,
-        offset: 0
-      },
-      cmH2O: {
-        name: "cmH2O",
-        base: BASE_UNITS.PRESSURE,
-        prefixes: PREFIXES.NONE,
-        value: 98.0665,
-        offset: 0
-      },
-      // Electric charge
-      coulomb: {
-        name: "coulomb",
-        base: BASE_UNITS.ELECTRIC_CHARGE,
-        prefixes: PREFIXES.LONG,
-        value: 1,
-        offset: 0
-      },
-      C: {
-        name: "C",
-        base: BASE_UNITS.ELECTRIC_CHARGE,
-        prefixes: PREFIXES.SHORT,
-        value: 1,
-        offset: 0
-      },
-      // Electric capacitance
-      farad: {
-        name: "farad",
-        base: BASE_UNITS.ELECTRIC_CAPACITANCE,
-        prefixes: PREFIXES.LONG,
-        value: 1,
-        offset: 0
-      },
-      F: {
-        name: "F",
-        base: BASE_UNITS.ELECTRIC_CAPACITANCE,
-        prefixes: PREFIXES.SHORT,
-        value: 1,
-        offset: 0
-      },
-      // Electric potential
-      volt: {
-        name: "volt",
-        base: BASE_UNITS.ELECTRIC_POTENTIAL,
-        prefixes: PREFIXES.LONG,
-        value: 1,
-        offset: 0
-      },
-      V: {
-        name: "V",
-        base: BASE_UNITS.ELECTRIC_POTENTIAL,
-        prefixes: PREFIXES.SHORT,
-        value: 1,
-        offset: 0
-      },
-      // Electric resistance
-      ohm: {
-        name: "ohm",
-        base: BASE_UNITS.ELECTRIC_RESISTANCE,
-        prefixes: PREFIXES.SHORTLONG,
-        // Both Mohm and megaohm are acceptable
-        value: 1,
-        offset: 0
-      },
-      /*
-       * Unicode breaks in browsers if charset is not specified
-      Ω: {
-        name: 'Ω',
-        base: BASE_UNITS.ELECTRIC_RESISTANCE,
-        prefixes: PREFIXES.SHORT,
-        value: 1,
-        offset: 0
-      },
-      */
-      // Electric inductance
-      henry: {
-        name: "henry",
-        base: BASE_UNITS.ELECTRIC_INDUCTANCE,
-        prefixes: PREFIXES.LONG,
-        value: 1,
-        offset: 0
-      },
-      H: {
-        name: "H",
-        base: BASE_UNITS.ELECTRIC_INDUCTANCE,
-        prefixes: PREFIXES.SHORT,
-        value: 1,
-        offset: 0
-      },
-      // Electric conductance
-      siemens: {
-        name: "siemens",
-        base: BASE_UNITS.ELECTRIC_CONDUCTANCE,
-        prefixes: PREFIXES.LONG,
-        value: 1,
-        offset: 0
-      },
-      S: {
-        name: "S",
-        base: BASE_UNITS.ELECTRIC_CONDUCTANCE,
-        prefixes: PREFIXES.SHORT,
-        value: 1,
-        offset: 0
-      },
-      // Magnetic flux
-      weber: {
-        name: "weber",
-        base: BASE_UNITS.MAGNETIC_FLUX,
-        prefixes: PREFIXES.LONG,
-        value: 1,
-        offset: 0
-      },
-      Wb: {
-        name: "Wb",
-        base: BASE_UNITS.MAGNETIC_FLUX,
-        prefixes: PREFIXES.SHORT,
-        value: 1,
-        offset: 0
-      },
-      // Magnetic flux density
-      tesla: {
-        name: "tesla",
-        base: BASE_UNITS.MAGNETIC_FLUX_DENSITY,
-        prefixes: PREFIXES.LONG,
-        value: 1,
-        offset: 0
-      },
-      T: {
-        name: "T",
-        base: BASE_UNITS.MAGNETIC_FLUX_DENSITY,
-        prefixes: PREFIXES.SHORT,
-        value: 1,
-        offset: 0
-      },
-      // Binary
-      b: {
-        name: "b",
-        base: BASE_UNITS.BIT,
-        prefixes: PREFIXES.BINARY_SHORT,
-        value: 1,
-        offset: 0
-      },
-      bits: {
-        name: "bits",
-        base: BASE_UNITS.BIT,
-        prefixes: PREFIXES.BINARY_LONG,
-        value: 1,
-        offset: 0
-      },
-      B: {
-        name: "B",
-        base: BASE_UNITS.BIT,
-        prefixes: PREFIXES.BINARY_SHORT,
-        value: 8,
-        offset: 0
-      },
-      bytes: {
-        name: "bytes",
-        base: BASE_UNITS.BIT,
-        prefixes: PREFIXES.BINARY_LONG,
-        value: 8,
-        offset: 0
-      }
-    };
-    const ALIASES = {
-      meters: "meter",
-      // Astronomical / nautical / typography aliases (B-5 port). Lowercase
-      // 'au' is deliberately ABSENT: it collides with the atomic unit of
-      // length (Bohr radius, ~5.29e-11 m), 21 orders of magnitude smaller.
-      AU: "astronomicalUnit",
-      astronomicalUnits: "astronomicalUnit",
-      lightyears: "lightyear",
-      parsecs: "parsec",
-      nmi: "nauticalMile",
-      nauticalMiles: "nauticalMile",
-      fathoms: "fathom",
-      furlongs: "furlong",
-      points: "point",
-      picas: "pica",
-      inches: "inch",
-      feet: "foot",
-      yards: "yard",
-      miles: "mile",
-      links: "link",
-      rods: "rod",
-      chains: "chain",
-      angstroms: "angstrom",
-      lt: "l",
-      litres: "litre",
-      liter: "litre",
-      liters: "litre",
-      teaspoons: "teaspoon",
-      tablespoons: "tablespoon",
-      minims: "minim",
-      fldr: "fluiddram",
-      fluiddrams: "fluiddram",
-      floz: "fluidounce",
-      fluidounces: "fluidounce",
-      gi: "gill",
-      gills: "gill",
-      cp: "cup",
-      cups: "cup",
-      pt: "pint",
-      pints: "pint",
-      qt: "quart",
-      quarts: "quart",
-      gal: "gallon",
-      gallons: "gallon",
-      bbl: "beerbarrel",
-      beerbarrels: "beerbarrel",
-      obl: "oilbarrel",
-      oilbarrels: "oilbarrel",
-      hogsheads: "hogshead",
-      gtts: "gtt",
-      grams: "gram",
-      tons: "ton",
-      tonnes: "tonne",
-      grains: "grain",
-      drams: "dram",
-      ounces: "ounce",
-      poundmasses: "poundmass",
-      hundredweights: "hundredweight",
-      sticks: "stick",
-      lb: "lbm",
-      lbs: "lbm",
-      kips: "kip",
-      kgf: "kilogramforce",
-      acres: "acre",
-      hectares: "hectare",
-      sqfeet: "sqft",
-      sqyard: "sqyd",
-      sqmile: "sqmi",
-      sqmiles: "sqmi",
-      mmhg: "mmHg",
-      mmh2o: "mmH2O",
-      cmh2o: "cmH2O",
-      seconds: "second",
-      secs: "second",
-      minutes: "minute",
-      mins: "minute",
-      hours: "hour",
-      hr: "hour",
-      hrs: "hour",
-      days: "day",
-      weeks: "week",
-      months: "month",
-      years: "year",
-      decades: "decade",
-      centuries: "century",
-      millennia: "millennium",
-      hertz: "hertz",
-      radians: "radian",
-      degrees: "degree",
-      gradians: "gradian",
-      cycles: "cycle",
-      arcsecond: "arcsec",
-      arcseconds: "arcsec",
-      arcminute: "arcmin",
-      arcminutes: "arcmin",
-      BTUs: "BTU",
-      watts: "watt",
-      joules: "joule",
-      amperes: "ampere",
-      amps: "ampere",
-      amp: "ampere",
-      coulombs: "coulomb",
-      volts: "volt",
-      ohms: "ohm",
-      farads: "farad",
-      webers: "weber",
-      teslas: "tesla",
-      electronvolts: "electronvolt",
-      moles: "mole",
-      bit: "bits",
-      byte: "bytes"
-    };
+    function imaginaryValue(scale) {
+      const i = Complex2.I;
+      return scale === 1 || i === void 0 ? i : multiplyScalar2(i, scale);
+    }
+    const UNITS = {};
+    for (const key of Object.keys(UNIT_ROWS)) {
+      const row = UNIT_ROWS[key];
+      const exact = readUnitScale(row.scale);
+      const scaled = roundExactScale(exact);
+      const exactOffset = row.offset === void 0 ? UNIT_ZERO_SCALE : readUnitScale(row.offset);
+      const def = {
+        name: row.name ?? key,
+        base: BASE_UNITS[row.base],
+        prefixes: PREFIXES[row.prefixes],
+        value: row.imaginary ? imaginaryValue(scaled) : scaled,
+        offset: roundExactScale(exactOffset)
+      };
+      if (row.reciprocal) def.reciprocal = true;
+      if (!row.imaginary) attachExactScale(def, exact, exactOffset);
+      UNITS[key] = def;
+    }
     function calculateAngleValues(config3) {
-      if (config3.number === "BigNumber") {
-        const pi = BIGNUMBER_PI;
-        UNITS.rad.value = new BigNumber2(1);
-        UNITS.deg.value = pi.div(180);
-        UNITS.grad.value = pi.div(200);
-        UNITS.cycle.value = pi.times(2);
-        UNITS.arcsec.value = pi.div(648e3);
-        UNITS.arcmin.value = pi.div(10800);
-      } else {
-        UNITS.rad.value = 1;
-        UNITS.deg.value = Math.PI / 180;
-        UNITS.grad.value = Math.PI / 200;
-        UNITS.cycle.value = Math.PI * 2;
-        UNITS.arcsec.value = Math.PI / 648e3;
-        UNITS.arcmin.value = Math.PI / 10800;
+      for (const key in UNITS) {
+        if (!hasOwnProperty(UNITS, key)) continue;
+        const exact = UNITS[key].exact;
+        if (exact === void 0 || irrationalPower(exact, "pi") === 0) continue;
+        UNITS[key].value = (config3.number === "BigNumber" ? exactToBigNumber(exact) : void 0) ?? roundExactScale(exact);
       }
-      UNITS.radian.value = UNITS.rad.value;
-      UNITS.degree.value = UNITS.deg.value;
-      UNITS.gradian.value = UNITS.grad.value;
     }
-    calculateAngleValues(config2);
     if (on) {
       on("config", function(curr, prev) {
         if (curr.number !== prev.number) {
@@ -4891,9 +4374,9 @@ var createUnitClass = /* @__PURE__ */ factory(
         unit.dimensions = unit.base.dimensions;
       }
     }
-    for (const name2 in ALIASES) {
-      if (hasOwnProperty(ALIASES, name2)) {
-        const unit = UNITS[ALIASES[name2]];
+    for (const name2 in UNIT_ROW_ALIASES) {
+      if (hasOwnProperty(UNIT_ROW_ALIASES, name2)) {
+        const unit = UNITS[UNIT_ROW_ALIASES[name2]];
         const alias = {};
         const aliasRec = alias;
         const unitRec = unit;
@@ -4903,9 +4386,11 @@ var createUnitClass = /* @__PURE__ */ factory(
           }
         }
         alias.name = name2;
+        if (unit.exact !== void 0) attachExactScale(alias, unit.exact, unit.exactOffset);
         UNITS[name2] = alias;
       }
     }
+    calculateAngleValues(config2);
     Unit2.isValidAlpha = function isValidAlpha(c2) {
       return /^[a-zA-Z]$/.test(c2);
     };
@@ -5727,7 +5212,7 @@ var COMPLEX_NEG_ONE = new Complex(-1, 0);
 function isFraction2(value) {
   return value instanceof Fraction;
 }
-function gcd(a, b) {
+function gcd2(a, b) {
   a = a < 0n ? -a : a;
   b = b < 0n ? -b : b;
   while (b !== 0n) {
@@ -5746,7 +5231,7 @@ function reducePair(num, den) {
     den = -den;
   }
   if (num === 0n) return [0n, 1n];
-  const g = gcd(num, den);
+  const g = gcd2(num, den);
   return [num / g, den / g];
 }
 var Fraction = class _Fraction {
@@ -5801,7 +5286,7 @@ var Fraction = class _Fraction {
       num = -num;
       den = -den;
     }
-    const g = gcd(num, den);
+    const g = gcd2(num, den);
     this.numerator = num / g;
     this.denominator = den / g;
   }
@@ -6537,6 +6022,39 @@ export {
   BIGNUMBER_LN10,
   UnitParseError,
   DimensionMismatchError,
+  NAMED_IRRATIONALS,
+  irrationalPower,
+  isRationalScale,
+  UNIT_EXACT_SCALE,
+  namedIrrationalScale,
+  PI_EXACT_SCALE,
+  LN2_EXACT_SCALE,
+  decimalExactScale,
+  exactScaleOf,
+  binaryExactScale,
+  ratioExactScale,
+  multiplyExactScales,
+  divideExactScales,
+  powerExactScale,
+  exactScalesEqual,
+  addExactScales,
+  clearExactScaleNumberCache,
+  exactScaleNumberCacheSize,
+  exactScaleToNumber,
+  formatExactScale,
+  readScaleExpression,
+  UNIT_PREFIX_SETS,
+  unitPrefixExactScale,
+  getUnitPrefix,
+  NAMED_SCALES,
+  UNIT_ROWS,
+  UNIT_ROW_ALIASES,
+  namedExactScale,
+  readUnitScale,
+  getUnitRow,
+  unitRowExactScale,
+  unitRowValue,
+  unitRowExactOffset,
   createUnitClass,
   isComplex2,
   Complex,