@puvaanraaj/moneta 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PuvaanRaaj
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,160 @@
+# moneta
+
+> Immutable, BigInt-precision monetary values for TypeScript. No float errors. Currency-safe by design.
+
+[![CI](https://github.com/PuvaanRaaj/moneta/actions/workflows/ci.yml/badge.svg)](https://github.com/PuvaanRaaj/moneta/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/moneta)](https://www.npmjs.com/package/moneta)
+[![npm bundle size](https://img.shields.io/bundlephobia/minzip/moneta)](https://bundlephobia.com/package/moneta)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+## Why moneta?
+
+Every JavaScript app that handles money eventually hits the float trap:
+
+```js
+0.1 + 0.2 === 0.3 // false — 0.30000000000000004
+```
+
+`moneta` solves this permanently using **native BigInt** under the hood — no floats, ever.
+It also catches **currency mismatches at the TypeScript type level**, not at runtime.
+
+```ts
+const usd = money('10.00', 'USD')
+const eur = money('5.00',  'EUR')
+
+usd.add(eur) // TypeError — caught at compile time, not in production
+```
+
+## Install
+
+```bash
+npm install moneta
+```
+
+Requires Node ≥ 18. Zero runtime dependencies.
+
+## Quick start
+
+```ts
+import { money } from 'moneta'
+
+const price = money('19.99', 'USD')
+const tax   = money('1.60',  'USD')
+
+price.add(tax).format('en-US')       // "$21.59"
+price.multiply(1.1).format('en-US')  // "$21.99"
+price.divide(3).format('en-US')      // "$6.66"
+
+// Allocate $10 in 3 parts — sum always equals original
+money('10.00', 'USD').allocate([1, 1, 1])
+// [Money('3.34 USD'), Money('3.33 USD'), Money('3.33 USD')]
+```
+
+## API
+
+### `money(amount, currency)`
+
+The primary factory. Returns an immutable `Money<C>` instance.
+
+```ts
+money('19.99', 'USD')   // from string  — recommended
+money(19.99, 'USD')     // from number  — uses toFixed() internally
+money(1999n, 'USD')     // from bigint  — treated as minor units (cents)
+```
+
+### `Money.fromMinorUnits(units, currency)`
+
+Create from raw minor units — useful when reading from a database.
+
+```ts
+Money.fromMinorUnits(1999n, 'USD') // $19.99
+```
+
+### Arithmetic
+
+All operations return a **new** `Money` instance (immutable).
+
+| Method | Description |
+|---|---|
+| `.add(other)` | Add two same-currency values |
+| `.subtract(other)` | Subtract two same-currency values |
+| `.multiply(factor)` | Multiply by a scalar (number or string) |
+| `.divide(divisor)` | Divide by a scalar, half-up rounding |
+| `.allocate(ratios)` | Proportional split — sum always exact |
+| `.abs()` | Absolute value |
+| `.negate()` | Flip sign |
+
+### Comparison
+
+```ts
+a.equals(b)
+a.greaterThan(b)
+a.lessThan(b)
+a.greaterThanOrEqual(b)
+a.lessThanOrEqual(b)
+a.isZero()
+a.isPositive()
+a.isNegative()
+```
+
+### Accessors
+
+```ts
+m.currency       // 'USD'
+m.minorUnits     // 1999n  — safe for DB storage
+m.decimalValue   // '19.99'
+```
+
+### Formatting
+
+```ts
+m.format()         // uses default locale
+m.format('de-DE')  // "19,99 $"
+m.format('ja-JP')  // "＄19.99"
+```
+
+### Serialisation
+
+```ts
+m.toJSON()
+// { amount: '19.99', currency: 'USD', minorUnits: '1999' }
+
+JSON.stringify(m)
+// '{"amount":"19.99","currency":"USD","minorUnits":"1999"}'
+
+m.toString()  // '19.99 USD'
+```
+
+## Supported currencies
+
+34 ISO 4217 currencies included: AED, AUD, BRL, CAD, CHF, CNY, CZK, DKK, EUR, GBP, HKD, HUF, IDR, ILS, INR, JPY, KRW, KWD, MXN, MYR, NOK, NZD, PHP, PLN, RON, SAR, SEK, SGD, THB, TRY, TWD, USD, VND, ZAR.
+
+## Error handling
+
+All errors extend `MonetaError` and are typed:
+
+```ts
+import {
+  CurrencyMismatchError,
+  DivisionByZeroError,
+  InvalidAmountError,
+  UnknownCurrencyError,
+} from 'moneta'
+```
+
+## Security
+
+- Zero runtime dependencies
+- No `eval`, no dynamic code execution
+- No install scripts — safe against supply-chain attacks
+- Every npm release is published with **provenance** (SLSA Level 2)
+
+```bash
+npm audit signatures  # verify the package wasn't tampered with
+```
+
+See [SECURITY.md](SECURITY.md) for the full policy and how to report vulnerabilities.
+
+## License
+
+[MIT](LICENSE)

package/dist/index.cjs

@@ -0,0 +1,314 @@
+'use strict';
+
+// src/currencies.ts
+var CURRENCIES = {
+  AED: { code: "AED", decimals: 2, name: "UAE Dirham" },
+  AUD: { code: "AUD", decimals: 2, name: "Australian Dollar" },
+  BRL: { code: "BRL", decimals: 2, name: "Brazilian Real" },
+  CAD: { code: "CAD", decimals: 2, name: "Canadian Dollar" },
+  CHF: { code: "CHF", decimals: 2, name: "Swiss Franc" },
+  CNY: { code: "CNY", decimals: 2, name: "Chinese Yuan" },
+  CZK: { code: "CZK", decimals: 2, name: "Czech Koruna" },
+  DKK: { code: "DKK", decimals: 2, name: "Danish Krone" },
+  EUR: { code: "EUR", decimals: 2, name: "Euro" },
+  GBP: { code: "GBP", decimals: 2, name: "British Pound" },
+  HKD: { code: "HKD", decimals: 2, name: "Hong Kong Dollar" },
+  HUF: { code: "HUF", decimals: 2, name: "Hungarian Forint" },
+  IDR: { code: "IDR", decimals: 2, name: "Indonesian Rupiah" },
+  ILS: { code: "ILS", decimals: 2, name: "Israeli New Shekel" },
+  INR: { code: "INR", decimals: 2, name: "Indian Rupee" },
+  JPY: { code: "JPY", decimals: 0, name: "Japanese Yen" },
+  KRW: { code: "KRW", decimals: 0, name: "South Korean Won" },
+  KWD: { code: "KWD", decimals: 3, name: "Kuwaiti Dinar" },
+  MXN: { code: "MXN", decimals: 2, name: "Mexican Peso" },
+  MYR: { code: "MYR", decimals: 2, name: "Malaysian Ringgit" },
+  NOK: { code: "NOK", decimals: 2, name: "Norwegian Krone" },
+  NZD: { code: "NZD", decimals: 2, name: "New Zealand Dollar" },
+  PHP: { code: "PHP", decimals: 2, name: "Philippine Peso" },
+  PLN: { code: "PLN", decimals: 2, name: "Polish Zloty" },
+  RON: { code: "RON", decimals: 2, name: "Romanian Leu" },
+  SAR: { code: "SAR", decimals: 2, name: "Saudi Riyal" },
+  SEK: { code: "SEK", decimals: 2, name: "Swedish Krona" },
+  SGD: { code: "SGD", decimals: 2, name: "Singapore Dollar" },
+  THB: { code: "THB", decimals: 2, name: "Thai Baht" },
+  TRY: { code: "TRY", decimals: 2, name: "Turkish Lira" },
+  TWD: { code: "TWD", decimals: 2, name: "New Taiwan Dollar" },
+  USD: { code: "USD", decimals: 2, name: "US Dollar" },
+  VND: { code: "VND", decimals: 0, name: "Vietnamese Dong" },
+  ZAR: { code: "ZAR", decimals: 2, name: "South African Rand" }
+};
+
+// src/errors.ts
+var MonetaError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MonetaError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var CurrencyMismatchError = class extends MonetaError {
+  expected;
+  received;
+  constructor(expected, received) {
+    super(
+      `Currency mismatch: cannot operate on ${expected} and ${received}. Convert to a common currency first.`
+    );
+    this.name = "CurrencyMismatchError";
+    this.expected = expected;
+    this.received = received;
+  }
+};
+var InvalidAmountError = class extends MonetaError {
+  input;
+  constructor(input) {
+    super(
+      `Invalid amount: "${String(input)}". Expected a numeric string (e.g. "19.99"), a number, or a bigint.`
+    );
+    this.name = "InvalidAmountError";
+    this.input = input;
+  }
+};
+var DivisionByZeroError = class extends MonetaError {
+  constructor() {
+    super("Division by zero is not allowed.");
+    this.name = "DivisionByZeroError";
+  }
+};
+var UnknownCurrencyError = class extends MonetaError {
+  currency;
+  constructor(currency) {
+    super(
+      `Unknown currency code: "${currency}". See the CurrencyCode type for supported currencies.`
+    );
+    this.name = "UnknownCurrencyError";
+    this.currency = currency;
+  }
+};
+
+// src/money.ts
+var AMOUNT_PATTERN = /^-?\d+(\.\d+)?$/;
+function parseToMinorUnits(input, decimals) {
+  if (typeof input === "bigint") return input;
+  const str = typeof input === "number" ? input.toFixed(decimals) : input.trim();
+  if (!AMOUNT_PATTERN.test(str)) {
+    throw new InvalidAmountError(str);
+  }
+  const negative = str.startsWith("-");
+  const abs = negative ? str.slice(1) : str;
+  const dotIdx = abs.indexOf(".");
+  let whole;
+  let fraction;
+  if (dotIdx === -1) {
+    whole = abs;
+    fraction = "0".repeat(decimals);
+  } else {
+    whole = abs.slice(0, dotIdx);
+    fraction = abs.slice(dotIdx + 1).padEnd(decimals, "0").slice(0, decimals);
+  }
+  const scale = 10n ** BigInt(decimals);
+  const result = BigInt(whole) * scale + BigInt(fraction);
+  return negative ? -result : result;
+}
+function minorUnitsToString(units, decimals) {
+  const negative = units < 0n;
+  const abs = negative ? -units : units;
+  const scale = 10n ** BigInt(decimals);
+  const whole = abs / scale;
+  const fraction = abs % scale;
+  const fractionStr = decimals > 0 ? `.${fraction.toString().padStart(decimals, "0")}` : "";
+  return `${negative ? "-" : ""}${whole}${fractionStr}`;
+}
+function roundDiv(numerator, denominator) {
+  if (denominator === 0n) throw new DivisionByZeroError();
+  const absN = numerator < 0n ? -numerator : numerator;
+  const absD = denominator < 0n ? -denominator : denominator;
+  const rounded = (absN + absD / 2n) / absD;
+  const negative = numerator < 0n !== denominator < 0n;
+  return negative ? -rounded : rounded;
+}
+function parseScalar(input) {
+  const f = typeof input === "number" ? input.toString() : input.trim();
+  if (!AMOUNT_PATTERN.test(f)) throw new InvalidAmountError(f);
+  const negative = f.startsWith("-");
+  const abs = negative ? f.slice(1) : f;
+  const dotIdx = abs.indexOf(".");
+  const fracLen = dotIdx === -1 ? 0 : abs.length - dotIdx - 1;
+  const precision = 10n ** BigInt(fracLen);
+  const parts = abs.split(".");
+  const whole = parts[0] ?? "";
+  const frac = parts[1] ?? "";
+  const unsigned = BigInt(whole) * precision + BigInt(frac.padEnd(fracLen, "0"));
+  return { factorBig: negative ? -unsigned : unsigned, precision };
+}
+var Money = class _Money {
+  #minorUnits;
+  #currency;
+  #decimals;
+  constructor(amount, currency) {
+    if (!(currency in CURRENCIES)) {
+      throw new UnknownCurrencyError(String(currency));
+    }
+    this.#currency = currency;
+    this.#decimals = CURRENCIES[currency].decimals;
+    this.#minorUnits = parseToMinorUnits(amount, this.#decimals);
+  }
+  // ─── Static factories ──────────────────────────────────────────────────────
+  /** Create from raw minor units (e.g. cents). Useful when reading from a database. */
+  static fromMinorUnits(units, currency) {
+    const decimals = CURRENCIES[currency].decimals;
+    return new _Money(minorUnitsToString(units, decimals), currency);
+  }
+  // ─── Accessors ─────────────────────────────────────────────────────────────
+  /** Raw amount in minor units (e.g. cents). Safe for storage and wire transfer. */
+  get minorUnits() {
+    return this.#minorUnits;
+  }
+  get currency() {
+    return this.#currency;
+  }
+  /** Human-readable decimal string, e.g. "19.99". */
+  get decimalValue() {
+    return minorUnitsToString(this.#minorUnits, this.#decimals);
+  }
+  // ─── Arithmetic ────────────────────────────────────────────────────────────
+  add(other) {
+    this.#assertSameCurrency(other);
+    return this.#fromUnits(this.#minorUnits + other.#minorUnits);
+  }
+  subtract(other) {
+    this.#assertSameCurrency(other);
+    return this.#fromUnits(this.#minorUnits - other.#minorUnits);
+  }
+  /**
+   * Multiply by a scalar. Uses half-up rounding to the currency's minor unit.
+   * @example money('10.00', 'USD').multiply(1.1)  // $11.00
+   * @example money('10.00', 'USD').multiply('1.5') // $15.00
+   */
+  multiply(factor) {
+    const { factorBig, precision } = parseScalar(factor);
+    return this.#fromUnits(roundDiv(this.#minorUnits * factorBig, precision));
+  }
+  /**
+   * Divide by a scalar. Uses half-up rounding to the currency's minor unit.
+   * @example money('10.00', 'USD').divide(3)  // $3.33
+   */
+  divide(divisor) {
+    const { factorBig, precision } = parseScalar(divisor);
+    if (factorBig === 0n) throw new DivisionByZeroError();
+    return this.#fromUnits(roundDiv(this.#minorUnits * precision, factorBig));
+  }
+  /**
+   * Allocate proportionally. The sum of all parts always equals the original —
+   * any rounding remainder is distributed to the first buckets.
+   *
+   * @example
+   * money('10.00', 'USD').allocate([1, 1, 1])
+   * // [Money('3.34'), Money('3.33'), Money('3.33')]
+   */
+  allocate(ratios) {
+    if (ratios.length === 0) throw new InvalidAmountError("ratios array must not be empty");
+    const total = ratios.reduce((a, b) => a + b, 0);
+    if (total <= 0) throw new InvalidAmountError("ratios must sum to a positive number");
+    const PRECISION = 1000000n;
+    const totalBig = BigInt(Math.round(total * Number(PRECISION)));
+    const shares = ratios.map((r) => {
+      const rBig = BigInt(Math.round(r * Number(PRECISION)));
+      return roundDiv(this.#minorUnits * rBig, totalBig);
+    });
+    let remainder = this.#minorUnits - shares.reduce((a, b) => a + b, 0n);
+    const direction = remainder > 0n ? 1n : -1n;
+    for (let i = 0; remainder !== 0n; i++) {
+      const idx = i % shares.length;
+      shares[idx] = (shares[idx] ?? 0n) + direction;
+      remainder -= direction;
+    }
+    return shares.map((u) => this.#fromUnits(u));
+  }
+  // ─── Comparison ────────────────────────────────────────────────────────────
+  equals(other) {
+    this.#assertSameCurrency(other);
+    return this.#minorUnits === other.#minorUnits;
+  }
+  greaterThan(other) {
+    this.#assertSameCurrency(other);
+    return this.#minorUnits > other.#minorUnits;
+  }
+  lessThan(other) {
+    this.#assertSameCurrency(other);
+    return this.#minorUnits < other.#minorUnits;
+  }
+  greaterThanOrEqual(other) {
+    return !this.lessThan(other);
+  }
+  lessThanOrEqual(other) {
+    return !this.greaterThan(other);
+  }
+  isZero() {
+    return this.#minorUnits === 0n;
+  }
+  isPositive() {
+    return this.#minorUnits > 0n;
+  }
+  isNegative() {
+    return this.#minorUnits < 0n;
+  }
+  abs() {
+    return this.#fromUnits(this.#minorUnits < 0n ? -this.#minorUnits : this.#minorUnits);
+  }
+  negate() {
+    return this.#fromUnits(-this.#minorUnits);
+  }
+  // ─── Formatting ────────────────────────────────────────────────────────────
+  /**
+   * Format using the platform's `Intl.NumberFormat` — no custom format strings.
+   *
+   * @example
+   * money('19.99', 'USD').format()        // "$19.99"
+   * money('19.99', 'EUR').format('de-DE') // "19,99 €"
+   */
+  format(locale) {
+    return new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency: this.#currency,
+      minimumFractionDigits: this.#decimals,
+      maximumFractionDigits: this.#decimals
+    }).format(Number(this.decimalValue));
+  }
+  // ─── Serialisation ─────────────────────────────────────────────────────────
+  /** Safe to store in JSON — no float representation. */
+  toJSON() {
+    return {
+      amount: this.decimalValue,
+      currency: this.#currency,
+      minorUnits: this.#minorUnits.toString()
+    };
+  }
+  toString() {
+    return `${this.decimalValue} ${this.#currency}`;
+  }
+  // ─── Private helpers ───────────────────────────────────────────────────────
+  #fromUnits(units) {
+    return new _Money(minorUnitsToString(units, this.#decimals), this.#currency);
+  }
+  #assertSameCurrency(other) {
+    if (this.#currency !== other.#currency) {
+      throw new CurrencyMismatchError(this.#currency, other.#currency);
+    }
+  }
+};
+
+// src/index.ts
+function money(amount, currency) {
+  return new Money(amount, currency);
+}
+
+exports.CURRENCIES = CURRENCIES;
+exports.CurrencyMismatchError = CurrencyMismatchError;
+exports.DivisionByZeroError = DivisionByZeroError;
+exports.InvalidAmountError = InvalidAmountError;
+exports.MonetaError = MonetaError;
+exports.Money = Money;
+exports.UnknownCurrencyError = UnknownCurrencyError;
+exports.money = money;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/currencies.ts","../src/errors.ts","../src/money.ts","../src/index.ts"],"names":[],"mappings":"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","file":"index.cjs","sourcesContent":["/**\n * ISO 4217 currency definitions.\n * Each entry contains the decimal precision used for minor-unit storage.\n */\nexport const CURRENCIES = {\n  AED: { code: 'AED', decimals: 2, name: 'UAE Dirham' },\n  AUD: { code: 'AUD', decimals: 2, name: 'Australian Dollar' },\n  BRL: { code: 'BRL', decimals: 2, name: 'Brazilian Real' },\n  CAD: { code: 'CAD', decimals: 2, name: 'Canadian Dollar' },\n  CHF: { code: 'CHF', decimals: 2, name: 'Swiss Franc' },\n  CNY: { code: 'CNY', decimals: 2, name: 'Chinese Yuan' },\n  CZK: { code: 'CZK', decimals: 2, name: 'Czech Koruna' },\n  DKK: { code: 'DKK', decimals: 2, name: 'Danish Krone' },\n  EUR: { code: 'EUR', decimals: 2, name: 'Euro' },\n  GBP: { code: 'GBP', decimals: 2, name: 'British Pound' },\n  HKD: { code: 'HKD', decimals: 2, name: 'Hong Kong Dollar' },\n  HUF: { code: 'HUF', decimals: 2, name: 'Hungarian Forint' },\n  IDR: { code: 'IDR', decimals: 2, name: 'Indonesian Rupiah' },\n  ILS: { code: 'ILS', decimals: 2, name: 'Israeli New Shekel' },\n  INR: { code: 'INR', decimals: 2, name: 'Indian Rupee' },\n  JPY: { code: 'JPY', decimals: 0, name: 'Japanese Yen' },\n  KRW: { code: 'KRW', decimals: 0, name: 'South Korean Won' },\n  KWD: { code: 'KWD', decimals: 3, name: 'Kuwaiti Dinar' },\n  MXN: { code: 'MXN', decimals: 2, name: 'Mexican Peso' },\n  MYR: { code: 'MYR', decimals: 2, name: 'Malaysian Ringgit' },\n  NOK: { code: 'NOK', decimals: 2, name: 'Norwegian Krone' },\n  NZD: { code: 'NZD', decimals: 2, name: 'New Zealand Dollar' },\n  PHP: { code: 'PHP', decimals: 2, name: 'Philippine Peso' },\n  PLN: { code: 'PLN', decimals: 2, name: 'Polish Zloty' },\n  RON: { code: 'RON', decimals: 2, name: 'Romanian Leu' },\n  SAR: { code: 'SAR', decimals: 2, name: 'Saudi Riyal' },\n  SEK: { code: 'SEK', decimals: 2, name: 'Swedish Krona' },\n  SGD: { code: 'SGD', decimals: 2, name: 'Singapore Dollar' },\n  THB: { code: 'THB', decimals: 2, name: 'Thai Baht' },\n  TRY: { code: 'TRY', decimals: 2, name: 'Turkish Lira' },\n  TWD: { code: 'TWD', decimals: 2, name: 'New Taiwan Dollar' },\n  USD: { code: 'USD', decimals: 2, name: 'US Dollar' },\n  VND: { code: 'VND', decimals: 0, name: 'Vietnamese Dong' },\n  ZAR: { code: 'ZAR', decimals: 2, name: 'South African Rand' },\n} as const;\n\nexport type CurrencyCode = keyof typeof CURRENCIES;\nexport type CurrencyDef = (typeof CURRENCIES)[CurrencyCode];\n","export class MonetaError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'MonetaError';\n    // Maintains proper prototype chain in transpiled ES5\n    Object.setPrototypeOf(this, new.target.prototype);\n  }\n}\n\nexport class CurrencyMismatchError extends MonetaError {\n  readonly expected: string;\n  readonly received: string;\n\n  constructor(expected: string, received: string) {\n    super(\n      `Currency mismatch: cannot operate on ${expected} and ${received}. Convert to a common currency first.`,\n    );\n    this.name = 'CurrencyMismatchError';\n    this.expected = expected;\n    this.received = received;\n  }\n}\n\nexport class InvalidAmountError extends MonetaError {\n  readonly input: unknown;\n\n  constructor(input: unknown) {\n    super(\n      `Invalid amount: \"${String(input)}\". Expected a numeric string (e.g. \"19.99\"), a number, or a bigint.`,\n    );\n    this.name = 'InvalidAmountError';\n    this.input = input;\n  }\n}\n\nexport class DivisionByZeroError extends MonetaError {\n  constructor() {\n    super('Division by zero is not allowed.');\n    this.name = 'DivisionByZeroError';\n  }\n}\n\nexport class UnknownCurrencyError extends MonetaError {\n  readonly currency: string;\n\n  constructor(currency: string) {\n    super(\n      `Unknown currency code: \"${currency}\". See the CurrencyCode type for supported currencies.`,\n    );\n    this.name = 'UnknownCurrencyError';\n    this.currency = currency;\n  }\n}\n","import { CURRENCIES, type CurrencyCode } from './currencies.js';\nimport {\n  CurrencyMismatchError,\n  DivisionByZeroError,\n  InvalidAmountError,\n  UnknownCurrencyError,\n} from './errors.js';\n\n// ─── Internal helpers ────────────────────────────────────────────────────────\n\nconst AMOUNT_PATTERN = /^-?\\d+(\\.\\d+)?$/;\n\n/**\n * Parse a decimal string or number into a BigInt in minor units.\n * \"19.99\" with decimals=2  →  1999n\n * \"-5.5\"  with decimals=2  →  -550n\n */\nfunction parseToMinorUnits(input: string | number | bigint, decimals: number): bigint {\n  if (typeof input === 'bigint') return input;\n\n  const str = typeof input === 'number' ? input.toFixed(decimals) : input.trim();\n\n  if (!AMOUNT_PATTERN.test(str)) {\n    throw new InvalidAmountError(str);\n  }\n\n  const negative = str.startsWith('-');\n  const abs = negative ? str.slice(1) : str;\n  const dotIdx = abs.indexOf('.');\n\n  let whole: string;\n  let fraction: string;\n\n  if (dotIdx === -1) {\n    whole = abs;\n    fraction = '0'.repeat(decimals);\n  } else {\n    whole = abs.slice(0, dotIdx);\n    fraction = abs\n      .slice(dotIdx + 1)\n      .padEnd(decimals, '0')\n      .slice(0, decimals);\n  }\n\n  const scale = 10n ** BigInt(decimals);\n  const result = BigInt(whole) * scale + BigInt(fraction);\n  return negative ? -result : result;\n}\n\n/**\n * Convert minor units back to a decimal string for re-parsing.\n * 1999n with decimals=2  →  \"19.99\"\n */\nfunction minorUnitsToString(units: bigint, decimals: number): string {\n  const negative = units < 0n;\n  const abs = negative ? -units : units;\n  const scale = 10n ** BigInt(decimals);\n  const whole = abs / scale;\n  const fraction = abs % scale;\n  const fractionStr = decimals > 0 ? `.${fraction.toString().padStart(decimals, '0')}` : '';\n  return `${negative ? '-' : ''}${whole}${fractionStr}`;\n}\n\n/**\n * Half-up rounding division for BigInt: round(numerator / denominator).\n */\nfunction roundDiv(numerator: bigint, denominator: bigint): bigint {\n  if (denominator === 0n) throw new DivisionByZeroError();\n  const absN = numerator < 0n ? -numerator : numerator;\n  const absD = denominator < 0n ? -denominator : denominator;\n  const rounded = (absN + absD / 2n) / absD;\n  const negative = numerator < 0n !== denominator < 0n;\n  return negative ? -rounded : rounded;\n}\n\n/**\n * Parse a scalar factor string into (factorBig, precision) where\n * the true factor = factorBig / precision.\n */\nfunction parseScalar(input: number | string): { factorBig: bigint; precision: bigint } {\n  const f = typeof input === 'number' ? input.toString() : input.trim();\n  if (!AMOUNT_PATTERN.test(f)) throw new InvalidAmountError(f);\n  const negative = f.startsWith('-');\n  const abs = negative ? f.slice(1) : f;\n  const dotIdx = abs.indexOf('.');\n  const fracLen = dotIdx === -1 ? 0 : abs.length - dotIdx - 1;\n  const precision = 10n ** BigInt(fracLen);\n  const parts = abs.split('.');\n  const whole = parts[0] ?? '';\n  const frac = parts[1] ?? '';\n  const unsigned = BigInt(whole) * precision + BigInt(frac.padEnd(fracLen, '0'));\n  return { factorBig: negative ? -unsigned : unsigned, precision };\n}\n\n// ─── Money class ─────────────────────────────────────────────────────────────\n\n/**\n * Immutable, BigInt-precision monetary value.\n *\n * The generic parameter `C` brands the currency at the type level so\n * cross-currency arithmetic is a **compile-time error**.\n *\n * @example\n * const price = money('19.99', 'USD')\n * const tax   = money('1.60',  'USD')\n * price.add(tax).format()       // \"$21.59\"\n * price.add(money('5', 'EUR'))  // TypeError: currency mismatch\n */\nexport class Money<C extends CurrencyCode = CurrencyCode> {\n  readonly #minorUnits: bigint;\n  readonly #currency: C;\n  readonly #decimals: number;\n\n  constructor(amount: string | number | bigint, currency: C) {\n    if (!(currency in CURRENCIES)) {\n      throw new UnknownCurrencyError(String(currency));\n    }\n    this.#currency = currency;\n    this.#decimals = CURRENCIES[currency].decimals;\n    this.#minorUnits = parseToMinorUnits(amount, this.#decimals);\n  }\n\n  // ─── Static factories ──────────────────────────────────────────────────────\n\n  /** Create from raw minor units (e.g. cents). Useful when reading from a database. */\n  static fromMinorUnits<C extends CurrencyCode>(units: bigint, currency: C): Money<C> {\n    const decimals = CURRENCIES[currency].decimals;\n    return new Money<C>(minorUnitsToString(units, decimals), currency);\n  }\n\n  // ─── Accessors ─────────────────────────────────────────────────────────────\n\n  /** Raw amount in minor units (e.g. cents). Safe for storage and wire transfer. */\n  get minorUnits(): bigint {\n    return this.#minorUnits;\n  }\n\n  get currency(): C {\n    return this.#currency;\n  }\n\n  /** Human-readable decimal string, e.g. \"19.99\". */\n  get decimalValue(): string {\n    return minorUnitsToString(this.#minorUnits, this.#decimals);\n  }\n\n  // ─── Arithmetic ────────────────────────────────────────────────────────────\n\n  add(other: Money<C>): Money<C> {\n    this.#assertSameCurrency(other);\n    return this.#fromUnits(this.#minorUnits + other.#minorUnits);\n  }\n\n  subtract(other: Money<C>): Money<C> {\n    this.#assertSameCurrency(other);\n    return this.#fromUnits(this.#minorUnits - other.#minorUnits);\n  }\n\n  /**\n   * Multiply by a scalar. Uses half-up rounding to the currency's minor unit.\n   * @example money('10.00', 'USD').multiply(1.1)  // $11.00\n   * @example money('10.00', 'USD').multiply('1.5') // $15.00\n   */\n  multiply(factor: number | string): Money<C> {\n    const { factorBig, precision } = parseScalar(factor);\n    return this.#fromUnits(roundDiv(this.#minorUnits * factorBig, precision));\n  }\n\n  /**\n   * Divide by a scalar. Uses half-up rounding to the currency's minor unit.\n   * @example money('10.00', 'USD').divide(3)  // $3.33\n   */\n  divide(divisor: number | string): Money<C> {\n    const { factorBig, precision } = parseScalar(divisor);\n    if (factorBig === 0n) throw new DivisionByZeroError();\n    return this.#fromUnits(roundDiv(this.#minorUnits * precision, factorBig));\n  }\n\n  /**\n   * Allocate proportionally. The sum of all parts always equals the original —\n   * any rounding remainder is distributed to the first buckets.\n   *\n   * @example\n   * money('10.00', 'USD').allocate([1, 1, 1])\n   * // [Money('3.34'), Money('3.33'), Money('3.33')]\n   */\n  allocate(ratios: readonly number[]): Money<C>[] {\n    if (ratios.length === 0) throw new InvalidAmountError('ratios array must not be empty');\n    const total = ratios.reduce((a, b) => a + b, 0);\n    if (total <= 0) throw new InvalidAmountError('ratios must sum to a positive number');\n\n    // Use large integer precision to avoid float loss in ratio math\n    const PRECISION = 1_000_000n;\n    const totalBig = BigInt(Math.round(total * Number(PRECISION)));\n\n    const shares = ratios.map((r) => {\n      const rBig = BigInt(Math.round(r * Number(PRECISION)));\n      return roundDiv(this.#minorUnits * rBig, totalBig);\n    });\n\n    // Distribute rounding remainder so that sum(shares) === this.#minorUnits\n    let remainder = this.#minorUnits - shares.reduce((a, b) => a + b, 0n);\n    const direction = remainder > 0n ? 1n : -1n;\n    for (let i = 0; remainder !== 0n; i++) {\n      const idx = i % shares.length;\n      shares[idx] = (shares[idx] ?? 0n) + direction;\n      remainder -= direction;\n    }\n\n    return shares.map((u) => this.#fromUnits(u));\n  }\n\n  // ─── Comparison ────────────────────────────────────────────────────────────\n\n  equals(other: Money<C>): boolean {\n    this.#assertSameCurrency(other);\n    return this.#minorUnits === other.#minorUnits;\n  }\n\n  greaterThan(other: Money<C>): boolean {\n    this.#assertSameCurrency(other);\n    return this.#minorUnits > other.#minorUnits;\n  }\n\n  lessThan(other: Money<C>): boolean {\n    this.#assertSameCurrency(other);\n    return this.#minorUnits < other.#minorUnits;\n  }\n\n  greaterThanOrEqual(other: Money<C>): boolean {\n    return !this.lessThan(other);\n  }\n\n  lessThanOrEqual(other: Money<C>): boolean {\n    return !this.greaterThan(other);\n  }\n\n  isZero(): boolean {\n    return this.#minorUnits === 0n;\n  }\n\n  isPositive(): boolean {\n    return this.#minorUnits > 0n;\n  }\n\n  isNegative(): boolean {\n    return this.#minorUnits < 0n;\n  }\n\n  abs(): Money<C> {\n    return this.#fromUnits(this.#minorUnits < 0n ? -this.#minorUnits : this.#minorUnits);\n  }\n\n  negate(): Money<C> {\n    return this.#fromUnits(-this.#minorUnits);\n  }\n\n  // ─── Formatting ────────────────────────────────────────────────────────────\n\n  /**\n   * Format using the platform's `Intl.NumberFormat` — no custom format strings.\n   *\n   * @example\n   * money('19.99', 'USD').format()        // \"$19.99\"\n   * money('19.99', 'EUR').format('de-DE') // \"19,99 €\"\n   */\n  format(locale?: string): string {\n    return new Intl.NumberFormat(locale, {\n      style: 'currency',\n      currency: this.#currency,\n      minimumFractionDigits: this.#decimals,\n      maximumFractionDigits: this.#decimals,\n    }).format(Number(this.decimalValue));\n  }\n\n  // ─── Serialisation ─────────────────────────────────────────────────────────\n\n  /** Safe to store in JSON — no float representation. */\n  toJSON(): { amount: string; currency: C; minorUnits: string } {\n    return {\n      amount: this.decimalValue,\n      currency: this.#currency,\n      minorUnits: this.#minorUnits.toString(),\n    };\n  }\n\n  toString(): string {\n    return `${this.decimalValue} ${this.#currency}`;\n  }\n\n  // ─── Private helpers ───────────────────────────────────────────────────────\n\n  #fromUnits(units: bigint): Money<C> {\n    return new Money<C>(minorUnitsToString(units, this.#decimals), this.#currency);\n  }\n\n  #assertSameCurrency(other: Money<C>): void {\n    if (this.#currency !== other.#currency) {\n      throw new CurrencyMismatchError(this.#currency, other.#currency as string);\n    }\n  }\n}\n","export { Money } from './money.js';\nexport { CURRENCIES } from './currencies.js';\nexport type { CurrencyCode, CurrencyDef } from './currencies.js';\nexport {\n  MonetaError,\n  CurrencyMismatchError,\n  DivisionByZeroError,\n  InvalidAmountError,\n  UnknownCurrencyError,\n} from './errors.js';\n\nimport type { CurrencyCode } from './currencies.js';\nimport { Money } from './money.js';\n\n/**\n * Create a Money value. This is the primary entry point.\n *\n * @example\n * import { money } from 'moneta'\n *\n * const price = money('19.99', 'USD')\n * const tax   = money('1.60',  'USD')\n * price.add(tax).format()  // \"$21.59\"\n */\nexport function money<C extends CurrencyCode>(\n  amount: string | number | bigint,\n  currency: C,\n): Money<C> {\n  return new Money(amount, currency);\n}\n"]}