@amboras-dev/money 0.0.0-stage → 0.1.0

package/dist/allocate-D7tm_t_o.cjs

@@ -0,0 +1,222 @@
+const require_money = require("./money-D5-vlv0h.cjs");
+const require_rounding = require("./rounding-oZ832yTD.cjs");
+//#region src/allocate.ts
+const invalid = (message) => new require_money.MoneyError("amount_invalid", message);
+const sumOf = (values) => values.reduce((a, b) => a + b, 0n);
+const floorShares = (units, weights, total) => weights.map((w) => require_money.divRound(units * w, total, "floor"));
+function largestRemainder(units, weights, total) {
+	const shares = floorShares(units, weights, total);
+	let rest = units - sumOf(shares);
+	const order = weights.map((w, i) => ({
+		i,
+		fraction: units * w % total
+	})).sort((a, b) => a.fraction === b.fraction ? a.i - b.i : a.fraction > b.fraction ? -1 : 1);
+	for (const { i } of order) {
+		if (rest === 0n) break;
+		shares[i] += 1n;
+		rest -= 1n;
+	}
+	return shares;
+}
+function largestWeight(units, weights, total) {
+	const top = weights.indexOf(weights.reduce((a, b) => b > a ? b : a));
+	const shares = weights.map((w, i) => i === top ? 0n : require_money.mulDiv(units, w, total, "half-up"));
+	let deficit = sumOf(shares) - units;
+	if (deficit <= 0n) {
+		shares[top] = -deficit;
+		return shares;
+	}
+	const byWeight = weights.map((w, i) => ({
+		w,
+		i
+	})).sort((a, b) => a.w === b.w ? a.i - b.i : a.w > b.w ? -1 : 1);
+	for (const { i } of byWeight) {
+		const take = shares[i] < deficit ? shares[i] : deficit;
+		shares[i] -= take;
+		deficit -= take;
+	}
+	return shares;
+}
+function lastAbsorbs(units, weights, total) {
+	const shares = floorShares(units, weights, total);
+	let last = weights.length - 1;
+	while (weights[last] === 0n) last -= 1;
+	shares[last] += units - sumOf(shares);
+	return shares;
+}
+function cumulative(units, weights, total) {
+	let running = 0n;
+	let previous = 0n;
+	return weights.map((w) => {
+		running += w;
+		const reached = require_money.mulDiv(units, running, total, "half-up");
+		const share = reached - previous;
+		previous = reached;
+		return share;
+	});
+}
+function lastFirst(amount, weights, total, step, caps) {
+	const capTotal = sumOf(caps);
+	const target = amount < capTotal ? amount : capTotal;
+	const shares = weights.map((w, i) => {
+		const share = require_money.mulDiv(target, w, total * step, "half-up") * step;
+		return share < caps[i] ? share : caps[i];
+	});
+	let rest = target - sumOf(shares);
+	for (let i = shares.length - 1; i >= 0 && rest !== 0n; i--) {
+		const wanted = shares[i] + rest;
+		const next = wanted < 0n ? 0n : wanted > caps[i] ? caps[i] : wanted;
+		rest -= next - shares[i];
+		shares[i] = next;
+	}
+	return shares;
+}
+/**
+* Internal: `total` split across non-negative integer `weights` in integer units, exactly.
+* Shares are multiples of `step`; a negative total is split by magnitude and negated;
+* all-zero weights need a zero total. Throws `amount_invalid` (weights, caps, step) or
+* `precision` (total not a multiple of step).
+*/
+function allocateUnits(total, weights, options = {}) {
+	const strategy = options.strategy ?? "largest-remainder";
+	const step = options.step ?? 1n;
+	if (step <= 0n) throw invalid(`Allocation step must be positive, got ${step}`);
+	if (weights.some((w) => w < 0n)) throw invalid("Allocation weights must not be negative");
+	if (total % step !== 0n) throw new require_money.MoneyError("precision", `${total} is not a whole number of ${step}-unit steps; round it first`);
+	const weightTotal = sumOf(weights);
+	const negative = total < 0n;
+	const magnitude = negative ? -total : total;
+	let shares;
+	if (weightTotal === 0n) {
+		if (magnitude !== 0n) throw invalid("Cannot allocate a non-zero total across zero weights");
+		shares = weights.map(() => 0n);
+	} else if (strategy === "last-first") {
+		const caps = options.caps;
+		if (!caps || caps.length !== weights.length || caps.some((c) => c < 0n)) throw invalid("'last-first' needs one non-negative cap per weight");
+		shares = lastFirst(magnitude, weights, weightTotal, step, caps);
+	} else {
+		const units = magnitude / step;
+		const split = strategy === "largest-weight" ? largestWeight : strategy === "last" ? lastAbsorbs : strategy === "cumulative" ? cumulative : strategy === "largest-remainder" ? largestRemainder : void 0;
+		if (!split) throw invalid(`Unknown allocation strategy: ${require_money.describeValue(strategy)}`);
+		shares = split(units, weights, weightTotal).map((s) => s * step);
+	}
+	return negative ? shares.map((s) => s === 0n ? 0n : -s) : shares;
+}
+/** Weights as integers on one common scale. Money weights must be in `currency` (when given). */
+function weightUnits(weights, info) {
+	const values = weights.map((w) => {
+		if (typeof w !== "object" || w === null) return require_money.decimalOf(w, true, "weight");
+		const own = require_money.storedDecimal(w).info;
+		if (info && own.code !== info.code) throw new require_money.MoneyError("currency_mismatch", `Weight in ${own.code}, total in ${info.code}`);
+		return {
+			units: BigInt(w.amount),
+			scale: 0
+		};
+	});
+	const scale = Math.max(0, ...values.map((v) => v.scale));
+	return values.map((v) => require_money.roundToScale(v, scale, "down").units);
+}
+function stepOf(info, unit) {
+	if (typeof unit === "object" && unit !== null) {
+		if (!Number.isSafeInteger(unit.step) || unit.step < 1) throw invalid(`unit.step must be a positive integer, got ${require_money.describeValue(unit.step)}`);
+		return BigInt(unit.step);
+	}
+	return require_rounding.unitSize(info, unit ?? "storage");
+}
+function allocate(total, weights, options = {}) {
+	if (typeof total === "object" && total !== null) {
+		const { info } = require_money.storedDecimal(total);
+		const units = weightUnits(weights, info);
+		let caps;
+		if (options.strategy === "last-first") caps = (options.caps ?? (weights.every((w) => typeof w === "object" && w !== null) ? weights : void 0))?.map((c) => weightUnits([c], info)[0]);
+		return allocateUnits(BigInt(total.amount), units, {
+			strategy: options.strategy,
+			step: stepOf(info, options.unit),
+			caps
+		}).map((s) => require_money.boundedMoney(s, info));
+	}
+	const scale = options.scale;
+	if (scale === void 0 || !Number.isSafeInteger(scale) || scale < 0 || scale > 100) throw invalid(`scale must be an integer from 0 to 100, got ${require_money.describeValue(scale)}`);
+	if (options.strategy === "last-first") throw invalid("'last-first' needs caps: allocate Money instead");
+	const value = require_money.decimalOf(total, true, "total");
+	if (require_money.fractionDigitsOf(value) > scale) throw new require_money.MoneyError("precision", `${total} has more than ${scale} fraction digits`);
+	return allocateUnits(require_money.roundToScale(value, scale, "down").units, weightUnits(weights, null), { strategy: options.strategy }).map((s) => require_money.toDecimalText({
+		units: s,
+		scale
+	}));
+}
+/**
+* Greedy capped allocation in the given order: `take_i = min(left, cap_i)`; `shortfall` is
+* what could not be placed. With `allOrNothing`, a shortfall allocates nothing (all zeros,
+* `shortfall = amount`). Negative caps or amount throw `amount_invalid`; all one currency.
+*/
+function allocateWaterfall(caps, amount, options = {}) {
+	const { info } = require_money.storedDecimal(amount);
+	const limits = caps.map((c) => weightUnits([c], info)[0]);
+	let left = BigInt(amount.amount);
+	if (left < 0n || limits.some((c) => c < 0n)) throw invalid("Waterfall caps and amount must not be negative");
+	const takes = limits.map((cap) => {
+		const take = cap < left ? cap : left;
+		left -= take;
+		return take;
+	});
+	if (left > 0n && options.allOrNothing) return {
+		allocations: takes.map(() => require_money.boundedMoney(0n, info)),
+		shortfall: require_money.boundedMoney(BigInt(amount.amount), info)
+	};
+	return {
+		allocations: takes.map((t) => require_money.boundedMoney(t, info)),
+		shortfall: require_money.boundedMoney(left, info)
+	};
+}
+/**
+* A line total charged at one unit price, or split in two parts one `unit` apart when it does
+* not divide by `quantity`, so `sum(quantity x unitPrice) === net` exactly (JPY 100000 x 3
+* gives `2 @ 33333`, `1 @ 33334`). Zero-quantity parts are omitted. `quantity` must be a
+* positive integer; `net` a whole `unit` (else `precision`).
+*/
+function splitUnitPrice(net, quantity, options = {}) {
+	const { info } = require_money.storedDecimal(net);
+	if (!Number.isSafeInteger(quantity) || quantity < 1) throw invalid(`quantity must be a positive integer, got ${require_money.describeValue(quantity)}`);
+	const unit = require_rounding.unitSize(info, options.unit ?? "storage");
+	const amount = BigInt(net.amount);
+	if (amount % unit !== 0n) throw new require_money.MoneyError("precision", `${net.amount} is not a whole number of ${unit}-unit steps`);
+	const units = amount / unit;
+	const q = BigInt(quantity);
+	const per = require_money.divRound(units, q, "floor");
+	const extra = units - per * q;
+	const parts = [{
+		quantity: Number(q - extra),
+		unitPrice: require_money.boundedMoney(per * unit, info)
+	}];
+	if (extra > 0n) parts.push({
+		quantity: Number(extra),
+		unitPrice: require_money.boundedMoney((per + 1n) * unit, info)
+	});
+	return parts;
+}
+//#endregion
+Object.defineProperty(exports, "allocate", {
+	enumerable: true,
+	get: function() {
+		return allocate;
+	}
+});
+Object.defineProperty(exports, "allocateUnits", {
+	enumerable: true,
+	get: function() {
+		return allocateUnits;
+	}
+});
+Object.defineProperty(exports, "allocateWaterfall", {
+	enumerable: true,
+	get: function() {
+		return allocateWaterfall;
+	}
+});
+Object.defineProperty(exports, "splitUnitPrice", {
+	enumerable: true,
+	get: function() {
+		return splitUnitPrice;
+	}
+});

package/dist/amount-D7dj76nH.js

@@ -0,0 +1,200 @@
+import { E as resolveCurrency, K as trimDecimalZeros, M as resolveLocale, N as separatorsOf, Z as MoneyError, c as toMajorDecimal, et as compareDecimal, it as fractionDigitsOf, n as fromMajor, rt as formatDecimal, s as storedDecimal } from "./money-CIgELekG.js";
+import { r as compare } from "./arithmetic-C-Q_aI49.js";
+import { n as readNumberText } from "./number-text-C82oh6JB.js";
+//#region src/input/amount.ts
+/** Internal: the exact signed decimal a successful separator-engine read holds. */
+function decimalOfText(read) {
+	return {
+		units: BigInt(read.sign) * read.units,
+		scale: read.scale
+	};
+}
+/** Internal: the locale's separators, as the engine takes them. */
+function localeSeparators(locale) {
+	const { decimal, group } = separatorsOf(resolveLocale(locale));
+	return {
+		decimalSeparator: decimal,
+		groupSeparator: group
+	};
+}
+/** Internal: a read decimal as Money, checked like typed entry (shared by parseModelMoney). */
+function entryMoney(value, info, options) {
+	const echo = options.original !== void 0 && compareDecimal(value, storedDecimal(options.original).value) === 0;
+	const round = options.roundExtraDigits === true;
+	if (!echo && !round && fractionDigitsOf(value) > info.storageDigits) return {
+		ok: false,
+		reason: "too_many_decimals"
+	};
+	if (value.units < 0n && !options.allowNegative) return {
+		ok: false,
+		reason: "negative"
+	};
+	if (value.units === 0n && options.allowZero === false) return {
+		ok: false,
+		reason: "zero"
+	};
+	let money;
+	if (echo) money = options.original;
+	else try {
+		money = fromMajor(formatDecimal(value), info.code, { precision: round ? "round" : "reject" });
+	} catch {
+		return {
+			ok: false,
+			reason: "above_max"
+		};
+	}
+	if (options.min && compare(money, options.min) < 0) return {
+		ok: false,
+		reason: "below_min"
+	};
+	if (options.max && compare(money, options.max) > 0) return {
+		ok: false,
+		reason: "above_max"
+	};
+	return {
+		ok: true,
+		money
+	};
+}
+/** Whether `shown` is exactly what `formatAmountInput(original)` prints for the field's locale or mode, grouped or not. */
+function echoesOriginal(shown, options) {
+	const { original, locale, decimalSeparator } = options;
+	if (original === void 0) return false;
+	const field = {
+		locale,
+		decimalSeparator
+	};
+	return shown === formatAmountInput(original, field) || shown === formatAmountInput(original, {
+		...field,
+		grouped: true
+	});
+}
+/** Which reading a field's options ask for; `decimalSeparator` and `locale` together, or a `decimalSeparator` other than `'.'`, throw. */
+function entryMode(options) {
+	if (options.decimalSeparator === void 0) return options.locale === void 0 ? "auto" : "locale";
+	if (options.decimalSeparator !== "." || options.locale !== void 0) throw new TypeError("decimalSeparator must be '.' and cannot be combined with locale");
+	return "machine";
+}
+const ENTRY_SEPARATORS = {
+	auto: {
+		decimalSeparator: "auto",
+		keepFraction: true
+	},
+	machine: {
+		decimalSeparator: ".",
+		groupSeparator: null
+	}
+};
+/**
+* Typed text to Money, one rule for every money field: the currency's symbols and code and all
+* whitespace are stripped; a leading `-` or U+2212 is the sign.
+* - Without `locale` (the chat wizard, any field with no locale): the 'auto' rule decides `.`
+*   against `,` (see `parseImportAmount`): `'29,99'` EUR is 29.99, `'1.299,00'` and `'1,299'`
+*   are 1299, KWD `'1,5'` is 1.5; a currency storing 0 digits rounds a fraction half-up to a
+*   whole unit (`'1200.5'` JPY is 1201).
+* - With `locale`: its decimal separator is the decimal and its group separator is valid only in
+*   3-digit (or Indian lakh) groups; in a currency that stores no fraction (JPY, VND) a separator
+*   before exactly three digits in grouping position is grouping (`'1.500'` JPY is 1500).
+*   en-US `'29,99'` USD is `'unparseable'`; de-DE `'29,99'` EUR is 29.99; en-US `'1200.5'` JPY
+*   is `'too_many_decimals'`.
+* - With `decimalSeparator: '.'` (every `<input type="number">`): `.` is the decimal, nothing
+*   groups (`'1,299'` is `'unparseable'`), TND and IQD `'1.500'` are 1.5, and a currency storing
+*   0 digits rounds a fraction half-up to a whole unit (`'1.5'` JPY is 2).
+* Otherwise more fraction digits than the currency stores is `'too_many_decimals'`, never rounded
+* (`'1,2345'` USD). Text equal to `original` returns it unchanged (JPY 120050 shown as
+* `'1200.50'`). An unknown currency, or an `original` in another currency, throws.
+*/
+function parseAmountInput(text, currency, options = {}) {
+	const info = resolveCurrency(currency, { allowHistoric: true });
+	if (options.original !== void 0 && storedDecimal(options.original).info.code !== info.code) throw new MoneyError("currency_mismatch", `original is ${options.original.currency}, the field is ${info.code}`);
+	const shown = typeof text === "string" ? text.trim() : "";
+	const mode = entryMode(options);
+	let value;
+	if (echoesOriginal(shown, options)) value = storedDecimal(options.original).value;
+	else {
+		const separators = mode === "locale" ? localeSeparators(options.locale) : ENTRY_SEPARATORS[mode];
+		const read = readNumberText(text, {
+			...separators,
+			currency: info.code
+		});
+		if ("reason" in read) return {
+			ok: false,
+			reason: read.reason,
+			text: shown
+		};
+		value = decimalOfText(read);
+	}
+	const result = entryMoney(value, info, {
+		...options,
+		roundExtraDigits: mode !== "locale" && info.storageDigits === 0
+	});
+	if (!result.ok) return {
+		ok: false,
+		reason: result.reason,
+		text: shown
+	};
+	return {
+		ok: true,
+		money: result.money,
+		text: toMajorDecimal(result.money)
+	};
+}
+/** Internal: `digits` with `group` between every three, from the right. */
+function groupDigits(digits, group) {
+	return digits.replace(/\B(?=(\d{3})+(?!\d))/g, group);
+}
+/**
+* The text a money field shows for a stored amount, no symbol, exact: a stored amount finer than
+* the storage digits keeps its digits (JPY 120050 is never rounded on display).
+* - Without `locale`: the spelling `parseAmountInput` reads back without a locale. Trailing
+*   fraction zeros are dropped (`'12.5'`, `'1200'`, KWD 1500 is `'1.5'`, JPY 120050 is
+*   `'1200.5'`), a currency written with a decimal comma (TND, `commaDecimal`) uses `,` and
+*   groups with `.` (`'1,125'`, `'1.234,5'`), every other currency `.` and `,`. Two amounts have no
+*   such spelling: IQD with a three-digit fraction (`'1.125'` reads as 1125, IQD displays no
+*   decimals) and a sub-unit amount of a currency storing 0 digits (`'1200.5'` JPY reads as a
+*   whole 1201); pass `{ original: m }` so the untouched text returns `m` itself.
+* - With `locale`: its decimal and group separators and the storage digits (`'12,50'` de-DE).
+* - With `decimalSeparator: '.'` (the value of an `<input type="number">`): `.` decimal, never
+*   grouped, trailing zeros dropped (TND 1500 is `'1.5'`, JPY 120050 `'1200.5'`), read back
+*   exactly by `parseAmountInput(text, currency, { decimalSeparator: '.' })` (JPY sub-unit
+*   amounts through `original`).
+* `grouped` adds group separators (not in `'.'` mode); `digits` overrides the zeros
+* (`'storage'` keeps them, `'trim-zero'` drops them).
+*/
+function formatAmountInput(m, options = {}) {
+	const { info } = storedDecimal(m);
+	const mode = entryMode(options);
+	const exact = toMajorDecimal(m);
+	const text = (options.digits ?? (mode === "locale" ? "storage" : "trim-zero")) === "trim-zero" ? trimDecimalZeros(exact) : exact;
+	const negative = text.startsWith("-");
+	const [whole, fraction] = (negative ? text.slice(1) : text).split(".");
+	const separators = mode === "locale" ? separatorsOf(resolveLocale(options.locale)) : mode === "auto" && info.commaDecimal ? {
+		decimal: ",",
+		group: "."
+	} : {
+		decimal: ".",
+		group: ","
+	};
+	const shownWhole = options.grouped && mode !== "machine" ? groupDigits(whole, separators.group) : whole;
+	return `${negative ? "-" : ""}${shownWhole}${fraction === void 0 ? "" : `${separators.decimal}${fraction}`}`;
+}
+const STEPS = {
+	0: "1",
+	2: "0.01",
+	3: "0.001"
+};
+const PLACEHOLDERS = {
+	0: "0",
+	2: "0.00",
+	3: "0.000"
+};
+/** The `step` of a money number input: `'1'` (JPY), `'0.01'` (USD), `'0.001'` (KWD), from the storage digits. */
+function inputStep(currency) {
+	return STEPS[resolveCurrency(currency, { allowHistoric: true }).storageDigits];
+}
+/** The placeholder of a money input: `'0'`, `'0.00'` or `'0.000'`, from the storage digits. */
+function inputPlaceholder(currency) {
+	return PLACEHOLDERS[resolveCurrency(currency, { allowHistoric: true }).storageDigits];
+}
+//#endregion
+export { inputStep as a, inputPlaceholder as i, formatAmountInput as n, localeSeparators as o, groupDigits as r, parseAmountInput as s, decimalOfText as t };

package/dist/amount-DHtvZSSm.cjs

@@ -0,0 +1,241 @@
+const require_money = require("./money-D5-vlv0h.cjs");
+const require_arithmetic = require("./arithmetic-Bq-8mSal.cjs");
+const require_number_text = require("./number-text-BpvN6NAo.cjs");
+//#region src/input/amount.ts
+/** Internal: the exact signed decimal a successful separator-engine read holds. */
+function decimalOfText(read) {
+	return {
+		units: BigInt(read.sign) * read.units,
+		scale: read.scale
+	};
+}
+/** Internal: the locale's separators, as the engine takes them. */
+function localeSeparators(locale) {
+	const { decimal, group } = require_money.separatorsOf(require_money.resolveLocale(locale));
+	return {
+		decimalSeparator: decimal,
+		groupSeparator: group
+	};
+}
+/** Internal: a read decimal as Money, checked like typed entry (shared by parseModelMoney). */
+function entryMoney(value, info, options) {
+	const echo = options.original !== void 0 && require_money.compareDecimal(value, require_money.storedDecimal(options.original).value) === 0;
+	const round = options.roundExtraDigits === true;
+	if (!echo && !round && require_money.fractionDigitsOf(value) > info.storageDigits) return {
+		ok: false,
+		reason: "too_many_decimals"
+	};
+	if (value.units < 0n && !options.allowNegative) return {
+		ok: false,
+		reason: "negative"
+	};
+	if (value.units === 0n && options.allowZero === false) return {
+		ok: false,
+		reason: "zero"
+	};
+	let money;
+	if (echo) money = options.original;
+	else try {
+		money = require_money.fromMajor(require_money.formatDecimal(value), info.code, { precision: round ? "round" : "reject" });
+	} catch {
+		return {
+			ok: false,
+			reason: "above_max"
+		};
+	}
+	if (options.min && require_arithmetic.compare(money, options.min) < 0) return {
+		ok: false,
+		reason: "below_min"
+	};
+	if (options.max && require_arithmetic.compare(money, options.max) > 0) return {
+		ok: false,
+		reason: "above_max"
+	};
+	return {
+		ok: true,
+		money
+	};
+}
+/** Whether `shown` is exactly what `formatAmountInput(original)` prints for the field's locale or mode, grouped or not. */
+function echoesOriginal(shown, options) {
+	const { original, locale, decimalSeparator } = options;
+	if (original === void 0) return false;
+	const field = {
+		locale,
+		decimalSeparator
+	};
+	return shown === formatAmountInput(original, field) || shown === formatAmountInput(original, {
+		...field,
+		grouped: true
+	});
+}
+/** Which reading a field's options ask for; `decimalSeparator` and `locale` together, or a `decimalSeparator` other than `'.'`, throw. */
+function entryMode(options) {
+	if (options.decimalSeparator === void 0) return options.locale === void 0 ? "auto" : "locale";
+	if (options.decimalSeparator !== "." || options.locale !== void 0) throw new TypeError("decimalSeparator must be '.' and cannot be combined with locale");
+	return "machine";
+}
+const ENTRY_SEPARATORS = {
+	auto: {
+		decimalSeparator: "auto",
+		keepFraction: true
+	},
+	machine: {
+		decimalSeparator: ".",
+		groupSeparator: null
+	}
+};
+/**
+* Typed text to Money, one rule for every money field: the currency's symbols and code and all
+* whitespace are stripped; a leading `-` or U+2212 is the sign.
+* - Without `locale` (the chat wizard, any field with no locale): the 'auto' rule decides `.`
+*   against `,` (see `parseImportAmount`): `'29,99'` EUR is 29.99, `'1.299,00'` and `'1,299'`
+*   are 1299, KWD `'1,5'` is 1.5; a currency storing 0 digits rounds a fraction half-up to a
+*   whole unit (`'1200.5'` JPY is 1201).
+* - With `locale`: its decimal separator is the decimal and its group separator is valid only in
+*   3-digit (or Indian lakh) groups; in a currency that stores no fraction (JPY, VND) a separator
+*   before exactly three digits in grouping position is grouping (`'1.500'` JPY is 1500).
+*   en-US `'29,99'` USD is `'unparseable'`; de-DE `'29,99'` EUR is 29.99; en-US `'1200.5'` JPY
+*   is `'too_many_decimals'`.
+* - With `decimalSeparator: '.'` (every `<input type="number">`): `.` is the decimal, nothing
+*   groups (`'1,299'` is `'unparseable'`), TND and IQD `'1.500'` are 1.5, and a currency storing
+*   0 digits rounds a fraction half-up to a whole unit (`'1.5'` JPY is 2).
+* Otherwise more fraction digits than the currency stores is `'too_many_decimals'`, never rounded
+* (`'1,2345'` USD). Text equal to `original` returns it unchanged (JPY 120050 shown as
+* `'1200.50'`). An unknown currency, or an `original` in another currency, throws.
+*/
+function parseAmountInput(text, currency, options = {}) {
+	const info = require_money.resolveCurrency(currency, { allowHistoric: true });
+	if (options.original !== void 0 && require_money.storedDecimal(options.original).info.code !== info.code) throw new require_money.MoneyError("currency_mismatch", `original is ${options.original.currency}, the field is ${info.code}`);
+	const shown = typeof text === "string" ? text.trim() : "";
+	const mode = entryMode(options);
+	let value;
+	if (echoesOriginal(shown, options)) value = require_money.storedDecimal(options.original).value;
+	else {
+		const separators = mode === "locale" ? localeSeparators(options.locale) : ENTRY_SEPARATORS[mode];
+		const read = require_number_text.readNumberText(text, {
+			...separators,
+			currency: info.code
+		});
+		if ("reason" in read) return {
+			ok: false,
+			reason: read.reason,
+			text: shown
+		};
+		value = decimalOfText(read);
+	}
+	const result = entryMoney(value, info, {
+		...options,
+		roundExtraDigits: mode !== "locale" && info.storageDigits === 0
+	});
+	if (!result.ok) return {
+		ok: false,
+		reason: result.reason,
+		text: shown
+	};
+	return {
+		ok: true,
+		money: result.money,
+		text: require_money.toMajorDecimal(result.money)
+	};
+}
+/** Internal: `digits` with `group` between every three, from the right. */
+function groupDigits(digits, group) {
+	return digits.replace(/\B(?=(\d{3})+(?!\d))/g, group);
+}
+/**
+* The text a money field shows for a stored amount, no symbol, exact: a stored amount finer than
+* the storage digits keeps its digits (JPY 120050 is never rounded on display).
+* - Without `locale`: the spelling `parseAmountInput` reads back without a locale. Trailing
+*   fraction zeros are dropped (`'12.5'`, `'1200'`, KWD 1500 is `'1.5'`, JPY 120050 is
+*   `'1200.5'`), a currency written with a decimal comma (TND, `commaDecimal`) uses `,` and
+*   groups with `.` (`'1,125'`, `'1.234,5'`), every other currency `.` and `,`. Two amounts have no
+*   such spelling: IQD with a three-digit fraction (`'1.125'` reads as 1125, IQD displays no
+*   decimals) and a sub-unit amount of a currency storing 0 digits (`'1200.5'` JPY reads as a
+*   whole 1201); pass `{ original: m }` so the untouched text returns `m` itself.
+* - With `locale`: its decimal and group separators and the storage digits (`'12,50'` de-DE).
+* - With `decimalSeparator: '.'` (the value of an `<input type="number">`): `.` decimal, never
+*   grouped, trailing zeros dropped (TND 1500 is `'1.5'`, JPY 120050 `'1200.5'`), read back
+*   exactly by `parseAmountInput(text, currency, { decimalSeparator: '.' })` (JPY sub-unit
+*   amounts through `original`).
+* `grouped` adds group separators (not in `'.'` mode); `digits` overrides the zeros
+* (`'storage'` keeps them, `'trim-zero'` drops them).
+*/
+function formatAmountInput(m, options = {}) {
+	const { info } = require_money.storedDecimal(m);
+	const mode = entryMode(options);
+	const exact = require_money.toMajorDecimal(m);
+	const text = (options.digits ?? (mode === "locale" ? "storage" : "trim-zero")) === "trim-zero" ? require_money.trimDecimalZeros(exact) : exact;
+	const negative = text.startsWith("-");
+	const [whole, fraction] = (negative ? text.slice(1) : text).split(".");
+	const separators = mode === "locale" ? require_money.separatorsOf(require_money.resolveLocale(options.locale)) : mode === "auto" && info.commaDecimal ? {
+		decimal: ",",
+		group: "."
+	} : {
+		decimal: ".",
+		group: ","
+	};
+	const shownWhole = options.grouped && mode !== "machine" ? groupDigits(whole, separators.group) : whole;
+	return `${negative ? "-" : ""}${shownWhole}${fraction === void 0 ? "" : `${separators.decimal}${fraction}`}`;
+}
+const STEPS = {
+	0: "1",
+	2: "0.01",
+	3: "0.001"
+};
+const PLACEHOLDERS = {
+	0: "0",
+	2: "0.00",
+	3: "0.000"
+};
+/** The `step` of a money number input: `'1'` (JPY), `'0.01'` (USD), `'0.001'` (KWD), from the storage digits. */
+function inputStep(currency) {
+	return STEPS[require_money.resolveCurrency(currency, { allowHistoric: true }).storageDigits];
+}
+/** The placeholder of a money input: `'0'`, `'0.00'` or `'0.000'`, from the storage digits. */
+function inputPlaceholder(currency) {
+	return PLACEHOLDERS[require_money.resolveCurrency(currency, { allowHistoric: true }).storageDigits];
+}
+//#endregion
+Object.defineProperty(exports, "decimalOfText", {
+	enumerable: true,
+	get: function() {
+		return decimalOfText;
+	}
+});
+Object.defineProperty(exports, "formatAmountInput", {
+	enumerable: true,
+	get: function() {
+		return formatAmountInput;
+	}
+});
+Object.defineProperty(exports, "groupDigits", {
+	enumerable: true,
+	get: function() {
+		return groupDigits;
+	}
+});
+Object.defineProperty(exports, "inputPlaceholder", {
+	enumerable: true,
+	get: function() {
+		return inputPlaceholder;
+	}
+});
+Object.defineProperty(exports, "inputStep", {
+	enumerable: true,
+	get: function() {
+		return inputStep;
+	}
+});
+Object.defineProperty(exports, "localeSeparators", {
+	enumerable: true,
+	get: function() {
+		return localeSeparators;
+	}
+});
+Object.defineProperty(exports, "parseAmountInput", {
+	enumerable: true,
+	get: function() {
+		return parseAmountInput;
+	}
+});