@amboras-dev/money 0.0.0-stage → 0.2.0

package/dist/number-text-BWu67jUq.cjs

@@ -0,0 +1,145 @@
+const require_money = require("./money-B3wH_Z4S.cjs");
+//#region src/internal/number-text.ts
+const MINUS = /^[-−]/;
+const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const unparseable = Object.freeze({ reason: "unparseable" });
+/**
+* THE digit grouping a whole part may use, as a regex source over the separator source `s`:
+* thousands (`\d{1,3}(s\d{3})+`: `1,234,567`) or Indian lakh (`\d{1,2}(s\d{2})+s\d{3}`:
+* three digits on the right, then pairs: `1,00,000`, `12,34,567`). Valid only when every
+* group fits one of the two, so `1,2345` and `12,3,456` are not grouping.
+*/
+function digitGroupingSource(s) {
+	return `\\d{1,3}(?:${s}\\d{3})+|\\d{1,2}(?:${s}\\d{2})+${s}\\d{3}`;
+}
+const GROUPED = new RegExp(`^(?:${digitGroupingSource(",")})$`);
+/** Whether `groups`, the digit runs between the separators read as grouping, are valid digit grouping. */
+const isDigitGrouping = (groups) => GROUPED.test(groups.join(","));
+function stripCurrency(text, info) {
+	return require_money.currencyMarks(info).sort((a, b) => b.length - a.length).reduce((rest, token) => rest.replace(new RegExp(escapeRegExp(token), "gi"), ""), text);
+}
+function value(negative, whole, fraction, decimalMark) {
+	const digits = whole + fraction;
+	if (digits.length > 400) return unparseable;
+	const units = BigInt(digits);
+	return {
+		sign: negative && units !== 0n ? -1 : 1,
+		units,
+		scale: fraction.length,
+		decimalMark
+	};
+}
+/** `'auto'`: decide which of `.` and `,` is the decimal separator (see `NumberTextOptions.decimalSeparator`). */
+function readAuto(negative, body, info, rounding) {
+	if (!/^[\d.,]+$/.test(body) || !/\d/.test(body)) return unparseable;
+	if (info?.storageDigits === 0) {
+		const groups = body.split(/[.,]/);
+		const last = groups.length > 1 ? groups[groups.length - 1] : null;
+		const isDecimal = last !== null && last.length !== 3;
+		const decimalMark = isDecimal ? body[body.length - last.length - 1] : null;
+		const wholeGroups = isDecimal ? groups.slice(0, -1) : groups;
+		if (wholeGroups.length > 1 && (!isDigitGrouping(wholeGroups) || last === "")) return unparseable;
+		const read = value(negative, wholeGroups.join("") || "0", isDecimal ? last : "", decimalMark);
+		if ("reason" in read || rounding === null) return read;
+		const rounded = require_money.roundToScale({
+			units: BigInt(read.sign) * read.units,
+			scale: read.scale
+		}, 0, rounding);
+		const units = rounded.units < 0n ? -rounded.units : rounded.units;
+		return {
+			sign: read.sign < 0 && units !== 0n ? -1 : 1,
+			units,
+			scale: 0,
+			decimalMark
+		};
+	}
+	const lastDot = body.lastIndexOf(".");
+	const lastComma = body.lastIndexOf(",");
+	if (lastDot >= 0 && lastComma >= 0) {
+		const at = Math.max(lastDot, lastComma);
+		const groups = body.slice(0, at).split(/[.,]/);
+		const fraction = body.slice(at + 1);
+		if (!isDigitGrouping(groups) || fraction === "") return unparseable;
+		return value(negative, groups.join(""), fraction, body[at]);
+	}
+	const mark = lastDot >= 0 ? "." : lastComma >= 0 ? "," : null;
+	if (mark === null) return value(negative, body, "", null);
+	const at = body.indexOf(mark);
+	if (at !== body.lastIndexOf(mark)) {
+		const groups = body.split(mark);
+		return isDigitGrouping(groups) ? value(negative, groups.join(""), "", null) : unparseable;
+	}
+	const whole = body.slice(0, at);
+	const fraction = body.slice(at + 1);
+	if (fraction.length !== 3 || /^0*$/.test(whole) || isThreeDecimalMark(mark, info)) return value(negative, whole || "0", fraction, mark);
+	return isDigitGrouping([whole, fraction]) ? value(negative, whole + fraction, "", null) : unparseable;
+}
+/** Whether `mark` is the decimal mark of a currency displaying three decimals: `','` for TND (`commaDecimal`), else `'.'`. */
+function isThreeDecimalMark(mark, info) {
+	return info?.displayDigits === 3 && mark === (info.commaDecimal ? "," : ".");
+}
+/** An explicit decimal separator, with grouping validated in 3-digit groups. */
+function readExplicit(negative, body, decimal, group, info) {
+	const d = escapeRegExp(decimal);
+	if (info?.storageDigits === 0 && group !== null && new RegExp(`^\\d{1,3}(?:${d}\\d{3})+$`).test(body)) return value(negative, body.split(decimal).join(""), "", null);
+	const [whole, fraction, extra] = body.split(decimal);
+	if (extra !== void 0 || fraction === "" || fraction !== void 0 && !/^\d+$/.test(fraction)) return unparseable;
+	const decimalMark = fraction === void 0 ? null : decimal;
+	if (/^\d+$/.test(whole)) return value(negative, whole, fraction ?? "", decimalMark);
+	if (whole === "" && group === null && fraction !== void 0) return value(negative, "0", fraction, decimalMark);
+	if (group === null || !new RegExp(`^(?:${digitGroupingSource(escapeRegExp(group))})$`).test(whole)) return unparseable;
+	return value(negative, whole.split(group).join(""), fraction ?? "", decimalMark);
+}
+/** The first separator written between two digits that is not the decimal mark. */
+function groupMarkOf(written, decimalMark) {
+	for (const [, mark] of written.matchAll(/\d(\D)(?=\d)/g)) if (mark !== decimalMark) return mark;
+	return null;
+}
+/**
+* Amount text to sign, digits and scale, exactly; or why not (`'empty'`, `'unparseable'`).
+* Whitespace of every kind (NBSP, thin, narrow NBSP) is grouping and removed; in `'auto'`
+* mode apostrophes are too. A leading `-` or U+2212 is the sign. No exponent, no hex; an
+* explicit separator also refuses `'1.'` and, unless `groupSeparator` is null, `'.5'` ('auto'
+* reads them as 1 and 0.5). Never throws for bad text; an unknown `currency` throws `currency_invalid`.
+*/
+function readNumberText(text, options = {}) {
+	const info = options.currency === void 0 ? null : require_money.resolveCurrency(options.currency, { allowHistoric: true });
+	const decimal = options.decimalSeparator ?? ".";
+	const auto = decimal === "auto";
+	const group = options.groupSeparator === void 0 ? decimal === "." ? "," : decimal === "," ? "." : null : options.groupSeparator;
+	if (!auto && (decimal.length !== 1 || group === decimal)) throw new TypeError(`Invalid separators: decimal ${require_money.describeValue(decimal)}, group ${require_money.describeValue(group)}`);
+	if (typeof text !== "string") return unparseable;
+	const written = info ? stripCurrency(text.trim(), info) : text.trim();
+	let rest = written.replace(auto ? /[\s'’]/g : /\s/g, "");
+	if (rest === "") return { reason: "empty" };
+	let negative = false;
+	if (options.allowTrailingText) {
+		const separators = auto ? ".," : escapeRegExp(`${decimal}${group ?? ""}`);
+		const run = new RegExp(`([-\\u2212]?)(\\d[\\d${separators}]*)`).exec(rest);
+		if (!run) return unparseable;
+		negative = run[1] !== "";
+		rest = run[2].replace(new RegExp(`[${separators}]+$`), "");
+	} else if (MINUS.test(rest)) {
+		negative = true;
+		rest = rest.slice(1);
+	}
+	const read = auto ? readAuto(negative, rest, info, options.keepFraction ? null : options.rounding ?? "half-up") : readExplicit(negative, rest, decimal, group, info);
+	if ("reason" in read) return read;
+	return {
+		...read,
+		groupMark: groupMarkOf(written, read.decimalMark)
+	};
+}
+//#endregion
+Object.defineProperty(exports, "digitGroupingSource", {
+	enumerable: true,
+	get: function() {
+		return digitGroupingSource;
+	}
+});
+Object.defineProperty(exports, "readNumberText", {
+	enumerable: true,
+	get: function() {
+		return readNumberText;
+	}
+});

package/dist/number-text-DE-q4jO5.js

@@ -0,0 +1,134 @@
+import { $ as describeValue, E as resolveCurrency, dt as roundToScale, m as currencyMarks } from "./money-WhnGiI00.js";
+//#region src/internal/number-text.ts
+const MINUS = /^[-−]/;
+const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const unparseable = Object.freeze({ reason: "unparseable" });
+/**
+* THE digit grouping a whole part may use, as a regex source over the separator source `s`:
+* thousands (`\d{1,3}(s\d{3})+`: `1,234,567`) or Indian lakh (`\d{1,2}(s\d{2})+s\d{3}`:
+* three digits on the right, then pairs: `1,00,000`, `12,34,567`). Valid only when every
+* group fits one of the two, so `1,2345` and `12,3,456` are not grouping.
+*/
+function digitGroupingSource(s) {
+	return `\\d{1,3}(?:${s}\\d{3})+|\\d{1,2}(?:${s}\\d{2})+${s}\\d{3}`;
+}
+const GROUPED = new RegExp(`^(?:${digitGroupingSource(",")})$`);
+/** Whether `groups`, the digit runs between the separators read as grouping, are valid digit grouping. */
+const isDigitGrouping = (groups) => GROUPED.test(groups.join(","));
+function stripCurrency(text, info) {
+	return currencyMarks(info).sort((a, b) => b.length - a.length).reduce((rest, token) => rest.replace(new RegExp(escapeRegExp(token), "gi"), ""), text);
+}
+function value(negative, whole, fraction, decimalMark) {
+	const digits = whole + fraction;
+	if (digits.length > 400) return unparseable;
+	const units = BigInt(digits);
+	return {
+		sign: negative && units !== 0n ? -1 : 1,
+		units,
+		scale: fraction.length,
+		decimalMark
+	};
+}
+/** `'auto'`: decide which of `.` and `,` is the decimal separator (see `NumberTextOptions.decimalSeparator`). */
+function readAuto(negative, body, info, rounding) {
+	if (!/^[\d.,]+$/.test(body) || !/\d/.test(body)) return unparseable;
+	if (info?.storageDigits === 0) {
+		const groups = body.split(/[.,]/);
+		const last = groups.length > 1 ? groups[groups.length - 1] : null;
+		const isDecimal = last !== null && last.length !== 3;
+		const decimalMark = isDecimal ? body[body.length - last.length - 1] : null;
+		const wholeGroups = isDecimal ? groups.slice(0, -1) : groups;
+		if (wholeGroups.length > 1 && (!isDigitGrouping(wholeGroups) || last === "")) return unparseable;
+		const read = value(negative, wholeGroups.join("") || "0", isDecimal ? last : "", decimalMark);
+		if ("reason" in read || rounding === null) return read;
+		const rounded = roundToScale({
+			units: BigInt(read.sign) * read.units,
+			scale: read.scale
+		}, 0, rounding);
+		const units = rounded.units < 0n ? -rounded.units : rounded.units;
+		return {
+			sign: read.sign < 0 && units !== 0n ? -1 : 1,
+			units,
+			scale: 0,
+			decimalMark
+		};
+	}
+	const lastDot = body.lastIndexOf(".");
+	const lastComma = body.lastIndexOf(",");
+	if (lastDot >= 0 && lastComma >= 0) {
+		const at = Math.max(lastDot, lastComma);
+		const groups = body.slice(0, at).split(/[.,]/);
+		const fraction = body.slice(at + 1);
+		if (!isDigitGrouping(groups) || fraction === "") return unparseable;
+		return value(negative, groups.join(""), fraction, body[at]);
+	}
+	const mark = lastDot >= 0 ? "." : lastComma >= 0 ? "," : null;
+	if (mark === null) return value(negative, body, "", null);
+	const at = body.indexOf(mark);
+	if (at !== body.lastIndexOf(mark)) {
+		const groups = body.split(mark);
+		return isDigitGrouping(groups) ? value(negative, groups.join(""), "", null) : unparseable;
+	}
+	const whole = body.slice(0, at);
+	const fraction = body.slice(at + 1);
+	if (fraction.length !== 3 || /^0*$/.test(whole) || isThreeDecimalMark(mark, info)) return value(negative, whole || "0", fraction, mark);
+	return isDigitGrouping([whole, fraction]) ? value(negative, whole + fraction, "", null) : unparseable;
+}
+/** Whether `mark` is the decimal mark of a currency displaying three decimals: `','` for TND (`commaDecimal`), else `'.'`. */
+function isThreeDecimalMark(mark, info) {
+	return info?.displayDigits === 3 && mark === (info.commaDecimal ? "," : ".");
+}
+/** An explicit decimal separator, with grouping validated in 3-digit groups. */
+function readExplicit(negative, body, decimal, group, info) {
+	const d = escapeRegExp(decimal);
+	if (info?.storageDigits === 0 && group !== null && new RegExp(`^\\d{1,3}(?:${d}\\d{3})+$`).test(body)) return value(negative, body.split(decimal).join(""), "", null);
+	const [whole, fraction, extra] = body.split(decimal);
+	if (extra !== void 0 || fraction === "" || fraction !== void 0 && !/^\d+$/.test(fraction)) return unparseable;
+	const decimalMark = fraction === void 0 ? null : decimal;
+	if (/^\d+$/.test(whole)) return value(negative, whole, fraction ?? "", decimalMark);
+	if (whole === "" && group === null && fraction !== void 0) return value(negative, "0", fraction, decimalMark);
+	if (group === null || !new RegExp(`^(?:${digitGroupingSource(escapeRegExp(group))})$`).test(whole)) return unparseable;
+	return value(negative, whole.split(group).join(""), fraction ?? "", decimalMark);
+}
+/** The first separator written between two digits that is not the decimal mark. */
+function groupMarkOf(written, decimalMark) {
+	for (const [, mark] of written.matchAll(/\d(\D)(?=\d)/g)) if (mark !== decimalMark) return mark;
+	return null;
+}
+/**
+* Amount text to sign, digits and scale, exactly; or why not (`'empty'`, `'unparseable'`).
+* Whitespace of every kind (NBSP, thin, narrow NBSP) is grouping and removed; in `'auto'`
+* mode apostrophes are too. A leading `-` or U+2212 is the sign. No exponent, no hex; an
+* explicit separator also refuses `'1.'` and, unless `groupSeparator` is null, `'.5'` ('auto'
+* reads them as 1 and 0.5). Never throws for bad text; an unknown `currency` throws `currency_invalid`.
+*/
+function readNumberText(text, options = {}) {
+	const info = options.currency === void 0 ? null : resolveCurrency(options.currency, { allowHistoric: true });
+	const decimal = options.decimalSeparator ?? ".";
+	const auto = decimal === "auto";
+	const group = options.groupSeparator === void 0 ? decimal === "." ? "," : decimal === "," ? "." : null : options.groupSeparator;
+	if (!auto && (decimal.length !== 1 || group === decimal)) throw new TypeError(`Invalid separators: decimal ${describeValue(decimal)}, group ${describeValue(group)}`);
+	if (typeof text !== "string") return unparseable;
+	const written = info ? stripCurrency(text.trim(), info) : text.trim();
+	let rest = written.replace(auto ? /[\s'’]/g : /\s/g, "");
+	if (rest === "") return { reason: "empty" };
+	let negative = false;
+	if (options.allowTrailingText) {
+		const separators = auto ? ".," : escapeRegExp(`${decimal}${group ?? ""}`);
+		const run = new RegExp(`([-\\u2212]?)(\\d[\\d${separators}]*)`).exec(rest);
+		if (!run) return unparseable;
+		negative = run[1] !== "";
+		rest = run[2].replace(new RegExp(`[${separators}]+$`), "");
+	} else if (MINUS.test(rest)) {
+		negative = true;
+		rest = rest.slice(1);
+	}
+	const read = auto ? readAuto(negative, rest, info, options.keepFraction ? null : options.rounding ?? "half-up") : readExplicit(negative, rest, decimal, group, info);
+	if ("reason" in read) return read;
+	return {
+		...read,
+		groupMark: groupMarkOf(written, read.decimalMark)
+	};
+}
+//#endregion
+export { readNumberText as n, digitGroupingSource as t };

package/dist/own-D7544D3k.js

@@ -0,0 +1,4 @@
+//#region src/internal/own.ts
+const hasOwnKey = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+//#endregion
+export { hasOwnKey as t };

package/dist/own-oP9DXFWv.cjs

@@ -0,0 +1,9 @@
+//#region src/internal/own.ts
+const hasOwnKey = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+//#endregion
+Object.defineProperty(exports, "hasOwnKey", {
+	enumerable: true,
+	get: function() {
+		return hasOwnKey;
+	}
+});

package/dist/percent-C0InC2t2.cjs

@@ -0,0 +1,43 @@
+const require_money = require("./money-B3wH_Z4S.cjs");
+//#region src/internal/percent.ts
+/** 100% for a percent written with `scale` fraction digits: the denominator of its units. */
+function hundredPercent(scale) {
+	return 100n * require_money.pow10(scale);
+}
+/** `percent` percent of `units`, rounded once by `mode`. */
+function percentOfUnits(units, percent, mode) {
+	return require_money.mulDiv(units, percent.units, hundredPercent(percent.scale), mode);
+}
+/** `bps` basis points of `units / denominator` (default a whole number of units), rounded once by `mode`. */
+function basisPointsOf(units, bps, mode, denominator = 1n) {
+	return require_money.mulDiv(units, bps, 10000n * denominator, mode);
+}
+/** `a / b` in percent with `digits` fraction digits, half-up (`b` must not be zero). */
+function percentRatio(a, b, digits) {
+	return require_money.ratioToDecimal(a * 100n, b, digits);
+}
+//#endregion
+Object.defineProperty(exports, "basisPointsOf", {
+	enumerable: true,
+	get: function() {
+		return basisPointsOf;
+	}
+});
+Object.defineProperty(exports, "hundredPercent", {
+	enumerable: true,
+	get: function() {
+		return hundredPercent;
+	}
+});
+Object.defineProperty(exports, "percentOfUnits", {
+	enumerable: true,
+	get: function() {
+		return percentOfUnits;
+	}
+});
+Object.defineProperty(exports, "percentRatio", {
+	enumerable: true,
+	get: function() {
+		return percentRatio;
+	}
+});

package/dist/percent-D1VB9xXG.js

@@ -0,0 +1,20 @@
+import { X as mulDiv, Z as ratioToDecimal, ut as pow10 } from "./money-WhnGiI00.js";
+//#region src/internal/percent.ts
+/** 100% for a percent written with `scale` fraction digits: the denominator of its units. */
+function hundredPercent(scale) {
+	return 100n * pow10(scale);
+}
+/** `percent` percent of `units`, rounded once by `mode`. */
+function percentOfUnits(units, percent, mode) {
+	return mulDiv(units, percent.units, hundredPercent(percent.scale), mode);
+}
+/** `bps` basis points of `units / denominator` (default a whole number of units), rounded once by `mode`. */
+function basisPointsOf(units, bps, mode, denominator = 1n) {
+	return mulDiv(units, bps, 10000n * denominator, mode);
+}
+/** `a / b` in percent with `digits` fraction digits, half-up (`b` must not be zero). */
+function percentRatio(a, b, digits) {
+	return ratioToDecimal(a * 100n, b, digits);
+}
+//#endregion
+export { percentRatio as i, hundredPercent as n, percentOfUnits as r, basisPointsOf as t };

package/dist/rate-CVeMii4a.cjs

@@ -0,0 +1,217 @@
+const require_money = require("./money-B3wH_Z4S.cjs");
+const require_own = require("./own-oP9DXFWv.cjs");
+//#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 require_money.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 = require_money.parseDecimal(value, "integer")?.units ?? null;
+	return part !== null && part >= 1n ? part : null;
+}
+const withinBounds = (n, d) => require_money.compareRatio(n, d, MIN_RATE.units, require_money.pow10(MIN_RATE.scale)) >= 0 && require_money.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 ${require_money.describeValue(numerator)}/${require_money.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 require_money.decimalOf(value);
+	} catch {
+		throw invalid(`Rate must be a finite decimal, got ${require_money.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 ${require_money.describeValue(value)}`);
+		const exponent = Math.max(7, 9 - exponentOf(v));
+		return {
+			numerator: require_money.roundToScale(v, exponent, "half-up").units,
+			denominator: require_money.pow10(exponent)
+		};
+	}
+	if (require_money.compareRatio(v.units, require_money.pow10(v.scale), MAX_RATE.units, 1n) > 0) throw invalid(`Rate must not be greater than ${RATE_BOUNDS.max}, got ${require_money.describeValue(value)}`);
+	const numerator = require_money.roundToScale(v, 7, "half-up").units;
+	if (numerator < 1n) throw invalid(`Rate must be greater than 0, got ${require_money.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: ${require_money.describeValue(r)}`);
+	return r;
+}
+function checkDecimals(decimals) {
+	if (!Number.isSafeInteger(decimals) || decimals < 0 || decimals > 30) throw new require_money.MoneyError("amount_invalid", `decimals must be an integer from 0 to 30, got ${require_money.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 require_money.toDecimalText(require_money.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 = require_own.hasOwnKey(table, lower) ? table[lower] : require_own.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 require_money.compareRatio(x.numerator, x.denominator, y.numerator, y.denominator) === 0;
+}
+//#endregion
+Object.defineProperty(exports, "RATE_BOUNDS", {
+	enumerable: true,
+	get: function() {
+		return RATE_BOUNDS;
+	}
+});
+Object.defineProperty(exports, "RATE_REF", {
+	enumerable: true,
+	get: function() {
+		return RATE_REF;
+	}
+});
+Object.defineProperty(exports, "checkRate", {
+	enumerable: true,
+	get: function() {
+		return checkRate;
+	}
+});
+Object.defineProperty(exports, "crossRate", {
+	enumerable: true,
+	get: function() {
+		return crossRate;
+	}
+});
+Object.defineProperty(exports, "invertRate", {
+	enumerable: true,
+	get: function() {
+		return invertRate;
+	}
+});
+Object.defineProperty(exports, "rate", {
+	enumerable: true,
+	get: function() {
+		return rate;
+	}
+});
+Object.defineProperty(exports, "rateEquals", {
+	enumerable: true,
+	get: function() {
+		return rateEquals;
+	}
+});
+Object.defineProperty(exports, "rateFromDecimal", {
+	enumerable: true,
+	get: function() {
+		return rateFromDecimal;
+	}
+});
+Object.defineProperty(exports, "rateFromRow", {
+	enumerable: true,
+	get: function() {
+		return rateFromRow;
+	}
+});
+Object.defineProperty(exports, "rateToDecimal", {
+	enumerable: true,
+	get: function() {
+		return rateToDecimal;
+	}
+});
+Object.defineProperty(exports, "rateToNumber", {
+	enumerable: true,
+	get: function() {
+		return rateToNumber;
+	}
+});

package/dist/rate-DBPiYgT1.d.ts

@@ -0,0 +1,63 @@
+import { R as DecimalText } from "./money-B-3aFjNJ.js";
+//#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 };