@amboras-dev/money 0.0.0-stage → 0.2.0

package/dist/format-DLhno7eX.cjs

@@ -0,0 +1,128 @@
+const require_money = require("./money-B3wH_Z4S.cjs");
+const require_rounding = require("./rounding-DHBtNCHG.cjs");
+//#region src/format.ts
+function intlDisplay(options) {
+	const display = options.currencyDisplay ?? "symbol";
+	return display === "symbol+code" ? "symbol" : display;
+}
+function finish(text, code, options) {
+	const withCode = options.currencyDisplay === "symbol+code" && !text.includes(code) ? `${text} ${code}` : text;
+	return options.minusSign === "−" ? withCode.replace("-", "−") : withCode;
+}
+const asIntlValue = (text) => text;
+/**
+* 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>'`.
+*/
+function formatMoney(m, options = {}) {
+	const { info, value } = require_money.storedDecimal(m);
+	const whole = require_money.fractionDigitsOf(value) === 0;
+	const digits = options.digits === "widen" ? Math.max(info.displayDigits, require_money.fractionDigitsOf(value)) : options.digits === "trim-zero" && whole ? 0 : info.displayDigits;
+	const text = require_money.formatDecimal(require_money.roundToScale(value, digits, "half-up"));
+	try {
+		return finish(require_money.numberFormat(require_money.resolveLocale(options.locale), {
+			style: "currency",
+			currency: info.code,
+			currencyDisplay: intlDisplay(options),
+			minimumFractionDigits: digits,
+			maximumFractionDigits: digits,
+			signDisplay: options.signDisplay ?? "auto"
+		}).format(asIntlValue(text)), info.code, options);
+	} catch {
+		return finish(`${info.code} ${text}`, info.code, options);
+	}
+}
+/**
+* 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`.
+*/
+function formatStored(amount, currency, options = {}) {
+	return formatMoney(require_rounding.roundToUnit(amount, currency), options);
+}
+function compact(currency, major, options, significant) {
+	return require_money.numberFormat(require_money.resolveLocale(options.locale), {
+		style: "currency",
+		currency,
+		currencyDisplay: intlDisplay(options),
+		notation: "compact",
+		compactDisplay: "short",
+		maximumSignificantDigits: significant,
+		signDisplay: options.signDisplay ?? "auto"
+	}).format(asIntlValue(major));
+}
+/**
+* Like `formatMoney` below `threshold` major units (default 10000, by magnitude); at or above
+* it, compact short notation with `maximumSignificantDigits` (default 3): `'$12.3K'`.
+*/
+function formatMoneyCompact(m, options = {}) {
+	const { info, value } = require_money.storedDecimal(m);
+	const threshold = require_money.decimalOf(options.threshold ?? 1e4, false, "threshold");
+	const magnitude = {
+		units: value.units < 0n ? -value.units : value.units,
+		scale: value.scale
+	};
+	if (require_money.compareDecimal(magnitude, threshold) < 0) return formatMoney(m, options);
+	try {
+		return finish(compact(info.code, require_money.formatDecimal(value), options, options.maximumSignificantDigits ?? 3), info.code, options);
+	} catch {
+		return formatMoney(m, options);
+	}
+}
+/** `'$10.00 – $20.00'` (en dash between spaces), `'$10.00+'` when `high` is null; zero amounts show `zeroLabel` when given. */
+function formatMoneyRange(low, high, options = {}) {
+	const lowCode = require_money.storedDecimal(low).info.code;
+	const show = (m) => m.amount === 0 && options.zeroLabel !== void 0 ? options.zeroLabel : formatMoney(m, options);
+	if (high === null) return `${show(low)}+`;
+	const highCode = require_money.storedDecimal(high).info.code;
+	if (highCode !== lowCode) throw new require_money.MoneyError("currency_mismatch", `Cannot format a range from ${lowCode} to ${highCode}`);
+	return `${show(low)} – ${show(high)}`;
+}
+/**
+* A chart tick formatter for values that already are major units: always compact, with the
+* same rounding as `formatMoneyCompact` (`1234567` gives `'$1.23M'`).
+*/
+function moneyAxisFormatter(currency, options = {}) {
+	const { code } = require_money.resolveCurrency(currency, { allowHistoric: true });
+	return (major) => {
+		if (!Number.isFinite(major)) return `${code} ${major}`;
+		const text = require_money.formatDecimal(require_money.decimalFromNumber(major));
+		try {
+			return finish(compact(code, text, options, 3), code, options);
+		} catch {
+			return `${code} ${text}`;
+		}
+	};
+}
+//#endregion
+Object.defineProperty(exports, "formatMoney", {
+	enumerable: true,
+	get: function() {
+		return formatMoney;
+	}
+});
+Object.defineProperty(exports, "formatMoneyCompact", {
+	enumerable: true,
+	get: function() {
+		return formatMoneyCompact;
+	}
+});
+Object.defineProperty(exports, "formatMoneyRange", {
+	enumerable: true,
+	get: function() {
+		return formatMoneyRange;
+	}
+});
+Object.defineProperty(exports, "formatStored", {
+	enumerable: true,
+	get: function() {
+		return formatStored;
+	}
+});
+Object.defineProperty(exports, "moneyAxisFormatter", {
+	enumerable: true,
+	get: function() {
+		return moneyAxisFormatter;
+	}
+});

package/dist/fx.cjs

@@ -0,0 +1,407 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_money = require("./money-B3wH_Z4S.cjs");
+const require_rounding = require("./rounding-DHBtNCHG.cjs");
+const require_own = require("./own-oP9DXFWv.cjs");
+const require_medusa = require("./medusa-lRY9xlsf.cjs");
+const require_rate = require("./rate-CVeMii4a.cjs");
+const require_retail = require("./retail-Cml8YSKg.cjs");
+//#region src/fx/convert.ts
+const infoOf = (code) => require_money.resolveCurrency(code, { allowHistoric: true });
+/**
+* The factor taking a stored `from` amount to a stored `to` amount for the major rate `r`
+* (1 from = r to): `{ r.n x storageScale(to), r.d x storageScale(from) }`. Replaces Medusa
+* `storedRateFactor`, `regionSwitchFactor`, `conversionFactor`.
+*/
+function convertFactor(from, to, r) {
+	const { numerator, denominator } = require_rate.checkRate(r);
+	return {
+		numerator: numerator * BigInt(infoOf(to).storageScale),
+		denominator: denominator * BigInt(infoOf(from).storageScale)
+	};
+}
+/**
+* `m` in `to` at the major rate `r` (1 m.currency = r to): exact `m x convertFactor`, rounded
+* once to `unit`, then `retail`. The same currency returns `m` unchanged.
+*/
+function convert(m, to, r, options = {}) {
+	const { info: source } = require_money.storedDecimal(m);
+	const target = infoOf(to);
+	if (source.code === target.code) return m;
+	const { numerator, denominator } = convertFactor(source.code, target.code, r);
+	const units = require_rounding.mulDivToUnit(BigInt(m.amount), numerator, denominator, target, options.unit ?? "currency", options.rounding);
+	return require_money.boundedMoney(options.retail === void 0 ? units : require_retail.retailUnits(units, 1n, target, options.retail), target);
+}
+/**
+* The major rate two prices imply, `major(b) / major(a)`, exactly and in lowest terms (JPY
+* 150000 against USD 1000 gives 150). Both must be positive, else `rate_invalid`.
+*/
+function impliedRate(a, b) {
+	const { info: left } = require_money.storedDecimal(a);
+	const { info: right } = require_money.storedDecimal(b);
+	if (a.amount <= 0 || b.amount <= 0) throw new require_money.MoneyError("rate_invalid", `An implied rate needs two positive amounts, got ${a.amount} and ${b.amount}`);
+	const numerator = BigInt(b.amount) * BigInt(left.storageScale);
+	const denominator = BigInt(a.amount) * BigInt(right.storageScale);
+	const divisor = require_money.gcd(numerator, denominator);
+	return {
+		numerator: numerator / divisor,
+		denominator: denominator / divisor
+	};
+}
+//#endregion
+//#region src/fx/format-rate.ts
+/** `floor(log10(n / d))` of a positive ratio, exactly. */
+function exponentOf(n, d) {
+	let e = n.toString().length - d.toString().length;
+	const at = (k) => k >= 0 ? require_money.compareRatio(n, d, require_money.pow10(k), 1n) : require_money.compareRatio(n, d, 1n, require_money.pow10(-k));
+	if (at(e) < 0) e -= 1;
+	return e;
+}
+const asIntlValue = (text) => text;
+/**
+* `'1 USD = 83.42 INR'`. `decimals: 'auto'` (default) shows 4 significant digits with at
+* least 2 and at most 8 fraction digits; a number fixes them. Rounded half-up exactly, then
+* grouped for `locale` (default `'en-US'`).
+*/
+function formatRate(r, from, to, options = {}) {
+	const { numerator, denominator } = require_rate.checkRate(r);
+	const fromCode = require_money.resolveCurrency(from, { allowHistoric: true }).code;
+	const toCode = require_money.resolveCurrency(to, { allowHistoric: true }).code;
+	const requested = options.decimals ?? "auto";
+	let digits;
+	if (requested === "auto") digits = Math.min(8, Math.max(2, 3 - exponentOf(numerator, denominator)));
+	else if (Number.isSafeInteger(requested) && requested >= 0 && requested <= 20) digits = requested;
+	else throw new require_money.MoneyError("amount_invalid", `decimals must be 'auto' or an integer from 0 to 20, got ${require_money.describeValue(requested)}`);
+	const value = require_money.ratioToDecimal(numerator, denominator, digits);
+	return `1 ${fromCode} = ${require_money.numberFormat(require_money.resolveLocale(options.locale), {
+		minimumFractionDigits: digits,
+		maximumFractionDigits: digits
+	}).format(asIntlValue(require_money.formatDecimal(value)))} ${toCode}`;
+}
+//#endregion
+//#region src/fx/plausibility.ts
+/** Medusa PRICE_SEED_RATE_MAX_DEVIATION's default. */
+const DEFAULT_RATE_MAX_DEVIATION = 2;
+/** chooseFactor's tolerance between the conventional factor and the observed median. */
+const FACTOR_TOLERANCE = .02;
+/** How far apart two positive rates are, as a factor >= 1 (2 = one is double the other). */
+function deviationFactor(stored, reference) {
+	const ratio = stored / reference;
+	return ratio >= 1 ? ratio : 1 / ratio;
+}
+const isPositiveFinite$1 = (n) => typeof n === "number" && Number.isFinite(n) && n > 0;
+/** A positive finite number as an exact Decimal; anything else throws `amount_invalid` naming `name`. */
+function positiveDecimal(n, name) {
+	if (!isPositiveFinite$1(n)) throw new require_money.MoneyError("amount_invalid", `${name} must be a positive finite number, got ${require_money.describeValue(n)}`);
+	return require_money.decimalFromNumber(n);
+}
+function validRate(r) {
+	try {
+		return require_rate.checkRate(r);
+	} catch {
+		return null;
+	}
+}
+/**
+* One locked rate against the reference, in Medusa `classifyRates` order: invalid (null or not
+* a rate) is refused `invalid`; no reference is unverifiable `no_reference`; no positive
+* reference for the currency is unverifiable `no_pair`; a deviation strictly above
+* `maxDeviation` (default 2) is refused `implausible`; else plausible.
+*/
+function classifyRate(r, code, reference, options = {}) {
+	const currency = code.toLowerCase();
+	const max = positiveDecimal(options.maxDeviation ?? 2, "maxDeviation");
+	const valid = validRate(r);
+	if (!valid) return {
+		status: "refused",
+		reason: "invalid",
+		currency,
+		stored: NaN
+	};
+	const stored = require_rate.rateToNumber(valid, { decimals: "exact" });
+	if (!reference) return {
+		status: "unverifiable",
+		reason: "no_reference",
+		currency,
+		stored
+	};
+	const ref = require_own.hasOwnKey(reference.rates, currency) ? reference.rates[currency] : void 0;
+	if (!isPositiveFinite$1(ref)) return {
+		status: "unverifiable",
+		reason: "no_pair",
+		currency,
+		stored
+	};
+	const refValue = require_money.decimalFromNumber(ref);
+	const top = valid.numerator * require_money.pow10(refValue.scale);
+	const bottom = valid.denominator * refValue.units;
+	const maxD = require_money.pow10(max.scale);
+	if (require_money.compareRatio(top, bottom, max.units, maxD) > 0 || require_money.compareRatio(bottom, top, max.units, maxD) > 0) return {
+		status: "refused",
+		reason: "implausible",
+		currency,
+		stored,
+		reference: ref,
+		factor: deviationFactor(stored, ref),
+		source: reference.source
+	};
+	return {
+		status: "plausible",
+		currency,
+		stored
+	};
+}
+/** `|value - c| / c <= tolerance`, exactly (`c` positive). */
+function closeTo(value, c, tolerance) {
+	const scaledC = c.numerator * require_money.pow10(value.scale);
+	const gap = value.units * c.denominator - scaledC;
+	return require_money.compareRatio((gap < 0n ? -gap : gap) * require_money.pow10(tolerance.scale), 1n, tolerance.units * scaledC, 1n) <= 0;
+}
+/**
+* The storage factor confirmed by the store's own prices (Medusa `chooseFactor`): the
+* candidates `[c, c / 100, c x 100]` against the upper median of the finite positive observed
+* ratios; the first within `tolerance` (default 0.02) wins, none gives null. No observations
+* trusts `conventional`.
+*/
+function confirmStoredFactor(conventional, observedRatios, options = {}) {
+	const c = require_rate.checkRate(conventional);
+	const tolerance = require_money.decimalFromNumber(nonNegative(options.tolerance ?? .02));
+	const ratios = observedRatios.filter(isPositiveFinite$1).sort((a, b) => a - b);
+	if (ratios.length === 0) return c;
+	const median = require_money.decimalFromNumber(ratios[Math.floor(ratios.length / 2)]);
+	return [
+		c,
+		{
+			numerator: c.numerator,
+			denominator: c.denominator * 100n
+		},
+		{
+			numerator: c.numerator * 100n,
+			denominator: c.denominator
+		}
+	].find((candidate) => closeTo(median, candidate, tolerance)) ?? null;
+}
+function nonNegative(n) {
+	if (typeof n !== "number" || !Number.isFinite(n) || n < 0) throw new require_money.MoneyError("amount_invalid", `tolerance must be a non-negative finite number, got ${require_money.describeValue(n)}`);
+	return n;
+}
+/**
+* The upper median of `rates` and which of them lie within `tolerance` (default 0.01) of it:
+* accepted iff `|r / median - 1| <= tolerance`, exactly. No rates: `{ median: null, accepted: [] }`.
+*/
+function rateConsensus(rates, options = {}) {
+	const valid = rates.map(require_rate.checkRate);
+	const tolerance = require_money.decimalFromNumber(nonNegative(options.tolerance ?? .01));
+	if (valid.length === 0) return {
+		median: null,
+		accepted: []
+	};
+	const sorted = [...valid].sort((a, b) => require_money.compareRatio(a.numerator, a.denominator, b.numerator, b.denominator));
+	const median = sorted[Math.floor(sorted.length / 2)];
+	return {
+		median,
+		accepted: valid.map((r) => {
+			const gap = r.numerator * median.denominator - median.numerator * r.denominator;
+			const scale = require_money.pow10(tolerance.scale);
+			return require_money.compareRatio((gap < 0n ? -gap : gap) * scale, 1n, tolerance.units * median.numerator * r.denominator, 1n) <= 0;
+		})
+	};
+}
+//#endregion
+//#region src/fx/reporting.ts
+const FACTOR_DIGITS = 20;
+/**
+* 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).
+*/
+function storeFactors(defaultCurrency, rows) {
+	const base = require_money.resolveCurrency(defaultCurrency, { allowHistoric: true });
+	const factors = { [base.code.toLowerCase()]: "1" };
+	for (const row of rows) {
+		const info = require_money.findCurrency(row?.currency_code, { allowHistoric: true });
+		const r = require_rate.rateFromRow(row);
+		if (!info || !r || info.code === base.code) continue;
+		const units = require_money.mulDiv(BigInt(base.storageScale) * r.denominator, require_money.pow10(FACTOR_DIGITS), BigInt(info.storageScale) * r.numerator, "half-up");
+		factors[info.code.toLowerCase()] = require_money.toDecimalText({
+			units,
+			scale: FACTOR_DIGITS
+		});
+	}
+	return {
+		base: base.code,
+		factors: Object.freeze(factors)
+	};
+}
+/**
+* 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`.
+*/
+function toReporting(items, table) {
+	const base = require_money.resolveCurrency(table.base, { allowHistoric: true });
+	const missing = /* @__PURE__ */ new Set();
+	let total = 0n;
+	for (const item of items) {
+		const { info } = require_money.storedDecimal(item);
+		const key = info.code.toLowerCase();
+		const text = require_own.hasOwnKey(table.factors, key) ? table.factors[key] : void 0;
+		if (text === void 0) {
+			missing.add(info.code);
+			continue;
+		}
+		const factor = require_money.decimalOf(text, false, `factors.${key}`);
+		total += require_money.mulDiv(BigInt(item.amount), factor.units, require_money.pow10(factor.scale), "half-up");
+	}
+	return {
+		total: require_money.boundedMoney(total, base),
+		complete: missing.size === 0,
+		missing: [...missing].sort()
+	};
+}
+//#endregion
+//#region src/fx/settings.ts
+const RATE_MODES = ["manual", "dynamic"];
+const PRICE_ROUNDINGS = ["none", "nearest"];
+/** `store_currency_rate.rate_mode` as readers coerce it: `'manual'` exactly, else `'dynamic'`. */
+function parseRateMode(value) {
+	return value === "manual" ? "manual" : "dynamic";
+}
+/** `store_currency_rate.rounding` as readers coerce it: `'nearest'` exactly, else `'none'`. */
+function parsePriceRounding(value) {
+	return value === "nearest" ? "nearest" : "none";
+}
+/**
+* The amount a per-currency setting holds for `currency`: the listed entry, else the explicit
+* fallback: `'refuse'` gives null; `'major'` is that many major units of `currency` itself
+* (the store-credit cap `{ kind: 'major', amount: '15000' }`); `'convert'` converts the
+* `from` entry at `rate` (null when there is no `from` entry). Never a silent default.
+*/
+function resolveMoneyByCurrency(setting, currency, options) {
+	const info = require_money.resolveCurrency(currency, { allowHistoric: true });
+	const listed = require_medusa.moneyFor(setting, info.code);
+	if (listed) return {
+		money: listed,
+		source: "listed"
+	};
+	const fallback = options.fallback;
+	if (fallback.kind === "major") return {
+		money: require_money.fromMajor(fallback.amount, info.code),
+		source: "fallback"
+	};
+	if (fallback.kind === "convert") {
+		const base = require_medusa.moneyFor(setting, fallback.from);
+		return base ? {
+			money: convert(base, info.code, fallback.rate, { retail: fallback.retail }),
+			source: "fallback"
+		} : null;
+	}
+	return null;
+}
+//#endregion
+//#region src/fx/tables.ts
+/** 1 USD = rate units of the currency, exact (see data/pegs.ts for the sources). Upper-case keys. */
+const USD_PEGS = Object.freeze(Object.fromEntries(Object.entries({
+	AED: [36725n, 10000n],
+	SAR: [375n, 100n],
+	QAR: [364n, 100n],
+	BHD: [376n, 1000n],
+	OMR: [3845n, 10000n]
+}).map(([code, [numerator, denominator]]) => [code, Object.freeze({
+	numerator,
+	denominator
+})])));
+const isPositiveFinite = (n) => typeof n === "number" && Number.isFinite(n) && n > 0;
+/** A feed's rate table with lower-case keys and only finite positive numbers kept (Medusa `lowerKeys`). Never throws. */
+function sanitizeRateTable(raw) {
+	const out = {};
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return out;
+	for (const [key, value] of Object.entries(raw)) if (isPositiveFinite(value)) out[key.toLowerCase()] = value;
+	return out;
+}
+/** `{ ...fallback, ...primary }`: the primary feed (ECB) wins every currency it publishes. */
+function mergeRateTables(primary, fallback) {
+	return {
+		...fallback,
+		...primary
+	};
+}
+function own(table, code) {
+	for (const key of [code.toUpperCase(), code.toLowerCase()]) if (require_own.hasOwnKey(table, key)) return table[key];
+}
+/** Units of `code` per 1 USD: the feed's finite positive value, else its peg, else undefined. */
+function perUsd(code, ratesPerUsd, pegs) {
+	const live = own(ratesPerUsd, code);
+	if (isPositiveFinite(live)) {
+		const d = require_money.decimalFromNumber(live);
+		return {
+			numerator: d.units,
+			denominator: require_money.pow10(d.scale)
+		};
+	}
+	const peg = own(pegs, code);
+	return peg === void 0 ? void 0 : require_rate.checkRate(peg);
+}
+/**
+* The rate 1 `from` = ? `to` when the live pair is unavailable, through the USD pegs
+* (orch `resolveRateMajor`): a pegged `to` gives the peg from USD, else `(from -> USD) x peg`
+* with `from -> USD` read from `ratesPerUsd` (units per 1 USD, any key case) or from `from`'s
+* own peg; a pegged `from` into USD gives the inverse peg (new, symmetric). The same code
+* gives 1/1; anything else null.
+*/
+function pegFallback(from, to, ratesPerUsd, pegs = USD_PEGS) {
+	const f = from.toUpperCase();
+	const t = to.toUpperCase();
+	if (f === t) return {
+		numerator: 1n,
+		denominator: 1n
+	};
+	const toPeg = own(pegs, t);
+	if (toPeg !== void 0) {
+		const peg = require_rate.checkRate(toPeg);
+		if (f === "USD") return peg;
+		const source = perUsd(f, ratesPerUsd, pegs);
+		if (!source) return null;
+		return {
+			numerator: peg.numerator * source.denominator,
+			denominator: peg.denominator * source.numerator
+		};
+	}
+	const fromPeg = own(pegs, f);
+	return fromPeg !== void 0 && t === "USD" ? require_rate.invertRate(fromPeg) : null;
+}
+//#endregion
+exports.DEFAULT_RATE_MAX_DEVIATION = DEFAULT_RATE_MAX_DEVIATION;
+exports.FACTOR_TOLERANCE = FACTOR_TOLERANCE;
+exports.PRICE_ROUNDINGS = PRICE_ROUNDINGS;
+exports.RATE_BOUNDS = require_rate.RATE_BOUNDS;
+exports.RATE_MODES = RATE_MODES;
+exports.RATE_REF = require_rate.RATE_REF;
+exports.USD_PEGS = USD_PEGS;
+exports.classifyRate = classifyRate;
+exports.confirmStoredFactor = confirmStoredFactor;
+exports.convert = convert;
+exports.convertFactor = convertFactor;
+exports.crossRate = require_rate.crossRate;
+exports.deviationFactor = deviationFactor;
+exports.formatRate = formatRate;
+exports.impliedRate = impliedRate;
+exports.invertRate = require_rate.invertRate;
+exports.mergeRateTables = mergeRateTables;
+exports.parsePriceRounding = parsePriceRounding;
+exports.parseRateMode = parseRateMode;
+exports.pegFallback = pegFallback;
+exports.priceRoundingParams = require_retail.priceRoundingParams;
+exports.rate = require_rate.rate;
+exports.rateConsensus = rateConsensus;
+exports.rateEquals = require_rate.rateEquals;
+exports.rateFromDecimal = require_rate.rateFromDecimal;
+exports.rateFromRow = require_rate.rateFromRow;
+exports.rateToDecimal = require_rate.rateToDecimal;
+exports.rateToNumber = require_rate.rateToNumber;
+exports.resolveMoneyByCurrency = resolveMoneyByCurrency;
+exports.roundRetail = require_retail.roundRetail;
+exports.sanitizeRateTable = sanitizeRateTable;
+exports.storeFactors = storeFactors;
+exports.toReporting = toReporting;