@amboras-dev/money 0.0.0-stage → 0.2.0

package/dist/rate-DicStBue.js

@@ -0,0 +1,152 @@
+import { $ as describeValue, B as decimalOf, J as compareRatio, Q as MoneyError, Z as ratioToDecimal, dt as roundToScale, lt as parseDecimal, pt as toDecimalText, ut as pow10 } from "./money-WhnGiI00.js";
+import { t as hasOwnKey } from "./own-D7544D3k.js";
+//#region src/fx/rate.ts
+/** Denominator of every locked rate (`store_currency_rate.rate_denominator` default): 7 decimals. */
+const RATE_REF = 10000000n;
+/** Inclusive bounds of a locked rate's value: `lockedRateNumerator` (n >= 1 at RATE_REF, value <= 1e9). */
+const RATE_BOUNDS = {
+	min: "0.0000001",
+	max: "1000000000"
+};
+const MIN_RATE = {
+	units: 1n,
+	scale: 7
+};
+const MAX_RATE = {
+	units: 1000000000n,
+	scale: 0
+};
+const invalid = (message) => new MoneyError("rate_invalid", message);
+/** A positive integer part (safe integer number, bigint or digit string), or null. */
+function partOf(value) {
+	let part = null;
+	if (typeof value === "bigint") part = value;
+	else if (typeof value === "number" && Number.isSafeInteger(value)) part = BigInt(value);
+	else if (typeof value === "string") part = parseDecimal(value, "integer")?.units ?? null;
+	return part !== null && part >= 1n ? part : null;
+}
+const withinBounds = (n, d) => compareRatio(n, d, MIN_RATE.units, pow10(MIN_RATE.scale)) >= 0 && compareRatio(n, d, MAX_RATE.units, 1n) <= 0;
+/**
+* A Rate from its parts: integers >= 1 (safe integer number, bigint or digit string) whose
+* value lies within `RATE_BOUNDS`. Anything else throws `rate_invalid`. Not reduced: a
+* RATE_REF denominator is written back as given.
+*/
+function rate(numerator, denominator) {
+	const n = partOf(numerator);
+	const d = partOf(denominator);
+	if (n === null || d === null) throw invalid(`Rate parts must be whole numbers >= 1, got ${describeValue(numerator)}/${describeValue(denominator)}`);
+	if (!withinBounds(n, d)) throw invalid(`Rate ${n}/${d} is outside ${RATE_BOUNDS.min}..${RATE_BOUNDS.max}`);
+	return {
+		numerator: n,
+		denominator: d
+	};
+}
+/** A `store_currency_rate` row's rate, or null for missing, non-integer, non-positive or out-of-bounds parts. Never throws. */
+function rateFromRow(row) {
+	if (typeof row !== "object" || row === null) return null;
+	const n = partOf(row.rate_numerator);
+	const d = partOf(row.rate_denominator);
+	return n !== null && d !== null && withinBounds(n, d) ? {
+		numerator: n,
+		denominator: d
+	} : null;
+}
+/** The exact decimal of a rate input; anything that is not a finite decimal throws `rate_invalid`. */
+function rateDecimal(value) {
+	try {
+		return decimalOf(value);
+	} catch {
+		throw invalid(`Rate must be a finite decimal, got ${describeValue(value)}`);
+	}
+}
+/** `floor(log10(v))` of a positive decimal, from its digits (no float log). */
+function exponentOf(v) {
+	return v.units.toString().length - 1 - v.scale;
+}
+/**
+* A major-unit rate given as a number or decimal text (`83.42`, `'0.000029175'`) as a Rate,
+* rounded half-up once. Numbers are taken by their shortest text, so `83.42` is exactly
+* 834200000 / 1e7. See `RateFromDecimalOptions` for the two encodings.
+*/
+function rateFromDecimal(value, options = {}) {
+	const v = rateDecimal(value);
+	if (options.encoding === "precise") {
+		if (v.units <= 0n) throw invalid(`Rate must be greater than 0, got ${describeValue(value)}`);
+		const exponent = Math.max(7, 9 - exponentOf(v));
+		return {
+			numerator: roundToScale(v, exponent, "half-up").units,
+			denominator: pow10(exponent)
+		};
+	}
+	if (compareRatio(v.units, pow10(v.scale), MAX_RATE.units, 1n) > 0) throw invalid(`Rate must not be greater than ${RATE_BOUNDS.max}, got ${describeValue(value)}`);
+	const numerator = roundToScale(v, 7, "half-up").units;
+	if (numerator < 1n) throw invalid(`Rate must be greater than 0, got ${describeValue(value)}`);
+	return {
+		numerator,
+		denominator: RATE_REF
+	};
+}
+/** Throws `rate_invalid` unless `r` has positive integer parts. */
+function checkRate(r) {
+	if (typeof r !== "object" || r === null || typeof r.numerator !== "bigint" || typeof r.denominator !== "bigint" || r.numerator < 1n || r.denominator < 1n) throw invalid(`Not a rate: ${describeValue(r)}`);
+	return r;
+}
+function checkDecimals(decimals) {
+	if (!Number.isSafeInteger(decimals) || decimals < 0 || decimals > 30) throw new MoneyError("amount_invalid", `decimals must be an integer from 0 to 30, got ${describeValue(decimals)}`);
+	return decimals;
+}
+/** `r` as text rounded half-up to `decimals` fraction digits (default 12: persisted `fx_rate`, `draft_market_rate`). */
+function rateToDecimal(r, options = {}) {
+	const { numerator, denominator } = checkRate(r);
+	const decimals = checkDecimals(options.decimals ?? 12);
+	return toDecimalText(ratioToDecimal(numerator, denominator, decimals));
+}
+/** `r` as a number: rounded half-up to 7 decimals by default (Medusa `toMajorRate`), or `'exact'` = `Number(n) / Number(d)`. */
+function rateToNumber(r, options = {}) {
+	const { numerator, denominator } = checkRate(r);
+	if (options.decimals === "exact") return Number(numerator) / Number(denominator);
+	return Number(rateToDecimal(r, { decimals: options.decimals ?? 7 }));
+}
+/** 1 quote = d/n base. */
+function invertRate(r) {
+	const { numerator, denominator } = checkRate(r);
+	return {
+		numerator: denominator,
+		denominator: numerator
+	};
+}
+const ONE = {
+	numerator: 1n,
+	denominator: 1n
+};
+function lookup(table, code) {
+	const lower = code.toLowerCase();
+	const found = hasOwnKey(table, lower) ? table[lower] : hasOwnKey(table, code.toUpperCase()) ? table[code.toUpperCase()] : void 0;
+	return found === void 0 ? void 0 : checkRate(found);
+}
+/**
+* 1 `from` = ? `to`, from a table of rates that each say what 1 `base` is worth (keys any
+* case; `base` itself counts as 1/1). Same code (any case) gives 1/1; a missing side gives
+* null. Exact on bigint (`{ b.n x a.d, b.d x a.n }`), never overflows.
+*/
+function crossRate(table, from, to, base) {
+	const f = from.toLowerCase();
+	const t = to.toLowerCase();
+	const b = base.toLowerCase();
+	if (f === t) return ONE;
+	const a = f === b ? ONE : lookup(table, f);
+	const c = t === b ? ONE : lookup(table, t);
+	if (!a || !c) return null;
+	return {
+		numerator: c.numerator * a.denominator,
+		denominator: c.denominator * a.numerator
+	};
+}
+/** Same value (cross-multiplied), whatever the parts: 2/4 equals 1/2. */
+function rateEquals(a, b) {
+	const x = checkRate(a);
+	const y = checkRate(b);
+	return compareRatio(x.numerator, x.denominator, y.numerator, y.denominator) === 0;
+}
+//#endregion
+export { invertRate as a, rateFromDecimal as c, rateToNumber as d, crossRate as i, rateFromRow as l, RATE_REF as n, rate as o, checkRate as r, rateEquals as s, RATE_BOUNDS as t, rateToDecimal as u };

package/dist/rate-tqK8ijG0.d.cts

@@ -0,0 +1,63 @@
+import { R as DecimalText } from "./money-B-3aFjNJ.cjs";
+//#region src/fx/rate.d.ts
+/** 1 base unit = numerator / denominator quote units, both in major units. Positive integers. */
+interface Rate {
+  readonly numerator: bigint;
+  readonly denominator: bigint;
+}
+/** A `store_currency_rate` row as the database driver returns it (bigint columns usually as text). */
+interface RateRow {
+  readonly rate_numerator: unknown;
+  readonly rate_denominator: unknown;
+  readonly currency_code?: unknown;
+}
+/** Denominator of every locked rate (`store_currency_rate.rate_denominator` default): 7 decimals. */
+declare const RATE_REF = 10000000n;
+/** Inclusive bounds of a locked rate's value: `lockedRateNumerator` (n >= 1 at RATE_REF, value <= 1e9). */
+declare const RATE_BOUNDS: {
+  readonly min: "0.0000001";
+  readonly max: "1000000000";
+};
+/**
+ * A Rate from its parts: integers >= 1 (safe integer number, bigint or digit string) whose
+ * value lies within `RATE_BOUNDS`. Anything else throws `rate_invalid`. Not reduced: a
+ * RATE_REF denominator is written back as given.
+ */
+declare function rate(numerator: number | bigint | string, denominator: number | bigint | string): Rate;
+/** A `store_currency_rate` row's rate, or null for missing, non-integer, non-positive or out-of-bounds parts. Never throws. */
+declare function rateFromRow(row: RateRow | null | undefined): Rate | null;
+interface RateFromDecimalOptions {
+  /**
+   * `'locked'` (default): `n = round_half_up(value x 1e7)`, `d = RATE_REF` (orch
+   * `lockedRateNumerator`); `n < 1` or `value > 1e9` throws `rate_invalid`.
+   * `'precise'`: about ten significant digits, `d = 10^max(7, 9 - floor(log10(value)))`
+   * (orch `precisePriceRate`, for one-off conversions); `value <= 0` throws `rate_invalid`.
+   */
+  encoding?: 'locked' | 'precise';
+}
+/**
+ * A major-unit rate given as a number or decimal text (`83.42`, `'0.000029175'`) as a Rate,
+ * rounded half-up once. Numbers are taken by their shortest text, so `83.42` is exactly
+ * 834200000 / 1e7. See `RateFromDecimalOptions` for the two encodings.
+ */
+declare function rateFromDecimal(value: number | string, options?: RateFromDecimalOptions): Rate;
+/** `r` as text rounded half-up to `decimals` fraction digits (default 12: persisted `fx_rate`, `draft_market_rate`). */
+declare function rateToDecimal(r: Rate, options?: {
+  decimals?: number;
+}): DecimalText;
+/** `r` as a number: rounded half-up to 7 decimals by default (Medusa `toMajorRate`), or `'exact'` = `Number(n) / Number(d)`. */
+declare function rateToNumber(r: Rate, options?: {
+  decimals?: number | 'exact';
+}): number;
+/** 1 quote = d/n base. */
+declare function invertRate(r: Rate): Rate;
+/**
+ * 1 `from` = ? `to`, from a table of rates that each say what 1 `base` is worth (keys any
+ * case; `base` itself counts as 1/1). Same code (any case) gives 1/1; a missing side gives
+ * null. Exact on bigint (`{ b.n x a.d, b.d x a.n }`), never overflows.
+ */
+declare function crossRate(table: Readonly<Record<string, Rate>>, from: string, to: string, base: string): Rate | null;
+/** Same value (cross-multiplied), whatever the parts: 2/4 equals 1/2. */
+declare function rateEquals(a: Rate, b: Rate): boolean;
+//#endregion
+export { RateRow as a, rate as c, rateFromRow as d, rateToDecimal as f, RateFromDecimalOptions as i, rateEquals as l, RATE_REF as n, crossRate as o, rateToNumber as p, Rate as r, invertRate as s, RATE_BOUNDS as t, rateFromDecimal as u };

package/dist/reporting-CG-ai2sM.d.cts

@@ -0,0 +1,31 @@
+import { R as DecimalText, g as CurrencyCode, i as Money } from "./money-B-3aFjNJ.cjs";
+import { a as RateRow } from "./rate-tqK8ijG0.cjs";
+//#region src/fx/reporting.d.ts
+/** `factors[lower code]` takes a stored amount in that currency to a stored amount in `base`. */
+interface FactorTable {
+  readonly base: CurrencyCode;
+  readonly factors: Readonly<Record<string, DecimalText>>;
+}
+/**
+ * The reporting factors of a store whose locked rates say `1 default = n/d <code>`:
+ * `factor(code) = storageScale(default) / storageScale(code) x d / n`, rounded half-up to 20
+ * fraction digits; the default currency is `'1'`. Rows for the default currency, unknown
+ * codes or invalid rates (see `rateFromRow`) are skipped, so those currencies have no factor.
+ * Port of Medusa `storeTotalFactors`, exact (it measured the factor at a 1e9 reference).
+ */
+declare function storeFactors(defaultCurrency: string, rows: readonly RateRow[]): FactorTable;
+interface ReportingTotal {
+  readonly total: Money;
+  /** False when some item's currency has no factor (it is excluded from `total`). */
+  readonly complete: boolean;
+  /** The excluded currencies, sorted, each once. */
+  readonly missing: CurrencyCode[];
+}
+/**
+ * The sum of `items` in `table.base`: each converted with its currency's factor and rounded
+ * half-up to a storage unit (per item, as customer-stats rounds per order), then summed.
+ * Items whose currency has no factor are excluded and reported in `missing`.
+ */
+declare function toReporting(items: readonly Money[], table: FactorTable): ReportingTotal;
+//#endregion
+export { toReporting as i, ReportingTotal as n, storeFactors as r, FactorTable as t };

package/dist/reporting-tpGJbqYp.d.ts

@@ -0,0 +1,31 @@
+import { R as DecimalText, g as CurrencyCode, i as Money } from "./money-B-3aFjNJ.js";
+import { a as RateRow } from "./rate-DBPiYgT1.js";
+//#region src/fx/reporting.d.ts
+/** `factors[lower code]` takes a stored amount in that currency to a stored amount in `base`. */
+interface FactorTable {
+  readonly base: CurrencyCode;
+  readonly factors: Readonly<Record<string, DecimalText>>;
+}
+/**
+ * The reporting factors of a store whose locked rates say `1 default = n/d <code>`:
+ * `factor(code) = storageScale(default) / storageScale(code) x d / n`, rounded half-up to 20
+ * fraction digits; the default currency is `'1'`. Rows for the default currency, unknown
+ * codes or invalid rates (see `rateFromRow`) are skipped, so those currencies have no factor.
+ * Port of Medusa `storeTotalFactors`, exact (it measured the factor at a 1e9 reference).
+ */
+declare function storeFactors(defaultCurrency: string, rows: readonly RateRow[]): FactorTable;
+interface ReportingTotal {
+  readonly total: Money;
+  /** False when some item's currency has no factor (it is excluded from `total`). */
+  readonly complete: boolean;
+  /** The excluded currencies, sorted, each once. */
+  readonly missing: CurrencyCode[];
+}
+/**
+ * The sum of `items` in `table.base`: each converted with its currency's factor and rounded
+ * half-up to a storage unit (per item, as customer-stats rounds per order), then summed.
+ * Items whose currency has no factor are excluded and reported in `missing`.
+ */
+declare function toReporting(items: readonly Money[], table: FactorTable): ReportingTotal;
+//#endregion
+export { toReporting as i, ReportingTotal as n, storeFactors as r, FactorTable as t };

package/dist/retail-1mu888J1.js

@@ -0,0 +1,69 @@
+import { $ as describeValue, E as resolveCurrency, Q as MoneyError, rt as divRound, s as storedDecimal, t as boundedMoney } from "./money-WhnGiI00.js";
+import { a as unitSize, t as mulDivToUnit } from "./rounding-g9rvye0k.js";
+import { r as percentOfUnits } from "./percent-D1VB9xXG.js";
+//#region src/fx/retail.ts
+const RETAIL_ROUNDINGS = [
+	"none",
+	"nearest",
+	"whole",
+	".99",
+	".95",
+	"up-to-99"
+];
+/** `round(0.95 x scale)`: the market charm (95, or 950 for three-decimal currencies). */
+/** A price ending (`.95`, `.99`) in storage units: `hundredths` of one major unit of `scale` storage units. */
+const endingOf = (scale, hundredths) => percentOfUnits(scale, {
+	units: hundredths,
+	scale: 0
+}, "half-up");
+const charmOf = (scale) => endingOf(scale, 95n);
+function checkMode(mode) {
+	if (!RETAIL_ROUNDINGS.includes(mode)) throw new MoneyError("amount_invalid", `Unknown retail rounding: ${describeValue(mode)}`);
+	return mode;
+}
+/** Internal: the stored amount `p / q` (`q > 0`) rounded by `mode`, as integer storage units. */
+function retailUnits(p, q, info, mode) {
+	const scale = BigInt(info.storageScale);
+	checkMode(mode);
+	if (mode === "up-to-99") return divRound(divRound(p, q, "ceil"), scale, "floor") * scale + scale - 1n;
+	const zeroDecimal = info.storageDigits === 0;
+	if (mode === "none" && zeroDecimal) {
+		const size = unitSize(info, "currency");
+		return divRound(2n * p + q * size, 2n * q * size, "floor") * size;
+	}
+	if (mode === "none" || p <= 0n) {
+		if (q === 1n) return p;
+		return mulDivToUnit(p, 1n, q, info, "currency");
+	}
+	if (mode === "nearest") {
+		if (zeroDecimal) return divRound(p, q * 100n * scale, "ceil") * 100n * scale;
+		const charm = charmOf(scale);
+		const whole = divRound(p, q * scale, "floor") * scale;
+		return p <= (whole + charm) * q ? whole + charm : whole + scale + charm;
+	}
+	if (mode === "whole" || zeroDecimal) return divRound(p, q * scale, "ceil") * scale;
+	const ending = endingOf(scale, mode === ".99" ? 99n : 95n);
+	const candidate = divRound(p, q * scale, "floor") * scale + ending;
+	return candidate * q < p ? candidate + scale : candidate;
+}
+/** `m` rounded to a retail price by `mode` (see `RetailRounding`). */
+function roundRetail(m, mode) {
+	const { info } = storedDecimal(m);
+	return boundedMoney(retailUnits(BigInt(m.amount), 1n, info, mode), info);
+}
+/**
+* The market rounding parameters of `currency` for the SQL builders' unnest arrays:
+* `unit` = storage units per currency unit, `majorUnit` = storageScale, `charm` = the
+* `.95` charm in storage units, null for a zero-decimal currency.
+*/
+function priceRoundingParams(currency) {
+	const info = resolveCurrency(currency, { allowHistoric: true });
+	const scale = BigInt(info.storageScale);
+	return {
+		unit: Number(unitSize(info, "currency")),
+		majorUnit: info.storageScale,
+		charm: info.storageDigits === 0 ? null : Number(charmOf(scale))
+	};
+}
+//#endregion
+export { retailUnits as n, roundRetail as r, priceRoundingParams as t };

package/dist/retail-C_BPLvMj.d.cts

@@ -0,0 +1,31 @@
+import { i as Money } from "./money-B-3aFjNJ.cjs";
+//#region src/fx/retail.d.ts
+/**
+ * - `'none'`: Medusa `applyRounding` 'none': a zero-decimal currency is rounded to a whole
+ *   unit (half toward +infinity, as `Math.round`: JPY 150050 gives 150100, since there is no
+ *   ¥0.50); any other currency is unchanged (an exact fractional price is rounded half-up to
+ *   the currency unit).
+ * - `'nearest'`: the market rule (Medusa `applyRounding`): up to the next `.95` of a major unit
+ *   (`.950` for three-decimal), or up to the next 100 major units for a zero-decimal currency.
+ * - `'whole'`, `'.99'`, `'.95'`: the AliExpress rule: up to a whole unit, or the smallest price
+ *   ending in .99 / .95 at or above it (zero-decimal currencies: up to a whole unit).
+ * - `'up-to-99'`: the smallest amount at or above it whose last storage digits are all 9
+ *   (domain retail `roundUpTo99`: 1234 cents gives 1299).
+ * A non-positive amount is never raised and a whole one is left as is (except by `'up-to-99'`
+ * and by `'none'` on a zero-decimal currency).
+ */
+type RetailRounding = 'none' | 'nearest' | 'whole' | '.99' | '.95' | 'up-to-99';
+/** `m` rounded to a retail price by `mode` (see `RetailRounding`). */
+declare function roundRetail(m: Money, mode: RetailRounding): Money;
+/**
+ * The market rounding parameters of `currency` for the SQL builders' unnest arrays:
+ * `unit` = storage units per currency unit, `majorUnit` = storageScale, `charm` = the
+ * `.95` charm in storage units, null for a zero-decimal currency.
+ */
+declare function priceRoundingParams(currency: string): {
+  unit: 1 | 100;
+  majorUnit: 100 | 1000;
+  charm: number | null;
+};
+//#endregion
+export { priceRoundingParams as n, roundRetail as r, RetailRounding as t };

package/dist/retail-Cml8YSKg.cjs

@@ -0,0 +1,86 @@
+const require_money = require("./money-B3wH_Z4S.cjs");
+const require_rounding = require("./rounding-DHBtNCHG.cjs");
+const require_percent = require("./percent-C0InC2t2.cjs");
+//#region src/fx/retail.ts
+const RETAIL_ROUNDINGS = [
+	"none",
+	"nearest",
+	"whole",
+	".99",
+	".95",
+	"up-to-99"
+];
+/** `round(0.95 x scale)`: the market charm (95, or 950 for three-decimal currencies). */
+/** A price ending (`.95`, `.99`) in storage units: `hundredths` of one major unit of `scale` storage units. */
+const endingOf = (scale, hundredths) => require_percent.percentOfUnits(scale, {
+	units: hundredths,
+	scale: 0
+}, "half-up");
+const charmOf = (scale) => endingOf(scale, 95n);
+function checkMode(mode) {
+	if (!RETAIL_ROUNDINGS.includes(mode)) throw new require_money.MoneyError("amount_invalid", `Unknown retail rounding: ${require_money.describeValue(mode)}`);
+	return mode;
+}
+/** Internal: the stored amount `p / q` (`q > 0`) rounded by `mode`, as integer storage units. */
+function retailUnits(p, q, info, mode) {
+	const scale = BigInt(info.storageScale);
+	checkMode(mode);
+	if (mode === "up-to-99") return require_money.divRound(require_money.divRound(p, q, "ceil"), scale, "floor") * scale + scale - 1n;
+	const zeroDecimal = info.storageDigits === 0;
+	if (mode === "none" && zeroDecimal) {
+		const size = require_rounding.unitSize(info, "currency");
+		return require_money.divRound(2n * p + q * size, 2n * q * size, "floor") * size;
+	}
+	if (mode === "none" || p <= 0n) {
+		if (q === 1n) return p;
+		return require_rounding.mulDivToUnit(p, 1n, q, info, "currency");
+	}
+	if (mode === "nearest") {
+		if (zeroDecimal) return require_money.divRound(p, q * 100n * scale, "ceil") * 100n * scale;
+		const charm = charmOf(scale);
+		const whole = require_money.divRound(p, q * scale, "floor") * scale;
+		return p <= (whole + charm) * q ? whole + charm : whole + scale + charm;
+	}
+	if (mode === "whole" || zeroDecimal) return require_money.divRound(p, q * scale, "ceil") * scale;
+	const ending = endingOf(scale, mode === ".99" ? 99n : 95n);
+	const candidate = require_money.divRound(p, q * scale, "floor") * scale + ending;
+	return candidate * q < p ? candidate + scale : candidate;
+}
+/** `m` rounded to a retail price by `mode` (see `RetailRounding`). */
+function roundRetail(m, mode) {
+	const { info } = require_money.storedDecimal(m);
+	return require_money.boundedMoney(retailUnits(BigInt(m.amount), 1n, info, mode), info);
+}
+/**
+* The market rounding parameters of `currency` for the SQL builders' unnest arrays:
+* `unit` = storage units per currency unit, `majorUnit` = storageScale, `charm` = the
+* `.95` charm in storage units, null for a zero-decimal currency.
+*/
+function priceRoundingParams(currency) {
+	const info = require_money.resolveCurrency(currency, { allowHistoric: true });
+	const scale = BigInt(info.storageScale);
+	return {
+		unit: Number(require_rounding.unitSize(info, "currency")),
+		majorUnit: info.storageScale,
+		charm: info.storageDigits === 0 ? null : Number(charmOf(scale))
+	};
+}
+//#endregion
+Object.defineProperty(exports, "priceRoundingParams", {
+	enumerable: true,
+	get: function() {
+		return priceRoundingParams;
+	}
+});
+Object.defineProperty(exports, "retailUnits", {
+	enumerable: true,
+	get: function() {
+		return retailUnits;
+	}
+});
+Object.defineProperty(exports, "roundRetail", {
+	enumerable: true,
+	get: function() {
+		return roundRetail;
+	}
+});

package/dist/retail-DRUTTQoJ.d.ts

@@ -0,0 +1,31 @@
+import { i as Money } from "./money-B-3aFjNJ.js";
+//#region src/fx/retail.d.ts
+/**
+ * - `'none'`: Medusa `applyRounding` 'none': a zero-decimal currency is rounded to a whole
+ *   unit (half toward +infinity, as `Math.round`: JPY 150050 gives 150100, since there is no
+ *   ¥0.50); any other currency is unchanged (an exact fractional price is rounded half-up to
+ *   the currency unit).
+ * - `'nearest'`: the market rule (Medusa `applyRounding`): up to the next `.95` of a major unit
+ *   (`.950` for three-decimal), or up to the next 100 major units for a zero-decimal currency.
+ * - `'whole'`, `'.99'`, `'.95'`: the AliExpress rule: up to a whole unit, or the smallest price
+ *   ending in .99 / .95 at or above it (zero-decimal currencies: up to a whole unit).
+ * - `'up-to-99'`: the smallest amount at or above it whose last storage digits are all 9
+ *   (domain retail `roundUpTo99`: 1234 cents gives 1299).
+ * A non-positive amount is never raised and a whole one is left as is (except by `'up-to-99'`
+ * and by `'none'` on a zero-decimal currency).
+ */
+type RetailRounding = 'none' | 'nearest' | 'whole' | '.99' | '.95' | 'up-to-99';
+/** `m` rounded to a retail price by `mode` (see `RetailRounding`). */
+declare function roundRetail(m: Money, mode: RetailRounding): Money;
+/**
+ * The market rounding parameters of `currency` for the SQL builders' unnest arrays:
+ * `unit` = storage units per currency unit, `majorUnit` = storageScale, `charm` = the
+ * `.95` charm in storage units, null for a zero-decimal currency.
+ */
+declare function priceRoundingParams(currency: string): {
+  unit: 1 | 100;
+  majorUnit: 100 | 1000;
+  charm: number | null;
+};
+//#endregion
+export { priceRoundingParams as n, roundRetail as r, RetailRounding as t };

package/dist/rounding-DHBtNCHG.cjs

@@ -0,0 +1,79 @@
+const require_money = require("./money-B3wH_Z4S.cjs");
+//#region src/rounding.ts
+/** Internal: the size of `unit` in storage units. */
+function unitSize(info, unit) {
+	if (unit === "storage") return 1n;
+	const scale = BigInt(info.storageScale);
+	return unit === "major" ? scale : scale / require_money.pow10(info.storageDigits);
+}
+/** Internal: `a x b / c` storage units rounded once by `mode` (default half-up) to a whole `unit`, in storage units. */
+function mulDivToUnit(a, b, c, info, unit, mode = "half-up") {
+	const size = unitSize(info, unit);
+	return require_money.mulDiv(a, b, c * size, mode) * size;
+}
+/** Internal: a fractional stored amount rounded to a whole unit (default a storage unit, half-up) as Money. */
+function roundStoredDecimal(amount, info, options = {}) {
+	const units = mulDivToUnit(amount.units, 1n, require_money.pow10(amount.scale), info, options.unit ?? "storage", options.rounding);
+	return require_money.boundedMoney(units, info);
+}
+/**
+* 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.
+*/
+function roundToUnit(value, currency, options = {}) {
+	const info = require_money.resolveCurrency(currency, { allowHistoric: true });
+	let amount;
+	if (typeof value === "object" && value !== null) {
+		const { info: own } = require_money.storedDecimal(value);
+		if (own.code !== info.code) throw new require_money.MoneyError("currency_mismatch", `Cannot round a ${own.code} amount as ${info.code}`);
+		amount = {
+			units: BigInt(value.amount),
+			scale: 0
+		};
+	} else amount = require_money.decimalOf(value);
+	return roundStoredDecimal(amount, info, options);
+}
+/**
+* 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.
+*/
+function roundMajor(major, currency, options = {}) {
+	const info = require_money.resolveCurrency(currency, { allowHistoric: true });
+	const value = require_money.decimalOf(major);
+	const digits = options.digits === "storage" ? info.storageDigits : info.displayDigits;
+	return Number(require_money.formatDecimal(require_money.roundToScale(value, digits, options.rounding ?? "half-up")));
+}
+//#endregion
+Object.defineProperty(exports, "mulDivToUnit", {
+	enumerable: true,
+	get: function() {
+		return mulDivToUnit;
+	}
+});
+Object.defineProperty(exports, "roundMajor", {
+	enumerable: true,
+	get: function() {
+		return roundMajor;
+	}
+});
+Object.defineProperty(exports, "roundStoredDecimal", {
+	enumerable: true,
+	get: function() {
+		return roundStoredDecimal;
+	}
+});
+Object.defineProperty(exports, "roundToUnit", {
+	enumerable: true,
+	get: function() {
+		return roundToUnit;
+	}
+});
+Object.defineProperty(exports, "unitSize", {
+	enumerable: true,
+	get: function() {
+		return unitSize;
+	}
+});

package/dist/rounding-g9rvye0k.js

@@ -0,0 +1,50 @@
+import { B as decimalOf, E as resolveCurrency, Q as MoneyError, X as mulDiv, dt as roundToScale, it as formatDecimal, s as storedDecimal, t as boundedMoney, ut as pow10 } from "./money-WhnGiI00.js";
+//#region src/rounding.ts
+/** Internal: the size of `unit` in storage units. */
+function unitSize(info, unit) {
+	if (unit === "storage") return 1n;
+	const scale = BigInt(info.storageScale);
+	return unit === "major" ? scale : scale / pow10(info.storageDigits);
+}
+/** Internal: `a x b / c` storage units rounded once by `mode` (default half-up) to a whole `unit`, in storage units. */
+function mulDivToUnit(a, b, c, info, unit, mode = "half-up") {
+	const size = unitSize(info, unit);
+	return mulDiv(a, b, c * size, mode) * size;
+}
+/** Internal: a fractional stored amount rounded to a whole unit (default a storage unit, half-up) as Money. */
+function roundStoredDecimal(amount, info, options = {}) {
+	const units = mulDivToUnit(amount.units, 1n, pow10(amount.scale), info, options.unit ?? "storage", options.rounding);
+	return boundedMoney(units, info);
+}
+/**
+* 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.
+*/
+function roundToUnit(value, currency, options = {}) {
+	const info = resolveCurrency(currency, { allowHistoric: true });
+	let amount;
+	if (typeof value === "object" && value !== null) {
+		const { info: own } = storedDecimal(value);
+		if (own.code !== info.code) throw new MoneyError("currency_mismatch", `Cannot round a ${own.code} amount as ${info.code}`);
+		amount = {
+			units: BigInt(value.amount),
+			scale: 0
+		};
+	} else amount = decimalOf(value);
+	return roundStoredDecimal(amount, info, options);
+}
+/**
+* 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.
+*/
+function roundMajor(major, currency, options = {}) {
+	const info = resolveCurrency(currency, { allowHistoric: true });
+	const value = decimalOf(major);
+	const digits = options.digits === "storage" ? info.storageDigits : info.displayDigits;
+	return Number(formatDecimal(roundToScale(value, digits, options.rounding ?? "half-up")));
+}
+//#endregion
+export { unitSize as a, roundToUnit as i, roundMajor as n, roundStoredDecimal as r, mulDivToUnit as t };