@vielzeug/coins 1.0.3

package/README.md

@@ -0,0 +1,262 @@
+# @vielzeug/coins
+
+> Zero-dependency TypeScript utilities for precise monetary arithmetic
+
+Bigint-based money creation, arithmetic, allocation, formatting, exchange rate conversion, and serialization — with no floating-point rounding errors.
+
+## Why Coins?
+
+Float arithmetic silently loses precision:
+
+```ts
+// number (float)
+10.1 + 10.2; // 20.299999999999997
+
+// @vielzeug/coins (bigint)
+import { add, money } from '@vielzeug/coins';
+add(money('10.10', 'USD'), money('10.20', 'USD')); // { amount: 2030n, currency: 'USD' }  — exact
+```
+
+Coins stores every value as bigint **minor units** (cents for USD, whole units for JPY, fils for KWD), so arithmetic and allocation are always lossless.
+
+## Installation
+
+```sh
+pnpm add @vielzeug/coins
+```
+
+## Quick Start
+
+```ts
+import { add, allocate, exchange, format, money, multiply } from '@vielzeug/coins';
+import type { ExchangeRate, Money } from '@vielzeug/coins';
+
+// Create money from a decimal string (lossless) or bigint minor units
+const price: Money = money('19.99', 'USD'); // { amount: 1999n, currency: 'USD' }
+const tax: Money = money('1.60', 'USD');
+const total: Money = add(price, tax); // { amount: 3559n, currency: 'USD' }
+
+// Arithmetic with explicit rounding mode
+multiply(total, '1.1'); // $39.15  (half-away-from-zero, default)
+multiply(total, '1.1', 'floor'); // $39.14  (explicit mode)
+
+// Lossless allocation — no minor unit is ever lost or gained
+allocate(money('10.00', 'USD'), [1, 1, 1]); // [$3.34, $3.33, $3.33]
+
+// Locale-aware formatting
+format(total); // '$35.59'
+format(total, { locale: 'de-DE' }); // '35,59 $'
+format(total, { style: 'code' }); // 'USD 35.59'
+
+// Currency exchange — ExchangeRate.from/to are plain strings; rate is a decimal string or number
+const rate: ExchangeRate = { from: 'USD', rate: '0.92', to: 'EUR' };
+exchange(total, rate); // { amount: 3274n, currency: 'EUR' }
+```
+
+## API
+
+### `money(amount, currency)`
+
+Creates a `Money` value. Validates the currency code against `Intl.NumberFormat`; throws `InvalidCurrencyError` for unrecognised ISO 4217 codes.
+
+| `amount` type        | Behaviour                                                              |
+| -------------------- | ---------------------------------------------------------------------- |
+| `string` `'1234.56'` | Parsed losslessly; excess digits rounded half-away-from-zero           |
+| `number` `1234.56`   | Converted via `String()` first — IEEE-754 limits apply; prefer strings |
+| `bigint` `123456n`   | Used as-is (already in minor units)                                    |
+
+```ts
+money('1234.56', 'USD'); // { amount: 123456n, currency: 'USD' }
+money(0n, 'USD'); // { amount: 0n, currency: 'USD' }  — zero accumulator
+money('1.00', 'FAKE'); // throws InvalidCurrencyError
+```
+
+### Arithmetic
+
+All binary functions (`add`, `subtract`) throw `CurrencyMismatchError` on currency mismatch.
+
+```ts
+add(a, b); // → Money
+subtract(a, b); // → Money
+multiply(money, factor, mode?); // → Money  (factor: number | string)
+divide(money, divisor, mode?); // → Money  (throws RangeError on division by zero)
+abs(money); // → Money  (absolute value)
+negate(money); // → Money  (sign flip)
+```
+
+### Allocation
+
+Uses the **Largest Remainder Method** — every output sums exactly to the input, no minor unit is ever lost or gained.
+
+```ts
+allocate(money, ratios); // → [Money, ...Money[]]  (weighted; use strings for lossless decimal ratios)
+splitEvenly(money, parts); // → [Money, ...Money[]]  (equal shares; sugar over allocate)
+```
+
+Both throw `RangeError` on empty ratios, negative ratios, or non-positive parts.
+
+### Aggregates
+
+```ts
+sum(moneys); // → Money  (throws RangeError if empty; CurrencyMismatchError on mismatch)
+min(moneys); // → Money  (non-empty array; CurrencyMismatchError on mismatch)
+max(moneys); // → Money  (non-empty array; CurrencyMismatchError on mismatch)
+clamp(m, lower, upper); // → Money  (CurrencyMismatchError on mismatch; RangeError if lower > upper)
+```
+
+### Comparison
+
+`isEqual` returns `false` on currency mismatch (safe for `.filter()`). All other comparison functions throw `CurrencyMismatchError` on mismatch.
+
+```ts
+compare(a, b); // → -1 | 0 | 1
+isEqual(a, b); // → boolean  (false on currency mismatch — no throw)
+greaterThan(a, b); // → boolean
+greaterThanOrEqual(a, b); // → boolean
+lessThan(a, b); // → boolean
+lessThanOrEqual(a, b); // → boolean
+isZero(m); // → boolean
+isPositive(m); // → boolean
+isNegative(m); // → boolean
+isNonNegative(m); // → boolean  (>= 0)
+isNonPositive(m); // → boolean  (<= 0)
+```
+
+### Serialization
+
+```ts
+toDecimal(money); // → string   e.g. '1234.56'  (round-trips losslessly with money())
+toNumber(money); // → number   e.g. 1234.56    (lossy — display/charting only)
+toJSON(money); // → MoneyJSON  { amount: '123456', currency: 'USD' }
+fromJSON(json); // → Money     (validates currency; throws on invalid input)
+```
+
+`bigint` cannot be serialized by `JSON.stringify`. Use `JSON.stringify(toJSON(price))` and `fromJSON(JSON.parse(raw))`.
+
+### `roundTo(money, places, mode?)`
+
+Rounds a `Money` value to fewer decimal places than the currency default — useful for display (whole dollars, chart axes). `places` must be in `0..currencyDecimals`.
+
+```ts
+roundTo(money('1234.56', 'USD'), 0); // { amount: 1235n, currency: 'USD' }  ($1,235)
+roundTo(money('1234.56', 'USD'), 1, 'floor'); // { amount: 12345n, currency: 'USD' } ($1,234.5)
+```
+
+### `format(money, options?)`
+
+Formats a `Money` value as a locale-aware currency string. Uses bigint arithmetic throughout — no floating-point precision loss.
+
+| Option                  | Type                                              | Default          | Description                  |
+| ----------------------- | ------------------------------------------------- | ---------------- | ---------------------------- |
+| `locale`                | `string`                                          | `'en-US'`        | BCP 47 language tag          |
+| `style`                 | `'symbol' \| 'code' \| 'name' \| 'narrowSymbol'` | `'symbol'`       | Display style                |
+| `minimumFractionDigits` | `number`                                          | currency default | Minimum decimal places shown |
+| `maximumFractionDigits` | `number`                                          | currency default | Maximum decimal places shown |
+
+```ts
+format(money('1234.56', 'USD')); // '$1,234.56'
+format(money('1234.56', 'USD'), { locale: 'de-DE' }); // '1.234,56 $'
+format(money('1234.56', 'USD'), { style: 'code' }); // 'USD 1,234.56'
+```
+
+### `formatParts(money, options?)`
+
+Same options as `format()`. Returns a `MoneyFormatPart[]` array of semantic segments — useful for applying separate styles to symbol, integer, decimal, and fraction parts.
+
+Joining all `value` fields produces the same string as `format()`.
+
+### `exchange(money, rate, mode?)`
+
+Converts a `Money` value using an `ExchangeRate`. `ExchangeRate.from` and `.to` are plain strings; `rate.rate` is a decimal string or number (`number | string`, for symmetry with `multiply()`/`divide()` — prefer a string for lossless bigint arithmetic). Throws `CurrencyMismatchError` if `money.currency !== rate.from`.
+
+```ts
+import type { ExchangeRate } from '@vielzeug/coins';
+
+const rate: ExchangeRate = { from: 'USD', rate: '0.92', to: 'EUR' };
+exchange(money('100.00', 'USD'), rate); // { amount: 9200n, currency: 'EUR' }
+exchange(money('100.00', 'USD'), rate, 'floor'); // explicit rounding mode
+```
+
+### Typed Errors
+
+```ts
+import { CurrencyMismatchError, InvalidCurrencyError } from '@vielzeug/coins';
+
+try {
+  add(money('1.00', 'USD'), money('1.00', 'EUR'));
+} catch (e) {
+  if (e instanceof CurrencyMismatchError) {
+    console.log(e.expected, e.received); // 'USD' 'EUR'
+  }
+}
+
+try {
+  money('1.00', 'FAKE');
+} catch (e) {
+  if (e instanceof InvalidCurrencyError) {
+    console.log(e.code); // 'FAKE'
+  }
+}
+```
+
+- `CurrencyMismatchError` extends `TypeError` — existing `instanceof TypeError` catch blocks still work.
+- `InvalidCurrencyError` extends `RangeError` — existing `instanceof RangeError` catch blocks still work.
+
+### Rounding Modes
+
+Used by `multiply`, `divide`, `exchange`, and `roundTo`.
+
+| Mode                    | Description                                    |
+| ----------------------- | ---------------------------------------------- |
+| `'half-away-from-zero'` | Round half away from zero **(default)**        |
+| `'half-even'`           | Banker's rounding — minimises cumulative error |
+| `'down'`                | Truncate toward zero                           |
+| `'up'`                  | Away from zero                                 |
+| `'floor'`               | Toward −∞                                      |
+| `'ceiling'`             | Toward +∞                                      |
+
+### Key Types
+
+```ts
+type Money = {
+  readonly amount: bigint; // minor units (cents for USD, whole units for JPY)
+  readonly currency: string; // validated ISO 4217 code
+};
+
+type ExchangeRate = {
+  readonly from: string; // source currency code
+  readonly rate: number | string; // decimal multiplier, e.g. '0.92' or 0.92
+  readonly to: string; // target currency code
+};
+
+type RoundingMode = 'ceiling' | 'down' | 'floor' | 'half-away-from-zero' | 'half-even' | 'up';
+
+type FormatOptions = {
+  locale?: string;
+  maximumFractionDigits?: number;
+  minimumFractionDigits?: number;
+  style?: 'code' | 'name' | 'narrowSymbol' | 'symbol';
+};
+
+type MoneyFormatPart = {
+  type: 'currency' | 'decimal' | 'fraction' | 'integer' | 'literal' | 'minusSign';
+  value: string;
+};
+
+type MoneyJSON = { amount: string; currency: string };
+```
+
+## Documentation
+
+- **[Full Guide](https://vielzeug.dev/coins/)** — Overview, concepts, quick start
+- **[Usage Guide](https://vielzeug.dev/coins/usage/)** — Common patterns and best practices
+- **[API Reference](https://vielzeug.dev/coins/api/)** — All types and function signatures
+- **[Examples](https://vielzeug.dev/coins/examples/)** — Real-world integration examples
+
+## TypeScript
+
+Requires TypeScript 5.0+ with `strict: true`.
+
+## License
+
+MIT

package/dist/_cache.cjs

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,6 @@
+/** 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,14 @@
+//#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

package/dist/_cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_cache.js","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,GAAsE;CACvG,IAAM,oBAAM,IAAI,IAAU;CAE1B,OAAO;EACL,MAAM,MAAM,EAAI,IAAI,CAAC;EACrB,IAAI,GAAG,GAAG;GAGR,AAFI,EAAI,QAAQ,KAAS,EAAI,OAAO,EAAI,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,KAAU,GAEhE,EAAI,IAAI,GAAG,CAAC;EACd;CACF;AACF"}

package/dist/_dev.cjs

@@ -0,0 +1,2 @@
+var e=!globalThis.__COINS_PROD__;function t(t){e&&console.warn(`[@vielzeug/coins] ${t}`)}exports.warn=t;
+//# sourceMappingURL=_dev.cjs.map

package/dist/_dev.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dev.cjs","names":[],"sources":["../src/_dev.ts"],"sourcesContent":["const isDev = !(globalThis as { __COINS_PROD__?: boolean }).__COINS_PROD__;\n\n/** @internal */\nexport function warn(msg: string): void {\n  if (isDev) console.warn(`[@vielzeug/coins] ${msg}`);\n}\n\n/** @internal — Run fn only in dev builds. Use when dev-only logic goes beyond a single warn() / error() call. */\nexport function devOnly(fn: () => void): void {\n  if (isDev) fn();\n}\n"],"mappings":"AAAA,IAAM,EAAQ,CAAE,WAA4C,eAG5D,SAAgB,EAAK,EAAmB,CAClC,GAAO,QAAQ,KAAK,qBAAqB,GAAK,CACpD"}

package/dist/_dev.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=_dev.d.ts.map

package/dist/_dev.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dev.d.ts","sourceRoot":"","sources":["../src/_dev.ts"],"names":[],"mappings":""}

package/dist/_dev.js

@@ -0,0 +1,9 @@
+//#region src/_dev.ts
+var e = !globalThis.__COINS_PROD__;
+function t(t) {
+	e && console.warn(`[@vielzeug/coins] ${t}`);
+}
+//#endregion
+export { t as warn };
+
+//# sourceMappingURL=_dev.js.map

package/dist/_dev.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dev.js","names":[],"sources":["../src/_dev.ts"],"sourcesContent":["const isDev = !(globalThis as { __COINS_PROD__?: boolean }).__COINS_PROD__;\n\n/** @internal */\nexport function warn(msg: string): void {\n  if (isDev) console.warn(`[@vielzeug/coins] ${msg}`);\n}\n\n/** @internal — Run fn only in dev builds. Use when dev-only logic goes beyond a single warn() / error() call. */\nexport function devOnly(fn: () => void): void {\n  if (isDev) fn();\n}\n"],"mappings":";AAAA,IAAM,IAAQ,CAAE,WAA4C;AAG5D,SAAgB,EAAK,GAAmB;CACtC,AAAI,KAAO,QAAQ,KAAK,qBAAqB,GAAK;AACpD"}

package/dist/coins.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});var e=class e extends Error{constructor(e,t){super(e,t),this.name=new.target.name,Object.setPrototypeOf(this,new.target.prototype)}static is(t){return t instanceof e}},t=class extends e{expected;received;constructor(e,t){super(`Currency mismatch: ${e} and ${t}`),this.expected=e,this.received=t}},n=class extends e{code;constructor(e){super(`Invalid ISO 4217 currency code: "${e}"`),this.code=e}};function r(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)}}}var i=r(512);function a(e){let t=i.get(e);if(t!==void 0)return t;let r;try{r=new Intl.NumberFormat(`en`,{currency:e,style:`currency`}).resolvedOptions().maximumFractionDigits}catch{throw new n(e)}if(r===void 0)throw new n(e);return i.set(e,r),r}function o(e){return a(e),e}function s(e){return 10n**BigInt(e)}var c=/^-?\d+(\.\d+)?$/,l=/^(-?\d+\.?\d*)[eE]([+-]?\d+)$/,u=1e3;function d(t){let n=l.exec(t),r=n[1],i=parseInt(n[2],10);if(Math.abs(i)>u)throw new e(`Scientific notation exponent too large: "${t}" (max ±${u})`);let a=r.startsWith(`-`),o=a?r.slice(1):r,s=o.indexOf(`.`),c=s===-1?o:o.replace(`.`,``),d=i-(s===-1?0:o.length-s-1),f;if(d>=0)f=c+`0`.repeat(d);else{let e=c.length+d;f=e<=0?`0.`+`0`.repeat(-e)+c:c.slice(0,e)+`.`+c.slice(e)}return a?`-${f}`:f}function f(t){let n=l.test(t)?d(t):t;if(!c.test(n))throw new e(`Invalid decimal string: "${t}"`);let r=n.startsWith(`-`),i=r?n.slice(1):n,a=i.indexOf(`.`),o=a===-1?i:i.slice(0,a),u=a===-1?``:i.slice(a+1),f=s(u.length);return{denominator:f,negative:r,numerator:BigInt(o||`0`)*f+BigInt(u||`0`)}}function p(t,n,r,i,a=!1){if(n===0n)return t;switch(i){case`ceiling`:return a?t:t+1n;case`down`:return t;case`floor`:return a?t+1n:t;case`half-away-from-zero`:return n*2n>=r?t+1n:t;case`half-even`:{let e=n*2n;return e<r?t:e>r?t+1n:t%2n==0n?t:t+1n}case`up`:return t+1n;default:throw new e(`Unknown rounding mode: ${String(i)}`)}}function m(n,r,i=`half-away-from-zero`){if(n.currency!==r.from)throw new t(n.currency,r.from);if(r.rate===``)throw new e(`Exchange rate must be a non-empty decimal string`);let{denominator:a,negative:s,numerator:c}=f(String(r.rate));if(s)throw new e(`Exchange rate must be non-negative`);let l=n.amount<0n,u=(n.amount<0n?-n.amount:n.amount)*c,d=p(u/a,u%a,a,i,l);return{amount:l?-d:d,currency:o(r.to)}}var h=r(512),g=r(32);function _(t,n){let{locale:r=`en-US`,maximumFractionDigits:i,minimumFractionDigits:o,style:c=`symbol`}=n,l=a(t.currency),u=b(`maximumFractionDigits`,i,l),d=b(`minimumFractionDigits`,o,Math.min(l,u));if(d>u)throw new e(`minimumFractionDigits must be less than or equal to maximumFractionDigits`);let f=ee(t.amount,l,u),p=f<0n,m=p?-f:f,h=s(u),g=m/h,_=x(u===0?``:(m%h).toString().padStart(u,`0`),d),v=S(r,t.currency,c,p);return{frac:_,intStr:C(r).format(g),negative:p,template:v}}function v(e,t={}){return y(e,t).map(e=>e.value).join(``)}function y(e,t={}){let{frac:n,intStr:r,template:i}=_(e,t),a=n.length>0,o=[],s=!1;for(let e of i)if(e.type!==`group`){if(e.type===`integer`){s||=(o.push({type:`integer`,value:r}),!0);continue}if(e.type===`decimal`){a&&o.push({type:`decimal`,value:e.value});continue}if(e.type===`fraction`){a&&o.push({type:`fraction`,value:n});continue}e.type===`currency`?o.push({type:`currency`,value:e.value}):e.type===`minusSign`?o.push({type:`minusSign`,value:e.value}):o.push({type:`literal`,value:e.value})}return o}function b(t,n,r){if(n==null)return r;if(!Number.isInteger(n)||n<0)throw new e(`${t} must be a non-negative integer`);return n}function ee(e,t,n){if(t===n)return e;if(n>t)return e*s(n-t);let r=e<0n,i=r?-e:e,a=s(t-n),o=p(i/a,i%a,a,`half-away-from-zero`);return r?-o:o}function x(e,t){if(e.length===0)return``;let n=e.length;for(;n>t&&e[n-1]===`0`;)n--;return e.slice(0,n)}function S(e,t,n,r){let i=[e,t,n,r?`neg`:`pos`].join(`\0`),a=h.get(i);if(a!==void 0)return a;let o=new Intl.NumberFormat(e,{currency:t,currencyDisplay:n,maximumFractionDigits:1,minimumFractionDigits:1,style:`currency`}).formatToParts(r?-1.1:1.1);return h.set(i,o),o}function C(e){let t=g.get(e);if(t!==void 0)return t;let n=new Intl.NumberFormat(e,{maximumFractionDigits:0,minimumFractionDigits:0,useGrouping:!0});return g.set(e,n),n}var w=!globalThis.__COINS_PROD__;function T(e){w&&console.warn(`[@vielzeug/coins] ${e}`)}function E(e,t){let n=o(t);if(typeof e==`bigint`)return{amount:e,currency:n};if(typeof e==`number`){let t=a(n),r=String(e),i=l.test(r)?d(r):r,o=i.indexOf(`.`),s=o===-1?0:i.length-o-1;return s>t&&T(`money(): number input "${e}" has more decimal places (${s}) than ${n} supports (${t}). Use a decimal string to avoid IEEE-754 precision loss.`),{amount:O(r,t),currency:n}}return{amount:O(String(e),a(n)),currency:n}}function D(e,n){if(e.currency!==n.currency)throw new t(e.currency,n.currency)}function O(e,t){let{denominator:n,negative:r,numerator:i}=f(e),a=i*s(t),o=p(a/n,a%n,n,`half-away-from-zero`);return r?-o:o}function k(e,t){return{amount:t,currency:e.currency}}function A(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 j(e,t){return D(e,t),{amount:e.amount+t.amount,currency:e.currency}}function M(e,t){return D(e,t),{amount:e.amount-t.amount,currency:e.currency}}function N(e,t,n=`half-away-from-zero`){let{denominator:r,negative:i,numerator:a}=f(String(t)),o=e.amount<0n!==i,s=(e.amount<0n?-e.amount:e.amount)*a,c=p(s/r,s%r,r,n,o);return{amount:o?-c:c,currency:e.currency}}function P(t,n,r=`half-away-from-zero`){let{denominator:i,negative:a,numerator:o}=f(String(n));if(o===0n)throw new e(`Division by zero`);let s=t.amount<0n!==a,c=(t.amount<0n?-t.amount:t.amount)*i,l=p(c/o,c%o,o,r,s);return{amount:s?-l:l,currency:t.currency}}function F(t,n){if(n.length===0)throw new e(`allocate requires at least one ratio`);let r=n.map(e=>f(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,o=r.reduce((e,t)=>t.denominator>e?t.denominator:e,1n),s=r.map(e=>e.numerator*(o/e.denominator)),c=s.reduce((e,t)=>e+t,0n),l=[],u=[];for(let e of s){let t=a*e;l.push(t/c),u.push(t%c)}let d=n.map((e,t)=>t).sort((e,t)=>{let n=u[t]-u[e];return n>0n?1:n<0n?-1:0}),p=[...l],m=a-l.reduce((e,t)=>e+t,0n);for(let e=0;m>0n;e++,m--)p[d[e]]+=1n;return p.map(e=>({amount:i?-e:e,currency:t.currency}))}function I(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 L(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=U(n,t[e])<=0?n:t[e];return n}function R(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=U(n,t[e])>=0?n:t[e];return n}function z(t,n){if(!Number.isInteger(n)||n<=0)throw new e(`splitEvenly requires a positive integer number of parts`);return F(t,Array.from({length:n},()=>1))}function B(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(U(r,i)>0)throw new e(`clamp: lower (${$(r)} ${r.currency}) must be <= upper (${$(i)} ${i.currency})`);return R([r,L([n,i])])}function V(e){return{amount:e.amount<0n?-e.amount:e.amount,currency:e.currency}}function H(e){return{amount:-e.amount,currency:e.currency}}function U(e,t){return D(e,t),e.amount<t.amount?-1:+(e.amount>t.amount)}function W(e,t){return e.currency===t.currency&&e.amount===t.amount}function G(e,t){return U(e,t)>0}function K(e,t){return U(e,t)>=0}function q(e,t){return U(e,t)<0}function J(e,t){return U(e,t)<=0}function Y(e){return e.amount===0n}function X(e){return e.amount>0n}function Z(e){return e.amount<0n}function Q(e){return e.amount>=0n}function te(e){return e.amount<=0n}function ne(e){return{amount:String(e.amount),currency:e.currency}}function re(t){let n=o(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 $(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 ie(e){let t=a(e.currency);return Number(e.amount)/Number(s(t))}function ae(t,n,r=`half-away-from-zero`){if(!Number.isInteger(n)||n<0)throw new e(`roundTo: places must be a non-negative integer, got ${n}`);let i=a(t.currency);if(n>i)throw new e(`roundTo: places (${n}) exceeds the decimal places for ${t.currency} (${i})`);if(n===i)return t;let o=s(i-n),c=t.amount<0n,l=c?-t.amount:t.amount,u=p(l/o,l%o,o,r,c);return{amount:c?-u:u,currency:t.currency}}exports.CoinsError=e,exports.CurrencyMismatchError=t,exports.InvalidCurrencyError=n,exports.abs=V,exports.add=j,exports.allocate=F,exports.clamp=B,exports.compare=U,exports.divide=P,exports.exchange=m,exports.format=v,exports.formatParts=y,exports.fromJSON=re,exports.getCurrencyDecimals=a,exports.greaterThan=G,exports.greaterThanOrEqual=K,exports.isEqual=W,exports.isMoney=A,exports.isNegative=Z,exports.isNonNegative=Q,exports.isNonPositive=te,exports.isPositive=X,exports.isZero=Y,exports.lessThan=q,exports.lessThanOrEqual=J,exports.max=R,exports.min=L,exports.money=E,exports.multiply=N,exports.negate=H,exports.roundTo=ae,exports.splitEvenly=z,exports.subtract=M,exports.sum=I,exports.toDecimal=$,exports.toJSON=ne,exports.toNumber=ie,exports.validateCurrencyCode=o,exports.withAmount=k;
+//# sourceMappingURL=coins.cjs.map

package/dist/coins.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"coins.cjs","names":[],"sources":["../src/errors.ts","../src/_cache.ts","../src/utils.ts","../src/exchange.ts","../src/format.ts","../src/_dev.ts","../src/money.ts"],"sourcesContent":["/** Base class for all coins errors. Use `instanceof CoinsError` to catch any coins-originated error. */\nexport class CoinsError extends Error {\n  constructor(message: string, opts?: ErrorOptions) {\n    super(message, opts);\n    this.name = new.target.name;\n    Object.setPrototypeOf(this, new.target.prototype);\n  }\n\n  static is(err: unknown): err is CoinsError {\n    return err instanceof CoinsError;\n  }\n}\n\n/**\n * Thrown when two `Money` values with different currencies are used in an\n * operation that requires the same currency (e.g. `add`, `compare`, `exchange`).\n *\n * @example\n * ```ts\n * import { CurrencyMismatchError } from '@vielzeug/coins';\n *\n * try {\n *   add(usd, eur);\n * } catch (e) {\n *   if (e instanceof CurrencyMismatchError) {\n *     console.log(e.expected, e.received);\n *   }\n * }\n * ```\n */\nexport class CurrencyMismatchError extends CoinsError {\n  /** The currency of the first operand. */\n  readonly expected: string;\n  /** The currency of the second (mismatching) operand. */\n  readonly received: string;\n\n  constructor(expected: string, received: string) {\n    super(`Currency mismatch: ${expected} and ${received}`);\n    this.expected = expected;\n    this.received = received;\n  }\n}\n\n/**\n * Thrown when an unrecognised ISO 4217 currency code is passed to `money`,\n * `exchange`, or any function that validates a currency string.\n *\n * @example\n * ```ts\n * import { InvalidCurrencyError } from '@vielzeug/coins';\n *\n * try {\n *   money('1.00', 'FAKE');\n * } catch (e) {\n *   if (e instanceof InvalidCurrencyError) {\n *     console.log('Bad code:', e.code);\n *   }\n * }\n * ```\n */\nexport class InvalidCurrencyError extends CoinsError {\n  /** The unrecognised currency code that was provided. */\n  readonly code: string;\n\n  constructor(code: string) {\n    super(`Invalid ISO 4217 currency code: \"${code}\"`);\n    this.code = code;\n  }\n}\n","/** 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","import type { CurrencyCode, RoundingMode } from './types';\n\nimport { boundedCache } from './_cache';\nimport { CoinsError, InvalidCurrencyError } from './errors';\n\nconst currencyDecimalsCache = boundedCache<string, number>(512);\n\n/**\n * Returns the number of minor-unit decimal places for a given ISO 4217 currency code.\n * Uses `Intl.NumberFormat` to resolve the canonical value (e.g. USD→2, JPY→0, KWD→3).\n * Throws `InvalidCurrencyError` for unrecognized codes or when the runtime cannot determine decimals.\n */\nexport function getCurrencyDecimals(currencyCode: CurrencyCode): number {\n  const cached = currencyDecimalsCache.get(currencyCode);\n\n  if (cached !== undefined) return cached;\n\n  let resolved: number | undefined;\n\n  try {\n    resolved = new Intl.NumberFormat('en', { currency: currencyCode, style: 'currency' }).resolvedOptions()\n      .maximumFractionDigits;\n  } catch {\n    throw new InvalidCurrencyError(currencyCode);\n  }\n\n  if (resolved === undefined) {\n    throw new InvalidCurrencyError(currencyCode);\n  }\n\n  currencyDecimalsCache.set(currencyCode, resolved);\n\n  return resolved;\n}\n\n/**\n * Validates an ISO 4217 currency code and returns it.\n * Throws `InvalidCurrencyError` if unrecognized. Uses `getCurrencyDecimals` internally so\n * the result is cached for subsequent decimal lookups.\n */\nexport function validateCurrencyCode(code: CurrencyCode): CurrencyCode {\n  getCurrencyDecimals(code);\n\n  return code;\n}\n\n/** Returns `10n ** BigInt(exponent)`. */\nexport function pow10(exponent: number): bigint {\n  return 10n ** BigInt(exponent);\n}\n\n/** Regex for valid decimal strings accepted by `parseRational`. */\nconst DECIMAL_RE = /^-?\\d+(\\.\\d+)?$/;\n\n/** Regex matching JavaScript scientific-notation strings, e.g. `'1e-7'`, `'-3.14E+5'`. */\nexport const SCIENTIFIC_RE = /^(-?\\d+\\.?\\d*)[eE]([+-]?\\d+)$/;\n\n/** Maximum absolute exponent allowed in scientific notation. Prevents '0'.repeat(N) allocation attacks. */\nconst MAX_SCIENTIFIC_EXP = 1000;\n\n/**\n * Expands a scientific-notation decimal string into a plain decimal string.\n * `'1e-7'` → `'0.0000001'`, `'1.23e+5'` → `'123000'`.\n * Only called when `SCIENTIFIC_RE` already matched — no extra validation.\n * @throws {CoinsError} If the absolute exponent exceeds `MAX_SCIENTIFIC_EXP` (1000).\n */\nexport function expandScientific(s: string): string {\n  const match = SCIENTIFIC_RE.exec(s)!;\n  const coeff = match[1]!;\n  const exp = parseInt(match[2]!, 10);\n\n  if (Math.abs(exp) > MAX_SCIENTIFIC_EXP) {\n    throw new CoinsError(`Scientific notation exponent too large: \"${s}\" (max ±${MAX_SCIENTIFIC_EXP})`);\n  }\n\n  const isNeg = coeff.startsWith('-');\n  const absCoeff = isNeg ? coeff.slice(1) : coeff;\n  const dotIndex = absCoeff.indexOf('.');\n  const digits = dotIndex === -1 ? absCoeff : absCoeff.replace('.', '');\n  const fracLen = dotIndex === -1 ? 0 : absCoeff.length - dotIndex - 1;\n  const newExp = exp - fracLen; // where the decimal point sits relative to end of digits\n\n  let result: string;\n\n  if (newExp >= 0) {\n    // All digits are to the left of the decimal — append trailing zeros\n    result = digits + '0'.repeat(newExp);\n  } else {\n    const intLen = digits.length + newExp; // digits before the decimal point\n\n    if (intLen <= 0) {\n      // Pure fraction: '0.' + leading zeros + digits\n      result = '0.' + '0'.repeat(-intLen) + digits;\n    } else {\n      result = digits.slice(0, intLen) + '.' + digits.slice(intLen);\n    }\n  }\n\n  return isNeg ? `-${result}` : result;\n}\n\n/**\n * Parses a decimal string into a rational `{ numerator, denominator, negative }`.\n * The denominator is always a power of 10 and the numerator is always non-negative.\n * @throws {CoinsError} For non-numeric input.\n *\n * Accepts standard decimal strings and JavaScript scientific notation\n * (e.g. `'1e-7'`, `'1.23E+5'`) — the latter is automatically expanded before parsing.\n *\n * @example\n * parseRational('1.5')   → { numerator: 15n, denominator: 10n, negative: false }\n * parseRational('-0.5')  → { numerator: 5n,  denominator: 10n, negative: true  }\n * parseRational('3')     → { numerator: 3n,  denominator: 1n,  negative: false }\n * parseRational('1e-7')  → { numerator: 1n,  denominator: 10000000n, negative: false }\n *\n * Note: `'-0'` and `'-0.0'` produce `{ negative: true, numerator: 0n, ... }`.\n * Callers that compute `negative ? -result : result` on `0n` remain correct\n * because `-0n === 0n` in bigint arithmetic.\n */\nexport function parseRational(str: string): { denominator: bigint; negative: boolean; numerator: bigint } {\n  // Expand scientific notation (e.g. from String(1e-7) = '1e-7') before validation.\n  const normalized = SCIENTIFIC_RE.test(str) ? expandScientific(str) : str;\n\n  if (!DECIMAL_RE.test(normalized)) {\n    throw new CoinsError(`Invalid decimal string: \"${str}\"`);\n  }\n\n  const negative = normalized.startsWith('-');\n  const absStr = negative ? normalized.slice(1) : normalized;\n  const dotIndex = absStr.indexOf('.');\n  const intStr = dotIndex === -1 ? absStr : absStr.slice(0, dotIndex);\n  const fracStr = dotIndex === -1 ? '' : absStr.slice(dotIndex + 1);\n  const denominator = pow10(fracStr.length);\n  const numerator = BigInt(intStr || '0') * denominator + BigInt(fracStr || '0');\n\n  return { denominator, negative, numerator };\n}\n\n/**\n * Applies a rounding mode to a truncated division result.\n *\n * **Contract**: `quotient` and `absRemainder` must be non-negative (absolute values).\n * The caller is responsible for:\n *   1. Computing everything in terms of absolute values.\n *   2. Passing `negative = true` when the true mathematical result is negative.\n *   3. Applying the sign after: `negative ? -result : result`.\n *\n * Returns the absolute value of the rounded result.\n *\n * @param quotient     Non-negative integer part of the division (`|dividend| / divisor`).\n * @param absRemainder Non-negative remainder (`|dividend| % divisor`).\n * @param denominator  The divisor used to produce quotient/remainder.\n * @param mode         The desired rounding mode.\n * @param negative     Whether the true mathematical result is negative. Defaults to `false`.\n */\nexport function applyRounding(\n  quotient: bigint,\n  absRemainder: bigint,\n  denominator: bigint,\n  mode: RoundingMode,\n  negative = false,\n): bigint {\n  if (absRemainder === 0n) return quotient;\n\n  switch (mode) {\n    case 'ceiling':\n      // Toward +∞: round up for positive results, truncate for negative results.\n      return negative ? quotient : quotient + 1n;\n\n    case 'down':\n      // Toward zero: always truncate.\n      return quotient;\n\n    case 'floor':\n      // Toward −∞: truncate for positive results, one step more for negative results.\n      return negative ? quotient + 1n : quotient;\n\n    case 'half-away-from-zero':\n      return absRemainder * 2n >= denominator ? quotient + 1n : quotient;\n\n    case 'half-even': {\n      const twice = absRemainder * 2n;\n\n      if (twice < denominator) return quotient;\n\n      if (twice > denominator) return quotient + 1n;\n\n      // Exactly half — round to the nearest even integer.\n      return quotient % 2n === 0n ? quotient : quotient + 1n;\n    }\n\n    case 'up':\n      // Away from zero: always round away.\n      return quotient + 1n;\n\n    default:\n      throw new CoinsError(`Unknown rounding mode: ${String(mode)}`);\n  }\n}\n","import type { ExchangeRate, Money, RoundingMode } from './types';\n\nimport { CoinsError, CurrencyMismatchError } from './errors';\nimport { applyRounding, parseRational, validateCurrencyCode } from './utils';\n\n/**\n * Converts a `Money` value to another currency using the provided exchange rate.\n * Uses lossless bigint arithmetic throughout — `rate.rate` is parsed as a decimal\n * string to avoid IEEE-754 rounding errors. A number `rate.rate` is converted via\n * `String()` first (for symmetry with `multiply()`/`divide()`); prefer a string when\n * precision matters.\n *\n * @param mode Rounding mode applied when the converted amount is not a whole minor unit.\n *             Defaults to `'half-away-from-zero'`.\n *\n * @throws {CurrencyMismatchError} If `money.currency` does not match `rate.from`.\n *   Note: `rate.from` is validated implicitly — because `money.currency` is always a valid ISO 4217\n *   code (enforced by `money()`), the mismatch check ensures `rate.from` must equal a valid code.\n *   If you supply an invalid code in `rate.from`, you will receive `CurrencyMismatchError`, not\n *   `InvalidCurrencyError`. Pre-validate `rate.from` with `validateCurrencyCode()` if needed.\n * @throws {InvalidCurrencyError}  If `rate.to` is not a recognised ISO 4217 currency code.\n * @throws {CoinsError}            If `rate.rate` is an empty string, non-numeric, or a negative value.\n *\n * @example\n * ```ts\n * const usd = money('1000.00', 'USD');\n * exchange(usd, { from: 'USD', to: 'EUR', rate: '0.85' });\n * // { amount: 85000n, currency: 'EUR' }\n * ```\n */\nexport function exchange(m: Money, rate: ExchangeRate, mode: RoundingMode = 'half-away-from-zero'): Money {\n  if (m.currency !== rate.from) {\n    throw new CurrencyMismatchError(m.currency, rate.from);\n  }\n\n  if (rate.rate === '') throw new CoinsError('Exchange rate must be a non-empty decimal string');\n\n  const { denominator, negative: rateNegative, numerator } = parseRational(String(rate.rate));\n\n  if (rateNegative) throw new CoinsError('Exchange rate must be non-negative');\n\n  const negative = m.amount < 0n;\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: validateCurrencyCode(rate.to) };\n}\n","import type { FormatOptions, Money, MoneyFormatPart } from './types';\n\nimport { boundedCache } from './_cache';\nimport { CoinsError } from './errors';\nimport { applyRounding, getCurrencyDecimals, pow10 } from './utils';\n\n// Template cache key: locale × currency × style × sign — 512 prevents thrashing in multi-locale apps.\nconst currencyTemplateCache = boundedCache<string, Intl.NumberFormatPart[]>(512);\n// Locale-only key — 32 covers virtually every realistic multi-locale deployment.\nconst integerFormatterCache = boundedCache<string, Intl.NumberFormat>(32);\n\n/**\n * Resolves and validates all formatting parameters, performs scaling, and\n * produces the pre-computed strings shared by `format()` and `formatParts()`.\n * Throws on invalid options. New options only need to be added in one place.\n */\ntype FormatState = {\n  frac: string;\n  intStr: string;\n  negative: boolean;\n  template: Intl.NumberFormatPart[];\n};\n\nfunction resolveFormatState(m: Money, options: FormatOptions): FormatState {\n  const { locale = 'en-US', maximumFractionDigits, minimumFractionDigits, style = 'symbol' } = options;\n\n  const decimalPlaces = getCurrencyDecimals(m.currency);\n  const maxFrac = validateFractionDigits('maximumFractionDigits', maximumFractionDigits, decimalPlaces);\n  const minFrac = validateFractionDigits(\n    'minimumFractionDigits',\n    minimumFractionDigits,\n    Math.min(decimalPlaces, maxFrac),\n  );\n\n  if (minFrac > maxFrac) {\n    throw new CoinsError('minimumFractionDigits must be less than or equal to maximumFractionDigits');\n  }\n\n  const scaled = rescaleMinorUnits(m.amount, decimalPlaces, maxFrac);\n  const negative = scaled < 0n;\n  const abs = negative ? -scaled : scaled;\n  const divisor = pow10(maxFrac);\n  const whole = abs / divisor;\n  const rawFrac = maxFrac === 0 ? '' : (abs % divisor).toString().padStart(maxFrac, '0');\n  const frac = trimFraction(rawFrac, minFrac);\n  const template = getCurrencyTemplate(locale, m.currency, style, negative);\n  const intStr = getIntegerFormatter(locale).format(whole);\n\n  return { frac, intStr, negative, template };\n}\n\n/**\n * Formats a `Money` value as a locale-aware currency string.\n * Uses bigint arithmetic throughout — no floating-point precision loss.\n *\n * When `maximumFractionDigits` is less than the currency's native decimal\n * places, the amount is rescaled using `'half-away-from-zero'` rounding.\n *\n * @example\n * ```ts\n * const price = money('1234.56', 'USD');\n *\n * format(price)                          // '$1,234.56'\n * format(price, { locale: 'de-DE' })    // '1.234,56 $'\n * format(price, { style: 'code' })      // 'USD 1,234.56'\n * format(price, { style: 'name' })      // '1,234.56 US dollars'\n * ```\n */\nexport function format(m: Money, options: FormatOptions = {}): string {\n  return formatParts(m, options)\n    .map((p) => p.value)\n    .join('');\n}\n\n/**\n * Returns the formatted parts of a `Money` value as a structured array.\n * Useful for custom rendering — apply different styles to each semantic segment\n * (currency symbol, integer, decimal separator, fraction, sign).\n *\n * Joining all `value` fields produces the same string as `format()`.\n * When `maximumFractionDigits` reduces precision, rescaling uses\n * `'half-away-from-zero'` rounding.\n *\n * @example\n * ```ts\n * formatParts(money('1234.56', 'USD'))\n * // [\n * //   { type: 'currency', value: '$' },\n * //   { type: 'integer',  value: '1,234' },\n * //   { type: 'decimal',  value: '.' },\n * //   { type: 'fraction', value: '56' },\n * // ]\n * ```\n */\nexport function formatParts(m: Money, options: FormatOptions = {}): MoneyFormatPart[] {\n  const { frac, intStr, template } = resolveFormatState(m, options);\n  const hasFrac = frac.length > 0;\n  const parts: MoneyFormatPart[] = [];\n  let replacedInteger = false;\n\n  for (const part of template) {\n    // Group separators (e.g. comma in '1,234') are already embedded in intStr by\n    // getIntegerFormatter(), so the template's group parts are intentionally discarded.\n    if (part.type === 'group') continue;\n\n    if (part.type === 'integer') {\n      if (!replacedInteger) {\n        parts.push({ type: 'integer', value: intStr });\n        replacedInteger = true;\n      }\n\n      continue;\n    }\n\n    if (part.type === 'decimal') {\n      if (hasFrac) parts.push({ type: 'decimal', value: part.value });\n\n      continue;\n    }\n\n    if (part.type === 'fraction') {\n      if (hasFrac) parts.push({ type: 'fraction', value: frac });\n\n      continue;\n    }\n\n    if (part.type === 'currency') {\n      parts.push({ type: 'currency', value: part.value });\n    } else if (part.type === 'minusSign') {\n      parts.push({ type: 'minusSign', value: part.value });\n    } else {\n      parts.push({ type: 'literal', value: part.value });\n    }\n  }\n\n  return parts;\n}\n\nfunction validateFractionDigits(name: string, value: number | undefined, fallback: number): number {\n  if (value == null) return fallback;\n\n  if (!Number.isInteger(value) || value < 0) {\n    throw new CoinsError(`${name} must be a non-negative integer`);\n  }\n\n  return value;\n}\n\n/**\n * Rescales minor units from `sourceFrac` decimal places to `targetFrac`,\n * using half-away-from-zero rounding when reducing precision.\n * Always normalizes to absolute value before rounding and reapplies the sign after.\n */\nfunction rescaleMinorUnits(amount: bigint, sourceFrac: number, targetFrac: number): bigint {\n  if (sourceFrac === targetFrac) return amount;\n\n  if (targetFrac > sourceFrac) return amount * pow10(targetFrac - sourceFrac);\n\n  const negative = amount < 0n;\n  const abs = negative ? -amount : amount;\n  const factor = pow10(sourceFrac - targetFrac);\n  const quotient = abs / factor;\n  const result = applyRounding(quotient, abs % factor, factor, 'half-away-from-zero');\n\n  return negative ? -result : result;\n}\n\nfunction trimFraction(value: string, minDigits: number): string {\n  if (value.length === 0) return '';\n\n  let end = value.length;\n\n  while (end > minDigits && value[end - 1] === '0') end--;\n\n  return value.slice(0, end);\n}\n\nfunction getCurrencyTemplate(\n  locale: string,\n  currencyCode: string,\n  style: NonNullable<FormatOptions['style']>,\n  negative: boolean,\n): Intl.NumberFormatPart[] {\n  const key = [locale, currencyCode, style, negative ? 'neg' : 'pos'].join('\\0');\n  const cached = currencyTemplateCache.get(key);\n\n  if (cached !== undefined) return cached;\n\n  const formatter = new Intl.NumberFormat(locale, {\n    currency: currencyCode,\n    currencyDisplay: style,\n    maximumFractionDigits: 1,\n    minimumFractionDigits: 1,\n    style: 'currency',\n  });\n\n  const template = formatter.formatToParts(negative ? -1.1 : 1.1);\n\n  currencyTemplateCache.set(key, template);\n\n  return template;\n}\n\nfunction getIntegerFormatter(locale: string): Intl.NumberFormat {\n  const cached = integerFormatterCache.get(locale);\n\n  if (cached !== undefined) return cached;\n\n  const formatter = new Intl.NumberFormat(locale, {\n    maximumFractionDigits: 0,\n    minimumFractionDigits: 0,\n    useGrouping: true,\n  });\n\n  integerFormatterCache.set(locale, formatter);\n\n  return formatter;\n}\n","const isDev = !(globalThis as { __COINS_PROD__?: boolean }).__COINS_PROD__;\n\n/** @internal */\nexport function warn(msg: string): void {\n  if (isDev) console.warn(`[@vielzeug/coins] ${msg}`);\n}\n\n/** @internal — Run fn only in dev builds. Use when dev-only logic goes beyond a single warn() / error() call. */\nexport function devOnly(fn: () => void): void {\n  if (isDev) fn();\n}\n","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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"}

package/dist/coins.iife.js

@@ -0,0 +1,2 @@
+var Coins=(function(e){Object.defineProperty(e,Symbol.toStringTag,{value:`Module`});var t=class e extends Error{constructor(e,t){super(e,t),this.name=new.target.name,Object.setPrototypeOf(this,new.target.prototype)}static is(t){return t instanceof e}},n=class extends t{expected;received;constructor(e,t){super(`Currency mismatch: ${e} and ${t}`),this.expected=e,this.received=t}},r=class extends t{code;constructor(e){super(`Invalid ISO 4217 currency code: "${e}"`),this.code=e}};function i(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)}}}var a=i(512);function o(e){let t=a.get(e);if(t!==void 0)return t;let n;try{n=new Intl.NumberFormat(`en`,{currency:e,style:`currency`}).resolvedOptions().maximumFractionDigits}catch{throw new r(e)}if(n===void 0)throw new r(e);return a.set(e,n),n}function s(e){return o(e),e}function c(e){return 10n**BigInt(e)}var l=/^-?\d+(\.\d+)?$/,u=/^(-?\d+\.?\d*)[eE]([+-]?\d+)$/,d=1e3;function f(e){let n=u.exec(e),r=n[1],i=parseInt(n[2],10);if(Math.abs(i)>d)throw new t(`Scientific notation exponent too large: "${e}" (max ±${d})`);let a=r.startsWith(`-`),o=a?r.slice(1):r,s=o.indexOf(`.`),c=s===-1?o:o.replace(`.`,``),l=i-(s===-1?0:o.length-s-1),f;if(l>=0)f=c+`0`.repeat(l);else{let e=c.length+l;f=e<=0?`0.`+`0`.repeat(-e)+c:c.slice(0,e)+`.`+c.slice(e)}return a?`-${f}`:f}function p(e){let n=u.test(e)?f(e):e;if(!l.test(n))throw new t(`Invalid decimal string: "${e}"`);let r=n.startsWith(`-`),i=r?n.slice(1):n,a=i.indexOf(`.`),o=a===-1?i:i.slice(0,a),s=a===-1?``:i.slice(a+1),d=c(s.length);return{denominator:d,negative:r,numerator:BigInt(o||`0`)*d+BigInt(s||`0`)}}function m(e,n,r,i,a=!1){if(n===0n)return e;switch(i){case`ceiling`:return a?e:e+1n;case`down`:return e;case`floor`:return a?e+1n:e;case`half-away-from-zero`:return n*2n>=r?e+1n:e;case`half-even`:{let t=n*2n;return t<r?e:t>r?e+1n:e%2n==0n?e:e+1n}case`up`:return e+1n;default:throw new t(`Unknown rounding mode: ${String(i)}`)}}function h(e,r,i=`half-away-from-zero`){if(e.currency!==r.from)throw new n(e.currency,r.from);if(r.rate===``)throw new t(`Exchange rate must be a non-empty decimal string`);let{denominator:a,negative:o,numerator:c}=p(String(r.rate));if(o)throw new t(`Exchange rate must be non-negative`);let l=e.amount<0n,u=(e.amount<0n?-e.amount:e.amount)*c,d=m(u/a,u%a,a,i,l);return{amount:l?-d:d,currency:s(r.to)}}var g=i(512),_=i(32);function v(e,n){let{locale:r=`en-US`,maximumFractionDigits:i,minimumFractionDigits:a,style:s=`symbol`}=n,l=o(e.currency),u=x(`maximumFractionDigits`,i,l),d=x(`minimumFractionDigits`,a,Math.min(l,u));if(d>u)throw new t(`minimumFractionDigits must be less than or equal to maximumFractionDigits`);let f=S(e.amount,l,u),p=f<0n,m=p?-f:f,h=c(u),g=m/h,_=C(u===0?``:(m%h).toString().padStart(u,`0`),d),v=w(r,e.currency,s,p);return{frac:_,intStr:T(r).format(g),negative:p,template:v}}function y(e,t={}){return b(e,t).map(e=>e.value).join(``)}function b(e,t={}){let{frac:n,intStr:r,template:i}=v(e,t),a=n.length>0,o=[],s=!1;for(let e of i)if(e.type!==`group`){if(e.type===`integer`){s||=(o.push({type:`integer`,value:r}),!0);continue}if(e.type===`decimal`){a&&o.push({type:`decimal`,value:e.value});continue}if(e.type===`fraction`){a&&o.push({type:`fraction`,value:n});continue}e.type===`currency`?o.push({type:`currency`,value:e.value}):e.type===`minusSign`?o.push({type:`minusSign`,value:e.value}):o.push({type:`literal`,value:e.value})}return o}function x(e,n,r){if(n==null)return r;if(!Number.isInteger(n)||n<0)throw new t(`${e} must be a non-negative integer`);return n}function S(e,t,n){if(t===n)return e;if(n>t)return e*c(n-t);let r=e<0n,i=r?-e:e,a=c(t-n),o=m(i/a,i%a,a,`half-away-from-zero`);return r?-o:o}function C(e,t){if(e.length===0)return``;let n=e.length;for(;n>t&&e[n-1]===`0`;)n--;return e.slice(0,n)}function w(e,t,n,r){let i=[e,t,n,r?`neg`:`pos`].join(`\0`),a=g.get(i);if(a!==void 0)return a;let o=new Intl.NumberFormat(e,{currency:t,currencyDisplay:n,maximumFractionDigits:1,minimumFractionDigits:1,style:`currency`}).formatToParts(r?-1.1:1.1);return g.set(i,o),o}function T(e){let t=_.get(e);if(t!==void 0)return t;let n=new Intl.NumberFormat(e,{maximumFractionDigits:0,minimumFractionDigits:0,useGrouping:!0});return _.set(e,n),n}var E=!globalThis.__COINS_PROD__;function D(e){E&&console.warn(`[@vielzeug/coins] ${e}`)}function ee(e,t){let n=s(t);if(typeof e==`bigint`)return{amount:e,currency:n};if(typeof e==`number`){let t=o(n),r=String(e),i=u.test(r)?f(r):r,a=i.indexOf(`.`),s=a===-1?0:i.length-a-1;return s>t&&D(`money(): number input "${e}" has more decimal places (${s}) than ${n} supports (${t}). Use a decimal string to avoid IEEE-754 precision loss.`),{amount:k(r,t),currency:n}}return{amount:k(String(e),o(n)),currency:n}}function O(e,t){if(e.currency!==t.currency)throw new n(e.currency,t.currency)}function k(e,t){let{denominator:n,negative:r,numerator:i}=p(e),a=i*c(t),o=m(a/n,a%n,n,`half-away-from-zero`);return r?-o:o}function A(e,t){return{amount:t,currency:e.currency}}function j(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 M(e,t){return O(e,t),{amount:e.amount+t.amount,currency:e.currency}}function N(e,t){return O(e,t),{amount:e.amount-t.amount,currency:e.currency}}function P(e,t,n=`half-away-from-zero`){let{denominator:r,negative:i,numerator:a}=p(String(t)),o=e.amount<0n!==i,s=(e.amount<0n?-e.amount:e.amount)*a,c=m(s/r,s%r,r,n,o);return{amount:o?-c:c,currency:e.currency}}function F(e,n,r=`half-away-from-zero`){let{denominator:i,negative:a,numerator:o}=p(String(n));if(o===0n)throw new t(`Division by zero`);let s=e.amount<0n!==a,c=(e.amount<0n?-e.amount:e.amount)*i,l=m(c/o,c%o,o,r,s);return{amount:s?-l:l,currency:e.currency}}function I(e,n){if(n.length===0)throw new t(`allocate requires at least one ratio`);let r=n.map(e=>p(String(e)));if(r.some(e=>e.negative))throw new t(`All ratios must be non-negative`);if(!r.some(e=>e.numerator>0n))throw new t(`At least one ratio must be positive`);let i=e.amount<0n,a=i?-e.amount:e.amount,o=r.reduce((e,t)=>t.denominator>e?t.denominator:e,1n),s=r.map(e=>e.numerator*(o/e.denominator)),c=s.reduce((e,t)=>e+t,0n),l=[],u=[];for(let e of s){let t=a*e;l.push(t/c),u.push(t%c)}let d=n.map((e,t)=>t).sort((e,t)=>{let n=u[t]-u[e];return n>0n?1:n<0n?-1:0}),f=[...l],m=a-l.reduce((e,t)=>e+t,0n);for(let e=0;m>0n;e++,m--)f[d[e]]+=1n;return f.map(t=>({amount:i?-t:t,currency:e.currency}))}function L(e){if(e.length===0)throw new t(`sum requires at least one Money value`);let r=e[0].currency;for(let t=1;t<e.length;t++)if(e[t].currency!==r)throw new n(r,e[t].currency);return{amount:e.reduce((e,t)=>e+t.amount,0n),currency:r}}function R(e){if(e.length===0)throw new t(`min requires at least one Money value`);let n=e[0];for(let t=1;t<e.length;t++)n=W(n,e[t])<=0?n:e[t];return n}function z(e){if(e.length===0)throw new t(`max requires at least one Money value`);let n=e[0];for(let t=1;t<e.length;t++)n=W(n,e[t])>=0?n:e[t];return n}function B(e,n){if(!Number.isInteger(n)||n<=0)throw new t(`splitEvenly requires a positive integer number of parts`);return I(e,Array.from({length:n},()=>1))}function V(e,r,i){if(e.currency!==r.currency||e.currency!==i.currency)throw new n(e.currency,e.currency===r.currency?i.currency:r.currency);if(W(r,i)>0)throw new t(`clamp: lower (${$(r)} ${r.currency}) must be <= upper (${$(i)} ${i.currency})`);return z([r,R([e,i])])}function H(e){return{amount:e.amount<0n?-e.amount:e.amount,currency:e.currency}}function U(e){return{amount:-e.amount,currency:e.currency}}function W(e,t){return O(e,t),e.amount<t.amount?-1:+(e.amount>t.amount)}function G(e,t){return e.currency===t.currency&&e.amount===t.amount}function K(e,t){return W(e,t)>0}function q(e,t){return W(e,t)>=0}function J(e,t){return W(e,t)<0}function Y(e,t){return W(e,t)<=0}function X(e){return e.amount===0n}function Z(e){return e.amount>0n}function Q(e){return e.amount<0n}function te(e){return e.amount>=0n}function ne(e){return e.amount<=0n}function re(e){return{amount:String(e.amount),currency:e.currency}}function ie(e){let n=s(e.currency);if(typeof e.amount!=`string`)throw new t(`Invalid money amount in JSON: ${String(e.amount)} (expected an integer string, e.g. '123456')`);let r;try{r=BigInt(e.amount)}catch{throw new t(`Invalid money amount in JSON: "${e.amount}" (expected an integer string, e.g. '123456')`)}return{amount:r,currency:n}}function $(e){let t=o(e.currency);if(t===0)return String(e.amount);let n=e.amount<0n,r=n?-e.amount:e.amount,i=c(t),a=r/i,s=(r%i).toString().padStart(t,`0`);return`${n?`-`:``}${a}.${s}`}function ae(e){let t=o(e.currency);return Number(e.amount)/Number(c(t))}function oe(e,n,r=`half-away-from-zero`){if(!Number.isInteger(n)||n<0)throw new t(`roundTo: places must be a non-negative integer, got ${n}`);let i=o(e.currency);if(n>i)throw new t(`roundTo: places (${n}) exceeds the decimal places for ${e.currency} (${i})`);if(n===i)return e;let a=c(i-n),s=e.amount<0n,l=s?-e.amount:e.amount,u=m(l/a,l%a,a,r,s);return{amount:s?-u:u,currency:e.currency}}return e.CoinsError=t,e.CurrencyMismatchError=n,e.InvalidCurrencyError=r,e.abs=H,e.add=M,e.allocate=I,e.clamp=V,e.compare=W,e.divide=F,e.exchange=h,e.format=y,e.formatParts=b,e.fromJSON=ie,e.getCurrencyDecimals=o,e.greaterThan=K,e.greaterThanOrEqual=q,e.isEqual=G,e.isMoney=j,e.isNegative=Q,e.isNonNegative=te,e.isNonPositive=ne,e.isPositive=Z,e.isZero=X,e.lessThan=J,e.lessThanOrEqual=Y,e.max=z,e.min=R,e.money=ee,e.multiply=P,e.negate=U,e.roundTo=oe,e.splitEvenly=B,e.subtract=N,e.sum=L,e.toDecimal=$,e.toJSON=re,e.toNumber=ae,e.validateCurrencyCode=s,e.withAmount=A,e})({});
+//# sourceMappingURL=coins.iife.js.map