@amboras-dev/money 0.0.0-stage → 0.2.0

package/dist/input.js

@@ -0,0 +1,153 @@
+import { B as decimalOf, Q as MoneyError, at as fractionDigitsOf, dt as roundToScale, it as formatDecimal, pt as toDecimalText, s as storedDecimal, tt as compareDecimal } from "./money-WhnGiI00.js";
+import { n as readNumberText } from "./number-text-DE-q4jO5.js";
+import { c as rateFromDecimal, o as rate } from "./rate-DicStBue.js";
+import { a as inputStep, i as inputPlaceholder, n as formatAmountInput, o as localeSeparators, r as groupDigits, s as parseAmountInput, t as decimalOfText } from "./amount-BoYBMgK9.js";
+//#region src/input/import.ts
+/**
+* Amount text from a file or a third party to canonical DecimalText (major units, exactly as
+* written: `'1.299,00'` gives `'1299'`), or null when it is not an amount (empty, exponent,
+* hex, garbage, negative without `allowNegative`). Never 0 for bad input.
+*/
+function parseImportAmount(text, options = {}) {
+	const read = readNumberText(text, {
+		decimalSeparator: options.decimalSeparator ?? "auto",
+		currency: options.currency,
+		allowTrailingText: options.allowTrailingText
+	});
+	if ("reason" in read || read.sign < 0 && !options.allowNegative) return null;
+	return toDecimalText(decimalOfText(read));
+}
+/**
+* Strict decimal entry: `.` decimal, no grouping, at most `maxDecimals` fraction digits (cost
+* entry at 4, metafields). `'4.5'` gives `'4.5'`, `'.5'` gives `'0.5'`; `'1,000'` is `'unparseable'`.
+*/
+function parseDecimalInput(text, options) {
+	const read = readNumberText(text, {
+		decimalSeparator: ".",
+		groupSeparator: null
+	});
+	if ("reason" in read) return {
+		ok: false,
+		reason: read.reason
+	};
+	const value = decimalOfText(read);
+	if (fractionDigitsOf(value) > options.maxDecimals) return {
+		ok: false,
+		reason: "too_many_decimals"
+	};
+	if (value.units < 0n && !options.allowNegative) return {
+		ok: false,
+		reason: "negative"
+	};
+	if (options.min !== void 0 && compareDecimal(value, decimalOf(options.min)) < 0) return {
+		ok: false,
+		reason: "below_min"
+	};
+	if (options.max !== void 0 && compareDecimal(value, decimalOf(options.max)) > 0) return {
+		ok: false,
+		reason: "above_max"
+	};
+	return {
+		ok: true,
+		value: toDecimalText(value)
+	};
+}
+//#endregion
+//#region src/input/percent-rate.ts
+/**
+* A typed percent (`'20'`, `'12.5'`, `'12,5 %'` in de-DE) as DecimalText. A `%` before or after
+* the number is allowed. Default range 0..100 with 2 decimals; below 0 (with a non-negative
+* `min`) is `'negative'`.
+*/
+function parsePercentInput(text, options = {}) {
+	const bare = typeof text === "string" ? text.trim().replace(/^%\s*|\s*%$/g, "") : text;
+	const read = readNumberText(bare, localeSeparators(options.locale));
+	if ("reason" in read) return {
+		ok: false,
+		reason: read.reason
+	};
+	const value = decimalOfText(read);
+	const min = decimalOf(options.min ?? 0, true, "min");
+	const max = decimalOf(options.max ?? 100, true, "max");
+	if (fractionDigitsOf(value) > (options.maxDecimals ?? 2)) return {
+		ok: false,
+		reason: "too_many_decimals"
+	};
+	if (compareDecimal(value, min) < 0) return {
+		ok: false,
+		reason: value.units < 0n && min.units >= 0n ? "negative" : "below_min"
+	};
+	if (compareDecimal(value, max) > 0) return {
+		ok: false,
+		reason: "above_max"
+	};
+	return {
+		ok: true,
+		value: toDecimalText(value)
+	};
+}
+/**
+* A typed exchange rate ("1 store-currency unit equals this many units") as a precise Rate
+* (`fx.rateFromDecimal(value, { encoding: 'precise' })`), or null when the text is not a
+* positive number or the rate is outside `RATE_BOUNDS` (0.0000001 to 1000000000).
+*/
+function parseRateInput(text, options = {}) {
+	const read = readNumberText(text, localeSeparators(options.locale));
+	if ("reason" in read || read.sign < 0 || read.units === 0n) return null;
+	try {
+		const precise = rateFromDecimal(formatDecimal(decimalOfText(read)), { encoding: "precise" });
+		return rate(precise.numerator, precise.denominator);
+	} catch (error) {
+		if (error instanceof MoneyError && error.code === "rate_invalid") return null;
+		throw error;
+	}
+}
+//#endregion
+//#region src/input/template.ts
+const DEFAULT_TEMPLATE = Object.freeze({
+	prefix: "",
+	suffix: "",
+	fractionDigits: 2,
+	decimalSeparator: ".",
+	groupSeparator: ","
+});
+const NUMBER_RUN = /\d[\d.,'’\s]*\d|\d/u;
+const counterpart = (separator) => separator === "," ? "." : ",";
+/**
+* The print template of one captured literal (cloner `analyzeMoneyFormat`): prefix and suffix
+* around the number, the decimal separator and digit count of its fraction (1 or 2 digits
+* read as 2, 3 as 3, none as 0), the separator it groups thousands with (else the decimal's
+* counterpart), all as the separator engine's `'auto'` rule reads them. A
+* sample with no number gives `{ prefix: '', suffix: '', fractionDigits: 2, '.', ',' }`.
+*/
+function moneyTemplateOf(sample) {
+	const text = typeof sample === "string" ? sample : "";
+	const run = NUMBER_RUN.exec(text);
+	if (!run) return DEFAULT_TEMPLATE;
+	const read = readNumberText(run[0], { decimalSeparator: "auto" });
+	if ("reason" in read) return DEFAULT_TEMPLATE;
+	const decimalSeparator = read.decimalMark ?? counterpart(read.groupMark ?? ",");
+	return Object.freeze({
+		prefix: text.slice(0, run.index),
+		suffix: text.slice(run.index + run[0].length),
+		fractionDigits: read.scale === 0 ? 0 : read.scale === 3 ? 3 : 2,
+		decimalSeparator,
+		groupSeparator: read.groupMark ?? counterpart(decimalSeparator)
+	});
+}
+/**
+* Money printed with a captured template: the exact major amount (stored / storageScale)
+* rounded half-up to the template's digits, grouped, the sign after the prefix
+* (`moneyTemplateOf('Rp 199.000')` prints IDR 2500050 as `'Rp 25.001'`).
+*/
+function formatWithTemplate(m, template) {
+	const { value } = storedDecimal(m);
+	const rounded = formatDecimal(roundToScale(value, template.fractionDigits, "half-up"));
+	const negative = rounded.startsWith("-");
+	const [whole, fraction] = (negative ? rounded.slice(1) : rounded).split(".");
+	const grouped = groupDigits(whole, template.groupSeparator);
+	const tail = fraction === void 0 ? "" : `${template.decimalSeparator}${fraction}`;
+	return `${template.prefix}${negative ? "-" : ""}${grouped}${tail}${template.suffix}`;
+}
+//#endregion
+export { formatAmountInput, formatWithTemplate, inputPlaceholder, inputStep, moneyTemplateOf, parseAmountInput, parseDecimalInput, parseImportAmount, parsePercentInput, parseRateInput };

package/dist/iso-minor-CqkWDxHS.js

@@ -0,0 +1,48 @@
+import { $ as describeValue, E as resolveCurrency, Q as MoneyError, X as mulDiv, k as storageExponent, lt as parseDecimal, s as storedDecimal, t as boundedMoney, ut as pow10 } from "./money-WhnGiI00.js";
+//#region src/iso-minor.ts
+/**
+* Internal: stored units per ISO minor unit at `digits`, `storageScale / 10^digits` (100 for
+* a zero-digit count on a x100 currency, 1 when the digits match the storage exponent).
+* `digits` above the storage exponent has no whole factor and throws `precision`.
+*/
+function isoMinorFactor(info, digits) {
+	if (digits > storageExponent(info)) throw new MoneyError("precision", `${info.code} stores ${storageExponent(info)} implied decimals, fewer than ${digits}`);
+	return BigInt(info.storageScale) / pow10(digits);
+}
+/**
+* ISO minor units at the display digits: `round(major x 10^displayDigits)` with `rounding`
+* (default half-up). JPY 150000 gives 1500, KWD 1005 gives 1005, IQD 10000 gives 10, HUF
+* 435050 gives 4351. Not for payment providers (use `/wire`).
+*/
+function toIsoMinor(m, options = {}) {
+	const { info } = storedDecimal(m);
+	return Number(mulDiv(BigInt(m.amount), 1n, isoMinorFactor(info, info.displayDigits), options.rounding ?? "half-up"));
+}
+/** Integer text as a number (unsafe ones included, refused by the caller), else the text itself. */
+function integerTextValue(text) {
+	const parsed = parseDecimal(text, "integer");
+	return parsed === null ? text : Number(parsed.units);
+}
+/**
+* ISO minor units at the display digits (or `digits`) as Money. The value must be a safe
+* integer (number or integer text). With `digits` above the storage exponent the value must
+* land on a whole storage unit, else `precision`.
+*/
+function fromIsoMinor(value, currency, options = {}) {
+	const info = resolveCurrency(currency, { allowHistoric: true });
+	const integer = typeof value === "string" ? integerTextValue(value) : value;
+	if (typeof integer !== "number" || !Number.isSafeInteger(integer)) throw new MoneyError("amount_invalid", `ISO minor amount must be a safe integer, got ${describeValue(value)}`);
+	const digits = options.digits ?? info.displayDigits;
+	if (![
+		0,
+		2,
+		3
+	].includes(digits)) throw new MoneyError("amount_invalid", `digits must be 0, 2 or 3, got ${describeValue(digits)}`);
+	const exponent = storageExponent(info);
+	if (digits <= exponent) return boundedMoney(BigInt(integer) * isoMinorFactor(info, digits), info);
+	const excess = pow10(digits - exponent);
+	if (BigInt(integer) % excess !== 0n) throw new MoneyError("precision", `${integer} at ${digits} digits is not a whole ${info.code} storage unit`);
+	return boundedMoney(BigInt(integer) / excess, info);
+}
+//#endregion
+export { isoMinorFactor as n, toIsoMinor as r, fromIsoMinor as t };

package/dist/iso-minor-wSwJN57T.cjs

@@ -0,0 +1,65 @@
+const require_money = require("./money-B3wH_Z4S.cjs");
+//#region src/iso-minor.ts
+/**
+* Internal: stored units per ISO minor unit at `digits`, `storageScale / 10^digits` (100 for
+* a zero-digit count on a x100 currency, 1 when the digits match the storage exponent).
+* `digits` above the storage exponent has no whole factor and throws `precision`.
+*/
+function isoMinorFactor(info, digits) {
+	if (digits > require_money.storageExponent(info)) throw new require_money.MoneyError("precision", `${info.code} stores ${require_money.storageExponent(info)} implied decimals, fewer than ${digits}`);
+	return BigInt(info.storageScale) / require_money.pow10(digits);
+}
+/**
+* ISO minor units at the display digits: `round(major x 10^displayDigits)` with `rounding`
+* (default half-up). JPY 150000 gives 1500, KWD 1005 gives 1005, IQD 10000 gives 10, HUF
+* 435050 gives 4351. Not for payment providers (use `/wire`).
+*/
+function toIsoMinor(m, options = {}) {
+	const { info } = require_money.storedDecimal(m);
+	return Number(require_money.mulDiv(BigInt(m.amount), 1n, isoMinorFactor(info, info.displayDigits), options.rounding ?? "half-up"));
+}
+/** Integer text as a number (unsafe ones included, refused by the caller), else the text itself. */
+function integerTextValue(text) {
+	const parsed = require_money.parseDecimal(text, "integer");
+	return parsed === null ? text : Number(parsed.units);
+}
+/**
+* ISO minor units at the display digits (or `digits`) as Money. The value must be a safe
+* integer (number or integer text). With `digits` above the storage exponent the value must
+* land on a whole storage unit, else `precision`.
+*/
+function fromIsoMinor(value, currency, options = {}) {
+	const info = require_money.resolveCurrency(currency, { allowHistoric: true });
+	const integer = typeof value === "string" ? integerTextValue(value) : value;
+	if (typeof integer !== "number" || !Number.isSafeInteger(integer)) throw new require_money.MoneyError("amount_invalid", `ISO minor amount must be a safe integer, got ${require_money.describeValue(value)}`);
+	const digits = options.digits ?? info.displayDigits;
+	if (![
+		0,
+		2,
+		3
+	].includes(digits)) throw new require_money.MoneyError("amount_invalid", `digits must be 0, 2 or 3, got ${require_money.describeValue(digits)}`);
+	const exponent = require_money.storageExponent(info);
+	if (digits <= exponent) return require_money.boundedMoney(BigInt(integer) * isoMinorFactor(info, digits), info);
+	const excess = require_money.pow10(digits - exponent);
+	if (BigInt(integer) % excess !== 0n) throw new require_money.MoneyError("precision", `${integer} at ${digits} digits is not a whole ${info.code} storage unit`);
+	return require_money.boundedMoney(BigInt(integer) / excess, info);
+}
+//#endregion
+Object.defineProperty(exports, "fromIsoMinor", {
+	enumerable: true,
+	get: function() {
+		return fromIsoMinor;
+	}
+});
+Object.defineProperty(exports, "isoMinorFactor", {
+	enumerable: true,
+	get: function() {
+		return isoMinorFactor;
+	}
+});
+Object.defineProperty(exports, "toIsoMinor", {
+	enumerable: true,
+	get: function() {
+		return toIsoMinor;
+	}
+});

package/dist/medusa-4K8N1pUc.d.cts

@@ -0,0 +1,87 @@
+import { R as DecimalText, a as ReadStoredOptions, i as Money, o as StoredAmount } from "./money-B-3aFjNJ.cjs";
+//#region src/medusa.d.ts
+/**
+ * `row['raw_' + key]` when it is not null/undefined (a failure to read it is final: no
+ * fallback to the lossy plain key), else `row[key]`, read like `readStored`.
+ */
+declare function readStoredField(row: unknown, key: string, currency: string, options: ReadStoredOptions & {
+  mode: 'lenient';
+}): Money | null;
+declare function readStoredField(row: unknown, key: string, currency: string, options?: ReadStoredOptions & {
+  mode?: 'strict';
+}): Money;
+declare function readStoredField(row: unknown, key: string, currency: string, options?: ReadStoredOptions): Money | null;
+interface ReadStoredDecimalOptions {
+  /** `'strict'` (default) throws `amount_invalid`; `'lenient'` returns null. Never 0. */
+  mode?: 'strict' | 'lenient';
+  /** Allow negative values. Default true. */
+  signed?: boolean;
+  /** Names the input field in errors. */
+  field?: string;
+}
+/**
+ * Like `readStored` but keeps fractions (Medusa fractional totals, ledger literals) and needs
+ * no currency: the canonical DecimalText (`{ value: '107.81750000000000000000' }` gives
+ * `'107.8175'`). Same shape precedence.
+ */
+declare function readStoredDecimal(raw: unknown, options: ReadStoredDecimalOptions & {
+  mode: 'lenient';
+}): DecimalText | null;
+declare function readStoredDecimal(raw: unknown, options?: ReadStoredDecimalOptions & {
+  mode?: 'strict';
+}): DecimalText;
+declare function readStoredDecimal(raw: unknown, options?: ReadStoredDecimalOptions): DecimalText | null;
+/**
+ * A Medusa amount's literal, verbatim (`'4300.00'` stays `'4300.00'`), for SQL and ledger columns:
+ * `.value ?? .numeric ?? raw` when it is an unsigned decimal literal without leading zeros
+ * (`isDecimalLiteral(text, { leadingZeros: false })`), else null. A number counts only while all
+ * its digits are there (finite; a safe integer when whole) and is spelled `String(n)`. Unlike
+ * `readStoredDecimal` it neither canonicalizes nor reads `.raw.value`, a bigint or a BigNumber's
+ * `valueOf`: the literal is passed on as Medusa holds it.
+ */
+declare function readStoredLiteral(raw: unknown): string | null;
+/**
+ * A variant's `calculated_price` (a number, or an object read through
+ * `raw_calculated_amount` / `calculated_amount`) as Money in
+ * `firstCurrency(calculated_price.currency_code, fallbackCurrency)`. Null on anything
+ * missing or unreadable.
+ */
+declare function readCalculatedPrice(variant: unknown, fallbackCurrency?: string): Money | null;
+/** Medusa's raw amount column shape. */
+interface MedusaRaw {
+  readonly value: string;
+  readonly precision: number;
+}
+/**
+ * `{ value, precision }` for a Medusa raw column: `value` is plain decimal text, never an
+ * exponent (`1e21` gives `'1000000000000000000000'`). NaN and Infinity throw `amount_invalid`.
+ */
+declare function toMedusaRaw(value: Money | DecimalText | number | bigint, precision?: number): MedusaRaw;
+/** A Money for a Medusa amount input: `'0'` for zero (Medusa drops numeric 0 on order-edit updates), else the number. */
+declare function toMedusaAmountInput(m: Money): number | string;
+/** A per-currency setting: upper-case currency code to stored amount. Build one with `moneyByCurrency`. */
+type MoneyByCurrency = {
+  readonly [code: string]: StoredAmount;
+};
+/**
+ * Validates an object of `code -> stored amount` (keys through `currencyCode`, values
+ * non-negative safe integers), upper-cases the keys and freezes it. A key given twice in
+ * different cases throws `currency_invalid`.
+ */
+declare function moneyByCurrency(input: unknown): MoneyByCurrency;
+/** A Medusa price row, or anything shaped like one. */
+interface PriceLike {
+  readonly amount: unknown;
+  readonly currency_code: string;
+  readonly price_list_id?: string | null;
+}
+/**
+ * The amount for `currency` from a MoneyByCurrency or a Medusa price list (base prices only:
+ * rows with a `price_list_id` are skipped). Exact currency match, any case; the amount is read
+ * strictly. Null when there is none.
+ */
+declare function moneyFor(source: MoneyByCurrency | readonly PriceLike[], currency: string): Money | null;
+/** Whether unknown Medusa input holds an amount above zero. `''`, null and garbage are false, never a throw. */
+declare function isPositiveAmount(raw: unknown): boolean;
+//#endregion
+export { isPositiveAmount as a, readCalculatedPrice as c, readStoredLiteral as d, toMedusaAmountInput as f, ReadStoredDecimalOptions as i, readStoredDecimal as l, MoneyByCurrency as n, moneyByCurrency as o, toMedusaRaw as p, PriceLike as r, moneyFor as s, MedusaRaw as t, readStoredField as u };

package/dist/medusa-DBXJXXvF.d.ts

@@ -0,0 +1,87 @@
+import { R as DecimalText, a as ReadStoredOptions, i as Money, o as StoredAmount } from "./money-B-3aFjNJ.js";
+//#region src/medusa.d.ts
+/**
+ * `row['raw_' + key]` when it is not null/undefined (a failure to read it is final: no
+ * fallback to the lossy plain key), else `row[key]`, read like `readStored`.
+ */
+declare function readStoredField(row: unknown, key: string, currency: string, options: ReadStoredOptions & {
+  mode: 'lenient';
+}): Money | null;
+declare function readStoredField(row: unknown, key: string, currency: string, options?: ReadStoredOptions & {
+  mode?: 'strict';
+}): Money;
+declare function readStoredField(row: unknown, key: string, currency: string, options?: ReadStoredOptions): Money | null;
+interface ReadStoredDecimalOptions {
+  /** `'strict'` (default) throws `amount_invalid`; `'lenient'` returns null. Never 0. */
+  mode?: 'strict' | 'lenient';
+  /** Allow negative values. Default true. */
+  signed?: boolean;
+  /** Names the input field in errors. */
+  field?: string;
+}
+/**
+ * Like `readStored` but keeps fractions (Medusa fractional totals, ledger literals) and needs
+ * no currency: the canonical DecimalText (`{ value: '107.81750000000000000000' }` gives
+ * `'107.8175'`). Same shape precedence.
+ */
+declare function readStoredDecimal(raw: unknown, options: ReadStoredDecimalOptions & {
+  mode: 'lenient';
+}): DecimalText | null;
+declare function readStoredDecimal(raw: unknown, options?: ReadStoredDecimalOptions & {
+  mode?: 'strict';
+}): DecimalText;
+declare function readStoredDecimal(raw: unknown, options?: ReadStoredDecimalOptions): DecimalText | null;
+/**
+ * A Medusa amount's literal, verbatim (`'4300.00'` stays `'4300.00'`), for SQL and ledger columns:
+ * `.value ?? .numeric ?? raw` when it is an unsigned decimal literal without leading zeros
+ * (`isDecimalLiteral(text, { leadingZeros: false })`), else null. A number counts only while all
+ * its digits are there (finite; a safe integer when whole) and is spelled `String(n)`. Unlike
+ * `readStoredDecimal` it neither canonicalizes nor reads `.raw.value`, a bigint or a BigNumber's
+ * `valueOf`: the literal is passed on as Medusa holds it.
+ */
+declare function readStoredLiteral(raw: unknown): string | null;
+/**
+ * A variant's `calculated_price` (a number, or an object read through
+ * `raw_calculated_amount` / `calculated_amount`) as Money in
+ * `firstCurrency(calculated_price.currency_code, fallbackCurrency)`. Null on anything
+ * missing or unreadable.
+ */
+declare function readCalculatedPrice(variant: unknown, fallbackCurrency?: string): Money | null;
+/** Medusa's raw amount column shape. */
+interface MedusaRaw {
+  readonly value: string;
+  readonly precision: number;
+}
+/**
+ * `{ value, precision }` for a Medusa raw column: `value` is plain decimal text, never an
+ * exponent (`1e21` gives `'1000000000000000000000'`). NaN and Infinity throw `amount_invalid`.
+ */
+declare function toMedusaRaw(value: Money | DecimalText | number | bigint, precision?: number): MedusaRaw;
+/** A Money for a Medusa amount input: `'0'` for zero (Medusa drops numeric 0 on order-edit updates), else the number. */
+declare function toMedusaAmountInput(m: Money): number | string;
+/** A per-currency setting: upper-case currency code to stored amount. Build one with `moneyByCurrency`. */
+type MoneyByCurrency = {
+  readonly [code: string]: StoredAmount;
+};
+/**
+ * Validates an object of `code -> stored amount` (keys through `currencyCode`, values
+ * non-negative safe integers), upper-cases the keys and freezes it. A key given twice in
+ * different cases throws `currency_invalid`.
+ */
+declare function moneyByCurrency(input: unknown): MoneyByCurrency;
+/** A Medusa price row, or anything shaped like one. */
+interface PriceLike {
+  readonly amount: unknown;
+  readonly currency_code: string;
+  readonly price_list_id?: string | null;
+}
+/**
+ * The amount for `currency` from a MoneyByCurrency or a Medusa price list (base prices only:
+ * rows with a `price_list_id` are skipped). Exact currency match, any case; the amount is read
+ * strictly. Null when there is none.
+ */
+declare function moneyFor(source: MoneyByCurrency | readonly PriceLike[], currency: string): Money | null;
+/** Whether unknown Medusa input holds an amount above zero. `''`, null and garbage are false, never a throw. */
+declare function isPositiveAmount(raw: unknown): boolean;
+//#endregion
+export { isPositiveAmount as a, readCalculatedPrice as c, readStoredLiteral as d, toMedusaAmountInput as f, ReadStoredDecimalOptions as i, readStoredDecimal as l, MoneyByCurrency as n, moneyByCurrency as o, toMedusaRaw as p, PriceLike as r, moneyFor as s, MedusaRaw as t, readStoredField as u };

package/dist/medusa-DqJY1qpj.js

@@ -0,0 +1,116 @@
+import { $ as describeValue, B as decimalOf, D as sameCurrency, E as resolveCurrency, G as isDecimalLiteral, Q as MoneyError, a as money, b as firstCurrency, d as currencyCode, ft as strictNumberDecimal, i as medusaAmountDecimal, o as readStored, ot as isPositiveDecimal, pt as toDecimalText, r as isStoredAmount, s as storedDecimal } from "./money-WhnGiI00.js";
+import { t as hasOwnKey } from "./own-D7544D3k.js";
+//#region src/medusa.ts
+const isObject = (value) => typeof value === "object" && value !== null;
+/** Internal: `row['raw_' + key]` when it is not null/undefined, else `row[key]` (undefined for a non-object row). */
+function storedFieldValue(row, key) {
+	if (!isObject(row)) return void 0;
+	const raw = row[`raw_${key}`];
+	return raw !== null && raw !== void 0 ? raw : row[key];
+}
+function readStoredField(row, key, currency, options = {}) {
+	return readStored(storedFieldValue(row, key), currency, {
+		...options,
+		field: options.field ?? key
+	});
+}
+function readStoredDecimal(raw, options = {}) {
+	const value = medusaAmountDecimal(raw);
+	if (value && (options.signed !== false || value.units >= 0n)) return toDecimalText(value);
+	if (options.mode === "lenient") return null;
+	throw new MoneyError("amount_invalid", `Invalid stored amount: ${describeValue(raw)}`, { field: options.field });
+}
+/**
+* A Medusa amount's literal, verbatim (`'4300.00'` stays `'4300.00'`), for SQL and ledger columns:
+* `.value ?? .numeric ?? raw` when it is an unsigned decimal literal without leading zeros
+* (`isDecimalLiteral(text, { leadingZeros: false })`), else null. A number counts only while all
+* its digits are there (finite; a safe integer when whole) and is spelled `String(n)`. Unlike
+* `readStoredDecimal` it neither canonicalizes nor reads `.raw.value`, a bigint or a BigNumber's
+* `valueOf`: the literal is passed on as Medusa holds it.
+*/
+function readStoredLiteral(raw) {
+	const picked = isObject(raw) ? raw.value ?? raw.numeric ?? raw : raw;
+	let literal = null;
+	if (typeof picked === "string") literal = picked;
+	else if (typeof picked === "number" && strictNumberDecimal(picked) !== null) literal = String(picked);
+	return literal !== null && isDecimalLiteral(literal, { leadingZeros: false }) ? literal : null;
+}
+/**
+* A variant's `calculated_price` (a number, or an object read through
+* `raw_calculated_amount` / `calculated_amount`) as Money in
+* `firstCurrency(calculated_price.currency_code, fallbackCurrency)`. Null on anything
+* missing or unreadable.
+*/
+function readCalculatedPrice(variant, fallbackCurrency) {
+	const price = isObject(variant) ? variant.calculated_price : void 0;
+	const priced = isObject(price) ? price : void 0;
+	let currency;
+	try {
+		currency = firstCurrency(priced?.currency_code, fallbackCurrency);
+	} catch {
+		return null;
+	}
+	return priced ? readStoredField(priced, "calculated_amount", currency, { mode: "lenient" }) : readStored(price, currency, { mode: "lenient" });
+}
+/**
+* `{ value, precision }` for a Medusa raw column: `value` is plain decimal text, never an
+* exponent (`1e21` gives `'1000000000000000000000'`). NaN and Infinity throw `amount_invalid`.
+*/
+function toMedusaRaw(value, precision = 20) {
+	if (!Number.isSafeInteger(precision) || precision < 1) throw new MoneyError("amount_invalid", `precision must be a positive integer, got ${describeValue(precision)}`);
+	let decimal;
+	if (isObject(value)) {
+		storedDecimal(value);
+		decimal = {
+			units: BigInt(value.amount),
+			scale: 0
+		};
+	} else decimal = decimalOf(value);
+	return {
+		value: toDecimalText(decimal),
+		precision
+	};
+}
+/** A Money for a Medusa amount input: `'0'` for zero (Medusa drops numeric 0 on order-edit updates), else the number. */
+function toMedusaAmountInput(m) {
+	storedDecimal(m);
+	return m.amount === 0 ? "0" : m.amount;
+}
+/**
+* Validates an object of `code -> stored amount` (keys through `currencyCode`, values
+* non-negative safe integers), upper-cases the keys and freezes it. A key given twice in
+* different cases throws `currency_invalid`.
+*/
+function moneyByCurrency(input) {
+	if (!isObject(input) || Array.isArray(input)) throw new MoneyError("amount_invalid", `Expected an object of currency code to stored amount, got ${describeValue(input)}`);
+	const out = {};
+	for (const key of Object.keys(input)) {
+		const code = currencyCode(key, { field: key });
+		if (hasOwnKey(out, code)) throw new MoneyError("currency_invalid", `${code} is given more than once`, { field: key });
+		const amount = input[key];
+		if (!isStoredAmount(amount)) throw new MoneyError("amount_invalid", `Stored amount must be a non-negative safe integer, got ${describeValue(amount)}`, { field: key });
+		out[code] = amount === 0 ? 0 : amount;
+	}
+	return Object.freeze(out);
+}
+/**
+* The amount for `currency` from a MoneyByCurrency or a Medusa price list (base prices only:
+* rows with a `price_list_id` are skipped). Exact currency match, any case; the amount is read
+* strictly. Null when there is none.
+*/
+function moneyFor(source, currency) {
+	const info = resolveCurrency(currency, { allowHistoric: true });
+	if (Array.isArray(source)) {
+		const row = source.find((p) => isObject(p) && (p.price_list_id === null || p.price_list_id === void 0) && sameCurrency(p.currency_code, info.code));
+		return row ? readStored(row.amount, info.code, { field: "amount" }) : null;
+	}
+	const map = source;
+	return hasOwnKey(map, info.code) ? money(map[info.code], info.code) : null;
+}
+/** Whether unknown Medusa input holds an amount above zero. `''`, null and garbage are false, never a throw. */
+function isPositiveAmount(raw) {
+	const value = medusaAmountDecimal(raw);
+	return value !== null && isPositiveDecimal(value);
+}
+//#endregion
+export { readStoredDecimal as a, storedFieldValue as c, readCalculatedPrice as i, toMedusaAmountInput as l, moneyByCurrency as n, readStoredField as o, moneyFor as r, readStoredLiteral as s, isPositiveAmount as t, toMedusaRaw as u };