@vielzeug/coins 1.0.4 → 2.0.0

package/dist/money.js

@@ -1,208 +1,95 @@
 import { CoinsError as e, CurrencyMismatchError as t } from "./errors.js";
-import { SCIENTIFIC_RE as n, applyRounding as r, expandScientific as i, getCurrencyDecimals as a, parseRational as o, pow10 as s, validateCurrencyCode as c } from "./utils.js";
-import { warn as l } from "./_dev.js";
+import { decimal as n, roundDivision as r, toDecimalString as i } from "./decimal.js";
+import { isCurrency as a } from "./currency.js";
 //#region src/money.ts
-function u(e, t) {
-	let r = c(t);
-	if (typeof e == "bigint") return {
-		amount: e,
-		currency: r
-	};
-	if (typeof e == "number") {
-		let t = a(r), o = String(e), s = n.test(o) ? i(o) : o, c = s.indexOf("."), u = c === -1 ? 0 : s.length - c - 1;
-		return u > t && l(`money(): number input "${e}" has more decimal places (${u}) than ${r} supports (${t}). Use a decimal string to avoid IEEE-754 precision loss.`), {
-			amount: f(o, t),
-			currency: r
-		};
+var o = "halfAwayFromZero";
+function s(t, i, a) {
+	if (C(i), typeof t == "bigint") {
+		if (!a || !("unit" in a) || a.unit !== "minor") throw new e("INVALID_MONEY", "Bigint amounts require { unit: 'minor' }");
+		return b(t, i);
 	}
-	return {
-		amount: f(String(e), a(r)),
-		currency: r
-	};
-}
-function d(e, n) {
-	if (e.currency !== n.currency) throw new t(e.currency, n.currency);
-}
-function f(e, t) {
-	let { denominator: n, negative: i, numerator: a } = o(e), c = a * s(t), l = r(c / n, c % n, n, "half-away-from-zero");
-	return i ? -l : l;
-}
-function p(e, t) {
-	return {
-		amount: t,
-		currency: e.currency
-	};
-}
-function m(e) {
-	if (typeof e != "object" || !e) return !1;
-	let t = e;
-	return Object.hasOwn(t, "amount") && typeof t.amount == "bigint" && Object.hasOwn(t, "currency") && typeof t.currency == "string";
-}
-function h(e, t) {
-	return d(e, t), {
-		amount: e.amount + t.amount,
-		currency: e.currency
-	};
-}
-function g(e, t) {
-	return d(e, t), {
-		amount: e.amount - t.amount,
-		currency: e.currency
-	};
-}
-function _(e, t, n = "half-away-from-zero") {
-	let { denominator: i, negative: a, numerator: s } = o(String(t)), c = e.amount < 0n !== a, l = (e.amount < 0n ? -e.amount : e.amount) * s, u = r(l / i, l % i, i, n, c);
-	return {
-		amount: c ? -u : u,
-		currency: e.currency
-	};
-}
-function v(t, n, i = "half-away-from-zero") {
-	let { denominator: a, negative: s, numerator: c } = o(String(n));
-	if (c === 0n) throw new e("Division by zero");
-	let l = t.amount < 0n !== s, u = (t.amount < 0n ? -t.amount : t.amount) * a, d = r(u / c, u % c, c, i, l);
-	return {
-		amount: l ? -d : d,
-		currency: t.currency
-	};
-}
-function y(t, n) {
-	if (n.length === 0) throw new e("allocate requires at least one ratio");
-	let r = n.map((e) => o(String(e)));
-	if (r.some((e) => e.negative)) throw new e("All ratios must be non-negative");
-	if (!r.some((e) => e.numerator > 0n)) throw new e("At least one ratio must be positive");
-	let i = t.amount < 0n, a = i ? -t.amount : t.amount, s = r.reduce((e, t) => t.denominator > e ? t.denominator : e, 1n), c = r.map((e) => e.numerator * (s / e.denominator)), l = c.reduce((e, t) => e + t, 0n), u = [], d = [];
-	for (let e of c) {
-		let t = a * e;
-		u.push(t / l), d.push(t % l);
+	if (a && "unit" in a) throw new e("INVALID_MONEY", "Decimal strings do not accept a unit option");
+	let s = n(t), c = s.numerator * 10n ** BigInt(i.minorUnit);
+	if (c % s.denominator !== 0n && !a) throw new e("INVALID_MONEY", `Amount "${t}" exceeds ${i.code} precision; provide rounding`);
+	return b(r(c, s.denominator, a?.rounding ?? o), i);
+}
+function c(t) {
+	if (!w(t)) throw new e("INVALID_MONEY", "Money must be a plain data object");
+	let n = Object.getOwnPropertyDescriptors(t), r = n.amount, i = n.currency;
+	if (!T(r) || !T(i)) throw new e("INVALID_MONEY", "Money properties must be plain data values");
+	if (typeof r.value != "bigint" || !a(i.value)) throw new e("INVALID_MONEY", "Money must contain bigint amount and a registered currency");
+	return b(r.value, i.value);
+}
+function l(e) {
+	try {
+		return c(e), !0;
+	} catch {
+		return !1;
 	}
-	let f = n.map((e, t) => t).sort((e, t) => {
-		let n = d[t] - d[e];
-		return n > 0n ? 1 : n < 0n ? -1 : 0;
-	}), p = [...u], m = a - u.reduce((e, t) => e + t, 0n);
-	for (let e = 0; m > 0n; e++, m--) p[f[e]] += 1n;
-	return p.map((e) => ({
-		amount: i ? -e : e,
-		currency: t.currency
-	}));
-}
-function b(n) {
-	if (n.length === 0) throw new e("sum requires at least one Money value");
-	let r = n[0].currency;
-	for (let e = 1; e < n.length; e++) if (n[e].currency !== r) throw new t(r, n[e].currency);
-	return {
-		amount: n.reduce((e, t) => e + t.amount, 0n),
-		currency: r
-	};
 }
-function x(t) {
-	if (t.length === 0) throw new e("min requires at least one Money value");
-	let n = t[0];
-	for (let e = 1; e < t.length; e++) n = D(n, t[e]) <= 0 ? n : t[e];
-	return n;
-}
-function S(t) {
-	if (t.length === 0) throw new e("max requires at least one Money value");
-	let n = t[0];
-	for (let e = 1; e < t.length; e++) n = D(n, t[e]) >= 0 ? n : t[e];
-	return n;
-}
-function C(t, n) {
-	if (!Number.isInteger(n) || n <= 0) throw new e("splitEvenly requires a positive integer number of parts");
-	return y(t, Array.from({ length: n }, () => 1));
-}
-function w(n, r, i) {
-	if (n.currency !== r.currency || n.currency !== i.currency) throw new t(n.currency, n.currency === r.currency ? i.currency : r.currency);
-	if (D(r, i) > 0) throw new e(`clamp: lower (${B(r)} ${r.currency}) must be <= upper (${B(i)} ${i.currency})`);
-	return S([r, x([n, i])]);
+function u(e, t) {
+	return S(e, t), b(e.amount + t.amount, e.currency);
 }
-function T(e) {
-	return {
-		amount: e.amount < 0n ? -e.amount : e.amount,
-		currency: e.currency
-	};
+function d(e, t) {
+	return S(e, t), b(e.amount - t.amount, e.currency);
 }
-function E(e) {
-	return {
-		amount: -e.amount,
-		currency: e.currency
-	};
+function f(e, t, i = {}) {
+	x(e);
+	let a = n(t);
+	return b(r(e.amount * a.numerator, a.denominator, i.rounding ?? o), e.currency);
 }
-function D(e, t) {
-	return d(e, t), e.amount < t.amount ? -1 : +(e.amount > t.amount);
+function p(t, i, a = {}) {
+	x(t);
+	let s = n(i);
+	if (s.numerator === 0n) throw new e("DIVISION_BY_ZERO", "Cannot divide money by zero");
+	return b(r(t.amount * s.denominator, s.numerator < 0n ? -s.numerator : s.numerator, a.rounding ?? o) * (s.numerator < 0n ? -1n : 1n), t.currency);
 }
-function O(e, t) {
-	return e.currency === t.currency && e.amount === t.amount;
+function m(e, t) {
+	return S(e, t), e.amount === t.amount ? 0 : e.amount < t.amount ? -1 : 1;
 }
-function k(e, t) {
-	return D(e, t) > 0;
+function h(e) {
+	return x(e), b(e.amount < 0n ? -e.amount : e.amount, e.currency);
 }
-function A(e, t) {
-	return D(e, t) >= 0;
+function g(e) {
+	return x(e), b(-e.amount, e.currency);
 }
-function j(e, t) {
-	return D(e, t) < 0;
+function _(t, n) {
+	x(t);
+	let { fractionDigits: i, rounding: a = o } = n;
+	if (!Number.isInteger(i) || i < 0 || i > t.currency.minorUnit) throw new e("INVALID_ROUNDING", `fractionDigits must be an integer from 0 to ${t.currency.minorUnit}`);
+	let s = 10n ** BigInt(t.currency.minorUnit - i);
+	return b(r(t.amount, s, a) * s, t.currency);
 }
-function M(e, t) {
-	return D(e, t) <= 0;
+function v(e) {
+	return x(e), i(e.amount, e.currency.minorUnit);
 }
-function N(e) {
-	return e.amount === 0n;
+function y(e, t) {
+	return C(t), b(e, t);
 }
-function P(e) {
-	return e.amount > 0n;
+function b(e, t) {
+	return Object.freeze({
+		amount: e,
+		currency: t
+	});
 }
-function F(e) {
-	return e.amount < 0n;
+function x(t) {
+	if (!Object.isFrozen(t) || !a(t.currency)) throw new e("INVALID_MONEY", "Money must be a canonical Coins value");
 }
-function I(e) {
-	return e.amount >= 0n;
+function S(e, n) {
+	if (x(e), x(n), e.currency !== n.currency) throw new t(e.currency.code, n.currency.code);
 }
-function L(e) {
-	return e.amount <= 0n;
+function C(t) {
+	if (!a(t)) throw new e("INVALID_CURRENCY", "Money requires a registered currency");
 }
-function R(e) {
-	return {
-		amount: String(e.amount),
-		currency: e.currency
-	};
+function w(e) {
+	if (typeof e != "object" || !e) return !1;
+	let t = Object.getPrototypeOf(e);
+	return t === Object.prototype || t === null;
 }
-function z(t) {
-	let n = c(t.currency);
-	if (typeof t.amount != "string") throw new e(`Invalid money amount in JSON: ${String(t.amount)} (expected an integer string, e.g. '123456')`);
-	let r;
-	try {
-		r = BigInt(t.amount);
-	} catch {
-		throw new e(`Invalid money amount in JSON: "${t.amount}" (expected an integer string, e.g. '123456')`);
-	}
-	return {
-		amount: r,
-		currency: n
-	};
-}
-function B(e) {
-	let t = a(e.currency);
-	if (t === 0) return String(e.amount);
-	let n = e.amount < 0n, r = n ? -e.amount : e.amount, i = s(t), o = r / i, c = (r % i).toString().padStart(t, "0");
-	return `${n ? "-" : ""}${o}.${c}`;
-}
-function V(e) {
-	let t = a(e.currency);
-	return Number(e.amount) / Number(s(t));
-}
-function H(t, n, i = "half-away-from-zero") {
-	if (!Number.isInteger(n) || n < 0) throw new e(`roundTo: places must be a non-negative integer, got ${n}`);
-	let o = a(t.currency);
-	if (n > o) throw new e(`roundTo: places (${n}) exceeds the decimal places for ${t.currency} (${o})`);
-	if (n === o) return t;
-	let c = s(o - n), l = t.amount < 0n, u = l ? -t.amount : t.amount, d = r(u / c, u % c, c, i, l);
-	return {
-		amount: l ? -d : d,
-		currency: t.currency
-	};
+function T(e) {
+	return e !== void 0 && "value" in e && e.get === void 0 && e.set === void 0;
 }
 //#endregion
-export { T as abs, h as add, y as allocate, w as clamp, D as compare, v as divide, z as fromJSON, k as greaterThan, A as greaterThanOrEqual, O as isEqual, m as isMoney, F as isNegative, I as isNonNegative, L as isNonPositive, P as isPositive, N as isZero, j as lessThan, M as lessThanOrEqual, S as max, x as min, u as money, _ as multiply, E as negate, H as roundTo, C as splitEvenly, g as subtract, b as sum, B as toDecimal, R as toJSON, V as toNumber, p as withAmount };
+export { h as abs, u as add, m as compare, p as divide, l as isMoney, s as money, f as multiply, g as negate, c as parseMoney, _ as round, d as subtract, v as toDecimal, y as withMinor };
 
 //# sourceMappingURL=money.js.map

package/dist/money.js.map

@@ -1 +1 @@
-{"version":3,"file":"money.js","names":[],"sources":["../src/money.ts"],"sourcesContent":["import type { CurrencyCode, Money, MoneyJSON, RoundingMode } from './types';\n\nimport { warn } from './_dev';\nimport { CoinsError, CurrencyMismatchError } from './errors';\nimport {\n  applyRounding,\n  expandScientific,\n  getCurrencyDecimals,\n  parseRational,\n  pow10,\n  SCIENTIFIC_RE,\n  validateCurrencyCode,\n} from './utils';\n\nexport { CoinsError, CurrencyMismatchError, InvalidCurrencyError } from './errors';\n\n// ─── Factories ───────────────────────────────────────────────────────────────\n\n/**\n * Creates a `Money` value from a decimal string, number, or raw bigint minor units.\n * Validates the currency code — throws `InvalidCurrencyError` for unrecognised ISO 4217 codes.\n *\n * - **string** `'1234.56'` → parsed losslessly; respects the currency's decimal places.\n * - **number** `1234.56` → converted via `String()` first; inherits IEEE-754 limits.\n *   Prefer strings when precision matters.\n * - **bigint** `123456n` → used as-is (already in minor units).\n *\n * @example\n * ```ts\n * money('1234.56', 'USD') // { amount: 123456n, currency: 'USD' }\n * money(1234,      'JPY') // { amount: 1234n,   currency: 'JPY' }\n * money(123456n,   'USD') // { amount: 123456n, currency: 'USD' }\n * ```\n */\nexport function money(amount: bigint | number | string, currency: CurrencyCode): Money {\n  const validCurrency = validateCurrencyCode(currency);\n\n  if (typeof amount === 'bigint') {\n    return { amount, currency: validCurrency };\n  }\n\n  if (typeof amount === 'number') {\n    const decimals = getCurrencyDecimals(validCurrency);\n    const str = String(amount);\n    // Expand scientific notation (e.g. String(1e-7) === '1e-7') before measuring fraction\n    // length — otherwise inputs like 1e-7 report 0 fractional digits and skip the warning\n    // below despite having far more precision than the currency supports.\n    const normalized = SCIENTIFIC_RE.test(str) ? expandScientific(str) : str;\n    const dotIndex = normalized.indexOf('.');\n    const fracLen = dotIndex === -1 ? 0 : normalized.length - dotIndex - 1;\n\n    if (fracLen > decimals) {\n      warn(\n        `money(): number input \"${amount}\" has more decimal places (${fracLen}) than ${validCurrency} supports (${decimals}). ` +\n          `Use a decimal string to avoid IEEE-754 precision loss.`,\n      );\n    }\n\n    // getCurrencyDecimals is cached from the validateCurrencyCode call above.\n    return { amount: parseToMinorUnits(str, decimals), currency: validCurrency };\n  }\n\n  // getCurrencyDecimals is cached from the validateCurrencyCode call above.\n  return { amount: parseToMinorUnits(String(amount), getCurrencyDecimals(validCurrency)), currency: validCurrency };\n}\n\n// ─── Internal ─────────────────────────────────────────────────────────────────\n\nfunction assertSameCurrency(a: Money, b: Money): void {\n  if (a.currency !== b.currency) {\n    throw new CurrencyMismatchError(a.currency, b.currency);\n  }\n}\n\n/**\n * Converts a decimal string to minor units for the given decimal precision.\n * Uses parseRational + applyRounding to share the single rounding implementation.\n */\nfunction parseToMinorUnits(str: string, decimals: number): bigint {\n  const { denominator, negative, numerator } = parseRational(str);\n  // numerator/denominator × 10^decimals = numerator × 10^decimals / denominator\n  const scale = pow10(decimals);\n  const raw = numerator * scale;\n  const quotient = raw / denominator;\n  const result = applyRounding(quotient, raw % denominator, denominator, 'half-away-from-zero');\n\n  return negative ? -result : result;\n}\n\n/**\n * Creates a new `Money` value with the given `amount` and the same currency as `m`.\n * Useful when you compute a raw `bigint` amount externally and need to wrap it\n * back into a `Money` value without re-validating the currency.\n *\n * @example\n * ```ts\n * const price = money('9.99', 'USD');\n * withAmount(price, 1999n)  // { amount: 1999n, currency: 'USD' }\n * ```\n */\nexport function withAmount(m: Money, amount: bigint): Money {\n  return { amount, currency: m.currency };\n}\n\n/**\n * Type guard that returns `true` if `value` is a `Money`-shaped object\n * (has a `bigint` `amount` and a `string` `currency`).\n * Useful for narrowing unknown payloads from APIs or deserialized storage.\n *\n * Note: does **not** validate the currency code — use `money(0n, currency)` or\n * `validateCurrencyCode()` if you also need to confirm it is a recognized ISO 4217 code.\n *\n * @example\n * ```ts\n * isMoney({ amount: 100n, currency: 'USD' })  // true\n * isMoney({ amount: 1.5, currency: 'USD' })   // false\n * isMoney(null)                               // false\n * ```\n */\nexport function isMoney(value: unknown): value is Money {\n  if (typeof value !== 'object' || value === null) return false;\n\n  const v = value as Record<string, unknown>;\n\n  return (\n    Object.hasOwn(v, 'amount') &&\n    typeof v.amount === 'bigint' &&\n    Object.hasOwn(v, 'currency') &&\n    typeof v.currency === 'string'\n  );\n}\n\n// ─── Arithmetic ──────────────────────────────────────────────────────────────\n\n/** Adds two `Money` values. Throws if their currencies differ. */\nexport function add(a: Money, b: Money): Money {\n  assertSameCurrency(a, b);\n\n  return { amount: a.amount + b.amount, currency: a.currency };\n}\n\n/** Subtracts `b` from `a`. Throws if their currencies differ. */\nexport function subtract(a: Money, b: Money): Money {\n  assertSameCurrency(a, b);\n\n  return { amount: a.amount - b.amount, currency: a.currency };\n}\n\n/**\n * Multiplies a `Money` value by a scalar factor.\n * The factor can be a decimal string (lossless) or a number.\n *\n * @param mode Rounding mode for fractional minor units. Defaults to `'half-away-from-zero'`.\n *\n * @example\n * ```ts\n * multiply(money('100.00', 'USD'), '1.5')              // $150.00\n * multiply(money('1.00', 'USD'), '0.339', 'floor')     // $0.33\n * multiply(money('1.00', 'USD'), '0.339', 'ceiling')   // $0.34\n * ```\n */\nexport function multiply(m: Money, factor: number | string, mode: RoundingMode = 'half-away-from-zero'): Money {\n  const { denominator, negative: factorNegative, numerator } = parseRational(String(factor));\n  const negative = m.amount < 0n !== factorNegative;\n  const absAmount = m.amount < 0n ? -m.amount : m.amount;\n  const raw = absAmount * numerator;\n  const quotient = raw / denominator;\n  const result = applyRounding(quotient, raw % denominator, denominator, mode, negative);\n\n  return { amount: negative ? -result : result, currency: m.currency };\n}\n\n/**\n * Divides a `Money` value by a scalar divisor.\n * The divisor can be a decimal string (lossless) or a number.\n *\n * @param mode Rounding mode for fractional minor units. Defaults to `'half-away-from-zero'`.\n * @throws {CoinsError} On division by zero.\n *\n * @example\n * ```ts\n * divide(money('100.00', 'USD'), 3)              // $33.33\n * divide(money('100.00', 'USD'), 3, 'ceiling')   // $33.34\n * ```\n */\nexport function divide(m: Money, divisor: number | string, mode: RoundingMode = 'half-away-from-zero'): Money {\n  const { denominator: parsedDenom, negative: divisorNegative, numerator } = parseRational(String(divisor));\n\n  if (numerator === 0n) throw new CoinsError('Division by zero');\n\n  const negative = m.amount < 0n !== divisorNegative;\n  const absAmount = m.amount < 0n ? -m.amount : m.amount;\n  // Dividing by (numerator/parsedDenom) = multiplying by (parsedDenom/numerator).\n  const raw = absAmount * parsedDenom;\n  const quotient = raw / numerator;\n  const result = applyRounding(quotient, raw % numerator, numerator, mode, negative);\n\n  return { amount: negative ? -result : result, currency: m.currency };\n}\n\n/**\n * Distributes `money` across `ratios` without losing or gaining a single minor unit.\n * Accepts both number and string ratios — use strings for lossless decimal weights.\n *\n * Uses the Largest Remainder Method: each share gets its floor allocation first,\n * then any remainder units are assigned one-by-one to the shares with the largest\n * fractional parts, breaking ties by original index (stable, left-to-right).\n *\n * Throws if `ratios` is empty, contains negative values (including negative strings like `'-0.5'`), or sums to zero.\n *\n * @example\n * ```ts\n * allocate(money('10.00', 'USD'), [1, 1, 1])\n * // → [$3.34, $3.33, $3.33]   (not three × $3.33 — that loses a penny)\n *\n * allocate(money('10.00', 'USD'), ['0.3', '0.7'])\n * // → [$3.00, $7.00]\n * ```\n */\nexport function allocate(m: Money, ratios: readonly (number | string)[]): [Money, ...Money[]] {\n  if (ratios.length === 0) throw new CoinsError('allocate requires at least one ratio');\n\n  const parsedRatios = ratios.map((r) => parseRational(String(r)));\n\n  if (parsedRatios.some((p) => p.negative)) throw new CoinsError('All ratios must be non-negative');\n\n  if (!parsedRatios.some((p) => p.numerator > 0n)) throw new CoinsError('At least one ratio must be positive');\n\n  const negative = m.amount < 0n;\n  const absAmount = negative ? -m.amount : m.amount;\n\n  // All denominators are powers of 10; the max is their LCM — use it to normalise weights to integers.\n  const maxDenominator = parsedRatios.reduce((max, p) => (p.denominator > max ? p.denominator : max), 1n);\n  const bigWeights = parsedRatios.map((p) => p.numerator * (maxDenominator / p.denominator));\n  const bigTotal = bigWeights.reduce((a, b) => a + b, 0n);\n\n  // Floor allocation + fractional remainders.\n  const floors: bigint[] = [];\n  const fracRemainders: bigint[] = [];\n\n  for (const w of bigWeights) {\n    const ideal = absAmount * w;\n\n    floors.push(ideal / bigTotal);\n    fracRemainders.push(ideal % bigTotal);\n  }\n\n  // Distribute leftover units to the shares with the largest fractional remainders.\n  // Relies on V8/SpiderMonkey's stable sort (ECMAScript 2019+ spec-mandated): ties\n  // in fractional remainders are broken by original index (left-to-right), ensuring\n  // deterministic output for equal-weight ratios (e.g. [1, 1, 1]).\n  const indices = ratios\n    .map((_, i) => i)\n    .sort((a, b) => {\n      const diff = fracRemainders[b]! - fracRemainders[a]!;\n\n      return diff > 0n ? 1 : diff < 0n ? -1 : 0;\n    });\n\n  const result = [...floors];\n  // `remaining` is always < ratios.length (at most one unit per share), safe for this loop.\n  let remaining = absAmount - floors.reduce((a, b) => a + b, 0n);\n\n  for (let i = 0; remaining > 0n; i++, remaining--) {\n    result[indices[i]!]! += 1n;\n  }\n\n  return result.map((amount) => ({ amount: negative ? -amount : amount, currency: m.currency })) as [Money, ...Money[]];\n}\n\n// ─── Aggregates ──────────────────────────────────────────────────────────────\n\n/**\n * Sums an array of `Money` values. Throws if the array is empty or currencies differ.\n *\n * @example\n * ```ts\n * sum([money('1.00', 'USD'), money('2.50', 'USD')]) // $3.50\n * ```\n */\nexport function sum(moneys: readonly Money[]): Money {\n  if (moneys.length === 0) throw new CoinsError('sum requires at least one Money value');\n\n  const currency = moneys[0]!.currency;\n\n  for (let i = 1; i < moneys.length; i++) {\n    if (moneys[i]!.currency !== currency) {\n      throw new CurrencyMismatchError(currency, moneys[i]!.currency);\n    }\n  }\n\n  return { amount: moneys.reduce((acc, m) => acc + m.amount, 0n), currency };\n}\n\n/**\n * Returns the smallest `Money` value from a non-empty array. Throws if currencies differ.\n *\n * @example\n * ```ts\n * min([money('3.00', 'USD'), money('1.00', 'USD'), money('2.00', 'USD')]) // $1.00\n * ```\n */\nexport function min(moneys: readonly Money[]): Money {\n  if (moneys.length === 0) throw new CoinsError('min requires at least one Money value');\n\n  let result = moneys[0]!;\n\n  for (let i = 1; i < moneys.length; i++) result = compare(result, moneys[i]!) <= 0 ? result : moneys[i]!;\n\n  return result;\n}\n\n/**\n * Returns the largest `Money` value from a non-empty array. Throws if currencies differ.\n *\n * @example\n * ```ts\n * max([money('1.00', 'USD'), money('3.00', 'USD'), money('2.00', 'USD')]) // $3.00\n * ```\n */\nexport function max(moneys: readonly Money[]): Money {\n  if (moneys.length === 0) throw new CoinsError('max requires at least one Money value');\n\n  let result = moneys[0]!;\n\n  for (let i = 1; i < moneys.length; i++) result = compare(result, moneys[i]!) >= 0 ? result : moneys[i]!;\n\n  return result;\n}\n\n/**\n * Splits `money` into `parts` equal shares without losing or gaining a single minor unit.\n * Equivalent to `allocate(money, Array.from({ length: parts }, () => 1))`.\n *\n * @throws {CoinsError} If `parts` is not a positive integer (≥ 1).\n *\n * @example\n * ```ts\n * splitEvenly(money('10.00', 'USD'), 3)\n * // → [$3.34, $3.33, $3.33]\n * ```\n */\nexport function splitEvenly(m: Money, parts: number): [Money, ...Money[]] {\n  if (!Number.isInteger(parts) || parts <= 0) {\n    throw new CoinsError('splitEvenly requires a positive integer number of parts');\n  }\n\n  return allocate(\n    m,\n    Array.from({ length: parts }, () => 1),\n  );\n}\n\n/**\n * Clamps `m` to the inclusive range `[lower, upper]`.\n *\n * @throws {CurrencyMismatchError} If `m`, `lower`, or `upper` have different currencies.\n * @throws {CoinsError}            If `lower > upper`.\n *\n * @example\n * ```ts\n * clamp(money('5.00', 'USD'), money('1.00', 'USD'), money('10.00', 'USD'))  // $5.00\n * clamp(money('0.00', 'USD'), money('1.00', 'USD'), money('10.00', 'USD'))  // $1.00\n * clamp(money('15.00', 'USD'), money('1.00', 'USD'), money('10.00', 'USD')) // $10.00\n * ```\n */\nexport function clamp(m: Money, lower: Money, upper: Money): Money {\n  // Validate currency consistency upfront so the error always names the mismatch,\n  // rather than surfacing mid-computation from min() or max().\n  if (m.currency !== lower.currency || m.currency !== upper.currency) {\n    throw new CurrencyMismatchError(m.currency, m.currency !== lower.currency ? lower.currency : upper.currency);\n  }\n\n  if (compare(lower, upper) > 0) {\n    throw new CoinsError(\n      `clamp: lower (${toDecimal(lower)} ${lower.currency}) must be <= upper (${toDecimal(upper)} ${upper.currency})`,\n    );\n  }\n\n  return max([lower, min([m, upper])]);\n}\n\n// ─── Unary ───────────────────────────────────────────────────────────────────\n\n/** Returns the absolute value of `money`. Negative amounts become positive. */\nexport function abs(m: Money): Money {\n  return { amount: m.amount < 0n ? -m.amount : m.amount, currency: m.currency };\n}\n\n/** Returns `money` with its sign flipped. */\nexport function negate(m: Money): Money {\n  return { amount: -m.amount, currency: m.currency };\n}\n\n// ─── Comparison ──────────────────────────────────────────────────────────────\n\n/**\n * Compares two `Money` values. Returns `-1`, `0`, or `1`.\n * Throws if their currencies differ.\n */\nexport function compare(a: Money, b: Money): -1 | 0 | 1 {\n  assertSameCurrency(a, b);\n\n  if (a.amount < b.amount) return -1;\n\n  if (a.amount > b.amount) return 1;\n\n  return 0;\n}\n\n/**\n * Returns `true` if both `Money` values have the same currency and amount.\n * Returns `false` if currencies differ — safe to use in `.filter()` and conditional chains.\n */\nexport function isEqual(a: Money, b: Money): boolean {\n  return a.currency === b.currency && a.amount === b.amount;\n}\n\n/** Returns `true` if `a` is strictly greater than `b`. Throws on currency mismatch. */\nexport function greaterThan(a: Money, b: Money): boolean {\n  return compare(a, b) > 0;\n}\n\n/** Returns `true` if `a` is greater than or equal to `b`. Throws on currency mismatch. */\nexport function greaterThanOrEqual(a: Money, b: Money): boolean {\n  return compare(a, b) >= 0;\n}\n\n/** Returns `true` if `a` is strictly less than `b`. Throws on currency mismatch. */\nexport function lessThan(a: Money, b: Money): boolean {\n  return compare(a, b) < 0;\n}\n\n/** Returns `true` if `a` is less than or equal to `b`. Throws on currency mismatch. */\nexport function lessThanOrEqual(a: Money, b: Money): boolean {\n  return compare(a, b) <= 0;\n}\n\n// ─── Predicates ──────────────────────────────────────────────────────────────\n\n/** Returns `true` if the amount is exactly zero. */\nexport function isZero(m: Money): boolean {\n  return m.amount === 0n;\n}\n\n/** Returns `true` if the amount is strictly positive (> 0). */\nexport function isPositive(m: Money): boolean {\n  return m.amount > 0n;\n}\n\n/** Returns `true` if the amount is strictly negative (< 0). */\nexport function isNegative(m: Money): boolean {\n  return m.amount < 0n;\n}\n\n/** Returns `true` if the amount is zero or positive (>= 0). */\nexport function isNonNegative(m: Money): boolean {\n  return m.amount >= 0n;\n}\n\n/** Returns `true` if the amount is zero or negative (<= 0). */\nexport function isNonPositive(m: Money): boolean {\n  return m.amount <= 0n;\n}\n\n// ─── Serialization ───────────────────────────────────────────────────────────\n\n/**\n * Serializes a `Money` value to a plain-object JSON-safe form.\n * `amount` is a bigint string (e.g. `'123456'`) to avoid `JSON.stringify` throwing.\n *\n * @example\n * ```ts\n * toJSON(money('1234.56', 'USD')) // { amount: '123456', currency: 'USD' }\n * JSON.stringify(toJSON(price))   // '{\"amount\":\"123456\",\"currency\":\"USD\"}'\n * ```\n */\nexport function toJSON(m: Money): MoneyJSON {\n  return { amount: String(m.amount), currency: m.currency };\n}\n\n/**\n * Deserializes a `MoneyJSON` object back into a `Money` value.\n * Validates the currency code and the amount string.\n *\n * @example\n * ```ts\n * fromJSON({ amount: '123456', currency: 'USD' }) // { amount: 123456n, currency: 'USD' }\n * ```\n */\nexport function fromJSON(json: MoneyJSON): Money {\n  const validCurrency = validateCurrencyCode(json.currency);\n\n  if (typeof json.amount !== 'string') {\n    throw new CoinsError(\n      `Invalid money amount in JSON: ${String(json.amount)} (expected an integer string, e.g. '123456')`,\n    );\n  }\n\n  let amount: bigint;\n\n  try {\n    amount = BigInt(json.amount);\n  } catch {\n    throw new CoinsError(`Invalid money amount in JSON: \"${json.amount}\" (expected an integer string, e.g. '123456')`);\n  }\n\n  return { amount, currency: validCurrency };\n}\n\n/**\n * Serializes a `Money` value to a decimal string (e.g. `'1234.56'`).\n * Round-trips losslessly with `money()`.\n *\n * @example\n * ```ts\n * toDecimal(money('1234.56', 'USD')) // '1234.56'\n * toDecimal(money(5n, 'USD'))        // '0.05'\n * toDecimal(money(1234n, 'JPY'))     // '1234'\n * ```\n */\nexport function toDecimal(m: Money): string {\n  const decimals = getCurrencyDecimals(m.currency);\n\n  if (decimals === 0) return String(m.amount);\n\n  const negative = m.amount < 0n;\n  const abs = negative ? -m.amount : m.amount;\n  const scale = pow10(decimals);\n  const whole = abs / scale;\n  const frac = (abs % scale).toString().padStart(decimals, '0');\n\n  return `${negative ? '-' : ''}${whole}.${frac}`;\n}\n\n/**\n * Converts a `Money` value to a floating-point number.\n * Useful for charting and display; **not** for arithmetic (lossy).\n *\n * @example\n * ```ts\n * toNumber(money('1234.56', 'USD')) // 1234.56\n * ```\n */\nexport function toNumber(m: Money): number {\n  const decimals = getCurrencyDecimals(m.currency);\n\n  return Number(m.amount) / Number(pow10(decimals));\n}\n\n// ─── Rounding ─────────────────────────────────────────────────────────────────\n\n/**\n * Rounds a `Money` value to fewer decimal places than the currency's default.\n * `places` must be a non-negative integer in the range `0..currencyDecimals`.\n *\n * Useful for display purposes (e.g. rounding USD to whole dollars).\n * @throws {CoinsError} If `places` is out of the allowed range.\n *\n * @param mode Rounding mode. Defaults to `'half-away-from-zero'`.\n *\n * @example\n * ```ts\n * roundTo(money('1234.56', 'USD'), 0)          // $1235   (whole dollars)\n * roundTo(money('1234.56', 'USD'), 1)          // $1234.6\n * roundTo(money('1234.56', 'USD'), 1, 'floor') // $1234.5\n * roundTo(money('1234', 'JPY'), 0)             // ¥1234   (no-op: JPY is already 0-decimal)\n * ```\n */\nexport function roundTo(m: Money, places: number, mode: RoundingMode = 'half-away-from-zero'): Money {\n  if (!Number.isInteger(places) || places < 0) {\n    throw new CoinsError(`roundTo: places must be a non-negative integer, got ${places}`);\n  }\n\n  const currencyDecimals = getCurrencyDecimals(m.currency);\n\n  if (places > currencyDecimals) {\n    throw new CoinsError(\n      `roundTo: places (${places}) exceeds the decimal places for ${m.currency} (${currencyDecimals})`,\n    );\n  }\n\n  if (places === currencyDecimals) return m;\n\n  const drop = currencyDecimals - places;\n  const divisor = pow10(drop);\n  const negative = m.amount < 0n;\n  const absAmount = negative ? -m.amount : m.amount;\n  const quotient = absAmount / divisor;\n  const remainder = absAmount % divisor;\n  const rounded = applyRounding(quotient, remainder, divisor, mode, negative);\n\n  return { amount: negative ? -rounded : rounded, currency: m.currency };\n}\n"],"mappings":"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"}
+{"version":3,"file":"money.js","names":[],"sources":["../src/money.ts"],"sourcesContent":["import type { Currency, Money, RoundingMode } from './types';\n\nimport { isCurrency } from './currency';\nimport { decimal, roundDivision, toDecimalString } from './decimal';\nimport { CoinsError, CurrencyMismatchError } from './errors';\n\nconst defaultRounding: RoundingMode = 'halfAwayFromZero';\n\nexport function money<C extends Currency>(amount: string, currency: C): Money<C>;\nexport function money<C extends Currency>(amount: string, currency: C, options: { rounding: RoundingMode }): Money<C>;\nexport function money<C extends Currency>(amount: bigint, currency: C, options: { unit: 'minor' }): Money<C>;\nexport function money<C extends Currency>(\n  amount: bigint | string,\n  currency: C,\n  options?: { rounding: RoundingMode } | { unit: 'minor' },\n): Money<C> {\n  assertCurrency(currency);\n\n  if (typeof amount === 'bigint') {\n    if (!options || !('unit' in options) || options.unit !== 'minor') {\n      throw new CoinsError('INVALID_MONEY', \"Bigint amounts require { unit: 'minor' }\");\n    }\n\n    return createMoney(amount, currency);\n  }\n\n  if (options && 'unit' in options)\n    throw new CoinsError('INVALID_MONEY', 'Decimal strings do not accept a unit option');\n\n  const value = decimal(amount);\n  const scaled = value.numerator * 10n ** BigInt(currency.minorUnit);\n  const remainder = scaled % value.denominator;\n\n  if (remainder !== 0n && !options) {\n    throw new CoinsError('INVALID_MONEY', `Amount \"${amount}\" exceeds ${currency.code} precision; provide rounding`);\n  }\n\n  return createMoney(roundDivision(scaled, value.denominator, options?.rounding ?? defaultRounding), currency);\n}\n\nexport function parseMoney(value: unknown): Money {\n  if (!isPlainDataObject(value)) throw new CoinsError('INVALID_MONEY', 'Money must be a plain data object');\n\n  const descriptors = Object.getOwnPropertyDescriptors(value);\n  const amountDescriptor = descriptors.amount;\n  const currencyDescriptor = descriptors.currency;\n\n  if (!isDataProperty(amountDescriptor) || !isDataProperty(currencyDescriptor)) {\n    throw new CoinsError('INVALID_MONEY', 'Money properties must be plain data values');\n  }\n\n  if (typeof amountDescriptor.value !== 'bigint' || !isCurrency(currencyDescriptor.value)) {\n    throw new CoinsError('INVALID_MONEY', 'Money must contain bigint amount and a registered currency');\n  }\n\n  return createMoney(amountDescriptor.value, currencyDescriptor.value);\n}\n\nexport function isMoney(value: unknown): value is Money {\n  try {\n    parseMoney(value);\n\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nexport function add<C extends Currency>(left: Money<C>, right: Money<NoInfer<C>>): Money<C> {\n  assertSameCurrency(left, right);\n\n  return createMoney(left.amount + right.amount, left.currency);\n}\n\nexport function subtract<C extends Currency>(left: Money<C>, right: Money<NoInfer<C>>): Money<C> {\n  assertSameCurrency(left, right);\n\n  return createMoney(left.amount - right.amount, left.currency);\n}\n\nexport function multiply<C extends Currency>(\n  value: Money<C>,\n  factor: string,\n  options: { rounding?: RoundingMode } = {},\n): Money<C> {\n  assertMoney(value);\n\n  const scalar = decimal(factor);\n\n  return createMoney(\n    roundDivision(value.amount * scalar.numerator, scalar.denominator, options.rounding ?? defaultRounding),\n    value.currency,\n  );\n}\n\nexport function divide<C extends Currency>(\n  value: Money<C>,\n  divisor: string,\n  options: { rounding?: RoundingMode } = {},\n): Money<C> {\n  assertMoney(value);\n\n  const scalar = decimal(divisor);\n\n  if (scalar.numerator === 0n) throw new CoinsError('DIVISION_BY_ZERO', 'Cannot divide money by zero');\n\n  return createMoney(\n    roundDivision(\n      value.amount * scalar.denominator,\n      scalar.numerator < 0n ? -scalar.numerator : scalar.numerator,\n      options.rounding ?? defaultRounding,\n    ) * (scalar.numerator < 0n ? -1n : 1n),\n    value.currency,\n  );\n}\n\nexport function compare<C extends Currency>(left: Money<C>, right: Money<NoInfer<C>>): -1 | 0 | 1 {\n  assertSameCurrency(left, right);\n\n  return left.amount === right.amount ? 0 : left.amount < right.amount ? -1 : 1;\n}\n\nexport function abs<C extends Currency>(value: Money<C>): Money<C> {\n  assertMoney(value);\n\n  return createMoney(value.amount < 0n ? -value.amount : value.amount, value.currency);\n}\n\nexport function negate<C extends Currency>(value: Money<C>): Money<C> {\n  assertMoney(value);\n\n  return createMoney(-value.amount, value.currency);\n}\n\nexport function round<C extends Currency>(\n  value: Money<C>,\n  options: { fractionDigits: number; rounding?: RoundingMode },\n): Money<C> {\n  assertMoney(value);\n\n  const { fractionDigits, rounding = defaultRounding } = options;\n\n  if (!Number.isInteger(fractionDigits) || fractionDigits < 0 || fractionDigits > value.currency.minorUnit) {\n    throw new CoinsError('INVALID_ROUNDING', `fractionDigits must be an integer from 0 to ${value.currency.minorUnit}`);\n  }\n\n  const factor = 10n ** BigInt(value.currency.minorUnit - fractionDigits);\n\n  return createMoney(roundDivision(value.amount, factor, rounding) * factor, value.currency);\n}\n\nexport function toDecimal(value: Money): string {\n  assertMoney(value);\n\n  return toDecimalString(value.amount, value.currency.minorUnit);\n}\n\nexport function withMinor<C extends Currency>(amount: bigint, currency: C): Money<C> {\n  assertCurrency(currency);\n\n  return createMoney(amount, currency);\n}\n\nfunction createMoney<C extends Currency>(amount: bigint, currency: C): Money<C> {\n  return Object.freeze({ amount, currency }) as Money<C>;\n}\n\nfunction assertMoney(value: Money): void {\n  if (!Object.isFrozen(value) || !isCurrency(value.currency)) {\n    throw new CoinsError('INVALID_MONEY', 'Money must be a canonical Coins value');\n  }\n}\n\nfunction assertSameCurrency(left: Money, right: Money): void {\n  assertMoney(left);\n  assertMoney(right);\n\n  if (left.currency !== right.currency) {\n    throw new CurrencyMismatchError(left.currency.code, right.currency.code);\n  }\n}\n\nfunction assertCurrency(value: Currency): void {\n  if (!isCurrency(value)) throw new CoinsError('INVALID_CURRENCY', 'Money requires a registered currency');\n}\n\nfunction isPlainDataObject(value: unknown): value is Record<PropertyKey, unknown> {\n  if (typeof value !== 'object' || value === null) return false;\n\n  const prototype = Object.getPrototypeOf(value);\n\n  return prototype === Object.prototype || prototype === null;\n}\n\nfunction isDataProperty(\n  descriptor: PropertyDescriptor | undefined,\n): descriptor is PropertyDescriptor & { value: unknown } {\n  return (\n    descriptor !== undefined && 'value' in descriptor && descriptor.get === undefined && descriptor.set === undefined\n  );\n}\n"],"mappings":"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"}

package/dist/serialization.cjs

@@ -0,0 +1,2 @@
+const e=require("./errors.cjs"),t=require("./currency.cjs"),n=require("./money.cjs");var r=/^(?:0|-[1-9]\d*|[1-9]\d*)$/,i=[`amount`,`currency`,`unit`];function a(e){return{amount:e.amount.toString(),currency:e.currency.code,unit:`minor`}}function o(r,i={}){try{let e=s(r),a=i.currency??t.resolveBuiltinCurrency;return n.money(BigInt(e.amount),a(e.currency),{unit:`minor`})}catch(t){throw new e.CoinsError(`INVALID_MONEY`,`Invalid Money JSON`,{cause:t})}}function s(e){if(typeof e!=`object`||!e||Object.getPrototypeOf(e)!==Object.prototype)throw TypeError(`Money JSON must be a plain object`);let t=Object.getOwnPropertyDescriptors(e),n=Reflect.ownKeys(e);if(n.length!==i.length||!i.every(e=>n.includes(e)))throw TypeError(`Money JSON must contain only amount, currency, and unit`);for(let e of i){let n=t[e];if(!n||!(`value`in n)||n.get||n.set)throw TypeError(`Money JSON property "${e}" must be a data value`)}let a=t.amount.value,o=t.currency.value,s=t.unit.value;if(typeof a!=`string`||!r.test(a))throw TypeError(`Money JSON amount must be a canonical integer string`);if(typeof o!=`string`||s!==`minor`)throw TypeError(`Money JSON currency/unit are invalid`);return{amount:a,currency:o,unit:s}}exports.parseMoneyJSON=o,exports.toJSON=a;
+//# sourceMappingURL=serialization.cjs.map

package/dist/serialization.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialization.cjs","names":[],"sources":["../src/serialization.ts"],"sourcesContent":["import type { Currency, Money, MoneyJSON } from './types';\n\nimport { resolveBuiltinCurrency } from './currency';\nimport { CoinsError } from './errors';\nimport { money } from './money';\n\nconst INTEGER = /^(?:0|-[1-9]\\d*|[1-9]\\d*)$/;\nconst KEYS = ['amount', 'currency', 'unit'] as const;\n\nexport function toJSON(value: Money): MoneyJSON {\n  return { amount: value.amount.toString(), currency: value.currency.code, unit: 'minor' };\n}\n\nexport function parseMoneyJSON(value: unknown, options: { currency?: (code: string) => Currency } = {}): Money {\n  try {\n    const payload = readPayload(value);\n    const resolveCurrency = options.currency ?? resolveBuiltinCurrency;\n\n    return money(BigInt(payload.amount), resolveCurrency(payload.currency), { unit: 'minor' });\n  } catch (error) {\n    throw new CoinsError('INVALID_MONEY', 'Invalid Money JSON', { cause: error });\n  }\n}\n\nfunction readPayload(value: unknown): MoneyJSON {\n  if (typeof value !== 'object' || value === null || Object.getPrototypeOf(value) !== Object.prototype) {\n    throw new TypeError('Money JSON must be a plain object');\n  }\n\n  const descriptors = Object.getOwnPropertyDescriptors(value);\n  const ownKeys = Reflect.ownKeys(value);\n\n  if (ownKeys.length !== KEYS.length || !KEYS.every((key) => ownKeys.includes(key))) {\n    throw new TypeError('Money JSON must contain only amount, currency, and unit');\n  }\n\n  for (const key of KEYS) {\n    const descriptor = descriptors[key];\n\n    if (!descriptor || !('value' in descriptor) || descriptor.get || descriptor.set) {\n      throw new TypeError(`Money JSON property \"${key}\" must be a data value`);\n    }\n  }\n\n  const amount = descriptors.amount!.value;\n  const currency = descriptors.currency!.value;\n  const unit = descriptors.unit!.value;\n\n  if (typeof amount !== 'string' || !INTEGER.test(amount))\n    throw new TypeError('Money JSON amount must be a canonical integer string');\n\n  if (typeof currency !== 'string' || unit !== 'minor') throw new TypeError('Money JSON currency/unit are invalid');\n\n  return { amount, currency, unit };\n}\n"],"mappings":"qFAMA,IAAM,EAAU,6BACV,EAAO,CAAC,SAAU,WAAY,MAAM,EAE1C,SAAgB,EAAO,EAAyB,CAC9C,MAAO,CAAE,OAAQ,EAAM,OAAO,SAAS,EAAG,SAAU,EAAM,SAAS,KAAM,KAAM,OAAQ,CACzF,CAEA,SAAgB,EAAe,EAAgB,EAAqD,CAAC,EAAU,CAC7G,GAAI,CACF,IAAM,EAAU,EAAY,CAAK,EAC3B,EAAkB,EAAQ,UAAY,EAAA,uBAE5C,OAAO,EAAA,MAAM,OAAO,EAAQ,MAAM,EAAG,EAAgB,EAAQ,QAAQ,EAAG,CAAE,KAAM,OAAQ,CAAC,CAC3F,OAAS,EAAO,CACd,MAAM,IAAI,EAAA,WAAW,gBAAiB,qBAAsB,CAAE,MAAO,CAAM,CAAC,CAC9E,CACF,CAEA,SAAS,EAAY,EAA2B,CAC9C,GAAI,OAAO,GAAU,WAAY,GAAkB,OAAO,eAAe,CAAK,IAAM,OAAO,UACzF,MAAU,UAAU,mCAAmC,EAGzD,IAAM,EAAc,OAAO,0BAA0B,CAAK,EACpD,EAAU,QAAQ,QAAQ,CAAK,EAErC,GAAI,EAAQ,SAAW,EAAK,QAAU,CAAC,EAAK,MAAO,GAAQ,EAAQ,SAAS,CAAG,CAAC,EAC9E,MAAU,UAAU,yDAAyD,EAG/E,IAAK,IAAM,KAAO,EAAM,CACtB,IAAM,EAAa,EAAY,GAE/B,GAAI,CAAC,GAAc,EAAE,UAAW,IAAe,EAAW,KAAO,EAAW,IAC1E,MAAU,UAAU,wBAAwB,EAAI,uBAAuB,CAE3E,CAEA,IAAM,EAAS,EAAY,OAAQ,MAC7B,EAAW,EAAY,SAAU,MACjC,EAAO,EAAY,KAAM,MAE/B,GAAI,OAAO,GAAW,UAAY,CAAC,EAAQ,KAAK,CAAM,EACpD,MAAU,UAAU,sDAAsD,EAE5E,GAAI,OAAO,GAAa,UAAY,IAAS,QAAS,MAAU,UAAU,sCAAsC,EAEhH,MAAO,CAAE,SAAQ,WAAU,MAAK,CAClC"}

package/dist/serialization.d.ts

@@ -0,0 +1,6 @@
+import type { Currency, Money, MoneyJSON } from './types';
+export declare function toJSON(value: Money): MoneyJSON;
+export declare function parseMoneyJSON(value: unknown, options?: {
+    currency?: (code: string) => Currency;
+}): Money;
+//# sourceMappingURL=serialization.d.ts.map

package/dist/serialization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialization.d.ts","sourceRoot":"","sources":["../src/serialization.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAS1D,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,CAE9C;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,QAAQ,CAAA;CAAO,GAAG,KAAK,CAS7G"}

package/dist/serialization.js

@@ -0,0 +1,45 @@
+import { CoinsError as e } from "./errors.js";
+import { resolveBuiltinCurrency as t } from "./currency.js";
+import { money as n } from "./money.js";
+//#region src/serialization.ts
+var r = /^(?:0|-[1-9]\d*|[1-9]\d*)$/, i = [
+	"amount",
+	"currency",
+	"unit"
+];
+function a(e) {
+	return {
+		amount: e.amount.toString(),
+		currency: e.currency.code,
+		unit: "minor"
+	};
+}
+function o(r, i = {}) {
+	try {
+		let e = s(r), a = i.currency ?? t;
+		return n(BigInt(e.amount), a(e.currency), { unit: "minor" });
+	} catch (t) {
+		throw new e("INVALID_MONEY", "Invalid Money JSON", { cause: t });
+	}
+}
+function s(e) {
+	if (typeof e != "object" || !e || Object.getPrototypeOf(e) !== Object.prototype) throw TypeError("Money JSON must be a plain object");
+	let t = Object.getOwnPropertyDescriptors(e), n = Reflect.ownKeys(e);
+	if (n.length !== i.length || !i.every((e) => n.includes(e))) throw TypeError("Money JSON must contain only amount, currency, and unit");
+	for (let e of i) {
+		let n = t[e];
+		if (!n || !("value" in n) || n.get || n.set) throw TypeError(`Money JSON property "${e}" must be a data value`);
+	}
+	let a = t.amount.value, o = t.currency.value, s = t.unit.value;
+	if (typeof a != "string" || !r.test(a)) throw TypeError("Money JSON amount must be a canonical integer string");
+	if (typeof o != "string" || s !== "minor") throw TypeError("Money JSON currency/unit are invalid");
+	return {
+		amount: a,
+		currency: o,
+		unit: s
+	};
+}
+//#endregion
+export { o as parseMoneyJSON, a as toJSON };
+
+//# sourceMappingURL=serialization.js.map

package/dist/serialization.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialization.js","names":[],"sources":["../src/serialization.ts"],"sourcesContent":["import type { Currency, Money, MoneyJSON } from './types';\n\nimport { resolveBuiltinCurrency } from './currency';\nimport { CoinsError } from './errors';\nimport { money } from './money';\n\nconst INTEGER = /^(?:0|-[1-9]\\d*|[1-9]\\d*)$/;\nconst KEYS = ['amount', 'currency', 'unit'] as const;\n\nexport function toJSON(value: Money): MoneyJSON {\n  return { amount: value.amount.toString(), currency: value.currency.code, unit: 'minor' };\n}\n\nexport function parseMoneyJSON(value: unknown, options: { currency?: (code: string) => Currency } = {}): Money {\n  try {\n    const payload = readPayload(value);\n    const resolveCurrency = options.currency ?? resolveBuiltinCurrency;\n\n    return money(BigInt(payload.amount), resolveCurrency(payload.currency), { unit: 'minor' });\n  } catch (error) {\n    throw new CoinsError('INVALID_MONEY', 'Invalid Money JSON', { cause: error });\n  }\n}\n\nfunction readPayload(value: unknown): MoneyJSON {\n  if (typeof value !== 'object' || value === null || Object.getPrototypeOf(value) !== Object.prototype) {\n    throw new TypeError('Money JSON must be a plain object');\n  }\n\n  const descriptors = Object.getOwnPropertyDescriptors(value);\n  const ownKeys = Reflect.ownKeys(value);\n\n  if (ownKeys.length !== KEYS.length || !KEYS.every((key) => ownKeys.includes(key))) {\n    throw new TypeError('Money JSON must contain only amount, currency, and unit');\n  }\n\n  for (const key of KEYS) {\n    const descriptor = descriptors[key];\n\n    if (!descriptor || !('value' in descriptor) || descriptor.get || descriptor.set) {\n      throw new TypeError(`Money JSON property \"${key}\" must be a data value`);\n    }\n  }\n\n  const amount = descriptors.amount!.value;\n  const currency = descriptors.currency!.value;\n  const unit = descriptors.unit!.value;\n\n  if (typeof amount !== 'string' || !INTEGER.test(amount))\n    throw new TypeError('Money JSON amount must be a canonical integer string');\n\n  if (typeof currency !== 'string' || unit !== 'minor') throw new TypeError('Money JSON currency/unit are invalid');\n\n  return { amount, currency, unit };\n}\n"],"mappings":";;;;AAMA,IAAM,IAAU,8BACV,IAAO;CAAC;CAAU;CAAY;AAAM;AAE1C,SAAgB,EAAO,GAAyB;CAC9C,OAAO;EAAE,QAAQ,EAAM,OAAO,SAAS;EAAG,UAAU,EAAM,SAAS;EAAM,MAAM;CAAQ;AACzF;AAEA,SAAgB,EAAe,GAAgB,IAAqD,CAAC,GAAU;CAC7G,IAAI;EACF,IAAM,IAAU,EAAY,CAAK,GAC3B,IAAkB,EAAQ,YAAY;EAE5C,OAAO,EAAM,OAAO,EAAQ,MAAM,GAAG,EAAgB,EAAQ,QAAQ,GAAG,EAAE,MAAM,QAAQ,CAAC;CAC3F,SAAS,GAAO;EACd,MAAM,IAAI,EAAW,iBAAiB,sBAAsB,EAAE,OAAO,EAAM,CAAC;CAC9E;AACF;AAEA,SAAS,EAAY,GAA2B;CAC9C,IAAI,OAAO,KAAU,aAAY,KAAkB,OAAO,eAAe,CAAK,MAAM,OAAO,WACzF,MAAU,UAAU,mCAAmC;CAGzD,IAAM,IAAc,OAAO,0BAA0B,CAAK,GACpD,IAAU,QAAQ,QAAQ,CAAK;CAErC,IAAI,EAAQ,WAAW,EAAK,UAAU,CAAC,EAAK,OAAO,MAAQ,EAAQ,SAAS,CAAG,CAAC,GAC9E,MAAU,UAAU,yDAAyD;CAG/E,KAAK,IAAM,KAAO,GAAM;EACtB,IAAM,IAAa,EAAY;EAE/B,IAAI,CAAC,KAAc,EAAE,WAAW,MAAe,EAAW,OAAO,EAAW,KAC1E,MAAU,UAAU,wBAAwB,EAAI,uBAAuB;CAE3E;CAEA,IAAM,IAAS,EAAY,OAAQ,OAC7B,IAAW,EAAY,SAAU,OACjC,IAAO,EAAY,KAAM;CAE/B,IAAI,OAAO,KAAW,YAAY,CAAC,EAAQ,KAAK,CAAM,GACpD,MAAU,UAAU,sDAAsD;CAE5E,IAAI,OAAO,KAAa,YAAY,MAAS,SAAS,MAAU,UAAU,sCAAsC;CAEhH,OAAO;EAAE;EAAQ;EAAU;CAAK;AAClC"}

package/dist/types.d.ts

@@ -1,60 +1,43 @@
-/**
- * A validated ISO 4217 currency code string (e.g. `'USD'`, `'EUR'`, `'JPY'`).
- * Plain string alias — runtime validation is performed by every function that
- * accepts a currency, and violations throw `InvalidCurrencyError`.
- */
-export type CurrencyCode = string;
-/** A monetary value. `amount` is stored as bigint minor units (e.g. cents for USD). */
-export type Money = {
-    readonly amount: bigint;
-    readonly currency: CurrencyCode;
+declare const currencyBrand: unique symbol;
+declare const decimalBrand: unique symbol;
+declare const moneyBrand: unique symbol;
+export type CurrencyCode<C extends string = string> = C & {
+    readonly [currencyBrand]: C;
 };
-/**
- * An exchange rate between two currencies.
- * - `from` must match the `currency` of the `Money` passed to `exchange()`.
- *   Since every `Money.currency` is already a validated ISO 4217 code, a matching
- *   `from` is implicitly valid.
- * - `to` is validated as a recognised ISO 4217 code by `exchange()` before returning.
- * - `rate` is a decimal string (e.g. `'0.847532'`) or number, for symmetry with
- *   `multiply()`/`divide()`. Prefer a string when precision matters — a number is
- *   converted via `String()` first and inherits IEEE-754 limits.
- */
-export type ExchangeRate = {
-    readonly from: CurrencyCode;
-    readonly rate: number | string;
-    readonly to: CurrencyCode;
-};
-/** Options for `format()`. */
-export type FormatOptions = {
+export type Currency<C extends string = string> = Readonly<{
+    code: CurrencyCode<C>;
+    minorUnit: number;
+}>;
+export type Decimal = Readonly<{
+    readonly [decimalBrand]: true;
+    denominator: bigint;
+    numerator: bigint;
+}>;
+export type Money<C extends Currency = Currency> = Readonly<{
+    amount: bigint;
+    currency: C;
+    readonly [moneyBrand]: C;
+}>;
+export type ExchangeRate<From extends Currency = Currency, To extends Currency = Currency> = Readonly<{
+    from: From;
+    to: To;
+    value: Decimal;
+}>;
+export type FormatOptions = Readonly<{
     locale?: string;
     maximumFractionDigits?: number;
     minimumFractionDigits?: number;
     style?: 'code' | 'name' | 'narrowSymbol' | 'symbol';
-};
-/**
- * Rounding mode for operations that produce fractional minor units.
- *
- * | Mode | Description |
- * |---|---|
- * | `'ceiling'` | Toward +∞ (up for positives, truncate for negatives) |
- * | `'down'` | Toward zero (truncate, regardless of sign) |
- * | `'floor'` | Toward −∞ (truncate for positives, down for negatives) |
- * | `'half-away-from-zero'` | Round half away from zero (default, common in finance) |
- * | `'half-even'` | Round half to even (banker's rounding, minimises cumulative error) |
- * | `'up'` | Away from zero (regardless of sign) |
- */
-export type RoundingMode = 'ceiling' | 'down' | 'floor' | 'half-away-from-zero' | 'half-even' | 'up';
-/** JSON-safe representation of `Money`. `amount` is a decimal integer string to avoid bigint serialization issues. */
-export type MoneyJSON = {
+}>;
+export type MoneyFormatPart = Readonly<{
+    type: 'currency' | 'decimal' | 'fraction' | 'integer' | 'literal' | 'minusSign' | 'plusSign';
+    value: string;
+}>;
+export type MoneyJSON = Readonly<{
     amount: string;
     currency: string;
-};
-/**
- * A single semantic part of a formatted money string, as returned by `formatParts()`.
- * Useful for custom rendering (e.g. applying different CSS to symbol, integer, fraction).
- */
-export type MoneyFormatPart = {
-    type: 'currency' | 'decimal' | 'fraction' | 'integer' | 'literal' | 'minusSign';
-    value: string;
-};
+    unit: 'minor';
+}>;
+export type RoundingMode = 'awayFromZero' | 'ceil' | 'floor' | 'halfAwayFromZero' | 'halfEven' | 'towardZero';
+export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC;AAElC,uFAAuF;AACvF,MAAM,MAAM,KAAK,GAAG;IAClB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;CACjC,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAC/B,QAAQ,CAAC,EAAE,EAAE,YAAY,CAAC;CAC3B,CAAC;AAEF,8BAA8B;AAC9B,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,cAAc,GAAG,QAAQ,CAAC;CACrD,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,qBAAqB,GAAG,WAAW,GAAG,IAAI,CAAC;AAErG,sHAAsH;AACtH,MAAM,MAAM,SAAS,GAAG;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,UAAU,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,CAAC;IAChF,KAAK,EAAE,MAAM,CAAC;CACf,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,aAAa,EAAE,OAAO,MAAM,CAAC;AAC3C,OAAO,CAAC,MAAM,YAAY,EAAE,OAAO,MAAM,CAAC;AAC1C,OAAO,CAAC,MAAM,UAAU,EAAE,OAAO,MAAM,CAAC;AAExC,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG;IAAE,QAAQ,CAAC,CAAC,aAAa,CAAC,EAAE,CAAC,CAAA;CAAE,CAAC;AAE1F,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI,QAAQ,CAAC;IACzD,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,QAAQ,CAAC;IAC7B,QAAQ,CAAC,CAAC,YAAY,CAAC,EAAE,IAAI,CAAC;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC,CAAC;AAEH,MAAM,MAAM,KAAK,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ,IAAI,QAAQ,CAAC;IAC1D,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,CAAC,CAAC;IACZ,QAAQ,CAAC,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;CAC1B,CAAC,CAAC;AAEH,MAAM,MAAM,YAAY,CAAC,IAAI,SAAS,QAAQ,GAAG,QAAQ,EAAE,EAAE,SAAS,QAAQ,GAAG,QAAQ,IAAI,QAAQ,CAAC;IACpG,IAAI,EAAE,IAAI,CAAC;IACX,EAAE,EAAE,EAAE,CAAC;IACP,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC;IACnC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,cAAc,GAAG,QAAQ,CAAC;CACrD,CAAC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC,IAAI,EAAE,UAAU,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,UAAU,CAAC;IAC7F,KAAK,EAAE,MAAM,CAAC;CACf,CAAC,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,QAAQ,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,OAAO,CAAC;CACf,CAAC,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,cAAc,GAAG,MAAM,GAAG,OAAO,GAAG,kBAAkB,GAAG,UAAU,GAAG,YAAY,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vielzeug/coins",
-  "version": "1.0.4",
+  "version": "2.0.0",
   "description": "Bigint-based monetary arithmetic with currency formatting, exchange rates, and rounding policies",
   "type": "module",
   "files": [
@@ -34,9 +34,9 @@
     "node": ">=22"
   },
   "devDependencies": {
-    "@types/node": "^26.1.0",
+    "@types/node": "^26.1.2",
     "typescript": "^6.0.3",
-    "vite": "^8.1.3",
+    "vite": "^8.2.0",
     "vitest": "^4.1.10"
   }
 }

package/dist/_cache.cjs

@@ -1,2 +0,0 @@
-function e(e){let t=new Map;return{get:e=>t.get(e),set(n,r){t.size>=e&&t.delete(t.keys().next().value),t.set(n,r)}}}exports.boundedCache=e;
-//# sourceMappingURL=_cache.cjs.map

package/dist/_cache.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"_cache.cjs","names":[],"sources":["../src/_cache.ts"],"sourcesContent":["/** A FIFO bounded Map cache that evicts the oldest entry when full. */\nexport function boundedCache<K, V>(maxSize: number): { get(k: K): V | undefined; set(k: K, v: V): void } {\n  const map = new Map<K, V>();\n\n  return {\n    get: (k) => map.get(k),\n    set(k, v) {\n      if (map.size >= maxSize) map.delete(map.keys().next().value as K);\n\n      map.set(k, v);\n    },\n  };\n}\n"],"mappings":"AACA,SAAgB,EAAmB,EAAsE,CACvG,IAAM,EAAM,IAAI,IAEhB,MAAO,CACL,IAAM,GAAM,EAAI,IAAI,CAAC,EACrB,IAAI,EAAG,EAAG,CACJ,EAAI,MAAQ,GAAS,EAAI,OAAO,EAAI,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,KAAU,EAEhE,EAAI,IAAI,EAAG,CAAC,CACd,CACF,CACF"}

package/dist/_cache.d.ts

@@ -1,6 +0,0 @@
-/** A FIFO bounded Map cache that evicts the oldest entry when full. */
-export declare function boundedCache<K, V>(maxSize: number): {
-    get(k: K): V | undefined;
-    set(k: K, v: V): void;
-};
-//# sourceMappingURL=_cache.d.ts.map

package/dist/_cache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_cache.d.ts","sourceRoot":"","sources":["../src/_cache.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG;IAAE,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,IAAI,CAAA;CAAE,CAWvG"}

package/dist/_cache.js

@@ -1,14 +0,0 @@
-//#region src/_cache.ts
-function e(e) {
-	let t = /* @__PURE__ */ new Map();
-	return {
-		get: (e) => t.get(e),
-		set(n, r) {
-			t.size >= e && t.delete(t.keys().next().value), t.set(n, r);
-		}
-	};
-}
-//#endregion
-export { e as boundedCache };
-
-//# sourceMappingURL=_cache.js.map