fundamental-js 1.0.0 → 1.1.0

package/README.md

@@ -0,0 +1,235 @@
+# fundamental-js
+
+A comprehensive, zero-dependency TypeScript financial calculator library for investing, loans, and personal finance.
+
+All functions are **pure**, **deterministic**, and work in both **Node.js** and **browser** environments. Rates are expressed as decimals (0.12 = 12%).
+
+## Install
+
+```bash
+npm install fundamental-js
+```
+
+## Quick Start
+
+```ts
+import {
+  emi,
+  sipFutureValue,
+  stepUpSipFutureValue,
+  swpPlan,
+  xirr,
+} from "fundamental-js";
+
+// EMI for a ₹25L loan at 8.5% for 20 years
+const loan = emi(2500000, 0.085, 240);
+console.log(loan);
+// { emi: 21698.69, totalPayment: 5207685.73, totalInterest: 2707685.73 }
+
+// SIP: ₹25,000/month at 12% for 15 years
+const sip = sipFutureValue({
+  monthlyInvestment: 25000,
+  annualRate: 0.12,
+  months: 180,
+});
+console.log(sip);
+// { futureValue: 12649741.45, totalInvested: 4500000, estimatedGains: 8149741.45 }
+
+// Step-up SIP: ₹25,000/month, 10% annual step-up
+const stepUp = stepUpSipFutureValue({
+  monthlyInvestment: 25000,
+  annualRate: 0.12,
+  months: 180,
+  stepUpPercentAnnual: 10,
+});
+console.log(stepUp);
+
+// SWP: ₹1Cr corpus, ₹50K/month withdrawal at 8%
+const withdrawal = swpPlan({
+  initialCorpus: 10000000,
+  monthlyWithdrawal: 50000,
+  annualRate: 0.08,
+  months: 300,
+});
+console.log(withdrawal.endingCorpus, withdrawal.totalWithdrawn);
+
+// XIRR: Irregular cashflows with dates
+const result = xirr([
+  { date: new Date("2020-01-01"), amount: -100000 },
+  { date: new Date("2020-06-15"), amount: 5000 },
+  { date: new Date("2021-01-01"), amount: 115000 },
+]);
+console.log(result); // ~0.1975 (19.75%)
+```
+
+## API Reference
+
+### Time Value of Money (Excel-compatible)
+
+| Function | Description |
+|----------|-------------|
+| `pv(rate, nper, pmt, fv?, type?)` | Present Value |
+| `fv(rate, nper, pmt, pv?, type?)` | Future Value |
+| `pmt(rate, nper, pv, fv?, type?)` | Payment per period |
+| `nper(rate, pmt, pv, fv?, type?)` | Number of periods |
+| `rateCalc(nper, pmt, pv, fv?, type?, guess?)` | Solve for interest rate (iterative) |
+| `npv(rate, cashflows)` | Net Present Value |
+| `irr(cashflows, guess?)` | Internal Rate of Return (Newton-Raphson + bisection fallback) |
+| `xnpv(rate, cashflows, dayCount?)` | NPV with irregular dates |
+| `xirr(cashflows, guess?, dayCount?)` | IRR with irregular dates |
+
+**Parameters:**
+- `rate` — periodic interest rate as decimal
+- `nper` — total number of periods
+- `pmt` — payment per period
+- `type` — 0 = end of period (default), 1 = beginning of period
+- `cashflows` for xnpv/xirr: `{ date: Date, amount: number }[]`
+- `dayCount` — `"ACT/365"` (default) or `"ACT/360"`
+
+### Returns Analysis
+
+| Function | Description |
+|----------|-------------|
+| `absoluteReturn(beginValue, endValue)` | Simple return as a decimal |
+| `cagr(beginValue, endValue, years)` | Compound Annual Growth Rate |
+| `annualizedReturn(beginValue, endValue, days)` | Annualized return using ACT/365 |
+| `trailingReturn(series, windowDays)` | Trailing return over a rolling window |
+
+**Parameters:**
+- `series` for trailingReturn: `{ date: Date, value: number }[]`
+- `windowDays` — lookback window in days
+
+### SIP / Lumpsum / SWP
+
+| Function | Description |
+|----------|-------------|
+| `sipFutureValue(params)` | SIP future value with optional step-up |
+| `stepUpSipFutureValue(params)` | SIP with required annual step-up |
+| `lumpsumFutureValue(principal, annualRate, years)` | One-time investment growth |
+| `swpPlan(params)` | Systematic Withdrawal Plan with schedule |
+| `inflationAdjustedValue(value, inflationRate, years)` | Purchasing power after inflation |
+| `realReturn(nominalRate, inflationRate)` | Fisher equation real return |
+
+**sipFutureValue params:**
+```ts
+{
+  monthlyInvestment: number,
+  annualRate: number,       // decimal (0.12 = 12%)
+  months: number,
+  stepUpPercentAnnual?: number, // e.g. 10 for 10%
+  investmentAt?: "begin" | "end"
+}
+```
+Returns: `{ futureValue, totalInvested, estimatedGains }`
+
+**swpPlan params:**
+```ts
+{
+  initialCorpus: number,
+  monthlyWithdrawal: number,
+  annualRate: number,
+  months: number,
+  inflationRateAnnual?: number, // e.g. 6 for 6%
+  withdrawalAt?: "begin" | "end"
+}
+```
+Returns: `{ endingCorpus, totalWithdrawn, schedule[] }`
+
+### Goal Planning
+
+| Function | Description |
+|----------|-------------|
+| `requiredMonthlyInvestmentForGoal(params)` | Required monthly SIP for a target amount |
+| `requiredLumpsumForGoal(goal, annualRate, years)` | Required lumpsum for a target amount |
+
+**requiredMonthlyInvestmentForGoal params:**
+```ts
+{
+  goalAmountFuture: number,
+  annualRate: number,
+  months: number,
+  stepUpPercentAnnual?: number,
+  investmentAt?: "begin" | "end"
+}
+```
+Returns: `{ requiredMonthlyInvestment, assumptions }`
+
+### Loans
+
+| Function | Description |
+|----------|-------------|
+| `emi(principal, annualRate, months)` | Equated Monthly Installment |
+| `amortizationSchedule(params)` | Full loan schedule with extra payments |
+| `prepaymentImpact(params)` | Compare original vs prepaid loan savings |
+
+**emi** returns: `{ emi, totalPayment, totalInterest }`
+
+**amortizationSchedule params:**
+```ts
+{
+  principal: number,
+  annualRate: number,
+  months: number,
+  extraPaymentMonthly?: number,
+  extraPayments?: { month: number, amount: number }[]
+}
+```
+Returns: `{ emi, schedule[], totalInterest, totalPaid, payoffMonth }`
+
+**prepaymentImpact params:**
+```ts
+{
+  principal: number,
+  annualRate: number,
+  months: number,
+  prepayments: { month: number, amount: number }[],
+  mode: "reduceTenure" | "reduceEmi"
+}
+```
+Returns: `{ original, new, savings: { interestSaved, monthsSaved } }`
+
+### Risk Metrics
+
+| Function | Description |
+|----------|-------------|
+| `volatility(returns, periodsPerYear?)` | Annualized volatility (sample stdev * sqrt(periods)) |
+| `sharpe(returns, riskFreeRate?, periodsPerYear?)` | Sharpe Ratio |
+| `sortino(returns, riskFreeRate?, periodsPerYear?)` | Sortino Ratio (downside deviation only) |
+| `maxDrawdown(values)` | Maximum drawdown with peak/trough indices |
+
+**Parameters:**
+- `returns` — array of periodic returns as decimals
+- `values` — array of portfolio values
+- `periodsPerYear` — defaults to 252 (daily trading)
+- `riskFreeRate` — annual risk-free rate as decimal
+
+### Portfolio Helpers
+
+| Function | Description |
+|----------|-------------|
+| `weightedReturn(returns, weights)` | Weighted average return |
+| `rebalance(targetWeights, currentValues)` | Calculate trades needed to rebalance |
+
+**rebalance** returns: `{ trades, newValues, total }` — positive trade = buy, negative = sell
+
+### Utilities
+
+| Function | Description |
+|----------|-------------|
+| `safeNum(value, fallback?)` | Returns fallback if value is NaN/Infinity/null/undefined |
+
+## Conventions
+
+- **Rates as decimals**: 12% = `0.12`, not `12`
+- **Step-up as percentage**: 10% step-up = `10`, not `0.10` (matches common Indian finance convention)
+- **Inflation as percentage** in SWP: `inflationRateAnnual: 6` means 6%
+- **Day count**: XNPV/XIRR default to ACT/365; pass `"ACT/360"` to override
+- **Period type**: `0` = end-of-period (ordinary annuity), `1` = beginning-of-period (annuity due)
+
+## Error Handling
+
+Functions return safe defaults (0, empty arrays) for invalid inputs instead of throwing, making them safe for use in reactive UIs. The `safeNum` utility guards against NaN/Infinity.
+
+## License
+
+MIT

package/dist/index.cjs

@@ -30,9 +30,12 @@ __export(index_exports, {
   irr: () => irr,
   lumpsumFutureValue: () => lumpsumFutureValue,
   maxDrawdown: () => maxDrawdown,
+  nper: () => nper,
   npv: () => npv,
+  pmt: () => pmt,
   prepaymentImpact: () => prepaymentImpact,
   pv: () => pv,
+  rateCalc: () => rateCalc,
   realReturn: () => realReturn,
   rebalance: () => rebalance,
   requiredLumpsumForGoal: () => requiredLumpsumForGoal,
@@ -41,9 +44,13 @@ __export(index_exports, {
   sharpe: () => sharpe,
   sipFutureValue: () => sipFutureValue,
   sortino: () => sortino,
+  stepUpSipFutureValue: () => stepUpSipFutureValue,
   swpPlan: () => swpPlan,
+  trailingReturn: () => trailingReturn,
   volatility: () => volatility,
-  weightedReturn: () => weightedReturn
+  weightedReturn: () => weightedReturn,
+  xirr: () => xirr,
+  xnpv: () => xnpv
 });
 module.exports = __toCommonJS(index_exports);
 function safeNum(v, fallback = 0) {
@@ -261,15 +268,126 @@ function annualizedReturn(beginValue, endValue, days) {
   if (beginValue <= 0 || days <= 0) return 0;
   return Math.pow(endValue / beginValue, 365 / days) - 1;
 }
-function pv(rate, nper, pmt, fv2 = 0, type = 0) {
-  if (rate === 0) return -(pmt * nper + fv2);
-  const factor = Math.pow(1 + rate, nper);
-  return -(pmt * (1 + rate * type) * ((factor - 1) / rate) + fv2) / factor;
+function pv(rate, nper2, pmt2, fv2 = 0, type = 0) {
+  if (rate === 0) return -(pmt2 * nper2 + fv2);
+  const factor = Math.pow(1 + rate, nper2);
+  return -(pmt2 * (1 + rate * type) * ((factor - 1) / rate) + fv2) / factor;
 }
-function fv(rate, nper, pmt, pvVal = 0, type = 0) {
-  if (rate === 0) return -(pvVal + pmt * nper);
-  const factor = Math.pow(1 + rate, nper);
-  return -(pvVal * factor + pmt * (1 + rate * type) * ((factor - 1) / rate));
+function fv(rate, nper2, pmt2, pvVal = 0, type = 0) {
+  if (rate === 0) return -(pvVal + pmt2 * nper2);
+  const factor = Math.pow(1 + rate, nper2);
+  return -(pvVal * factor + pmt2 * (1 + rate * type) * ((factor - 1) / rate));
+}
+function pmt(rate, nper2, pvVal, fvVal = 0, type = 0) {
+  if (nper2 <= 0) return 0;
+  if (rate === 0) return -(pvVal + fvVal) / nper2;
+  const factor = Math.pow(1 + rate, nper2);
+  return -(pvVal * factor + fvVal) * rate / ((1 + rate * type) * (factor - 1));
+}
+function nper(rate, pmtVal, pvVal, fvVal = 0, type = 0) {
+  if (rate === 0) {
+    if (pmtVal === 0) return 0;
+    return -(pvVal + fvVal) / pmtVal;
+  }
+  const pmtAdj = pmtVal * (1 + rate * type);
+  const num = Math.log((pmtAdj - fvVal * rate) / (pmtAdj + pvVal * rate));
+  const den = Math.log(1 + rate);
+  if (den === 0) return 0;
+  return num / den;
+}
+function rateCalc(nperVal, pmtVal, pvVal, fvVal = 0, type = 0, guess = 0.1) {
+  if (nperVal <= 0) return 0;
+  let r = guess;
+  const maxIter = 1e3;
+  const tol = 1e-10;
+  for (let i = 0; i < maxIter; i++) {
+    const factor = Math.pow(1 + r, nperVal);
+    const pmtAdj = pmtVal * (1 + r * type);
+    const f = pvVal * factor + pmtAdj * ((factor - 1) / r) + fvVal;
+    const dfactor = nperVal * Math.pow(1 + r, nperVal - 1);
+    const dpmtAdj = pmtVal * type;
+    const df = pvVal * dfactor + dpmtAdj * ((factor - 1) / r) + pmtAdj * ((dfactor * r - (factor - 1)) / (r * r));
+    if (Math.abs(df) < tol) break;
+    const newR = r - f / df;
+    if (Math.abs(newR - r) < tol) return newR;
+    r = newR;
+  }
+  return r;
+}
+function yearFrac(d1, d2, dayCount = "ACT/365") {
+  const ms = d2.getTime() - d1.getTime();
+  const days = ms / (1e3 * 60 * 60 * 24);
+  return dayCount === "ACT/360" ? days / 360 : days / 365;
+}
+function xnpv(rate, cashflows, dayCount = "ACT/365") {
+  if (cashflows.length === 0) return 0;
+  const sorted = [...cashflows].sort((a, b) => a.date.getTime() - b.date.getTime());
+  const d0 = sorted[0].date;
+  return sorted.reduce((sum, cf) => {
+    const yf = yearFrac(d0, cf.date, dayCount);
+    return sum + cf.amount / Math.pow(1 + rate, yf);
+  }, 0);
+}
+function xirr(cashflows, guess = 0.1, dayCount = "ACT/365") {
+  if (cashflows.length < 2) return 0;
+  const sorted = [...cashflows].sort((a, b) => a.date.getTime() - b.date.getTime());
+  const d0 = sorted[0].date;
+  const yfs = sorted.map((cf) => yearFrac(d0, cf.date, dayCount));
+  const amounts = sorted.map((cf) => cf.amount);
+  let rate = guess;
+  const maxIter = 1e3;
+  const tol = 1e-10;
+  for (let i = 0; i < maxIter; i++) {
+    let f = 0;
+    let df = 0;
+    for (let j = 0; j < amounts.length; j++) {
+      const disc = Math.pow(1 + rate, yfs[j]);
+      f += amounts[j] / disc;
+      if (yfs[j] !== 0) {
+        df -= yfs[j] * amounts[j] / Math.pow(1 + rate, yfs[j] + 1);
+      }
+    }
+    if (Math.abs(f) < tol) return rate;
+    if (Math.abs(df) < tol) break;
+    rate -= f / df;
+  }
+  let lo = -0.99;
+  let hi = 10;
+  for (let i = 0; i < 1e3; i++) {
+    const mid = (lo + hi) / 2;
+    let f = 0;
+    for (let j = 0; j < amounts.length; j++) {
+      f += amounts[j] / Math.pow(1 + mid, yfs[j]);
+    }
+    if (Math.abs(f) < tol) return mid;
+    let fLo = 0;
+    for (let j = 0; j < amounts.length; j++) {
+      fLo += amounts[j] / Math.pow(1 + lo, yfs[j]);
+    }
+    if (f * fLo > 0) lo = mid;
+    else hi = mid;
+  }
+  return (lo + hi) / 2;
+}
+function trailingReturn(series, windowDays) {
+  if (series.length < 2 || windowDays <= 0) return 0;
+  const sorted = [...series].sort((a, b) => a.date.getTime() - b.date.getTime());
+  const latest = sorted[sorted.length - 1];
+  const cutoff = latest.date.getTime() - windowDays * 24 * 60 * 60 * 1e3;
+  let closest = sorted[0];
+  let minDiff = Math.abs(sorted[0].date.getTime() - cutoff);
+  for (const pt of sorted) {
+    const diff = Math.abs(pt.date.getTime() - cutoff);
+    if (diff < minDiff) {
+      minDiff = diff;
+      closest = pt;
+    }
+  }
+  if (closest.value <= 0) return 0;
+  return (latest.value - closest.value) / closest.value;
+}
+function stepUpSipFutureValue(params) {
+  return sipFutureValue(params);
 }
 function volatility(returns, periodsPerYear = 252) {
   if (returns.length < 2) return 0;

package/dist/index.d.ts

@@ -103,6 +103,32 @@ export declare function absoluteReturn(beginValue: number, endValue: number): nu
 export declare function annualizedReturn(beginValue: number, endValue: number, days: number): number;
 export declare function pv(rate: number, nper: number, pmt: number, fv?: number, type?: number): number;
 export declare function fv(rate: number, nper: number, pmt: number, pvVal?: number, type?: number): number;
+export declare function pmt(rate: number, nper: number, pvVal: number, fvVal?: number, type?: number): number;
+export declare function nper(rate: number, pmtVal: number, pvVal: number, fvVal?: number, type?: number): number;
+export declare function rateCalc(nperVal: number, pmtVal: number, pvVal: number, fvVal?: number, type?: number, guess?: number): number;
+export declare function xnpv(rate: number, cashflows: {
+    date: Date;
+    amount: number;
+}[], dayCount?: "ACT/365" | "ACT/360"): number;
+export declare function xirr(cashflows: {
+    date: Date;
+    amount: number;
+}[], guess?: number, dayCount?: "ACT/365" | "ACT/360"): number;
+export declare function trailingReturn(series: {
+    date: Date;
+    value: number;
+}[], windowDays: number): number;
+export declare function stepUpSipFutureValue(params: {
+    monthlyInvestment: number;
+    annualRate: number;
+    months: number;
+    stepUpPercentAnnual: number;
+    investmentAt?: "begin" | "end";
+}): {
+    futureValue: number;
+    totalInvested: number;
+    estimatedGains: number;
+};
 export declare function volatility(returns: number[], periodsPerYear?: number): number;
 export declare function sharpe(returns: number[], riskFreeRateAnnual?: number, periodsPerYear?: number): number;
 export declare function sortino(returns: number[], riskFreeRateAnnual?: number, periodsPerYear?: number): number;

package/dist/index.mjs

@@ -214,15 +214,126 @@ function annualizedReturn(beginValue, endValue, days) {
   if (beginValue <= 0 || days <= 0) return 0;
   return Math.pow(endValue / beginValue, 365 / days) - 1;
 }
-function pv(rate, nper, pmt, fv2 = 0, type = 0) {
-  if (rate === 0) return -(pmt * nper + fv2);
-  const factor = Math.pow(1 + rate, nper);
-  return -(pmt * (1 + rate * type) * ((factor - 1) / rate) + fv2) / factor;
+function pv(rate, nper2, pmt2, fv2 = 0, type = 0) {
+  if (rate === 0) return -(pmt2 * nper2 + fv2);
+  const factor = Math.pow(1 + rate, nper2);
+  return -(pmt2 * (1 + rate * type) * ((factor - 1) / rate) + fv2) / factor;
 }
-function fv(rate, nper, pmt, pvVal = 0, type = 0) {
-  if (rate === 0) return -(pvVal + pmt * nper);
-  const factor = Math.pow(1 + rate, nper);
-  return -(pvVal * factor + pmt * (1 + rate * type) * ((factor - 1) / rate));
+function fv(rate, nper2, pmt2, pvVal = 0, type = 0) {
+  if (rate === 0) return -(pvVal + pmt2 * nper2);
+  const factor = Math.pow(1 + rate, nper2);
+  return -(pvVal * factor + pmt2 * (1 + rate * type) * ((factor - 1) / rate));
+}
+function pmt(rate, nper2, pvVal, fvVal = 0, type = 0) {
+  if (nper2 <= 0) return 0;
+  if (rate === 0) return -(pvVal + fvVal) / nper2;
+  const factor = Math.pow(1 + rate, nper2);
+  return -(pvVal * factor + fvVal) * rate / ((1 + rate * type) * (factor - 1));
+}
+function nper(rate, pmtVal, pvVal, fvVal = 0, type = 0) {
+  if (rate === 0) {
+    if (pmtVal === 0) return 0;
+    return -(pvVal + fvVal) / pmtVal;
+  }
+  const pmtAdj = pmtVal * (1 + rate * type);
+  const num = Math.log((pmtAdj - fvVal * rate) / (pmtAdj + pvVal * rate));
+  const den = Math.log(1 + rate);
+  if (den === 0) return 0;
+  return num / den;
+}
+function rateCalc(nperVal, pmtVal, pvVal, fvVal = 0, type = 0, guess = 0.1) {
+  if (nperVal <= 0) return 0;
+  let r = guess;
+  const maxIter = 1e3;
+  const tol = 1e-10;
+  for (let i = 0; i < maxIter; i++) {
+    const factor = Math.pow(1 + r, nperVal);
+    const pmtAdj = pmtVal * (1 + r * type);
+    const f = pvVal * factor + pmtAdj * ((factor - 1) / r) + fvVal;
+    const dfactor = nperVal * Math.pow(1 + r, nperVal - 1);
+    const dpmtAdj = pmtVal * type;
+    const df = pvVal * dfactor + dpmtAdj * ((factor - 1) / r) + pmtAdj * ((dfactor * r - (factor - 1)) / (r * r));
+    if (Math.abs(df) < tol) break;
+    const newR = r - f / df;
+    if (Math.abs(newR - r) < tol) return newR;
+    r = newR;
+  }
+  return r;
+}
+function yearFrac(d1, d2, dayCount = "ACT/365") {
+  const ms = d2.getTime() - d1.getTime();
+  const days = ms / (1e3 * 60 * 60 * 24);
+  return dayCount === "ACT/360" ? days / 360 : days / 365;
+}
+function xnpv(rate, cashflows, dayCount = "ACT/365") {
+  if (cashflows.length === 0) return 0;
+  const sorted = [...cashflows].sort((a, b) => a.date.getTime() - b.date.getTime());
+  const d0 = sorted[0].date;
+  return sorted.reduce((sum, cf) => {
+    const yf = yearFrac(d0, cf.date, dayCount);
+    return sum + cf.amount / Math.pow(1 + rate, yf);
+  }, 0);
+}
+function xirr(cashflows, guess = 0.1, dayCount = "ACT/365") {
+  if (cashflows.length < 2) return 0;
+  const sorted = [...cashflows].sort((a, b) => a.date.getTime() - b.date.getTime());
+  const d0 = sorted[0].date;
+  const yfs = sorted.map((cf) => yearFrac(d0, cf.date, dayCount));
+  const amounts = sorted.map((cf) => cf.amount);
+  let rate = guess;
+  const maxIter = 1e3;
+  const tol = 1e-10;
+  for (let i = 0; i < maxIter; i++) {
+    let f = 0;
+    let df = 0;
+    for (let j = 0; j < amounts.length; j++) {
+      const disc = Math.pow(1 + rate, yfs[j]);
+      f += amounts[j] / disc;
+      if (yfs[j] !== 0) {
+        df -= yfs[j] * amounts[j] / Math.pow(1 + rate, yfs[j] + 1);
+      }
+    }
+    if (Math.abs(f) < tol) return rate;
+    if (Math.abs(df) < tol) break;
+    rate -= f / df;
+  }
+  let lo = -0.99;
+  let hi = 10;
+  for (let i = 0; i < 1e3; i++) {
+    const mid = (lo + hi) / 2;
+    let f = 0;
+    for (let j = 0; j < amounts.length; j++) {
+      f += amounts[j] / Math.pow(1 + mid, yfs[j]);
+    }
+    if (Math.abs(f) < tol) return mid;
+    let fLo = 0;
+    for (let j = 0; j < amounts.length; j++) {
+      fLo += amounts[j] / Math.pow(1 + lo, yfs[j]);
+    }
+    if (f * fLo > 0) lo = mid;
+    else hi = mid;
+  }
+  return (lo + hi) / 2;
+}
+function trailingReturn(series, windowDays) {
+  if (series.length < 2 || windowDays <= 0) return 0;
+  const sorted = [...series].sort((a, b) => a.date.getTime() - b.date.getTime());
+  const latest = sorted[sorted.length - 1];
+  const cutoff = latest.date.getTime() - windowDays * 24 * 60 * 60 * 1e3;
+  let closest = sorted[0];
+  let minDiff = Math.abs(sorted[0].date.getTime() - cutoff);
+  for (const pt of sorted) {
+    const diff = Math.abs(pt.date.getTime() - cutoff);
+    if (diff < minDiff) {
+      minDiff = diff;
+      closest = pt;
+    }
+  }
+  if (closest.value <= 0) return 0;
+  return (latest.value - closest.value) / closest.value;
+}
+function stepUpSipFutureValue(params) {
+  return sipFutureValue(params);
 }
 function volatility(returns, periodsPerYear = 252) {
   if (returns.length < 2) return 0;
@@ -322,9 +433,12 @@ export {
   irr,
   lumpsumFutureValue,
   maxDrawdown,
+  nper,
   npv,
+  pmt,
   prepaymentImpact,
   pv,
+  rateCalc,
   realReturn,
   rebalance,
   requiredLumpsumForGoal,
@@ -333,7 +447,11 @@ export {
   sharpe,
   sipFutureValue,
   sortino,
+  stepUpSipFutureValue,
   swpPlan,
+  trailingReturn,
   volatility,
-  weightedReturn
+  weightedReturn,
+  xirr,
+  xnpv
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fundamental-js",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Comprehensive financial calculator library for investing, loans, and personal finance. Includes EMI, SIP, SWP, amortization, CAGR, IRR, NPV, risk metrics, and more.",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
@@ -13,7 +13,8 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "README.md"
   ],
   "keywords": [
     "finance",