finance-calculator-pro 1.1.0 → 1.2.1

package/README.md

@@ -11,7 +11,7 @@
 ![finance-calculator-pro banner](https://raw.githubusercontent.com/boffincoders/finance-calculator/refs/heads/master/.github/assets/finance-calculator-pro.png)
 
 > **Zero-dependency financial analysis engine for JavaScript and TypeScript.**
-> Calculate 30+ fundamental analysis metrics — valuation ratios, profitability metrics, liquidity ratios, solvency indicators, efficiency metrics, earnings quality signals, and bankruptcy risk scores — from raw financial data. No API calls. No heavy dependencies. Works in Node.js, browsers, and edge runtimes.
+> Calculate 70+ financial metrics — valuation ratios, profitability, liquidity, solvency, efficiency, intrinsic value, composite scoring, TTM aggregation, historical analysis, and bankruptcy risk scores — from raw financial data. No API calls. No runtime dependencies. Works in Node.js, browsers, and edge runtimes.
 
 ---
 
@@ -50,7 +50,7 @@ Building a stock screener, neo-bank, or internal financial analysis tool? [Let's
 
 ---
 
-## Metrics Reference — 30+ Fundamental Analysis Metrics
+## Metrics Reference — 70+ Functions Across 11 Categories
 
 ### Valuation Ratios
 | Metric | Function | Formula |
@@ -67,6 +67,7 @@ Building a stock screener, neo-bank, or internal financial analysis tool? [Let's
 | Dividend Yield | `dividendYield()` | `Annual Dividend / Price` |
 | Discounted Cash Flow (DCF) | `calculateDCF()` | Terminal value + discounted FCF streams |
 | Graham Number | `grahamNumber()` | `√(22.5 × EPS × Book Value)` |
+| Market Cap to Total Capital | `marketCapToDebtCap()` | `Market Cap / (Market Cap + Total Debt)` |
 
 ### Profitability Metrics
 | Metric | Function | Formula |
@@ -101,6 +102,9 @@ Building a stock screener, neo-bank, or internal financial analysis tool? [Let's
 | Inventory Turnover | `inventoryTurnover()` | `COGS / Average Inventory` |
 | Receivables Turnover | `receivablesTurnover()` | `Revenue / Trade Receivables` |
 | Days Sales Outstanding (DSO) | `daysSalesOutstanding()` | `365 / Receivables Turnover` |
+| Payable Days (DPO) | `payableDays()` | `(Trade Payables / COGS) × 365` |
+| Working Capital Days | `workingCapitalDays()` | `(Working Capital / Revenue) × 365` |
+| Cash Conversion Cycle | `cashConversionCycle()` | `DSO + DIO − DPO` |
 
 ### Earnings Quality Metrics
 | Metric | Function | Formula |
@@ -116,11 +120,37 @@ Building a stock screener, neo-bank, or internal financial analysis tool? [Let's
 | Sharpe Ratio | `sharpe()` | Risk-adjusted return vs risk-free rate |
 | Target Upside | `targetUpside()` | % gap to analyst target price |
 
+### Intrinsic Valuation & Scoring
+| Metric | Function | Notes |
+|---|---|---|
+| Graham Number | `grahamNumber()` | Benjamin Graham's defensive value ceiling |
+| Net Current Value Per Share | `computeNCVPS()` | (Current Assets − Total Liabilities) / Shares |
+| Intrinsic Value Estimate | `computeIntrinsicValue()` | Simple 5-yr EPS projection with margin of safety |
+| G-Factor (Composite) | `computeGFactor()` | Quality×40% + Growth×35% + Momentum×25% |
+| Quality Score | `computeQualityScore()` | Piotroski + ROE vs sector + margins + pledge + promoter |
+| Growth Score | `computeGrowthScore()` | Revenue growth + profit growth + EPS growth + CFO |
+| Value Score | `computeValueScore()` | P/E vs avg + P/B vs sector + PEG + historical percentile |
+| Momentum Score | `computeMomentumScore()` | SMA200 + RSI + ADX + volume ratio + ROC-125 |
+
 ### Growth & Timeseries Analysis
-- **YoY Growth** — Year-over-year revenue, net income, EPS growth rates
-- **QoQ Growth** — Quarter-over-quarter sequential growth
-- **CAGR** — Compound Annual Growth Rate over any period
-- **Fundamental Trends** — Multi-period margin trends, FCF conversion tracking
+| Function | Description |
+|---|---|
+| `calculateGrowthRate()` | Single-period % growth rate |
+| `yoyGrowth()` | Year-over-year growth rates for a series |
+| `qoqGrowth()` | Quarter-over-quarter growth rates |
+| `cagr()` | Compound Annual Growth Rate |
+| `medianGrowth()` | Median YoY growth rate (outlier-resistant) |
+
+### TTM & Historical Aggregation
+| Function | Description |
+|---|---|
+| `computeTTM()` | Trailing Twelve Months sum (last 4 quarters) |
+| `computeTTMAvg()` | Trailing Twelve Months average |
+| `computeNYearAverage()` | Rolling N-year average of quarterly data |
+| `computeNYearSum()` | Rolling N-year sum of quarterly data |
+| `computeHistoricalPoint()` | Value at exactly N quarters back |
+
+
 
 ---
 
@@ -247,14 +277,46 @@ Import any function directly for lightweight single-metric use. Every function r
 
 ```typescript
 import {
+  // Valuation
   pe, pb, ps, peg, evEbitda, evRevenue, evFcf,
   priceToCashFlow, earningsYield, grahamNumber, calculateDCF,
-  roa, roe, roic, grossMargin, operatingMargin, netProfitMargin,
+  marketCapToDebtCap,
+
+  // Profitability
+  roa, roe, roic, grossMargin, operatingMargin, netProfitMargin, fcfMargin,
+
+  // Liquidity
   currentRatio, quickRatio, debtToEquity, interestCoverage,
+
+  // Solvency
   netDebt, netDebtToEbitda, debtToAssets,
-  assetTurnover, receivablesTurnover, daysSalesOutstanding,
+
+  // Efficiency
+  assetTurnover, inventoryTurnover, receivablesTurnover, daysSalesOutstanding,
+  payableDays, workingCapitalDays, cashConversionCycle,
+
+  // Quality
   payoutRatio, cashConversionRatio,
+
+  // Risk
   altmanZScore, piotroski, sharpe, targetUpside,
+
+  // Intrinsic Valuation
+  computeNCVPS, computeGFactor, computeIntrinsicValue,
+
+  // Composite Scoring
+  computeQualityScore, computeGrowthScore, computeValueScore, computeMomentumScore,
+
+  // Growth
+  calculateGrowthRate, yoyGrowth, qoqGrowth, cagr, medianGrowth,
+
+  // TTM
+  computeTTM, computeTTMAvg,
+
+  // Historical
+  computeNYearAverage, computeNYearSum, computeHistoricalPoint,
+
+  // Insights Engine
   evaluate,
 } from 'finance-calculator-pro';
 
@@ -262,7 +324,8 @@ import {
 pe(150, 5);                               // → 30
 priceToCashFlow(150_000, 7_000);          // → 21.43
 earningsYield(5, 150);                    // → 0.0333 (3.33%)
-grahamNumber(5, 20);                      // → 47.43  (null if EPS or book ≤ 0)
+grahamNumber(5, 20);                      // → 47.43
+marketCapToDebtCap(150_000, 20_000);      // → 0.882 (88.2% equity financed)
 
 // Solvency
 netDebtToEbitda(20_000, 5_000, 10_000);   // → 1.5
@@ -270,9 +333,8 @@ debtToAssets(20_000, 100_000);            // → 0.20
 
 // Efficiency
 daysSalesOutstanding(50_000, 6_250);      // → 45.6 days
-
-// Earnings Quality
-cashConversionRatio(7_000, 5_000);        // → 1.4
+payableDays(30_000, 200_000);             // → 54.75 days
+cashConversionCycle(45, 60, 55);          // → 50 days
 
 // Risk
 altmanZScore(15_000, 20_000, 7_500, 250_000, 50_000, 100_000, 60_000); // → 3.71
@@ -286,6 +348,36 @@ const result = piotroski({
 result.score;     // → 4
 result.maxScore;  // → 5
 
+// Intrinsic Valuation
+computeNCVPS(500_000, 300_000, 100_000);  // → 2.00 (net current value per share)
+computeIntrinsicValue(10, 0.15, 0.25);    // → 5-yr EPS projection with 25% safety margin
+computeGFactor(82, 78, 67);               // → composite G-Factor score
+
+// Composite Scoring
+computeQualityScore({ piotroskiScore: 7, roeVsSector: 1.1,
+  marginsImproving: true, pledgeFree: true, promoterStable: true }); // → 82
+computeGrowthScore({ revenueGrowthVsSector: 1.3, profitGrowthRate: 0.20,
+  epsGrowthRate: 0.18, cfoPositive: true, revenueAccelerating: true }); // → 78
+computeValueScore({ peVs3yrAvg: 0.8, pbVsSector: 0.75, peg: 0.9,
+  historicalPePercentile: 30 }); // → 72
+computeMomentumScore({ priceVsSma200: 1.08, rsi: 58, adx: 28,
+  volumeRatio: 1.2, roc125: 0.18 }); // → 67
+
+// TTM Aggregation
+const quarters = [2200, 2400, 2600, 2800]; // Q1–Q4 revenue
+computeTTM(quarters);     // → 10000  (annualised TTM)
+computeTTMAvg(quarters);  // → 2500   (average quarterly)
+
+// Historical Analysis
+const qData = [2000, 2200, 2400, 2600, 2800, 3000, 3200, 3400];
+computeNYearAverage(qData, 2);     // → 2700  (2-year average)
+computeNYearSum(qData, 1);         // → 12400 (last 4 quarters sum)
+computeHistoricalPoint(qData, 4);  // → 2600  (same quarter last year)
+
+// Growth
+cagr(1000, 2000, 5);                                       // → 0.1487 (14.87%)
+medianGrowth([800, 900, 1100, 1050, 1300]);                // → 0.176  (17.6%)
+
 // Pair raw math with the Insights Engine
 const ratio = pe(150, 5);  // → 30
 evaluate.pe(ratio);
@@ -372,7 +464,7 @@ interface CompanySnapshotInput {
 | `analyzeProfitability(data, insights?)` | Profitability | ROA, ROE, ROIC, all margins |
 | `analyzeLiquidity(data, insights?)` | Liquidity | Current, Quick, D/E, Interest Coverage |
 | `analyzeSolvency(data, insights?)` | Solvency | Net Debt, Net Debt/EBITDA, Debt/Assets |
-| `analyzeEfficiency(data, insights?)` | Efficiency | Asset Turnover, Inventory, Receivables, DSO |
+| `analyzeEfficiency(data, insights?)` | Efficiency | Asset Turnover, Inventory, Receivables, DSO, Payable Days, WC Days, CCC |
 | `analyzeRisk(data, insights?)` | Risk | Altman Z-Score, Sharpe, Piotroski F-Score |
 | `analyzeQuality(data, insights?)` | Quality | Payout Ratio, Cash Conversion Ratio |
 | `analyzeBatch(dataArray, insights?)` | Batch | Array of snapshots → array of analyses |
@@ -385,7 +477,7 @@ interface CompanySnapshotInput {
 | Feature | finance-calculator-pro |
 |---|---|
 | Dependencies | **Zero** |
-| Bundle size | **< 20 KB** (tree-shakeable) |
+| Bundle size | **< 50 KB** (tree-shakeable) |
 | TypeScript | **Full types included** |
 | Return type | `number \| null` (never throws) |
 | Insights engine | **Built-in** (value + status + insight) |

package/dist/index.d.mts

@@ -711,6 +711,18 @@ declare const evRevenue: (enterpriseValue: number, totalRevenue: number) => numb
  */
 declare const evFcf: (enterpriseValue: number, freeCashFlow: number) => number | null;
 
+/**
+ * Market Cap to Total Capitalization Ratio (Market Cap / (Market Cap + Debt))
+ * Also known as the equity-to-total-capital ratio.
+ * Formula: Market Cap / (Market Cap + Total Debt)
+ * Interpretation:
+ * - Ranges from 0 to 1.
+ * - Higher ratio → company is predominantly equity-financed (lower financial risk).
+ * - Lower ratio → company is more debt-heavy relative to its total capital.
+ * - Useful for comparing capital structure across companies.
+ */
+declare const marketCapToDebtCap: (marketCap: number, totalDebt: number) => number | null;
+
 /**
  * Return on Equity (ROE)
  * Formula: Net Income / Equity
@@ -870,6 +882,38 @@ declare const receivablesTurnover: (totalRevenue: number, tradeReceivables: numb
  */
 declare const daysSalesOutstanding: (totalRevenue: number, tradeReceivables: number) => number | null;
 
+/**
+ * Payable Days (Days Payable Outstanding — DPO)
+ * Formula: (Trade Payables / COGS) × 365
+ * Interpretation:
+ * - How many days on average it takes the company to pay its suppliers.
+ * - Higher DPO can indicate strong bargaining power, but excessively high values
+ *   may signal liquidity stress or strained supplier relationships.
+ */
+declare const payableDays: (tradePayables: number, cogs: number) => number | null;
+
+/**
+ * Working Capital Days
+ * Formula: (Working Capital / Revenue) × 365
+ * Where Working Capital = Current Assets - Current Liabilities
+ * Interpretation:
+ * - Measures how many days of revenue are tied up in working capital.
+ * - Lower is generally better (capital is not locked in operations).
+ * - Negative values indicate current liabilities exceed current assets.
+ */
+declare const workingCapitalDays: (workingCapital: number, revenue: number) => number | null;
+
+/**
+ * Cash Conversion Cycle (CCC)
+ * Formula: Debtor Days + Inventory Days - Payable Days
+ * Interpretation:
+ * - Measures the number of days it takes to convert inventory/payables into cash.
+ * - Lower (or negative) is better — negative CCC means the company collects cash
+ *   before it pays its suppliers (e.g. e-commerce, supermarkets).
+ * - High positive CCC indicates capital is tied up in operations for longer.
+ */
+declare const cashConversionCycle: (debtorDays: number, inventoryDays: number, payableDays: number) => number;
+
 /**
  * Dividend Payout Ratio
  * The proportion of earnings paid to shareholders as dividends.
@@ -930,6 +974,56 @@ declare const altmanZScore: (workingCapital: number, retainedEarnings: number, e
  */
 declare const grahamNumber: (eps: number, book: number) => number | null;
 
+/**
+ * Net Current Value Per Share (NCVPS)
+ * Formula: (Current Assets - Total Liabilities) / Shares Outstanding
+ * Interpretation:
+ * - A conservative "liquidation value" per share, inspired by Benjamin Graham's
+ *   net-net working capital criterion.
+ * - If NCVPS > market price, the stock may be trading below liquidation value —
+ *   a deep value signal (but also common in distressed or declining businesses).
+ * - Positive NCVPS means current assets alone cover all liabilities.
+ */
+declare const computeNCVPS: (currentAssets: number, totalLiabilities: number, sharesOutstanding: number) => number | null;
+
+/**
+ * G-Factor (Composite Fundamental Score)
+ * Formula: (Quality × 0.40) + (Growth × 0.35) + (Momentum × 0.25)
+ * Inputs should be scores in the range [0, 100].
+ * Output is a weighted composite in the range [0, 100].
+ *
+ * Interpretation:
+ * - G-Factor > 70  → Strong composite fundamentals
+ * - G-Factor 40–70 → Average
+ * - G-Factor < 40  → Weak
+ *
+ * Weights are based on typical quantitative equity-factor research priorities:
+ * Quality is the most predictive of long-term returns; Growth drives near-term
+ * re-rating; Momentum captures market confirmation of the thesis.
+ */
+declare const computeGFactor: (qualityScore: number, growthScore: number, momentumScore: number) => number;
+
+/**
+ * Simplified Intrinsic Value Estimate
+ * Formula: EPS × (1 + growthRate) ^ years / (1 + discountRate) ^ years
+ *          applied over a default 5-year horizon, then divided by (1 - safetyMargin)
+ *
+ * A lightweight DCF approximation for quick screening:
+ *   intrinsicValue = (EPS × (1 + growthRate)^5) / (1 - safetyMargin)
+ *
+ * Parameters:
+ * @param eps           Earnings Per Share (current or TTM)
+ * @param growthRate    Expected annual EPS growth rate as a decimal (e.g. 0.15 for 15%)
+ * @param safetyMargin  Margin of safety as a decimal (e.g. 0.25 for 25% discount)
+ *
+ * Interpretation:
+ * - If market price < intrinsicValue → potential undervaluation
+ * - safetyMargin of 0.25–0.35 is conventional for conservative investing
+ *
+ * Returns null for non-positive EPS or invalid inputs.
+ */
+declare const computeIntrinsicValue: (eps: number, growthRate: number, safetyMargin: number) => number | null;
+
 /**
  * Calculate basic growth rate given current and previous values.
  * Useful for building out mapping functions natively in the analyzer.
@@ -950,6 +1044,16 @@ declare const qoqGrowth: (dataPoints: number[]) => number[];
  * Formula: (Ending Value / Beginning Value) ^ (1 / Years) - 1
  */
 declare const cagr: (beginningValue: number, endingValue: number, periods: number) => number | null;
+/**
+ * Median Growth Rate
+ * Calculates the YoY growth rates for a series of annual values (oldest first),
+ * then returns the median of those rates.
+ * Interpretation:
+ * - More robust than mean growth because it is not skewed by outlier years.
+ * - Useful for evaluating the "typical" annual growth of earnings, revenue, etc.
+ * Returns null if fewer than 2 data points are provided.
+ */
+declare const medianGrowth: (annualValues: number[]) => number | null;
 
 /**
  * Analyst Target Upside / Downside
@@ -960,4 +1064,192 @@ declare const cagr: (beginningValue: number, endingValue: number, periods: numbe
  */
 declare const targetUpside: (currentPrice: number, targetPrice: number) => number | null;
 
-export { type CompanySnapshotInput, type EvaluatedMetric, type FundamentalTimeseriesInput, type MetricStatus, type PiotroskiInput, type PiotroskiResult, type PiotroskiSignals, altmanZScore, analyzeBatch, analyzeCompany, analyzeEfficiency, analyzeFundamentalTrends, analyzeLiquidity, analyzeProfitability, analyzeQuality, analyzeRisk, analyzeSolvency, analyzeValuation, assetTurnover, cagr, calculateDCF, calculateEnterpriseValue, calculateGrowthRate, cashConversionRatio, currentRatio, daysSalesOutstanding, debtToAssets, debtToEquity, dividendYield, earningsYield, evEbitda, evFcf, evRevenue, evaluate, fcfMargin, grahamNumber, grossMargin, impliedSharePrice, interestCoverage, inventoryTurnover, netDebt, netDebtToEbitda, netProfitMargin, operatingMargin, payoutRatio, pb, pbFromMarketCap, pe, peg, piotroski, priceToCashFlow, priceToCashFlowPerShare, ps, psFromMarketCap, qoqGrowth, quickRatio, receivablesTurnover, roa, roe, roic, safeDivide, sharpe, targetUpside, yoyGrowth };
+/**
+ * Trailing Twelve Months (TTM) Utilities
+ *
+ * TTM aggregates the most recent four quarters of data to produce
+ * an annualised figure without waiting for a full fiscal year.
+ */
+/**
+ * Trailing Twelve Months Sum
+ * Returns the sum of the last 4 quarterly values (or fewer if < 4 available).
+ * Expects values in chronological order: oldest first, most recent last.
+ * e.g. [Q1, Q2, Q3, Q4, Q1_next, Q2_next] → sums last 4
+ */
+declare const computeTTM: (quarterlyValues: number[]) => number | null;
+/**
+ * Trailing Twelve Months Average
+ * Returns the average of the last 4 quarterly values (or fewer if < 4 available).
+ * Handles arrays shorter than 4 gracefully by averaging whatever is available.
+ * Expects chronological order: oldest first, most recent last.
+ */
+declare const computeTTMAvg: (quarterlyValues: number[]) => number | null;
+
+/**
+ * Historical Aggregation Utilities
+ *
+ * Functions for computing averages, sums, and point lookups over
+ * rolling windows of quarterly (or annual) data.
+ * All functions expect chronological order: oldest first, most recent last.
+ */
+/**
+ * N-Year Average
+ * Returns the average of the last (years × 4) quarterly values.
+ * e.g. computeNYearAverage(data, 3) → average of last 12 quarters.
+ * If fewer values are available than requested, averages all available values.
+ */
+declare const computeNYearAverage: (quarterlyValues: number[], years: number) => number | null;
+/**
+ * N-Year Sum
+ * Returns the sum of the last (years × 4) quarterly values.
+ * If fewer values are available, sums all available values.
+ */
+declare const computeNYearSum: (quarterlyValues: number[], years: number) => number | null;
+/**
+ * Historical Point Lookup
+ * Returns the value at exactly `quartersBack` quarters from the most recent value.
+ * quartersBack = 0 → most recent value
+ * quartersBack = 4 → value from 1 year ago (same quarter last year)
+ * Returns null if the index is out of bounds.
+ */
+declare const computeHistoricalPoint: (quarterlyValues: number[], quartersBack: number) => number | null;
+
+/**
+ * Composite Scoring Engine
+ *
+ * Four domain scores — Quality, Growth, Value, Momentum — each in range [0, 100].
+ * Each score is a weighted sum of normalised sub-signals (also 0-100 or boolean).
+ *
+ * These scores feed into computeGFactor for the overall composite.
+ */
+interface QualityScoreInput {
+    /** Piotroski F-Score (0–9) */
+    piotroskiScore: number;
+    /**
+     * ROE vs. sector median — percentage of sector ROE this company achieves.
+     * e.g. if company ROE is 18% and sector median is 15%, pass 18/15 = 1.2.
+     * Capped at 1.0 (100 points if >= sector median).
+     */
+    roeVsSector: number;
+    /** Whether operating margins are improving YoY (boolean) */
+    marginsImproving: boolean;
+    /** Promoter pledge percentage is 0 or negligible (boolean) */
+    pledgeFree: boolean;
+    /** Promoter holding is stable or increasing YoY (boolean) */
+    promoterStable: boolean;
+}
+/**
+ * Quality Score (0–100)
+ * Weights:
+ *   Piotroski (0–9 → 0–100): 30 %
+ *   ROE vs Sector (capped at 1.0 multiplier): 20 %
+ *   Margins improving: 20 %
+ *   Pledge-free: 15 %
+ *   Promoter stable: 15 %
+ */
+declare const computeQualityScore: (input: QualityScoreInput) => number;
+interface GrowthScoreInput {
+    /**
+     * Revenue growth rate relative to sector.
+     * e.g. if company revenue grew 20% and sector average is 12%, pass 20/12 = 1.67.
+     * Capped at 1.0 (100 points if >= sector growth).
+     */
+    revenueGrowthVsSector: number;
+    /**
+     * Profit (net income) growth rate as decimal (e.g. 0.20 for 20% growth).
+     * Capped at 30% for full score (0.30 → 100).
+     */
+    profitGrowthRate: number;
+    /**
+     * EPS growth rate as decimal. Capped at 25% for full score (0.25 → 100).
+     */
+    epsGrowthRate: number;
+    /** Operating cash flow is positive this period (boolean) */
+    cfoPositive: boolean;
+    /** Revenue acceleration: current year growth > prior year growth (boolean) */
+    revenueAccelerating: boolean;
+}
+/**
+ * Growth Score (0–100)
+ * Weights:
+ *   Revenue growth vs sector: 25 %
+ *   Profit growth rate: 25 %
+ *   EPS growth rate: 20 %
+ *   CFO positive: 15 %
+ *   Revenue accelerating: 15 %
+ */
+declare const computeGrowthScore: (input: GrowthScoreInput) => number;
+interface ValueScoreInput {
+    /**
+     * Current P/E divided by the stock's own 3-year average P/E.
+     * e.g. currentPE = 15, avgPE = 20 → ratio = 15/20 = 0.75 (trading below avg → higher score).
+     * Score is higher when ratio < 1 (currently cheaper than historical average).
+     */
+    peVs3yrAvg: number;
+    /**
+     * Current P/B vs sector median P/B. Score is higher when < 1.
+     * e.g. company PB = 2, sector median PB = 3 → ratio = 2/3 ≈ 0.67
+     */
+    pbVsSector: number;
+    /**
+     * PEG ratio (P/E ÷ Growth Rate). Lower is better; 1.0 = fair, < 1 = undervalued.
+     * Capped at 0 for negative PEG; capped at full score for PEG ≤ 0.5.
+     */
+    peg: number;
+    /**
+     * Current P/E percentile over the stock's own 5-year history (0–100).
+     * Lower percentile = cheaper vs history = higher score.
+     * Pass 0–100 directly.
+     */
+    historicalPePercentile: number;
+}
+/**
+ * Value Score (0–100)
+ * Weights:
+ *   P/E vs 3yr avg: 30 %
+ *   P/B vs sector: 25 %
+ *   PEG: 25 %
+ *   Historical P/E percentile: 20 %
+ */
+declare const computeValueScore: (input: ValueScoreInput) => number;
+interface MomentumScoreInput {
+    /**
+     * Current price vs its 200-day SMA ratio.
+     * e.g. price = 105, SMA200 = 100 → ratio = 1.05 (above SMA → bullish).
+     * Score peaks at ratio ≥ 1.10 (10% above SMA).
+     */
+    priceVsSma200: number;
+    /**
+     * RSI (14-period). Range 0–100.
+     * Score peaks at RSI 50–65 (trending without being overbought).
+     */
+    rsi: number;
+    /**
+     * ADX (Average Directional Index). Range 0–100.
+     * ADX > 25 indicates a strong trend; ADX < 20 is trendless.
+     * Score peaks at ADX ≥ 30.
+     */
+    adx: number;
+    /**
+     * Volume ratio: current 20-day avg volume / 90-day avg volume.
+     * > 1.0 = rising volume (confirming move). Score caps at 1.5x.
+     */
+    volumeRatio: number;
+    /**
+     * Rate of Change over 125 trading days (6 months), as a decimal.
+     * e.g. 0.20 = 20% return over 6 months. Capped at 40% for full score.
+     */
+    roc125: number;
+}
+/**
+ * Momentum Score (0–100)
+ * Weights:
+ *   Price vs SMA200: 25 %
+ *   RSI: 20 %
+ *   ADX: 20 %
+ *   Volume ratio: 20 %
+ *   ROC-125: 15 %
+ */
+declare const computeMomentumScore: (input: MomentumScoreInput) => number;
+
+export { type CompanySnapshotInput, type EvaluatedMetric, type FundamentalTimeseriesInput, type GrowthScoreInput, type MetricStatus, type MomentumScoreInput, type PiotroskiInput, type PiotroskiResult, type PiotroskiSignals, type QualityScoreInput, type ValueScoreInput, altmanZScore, analyzeBatch, analyzeCompany, analyzeEfficiency, analyzeFundamentalTrends, analyzeLiquidity, analyzeProfitability, analyzeQuality, analyzeRisk, analyzeSolvency, analyzeValuation, assetTurnover, cagr, calculateDCF, calculateEnterpriseValue, calculateGrowthRate, cashConversionCycle, cashConversionRatio, computeGFactor, computeGrowthScore, computeHistoricalPoint, computeIntrinsicValue, computeMomentumScore, computeNCVPS, computeNYearAverage, computeNYearSum, computeQualityScore, computeTTM, computeTTMAvg, computeValueScore, currentRatio, daysSalesOutstanding, debtToAssets, debtToEquity, dividendYield, earningsYield, evEbitda, evFcf, evRevenue, evaluate, fcfMargin, grahamNumber, grossMargin, impliedSharePrice, interestCoverage, inventoryTurnover, marketCapToDebtCap, medianGrowth, netDebt, netDebtToEbitda, netProfitMargin, operatingMargin, payableDays, payoutRatio, pb, pbFromMarketCap, pe, peg, piotroski, priceToCashFlow, priceToCashFlowPerShare, ps, psFromMarketCap, qoqGrowth, quickRatio, receivablesTurnover, roa, roe, roic, safeDivide, sharpe, targetUpside, workingCapitalDays, yoyGrowth };

package/dist/index.d.ts

@@ -711,6 +711,18 @@ declare const evRevenue: (enterpriseValue: number, totalRevenue: number) => numb
  */
 declare const evFcf: (enterpriseValue: number, freeCashFlow: number) => number | null;
 
+/**
+ * Market Cap to Total Capitalization Ratio (Market Cap / (Market Cap + Debt))
+ * Also known as the equity-to-total-capital ratio.
+ * Formula: Market Cap / (Market Cap + Total Debt)
+ * Interpretation:
+ * - Ranges from 0 to 1.
+ * - Higher ratio → company is predominantly equity-financed (lower financial risk).
+ * - Lower ratio → company is more debt-heavy relative to its total capital.
+ * - Useful for comparing capital structure across companies.
+ */
+declare const marketCapToDebtCap: (marketCap: number, totalDebt: number) => number | null;
+
 /**
  * Return on Equity (ROE)
  * Formula: Net Income / Equity
@@ -870,6 +882,38 @@ declare const receivablesTurnover: (totalRevenue: number, tradeReceivables: numb
  */
 declare const daysSalesOutstanding: (totalRevenue: number, tradeReceivables: number) => number | null;
 
+/**
+ * Payable Days (Days Payable Outstanding — DPO)
+ * Formula: (Trade Payables / COGS) × 365
+ * Interpretation:
+ * - How many days on average it takes the company to pay its suppliers.
+ * - Higher DPO can indicate strong bargaining power, but excessively high values
+ *   may signal liquidity stress or strained supplier relationships.
+ */
+declare const payableDays: (tradePayables: number, cogs: number) => number | null;
+
+/**
+ * Working Capital Days
+ * Formula: (Working Capital / Revenue) × 365
+ * Where Working Capital = Current Assets - Current Liabilities
+ * Interpretation:
+ * - Measures how many days of revenue are tied up in working capital.
+ * - Lower is generally better (capital is not locked in operations).
+ * - Negative values indicate current liabilities exceed current assets.
+ */
+declare const workingCapitalDays: (workingCapital: number, revenue: number) => number | null;
+
+/**
+ * Cash Conversion Cycle (CCC)
+ * Formula: Debtor Days + Inventory Days - Payable Days
+ * Interpretation:
+ * - Measures the number of days it takes to convert inventory/payables into cash.
+ * - Lower (or negative) is better — negative CCC means the company collects cash
+ *   before it pays its suppliers (e.g. e-commerce, supermarkets).
+ * - High positive CCC indicates capital is tied up in operations for longer.
+ */
+declare const cashConversionCycle: (debtorDays: number, inventoryDays: number, payableDays: number) => number;
+
 /**
  * Dividend Payout Ratio
  * The proportion of earnings paid to shareholders as dividends.
@@ -930,6 +974,56 @@ declare const altmanZScore: (workingCapital: number, retainedEarnings: number, e
  */
 declare const grahamNumber: (eps: number, book: number) => number | null;
 
+/**
+ * Net Current Value Per Share (NCVPS)
+ * Formula: (Current Assets - Total Liabilities) / Shares Outstanding
+ * Interpretation:
+ * - A conservative "liquidation value" per share, inspired by Benjamin Graham's
+ *   net-net working capital criterion.
+ * - If NCVPS > market price, the stock may be trading below liquidation value —
+ *   a deep value signal (but also common in distressed or declining businesses).
+ * - Positive NCVPS means current assets alone cover all liabilities.
+ */
+declare const computeNCVPS: (currentAssets: number, totalLiabilities: number, sharesOutstanding: number) => number | null;
+
+/**
+ * G-Factor (Composite Fundamental Score)
+ * Formula: (Quality × 0.40) + (Growth × 0.35) + (Momentum × 0.25)
+ * Inputs should be scores in the range [0, 100].
+ * Output is a weighted composite in the range [0, 100].
+ *
+ * Interpretation:
+ * - G-Factor > 70  → Strong composite fundamentals
+ * - G-Factor 40–70 → Average
+ * - G-Factor < 40  → Weak
+ *
+ * Weights are based on typical quantitative equity-factor research priorities:
+ * Quality is the most predictive of long-term returns; Growth drives near-term
+ * re-rating; Momentum captures market confirmation of the thesis.
+ */
+declare const computeGFactor: (qualityScore: number, growthScore: number, momentumScore: number) => number;
+
+/**
+ * Simplified Intrinsic Value Estimate
+ * Formula: EPS × (1 + growthRate) ^ years / (1 + discountRate) ^ years
+ *          applied over a default 5-year horizon, then divided by (1 - safetyMargin)
+ *
+ * A lightweight DCF approximation for quick screening:
+ *   intrinsicValue = (EPS × (1 + growthRate)^5) / (1 - safetyMargin)
+ *
+ * Parameters:
+ * @param eps           Earnings Per Share (current or TTM)
+ * @param growthRate    Expected annual EPS growth rate as a decimal (e.g. 0.15 for 15%)
+ * @param safetyMargin  Margin of safety as a decimal (e.g. 0.25 for 25% discount)
+ *
+ * Interpretation:
+ * - If market price < intrinsicValue → potential undervaluation
+ * - safetyMargin of 0.25–0.35 is conventional for conservative investing
+ *
+ * Returns null for non-positive EPS or invalid inputs.
+ */
+declare const computeIntrinsicValue: (eps: number, growthRate: number, safetyMargin: number) => number | null;
+
 /**
  * Calculate basic growth rate given current and previous values.
  * Useful for building out mapping functions natively in the analyzer.
@@ -950,6 +1044,16 @@ declare const qoqGrowth: (dataPoints: number[]) => number[];
  * Formula: (Ending Value / Beginning Value) ^ (1 / Years) - 1
  */
 declare const cagr: (beginningValue: number, endingValue: number, periods: number) => number | null;
+/**
+ * Median Growth Rate
+ * Calculates the YoY growth rates for a series of annual values (oldest first),
+ * then returns the median of those rates.
+ * Interpretation:
+ * - More robust than mean growth because it is not skewed by outlier years.
+ * - Useful for evaluating the "typical" annual growth of earnings, revenue, etc.
+ * Returns null if fewer than 2 data points are provided.
+ */
+declare const medianGrowth: (annualValues: number[]) => number | null;
 
 /**
  * Analyst Target Upside / Downside
@@ -960,4 +1064,192 @@ declare const cagr: (beginningValue: number, endingValue: number, periods: numbe
  */
 declare const targetUpside: (currentPrice: number, targetPrice: number) => number | null;
 
-export { type CompanySnapshotInput, type EvaluatedMetric, type FundamentalTimeseriesInput, type MetricStatus, type PiotroskiInput, type PiotroskiResult, type PiotroskiSignals, altmanZScore, analyzeBatch, analyzeCompany, analyzeEfficiency, analyzeFundamentalTrends, analyzeLiquidity, analyzeProfitability, analyzeQuality, analyzeRisk, analyzeSolvency, analyzeValuation, assetTurnover, cagr, calculateDCF, calculateEnterpriseValue, calculateGrowthRate, cashConversionRatio, currentRatio, daysSalesOutstanding, debtToAssets, debtToEquity, dividendYield, earningsYield, evEbitda, evFcf, evRevenue, evaluate, fcfMargin, grahamNumber, grossMargin, impliedSharePrice, interestCoverage, inventoryTurnover, netDebt, netDebtToEbitda, netProfitMargin, operatingMargin, payoutRatio, pb, pbFromMarketCap, pe, peg, piotroski, priceToCashFlow, priceToCashFlowPerShare, ps, psFromMarketCap, qoqGrowth, quickRatio, receivablesTurnover, roa, roe, roic, safeDivide, sharpe, targetUpside, yoyGrowth };
+/**
+ * Trailing Twelve Months (TTM) Utilities
+ *
+ * TTM aggregates the most recent four quarters of data to produce
+ * an annualised figure without waiting for a full fiscal year.
+ */
+/**
+ * Trailing Twelve Months Sum
+ * Returns the sum of the last 4 quarterly values (or fewer if < 4 available).
+ * Expects values in chronological order: oldest first, most recent last.
+ * e.g. [Q1, Q2, Q3, Q4, Q1_next, Q2_next] → sums last 4
+ */
+declare const computeTTM: (quarterlyValues: number[]) => number | null;
+/**
+ * Trailing Twelve Months Average
+ * Returns the average of the last 4 quarterly values (or fewer if < 4 available).
+ * Handles arrays shorter than 4 gracefully by averaging whatever is available.
+ * Expects chronological order: oldest first, most recent last.
+ */
+declare const computeTTMAvg: (quarterlyValues: number[]) => number | null;
+
+/**
+ * Historical Aggregation Utilities
+ *
+ * Functions for computing averages, sums, and point lookups over
+ * rolling windows of quarterly (or annual) data.
+ * All functions expect chronological order: oldest first, most recent last.
+ */
+/**
+ * N-Year Average
+ * Returns the average of the last (years × 4) quarterly values.
+ * e.g. computeNYearAverage(data, 3) → average of last 12 quarters.
+ * If fewer values are available than requested, averages all available values.
+ */
+declare const computeNYearAverage: (quarterlyValues: number[], years: number) => number | null;
+/**
+ * N-Year Sum
+ * Returns the sum of the last (years × 4) quarterly values.
+ * If fewer values are available, sums all available values.
+ */
+declare const computeNYearSum: (quarterlyValues: number[], years: number) => number | null;
+/**
+ * Historical Point Lookup
+ * Returns the value at exactly `quartersBack` quarters from the most recent value.
+ * quartersBack = 0 → most recent value
+ * quartersBack = 4 → value from 1 year ago (same quarter last year)
+ * Returns null if the index is out of bounds.
+ */
+declare const computeHistoricalPoint: (quarterlyValues: number[], quartersBack: number) => number | null;
+
+/**
+ * Composite Scoring Engine
+ *
+ * Four domain scores — Quality, Growth, Value, Momentum — each in range [0, 100].
+ * Each score is a weighted sum of normalised sub-signals (also 0-100 or boolean).
+ *
+ * These scores feed into computeGFactor for the overall composite.
+ */
+interface QualityScoreInput {
+    /** Piotroski F-Score (0–9) */
+    piotroskiScore: number;
+    /**
+     * ROE vs. sector median — percentage of sector ROE this company achieves.
+     * e.g. if company ROE is 18% and sector median is 15%, pass 18/15 = 1.2.
+     * Capped at 1.0 (100 points if >= sector median).
+     */
+    roeVsSector: number;
+    /** Whether operating margins are improving YoY (boolean) */
+    marginsImproving: boolean;
+    /** Promoter pledge percentage is 0 or negligible (boolean) */
+    pledgeFree: boolean;
+    /** Promoter holding is stable or increasing YoY (boolean) */
+    promoterStable: boolean;
+}
+/**
+ * Quality Score (0–100)
+ * Weights:
+ *   Piotroski (0–9 → 0–100): 30 %
+ *   ROE vs Sector (capped at 1.0 multiplier): 20 %
+ *   Margins improving: 20 %
+ *   Pledge-free: 15 %
+ *   Promoter stable: 15 %
+ */
+declare const computeQualityScore: (input: QualityScoreInput) => number;
+interface GrowthScoreInput {
+    /**
+     * Revenue growth rate relative to sector.
+     * e.g. if company revenue grew 20% and sector average is 12%, pass 20/12 = 1.67.
+     * Capped at 1.0 (100 points if >= sector growth).
+     */
+    revenueGrowthVsSector: number;
+    /**
+     * Profit (net income) growth rate as decimal (e.g. 0.20 for 20% growth).
+     * Capped at 30% for full score (0.30 → 100).
+     */
+    profitGrowthRate: number;
+    /**
+     * EPS growth rate as decimal. Capped at 25% for full score (0.25 → 100).
+     */
+    epsGrowthRate: number;
+    /** Operating cash flow is positive this period (boolean) */
+    cfoPositive: boolean;
+    /** Revenue acceleration: current year growth > prior year growth (boolean) */
+    revenueAccelerating: boolean;
+}
+/**
+ * Growth Score (0–100)
+ * Weights:
+ *   Revenue growth vs sector: 25 %
+ *   Profit growth rate: 25 %
+ *   EPS growth rate: 20 %
+ *   CFO positive: 15 %
+ *   Revenue accelerating: 15 %
+ */
+declare const computeGrowthScore: (input: GrowthScoreInput) => number;
+interface ValueScoreInput {
+    /**
+     * Current P/E divided by the stock's own 3-year average P/E.
+     * e.g. currentPE = 15, avgPE = 20 → ratio = 15/20 = 0.75 (trading below avg → higher score).
+     * Score is higher when ratio < 1 (currently cheaper than historical average).
+     */
+    peVs3yrAvg: number;
+    /**
+     * Current P/B vs sector median P/B. Score is higher when < 1.
+     * e.g. company PB = 2, sector median PB = 3 → ratio = 2/3 ≈ 0.67
+     */
+    pbVsSector: number;
+    /**
+     * PEG ratio (P/E ÷ Growth Rate). Lower is better; 1.0 = fair, < 1 = undervalued.
+     * Capped at 0 for negative PEG; capped at full score for PEG ≤ 0.5.
+     */
+    peg: number;
+    /**
+     * Current P/E percentile over the stock's own 5-year history (0–100).
+     * Lower percentile = cheaper vs history = higher score.
+     * Pass 0–100 directly.
+     */
+    historicalPePercentile: number;
+}
+/**
+ * Value Score (0–100)
+ * Weights:
+ *   P/E vs 3yr avg: 30 %
+ *   P/B vs sector: 25 %
+ *   PEG: 25 %
+ *   Historical P/E percentile: 20 %
+ */
+declare const computeValueScore: (input: ValueScoreInput) => number;
+interface MomentumScoreInput {
+    /**
+     * Current price vs its 200-day SMA ratio.
+     * e.g. price = 105, SMA200 = 100 → ratio = 1.05 (above SMA → bullish).
+     * Score peaks at ratio ≥ 1.10 (10% above SMA).
+     */
+    priceVsSma200: number;
+    /**
+     * RSI (14-period). Range 0–100.
+     * Score peaks at RSI 50–65 (trending without being overbought).
+     */
+    rsi: number;
+    /**
+     * ADX (Average Directional Index). Range 0–100.
+     * ADX > 25 indicates a strong trend; ADX < 20 is trendless.
+     * Score peaks at ADX ≥ 30.
+     */
+    adx: number;
+    /**
+     * Volume ratio: current 20-day avg volume / 90-day avg volume.
+     * > 1.0 = rising volume (confirming move). Score caps at 1.5x.
+     */
+    volumeRatio: number;
+    /**
+     * Rate of Change over 125 trading days (6 months), as a decimal.
+     * e.g. 0.20 = 20% return over 6 months. Capped at 40% for full score.
+     */
+    roc125: number;
+}
+/**
+ * Momentum Score (0–100)
+ * Weights:
+ *   Price vs SMA200: 25 %
+ *   RSI: 20 %
+ *   ADX: 20 %
+ *   Volume ratio: 20 %
+ *   ROC-125: 15 %
+ */
+declare const computeMomentumScore: (input: MomentumScoreInput) => number;
+
+export { type CompanySnapshotInput, type EvaluatedMetric, type FundamentalTimeseriesInput, type GrowthScoreInput, type MetricStatus, type MomentumScoreInput, type PiotroskiInput, type PiotroskiResult, type PiotroskiSignals, type QualityScoreInput, type ValueScoreInput, altmanZScore, analyzeBatch, analyzeCompany, analyzeEfficiency, analyzeFundamentalTrends, analyzeLiquidity, analyzeProfitability, analyzeQuality, analyzeRisk, analyzeSolvency, analyzeValuation, assetTurnover, cagr, calculateDCF, calculateEnterpriseValue, calculateGrowthRate, cashConversionCycle, cashConversionRatio, computeGFactor, computeGrowthScore, computeHistoricalPoint, computeIntrinsicValue, computeMomentumScore, computeNCVPS, computeNYearAverage, computeNYearSum, computeQualityScore, computeTTM, computeTTMAvg, computeValueScore, currentRatio, daysSalesOutstanding, debtToAssets, debtToEquity, dividendYield, earningsYield, evEbitda, evFcf, evRevenue, evaluate, fcfMargin, grahamNumber, grossMargin, impliedSharePrice, interestCoverage, inventoryTurnover, marketCapToDebtCap, medianGrowth, netDebt, netDebtToEbitda, netProfitMargin, operatingMargin, payableDays, payoutRatio, pb, pbFromMarketCap, pe, peg, piotroski, priceToCashFlow, priceToCashFlowPerShare, ps, psFromMarketCap, qoqGrowth, quickRatio, receivablesTurnover, roa, roe, roic, safeDivide, sharpe, targetUpside, workingCapitalDays, yoyGrowth };

package/dist/index.js

@@ -35,7 +35,20 @@ __export(index_exports, {
   calculateDCF: () => calculateDCF,
   calculateEnterpriseValue: () => calculateEnterpriseValue,
   calculateGrowthRate: () => calculateGrowthRate,
+  cashConversionCycle: () => cashConversionCycle,
   cashConversionRatio: () => cashConversionRatio,
+  computeGFactor: () => computeGFactor,
+  computeGrowthScore: () => computeGrowthScore,
+  computeHistoricalPoint: () => computeHistoricalPoint,
+  computeIntrinsicValue: () => computeIntrinsicValue,
+  computeMomentumScore: () => computeMomentumScore,
+  computeNCVPS: () => computeNCVPS,
+  computeNYearAverage: () => computeNYearAverage,
+  computeNYearSum: () => computeNYearSum,
+  computeQualityScore: () => computeQualityScore,
+  computeTTM: () => computeTTM,
+  computeTTMAvg: () => computeTTMAvg,
+  computeValueScore: () => computeValueScore,
   currentRatio: () => currentRatio,
   daysSalesOutstanding: () => daysSalesOutstanding,
   debtToAssets: () => debtToAssets,
@@ -52,10 +65,13 @@ __export(index_exports, {
   impliedSharePrice: () => impliedSharePrice,
   interestCoverage: () => interestCoverage,
   inventoryTurnover: () => inventoryTurnover,
+  marketCapToDebtCap: () => marketCapToDebtCap,
+  medianGrowth: () => medianGrowth,
   netDebt: () => netDebt,
   netDebtToEbitda: () => netDebtToEbitda,
   netProfitMargin: () => netProfitMargin,
   operatingMargin: () => operatingMargin,
+  payableDays: () => payableDays,
   payoutRatio: () => payoutRatio,
   pb: () => pb,
   pbFromMarketCap: () => pbFromMarketCap,
@@ -75,6 +91,7 @@ __export(index_exports, {
   safeDivide: () => safeDivide,
   sharpe: () => sharpe,
   targetUpside: () => targetUpside,
+  workingCapitalDays: () => workingCapitalDays,
   yoyGrowth: () => yoyGrowth
 });
 module.exports = __toCommonJS(index_exports);
@@ -740,6 +757,14 @@ var cagr = (beginningValue, endingValue, periods) => {
   if (periods <= 0 || beginningValue <= 0 || endingValue < 0) return null;
   return Math.pow(endingValue / beginningValue, 1 / periods) - 1;
 };
+var medianGrowth = (annualValues) => {
+  if (!annualValues || annualValues.length < 2) return null;
+  const rates = yoyGrowth(annualValues).filter((r) => isFinite(r));
+  if (rates.length === 0) return null;
+  const sorted = [...rates].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+};
 
 // src/analyzer/analyzeFundamentalTrends.ts
 function analyzeFundamentalTrends(data, periodType = "annual") {
@@ -811,6 +836,100 @@ var impliedSharePrice = (enterpriseValue, totalDebt, cashEquivalents, sharesOuts
   const equityValue = enterpriseValue - totalDebt + cashEquivalents;
   return equityValue / sharesOutstanding;
 };
+
+// src/valuation/marketCapToDebtCap.ts
+var marketCapToDebtCap = (marketCap, totalDebt) => safeDivide(marketCap, marketCap + totalDebt);
+
+// src/efficiency/payableDays.ts
+var payableDays = (tradePayables, cogs) => safeDivide(tradePayables * 365, cogs);
+
+// src/efficiency/workingCapitalDays.ts
+var workingCapitalDays = (workingCapital, revenue) => safeDivide(workingCapital * 365, revenue);
+
+// src/efficiency/cashConversionCycle.ts
+var cashConversionCycle = (debtorDays, inventoryDays, payableDays2) => debtorDays + inventoryDays - payableDays2;
+
+// src/intrinsic/ncvps.ts
+var computeNCVPS = (currentAssets, totalLiabilities, sharesOutstanding) => safeDivide(currentAssets - totalLiabilities, sharesOutstanding);
+
+// src/intrinsic/gfactor.ts
+var computeGFactor = (qualityScore, growthScore, momentumScore) => qualityScore * 0.4 + growthScore * 0.35 + momentumScore * 0.25;
+
+// src/intrinsic/intrinsicValue.ts
+var computeIntrinsicValue = (eps, growthRate, safetyMargin) => {
+  if (eps == null || eps <= 0) return null;
+  if (growthRate < -1) return null;
+  if (safetyMargin < 0 || safetyMargin >= 1) return null;
+  const futureEps = eps * Math.pow(1 + growthRate, 5);
+  return futureEps / (1 - safetyMargin);
+};
+
+// src/ttm/index.ts
+var computeTTM = (quarterlyValues) => {
+  if (!quarterlyValues || quarterlyValues.length === 0) return null;
+  const last4 = quarterlyValues.slice(-4);
+  return last4.reduce((sum, v) => sum + v, 0);
+};
+var computeTTMAvg = (quarterlyValues) => {
+  if (!quarterlyValues || quarterlyValues.length === 0) return null;
+  const last4 = quarterlyValues.slice(-4);
+  return last4.reduce((sum, v) => sum + v, 0) / last4.length;
+};
+
+// src/historical/index.ts
+var computeNYearAverage = (quarterlyValues, years) => {
+  if (!quarterlyValues || quarterlyValues.length === 0 || years <= 0) return null;
+  const window = quarterlyValues.slice(-(years * 4));
+  return window.reduce((sum, v) => sum + v, 0) / window.length;
+};
+var computeNYearSum = (quarterlyValues, years) => {
+  if (!quarterlyValues || quarterlyValues.length === 0 || years <= 0) return null;
+  const window = quarterlyValues.slice(-(years * 4));
+  return window.reduce((sum, v) => sum + v, 0);
+};
+var computeHistoricalPoint = (quarterlyValues, quartersBack) => {
+  if (!quarterlyValues || quarterlyValues.length === 0 || quartersBack < 0) return null;
+  const idx = quarterlyValues.length - 1 - quartersBack;
+  if (idx < 0) return null;
+  return quarterlyValues[idx];
+};
+
+// src/scoring/index.ts
+var computeQualityScore = (input) => {
+  const { piotroskiScore, roeVsSector, marginsImproving, pledgeFree, promoterStable } = input;
+  const piotroskiNorm = Math.min(piotroskiScore / 9, 1) * 100;
+  const roeNorm = Math.min(roeVsSector, 1) * 100;
+  const marginsScore = marginsImproving ? 100 : 0;
+  const pledgeScore = pledgeFree ? 100 : 0;
+  const promoterScore = promoterStable ? 100 : 0;
+  return piotroskiNorm * 0.3 + roeNorm * 0.2 + marginsScore * 0.2 + pledgeScore * 0.15 + promoterScore * 0.15;
+};
+var computeGrowthScore = (input) => {
+  const { revenueGrowthVsSector, profitGrowthRate, epsGrowthRate, cfoPositive, revenueAccelerating } = input;
+  const revVsSectorNorm = Math.min(Math.max(revenueGrowthVsSector, 0), 1) * 100;
+  const profitNorm = Math.min(Math.max(profitGrowthRate / 0.3, 0), 1) * 100;
+  const epsNorm = Math.min(Math.max(epsGrowthRate / 0.25, 0), 1) * 100;
+  const cfoScore = cfoPositive ? 100 : 0;
+  const accelScore = revenueAccelerating ? 100 : 0;
+  return revVsSectorNorm * 0.25 + profitNorm * 0.25 + epsNorm * 0.2 + cfoScore * 0.15 + accelScore * 0.15;
+};
+var computeValueScore = (input) => {
+  const { peVs3yrAvg, pbVsSector, peg: peg2, historicalPePercentile } = input;
+  const peAvgScore = Math.min(Math.max((1 - peVs3yrAvg + 1) * 50, 0), 100);
+  const pbScore = Math.min(Math.max((1 - pbVsSector + 1) * 50, 0), 100);
+  const pegScore = peg2 <= 0 ? 0 : Math.min(Math.max((2 - peg2) / 1.5 * 100, 0), 100);
+  const histScore = Math.max(0, 100 - historicalPePercentile);
+  return peAvgScore * 0.3 + pbScore * 0.25 + pegScore * 0.25 + histScore * 0.2;
+};
+var computeMomentumScore = (input) => {
+  const { priceVsSma200, rsi, adx, volumeRatio, roc125 } = input;
+  const smaScore = Math.min(Math.max((priceVsSma200 - 0.9) / 0.2 * 100, 0), 100);
+  const rsiScore = rsi <= 0 || rsi >= 100 ? 0 : Math.max(0, 100 - Math.abs(rsi - 57.5) * 2.5);
+  const adxScore = Math.min(Math.max(adx / 30 * 100, 0), 100);
+  const volScore = Math.min(Math.max((volumeRatio - 0.5) / 1 * 100, 0), 100);
+  const rocScore = Math.min(Math.max(roc125 / 0.4 * 100, 0), 100);
+  return smaScore * 0.25 + rsiScore * 0.2 + adxScore * 0.2 + volScore * 0.2 + rocScore * 0.15;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   altmanZScore,
@@ -829,7 +948,20 @@ var impliedSharePrice = (enterpriseValue, totalDebt, cashEquivalents, sharesOuts
   calculateDCF,
   calculateEnterpriseValue,
   calculateGrowthRate,
+  cashConversionCycle,
   cashConversionRatio,
+  computeGFactor,
+  computeGrowthScore,
+  computeHistoricalPoint,
+  computeIntrinsicValue,
+  computeMomentumScore,
+  computeNCVPS,
+  computeNYearAverage,
+  computeNYearSum,
+  computeQualityScore,
+  computeTTM,
+  computeTTMAvg,
+  computeValueScore,
   currentRatio,
   daysSalesOutstanding,
   debtToAssets,
@@ -846,10 +978,13 @@ var impliedSharePrice = (enterpriseValue, totalDebt, cashEquivalents, sharesOuts
   impliedSharePrice,
   interestCoverage,
   inventoryTurnover,
+  marketCapToDebtCap,
+  medianGrowth,
   netDebt,
   netDebtToEbitda,
   netProfitMargin,
   operatingMargin,
+  payableDays,
   payoutRatio,
   pb,
   pbFromMarketCap,
@@ -869,5 +1004,6 @@ var impliedSharePrice = (enterpriseValue, totalDebt, cashEquivalents, sharesOuts
   safeDivide,
   sharpe,
   targetUpside,
+  workingCapitalDays,
   yoyGrowth
 });

package/dist/index.mjs

@@ -659,6 +659,14 @@ var cagr = (beginningValue, endingValue, periods) => {
   if (periods <= 0 || beginningValue <= 0 || endingValue < 0) return null;
   return Math.pow(endingValue / beginningValue, 1 / periods) - 1;
 };
+var medianGrowth = (annualValues) => {
+  if (!annualValues || annualValues.length < 2) return null;
+  const rates = yoyGrowth(annualValues).filter((r) => isFinite(r));
+  if (rates.length === 0) return null;
+  const sorted = [...rates].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+};
 
 // src/analyzer/analyzeFundamentalTrends.ts
 function analyzeFundamentalTrends(data, periodType = "annual") {
@@ -730,6 +738,100 @@ var impliedSharePrice = (enterpriseValue, totalDebt, cashEquivalents, sharesOuts
   const equityValue = enterpriseValue - totalDebt + cashEquivalents;
   return equityValue / sharesOutstanding;
 };
+
+// src/valuation/marketCapToDebtCap.ts
+var marketCapToDebtCap = (marketCap, totalDebt) => safeDivide(marketCap, marketCap + totalDebt);
+
+// src/efficiency/payableDays.ts
+var payableDays = (tradePayables, cogs) => safeDivide(tradePayables * 365, cogs);
+
+// src/efficiency/workingCapitalDays.ts
+var workingCapitalDays = (workingCapital, revenue) => safeDivide(workingCapital * 365, revenue);
+
+// src/efficiency/cashConversionCycle.ts
+var cashConversionCycle = (debtorDays, inventoryDays, payableDays2) => debtorDays + inventoryDays - payableDays2;
+
+// src/intrinsic/ncvps.ts
+var computeNCVPS = (currentAssets, totalLiabilities, sharesOutstanding) => safeDivide(currentAssets - totalLiabilities, sharesOutstanding);
+
+// src/intrinsic/gfactor.ts
+var computeGFactor = (qualityScore, growthScore, momentumScore) => qualityScore * 0.4 + growthScore * 0.35 + momentumScore * 0.25;
+
+// src/intrinsic/intrinsicValue.ts
+var computeIntrinsicValue = (eps, growthRate, safetyMargin) => {
+  if (eps == null || eps <= 0) return null;
+  if (growthRate < -1) return null;
+  if (safetyMargin < 0 || safetyMargin >= 1) return null;
+  const futureEps = eps * Math.pow(1 + growthRate, 5);
+  return futureEps / (1 - safetyMargin);
+};
+
+// src/ttm/index.ts
+var computeTTM = (quarterlyValues) => {
+  if (!quarterlyValues || quarterlyValues.length === 0) return null;
+  const last4 = quarterlyValues.slice(-4);
+  return last4.reduce((sum, v) => sum + v, 0);
+};
+var computeTTMAvg = (quarterlyValues) => {
+  if (!quarterlyValues || quarterlyValues.length === 0) return null;
+  const last4 = quarterlyValues.slice(-4);
+  return last4.reduce((sum, v) => sum + v, 0) / last4.length;
+};
+
+// src/historical/index.ts
+var computeNYearAverage = (quarterlyValues, years) => {
+  if (!quarterlyValues || quarterlyValues.length === 0 || years <= 0) return null;
+  const window = quarterlyValues.slice(-(years * 4));
+  return window.reduce((sum, v) => sum + v, 0) / window.length;
+};
+var computeNYearSum = (quarterlyValues, years) => {
+  if (!quarterlyValues || quarterlyValues.length === 0 || years <= 0) return null;
+  const window = quarterlyValues.slice(-(years * 4));
+  return window.reduce((sum, v) => sum + v, 0);
+};
+var computeHistoricalPoint = (quarterlyValues, quartersBack) => {
+  if (!quarterlyValues || quarterlyValues.length === 0 || quartersBack < 0) return null;
+  const idx = quarterlyValues.length - 1 - quartersBack;
+  if (idx < 0) return null;
+  return quarterlyValues[idx];
+};
+
+// src/scoring/index.ts
+var computeQualityScore = (input) => {
+  const { piotroskiScore, roeVsSector, marginsImproving, pledgeFree, promoterStable } = input;
+  const piotroskiNorm = Math.min(piotroskiScore / 9, 1) * 100;
+  const roeNorm = Math.min(roeVsSector, 1) * 100;
+  const marginsScore = marginsImproving ? 100 : 0;
+  const pledgeScore = pledgeFree ? 100 : 0;
+  const promoterScore = promoterStable ? 100 : 0;
+  return piotroskiNorm * 0.3 + roeNorm * 0.2 + marginsScore * 0.2 + pledgeScore * 0.15 + promoterScore * 0.15;
+};
+var computeGrowthScore = (input) => {
+  const { revenueGrowthVsSector, profitGrowthRate, epsGrowthRate, cfoPositive, revenueAccelerating } = input;
+  const revVsSectorNorm = Math.min(Math.max(revenueGrowthVsSector, 0), 1) * 100;
+  const profitNorm = Math.min(Math.max(profitGrowthRate / 0.3, 0), 1) * 100;
+  const epsNorm = Math.min(Math.max(epsGrowthRate / 0.25, 0), 1) * 100;
+  const cfoScore = cfoPositive ? 100 : 0;
+  const accelScore = revenueAccelerating ? 100 : 0;
+  return revVsSectorNorm * 0.25 + profitNorm * 0.25 + epsNorm * 0.2 + cfoScore * 0.15 + accelScore * 0.15;
+};
+var computeValueScore = (input) => {
+  const { peVs3yrAvg, pbVsSector, peg: peg2, historicalPePercentile } = input;
+  const peAvgScore = Math.min(Math.max((1 - peVs3yrAvg + 1) * 50, 0), 100);
+  const pbScore = Math.min(Math.max((1 - pbVsSector + 1) * 50, 0), 100);
+  const pegScore = peg2 <= 0 ? 0 : Math.min(Math.max((2 - peg2) / 1.5 * 100, 0), 100);
+  const histScore = Math.max(0, 100 - historicalPePercentile);
+  return peAvgScore * 0.3 + pbScore * 0.25 + pegScore * 0.25 + histScore * 0.2;
+};
+var computeMomentumScore = (input) => {
+  const { priceVsSma200, rsi, adx, volumeRatio, roc125 } = input;
+  const smaScore = Math.min(Math.max((priceVsSma200 - 0.9) / 0.2 * 100, 0), 100);
+  const rsiScore = rsi <= 0 || rsi >= 100 ? 0 : Math.max(0, 100 - Math.abs(rsi - 57.5) * 2.5);
+  const adxScore = Math.min(Math.max(adx / 30 * 100, 0), 100);
+  const volScore = Math.min(Math.max((volumeRatio - 0.5) / 1 * 100, 0), 100);
+  const rocScore = Math.min(Math.max(roc125 / 0.4 * 100, 0), 100);
+  return smaScore * 0.25 + rsiScore * 0.2 + adxScore * 0.2 + volScore * 0.2 + rocScore * 0.15;
+};
 export {
   altmanZScore,
   analyzeBatch,
@@ -747,7 +849,20 @@ export {
   calculateDCF,
   calculateEnterpriseValue,
   calculateGrowthRate,
+  cashConversionCycle,
   cashConversionRatio,
+  computeGFactor,
+  computeGrowthScore,
+  computeHistoricalPoint,
+  computeIntrinsicValue,
+  computeMomentumScore,
+  computeNCVPS,
+  computeNYearAverage,
+  computeNYearSum,
+  computeQualityScore,
+  computeTTM,
+  computeTTMAvg,
+  computeValueScore,
   currentRatio,
   daysSalesOutstanding,
   debtToAssets,
@@ -764,10 +879,13 @@ export {
   impliedSharePrice,
   interestCoverage,
   inventoryTurnover,
+  marketCapToDebtCap,
+  medianGrowth,
   netDebt,
   netDebtToEbitda,
   netProfitMargin,
   operatingMargin,
+  payableDays,
   payoutRatio,
   pb,
   pbFromMarketCap,
@@ -787,5 +905,6 @@ export {
   safeDivide,
   sharpe,
   targetUpside,
+  workingCapitalDays,
   yoyGrowth
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "finance-calculator-pro",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "author": "boffincoders",
   "repository": {
     "type": "git",
@@ -10,7 +10,7 @@
     "url": "https://github.com/boffincoders/finance-calculator/issues"
   },
   "homepage": "https://boffincoders.github.io/finance-calculator/",
-  "description": "Zero-dependency financial analysis engine for JavaScript/TypeScript. Calculates 30+ metrics: P/E, P/B, EV/EBITDA, ROE, Altman Z-Score, Piotroski F-Score, DCF, Graham Number, Sharpe Ratio and more. Works with yahoo-finance2 and any data source.",
+  "description": "Zero-dependency financial analysis engine for JavaScript/TypeScript. Calculates 60+ metrics: P/E, P/B, EV/EBITDA, ROE, Altman Z-Score, Piotroski F-Score, DCF, Graham Number, Sharpe Ratio, RSI, MACD, Bollinger Bands, ATR, VWAP, Beta, Cash Conversion Cycle, TTM aggregation, composite scoring engine, and more. Works with any data source.",
   "keywords": [
     "finance",
     "financial-ratios",
@@ -45,7 +45,25 @@
     "solvency",
     "portfolio-analysis",
     "typescript",
-    "zero-dependency"
+    "zero-dependency",
+    "technical-analysis",
+    "rsi",
+    "macd",
+    "bollinger-bands",
+    "moving-average",
+    "ema",
+    "sma",
+    "atr",
+    "vwap",
+    "beta",
+    "pivot-points",
+    "cash-conversion-cycle",
+    "ttm",
+    "trailing-twelve-months",
+    "intrinsic-value",
+    "composite-scoring",
+    "f-score",
+    "quant-finance"
   ],
   "main": "dist/index.js",
   "module": "dist/index.mjs",