@azghr/specie 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,28 @@
+# Changelog
+
+## [0.1.0] - 2026-07-22
+
+### Added
+- Complete Money implementation with integer-cents arithmetic
+- Currency-aware formatting via Intl.NumberFormat
+- Largest-remainder allocation algorithm for exact bill splitting
+- Half-even (banker's), half-up, down, and up rounding modes
+- Safe integer validation and overflow protection
+- Currency mismatch protection with CurrencyMismatch error
+- Comprehensive test suite with 54 tests covering all invariants and edge cases
+- Runnable demo with printed evidence of package claims
+
+### Fixed
+- fromDecimal now correctly uses getCurrencyFractionDigits instead of hardcoded value
+- Negative decimal string parsing ("-10.50" → -1050 cents)
+- Multiply overflow protection (caps at MAX_SAFE_INTEGER/MIN_SAFE_INTEGER)
+
+### Documentation
+- Complete README with API documentation, usage examples, and non-goals
+- Seven-section demo showing float bug prevention, allocation, rounding, and formatting
+- TypeScript examples for full type safety
+
+## 0.1.0 (2026-07-22)
+
+### Added
+- Initial package scaffold with TypeScript, ESLint, and Vitest configuration

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 npmdevkit authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,127 @@
+# specie
+
+Tiny integer-cents money type — safe arithmetic, currency-aware rounding, Intl formatting. No bignum, no dependencies.
+
+## The Problem
+
+`0.1 + 0.2 !== 0.3`. Storing money as floats produces rounding errors and audit nightmares. Correct money is integer minor units + a currency + explicit rounding + locale formatting.
+
+This is competitive space: dinero.js, big.js, and decimal.js cover arbitrary decimals. specie is worth building only because it stays radically smaller: integer minor units only, currency-aware default fractions via Intl, and a few explicit operations.
+
+## Install
+
+```bash
+npm install @azghr/specie
+```
+
+## Use
+
+```typescript
+import { money, fromDecimal } from "@azghr/specie";
+
+// 10-second copy-paste
+const price = money(1999, "USD");           // $19.99 as 1999 cents
+price.add(money(100, "USD")).format();    // "$20.99"
+
+// Realistic usage
+const subtotal = fromDecimal("19.99", "USD");
+const tax = subtotal.multiply(0.0825);     // 8.25% tax
+const total = subtotal.add(tax);
+total.format();                          // "$21.64"
+```
+
+## API
+
+### `money(amount: number, currency: string): Money`
+Create Money from integer minor units. `amount` must be a safe integer.
+
+```typescript
+money(1999, "USD")  // $19.99
+money(500, "JPY")   // ¥500
+```
+
+### `fromDecimal(value: string, currency: string): Money`
+Parse decimal string to Money. Never uses float parsing to avoid rounding errors.
+
+```typescript
+fromDecimal("19.99", "USD")  // 1999 cents
+fromDecimal("-10.50", "USD") // -1050 cents
+```
+
+### `Money.add(other: Money): Money`
+Add another Money value (same currency only). Throws `CurrencyMismatch` on currency mismatch.
+
+### `Money.subtract(other: Money): Money`
+Subtract another Money value (same currency only).
+
+### `Money.multiply(factor: number, rounding?: Rounding): Money`
+Multiply by a factor with rounding. Default: `"half-even"` (banker's rounding).
+
+```typescript
+money(1000, "USD").multiply(1.0825)              // Apply 8.25% tax
+money(100, "USD").multiply(1.5, "half-up")       // Force ties up
+```
+
+### `Money.allocate(ratios: readonly number[]): Money[]`
+Distribute by ratios using largest-remainder method. Parts sum exactly to the original amount.
+
+```typescript
+money(100, "USD").allocate([3, 2])  // [$60, $40] (not $59.99/$40.01)
+```
+
+### `Money.format(locale?: string): string`
+Format using `Intl.NumberFormat`.
+
+```typescript
+money(1999, "USD").format()        // "$19.99"
+money(123456, "JPY").format("ja-JP") // "￥123,456" (no decimals)
+```
+
+### `Money.compare(other: Money): -1 | 0 | 1`
+Compare with another Money. Throws `CurrencyMismatch` on currency mismatch.
+
+### `Money.equals(other: Money): boolean`
+Check equality.
+
+### `Money.isZero()`, `Money.isNegative()`, `Money.isPositive()`
+Check amount sign.
+
+### `Money.toJSON(): { amount: number; currency: string }`
+Serialize to plain object.
+
+### Type: `Rounding`
+
+```typescript
+"half-up" | "half-even" | "down" | "up"
+```
+
+### Class: `CurrencyMismatch`
+
+Error thrown when operations mix different currencies.
+
+## Non-Goals
+
+Use dinero.js or decimal.js for:
+- Arbitrary precision / values beyond `Number.MAX_SAFE_INTEGER`
+- Multi-currency conversion / forex
+- Historical rates
+- Crypto amounts with 18 decimals
+
+## TypeScript Note
+
+```typescript
+import { money, fromDecimal } from "@azghr/specie";
+
+// Full type safety
+const price: Money = money(1999, "USD");
+const total: Money = price.add(money(500, "USD"));
+
+// Currency mismatch caught at compile time
+const usd = money(100, "USD");
+const eur = money(100, "EUR");
+// usd.add(eur) // TypeScript: this works, runtime throws CurrencyMismatch
+```
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,251 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CurrencyMismatch: () => CurrencyMismatch,
+  default: () => money,
+  fromDecimal: () => fromDecimal,
+  money: () => money
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/format.ts
+var FRACTION_DIGITS = {
+  JPY: 0,
+  USD: 2,
+  EUR: 2,
+  GBP: 2,
+  CAD: 2,
+  AUD: 2,
+  CHF: 2,
+  CNY: 2,
+  INR: 2
+};
+function getCurrencyFractionDigits(currency) {
+  try {
+    const formatter = new Intl.NumberFormat("en-US", {
+      style: "currency",
+      currency
+    });
+    const resolved = formatter.resolvedOptions();
+    if (resolved.fractionDigits !== void 0) {
+      return resolved.fractionDigits;
+    }
+    if (resolved.minimumFractionDigits !== void 0) {
+      return resolved.minimumFractionDigits;
+    }
+  } catch {
+  }
+  return FRACTION_DIGITS[currency] ?? 2;
+}
+function formatMoney(amount, currency, locale = "en-US") {
+  const fractionDigits = getCurrencyFractionDigits(currency);
+  const divisor = Math.pow(10, fractionDigits);
+  const majorAmount = amount / divisor;
+  const formatter = new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency,
+    minimumFractionDigits: fractionDigits,
+    maximumFractionDigits: fractionDigits
+  });
+  return formatter.format(majorAmount);
+}
+
+// src/allocate.ts
+function allocate(totalAmount, ratios) {
+  if (ratios.length === 0) {
+    throw new RangeError("Cannot allocate with empty ratios");
+  }
+  const totalRatio = ratios.reduce((sum, ratio) => sum + ratio, 0);
+  if (totalRatio <= 0) {
+    throw new RangeError("Ratios must sum to a positive value");
+  }
+  const allocations = [];
+  const remainders = [];
+  let distributed = 0;
+  for (let i = 0; i < ratios.length; i++) {
+    const ratio = ratios[i];
+    if (ratio === void 0) continue;
+    const exact = totalAmount * ratio / totalRatio;
+    const floored = Math.floor(exact);
+    allocations.push(floored);
+    remainders.push({ index: i, remainder: exact - floored });
+    distributed += floored;
+  }
+  const remainder = totalAmount - distributed;
+  const sortedByRemainder = remainders.map((r, index) => ({ ...r, originalIndex: index })).sort((a, b) => {
+    if (b.remainder !== a.remainder) {
+      return b.remainder - a.remainder;
+    }
+    return a.originalIndex - b.originalIndex;
+  });
+  for (let i = 0; i < remainder && i < sortedByRemainder.length; i++) {
+    const item = sortedByRemainder[i];
+    if (item) {
+      const idx = item.originalIndex;
+      allocations[idx] = (allocations[idx] ?? 0) + 1;
+    }
+  }
+  return allocations;
+}
+
+// src/errors.ts
+var CurrencyMismatch = class extends Error {
+  constructor() {
+    super("Currency mismatch: operations require matching currencies");
+    this.name = "CurrencyMismatch";
+  }
+};
+
+// src/money.ts
+var MoneyImpl = class _MoneyImpl {
+  constructor(amount, currency) {
+    this.amount = amount;
+    this.currency = currency;
+    if (!Number.isSafeInteger(amount)) {
+      throw new RangeError(
+        `Amount must be a safe integer, got: ${String(amount)}`
+      );
+    }
+  }
+  amount;
+  currency;
+  add(other) {
+    this.ensureSameCurrency(other);
+    return new _MoneyImpl(this.amount + other.amount, this.currency);
+  }
+  subtract(other) {
+    this.ensureSameCurrency(other);
+    return new _MoneyImpl(this.amount - other.amount, this.currency);
+  }
+  multiply(factor, rounding = "half-even") {
+    const exact = this.amount * factor;
+    const rounded = this.applyRounding(exact, rounding);
+    if (rounded > Number.MAX_SAFE_INTEGER) {
+      return new _MoneyImpl(Number.MAX_SAFE_INTEGER, this.currency);
+    }
+    if (rounded < Number.MIN_SAFE_INTEGER) {
+      return new _MoneyImpl(Number.MIN_SAFE_INTEGER, this.currency);
+    }
+    return new _MoneyImpl(rounded, this.currency);
+  }
+  allocate(ratios) {
+    const allocations = allocate(this.amount, ratios);
+    return allocations.map((amount) => new _MoneyImpl(amount, this.currency));
+  }
+  compare(other) {
+    this.ensureSameCurrency(other);
+    if (this.amount < other.amount) return -1;
+    if (this.amount > other.amount) return 1;
+    return 0;
+  }
+  equals(other) {
+    return this.compare(other) === 0;
+  }
+  isZero() {
+    return this.amount === 0;
+  }
+  isNegative() {
+    return this.amount < 0;
+  }
+  isPositive() {
+    return this.amount > 0;
+  }
+  format(locale = "en-US") {
+    return formatMoney(this.amount, this.currency, locale);
+  }
+  toJSON() {
+    return { amount: this.amount, currency: this.currency };
+  }
+  ensureSameCurrency(other) {
+    if (this.currency !== other.currency) {
+      throw new CurrencyMismatch();
+    }
+  }
+  applyRounding(value, mode) {
+    if (Number.isSafeInteger(value)) {
+      return value;
+    }
+    switch (mode) {
+      case "half-up": {
+        const fractional = value - Math.floor(value);
+        if (fractional === 0.5) {
+          return Math.ceil(value);
+        }
+        return Math.round(value);
+      }
+      case "half-even": {
+        const rounded = Math.round(value);
+        const isHalf = Math.abs(value - rounded) === 0.5;
+        if (isHalf) {
+          return Math.round(value / 2) * 2;
+        }
+        return rounded;
+      }
+      case "down":
+        return Math.floor(value);
+      case "up":
+        return Math.ceil(value);
+      default:
+        return Math.round(value);
+    }
+  }
+};
+function money(amount, currency) {
+  return new MoneyImpl(amount, currency);
+}
+function fromDecimal(value, currency) {
+  const fractionDigits = getCurrencyFractionDigits(currency);
+  const parts = value.split(".");
+  if (parts.length > 2) {
+    throw new RangeError(`Invalid decimal format: ${value}`);
+  }
+  const integerPart = parts[0] || "0";
+  const fractionalPart = parts[1] || "";
+  const isNegative = integerPart.startsWith("-");
+  const absIntegerPart = isNegative ? integerPart.slice(1) : integerPart;
+  if (absIntegerPart === "0" && (fractionalPart === "" || fractionalPart === "0")) {
+    return money(0, currency);
+  }
+  if (fractionalPart.length > fractionDigits) {
+    const hasExtraDigits = fractionalPart.slice(fractionDigits).split("").some((d) => d !== "0");
+    if (hasExtraDigits) {
+      throw new RangeError(
+        `Too many fraction digits for ${currency}: ${value} (max ${String(fractionDigits)})`
+      );
+    }
+  }
+  const majorUnits = parseInt(absIntegerPart, 10);
+  let minorUnits = 0;
+  if (fractionalPart.length > 0) {
+    const padded = fractionalPart.padEnd(fractionDigits, "0");
+    minorUnits = parseInt(padded, 10);
+  }
+  const totalAmount = majorUnits * Math.pow(10, fractionDigits) + minorUnits;
+  return money(isNegative ? -totalAmount : totalAmount, currency);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CurrencyMismatch,
+  fromDecimal,
+  money
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/format.ts","../src/allocate.ts","../src/errors.ts","../src/money.ts"],"sourcesContent":["/**\n * specie - Tiny integer-cents money type\n *\n * Safe arithmetic, currency-aware rounding, Intl formatting.\n * No bignum, no dependencies.\n */\n\n// Re-export everything from money.ts (main module)\nexport {\n  money,\n  fromDecimal,\n  type Money,\n  type Rounding,\n  CurrencyMismatch,\n} from \"./money.js\";\n\n// Default export\nexport { money as default } from \"./money.js\";\n","/**\n * Currency fraction digits fallback table for common currencies.\n * Used when Intl.NumberFormat is not available or returns unexpected results.\n */\nconst FRACTION_DIGITS: Record<string, number> = {\n  JPY: 0,\n  USD: 2,\n  EUR: 2,\n  GBP: 2,\n  CAD: 2,\n  AUD: 2,\n  CHF: 2,\n  CNY: 2,\n  INR: 2,\n};\n\n/**\n * Get the number of fraction digits for a currency code.\n * Uses Intl.NumberFormat if available, with fallback table.\n *\n * @param currency - ISO 4217 currency code\n * @returns Number of fraction digits (usually 0 or 2)\n */\nexport function getCurrencyFractionDigits(currency: string): number {\n  try {\n    // Try to get from Intl\n    const formatter = new Intl.NumberFormat(\"en-US\", {\n      style: \"currency\",\n      currency,\n    });\n\n    const resolved =\n      formatter.resolvedOptions() as Intl.ResolvedNumberFormatOptions & {\n        fractionDigits?: number;\n        minimumFractionDigits?: number;\n        maximumFractionDigits?: number;\n      };\n\n    if (resolved.fractionDigits !== undefined) {\n      return resolved.fractionDigits;\n    }\n\n    // Use minimum/maximum as fallback\n    if (resolved.minimumFractionDigits !== undefined) {\n      return resolved.minimumFractionDigits;\n    }\n  } catch {\n    // Fall through to fallback table\n  }\n\n  // Use fallback table\n  return FRACTION_DIGITS[currency] ?? 2;\n}\n\n/**\n * Format a money amount using Intl.NumberFormat.\n *\n * @param amount - Amount in minor units (e.g. cents)\n * @param currency - ISO 4217 currency code\n * @param locale - Locale string (default: \"en-US\")\n * @returns Formatted currency string\n */\nexport function formatMoney(\n  amount: number,\n  currency: string,\n  locale: string = \"en-US\",\n): string {\n  const fractionDigits = getCurrencyFractionDigits(currency);\n  const divisor = Math.pow(10, fractionDigits);\n  const majorAmount = amount / divisor;\n\n  const formatter = new Intl.NumberFormat(locale, {\n    style: \"currency\",\n    currency,\n    minimumFractionDigits: fractionDigits,\n    maximumFractionDigits: fractionDigits,\n  });\n\n  return formatter.format(majorAmount);\n}\n","/**\n * Largest-remainder method for allocating money amounts by ratios.\n * Ensures that parts sum exactly to the original amount with no penny lost.\n *\n * @param totalAmount - Total amount in minor units to allocate\n * @param ratios - Array of ratios for allocation (must sum > 0)\n * @returns Array of allocated amounts that sum to totalAmount\n * @throws RangeError if ratios don't sum to positive value\n */\nexport function allocate(\n  totalAmount: number,\n  ratios: readonly number[],\n): number[] {\n  if (ratios.length === 0) {\n    throw new RangeError(\"Cannot allocate with empty ratios\");\n  }\n\n  const totalRatio = ratios.reduce((sum, ratio) => sum + ratio, 0);\n  if (totalRatio <= 0) {\n    throw new RangeError(\"Ratios must sum to a positive value\");\n  }\n\n  // Calculate initial floored allocations and remainders\n  const allocations: number[] = [];\n  const remainders: Array<{ index: number; remainder: number }> = [];\n  let distributed = 0;\n\n  for (let i = 0; i < ratios.length; i++) {\n    const ratio = ratios[i];\n    if (ratio === undefined) continue;\n\n    const exact = (totalAmount * ratio) / totalRatio;\n    const floored = Math.floor(exact);\n    allocations.push(floored);\n    remainders.push({ index: i, remainder: exact - floored });\n    distributed += floored;\n  }\n\n  // Distribute remaining units to items with largest remainders\n  const remainder = totalAmount - distributed;\n\n  // Sort by remainder (descending) and give extra to items with largest remainders\n  // Earlier items get priority when remainders are equal\n  const sortedByRemainder = remainders\n    .map((r, index) => ({ ...r, originalIndex: index }))\n    .sort((a, b) => {\n      if (b.remainder !== a.remainder) {\n        return b.remainder - a.remainder; // Larger remainder first\n      }\n      return a.originalIndex - b.originalIndex; // Earlier index first for ties\n    });\n\n  for (let i = 0; i < remainder && i < sortedByRemainder.length; i++) {\n    const item = sortedByRemainder[i];\n    if (item) {\n      const idx = item.originalIndex;\n      allocations[idx] = (allocations[idx] ?? 0) + 1;\n    }\n  }\n\n  return allocations;\n}\n","/**\n * Error thrown when operations are attempted on Money objects with different currencies.\n */\nexport class CurrencyMismatch extends Error {\n  constructor() {\n    super(\"Currency mismatch: operations require matching currencies\");\n    this.name = \"CurrencyMismatch\";\n  }\n}\n","import { formatMoney, getCurrencyFractionDigits } from \"./format.js\";\nimport { allocate } from \"./allocate.js\";\nimport { CurrencyMismatch } from \"./errors.js\";\n\n/**\n * Rounding modes for multiply operations.\n */\nexport type Rounding = \"half-up\" | \"half-even\" | \"down\" | \"up\";\n\n/**\n * Money value object - immutable representation of an amount in a specific currency.\n * Uses integer minor units (e.g. cents) to avoid floating-point rounding errors.\n */\nexport interface Money {\n  /** Amount in minor units (e.g. cents for USD) - must be a safe integer */\n  readonly amount: number;\n  /** ISO 4217 currency code */\n  readonly currency: string;\n\n  /**\n   * Add another Money value (same currency only).\n   * @throws CurrencyMismatch if currencies differ\n   */\n  add(other: Money): Money;\n\n  /**\n   * Subtract another Money value (same currency only).\n   * @throws CurrencyMismatch if currencies differ\n   */\n  subtract(other: Money): Money;\n\n  /**\n   * Multiply by a factor with optional rounding mode.\n   * @param factor - Multiplication factor (can be fractional, e.g. 1.0825 for 8.25% tax)\n   * @param rounding - Rounding mode (default: \"half-even\")\n   */\n  multiply(factor: number, rounding?: Rounding): Money;\n\n  /**\n   * Allocate amount by integer ratios using largest-remainder method.\n   * Parts always sum exactly to the original amount.\n   * @param ratios - Array of ratios (must sum > 0)\n   * @throws RangeError if ratios don't sum to positive value\n   */\n  allocate(ratios: readonly number[]): Money[];\n\n  /**\n   * Compare with another Money value (same currency only).\n   * @returns -1 if less, 0 if equal, 1 if greater\n   * @throws CurrencyMismatch if currencies differ\n   */\n  compare(other: Money): -1 | 0 | 1;\n\n  /**\n   * Check equality with another Money value (same currency only).\n   * @throws CurrencyMismatch if currencies differ\n   */\n  equals(other: Money): boolean;\n\n  /** Check if amount is zero */\n  isZero(): boolean;\n  /** Check if amount is negative */\n  isNegative(): boolean;\n  /** Check if amount is positive */\n  isPositive(): boolean;\n\n  /**\n   * Format using Intl.NumberFormat.\n   * @param locale - Locale string (default: \"en-US\")\n   */\n  format(locale?: string): string;\n\n  /** Serialize to plain object */\n  toJSON(): { amount: number; currency: string };\n}\n\n/**\n * Create a Money implementation class.\n */\nclass MoneyImpl implements Money {\n  constructor(\n    public readonly amount: number,\n    public readonly currency: string,\n  ) {\n    // Validate safe integer\n    if (!Number.isSafeInteger(amount)) {\n      throw new RangeError(\n        `Amount must be a safe integer, got: ${String(amount)}`,\n      );\n    }\n  }\n\n  add(other: Money): Money {\n    this.ensureSameCurrency(other);\n    return new MoneyImpl(this.amount + other.amount, this.currency);\n  }\n\n  subtract(other: Money): Money {\n    this.ensureSameCurrency(other);\n    return new MoneyImpl(this.amount - other.amount, this.currency);\n  }\n\n  multiply(factor: number, rounding: Rounding = \"half-even\"): Money {\n    const exact = this.amount * factor;\n    const rounded = this.applyRounding(exact, rounding);\n\n    // Check if result exceeds safe integer range before capping\n    if (rounded > Number.MAX_SAFE_INTEGER) {\n      return new MoneyImpl(Number.MAX_SAFE_INTEGER, this.currency);\n    }\n    if (rounded < Number.MIN_SAFE_INTEGER) {\n      return new MoneyImpl(Number.MIN_SAFE_INTEGER, this.currency);\n    }\n\n    return new MoneyImpl(rounded, this.currency);\n  }\n\n  allocate(ratios: readonly number[]): Money[] {\n    const allocations = allocate(this.amount, ratios);\n    return allocations.map((amount) => new MoneyImpl(amount, this.currency));\n  }\n\n  compare(other: Money): -1 | 0 | 1 {\n    this.ensureSameCurrency(other);\n    if (this.amount < other.amount) return -1;\n    if (this.amount > other.amount) return 1;\n    return 0;\n  }\n\n  equals(other: Money): boolean {\n    return this.compare(other) === 0;\n  }\n\n  isZero(): boolean {\n    return this.amount === 0;\n  }\n\n  isNegative(): boolean {\n    return this.amount < 0;\n  }\n\n  isPositive(): boolean {\n    return this.amount > 0;\n  }\n\n  format(locale: string = \"en-US\"): string {\n    return formatMoney(this.amount, this.currency, locale);\n  }\n\n  toJSON(): { amount: number; currency: string } {\n    return { amount: this.amount, currency: this.currency };\n  }\n\n  private ensureSameCurrency(other: Money): void {\n    if (this.currency !== other.currency) {\n      throw new CurrencyMismatch();\n    }\n  }\n\n  private applyRounding(value: number, mode: Rounding): number {\n    if (Number.isSafeInteger(value)) {\n      return value;\n    }\n\n    switch (mode) {\n      case \"half-up\": {\n        // Round to nearest, with ties going up\n        const fractional = value - Math.floor(value);\n        if (fractional === 0.5) {\n          return Math.ceil(value);\n        }\n        return Math.round(value);\n      }\n      case \"half-even\": {\n        // Banker's rounding: round to nearest even integer\n        const rounded = Math.round(value);\n        const isHalf = Math.abs(value - rounded) === 0.5;\n        if (isHalf) {\n          // Round to nearest even\n          return Math.round(value / 2) * 2;\n        }\n        return rounded;\n      }\n      case \"down\":\n        return Math.floor(value);\n      case \"up\":\n        return Math.ceil(value);\n      default:\n        return Math.round(value);\n    }\n  }\n}\n\n/**\n * Factory function to create Money objects.\n *\n * @param amount - Amount in minor units (e.g. cents for USD)\n * @param currency - ISO 4217 currency code\n * @throws RangeError if amount is not a safe integer\n */\nexport function money(amount: number, currency: string): Money {\n  return new MoneyImpl(amount, currency);\n}\n\n/**\n * Create Money from a decimal string representation.\n * Parses a string like \"19.99\" to 1999 cents for USD.\n * Never uses float parsing to avoid reintroducing float errors.\n *\n * @param value - Decimal string (e.g. \"19.99\")\n * @param currency - ISO 4217 currency code\n * @throws RangeError if value has more fraction digits than currency allows\n */\nexport function fromDecimal(value: string, currency: string): Money {\n  // Get fraction digits for currency (FIX: use the proper function)\n  const fractionDigits = getCurrencyFractionDigits(currency);\n\n  // Parse the string\n  const parts = value.split(\".\");\n  if (parts.length > 2) {\n    throw new RangeError(`Invalid decimal format: ${value}`);\n  }\n\n  const integerPart = parts[0] || \"0\";\n  const fractionalPart = parts[1] || \"\";\n\n  // Handle negative numbers\n  const isNegative = integerPart.startsWith(\"-\");\n  const absIntegerPart = isNegative ? integerPart.slice(1) : integerPart;\n\n  // Handle special case: \"-0\" or \"-0.\" should be 0\n  if (\n    absIntegerPart === \"0\" &&\n    (fractionalPart === \"\" || fractionalPart === \"0\")\n  ) {\n    return money(0, currency);\n  }\n\n  // Validate fraction digits\n  if (fractionalPart.length > fractionDigits) {\n    // Check if it can be cleanly rounded\n    const hasExtraDigits = fractionalPart\n      .slice(fractionDigits)\n      .split(\"\")\n      .some((d) => d !== \"0\");\n    if (hasExtraDigits) {\n      throw new RangeError(\n        `Too many fraction digits for ${currency}: ${value} (max ${String(fractionDigits)})`,\n      );\n    }\n  }\n\n  // Convert to integer minor units\n  const majorUnits = parseInt(absIntegerPart, 10);\n  let minorUnits = 0;\n\n  if (fractionalPart.length > 0) {\n    const padded = fractionalPart.padEnd(fractionDigits, \"0\");\n    minorUnits = parseInt(padded, 10);\n  }\n\n  const totalAmount = majorUnits * Math.pow(10, fractionDigits) + minorUnits;\n  return money(isNegative ? -totalAmount : totalAmount, currency);\n}\n\n// Re-export CurrencyMismatch for convenience\nexport { CurrencyMismatch };\n"],"mappings":"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","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,91 @@
+/**
+ * Error thrown when operations are attempted on Money objects with different currencies.
+ */
+declare class CurrencyMismatch extends Error {
+    constructor();
+}
+
+/**
+ * Rounding modes for multiply operations.
+ */
+type Rounding = "half-up" | "half-even" | "down" | "up";
+/**
+ * Money value object - immutable representation of an amount in a specific currency.
+ * Uses integer minor units (e.g. cents) to avoid floating-point rounding errors.
+ */
+interface Money {
+    /** Amount in minor units (e.g. cents for USD) - must be a safe integer */
+    readonly amount: number;
+    /** ISO 4217 currency code */
+    readonly currency: string;
+    /**
+     * Add another Money value (same currency only).
+     * @throws CurrencyMismatch if currencies differ
+     */
+    add(other: Money): Money;
+    /**
+     * Subtract another Money value (same currency only).
+     * @throws CurrencyMismatch if currencies differ
+     */
+    subtract(other: Money): Money;
+    /**
+     * Multiply by a factor with optional rounding mode.
+     * @param factor - Multiplication factor (can be fractional, e.g. 1.0825 for 8.25% tax)
+     * @param rounding - Rounding mode (default: "half-even")
+     */
+    multiply(factor: number, rounding?: Rounding): Money;
+    /**
+     * Allocate amount by integer ratios using largest-remainder method.
+     * Parts always sum exactly to the original amount.
+     * @param ratios - Array of ratios (must sum > 0)
+     * @throws RangeError if ratios don't sum to positive value
+     */
+    allocate(ratios: readonly number[]): Money[];
+    /**
+     * Compare with another Money value (same currency only).
+     * @returns -1 if less, 0 if equal, 1 if greater
+     * @throws CurrencyMismatch if currencies differ
+     */
+    compare(other: Money): -1 | 0 | 1;
+    /**
+     * Check equality with another Money value (same currency only).
+     * @throws CurrencyMismatch if currencies differ
+     */
+    equals(other: Money): boolean;
+    /** Check if amount is zero */
+    isZero(): boolean;
+    /** Check if amount is negative */
+    isNegative(): boolean;
+    /** Check if amount is positive */
+    isPositive(): boolean;
+    /**
+     * Format using Intl.NumberFormat.
+     * @param locale - Locale string (default: "en-US")
+     */
+    format(locale?: string): string;
+    /** Serialize to plain object */
+    toJSON(): {
+        amount: number;
+        currency: string;
+    };
+}
+/**
+ * Factory function to create Money objects.
+ *
+ * @param amount - Amount in minor units (e.g. cents for USD)
+ * @param currency - ISO 4217 currency code
+ * @throws RangeError if amount is not a safe integer
+ */
+declare function money(amount: number, currency: string): Money;
+/**
+ * Create Money from a decimal string representation.
+ * Parses a string like "19.99" to 1999 cents for USD.
+ * Never uses float parsing to avoid reintroducing float errors.
+ *
+ * @param value - Decimal string (e.g. "19.99")
+ * @param currency - ISO 4217 currency code
+ * @throws RangeError if value has more fraction digits than currency allows
+ */
+declare function fromDecimal(value: string, currency: string): Money;
+
+export { CurrencyMismatch, type Money, type Rounding, money as default, fromDecimal, money };

package/dist/index.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Error thrown when operations are attempted on Money objects with different currencies.
+ */
+declare class CurrencyMismatch extends Error {
+    constructor();
+}
+
+/**
+ * Rounding modes for multiply operations.
+ */
+type Rounding = "half-up" | "half-even" | "down" | "up";
+/**
+ * Money value object - immutable representation of an amount in a specific currency.
+ * Uses integer minor units (e.g. cents) to avoid floating-point rounding errors.
+ */
+interface Money {
+    /** Amount in minor units (e.g. cents for USD) - must be a safe integer */
+    readonly amount: number;
+    /** ISO 4217 currency code */
+    readonly currency: string;
+    /**
+     * Add another Money value (same currency only).
+     * @throws CurrencyMismatch if currencies differ
+     */
+    add(other: Money): Money;
+    /**
+     * Subtract another Money value (same currency only).
+     * @throws CurrencyMismatch if currencies differ
+     */
+    subtract(other: Money): Money;
+    /**
+     * Multiply by a factor with optional rounding mode.
+     * @param factor - Multiplication factor (can be fractional, e.g. 1.0825 for 8.25% tax)
+     * @param rounding - Rounding mode (default: "half-even")
+     */
+    multiply(factor: number, rounding?: Rounding): Money;
+    /**
+     * Allocate amount by integer ratios using largest-remainder method.
+     * Parts always sum exactly to the original amount.
+     * @param ratios - Array of ratios (must sum > 0)
+     * @throws RangeError if ratios don't sum to positive value
+     */
+    allocate(ratios: readonly number[]): Money[];
+    /**
+     * Compare with another Money value (same currency only).
+     * @returns -1 if less, 0 if equal, 1 if greater
+     * @throws CurrencyMismatch if currencies differ
+     */
+    compare(other: Money): -1 | 0 | 1;
+    /**
+     * Check equality with another Money value (same currency only).
+     * @throws CurrencyMismatch if currencies differ
+     */
+    equals(other: Money): boolean;
+    /** Check if amount is zero */
+    isZero(): boolean;
+    /** Check if amount is negative */
+    isNegative(): boolean;
+    /** Check if amount is positive */
+    isPositive(): boolean;
+    /**
+     * Format using Intl.NumberFormat.
+     * @param locale - Locale string (default: "en-US")
+     */
+    format(locale?: string): string;
+    /** Serialize to plain object */
+    toJSON(): {
+        amount: number;
+        currency: string;
+    };
+}
+/**
+ * Factory function to create Money objects.
+ *
+ * @param amount - Amount in minor units (e.g. cents for USD)
+ * @param currency - ISO 4217 currency code
+ * @throws RangeError if amount is not a safe integer
+ */
+declare function money(amount: number, currency: string): Money;
+/**
+ * Create Money from a decimal string representation.
+ * Parses a string like "19.99" to 1999 cents for USD.
+ * Never uses float parsing to avoid reintroducing float errors.
+ *
+ * @param value - Decimal string (e.g. "19.99")
+ * @param currency - ISO 4217 currency code
+ * @throws RangeError if value has more fraction digits than currency allows
+ */
+declare function fromDecimal(value: string, currency: string): Money;
+
+export { CurrencyMismatch, type Money, type Rounding, money as default, fromDecimal, money };

package/dist/index.js

@@ -0,0 +1,222 @@
+// src/format.ts
+var FRACTION_DIGITS = {
+  JPY: 0,
+  USD: 2,
+  EUR: 2,
+  GBP: 2,
+  CAD: 2,
+  AUD: 2,
+  CHF: 2,
+  CNY: 2,
+  INR: 2
+};
+function getCurrencyFractionDigits(currency) {
+  try {
+    const formatter = new Intl.NumberFormat("en-US", {
+      style: "currency",
+      currency
+    });
+    const resolved = formatter.resolvedOptions();
+    if (resolved.fractionDigits !== void 0) {
+      return resolved.fractionDigits;
+    }
+    if (resolved.minimumFractionDigits !== void 0) {
+      return resolved.minimumFractionDigits;
+    }
+  } catch {
+  }
+  return FRACTION_DIGITS[currency] ?? 2;
+}
+function formatMoney(amount, currency, locale = "en-US") {
+  const fractionDigits = getCurrencyFractionDigits(currency);
+  const divisor = Math.pow(10, fractionDigits);
+  const majorAmount = amount / divisor;
+  const formatter = new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency,
+    minimumFractionDigits: fractionDigits,
+    maximumFractionDigits: fractionDigits
+  });
+  return formatter.format(majorAmount);
+}
+
+// src/allocate.ts
+function allocate(totalAmount, ratios) {
+  if (ratios.length === 0) {
+    throw new RangeError("Cannot allocate with empty ratios");
+  }
+  const totalRatio = ratios.reduce((sum, ratio) => sum + ratio, 0);
+  if (totalRatio <= 0) {
+    throw new RangeError("Ratios must sum to a positive value");
+  }
+  const allocations = [];
+  const remainders = [];
+  let distributed = 0;
+  for (let i = 0; i < ratios.length; i++) {
+    const ratio = ratios[i];
+    if (ratio === void 0) continue;
+    const exact = totalAmount * ratio / totalRatio;
+    const floored = Math.floor(exact);
+    allocations.push(floored);
+    remainders.push({ index: i, remainder: exact - floored });
+    distributed += floored;
+  }
+  const remainder = totalAmount - distributed;
+  const sortedByRemainder = remainders.map((r, index) => ({ ...r, originalIndex: index })).sort((a, b) => {
+    if (b.remainder !== a.remainder) {
+      return b.remainder - a.remainder;
+    }
+    return a.originalIndex - b.originalIndex;
+  });
+  for (let i = 0; i < remainder && i < sortedByRemainder.length; i++) {
+    const item = sortedByRemainder[i];
+    if (item) {
+      const idx = item.originalIndex;
+      allocations[idx] = (allocations[idx] ?? 0) + 1;
+    }
+  }
+  return allocations;
+}
+
+// src/errors.ts
+var CurrencyMismatch = class extends Error {
+  constructor() {
+    super("Currency mismatch: operations require matching currencies");
+    this.name = "CurrencyMismatch";
+  }
+};
+
+// src/money.ts
+var MoneyImpl = class _MoneyImpl {
+  constructor(amount, currency) {
+    this.amount = amount;
+    this.currency = currency;
+    if (!Number.isSafeInteger(amount)) {
+      throw new RangeError(
+        `Amount must be a safe integer, got: ${String(amount)}`
+      );
+    }
+  }
+  amount;
+  currency;
+  add(other) {
+    this.ensureSameCurrency(other);
+    return new _MoneyImpl(this.amount + other.amount, this.currency);
+  }
+  subtract(other) {
+    this.ensureSameCurrency(other);
+    return new _MoneyImpl(this.amount - other.amount, this.currency);
+  }
+  multiply(factor, rounding = "half-even") {
+    const exact = this.amount * factor;
+    const rounded = this.applyRounding(exact, rounding);
+    if (rounded > Number.MAX_SAFE_INTEGER) {
+      return new _MoneyImpl(Number.MAX_SAFE_INTEGER, this.currency);
+    }
+    if (rounded < Number.MIN_SAFE_INTEGER) {
+      return new _MoneyImpl(Number.MIN_SAFE_INTEGER, this.currency);
+    }
+    return new _MoneyImpl(rounded, this.currency);
+  }
+  allocate(ratios) {
+    const allocations = allocate(this.amount, ratios);
+    return allocations.map((amount) => new _MoneyImpl(amount, this.currency));
+  }
+  compare(other) {
+    this.ensureSameCurrency(other);
+    if (this.amount < other.amount) return -1;
+    if (this.amount > other.amount) return 1;
+    return 0;
+  }
+  equals(other) {
+    return this.compare(other) === 0;
+  }
+  isZero() {
+    return this.amount === 0;
+  }
+  isNegative() {
+    return this.amount < 0;
+  }
+  isPositive() {
+    return this.amount > 0;
+  }
+  format(locale = "en-US") {
+    return formatMoney(this.amount, this.currency, locale);
+  }
+  toJSON() {
+    return { amount: this.amount, currency: this.currency };
+  }
+  ensureSameCurrency(other) {
+    if (this.currency !== other.currency) {
+      throw new CurrencyMismatch();
+    }
+  }
+  applyRounding(value, mode) {
+    if (Number.isSafeInteger(value)) {
+      return value;
+    }
+    switch (mode) {
+      case "half-up": {
+        const fractional = value - Math.floor(value);
+        if (fractional === 0.5) {
+          return Math.ceil(value);
+        }
+        return Math.round(value);
+      }
+      case "half-even": {
+        const rounded = Math.round(value);
+        const isHalf = Math.abs(value - rounded) === 0.5;
+        if (isHalf) {
+          return Math.round(value / 2) * 2;
+        }
+        return rounded;
+      }
+      case "down":
+        return Math.floor(value);
+      case "up":
+        return Math.ceil(value);
+      default:
+        return Math.round(value);
+    }
+  }
+};
+function money(amount, currency) {
+  return new MoneyImpl(amount, currency);
+}
+function fromDecimal(value, currency) {
+  const fractionDigits = getCurrencyFractionDigits(currency);
+  const parts = value.split(".");
+  if (parts.length > 2) {
+    throw new RangeError(`Invalid decimal format: ${value}`);
+  }
+  const integerPart = parts[0] || "0";
+  const fractionalPart = parts[1] || "";
+  const isNegative = integerPart.startsWith("-");
+  const absIntegerPart = isNegative ? integerPart.slice(1) : integerPart;
+  if (absIntegerPart === "0" && (fractionalPart === "" || fractionalPart === "0")) {
+    return money(0, currency);
+  }
+  if (fractionalPart.length > fractionDigits) {
+    const hasExtraDigits = fractionalPart.slice(fractionDigits).split("").some((d) => d !== "0");
+    if (hasExtraDigits) {
+      throw new RangeError(
+        `Too many fraction digits for ${currency}: ${value} (max ${String(fractionDigits)})`
+      );
+    }
+  }
+  const majorUnits = parseInt(absIntegerPart, 10);
+  let minorUnits = 0;
+  if (fractionalPart.length > 0) {
+    const padded = fractionalPart.padEnd(fractionDigits, "0");
+    minorUnits = parseInt(padded, 10);
+  }
+  const totalAmount = majorUnits * Math.pow(10, fractionDigits) + minorUnits;
+  return money(isNegative ? -totalAmount : totalAmount, currency);
+}
+export {
+  CurrencyMismatch,
+  money as default,
+  fromDecimal,
+  money
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/format.ts","../src/allocate.ts","../src/errors.ts","../src/money.ts"],"sourcesContent":["/**\n * Currency fraction digits fallback table for common currencies.\n * Used when Intl.NumberFormat is not available or returns unexpected results.\n */\nconst FRACTION_DIGITS: Record<string, number> = {\n  JPY: 0,\n  USD: 2,\n  EUR: 2,\n  GBP: 2,\n  CAD: 2,\n  AUD: 2,\n  CHF: 2,\n  CNY: 2,\n  INR: 2,\n};\n\n/**\n * Get the number of fraction digits for a currency code.\n * Uses Intl.NumberFormat if available, with fallback table.\n *\n * @param currency - ISO 4217 currency code\n * @returns Number of fraction digits (usually 0 or 2)\n */\nexport function getCurrencyFractionDigits(currency: string): number {\n  try {\n    // Try to get from Intl\n    const formatter = new Intl.NumberFormat(\"en-US\", {\n      style: \"currency\",\n      currency,\n    });\n\n    const resolved =\n      formatter.resolvedOptions() as Intl.ResolvedNumberFormatOptions & {\n        fractionDigits?: number;\n        minimumFractionDigits?: number;\n        maximumFractionDigits?: number;\n      };\n\n    if (resolved.fractionDigits !== undefined) {\n      return resolved.fractionDigits;\n    }\n\n    // Use minimum/maximum as fallback\n    if (resolved.minimumFractionDigits !== undefined) {\n      return resolved.minimumFractionDigits;\n    }\n  } catch {\n    // Fall through to fallback table\n  }\n\n  // Use fallback table\n  return FRACTION_DIGITS[currency] ?? 2;\n}\n\n/**\n * Format a money amount using Intl.NumberFormat.\n *\n * @param amount - Amount in minor units (e.g. cents)\n * @param currency - ISO 4217 currency code\n * @param locale - Locale string (default: \"en-US\")\n * @returns Formatted currency string\n */\nexport function formatMoney(\n  amount: number,\n  currency: string,\n  locale: string = \"en-US\",\n): string {\n  const fractionDigits = getCurrencyFractionDigits(currency);\n  const divisor = Math.pow(10, fractionDigits);\n  const majorAmount = amount / divisor;\n\n  const formatter = new Intl.NumberFormat(locale, {\n    style: \"currency\",\n    currency,\n    minimumFractionDigits: fractionDigits,\n    maximumFractionDigits: fractionDigits,\n  });\n\n  return formatter.format(majorAmount);\n}\n","/**\n * Largest-remainder method for allocating money amounts by ratios.\n * Ensures that parts sum exactly to the original amount with no penny lost.\n *\n * @param totalAmount - Total amount in minor units to allocate\n * @param ratios - Array of ratios for allocation (must sum > 0)\n * @returns Array of allocated amounts that sum to totalAmount\n * @throws RangeError if ratios don't sum to positive value\n */\nexport function allocate(\n  totalAmount: number,\n  ratios: readonly number[],\n): number[] {\n  if (ratios.length === 0) {\n    throw new RangeError(\"Cannot allocate with empty ratios\");\n  }\n\n  const totalRatio = ratios.reduce((sum, ratio) => sum + ratio, 0);\n  if (totalRatio <= 0) {\n    throw new RangeError(\"Ratios must sum to a positive value\");\n  }\n\n  // Calculate initial floored allocations and remainders\n  const allocations: number[] = [];\n  const remainders: Array<{ index: number; remainder: number }> = [];\n  let distributed = 0;\n\n  for (let i = 0; i < ratios.length; i++) {\n    const ratio = ratios[i];\n    if (ratio === undefined) continue;\n\n    const exact = (totalAmount * ratio) / totalRatio;\n    const floored = Math.floor(exact);\n    allocations.push(floored);\n    remainders.push({ index: i, remainder: exact - floored });\n    distributed += floored;\n  }\n\n  // Distribute remaining units to items with largest remainders\n  const remainder = totalAmount - distributed;\n\n  // Sort by remainder (descending) and give extra to items with largest remainders\n  // Earlier items get priority when remainders are equal\n  const sortedByRemainder = remainders\n    .map((r, index) => ({ ...r, originalIndex: index }))\n    .sort((a, b) => {\n      if (b.remainder !== a.remainder) {\n        return b.remainder - a.remainder; // Larger remainder first\n      }\n      return a.originalIndex - b.originalIndex; // Earlier index first for ties\n    });\n\n  for (let i = 0; i < remainder && i < sortedByRemainder.length; i++) {\n    const item = sortedByRemainder[i];\n    if (item) {\n      const idx = item.originalIndex;\n      allocations[idx] = (allocations[idx] ?? 0) + 1;\n    }\n  }\n\n  return allocations;\n}\n","/**\n * Error thrown when operations are attempted on Money objects with different currencies.\n */\nexport class CurrencyMismatch extends Error {\n  constructor() {\n    super(\"Currency mismatch: operations require matching currencies\");\n    this.name = \"CurrencyMismatch\";\n  }\n}\n","import { formatMoney, getCurrencyFractionDigits } from \"./format.js\";\nimport { allocate } from \"./allocate.js\";\nimport { CurrencyMismatch } from \"./errors.js\";\n\n/**\n * Rounding modes for multiply operations.\n */\nexport type Rounding = \"half-up\" | \"half-even\" | \"down\" | \"up\";\n\n/**\n * Money value object - immutable representation of an amount in a specific currency.\n * Uses integer minor units (e.g. cents) to avoid floating-point rounding errors.\n */\nexport interface Money {\n  /** Amount in minor units (e.g. cents for USD) - must be a safe integer */\n  readonly amount: number;\n  /** ISO 4217 currency code */\n  readonly currency: string;\n\n  /**\n   * Add another Money value (same currency only).\n   * @throws CurrencyMismatch if currencies differ\n   */\n  add(other: Money): Money;\n\n  /**\n   * Subtract another Money value (same currency only).\n   * @throws CurrencyMismatch if currencies differ\n   */\n  subtract(other: Money): Money;\n\n  /**\n   * Multiply by a factor with optional rounding mode.\n   * @param factor - Multiplication factor (can be fractional, e.g. 1.0825 for 8.25% tax)\n   * @param rounding - Rounding mode (default: \"half-even\")\n   */\n  multiply(factor: number, rounding?: Rounding): Money;\n\n  /**\n   * Allocate amount by integer ratios using largest-remainder method.\n   * Parts always sum exactly to the original amount.\n   * @param ratios - Array of ratios (must sum > 0)\n   * @throws RangeError if ratios don't sum to positive value\n   */\n  allocate(ratios: readonly number[]): Money[];\n\n  /**\n   * Compare with another Money value (same currency only).\n   * @returns -1 if less, 0 if equal, 1 if greater\n   * @throws CurrencyMismatch if currencies differ\n   */\n  compare(other: Money): -1 | 0 | 1;\n\n  /**\n   * Check equality with another Money value (same currency only).\n   * @throws CurrencyMismatch if currencies differ\n   */\n  equals(other: Money): boolean;\n\n  /** Check if amount is zero */\n  isZero(): boolean;\n  /** Check if amount is negative */\n  isNegative(): boolean;\n  /** Check if amount is positive */\n  isPositive(): boolean;\n\n  /**\n   * Format using Intl.NumberFormat.\n   * @param locale - Locale string (default: \"en-US\")\n   */\n  format(locale?: string): string;\n\n  /** Serialize to plain object */\n  toJSON(): { amount: number; currency: string };\n}\n\n/**\n * Create a Money implementation class.\n */\nclass MoneyImpl implements Money {\n  constructor(\n    public readonly amount: number,\n    public readonly currency: string,\n  ) {\n    // Validate safe integer\n    if (!Number.isSafeInteger(amount)) {\n      throw new RangeError(\n        `Amount must be a safe integer, got: ${String(amount)}`,\n      );\n    }\n  }\n\n  add(other: Money): Money {\n    this.ensureSameCurrency(other);\n    return new MoneyImpl(this.amount + other.amount, this.currency);\n  }\n\n  subtract(other: Money): Money {\n    this.ensureSameCurrency(other);\n    return new MoneyImpl(this.amount - other.amount, this.currency);\n  }\n\n  multiply(factor: number, rounding: Rounding = \"half-even\"): Money {\n    const exact = this.amount * factor;\n    const rounded = this.applyRounding(exact, rounding);\n\n    // Check if result exceeds safe integer range before capping\n    if (rounded > Number.MAX_SAFE_INTEGER) {\n      return new MoneyImpl(Number.MAX_SAFE_INTEGER, this.currency);\n    }\n    if (rounded < Number.MIN_SAFE_INTEGER) {\n      return new MoneyImpl(Number.MIN_SAFE_INTEGER, this.currency);\n    }\n\n    return new MoneyImpl(rounded, this.currency);\n  }\n\n  allocate(ratios: readonly number[]): Money[] {\n    const allocations = allocate(this.amount, ratios);\n    return allocations.map((amount) => new MoneyImpl(amount, this.currency));\n  }\n\n  compare(other: Money): -1 | 0 | 1 {\n    this.ensureSameCurrency(other);\n    if (this.amount < other.amount) return -1;\n    if (this.amount > other.amount) return 1;\n    return 0;\n  }\n\n  equals(other: Money): boolean {\n    return this.compare(other) === 0;\n  }\n\n  isZero(): boolean {\n    return this.amount === 0;\n  }\n\n  isNegative(): boolean {\n    return this.amount < 0;\n  }\n\n  isPositive(): boolean {\n    return this.amount > 0;\n  }\n\n  format(locale: string = \"en-US\"): string {\n    return formatMoney(this.amount, this.currency, locale);\n  }\n\n  toJSON(): { amount: number; currency: string } {\n    return { amount: this.amount, currency: this.currency };\n  }\n\n  private ensureSameCurrency(other: Money): void {\n    if (this.currency !== other.currency) {\n      throw new CurrencyMismatch();\n    }\n  }\n\n  private applyRounding(value: number, mode: Rounding): number {\n    if (Number.isSafeInteger(value)) {\n      return value;\n    }\n\n    switch (mode) {\n      case \"half-up\": {\n        // Round to nearest, with ties going up\n        const fractional = value - Math.floor(value);\n        if (fractional === 0.5) {\n          return Math.ceil(value);\n        }\n        return Math.round(value);\n      }\n      case \"half-even\": {\n        // Banker's rounding: round to nearest even integer\n        const rounded = Math.round(value);\n        const isHalf = Math.abs(value - rounded) === 0.5;\n        if (isHalf) {\n          // Round to nearest even\n          return Math.round(value / 2) * 2;\n        }\n        return rounded;\n      }\n      case \"down\":\n        return Math.floor(value);\n      case \"up\":\n        return Math.ceil(value);\n      default:\n        return Math.round(value);\n    }\n  }\n}\n\n/**\n * Factory function to create Money objects.\n *\n * @param amount - Amount in minor units (e.g. cents for USD)\n * @param currency - ISO 4217 currency code\n * @throws RangeError if amount is not a safe integer\n */\nexport function money(amount: number, currency: string): Money {\n  return new MoneyImpl(amount, currency);\n}\n\n/**\n * Create Money from a decimal string representation.\n * Parses a string like \"19.99\" to 1999 cents for USD.\n * Never uses float parsing to avoid reintroducing float errors.\n *\n * @param value - Decimal string (e.g. \"19.99\")\n * @param currency - ISO 4217 currency code\n * @throws RangeError if value has more fraction digits than currency allows\n */\nexport function fromDecimal(value: string, currency: string): Money {\n  // Get fraction digits for currency (FIX: use the proper function)\n  const fractionDigits = getCurrencyFractionDigits(currency);\n\n  // Parse the string\n  const parts = value.split(\".\");\n  if (parts.length > 2) {\n    throw new RangeError(`Invalid decimal format: ${value}`);\n  }\n\n  const integerPart = parts[0] || \"0\";\n  const fractionalPart = parts[1] || \"\";\n\n  // Handle negative numbers\n  const isNegative = integerPart.startsWith(\"-\");\n  const absIntegerPart = isNegative ? integerPart.slice(1) : integerPart;\n\n  // Handle special case: \"-0\" or \"-0.\" should be 0\n  if (\n    absIntegerPart === \"0\" &&\n    (fractionalPart === \"\" || fractionalPart === \"0\")\n  ) {\n    return money(0, currency);\n  }\n\n  // Validate fraction digits\n  if (fractionalPart.length > fractionDigits) {\n    // Check if it can be cleanly rounded\n    const hasExtraDigits = fractionalPart\n      .slice(fractionDigits)\n      .split(\"\")\n      .some((d) => d !== \"0\");\n    if (hasExtraDigits) {\n      throw new RangeError(\n        `Too many fraction digits for ${currency}: ${value} (max ${String(fractionDigits)})`,\n      );\n    }\n  }\n\n  // Convert to integer minor units\n  const majorUnits = parseInt(absIntegerPart, 10);\n  let minorUnits = 0;\n\n  if (fractionalPart.length > 0) {\n    const padded = fractionalPart.padEnd(fractionDigits, \"0\");\n    minorUnits = parseInt(padded, 10);\n  }\n\n  const totalAmount = majorUnits * Math.pow(10, fractionDigits) + minorUnits;\n  return money(isNegative ? -totalAmount : totalAmount, currency);\n}\n\n// Re-export CurrencyMismatch for convenience\nexport { CurrencyMismatch };\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@azghr/specie",
+  "version": "0.1.0",
+  "description": "Tiny integer-cents money type — safe arithmetic, currency-aware rounding, Intl formatting. No bignum, no dependencies.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --sourcemap --clean",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src test examples",
+    "demo": "tsx examples/demo.ts",
+    "check": "npm run typecheck && npm run lint && npm run test && npm run build",
+    "prepublishOnly": "npm run check"
+  },
+  "keywords": [
+    "money",
+    "currency",
+    "arithmetic",
+    "formatting",
+    "intl",
+    "cents",
+    "financial",
+    "decimal",
+    "rounding",
+    "allocation"
+  ],
+  "devDependencies": {
+    "@eslint/js": "^9.18.0",
+    "eslint": "^9.18.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3",
+    "typescript-eslint": "^8.19.1",
+    "vitest": "^2.1.8",
+    "tsup": "^8.3.5"
+  }
+}