fin-ratios 0.1.0

package/dist/index.js

@@ -0,0 +1,1040 @@
+// src/utils/safe-divide.ts
+function safeDivide(numerator, denominator) {
+  if (numerator == null || denominator == null) return null;
+  if (denominator === 0) return null;
+  return numerator / denominator;
+}
+
+// src/ratios/valuation/index.ts
+function pe(input) {
+  return safeDivide(input.marketCap, input.netIncome);
+}
+pe.formula = "Market Capitalization / Net Income";
+pe.description = "Trailing price-to-earnings ratio. How much investors pay per dollar of earnings.";
+function forwardPe(input) {
+  return safeDivide(input.price, input.forwardEps);
+}
+forwardPe.formula = "Stock Price / Forward EPS Estimate";
+forwardPe.description = "P/E based on next twelve months analyst EPS estimate.";
+function peg(input) {
+  return safeDivide(input.peRatio, input.epsGrowthRatePercent);
+}
+peg.formula = "P/E Ratio / EPS Annual Growth Rate (%)";
+peg.description = "PEG ratio. < 1 may indicate undervaluation relative to growth.";
+function pb(input) {
+  return safeDivide(input.marketCap, input.totalEquity);
+}
+pb.formula = "Market Capitalization / Total Shareholders Equity";
+pb.description = "Price-to-book ratio. < 1 may indicate trading below net asset value.";
+function ps(input) {
+  return safeDivide(input.marketCap, input.revenue);
+}
+ps.formula = "Market Capitalization / Revenue";
+ps.description = "Price-to-sales ratio. Useful when earnings are negative.";
+function pFcf(input) {
+  const fcf = input.operatingCashFlow - Math.abs(input.capex);
+  return safeDivide(input.marketCap, fcf);
+}
+pFcf.formula = "Market Capitalization / (Operating Cash Flow - Capex)";
+pFcf.description = "Price-to-free-cash-flow. Often considered cleaner than P/E.";
+function enterpriseValue(input) {
+  return input.marketCap + input.totalDebt - input.cash + (input.minorityInterest ?? 0) + (input.preferredStock ?? 0);
+}
+enterpriseValue.formula = "Market Cap + Total Debt - Cash + Minority Interest + Preferred Stock";
+enterpriseValue.description = "Enterprise value \u2014 the theoretical takeover price of a company.";
+function evEbitda(input) {
+  return safeDivide(input.enterpriseValue, input.ebitda);
+}
+evEbitda.formula = "Enterprise Value / EBITDA";
+evEbitda.description = "Capital-structure-neutral valuation multiple. Popular in LBO analysis.";
+function evEbit(input) {
+  return safeDivide(input.enterpriseValue, input.ebit);
+}
+evEbit.formula = "Enterprise Value / EBIT";
+evEbit.description = "Like EV/EBITDA but accounts for depreciation-heavy businesses.";
+function evRevenue(input) {
+  return safeDivide(input.enterpriseValue, input.revenue);
+}
+evRevenue.formula = "Enterprise Value / Revenue";
+evRevenue.description = "Useful for high-growth companies without positive EBITDA.";
+function evFcf(input) {
+  return safeDivide(input.enterpriseValue, input.freeCashFlow);
+}
+evFcf.formula = "Enterprise Value / Free Cash Flow";
+evFcf.description = "EV-to-free-cash-flow. Preferred by value investors.";
+function evInvestedCapital(input) {
+  return safeDivide(input.enterpriseValue, input.investedCapital);
+}
+evInvestedCapital.formula = "Enterprise Value / Invested Capital";
+evInvestedCapital.description = "Indicates whether the market values the company above its invested capital base.";
+function tobinsQ(input) {
+  const marketValue = input.marketCap + input.totalDebt;
+  return safeDivide(marketValue, input.totalAssets);
+}
+tobinsQ.formula = "(Market Cap + Total Debt) / Total Assets";
+tobinsQ.description = "Q > 1 = market values firm above replacement cost. Q < 1 = below.";
+function grahamNumber(input) {
+  if (input.eps <= 0 || input.bookValuePerShare <= 0) return null;
+  return Math.sqrt(22.5 * input.eps * input.bookValuePerShare);
+}
+grahamNumber.formula = "sqrt(22.5 \xD7 EPS \xD7 Book Value Per Share)";
+grahamNumber.description = "Ben Graham's estimate of fair value. Buy below, sell above.";
+function grahamIntrinsicValue(input) {
+  if (input.aaaBondYield <= 0) return null;
+  return safeDivide(
+    input.eps * (8.5 + 2 * input.growthRate) * 4.4,
+    input.aaaBondYield
+  );
+}
+grahamIntrinsicValue.formula = "EPS \xD7 (8.5 + 2 \xD7 Growth Rate) \xD7 4.4 / AAA Bond Yield";
+grahamIntrinsicValue.description = "Graham's 1962 revised intrinsic value formula. Use growth rate as %, e.g. 15.";
+
+// src/ratios/valuation/dcf.ts
+function dcf2Stage(input) {
+  if (input.wacc <= input.terminalGrowthRate) return null;
+  if (input.wacc <= 0) return null;
+  let pvStage1 = 0;
+  let fcf = input.baseFcf;
+  for (let t = 1; t <= input.years; t++) {
+    fcf = fcf * (1 + input.growthRate);
+    pvStage1 += fcf / Math.pow(1 + input.wacc, t);
+  }
+  const terminalFcf = fcf * (1 + input.terminalGrowthRate);
+  const terminalValue = terminalFcf / (input.wacc - input.terminalGrowthRate);
+  const pvTerminalValue = terminalValue / Math.pow(1 + input.wacc, input.years);
+  const enterpriseValue2 = pvStage1 + pvTerminalValue;
+  const intrinsicValue = enterpriseValue2 - (input.netDebt ?? 0);
+  const intrinsicValuePerShare = input.sharesOutstanding ? safeDivide(intrinsicValue, input.sharesOutstanding) : null;
+  return { intrinsicValue, intrinsicValuePerShare, pvStage1, pvTerminalValue, terminalValue };
+}
+dcf2Stage.formula = "Sum(FCF_t / (1+WACC)^t) + [FCF_n*(1+g) / (WACC-g)] / (1+WACC)^n";
+dcf2Stage.description = "2-stage DCF. Stage 1 explicit growth, Stage 2 terminal value via Gordon Growth Model.";
+function gordonGrowthModel(input) {
+  if (input.requiredReturn <= input.dividendGrowthRate) return null;
+  return safeDivide(input.nextDividend, input.requiredReturn - input.dividendGrowthRate);
+}
+gordonGrowthModel.formula = "D1 / (r - g)";
+gordonGrowthModel.description = "DDM for stable dividend-paying stocks. Only valid when r > g.";
+function reverseDcf(input) {
+  const target = input.marketCap + (input.netDebt ?? 0);
+  const computeEV = (g) => {
+    const result = dcf2Stage({
+      baseFcf: input.baseFcf,
+      growthRate: g,
+      years: input.years,
+      terminalGrowthRate: input.terminalGrowthRate,
+      wacc: input.wacc
+    });
+    return result?.intrinsicValue ?? null;
+  };
+  let low = -0.5;
+  let high = 5;
+  for (let i = 0; i < 50; i++) {
+    const mid = (low + high) / 2;
+    const ev = computeEV(mid);
+    if (ev == null) return null;
+    if (Math.abs(ev - target) < 1) break;
+    if (ev < target) low = mid;
+    else high = mid;
+  }
+  const impliedGrowthRate = (low + high) / 2;
+  return {
+    impliedGrowthRate,
+    interpretation: `Market implies ${(impliedGrowthRate * 100).toFixed(1)}% annual FCF growth over ${input.years} years`
+  };
+}
+reverseDcf.formula = "Solve g such that DCF(g) = Market Cap";
+reverseDcf.description = "Reverse-engineers the FCF growth rate implied by the current stock price.";
+
+// src/ratios/profitability/index.ts
+function grossMargin(input) {
+  return safeDivide(input.grossProfit, input.revenue);
+}
+grossMargin.formula = "Gross Profit / Revenue";
+grossMargin.description = "Percentage of revenue remaining after cost of goods sold.";
+function operatingMargin(input) {
+  return safeDivide(input.ebit, input.revenue);
+}
+operatingMargin.formula = "EBIT / Revenue";
+operatingMargin.description = "Operating income as a percentage of revenue.";
+function ebitdaMargin(input) {
+  return safeDivide(input.ebitda, input.revenue);
+}
+ebitdaMargin.formula = "EBITDA / Revenue";
+ebitdaMargin.description = "Earnings before interest, taxes, D&A as % of revenue.";
+function netProfitMargin(input) {
+  return safeDivide(input.netIncome, input.revenue);
+}
+netProfitMargin.formula = "Net Income / Revenue";
+netProfitMargin.description = "Bottom-line profitability after all expenses.";
+function nopatMargin(input) {
+  return safeDivide(input.nopat, input.revenue);
+}
+nopatMargin.formula = "NOPAT / Revenue";
+nopatMargin.description = "Net operating profit after tax as % of revenue.";
+function roe(input) {
+  return safeDivide(input.netIncome, input.avgTotalEquity);
+}
+roe.formula = "Net Income / Average Total Equity";
+roe.description = "Return on equity \u2014 how efficiently a company uses shareholder capital.";
+function roa(input) {
+  return safeDivide(input.netIncome, input.avgTotalAssets);
+}
+roa.formula = "Net Income / Average Total Assets";
+roa.description = "Return on assets \u2014 how efficiently assets are used to generate profit.";
+function nopat(input) {
+  return input.ebit * (1 - input.taxRate);
+}
+nopat.formula = "EBIT \xD7 (1 - Effective Tax Rate)";
+nopat.description = "Net operating profit after tax \u2014 removes financing effects.";
+function roic(input) {
+  return safeDivide(input.nopat, input.investedCapital);
+}
+roic.formula = "NOPAT / Invested Capital";
+roic.description = "ROIC vs WACC determines whether a company creates or destroys value.";
+function roce(input) {
+  const capitalEmployed = input.totalAssets - input.currentLiabilities;
+  return safeDivide(input.ebit, capitalEmployed);
+}
+roce.formula = "EBIT / (Total Assets - Current Liabilities)";
+roce.description = "Return on capital employed. Includes both equity and long-term debt.";
+function rote(input) {
+  const tangibleEquity = input.avgTotalEquity - input.avgGoodwill - input.avgIntangibleAssets;
+  return safeDivide(input.netIncome, tangibleEquity);
+}
+rote.formula = "Net Income / (Avg Equity - Avg Goodwill - Avg Intangibles)";
+rote.description = "Return on tangible equity. Strips acquisition premiums from the denominator.";
+function duPont3(input) {
+  const margin = safeDivide(input.netIncome, input.revenue);
+  const turnover = safeDivide(input.revenue, input.avgTotalAssets);
+  const multiplier = safeDivide(input.avgTotalAssets, input.avgTotalEquity);
+  const roeVal = margin != null && turnover != null && multiplier != null ? margin * turnover * multiplier : null;
+  return { netProfitMargin: margin, assetTurnover: turnover, equityMultiplier: multiplier, roe: roeVal };
+}
+duPont3.formula = "ROE = Net Profit Margin \xD7 Asset Turnover \xD7 Equity Multiplier";
+duPont3.description = "3-factor DuPont decomposition of ROE.";
+function revenuePerEmployee(input) {
+  return safeDivide(input.revenue, input.employeeCount);
+}
+revenuePerEmployee.formula = "Revenue / Full-Time Employees";
+revenuePerEmployee.description = "Measures workforce productivity.";
+function profitPerEmployee(input) {
+  return safeDivide(input.netIncome, input.employeeCount);
+}
+profitPerEmployee.formula = "Net Income / Full-Time Employees";
+profitPerEmployee.description = "Net income generated per employee.";
+function investedCapital(input) {
+  return input.totalEquity + input.totalDebt - input.cash;
+}
+investedCapital.formula = "Total Equity + Total Debt - Excess Cash";
+investedCapital.description = "Capital deployed to generate operating returns.";
+
+// src/ratios/liquidity/index.ts
+function currentRatio(input) {
+  return safeDivide(input.currentAssets, input.currentLiabilities);
+}
+currentRatio.formula = "Current Assets / Current Liabilities";
+currentRatio.description = "Ability to pay short-term obligations. > 1 generally healthy.";
+function quickRatio(input) {
+  const liquid = input.cash + input.shortTermInvestments + input.accountsReceivable;
+  return safeDivide(liquid, input.currentLiabilities);
+}
+quickRatio.formula = "(Cash + ST Investments + Accounts Receivable) / Current Liabilities";
+quickRatio.description = "Liquidity excluding inventory. More conservative than current ratio.";
+function cashRatio(input) {
+  return safeDivide(input.cash + input.shortTermInvestments, input.currentLiabilities);
+}
+cashRatio.formula = "(Cash + Short-Term Investments) / Current Liabilities";
+cashRatio.description = "Most conservative liquidity measure. Only counts actual cash.";
+function operatingCashFlowRatio(input) {
+  return safeDivide(input.operatingCashFlow, input.currentLiabilities);
+}
+operatingCashFlowRatio.formula = "Operating Cash Flow / Current Liabilities";
+operatingCashFlowRatio.description = "How well operating cash flow covers short-term obligations.";
+function dso(input) {
+  return safeDivide(input.accountsReceivable * 365, input.revenue);
+}
+dso.formula = "(Accounts Receivable / Revenue) \xD7 365";
+dso.description = "Days Sales Outstanding \u2014 average days to collect payment after a sale.";
+function dio(input) {
+  return safeDivide(input.inventory * 365, input.cogs);
+}
+dio.formula = "(Inventory / COGS) \xD7 365";
+dio.description = "Days Inventory Outstanding \u2014 average days inventory is held before sale.";
+function dpo(input) {
+  return safeDivide(input.accountsPayable * 365, input.cogs);
+}
+dpo.formula = "(Accounts Payable / COGS) \xD7 365";
+dpo.description = "Days Payable Outstanding \u2014 average days taken to pay suppliers.";
+function cashConversionCycle(input) {
+  return input.dso + input.dio - input.dpo;
+}
+cashConversionCycle.formula = "DSO + DIO - DPO";
+cashConversionCycle.description = "Days from cash outflow (inventory) to cash inflow (collections). Lower is better.";
+function defensiveIntervalRatio(input) {
+  const liquid = input.cash + input.shortTermInvestments + input.accountsReceivable;
+  return safeDivide(liquid, input.dailyOperatingExpenses);
+}
+defensiveIntervalRatio.formula = "(Cash + ST Investments + AR) / Daily Operating Expenses";
+defensiveIntervalRatio.description = "Days the company can operate using liquid assets alone, without new revenue.";
+
+// src/ratios/solvency/index.ts
+function debtToEquity(input) {
+  return safeDivide(input.totalDebt, input.totalEquity);
+}
+debtToEquity.formula = "Total Debt / Total Equity";
+debtToEquity.description = "Financial leverage. Higher = more debt-financed.";
+function netDebtToEquity(input) {
+  const netDebt = input.totalDebt - input.cash;
+  return safeDivide(netDebt, input.totalEquity);
+}
+netDebtToEquity.formula = "(Total Debt - Cash) / Total Equity";
+netDebtToEquity.description = "Net leverage ratio. Negative = net cash position.";
+function netDebtToEbitda(input) {
+  const netDebt = input.totalDebt - input.cash;
+  return safeDivide(netDebt, input.ebitda);
+}
+netDebtToEbitda.formula = "(Total Debt - Cash) / EBITDA";
+netDebtToEbitda.description = "Years to repay net debt from EBITDA. Lenders often require < 3x.";
+function debtToAssets(input) {
+  return safeDivide(input.totalDebt, input.totalAssets);
+}
+debtToAssets.formula = "Total Debt / Total Assets";
+debtToAssets.description = "Proportion of assets financed by debt.";
+function debtToCapital(input) {
+  return safeDivide(input.totalDebt, input.totalDebt + input.totalEquity);
+}
+debtToCapital.formula = "Total Debt / (Total Debt + Total Equity)";
+debtToCapital.description = "Proportion of capital structure that is debt.";
+function interestCoverageRatio(input) {
+  return safeDivide(input.ebit, input.interestExpense);
+}
+interestCoverageRatio.formula = "EBIT / Interest Expense";
+interestCoverageRatio.description = "Times interest is covered by operating earnings. < 1.5 is risky.";
+function ebitdaCoverageRatio(input) {
+  return safeDivide(input.ebitda, input.interestExpense);
+}
+ebitdaCoverageRatio.formula = "EBITDA / Interest Expense";
+ebitdaCoverageRatio.description = "Softer coverage ratio including D&A add-back.";
+function debtServiceCoverageRatio(input) {
+  return safeDivide(input.netOperatingIncome, input.annualDebtService);
+}
+debtServiceCoverageRatio.formula = "Net Operating Income / Annual Debt Service (Principal + Interest)";
+debtServiceCoverageRatio.description = "Lenders require DSCR > 1.25. Critical for real estate and leveraged deals.";
+function fixedChargeCoverageRatio(input) {
+  return safeDivide(input.ebit + input.fixedCharges, input.fixedCharges + input.interestExpense);
+}
+fixedChargeCoverageRatio.formula = "(EBIT + Fixed Charges) / (Fixed Charges + Interest Expense)";
+fixedChargeCoverageRatio.description = "Covers lease payments and other fixed obligations beyond interest.";
+function equityMultiplier(input) {
+  return safeDivide(input.totalAssets, input.totalEquity);
+}
+equityMultiplier.formula = "Total Assets / Total Equity";
+equityMultiplier.description = "Leverage component of DuPont analysis.";
+
+// src/ratios/efficiency/index.ts
+function assetTurnover(input) {
+  return safeDivide(input.revenue, input.avgTotalAssets);
+}
+assetTurnover.formula = "Revenue / Average Total Assets";
+assetTurnover.description = "Sales generated per dollar of total assets.";
+function fixedAssetTurnover(input) {
+  return safeDivide(input.revenue, input.avgNetPPE);
+}
+fixedAssetTurnover.formula = "Revenue / Average Net PP&E";
+fixedAssetTurnover.description = "Efficiency of physical asset use. Low in capital-intensive industries.";
+function inventoryTurnover(input) {
+  return safeDivide(input.cogs, input.avgInventory);
+}
+inventoryTurnover.formula = "COGS / Average Inventory";
+inventoryTurnover.description = "How many times inventory is sold per year. Higher = less cash tied up.";
+function receivablesTurnover(input) {
+  return safeDivide(input.revenue, input.avgAccountsReceivable);
+}
+receivablesTurnover.formula = "Revenue / Average Accounts Receivable";
+receivablesTurnover.description = "How quickly the company collects what it is owed.";
+function payablesTurnover(input) {
+  return safeDivide(input.cogs, input.avgAccountsPayable);
+}
+payablesTurnover.formula = "COGS / Average Accounts Payable";
+payablesTurnover.description = "How quickly the company pays its suppliers.";
+function workingCapitalTurnover(input) {
+  return safeDivide(input.revenue, input.avgWorkingCapital);
+}
+workingCapitalTurnover.formula = "Revenue / Average Working Capital";
+workingCapitalTurnover.description = "Revenue generated from each dollar of working capital.";
+function capitalTurnover(input) {
+  return safeDivide(input.revenue, input.investedCapital);
+}
+capitalTurnover.formula = "Revenue / Invested Capital";
+capitalTurnover.description = "Sales generated per dollar of invested capital.";
+function operatingLeverage(input) {
+  const ebitChange = safeDivide(
+    input.ebitCurrent - input.ebitPrior,
+    Math.abs(input.ebitPrior)
+  );
+  const revenueChange = safeDivide(
+    input.revenueCurrent - input.revenuePrior,
+    Math.abs(input.revenuePrior)
+  );
+  return safeDivide(ebitChange, revenueChange);
+}
+operatingLeverage.formula = "% Change in EBIT / % Change in Revenue";
+operatingLeverage.description = "Sensitivity of operating income to revenue changes. High = more fixed costs.";
+
+// src/ratios/cashflow/index.ts
+function freeCashFlow(input) {
+  return input.operatingCashFlow - Math.abs(input.capex);
+}
+freeCashFlow.formula = "Operating Cash Flow - Capital Expenditures";
+freeCashFlow.description = "Cash available after maintaining/growing asset base. The most important cash flow metric.";
+function leveredFcf(input) {
+  return input.freeCashFlow + input.debtIssuance - input.debtRepayments;
+}
+leveredFcf.formula = "FCF + Net Debt Change (Issuance - Repayments)";
+leveredFcf.description = "FCF after accounting for debt financing activities.";
+function unleveredFcf(input) {
+  return input.nopat + input.depreciationAndAmortization - Math.abs(input.capex) - input.changeInWorkingCapital;
+}
+unleveredFcf.formula = "NOPAT + D&A - Capex - Change in Working Capital";
+unleveredFcf.description = "FCF before debt payments \u2014 used in DCF valuation as FCFF.";
+function ownerEarnings(input) {
+  return input.netIncome + input.depreciationAndAmortization - input.maintenanceCapex - (input.changeInWorkingCapital ?? 0);
+}
+ownerEarnings.formula = "Net Income + D&A - Maintenance Capex - Change in WC";
+ownerEarnings.description = "Buffett's owner earnings \u2014 true economic earnings available to shareholders.";
+function fcfYield(input) {
+  return safeDivide(input.freeCashFlow, input.marketCap);
+}
+fcfYield.formula = "Free Cash Flow / Market Capitalization";
+fcfYield.description = "FCF per dollar invested. Inverse of P/FCF. Higher = cheaper.";
+function fcfMargin(input) {
+  return safeDivide(input.freeCashFlow, input.revenue);
+}
+fcfMargin.formula = "Free Cash Flow / Revenue";
+fcfMargin.description = "FCF generated per dollar of revenue.";
+function fcfConversion(input) {
+  return safeDivide(input.freeCashFlow, input.netIncome);
+}
+fcfConversion.formula = "Free Cash Flow / Net Income";
+fcfConversion.description = "FCF conversion > 1 means earnings are backed by real cash. < 1 raises quality concerns.";
+function ocfToSales(input) {
+  return safeDivide(input.operatingCashFlow, input.revenue);
+}
+ocfToSales.formula = "Operating Cash Flow / Revenue";
+ocfToSales.description = "Cash generated from operations per dollar of sales.";
+function capexToRevenue(input) {
+  return safeDivide(Math.abs(input.capex), input.revenue);
+}
+capexToRevenue.formula = "Capital Expenditures / Revenue";
+capexToRevenue.description = "Investment intensity. High in capital-intensive industries like manufacturing.";
+function capexToDepreciation(input) {
+  return safeDivide(Math.abs(input.capex), input.depreciation);
+}
+capexToDepreciation.formula = "Capital Expenditures / Depreciation";
+capexToDepreciation.description = "> 1 = company is investing more than assets are aging (growth). < 1 = under-investing.";
+function cashReturnOnAssets(input) {
+  return safeDivide(input.operatingCashFlow, input.totalAssets);
+}
+cashReturnOnAssets.formula = "Operating Cash Flow / Total Assets";
+cashReturnOnAssets.description = "Cash-based ROA. Harder to manipulate than accrual-based ROA.";
+
+// src/utils/math.ts
+function cagr(start, end, years) {
+  if (start == null || end == null || years <= 0) return null;
+  if (start <= 0) return null;
+  return Math.pow(end / start, 1 / years) - 1;
+}
+function annualizeReturn(returnValue, periodsPerYear) {
+  return Math.pow(1 + returnValue, periodsPerYear) - 1;
+}
+function stdDev(values, ddof = 1) {
+  if (values.length < 2) return null;
+  const mean2 = values.reduce((a, b) => a + b, 0) / values.length;
+  const variance = values.reduce((sum, v) => sum + Math.pow(v - mean2, 2), 0) / (values.length - ddof);
+  return Math.sqrt(variance);
+}
+function mean(values) {
+  if (values.length === 0) return null;
+  return values.reduce((a, b) => a + b, 0) / values.length;
+}
+function percentile(values, p) {
+  if (values.length === 0) return null;
+  const sorted = [...values].sort((a, b) => a - b);
+  const idx = p * (sorted.length - 1);
+  const lower = Math.floor(idx);
+  const upper = Math.ceil(idx);
+  if (lower === upper) return sorted[lower] ?? null;
+  const lv = sorted[lower];
+  const uv = sorted[upper];
+  if (lv == null || uv == null) return null;
+  return lv + (uv - lv) * (idx - lower);
+}
+function maxDrawdown(prices) {
+  if (prices.length < 2) return null;
+  let peak = prices[0] ?? 0;
+  let maxDD = 0;
+  for (const price of prices) {
+    if (price > peak) peak = price;
+    const dd = peak > 0 ? (peak - price) / peak : 0;
+    if (dd > maxDD) maxDD = dd;
+  }
+  return maxDD;
+}
+function pricesToReturns(prices) {
+  const returns = [];
+  for (let i = 1; i < prices.length; i++) {
+    const prev = prices[i - 1];
+    const curr = prices[i];
+    if (prev != null && curr != null && prev !== 0) {
+      returns.push((curr - prev) / prev);
+    }
+  }
+  return returns;
+}
+
+// src/ratios/growth/index.ts
+function yoyGrowth(current, prior) {
+  if (prior === 0) return null;
+  return safeDivide(current - prior, Math.abs(prior));
+}
+function revenueGrowth(input) {
+  return yoyGrowth(input.revenueCurrent, input.revenuePrior);
+}
+revenueGrowth.formula = "(Revenue_t - Revenue_t-1) / |Revenue_t-1|";
+revenueGrowth.description = "Year-over-year revenue growth rate.";
+function revenueCAGR(input) {
+  return cagr(input.revenueStart, input.revenueEnd, input.years);
+}
+revenueCAGR.formula = "(Revenue_end / Revenue_start)^(1/years) - 1";
+revenueCAGR.description = "Compound annual growth rate of revenue over multiple years.";
+function epsGrowth(input) {
+  return yoyGrowth(input.epsCurrent, input.epsPrior);
+}
+epsGrowth.formula = "(EPS_t - EPS_t-1) / |EPS_t-1|";
+epsGrowth.description = "Year-over-year earnings per share growth.";
+function ebitdaGrowth(input) {
+  return yoyGrowth(input.ebitdaCurrent, input.ebitdaPrior);
+}
+ebitdaGrowth.formula = "(EBITDA_t - EBITDA_t-1) / |EBITDA_t-1|";
+ebitdaGrowth.description = "Year-over-year EBITDA growth.";
+function fcfGrowth(input) {
+  return yoyGrowth(input.fcfCurrent, input.fcfPrior);
+}
+fcfGrowth.formula = "(FCF_t - FCF_t-1) / |FCF_t-1|";
+fcfGrowth.description = "Year-over-year free cash flow growth.";
+function bvpsGrowth(input) {
+  return yoyGrowth(input.bvpsCurrent, input.bvpsPrior);
+}
+bvpsGrowth.formula = "(BVPS_t - BVPS_t-1) / |BVPS_t-1|";
+bvpsGrowth.description = "Book value per share growth \u2014 tracks compounding of equity.";
+function dividendGrowthRate(input) {
+  return yoyGrowth(input.dpsCurrent, input.dpsPrior);
+}
+dividendGrowthRate.formula = "(DPS_t - DPS_t-1) / DPS_t-1";
+dividendGrowthRate.description = "Year-over-year dividend per share growth.";
+function earningsPowerValue(input) {
+  const nopatValue = input.ebit * (1 - input.taxRate);
+  return safeDivide(nopatValue, input.wacc);
+}
+earningsPowerValue.formula = "EBIT \xD7 (1 - Tax Rate) / WACC";
+earningsPowerValue.description = "EPV \u2014 intrinsic value assuming zero growth. Conservative floor for valuation.";
+
+// src/ratios/risk/index.ts
+function beta(input) {
+  const { stockReturns, marketReturns } = input;
+  if (stockReturns.length !== marketReturns.length || stockReturns.length < 2) return null;
+  const n = stockReturns.length;
+  const meanStock = stockReturns.reduce((a, b) => a + b, 0) / n;
+  const meanMarket = marketReturns.reduce((a, b) => a + b, 0) / n;
+  let covariance = 0;
+  let varianceMarket = 0;
+  for (let i = 0; i < n; i++) {
+    const ds = (stockReturns[i] ?? 0) - meanStock;
+    const dm = (marketReturns[i] ?? 0) - meanMarket;
+    covariance += ds * dm;
+    varianceMarket += dm * dm;
+  }
+  return safeDivide(covariance, varianceMarket);
+}
+beta.formula = "Cov(r_stock, r_market) / Var(r_market)";
+beta.description = "Sensitivity of stock returns to market returns. Beta = 1 means moves with market.";
+function jensensAlpha(input) {
+  return input.portfolioReturn - (input.riskFreeRate + input.beta * (input.marketReturn - input.riskFreeRate));
+}
+jensensAlpha.formula = "Rp - [Rf + \u03B2 \xD7 (Rm - Rf)]";
+jensensAlpha.description = "Excess return above what CAPM predicts. Positive = outperformance.";
+function sharpeRatio(input) {
+  const { returns, riskFreeRate, periodsPerYear = 252 } = input;
+  const avgReturn = mean(returns);
+  const vol = stdDev(returns, 1);
+  if (avgReturn == null || vol == null || vol === 0) return null;
+  const annualizedReturn = annualizeReturn(avgReturn, periodsPerYear);
+  const annualizedVol = vol * Math.sqrt(periodsPerYear);
+  return safeDivide(annualizedReturn - riskFreeRate, annualizedVol);
+}
+sharpeRatio.formula = "(Annualized Return - Risk-Free Rate) / Annualized StdDev";
+sharpeRatio.description = "Risk-adjusted return per unit of total volatility. > 1 is good, > 2 is excellent.";
+function sortinoRatio(input) {
+  const { returns, riskFreeRate, mar = 0, periodsPerYear = 252 } = input;
+  const avgReturn = mean(returns);
+  if (avgReturn == null) return null;
+  const downsideReturns = returns.filter((r) => r < mar);
+  if (downsideReturns.length === 0) return null;
+  const downsideVariance = downsideReturns.reduce((sum, r) => sum + Math.pow(r - mar, 2), 0) / returns.length;
+  const downsideDeviation = Math.sqrt(downsideVariance) * Math.sqrt(periodsPerYear);
+  if (downsideDeviation === 0) return null;
+  const annualizedReturn = annualizeReturn(avgReturn, periodsPerYear);
+  return safeDivide(annualizedReturn - riskFreeRate, downsideDeviation);
+}
+sortinoRatio.formula = "(Annualized Return - Rf) / Downside Deviation";
+sortinoRatio.description = "Like Sharpe but penalizes only downside volatility. Better for asymmetric returns.";
+function treynorRatio(input) {
+  return safeDivide(input.portfolioReturn - input.riskFreeRate, input.beta);
+}
+treynorRatio.formula = "(Portfolio Return - Risk-Free Rate) / Beta";
+treynorRatio.description = "Risk-adjusted return per unit of market (systematic) risk.";
+function calmarRatio(input) {
+  const { returns, periodsPerYear = 252 } = input;
+  const avgReturn = mean(returns);
+  if (avgReturn == null) return null;
+  returns.reduce((acc, r) => acc * (1 + r), 1);
+  const prices = [1];
+  let cur = 1;
+  for (const r of returns) {
+    cur *= 1 + r;
+    prices.push(cur);
+  }
+  const mdd = maxDrawdown(prices);
+  if (mdd == null || mdd === 0) return null;
+  const annualizedReturn = annualizeReturn(avgReturn, periodsPerYear);
+  return safeDivide(annualizedReturn, mdd);
+}
+calmarRatio.formula = "Annualized Return / Maximum Drawdown";
+calmarRatio.description = "Return relative to worst drawdown. Popular in hedge fund analysis.";
+function informationRatio(input) {
+  const { portfolioReturns, benchmarkReturns } = input;
+  if (portfolioReturns.length !== benchmarkReturns.length) return null;
+  const activeReturns = portfolioReturns.map((r, i) => r - (benchmarkReturns[i] ?? 0));
+  const avgActive = mean(activeReturns);
+  const trackingErr = stdDev(activeReturns, 1);
+  return safeDivide(avgActive, trackingErr);
+}
+informationRatio.formula = "Mean Active Return / Tracking Error";
+informationRatio.description = "Skill of an active manager. IR > 0.5 is considered good.";
+function omegaRatio(input) {
+  const { returns, threshold = 0 } = input;
+  let gains = 0;
+  let losses = 0;
+  for (const r of returns) {
+    if (r > threshold) gains += r - threshold;
+    else losses += threshold - r;
+  }
+  return safeDivide(gains, losses);
+}
+omegaRatio.formula = "E[returns above threshold] / E[returns below threshold]";
+omegaRatio.description = "Non-parametric risk-adjusted return. > 1 is desirable.";
+function maximumDrawdown(input) {
+  return maxDrawdown(input.prices);
+}
+maximumDrawdown.formula = "(Peak - Trough) / Peak";
+maximumDrawdown.description = "Largest peak-to-trough decline. Measures worst-case loss scenario.";
+function trackingError(input) {
+  const { portfolioReturns, benchmarkReturns, periodsPerYear = 252 } = input;
+  if (portfolioReturns.length !== benchmarkReturns.length) return null;
+  const activeReturns = portfolioReturns.map((r, i) => r - (benchmarkReturns[i] ?? 0));
+  const te = stdDev(activeReturns, 1);
+  if (te == null) return null;
+  return te * Math.sqrt(periodsPerYear);
+}
+trackingError.formula = "Annualized StdDev(Portfolio Returns - Benchmark Returns)";
+trackingError.description = "How closely a portfolio tracks its benchmark. Lower = more index-like.";
+function historicalVaR(input) {
+  const { returns, confidence = 0.95 } = input;
+  const p = percentile(returns, 1 - confidence);
+  return p != null ? -p : null;
+}
+historicalVaR.formula = "-Percentile(returns, 1 - confidence)";
+historicalVaR.description = "Historical VaR at given confidence level. Returns a positive loss value.";
+function parametricVaR(input) {
+  const { returns, confidence = 0.95 } = input;
+  const mu = mean(returns);
+  const sigma = stdDev(returns, 1);
+  if (mu == null || sigma == null) return null;
+  const zScores = {
+    0.9: 1.282,
+    0.95: 1.645,
+    0.99: 2.326,
+    0.999: 3.09
+  };
+  const z = zScores[confidence] ?? 1.645;
+  return -(mu - z * sigma);
+}
+parametricVaR.formula = "-(\u03BC - z \xD7 \u03C3)  where z is the normal quantile for confidence level";
+parametricVaR.description = "Parametric VaR assuming normal distribution.";
+function conditionalVaR(input) {
+  const { returns, confidence = 0.95 } = input;
+  const var_ = percentile(returns, 1 - confidence);
+  if (var_ == null) return null;
+  const tailReturns = returns.filter((r) => r <= var_);
+  const cvar = mean(tailReturns);
+  return cvar != null ? -cvar : null;
+}
+conditionalVaR.formula = "-Mean(returns that are \u2264 VaR threshold)";
+conditionalVaR.description = "CVaR / Expected Shortfall \u2014 average loss in the worst (1-confidence)% scenarios.";
+function ulcerIndex(input) {
+  const { prices } = input;
+  if (prices.length < 2) return null;
+  let peak = prices[0] ?? 0;
+  const drawdowns = [];
+  for (const p of prices) {
+    if (p > peak) peak = p;
+    drawdowns.push(peak > 0 ? (p - peak) / peak * 100 : 0);
+  }
+  const meanSqDD = drawdowns.reduce((sum, d) => sum + d * d, 0) / drawdowns.length;
+  return Math.sqrt(meanSqDD);
+}
+ulcerIndex.formula = "sqrt(mean(drawdown_pct^2))";
+ulcerIndex.description = "Measures drawdown depth and duration. Lower is less stressful.";
+function upsideCaptureRatio(input) {
+  const { portfolioReturns, benchmarkReturns } = input;
+  const upPeriods = benchmarkReturns.map((b, i) => ({ b, p: portfolioReturns[i] ?? 0 })).filter(({ b }) => b > 0);
+  if (upPeriods.length === 0) return null;
+  const portAvg = mean(upPeriods.map((x) => x.p));
+  const benchAvg = mean(upPeriods.map((x) => x.b));
+  return safeDivide(portAvg, benchAvg);
+}
+upsideCaptureRatio.formula = "Portfolio Return (up markets) / Benchmark Return (up markets)";
+upsideCaptureRatio.description = "> 100% means outperformed benchmark in up markets.";
+function downsideCaptureRatio(input) {
+  const { portfolioReturns, benchmarkReturns } = input;
+  const downPeriods = benchmarkReturns.map((b, i) => ({ b, p: portfolioReturns[i] ?? 0 })).filter(({ b }) => b < 0);
+  if (downPeriods.length === 0) return null;
+  const portAvg = mean(downPeriods.map((x) => x.p));
+  const benchAvg = mean(downPeriods.map((x) => x.b));
+  return safeDivide(portAvg, benchAvg);
+}
+downsideCaptureRatio.formula = "Portfolio Return (down markets) / Benchmark Return (down markets)";
+downsideCaptureRatio.description = "< 100% means lost less than benchmark in down markets.";
+
+// src/ratios/composite/index.ts
+function piotroskiFScore(input) {
+  const { current, prior } = input;
+  const roaCurrent = current.netIncome / current.totalAssets;
+  const roaPrior = prior.netIncome / prior.totalAssets;
+  const leverageCurrent = current.totalAssets > 0 ? current.longTermDebt / current.totalAssets : 0;
+  const leveragePrior = prior.totalAssets > 0 ? prior.longTermDebt / prior.totalAssets : 0;
+  const crCurrent = current.currentLiabilities > 0 ? current.currentAssets / current.currentLiabilities : 0;
+  const crPrior = prior.currentLiabilities > 0 ? prior.currentAssets / prior.currentLiabilities : 0;
+  const gmCurrent = current.revenue > 0 ? current.grossProfit / current.revenue : 0;
+  const gmPrior = prior.revenue > 0 ? prior.grossProfit / prior.revenue : 0;
+  const atCurrent = current.totalAssets > 0 ? current.revenue / current.totalAssets : 0;
+  const atPrior = prior.totalAssets > 0 ? prior.revenue / prior.totalAssets : 0;
+  const signals = {
+    // F1: ROA positive
+    roa_positive: roaCurrent > 0,
+    // F2: Operating cash flow positive
+    ocf_positive: current.operatingCashFlow > 0,
+    // F3: ROA improving year over year
+    roa_improving: roaCurrent > roaPrior,
+    // F4: Accruals — OCF > NI (quality earnings, cash-backed)
+    quality_earnings: current.operatingCashFlow > current.netIncome,
+    // F5: Long-term debt / assets ratio declined
+    lower_leverage: leverageCurrent < leveragePrior,
+    // F6: Current ratio improved
+    higher_liquidity: crCurrent > crPrior,
+    // F7: No new shares issued (dilution)
+    no_dilution: current.sharesOutstanding <= prior.sharesOutstanding,
+    // F8: Gross margin improved
+    higher_gross_margin: gmCurrent > gmPrior,
+    // F9: Asset turnover improved
+    higher_asset_turnover: atCurrent > atPrior
+  };
+  const score = Object.values(signals).filter(Boolean).length;
+  let interpretation = "";
+  if (score >= 8) interpretation = "Strong (8-9): High financial strength, potential value opportunity";
+  else if (score >= 6) interpretation = "Good (6-7): Reasonably healthy fundamentals";
+  else if (score >= 4) interpretation = "Neutral (4-5): Mixed signals, further analysis needed";
+  else interpretation = "Weak (0-3): Multiple red flags, high risk";
+  return { score, signals, interpretation };
+}
+piotroskiFScore.formula = "9 binary signals across Profitability, Leverage/Liquidity, Operating Efficiency";
+piotroskiFScore.description = "F-Score 0-9. >= 8 is strong buy signal. <= 2 is short signal.";
+function altmanZScore(input) {
+  if (input.totalAssets === 0 || input.totalLiabilities === 0) return null;
+  const x1 = input.workingCapital / input.totalAssets;
+  const x2 = input.retainedEarnings / input.totalAssets;
+  const x3 = input.ebit / input.totalAssets;
+  const x4 = input.marketCap / input.totalLiabilities;
+  const x5 = input.revenue / input.totalAssets;
+  const z = 1.2 * x1 + 1.4 * x2 + 3.3 * x3 + 0.6 * x4 + 1 * x5;
+  let zone;
+  let interpretation;
+  if (z > 2.99) {
+    zone = "safe";
+    interpretation = "Safe zone (Z > 2.99): Low probability of bankruptcy";
+  } else if (z > 1.81) {
+    zone = "grey";
+    interpretation = "Grey zone (1.81 < Z < 2.99): Uncertain, monitor closely";
+  } else {
+    zone = "distress";
+    interpretation = "Distress zone (Z < 1.81): High probability of financial distress";
+  }
+  return { z, x1, x2, x3, x4, x5, zone, interpretation };
+}
+altmanZScore.formula = "1.2\xD7X1 + 1.4\xD7X2 + 3.3\xD7X3 + 0.6\xD7X4 + 1.0\xD7X5 (public manufacturing)";
+altmanZScore.description = "Bankruptcy prediction model. Safe > 2.99, Distress < 1.81.";
+function beneishMScore(input) {
+  const { current: c, prior: p } = input;
+  if (p.revenue === 0 || p.totalAssets === 0 || p.grossProfit === 0) return null;
+  const dsri = safeDivide(
+    safeDivide(c.accountsReceivable, c.revenue),
+    safeDivide(p.accountsReceivable, p.revenue)
+  );
+  const gmi = safeDivide(
+    safeDivide(p.grossProfit, p.revenue),
+    safeDivide(c.grossProfit, c.revenue)
+  );
+  const aqiCurrent = c.totalAssets > 0 ? 1 - (c.accountsReceivable + c.ppGross + c.cashFlowFromOps) / c.totalAssets : null;
+  const aqiPrior = p.totalAssets > 0 ? 1 - (p.accountsReceivable + p.ppGross) / p.totalAssets : null;
+  const aqi = safeDivide(aqiCurrent, aqiPrior);
+  const sgi = safeDivide(c.revenue, p.revenue);
+  const depiCurrent = c.ppGross > 0 ? c.depreciation / (c.depreciation + c.ppGross) : null;
+  const depiPrior = p.ppGross > 0 ? p.depreciation / (p.depreciation + p.ppGross) : null;
+  const depi = safeDivide(depiPrior, depiCurrent);
+  const sgai = safeDivide(
+    safeDivide(c.sgaExpense, c.revenue),
+    safeDivide(p.sgaExpense, p.revenue)
+  );
+  const lvgi = safeDivide(
+    safeDivide(c.totalDebt, c.totalAssets),
+    safeDivide(p.totalDebt, p.totalAssets)
+  );
+  const tata = c.totalAssets > 0 ? (c.netIncome - c.cashFlowFromOps) / c.totalAssets : null;
+  if (dsri == null || gmi == null || aqi == null || sgi == null || depi == null || sgai == null || lvgi == null || tata == null) return null;
+  const mScore = -4.84 + 0.92 * dsri + 0.528 * gmi + 0.404 * aqi + 0.892 * sgi + 0.115 * depi - 0.172 * sgai + 4.679 * tata - 0.327 * lvgi;
+  const manipulationLikely = mScore > -2.22;
+  return {
+    mScore,
+    variables: { dsri, gmi, aqi, sgi, depi, sgai, lvgi, tata },
+    manipulationLikely,
+    interpretation: manipulationLikely ? `M-Score ${mScore.toFixed(2)} > -2.22: Possible earnings manipulation` : `M-Score ${mScore.toFixed(2)} \u2264 -2.22: No strong sign of manipulation`
+  };
+}
+beneishMScore.formula = "-4.84 + 0.92\xD7DSRI + 0.528\xD7GMI + 0.404\xD7AQI + 0.892\xD7SGI + 0.115\xD7DEPI - 0.172\xD7SGAI + 4.679\xD7TATA - 0.327\xD7LVGI";
+beneishMScore.description = "Earnings manipulation detector. M-Score > -2.22 indicates likely manipulation.";
+function magicFormula(input) {
+  const tangibleCapital = input.netWorkingCapital + input.netFixedAssets;
+  return {
+    roic: safeDivide(input.ebit, tangibleCapital),
+    evEbit: safeDivide(input.enterpriseValue, input.ebit)
+  };
+}
+magicFormula.formula = "ROIC = EBIT / (Net Working Capital + Net Fixed Assets); Earnings Yield = EBIT / EV";
+magicFormula.description = "Greenblatt's Magic Formula: rank by ROIC + EV/EBIT. Best combo = buy.";
+function ohlsonOScore(input) {
+  if (input.totalAssets <= 0) return null;
+  const t1 = -1.32 - 0.407 * Math.log(input.totalAssets / input.gnp);
+  const t2 = 6.03 * (input.totalLiabilities / input.totalAssets);
+  const t3 = -1.43 * (input.workingCapital / input.totalAssets);
+  const t4 = 0.0757 * (input.currentLiabilities / input.currentAssets);
+  const t5 = input.totalLiabilities > input.totalAssets ? -1.72 * 1 : 0;
+  const t6 = -2.37 * (input.netIncome / input.totalAssets);
+  const t7 = -1.83 * (input.operatingCashFlow / input.totalAssets);
+  const t8 = 0.285 * (input.netIncome + input.priorNetIncome < 0 ? 1 : 0);
+  const t9 = -0.521 * safeDivide(
+    input.netIncome - input.priorNetIncome,
+    Math.abs(input.netIncome) + Math.abs(input.priorNetIncome)
+  );
+  const oScore = t1 + t2 + t3 + t4 + t5 + t6 + t7 + t8 + t9;
+  const bankruptcyProbability = 1 / (1 + Math.exp(-oScore));
+  return {
+    oScore,
+    bankruptcyProbability,
+    interpretation: bankruptcyProbability > 0.5 ? `High bankruptcy risk (${(bankruptcyProbability * 100).toFixed(1)}% probability)` : `Low bankruptcy risk (${(bankruptcyProbability * 100).toFixed(1)}% probability)`
+  };
+}
+ohlsonOScore.formula = "Logistic regression: -1.32 - 0.407*SIZE + 6.03*TLTA - 1.43*WCTA + 0.0757*CLCA ...";
+ohlsonOScore.description = "Bankruptcy prediction via logistic regression. Outputs probability 0-1.";
+
+// src/ratios/sector/saas/index.ts
+function ruleOf40(input) {
+  return input.revenueGrowthRatePct + input.fcfMarginPct;
+}
+ruleOf40.formula = "Revenue Growth Rate (%) + FCF Margin (%)";
+ruleOf40.description = "SaaS health metric. > 40 = healthy balance of growth and profitability.";
+function magicNumber(input) {
+  const netNewArrAnnualized = (input.currentQuarterRevenue - input.priorQuarterRevenue) * 4;
+  return safeDivide(netNewArrAnnualized, input.priorQuarterSalesAndMarketingSpend);
+}
+magicNumber.formula = "(Current Quarter Revenue - Prior Quarter Revenue) \xD7 4 / Prior Quarter S&M";
+magicNumber.description = "SaaS go-to-market efficiency. > 0.75 is good, > 1.0 is exceptional.";
+function netRevenueRetention(input) {
+  return safeDivide(
+    input.beginningArr + input.expansion - input.churn - input.contraction,
+    input.beginningArr
+  );
+}
+netRevenueRetention.formula = "(Beginning ARR + Expansion - Churn - Contraction) / Beginning ARR";
+netRevenueRetention.description = "NRR > 100% means existing customers generate more revenue over time (net expansion).";
+function grossRevenueRetention(input) {
+  return safeDivide(
+    input.beginningArr - input.churn - input.contraction,
+    input.beginningArr
+  );
+}
+grossRevenueRetention.formula = "(Beginning ARR - Churn - Contraction) / Beginning ARR";
+grossRevenueRetention.description = "GRR measures pure retention without expansion. Best case = 100%.";
+function customerAcquisitionCost(input) {
+  return safeDivide(input.salesAndMarketingSpend, input.newCustomersAcquired);
+}
+customerAcquisitionCost.formula = "Sales & Marketing Spend / New Customers Acquired";
+customerAcquisitionCost.description = "Cost to acquire one new customer.";
+function customerLifetimeValue(input) {
+  if (input.monthlyChurnRate <= 0) return null;
+  return safeDivide(
+    input.avgMonthlyRevenuePerCustomer * input.grossMargin,
+    input.monthlyChurnRate
+  );
+}
+customerLifetimeValue.formula = "(Avg Monthly Revenue \xD7 Gross Margin) / Monthly Churn Rate";
+customerLifetimeValue.description = "Expected revenue from a customer over their lifetime.";
+function ltvCacRatio(input) {
+  return safeDivide(input.ltv, input.cac);
+}
+ltvCacRatio.formula = "LTV / CAC";
+ltvCacRatio.description = "LTV:CAC > 3 is healthy. < 1 means you lose money on every customer.";
+function cacPaybackPeriod(input) {
+  const monthlyMargin = input.avgMonthlyRevenuePerCustomer * input.grossMarginPct;
+  return safeDivide(input.cac, monthlyMargin);
+}
+cacPaybackPeriod.formula = "CAC / (Avg Monthly Revenue \xD7 Gross Margin %)";
+cacPaybackPeriod.description = "Months to recoup customer acquisition cost. < 12 months is excellent.";
+function burnMultiple(input) {
+  return safeDivide(input.netBurnRate, input.netNewArr);
+}
+burnMultiple.formula = "Net Burn Rate / Net New ARR";
+burnMultiple.description = "Cash spent to acquire $1 of new ARR. < 1 is excellent, > 2 is concerning.";
+function saasQuickRatio(input) {
+  const gained = input.newMrr + input.expansionMrr;
+  const lost = input.churnedMrr + input.contractionMrr;
+  return safeDivide(gained, lost);
+}
+saasQuickRatio.formula = "(New MRR + Expansion MRR) / (Churned MRR + Contraction MRR)";
+saasQuickRatio.description = "Growth efficiency. > 4 is excellent, < 1 means shrinking.";
+function arrPerFte(input) {
+  return safeDivide(input.arr, input.fullTimeEmployees);
+}
+arrPerFte.formula = "ARR / Full-Time Employees";
+arrPerFte.description = "Productivity benchmark. > $200k/FTE is world-class.";
+
+// src/ratios/sector/reit/index.ts
+function ffo(input) {
+  return input.netIncome + input.depreciation - input.gainsOnSaleOfProperties;
+}
+ffo.formula = "Net Income + Depreciation & Amortization - Gains on Sale of Properties";
+ffo.description = "Funds From Operations \u2014 the primary REIT earnings metric, strips out real estate depreciation.";
+function affo(input) {
+  return input.ffo - input.recurringCapex + input.straightLineRentAdjustment;
+}
+affo.formula = "FFO - Recurring Capex + Straight-Line Rent Adjustment";
+affo.description = "Adjusted FFO \u2014 closer to actual distributable cash flow.";
+function pFfo(input) {
+  return safeDivide(input.marketCap, input.ffo);
+}
+pFfo.formula = "Market Cap / FFO";
+pFfo.description = "Price-to-FFO \u2014 the REIT equivalent of P/E.";
+function pAffo(input) {
+  return safeDivide(input.marketCap, input.affo);
+}
+pAffo.formula = "Market Cap / AFFO";
+pAffo.description = "Price-to-AFFO. More conservative and widely used by REIT analysts.";
+function netOperatingIncome(input) {
+  return input.revenue - input.operatingExpenses;
+}
+netOperatingIncome.formula = "Revenue - Operating Expenses (excluding D&A and interest)";
+netOperatingIncome.description = "NOI \u2014 the core profitability metric for real estate properties.";
+function capRate(input) {
+  return safeDivide(input.noi, input.propertyValue);
+}
+capRate.formula = "Net Operating Income / Property Value";
+capRate.description = "Expected annual return on a property. Higher cap rate = higher yield, often higher risk.";
+function occupancyRate(input) {
+  return safeDivide(input.occupiedUnits, input.totalUnits);
+}
+occupancyRate.formula = "Occupied Units / Total Units";
+occupancyRate.description = "Key operational metric. > 95% is generally considered strong.";
+
+// src/ratios/sector/banking/index.ts
+function netInterestMargin(input) {
+  return safeDivide(input.interestIncome - input.interestExpense, input.avgEarningAssets);
+}
+netInterestMargin.formula = "(Interest Income - Interest Expense) / Average Earning Assets";
+netInterestMargin.description = "NIM \u2014 core profitability of a bank's lending activity.";
+function efficiencyRatio(input) {
+  return safeDivide(input.nonInterestExpense, input.netInterestIncome + input.nonInterestIncome);
+}
+efficiencyRatio.formula = "Non-Interest Expense / (Net Interest Income + Non-Interest Income)";
+efficiencyRatio.description = "Cost to generate $1 of revenue. Lower is better. < 60% is well-run.";
+function loanToDepositRatio(input) {
+  return safeDivide(input.totalLoans, input.totalDeposits);
+}
+loanToDepositRatio.formula = "Total Loans / Total Deposits";
+loanToDepositRatio.description = "Liquidity indicator. > 100% means more loans than deposits (reliant on borrowing).";
+function nplRatio(input) {
+  return safeDivide(input.nonPerformingLoans, input.totalLoans);
+}
+nplRatio.formula = "Non-Performing Loans / Total Loans";
+nplRatio.description = "Asset quality metric. > 2-3% warrants scrutiny.";
+function provisionCoverageRatio(input) {
+  return safeDivide(input.loanLossReserves, input.nonPerformingLoans);
+}
+provisionCoverageRatio.formula = "Loan Loss Reserves / Non-Performing Loans";
+provisionCoverageRatio.description = "How much of bad loans are reserved for. > 100% is conservative.";
+function tier1CapitalRatio(input) {
+  return safeDivide(input.tier1Capital, input.riskWeightedAssets);
+}
+tier1CapitalRatio.formula = "Tier 1 Capital / Risk-Weighted Assets";
+tier1CapitalRatio.description = "Core capital adequacy. Regulatory minimum is 6%, well-capitalized is > 8%.";
+function cet1Ratio(input) {
+  return safeDivide(input.commonEquityTier1, input.riskWeightedAssets);
+}
+cet1Ratio.formula = "Common Equity Tier 1 / Risk-Weighted Assets";
+cet1Ratio.description = "Highest-quality capital ratio. Regulatory minimum is 4.5%.";
+function tangibleBookValuePerShare(input) {
+  const tbv = input.totalEquity - input.goodwill - input.intangibleAssets;
+  return safeDivide(tbv, input.sharesOutstanding);
+}
+tangibleBookValuePerShare.formula = "(Equity - Goodwill - Intangibles) / Shares Outstanding";
+tangibleBookValuePerShare.description = "TBVPS \u2014 the most conservative per-share book value for banks.";
+
+// src/ratios/sector/insurance/index.ts
+function lossRatio(input) {
+  return safeDivide(input.lossesIncurred, input.premiumsEarned);
+}
+lossRatio.formula = "Losses Incurred / Premiums Earned";
+lossRatio.description = "Portion of premiums paid out as claims. < 60% is generally good for P&C.";
+function expenseRatio(input) {
+  return safeDivide(input.underwritingExpenses, input.premiumsWritten);
+}
+expenseRatio.formula = "Underwriting Expenses / Net Premiums Written";
+expenseRatio.description = "Cost of writing insurance. Lower is more efficient.";
+function combinedRatio(input) {
+  return input.lossRatio + input.expenseRatio;
+}
+combinedRatio.formula = "Loss Ratio + Expense Ratio";
+combinedRatio.description = "The key insurance profitability metric. < 100% = underwriting profit. > 100% = loss.";
+function underwritingProfitMargin(input) {
+  return 1 - input.combinedRatio;
+}
+underwritingProfitMargin.formula = "1 - Combined Ratio";
+underwritingProfitMargin.description = "Positive = underwriting profit. Most insurers also earn investment income.";
+function premiumsToSurplus(input) {
+  return safeDivide(input.netPremiumsWritten, input.policyholderSurplus);
+}
+premiumsToSurplus.formula = "Net Premiums Written / Policyholder Surplus";
+premiumsToSurplus.description = "Leverage ratio for insurers. > 3x is considered risky.";
+
+export { affo, altmanZScore, annualizeReturn, arrPerFte, assetTurnover, beneishMScore, beta, burnMultiple, bvpsGrowth, cacPaybackPeriod, cagr, calmarRatio, capRate, capexToDepreciation, capexToRevenue, capitalTurnover, cashConversionCycle, cashRatio, cashReturnOnAssets, cet1Ratio, combinedRatio, conditionalVaR, currentRatio, customerAcquisitionCost, customerLifetimeValue, dcf2Stage, debtServiceCoverageRatio, debtToAssets, debtToCapital, debtToEquity, defensiveIntervalRatio, dio, dividendGrowthRate, downsideCaptureRatio, dpo, dso, duPont3, earningsPowerValue, ebitdaCoverageRatio, ebitdaGrowth, ebitdaMargin, efficiencyRatio, enterpriseValue, epsGrowth, equityMultiplier, evEbit, evEbitda, evFcf, evInvestedCapital, evRevenue, expenseRatio, fcfConversion, fcfGrowth, fcfMargin, fcfYield, ffo, fixedAssetTurnover, fixedChargeCoverageRatio, forwardPe, freeCashFlow, gordonGrowthModel, grahamIntrinsicValue, grahamNumber, grossMargin, grossRevenueRetention, historicalVaR, informationRatio, interestCoverageRatio, inventoryTurnover, investedCapital, jensensAlpha, leveredFcf, loanToDepositRatio, lossRatio, ltvCacRatio, magicFormula, magicNumber, maxDrawdown, maximumDrawdown, mean, netDebtToEbitda, netDebtToEquity, netInterestMargin, netOperatingIncome, netProfitMargin, netRevenueRetention, nopat, nopatMargin, nplRatio, occupancyRate, ocfToSales, ohlsonOScore, omegaRatio, operatingCashFlowRatio, operatingLeverage, operatingMargin, ownerEarnings, pAffo, pFcf, pFfo, parametricVaR, payablesTurnover, pb, pe, peg, percentile, piotroskiFScore, premiumsToSurplus, pricesToReturns, profitPerEmployee, provisionCoverageRatio, ps, quickRatio, receivablesTurnover, revenueCAGR, revenueGrowth, revenuePerEmployee, reverseDcf, roa, roce, roe, roic, rote, ruleOf40, saasQuickRatio, safeDivide, sharpeRatio, sortinoRatio, stdDev, tangibleBookValuePerShare, tier1CapitalRatio, tobinsQ, trackingError, treynorRatio, ulcerIndex, underwritingProfitMargin, unleveredFcf, upsideCaptureRatio, workingCapitalTurnover };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map