@shirudo/ddd-kit 2.2.0 → 3.0.0-rc.3

package/dist/money.js

@@ -0,0 +1,578 @@
+import { i as DomainError } from "./chunks/errors.js";
+import { err, ok } from "@shirudo/result";
+
+//#region src/money/errors.ts
+/**
+* Renders a value for a diagnostic message with a hard size ceiling:
+* error messages must never carry attacker-sized payloads into logs.
+* Total: never throws, whatever the value (JSON.stringify alone would
+* crash on bigint and circular input, replacing the documented kit
+* error with a raw TypeError). Module-internal, not part of the
+* package entry.
+*/
+function describeValue(value) {
+	if (typeof value === "bigint") {
+		const digits = value.toString();
+		return digits.length > 48 ? `${digits.slice(0, 48)}... (truncated bigint)` : `${digits}n`;
+	}
+	if (typeof value === "string" && value.length > 48) return `${JSON.stringify(value.slice(0, 48))} (truncated, ${value.length} chars)`;
+	let rendered;
+	try {
+		rendered = JSON.stringify(value);
+	} catch {
+		rendered = void 0;
+	}
+	if (rendered === void 0) try {
+		rendered = String(value);
+	} catch {
+		rendered = `[unserializable ${typeof value}]`;
+	}
+	if (rendered.length > 64) return `${rendered.slice(0, 64)} (truncated)`;
+	return rendered;
+}
+var InvalidMoneyError = class extends DomainError {
+	constructor(message) {
+		super({
+			code: "INVALID_MONEY",
+			message
+		});
+	}
+};
+var MoneyCurrencyMismatchError = class extends DomainError {
+	constructor(left, right) {
+		super({
+			code: "MONEY_CURRENCY_MISMATCH",
+			message: `money operations require the same currency; got ${describeValue(left)} and ${describeValue(right)}`
+		});
+	}
+};
+var MoneyScaleMismatchError = class extends DomainError {
+	constructor(left, right) {
+		super({
+			code: "MONEY_SCALE_MISMATCH",
+			message: `money operations require the same scale; got ${left} and ${right} (rescaleMoney is the explicit conversion)`
+		});
+	}
+};
+var MoneyPrecisionLossError = class extends DomainError {
+	constructor(message) {
+		super({
+			code: "MONEY_PRECISION_LOSS",
+			message
+		});
+	}
+};
+var UnknownCurrencyError = class extends DomainError {
+	constructor(currency) {
+		super({
+			code: "UNKNOWN_CURRENCY",
+			message: `The currency scale resolver has no entry for ${describeValue(currency)}`
+		});
+	}
+};
+
+//#endregion
+//#region src/money/money.ts
+const INTEGER_STRING = /^-?\d+$/;
+/**
+* Hard bounds, enforced at the single construction door so hostile
+* input cannot buy unbounded CPU (BigInt conversion is superlinear in
+* digit count) or memory (cache keys, padded strings, log echoes):
+*
+* - amounts: fewer than 97 digits (uint256 is 78 digits; headroom)
+* - scale: at most 64 (ETH wei is 18)
+* - currency: at most 32 characters (ISO 4217 needs 3)
+*
+* Everything past a bound is `INVALID_MONEY` by construction, and the
+* DTO/parse boundaries reject oversized strings before converting them.
+*/
+const MONEY_AMOUNT_LIMIT = 10n ** 96n;
+const MAX_MONEY_SCALE = 64;
+const MAX_CURRENCY_LENGTH = 32;
+const MAX_DTO_AMOUNT_LENGTH = 97;
+function isValidAmount(amountMinor) {
+	return typeof amountMinor === "bigint" && amountMinor < MONEY_AMOUNT_LIMIT && amountMinor > -MONEY_AMOUNT_LIMIT;
+}
+function isValidCurrency(currency) {
+	return typeof currency === "string" && currency.length > 0 && currency.length <= MAX_CURRENCY_LENGTH && !/\s/.test(currency);
+}
+/**
+* Scale guard for operations that must validate a TARGET scale before
+* computing with it (10^scale on an unchecked value is an attack
+* surface). Module-internal export, not part of the package entry.
+*/
+function assertValidScale(scale) {
+	if (!isValidScale(scale)) throw new InvalidMoneyError(`scale must be an integer between 0 and ${MAX_MONEY_SCALE}; got ${describeValue(scale)}`);
+}
+/**
+* Currency counterpart to {@link assertValidScale}, for call sites
+* that must reject a wiring-provided currency before any input work.
+* Module-internal export, not part of the package entry.
+*/
+function assertValidCurrency(currency) {
+	if (!isValidCurrency(currency)) throw new InvalidMoneyError(`currency must be a non-empty string without whitespace, at most ${MAX_CURRENCY_LENGTH} characters; got ${describeValue(currency)}`);
+}
+/**
+* Validates an unknown plain shape and mints a FRESH, frozen
+* {@link Money} from it: the result shares no reference with the
+* input, so later mutation of the input cannot reach domain state.
+* The door for re-hydrating foreign minor-units data (rows already
+* mapped by an ORM, caches, deserialized snapshots); wire strings go
+* through `moneyFromDto` instead.
+*/
+function moneyFromUnknown(value) {
+	assertMoney(value);
+	return moneyOfMinor(value.amountMinor, value.currency, value.scale);
+}
+function isValidScale(scale) {
+	return typeof scale === "number" && Number.isSafeInteger(scale) && scale >= 0 && scale <= MAX_MONEY_SCALE;
+}
+/**
+* Constructs a frozen {@link Money} from an exact minor-unit amount.
+* The only door into the shape: rejects `number` amounts (floats have
+* no place in stored money), invalid scales, and empty or
+* whitespace-carrying currency codes with `InvalidMoneyError`.
+*/
+function moneyOfMinor(amountMinor, currency, scale) {
+	if (typeof amountMinor !== "bigint") throw new InvalidMoneyError(`amountMinor must be a bigint in minor units; got ${typeof amountMinor}`);
+	if (!isValidAmount(amountMinor)) throw new InvalidMoneyError("amountMinor must stay below 97 digits (uint256 fits with headroom)");
+	assertValidCurrency(currency);
+	assertValidScale(scale);
+	return Object.freeze({
+		amountMinor,
+		currency,
+		scale
+	});
+}
+/**
+* Validates a {@link MoneyDto} fresh off the wire and converts it to
+* {@link Money}. Takes `unknown` on purpose: this IS the trust
+* boundary, so callers never cast before validating. `amountMinor`
+* must be a plain integer string (`/^-?\d+$/`); anything `Number()`
+* would tolerate but bigint arithmetic cannot represent exactly
+* ("1e5", "10.99", "0x10") is rejected with `InvalidMoneyError`.
+*/
+function moneyFromDto(dto) {
+	if (dto === null || typeof dto !== "object") throw new InvalidMoneyError(`MoneyDto must be an object; got ${dto === null ? "null" : typeof dto}`);
+	const { amountMinor, currency, scale } = dto;
+	if (typeof amountMinor !== "string" || amountMinor.length > MAX_DTO_AMOUNT_LENGTH || !INTEGER_STRING.test(amountMinor)) throw new InvalidMoneyError(`MoneyDto.amountMinor must be an integer string matching /^-?\\d+$/ with at most 96 digits; got ${describeValue(amountMinor)}`);
+	return moneyOfMinor(BigInt(amountMinor), currency, scale);
+}
+/**
+* Converts {@link Money} to its JSON-safe wire shape. Guards the input
+* so untyped callers cannot leak a number-amount object onto the wire.
+*/
+function moneyToDto(money) {
+	assertMoney(money);
+	return {
+		amountMinor: money.amountMinor.toString(),
+		currency: money.currency,
+		scale: money.scale
+	};
+}
+/**
+* Narrows an unknown value to the canonical {@link Money} shape. A
+* CHECK, not a door: narrowing neither copies nor freezes, so an
+* external alias can still mutate the underlying object after the
+* check. For anything entering domain state, mint a fresh frozen
+* value with {@link moneyFromUnknown} instead.
+*/
+function isMoney(value) {
+	if (value === null || typeof value !== "object") return false;
+	const candidate = value;
+	return isValidAmount(candidate.amountMinor) && isValidCurrency(candidate.currency) && isValidScale(candidate.scale);
+}
+/**
+* Loud form of {@link isMoney} for boundary functions. Module-internal
+* export, not part of the package entry.
+*/
+function assertMoney(value) {
+	if (!isMoney(value)) throw new InvalidMoneyError("expected a Money value ({ amountMinor: bigint, currency: string, scale: number })");
+}
+/**
+* REPRESENTATION equality, deliberately: amount, currency, AND scale.
+* `10.0` EUR at scale 1 and `10.00` EUR at scale 2 denote the same
+* monetary value but are NOT equal here, because silently conflating
+* scales is how precision bugs hide. For monetary-value comparison,
+* align the scales explicitly first (lossless `rescaleMoney` upscales
+* the coarser side) and then compare.
+*/
+function moneyEquals(a, b) {
+	return a.amountMinor === b.amountMinor && a.currency === b.currency && a.scale === b.scale;
+}
+/** True when the amount is exactly zero. */
+function isZeroMoney(money) {
+	return money.amountMinor === 0n;
+}
+/** True when the amount is strictly greater than zero. */
+function isPositiveMoney(money) {
+	return money.amountMinor > 0n;
+}
+/** True when the amount is strictly less than zero. */
+function isNegativeMoney(money) {
+	return money.amountMinor < 0n;
+}
+/**
+* Renders the exact decimal representation ("10.99", "-0.05", "10").
+* The inverse of `parseMoneyInput` and the precision-safe input for
+* display formatting; never feed the result back into arithmetic.
+* Guards its input like the wire emitters do: a non-Money value fails
+* loudly instead of rendering garbage.
+*/
+function moneyToDecimalString(money) {
+	assertMoney(money);
+	const negative = money.amountMinor < 0n;
+	const digits = (negative ? -money.amountMinor : money.amountMinor).toString();
+	const sign = negative ? "-" : "";
+	if (money.scale === 0) return sign + digits;
+	const padded = digits.padStart(money.scale + 1, "0");
+	return `${sign}${padded.slice(0, -money.scale)}.${padded.slice(-money.scale)}`;
+}
+
+//#endregion
+//#region src/money/arithmetic.ts
+/**
+* Exact operations only. Everything here is closed (Money in, Money
+* out) and cannot lose information, so no rounding decision exists to
+* make. Anything that WOULD need one (multiplication, ratios, fees,
+* division, lossy rescaling) plus everything distributive (allocation:
+* splitting 10.00 EUR three ways must hand out 3.34 + 3.33 + 3.33, not
+* round three times) and rate-based (FX) is deliberately NOT
+* implemented by the kit: rounding timing, order, and remainder policy
+* are domain policy, and a battle-tested calculation library should
+* execute them at the use-case boundary (see the snapshot bridge). The
+* kit NEVER rounds; even over-precise parse input is rejected instead
+* of rounded.
+*/
+function assertSameUnit(a, b) {
+	if (a.currency !== b.currency) throw new MoneyCurrencyMismatchError(a.currency, b.currency);
+	if (a.scale !== b.scale) throw new MoneyScaleMismatchError(a.scale, b.scale);
+}
+/**
+* Exact addition of same-currency, same-scale amounts. Mismatches
+* throw (`MONEY_CURRENCY_MISMATCH` / `MONEY_SCALE_MISMATCH`); there is
+* no implicit conversion of either. A result past the amount bound
+* fails as `INVALID_MONEY` instead of wrapping.
+*/
+function addMoney(a, b) {
+	assertSameUnit(a, b);
+	return moneyOfMinor(a.amountMinor + b.amountMinor, a.currency, a.scale);
+}
+/** Exact subtraction under the same guards as {@link addMoney}. */
+function subtractMoney(a, b) {
+	assertSameUnit(a, b);
+	return moneyOfMinor(a.amountMinor - b.amountMinor, a.currency, a.scale);
+}
+/** Exact sign flip; useful for ledger reversals and refunds. */
+function negateMoney(money) {
+	return moneyOfMinor(-money.amountMinor, money.currency, money.scale);
+}
+/**
+* Converts to another scale, LOSSLESSLY or not at all: upscaling and
+* exact downscaling succeed; a downscale that would drop non-zero
+* digits throws `MONEY_PRECISION_LOSS`. There is deliberately no
+* rounding parameter; lossy conversions carry a rounding policy and
+* belong to your calculation library. The intended use is aligning
+* mixed-scale amounts for `addMoney`/`subtractMoney` by upscaling the
+* coarser one.
+*/
+function rescaleMoney(money, scale) {
+	assertValidScale(scale);
+	if (scale === money.scale) return money;
+	if (scale > money.scale) return moneyOfMinor(money.amountMinor * 10n ** BigInt(scale - money.scale), money.currency, scale);
+	const factor = 10n ** BigInt(money.scale - scale);
+	if (money.amountMinor % factor !== 0n) throw new MoneyPrecisionLossError(`rescaling from scale ${money.scale} to ${scale} loses precision; lossy conversions belong to your calculation library, where the rounding policy is explicit`);
+	return moneyOfMinor(money.amountMinor / factor, money.currency, scale);
+}
+
+//#endregion
+//#region src/money/parse.ts
+const DECIMAL_INPUT = /^(-?)(\d+)(?:\.(\d+))?$/;
+const MAX_INPUT_LENGTH = 256;
+/**
+* Parses a plain decimal string ("10.99") into exact minor units,
+* without ever touching floating point. This is the safe replacement
+* for the classic bugs `Number(input) * 100` and `parseFloat`: no
+* exponents, no `Infinity`, no locale separators, and NO rounding; the
+* kit never rounds.
+*
+* EXACT OR REJECTED: missing fraction digits pad losslessly ("10.5" at
+* scale 2 is 1050n) and all-zero excess digits are accepted ("10.990"
+* at scale 2 is 1099n), but input that cannot be represented exactly
+* at the target scale throws `MONEY_PRECISION_LOSS`. Whether "10.999"
+* should be rejected or become 11.00 is a BUSINESS decision, not a
+* parsing feature: put it in a domain-named policy function (a
+* `normalizeQuotedPrice`, a `calculateVat`) that rounds via your
+* calculation library and returns `Money`.
+*
+* The grammar is deliberately strict (`/^-?\d+(\.\d+)?$/`). Locale
+* input ("10,99", grouping, currency signs) is a UI concern; normalize
+* it to this grammar before calling.
+*
+* Takes `unknown` on purpose: this is the trust boundary for raw
+* request values, so callers pass `req.body.amount` directly instead
+* of coercing (`String([...])` silently joins arrays) or casting.
+*/
+function parseMoneyInput(input, options) {
+	const { currency, scale } = options;
+	assertValidScale(scale);
+	if (typeof input !== "string" || input.length > MAX_INPUT_LENGTH) throw new InvalidMoneyError(`money input must be a decimal string of at most ${MAX_INPUT_LENGTH} characters; got ${describeValue(input)}`);
+	const match = DECIMAL_INPUT.exec(input);
+	if (!match) throw new InvalidMoneyError(`money input must be a plain decimal string matching /^-?\\d+(\\.\\d+)?$/; got ${describeValue(input)}`);
+	const sign = match[1] ?? "";
+	const whole = match[2] ?? "";
+	const fraction = match[3] ?? "";
+	if (fraction.length <= scale) return moneyOfMinor(BigInt(sign + whole + fraction.padEnd(scale, "0")), currency, scale);
+	const excess = fraction.slice(scale);
+	if (/^0+$/.test(excess)) return moneyOfMinor(BigInt(sign + whole + fraction.slice(0, scale)), currency, scale);
+	throw new MoneyPrecisionLossError(`parsing ${describeValue(input)} at scale ${scale} would lose precision; accepting over-precise input is a business decision, round it in a domain-named policy function via your calculation library`);
+}
+
+//#endregion
+//#region src/money/factory.ts
+/**
+* Binds a {@link CurrencyScaleResolver} once and returns construction
+* helpers that no longer need an explicit scale per call.
+*
+* @example
+* ```ts
+* const money = createMoneyFactory({
+*   scaleFor: currencyScaleFromRecord({ EUR: 2, JPY: 0 }),
+* });
+* money.parse("10.99", "EUR"); // { amountMinor: 1099n, currency: "EUR", scale: 2 }
+* ```
+*/
+function createMoneyFactory(options) {
+	const { scaleFor } = options;
+	const scaleOf = (currency) => {
+		const scale = scaleFor(currency);
+		if (scale === void 0) throw new UnknownCurrencyError(currency);
+		return scale;
+	};
+	return Object.freeze({
+		ofMinor: (amountMinor, currency) => moneyOfMinor(amountMinor, currency, scaleOf(currency)),
+		parse: (input, currency) => parseMoneyInput(input, {
+			currency,
+			scale: scaleOf(currency)
+		}),
+		zero: (currency) => moneyOfMinor(0n, currency, scaleOf(currency)),
+		scaleOf
+	});
+}
+/**
+* Resolver over a plain currency-to-scale record
+* (`{ EUR: 2, JPY: 0 }`). The record is copied into a `Map` at
+* creation, so later mutation of the input and hostile own keys have
+* no effect.
+*/
+function currencyScaleFromRecord(record) {
+	const scales = new Map(Object.entries(record));
+	return (currency) => scales.get(currency);
+}
+const CANONICAL_ISO_CODE = /^[A-Z]{3}$/;
+/**
+* Resolver backed by the runtime's own currency data (ICU via
+* `Intl.NumberFormat`), so no currency table ships with the kit or the
+* consumer. Resolves ONLY canonical uppercase ISO 4217 codes: Intl
+* itself would accept "eur", but a silent alias would let "eur"-Money
+* and "EUR"-Money circulate side by side until an operation throws
+* `MONEY_CURRENCY_MISMATCH`; here "eur" resolves to `undefined` and
+* fails fast as `UNKNOWN_CURRENCY` at the factory.
+*
+* A CONVENIENCE, not an enterprise source of truth: ICU resolves
+* well-formed but UNASSIGNED codes to its default of 2 rather than
+* `undefined`, and the data shifts with the runtime's ICU version.
+* Production money paths should pin a closed, versioned currency map
+* (`currencyScaleFromRecord`) or a calculation library's versioned
+* currency package; use this resolver for demos, prototypes, and
+* internal tooling.
+*/
+function currencyScaleFromIntl() {
+	const cache = /* @__PURE__ */ new Map();
+	return (currency) => {
+		if (typeof currency !== "string" || !CANONICAL_ISO_CODE.test(currency)) return;
+		if (cache.has(currency)) return cache.get(currency);
+		let scale;
+		try {
+			scale = new Intl.NumberFormat("en", {
+				style: "currency",
+				currency
+			}).resolvedOptions().maximumFractionDigits;
+		} catch {
+			scale = void 0;
+		}
+		if (cache.size < CACHE_LIMIT$1) cache.set(currency, scale);
+		return scale;
+	};
+}
+const CACHE_LIMIT$1 = 1e3;
+
+//#endregion
+//#region src/money/format.ts
+const CACHE_LIMIT = 1e3;
+function formatterFor(locale, currency, scale) {
+	return new Intl.NumberFormat(locale, {
+		style: "currency",
+		currency,
+		minimumFractionDigits: scale,
+		maximumFractionDigits: scale
+	});
+}
+function formatDecimal(formatter, money) {
+	return formatter.format(moneyToDecimalString(money));
+}
+/**
+* Formats for display via `Intl.NumberFormat`, feeding the exact
+* decimal string (never a float), with the money's own scale as the
+* fraction-digit count. Presentation only: the output is
+* locale-dependent text and must never flow back into parsing,
+* storage, or arithmetic. Non-Money input fails loudly with
+* `INVALID_MONEY` before Intl is touched.
+*
+* The currency must be well-formed for `Intl` (ISO alpha-3); for
+* non-ISO codes, format `moneyToDecimalString(money)` yourself.
+*/
+function formatMoney(money, locale) {
+	assertMoney(money);
+	return formatDecimal(formatterFor(locale, money.currency, money.scale), money);
+}
+/**
+* Binds the locale once and caches one `Intl.NumberFormat` per
+* currency/scale pair; constructing formatters is expensive, so use
+* this over `formatMoney` anywhere hot (lists, tables, exports).
+*/
+function createMoneyFormatter(locale) {
+	const formatters = /* @__PURE__ */ new Map();
+	return (money) => {
+		assertMoney(money);
+		const key = `${money.currency}@${money.scale}`;
+		let formatter = formatters.get(key);
+		if (!formatter) {
+			formatter = formatterFor(locale, money.currency, money.scale);
+			if (formatters.size < CACHE_LIMIT) formatters.set(key, formatter);
+		}
+		return formatDecimal(formatter, money);
+	};
+}
+
+//#endregion
+//#region src/money/snapshot.ts
+function toScaleNumber(value, what) {
+	const scale = typeof value === "bigint" ? Number(value) : value;
+	if (typeof scale !== "number" || !Number.isSafeInteger(scale)) throw new InvalidMoneyError(`snapshot ${what} must be an integer; got ${describeValue(value)}`);
+	return scale;
+}
+/**
+* Converts a calculation-library snapshot into canonical {@link Money}.
+* The anti-corruption checks live here so they run exactly once, at
+* the boundary:
+*
+* - non-decimal currencies are rejected (`base` other than 10; some
+*   library currency packages model MGA/MRU with base 5, and pre-1971
+*   GBP with a base array): their minor units do not map onto a
+*   power-of-ten scale
+* - number amounts must be safe integers; fractional or beyond-2^53
+*   amounts are rejected instead of silently corrupted
+* - bigint amounts pass through exactly
+*
+* Takes `unknown` on purpose: this is the trust boundary for foreign
+* library data, so callers never cast before validating (the
+* {@link MoneySnapshotLike} type documents the expected shape).
+*/
+function moneyFromSnapshot(snapshot) {
+	if (snapshot === null || typeof snapshot !== "object") throw new InvalidMoneyError(`money snapshot must be an object; got ${snapshot === null ? "null" : typeof snapshot}`);
+	const { amount, currency, scale } = snapshot;
+	const currencyObject = typeof currency === "string" ? { code: currency } : currency;
+	if (currencyObject === null || typeof currencyObject !== "object") throw new InvalidMoneyError(`snapshot currency must be a code or a currency object; got ${typeof currency}`);
+	const { base } = currencyObject;
+	if (base !== void 0 && base !== 10 && base !== 10n) throw new InvalidMoneyError(`only base-10 currencies map onto Money; got base ${describeValue(base)} for ${describeValue(currencyObject.code)}`);
+	const scaleSource = scale ?? currencyObject.exponent;
+	if (scaleSource === void 0) throw new InvalidMoneyError("money snapshot carries neither a scale nor a currency exponent");
+	return moneyOfMinor(toBigIntAmount(amount), currencyObject.code, toScaleNumber(scaleSource, "scale"));
+}
+function toBigIntAmount(amount) {
+	if (typeof amount === "bigint") return amount;
+	if (typeof amount === "number" && Number.isSafeInteger(amount)) return BigInt(amount);
+	throw new InvalidMoneyError(`snapshot amount must be a bigint or a safe integer; got ${describeValue(amount)}`);
+}
+/**
+* Converts {@link Money} into the snapshot shape the common
+* calculation-library constructors accept. Number-based by design (the
+* libraries' default calculators are), so amounts past
+* `Number.MAX_SAFE_INTEGER` are rejected loudly; wire such amounts
+* into a bigint calculator directly from `money.amountMinor` instead.
+*/
+function moneyToSnapshot(money) {
+	assertMoney(money);
+	const amount = Number(money.amountMinor);
+	if (!Number.isSafeInteger(amount)) throw new InvalidMoneyError(`amountMinor ${money.amountMinor} exceeds Number.MAX_SAFE_INTEGER; use your library's bigint calculator and pass amountMinor directly`);
+	return {
+		amount,
+		currency: {
+			code: money.currency,
+			base: 10,
+			exponent: money.scale
+		},
+		scale: money.scale
+	};
+}
+
+//#endregion
+//#region src/money/try-parse.ts
+/**
+* Result-returning counterparts to the three money boundary parsers,
+* for call sites that process many candidate values in one pass: a
+* CSV import, a batch migration, a message replay. Per-row try/catch
+* reads badly and, hand-rolled, usually catches too much; these
+* wrappers apply the `result-vs-throw` guide's discipline instead.
+*
+* The contract, mirroring `voValidated`: only the parser's DOCUMENTED
+* rejections of the INPUT become `Err`. Anything else, an assertion
+* firing, a typo-ed helper, a genuine bug, keeps propagating as a
+* throw, because a bug wrapped in `Err` is a bug silently counted as
+* a bad input row. That includes the parse OPTIONS: a broken scale
+* resolver is a bug in the caller's wiring, so it is validated
+* eagerly and throws instead of marking every row bad. The `Err`
+* types are exact per parser: the wire parsers reject only with
+* `InvalidMoneyError`, while decimal-string parsing can additionally
+* refuse over-precise input with `MoneyPrecisionLossError`.
+*
+* `Result`, `ok`, and `err` come from `@shirudo/result` (already a
+* peer dependency); import them from there to work with the branches.
+*/
+function tryCatching(parse, isExpected) {
+	try {
+		return ok(parse());
+	} catch (error) {
+		if (isExpected(error)) return err(error);
+		throw error;
+	}
+}
+/**
+* {@link parseMoneyInput} as a `Result`: `Err` for the documented
+* rejections (malformed input as `InvalidMoneyError`, over-precise
+* input as `MoneyPrecisionLossError`), a throw for everything else.
+*/
+function tryParseMoneyInput(input, options) {
+	assertValidScale(options.scale);
+	assertValidCurrency(options.currency);
+	return tryCatching(() => parseMoneyInput(input, options), (error) => error instanceof InvalidMoneyError || error instanceof MoneyPrecisionLossError);
+}
+/**
+* {@link moneyFromDto} as a `Result`: `Err` for the documented
+* rejection (`InvalidMoneyError`), a throw for everything else.
+*/
+function tryMoneyFromDto(dto) {
+	return tryCatching(() => moneyFromDto(dto), (error) => error instanceof InvalidMoneyError);
+}
+/**
+* {@link moneyFromSnapshot} as a `Result`: `Err` for the documented
+* rejection (`InvalidMoneyError`), a throw for everything else.
+*/
+function tryMoneyFromSnapshot(snapshot) {
+	return tryCatching(() => moneyFromSnapshot(snapshot), (error) => error instanceof InvalidMoneyError);
+}
+
+//#endregion
+export { InvalidMoneyError, MoneyCurrencyMismatchError, MoneyPrecisionLossError, MoneyScaleMismatchError, UnknownCurrencyError, addMoney, createMoneyFactory, createMoneyFormatter, currencyScaleFromIntl, currencyScaleFromRecord, formatMoney, isMoney, isNegativeMoney, isPositiveMoney, isZeroMoney, moneyEquals, moneyFromDto, moneyFromSnapshot, moneyFromUnknown, moneyOfMinor, moneyToDecimalString, moneyToDto, moneyToSnapshot, negateMoney, parseMoneyInput, rescaleMoney, subtractMoney, tryMoneyFromDto, tryMoneyFromSnapshot, tryParseMoneyInput };
+//# sourceMappingURL=money.js.map