@amboras-dev/money 0.1.0 → 0.3.0

package/dist/input.d.cts

@@ -1,6 +1,5 @@
-import { L as DecimalText, r as Money, y as FractionDigits } from "./money-CbhsT0fB.cjs";
-import { r as Rate } from "./rate-toyS3EMf.cjs";
-//#region src/input/amount.d.ts
+import { R as DecimalText, b as FractionDigits, i as Money } from "./money-BkMeYDEW.cjs";
+import { r as Rate } from "./rate-CEakW3ia.cjs";
 /** Why typed text is not an acceptable amount. */
 type ParseFailureReason = 'empty' | 'unparseable' | 'too_many_decimals' | 'negative' | 'zero' | 'below_min' | 'above_max';
 interface ParseAmountInputOptions {
@@ -58,17 +57,18 @@ type ParseAmountResult = {
  *   against `,` (see `parseImportAmount`): `'29,99'` EUR is 29.99, `'1.299,00'` and `'1,299'`
  *   are 1299, KWD `'1,5'` is 1.5; a currency storing 0 digits rounds a fraction half-up to a
  *   whole unit (`'1200.5'` JPY is 1201).
- * - With `locale`: its decimal separator is the decimal and its group separator is valid only in
- *   3-digit (or Indian lakh) groups; in a currency that stores no fraction (JPY, VND) a separator
- *   before exactly three digits in grouping position is grouping (`'1.500'` JPY is 1500).
- *   en-US `'29,99'` USD is `'unparseable'`; de-DE `'29,99'` EUR is 29.99; en-US `'1200.5'` JPY
- *   is `'too_many_decimals'`.
+ * - With `locale`: its decimal separator is always the decimal and its group separator is valid
+ *   only in 3-digit (or Indian lakh) groups. In a currency that stores no fraction (JPY, VND) the
+ *   decimal separator before exactly three digits is ambiguous (en-US `'1.234'` JPY could be
+ *   1,234 or 1.234) and is `'too_many_decimals'`, never read as grouping; grouping takes the
+ *   locale's group separator (`'1,234'` en-US, `'1.234'` de-DE). en-US `'29,99'` USD is
+ *   `'unparseable'`; de-DE `'29,99'` EUR is 29.99; en-US `'1200.5'` JPY is `'too_many_decimals'`.
  * - With `decimalSeparator: '.'` (every `<input type="number">`): `.` is the decimal, nothing
  *   groups (`'1,299'` is `'unparseable'`), TND and IQD `'1.500'` are 1.5, and a currency storing
  *   0 digits rounds a fraction half-up to a whole unit (`'1.5'` JPY is 2).
  * Otherwise more fraction digits than the currency stores is `'too_many_decimals'`, never rounded
  * (`'1,2345'` USD). Text equal to `original` returns it unchanged (JPY 120050 shown as
- * `'1200.50'`). An unknown currency, or an `original` in another currency, throws.
+ * `'1200.50'`), except the ambiguous zero-digit text above. An unknown currency, or an `original` in another currency, throws.
  */
 export declare function parseAmountInput(text: string, currency: string, options?: ParseAmountInputOptions): ParseAmountResult;
 /**
@@ -99,8 +99,6 @@ export declare function formatAmountInput(m: Money, options?: {
 export declare function inputStep(currency: string): '1' | '0.01' | '0.001';
 /** The placeholder of a money input: `'0'`, `'0.00'` or `'0.000'`, from the storage digits. */
 export declare function inputPlaceholder(currency: string): '0' | '0.00' | '0.000';
-//#endregion
-//#region src/input/import.d.ts
 interface ImportAmountOptions {
   /**
    * `'auto'` (default): spaces, NBSP, thin spaces and apostrophes are grouping, and the
@@ -142,8 +140,6 @@ export declare function parseDecimalInput(text: string, options: DecimalInputOpt
   ok: false;
   reason: ParseFailureReason;
 };
-//#endregion
-//#region src/input/percent-rate.d.ts
 interface PercentInputOptions {
   /** Inclusive, default 0. */
   min?: number;
@@ -174,8 +170,6 @@ export declare function parsePercentInput(text: string, options?: PercentInputOp
 export declare function parseRateInput(text: string, options?: {
   locale?: string;
 }): Rate | null;
-//#endregion
-//#region src/input/template.d.ts
 interface MoneyTemplate {
   /** Text before the number (`'Rp '`, `'€'`), the sign goes after it. */
   readonly prefix: string;
@@ -199,5 +193,4 @@ export declare function moneyTemplateOf(sample: string): MoneyTemplate;
  * (`moneyTemplateOf('Rp 199.000')` prints IDR 2500050 as `'Rp 25.001'`).
  */
 export declare function formatWithTemplate(m: Money, template: MoneyTemplate): string;
-//#endregion
 export type { DecimalInputOptions, ImportAmountOptions, MoneyTemplate, ParseAmountInputOptions, ParseAmountResult, ParseFailureReason, PercentInputOptions };

package/dist/input.d.ts

@@ -1,6 +1,5 @@
-import { L as DecimalText, r as Money, y as FractionDigits } from "./money-CbhsT0fB.js";
-import { r as Rate } from "./rate-CmeTGNex.js";
-//#region src/input/amount.d.ts
+import { R as DecimalText, b as FractionDigits, i as Money } from "./money-BkMeYDEW.js";
+import { r as Rate } from "./rate-BvvZUdSu.js";
 /** Why typed text is not an acceptable amount. */
 type ParseFailureReason = 'empty' | 'unparseable' | 'too_many_decimals' | 'negative' | 'zero' | 'below_min' | 'above_max';
 interface ParseAmountInputOptions {
@@ -58,17 +57,18 @@ type ParseAmountResult = {
  *   against `,` (see `parseImportAmount`): `'29,99'` EUR is 29.99, `'1.299,00'` and `'1,299'`
  *   are 1299, KWD `'1,5'` is 1.5; a currency storing 0 digits rounds a fraction half-up to a
  *   whole unit (`'1200.5'` JPY is 1201).
- * - With `locale`: its decimal separator is the decimal and its group separator is valid only in
- *   3-digit (or Indian lakh) groups; in a currency that stores no fraction (JPY, VND) a separator
- *   before exactly three digits in grouping position is grouping (`'1.500'` JPY is 1500).
- *   en-US `'29,99'` USD is `'unparseable'`; de-DE `'29,99'` EUR is 29.99; en-US `'1200.5'` JPY
- *   is `'too_many_decimals'`.
+ * - With `locale`: its decimal separator is always the decimal and its group separator is valid
+ *   only in 3-digit (or Indian lakh) groups. In a currency that stores no fraction (JPY, VND) the
+ *   decimal separator before exactly three digits is ambiguous (en-US `'1.234'` JPY could be
+ *   1,234 or 1.234) and is `'too_many_decimals'`, never read as grouping; grouping takes the
+ *   locale's group separator (`'1,234'` en-US, `'1.234'` de-DE). en-US `'29,99'` USD is
+ *   `'unparseable'`; de-DE `'29,99'` EUR is 29.99; en-US `'1200.5'` JPY is `'too_many_decimals'`.
  * - With `decimalSeparator: '.'` (every `<input type="number">`): `.` is the decimal, nothing
  *   groups (`'1,299'` is `'unparseable'`), TND and IQD `'1.500'` are 1.5, and a currency storing
  *   0 digits rounds a fraction half-up to a whole unit (`'1.5'` JPY is 2).
  * Otherwise more fraction digits than the currency stores is `'too_many_decimals'`, never rounded
  * (`'1,2345'` USD). Text equal to `original` returns it unchanged (JPY 120050 shown as
- * `'1200.50'`). An unknown currency, or an `original` in another currency, throws.
+ * `'1200.50'`), except the ambiguous zero-digit text above. An unknown currency, or an `original` in another currency, throws.
  */
 export declare function parseAmountInput(text: string, currency: string, options?: ParseAmountInputOptions): ParseAmountResult;
 /**
@@ -99,8 +99,6 @@ export declare function formatAmountInput(m: Money, options?: {
 export declare function inputStep(currency: string): '1' | '0.01' | '0.001';
 /** The placeholder of a money input: `'0'`, `'0.00'` or `'0.000'`, from the storage digits. */
 export declare function inputPlaceholder(currency: string): '0' | '0.00' | '0.000';
-//#endregion
-//#region src/input/import.d.ts
 interface ImportAmountOptions {
   /**
    * `'auto'` (default): spaces, NBSP, thin spaces and apostrophes are grouping, and the
@@ -142,8 +140,6 @@ export declare function parseDecimalInput(text: string, options: DecimalInputOpt
   ok: false;
   reason: ParseFailureReason;
 };
-//#endregion
-//#region src/input/percent-rate.d.ts
 interface PercentInputOptions {
   /** Inclusive, default 0. */
   min?: number;
@@ -174,8 +170,6 @@ export declare function parsePercentInput(text: string, options?: PercentInputOp
 export declare function parseRateInput(text: string, options?: {
   locale?: string;
 }): Rate | null;
-//#endregion
-//#region src/input/template.d.ts
 interface MoneyTemplate {
   /** Text before the number (`'Rp '`, `'€'`), the sign goes after it. */
   readonly prefix: string;
@@ -199,5 +193,4 @@ export declare function moneyTemplateOf(sample: string): MoneyTemplate;
  * (`moneyTemplateOf('Rp 199.000')` prints IDR 2500050 as `'Rp 25.001'`).
  */
 export declare function formatWithTemplate(m: Money, template: MoneyTemplate): string;
-//#endregion
 export type { DecimalInputOptions, ImportAmountOptions, MoneyTemplate, ParseAmountInputOptions, ParseAmountResult, ParseFailureReason, PercentInputOptions };

package/dist/input.js

@@ -1,8 +1,8 @@
-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
+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-BxbAw7BP.js";
+import { n as readNumberText } from "./number-text-Bj-gZXiF.js";
+import { c as rateFromDecimal, o as rate } from "./rate-D6S2_wgZ.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-DHFOK2Yd.js";
+// 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,
@@ -52,8 +52,7 @@ function parseDecimalInput(text, options) {
 		value: toDecimalText(value)
 	};
 }
-//#endregion
-//#region src/input/percent-rate.ts
+// 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
@@ -102,8 +101,7 @@ function parseRateInput(text, options = {}) {
 		throw error;
 	}
 }
-//#endregion
-//#region src/input/template.ts
+// src/input/template.ts
 const DEFAULT_TEMPLATE = Object.freeze({
 	prefix: "",
 	suffix: "",
@@ -149,5 +147,4 @@ function formatWithTemplate(m, template) {
 	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 → iso-minor-DyNjT9A1.cjs}

@@ -1,5 +1,5 @@
-const require_money = require("./money-D5-vlv0h.cjs");
-//#region src/iso-minor.ts
+const require_money = require("./money-DWBjuuEK.cjs");
+// 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).
@@ -44,7 +44,6 @@ function fromIsoMinor(value, currency, options = {}) {
 	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() {

package/dist/{iso-minor-CtaiIifs.js → iso-minor-odkY-e6I.js}

@@ -1,5 +1,5 @@
-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
+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-BxbAw7BP.js";
+// 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).
@@ -44,5 +44,4 @@ function fromIsoMinor(value, currency, options = {}) {
 	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-OJ2TJOxt.cjs → medusa-CzVK0bth.cjs}

@@ -1,6 +1,6 @@
-const require_money = require("./money-D5-vlv0h.cjs");
-const require_own = require("./own-oP9DXFWv.cjs");
-//#region src/medusa.ts
+const require_money = require("./money-DWBjuuEK.cjs");
+const require_own = require("./own-C5imDkyB.cjs");
+// 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) {
@@ -21,6 +21,21 @@ function readStoredDecimal(raw, options = {}) {
 	throw new require_money.MoneyError("amount_invalid", `Invalid stored amount: ${require_money.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" && require_money.strictNumberDecimal(picked) !== null) literal = String(picked);
+	return literal !== null && require_money.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
@@ -97,7 +112,6 @@ 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() {
@@ -134,6 +148,12 @@ Object.defineProperty(exports, "readStoredField", {
 		return readStoredField;
 	}
 });
+Object.defineProperty(exports, "readStoredLiteral", {
+	enumerable: true,
+	get: function() {
+		return readStoredLiteral;
+	}
+});
 Object.defineProperty(exports, "storedFieldValue", {
 	enumerable: true,
 	get: function() {

package/dist/{medusa-DuQ3-KoD.d.cts → medusa-DofdvIgQ.d.cts}

@@ -1,5 +1,4 @@
-import { L as DecimalText, a as StoredAmount, i as ReadStoredOptions, r as Money } from "./money-CbhsT0fB.cjs";
-//#region src/medusa.d.ts
+import { R as DecimalText, a as ReadStoredOptions, i as Money, o as StoredAmount } from "./money-BkMeYDEW.cjs";
 /**
  * `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`.
@@ -31,6 +30,15 @@ declare function readStoredDecimal(raw: unknown, options?: ReadStoredDecimalOpti
   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
@@ -74,5 +82,4 @@ interface PriceLike {
 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 };
+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-RwqxaDGq.d.ts → medusa-DrbYmD2Y.d.ts}

@@ -1,5 +1,4 @@
-import { L as DecimalText, a as StoredAmount, i as ReadStoredOptions, r as Money } from "./money-CbhsT0fB.js";
-//#region src/medusa.d.ts
+import { R as DecimalText, a as ReadStoredOptions, i as Money, o as StoredAmount } from "./money-BkMeYDEW.js";
 /**
  * `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`.
@@ -31,6 +30,15 @@ declare function readStoredDecimal(raw: unknown, options?: ReadStoredDecimalOpti
   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
@@ -74,5 +82,4 @@ interface PriceLike {
 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 };
+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-CmxCni-G.js → medusa-pKGlImn9.js}

@@ -1,6 +1,6 @@
-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
+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-BxbAw7BP.js";
+import { t as hasOwnKey } from "./own-DHxqIYqL.js";
+// 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) {
@@ -21,6 +21,21 @@ function readStoredDecimal(raw, options = {}) {
 	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
@@ -97,5 +112,4 @@ 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 };
+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 };

package/dist/{money-CbhsT0fB.d.cts → money-BkMeYDEW.d.cts}

@@ -1,4 +1,3 @@
-//#region src/decimal.d.ts
 /**
  * How a value between two representable amounts is resolved. `half-up` rounds a tie away from zero.
  * `floor-after-tenth` is Shopify's discount truncation: round to a tenth of the unit (half-up), then
@@ -10,8 +9,6 @@ declare const DECIMAL_TEXT_BRAND: unique symbol;
 type DecimalText = string & {
   readonly [DECIMAL_TEXT_BRAND]: true;
 };
-//#endregion
-//#region src/registry.d.ts
 declare const CURRENCY_CODE: unique symbol;
 /** An upper-case code this package knows. Obtain one from `currencyCode` or `isCurrencyCode`. */
 type CurrencyCode = string & {
@@ -128,8 +125,6 @@ declare function localeForCurrency(code: string): string;
  * numbers, as Medusa does, so these sites agree with Medusa's own `payment_status`.
  */
 declare function medusaEpsilon(code: string): DecimalText;
-//#endregion
-//#region src/money.d.ts
 declare const STORED_AMOUNT: unique symbol;
 declare const MAJOR_DECIMAL: unique symbol;
 /** An amount in Amboras storage units (major x storageScale): a safe integer. */
@@ -145,6 +140,16 @@ interface Money {
   readonly amount: StoredAmount;
   readonly currency: CurrencyCode;
 }
+/**
+ * A stored amount that may hold a fraction of a storage unit, as Medusa keeps unrounded totals (a
+ * tax line can leave 107.8175): a finite number (a safe integer when whole) or plain decimal text
+ * (`readStoredDecimal`'s result). `Money` is always whole; the PSP codecs and comparators take
+ * either, and `formatStored` formats one.
+ */
+interface FractionalMoney {
+  readonly amount: number | DecimalText;
+  readonly currency: string;
+}
 interface FromMajorOptions {
   /**
    * More fraction digits than the currency stores: `'reject'` (default) throws
@@ -176,6 +181,11 @@ interface ToMajorDecimalOptions {
 interface ReadStoredOptions {
   /** `'strict'` (default) throws `amount_invalid` on a bad amount; `'lenient'` returns null. Never 0. */
   mode?: 'strict' | 'lenient';
+  /**
+   * A fractional stored amount (Medusa's unrounded totals, 107.8175): `'reject'` (default) reads it
+   * as invalid; `'round'` rounds it half-up, exactly, to a whole storage unit (107.8175 gives 108).
+   */
+  precision?: 'reject' | 'round';
   /** Names the input field in errors. */
   field?: string;
 }
@@ -217,8 +227,9 @@ declare function toMajorNumber(m: Money, options?: ToMajorDecimalOptions): numbe
  * A stored amount as Medusa hands it over (a number, a numeric string, a raw
  * `{ value: '4300', precision: 20 }`, a live BigNumber) as Money. Precedence
  * `.value ?? .raw.value ?? .raw_.value`, then `.numeric ?? .numeric_`, then the
- * primitive. `'4300.00'` is accepted; a fractional, non-finite, unsafe or unreadable
- * amount throws `amount_invalid`, or gives null with `mode: 'lenient'` (never 0).
+ * primitive. `'4300.00'` is accepted; a fractional amount is rounded half-up to a whole
+ * storage unit with `precision: 'round'`; otherwise a fractional, non-finite, unsafe or
+ * unreadable amount throws `amount_invalid`, or gives null with `mode: 'lenient'` (never 0).
  * An unknown currency always throws.
  */
 declare function readStored(raw: unknown, currency: string, options: ReadStoredOptions & {
@@ -228,5 +239,4 @@ declare function readStored(raw: unknown, currency: string, options?: ReadStored
   mode?: 'strict';
 }): Money;
 declare function readStored(raw: unknown, currency: string, options?: ReadStoredOptions): Money | null;
-//#endregion
-export { localeForCurrency as A, currencyLabel as C, displayDigits as D, currencySymbol as E, storageDigits as F, storageScale as I, DecimalText as L, medusaEpsilon as M, parseCurrencyCode as N, firstCurrency as O, sameCurrency as P, RoundingMode as R, currencyInfo as S, currencyOptions as T, CurrencyInfo as _, StoredAmount as a, StorageScale as b, fromMajor as c, readStored as d, toMajorDecimal as f, CurrencyCodeOptions as g, CurrencyCode as h, ReadStoredOptions as i, medusaCurrencyCode as j, isCurrencyCode as k, isStoredAmount as l, CURRENCIES as m, MajorDecimal as n, StoredAmountOptions as o, toMajorNumber as p, Money as r, ToMajorDecimalOptions as s, FromMajorOptions as t, money as u, CurrencyStatus as v, currencyName as w, currencyCode as x, FractionDigits as y };
+export { isCurrencyCode as A, currencyInfo as C, currencySymbol as D, currencyOptions as E, sameCurrency as F, storageDigits as I, storageScale as L, medusaCurrencyCode as M, medusaEpsilon as N, displayDigits as O, parseCurrencyCode as P, DecimalText as R, currencyCode as S, currencyName as T, CurrencyCodeOptions as _, ReadStoredOptions as a, FractionDigits as b, ToMajorDecimalOptions as c, money as d, readStored as f, CurrencyCode as g, CURRENCIES as h, Money as i, localeForCurrency as j, firstCurrency as k, fromMajor as l, toMajorNumber as m, FromMajorOptions as n, StoredAmount as o, toMajorDecimal as p, MajorDecimal as r, StoredAmountOptions as s, FractionalMoney as t, isStoredAmount as u, CurrencyInfo as v, currencyLabel as w, StorageScale as x, CurrencyStatus as y, RoundingMode as z };

package/dist/{money-CbhsT0fB.d.ts → money-BkMeYDEW.d.ts}

@@ -1,4 +1,3 @@
-//#region src/decimal.d.ts
 /**
  * How a value between two representable amounts is resolved. `half-up` rounds a tie away from zero.
  * `floor-after-tenth` is Shopify's discount truncation: round to a tenth of the unit (half-up), then
@@ -10,8 +9,6 @@ declare const DECIMAL_TEXT_BRAND: unique symbol;
 type DecimalText = string & {
   readonly [DECIMAL_TEXT_BRAND]: true;
 };
-//#endregion
-//#region src/registry.d.ts
 declare const CURRENCY_CODE: unique symbol;
 /** An upper-case code this package knows. Obtain one from `currencyCode` or `isCurrencyCode`. */
 type CurrencyCode = string & {
@@ -128,8 +125,6 @@ declare function localeForCurrency(code: string): string;
  * numbers, as Medusa does, so these sites agree with Medusa's own `payment_status`.
  */
 declare function medusaEpsilon(code: string): DecimalText;
-//#endregion
-//#region src/money.d.ts
 declare const STORED_AMOUNT: unique symbol;
 declare const MAJOR_DECIMAL: unique symbol;
 /** An amount in Amboras storage units (major x storageScale): a safe integer. */
@@ -145,6 +140,16 @@ interface Money {
   readonly amount: StoredAmount;
   readonly currency: CurrencyCode;
 }
+/**
+ * A stored amount that may hold a fraction of a storage unit, as Medusa keeps unrounded totals (a
+ * tax line can leave 107.8175): a finite number (a safe integer when whole) or plain decimal text
+ * (`readStoredDecimal`'s result). `Money` is always whole; the PSP codecs and comparators take
+ * either, and `formatStored` formats one.
+ */
+interface FractionalMoney {
+  readonly amount: number | DecimalText;
+  readonly currency: string;
+}
 interface FromMajorOptions {
   /**
    * More fraction digits than the currency stores: `'reject'` (default) throws
@@ -176,6 +181,11 @@ interface ToMajorDecimalOptions {
 interface ReadStoredOptions {
   /** `'strict'` (default) throws `amount_invalid` on a bad amount; `'lenient'` returns null. Never 0. */
   mode?: 'strict' | 'lenient';
+  /**
+   * A fractional stored amount (Medusa's unrounded totals, 107.8175): `'reject'` (default) reads it
+   * as invalid; `'round'` rounds it half-up, exactly, to a whole storage unit (107.8175 gives 108).
+   */
+  precision?: 'reject' | 'round';
   /** Names the input field in errors. */
   field?: string;
 }
@@ -217,8 +227,9 @@ declare function toMajorNumber(m: Money, options?: ToMajorDecimalOptions): numbe
  * A stored amount as Medusa hands it over (a number, a numeric string, a raw
  * `{ value: '4300', precision: 20 }`, a live BigNumber) as Money. Precedence
  * `.value ?? .raw.value ?? .raw_.value`, then `.numeric ?? .numeric_`, then the
- * primitive. `'4300.00'` is accepted; a fractional, non-finite, unsafe or unreadable
- * amount throws `amount_invalid`, or gives null with `mode: 'lenient'` (never 0).
+ * primitive. `'4300.00'` is accepted; a fractional amount is rounded half-up to a whole
+ * storage unit with `precision: 'round'`; otherwise a fractional, non-finite, unsafe or
+ * unreadable amount throws `amount_invalid`, or gives null with `mode: 'lenient'` (never 0).
  * An unknown currency always throws.
  */
 declare function readStored(raw: unknown, currency: string, options: ReadStoredOptions & {
@@ -228,5 +239,4 @@ declare function readStored(raw: unknown, currency: string, options?: ReadStored
   mode?: 'strict';
 }): Money;
 declare function readStored(raw: unknown, currency: string, options?: ReadStoredOptions): Money | null;
-//#endregion
-export { localeForCurrency as A, currencyLabel as C, displayDigits as D, currencySymbol as E, storageDigits as F, storageScale as I, DecimalText as L, medusaEpsilon as M, parseCurrencyCode as N, firstCurrency as O, sameCurrency as P, RoundingMode as R, currencyInfo as S, currencyOptions as T, CurrencyInfo as _, StoredAmount as a, StorageScale as b, fromMajor as c, readStored as d, toMajorDecimal as f, CurrencyCodeOptions as g, CurrencyCode as h, ReadStoredOptions as i, medusaCurrencyCode as j, isCurrencyCode as k, isStoredAmount as l, CURRENCIES as m, MajorDecimal as n, StoredAmountOptions as o, toMajorNumber as p, Money as r, ToMajorDecimalOptions as s, FromMajorOptions as t, money as u, CurrencyStatus as v, currencyName as w, currencyCode as x, FractionDigits as y };
+export { isCurrencyCode as A, currencyInfo as C, currencySymbol as D, currencyOptions as E, sameCurrency as F, storageDigits as I, storageScale as L, medusaCurrencyCode as M, medusaEpsilon as N, displayDigits as O, parseCurrencyCode as P, DecimalText as R, currencyCode as S, currencyName as T, CurrencyCodeOptions as _, ReadStoredOptions as a, FractionDigits as b, ToMajorDecimalOptions as c, money as d, readStored as f, CurrencyCode as g, CURRENCIES as h, Money as i, localeForCurrency as j, firstCurrency as k, fromMajor as l, toMajorNumber as m, FromMajorOptions as n, StoredAmount as o, toMajorDecimal as p, MajorDecimal as r, StoredAmountOptions as s, FractionalMoney as t, isStoredAmount as u, CurrencyInfo as v, currencyLabel as w, StorageScale as x, CurrencyStatus as y, RoundingMode as z };

package/dist/{money-CIgELekG.js → money-BxbAw7BP.js}

@@ -137,8 +137,7 @@ function withinFloatNoise(major, digits) {
 function unitsWithin(d, limit) {
 	return (d.units < 0n ? -d.units : d.units) <= limit;
 }
-//#endregion
-//#region src/errors.ts
+// src/errors.ts
 /** The one error this package throws for bad money input. Check `code`, not the message. */
 var MoneyError = class extends Error {
 	constructor(code, message, options = {}) {
@@ -157,8 +156,7 @@ function describeValue(value) {
 		return Object.prototype.toString.call(value);
 	}
 }
-//#endregion
-//#region src/internal/rational.ts
+// src/internal/rational.ts
 /** `a x b / c` rounded by `mode`. `c` must not be zero; its sign is folded into the numerator. */
 function mulDiv(a, b, c, mode) {
 	if (c === 0n) throw new RangeError("mulDiv: division by zero");
@@ -185,8 +183,7 @@ function gcd(a, b) {
 	while (y !== 0n) [x, y] = [y, x % y];
 	return x;
 }
-//#endregion
-//#region src/decimal-text.ts
+// src/decimal-text.ts
 /**
 * Internal: `input` as an exact Decimal. Text must be plain decimal (`'-12.50'`, `'7'`):
 * no blank, whitespace, exponent, hex, `'.5'` or `'1.'` (`parse`). Numbers are taken by
@@ -276,6 +273,18 @@ function decimalRound(a, options) {
 function decimalCompare(a, b) {
 	return compareDecimal(decimalOf(a), decimalOf(b));
 }
+/**
+* Whether `a` and `b` are the same decimal, exactly (`'43.0'` equals `'43.00'` and `43`). Takes what
+* `decimalCompare` takes, but never throws: anything that is not plain decimal text, a finite number
+* or a bigint is never equal, not even to itself.
+*/
+function decimalEquals(a, b) {
+	try {
+		return compareDecimal(decimalOf(a), decimalOf(b)) === 0;
+	} catch {
+		return false;
+	}
+}
 /** `a` limited to `[min, max]` (either bound optional). `min` above `max` throws `amount_invalid`. */
 function decimalClamp(a, bounds) {
 	const value = decimalOf(a);
@@ -296,8 +305,7 @@ function decimalWithin(a, b, tolerance, options = {}) {
 	}, limit);
 	return options.inclusive === false ? gap < 0 : gap <= 0;
 }
-//#endregion
-//#region src/data/currencies.ts
+// src/data/currencies.ts
 const CURRENCY_ROWS = [
 	{
 		code: "AED",
@@ -3215,8 +3223,7 @@ const CURRENCY_ROWS = [
 		commaDecimal: false
 	}
 ];
-//#endregion
-//#region src/internal/intl.ts
+// src/internal/intl.ts
 const DEFAULT_LOCALE = "en-US";
 /**
 * `locale` when the runtime supports it, else `'en-US'`. Blank, malformed or unsupported
@@ -3253,8 +3260,7 @@ function separatorsOf(locale) {
 		group: parts.find((p) => p.type === "group")?.value ?? (decimal === "." ? "," : ".")
 	};
 }
-//#endregion
-//#region src/registry.ts
+// src/registry.ts
 /** Every currency this package knows, active and historic, sorted by code. */
 const CURRENCIES = Object.freeze(CURRENCY_ROWS.map((row) => Object.freeze({
 	...row,
@@ -3413,8 +3419,7 @@ function medusaEpsilon(code) {
 		scale: currencyInfo(code).medusaDigits
 	});
 }
-//#endregion
-//#region src/money.ts
+// src/money.ts
 const MAX_UNITS = 2n ** 46n;
 const anyKnownCurrency = (currency, field) => resolveCurrency(currency, {
 	allowHistoric: true,
@@ -3553,19 +3558,18 @@ function medusaAmountDecimal(raw) {
 	return typeof primitive === "string" ? parseDecimal(primitive) : null;
 }
 const SAFE_LIMIT = BigInt(Number.MAX_SAFE_INTEGER);
-/** A stored integer from Medusa's shapes, or null when it is fractional, unsafe or unreadable. */
-function unwrapStored(raw) {
+/** A stored integer from Medusa's shapes (a fraction rounded half-up with `round`), or null when it is fractional, unsafe or unreadable. */
+function unwrapStored(raw, round) {
 	const parsed = medusaAmountDecimal(raw);
-	if (!parsed || fractionDigitsOf(parsed) !== 0) return null;
-	const whole = roundToScale(parsed, 0, "down");
+	if (!parsed || !round && fractionDigitsOf(parsed) !== 0) return null;
+	const whole = roundToScale(parsed, 0, "half-up");
 	return unitsWithin(whole, SAFE_LIMIT) ? Number(whole.units) : null;
 }
 function readStored(raw, currency, options = {}) {
 	const info = anyKnownCurrency(currency, options.field);
-	const amount = unwrapStored(raw);
+	const amount = unwrapStored(raw, options.precision === "round");
 	if (amount !== null) return storedFrom(amount, info);
 	if (options.mode === "lenient") return null;
 	throw new MoneyError("amount_invalid", `Invalid stored amount: ${describeValue(raw)}`, { field: options.field });
 }
-//#endregion
-export { addDecimal as $, storageScale as A, decimalRound as B, medusaCurrencyCode as C, sameCurrency as D, resolveCurrency as E, decimalClamp as F, parseDecimalText as G, decimalSum as H, decimalCompare as I, gcd as J, trimDecimalZeros as K, decimalDivide as L, resolveLocale as M, separatorsOf as N, storageDigits as O, assertDecimalLiteral as P, describeValue as Q, decimalMultiply as R, localeForCurrency as S, parseCurrencyCode as T, decimalWithin as U, decimalSubtract as V, isDecimalLiteral as W, ratioToDecimal as X, mulDiv as Y, MoneyError as Z, currencySymbol as _, money as a, isPositiveDecimal as at, firstCurrency as b, toMajorDecimal as c, pow10 as ct, currencyCode as d, toDecimalText as dt, compareDecimal as et, currencyInfo as f, currencyOptions as g, currencyName as h, medusaAmountDecimal as i, fractionDigitsOf as it, numberFormat as j, storageExponent as k, toMajorNumber as l, roundToScale as lt, currencyMarks as m, fromMajor as n, divRound as nt, readStored as o, multiplyDecimal as ot, currencyLabel as p, compareRatio as q, isStoredAmount as r, formatDecimal as rt, storedDecimal as s, parseDecimal as st, boundedMoney as t, decimalFromNumber as tt, CURRENCIES as u, strictNumberDecimal as ut, displayDigits as v, medusaEpsilon as w, isCurrencyCode as x, findCurrency as y, decimalOf as z };
+export { describeValue as $, storageScale as A, decimalOf as B, medusaCurrencyCode as C, sameCurrency as D, resolveCurrency as E, decimalClamp as F, isDecimalLiteral as G, decimalSubtract as H, decimalCompare as I, compareRatio as J, parseDecimalText as K, decimalDivide as L, resolveLocale as M, separatorsOf as N, storageDigits as O, assertDecimalLiteral as P, MoneyError as Q, decimalEquals as R, localeForCurrency as S, parseCurrencyCode as T, decimalSum as U, decimalRound as V, decimalWithin as W, mulDiv as X, gcd as Y, ratioToDecimal as Z, currencySymbol as _, money as a, fractionDigitsOf as at, firstCurrency as b, toMajorDecimal as c, normalizeDecimal as ct, currencyCode as d, roundToScale as dt, addDecimal as et, currencyInfo as f, strictNumberDecimal as ft, currencyOptions as g, currencyName as h, medusaAmountDecimal as i, formatDecimal as it, numberFormat as j, storageExponent as k, toMajorNumber as l, parseDecimal as lt, currencyMarks as m, unitsWithin as mt, fromMajor as n, decimalFromNumber as nt, readStored as o, isPositiveDecimal as ot, currencyLabel as p, toDecimalText as pt, trimDecimalZeros as q, isStoredAmount as r, divRound as rt, storedDecimal as s, multiplyDecimal as st, boundedMoney as t, compareDecimal as tt, CURRENCIES as u, pow10 as ut, displayDigits as v, medusaEpsilon as w, isCurrencyCode as x, findCurrency as y, decimalMultiply as z };