@amboras-dev/money 0.0.0-stage → 0.1.0

package/dist/input.js

@@ -0,0 +1,153 @@
+import { Z as MoneyError, dt as toDecimalText, et as compareDecimal, it as fractionDigitsOf, lt as roundToScale, rt as formatDecimal, s as storedDecimal, z as decimalOf } from "./money-CIgELekG.js";
+import { n as readNumberText } from "./number-text-C82oh6JB.js";
+import { c as rateFromDecimal, o as rate } from "./rate-lLPViBuM.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-D7dj76nH.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--gQWI1f2.cjs

@@ -0,0 +1,65 @@
+const require_money = require("./money-D5-vlv0h.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/iso-minor-CtaiIifs.js

@@ -0,0 +1,48 @@
+import { E as resolveCurrency, Q as describeValue, Y as mulDiv, Z as MoneyError, ct as pow10, k as storageExponent, s as storedDecimal, st as parseDecimal, t as boundedMoney } from "./money-CIgELekG.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/medusa-CmxCni-G.js

@@ -0,0 +1,101 @@
+import { D as sameCurrency, E as resolveCurrency, Q as describeValue, Z as MoneyError, a as money, at as isPositiveDecimal, b as firstCurrency, d as currencyCode, dt as toDecimalText, i as medusaAmountDecimal, o as readStored, r as isStoredAmount, s as storedDecimal, z as decimalOf } from "./money-CIgELekG.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 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, toMedusaAmountInput as c, readCalculatedPrice as i, toMedusaRaw as l, moneyByCurrency as n, readStoredField as o, moneyFor as r, storedFieldValue as s, isPositiveAmount as t };

package/dist/medusa-DuQ3-KoD.d.cts

@@ -0,0 +1,78 @@
+import { L as DecimalText, a as StoredAmount, i as ReadStoredOptions, r as Money } from "./money-CbhsT0fB.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 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, toMedusaAmountInput as d, toMedusaRaw as f, ReadStoredDecimalOptions as i, readStoredDecimal as l, MoneyByCurrency as n, moneyByCurrency as o, PriceLike as r, moneyFor as s, MedusaRaw as t, readStoredField as u };

package/dist/medusa-OJ2TJOxt.cjs

@@ -0,0 +1,154 @@
+const require_money = require("./money-D5-vlv0h.cjs");
+const require_own = require("./own-oP9DXFWv.cjs");
+//#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 require_money.readStored(storedFieldValue(row, key), currency, {
+		...options,
+		field: options.field ?? key
+	});
+}
+function readStoredDecimal(raw, options = {}) {
+	const value = require_money.medusaAmountDecimal(raw);
+	if (value && (options.signed !== false || value.units >= 0n)) return require_money.toDecimalText(value);
+	if (options.mode === "lenient") return null;
+	throw new require_money.MoneyError("amount_invalid", `Invalid stored amount: ${require_money.describeValue(raw)}`, { field: options.field });
+}
+/**
+* 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 = require_money.firstCurrency(priced?.currency_code, fallbackCurrency);
+	} catch {
+		return null;
+	}
+	return priced ? readStoredField(priced, "calculated_amount", currency, { mode: "lenient" }) : require_money.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 require_money.MoneyError("amount_invalid", `precision must be a positive integer, got ${require_money.describeValue(precision)}`);
+	let decimal;
+	if (isObject(value)) {
+		require_money.storedDecimal(value);
+		decimal = {
+			units: BigInt(value.amount),
+			scale: 0
+		};
+	} else decimal = require_money.decimalOf(value);
+	return {
+		value: require_money.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) {
+	require_money.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 require_money.MoneyError("amount_invalid", `Expected an object of currency code to stored amount, got ${require_money.describeValue(input)}`);
+	const out = {};
+	for (const key of Object.keys(input)) {
+		const code = require_money.currencyCode(key, { field: key });
+		if (require_own.hasOwnKey(out, code)) throw new require_money.MoneyError("currency_invalid", `${code} is given more than once`, { field: key });
+		const amount = input[key];
+		if (!require_money.isStoredAmount(amount)) throw new require_money.MoneyError("amount_invalid", `Stored amount must be a non-negative safe integer, got ${require_money.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 = require_money.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) && require_money.sameCurrency(p.currency_code, info.code));
+		return row ? require_money.readStored(row.amount, info.code, { field: "amount" }) : null;
+	}
+	const map = source;
+	return require_own.hasOwnKey(map, info.code) ? require_money.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 = require_money.medusaAmountDecimal(raw);
+	return value !== null && require_money.isPositiveDecimal(value);
+}
+//#endregion
+Object.defineProperty(exports, "isPositiveAmount", {
+	enumerable: true,
+	get: function() {
+		return isPositiveAmount;
+	}
+});
+Object.defineProperty(exports, "moneyByCurrency", {
+	enumerable: true,
+	get: function() {
+		return moneyByCurrency;
+	}
+});
+Object.defineProperty(exports, "moneyFor", {
+	enumerable: true,
+	get: function() {
+		return moneyFor;
+	}
+});
+Object.defineProperty(exports, "readCalculatedPrice", {
+	enumerable: true,
+	get: function() {
+		return readCalculatedPrice;
+	}
+});
+Object.defineProperty(exports, "readStoredDecimal", {
+	enumerable: true,
+	get: function() {
+		return readStoredDecimal;
+	}
+});
+Object.defineProperty(exports, "readStoredField", {
+	enumerable: true,
+	get: function() {
+		return readStoredField;
+	}
+});
+Object.defineProperty(exports, "storedFieldValue", {
+	enumerable: true,
+	get: function() {
+		return storedFieldValue;
+	}
+});
+Object.defineProperty(exports, "toMedusaAmountInput", {
+	enumerable: true,
+	get: function() {
+		return toMedusaAmountInput;
+	}
+});
+Object.defineProperty(exports, "toMedusaRaw", {
+	enumerable: true,
+	get: function() {
+		return toMedusaRaw;
+	}
+});