@pyverret/ratejs 1.0.0

package/LICENSE

@@ -0,0 +1,16 @@
+ISC License
+
+Copyright (c) 2026, Pierre-Yves Verret
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+

package/README.md

@@ -0,0 +1,220 @@
+# @pyverret/ratejs
+
+Lightweight, dependency-free TypeScript financial math library providing pure calculation utilities.
+
+## Install
+
+```bash
+npm i @pyverret/ratejs
+```
+
+## Usage
+
+All functions take a single options object (no positional args). Rates are decimals (e.g. `0.05` = 5%).
+
+### Interest & growth
+
+- **`compound`** - Final amount for a lump sum with compound interest.
+
+```ts
+compound({ principal: 1000, rate: 0.05, timesPerYear: 12, years: 10 });
+```
+
+- **`futureValue`** - Future value of a present lump sum.
+
+```ts
+futureValue({ presentValue: 2500, rate: 0.07, timesPerYear: 4, years: 3 });
+```
+
+- **`presentValue`** - Present value of a future lump sum.
+
+```ts
+presentValue({ futureValue: 5000, rate: 0.06, timesPerYear: 12, years: 5 });
+```
+
+- **`investmentGrowth`** - Future value with optional periodic contributions. Returns `{ futureValue, totalContributions, totalInterest }`.
+
+```ts
+investmentGrowth({
+  initial: 1000,
+  contributionPerPeriod: 100,
+  rate: 0.06,
+  timesPerYear: 12,
+  years: 2,
+  contributionTiming: "end", // or "begin"
+});
+```
+
+- **`effectiveAnnualRate`** - Convert nominal rate + compounding frequency to effective annual rate (EAR).
+
+```ts
+effectiveAnnualRate({ nominalRate: 0.06, timesPerYear: 12 });
+```
+
+- **`periodsToReachGoal`** — Number of compounding periods until future value reaches a target (lump sum or with contributions).
+
+```ts
+periodsToReachGoal({
+  principal: 1000,
+  targetFutureValue: 2000,
+  rate: 0.06,
+  timesPerYear: 12,
+  contributionPerPeriod: 0, // optional
+  contributionTiming: "end",
+});
+```
+
+Edge cases:
+- Returns `Infinity` when the goal is unreachable.
+- Throws `RangeError` when `rate / timesPerYear <= -1`.
+
+- **`rateToReachGoal`** - Rate per period required to reach a target future value in a given number of periods.
+
+```ts
+rateToReachGoal({
+  principal: 1000,
+  targetFutureValue: 1500,
+  periods: 24,
+  contributionPerPeriod: 0,
+  contributionTiming: "end",
+});
+```
+
+- **`ruleOf72`** - Approximate years to double a lump sum at a given annual rate. Optional `constant: 69` for rule of 69.
+
+```ts
+ruleOf72({ rate: 0.07 }); // ~10.3 years
+ruleOf72({ rate: 0.07, constant: 69 });
+```
+
+### Returns
+
+- **`cagr`** - Compound annual growth rate between a start and end value over years.
+
+```ts
+cagr({ startValue: 1000, endValue: 2000, years: 10 });
+```
+
+- **`irr`** - Internal rate of return: discount rate that makes NPV of cash flows zero. `cashFlows[0]` is typically the initial outlay (negative).
+
+```ts
+irr({ cashFlows: [-1000, 300, 400, 500], guess: 0.1, maxIterations: 100 });
+```
+
+### Inflation
+
+- **`realReturn`** - Real (inflation-adjusted) return from nominal return and inflation rate.
+
+```ts
+realReturn({ nominalReturn: 0.07, inflationRate: 0.02 });
+```
+
+- **`inflationAdjustedAmount`** - Purchasing power across time. `toPast`: value years ago with same purchasing power; `toFuture`: nominal amount in the future with same purchasing power.
+
+```ts
+inflationAdjustedAmount({
+  amount: 100,
+  annualInflationRate: 0.03,
+  years: 10,
+  direction: "toPast",
+});
+inflationAdjustedAmount({
+  amount: 100,
+  annualInflationRate: 0.03,
+  years: 10,
+  direction: "toFuture",
+});
+```
+
+### Annuities
+
+- **`presentValueOfAnnuity`** - Present value of a series of equal payments. `timing`: `"end"` (ordinary) or `"begin"` (annuity due).
+
+```ts
+presentValueOfAnnuity({
+  paymentPerPeriod: 100,
+  ratePerPeriod: 0.01,
+  periods: 36,
+  timing: "end",
+});
+```
+
+- **`paymentFromPresentValue`** - Periodic payment to pay off a present value (e.g. loan) over a number of periods.
+
+```ts
+paymentFromPresentValue({
+  presentValue: 100000,
+  ratePerPeriod: 0.005,
+  periods: 360,
+  timing: "end",
+});
+```
+
+### Loans
+
+- **`loanPayment`** - Fixed periodic payment for an amortizing loan (nominal annual rate, payments per year, years).
+
+```ts
+loanPayment({
+  principal: 200000,
+  annualRate: 0.06,
+  paymentsPerYear: 12,
+  years: 30,
+});
+```
+
+- **`amortizationSchedule`** - Full schedule: `{ paymentPerPeriod, schedule, totalPaid, totalInterest }`. Optional `extraPaymentPerPeriod`.
+
+```ts
+amortizationSchedule({
+  principal: 200000,
+  annualRate: 0.06,
+  paymentsPerYear: 12,
+  years: 30,
+  extraPaymentPerPeriod: 50,
+});
+```
+
+- **`remainingBalance`** - Balance remaining after a given number of payments (1-based `afterPeriodNumber`).
+
+```ts
+remainingBalance({
+  principal: 200000,
+  annualRate: 0.06,
+  paymentsPerYear: 12,
+  years: 30,
+  afterPeriodNumber: 12,
+});
+```
+
+- **`payoffPeriodWithExtra`** — Number of periods until the loan is paid off with base payment + extra payment.
+
+```ts
+payoffPeriodWithExtra({
+  principal: 100000,
+  annualRate: 0.06,
+  paymentsPerYear: 12,
+  basePaymentPerPeriod: 599.55,
+  extraPaymentPerPeriod: 100,
+});
+```
+
+Edge cases:
+- Returns `Infinity` when payment is zero or does not cover per-period interest.
+
+### Utils
+
+- **`roundToCurrency`** - Round to decimal places (default 2). `mode`: `"half-up"` or `"half-even"` (banker's rounding).
+
+```ts
+roundToCurrency({ value: 2.125 }); // 2.13
+roundToCurrency({ value: 2.125, decimals: 2, mode: "half-even" });
+```
+
+## Design
+
+- Pure functions only
+- No runtime dependencies
+- Object-parameter inputs (no positional args)
+- Deterministic outputs
+- Tree-shakeable (import only what you use)

package/dist/index.cjs

@@ -0,0 +1,430 @@
+'use strict';
+
+// src/utils/assertions.ts
+function assertFiniteNumber(value, name) {
+  if (!Number.isFinite(value)) {
+    throw new RangeError(`${name} must be a finite number`);
+  }
+}
+function assertNonNegative(value, name) {
+  assertFiniteNumber(value, name);
+  if (value < 0) {
+    throw new RangeError(`${name} must be >= 0`);
+  }
+}
+function assertPositive(value, name) {
+  assertFiniteNumber(value, name);
+  if (value <= 0) {
+    throw new RangeError(`${name} must be > 0`);
+  }
+}
+
+// src/interest/cagr.ts
+function cagr(params) {
+  const { startValue, endValue, years } = params;
+  assertPositive(startValue, "startValue");
+  assertPositive(years, "years");
+  if (endValue <= 0) return -1;
+  return (endValue / startValue) ** (1 / years) - 1;
+}
+
+// src/interest/compound.ts
+function compound(params) {
+  const { principal, rate, timesPerYear, years } = params;
+  assertNonNegative(principal, "principal");
+  assertPositive(timesPerYear, "timesPerYear");
+  assertNonNegative(years, "years");
+  if (rate === 0 || years === 0) return principal;
+  const n = timesPerYear;
+  const t = years;
+  return principal * (1 + rate / n) ** (n * t);
+}
+
+// src/interest/effectiveAnnualRate.ts
+function effectiveAnnualRate(params) {
+  const { nominalRate, timesPerYear } = params;
+  assertFiniteNumber(nominalRate, "nominalRate");
+  assertPositive(timesPerYear, "timesPerYear");
+  const r = nominalRate / timesPerYear;
+  return (1 + r) ** timesPerYear - 1;
+}
+
+// src/interest/futureValue.ts
+function futureValue(params) {
+  const { presentValue: presentValue2, rate, timesPerYear, years } = params;
+  assertNonNegative(presentValue2, "presentValue");
+  assertPositive(timesPerYear, "timesPerYear");
+  assertNonNegative(years, "years");
+  if (rate === 0 || years === 0) return presentValue2;
+  const n = timesPerYear;
+  const t = years;
+  return presentValue2 * (1 + rate / n) ** (n * t);
+}
+
+// src/interest/inflationAdjustedAmount.ts
+function inflationAdjustedAmount(params) {
+  const { amount, annualInflationRate, years, direction } = params;
+  assertFiniteNumber(amount, "amount");
+  assertFiniteNumber(annualInflationRate, "annualInflationRate");
+  assertNonNegative(years, "years");
+  const factor = (1 + annualInflationRate) ** years;
+  return direction === "toPast" ? amount / factor : amount * factor;
+}
+
+// src/interest/investmentGrowth.ts
+function investmentGrowth(params) {
+  const {
+    initial,
+    contributionPerPeriod = 0,
+    rate,
+    timesPerYear,
+    years,
+    contributionTiming = "end"
+  } = params;
+  assertNonNegative(initial, "initial");
+  assertNonNegative(contributionPerPeriod, "contributionPerPeriod");
+  assertPositive(timesPerYear, "timesPerYear");
+  assertNonNegative(years, "years");
+  const periods = Math.round(timesPerYear * years);
+  if (periods === 0) {
+    return {
+      futureValue: initial,
+      totalContributions: 0,
+      totalInterest: 0
+    };
+  }
+  const r = rate / timesPerYear;
+  const fvInitial = rate === 0 ? initial : initial * (1 + r) ** periods;
+  let fvContrib = 0;
+  if (contributionPerPeriod !== 0) {
+    if (rate === 0) {
+      fvContrib = contributionPerPeriod * periods;
+    } else {
+      const ordinary = contributionPerPeriod * (((1 + r) ** periods - 1) / r);
+      fvContrib = contributionTiming === "begin" ? ordinary * (1 + r) : ordinary;
+    }
+  }
+  const futureValue2 = fvInitial + fvContrib;
+  const totalContributions = contributionPerPeriod * periods;
+  const totalInterest = futureValue2 - initial - totalContributions;
+  return { futureValue: futureValue2, totalContributions, totalInterest };
+}
+
+// src/interest/irr.ts
+function npv(rate, cashFlows) {
+  let sum = 0;
+  for (let t = 0; t < cashFlows.length; t++) {
+    const cf = cashFlows[t];
+    if (cf !== void 0) sum += cf / (1 + rate) ** t;
+  }
+  return sum;
+}
+function npvDerivative(rate, cashFlows) {
+  let sum = 0;
+  for (let t = 1; t < cashFlows.length; t++) {
+    const cf = cashFlows[t];
+    if (cf !== void 0) sum -= t * cf / (1 + rate) ** (t + 1);
+  }
+  return sum;
+}
+function irr(params) {
+  const { cashFlows, guess = 0.1, maxIterations = 100 } = params;
+  if (cashFlows.length === 0) return NaN;
+  for (const cf of cashFlows) assertFiniteNumber(cf, "cashFlows[]");
+  let r = guess;
+  for (let i = 0; i < maxIterations; i++) {
+    const val = npv(r, cashFlows);
+    if (Math.abs(val) < 1e-10) return r;
+    const der = npvDerivative(r, cashFlows);
+    if (!Number.isFinite(der) || Math.abs(der) < 1e-15) break;
+    r = r - val / der;
+    if (r < -0.99) r = -0.99;
+    if (r > 10) r = 10;
+  }
+  return r;
+}
+
+// src/interest/paymentFromPresentValue.ts
+function paymentFromPresentValue(params) {
+  const { presentValue: presentValue2, ratePerPeriod, periods, timing = "end" } = params;
+  assertNonNegative(presentValue2, "presentValue");
+  assertNonNegative(periods, "periods");
+  if (presentValue2 === 0 || periods === 0) return 0;
+  if (ratePerPeriod === 0) {
+    const pmt2 = presentValue2 / periods;
+    return timing === "begin" ? pmt2 / (1 + ratePerPeriod) : pmt2;
+  }
+  let pmt = ratePerPeriod * presentValue2 / (1 - (1 + ratePerPeriod) ** -periods);
+  if (timing === "begin") pmt /= 1 + ratePerPeriod;
+  return pmt;
+}
+
+// src/interest/periodsToReachGoal.ts
+function periodsToReachGoal(params) {
+  const {
+    principal,
+    targetFutureValue,
+    rate,
+    timesPerYear,
+    contributionPerPeriod = 0,
+    contributionTiming = "end"
+  } = params;
+  assertNonNegative(principal, "principal");
+  assertNonNegative(targetFutureValue, "targetFutureValue");
+  assertFiniteNumber(rate, "rate");
+  assertPositive(timesPerYear, "timesPerYear");
+  assertNonNegative(contributionPerPeriod, "contributionPerPeriod");
+  if (targetFutureValue <= principal) return 0;
+  const r = rate / timesPerYear;
+  if (r <= -1) {
+    throw new RangeError("rate / timesPerYear must be > -1");
+  }
+  if (contributionPerPeriod === 0) {
+    if (principal === 0) return Number.POSITIVE_INFINITY;
+    if (rate === 0) return targetFutureValue <= principal ? 0 : Number.POSITIVE_INFINITY;
+    if (r < 0) return Number.POSITIVE_INFINITY;
+    const n = Math.log(targetFutureValue / principal) / Math.log(1 + r);
+    return Number.isFinite(n) && n >= 0 ? Math.ceil(n) : Number.POSITIVE_INFINITY;
+  }
+  if (rate === 0) {
+    const needed = targetFutureValue - principal;
+    if (needed <= 0) return 0;
+    return Math.ceil(needed / contributionPerPeriod);
+  }
+  let fv = principal;
+  let periods = 0;
+  const maxPeriods = 1e4;
+  while (fv < targetFutureValue && periods < maxPeriods) {
+    if (contributionTiming === "begin") fv += contributionPerPeriod;
+    fv = fv * (1 + r) + (contributionTiming === "end" ? contributionPerPeriod : 0);
+    periods++;
+  }
+  return fv >= targetFutureValue ? periods : Number.POSITIVE_INFINITY;
+}
+
+// src/interest/presentValue.ts
+function presentValue(params) {
+  const { futureValue: fv, rate, timesPerYear, years } = params;
+  assertNonNegative(fv, "futureValue");
+  assertPositive(timesPerYear, "timesPerYear");
+  assertNonNegative(years, "years");
+  if (rate === 0 || years === 0) return fv;
+  const n = timesPerYear;
+  const t = years;
+  return fv / (1 + rate / n) ** (n * t);
+}
+
+// src/interest/presentValueOfAnnuity.ts
+function presentValueOfAnnuity(params) {
+  const { paymentPerPeriod, ratePerPeriod, periods, timing = "end" } = params;
+  assertNonNegative(paymentPerPeriod, "paymentPerPeriod");
+  assertNonNegative(periods, "periods");
+  if (periods === 0) return 0;
+  if (ratePerPeriod === 0) {
+    const pv2 = paymentPerPeriod * periods;
+    return timing === "begin" ? pv2 * (1 + ratePerPeriod) : pv2;
+  }
+  const pv = paymentPerPeriod * (1 - (1 + ratePerPeriod) ** -periods) / ratePerPeriod;
+  return timing === "begin" ? pv * (1 + ratePerPeriod) : pv;
+}
+
+// src/interest/rateToReachGoal.ts
+function rateToReachGoal(params) {
+  const {
+    principal,
+    targetFutureValue,
+    periods,
+    contributionPerPeriod = 0,
+    contributionTiming = "end"
+  } = params;
+  assertNonNegative(principal, "principal");
+  assertNonNegative(targetFutureValue, "targetFutureValue");
+  assertPositive(periods, "periods");
+  assertNonNegative(contributionPerPeriod, "contributionPerPeriod");
+  if (periods === 0) return 0;
+  if (targetFutureValue <= principal && contributionPerPeriod === 0) return 0;
+  if (contributionPerPeriod === 0) {
+    if (targetFutureValue <= principal) return 0;
+    return (targetFutureValue / principal) ** (1 / periods) - 1;
+  }
+  const dueFactor = contributionTiming === "begin" ? 1 : 0;
+  let r = (targetFutureValue / (principal + contributionPerPeriod * periods)) ** (1 / periods) - 1;
+  if (r <= -1) r = 0.01;
+  for (let i = 0; i < 100; i++) {
+    const onePlusR = 1 + r;
+    const onePlusRN = onePlusR ** periods;
+    const fvLump = principal * onePlusRN;
+    const annuity = contributionPerPeriod * ((onePlusRN - 1) / (r || 1e-14)) * (1 + dueFactor * r);
+    const fv = fvLump + annuity;
+    const err = fv - targetFutureValue;
+    if (Math.abs(err) < 1e-10) return r;
+    const dr = r * 1e-6 || 1e-10;
+    const r2 = r + dr;
+    const onePlusR2 = 1 + r2;
+    const onePlusR2N = onePlusR2 ** periods;
+    const fv2 = principal * onePlusR2N + contributionPerPeriod * ((onePlusR2N - 1) / r2) * (1 + dueFactor * r2);
+    const dFvDr = (fv2 - fv) / dr;
+    r = r - err / dFvDr;
+    if (r <= -1) r = 0.01;
+    if (r > 10) r = 10;
+  }
+  return r;
+}
+
+// src/interest/realReturn.ts
+function realReturn(params) {
+  const { nominalReturn, inflationRate } = params;
+  assertFiniteNumber(nominalReturn, "nominalReturn");
+  assertFiniteNumber(inflationRate, "inflationRate");
+  if (inflationRate <= -1) return NaN;
+  return (1 + nominalReturn) / (1 + inflationRate) - 1;
+}
+
+// src/interest/ruleOf72.ts
+function ruleOf72(params) {
+  const { rate, constant = 72 } = params;
+  assertFiniteNumber(rate, "rate");
+  assertPositive(rate, "rate");
+  return constant / 100 / rate;
+}
+
+// src/loans/loanPayment.ts
+function loanPayment(params) {
+  const { principal, annualRate, paymentsPerYear, years } = params;
+  assertNonNegative(principal, "principal");
+  assertPositive(paymentsPerYear, "paymentsPerYear");
+  assertNonNegative(years, "years");
+  const n = Math.round(paymentsPerYear * years);
+  if (n === 0) return 0;
+  const r = annualRate / paymentsPerYear;
+  if (r === 0) return principal / n;
+  return r * principal / (1 - (1 + r) ** -n);
+}
+
+// src/loans/amortizationSchedule.ts
+function amortizationSchedule(params) {
+  const { principal, annualRate, paymentsPerYear, years, extraPaymentPerPeriod = 0 } = params;
+  assertNonNegative(principal, "principal");
+  assertPositive(paymentsPerYear, "paymentsPerYear");
+  assertNonNegative(years, "years");
+  assertNonNegative(extraPaymentPerPeriod, "extraPaymentPerPeriod");
+  const scheduledN = Math.round(paymentsPerYear * years);
+  if (scheduledN === 0 || principal === 0) {
+    return { paymentPerPeriod: 0, schedule: [], totalPaid: 0, totalInterest: 0 };
+  }
+  const basePayment = loanPayment({ principal, annualRate, paymentsPerYear, years });
+  const r = annualRate / paymentsPerYear;
+  const schedule = [];
+  let balance = principal;
+  let totalPaid = 0;
+  let totalInterest = 0;
+  for (let period = 1; period <= scheduledN && balance > 0; period++) {
+    const interestPayment = r === 0 ? 0 : balance * r;
+    let payment = basePayment + extraPaymentPerPeriod;
+    let principalPayment = payment - interestPayment;
+    if (principalPayment > balance) {
+      principalPayment = balance;
+      payment = principalPayment + interestPayment;
+    }
+    balance = balance - principalPayment;
+    if (Math.abs(balance) < 1e-12) balance = 0;
+    totalPaid += payment;
+    totalInterest += interestPayment;
+    schedule.push({
+      period,
+      payment,
+      principalPayment,
+      interestPayment,
+      balance
+    });
+  }
+  return {
+    paymentPerPeriod: basePayment,
+    schedule,
+    totalPaid,
+    totalInterest
+  };
+}
+
+// src/loans/payoffPeriodWithExtra.ts
+function payoffPeriodWithExtra(params) {
+  const { principal, annualRate, paymentsPerYear, basePaymentPerPeriod, extraPaymentPerPeriod } = params;
+  assertNonNegative(principal, "principal");
+  assertFiniteNumber(annualRate, "annualRate");
+  assertPositive(paymentsPerYear, "paymentsPerYear");
+  assertNonNegative(basePaymentPerPeriod, "basePaymentPerPeriod");
+  assertNonNegative(extraPaymentPerPeriod, "extraPaymentPerPeriod");
+  if (principal <= 0) return 0;
+  const payment = basePaymentPerPeriod + extraPaymentPerPeriod;
+  if (payment <= 0) return Number.POSITIVE_INFINITY;
+  const r = annualRate / paymentsPerYear;
+  let balance = principal;
+  let period = 0;
+  while (balance > 1e-12 && period < 1e5) {
+    const interest = r > 0 ? balance * r : 0;
+    if (payment <= interest) return Number.POSITIVE_INFINITY;
+    const principalPaid = Math.min(payment - interest, balance);
+    balance -= principalPaid;
+    period++;
+  }
+  return balance <= 1e-12 ? period : Number.POSITIVE_INFINITY;
+}
+
+// src/loans/remainingBalance.ts
+function remainingBalance(params) {
+  const { principal, annualRate, paymentsPerYear, years, afterPeriodNumber } = params;
+  assertNonNegative(principal, "principal");
+  assertPositive(paymentsPerYear, "paymentsPerYear");
+  assertNonNegative(years, "years");
+  assertNonNegative(afterPeriodNumber, "afterPeriodNumber");
+  const n = Math.round(paymentsPerYear * years);
+  if (n === 0 || afterPeriodNumber >= n) return 0;
+  if (afterPeriodNumber <= 0) return principal;
+  const payment = loanPayment({ principal, annualRate, paymentsPerYear, years });
+  const r = annualRate / paymentsPerYear;
+  const k = afterPeriodNumber;
+  if (r === 0) return Math.max(0, principal - payment * k);
+  const balance = principal * (1 + r) ** k - payment * (((1 + r) ** k - 1) / r);
+  return Math.max(0, balance);
+}
+
+// src/utils/roundToCurrency.ts
+function roundToCurrency(params) {
+  const { value, decimals = 2, mode = "half-up" } = params;
+  assertFiniteNumber(value, "value");
+  const d = Math.max(0, Math.floor(decimals));
+  const factor = 10 ** d;
+  if (mode === "half-even") {
+    const scaled = value * factor;
+    const rounded = Math.round(scaled);
+    const remainder = Math.abs(scaled - rounded);
+    if (remainder === 0.5) {
+      const down = Math.floor(scaled);
+      return (down % 2 === 0 ? down : down + 1) / factor;
+    }
+    return rounded / factor;
+  }
+  return Math.round(value * factor) / factor;
+}
+
+exports.amortizationSchedule = amortizationSchedule;
+exports.cagr = cagr;
+exports.compound = compound;
+exports.effectiveAnnualRate = effectiveAnnualRate;
+exports.futureValue = futureValue;
+exports.inflationAdjustedAmount = inflationAdjustedAmount;
+exports.investmentGrowth = investmentGrowth;
+exports.irr = irr;
+exports.loanPayment = loanPayment;
+exports.paymentFromPresentValue = paymentFromPresentValue;
+exports.payoffPeriodWithExtra = payoffPeriodWithExtra;
+exports.periodsToReachGoal = periodsToReachGoal;
+exports.presentValue = presentValue;
+exports.presentValueOfAnnuity = presentValueOfAnnuity;
+exports.rateToReachGoal = rateToReachGoal;
+exports.realReturn = realReturn;
+exports.remainingBalance = remainingBalance;
+exports.roundToCurrency = roundToCurrency;
+exports.ruleOf72 = ruleOf72;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map