@arki/money 0.0.0-stage → 0.0.4

package/src/currency.ts

@@ -0,0 +1,174 @@
+/**
+ * Currencies. The ISO 4217 list ships with the package, so a currency's number
+ * of decimals is the same on every runtime and device. `Intl` is only used for
+ * display (see `@arki/money/format`); it accepts made-up codes such as `ZZZ`
+ * and its decimals can differ from ISO, so it never decides arithmetic.
+ *
+ * `Currency.of('EUR')` returns the same object every time, so comparing two
+ * currencies is a pointer check on the hot path.
+ */
+
+import { InvalidArgumentError } from '@arki/math/errors';
+
+import { ISO_4217 } from './data/iso4217.js';
+import { CurrencyMismatchError, UnknownCurrencyError } from './errors.js';
+import { MAX_SCALE } from './internal/units.js';
+
+export { ISO_4217_VERSION } from './data/iso4217.js';
+
+const BRAND = Symbol('Currency');
+const CUSTOM_CODE = /^[a-z][\w.:-]{0,31}$/i;
+
+let byCode: Map<string, Currency> | undefined;
+let byNumeric: Map<string, Currency> | undefined;
+
+/** A currency, or the code of an ISO 4217 currency. */
+export type CurrencyLike<C extends string = string> = C | Currency<C>;
+
+/** What `Currency.custom` needs. */
+export type CurrencyDefinition<C extends string = string> = {
+  /** Letters, digits and `. _ : -`, up to 32 characters, not an ISO 4217 code: `'BTC'`, `'crypto:ETH'`, `'points'`. */
+  code: C;
+  /** Number of decimals, 0–100: 8 for BTC, 18 for ETH, 0 for loyalty points. */
+  scale: number;
+  /** Optional three-digit numeric code. */
+  numeric?: string;
+};
+
+/** An immutable currency: its code, its ISO numeric code and its number of decimals. */
+export class Currency<C extends string = string> {
+  /** `'EUR'`. */
+  readonly code: C;
+  /** Three-digit ISO numeric code as a string, so `'008'` keeps its zeros. `undefined` for most custom currencies. */
+  readonly numeric: string | undefined;
+  /** Number of decimals: 2 for EUR, 0 for JPY, 3 for KWD. ISO codes without minor units (XAU, XTS) use 0. */
+  readonly scale: number;
+  /** `true` for a currency from the shipped ISO 4217 table. */
+  readonly iso: boolean;
+
+  private constructor(code: C, numeric: string | undefined, scale: number, iso: boolean, brand: typeof BRAND) {
+    if (brand !== BRAND) throw new TypeError('Use Currency.of(code) or Currency.custom(definition)');
+    this.code = code;
+    this.numeric = numeric;
+    this.scale = scale;
+    this.iso = iso;
+    Object.freeze(this);
+  }
+
+  /**
+   * The ISO 4217 currency with this upper-case code: `Currency.of('EUR')`.
+   * Throws `UnknownCurrencyError` for anything not in the table, including `'eur'`.
+   */
+  static of<const C extends string>(code: C): Currency<C> {
+    const found = Currency.table().get(code);
+    if (found === undefined || !hasCode(found, code)) throw new UnknownCurrencyError(String(code));
+    return found;
+  }
+
+  /** The ISO 4217 currency with this numeric code: `Currency.fromNumeric('978')` or `(978)` → EUR. */
+  static fromNumeric(numeric: string | number): Currency {
+    const key = typeof numeric === 'number' ? String(numeric).padStart(3, '0') : numeric;
+    if (byNumeric === undefined) {
+      byNumeric = new Map();
+      for (const currency of Currency.table().values()) {
+        if (currency.numeric !== undefined) byNumeric.set(currency.numeric, currency);
+      }
+    }
+    const found = byNumeric.get(key);
+    if (found === undefined) throw new UnknownCurrencyError(key);
+    return found;
+  }
+
+  /**
+   * A currency that is not in ISO 4217: crypto, loyalty points, a withdrawn
+   * currency you still hold data in. It is not registered anywhere; keep the
+   * object and pass it where you would pass a code. Two custom currencies with
+   * the same code and scale are treated as the same currency.
+   */
+  static custom<const C extends string>(definition: CurrencyDefinition<C>): Currency<C> {
+    const { code, scale, numeric } = definition;
+    if (typeof code !== 'string' || !CUSTOM_CODE.test(code)) {
+      throw new InvalidArgumentError(
+        `A currency code is 1–32 letters, digits or ". _ : -", starting with a letter; got ${JSON.stringify(code)}`,
+      );
+    }
+    if (Currency.table().has(code)) {
+      throw new InvalidArgumentError(`${code} is an ISO 4217 currency; use Currency.of('${code}')`);
+    }
+    if (!Number.isInteger(scale) || scale < 0 || scale > MAX_SCALE) {
+      throw new InvalidArgumentError(`A currency scale is a whole number from 0 to ${MAX_SCALE}, got ${scale}`);
+    }
+    if (numeric !== undefined && !/^\d{3}$/.test(numeric)) {
+      throw new InvalidArgumentError(`A numeric currency code has three digits, got ${JSON.stringify(numeric)}`);
+    }
+    return new Currency(code, numeric, scale, false, BRAND);
+  }
+
+  /** `true` when `code` is in the shipped ISO 4217 table. */
+  static isKnown(code: string): boolean {
+    return Currency.table().has(code);
+  }
+
+  /** Every ISO 4217 code in the shipped table, sorted. */
+  static codes(): string[] {
+    return [...Currency.table().keys()];
+  }
+
+  /** Same code and same scale. */
+  eq(other: Currency): boolean {
+    return this === other || (this.code === other.code && this.scale === other.scale);
+  }
+
+  toString(): C {
+    return this.code;
+  }
+
+  toJSON(): C {
+    return this.code;
+  }
+
+  [Symbol.for('nodejs.util.inspect.custom')](): string {
+    return `Currency(${this.code})`;
+  }
+
+  [Symbol.for('Deno.customInspect')](): string {
+    return `Currency(${this.code})`;
+  }
+
+  /** Decodes the packed table on first use. */
+  private static table(): Map<string, Currency> {
+    if (byCode !== undefined) return byCode;
+    const table = new Map<string, Currency>();
+    for (let i = 0; i < ISO_4217.length; i += 7) {
+      const code = ISO_4217.slice(i, i + 3);
+      const digit = ISO_4217.charAt(i + 6);
+      table.set(code, new Currency(code, ISO_4217.slice(i + 3, i + 6), digit === '-' ? 0 : Number(digit), true, BRAND));
+    }
+    byCode = table;
+    return table;
+  }
+}
+
+function hasCode<C extends string>(currency: Currency, code: C): currency is Currency<C> {
+  return currency.code === code;
+}
+
+/** Accepts a `Currency` or an ISO code. */
+export function toCurrency<C extends string>(currency: CurrencyLike<C>): Currency<C> {
+  if (currency instanceof Currency) return currency;
+  if (typeof currency !== 'string') throw new TypeError('Expected a currency code or a Currency');
+  return Currency.of(currency);
+}
+
+/** Finds a currency by code among `custom`, then in the ISO table. */
+export function resolveCurrency(code: string, custom: readonly Currency[] | undefined): Currency {
+  if (custom !== undefined) {
+    for (const currency of custom) if (currency.code === code) return currency;
+  }
+  return Currency.of(code);
+}
+
+/** Throws `CurrencyMismatchError` unless the two are the same currency. */
+export function assertSameCurrency(a: Currency, b: Currency): void {
+  if (a !== b && (a.code !== b.code || a.scale !== b.scale)) throw new CurrencyMismatchError(a.code, b.code);
+}

package/src/data/iso4217.ts

@@ -0,0 +1,13 @@
+// Generated by scripts/generate-iso4217.mjs. Do not edit by hand.
+// Source: ISO 4217 list one, published by SIX on 2026-09-17. 178 currencies.
+
+/** Publication date of the ISO 4217 list this table was built from. */
+export const ISO_4217_VERSION = '2026-09-17';
+
+/**
+ * Every active ISO 4217 currency, 7 characters each: alphabetic code (3),
+ * numeric code (3), minor-unit digits (1). '-' marks a code with no minor
+ * unit in ISO (gold, the test code, ...); those are treated as 0 digits.
+ */
+export const ISO_4217 =
+  'AED7842AFN9712ALL0082AMD0512AOA9732ARS0322AUD0362AWG5332AZN9442BAM9772BBD0522BDT0502BHD0483BIF1080BMD0602BND0962BOB0682BOV9842BRL9862BSD0442BTN0642BWP0722BYN9332BZD0842CAD1242CDF9762CHE9472CHF7562CHW9482CLF9904CLP1520CNY1562COP1702COU9702CRC1882CUP1922CVE1322CZK2032DJF2620DKK2082DOP2142DZD0122EGP8182ERN2322ETB2302EUR9782FJD2422FKP2382GBP8262GEL9812GHS9362GIP2922GMD2702GNF3240GTQ3202GYD3282HKD3442HNL3402HTG3322HUF3482IDR3602ILS3762INR3562IQD3683IRR3642ISK3520JMD3882JOD4003JPY3920KES4042KGS4172KHR1162KMF1740KPW4082KRW4100KWD4143KYD1362KZT3982LAK4182LBP4222LKR1442LRD4302LSL4262LYD4343MAD5042MDL4982MGA9692MKD8072MMK1042MNT4962MOP4462MRU9292MUR4802MVR4622MWK4542MXN4842MXV9792MYR4582MZN9432NAD5162NGN5662NIO5582NOK5782NPR5242NZD5542OMR5123PAB5902PEN6042PGK5982PHP6082PKR5862PLN9852PYG6000QAR6342RON9462RSD9412RUB6432RWF6460SAR6822SBD0902SCR6902SDG9382SEK7522SGD7022SHP6542SLE9252SOS7062SRD9682SSP7282STN9302SVC2222SYP7602SZL7482THB7642TJS9722TMT9342TND7883TOP7762TRY9492TTD7802TWD9012TZS8342UAH9802UGX8000USD8402USN9972UYI9400UYU8582UYW9274UZS8602VED9262VES9282VND7040VUV5480WST8822XAD3962XAF9500XAG961-XAU959-XBA955-XBB956-XBC957-XBD958-XCD9512XCG5322XDR960-XOF9520XPD964-XPF9530XPT962-XSU994-XTS963-XUA965-XXX999-YER8862ZAR7102ZMW9672ZWG9242';

package/src/drizzle/config.ts

@@ -0,0 +1,39 @@
+/** Column options shared by every SQL dialect. */
+
+import type { Currency, CurrencyLike } from '../currency.js';
+import { toCurrency } from '../currency.js';
+import { InvalidArgumentError } from '../errors.js';
+import { MAX_SCALE } from '../internal/units.js';
+
+export type MoneyMinorConfig<C extends string> = {
+  currency: CurrencyLike<C>;
+  /** Decimals the stored integer carries. Defaults to the currency's. */
+  scale?: number;
+};
+
+export type MoneyDecimalConfig<C extends string> = {
+  currency: CurrencyLike<C>;
+  /** Total digits, as in `numeric(precision, scale)`. Default 19. Ignored by SQLite. */
+  precision?: number;
+  /** Decimals stored. Defaults to the currency's. */
+  scale?: number;
+};
+
+export type MoneyJsonConfig = {
+  /** Custom currencies to resolve by code on read. */
+  currencies?: readonly Currency[];
+};
+
+/** Validates a column config once, when the table is defined. */
+export function resolveColumn<C extends string>(
+  config: { currency: CurrencyLike<C>; scale?: number } | undefined,
+  column: string,
+): { currency: Currency<C>; scale: number } {
+  if (config === undefined) throw new InvalidArgumentError(`${column} needs a config with a currency`);
+  const currency = toCurrency(config.currency);
+  const scale = config.scale ?? currency.scale;
+  if (!Number.isInteger(scale) || scale < 0 || scale > MAX_SCALE) {
+    throw new InvalidArgumentError(`${column}: scale must be a whole number from 0 to ${MAX_SCALE}, got ${scale}`);
+  }
+  return { currency, scale };
+}

package/src/drizzle/mysql.ts

@@ -0,0 +1,61 @@
+/**
+ * Drizzle columns for MySQL and MariaDB that read and write `Money`.
+ * Optional: needs `drizzle-orm` 1.x installed.
+ *
+ * - `moneyMinor(name, { currency })` — a `bigint` column of minor units ↔ `Money<C>`.
+ * - `moneyDecimal(name, { currency, precision, scale })` — a `decimal` column ↔ `Money<C>`.
+ * - `moneyJson(name)` — a `json` column of `{ amount, currency }` ↔ `Money` in any currency.
+ *
+ * `mysql2` returns `DECIMAL` as text and `JSON` as parsed objects by default,
+ * and the `bigint` column declares a text codec, so no value passes through a
+ * float. If a driver still returns a big integer as an unsafe `number`, reading
+ * it throws instead of returning a wrong amount.
+ */
+
+import { customType } from 'drizzle-orm/mysql-core';
+
+import type { IntegerDriverValue } from '../internal/columns.js';
+import type { Money } from '../money.js';
+import type { MoneyDecimalConfig, MoneyJsonConfig, MoneyMinorConfig } from './config.js';
+import {
+  decimalFromDriver,
+  decimalToDriver,
+  jsonFromDriver,
+  jsonToDriver,
+  minorFromDriver,
+  minorToDriver,
+} from '../internal/columns.js';
+import { resolveColumn } from './config.js';
+
+export type { MoneyDecimalConfig, MoneyJsonConfig, MoneyMinorConfig } from './config.js';
+
+/** `bigint` column ↔ `Money<C>` in one fixed currency. */
+export function moneyMinor<const C extends string>(name: string, config: MoneyMinorConfig<C>) {
+  const { currency, scale } = resolveColumn(config, 'moneyMinor');
+  return customType<{ data: Money<C>; driverData: IntegerDriverValue; config: MoneyMinorConfig<C> }>({
+    dataType: () => 'bigint',
+    codec: 'bigint:string',
+    toDriver: value => String(minorToDriver(value, currency, scale)),
+    fromDriver: value => minorFromDriver(value, currency, scale),
+  })(name, config);
+}
+
+/** `decimal(precision, scale)` column ↔ `Money<C>` in one fixed currency. */
+export function moneyDecimal<const C extends string>(name: string, config: MoneyDecimalConfig<C>) {
+  const { currency, scale } = resolveColumn(config, 'moneyDecimal');
+  const precision = config.precision ?? 19;
+  return customType<{ data: Money<C>; driverData: string | number; config: MoneyDecimalConfig<C> }>({
+    dataType: () => `decimal(${precision}, ${scale})`,
+    toDriver: value => decimalToDriver(value, currency, scale),
+    fromDriver: value => decimalFromDriver(value, currency, scale),
+  })(name, config);
+}
+
+/** `json` column of `{ amount, currency }` ↔ `Money` in any currency. */
+export function moneyJson(name: string, config: MoneyJsonConfig = {}) {
+  return customType<{ data: Money; driverData: unknown; config: MoneyJsonConfig }>({
+    dataType: () => 'json',
+    toDriver: jsonToDriver,
+    fromDriver: value => jsonFromDriver(value, config.currencies),
+  })(name, config);
+}

package/src/drizzle/pg.ts

@@ -0,0 +1,64 @@
+/**
+ * Drizzle columns for Postgres that read and write `Money`. Optional: needs
+ * `drizzle-orm` 1.x installed.
+ *
+ * - `moneyMinor(name, { currency })` — a `bigint` column of minor units for one
+ *   fixed currency ↔ `Money<C>`. Best for sums in SQL.
+ * - `moneyDecimal(name, { currency, precision, scale })` — a `numeric` column ↔
+ *   `Money<C>`. Readable in SQL tools; holds more decimals than the currency.
+ * - `moneyJson(name)` — a `jsonb` column of `{ amount, currency }` ↔ `Money`
+ *   in any currency. For prices that vary by row.
+ *
+ * The columns declare text codecs, so every driver (node-postgres,
+ * postgres.js, PGlite, Bun SQL) hands back text and no value passes through a
+ * float. Writing a `Money` in another currency, or with more decimals than the
+ * column holds, throws instead of storing a wrong value.
+ */
+
+import { customType } from 'drizzle-orm/pg-core';
+
+import type { Money } from '../money.js';
+import type { MoneyDecimalConfig, MoneyJsonConfig, MoneyMinorConfig } from './config.js';
+import {
+  decimalFromDriver,
+  decimalToDriver,
+  jsonFromDriver,
+  jsonToDriver,
+  minorFromDriver,
+  minorToDriver,
+} from '../internal/columns.js';
+import { resolveColumn } from './config.js';
+
+export type { MoneyDecimalConfig, MoneyJsonConfig, MoneyMinorConfig } from './config.js';
+
+/** `bigint` column ↔ `Money<C>` in one fixed currency. */
+export function moneyMinor<const C extends string>(name: string, config: MoneyMinorConfig<C>) {
+  const { currency, scale } = resolveColumn(config, 'moneyMinor');
+  return customType<{ data: Money<C>; driverData: string; config: MoneyMinorConfig<C> }>({
+    dataType: () => 'bigint',
+    codec: 'bigint:string',
+    toDriver: value => String(minorToDriver(value, currency, scale)),
+    fromDriver: value => minorFromDriver(value, currency, scale),
+  })(name, config);
+}
+
+/** `numeric(precision, scale)` column ↔ `Money<C>` in one fixed currency. */
+export function moneyDecimal<const C extends string>(name: string, config: MoneyDecimalConfig<C>) {
+  const { currency, scale } = resolveColumn(config, 'moneyDecimal');
+  const precision = config.precision ?? 19;
+  return customType<{ data: Money<C>; driverData: string; config: MoneyDecimalConfig<C> }>({
+    dataType: () => `numeric(${precision}, ${scale})`,
+    codec: 'numeric',
+    toDriver: value => decimalToDriver(value, currency, scale),
+    fromDriver: value => decimalFromDriver(value, currency, scale),
+  })(name, config);
+}
+
+/** `jsonb` column of `{ amount, currency }` ↔ `Money` in any currency. */
+export function moneyJson(name: string, config: MoneyJsonConfig = {}) {
+  return customType<{ data: Money; driverData: string; config: MoneyJsonConfig }>({
+    dataType: () => 'jsonb',
+    toDriver: jsonToDriver,
+    fromDriver: value => jsonFromDriver(value, config.currencies),
+  })(name, config);
+}

package/src/drizzle/sqlite.ts

@@ -0,0 +1,61 @@
+/**
+ * Drizzle columns for SQLite (libSQL, Turso, better-sqlite3, Bun SQLite,
+ * Cloudflare D1, Expo SQLite) that read and write `Money`. Optional: needs
+ * `drizzle-orm` 1.x installed.
+ *
+ * - `moneyMinor(name, { currency })` — an `integer` column of minor units ↔ `Money<C>`.
+ * - `moneyDecimal(name, { currency, scale })` — a `text` column of exact decimal
+ *   text ↔ `Money<C>`. SQLite has no exact decimal type, so text keeps every digit.
+ * - `moneyJson(name)` — a `text` column of `{ amount, currency }` JSON ↔ `Money`.
+ *
+ * SQLite integers are 64-bit, but most drivers return JavaScript numbers.
+ * Amounts up to 2^53 minor units are exact. A bigger stored amount throws on
+ * read instead of becoming a wrong value; to read those, switch the driver to
+ * big integers (libSQL `intMode: 'bigint'`, better-sqlite3 `safeIntegers()`).
+ */
+
+import { customType } from 'drizzle-orm/sqlite-core';
+
+import type { IntegerDriverValue } from '../internal/columns.js';
+import type { Money } from '../money.js';
+import type { MoneyDecimalConfig, MoneyJsonConfig, MoneyMinorConfig } from './config.js';
+import {
+  decimalFromDriver,
+  decimalToDriver,
+  jsonFromDriver,
+  jsonToDriver,
+  minorFromDriver,
+  minorToDriver,
+} from '../internal/columns.js';
+import { resolveColumn } from './config.js';
+
+export type { MoneyDecimalConfig, MoneyJsonConfig, MoneyMinorConfig } from './config.js';
+
+/** `integer` column ↔ `Money<C>` in one fixed currency. Writes a `bigint` past 2^53. */
+export function moneyMinor<const C extends string>(name: string, config: MoneyMinorConfig<C>) {
+  const { currency, scale } = resolveColumn(config, 'moneyMinor');
+  return customType<{ data: Money<C>; driverData: IntegerDriverValue; config: MoneyMinorConfig<C> }>({
+    dataType: () => 'integer',
+    toDriver: value => minorToDriver(value, currency, scale),
+    fromDriver: value => minorFromDriver(value, currency, scale),
+  })(name, config);
+}
+
+/** `text` column of exact decimal text ↔ `Money<C>` in one fixed currency. */
+export function moneyDecimal<const C extends string>(name: string, config: MoneyDecimalConfig<C>) {
+  const { currency, scale } = resolveColumn(config, 'moneyDecimal');
+  return customType<{ data: Money<C>; driverData: string; config: MoneyDecimalConfig<C> }>({
+    dataType: () => 'text',
+    toDriver: value => decimalToDriver(value, currency, scale),
+    fromDriver: value => decimalFromDriver(value, currency, scale),
+  })(name, config);
+}
+
+/** `text` column of `{ amount, currency }` JSON ↔ `Money` in any currency. */
+export function moneyJson(name: string, config: MoneyJsonConfig = {}) {
+  return customType<{ data: Money; driverData: string; config: MoneyJsonConfig }>({
+    dataType: () => 'text',
+    toDriver: jsonToDriver,
+    fromDriver: value => jsonFromDriver(value, config.currencies),
+  })(name, config);
+}

package/src/errors.ts

@@ -0,0 +1,61 @@
+/**
+ * Every failure this package raises on purpose extends `MathError` from
+ * `@arki/math`, so one `instanceof MathError` catches both libraries. The
+ * money-only failures also extend `MoneyError`. Wrong runtime types (a number
+ * where a `Money` was required, or `money + 1`) throw the built-in `TypeError`.
+ * Nothing here returns `NaN` or `null` as a hidden failure channel.
+ */
+
+import { MathError } from '@arki/math/errors';
+
+export {
+  DivisionByZeroError,
+  EmptyDataError,
+  InvalidArgumentError,
+  MathError,
+  NumberFormatError,
+  NumericRangeError,
+  ResourceLimitError,
+  RoundingNecessaryError,
+  UnsupportedFeatureError,
+} from '@arki/math/errors';
+
+/** Base class of the failures that only money can have. */
+export class MoneyError extends MathError {}
+
+/** Two amounts in different currencies were combined or compared. */
+export class CurrencyMismatchError extends MoneyError {
+  /** Code of the currency on the left-hand side. */
+  readonly left: string;
+  /** Code of the currency on the right-hand side. */
+  readonly right: string;
+
+  constructor(left: string, right: string) {
+    super(
+      left === right
+        ? `Cannot combine two different definitions of ${left}; they disagree on the number of decimals`
+        : `Cannot combine ${left} with ${right}`,
+    );
+    this.left = left;
+    this.right = right;
+  }
+}
+
+/** The code is not in the shipped ISO 4217 table and no custom currency was supplied for it. */
+export class UnknownCurrencyError extends MoneyError {
+  readonly code: string;
+
+  constructor(code: string) {
+    super(
+      `Unknown currency ${JSON.stringify(code)}. ISO 4217 codes are three upper-case letters; ` +
+        'for anything else create one with Currency.custom()',
+    );
+    this.code = code;
+  }
+}
+
+/** No exchange rate is known for the pair, or a rate is invalid (zero, negative, conflicting). */
+export class ExchangeRateError extends MoneyError {}
+
+/** An amount cannot be expressed in a payment provider's units (fraction it does not accept, wrong step, unsupported currency). */
+export class ProviderAmountError extends MoneyError {}

package/src/exact.ts

@@ -0,0 +1,29 @@
+/**
+ * Bridges to `@arki/math`'s exact types, for multi-step math that should
+ * round only once at the end:
+ *
+ * ```ts
+ * const share = toRational(price).times(ratio(1, 3)).plus(ratio(1, 7));
+ * Money.of(share, 'EUR', { rounding: 'halfEven' }); // Money.of reads Decimal and Rational directly
+ * ```
+ *
+ * Kept in its own entry point so the core never loads the `Decimal` and
+ * `Rational` classes.
+ */
+
+import type { Decimal } from '@arki/math/decimal';
+import type { Rational } from '@arki/math/rational';
+import { decimal } from '@arki/math/decimal';
+import { ratio } from '@arki/math/rational';
+
+import type { Money } from './money.js';
+
+/** `19.99 EUR` → `Decimal('19.99')`, keeping the scale. */
+export function toDecimal(money: Money): Decimal {
+  return decimal(money.toDecimalString());
+}
+
+/** `19.99 EUR` → `1999/100`, reduced. */
+export function toRational(money: Money): Rational {
+  return ratio(BigInt(money.units), 10n ** BigInt(money.scale));
+}