@vielzeug/coins 1.0.4 → 2.0.0

package/dist/money.cjs

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

package/dist/money.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"money.cjs","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.cjs","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/money.d.ts

@@ -1,247 +1,28 @@
-import type { CurrencyCode, Money, MoneyJSON, RoundingMode } from './types';
-export { CoinsError, CurrencyMismatchError, InvalidCurrencyError } from './errors';
-/**
- * Creates a `Money` value from a decimal string, number, or raw bigint minor units.
- * Validates the currency code — throws `InvalidCurrencyError` for unrecognised ISO 4217 codes.
- *
- * - **string** `'1234.56'` → parsed losslessly; respects the currency's decimal places.
- * - **number** `1234.56` → converted via `String()` first; inherits IEEE-754 limits.
- *   Prefer strings when precision matters.
- * - **bigint** `123456n` → used as-is (already in minor units).
- *
- * @example
- * ```ts
- * money('1234.56', 'USD') // { amount: 123456n, currency: 'USD' }
- * money(1234,      'JPY') // { amount: 1234n,   currency: 'JPY' }
- * money(123456n,   'USD') // { amount: 123456n, currency: 'USD' }
- * ```
- */
-export declare function money(amount: bigint | number | string, currency: CurrencyCode): Money;
-/**
- * Creates a new `Money` value with the given `amount` and the same currency as `m`.
- * Useful when you compute a raw `bigint` amount externally and need to wrap it
- * back into a `Money` value without re-validating the currency.
- *
- * @example
- * ```ts
- * const price = money('9.99', 'USD');
- * withAmount(price, 1999n)  // { amount: 1999n, currency: 'USD' }
- * ```
- */
-export declare function withAmount(m: Money, amount: bigint): Money;
-/**
- * Type guard that returns `true` if `value` is a `Money`-shaped object
- * (has a `bigint` `amount` and a `string` `currency`).
- * Useful for narrowing unknown payloads from APIs or deserialized storage.
- *
- * Note: does **not** validate the currency code — use `money(0n, currency)` or
- * `validateCurrencyCode()` if you also need to confirm it is a recognized ISO 4217 code.
- *
- * @example
- * ```ts
- * isMoney({ amount: 100n, currency: 'USD' })  // true
- * isMoney({ amount: 1.5, currency: 'USD' })   // false
- * isMoney(null)                               // false
- * ```
- */
+import type { Currency, Money, RoundingMode } from './types';
+export declare function money<C extends Currency>(amount: string, currency: C): Money<C>;
+export declare function money<C extends Currency>(amount: string, currency: C, options: {
+    rounding: RoundingMode;
+}): Money<C>;
+export declare function money<C extends Currency>(amount: bigint, currency: C, options: {
+    unit: 'minor';
+}): Money<C>;
+export declare function parseMoney(value: unknown): Money;
 export declare function isMoney(value: unknown): value is Money;
-/** Adds two `Money` values. Throws if their currencies differ. */
-export declare function add(a: Money, b: Money): Money;
-/** Subtracts `b` from `a`. Throws if their currencies differ. */
-export declare function subtract(a: Money, b: Money): Money;
-/**
- * Multiplies a `Money` value by a scalar factor.
- * The factor can be a decimal string (lossless) or a number.
- *
- * @param mode Rounding mode for fractional minor units. Defaults to `'half-away-from-zero'`.
- *
- * @example
- * ```ts
- * multiply(money('100.00', 'USD'), '1.5')              // $150.00
- * multiply(money('1.00', 'USD'), '0.339', 'floor')     // $0.33
- * multiply(money('1.00', 'USD'), '0.339', 'ceiling')   // $0.34
- * ```
- */
-export declare function multiply(m: Money, factor: number | string, mode?: RoundingMode): Money;
-/**
- * Divides a `Money` value by a scalar divisor.
- * The divisor can be a decimal string (lossless) or a number.
- *
- * @param mode Rounding mode for fractional minor units. Defaults to `'half-away-from-zero'`.
- * @throws {CoinsError} On division by zero.
- *
- * @example
- * ```ts
- * divide(money('100.00', 'USD'), 3)              // $33.33
- * divide(money('100.00', 'USD'), 3, 'ceiling')   // $33.34
- * ```
- */
-export declare function divide(m: Money, divisor: number | string, mode?: RoundingMode): Money;
-/**
- * Distributes `money` across `ratios` without losing or gaining a single minor unit.
- * Accepts both number and string ratios — use strings for lossless decimal weights.
- *
- * Uses the Largest Remainder Method: each share gets its floor allocation first,
- * then any remainder units are assigned one-by-one to the shares with the largest
- * fractional parts, breaking ties by original index (stable, left-to-right).
- *
- * Throws if `ratios` is empty, contains negative values (including negative strings like `'-0.5'`), or sums to zero.
- *
- * @example
- * ```ts
- * allocate(money('10.00', 'USD'), [1, 1, 1])
- * // → [$3.34, $3.33, $3.33]   (not three × $3.33 — that loses a penny)
- *
- * allocate(money('10.00', 'USD'), ['0.3', '0.7'])
- * // → [$3.00, $7.00]
- * ```
- */
-export declare function allocate(m: Money, ratios: readonly (number | string)[]): [Money, ...Money[]];
-/**
- * Sums an array of `Money` values. Throws if the array is empty or currencies differ.
- *
- * @example
- * ```ts
- * sum([money('1.00', 'USD'), money('2.50', 'USD')]) // $3.50
- * ```
- */
-export declare function sum(moneys: readonly Money[]): Money;
-/**
- * Returns the smallest `Money` value from a non-empty array. Throws if currencies differ.
- *
- * @example
- * ```ts
- * min([money('3.00', 'USD'), money('1.00', 'USD'), money('2.00', 'USD')]) // $1.00
- * ```
- */
-export declare function min(moneys: readonly Money[]): Money;
-/**
- * Returns the largest `Money` value from a non-empty array. Throws if currencies differ.
- *
- * @example
- * ```ts
- * max([money('1.00', 'USD'), money('3.00', 'USD'), money('2.00', 'USD')]) // $3.00
- * ```
- */
-export declare function max(moneys: readonly Money[]): Money;
-/**
- * Splits `money` into `parts` equal shares without losing or gaining a single minor unit.
- * Equivalent to `allocate(money, Array.from({ length: parts }, () => 1))`.
- *
- * @throws {CoinsError} If `parts` is not a positive integer (≥ 1).
- *
- * @example
- * ```ts
- * splitEvenly(money('10.00', 'USD'), 3)
- * // → [$3.34, $3.33, $3.33]
- * ```
- */
-export declare function splitEvenly(m: Money, parts: number): [Money, ...Money[]];
-/**
- * Clamps `m` to the inclusive range `[lower, upper]`.
- *
- * @throws {CurrencyMismatchError} If `m`, `lower`, or `upper` have different currencies.
- * @throws {CoinsError}            If `lower > upper`.
- *
- * @example
- * ```ts
- * clamp(money('5.00', 'USD'), money('1.00', 'USD'), money('10.00', 'USD'))  // $5.00
- * clamp(money('0.00', 'USD'), money('1.00', 'USD'), money('10.00', 'USD'))  // $1.00
- * clamp(money('15.00', 'USD'), money('1.00', 'USD'), money('10.00', 'USD')) // $10.00
- * ```
- */
-export declare function clamp(m: Money, lower: Money, upper: Money): Money;
-/** Returns the absolute value of `money`. Negative amounts become positive. */
-export declare function abs(m: Money): Money;
-/** Returns `money` with its sign flipped. */
-export declare function negate(m: Money): Money;
-/**
- * Compares two `Money` values. Returns `-1`, `0`, or `1`.
- * Throws if their currencies differ.
- */
-export declare function compare(a: Money, b: Money): -1 | 0 | 1;
-/**
- * Returns `true` if both `Money` values have the same currency and amount.
- * Returns `false` if currencies differ — safe to use in `.filter()` and conditional chains.
- */
-export declare function isEqual(a: Money, b: Money): boolean;
-/** Returns `true` if `a` is strictly greater than `b`. Throws on currency mismatch. */
-export declare function greaterThan(a: Money, b: Money): boolean;
-/** Returns `true` if `a` is greater than or equal to `b`. Throws on currency mismatch. */
-export declare function greaterThanOrEqual(a: Money, b: Money): boolean;
-/** Returns `true` if `a` is strictly less than `b`. Throws on currency mismatch. */
-export declare function lessThan(a: Money, b: Money): boolean;
-/** Returns `true` if `a` is less than or equal to `b`. Throws on currency mismatch. */
-export declare function lessThanOrEqual(a: Money, b: Money): boolean;
-/** Returns `true` if the amount is exactly zero. */
-export declare function isZero(m: Money): boolean;
-/** Returns `true` if the amount is strictly positive (> 0). */
-export declare function isPositive(m: Money): boolean;
-/** Returns `true` if the amount is strictly negative (< 0). */
-export declare function isNegative(m: Money): boolean;
-/** Returns `true` if the amount is zero or positive (>= 0). */
-export declare function isNonNegative(m: Money): boolean;
-/** Returns `true` if the amount is zero or negative (<= 0). */
-export declare function isNonPositive(m: Money): boolean;
-/**
- * Serializes a `Money` value to a plain-object JSON-safe form.
- * `amount` is a bigint string (e.g. `'123456'`) to avoid `JSON.stringify` throwing.
- *
- * @example
- * ```ts
- * toJSON(money('1234.56', 'USD')) // { amount: '123456', currency: 'USD' }
- * JSON.stringify(toJSON(price))   // '{"amount":"123456","currency":"USD"}'
- * ```
- */
-export declare function toJSON(m: Money): MoneyJSON;
-/**
- * Deserializes a `MoneyJSON` object back into a `Money` value.
- * Validates the currency code and the amount string.
- *
- * @example
- * ```ts
- * fromJSON({ amount: '123456', currency: 'USD' }) // { amount: 123456n, currency: 'USD' }
- * ```
- */
-export declare function fromJSON(json: MoneyJSON): Money;
-/**
- * Serializes a `Money` value to a decimal string (e.g. `'1234.56'`).
- * Round-trips losslessly with `money()`.
- *
- * @example
- * ```ts
- * toDecimal(money('1234.56', 'USD')) // '1234.56'
- * toDecimal(money(5n, 'USD'))        // '0.05'
- * toDecimal(money(1234n, 'JPY'))     // '1234'
- * ```
- */
-export declare function toDecimal(m: Money): string;
-/**
- * Converts a `Money` value to a floating-point number.
- * Useful for charting and display; **not** for arithmetic (lossy).
- *
- * @example
- * ```ts
- * toNumber(money('1234.56', 'USD')) // 1234.56
- * ```
- */
-export declare function toNumber(m: Money): number;
-/**
- * Rounds a `Money` value to fewer decimal places than the currency's default.
- * `places` must be a non-negative integer in the range `0..currencyDecimals`.
- *
- * Useful for display purposes (e.g. rounding USD to whole dollars).
- * @throws {CoinsError} If `places` is out of the allowed range.
- *
- * @param mode Rounding mode. Defaults to `'half-away-from-zero'`.
- *
- * @example
- * ```ts
- * roundTo(money('1234.56', 'USD'), 0)          // $1235   (whole dollars)
- * roundTo(money('1234.56', 'USD'), 1)          // $1234.6
- * roundTo(money('1234.56', 'USD'), 1, 'floor') // $1234.5
- * roundTo(money('1234', 'JPY'), 0)             // ¥1234   (no-op: JPY is already 0-decimal)
- * ```
- */
-export declare function roundTo(m: Money, places: number, mode?: RoundingMode): Money;
+export declare function add<C extends Currency>(left: Money<C>, right: Money<NoInfer<C>>): Money<C>;
+export declare function subtract<C extends Currency>(left: Money<C>, right: Money<NoInfer<C>>): Money<C>;
+export declare function multiply<C extends Currency>(value: Money<C>, factor: string, options?: {
+    rounding?: RoundingMode;
+}): Money<C>;
+export declare function divide<C extends Currency>(value: Money<C>, divisor: string, options?: {
+    rounding?: RoundingMode;
+}): Money<C>;
+export declare function compare<C extends Currency>(left: Money<C>, right: Money<NoInfer<C>>): -1 | 0 | 1;
+export declare function abs<C extends Currency>(value: Money<C>): Money<C>;
+export declare function negate<C extends Currency>(value: Money<C>): Money<C>;
+export declare function round<C extends Currency>(value: Money<C>, options: {
+    fractionDigits: number;
+    rounding?: RoundingMode;
+}): Money<C>;
+export declare function toDecimal(value: Money): string;
+export declare function withMinor<C extends Currency>(amount: bigint, currency: C): Money<C>;
 //# sourceMappingURL=money.d.ts.map

package/dist/money.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"money.d.ts","sourceRoot":"","sources":["../src/money.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"money.d.ts","sourceRoot":"","sources":["../src/money.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAQ7D,wBAAgB,KAAK,CAAC,CAAC,SAAS,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AACjF,wBAAgB,KAAK,CAAC,CAAC,SAAS,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,EAAE,OAAO,EAAE;IAAE,QAAQ,EAAE,YAAY,CAAA;CAAE,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AACtH,wBAAgB,KAAK,CAAC,CAAC,SAAS,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,EAAE,OAAO,EAAE;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AA8B7G,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAgBhD;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,KAAK,CAQtD;AAED,wBAAgB,GAAG,CAAC,CAAC,SAAS,QAAQ,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAI1F;AAED,wBAAgB,QAAQ,CAAC,CAAC,SAAS,QAAQ,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAI/F;AAED,wBAAgB,QAAQ,CAAC,CAAC,SAAS,QAAQ,EACzC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EACf,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,YAAY,CAAA;CAAO,GACxC,KAAK,CAAC,CAAC,CAAC,CASV;AAED,wBAAgB,MAAM,CAAC,CAAC,SAAS,QAAQ,EACvC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EACf,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,YAAY,CAAA;CAAO,GACxC,KAAK,CAAC,CAAC,CAAC,CAeV;AAED,wBAAgB,OAAO,CAAC,CAAC,SAAS,QAAQ,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAIhG;AAED,wBAAgB,GAAG,CAAC,CAAC,SAAS,QAAQ,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAIjE;AAED,wBAAgB,MAAM,CAAC,CAAC,SAAS,QAAQ,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAIpE;AAED,wBAAgB,KAAK,CAAC,CAAC,SAAS,QAAQ,EACtC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EACf,OAAO,EAAE;IAAE,cAAc,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,YAAY,CAAA;CAAE,GAC3D,KAAK,CAAC,CAAC,CAAC,CAYV;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAI9C;AAED,wBAAgB,SAAS,CAAC,CAAC,SAAS,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAInF"}