@eriveltondasilva/currency 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,526 @@
+/**
+ * @ERIVELTONDASILVA/CURRENCY v1.0.0
+ *
+ * A lightweight and reliable JavaScript library for precise currency operations, built to safely handle monetary values without floating point errors.
+ *
+ * @author Erivelton Silva <eriveltondasilva13@gmail.com>
+ * @license MIT
+ * @copyright 2026 Erivelton Silva
+ * @version 1.0.0
+ *
+ * @see https://github.com/eriveltondasilva/currency#readme - Documentation
+ *
+ * Inspired by:
+ * @see https://github.com/scurker/currency.js
+ */
+
+import { M as MoneyInput, C as CountryCode, P as PricedItem, a as MoneyContract, R as RoundingMode } from './types-BX9n6pbS.js';
+export { F as FormatOptions } from './types-BX9n6pbS.js';
+
+/**
+ * Computes the total cost of a list of priced items.
+ *
+ * Each item must have a `price` (`number` in major units or `MoneyContract`)
+ * and an optional `quantity` (non-negative integer, defaults to `1`).
+ * Returns `zero(country)` when `items` is empty.
+ *
+ * @param items - Array of `{ price, quantity? }` objects. See {@link PricedItem}.
+ * @param country - Supported country code that defines the output currency.
+ *
+ * @returns A new `MoneyContract` with the total amount.
+ *
+ * @throws `InvalidInputError` - when any item is not a plain object, or `quantity` is not a non-negative integer.
+ * @throws `CurrencyMismatchError` - when any `price` is a `MoneyContract` with a different currency.
+ * @throws `UnsupportedCurrencyError` - when `country` is not a supported code.
+ * @throws `UnsafeIntegerError` - when the accumulated total exceeds `Number.MAX_SAFE_INTEGER`.
+ *
+ * @example
+ * const items = [
+ *   { price: 29.90, quantity: 2 },
+ *   { price: 9.99 },
+ * ];
+ *
+ * total(items, 'BR').format()
+ * // => 'R$ 69,79'
+ */
+declare function total(items: PricedItem[], country: CountryCode): MoneyContract;
+/**
+ * Calculates what percentage `portion` represents of `base`.
+ *
+ * Both arguments are resolved to minor units before division, ensuring
+ * precision. The result is a plain `number`, not a `MoneyContract`.
+ *
+ * @param value - The partial amount (numerator).
+ * @param total - The reference amount (denominator). Must be non-zero.
+ * @param country - Supported country code used to resolve both amounts.
+ *
+ * @returns The percentage as a `number` (e.g. `25` for 25%).
+ *
+ * @throws `DivisionByZeroError` - when `base` resolves to zero.
+ * @throws `CurrencyMismatchError` - when either argument is a `MoneyContract` with a different currency.
+ * @throws `UnsupportedCurrencyError` - when `country` is not a supported code.
+ *
+ * @example
+ * percent(25, 200, 'US') // => 12.5
+ * percent(1, 3, 'BR')    // => 33.333...
+ */
+declare function percent(value: MoneyInput, total: MoneyInput, country: CountryCode): number;
+
+/**
+ * Sums an array of monetary values.
+ *
+ * Returns `zero(country)` when `values` is empty.
+ * All values must share the same currency as `country` — passing a
+ * `MoneyContract` with a different currency throws `CurrencyMismatchError`.
+ *
+ * @param values - Array of amounts as numbers (major units) or `MoneyContract` instances.
+ * @param country - Supported country code that defines the output currency.
+ *
+ * @returns A new `MoneyContract` with the total sum.
+ *
+ * @throws `CurrencyMismatchError` - when any `MoneyContract` in `values` has a different currency.
+ * @throws `UnsupportedCurrencyError` - when `country` is not a supported code.
+ * @throws `UnsafeIntegerError` - when the accumulated sum exceeds `Number.MAX_SAFE_INTEGER`.
+ *
+ * @example
+ * sum([10, 20.50, 5], 'BR').format() // => 'R$ 35,50'
+ * sum([], 'US').isZero()             // => true
+ */
+declare function sum(values: MoneyInput[], country: CountryCode): MoneyContract;
+/**
+ * Computes the arithmetic mean of an array of monetary values.
+ *
+ * The result is rounded to the nearest minor unit using `'halfExpand'`.
+ * Returns `zero(country)` when `values` is empty.
+ *
+ * @param values - Array of amounts as numbers (major units) or `MoneyContract` instances.
+ * @param country - Supported country code that defines the output currency.
+ *
+ * @returns A new `MoneyContract` with the average amount.
+ *
+ * @throws `CurrencyMismatchError` - when any `MoneyContract` in `values` has a different currency.
+ * @throws `UnsupportedCurrencyError` - when `country` is not a supported code.
+ *
+ * @example
+ * average([10, 20, 30], 'US').amount() // => 20
+ * average([1, 2], 'BR').amount()       // => 1.5
+ */
+declare function average(values: MoneyInput[], country: CountryCode, roundingMode?: RoundingMode): MoneyContract;
+/**
+ * Returns the largest value in an array of monetary values.
+ *
+ * Unlike {@link sum} and {@link average}, `max` requires at least one element.
+ *
+ * @param values - Non-empty array of amounts as numbers (major units) or `MoneyContract` instances.
+ * @param country - Supported country code that defines the output currency.
+ *
+ * @returns A new `MoneyContract` representing the maximum amount.
+ *
+ * @throws `InvalidInputError` - when `values` is empty.
+ * @throws `CurrencyMismatchError` - when any `MoneyContract` in `values` has a different currency.
+ * @throws `UnsupportedCurrencyError` - when `country` is not a supported code.
+ *
+ * @example
+ * max([5, 30, 10], 'US').amount() // => 30
+ */
+declare function max(values: MoneyInput[], country: CountryCode): MoneyContract;
+/**
+ * Returns the smallest value in an array of monetary values.
+ *
+ * Unlike {@link sum} and {@link average}, `min` requires at least one element.
+ *
+ * @param values - Non-empty array of amounts as numbers (major units) or `MoneyContract` instances.
+ * @param country - Supported country code that defines the output currency.
+ *
+ * @returns A new `MoneyContract` representing the minimum amount.
+ *
+ * @throws `InvalidInputError` - when `values` is empty.
+ * @throws `CurrencyMismatchError` - when any `MoneyContract` in `values` has a different currency.
+ * @throws `UnsupportedCurrencyError` - when `country` is not a supported code.
+ *
+ * @example
+ * min([5, 30, 10], 'US').amount() // => 5
+ */
+declare function min(values: MoneyInput[], country: CountryCode): MoneyContract;
+/**
+ * Constrains a monetary value within a `[min, max]` closed interval.
+ *
+ * - When `value < min`, returns `min`.
+ * - When `value > max`, returns `max`.
+ * - Otherwise, returns `value` unchanged.
+ *
+ * @param value - The amount to constrain.
+ * @param min - Lower bound of the interval.
+ * @param max - Upper bound of the interval.
+ * @param country - Supported country code that defines the output currency.
+ *
+ * @returns A new `MoneyContract` clamped within `[min, max]`.
+ *
+ * @throws `InvalidRangeError` - when `min` is greater than `max`.
+ * @throws `CurrencyMismatchError` - when any `MoneyContract` argument has a different currency.
+ * @throws `UnsupportedCurrencyError` - when `country` is not a supported code.
+ *
+ * @example
+ * clamp(150, 0, 100, 'US').amount() // => 100
+ * clamp(-10, 0, 100, 'US').amount() // => 0
+ * clamp(50, 0, 100, 'US').amount()  // => 50
+ */
+declare function clamp(value: MoneyInput, min: MoneyInput, max: MoneyInput, country: CountryCode): MoneyContract;
+
+/**
+ * Creates a `MoneyContract` from a `number` in major units.
+ *
+ * The value is converted to minor units internally using the currency's
+ * `fractionDigits`. Rounding is applied with `'halfExpand'` when the
+ * conversion produces a non-integer result.
+ *
+ * Also exported as `money` for more expressive usage.
+ *
+ * @param value - Amount in major units (e.g. `19.99`).
+ * @param country - Supported country code (e.g. `'BR'`, `'US'`).
+ *
+ * @returns A new `MoneyContract` instance.
+ *
+ * @throws `InvalidInputError` - when `value` is not a finite number, is null/undefined, or exceeds the safe integer range after conversion to minor units.
+ * @throws `UnsupportedCurrencyError` - when `country` is not a supported code.
+ *
+ * @example
+ * from(19.99, 'BR').format() // => 'R$ 19,99'
+ * from(0, 'US').isZero()     // => true
+ */
+declare function from(value: number, country: CountryCode): MoneyContract;
+/**
+ * Creates a `MoneyContract` by parsing a locale-formatted currency string.
+ *
+ * The string is parsed according to the country's decimal and grouping
+ * separators. Currency symbols and unknown characters are stripped before
+ * parsing.
+ *
+ * @param value - A locale-formatted string (e.g. `'R$ 1.999,99'`, `'1,999.99'`).
+ * @param country - Supported country code that defines the decimal/grouping separators.
+ *
+ * @returns A new `MoneyContract` instance.
+ *
+ * @throws `InvalidInputError` - when `value` is not a string, cannot be parsed as a monetary amount, or contains multiple decimal separators.
+ * @throws `UnsupportedCurrencyError` - when `country` is not a supported code.
+ *
+ * @example
+ * parse('R$ 1.999,99', 'BR').amount() // => 1999.99
+ * parse('$1,999.99', 'US').amount()   // => 1999.99
+ */
+declare function parse(value: string, country: CountryCode): MoneyContract;
+/**
+ * Creates a `MoneyContract` directly from an integer in minor units.
+ *
+ * Use this when the value is already in minor units — for example, when
+ * reconstructing from a database or a {@link MoneyContract.toJSON} payload.
+ *
+ * @param value - Integer minor-unit value (e.g. `1999` for R$ 19,99).
+ * @param country - Supported country code.
+ *
+ * @returns A new `MoneyContract` instance.
+ *
+ * @throws `InvalidInputError` - when `value` is not a finite integer or exceeds `Number.MAX_SAFE_INTEGER`.
+ * @throws `UnsupportedCurrencyError` - when `country` is not a supported code.
+ *
+ * @example
+ * fromMinorUnits(1999, 'BR').amount() // => 19.99
+ * fromMinorUnits(500, 'JP').amount()  // => 500  (JPY has 0 fraction digits)
+ */
+declare function fromMinorUnits(value: number, country: CountryCode): MoneyContract;
+/**
+ * Creates a `MoneyContract` with an amount of zero for the given country.
+ * Useful as an identity value for reductions or as a neutral starting point.
+ *
+ * @param country - Supported country code.
+ *
+ * @returns A new `MoneyContract` with `minorUnits === 0`.
+ *
+ * @throws `UnsupportedCurrencyError` - when `country` is not a supported code.
+ *
+ * @example
+ * zero('BR').isZero()       // => true
+ * zero('BR').format()       // => 'R$ 0,00'
+ * zero('US').currencyCode() // => 'USD'
+ */
+declare function zero(country: CountryCode): MoneyContract;
+
+/**
+ * Returns `true` if `value` is a `MoneyContract` instance.
+ *
+ * Use this as a type guard to distinguish `MoneyContract` from plain `number`
+ * when handling {@link MoneyInput}.
+ *
+ * @param value — Any value to test.
+ * @returns `true` when `value` is an instance of `Money`.
+ *
+ * @example
+ * isMoney(from(10, 'BR')) // => true
+ * isMoney(10)             // => false
+ * isMoney(null)           // => false
+ */
+declare function isMoney(value: unknown): value is MoneyContract;
+/**
+ * Returns `true` if `value` is a valid {@link MoneyInput} — either a `number`
+ * or a `MoneyContract` instance.
+ *
+ * Use this to validate external inputs before passing them to API functions
+ * that accept `MoneyInput`.
+ *
+ * @param value — Any value to test.
+ * @returns `true` when `value` is a `number` or a `MoneyContract` instance.
+ *
+ * @example
+ * isMoneyInput(19.99)          // => true
+ * isMoneyInput(from(10, 'BR')) // => true
+ * isMoneyInput('19.99')        // => false
+ * isMoneyInput(null)           // => false
+ */
+declare function isMoneyInput(value: unknown): value is number | MoneyContract;
+
+declare const api_average: typeof average;
+declare const api_clamp: typeof clamp;
+declare const api_from: typeof from;
+declare const api_fromMinorUnits: typeof fromMinorUnits;
+declare const api_isMoney: typeof isMoney;
+declare const api_isMoneyInput: typeof isMoneyInput;
+declare const api_max: typeof max;
+declare const api_min: typeof min;
+declare const api_parse: typeof parse;
+declare const api_percent: typeof percent;
+declare const api_sum: typeof sum;
+declare const api_total: typeof total;
+declare const api_zero: typeof zero;
+declare namespace api {
+  export { api_average as average, api_clamp as clamp, api_from as from, api_fromMinorUnits as fromMinorUnits, api_isMoney as isMoney, api_isMoneyInput as isMoneyInput, api_max as max, api_min as min, api_parse as parse, api_percent as percent, api_sum as sum, api_total as total, api_zero as zero };
+}
+
+/**
+ * Discriminant union of all error codes produced by this library.
+ * Available on every {@link MoneyError} instance via the `code` property,
+ * enabling exhaustive error handling without `instanceof` checks.
+ *
+ * @example
+ * try {
+ *   from(10, 'BR').divide(0)
+ * } catch (err) {
+ *   if (err instanceof MoneyError) {
+ *     switch (err.code) {
+ *       case 'DIVISION_BY_ZERO': // handle
+ *     }
+ *   }
+ * }
+ */
+type MoneyErrorCode = 'INVALID_INPUT' | 'INVALID_PERCENTAGE' | 'DIVISION_BY_ZERO' | 'INVALID_ALLOCATION' | 'INVALID_RANGE' | 'CURRENCY_MISMATCH' | 'UNSUPPORTED_CURRENCY' | 'UNSAFE_INTEGER';
+/**
+ * Options accepted by {@link MoneyError} and its subclasses.
+ * Extends the native `ErrorOptions` (which includes `cause`).
+ */
+interface MoneyErrorOptions extends ErrorOptions {
+    input?: unknown;
+}
+/**
+ * Base class for all errors thrown by this library.
+ *
+ * Extends the native `Error` with two additional properties:
+ * - `code` — a machine-readable {@link MoneyErrorCode} for programmatic handling.
+ * - `input` — the offending value, when available, for easier debugging.
+ *
+ * Use `instanceof MoneyError` to catch any library error in a single branch,
+ * or check `error.code` to distinguish between specific cases.
+ *
+ * @example
+ * import { MoneyError } from '@eriveltondasilva/currency'
+ *
+ * try {
+ *   from(10, 'BR').plus(from(10, 'US'))
+ * } catch (err) {
+ *   if (err instanceof MoneyError) {
+ *     console.error(err.code, err.message)
+ *   }
+ * }
+ */
+declare abstract class MoneyError extends Error {
+    abstract name: string;
+    readonly code: MoneyErrorCode;
+    readonly input?: unknown;
+    constructor(message: string, code: MoneyErrorCode, options?: MoneyErrorOptions);
+}
+/**
+ * Thrown when a value fails basic input validation — wrong type, non-finite
+ * number, unsafe integer, or a value that cannot be parsed as a monetary amount.
+ *
+ * `code`: `'INVALID_INPUT'`
+ */
+declare class InvalidInputError extends MoneyError {
+    readonly name = "InvalidInputError";
+    constructor(message: string, options?: MoneyErrorOptions);
+}
+/**
+ * Thrown when a percentage or discount/surcharge value is invalid —
+ * negative, non-finite, or out of the expected range.
+ *
+ * `code`: `'INVALID_PERCENTAGE'`
+ */
+declare class InvalidPercentageError extends MoneyError {
+    readonly name = "InvalidPercentageError";
+    constructor(message: string, options?: MoneyErrorOptions);
+}
+/**
+ * Thrown when a division or percentage operation is attempted with a
+ * denominator of zero.
+ *
+ * `code`: `'DIVISION_BY_ZERO'`
+ *
+ * @example
+ * from(10, 'US').divide(0) // throws DivisionByZeroError
+ * percent(5, 0, 'US')      // throws DivisionByZeroError
+ */
+declare class DivisionByZeroError extends MoneyError {
+    readonly name = "DivisionByZeroError";
+    constructor(options?: MoneyErrorOptions);
+}
+/**
+ * Thrown when arguments passed to {@link MoneyContract.allocate} or
+ * {@link MoneyContract.allocateByRatio} are invalid — non-integer parts,
+ * negative ratios, zero-sum ratios, or an empty ratio array.
+ *
+ * `code`: `'INVALID_ALLOCATION'`
+ */
+declare class InvalidAllocationError extends MoneyError {
+    readonly name = "InvalidAllocationError";
+    constructor(message: string, options?: MoneyErrorOptions);
+}
+/**
+ * Thrown when a `min` value is greater than a `max` value in range-based
+ * operations such as {@link MoneyContract.isBetween} or `clamp`.
+ *
+ * `code`: `'INVALID_RANGE'`
+ *
+ * @example
+ * from(5, 'US').isBetween(10, 1) // throws InvalidRangeError
+ */
+declare class InvalidRangeError extends MoneyError {
+    readonly name = "InvalidRangeError";
+    constructor(options?: MoneyErrorOptions);
+}
+/**
+ * Thrown when an operation is attempted between two `MoneyContract` instances
+ * with different currency codes.
+ *
+ * `code`: `'CURRENCY_MISMATCH'`
+ *
+ * @example
+ * from(10, 'BR').plus(from(10, 'US')) // throws CurrencyMismatchError
+ */
+declare class CurrencyMismatchError extends MoneyError {
+    readonly name = "CurrencyMismatchError";
+    constructor(baseCode: string, otherCode: string, options?: MoneyErrorOptions);
+}
+/**
+ * Thrown when an unsupported country code is passed to any API function.
+ *
+ * `code`: `'UNSUPPORTED_CURRENCY'`
+ *
+ * @example
+ * from(10, 'XX' as any) // throws UnsupportedCurrencyError
+ */
+declare class UnsupportedCurrencyError extends MoneyError {
+    readonly name = "UnsupportedCurrencyError";
+    constructor(country: string, supportedCodes: string, options?: MoneyErrorOptions);
+}
+/**
+ * Thrown when an arithmetic operation produces a result that exceeds
+ * `Number.MAX_SAFE_INTEGER`, which would compromise integer precision
+ * in minor-unit calculations.
+ *
+ * `code`: `'UNSAFE_INTEGER'`
+ */
+declare class UnsafeIntegerError extends MoneyError {
+    readonly name = "UnsafeIntegerError";
+    constructor(options?: MoneyErrorOptions);
+}
+
+/**
+ * @module @eriveltondasilva/currency
+ *
+ * # A lightweight TypeScript library for precise monetary operations.
+ *
+ * All values are stored internally as **minor-unit integers** to eliminate
+ * floating-point errors. Every operation returns a new instance — the API
+ * is fully immutable.
+ *
+ * ## Quick start
+ *
+ * @example
+ * import { from, sum, total } from '@eriveltondasilva/currency'
+ *
+ * const price = from(19.99, 'BR')
+ * price.format()                   // => 'R$ 19,99'
+ * price.applyDiscount(10).format() // => 'R$ 17,99'
+ *
+ * sum([10, 20, 30], 'US').format() // => '$60.00'
+ *
+ * const items = [
+ *   { price: 9.99, quantity: 3 },
+ *   { price: 4.99 },
+ * ]
+ * total(items, 'US').format()
+ * // => '$34.96'
+ *
+ * ## Preset shorthand (optional import)
+ *
+ * @example
+ * import { br, us } from '@eriveltondasilva/currency/presets'
+ *
+ * br(19.99).format() // => 'R$ 19,99'
+ * us(9.99).format()  // => '$9.99'
+ *
+ * ## Supported countries
+ *
+ * `AU`, `BR`, `CA`, `CH`, `CN`, `DE`, `FR`, `GB`, `IN`, `JP`, `MX`, `PT`, `SG`, `US`
+ */
+
+/**
+ * Frozen namespace that exposes the full library API as a single object.
+ * Useful when a single import is preferred over named imports.
+ *
+ * @remarks
+ * Prefer named imports over this namespace for better tree-shaking.
+ *
+ * ```ts
+ * // ✅ Only `from` and `format` are bundled
+ * import { from } from '@eriveltondasilva/currency'
+ *
+ * // ⚠️  Entire library is bundled
+ * import Money from '@eriveltondasilva/currency'
+ * ```
+ *
+ * @example
+ * import Money from '@eriveltondasilva/currency'
+ *
+ * // Creation
+ * Money.from(19.99, 'BR').format()          // => 'R$ 19,99'
+ * Money.fromMinorUnits(2000, 'BR').format() // => 'R$ 20,00'
+ * Money.parse('$20.00', 'US').format()      // => '$20.00'
+ * Money.zero('US').format()                 // => '$0.00'
+ *
+ * // Collection
+ * Money.average([10, 20], 'US').format() // => '$15.00'
+ * Money.clamp(100, 1, 20, 'US').format() // => '$20.00'
+ * Money.max([10, 20], 'US').format()     // => '$20.00'
+ * Money.min([10, 20], 'US').format()     // => '$10.00'
+ * Money.sum([10, 20, 30], 'US').format() // => '$60.00'
+ *
+ * // Business
+ * Money.percent(10, 200, 'US') // => 5
+ * Money.total([{ price: 5, quantity: 2 }], 'US').format()
+ * // => '$10.00'
+ *
+ * // Utils
+ * Money.isMoney(Money.from(19.99, 'BR'))      // => true
+ * Money.isMoneyInput(Money.from(19.99, 'BR')) // => true
+ */
+declare const Money: typeof api;
+
+export { CurrencyMismatchError, DivisionByZeroError, InvalidAllocationError, InvalidInputError, InvalidPercentageError, InvalidRangeError, Money, MoneyContract, MoneyError, MoneyInput, PricedItem, RoundingMode, UnsafeIntegerError, UnsupportedCurrencyError, average, clamp, Money as default, from, fromMinorUnits, parse as fromString, isMoney, isMoneyInput, max, min, from as money, parse, percent, sum, total, zero };

package/dist/index.js

@@ -0,0 +1,17 @@
+import {w}from'./chunk-5VVSCRNB.js';export{g as CurrencyMismatchError,d as DivisionByZeroError,e as InvalidAllocationError,b as InvalidInputError,c as InvalidPercentageError,f as InvalidRangeError,a as MoneyError,i as UnsafeIntegerError,h as UnsupportedCurrencyError,s as average,v as clamp,l as from,n as fromMinorUnits,m as fromString,j as isMoney,k as isMoneyInput,t as max,u as min,l as money,m as parse,q as percent,r as sum,p as total,o as zero}from'./chunk-5VVSCRNB.js';/**
+ * @ERIVELTONDASILVA/CURRENCY v1.0.0
+ *
+ * A lightweight and reliable JavaScript library for precise currency operations, built to safely handle monetary values without floating point errors.
+ *
+ * @author Erivelton Silva <eriveltondasilva13@gmail.com>
+ * @license MIT
+ * @copyright 2026 Erivelton Silva
+ * @version 1.0.0
+ *
+ * @see https://github.com/eriveltondasilva/currency#readme - Documentation
+ *
+ * Inspired by:
+ * @see https://github.com/scurker/currency.js
+ */
+
+var U=Object.freeze({...w}),z=U;export{U as Money,z as default};

package/dist/presets.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @ERIVELTONDASILVA/CURRENCY v1.0.0
+ *
+ * A lightweight and reliable JavaScript library for precise currency operations, built to safely handle monetary values without floating point errors.
+ *
+ * @author Erivelton Silva <eriveltondasilva13@gmail.com>
+ * @license MIT
+ * @copyright 2026 Erivelton Silva
+ * @version 1.0.0
+ *
+ * @see https://github.com/eriveltondasilva/currency#readme - Documentation
+ *
+ * Inspired by:
+ * @see https://github.com/scurker/currency.js
+ */
+
+import { a as MoneyContract } from './types-BX9n6pbS.js';
+
+/**
+ * @module presets
+ *
+ * Country-specific shorthand factories. Each preset is a function that accepts
+ * a `number` (major units) or a `string` (parsed according to the country's
+ * decimal and grouping separators) and returns a `MoneyContract`.
+ *
+ * Import from the `/presets` entry point:
+ *
+ * @example
+ * import { br, us } from '@eriveltondasilva/currency/presets'
+ *
+ * br(19.99).format()     // => 'R$ 19,99'
+ * us('1,500.00').format() // => '$1,500.00'
+ */
+
+/**
+ * A country-bound factory that creates a `MoneyContract` from a `number` or
+ * a locale-formatted `string`.
+ *
+ * - `number` — interpreted as major units (e.g. `19.99`) {@link from}.
+ * - `string` — parsed using the country's decimal and grouping separators {@link parse}.
+ *
+ * @throws `InvalidInputError` — when the string cannot be parsed as a monetary amount.
+ */
+type CreatePreset = (value: number | string) => MoneyContract;
+declare const au: CreatePreset;
+declare const br: CreatePreset;
+declare const ca: CreatePreset;
+declare const ch: CreatePreset;
+declare const cn: CreatePreset;
+declare const de: CreatePreset;
+declare const fr: CreatePreset;
+declare const gb: CreatePreset;
+declare const ind: CreatePreset;
+declare const jp: CreatePreset;
+declare const mx: CreatePreset;
+declare const sg: CreatePreset;
+declare const pt: CreatePreset;
+declare const us: CreatePreset;
+
+export { au, br, ca, ch, cn, de, fr, gb, ind, jp, mx, pt, sg, us };

package/dist/presets.js

@@ -0,0 +1,17 @@
+import {m as m$1,l}from'./chunk-5VVSCRNB.js';/**
+ * @ERIVELTONDASILVA/CURRENCY v1.0.0
+ *
+ * A lightweight and reliable JavaScript library for precise currency operations, built to safely handle monetary values without floating point errors.
+ *
+ * @author Erivelton Silva <eriveltondasilva13@gmail.com>
+ * @license MIT
+ * @copyright 2026 Erivelton Silva
+ * @version 1.0.0
+ *
+ * @see https://github.com/eriveltondasilva/currency#readme - Documentation
+ *
+ * Inspired by:
+ * @see https://github.com/scurker/currency.js
+ */
+
+function e(r){return t=>typeof t=="string"?m$1(t,r):l(t,r)}var p=e("AU"),C=e("BR"),c=e("CA"),a=e("CH"),P=e("CN"),x=e("DE"),i=e("FR"),m=e("GB"),y=e("IN"),f=e("JP"),u=e("MX"),b=e("SG"),g=e("PT"),d=e("US");export{p as au,C as br,c as ca,a as ch,P as cn,x as de,i as fr,m as gb,y as ind,f as jp,u as mx,g as pt,b as sg,d as us};