@amboras-dev/money 0.0.0-stage → 0.2.0

package/dist/commerce.cjs

@@ -0,0 +1,536 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_money = require("./money-B3wH_Z4S.cjs");
+const require_rounding = require("./rounding-DHBtNCHG.cjs");
+const require_allocate = require("./allocate-CZRg4TOP.cjs");
+const require_percent = require("./percent-C0InC2t2.cjs");
+const require_format = require("./format-DLhno7eX.cjs");
+const require_medusa = require("./medusa-lRY9xlsf.cjs");
+const require_retail = require("./retail-Cml8YSKg.cjs");
+//#region src/commerce/convention.ts
+/**
+* Currencies with storage digits: step 1, `'x100'`. Zero-decimal currencies: step 100 when
+* there is a positive sample and every positive sample is a multiple of 100 (the platform
+* convention), else step 1 `'whole-unit'` (never truncate a whole-unit store to hundreds).
+*/
+function storageConventionOf(currency, samples) {
+	const info = require_money.resolveCurrency(currency, { allowHistoric: true });
+	for (const s of samples) require_money.storedDecimal(s);
+	if (info.storageDigits !== 0) return {
+		step: 1,
+		convention: "x100"
+	};
+	const step = require_rounding.unitSize(info, "currency");
+	const positive = samples.filter((s) => s.amount > 0);
+	return positive.length > 0 && positive.every((s) => BigInt(s.amount) % step === 0n) ? {
+		step: 100,
+		convention: "x100"
+	} : {
+		step: 1,
+		convention: "whole-unit"
+	};
+}
+//#endregion
+//#region src/commerce/shared.ts
+/** The one currency of `amounts` (the first defined one decides) and their stored integers. Throws `currency_mismatch`. */
+function oneCurrency(amounts, verb) {
+	let info;
+	const units = amounts.map((m) => {
+		const own = require_money.storedDecimal(m).info;
+		if (info && own.code !== info.code) throw new require_money.MoneyError("currency_mismatch", `Cannot ${verb} ${info.code} and ${own.code}`);
+		info = info ?? own;
+		return BigInt(m.amount);
+	});
+	return {
+		info,
+		units
+	};
+}
+/** A percent (or any plain decimal) as an exact Decimal; `parse` / `amount_invalid` as `decimalOf`. */
+function percentValue(value, field) {
+	return require_money.decimalOf(value, true, field);
+}
+/** `value` clamped to [0, 100] percent. */
+function clampPercent(value) {
+	if (value.units < 0n) return {
+		units: 0n,
+		scale: 0
+	};
+	return value.units > require_percent.hundredPercent(value.scale) ? {
+		units: 100n,
+		scale: 0
+	} : value;
+}
+/** A positive safe integer, else `amount_invalid`. */
+function positiveInteger(value, name) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) throw new require_money.MoneyError("amount_invalid", `${name} must be a positive integer, got ${require_money.describeValue(value)}`);
+	return BigInt(value);
+}
+/** A non-negative safe integer, else `amount_invalid`. */
+function nonNegativeInteger(value, name) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw new require_money.MoneyError("amount_invalid", `${name} must be a non-negative integer, got ${require_money.describeValue(value)}`);
+	return BigInt(value);
+}
+/** `decimals` as a digit count from 0 to 20, else `amount_invalid`. */
+function digitsOf(decimals, name = "decimals") {
+	if (typeof decimals !== "number" || !Number.isSafeInteger(decimals) || decimals < 0 || decimals > 20) throw new require_money.MoneyError("amount_invalid", `${name} must be an integer from 0 to 20, got ${require_money.describeValue(decimals)}`);
+	return decimals;
+}
+//#endregion
+//#region src/commerce/cost.ts
+const scaleOf = (scale) => digitsOf(scale ?? 4, "scale");
+function quantityOf(value, name) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value)) throw new require_money.MoneyError("amount_invalid", `${name} must be an integer, got ${require_money.describeValue(value)}`);
+	return BigInt(value);
+}
+/**
+* Extra costs (freight, duties) spread over receipt lines by quantity, exactly: `extras`
+* (rounded half-up to `scale`, default 4) is allocated with the last line absorbing the
+* remainder; each line's landed unit cost is `max(0, round(unitCost + share / quantity))` at
+* `scale`. Non-positive extras or quantities spread nothing.
+*/
+function landedUnitCosts(lines, extras, options = {}) {
+	const scale = scaleOf(options.scale);
+	const quantities = lines.map((l, i) => quantityOf(l.quantity, `lines[${i}].quantity`));
+	const pot = require_money.roundToScale(require_money.decimalOf(extras, true, "extras"), scale, "half-up");
+	const shares = pot.units > 0n && quantities.every((q) => q >= 0n) && quantities.some((q) => q > 0n) ? require_allocate.allocate(require_money.toDecimalText(pot), quantities.map((q) => Number(q)), {
+		strategy: "last",
+		scale
+	}) : lines.map(() => "0");
+	return lines.map((line, i) => {
+		const unit = require_money.decimalOf(line.unitCost, true, `lines[${i}].unitCost`);
+		const share = require_money.roundToScale(require_money.decimalOf(shares[i]), scale, "down").units;
+		const q = quantities[i];
+		const total = require_money.addDecimal(require_money.multiplyDecimal(unit, {
+			units: q,
+			scale: 0
+		}), {
+			units: share,
+			scale
+		});
+		const landed = q > 0n ? require_money.ratioToDecimal(total.units, require_money.pow10(total.scale) * q, scale) : require_money.roundToScale(unit, scale, "half-up");
+		return {
+			share: shares[i],
+			landedUnitCost: require_money.toDecimalText({
+				units: landed.units > 0n ? landed.units : 0n,
+				scale
+			})
+		};
+	});
+}
+/**
+* The weighted-average unit cost after a receipt: the receipt's cost (half-up to `scale`,
+* default 4) when there is no average, nothing on hand or nothing received; else
+* `(onHand x average + quantity x unitCost) / (onHand + quantity)` half-up to `scale`.
+*/
+function weightedAverageCost(current, receipt, options = {}) {
+	const scale = scaleOf(options.scale);
+	const onHand = quantityOf(current.onHand, "onHand");
+	const quantity = quantityOf(receipt.quantity, "quantity");
+	const cost = require_money.decimalOf(receipt.unitCost, true, "unitCost");
+	if (current.average === null || onHand <= 0n || quantity <= 0n) return require_money.toDecimalText(require_money.roundToScale(cost, scale, "half-up"));
+	const average = require_money.decimalOf(current.average, true, "average");
+	const held = require_money.multiplyDecimal({
+		units: onHand,
+		scale: 0
+	}, average);
+	const sum = require_money.addDecimal(held, require_money.multiplyDecimal({
+		units: quantity,
+		scale: 0
+	}, cost));
+	return require_money.toDecimalText(require_money.ratioToDecimal(sum.units, require_money.pow10(sum.scale) * (onHand + quantity), scale));
+}
+//#endregion
+//#region src/commerce/discount.ts
+const isMoney = (value) => typeof value === "object" && value !== null;
+/**
+* The discount `spec` takes off `base` (a line or order total), clamped to `[0, base]`; a
+* non-positive base gives 0. A percentage of the total rounds once (`per: 'total'`) or per
+* unit then times the quantity (`per: 'unit'`: 10% of 2 x 18.99 truncated is 2 x 1.89); a
+* fixed amount is Money in base's currency, per unit times the quantity with `per: 'unit'`.
+*/
+function discountAmount(spec, base, options = {}) {
+	const { info } = require_money.storedDecimal(base);
+	const total = BigInt(base.amount);
+	const quantity = options.per === "unit" ? positiveInteger(options.quantity, "quantity") : 1n;
+	let amount;
+	if (spec?.type === "percentage") {
+		if (isMoney(spec.value)) throw new require_money.MoneyError("amount_invalid", "A percentage discount takes a percent, not Money");
+		const pct = clampPercent(percentValue(spec.value, "value"));
+		const denominator = require_percent.hundredPercent(pct.scale) * quantity;
+		amount = require_rounding.mulDivToUnit(total, pct.units, denominator, info, options.unit ?? "currency", options.rounding) * quantity;
+	} else if (spec?.type === "fixed") {
+		if (!isMoney(spec.value)) throw new require_money.MoneyError("amount_invalid", `A fixed discount takes Money, got ${require_money.describeValue(spec.value)}`);
+		amount = oneCurrency([base, spec.value], "discount").units[1] * quantity;
+	} else throw new require_money.MoneyError("amount_invalid", `Unknown discount type: ${require_money.describeValue(spec?.type)}`);
+	if (total <= 0n || amount <= 0n) return require_money.boundedMoney(0n, info);
+	return require_money.boundedMoney(amount < total ? amount : total, info);
+}
+/**
+* The reward of a buy X get Y offer on one line: `min(quantity, maxQuantity)` discounted
+* units, each `percent` of the unit price (rounded once on the total to the currency unit) or
+* a fixed amount off each, never more than the unit price (promotion `fixBuyGetFixedRewards`).
+* The units come from the input, never recovered from an amount.
+*/
+function buyGetReward(input) {
+	const { info } = require_money.storedDecimal(input.unitPrice);
+	const price = BigInt(input.unitPrice.amount);
+	const quantity = nonNegativeInteger(input.quantity, "quantity");
+	const cap = input.maxQuantity === void 0 ? quantity : nonNegativeInteger(input.maxQuantity, "maxQuantity");
+	const units = quantity < cap ? quantity : cap;
+	let amount;
+	if (input.reward?.kind === "percent") {
+		const pct = clampPercent(percentValue(input.reward.value, "reward.value"));
+		amount = require_rounding.mulDivToUnit(price * units, pct.units, require_percent.hundredPercent(pct.scale), info, "currency");
+	} else if (input.reward?.kind === "fixed-each") {
+		const off = oneCurrency([input.unitPrice, input.reward.value], "reward").units[1];
+		amount = (off < price ? off : price) * units;
+	} else throw new require_money.MoneyError("amount_invalid", `Unknown reward kind: ${require_money.describeValue(input.reward?.kind)}`);
+	return {
+		amount: require_money.boundedMoney(amount > 0n ? amount : 0n, info),
+		discountedUnits: Number(units)
+	};
+}
+/** `'10%'`, `'12.5%'` (up to 2 decimals, half-up) or the fixed amount via `formatMoney` (its currency must be `currency`). */
+function formatDiscount(spec, currency, options = {}) {
+	const info = require_money.resolveCurrency(currency, { allowHistoric: true });
+	if (spec?.type === "percentage" && !isMoney(spec.value)) {
+		const pct = percentValue(spec.value, "value");
+		return `${require_money.toDecimalText(require_money.roundToScale(pct, 2, "half-up"))}%`;
+	}
+	if (spec?.type === "fixed" && isMoney(spec.value)) {
+		const own = require_money.storedDecimal(spec.value).info;
+		if (own.code !== info.code) throw new require_money.MoneyError("currency_mismatch", `Discount in ${own.code}, shown in ${info.code}`);
+		return require_format.formatMoney(spec.value, { locale: options.locale });
+	}
+	throw new require_money.MoneyError("amount_invalid", `Not a discount: ${require_money.describeValue(spec)}`);
+}
+//#endregion
+//#region src/commerce/order-value.ts
+const negate = (a) => ({
+	units: -a.units,
+	scale: a.scale
+});
+const ZERO = {
+	units: 0n,
+	scale: 0
+};
+/** Sum of lines `max(0, unit_price x quantity - sum(adjustments))`; null when any part is unreadable. */
+function itemsValue(items) {
+	let total = ZERO;
+	for (const item of items) {
+		const price = require_money.medusaAmountDecimal(item?.unit_price);
+		const quantity = require_money.medusaAmountDecimal(item?.quantity);
+		if (!price || !quantity) return null;
+		let line = require_money.multiplyDecimal(price, quantity);
+		for (const adjustment of item.adjustments ?? []) {
+			const amount = require_money.medusaAmountDecimal(adjustment?.amount);
+			if (!amount) return null;
+			line = require_money.addDecimal(line, negate(amount));
+		}
+		if (line.units > 0n) total = require_money.addDecimal(total, line);
+	}
+	return total;
+}
+/** An optional total: absent (null/undefined) is 0, unreadable is null. */
+const optional = (raw) => raw === null || raw === void 0 ? ZERO : require_money.medusaAmountDecimal(raw);
+/**
+* The value an order reports to ad platforms, and where it came from: the graph total when
+* trusted and positive, else the summary total (a genuine 0 or a negative is kept), else the
+* items netted of adjustments when positive, else null. The result is rounded half-up to a
+* storage unit. Skipping a send when the value is not positive (GA4) stays an app policy.
+*/
+function resolveOrderValue(input) {
+	const info = require_money.resolveCurrency(input.currency, { allowHistoric: true });
+	const toMoney = (d) => require_rounding.roundStoredDecimal(d, info);
+	const net = (total) => {
+		if (input.basis !== "net-of-tax-shipping") return total;
+		const tax = optional(input.taxTotal);
+		const shipping = optional(input.shippingTotal);
+		return tax && shipping ? require_money.addDecimal(total, negate(require_money.addDecimal(tax, shipping))) : null;
+	};
+	const graph = input.trustGraph ? require_money.medusaAmountDecimal(input.graphTotal) : null;
+	if (graph && graph.units > 0n) {
+		const value = net(graph);
+		return value ? {
+			value: toMoney(value),
+			source: "graph"
+		} : null;
+	}
+	const summary = require_money.medusaAmountDecimal(input.summaryTotal);
+	if (summary) {
+		const value = net(summary);
+		return value ? {
+			value: toMoney(value),
+			source: "summary"
+		} : null;
+	}
+	const items = input.items ? itemsValue(input.items) : null;
+	return items && items.units > 0n ? {
+		value: toMoney(items),
+		source: "items"
+	} : null;
+}
+//#endregion
+//#region src/commerce/payable.ts
+/**
+* `false` when the cart can complete with no payment (`total <= 0` and no negative credit-line
+* balance: `credit_line_total >= 0 && total <= 0`), `true` when it must be paid, `undefined`
+* when the total is not a finite number (still loading: fail closed, never "free"). As in the
+* starter, only a number counts as a total, and an absent credit-line total counts as none.
+*/
+function requiresPayment(input, currency) {
+	require_money.resolveCurrency(currency, { allowHistoric: true });
+	const total = input?.total;
+	if (typeof total !== "number" || !Number.isFinite(total)) return void 0;
+	const credit = input.creditLineTotal;
+	return !(total <= 0 && (credit == null || credit >= 0));
+}
+//#endregion
+//#region src/commerce/pricing.ts
+/**
+* `m` with a markup: exact percent and flat in `order`, one rounding to a storage unit, then
+* clamped to `[floor, ceiling]`, then to `>= 0`. A non-positive `m` (a failed quote) is
+* returned unchanged.
+*/
+function applyMarkup(m, options) {
+	const { info } = oneCurrency([m, ...[
+		options.flat,
+		options.floor,
+		options.ceiling
+	].filter((x) => x !== void 0)], "mark up");
+	const amount = BigInt(m.amount);
+	if (amount <= 0n) return m;
+	const pct = percentValue(options.percent ?? 0, "percent");
+	const scale = require_percent.hundredPercent(pct.scale);
+	const factor = scale + pct.units;
+	const flat = options.flat ? BigInt(options.flat.amount) : 0n;
+	const rounding = options.rounding ?? "half-up";
+	let value = options.order === "flat-then-percent" ? require_money.mulDiv(amount + flat, factor, scale, rounding) : require_money.divRound(amount * factor + flat * scale, scale, rounding);
+	if (options.floor && value < BigInt(options.floor.amount)) value = BigInt(options.floor.amount);
+	if (options.ceiling && value > BigInt(options.ceiling.amount)) value = BigInt(options.ceiling.amount);
+	return require_money.boundedMoney(value > 0n ? value : 0n, info);
+}
+/**
+* The one retail price:
+* - AliExpress (`markup: { percent }`): `cost x (1 + percent / 100)`, exact, then `rounding`
+*   once (`'none'`: half-up to the currency unit; `'.99'`, `'.95'`, `'whole'`: up to the ending).
+* - Domains (`markup: { bps, capTiers }`, integer cents): `markup = min(round(cost x bps / 1e4),
+*   cap)` with the cap of the first tier whose `below` the cost is under (or that has none);
+*   `subtotal = cost + markup + extras`; `fee = ceil(subtotal x feeBps / 1e4) + fixed`; then
+*   `max(roundRetail(subtotal + fee, rounding), floor)` (`'up-to-99'` for domains).
+*/
+function retailPrice(input) {
+	const tiers = "bps" in input.markup ? input.markup.capTiers ?? [] : [];
+	const optional = [
+		input.extras,
+		input.fee?.fixed,
+		input.floor,
+		...tiers.flatMap((t) => [t.cap, t.below])
+	];
+	const { info } = oneCurrency([input.cost, ...optional.filter((x) => x !== void 0)], "price");
+	const cost = BigInt(input.cost.amount);
+	let p;
+	let q;
+	if ("percent" in input.markup) {
+		const pct = percentValue(input.markup.percent, "markup.percent");
+		q = require_percent.hundredPercent(pct.scale);
+		p = cost * (q + pct.units);
+	} else if ("bps" in input.markup) {
+		const bps = nonNegativeInteger(input.markup.bps, "markup.bps");
+		let markup = require_percent.basisPointsOf(cost, bps, "half-up");
+		const tier = tiers.find((t) => t.below === void 0 || cost < BigInt(t.below.amount));
+		if (tier && markup > BigInt(tier.cap.amount)) markup = BigInt(tier.cap.amount);
+		p = cost + markup;
+		q = 1n;
+	} else throw new require_money.MoneyError("amount_invalid", `markup needs percent or bps, got ${require_money.describeValue(input.markup)}`);
+	if (input.extras) p += BigInt(input.extras.amount) * q;
+	if (input.fee) {
+		const feeBps = nonNegativeInteger(input.fee.bps, "fee.bps");
+		const fee = require_percent.basisPointsOf(p, feeBps, "ceil", q) + BigInt(input.fee.fixed.amount);
+		p += fee * q;
+	}
+	let price = require_retail.retailUnits(p, q, info, input.rounding ?? "none");
+	if (input.floor && price < BigInt(input.floor.amount)) price = BigInt(input.floor.amount);
+	return require_money.boundedMoney(price, info);
+}
+/** `(price - cost) / price` in percent, half-up to `decimals` (default 1); a non-positive price gives 0. */
+function marginPercent(price, cost, options = {}) {
+	const [p, c] = oneCurrency([price, cost], "compare").units;
+	const decimals = digitsOf(options.decimals ?? 1);
+	if (p <= 0n) return 0;
+	return Number(require_money.toDecimalText(require_percent.percentRatio(p - c, p, decimals)));
+}
+/**
+* The change from `from` to `to` in percent, half-up to `decimals` (default 1): `'change'`
+* (default) is `(to - from) / from`, `'off'` the discount `(from - to) / from` (promotion
+* percent off, subscription `discount_percentage`). A non-positive `from` gives null.
+*/
+function percentChange(from, to, options = {}) {
+	const [f, t] = oneCurrency([from, to], "compare").units;
+	const decimals = digitsOf(options.decimals ?? 1);
+	if (f <= 0n) return null;
+	const delta = options.as === "off" ? f - t : t - f;
+	return Number(require_money.toDecimalText(require_percent.percentRatio(delta, f, decimals)));
+}
+/** What is kept of a charge after a card fee: `m - round(m x bps / 1e4) - fixed`. */
+function netOfFee(m, fee) {
+	const { info, units } = oneCurrency([m, fee.fixed], "net");
+	const bps = nonNegativeInteger(fee.bps, "fee.bps");
+	const [amount, fixed] = units;
+	return require_money.boundedMoney(amount - require_percent.basisPointsOf(amount, bps, "half-up") - fixed, info);
+}
+//#endregion
+//#region src/commerce/tax.ts
+/**
+* The tax rate in percent that `tax` on `net` implies, snapped half-up to a multiple of `snap`
+* (default 0.5, every real EU VAT rate; 0 = no snap, 10 decimals). `net <= 0` gives 0.
+* sevDesk `inferTaxRatePercent`, exact.
+*/
+function inferTaxRatePercent(net, tax, options = {}) {
+	const { units } = oneCurrency([net, tax], "infer a tax rate from");
+	const [n, t] = units;
+	const snap = percentValue(options.snap ?? .5, "snap");
+	if (snap.units < 0n) throw new require_money.MoneyError("amount_invalid", `snap must not be negative, got ${require_money.describeValue(options.snap)}`);
+	if (n <= 0n) return 0;
+	if (snap.units === 0n) return Number(require_money.toDecimalText(require_percent.percentRatio(t, n, 10)));
+	const steps = require_percent.percentRatio(t, n * snap.units, snap.scale).units;
+	return Number(require_money.toDecimalText({
+		units: steps * snap.units,
+		scale: snap.scale
+	}));
+}
+/**
+* The rate in percent behind `tax` on `base` (Shopify archive `taxRateFor`): exclusive
+* `100 tax / base`, inclusive `100 tax / (base - tax)`, half-up to `decimals` (default 10),
+* trailing zeros dropped. Null when tax or base is not positive, or the denominator is not.
+*/
+function solveTaxRate(input) {
+	const { units } = oneCurrency([input.tax, input.base], "solve a tax rate from");
+	const [tax, base] = units;
+	const decimals = digitsOf(input.decimals ?? 10);
+	if (tax <= 0n || base <= 0n) return null;
+	const denominator = input.inclusive ? base - tax : base;
+	if (denominator <= 0n) return null;
+	return require_money.toDecimalText(require_percent.percentRatio(tax, denominator, decimals));
+}
+/**
+* Whether prices include tax (Shopify archive `inferTaxesIncluded`): `explicit` wins; a null
+* total or a non-positive tax is exclusive; else inclusive iff
+* `|sub + ship - total| < |sub + ship + tax - total|`.
+*/
+function inferTaxesIncluded(input) {
+	if (typeof input.explicit === "boolean") return input.explicit;
+	const { units } = oneCurrency([
+		input.subtotal,
+		input.shipping,
+		input.tax,
+		...input.total ? [input.total] : []
+	], "compare");
+	const [sub, ship, tax] = units;
+	if (!input.total || tax <= 0n) return false;
+	const total = units[3];
+	const abs = (x) => x < 0n ? -x : x;
+	return abs(sub + ship - total) < abs(sub + ship + tax - total);
+}
+/** `gross x 100 / (100 + rate)` rounded once to a storage unit. */
+function netOf(gross, ratePercent, rounding) {
+	const rate = percentValue(ratePercent, "ratePercent");
+	const whole = require_percent.hundredPercent(rate.scale);
+	const denominator = whole + rate.units;
+	if (denominator <= 0n) throw new require_money.MoneyError("amount_invalid", `A tax rate must be above -100%, got ${require_money.describeValue(ratePercent)}`);
+	return require_money.mulDiv(BigInt(gross.amount), whole, denominator, rounding);
+}
+/** `gross` split into `net = round(gross x 100 / (100 + rate))` and `tax = gross - net` (net + tax == gross). */
+function splitGross(gross, ratePercent, options = {}) {
+	const { info } = require_money.storedDecimal(gross);
+	const net = netOf(gross, ratePercent, options.rounding ?? "half-up");
+	return {
+		net: require_money.boundedMoney(net, info),
+		tax: require_money.boundedMoney(BigInt(gross.amount) - net, info)
+	};
+}
+/** A unit price without its tax when prices include tax (`round(unit x 100 / (100 + rate))`), else `unit`. */
+function unitNetOfTax(unit, options) {
+	const { info } = require_money.storedDecimal(unit);
+	if (!options.taxInclusive) return unit;
+	return require_money.boundedMoney(netOf(unit, options.ratePercent, "half-up"), info);
+}
+/**
+* `refund` spread over positions (each a net and its tax): capped at the gross total, split by
+* gross with the largest remainder, then each gross share split into net and tax in the
+* position's proportion (largest remainder). Per row `net + tax == gross`, and the grosses
+* sum to the (capped) refund. Negative amounts throw `amount_invalid`.
+*/
+function allocateWithTax(refund, positions) {
+	const { info, units } = oneCurrency([refund, ...positions.flatMap((p) => [p.net, p.tax])], "allocate");
+	const [total, ...parts] = units;
+	if (total < 0n || parts.some((p) => p < 0n)) throw new require_money.MoneyError("amount_invalid", "A refund and its positions must not be negative");
+	const grosses = positions.map((_, i) => parts[2 * i] + parts[2 * i + 1]);
+	const grossSum = grosses.reduce((a, b) => a + b, 0n);
+	return require_allocate.allocateUnits(total < grossSum ? total : grossSum, grosses).map((share, i) => {
+		const [net, tax] = require_allocate.allocateUnits(share, [parts[2 * i], parts[2 * i + 1]]);
+		return {
+			net: require_money.boundedMoney(net, info),
+			tax: require_money.boundedMoney(tax, info),
+			gross: require_money.boundedMoney(share, info)
+		};
+	});
+}
+const INCLUSIVE_KEYS = [
+	"original_item_total",
+	"discount_total",
+	"original_shipping_total",
+	"tax_total",
+	"total"
+];
+const EXCLUSIVE_KEYS = [
+	"item_subtotal",
+	"discount_subtotal",
+	"shipping_subtotal",
+	"tax_total",
+	"total"
+];
+/**
+* The totals a customer-facing summary shows, one selection for every email: tax-inclusive
+* stores show the gross item and shipping totals with the tax "included", exclusive stores the
+* net subtotals with the tax "added". Each field reads `raw_<key>` first, like
+* `readStoredField`; Medusa's fractional totals round half-up to a storage unit; a missing or
+* unreadable field is null, never 0.
+*/
+function displayTotals(totals, currency, options) {
+	const info = require_money.resolveCurrency(currency, { allowHistoric: true });
+	const read = (key) => {
+		const exact = require_medusa.readStoredDecimal(require_medusa.storedFieldValue(totals, key), { mode: "lenient" });
+		return exact === null ? null : require_rounding.roundStoredDecimal(require_money.decimalOf(exact), info);
+	};
+	const [subtotal, discount, shipping, tax, total] = (options.taxInclusive ? INCLUSIVE_KEYS : EXCLUSIVE_KEYS).map(read);
+	return {
+		subtotal,
+		discount,
+		shipping,
+		tax,
+		total,
+		taxIncluded: options.taxInclusive
+	};
+}
+//#endregion
+exports.allocateWithTax = allocateWithTax;
+exports.applyMarkup = applyMarkup;
+exports.buyGetReward = buyGetReward;
+exports.discountAmount = discountAmount;
+exports.displayTotals = displayTotals;
+exports.formatDiscount = formatDiscount;
+exports.inferTaxRatePercent = inferTaxRatePercent;
+exports.inferTaxesIncluded = inferTaxesIncluded;
+exports.landedUnitCosts = landedUnitCosts;
+exports.marginPercent = marginPercent;
+exports.netOfFee = netOfFee;
+exports.percentChange = percentChange;
+exports.requiresPayment = requiresPayment;
+exports.resolveOrderValue = resolveOrderValue;
+exports.retailPrice = retailPrice;
+exports.solveTaxRate = solveTaxRate;
+exports.splitGross = splitGross;
+exports.storageConventionOf = storageConventionOf;
+exports.unitNetOfTax = unitNetOfTax;
+exports.weightedAverageCost = weightedAverageCost;