@f-o-t/money 1.1.0

package/dist/shared/chunk-jf6gzvp1.js

@@ -0,0 +1,852 @@
+// src/errors.ts
+class MoneyError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MoneyError";
+    Error.captureStackTrace?.(this, MoneyError);
+  }
+}
+
+class CurrencyMismatchError extends MoneyError {
+  currencyA;
+  currencyB;
+  constructor(message, currencyA, currencyB) {
+    super(message);
+    this.currencyA = currencyA;
+    this.currencyB = currencyB;
+    this.name = "CurrencyMismatchError";
+  }
+  static create(currencyA, currencyB) {
+    return new CurrencyMismatchError(`Cannot operate on different currencies: ${currencyA} and ${currencyB}`, currencyA, currencyB);
+  }
+}
+
+class InvalidAmountError extends MoneyError {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidAmountError";
+  }
+}
+
+class DivisionByZeroError extends MoneyError {
+  constructor(message = "Division by zero") {
+    super(message);
+    this.name = "DivisionByZeroError";
+  }
+}
+
+class UnknownCurrencyError extends MoneyError {
+  currencyCode;
+  constructor(message, currencyCode) {
+    super(message);
+    this.currencyCode = currencyCode;
+    this.name = "UnknownCurrencyError";
+  }
+}
+
+class OverflowError extends MoneyError {
+  constructor(message = "Value exceeds safe integer range") {
+    super(message);
+    this.name = "OverflowError";
+  }
+}
+
+class ScaleMismatchError extends MoneyError {
+  currency;
+  scaleA;
+  scaleB;
+  constructor(message, currency, scaleA, scaleB) {
+    super(message);
+    this.currency = currency;
+    this.scaleA = scaleA;
+    this.scaleB = scaleB;
+    this.name = "ScaleMismatchError";
+  }
+  static create(currency, scaleA, scaleB) {
+    return new ScaleMismatchError(`Scale mismatch for ${currency}: ${scaleA} vs ${scaleB}. Same currency must have same scale.`, currency, scaleA, scaleB);
+  }
+}
+
+// src/core/assertions.ts
+function assertSameCurrency(a, b) {
+  if (a.currency !== b.currency) {
+    throw CurrencyMismatchError.create(a.currency, b.currency);
+  }
+  if (a.scale !== b.scale) {
+    throw ScaleMismatchError.create(a.currency, a.scale, b.scale);
+  }
+}
+function assertAllSameCurrency(moneys) {
+  if (moneys.length === 0)
+    return;
+  const first = moneys[0];
+  for (let i = 1;i < moneys.length; i++) {
+    const current = moneys[i];
+    if (current.currency !== first.currency) {
+      throw CurrencyMismatchError.create(first.currency, current.currency);
+    }
+    if (current.scale !== first.scale) {
+      throw ScaleMismatchError.create(first.currency, first.scale, current.scale);
+    }
+  }
+}
+
+// src/core/rounding.ts
+function bankersRound(value, divisor) {
+  if (divisor === 0n) {
+    throw new Error("Division by zero");
+  }
+  const isNegative = value < 0n !== divisor < 0n;
+  const absValue = value < 0n ? -value : value;
+  const absDivisor = divisor < 0n ? -divisor : divisor;
+  const quotient = absValue / absDivisor;
+  const remainder = absValue % absDivisor;
+  let result;
+  const isExactlyHalf = remainder * 2n === absDivisor;
+  if (isExactlyHalf) {
+    if (quotient % 2n === 0n) {
+      result = quotient;
+    } else {
+      result = quotient + 1n;
+    }
+  } else {
+    const half = absDivisor / 2n;
+    if (remainder <= half) {
+      result = quotient;
+    } else {
+      result = quotient + 1n;
+    }
+  }
+  return isNegative ? -result : result;
+}
+var EXTENDED_PRECISION = 18;
+var PRECISION_FACTOR = 10n ** BigInt(EXTENDED_PRECISION);
+
+// src/core/internal.ts
+function createMoney(amount, currency, scale) {
+  return Object.freeze({ amount, currency, scale });
+}
+function parseDecimalToMinorUnits(amountStr, scale, roundingMode = "truncate") {
+  const normalized = amountStr.trim();
+  const isNegative = normalized.startsWith("-");
+  const absStr = isNegative ? normalized.slice(1) : normalized;
+  const parts = absStr.split(".");
+  const intPart = parts[0] || "0";
+  const decPart = parts[1] || "";
+  if (!/^\d*$/.test(intPart) || !/^\d*$/.test(decPart)) {
+    throw new Error(`Invalid amount format: ${amountStr}`);
+  }
+  let amount;
+  if (decPart.length <= scale) {
+    const adjustedDecPart = decPart.padEnd(scale, "0");
+    const combined = intPart + adjustedDecPart;
+    amount = BigInt(combined);
+  } else if (roundingMode === "truncate") {
+    const adjustedDecPart = decPart.slice(0, scale);
+    const combined = intPart + adjustedDecPart;
+    amount = BigInt(combined);
+  } else {
+    const fullAmount = BigInt(intPart + decPart);
+    const extraDigits = decPart.length - scale;
+    const divisor = 10n ** BigInt(extraDigits);
+    amount = bankersRound(fullAmount, divisor);
+  }
+  return isNegative ? -amount : amount;
+}
+function minorUnitsToDecimal(amount, scale) {
+  if (scale === 0) {
+    return amount.toString();
+  }
+  const isNegative = amount < 0n;
+  const absAmount = isNegative ? -amount : amount;
+  const str = absAmount.toString().padStart(scale + 1, "0");
+  const intPart = str.slice(0, -scale) || "0";
+  const decPart = str.slice(-scale);
+  const result = `${intPart}.${decPart}`;
+  return isNegative ? `-${result}` : result;
+}
+function maxBigInt(a, b) {
+  return a > b ? a : b;
+}
+function minBigInt(a, b) {
+  return a < b ? a : b;
+}
+
+// src/currency/currencies.ts
+var ISO_4217_CURRENCIES = {
+  USD: {
+    code: "USD",
+    numericCode: 840,
+    name: "US Dollar",
+    decimalPlaces: 2,
+    symbol: "$",
+    subunitName: "cent"
+  },
+  CAD: {
+    code: "CAD",
+    numericCode: 124,
+    name: "Canadian Dollar",
+    decimalPlaces: 2,
+    symbol: "C$",
+    subunitName: "cent"
+  },
+  MXN: {
+    code: "MXN",
+    numericCode: 484,
+    name: "Mexican Peso",
+    decimalPlaces: 2,
+    symbol: "$",
+    subunitName: "centavo"
+  },
+  BRL: {
+    code: "BRL",
+    numericCode: 986,
+    name: "Brazilian Real",
+    decimalPlaces: 2,
+    symbol: "R$",
+    subunitName: "centavo"
+  },
+  ARS: {
+    code: "ARS",
+    numericCode: 32,
+    name: "Argentine Peso",
+    decimalPlaces: 2,
+    symbol: "$",
+    subunitName: "centavo"
+  },
+  CLP: {
+    code: "CLP",
+    numericCode: 152,
+    name: "Chilean Peso",
+    decimalPlaces: 0,
+    symbol: "$"
+  },
+  COP: {
+    code: "COP",
+    numericCode: 170,
+    name: "Colombian Peso",
+    decimalPlaces: 2,
+    symbol: "$",
+    subunitName: "centavo"
+  },
+  PEN: {
+    code: "PEN",
+    numericCode: 604,
+    name: "Peruvian Sol",
+    decimalPlaces: 2,
+    symbol: "S/",
+    subunitName: "céntimo"
+  },
+  EUR: {
+    code: "EUR",
+    numericCode: 978,
+    name: "Euro",
+    decimalPlaces: 2,
+    symbol: "€",
+    subunitName: "cent"
+  },
+  GBP: {
+    code: "GBP",
+    numericCode: 826,
+    name: "Pound Sterling",
+    decimalPlaces: 2,
+    symbol: "£",
+    subunitName: "penny"
+  },
+  CHF: {
+    code: "CHF",
+    numericCode: 756,
+    name: "Swiss Franc",
+    decimalPlaces: 2,
+    symbol: "CHF",
+    subunitName: "rappen"
+  },
+  SEK: {
+    code: "SEK",
+    numericCode: 752,
+    name: "Swedish Krona",
+    decimalPlaces: 2,
+    symbol: "kr",
+    subunitName: "öre"
+  },
+  NOK: {
+    code: "NOK",
+    numericCode: 578,
+    name: "Norwegian Krone",
+    decimalPlaces: 2,
+    symbol: "kr",
+    subunitName: "øre"
+  },
+  DKK: {
+    code: "DKK",
+    numericCode: 208,
+    name: "Danish Krone",
+    decimalPlaces: 2,
+    symbol: "kr",
+    subunitName: "øre"
+  },
+  PLN: {
+    code: "PLN",
+    numericCode: 985,
+    name: "Polish Zloty",
+    decimalPlaces: 2,
+    symbol: "zł",
+    subunitName: "grosz"
+  },
+  CZK: {
+    code: "CZK",
+    numericCode: 203,
+    name: "Czech Koruna",
+    decimalPlaces: 2,
+    symbol: "Kč",
+    subunitName: "haléř"
+  },
+  HUF: {
+    code: "HUF",
+    numericCode: 348,
+    name: "Hungarian Forint",
+    decimalPlaces: 2,
+    symbol: "Ft",
+    subunitName: "fillér"
+  },
+  RON: {
+    code: "RON",
+    numericCode: 946,
+    name: "Romanian Leu",
+    decimalPlaces: 2,
+    symbol: "lei",
+    subunitName: "ban"
+  },
+  RUB: {
+    code: "RUB",
+    numericCode: 643,
+    name: "Russian Ruble",
+    decimalPlaces: 2,
+    symbol: "₽",
+    subunitName: "kopek"
+  },
+  TRY: {
+    code: "TRY",
+    numericCode: 949,
+    name: "Turkish Lira",
+    decimalPlaces: 2,
+    symbol: "₺",
+    subunitName: "kuruş"
+  },
+  ISK: {
+    code: "ISK",
+    numericCode: 352,
+    name: "Icelandic Krona",
+    decimalPlaces: 0,
+    symbol: "kr"
+  },
+  JPY: {
+    code: "JPY",
+    numericCode: 392,
+    name: "Japanese Yen",
+    decimalPlaces: 0,
+    symbol: "¥"
+  },
+  CNY: {
+    code: "CNY",
+    numericCode: 156,
+    name: "Chinese Yuan",
+    decimalPlaces: 2,
+    symbol: "¥",
+    subunitName: "fen"
+  },
+  HKD: {
+    code: "HKD",
+    numericCode: 344,
+    name: "Hong Kong Dollar",
+    decimalPlaces: 2,
+    symbol: "HK$",
+    subunitName: "cent"
+  },
+  TWD: {
+    code: "TWD",
+    numericCode: 901,
+    name: "New Taiwan Dollar",
+    decimalPlaces: 2,
+    symbol: "NT$",
+    subunitName: "cent"
+  },
+  KRW: {
+    code: "KRW",
+    numericCode: 410,
+    name: "South Korean Won",
+    decimalPlaces: 0,
+    symbol: "₩"
+  },
+  INR: {
+    code: "INR",
+    numericCode: 356,
+    name: "Indian Rupee",
+    decimalPlaces: 2,
+    symbol: "₹",
+    subunitName: "paisa"
+  },
+  IDR: {
+    code: "IDR",
+    numericCode: 360,
+    name: "Indonesian Rupiah",
+    decimalPlaces: 2,
+    symbol: "Rp",
+    subunitName: "sen"
+  },
+  MYR: {
+    code: "MYR",
+    numericCode: 458,
+    name: "Malaysian Ringgit",
+    decimalPlaces: 2,
+    symbol: "RM",
+    subunitName: "sen"
+  },
+  SGD: {
+    code: "SGD",
+    numericCode: 702,
+    name: "Singapore Dollar",
+    decimalPlaces: 2,
+    symbol: "S$",
+    subunitName: "cent"
+  },
+  THB: {
+    code: "THB",
+    numericCode: 764,
+    name: "Thai Baht",
+    decimalPlaces: 2,
+    symbol: "฿",
+    subunitName: "satang"
+  },
+  PHP: {
+    code: "PHP",
+    numericCode: 608,
+    name: "Philippine Peso",
+    decimalPlaces: 2,
+    symbol: "₱",
+    subunitName: "sentimo"
+  },
+  VND: {
+    code: "VND",
+    numericCode: 704,
+    name: "Vietnamese Dong",
+    decimalPlaces: 0,
+    symbol: "₫"
+  },
+  AUD: {
+    code: "AUD",
+    numericCode: 36,
+    name: "Australian Dollar",
+    decimalPlaces: 2,
+    symbol: "A$",
+    subunitName: "cent"
+  },
+  NZD: {
+    code: "NZD",
+    numericCode: 554,
+    name: "New Zealand Dollar",
+    decimalPlaces: 2,
+    symbol: "NZ$",
+    subunitName: "cent"
+  },
+  AED: {
+    code: "AED",
+    numericCode: 784,
+    name: "UAE Dirham",
+    decimalPlaces: 2,
+    symbol: "د.إ",
+    subunitName: "fils"
+  },
+  SAR: {
+    code: "SAR",
+    numericCode: 682,
+    name: "Saudi Riyal",
+    decimalPlaces: 2,
+    symbol: "﷼",
+    subunitName: "halala"
+  },
+  ILS: {
+    code: "ILS",
+    numericCode: 376,
+    name: "Israeli New Shekel",
+    decimalPlaces: 2,
+    symbol: "₪",
+    subunitName: "agora"
+  },
+  KWD: {
+    code: "KWD",
+    numericCode: 414,
+    name: "Kuwaiti Dinar",
+    decimalPlaces: 3,
+    symbol: "د.ك",
+    subunitName: "fils"
+  },
+  BHD: {
+    code: "BHD",
+    numericCode: 48,
+    name: "Bahraini Dinar",
+    decimalPlaces: 3,
+    symbol: ".د.ب",
+    subunitName: "fils"
+  },
+  OMR: {
+    code: "OMR",
+    numericCode: 512,
+    name: "Omani Rial",
+    decimalPlaces: 3,
+    symbol: "ر.ع.",
+    subunitName: "baisa"
+  },
+  ZAR: {
+    code: "ZAR",
+    numericCode: 710,
+    name: "South African Rand",
+    decimalPlaces: 2,
+    symbol: "R",
+    subunitName: "cent"
+  },
+  EGP: {
+    code: "EGP",
+    numericCode: 818,
+    name: "Egyptian Pound",
+    decimalPlaces: 2,
+    symbol: "E£",
+    subunitName: "piastre"
+  },
+  NGN: {
+    code: "NGN",
+    numericCode: 566,
+    name: "Nigerian Naira",
+    decimalPlaces: 2,
+    symbol: "₦",
+    subunitName: "kobo"
+  },
+  BTC: {
+    code: "BTC",
+    numericCode: 0,
+    name: "Bitcoin",
+    decimalPlaces: 8,
+    symbol: "₿",
+    subunitName: "satoshi"
+  },
+  ETH: {
+    code: "ETH",
+    numericCode: 0,
+    name: "Ethereum",
+    decimalPlaces: 18,
+    symbol: "Ξ",
+    subunitName: "wei"
+  }
+};
+
+// src/currency/registry.ts
+var customCurrencies = new Map;
+function getCurrency(code) {
+  const upperCode = code.toUpperCase();
+  const custom = customCurrencies.get(upperCode);
+  if (custom)
+    return custom;
+  const iso = ISO_4217_CURRENCIES[upperCode];
+  if (iso)
+    return iso;
+  throw new UnknownCurrencyError(`Unknown currency: ${code}`, upperCode);
+}
+function registerCurrency(currency) {
+  customCurrencies.set(currency.code.toUpperCase(), currency);
+}
+function hasCurrency(code) {
+  const upperCode = code.toUpperCase();
+  return customCurrencies.has(upperCode) || upperCode in ISO_4217_CURRENCIES;
+}
+function getAllCurrencies() {
+  return {
+    ...ISO_4217_CURRENCIES,
+    ...Object.fromEntries(customCurrencies)
+  };
+}
+function clearCustomCurrencies() {
+  customCurrencies.clear();
+}
+
+// src/core/money.ts
+function hasLikelyPrecisionIssue(num) {
+  if (!Number.isFinite(num))
+    return false;
+  if (Number.isInteger(num))
+    return false;
+  const str = num.toString();
+  const decimalPart = str.split(".")[1];
+  if (!decimalPart)
+    return false;
+  if (decimalPart.length > 10) {
+    return true;
+  }
+  if (/0{4,}|9{4,}/.test(decimalPart)) {
+    return true;
+  }
+  return false;
+}
+function of(amount, currency, roundingMode) {
+  const curr = getCurrency(currency);
+  const scale = curr.decimalPlaces;
+  let amountStr;
+  if (typeof amount === "number") {
+    if (hasLikelyPrecisionIssue(amount)) {
+      console.warn(`Money.of() received number ${amount} which may have precision issues. ` + `Consider using string amounts: of("${amount}", "${currency}") instead.`);
+    }
+    amountStr = amount.toString();
+  } else {
+    amountStr = amount;
+  }
+  try {
+    const minorUnits = parseDecimalToMinorUnits(amountStr, scale, roundingMode ?? "truncate");
+    return createMoney(minorUnits, currency.toUpperCase(), scale);
+  } catch {
+    throw new InvalidAmountError(`Invalid amount format: ${amountStr}`);
+  }
+}
+function ofRounded(amount, currency) {
+  return of(amount, currency, "round");
+}
+function fromMinorUnits(minorUnits, currency) {
+  const curr = getCurrency(currency);
+  if (typeof minorUnits === "number") {
+    if (!Number.isInteger(minorUnits)) {
+      throw new InvalidAmountError(`Minor units must be an integer, got: ${minorUnits}`);
+    }
+    if (!Number.isFinite(minorUnits)) {
+      throw new InvalidAmountError("Minor units must be finite");
+    }
+  }
+  const amount = typeof minorUnits === "number" ? BigInt(minorUnits) : minorUnits;
+  return createMoney(amount, currency.toUpperCase(), curr.decimalPlaces);
+}
+function zero(currency) {
+  const curr = getCurrency(currency);
+  return createMoney(0n, currency.toUpperCase(), curr.decimalPlaces);
+}
+function fromMajorUnits(amount, currency) {
+  return of(amount, currency);
+}
+
+// src/schemas.ts
+import { z } from "zod";
+var CurrencyCodeSchema = z.string().length(3, "Currency code must be exactly 3 characters").regex(/^[A-Z]{3}$/, "Currency code must be 3 uppercase letters").describe("ISO 4217 currency code");
+var CurrencySchema = z.object({
+  code: CurrencyCodeSchema,
+  numericCode: z.number().int().min(0).describe("ISO 4217 numeric code (0 for custom)"),
+  name: z.string().min(1).describe("Full currency name"),
+  decimalPlaces: z.number().int().min(0).max(18).describe("Number of decimal places"),
+  symbol: z.string().optional().describe("Currency symbol"),
+  subunitName: z.string().optional().describe("Name of minor unit")
+}).describe("Currency definition");
+var AmountStringSchema = z.string().regex(/^-?\d+(\.\d+)?$/, "Amount must be a valid decimal string").describe("Decimal amount as string");
+var MoneySchema = z.object({
+  amount: AmountStringSchema,
+  currency: CurrencyCodeSchema
+}).describe("Money JSON representation");
+var DatabaseMoneySchema = z.object({
+  amount: z.string().describe("Decimal amount as string"),
+  currency: CurrencyCodeSchema
+}).describe("Database Money representation");
+var MoneyInputSchema = z.object({
+  amount: z.union([z.string(), z.number()]).describe("Amount (string or number)"),
+  currency: CurrencyCodeSchema
+}).describe("Money input from user");
+var MoneyInternalSchema = z.object({
+  amount: z.bigint().describe("Amount in minor units as BigInt"),
+  currency: CurrencyCodeSchema,
+  scale: z.number().int().min(0).max(18).describe("Decimal places")
+}).describe("Internal Money representation");
+var FormatOptionsSchema = z.object({
+  locale: z.string().optional(),
+  notation: z.enum(["standard", "compact"]).optional(),
+  signDisplay: z.enum(["auto", "always", "never", "exceptZero"]).optional(),
+  currencyDisplay: z.enum(["symbol", "code", "name", "narrowSymbol"]).optional(),
+  hideSymbol: z.boolean().optional(),
+  minimumFractionDigits: z.number().int().min(0).optional(),
+  maximumFractionDigits: z.number().int().min(0).optional()
+}).describe("Money formatting options");
+var AllocationRatiosSchema = z.array(z.number().min(0, "Ratios cannot be negative")).min(1, "At least one ratio is required").refine((ratios) => ratios.some((r) => r > 0), {
+  message: "At least one ratio must be greater than zero"
+}).describe("Allocation ratios");
+
+// src/operations/comparison.ts
+import { createOperator } from "@f-o-t/condition-evaluator";
+import { z as z2 } from "zod";
+function toMoney(value) {
+  if (value === null || value === undefined) {
+    throw new Error("Cannot convert null/undefined to Money");
+  }
+  if (typeof value === "object" && "amount" in value && "currency" in value && "scale" in value && typeof value.amount === "bigint") {
+    return value;
+  }
+  if (typeof value === "object" && "amount" in value && "currency" in value && typeof value.amount === "string") {
+    const json = value;
+    return of(json.amount, json.currency);
+  }
+  throw new Error(`Cannot convert value to Money: ${JSON.stringify(value)}`);
+}
+var moneyEqualsOperator = createOperator({
+  name: "money_eq",
+  type: "custom",
+  description: "Check if two Money values are equal",
+  evaluate: (actual, expected) => {
+    const a = toMoney(actual);
+    const b = toMoney(expected);
+    assertSameCurrency(a, b);
+    return a.amount === b.amount;
+  },
+  valueSchema: MoneySchema,
+  reasonGenerator: (passed, actual, expected, field) => {
+    const a = toMoney(actual);
+    const b = toMoney(expected);
+    if (passed) {
+      return `${field} equals ${minorUnitsToDecimal(b.amount, b.scale)} ${b.currency}`;
+    }
+    return `${field} (${minorUnitsToDecimal(a.amount, a.scale)} ${a.currency}) does not equal ${minorUnitsToDecimal(b.amount, b.scale)} ${b.currency}`;
+  }
+});
+var moneyNotEqualsOperator = createOperator({
+  name: "money_neq",
+  type: "custom",
+  description: "Check if two Money values are not equal",
+  evaluate: (actual, expected) => {
+    const a = toMoney(actual);
+    const b = toMoney(expected);
+    assertSameCurrency(a, b);
+    return a.amount !== b.amount;
+  },
+  valueSchema: MoneySchema
+});
+var moneyGreaterThanOperator = createOperator({
+  name: "money_gt",
+  type: "custom",
+  description: "Check if Money value is greater than expected",
+  evaluate: (actual, expected) => {
+    const a = toMoney(actual);
+    const b = toMoney(expected);
+    assertSameCurrency(a, b);
+    return a.amount > b.amount;
+  },
+  valueSchema: MoneySchema
+});
+var moneyGreaterThanOrEqualOperator = createOperator({
+  name: "money_gte",
+  type: "custom",
+  description: "Check if Money value is greater than or equal to expected",
+  evaluate: (actual, expected) => {
+    const a = toMoney(actual);
+    const b = toMoney(expected);
+    assertSameCurrency(a, b);
+    return a.amount >= b.amount;
+  },
+  valueSchema: MoneySchema
+});
+var moneyLessThanOperator = createOperator({
+  name: "money_lt",
+  type: "custom",
+  description: "Check if Money value is less than expected",
+  evaluate: (actual, expected) => {
+    const a = toMoney(actual);
+    const b = toMoney(expected);
+    assertSameCurrency(a, b);
+    return a.amount < b.amount;
+  },
+  valueSchema: MoneySchema
+});
+var moneyLessThanOrEqualOperator = createOperator({
+  name: "money_lte",
+  type: "custom",
+  description: "Check if Money value is less than or equal to expected",
+  evaluate: (actual, expected) => {
+    const a = toMoney(actual);
+    const b = toMoney(expected);
+    assertSameCurrency(a, b);
+    return a.amount <= b.amount;
+  },
+  valueSchema: MoneySchema
+});
+var moneyBetweenOperator = createOperator({
+  name: "money_between",
+  type: "custom",
+  description: "Check if Money value is between two values (inclusive)",
+  evaluate: (actual, expected) => {
+    if (!Array.isArray(expected) || expected.length !== 2) {
+      throw new Error("Expected value must be an array of two Money values");
+    }
+    const a = toMoney(actual);
+    const min = toMoney(expected[0]);
+    const max = toMoney(expected[1]);
+    assertSameCurrency(a, min);
+    assertSameCurrency(a, max);
+    return a.amount >= min.amount && a.amount <= max.amount;
+  },
+  valueSchema: z2.tuple([MoneySchema, MoneySchema])
+});
+var moneyPositiveOperator = createOperator({
+  name: "money_positive",
+  type: "custom",
+  description: "Check if Money value is positive (> 0)",
+  evaluate: (actual) => {
+    const a = toMoney(actual);
+    return a.amount > 0n;
+  }
+});
+var moneyNegativeOperator = createOperator({
+  name: "money_negative",
+  type: "custom",
+  description: "Check if Money value is negative (< 0)",
+  evaluate: (actual) => {
+    const a = toMoney(actual);
+    return a.amount < 0n;
+  }
+});
+var moneyZeroOperator = createOperator({
+  name: "money_zero",
+  type: "custom",
+  description: "Check if Money value is zero",
+  evaluate: (actual) => {
+    const a = toMoney(actual);
+    return a.amount === 0n;
+  }
+});
+function equals(a, b) {
+  assertSameCurrency(a, b);
+  return a.amount === b.amount;
+}
+function greaterThan(a, b) {
+  assertSameCurrency(a, b);
+  return a.amount > b.amount;
+}
+function greaterThanOrEqual(a, b) {
+  assertSameCurrency(a, b);
+  return a.amount >= b.amount;
+}
+function lessThan(a, b) {
+  assertSameCurrency(a, b);
+  return a.amount < b.amount;
+}
+function lessThanOrEqual(a, b) {
+  assertSameCurrency(a, b);
+  return a.amount <= b.amount;
+}
+function isPositive(money) {
+  return money.amount > 0n;
+}
+function isNegative(money) {
+  return money.amount < 0n;
+}
+function isZero(money) {
+  return money.amount === 0n;
+}
+function compare(a, b) {
+  assertSameCurrency(a, b);
+  if (a.amount < b.amount)
+    return -1;
+  if (a.amount > b.amount)
+    return 1;
+  return 0;
+}
+
+export { MoneyError, CurrencyMismatchError, InvalidAmountError, DivisionByZeroError, UnknownCurrencyError, OverflowError, ScaleMismatchError, assertSameCurrency, assertAllSameCurrency, bankersRound, EXTENDED_PRECISION, PRECISION_FACTOR, createMoney, parseDecimalToMinorUnits, minorUnitsToDecimal, maxBigInt, minBigInt, ISO_4217_CURRENCIES, getCurrency, registerCurrency, hasCurrency, getAllCurrencies, clearCustomCurrencies, of, ofRounded, fromMinorUnits, zero, fromMajorUnits, CurrencyCodeSchema, CurrencySchema, AmountStringSchema, MoneySchema, DatabaseMoneySchema, MoneyInputSchema, MoneyInternalSchema, FormatOptionsSchema, AllocationRatiosSchema, moneyEqualsOperator, moneyNotEqualsOperator, moneyGreaterThanOperator, moneyGreaterThanOrEqualOperator, moneyLessThanOperator, moneyLessThanOrEqualOperator, moneyBetweenOperator, moneyPositiveOperator, moneyNegativeOperator, moneyZeroOperator, equals, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, isPositive, isNegative, isZero, compare };