@amboras-dev/money 0.0.0-stage → 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,300 @@
+import { A as isCurrencyCode, C as currencyInfo, D as currencySymbol, E as currencyOptions, F as sameCurrency, I as storageDigits, L as storageScale, M as medusaCurrencyCode, N as medusaEpsilon, O as displayDigits, P as parseCurrencyCode, R as DecimalText, S as currencyCode, T as currencyName, _ as CurrencyCodeOptions, a as ReadStoredOptions, b as FractionDigits, c as ToMajorDecimalOptions, d as money, f as readStored, g as CurrencyCode, h as CURRENCIES, i as Money, j as localeForCurrency, k as firstCurrency, l as fromMajor, m as toMajorNumber, n as FromMajorOptions, o as StoredAmount, p as toMajorDecimal, r as MajorDecimal, s as StoredAmountOptions, t as FractionalMoney, u as isStoredAmount, v as CurrencyInfo, w as currencyLabel, x as StorageScale, y as CurrencyStatus, z as RoundingMode } from "./money-B-3aFjNJ.js";
+import { a as isPositiveAmount, c as readCalculatedPrice, d as readStoredLiteral, f as toMedusaAmountInput, i as ReadStoredDecimalOptions, l as readStoredDecimal, n as MoneyByCurrency, o as moneyByCurrency, p as toMedusaRaw, r as PriceLike, s as moneyFor, t as MedusaRaw, u as readStoredField } from "./medusa-DBXJXXvF.js";
+//#region src/allocate.d.ts
+/**
+ * Where the rounding remainder goes:
+ * - `'largest-remainder'` (default; promotion parity engine): floor every share, then +1 unit
+ *   to the largest fractional parts, ties to the lower index.
+ * - `'largest-weight'` (subscription offers): every share but the first largest-weight one is
+ *   rounded half-up; that one absorbs the rest. A deficit it cannot absorb is taken from the
+ *   others in descending weight order, so the sum stays exact and no share goes negative.
+ * - `'last'` (Shopify archive, inventory extra costs): floor every share; the last positive
+ *   weight absorbs the remainder.
+ * - `'last-first'` (draft discounts): shares rounded half-up and capped at `caps`, the target
+ *   being `min(total, sum(caps))`; the remainder then moves from the last share backwards,
+ *   each kept within `[0, cap]`.
+ * - `'cumulative'` (cash on delivery): each share is the difference of the rounded running
+ *   pro-rata total.
+ */
+type AllocationStrategy = 'largest-remainder' | 'largest-weight' | 'last' | 'last-first' | 'cumulative';
+type AllocationWeight = number | DecimalText | Money;
+interface AllocateOptions {
+  /** Default `'largest-remainder'`. */
+  strategy?: AllocationStrategy;
+  /** The unit shares are whole multiples of: `'storage'` (default), `'currency'`, or `{ step }` storage units (COD whole dong: 100). */
+  unit?: 'storage' | 'currency' | {
+    step: number;
+  };
+  /** Per-share caps for `'last-first'`; default: the weights, when they are Money. */
+  caps?: readonly Money[];
+}
+/**
+ * `total` split in proportion to `weights` so the shares add up to it exactly (see
+ * `AllocationStrategy` for where the remainder goes). Shares are whole `unit`s; `total`
+ * must be one (else `precision`: round it with `roundToUnit` first). Weights must be
+ * non-negative (else `amount_invalid`); all-zero weights give all-zero shares and need a
+ * zero total. A negative total is allocated by magnitude and negated.
+ *
+ * The DecimalText overload splits exact decimals at `scale` fraction digits (inventory extra
+ * costs at 4, sub-cent USD at 6); it has no caps, so `'last-first'` is Money-only.
+ */
+export declare function allocate(total: Money, weights: readonly AllocationWeight[], options?: AllocateOptions): Money[];
+export declare function allocate(total: DecimalText, weights: readonly AllocationWeight[], options: Omit<AllocateOptions, 'unit' | 'caps'> & {
+  scale: number;
+}): DecimalText[];
+interface WaterfallResult {
+  readonly allocations: Money[];
+  readonly shortfall: Money;
+}
+/**
+ * Greedy capped allocation in the given order: `take_i = min(left, cap_i)`; `shortfall` is
+ * what could not be placed. With `allOrNothing`, a shortfall allocates nothing (all zeros,
+ * `shortfall = amount`). Negative caps or amount throw `amount_invalid`; all one currency.
+ */
+export declare function allocateWaterfall(caps: readonly Money[], amount: Money, options?: {
+  allOrNothing?: boolean;
+}): WaterfallResult;
+interface UnitPricePart {
+  readonly quantity: number;
+  readonly unitPrice: Money;
+}
+/**
+ * A line total charged at one unit price, or split in two parts one `unit` apart when it does
+ * not divide by `quantity`, so `sum(quantity x unitPrice) === net` exactly (JPY 100000 x 3
+ * gives `2 @ 33333`, `1 @ 33334`). Zero-quantity parts are omitted. `quantity` must be a
+ * positive integer; `net` a whole `unit` (else `precision`).
+ */
+export declare function splitUnitPrice(net: Money, quantity: number, options?: {
+  unit?: 'storage' | 'currency';
+}): UnitPricePart[];
+//#endregion
+//#region src/rounding.d.ts
+/**
+ * - `'storage'`: one storage unit (USD 1 cent, JPY 1/100 yen).
+ * - `'currency'`: the smallest unit the currency stores, 10^-storageDigits major (JPY 1 yen
+ *   = 100 storage units, USD and IDR 1 cent = 1, KWD and IQD 1 fils = 1). Keyed on storage
+ *   digits, as Medusa `roundToDisplayUnit` is, so stored prices and checkout agree.
+ * - `'major'`: one whole major unit (USD 100, JPY 100, KWD 1000).
+ */
+type AmountUnit = 'storage' | 'currency' | 'major';
+interface RoundToUnitOptions {
+  /** Default `'storage'`. */
+  unit?: AmountUnit;
+  /** Default `'half-up'`. */
+  rounding?: RoundingMode;
+}
+/**
+ * A stored amount (possibly fractional: a percentage of a price, a pro-rated fee) rounded to
+ * a whole `unit` with `rounding`, as Money. Replaces `roundToStorageUnit`,
+ * `roundToDisplayUnit` (`unit: 'currency'`), `Math.floor(round2(x))` (`rounding: 'floor'`).
+ * A Money input must be in `currency`; a number must be finite; text is plain decimal.
+ */
+export declare function roundToUnit(value: Money | DecimalText | number, currency: string, options?: RoundToUnitOptions): Money;
+/**
+ * A major-unit number rounded to the currency's display digits (default) or storage digits,
+ * half-up by default, as a number. For report outputs that already are majors; new code
+ * keeps Money and converts once.
+ */
+export declare function roundMajor(major: number | DecimalText, currency: string, options?: {
+  digits?: 'display' | 'storage';
+  rounding?: RoundingMode;
+}): number;
+//#endregion
+//#region src/arithmetic.d.ts
+/** An exact ratio of integers (`{ numerator: 1, denominator: 3 }`). */
+interface Ratio {
+  readonly numerator: number | bigint;
+  readonly denominator: number | bigint;
+}
+export declare function add(a: Money, b: Money): Money;
+export declare function subtract(a: Money, b: Money): Money;
+/** The exact total of `items`, every one in `currency` (required, so an empty list has one). */
+export declare function sum(items: readonly Money[], currency: string): Money;
+/**
+ * `m x factor`, rounded once to a whole `unit` (default `'storage'`) with `rounding`
+ * (default half-up). A number is taken by its shortest decimal text (as JSON carries it);
+ * text is exact decimal; a Ratio is exact. Integer factors are exact. A non-finite factor or
+ * a zero denominator throws `amount_invalid`.
+ */
+export declare function multiply(m: Money, factor: number | DecimalText | Ratio, options?: RoundToUnitOptions): Money;
+/** `m / divisor`, rounded once like `multiply`. Divisor 0 throws `amount_invalid`. */
+export declare function divide(m: Money, divisor: number | DecimalText, options?: RoundToUnitOptions): Money;
+/** `percent` percent of `m` (12.5 is an eighth), rounded once like `multiply` (default unit `'storage'`). */
+export declare function percentOf(m: Money, percent: number | DecimalText, options?: RoundToUnitOptions): Money;
+/** `-1`, `0` or `1`. Different currencies throw `currency_mismatch`. */
+export declare function compare(a: Money, b: Money): -1 | 0 | 1;
+/** Same currency and same amount. Different currencies are `false`, never a throw. */
+export declare function equals(a: Money, b: Money): boolean;
+export declare function isZero(m: Money): boolean;
+export declare function isPositive(m: Money): boolean;
+export declare function isNegative(m: Money): boolean;
+/** The smallest of the amounts, all in one currency (the first of equals). */
+export declare function min(first: Money, ...rest: Money[]): Money;
+/** The largest of the amounts, all in one currency (the first of equals). */
+export declare function max(first: Money, ...rest: Money[]): Money;
+/** `m` limited to `[min, max]` (either optional, same currency). `min` above `max` throws `amount_invalid`. */
+export declare function clamp(m: Money, bounds: {
+  min?: Money;
+  max?: Money;
+}): Money;
+/** What is left: `max(0, total - used)`. */
+export declare function remaining(total: Money, used: Money): Money;
+/** `|a - b| <= tolerance` (`<` with `inclusive: false`), all one currency. A negative tolerance throws `amount_invalid`. */
+export declare function within(a: Money, b: Money, tolerance: Money, options?: {
+  inclusive?: boolean;
+}): boolean;
+/** `d = a - b`; `d` below `tolerance` counts as rounding and gives 0, else `d` (Stripe `refundSyncDelta`). */
+export declare function excessOver(a: Money, b: Money, tolerance: Money): Money;
+//#endregion
+//#region src/country.d.ts
+/** The current legal tender of an ISO 3166 country (`'US'` or `'us'`), or null when unknown. Never guesses USD. */
+export declare function defaultCurrencyForCountry(country: string): CurrencyCode | null;
+//#endregion
+//#region src/decimal-text.d.ts
+/** Anything the family takes as a value. */
+type DecimalInput = DecimalText | string | number | bigint;
+/** Canonical DecimalText of `input` (`'4300.00'` gives `'4300'`, `0.1 + 0.2` gives `'0.30000000000000004'`). See `decimalOf` for what is refused. */
+export declare function parseDecimalText(input: unknown, options?: {
+  signed?: boolean;
+}): DecimalText;
+/**
+ * THE storage-literal grammar: `parseDecimal`'s `'plain'` text (decimal, optional fraction,
+ * no exponent, at most `MAX_DIGITS` characters). `signed` (default false) allows a leading
+ * `-`; `leadingZeros: false` refuses `'04300'`.
+ * `{ leadingZeros: false }` is AMOUNT_COLUMN_LITERAL, `{}` STORAGE_AMOUNT_LITERAL,
+ * `{ signed: true }` the oracle / iyzico / Authorize.Net grammar.
+ */
+export declare function isDecimalLiteral(text: unknown, options?: {
+  signed?: boolean;
+  leadingZeros?: boolean;
+}): boolean;
+/** Throws `amount_invalid` unless `value` is an unsigned decimal literal without leading zeros (the seam ledger rule). */
+export declare function assertDecimalLiteral(value: unknown, label: string): asserts value is string;
+/** Drops trailing fraction zeros and a trailing `.` (`'12.500'` gives `'12.5'`, `'12.00'` gives `'12'`). Text without a `.` is unchanged. */
+export declare function trimDecimalZeros(text: string): string;
+/** The exact sum (`[]` gives `'0'`). */
+export declare function decimalSum(values: readonly DecimalInput[]): DecimalText;
+/** `a - b`, exactly. */
+export declare function decimalSubtract(a: DecimalText | string, b: DecimalText | string): DecimalText;
+/** `a x b`, exactly. */
+export declare function decimalMultiply(a: DecimalText | string | number, b: DecimalText | string | number): DecimalText;
+/** `a / b` rounded once to `scale` fraction digits (`rounding` default half-up). `b` = 0 throws `amount_invalid`. */
+export declare function decimalDivide(a: DecimalText | string | number, b: DecimalText | string | number, options: {
+  scale: number;
+  rounding?: RoundingMode;
+}): DecimalText;
+/** `a` rounded to `scale` fraction digits (`rounding` default half-up). */
+export declare function decimalRound(a: DecimalText | string | number, options: {
+  scale: number;
+  rounding?: RoundingMode;
+}): DecimalText;
+/** `-1`, `0` or `1` as `a` is below, equal to or above `b`. */
+export declare function decimalCompare(a: DecimalText | string, b: DecimalText | string): -1 | 0 | 1;
+/**
+ * Whether `a` and `b` are the same decimal, exactly (`'43.0'` equals `'43.00'` and `43`). Takes what
+ * `decimalCompare` takes, but never throws: anything that is not plain decimal text, a finite number
+ * or a bigint is never equal, not even to itself.
+ */
+export declare function decimalEquals(a: unknown, b: unknown): boolean;
+/** `a` limited to `[min, max]` (either bound optional). `min` above `max` throws `amount_invalid`. */
+export declare function decimalClamp(a: DecimalText | string, bounds: {
+  min?: DecimalText | string;
+  max?: DecimalText | string;
+}): DecimalText;
+/** `|a - b| <= tolerance` (`<` with `inclusive: false`). A negative tolerance throws `amount_invalid`. */
+export declare function decimalWithin(a: DecimalText | string, b: DecimalText | string, tolerance: DecimalText | string, options?: {
+  inclusive?: boolean;
+}): boolean;
+//#endregion
+//#region src/errors.d.ts
+/**
+ * Why a money operation refused its input:
+ * - `currency_invalid`: not a currency this package knows (or a retired one where only active codes are allowed)
+ * - `currency_mismatch`: two amounts in different currencies were combined
+ * - `amount_invalid`: not a finite number, or a stored amount that is not a safe integer
+ * - `precision`: more fraction digits than the currency stores (19.999 USD, 5.5 JPY)
+ * - `overflow`: too large to store exactly
+ * - `parse`: text that is not a decimal number
+ * - `currency_missing`: no candidate currency at all (every candidate was empty)
+ * - `rate_invalid`: an exchange rate that is non-positive, not an integer ratio, or out of bounds
+ * - `wire_unsupported`: the payment provider or destination does not take this currency
+ * - `wire_refused`: the amount cannot be sent to the provider (non-positive, a fraction of a whole unit, rounds to nothing)
+ */
+type MoneyErrorCode = 'currency_invalid' | 'currency_mismatch' | 'amount_invalid' | 'precision' | 'overflow' | 'parse' | 'currency_missing' | 'rate_invalid' | 'wire_unsupported' | 'wire_refused';
+interface MoneyErrorOptions {
+  /** The input field the value came from; prefixed to the message. */
+  field?: string;
+}
+/** The one error this package throws for bad money input. Check `code`, not the message. */
+export declare class MoneyError extends Error {
+  readonly code: MoneyErrorCode;
+  readonly field?: string;
+  constructor(code: MoneyErrorCode, message: string, options?: MoneyErrorOptions);
+}
+//#endregion
+//#region src/format.d.ts
+interface FormatMoneyOptions {
+  /** Default `'en-US'`; an unsupported or malformed tag falls back to it. */
+  locale?: string;
+  /** Default `'symbol'`. `'symbol+code'` appends the code unless the output already shows it. */
+  currencyDisplay?: 'symbol' | 'narrowSymbol' | 'code' | 'symbol+code';
+  /**
+   * `'display'` (default): the display digits, half-up. `'widen'`: at least the display
+   * digits, more when the stored value needs them (JPY 550 shows `¥5.5`). `'trim-zero'`:
+   * no fraction for a whole number of major units, else the display digits.
+   */
+  digits?: 'display' | 'widen' | 'trim-zero';
+  /** Default `'auto'`. */
+  signDisplay?: 'auto' | 'always' | 'exceptZero';
+  /** Default `'-'`; `'−'` (U+2212) replaces the leading ASCII minus. */
+  minusSign?: '-' | '−';
+}
+/**
+ * Money for people: `'$1,234.50'`, `'¥1,200'`, `'KWD 1.005'`, `'-€5.00'`. Locale, currency
+ * display, digits and sign are explicit options; the active app locale is the caller's to
+ * pass. If Intl throws, `'<CODE> <decimal>'`.
+ */
+export declare function formatMoney(m: Money, options?: FormatMoneyOptions): string;
+/**
+ * A stored amount that may be fractional (a Medusa total, 107.8175; a percentage promotion) for
+ * people: rounded half-up to a whole storage unit (`roundToUnit`), then `formatMoney` with `options`.
+ * A number must be finite; text is plain decimal; an unknown currency throws `currency_invalid`.
+ */
+export declare function formatStored(amount: number | DecimalText, currency: string, options?: FormatMoneyOptions): string;
+/**
+ * Like `formatMoney` below `threshold` major units (default 10000, by magnitude); at or above
+ * it, compact short notation with `maximumSignificantDigits` (default 3): `'$12.3K'`.
+ */
+export declare function formatMoneyCompact(m: Money, options?: FormatMoneyOptions & {
+  threshold?: number;
+  maximumSignificantDigits?: number;
+}): string;
+/** `'$10.00 – $20.00'` (en dash between spaces), `'$10.00+'` when `high` is null; zero amounts show `zeroLabel` when given. */
+export declare function formatMoneyRange(low: Money, high: Money | null, options?: FormatMoneyOptions & {
+  zeroLabel?: string;
+}): string;
+/**
+ * A chart tick formatter for values that already are major units: always compact, with the
+ * same rounding as `formatMoneyCompact` (`1234567` gives `'$1.23M'`).
+ */
+export declare function moneyAxisFormatter(currency: string, options?: Pick<FormatMoneyOptions, 'locale' | 'currencyDisplay'>): (major: number) => string;
+//#endregion
+//#region src/iso-minor.d.ts
+/**
+ * ISO minor units at the display digits: `round(major x 10^displayDigits)` with `rounding`
+ * (default half-up). JPY 150000 gives 1500, KWD 1005 gives 1005, IQD 10000 gives 10, HUF
+ * 435050 gives 4351. Not for payment providers (use `/wire`).
+ */
+export declare function toIsoMinor(m: Money, options?: {
+  rounding?: RoundingMode;
+}): number;
+/**
+ * ISO minor units at the display digits (or `digits`) as Money. The value must be a safe
+ * integer (number or integer text). With `digits` above the storage exponent the value must
+ * land on a whole storage unit, else `precision`.
+ */
+export declare function fromIsoMinor(value: number | string, currency: string, options?: {
+  digits?: FractionDigits;
+}): Money;
+//#endregion
+export { type AllocateOptions, type AllocationStrategy, type AllocationWeight, type AmountUnit, CURRENCIES, type CurrencyCode, type CurrencyCodeOptions, type CurrencyInfo, type CurrencyStatus, type DecimalInput, type DecimalText, type FormatMoneyOptions, type FractionDigits, type FractionalMoney, type FromMajorOptions, type MajorDecimal, type MedusaRaw, type Money, type MoneyByCurrency, type MoneyErrorCode, type MoneyErrorOptions, type PriceLike, type Ratio, type ReadStoredDecimalOptions, type ReadStoredOptions, type RoundToUnitOptions, type RoundingMode, type StorageScale, type StoredAmount, type StoredAmountOptions, type ToMajorDecimalOptions, type UnitPricePart, type WaterfallResult, currencyCode, currencyInfo, currencyLabel, currencyName, currencyOptions, currencySymbol, displayDigits, firstCurrency, fromMajor, isCurrencyCode, isPositiveAmount, isStoredAmount, localeForCurrency, medusaCurrencyCode, medusaEpsilon, money, moneyByCurrency, moneyFor, parseCurrencyCode, readCalculatedPrice, readStored, readStoredDecimal, readStoredField, readStoredLiteral, sameCurrency, storageDigits, storageScale, toMajorDecimal, toMajorNumber, toMedusaAmountInput, toMedusaRaw };

package/dist/index.js

@@ -0,0 +1,276 @@
+import { A as storageScale, C as medusaCurrencyCode, D as sameCurrency, F as decimalClamp, G as isDecimalLiteral, H as decimalSubtract, I as decimalCompare, K as parseDecimalText, L as decimalDivide, O as storageDigits, P as assertDecimalLiteral, Q as MoneyError, R as decimalEquals, S as localeForCurrency, T as parseCurrencyCode, U as decimalSum, V as decimalRound, W as decimalWithin, _ as currencySymbol, a as money, b as firstCurrency, c as toMajorDecimal, d as currencyCode, f as currencyInfo, g as currencyOptions, h as currencyName, l as toMajorNumber, n as fromMajor, o as readStored, p as currencyLabel, q as trimDecimalZeros, r as isStoredAmount, u as CURRENCIES, v as displayDigits, w as medusaEpsilon, x as isCurrencyCode, z as decimalMultiply } from "./money-WhnGiI00.js";
+import { i as roundToUnit, n as roundMajor } from "./rounding-g9rvye0k.js";
+import { i as splitUnitPrice, r as allocateWaterfall, t as allocate } from "./allocate-X7_jAtOj.js";
+import { _ as within, a as equals, c as isPositive, d as min, f as multiply, g as sum, h as subtract, i as divide, l as isZero, m as remaining, n as clamp, o as excessOver, p as percentOf, r as compare, s as isNegative, t as add, u as max } from "./arithmetic-BhNwisjb.js";
+import { t as hasOwnKey } from "./own-D7544D3k.js";
+import { a as moneyAxisFormatter, i as formatStored, n as formatMoneyCompact, r as formatMoneyRange, t as formatMoney } from "./format-BdPnijvn.js";
+import { r as toIsoMinor, t as fromIsoMinor } from "./iso-minor-CqkWDxHS.js";
+import { a as readStoredDecimal, i as readCalculatedPrice, l as toMedusaAmountInput, n as moneyByCurrency, o as readStoredField, r as moneyFor, s as readStoredLiteral, t as isPositiveAmount, u as toMedusaRaw } from "./medusa-DqJY1qpj.js";
+//#region src/data/countries.ts
+const COUNTRY_CURRENCY = {
+	AC: "SHP",
+	AD: "EUR",
+	AE: "AED",
+	AF: "AFN",
+	AG: "XCD",
+	AI: "XCD",
+	AL: "ALL",
+	AM: "AMD",
+	AO: "AOA",
+	AR: "ARS",
+	AS: "USD",
+	AT: "EUR",
+	AU: "AUD",
+	AW: "AWG",
+	AX: "EUR",
+	AZ: "AZN",
+	BA: "BAM",
+	BB: "BBD",
+	BD: "BDT",
+	BE: "EUR",
+	BF: "XOF",
+	BG: "EUR",
+	BH: "BHD",
+	BI: "BIF",
+	BJ: "XOF",
+	BL: "EUR",
+	BM: "BMD",
+	BN: "BND",
+	BO: "BOB",
+	BQ: "USD",
+	BR: "BRL",
+	BS: "BSD",
+	BT: "BTN",
+	BV: "NOK",
+	BW: "BWP",
+	BY: "BYN",
+	BZ: "BZD",
+	CA: "CAD",
+	CC: "AUD",
+	CD: "CDF",
+	CF: "XAF",
+	CG: "XAF",
+	CH: "CHF",
+	CI: "XOF",
+	CK: "NZD",
+	CL: "CLP",
+	CM: "XAF",
+	CN: "CNY",
+	CO: "COP",
+	CR: "CRC",
+	CU: "CUP",
+	CV: "CVE",
+	CW: "XCG",
+	CX: "AUD",
+	CY: "EUR",
+	CZ: "CZK",
+	DE: "EUR",
+	DG: "USD",
+	DJ: "DJF",
+	DK: "DKK",
+	DM: "XCD",
+	DO: "DOP",
+	DZ: "DZD",
+	EA: "EUR",
+	EC: "USD",
+	EE: "EUR",
+	EG: "EGP",
+	EH: "MAD",
+	ER: "ERN",
+	ES: "EUR",
+	ET: "ETB",
+	EU: "EUR",
+	FI: "EUR",
+	FJ: "FJD",
+	FK: "FKP",
+	FM: "USD",
+	FO: "DKK",
+	FR: "EUR",
+	GA: "XAF",
+	GB: "GBP",
+	GD: "XCD",
+	GE: "GEL",
+	GF: "EUR",
+	GG: "GBP",
+	GH: "GHS",
+	GI: "GIP",
+	GL: "DKK",
+	GM: "GMD",
+	GN: "GNF",
+	GP: "EUR",
+	GQ: "XAF",
+	GR: "EUR",
+	GS: "GBP",
+	GT: "GTQ",
+	GU: "USD",
+	GW: "XOF",
+	GY: "GYD",
+	HK: "HKD",
+	HM: "AUD",
+	HN: "HNL",
+	HR: "EUR",
+	HT: "HTG",
+	HU: "HUF",
+	IC: "EUR",
+	ID: "IDR",
+	IE: "EUR",
+	IL: "ILS",
+	IM: "GBP",
+	IN: "INR",
+	IO: "USD",
+	IQ: "IQD",
+	IR: "IRR",
+	IS: "ISK",
+	IT: "EUR",
+	JE: "GBP",
+	JM: "JMD",
+	JO: "JOD",
+	JP: "JPY",
+	KE: "KES",
+	KG: "KGS",
+	KH: "KHR",
+	KI: "AUD",
+	KM: "KMF",
+	KN: "XCD",
+	KP: "KPW",
+	KR: "KRW",
+	KW: "KWD",
+	KY: "KYD",
+	KZ: "KZT",
+	LA: "LAK",
+	LB: "LBP",
+	LC: "XCD",
+	LI: "CHF",
+	LK: "LKR",
+	LR: "LRD",
+	LS: "LSL",
+	LT: "EUR",
+	LU: "EUR",
+	LV: "EUR",
+	LY: "LYD",
+	MA: "MAD",
+	MC: "EUR",
+	MD: "MDL",
+	ME: "EUR",
+	MF: "EUR",
+	MG: "MGA",
+	MH: "USD",
+	MK: "MKD",
+	ML: "XOF",
+	MM: "MMK",
+	MN: "MNT",
+	MO: "MOP",
+	MP: "USD",
+	MQ: "EUR",
+	MR: "MRU",
+	MS: "XCD",
+	MT: "EUR",
+	MU: "MUR",
+	MV: "MVR",
+	MW: "MWK",
+	MX: "MXN",
+	MY: "MYR",
+	MZ: "MZN",
+	NA: "NAD",
+	NC: "XPF",
+	NE: "XOF",
+	NF: "AUD",
+	NG: "NGN",
+	NI: "NIO",
+	NL: "EUR",
+	NO: "NOK",
+	NP: "NPR",
+	NR: "AUD",
+	NU: "NZD",
+	NZ: "NZD",
+	OM: "OMR",
+	PA: "PAB",
+	PE: "PEN",
+	PF: "XPF",
+	PG: "PGK",
+	PH: "PHP",
+	PK: "PKR",
+	PL: "PLN",
+	PM: "EUR",
+	PN: "NZD",
+	PR: "USD",
+	PS: "ILS",
+	PT: "EUR",
+	PW: "USD",
+	PY: "PYG",
+	QA: "QAR",
+	RE: "EUR",
+	RO: "RON",
+	RS: "RSD",
+	RU: "RUB",
+	RW: "RWF",
+	SA: "SAR",
+	SB: "SBD",
+	SC: "SCR",
+	SD: "SDG",
+	SE: "SEK",
+	SG: "SGD",
+	SH: "SHP",
+	SI: "EUR",
+	SJ: "NOK",
+	SK: "EUR",
+	SL: "SLE",
+	SM: "EUR",
+	SN: "XOF",
+	SO: "SOS",
+	SR: "SRD",
+	SS: "SSP",
+	ST: "STN",
+	SV: "USD",
+	SX: "XCG",
+	SY: "SYP",
+	SZ: "SZL",
+	TA: "GBP",
+	TC: "USD",
+	TD: "XAF",
+	TF: "EUR",
+	TG: "XOF",
+	TH: "THB",
+	TJ: "TJS",
+	TK: "NZD",
+	TL: "USD",
+	TM: "TMT",
+	TN: "TND",
+	TO: "TOP",
+	TR: "TRY",
+	TT: "TTD",
+	TV: "AUD",
+	TW: "TWD",
+	TZ: "TZS",
+	UA: "UAH",
+	UG: "UGX",
+	UM: "USD",
+	US: "USD",
+	UY: "UYU",
+	UZ: "UZS",
+	VA: "EUR",
+	VC: "XCD",
+	VE: "VES",
+	VG: "USD",
+	VI: "USD",
+	VN: "VND",
+	VU: "VUV",
+	WF: "XPF",
+	WS: "WST",
+	XK: "EUR",
+	YE: "YER",
+	YT: "EUR",
+	ZA: "ZAR",
+	ZM: "ZMW",
+	ZW: "ZWG"
+};
+//#endregion
+//#region src/country.ts
+/** The current legal tender of an ISO 3166 country (`'US'` or `'us'`), or null when unknown. Never guesses USD. */
+function defaultCurrencyForCountry(country) {
+	if (typeof country !== "string") return null;
+	const key = country.toUpperCase();
+	return hasOwnKey(COUNTRY_CURRENCY, key) ? COUNTRY_CURRENCY[key] : null;
+}
+//#endregion
+export { CURRENCIES, MoneyError, add, allocate, allocateWaterfall, assertDecimalLiteral, clamp, compare, currencyCode, currencyInfo, currencyLabel, currencyName, currencyOptions, currencySymbol, decimalClamp, decimalCompare, decimalDivide, decimalEquals, decimalMultiply, decimalRound, decimalSubtract, decimalSum, decimalWithin, defaultCurrencyForCountry, displayDigits, divide, equals, excessOver, firstCurrency, formatMoney, formatMoneyCompact, formatMoneyRange, formatStored, fromIsoMinor, fromMajor, isCurrencyCode, isDecimalLiteral, isNegative, isPositive, isPositiveAmount, isStoredAmount, isZero, localeForCurrency, max, medusaCurrencyCode, medusaEpsilon, min, money, moneyAxisFormatter, moneyByCurrency, moneyFor, multiply, parseCurrencyCode, parseDecimalText, percentOf, readCalculatedPrice, readStored, readStoredDecimal, readStoredField, readStoredLiteral, remaining, roundMajor, roundToUnit, sameCurrency, splitUnitPrice, storageDigits, storageScale, subtract, sum, toIsoMinor, toMajorDecimal, toMajorNumber, toMedusaAmountInput, toMedusaRaw, trimDecimalZeros, within };