fx-forward-math 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Moshe Malka
+
+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,48 @@
+# fx-forward-math
+
+FX **trading conventions** math — forward points ↔ outright forwards, cross-rate derivation, triangular-arbitrage checks, pip / big-figure handling, and pip value. Zero dependencies.
+
+```
+npm install fx-forward-math
+```
+
+## Why
+
+`currency.js` and `dinero.js` handle *consumer* money — formatting and allocation. Neither knows what a **pip** is, how to turn **forward points** into an outright, or how to derive a **cross rate**. That's the arithmetic an FX desk actually uses, and npm had no library for it.
+
+```ts
+import { outrightForward, crossRate, triangularArbitrage } from "fx-forward-math";
+
+// 25 forward points on EUR/USD (pip = 0.0001):
+outrightForward("EUR/USD", 1.0850, 25);    // 1.0875
+// −40 points on USD/JPY (pip = 0.01):
+outrightForward("USD/JPY", 156.20, -40);   // 155.80
+
+// EUR/JPY implied from the two USD legs:
+crossRate("EUR/USD", 1.0850, "USD/JPY", 156.20);  // 169.477
+
+triangularArbitrage("EUR/USD", 1.0850, "USD/JPY", 156.20, "EUR/JPY", 169.60);
+// { impliedCross: 169.477, differencePips: 12.3, arbitrageFree: false }
+```
+
+## API
+
+Pairs are `"BASE/QUOTE"`; the rate is how many QUOTE units one BASE unit buys. Pip size is inferred from the quote currency (JPY-quoted pairs → 0.01, most others → 0.0001) and overridable everywhere.
+
+- **`outrightForward(pair, spot, forwardPoints)`** / **`forwardPoints(pair, spot, outright)`** — convert both ways.
+- **`crossRate(pairA, rateA, pairB, rateB)`** — derive the cross from two legs sharing a currency; returns the rate of *A's non-shared currency / B's non-shared currency* (any leg orientation).
+- **`triangularArbitrage(legA, rA, legB, rB, crossPair, crossQuote, tolerancePips?)`** — implied vs quoted cross and whether they agree.
+- **`pipValueQuote(pair, notional)`** / **`pipValueBase(pair, notional, rate)`** — value of one pip.
+- **`splitRate(pair, rate)`** → `{ bigFigure, pips }`; **`roundToPip(pair, rate)`**; **`pipSize`**, **`pipDecimals`**, **`parsePair`**.
+
+All rates must be positive and finite, else `RangeError`.
+
+## Related
+
+Pairs with [`fx-value-date`](https://github.com/moshejs/fx-value-date) (settlement dates). Part of a fixed-income & markets toolkit: [`32nds`](https://github.com/moshejs/32nds) · [`day-count`](https://github.com/moshejs/day-count) · [`newyorkfed`](https://github.com/moshejs/newyorkfed) · [`instrument-identifiers`](https://github.com/moshejs/instrument-identifiers).
+
+## Author
+
+Built by **[Moshe Malka](https://moshemalka.com)** — engineering leader in New York City. Studio work at [Quentin.Code](https://www.quentin.software/).
+
+MIT © Moshe Malka

package/dist/index.cjs

@@ -0,0 +1,147 @@
+"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, {
+  crossRate: () => crossRate,
+  forwardPoints: () => forwardPoints,
+  outrightForward: () => outrightForward,
+  parsePair: () => parsePair,
+  pipDecimals: () => pipDecimals,
+  pipSize: () => pipSize,
+  pipValueBase: () => pipValueBase,
+  pipValueQuote: () => pipValueQuote,
+  roundToPip: () => roundToPip,
+  splitRate: () => splitRate,
+  triangularArbitrage: () => triangularArbitrage
+});
+module.exports = __toCommonJS(index_exports);
+var QUOTE_PIP_DECIMALS = {
+  JPY: 2,
+  KRW: 2,
+  CLP: 2,
+  HUF: 2,
+  IDR: 2,
+  TWD: 2
+};
+var DEFAULT_PIP_DECIMALS = 4;
+var PAIR_RE = /^([A-Z]{3})\/([A-Z]{3})$/;
+function parsePair(pair) {
+  const m = PAIR_RE.exec(pair.trim().toUpperCase());
+  if (!m) throw new RangeError(`Invalid currency pair: "${pair}" (expected "BASE/QUOTE")`);
+  if (m[1] === m[2]) throw new RangeError(`Base and quote currency are identical in "${pair}"`);
+  return { base: m[1], quote: m[2] };
+}
+function pipDecimals(pair, override) {
+  if (override !== void 0) {
+    if (!Number.isInteger(override) || override < 0 || override > 10) {
+      throw new RangeError(`pipDecimals override must be an integer 0\u201310, got ${override}`);
+    }
+    return override;
+  }
+  const { quote } = parsePair(pair);
+  return QUOTE_PIP_DECIMALS[quote] ?? DEFAULT_PIP_DECIMALS;
+}
+function pipSize(pair, override) {
+  return 1 / 10 ** pipDecimals(pair, override);
+}
+function checkFinite(x, label) {
+  if (!Number.isFinite(x)) throw new RangeError(`${label} must be a finite number, got ${x}`);
+}
+function checkRate(rate, label) {
+  checkFinite(rate, label);
+  if (rate <= 0) throw new RangeError(`${label} must be positive, got ${rate}`);
+}
+function outrightForward(pair, spot, forwardPoints2, pipDecimalsOverride) {
+  checkRate(spot, "spot");
+  checkFinite(forwardPoints2, "forwardPoints");
+  return spot + forwardPoints2 * pipSize(pair, pipDecimalsOverride);
+}
+function forwardPoints(pair, spot, outright, pipDecimalsOverride) {
+  checkRate(spot, "spot");
+  checkRate(outright, "outright");
+  return (outright - spot) / pipSize(pair, pipDecimalsOverride);
+}
+function crossRate(pairA, rateA, pairB, rateB) {
+  const a = parsePair(pairA);
+  const b = parsePair(pairB);
+  checkRate(rateA, "rateA");
+  checkRate(rateB, "rateB");
+  const shared = [a.base, a.quote].find((c) => c === b.base || c === b.quote);
+  if (!shared) {
+    throw new RangeError(`No common currency between ${pairA} and ${pairB}`);
+  }
+  const aOther = a.base === shared ? a.quote : a.base;
+  const bOther = b.base === shared ? b.quote : b.base;
+  if (aOther === bOther) throw new RangeError(`${pairA} and ${pairB} describe the same pair`);
+  const aInShared = a.quote === shared ? rateA : 1 / rateA;
+  const bInShared = b.quote === shared ? rateB : 1 / rateB;
+  return aInShared / bInShared;
+}
+function triangularArbitrage(legAPair, legARate, legBPair, legBRate, crossPair, crossQuote, tolerancePips = 1) {
+  const impliedCross = crossRate(legAPair, legARate, legBPair, legBRate);
+  checkRate(crossQuote, "crossQuote");
+  const size = pipSize(crossPair);
+  const differencePips = (crossQuote - impliedCross) / size;
+  return {
+    impliedCross,
+    quotedCross: crossQuote,
+    differencePips,
+    arbitrageFree: Math.abs(differencePips) <= tolerancePips
+  };
+}
+function pipValueQuote(pair, notionalBase, pipDecimalsOverride) {
+  checkFinite(notionalBase, "notionalBase");
+  return notionalBase * pipSize(pair, pipDecimalsOverride);
+}
+function pipValueBase(pair, notionalBase, rate, pipDecimalsOverride) {
+  checkRate(rate, "rate");
+  return pipValueQuote(pair, notionalBase, pipDecimalsOverride) / rate;
+}
+function splitRate(pair, rate, pipDecimalsOverride) {
+  checkRate(rate, "rate");
+  const dp = pipDecimals(pair, pipDecimalsOverride);
+  const bigFigureUnit = 1 / 10 ** (dp - 2);
+  const bigFigure = Math.floor(rate / bigFigureUnit) * bigFigureUnit;
+  const pips = (rate - bigFigure) / pipSize(pair, pipDecimalsOverride);
+  return { bigFigure: round(bigFigure, dp), pips: round(pips, 4) };
+}
+function roundToPip(pair, rate, pipDecimalsOverride) {
+  const dp = pipDecimals(pair, pipDecimalsOverride);
+  return round(rate, dp);
+}
+function round(x, dp) {
+  const f = 10 ** dp;
+  return Math.round(x * f) / f;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  crossRate,
+  forwardPoints,
+  outrightForward,
+  parsePair,
+  pipDecimals,
+  pipSize,
+  pipValueBase,
+  pipValueQuote,
+  roundToPip,
+  splitRate,
+  triangularArbitrage
+});

package/dist/index.d.cts

@@ -0,0 +1,88 @@
+/**
+ * fx-forward-math — FX quote and forward conventions math.
+ *
+ * The trading-desk arithmetic that consumer money libraries ignore: forward
+ * points ↔ outright forwards with correct per-pair pip scaling, cross-rate
+ * derivation, triangular-arbitrage checks, pip / big-figure handling, and pip
+ * value. Pure functions, zero dependencies.
+ *
+ * A currency pair is written "BASE/QUOTE" (e.g. "EUR/USD"): the rate is how
+ * many QUOTE units one BASE unit buys.
+ */
+interface PairConvention {
+    /** Decimal places a spot rate is quoted to (EUR/USD → 4, USD/JPY → 2). */
+    pipDecimals: number;
+}
+interface Pair {
+    base: string;
+    quote: string;
+}
+/** Parse "EUR/USD" into `{ base, quote }`. Throws on malformed input. */
+declare function parsePair(pair: string): Pair;
+/**
+ * Decimal places a pair's spot rate is quoted to. Determined by the quote
+ * currency (JPY pairs → 2, most others → 4). Pass `override` to force it.
+ */
+declare function pipDecimals(pair: string, override?: number): number;
+/** The size of one pip for a pair, e.g. EUR/USD → 0.0001, USD/JPY → 0.01. */
+declare function pipSize(pair: string, override?: number): number;
+/**
+ * Outright forward rate from spot and forward points.
+ * `forward = spot + points × pipSize`.
+ *
+ * ```ts
+ * outrightForward("EUR/USD", 1.0850, 25);   // 1.0875  (25 points = 0.0025)
+ * outrightForward("USD/JPY", 156.20, -40);  // 155.80  (JPY pip = 0.01)
+ * ```
+ */
+declare function outrightForward(pair: string, spot: number, forwardPoints: number, pipDecimalsOverride?: number): number;
+/**
+ * Forward points from spot and an outright forward:
+ * `(forward − spot) / pipSize`.
+ */
+declare function forwardPoints(pair: string, spot: number, outright: number, pipDecimalsOverride?: number): number;
+/**
+ * Derive a cross rate BASE/QUOTE from two rates that share a common currency
+ * (typically USD). Handles all four leg orientations automatically.
+ *
+ * ```ts
+ * // EUR/JPY from EUR/USD and USD/JPY:
+ * crossRate("EUR/USD", 1.0850, "USD/JPY", 156.20); // 169.477
+ * ```
+ */
+declare function crossRate(pairA: string, rateA: number, pairB: string, rateB: number): number;
+/**
+ * Triangular-arbitrage consistency check for three rates forming a loop
+ * (e.g. EUR/USD, USD/JPY, EUR/JPY). Returns the implied cross, the quoted
+ * cross, and whether they agree within `tolerancePips`.
+ */
+interface TriangularCheck {
+    impliedCross: number;
+    quotedCross: number;
+    differencePips: number;
+    arbitrageFree: boolean;
+}
+declare function triangularArbitrage(legAPair: string, legARate: number, legBPair: string, legBRate: number, crossPair: string, crossQuote: number, tolerancePips?: number): TriangularCheck;
+/**
+ * Value of one pip on a notional, expressed in the QUOTE currency.
+ * `pipValueQuote("EUR/USD", 1_000_000)` → 100 (USD per pip).
+ */
+declare function pipValueQuote(pair: string, notionalBase: number, pipDecimalsOverride?: number): number;
+/**
+ * Value of one pip on a notional, expressed in the BASE currency, given the
+ * current rate. `pipValueBase("EUR/USD", 1_000_000, 1.085)` ≈ 92.17.
+ */
+declare function pipValueBase(pair: string, notionalBase: number, rate: number, pipDecimalsOverride?: number): number;
+/**
+ * Split a rate into its big figure (the "handle") and pips. For EUR/USD
+ * 1.08525 → `{ bigFigure: 1.08, pips: 52.5 }`.
+ */
+interface RateParts {
+    bigFigure: number;
+    pips: number;
+}
+declare function splitRate(pair: string, rate: number, pipDecimalsOverride?: number): RateParts;
+/** Round a rate to the pair's quoting precision. */
+declare function roundToPip(pair: string, rate: number, pipDecimalsOverride?: number): number;
+
+export { type Pair, type PairConvention, type RateParts, type TriangularCheck, crossRate, forwardPoints, outrightForward, parsePair, pipDecimals, pipSize, pipValueBase, pipValueQuote, roundToPip, splitRate, triangularArbitrage };

package/dist/index.d.ts

@@ -0,0 +1,88 @@
+/**
+ * fx-forward-math — FX quote and forward conventions math.
+ *
+ * The trading-desk arithmetic that consumer money libraries ignore: forward
+ * points ↔ outright forwards with correct per-pair pip scaling, cross-rate
+ * derivation, triangular-arbitrage checks, pip / big-figure handling, and pip
+ * value. Pure functions, zero dependencies.
+ *
+ * A currency pair is written "BASE/QUOTE" (e.g. "EUR/USD"): the rate is how
+ * many QUOTE units one BASE unit buys.
+ */
+interface PairConvention {
+    /** Decimal places a spot rate is quoted to (EUR/USD → 4, USD/JPY → 2). */
+    pipDecimals: number;
+}
+interface Pair {
+    base: string;
+    quote: string;
+}
+/** Parse "EUR/USD" into `{ base, quote }`. Throws on malformed input. */
+declare function parsePair(pair: string): Pair;
+/**
+ * Decimal places a pair's spot rate is quoted to. Determined by the quote
+ * currency (JPY pairs → 2, most others → 4). Pass `override` to force it.
+ */
+declare function pipDecimals(pair: string, override?: number): number;
+/** The size of one pip for a pair, e.g. EUR/USD → 0.0001, USD/JPY → 0.01. */
+declare function pipSize(pair: string, override?: number): number;
+/**
+ * Outright forward rate from spot and forward points.
+ * `forward = spot + points × pipSize`.
+ *
+ * ```ts
+ * outrightForward("EUR/USD", 1.0850, 25);   // 1.0875  (25 points = 0.0025)
+ * outrightForward("USD/JPY", 156.20, -40);  // 155.80  (JPY pip = 0.01)
+ * ```
+ */
+declare function outrightForward(pair: string, spot: number, forwardPoints: number, pipDecimalsOverride?: number): number;
+/**
+ * Forward points from spot and an outright forward:
+ * `(forward − spot) / pipSize`.
+ */
+declare function forwardPoints(pair: string, spot: number, outright: number, pipDecimalsOverride?: number): number;
+/**
+ * Derive a cross rate BASE/QUOTE from two rates that share a common currency
+ * (typically USD). Handles all four leg orientations automatically.
+ *
+ * ```ts
+ * // EUR/JPY from EUR/USD and USD/JPY:
+ * crossRate("EUR/USD", 1.0850, "USD/JPY", 156.20); // 169.477
+ * ```
+ */
+declare function crossRate(pairA: string, rateA: number, pairB: string, rateB: number): number;
+/**
+ * Triangular-arbitrage consistency check for three rates forming a loop
+ * (e.g. EUR/USD, USD/JPY, EUR/JPY). Returns the implied cross, the quoted
+ * cross, and whether they agree within `tolerancePips`.
+ */
+interface TriangularCheck {
+    impliedCross: number;
+    quotedCross: number;
+    differencePips: number;
+    arbitrageFree: boolean;
+}
+declare function triangularArbitrage(legAPair: string, legARate: number, legBPair: string, legBRate: number, crossPair: string, crossQuote: number, tolerancePips?: number): TriangularCheck;
+/**
+ * Value of one pip on a notional, expressed in the QUOTE currency.
+ * `pipValueQuote("EUR/USD", 1_000_000)` → 100 (USD per pip).
+ */
+declare function pipValueQuote(pair: string, notionalBase: number, pipDecimalsOverride?: number): number;
+/**
+ * Value of one pip on a notional, expressed in the BASE currency, given the
+ * current rate. `pipValueBase("EUR/USD", 1_000_000, 1.085)` ≈ 92.17.
+ */
+declare function pipValueBase(pair: string, notionalBase: number, rate: number, pipDecimalsOverride?: number): number;
+/**
+ * Split a rate into its big figure (the "handle") and pips. For EUR/USD
+ * 1.08525 → `{ bigFigure: 1.08, pips: 52.5 }`.
+ */
+interface RateParts {
+    bigFigure: number;
+    pips: number;
+}
+declare function splitRate(pair: string, rate: number, pipDecimalsOverride?: number): RateParts;
+/** Round a rate to the pair's quoting precision. */
+declare function roundToPip(pair: string, rate: number, pipDecimalsOverride?: number): number;
+
+export { type Pair, type PairConvention, type RateParts, type TriangularCheck, crossRate, forwardPoints, outrightForward, parsePair, pipDecimals, pipSize, pipValueBase, pipValueQuote, roundToPip, splitRate, triangularArbitrage };

package/dist/index.js

@@ -0,0 +1,112 @@
+// src/index.ts
+var QUOTE_PIP_DECIMALS = {
+  JPY: 2,
+  KRW: 2,
+  CLP: 2,
+  HUF: 2,
+  IDR: 2,
+  TWD: 2
+};
+var DEFAULT_PIP_DECIMALS = 4;
+var PAIR_RE = /^([A-Z]{3})\/([A-Z]{3})$/;
+function parsePair(pair) {
+  const m = PAIR_RE.exec(pair.trim().toUpperCase());
+  if (!m) throw new RangeError(`Invalid currency pair: "${pair}" (expected "BASE/QUOTE")`);
+  if (m[1] === m[2]) throw new RangeError(`Base and quote currency are identical in "${pair}"`);
+  return { base: m[1], quote: m[2] };
+}
+function pipDecimals(pair, override) {
+  if (override !== void 0) {
+    if (!Number.isInteger(override) || override < 0 || override > 10) {
+      throw new RangeError(`pipDecimals override must be an integer 0\u201310, got ${override}`);
+    }
+    return override;
+  }
+  const { quote } = parsePair(pair);
+  return QUOTE_PIP_DECIMALS[quote] ?? DEFAULT_PIP_DECIMALS;
+}
+function pipSize(pair, override) {
+  return 1 / 10 ** pipDecimals(pair, override);
+}
+function checkFinite(x, label) {
+  if (!Number.isFinite(x)) throw new RangeError(`${label} must be a finite number, got ${x}`);
+}
+function checkRate(rate, label) {
+  checkFinite(rate, label);
+  if (rate <= 0) throw new RangeError(`${label} must be positive, got ${rate}`);
+}
+function outrightForward(pair, spot, forwardPoints2, pipDecimalsOverride) {
+  checkRate(spot, "spot");
+  checkFinite(forwardPoints2, "forwardPoints");
+  return spot + forwardPoints2 * pipSize(pair, pipDecimalsOverride);
+}
+function forwardPoints(pair, spot, outright, pipDecimalsOverride) {
+  checkRate(spot, "spot");
+  checkRate(outright, "outright");
+  return (outright - spot) / pipSize(pair, pipDecimalsOverride);
+}
+function crossRate(pairA, rateA, pairB, rateB) {
+  const a = parsePair(pairA);
+  const b = parsePair(pairB);
+  checkRate(rateA, "rateA");
+  checkRate(rateB, "rateB");
+  const shared = [a.base, a.quote].find((c) => c === b.base || c === b.quote);
+  if (!shared) {
+    throw new RangeError(`No common currency between ${pairA} and ${pairB}`);
+  }
+  const aOther = a.base === shared ? a.quote : a.base;
+  const bOther = b.base === shared ? b.quote : b.base;
+  if (aOther === bOther) throw new RangeError(`${pairA} and ${pairB} describe the same pair`);
+  const aInShared = a.quote === shared ? rateA : 1 / rateA;
+  const bInShared = b.quote === shared ? rateB : 1 / rateB;
+  return aInShared / bInShared;
+}
+function triangularArbitrage(legAPair, legARate, legBPair, legBRate, crossPair, crossQuote, tolerancePips = 1) {
+  const impliedCross = crossRate(legAPair, legARate, legBPair, legBRate);
+  checkRate(crossQuote, "crossQuote");
+  const size = pipSize(crossPair);
+  const differencePips = (crossQuote - impliedCross) / size;
+  return {
+    impliedCross,
+    quotedCross: crossQuote,
+    differencePips,
+    arbitrageFree: Math.abs(differencePips) <= tolerancePips
+  };
+}
+function pipValueQuote(pair, notionalBase, pipDecimalsOverride) {
+  checkFinite(notionalBase, "notionalBase");
+  return notionalBase * pipSize(pair, pipDecimalsOverride);
+}
+function pipValueBase(pair, notionalBase, rate, pipDecimalsOverride) {
+  checkRate(rate, "rate");
+  return pipValueQuote(pair, notionalBase, pipDecimalsOverride) / rate;
+}
+function splitRate(pair, rate, pipDecimalsOverride) {
+  checkRate(rate, "rate");
+  const dp = pipDecimals(pair, pipDecimalsOverride);
+  const bigFigureUnit = 1 / 10 ** (dp - 2);
+  const bigFigure = Math.floor(rate / bigFigureUnit) * bigFigureUnit;
+  const pips = (rate - bigFigure) / pipSize(pair, pipDecimalsOverride);
+  return { bigFigure: round(bigFigure, dp), pips: round(pips, 4) };
+}
+function roundToPip(pair, rate, pipDecimalsOverride) {
+  const dp = pipDecimals(pair, pipDecimalsOverride);
+  return round(rate, dp);
+}
+function round(x, dp) {
+  const f = 10 ** dp;
+  return Math.round(x * f) / f;
+}
+export {
+  crossRate,
+  forwardPoints,
+  outrightForward,
+  parsePair,
+  pipDecimals,
+  pipSize,
+  pipValueBase,
+  pipValueQuote,
+  roundToPip,
+  splitRate,
+  triangularArbitrage
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "fx-forward-math",
+  "version": "1.0.0",
+  "description": "FX trading conventions math — forward points ↔ outright forwards, cross-rate derivation, triangular-arbitrage checks, pip / big-figure handling, and pip value. Zero dependencies.",
+  "keywords": [
+    "fx",
+    "forex",
+    "forward-points",
+    "cross-rate",
+    "triangular-arbitrage",
+    "pip",
+    "big-figure",
+    "currency",
+    "trading",
+    "finance",
+    "foreign-exchange"
+  ],
+  "homepage": "https://moshemalka.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moshejs/fx-forward-math.git"
+  },
+  "bugs": "https://github.com/moshejs/fx-forward-math/issues",
+  "author": "Moshe Malka <hello@moshemalka.com> (https://moshemalka.com)",
+  "license": "MIT",
+  "type": "module",
+  "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"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run typecheck && npm run test && npm run build"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.0",
+    "vitest": "^3.2.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}