@amboras-dev/money 0.0.0-stage → 0.2.0

package/dist/ai.d.cts

@@ -0,0 +1,97 @@
+import { R as DecimalText, g as CurrencyCode, i as Money } from "./money-B-3aFjNJ.cjs";
+//#region src/ai/mentions.d.ts
+/** One price found in text. `code` is set when the mark names one currency; `amount` when the number reads (see the separator engine's 'auto' rule). */
+interface MoneyMention {
+  /** The matched text, mark and number. */
+  readonly raw: string;
+  /** UTF-16 offset of `raw` in the text. */
+  readonly index: number;
+  /** The currency mark as written (`'$'`, `'AED'`, `'Rp'`). */
+  readonly symbol?: string;
+  readonly code?: CurrencyCode;
+  /** Major units as canonical decimal text. */
+  readonly amount?: DecimalText;
+}
+/**
+ * Every spelling a store may print for `currency` besides its ISO code, from the registry:
+ * symbol, narrow symbol and aliases (`['₹', 'Rs.', 'Rs']` for INR, `['$', 'US$']` for USD).
+ */
+export declare function currencySymbolAliases(currency: string): readonly string[];
+/**
+ * The money-literal regex as `{ source, flags }` (flags `'gu'`), a string so a browser script
+ * (`page.evaluate`) runs exactly what Node runs. It matches a currency mark next to a number,
+ * either order, at most one space between: the marks of `currency`, or of every active
+ * currency (single-letter marks such as `R` only when `currency` names them), plus any Unicode
+ * currency sign. Numbers group in threes or in Indian lakh (`1,00,000`) with `.`, `,`, space
+ * or apostrophe and carry up to `maxFractionDigits` (default 3) fraction digits. Groups: 1 mark and 2 number, or 3 number
+ * and 4 mark. A bare number never matches.
+ */
+export declare function moneyLiteralPattern(options?: {
+  currency?: string;
+  maxFractionDigits?: number;
+}): {
+  source: string;
+  flags: string;
+};
+/**
+ * Every price in `text`, in order (see `moneyLiteralPattern`). With `currency`, its marks are
+ * matched (single letters too) and claim the mentions they appear in; a mark only one active
+ * currency prints names that currency; `$`, `kr` and other shared marks leave `code` unset.
+ * `amount` is read with the separator engine's `'auto'` rule in the named currency (one
+ * separator before exactly three digits groups, except a KWD-style decimal mark).
+ */
+export declare function moneyMentions(text: string, options?: {
+  currency?: string;
+}): MoneyMention[];
+//#endregion
+//#region src/ai/model-money.d.ts
+/** A stored amount as the model sees it: the major amount, the code and a display string. */
+interface MoneyView {
+  readonly amount: number;
+  readonly currency: CurrencyCode;
+  readonly display: string;
+}
+/**
+ * `{ amount: 19.99, currency: 'USD', display: '$19.99' }`. `amount` is exact; `display` shows the
+ * display digits, widened to keep a stored value finer than them (JPY 550 is `'¥5.5'`, HUF 435050
+ * `'HUF 4,350.5'`). capability-kit's `moneyView` uses the storage digits as the minimum instead
+ * (HUF 435000 is `'HUF 4,350.00'` there and `'HUF 4,350'` here, IQD 1500 `'IQD 1.500'` against
+ * `'IQD 1.5'`): a deliberate change, listed in the README's behaviour changes.
+ */
+export declare function moneyView(m: Money): MoneyView;
+type ParseModelMoneyResult = {
+  readonly ok: true;
+  readonly money: Money;
+} | {
+  readonly ok: false;
+  readonly error: string;
+};
+interface ParseModelMoneyOptions {
+  /** Default false. */
+  allowNegative?: boolean;
+  /** Default true. */
+  allowZero?: boolean;
+}
+/**
+ * An amount from a model tool call (major units, as the merchant says it) as Money, or an
+ * error to send back to the model ending with `MONEY_UNIT_SENTENCE`. Numbers go through
+ * `fromMajor` (float noise such as 0.1 + 0.2 allowed); strings through `/input`'s entry rule
+ * in English (`'1,299.00'`, `'$1,299'`, `'99.000'` VND, `'1.500'` JPY). More fraction digits
+ * than the currency stores and negative amounts are refused, never rounded or flipped. An
+ * unknown currency throws `currency_invalid` (it is the tool's, not the model's).
+ */
+export declare function parseModelMoney(input: unknown, currency: string, options?: ParseModelMoneyOptions): ParseModelMoneyResult;
+//#endregion
+//#region src/ai/wording.d.ts
+/** The one unit sentence every money field carries, for the model and for people. Verbatim. */
+export declare const MONEY_UNIT_SENTENCE = "Amount in normal currency units as the merchant says it (99 means 99.00; 1.5 means 1.50). Never cents or minor units.";
+/** JSON Schema keyword marking a money field. Verbatim. */
+export declare const MONEY_META_KEY = "x-amboras-money";
+/** How store API amounts are scaled, for tool descriptions that hand stored amounts to the model. */
+export declare const STORAGE_UNIT_SENTENCE = "Store API amounts are storage units: major units x100, x1000 for KWD, BHD, OMR, TND, JOD, IQD and LYD, and x100 for zero-decimal currencies too. Render them with the money formatter; never divide or multiply by hand.";
+/** What a manual exchange rate means, for rate fields. */
+export declare const RATE_UNIT_SENTENCE = "1 unit of the store currency equals this many units of the other currency.";
+/** A money field's description: `describe` (trimmed) followed by the unit sentence, or the sentence alone. */
+export declare function moneyFieldDescription(describe?: string): string;
+//#endregion
+export type { MoneyMention, MoneyView, ParseModelMoneyOptions, ParseModelMoneyResult };

package/dist/ai.d.ts

@@ -0,0 +1,97 @@
+import { R as DecimalText, g as CurrencyCode, i as Money } from "./money-B-3aFjNJ.js";
+//#region src/ai/mentions.d.ts
+/** One price found in text. `code` is set when the mark names one currency; `amount` when the number reads (see the separator engine's 'auto' rule). */
+interface MoneyMention {
+  /** The matched text, mark and number. */
+  readonly raw: string;
+  /** UTF-16 offset of `raw` in the text. */
+  readonly index: number;
+  /** The currency mark as written (`'$'`, `'AED'`, `'Rp'`). */
+  readonly symbol?: string;
+  readonly code?: CurrencyCode;
+  /** Major units as canonical decimal text. */
+  readonly amount?: DecimalText;
+}
+/**
+ * Every spelling a store may print for `currency` besides its ISO code, from the registry:
+ * symbol, narrow symbol and aliases (`['₹', 'Rs.', 'Rs']` for INR, `['$', 'US$']` for USD).
+ */
+export declare function currencySymbolAliases(currency: string): readonly string[];
+/**
+ * The money-literal regex as `{ source, flags }` (flags `'gu'`), a string so a browser script
+ * (`page.evaluate`) runs exactly what Node runs. It matches a currency mark next to a number,
+ * either order, at most one space between: the marks of `currency`, or of every active
+ * currency (single-letter marks such as `R` only when `currency` names them), plus any Unicode
+ * currency sign. Numbers group in threes or in Indian lakh (`1,00,000`) with `.`, `,`, space
+ * or apostrophe and carry up to `maxFractionDigits` (default 3) fraction digits. Groups: 1 mark and 2 number, or 3 number
+ * and 4 mark. A bare number never matches.
+ */
+export declare function moneyLiteralPattern(options?: {
+  currency?: string;
+  maxFractionDigits?: number;
+}): {
+  source: string;
+  flags: string;
+};
+/**
+ * Every price in `text`, in order (see `moneyLiteralPattern`). With `currency`, its marks are
+ * matched (single letters too) and claim the mentions they appear in; a mark only one active
+ * currency prints names that currency; `$`, `kr` and other shared marks leave `code` unset.
+ * `amount` is read with the separator engine's `'auto'` rule in the named currency (one
+ * separator before exactly three digits groups, except a KWD-style decimal mark).
+ */
+export declare function moneyMentions(text: string, options?: {
+  currency?: string;
+}): MoneyMention[];
+//#endregion
+//#region src/ai/model-money.d.ts
+/** A stored amount as the model sees it: the major amount, the code and a display string. */
+interface MoneyView {
+  readonly amount: number;
+  readonly currency: CurrencyCode;
+  readonly display: string;
+}
+/**
+ * `{ amount: 19.99, currency: 'USD', display: '$19.99' }`. `amount` is exact; `display` shows the
+ * display digits, widened to keep a stored value finer than them (JPY 550 is `'¥5.5'`, HUF 435050
+ * `'HUF 4,350.5'`). capability-kit's `moneyView` uses the storage digits as the minimum instead
+ * (HUF 435000 is `'HUF 4,350.00'` there and `'HUF 4,350'` here, IQD 1500 `'IQD 1.500'` against
+ * `'IQD 1.5'`): a deliberate change, listed in the README's behaviour changes.
+ */
+export declare function moneyView(m: Money): MoneyView;
+type ParseModelMoneyResult = {
+  readonly ok: true;
+  readonly money: Money;
+} | {
+  readonly ok: false;
+  readonly error: string;
+};
+interface ParseModelMoneyOptions {
+  /** Default false. */
+  allowNegative?: boolean;
+  /** Default true. */
+  allowZero?: boolean;
+}
+/**
+ * An amount from a model tool call (major units, as the merchant says it) as Money, or an
+ * error to send back to the model ending with `MONEY_UNIT_SENTENCE`. Numbers go through
+ * `fromMajor` (float noise such as 0.1 + 0.2 allowed); strings through `/input`'s entry rule
+ * in English (`'1,299.00'`, `'$1,299'`, `'99.000'` VND, `'1.500'` JPY). More fraction digits
+ * than the currency stores and negative amounts are refused, never rounded or flipped. An
+ * unknown currency throws `currency_invalid` (it is the tool's, not the model's).
+ */
+export declare function parseModelMoney(input: unknown, currency: string, options?: ParseModelMoneyOptions): ParseModelMoneyResult;
+//#endregion
+//#region src/ai/wording.d.ts
+/** The one unit sentence every money field carries, for the model and for people. Verbatim. */
+export declare const MONEY_UNIT_SENTENCE = "Amount in normal currency units as the merchant says it (99 means 99.00; 1.5 means 1.50). Never cents or minor units.";
+/** JSON Schema keyword marking a money field. Verbatim. */
+export declare const MONEY_META_KEY = "x-amboras-money";
+/** How store API amounts are scaled, for tool descriptions that hand stored amounts to the model. */
+export declare const STORAGE_UNIT_SENTENCE = "Store API amounts are storage units: major units x100, x1000 for KWD, BHD, OMR, TND, JOD, IQD and LYD, and x100 for zero-decimal currencies too. Render them with the money formatter; never divide or multiply by hand.";
+/** What a manual exchange rate means, for rate fields. */
+export declare const RATE_UNIT_SENTENCE = "1 unit of the store currency equals this many units of the other currency.";
+/** A money field's description: `describe` (trimmed) followed by the unit sentence, or the sentence alone. */
+export declare function moneyFieldDescription(describe?: string): string;
+//#endregion
+export type { MoneyMention, MoneyView, ParseModelMoneyOptions, ParseModelMoneyResult };

package/dist/ai.js

@@ -0,0 +1,175 @@
+import { $ as describeValue, E as resolveCurrency, Q as MoneyError, l as toMajorNumber, m as currencyMarks, n as fromMajor, pt as toDecimalText, s as storedDecimal, u as CURRENCIES } from "./money-WhnGiI00.js";
+import { t as formatMoney } from "./format-BdPnijvn.js";
+import { n as readNumberText, t as digitGroupingSource } from "./number-text-DE-q4jO5.js";
+import { s as parseAmountInput } from "./amount-BoYBMgK9.js";
+//#region src/ai/mentions.ts
+const ACTIVE = CURRENCIES.filter((c) => c.status === "active");
+const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const LETTER_START = /^\p{L}/u;
+const LETTER_END = /\p{L}$/u;
+const SINGLE_LETTER = /^\p{L}$/u;
+const OWNERS = /* @__PURE__ */ new Map();
+for (const info of ACTIVE) for (const mark of currencyMarks(info)) OWNERS.set(mark, [...OWNERS.get(mark) ?? [], info.code]);
+/**
+* Every spelling a store may print for `currency` besides its ISO code, from the registry:
+* symbol, narrow symbol and aliases (`['₹', 'Rs.', 'Rs']` for INR, `['$', 'US$']` for USD).
+*/
+function currencySymbolAliases(currency) {
+	const info = resolveCurrency(currency, { allowHistoric: true });
+	return Object.freeze(currencyMarks(info).filter((mark) => mark !== info.code));
+}
+/** A mark as a regex alternative; a mark that starts or ends with a letter must not touch another letter. */
+function markSource(mark) {
+	const before = LETTER_START.test(mark) ? "(?<!\\p{L})" : "";
+	const after = LETTER_END.test(mark) ? "(?!\\p{L})" : "";
+	return `${before}${escapeRegExp(mark)}${after}`;
+}
+function numberSource(maxFractionDigits) {
+	const fraction = maxFractionDigits === 0 ? "" : `(?:[.,]\\d{1,${maxFractionDigits}})?`;
+	return `(?:${digitGroupingSource("[ \\u00a0\\u2009\\u202f.,'’]")})${fraction}|\\d+${fraction}`;
+}
+/**
+* The money-literal regex as `{ source, flags }` (flags `'gu'`), a string so a browser script
+* (`page.evaluate`) runs exactly what Node runs. It matches a currency mark next to a number,
+* either order, at most one space between: the marks of `currency`, or of every active
+* currency (single-letter marks such as `R` only when `currency` names them), plus any Unicode
+* currency sign. Numbers group in threes or in Indian lakh (`1,00,000`) with `.`, `,`, space
+* or apostrophe and carry up to `maxFractionDigits` (default 3) fraction digits. Groups: 1 mark and 2 number, or 3 number
+* and 4 mark. A bare number never matches.
+*/
+function moneyLiteralPattern(options = {}) {
+	const digits = options.maxFractionDigits ?? 3;
+	if (!Number.isInteger(digits) || digits < 0 || digits > 6) throw new MoneyError("amount_invalid", `maxFractionDigits must be an integer from 0 to 6, got ${describeValue(digits)}`);
+	const mark = `(${[...(options.currency === void 0 ? [...OWNERS.keys()].filter((mark) => !SINGLE_LETTER.test(mark)) : currencyMarks(resolveCurrency(options.currency, { allowHistoric: true }))).sort((a, b) => b.length - a.length || (a < b ? -1 : 1)).map(markSource), "\\p{Sc}"].join("|")})`;
+	const number = `(${numberSource(digits)})`;
+	return {
+		source: `${mark}\\s?${number}|${number}\\s?${mark}`,
+		flags: "gu"
+	};
+}
+function codeOfMark(mark, currency) {
+	if (currency && currencyMarks(currency).includes(mark)) return currency.code;
+	const owners = OWNERS.get(mark);
+	return owners?.length === 1 ? owners[0] : void 0;
+}
+/**
+* Every price in `text`, in order (see `moneyLiteralPattern`). With `currency`, its marks are
+* matched (single letters too) and claim the mentions they appear in; a mark only one active
+* currency prints names that currency; `$`, `kr` and other shared marks leave `code` unset.
+* `amount` is read with the separator engine's `'auto'` rule in the named currency (one
+* separator before exactly three digits groups, except a KWD-style decimal mark).
+*/
+function moneyMentions(text, options = {}) {
+	const currency = options.currency === void 0 ? null : resolveCurrency(options.currency, { allowHistoric: true });
+	const { source, flags } = moneyLiteralPattern({ currency: currency?.code });
+	const mentions = [];
+	for (const match of String(text).matchAll(new RegExp(source, flags))) {
+		const symbol = match[1] ?? match[4];
+		const code = codeOfMark(symbol, currency);
+		const read = readNumberText(match[2] ?? match[3], {
+			decimalSeparator: "auto",
+			currency: code
+		});
+		mentions.push({
+			raw: match[0],
+			index: match.index,
+			symbol,
+			...code === void 0 ? {} : { code },
+			..."reason" in read ? {} : { amount: toDecimalText({
+				units: read.units,
+				scale: read.scale
+			}) }
+		});
+	}
+	return mentions;
+}
+//#endregion
+//#region src/ai/wording.ts
+/** The one unit sentence every money field carries, for the model and for people. Verbatim. */
+const MONEY_UNIT_SENTENCE = "Amount in normal currency units as the merchant says it (99 means 99.00; 1.5 means 1.50). Never cents or minor units.";
+/** JSON Schema keyword marking a money field. Verbatim. */
+const MONEY_META_KEY = "x-amboras-money";
+/** How store API amounts are scaled, for tool descriptions that hand stored amounts to the model. */
+const STORAGE_UNIT_SENTENCE = "Store API amounts are storage units: major units x100, x1000 for KWD, BHD, OMR, TND, JOD, IQD and LYD, and x100 for zero-decimal currencies too. Render them with the money formatter; never divide or multiply by hand.";
+/** What a manual exchange rate means, for rate fields. */
+const RATE_UNIT_SENTENCE = "1 unit of the store currency equals this many units of the other currency.";
+/** A money field's description: `describe` (trimmed) followed by the unit sentence, or the sentence alone. */
+function moneyFieldDescription(describe) {
+	const lead = typeof describe === "string" ? describe.trim() : "";
+	return lead ? `${lead} ${MONEY_UNIT_SENTENCE}` : MONEY_UNIT_SENTENCE;
+}
+//#endregion
+//#region src/ai/model-money.ts
+/**
+* `{ amount: 19.99, currency: 'USD', display: '$19.99' }`. `amount` is exact; `display` shows the
+* display digits, widened to keep a stored value finer than them (JPY 550 is `'¥5.5'`, HUF 435050
+* `'HUF 4,350.5'`). capability-kit's `moneyView` uses the storage digits as the minimum instead
+* (HUF 435000 is `'HUF 4,350.00'` there and `'HUF 4,350'` here, IQD 1500 `'IQD 1.500'` against
+* `'IQD 1.5'`): a deliberate change, listed in the README's behaviour changes.
+*/
+function moneyView(m) {
+	const { info } = storedDecimal(m);
+	return {
+		amount: toMajorNumber(m),
+		currency: info.code,
+		display: formatMoney(m, {
+			locale: "en",
+			digits: "widen"
+		})
+	};
+}
+function failure(reason, input, code, digits) {
+	const shown = describeValue(input);
+	return {
+		ok: false,
+		error: `${{
+			empty: `Not an amount: ${shown}.`,
+			unparseable: `Not an amount: ${shown}.`,
+			too_many_decimals: `${shown} has more decimal places than ${code} uses (at most ${digits}).`,
+			negative: "The amount must not be negative.",
+			zero: "The amount must be more than zero.",
+			below_min: `${shown} is out of range for ${code}.`,
+			above_max: `${shown} is out of range for ${code}.`
+		}[reason]} ${MONEY_UNIT_SENTENCE}`
+	};
+}
+function fromNumber(input, currency, options) {
+	if (!Number.isFinite(input)) return "unparseable";
+	if (input < 0 && !options.allowNegative) return "negative";
+	if (input === 0 && options.allowZero === false) return "zero";
+	try {
+		return fromMajor(input, currency);
+	} catch (error) {
+		return error.code === "precision" ? "too_many_decimals" : "above_max";
+	}
+}
+/**
+* An amount from a model tool call (major units, as the merchant says it) as Money, or an
+* error to send back to the model ending with `MONEY_UNIT_SENTENCE`. Numbers go through
+* `fromMajor` (float noise such as 0.1 + 0.2 allowed); strings through `/input`'s entry rule
+* in English (`'1,299.00'`, `'$1,299'`, `'99.000'` VND, `'1.500'` JPY). More fraction digits
+* than the currency stores and negative amounts are refused, never rounded or flipped. An
+* unknown currency throws `currency_invalid` (it is the tool's, not the model's).
+*/
+function parseModelMoney(input, currency, options = {}) {
+	const info = resolveCurrency(currency, { allowHistoric: true });
+	if (typeof input === "number") {
+		const result = fromNumber(input, info.code, options);
+		return typeof result === "string" ? failure(result, input, info.code, info.storageDigits) : {
+			ok: true,
+			money: result
+		};
+	}
+	if (typeof input !== "string") return failure("unparseable", input, info.code, info.storageDigits);
+	const result = parseAmountInput(input, info.code, {
+		locale: "en",
+		allowNegative: options.allowNegative,
+		allowZero: options.allowZero
+	});
+	return result.ok ? {
+		ok: true,
+		money: result.money
+	} : failure(result.reason, input, info.code, info.storageDigits);
+}
+//#endregion
+export { MONEY_META_KEY, MONEY_UNIT_SENTENCE, RATE_UNIT_SENTENCE, STORAGE_UNIT_SENTENCE, currencySymbolAliases, moneyFieldDescription, moneyLiteralPattern, moneyMentions, moneyView, parseModelMoney };

package/dist/allocate-CZRg4TOP.cjs

@@ -0,0 +1,222 @@
+const require_money = require("./money-B3wH_Z4S.cjs");
+const require_rounding = require("./rounding-DHBtNCHG.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;
+	}
+});