@ducatjs/money 0.2.1 → 0.3.0

package/dist/wire.d.ts

@@ -0,0 +1,105 @@
+import { type CurrencyInput, type Money } from './money.js';
+import { type RoundingMode } from './rounding.js';
+/** Options for the readers: the scale of the Money they return, and how to round to it. */
+export interface WireReadOptions {
+    /** The result's scale (default: the currency's ISO exponent). */
+    readonly scale?: number;
+    /** How to round when the value has more decimals than that (default 'unnecessary': throw). */
+    readonly rounding?: RoundingMode;
+}
+/**
+ * `google.type.Money` in its proto3 JSON form: `units` is an int64, which proto3 JSON writes as a
+ * string, and `nanos` the billionths, with the same sign as `units`.
+ */
+export interface GoogleMoney {
+    readonly currencyCode: string;
+    readonly units: string;
+    readonly nanos: number;
+}
+/**
+ * Money as `google.type.Money`: `toGoogleMoney(money('-1.75', 'EUR'))` is `{ currencyCode: 'EUR',
+ * units: '-1', nanos: -750000000 }`. Throws a RoundingError for an amount with more than 9
+ * decimals (unless `rounding` is given), and a RangeError when the whole units don't fit in an
+ * int64 or the code isn't three capital letters, as the format requires.
+ */
+export declare function toGoogleMoney(money: Money, rounding?: RoundingMode): GoogleMoney;
+/** What `fromGoogleMoney` accepts: the proto3 JSON form, or units as a number or bigint. */
+export interface GoogleMoneyInput {
+    readonly currencyCode: string;
+    readonly units?: string | number | bigint;
+    readonly nanos?: number;
+}
+/**
+ * Reads `google.type.Money`, exactly: `fromGoogleMoney({ currencyCode: 'EUR', units: '12', nanos:
+ * 340000000 })` is 12.34 EUR. Missing `units` or `nanos` mean 0, as in proto3. The value is checked
+ * as the format defines it: `units` an int64, `nanos` from -999,999,999 to 999,999,999 with the
+ * same sign as a non-zero `units`. A malformed value throws a RangeError. The result has the
+ * currency's exponent; more decimals throw a RoundingError unless `options` says what to do.
+ */
+export declare function fromGoogleMoney<C extends CurrencyInput>(value: GoogleMoneyInput & {
+    readonly currencyCode: C;
+}, options?: WireReadOptions): Money<C>;
+/**
+ * An ISO 20022 amount, as in `<InstdAmt Ccy="EUR">12.34</InstdAmt>`: `Ccy` is the attribute and
+ * `value` the element's text.
+ */
+export interface Iso20022Amount {
+    readonly Ccy: string;
+    readonly value: string;
+}
+/** Options for `toIso20022Amount`. */
+export interface Iso20022WriteOptions {
+    /**
+     * The number of decimals to write (default: the currency's ISO exponent), at most 5. The payment
+     * networks' rules (CBPR+, HVPS+) require the currency's minor unit, so give another only for
+     * messages that allow it.
+     */
+    readonly scale?: number;
+}
+/**
+ * Money as an ISO 20022 amount: `toIso20022Amount(money('12.34', 'EUR'))` is `{ Ccy: 'EUR', value:
+ * '12.34' }`. It is written with the currency's decimals, as the payment networks' rules (CBPR+,
+ * HVPS+) require for ActiveCurrencyAndAmount: 12.3400 EUR at scale 4 is written '12.34', and JPY
+ * '1000'. More decimals than that throw a RoundingError unless `rounding` is given. The schema
+ * types allow at most 5 decimals and 18 digits, and no negative amounts: the direction is carried
+ * elsewhere in the message (a credit/debit indicator). An amount that doesn't fit throws a
+ * RangeError.
+ */
+export declare function toIso20022Amount(money: Money, rounding?: RoundingMode, options?: Iso20022WriteOptions): Iso20022Amount;
+/**
+ * Reads an ISO 20022 amount, exactly: `fromIso20022Amount({ Ccy: 'EUR', value: '12.34' })` is
+ * 12.34 EUR. The text is checked as the schema defines it: plain digits with an optional decimal
+ * point, at most 5 decimals and 18 digits (not counting leading or trailing zeros, as XSD
+ * counts them), no sign, exponent or spaces (XML whitespace around the
+ * element's text should be trimmed by the XML reader). Anything else throws a SyntaxError. The
+ * result has the currency's exponent; more decimals throw a RoundingError unless `options` says what
+ * to do (KWD's 3 decimals fit; 12.345 EUR needs `{ scale: 3 }` or a rounding mode).
+ */
+export declare function fromIso20022Amount<C extends CurrencyInput>(amount: {
+    readonly Ccy: C;
+    readonly value: string;
+}, options?: WireReadOptions): Money<C>;
+/** An integer count of the currency's ISO 4217 minor units: `{ value: 1234, currency: 'EUR' }`. */
+export interface MinorUnitAmount {
+    readonly value: number;
+    readonly currency: string;
+}
+/**
+ * Money as `{ value, currency }` in ISO 4217 minor units: `toMinorUnits(money('12.34', 'EUR'))` is
+ * `{ value: 1234, currency: 'EUR' }`, and JPY 500 is `{ value: 500, currency: 'JPY' }`. The same
+ * shape as Adyen's `amount`, at the ISO exponent; use the processor's own view (`toAdyen`,
+ * `toCheckout`, ...) where its exponents differ from ISO. Throws a RoundingError for an amount with
+ * more decimals than the currency (unless `rounding` is given), and a RangeError beyond 2^53 - 1
+ * minor units, which JSON numbers can't hold exactly.
+ */
+export declare function toMinorUnits(money: Money, rounding?: RoundingMode): MinorUnitAmount;
+/**
+ * Reads `{ value, currency }` in ISO 4217 minor units: `fromMinorUnits({ value: 1234, currency:
+ * 'EUR' })` is 12.34 EUR. `value` must be a safe integer (or a bigint); anything else throws a
+ * RangeError.
+ */
+export declare function fromMinorUnits<C extends CurrencyInput>(amount: {
+    readonly value: number | bigint;
+    readonly currency: C;
+}): Money<C>;
+//# sourceMappingURL=wire.d.ts.map

package/dist/wire.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire.d.ts","sourceRoot":"","sources":["../src/wire.ts"],"names":[],"mappings":"AAcA,OAAO,EAAsB,KAAK,aAAa,EAAE,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AAEhF,OAAO,EAAiB,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AAOjE,2FAA2F;AAC3F,MAAM,WAAW,eAAe;IAC9B,iEAAiE;IACjE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,8FAA8F;IAC9F,QAAQ,CAAC,QAAQ,CAAC,EAAE,YAAY,CAAC;CAClC;AAsCD;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,GAAE,YAA4B,GAAG,WAAW,CAsB/F;AAED,4FAA4F;AAC5F,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IAC1C,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,aAAa,EACrD,KAAK,EAAE,gBAAgB,GAAG;IAAE,QAAQ,CAAC,YAAY,EAAE,CAAC,CAAA;CAAE,EACtD,OAAO,CAAC,EAAE,eAAe,GACxB,KAAK,CAAC,CAAC,CAAC,CAkCV;AAMD;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAoBD,sCAAsC;AACtC,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,KAAK,EACZ,QAAQ,GAAE,YAA4B,EACtC,OAAO,CAAC,EAAE,oBAAoB,GAC7B,cAAc,CA+BhB;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,aAAa,EACxD,MAAM,EAAE;IAAE,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EACnD,OAAO,CAAC,EAAE,eAAe,GACxB,KAAK,CAAC,CAAC,CAAC,CAaV;AAMD,mGAAmG;AACnG,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,KAAK,EACZ,QAAQ,GAAE,YAA4B,GACrC,eAAe,CAMjB;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,aAAa,EAAE,MAAM,EAAE;IAC9D,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAChC,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC;CACtB,GAAG,KAAK,CAAC,CAAC,CAAC,CAUX"}

package/dist/wire.js

@@ -0,0 +1,212 @@
+/**
+ * `@ducatjs/money/wire`: Money to and from common wire formats, exactly in both directions:
+ * - `google.type.Money` (`currencyCode`, `units`, `nanos`), used by Google APIs and many gRPC
+ *   services;
+ * - ISO 20022 amounts (`<InstdAmt Ccy="EUR">12.34</InstdAmt>`): a non-negative decimal with at
+ *   most 5 decimals and 18 digits;
+ * - `{ value, currency }` with an integer count of ISO 4217 minor units, the JSON several
+ *   processors and ledgers use.
+ *
+ * Every reader checks the format strictly, and every writer throws rather than send a value the
+ * format can't hold.
+ */
+import { currencyExponent } from './currency.js';
+import { formatScaled, parseDecimal } from './decimal.js';
+import { fromMinor, toScale } from './money.js';
+import { fromProcessorAmount, toProcessorAmount } from './processor.js';
+import { RoundingError } from './rounding.js';
+const NANOS_PER_UNIT = 1000000000n;
+const MAX_INT64 = 2n ** 63n - 1n;
+const MIN_INT64 = -(2n ** 63n);
+const CURRENCY_CODE = /^[A-Z]{3}$/;
+/** `value` (an integer count of 10^-from units) as Money at the requested scale. */
+function atScale(format, value, from, currency, options) {
+    const exact = fromMinor(value, currency, from);
+    const scale = options?.scale ?? currencyExponent(currency);
+    try {
+        return toScale(exact, scale, options?.rounding ?? 'unnecessary');
+    }
+    catch (error) {
+        if (error instanceof RoundingError) {
+            throw new RoundingError(`${format} ${formatScaled(exact.minor, exact.scale)} ${currency} has more than ${scale} decimals; pass { rounding } or { scale }`);
+        }
+        throw error;
+    }
+}
+/** `money` as an integer count of 10^-scale units, or undefined when that would drop digits. */
+function exactAt(money, scale) {
+    const minor = BigInt(money.minor);
+    if (money.scale <= scale) {
+        return minor * 10n ** BigInt(scale - money.scale);
+    }
+    const divisor = 10n ** BigInt(money.scale - scale);
+    return minor % divisor === 0n ? minor / divisor : undefined;
+}
+/**
+ * Money as `google.type.Money`: `toGoogleMoney(money('-1.75', 'EUR'))` is `{ currencyCode: 'EUR',
+ * units: '-1', nanos: -750000000 }`. Throws a RoundingError for an amount with more than 9
+ * decimals (unless `rounding` is given), and a RangeError when the whole units don't fit in an
+ * int64 or the code isn't three capital letters, as the format requires.
+ */
+export function toGoogleMoney(money, rounding = 'unnecessary') {
+    if (!CURRENCY_CODE.test(money.currency)) {
+        throw new RangeError(`google.type.Money needs an ISO 4217 code, got ${money.currency}`);
+    }
+    let total = exactAt(money, 9);
+    if (total === undefined) {
+        if (rounding === 'unnecessary') {
+            throw new RoundingError(`${money.toString()} has more than 9 decimals, the most google.type.Money holds; pass a rounding mode`);
+        }
+        total = BigInt(toScale(money, 9, rounding).minor);
+    }
+    // bigint division and remainder truncate toward zero, so units and nanos share the sign
+    const units = total / NANOS_PER_UNIT;
+    const nanos = Number(total % NANOS_PER_UNIT);
+    if (units > MAX_INT64 || units < MIN_INT64) {
+        throw new RangeError(`${money.toString()} doesn't fit in google.type.Money (int64 units)`);
+    }
+    // `+ 0` turns -0 into 0
+    return { currencyCode: money.currency, units: String(units), nanos: nanos + 0 };
+}
+/**
+ * Reads `google.type.Money`, exactly: `fromGoogleMoney({ currencyCode: 'EUR', units: '12', nanos:
+ * 340000000 })` is 12.34 EUR. Missing `units` or `nanos` mean 0, as in proto3. The value is checked
+ * as the format defines it: `units` an int64, `nanos` from -999,999,999 to 999,999,999 with the
+ * same sign as a non-zero `units`. A malformed value throws a RangeError. The result has the
+ * currency's exponent; more decimals throw a RoundingError unless `options` says what to do.
+ */
+export function fromGoogleMoney(value, options) {
+    const invalid = (reason) => {
+        throw new RangeError(`Invalid google.type.Money: ${reason}`);
+    };
+    if (value === null || typeof value !== 'object') {
+        return invalid('expected an object');
+    }
+    const { currencyCode, units = 0, nanos = 0 } = value;
+    if (typeof currencyCode !== 'string' || !CURRENCY_CODE.test(currencyCode)) {
+        return invalid(`currencyCode ${JSON.stringify(currencyCode)}`);
+    }
+    let wholeUnits;
+    if (typeof units === 'bigint') {
+        wholeUnits = units;
+    }
+    else if (typeof units === 'number' && Number.isSafeInteger(units)) {
+        wholeUnits = BigInt(units);
+    }
+    else if (typeof units === 'string' && /^-?\d{1,19}$/.test(units)) {
+        wholeUnits = BigInt(units);
+    }
+    else {
+        return invalid(`units ${JSON.stringify(String(units))}`);
+    }
+    if (wholeUnits > MAX_INT64 || wholeUnits < MIN_INT64) {
+        return invalid(`units ${wholeUnits} is beyond int64`);
+    }
+    if (!Number.isInteger(nanos) || nanos > 999_999_999 || nanos < -999_999_999) {
+        return invalid(`nanos ${nanos}`);
+    }
+    if ((wholeUnits > 0n && nanos < 0) || (wholeUnits < 0n && nanos > 0)) {
+        return invalid(`units ${wholeUnits} and nanos ${nanos} have different signs`);
+    }
+    const total = wholeUnits * NANOS_PER_UNIT + BigInt(nanos);
+    return atScale('google.type.Money', total, 9, currencyCode, options);
+}
+// ActiveOrHistoricCurrencyAndAmount: xs:decimal, fractionDigits 5, totalDigits 18, minInclusive 0
+const ISO_20022_AMOUNT = /^(\d+)(?:\.(\d+))?$/;
+const ISO_20022_MAX_DECIMALS = 5;
+const ISO_20022_MAX_DIGITS = 18;
+/**
+ * Whether a decimal's value fits the schema's facets. XSD counts digits in the value, not the text,
+ * so leading zeros and trailing fractional zeros don't count: '0012.3400' has 4 digits, 2 decimals.
+ */
+function fitsIso20022(integer, fraction) {
+    const decimals = fraction.replace(/0+$/, '');
+    const whole = integer.replace(/^0+/, '');
+    return (decimals.length <= ISO_20022_MAX_DECIMALS &&
+        whole.length + decimals.length <= ISO_20022_MAX_DIGITS);
+}
+/**
+ * Money as an ISO 20022 amount: `toIso20022Amount(money('12.34', 'EUR'))` is `{ Ccy: 'EUR', value:
+ * '12.34' }`. It is written with the currency's decimals, as the payment networks' rules (CBPR+,
+ * HVPS+) require for ActiveCurrencyAndAmount: 12.3400 EUR at scale 4 is written '12.34', and JPY
+ * '1000'. More decimals than that throw a RoundingError unless `rounding` is given. The schema
+ * types allow at most 5 decimals and 18 digits, and no negative amounts: the direction is carried
+ * elsewhere in the message (a credit/debit indicator). An amount that doesn't fit throws a
+ * RangeError.
+ */
+export function toIso20022Amount(money, rounding = 'unnecessary', options) {
+    if (!CURRENCY_CODE.test(money.currency)) {
+        throw new RangeError(`ISO 20022 amounts need an ISO 4217 code, got ${money.currency}`);
+    }
+    const scale = options?.scale ?? currencyExponent(money.currency);
+    if (!Number.isInteger(scale) || scale < 0 || scale > ISO_20022_MAX_DECIMALS) {
+        throw new RangeError(`ISO 20022 amounts have 0 to 5 decimals, not ${scale}`);
+    }
+    let amount;
+    try {
+        amount = toScale(money, scale, rounding);
+    }
+    catch (error) {
+        if (error instanceof RoundingError) {
+            throw new RoundingError(`${money.toString()} has more than ${scale} decimals for an ISO 20022 ${money.currency} amount; pass a rounding mode`);
+        }
+        throw error;
+    }
+    if (amount.minor < 0) {
+        throw new RangeError(`ISO 20022 amounts can't be negative (${money.toString()}); use the credit/debit indicator`);
+    }
+    const value = formatScaled(amount.minor, amount.scale);
+    const [integer = '', fraction = ''] = value.split('.');
+    if (!fitsIso20022(integer, fraction)) {
+        throw new RangeError(`${money.toString()} has more than 18 digits, the most ISO 20022 allows`);
+    }
+    return { Ccy: money.currency, value };
+}
+/**
+ * Reads an ISO 20022 amount, exactly: `fromIso20022Amount({ Ccy: 'EUR', value: '12.34' })` is
+ * 12.34 EUR. The text is checked as the schema defines it: plain digits with an optional decimal
+ * point, at most 5 decimals and 18 digits (not counting leading or trailing zeros, as XSD
+ * counts them), no sign, exponent or spaces (XML whitespace around the
+ * element's text should be trimmed by the XML reader). Anything else throws a SyntaxError. The
+ * result has the currency's exponent; more decimals throw a RoundingError unless `options` says what
+ * to do (KWD's 3 decimals fit; 12.345 EUR needs `{ scale: 3 }` or a rounding mode).
+ */
+export function fromIso20022Amount(amount, options) {
+    const { Ccy: currency, value } = amount ?? {};
+    if (typeof currency !== 'string' || !CURRENCY_CODE.test(currency)) {
+        throw new SyntaxError(`Invalid ISO 20022 currency ${JSON.stringify(currency)}`);
+    }
+    const match = typeof value === 'string' ? ISO_20022_AMOUNT.exec(value) : null;
+    if (match === null || !fitsIso20022(match[1], match[2] ?? '')) {
+        throw new SyntaxError(`Invalid ISO 20022 amount ${JSON.stringify(value)}: at most 18 digits, 5 of them decimals`);
+    }
+    const parsed = parseDecimal(value);
+    return atScale('ISO 20022 amount', parsed.digits, parsed.scale, currency, options);
+}
+/**
+ * Money as `{ value, currency }` in ISO 4217 minor units: `toMinorUnits(money('12.34', 'EUR'))` is
+ * `{ value: 1234, currency: 'EUR' }`, and JPY 500 is `{ value: 500, currency: 'JPY' }`. The same
+ * shape as Adyen's `amount`, at the ISO exponent; use the processor's own view (`toAdyen`,
+ * `toCheckout`, ...) where its exponents differ from ISO. Throws a RoundingError for an amount with
+ * more decimals than the currency (unless `rounding` is given), and a RangeError beyond 2^53 - 1
+ * minor units, which JSON numbers can't hold exactly.
+ */
+export function toMinorUnits(money, rounding = 'unnecessary') {
+    const exponent = currencyExponent(money.currency);
+    return {
+        value: toProcessorAmount('ISO 4217 minor units', money, exponent, 1, rounding),
+        currency: money.currency,
+    };
+}
+/**
+ * Reads `{ value, currency }` in ISO 4217 minor units: `fromMinorUnits({ value: 1234, currency:
+ * 'EUR' })` is 12.34 EUR. `value` must be a safe integer (or a bigint); anything else throws a
+ * RangeError.
+ */
+export function fromMinorUnits(amount) {
+    if (amount === null || typeof amount !== 'object' || typeof amount.currency !== 'string') {
+        throw new RangeError('Expected { value, currency }');
+    }
+    return fromProcessorAmount('ISO 4217 minor units', amount.value, amount.currency, currencyExponent(amount.currency));
+}
+//# sourceMappingURL=wire.js.map

package/dist/wire.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire.js","sourceRoot":"","sources":["../src/wire.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,EAAE,SAAS,EAAE,OAAO,EAAkC,MAAM,YAAY,CAAC;AAChF,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxE,OAAO,EAAE,aAAa,EAAqB,MAAM,eAAe,CAAC;AAEjE,MAAM,cAAc,GAAG,WAAc,CAAC;AACtC,MAAM,SAAS,GAAG,EAAE,IAAI,GAAG,GAAG,EAAE,CAAC;AACjC,MAAM,SAAS,GAAG,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,CAAC;AAC/B,MAAM,aAAa,GAAG,YAAY,CAAC;AAUnC,oFAAoF;AACpF,SAAS,OAAO,CACd,MAAc,EACd,KAAa,EACb,IAAY,EACZ,QAAW,EACX,OAAoC;IAEpC,MAAM,KAAK,GAAG,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;IAC/C,MAAM,KAAK,GAAG,OAAO,EAAE,KAAK,IAAI,gBAAgB,CAAC,QAAQ,CAAC,CAAC;IAC3D,IAAI,CAAC;QACH,OAAO,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,IAAI,aAAa,CAAC,CAAC;IACnE,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,KAAK,YAAY,aAAa,EAAE,CAAC;YACnC,MAAM,IAAI,aAAa,CACrB,GAAG,MAAM,IAAI,YAAY,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,QAAQ,kBAAkB,KAAK,2CAA2C,CAClI,CAAC;QACJ,CAAC;QACD,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC;AAED,gGAAgG;AAChG,SAAS,OAAO,CAAC,KAAY,EAAE,KAAa;IAC1C,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAClC,IAAI,KAAK,CAAC,KAAK,IAAI,KAAK,EAAE,CAAC;QACzB,OAAO,KAAK,GAAG,GAAG,IAAI,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;IACpD,CAAC;IACD,MAAM,OAAO,GAAG,GAAG,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC;IACnD,OAAO,KAAK,GAAG,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;AAC9D,CAAC;AAgBD;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,KAAY,EAAE,WAAyB,aAAa;IAChF,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC;QACxC,MAAM,IAAI,UAAU,CAAC,iDAAiD,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC1F,CAAC;IACD,IAAI,KAAK,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IAC9B,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,IAAI,QAAQ,KAAK,aAAa,EAAE,CAAC;YAC/B,MAAM,IAAI,aAAa,CACrB,GAAG,KAAK,CAAC,QAAQ,EAAE,mFAAmF,CACvG,CAAC;QACJ,CAAC;QACD,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC,KAAK,CAAC,CAAC;IACpD,CAAC;IAED,wFAAwF;IACxF,MAAM,KAAK,GAAG,KAAK,GAAG,cAAc,CAAC;IACrC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,GAAG,cAAc,CAAC,CAAC;IAC7C,IAAI,KAAK,GAAG,SAAS,IAAI,KAAK,GAAG,SAAS,EAAE,CAAC;QAC3C,MAAM,IAAI,UAAU,CAAC,GAAG,KAAK,CAAC,QAAQ,EAAE,iDAAiD,CAAC,CAAC;IAC7F,CAAC;IACD,wBAAwB;IACxB,OAAO,EAAE,YAAY,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,KAAK,GAAG,CAAC,EAAE,CAAC;AAClF,CAAC;AASD;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAC7B,KAAsD,EACtD,OAAyB;IAEzB,MAAM,OAAO,GAAG,CAAC,MAAc,EAAS,EAAE;QACxC,MAAM,IAAI,UAAU,CAAC,8BAA8B,MAAM,EAAE,CAAC,CAAC;IAC/D,CAAC,CAAC;IACF,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAChD,OAAO,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACvC,CAAC;IACD,MAAM,EAAE,YAAY,EAAE,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,EAAE,GAAG,KAAK,CAAC;IACrD,IAAI,OAAO,YAAY,KAAK,QAAQ,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC;QAC1E,OAAO,OAAO,CAAC,gBAAgB,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;IACjE,CAAC;IAED,IAAI,UAAkB,CAAC;IACvB,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,UAAU,GAAG,KAAK,CAAC;IACrB,CAAC;SAAM,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;QACpE,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAC7B,CAAC;SAAM,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACnE,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAC7B,CAAC;SAAM,CAAC;QACN,OAAO,OAAO,CAAC,SAAS,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;IAC3D,CAAC;IACD,IAAI,UAAU,GAAG,SAAS,IAAI,UAAU,GAAG,SAAS,EAAE,CAAC;QACrD,OAAO,OAAO,CAAC,SAAS,UAAU,kBAAkB,CAAC,CAAC;IACxD,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,WAAW,IAAI,KAAK,GAAG,CAAC,WAAW,EAAE,CAAC;QAC5E,OAAO,OAAO,CAAC,SAAS,KAAK,EAAE,CAAC,CAAC;IACnC,CAAC;IACD,IAAI,CAAC,UAAU,GAAG,EAAE,IAAI,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC,UAAU,GAAG,EAAE,IAAI,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC;QACrE,OAAO,OAAO,CAAC,SAAS,UAAU,cAAc,KAAK,uBAAuB,CAAC,CAAC;IAChF,CAAC;IAED,MAAM,KAAK,GAAG,UAAU,GAAG,cAAc,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAC1D,OAAO,OAAO,CAAC,mBAAmB,EAAE,KAAK,EAAE,CAAC,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;AACvE,CAAC;AAeD,kGAAkG;AAClG,MAAM,gBAAgB,GAAG,qBAAqB,CAAC;AAC/C,MAAM,sBAAsB,GAAG,CAAC,CAAC;AACjC,MAAM,oBAAoB,GAAG,EAAE,CAAC;AAEhC;;;GAGG;AACH,SAAS,YAAY,CAAC,OAAe,EAAE,QAAgB;IACrD,MAAM,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IAC7C,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IACzC,OAAO,CACL,QAAQ,CAAC,MAAM,IAAI,sBAAsB;QACzC,KAAK,CAAC,MAAM,GAAG,QAAQ,CAAC,MAAM,IAAI,oBAAoB,CACvD,CAAC;AACJ,CAAC;AAYD;;;;;;;;GAQG;AACH,MAAM,UAAU,gBAAgB,CAC9B,KAAY,EACZ,WAAyB,aAAa,EACtC,OAA8B;IAE9B,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC;QACxC,MAAM,IAAI,UAAU,CAAC,gDAAgD,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;IACzF,CAAC;IACD,MAAM,KAAK,GAAG,OAAO,EAAE,KAAK,IAAI,gBAAgB,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IACjE,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,GAAG,sBAAsB,EAAE,CAAC;QAC5E,MAAM,IAAI,UAAU,CAAC,+CAA+C,KAAK,EAAE,CAAC,CAAC;IAC/E,CAAC;IAED,IAAI,MAAa,CAAC;IAClB,IAAI,CAAC;QACH,MAAM,GAAG,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;IAC3C,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,KAAK,YAAY,aAAa,EAAE,CAAC;YACnC,MAAM,IAAI,aAAa,CACrB,GAAG,KAAK,CAAC,QAAQ,EAAE,kBAAkB,KAAK,8BAA8B,KAAK,CAAC,QAAQ,+BAA+B,CACtH,CAAC;QACJ,CAAC;QACD,MAAM,KAAK,CAAC;IACd,CAAC;IACD,IAAI,MAAM,CAAC,KAAK,GAAG,CAAC,EAAE,CAAC;QACrB,MAAM,IAAI,UAAU,CAClB,wCAAwC,KAAK,CAAC,QAAQ,EAAE,mCAAmC,CAC5F,CAAC;IACJ,CAAC;IACD,MAAM,KAAK,GAAG,YAAY,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACvD,MAAM,CAAC,OAAO,GAAG,EAAE,EAAE,QAAQ,GAAG,EAAE,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACvD,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,CAAC;QACrC,MAAM,IAAI,UAAU,CAAC,GAAG,KAAK,CAAC,QAAQ,EAAE,qDAAqD,CAAC,CAAC;IACjG,CAAC;IACD,OAAO,EAAE,GAAG,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,EAAE,CAAC;AACxC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,kBAAkB,CAChC,MAAmD,EACnD,OAAyB;IAEzB,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG,MAAM,IAAK,EAAY,CAAC;IACzD,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;QAClE,MAAM,IAAI,WAAW,CAAC,8BAA8B,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IAClF,CAAC;IACD,MAAM,KAAK,GAAG,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC9E,IAAI,KAAK,KAAK,IAAI,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAE,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC;QAC/D,MAAM,IAAI,WAAW,CACnB,4BAA4B,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,yCAAyC,CAC3F,CAAC;IACJ,CAAC;IACD,MAAM,MAAM,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;IACnC,OAAO,OAAO,CAAC,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;AACrF,CAAC;AAYD;;;;;;;GAOG;AACH,MAAM,UAAU,YAAY,CAC1B,KAAY,EACZ,WAAyB,aAAa;IAEtC,MAAM,QAAQ,GAAG,gBAAgB,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IAClD,OAAO;QACL,KAAK,EAAE,iBAAiB,CAAC,sBAAsB,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,CAAC;QAC9E,QAAQ,EAAE,KAAK,CAAC,QAAQ;KACzB,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAA0B,MAGvD;IACC,IAAI,MAAM,KAAK,IAAI,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,OAAO,MAAM,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;QACzF,MAAM,IAAI,UAAU,CAAC,8BAA8B,CAAC,CAAC;IACvD,CAAC;IACD,OAAO,mBAAmB,CACxB,sBAAsB,EACtB,MAAM,CAAC,KAAK,EACZ,MAAM,CAAC,QAAQ,EACf,gBAAgB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAClC,CAAC;AACJ,CAAC"}

package/dist/words/de.d.ts

@@ -0,0 +1,4 @@
+import type { SpelloutRules } from '../rbnf.js';
+/** German spell-out rules (CLDR 49). */
+export declare const german: SpelloutRules;
+//# sourceMappingURL=de.d.ts.map

package/dist/words/de.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"de.d.ts","sourceRoot":"","sources":["../../src/words/de.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,wCAAwC;AACxC,eAAO,MAAM,MAAM,EAAE,aAA8C,CAAC"}

package/dist/words/de.js

@@ -0,0 +1,8 @@
+/**
+ * `@ducatjs/money/words/de`: German spell-out rules from CLDR, for `spellOut` and
+ * `amountInWords` in `@ducatjs/money/words`.
+ */
+import { RULES } from '../generated/rbnf-de.js';
+/** German spell-out rules (CLDR 49). */
+export const german = { locale: 'de', rules: RULES };
+//# sourceMappingURL=de.js.map

package/dist/words/de.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"de.js","sourceRoot":"","sources":["../../src/words/de.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAGhD,wCAAwC;AACxC,MAAM,CAAC,MAAM,MAAM,GAAkB,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC"}

package/dist/words/en.d.ts

@@ -0,0 +1,4 @@
+import type { SpelloutRules } from '../rbnf.js';
+/** English spell-out rules (CLDR 49). */
+export declare const english: SpelloutRules;
+//# sourceMappingURL=en.d.ts.map

package/dist/words/en.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"en.d.ts","sourceRoot":"","sources":["../../src/words/en.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,yCAAyC;AACzC,eAAO,MAAM,OAAO,EAAE,aAA8C,CAAC"}

package/dist/words/en.js

@@ -0,0 +1,8 @@
+/**
+ * `@ducatjs/money/words/en`: English spell-out rules from CLDR, for `spellOut` and
+ * `amountInWords` in `@ducatjs/money/words`.
+ */
+import { RULES } from '../generated/rbnf-en.js';
+/** English spell-out rules (CLDR 49). */
+export const english = { locale: 'en', rules: RULES };
+//# sourceMappingURL=en.js.map

package/dist/words/en.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"en.js","sourceRoot":"","sources":["../../src/words/en.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAGhD,yCAAyC;AACzC,MAAM,CAAC,MAAM,OAAO,GAAkB,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC"}

package/dist/words/es.d.ts

@@ -0,0 +1,4 @@
+import type { SpelloutRules } from '../rbnf.js';
+/** Spanish spell-out rules (CLDR 49). */
+export declare const spanish: SpelloutRules;
+//# sourceMappingURL=es.d.ts.map

package/dist/words/es.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"es.d.ts","sourceRoot":"","sources":["../../src/words/es.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,yCAAyC;AACzC,eAAO,MAAM,OAAO,EAAE,aAA8C,CAAC"}

package/dist/words/es.js

@@ -0,0 +1,8 @@
+/**
+ * `@ducatjs/money/words/es`: Spanish spell-out rules from CLDR, for `spellOut` and
+ * `amountInWords` in `@ducatjs/money/words`.
+ */
+import { RULES } from '../generated/rbnf-es.js';
+/** Spanish spell-out rules (CLDR 49). */
+export const spanish = { locale: 'es', rules: RULES };
+//# sourceMappingURL=es.js.map

package/dist/words/es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"es.js","sourceRoot":"","sources":["../../src/words/es.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAGhD,yCAAyC;AACzC,MAAM,CAAC,MAAM,OAAO,GAAkB,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC"}

package/dist/words/fr.d.ts

@@ -0,0 +1,4 @@
+import type { SpelloutRules } from '../rbnf.js';
+/** French spell-out rules (CLDR 49). */
+export declare const french: SpelloutRules;
+//# sourceMappingURL=fr.d.ts.map

package/dist/words/fr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fr.d.ts","sourceRoot":"","sources":["../../src/words/fr.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,wCAAwC;AACxC,eAAO,MAAM,MAAM,EAAE,aAA8C,CAAC"}

package/dist/words/fr.js

@@ -0,0 +1,8 @@
+/**
+ * `@ducatjs/money/words/fr`: French spell-out rules from CLDR, for `spellOut` and
+ * `amountInWords` in `@ducatjs/money/words`.
+ */
+import { RULES } from '../generated/rbnf-fr.js';
+/** French spell-out rules (CLDR 49). */
+export const french = { locale: 'fr', rules: RULES };
+//# sourceMappingURL=fr.js.map

package/dist/words/fr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fr.js","sourceRoot":"","sources":["../../src/words/fr.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAGhD,wCAAwC;AACxC,MAAM,CAAC,MAAM,MAAM,GAAkB,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC"}

package/dist/words/it.d.ts

@@ -0,0 +1,4 @@
+import type { SpelloutRules } from '../rbnf.js';
+/** Italian spell-out rules (CLDR 49). */
+export declare const italian: SpelloutRules;
+//# sourceMappingURL=it.d.ts.map

package/dist/words/it.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"it.d.ts","sourceRoot":"","sources":["../../src/words/it.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,yCAAyC;AACzC,eAAO,MAAM,OAAO,EAAE,aAA8C,CAAC"}

package/dist/words/it.js

@@ -0,0 +1,8 @@
+/**
+ * `@ducatjs/money/words/it`: Italian spell-out rules from CLDR, for `spellOut` and
+ * `amountInWords` in `@ducatjs/money/words`.
+ */
+import { RULES } from '../generated/rbnf-it.js';
+/** Italian spell-out rules (CLDR 49). */
+export const italian = { locale: 'it', rules: RULES };
+//# sourceMappingURL=it.js.map

package/dist/words/it.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"it.js","sourceRoot":"","sources":["../../src/words/it.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAGhD,yCAAyC;AACzC,MAAM,CAAC,MAAM,OAAO,GAAkB,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC"}

package/dist/words/nl.d.ts

@@ -0,0 +1,4 @@
+import type { SpelloutRules } from '../rbnf.js';
+/** Dutch spell-out rules (CLDR 49). */
+export declare const dutch: SpelloutRules;
+//# sourceMappingURL=nl.d.ts.map

package/dist/words/nl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nl.d.ts","sourceRoot":"","sources":["../../src/words/nl.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,uCAAuC;AACvC,eAAO,MAAM,KAAK,EAAE,aAA8C,CAAC"}

package/dist/words/nl.js

@@ -0,0 +1,8 @@
+/**
+ * `@ducatjs/money/words/nl`: Dutch spell-out rules from CLDR, for `spellOut` and
+ * `amountInWords` in `@ducatjs/money/words`.
+ */
+import { RULES } from '../generated/rbnf-nl.js';
+/** Dutch spell-out rules (CLDR 49). */
+export const dutch = { locale: 'nl', rules: RULES };
+//# sourceMappingURL=nl.js.map

package/dist/words/nl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nl.js","sourceRoot":"","sources":["../../src/words/nl.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAGhD,uCAAuC;AACvC,MAAM,CAAC,MAAM,KAAK,GAAkB,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC"}

package/dist/words/pt.d.ts

@@ -0,0 +1,4 @@
+import type { SpelloutRules } from '../rbnf.js';
+/** Portuguese spell-out rules (CLDR 49). */
+export declare const portuguese: SpelloutRules;
+//# sourceMappingURL=pt.d.ts.map

package/dist/words/pt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pt.d.ts","sourceRoot":"","sources":["../../src/words/pt.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,4CAA4C;AAC5C,eAAO,MAAM,UAAU,EAAE,aAA8C,CAAC"}

package/dist/words/pt.js

@@ -0,0 +1,8 @@
+/**
+ * `@ducatjs/money/words/pt`: Portuguese spell-out rules from CLDR, for `spellOut` and
+ * `amountInWords` in `@ducatjs/money/words`.
+ */
+import { RULES } from '../generated/rbnf-pt.js';
+/** Portuguese spell-out rules (CLDR 49). */
+export const portuguese = { locale: 'pt', rules: RULES };
+//# sourceMappingURL=pt.js.map

package/dist/words/pt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pt.js","sourceRoot":"","sources":["../../src/words/pt.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAGhD,4CAA4C;AAC5C,MAAM,CAAC,MAAM,UAAU,GAAkB,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC"}

package/dist/words.d.ts

@@ -0,0 +1,63 @@
+/**
+ * `@ducatjs/money/words`: amounts and numbers in words, as cheques, invoices and legal documents
+ * need. The words come from CLDR's rule-based number formats (RBNF), the rules ICU uses, through a
+ * small interpreter; each language is its own entry (`@ducatjs/money/words/en`, `/de`, `/fr`, `/es`,
+ * `/it`, `/pt`, `/nl`), so a bundle carries only the languages it imports. The currency's name, in
+ * the right plural, comes from the runtime's `Intl`.
+ *
+ *     import { amountInWords } from '@ducatjs/money/words';
+ *     import { english } from '@ducatjs/money/words/en';
+ *
+ *     amountInWords(money('123.45', 'EUR'), english); // 'one hundred twenty-three euros and 45/100'
+ *
+ * Nothing here loads Money or the currency table: an amount is read through its fields.
+ */
+import type { Money } from './money.js';
+import { type SpelloutRules } from './rbnf.js';
+export { ruleSets, spellOut, type SpelloutRules } from './rbnf.js';
+/** Plural forms of a minor unit's name, by `Intl.PluralRules` category: `{ one: 'cent', other: 'cents' }`. */
+export type UnitNames = Readonly<Partial<Record<Intl.LDMLPluralRule, string>>> & {
+    readonly other: string;
+};
+/** Options for `amountInWords`. */
+export interface AmountInWordsOptions {
+    /**
+     * The grammatical gender of the currency's name, which some languages' numbers agree with
+     * (Spanish 'un euro' but 'una libra', French 'vingt et un' and 'vingt et une'). CLDR doesn't say
+     * which gender a currency has, so it's yours to give; default masculine, where the language has
+     * genders.
+     */
+    readonly gender?: 'masculine' | 'feminine' | 'neuter';
+    /** A public rule set to spell numbers with, instead of the gender's cardinal (see `ruleSets`). */
+    readonly ruleSet?: string;
+    /**
+     * How to write the minor part. By default, as cheques do: '45/100' after the language's 'and'
+     * ('one hundred twenty-three euros and 45/100'). Give the minor unit's names to spell it out
+     * instead ('and forty-five cents'): CLDR has no names for minor units, so they are yours to
+     * give, in the plural forms the language uses.
+     */
+    readonly minor?: UnitNames;
+}
+/**
+ * An amount in words: the whole units spelled out with the currency's name, then the minor part.
+ *
+ *     amountInWords(money('123.45', 'EUR'), english) // 'one hundred twenty-three euros and 45/100'
+ *     amountInWords(money('123.45', 'EUR'), german)  // 'einhundertdreiundzwanzig Euro und 45/100'
+ *     amountInWords(money('21', 'EUR'), french)      // 'vingt-et-un euros et 00/100'
+ *     amountInWords(money('0.45', 'USD'), english, { minor: { one: 'cent', other: 'cents' } })
+ *     // 'forty-five cents'
+ *
+ * The minor part is written at the amount's scale, so round first for a currency's usual decimals
+ * (an amount at scale 3 gives '/1000'). Zero minor units are written as '00/100' cheque-style, and
+ * left out when `minor` names are given. Negative amounts throw a RangeError: words are for amounts
+ * to pay, and so do whole units or spelled minor units past 2^63 - 1, where ICU's rules stop (see
+ * `spellOut`). German, Italian and Dutch words keep CLDR's soft hyphens (U+00AD), which show only
+ * where a line breaks. The grammar is CLDR's numbers plus Intl's currency name: languages that put
+ * a preposition after a round million ('un million de yens') don't get it. The currency's name, the
+ * word for 'and' and the digit grouping of numbers the rules write as digits come from the
+ * runtime's `Intl`. A code Intl can't name (not three letters, such as one registered with
+ * `defineCurrency('USDC', 6)`) throws a RangeError; a three-letter code Intl doesn't know is
+ * written as the code ('five XBT').
+ */
+export declare function amountInWords(money: Money, rules: SpelloutRules, options?: AmountInWordsOptions): string;
+//# sourceMappingURL=words.d.ts.map

package/dist/words.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"words.d.ts","sourceRoot":"","sources":["../src/words.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAAwC,KAAK,aAAa,EAAE,MAAM,WAAW,CAAC;AAErF,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,aAAa,EAAE,MAAM,WAAW,CAAC;AAEnE,8GAA8G;AAC9G,MAAM,MAAM,SAAS,GAAG,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG;IAC/E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,mCAAmC;AACnC,MAAM,WAAW,oBAAoB;IACnC;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,UAAU,GAAG,QAAQ,CAAC;IACtD,kGAAkG;IAClG,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC;CAC5B;AA8DD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,aAAa,EACpB,OAAO,CAAC,EAAE,oBAAoB,GAC7B,MAAM,CAsCR"}