@ducatjs/money 0.0.0-stage → 0.1.0

package/src/parse.ts

@@ -0,0 +1,144 @@
+import { money, type CurrencyInput, type Money, type MoneyOptions } from './money.js';
+
+interface Symbols {
+  group: string;
+  decimal: string;
+}
+const symCache = new Map<string, Symbols>();
+
+/**
+ * The group and decimal separators `format()` uses for this locale and currency. They come from a
+ * currency-style formatter, not a plain number one, because some locales use different separators
+ * for money: fr-CH writes 1 234.56 € but 1 234,56 for a number, and de-AT 1.234,56 € but 1 234,56.
+ */
+function symbols(locale: string | undefined, currency: string): Symbols {
+  const key = `${locale ?? ''}|${currency}`;
+  let found = symCache.get(key);
+  if (!found) {
+    const parts = separatorParts(locale, currency);
+    found = {
+      group: parts.find((part) => part.type === 'group')?.value ?? ',',
+      decimal: parts.find((part) => part.type === 'decimal')?.value ?? '.',
+    };
+    if (symCache.size > 256) {
+      symCache.clear();
+    }
+    symCache.set(key, found);
+  }
+  return found;
+}
+
+function separatorParts(locale: string | undefined, currency: string): Intl.NumberFormatPart[] {
+  try {
+    // Two fraction digits even for JPY and the like, so the decimal separator always appears.
+    return new Intl.NumberFormat(locale, {
+      style: 'currency',
+      currency,
+      useGrouping: true,
+      minimumFractionDigits: 2,
+      maximumFractionDigits: 2,
+    }).formatToParts(1234567.5);
+  } catch {
+    // Codes Intl rejects as currencies (custom ones that are not three letters): a number format's
+    // separators.
+    return new Intl.NumberFormat(locale, { useGrouping: true }).formatToParts(1234567.5);
+  }
+}
+
+// Zero code points of the decimal digit blocks Intl uses (arab, arabext, deva, beng, thai,
+// fullwide, ...).
+const ZEROS = [
+  0x660, 0x6f0, 0x7c0, 0x966, 0x9e6, 0xa66, 0xae6, 0xb66, 0xbe6, 0xc66, 0xce6, 0xd66, 0xe50, 0xed0,
+  0xf20, 0x1040, 0x17e0, 0x1810, 0xff10,
+];
+const FULLWIDTH_ZERO = 0xff10;
+const LAST_BLOCK_BEFORE_FULLWIDTH = 0x1810;
+function asciiDigit(cp: number): number {
+  if (cp >= 48 && cp <= 57) {
+    return cp - 48;
+  }
+  // Every non-digit character used to scan the whole table. Separators, signs and Latin-1 spaces
+  // are below the first block (U+0660); currency signs such as € (U+20AC) and the narrow no-break
+  // space (U+202F) fall in the gap before the fullwidth digits.
+  if (cp < ZEROS[0]! || (cp > LAST_BLOCK_BEFORE_FULLWIDTH + 9 && cp < FULLWIDTH_ZERO)) {
+    return -1;
+  }
+  // ZEROS is sorted, so the first block above cp ends the search
+  for (let i = 0; i < ZEROS.length; i++) {
+    const zero = ZEROS[i]!;
+    if (cp < zero) {
+      return -1;
+    }
+    if (cp <= zero + 9) {
+      return cp - zero;
+    }
+  }
+  return -1;
+}
+
+/**
+ * Parses a locale-formatted amount: parse('1.234,50 €', 'EUR', 'de-DE'), parse('CHF 1’234.50',
+ * 'CHF', 'de-CH'), parse('١٢٣٫٤٥ US$', 'USD', 'ar-EG'). Currency symbols/codes, spaces and bidi
+ * marks around the number are ignored (the currency is the `currency` argument, never guessed from
+ * the text). A minus sign (ASCII or U+2212) or accounting parentheses anywhere in the affixes make
+ * it negative. Inside the number only digits, the locale's group separator (before the decimal
+ * separator) and one decimal separator are allowed.
+ */
+export function parse<C extends CurrencyInput>(
+  input: string,
+  currency: C,
+  locale?: string,
+  options?: MoneyOptions,
+): Money<C> {
+  const { group, decimal } = symbols(locale, currency);
+  const chars = Array.from(input);
+  let first = -1;
+  let last = -1;
+  for (let i = 0; i < chars.length; i++) {
+    if (asciiDigit(chars[i]!.codePointAt(0)!) >= 0) {
+      if (first < 0) {
+        first = i;
+      }
+      last = i;
+    }
+  }
+  if (first < 0) {
+    throw new SyntaxError(`Cannot parse "${input}": no digits`);
+  }
+  const prefix = chars.slice(0, first).join('');
+  const suffix = chars.slice(last + 1).join('');
+  const affix = prefix + suffix;
+  if (!/^[\p{L}\p{Sc}\p{Z}\s\p{Cf}.()+\-−]*$/u.test(affix)) {
+    throw new SyntaxError(`Cannot parse "${input}": unexpected characters`);
+  }
+  const neg = /[-−(]/.test(affix);
+  const isGroup = (ch: string) =>
+    ch === group ||
+    (/^[\s\p{Z}]$/u.test(group) && /^[\s\p{Z}]$/u.test(ch)) ||
+    ((group === '’' || group === "'") && (ch === "'" || ch === '’')) ||
+    ch === '٬';
+  let out = prefix.endsWith(decimal) ? '0.' : '';
+  let seenDecimal = out !== '';
+  for (let i = first; i <= last; i++) {
+    const ch = chars[i]!;
+    const digit = asciiDigit(ch.codePointAt(0)!);
+    if (digit >= 0) {
+      out += digit;
+    } else if (ch === decimal || ch === '٫') {
+      if (seenDecimal) {
+        throw new SyntaxError(`Cannot parse "${input}": more than one decimal separator`);
+      }
+      seenDecimal = true;
+      out += '.';
+    } else if (isGroup(ch)) {
+      if (seenDecimal) {
+        throw new SyntaxError(
+          `Cannot parse "${input}": group separator after the decimal separator`,
+        );
+      }
+    } else {
+      throw new SyntaxError(`Cannot parse "${input}": unexpected "${ch}"`);
+    }
+  }
+  return money((neg ? '-' : '') + out, currency, options);
+}

package/src/paypal.ts

@@ -0,0 +1,93 @@
+/**
+ * PayPal's amount view for the REST APIs (Orders v2, Payments v2):
+ * https://developer.paypal.com/api/rest/reference/currency-codes/, encoded in data/paypal.json.
+ * `value` is a decimal string in major units, with at most 15 digits before the point:
+ * - HUF, JPY and TWD don't support decimals: "1000", never "1000.00" (ISO 4217 gives HUF and TWD
+ *   2);
+ * - every other listed currency has 2 decimals: "10.99".
+ * BRL, CNY and MYR are for in-country accounts only; that isn't checked here.
+ */
+import { PAYPAL_EXPONENTS } from './generated/paypal.js';
+import { type CurrencyInput, type Money } from './money.js';
+import { fromProcessorDecimal, toProcessorDecimal } from './processor.js';
+import type { RoundingMode } from './rounding.js';
+
+export { PAYPAL_EXPONENTS };
+
+/** The `value` pattern from PayPal's Orders v2 schema. */
+const VALUE_PATTERN = /^((-?[0-9]+)|(-?([0-9]+)?[.][0-9]+))$/;
+
+/** PayPal allows at most 15 digits before the decimal point. */
+const MAX_INTEGER_DIGITS = 15;
+
+/** The `value` field's maxLength in the Orders v2 schema. */
+const MAX_VALUE_LENGTH = 32;
+
+/** The number of decimals PayPal takes for a currency (JPY, HUF, TWD 0; the others 2). */
+export function paypalExponent(currency: string): number {
+  const exponent = PAYPAL_EXPONENTS[currency.toUpperCase()];
+  if (exponent === undefined) {
+    throw new RangeError(`${currency} is not a PayPal currency`);
+  }
+  return exponent;
+}
+
+/** Whether PayPal lists the currency (case-insensitive). */
+export function isPayPalCurrency(currency: string): boolean {
+  return PAYPAL_EXPONENTS[currency.toUpperCase()] !== undefined;
+}
+
+/** Options for the PayPal amount: how to round when PayPal needs a coarser amount. */
+export interface PayPalAmountOptions {
+  /**
+   * How to round when PayPal needs fewer decimals than the value has (default 'unnecessary':
+   * throw).
+   */
+  readonly rounding?: RoundingMode;
+}
+
+/**
+ * The exact `value` string: toPayPalValue(money('10.99', 'USD')) === '10.99', HUF 1000 -> '1000'.
+ * Throws a RangeError for negative amounts (refunds are sent as positive amounts).
+ */
+export function toPayPalValue(money: Money, options?: PayPalAmountOptions): string {
+  const rounding = options?.rounding ?? 'unnecessary';
+
+  // "The amount must be a positive number"; zero stays allowed because the same money object is
+  // used for breakdown fields such as a zero tax_total. Refunds are positive amounts.
+  const value = toProcessorDecimal(
+    'PayPal',
+    money,
+    paypalExponent(money.currency),
+    rounding,
+    'nonNegative',
+  );
+
+  const integerDigits = value.replace('-', '').split('.')[0]!;
+  if (integerDigits.length > MAX_INTEGER_DIGITS) {
+    throw new RangeError(
+      `${money} is too large for PayPal (at most 15 digits before the decimal point)`,
+    );
+  }
+  return value;
+}
+
+/** A PayPal `money` object: `{ currency_code, value }`. */
+export function toPayPal(
+  money: Money,
+  options?: PayPalAmountOptions,
+): { currency_code: string; value: string } {
+  return { currency_code: money.currency.toUpperCase(), value: toPayPalValue(money, options) };
+}
+
+/** Reads a PayPal `money` object exactly: fromPayPal({ currency_code: 'USD', value: '230.00' }). */
+export function fromPayPal<C extends CurrencyInput>(amount: {
+  currency_code: C;
+  value: string;
+}): Money<Uppercase<C>> {
+  const code = amount.currency_code.toUpperCase() as Uppercase<C>;
+
+  // Validates the currency before parsing, so an unlisted currency is the error reported.
+  paypalExponent(code);
+  return fromProcessorDecimal('PayPal', amount.value, code, VALUE_PATTERN, MAX_VALUE_LENGTH);
+}

package/src/plugins/adyen.ts

@@ -0,0 +1,25 @@
+/** `@ducatjs/money/adyen`: Adyen's minor-unit view. Importing this module adds `toAdyen`. */
+import { toAdyen } from '../adyen.js';
+import { extendMoney, type Money } from '../money.js';
+import type { RoundingMode } from '../rounding.js';
+
+export * from '../adyen.js';
+
+declare module '../money.js' {
+  interface Money<C extends string> {
+    /**
+     * Adyen `amount` object: `money('15000', 'IDR').toAdyen()` is `{ value: 15000, currency: 'IDR'
+     * }`.
+     */
+    toAdyen(rounding?: RoundingMode): { value: number; currency: string };
+  }
+}
+
+extendMoney(
+  {
+    toAdyen(this: Money, rounding?: RoundingMode) {
+      return toAdyen(this, rounding);
+    },
+  },
+  { owner: '@ducatjs/money/adyen' },
+);

package/src/plugins/all.ts

@@ -0,0 +1,47 @@
+/** `@ducatjs/money/all`: core plus every opt-in module, with all methods installed. */
+export * from '../index.js';
+// The core Money methods as plain functions too, as in /fn: /all is everything.
+export {
+  add,
+  subtract,
+  negate,
+  abs,
+  multiply,
+  divide,
+  round,
+  toScale,
+  compare,
+  equals,
+  lessThan,
+  lessThanOrEqual,
+  greaterThan,
+  greaterThanOrEqual,
+  isZero,
+  isPositive,
+  isNegative,
+  sign,
+  min,
+  max,
+  clamp,
+  toDecimal,
+  toMinor,
+  toMinorNumber,
+} from '../money.js';
+export * from './allocate.js';
+export * from './tax.js';
+export * from './convert.js';
+export * from './exact.js';
+export * from '../ecb.js';
+export * from '../stripe-fx.js';
+export * from '../adyen-fx.js';
+export * from './cash.js';
+export * from './format.js';
+export * from '../parse.js';
+export * from './stripe.js';
+export * from './adyen.js';
+export * from './checkout.js';
+export * from './paypal.js';
+export * from './braintree.js';
+export * from './klarna.js';
+export * from './prisma.js';
+export * from './fixed.js';

package/src/plugins/allocate.ts

@@ -0,0 +1,53 @@
+/**
+ * `@ducatjs/money/allocate`: allocation, splitting and tranches. Importing this module adds the
+ * methods below to every Money; the free functions are exported too (and from `@ducatjs/money/fn`,
+ * which changes no prototypes).
+ */
+import {
+  allocate,
+  chunk,
+  instalments,
+  schedule,
+  split,
+  type AllocateOptions,
+  type InstalmentOptions,
+  type Tranche,
+  type Weight,
+} from '../allocate.js';
+import { extendMoney, type Money } from '../money.js';
+
+export * from '../allocate.js';
+
+declare module '../money.js' {
+  interface Money<C extends string> {
+    /** Splits by weights; the parts always sum to this. */
+    allocate(weights: readonly Weight[], options?: AllocateOptions): Money<C>[];
+    /** Splits into `count` near-equal parts that sum to this. */
+    split(count: number, options?: AllocateOptions): Money<C>[];
+    instalments(count: number, options?: InstalmentOptions<C>): Money<C>[];
+    schedule(tranches: readonly Tranche<C>[]): Money<C>[];
+    /** Tranches of at most `max`: 1000 by 300 gives 300, 300, 300, 100. */
+    chunk(max: Money<C>): Money<C>[];
+  }
+}
+
+extendMoney(
+  {
+    allocate(this: Money, weights: readonly Weight[], options?: AllocateOptions) {
+      return allocate(this, weights, options);
+    },
+    split(this: Money, count: number, options?: AllocateOptions) {
+      return split(this, count, options);
+    },
+    instalments(this: Money, count: number, options?: InstalmentOptions<string>) {
+      return instalments(this, count, options);
+    },
+    schedule(this: Money, tranches: readonly Tranche<string>[]) {
+      return schedule(this, tranches);
+    },
+    chunk(this: Money, max: Money) {
+      return chunk(this, max);
+    },
+  },
+  { owner: '@ducatjs/money/allocate' },
+);

package/src/plugins/braintree.ts

@@ -0,0 +1,23 @@
+/**
+ * `@ducatjs/money/braintree`: Braintree's amount view. Importing this module adds `toBraintree`.
+ */
+import { toBraintree, type BraintreeAmountOptions } from '../braintree.js';
+import { extendMoney, type Money } from '../money.js';
+
+export * from '../braintree.js';
+
+declare module '../money.js' {
+  interface Money<C extends string> {
+    /** The exact `amount` string for Braintree: `money('10', 'USD').toBraintree()` is '10.00'. */
+    toBraintree(options?: BraintreeAmountOptions): string;
+  }
+}
+
+extendMoney(
+  {
+    toBraintree(this: Money, options?: BraintreeAmountOptions) {
+      return toBraintree(this, options);
+    },
+  },
+  { owner: '@ducatjs/money/braintree' },
+);

package/src/plugins/cash.ts

@@ -0,0 +1,33 @@
+/**
+ * `@ducatjs/money/cash`: cash rounding (cash tenders only; card payments are never rounded) and
+ * rounding to an increment. Importing this module adds the methods below.
+ */
+import { cashRound, roundToIncrement, type CashRoundOptions } from '../cash.js';
+import { extendMoney, type Money } from '../money.js';
+import type { RoundingMode } from '../rounding.js';
+
+export * from '../cash.js';
+
+declare module '../money.js' {
+  interface Money<C extends string> {
+    /**
+     * Rounds a cash total to the local cash step (CHF 0.05, SEK 1, ...); unchanged when no rule
+     * applies.
+     */
+    cashRound(options?: CashRoundOptions): Money<C>;
+    /** Rounds to a multiple of `increment`, e.g. CHF 10.03 to CHF 0.05 gives CHF 10.05. */
+    roundToIncrement(increment: Money<C>, rounding?: RoundingMode): Money<C>;
+  }
+}
+
+extendMoney(
+  {
+    cashRound(this: Money, options?: CashRoundOptions) {
+      return cashRound(this, options);
+    },
+    roundToIncrement(this: Money, increment: Money, rounding?: RoundingMode) {
+      return roundToIncrement(this, increment, rounding);
+    },
+  },
+  { owner: '@ducatjs/money/cash' },
+);

package/src/plugins/checkout.ts

@@ -0,0 +1,32 @@
+/**
+ * `@ducatjs/money/checkout`: Checkout.com's amount view. Importing this module adds `toCheckout`
+ * and `toCheckoutAmount`.
+ */
+import { toCheckout, toCheckoutAmount, type CheckoutAmountOptions } from '../checkout.js';
+import { extendMoney, type Money } from '../money.js';
+
+export * from '../checkout.js';
+
+declare module '../money.js' {
+  interface Money<C extends string> {
+    /**
+     * The integer `amount` to send to Checkout.com: `money('5000', 'CLP').toCheckoutAmount()` is
+     * 500000.
+     */
+    toCheckoutAmount(options?: CheckoutAmountOptions): number;
+    /** `{ amount, currency }` for a Checkout.com payment request. */
+    toCheckout(options?: CheckoutAmountOptions): { amount: number; currency: string };
+  }
+}
+
+extendMoney(
+  {
+    toCheckoutAmount(this: Money, options?: CheckoutAmountOptions) {
+      return toCheckoutAmount(this, options);
+    },
+    toCheckout(this: Money, options?: CheckoutAmountOptions) {
+      return toCheckout(this, options);
+    },
+  },
+  { owner: '@ducatjs/money/checkout' },
+);

package/src/plugins/convert.ts

@@ -0,0 +1,50 @@
+/**
+ * `@ducatjs/money/convert`: currency conversion at exact rates. Importing this module adds
+ * `Money#convert`.
+ */
+import { convert } from '../convert.js';
+import type { Factor } from '../decimal.js';
+import { extendMoney, type CurrencyInput, type Money } from '../money.js';
+import type { ProviderConvertOptions } from '../convert.js';
+import type { RateProvider } from '../provider.js';
+import type { ConvertOptions, Rate } from '../rate.js';
+import type { RoundingMode } from '../rounding.js';
+
+export * from '../convert.js';
+
+declare module '../money.js' {
+  interface Money<C extends string> {
+    /** Converts at a Rate, rounding once: `eur.convert(eurUsd, 'halfEven')`. */
+    convert<To extends string>(
+      rate: Rate<NoInfer<C>, To>,
+      rounding?: RoundingMode,
+      options?: ConvertOptions,
+    ): Money<To>;
+    /** Converts at an exact decimal-string rate: `eur.convert('USD', '1.0832', 'halfEven')`. */
+    convert<To extends CurrencyInput>(
+      to: To,
+      rate: Factor,
+      rounding?: RoundingMode,
+      options?: ConvertOptions,
+    ): Money<To>;
+    /**
+     * Converts through a provider, rounding once: `usd.convert('JPY', via('EUR', ecb),
+     * 'halfEven')`.
+     */
+    convert<To extends CurrencyInput>(
+      to: To,
+      provider: RateProvider,
+      rounding?: RoundingMode,
+      options?: ProviderConvertOptions,
+    ): Money<To>;
+  }
+}
+
+extendMoney(
+  {
+    convert(this: Money, ...args: [never, never?, never?, never?]) {
+      return (convert as (money: Money, ...rest: unknown[]) => Money)(this, ...args);
+    },
+  },
+  { owner: '@ducatjs/money/convert' },
+);

package/src/plugins/exact.ts

@@ -0,0 +1,23 @@
+/**
+ * `@ducatjs/money/exact`: exact rational amounts that round once. Importing this module adds
+ * `Money#exact`.
+ */
+import { exact, type ExactMoney } from '../exact.js';
+import { extendMoney, type Money } from '../money.js';
+
+export * from '../exact.js';
+
+declare module '../money.js' {
+  interface Money<C extends string> {
+    /**
+     * The exact value, for chained arithmetic that rounds once: `price.exact().divide(3).round()`.
+     */
+    exact(): ExactMoney<C>;
+  }
+}
+
+extendMoney({
+  exact(this: Money) {
+    return exact(this);
+  },
+});

package/src/plugins/fixed.ts

@@ -0,0 +1,28 @@
+/**
+ * `@ducatjs/money/fixed`: exact fixed-point decimals without a currency, on the same engine as
+ * Money. Importing this module adds `Money#toFixedPoint()`.
+ */
+import { moneyToFixed, type Fixed } from '../fixed.js';
+import { extendMoney, type Money } from '../money.js';
+
+export * from '../fixed.js';
+
+declare module '../money.js' {
+  interface Money<C extends string> {
+    /**
+     * The exact Fixed of this amount, at its scale: `money('12.34', 'EUR').toFixedPoint()` is
+     * 12.34. Not `toFixed`, which Number, decimal.js and big.js all use for `toFixed(places):
+     * string`.
+     */
+    toFixedPoint(): Fixed;
+  }
+}
+
+extendMoney(
+  {
+    toFixedPoint(this: Money) {
+      return moneyToFixed(this);
+    },
+  },
+  { owner: '@ducatjs/money/fixed' },
+);

package/src/plugins/format.ts

@@ -0,0 +1,28 @@
+/**
+ * `@ducatjs/money/format`: locale formatting through Intl. Importing this module adds the methods
+ * below.
+ */
+import { format, formatToParts } from '../format.js';
+import { extendMoney, type Money } from '../money.js';
+
+export * from '../format.js';
+
+declare module '../money.js' {
+  interface Money<C extends string> {
+    /** Locale formatting via Intl: `price.format('de-DE')` gives "19,99 €" */
+    format(locale?: string, options?: Intl.NumberFormatOptions): string;
+    formatToParts(locale?: string, options?: Intl.NumberFormatOptions): Intl.NumberFormatPart[];
+  }
+}
+
+extendMoney(
+  {
+    format(this: Money, locale?: string, options?: Intl.NumberFormatOptions) {
+      return format(this, locale, options);
+    },
+    formatToParts(this: Money, locale?: string, options?: Intl.NumberFormatOptions) {
+      return formatToParts(this, locale, options);
+    },
+  },
+  { owner: '@ducatjs/money/format' },
+);

package/src/plugins/klarna.ts

@@ -0,0 +1,21 @@
+/** `@ducatjs/money/klarna`: Klarna's amount view. Importing this module adds `toKlarna`. */
+import { toKlarna, type KlarnaAmountOptions } from '../klarna.js';
+import { extendMoney, type Money } from '../money.js';
+
+export * from '../klarna.js';
+
+declare module '../money.js' {
+  interface Money<C extends string> {
+    /** The integer for any Klarna amount field: `money('25', 'EUR').toKlarna()` is 2500. */
+    toKlarna(options?: KlarnaAmountOptions): number;
+  }
+}
+
+extendMoney(
+  {
+    toKlarna(this: Money, options?: KlarnaAmountOptions) {
+      return toKlarna(this, options);
+    },
+  },
+  { owner: '@ducatjs/money/klarna' },
+);

package/src/plugins/paypal.ts

@@ -0,0 +1,29 @@
+/**
+ * `@ducatjs/money/paypal`: PayPal's amount view. Importing this module adds `toPayPal` and
+ * `toPayPalValue`.
+ */
+import { extendMoney, type Money } from '../money.js';
+import { toPayPal, toPayPalValue, type PayPalAmountOptions } from '../paypal.js';
+
+export * from '../paypal.js';
+
+declare module '../money.js' {
+  interface Money<C extends string> {
+    /** The exact `value` string for PayPal: `money('1000', 'HUF').toPayPalValue()` is '1000'. */
+    toPayPalValue(options?: PayPalAmountOptions): string;
+    /** A PayPal `money` object: `{ currency_code, value }`. */
+    toPayPal(options?: PayPalAmountOptions): { currency_code: string; value: string };
+  }
+}
+
+extendMoney(
+  {
+    toPayPalValue(this: Money, options?: PayPalAmountOptions) {
+      return toPayPalValue(this, options);
+    },
+    toPayPal(this: Money, options?: PayPalAmountOptions) {
+      return toPayPal(this, options);
+    },
+  },
+  { owner: '@ducatjs/money/paypal' },
+);

package/src/plugins/prisma.ts

@@ -0,0 +1,24 @@
+/**
+ * `@ducatjs/money/prisma`: Prisma and SQL column helpers. Importing this module adds
+ * `toDecimalValue`.
+ */
+import { extendMoney, type Money } from '../money.js';
+import { toDecimalValue } from '../prisma.js';
+
+export * from '../prisma.js';
+
+declare module '../money.js' {
+  interface Money<C extends string> {
+    /** A Decimal for a NUMERIC column: `m.toDecimalValue(Prisma.Decimal)`. */
+    toDecimalValue<D>(Decimal: new (value: string) => D): D;
+  }
+}
+
+extendMoney(
+  {
+    toDecimalValue(this: Money, Decimal: new (value: string) => unknown) {
+      return toDecimalValue(this, Decimal);
+    },
+  },
+  { owner: '@ducatjs/money/prisma' },
+);