ta-crypto 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,114 @@
+# pandas_btc
+
+[![npm version](https://img.shields.io/npm/v/ta-crypto.svg)](https://www.npmjs.com/package/ta-crypto)
+[![CI](https://github.com/tdamiao/pandas-btc/actions/workflows/ci.yml/badge.svg)](https://github.com/tdamiao/pandas-btc/actions/workflows/ci.yml)
+
+Technical analysis indicators for crypto markets in Node.js. Inspired by pandas-ta, but focused on crypto use-cases and Node-friendly APIs.
+
+## Features
+
+- Typed, lightweight indicators for OHLCV arrays
+- Crypto-specific extras like session VWAP, funding rate helpers, volatility regimes, and orderflow proxies
+- Functions return arrays aligned to input length with `null` for insufficient data
+
+## Install
+
+```bash
+npm i ta-crypto
+```
+
+## Quick Start
+
+```ts
+import {
+  ta,
+  sma,
+  rsi,
+  macd,
+  bbands,
+  atr,
+  vwap,
+  vwapSession,
+  realizedVolatility,
+  fundingRateCumulative,
+  volatilityRegime,
+  orderflowImbalance,
+  obv,
+  mfi,
+  stoch,
+  adx
+} from "ta-crypto";
+
+const close = [101, 102, 99, 105, 110, 108, 111];
+const open =  [100, 101, 100, 103, 108, 109, 110];
+const high =  [102, 103, 101, 106, 112, 110, 112];
+const low =   [ 99, 100,  98, 102, 107, 106, 109];
+const volume =[ 10,  12,  11,  15,  17,  14,  18];
+const session=[  1,   1,   1,   2,   2,   2,   3];
+
+const s = sma(close, 3);
+const r = rsi(close, 14);
+const m = macd(close);
+const b = bbands(close, 20, 2);
+const a = atr(high, low, close, 14);
+const v = vwap(high, low, close, volume);
+const vs = vwapSession(high, low, close, volume, session);
+const rv = realizedVolatility(close, 30, 365);
+const fr = fundingRateCumulative([0.0001, -0.0002, 0.00005]);
+const vr = volatilityRegime(close, 30, 365);
+const ofi = orderflowImbalance(open, close, volume, 20);
+const o = obv(close, volume);
+const moneyFlow = mfi(high, low, close, volume, 14);
+const st = stoch(high, low, close, 14, 3);
+const dx = adx(high, low, close, 14);
+
+const s2 = ta.sma(close, 3);
+```
+
+## API Conventions
+
+- Input arrays must be the same length.
+- Outputs are aligned to input length.
+- `null` marks periods with insufficient data.
+
+## Indicators
+
+Overlap:
+- `sma`, `ema`, `rma`, `hl2`, `hlc3`, `ohlc4`, `vwap`, `bbands`
+
+Momentum:
+- `rsi`, `macd`, `stoch`
+
+Volatility:
+- `trueRange`, `atr`, `natr`, `realizedVolatility`
+
+Performance:
+- `logReturn`, `percentReturn`
+
+Volume:
+- `obv`, `mfi`
+
+Trend:
+- `adx`
+
+Crypto:
+- `vwapSession`, `fundingRateCumulative`, `fundingRateAPR`, `volatilityRegime`, `signedVolume`, `volumeDelta`, `orderflowImbalance`
+
+## Crypto-Specific Notes
+
+Session VWAP:
+- Provide a `session` array with an id per candle. VWAP resets on each new session id.
+
+Funding rate:
+- `fundingRateCumulative` sums periodic rates over time.
+- `fundingRateAPR` annualizes a periodic rate using `periodsPerYear`.
+
+Volatility regimes:
+- `volatilityRegime` computes realized volatility and returns -1, 0, or 1 based on z-score thresholds.
+
+Orderflow proxies:
+- `signedVolume`, `volumeDelta`, and `orderflowImbalance` infer buy/sell pressure from candle direction.
+
+## License
+
+MIT

package/dist/core/crypto.d.ts

@@ -0,0 +1,7 @@
+export declare function vwapSession(high: number[], low: number[], close: number[], volume: number[], session: Array<string | number>): Array<number | null>;
+export declare function fundingRateCumulative(values: number[]): Array<number | null>;
+export declare function fundingRateAPR(values: number[], periodsPerYear?: number): Array<number | null>;
+export declare function volatilityRegime(values: number[], length?: number, periodsPerYear?: number, lowZ?: number, highZ?: number): Array<number | null>;
+export declare function signedVolume(open: number[], close: number[], volume: number[]): Array<number | null>;
+export declare function volumeDelta(open: number[], close: number[], volume: number[], length?: number): Array<number | null>;
+export declare function orderflowImbalance(open: number[], close: number[], volume: number[], length?: number): Array<number | null>;

package/dist/core/crypto.js

@@ -0,0 +1,98 @@
+import { assertSameLength, makeSeries, mean, stdev } from "./math";
+import { hlc3 } from "./overlap";
+import { realizedVolatility } from "./performance";
+export function vwapSession(high, low, close, volume, session) {
+    assertSameLength(high, low, close, volume);
+    if (session.length !== high.length) {
+        throw new Error("All series must have the same length");
+    }
+    const out = makeSeries(high.length);
+    const typical = hlc3(high, low, close).map(v => (v === null ? 0 : v));
+    let cumPV = 0;
+    let cumV = 0;
+    let lastSession = undefined;
+    for (let i = 0; i < high.length; i++) {
+        if (lastSession !== session[i]) {
+            cumPV = 0;
+            cumV = 0;
+            lastSession = session[i];
+        }
+        cumPV += typical[i] * volume[i];
+        cumV += volume[i];
+        out[i] = cumV === 0 ? null : cumPV / cumV;
+    }
+    return out;
+}
+export function fundingRateCumulative(values) {
+    const out = makeSeries(values.length);
+    let acc = 0;
+    for (let i = 0; i < values.length; i++) {
+        acc += values[i];
+        out[i] = acc;
+    }
+    return out;
+}
+export function fundingRateAPR(values, periodsPerYear = 365 * 3) {
+    const out = makeSeries(values.length);
+    for (let i = 0; i < values.length; i++) {
+        out[i] = values[i] * periodsPerYear * 100;
+    }
+    return out;
+}
+export function volatilityRegime(values, length = 30, periodsPerYear = 365, lowZ = -0.5, highZ = 0.5) {
+    const vol = realizedVolatility(values, length, periodsPerYear);
+    const out = makeSeries(values.length);
+    for (let i = length * 2; i < values.length; i++) {
+        const windowStart = i - length + 1;
+        const windowEnd = i;
+        const window = vol.slice(windowStart, windowEnd + 1).map(v => (v === null ? 0 : v));
+        const m = mean(window, 0, window.length - 1);
+        const s = stdev(window, 0, window.length - 1);
+        if (s === 0) {
+            out[i] = 0;
+            continue;
+        }
+        const z = (vol[i] - m) / s;
+        out[i] = z > highZ ? 1 : z < lowZ ? -1 : 0;
+    }
+    return out;
+}
+export function signedVolume(open, close, volume) {
+    assertSameLength(open, close, volume);
+    const out = makeSeries(close.length);
+    for (let i = 0; i < close.length; i++) {
+        const diff = close[i] - open[i];
+        out[i] = diff > 0 ? volume[i] : diff < 0 ? -volume[i] : 0;
+    }
+    return out;
+}
+export function volumeDelta(open, close, volume, length = 14) {
+    const sv = signedVolume(open, close, volume).map(v => (v === null ? 0 : v));
+    const out = makeSeries(close.length);
+    if (length <= 0)
+        return out;
+    for (let i = length - 1; i < close.length; i++) {
+        let acc = 0;
+        for (let j = i - length + 1; j <= i; j++)
+            acc += sv[j];
+        out[i] = acc;
+    }
+    return out;
+}
+export function orderflowImbalance(open, close, volume, length = 14) {
+    assertSameLength(open, close, volume);
+    const out = makeSeries(close.length);
+    if (length <= 0)
+        return out;
+    for (let i = length - 1; i < close.length; i++) {
+        let signed = 0;
+        let total = 0;
+        for (let j = i - length + 1; j <= i; j++) {
+            const diff = close[j] - open[j];
+            signed += diff > 0 ? volume[j] : diff < 0 ? -volume[j] : 0;
+            total += volume[j];
+        }
+        out[i] = total === 0 ? null : signed / total;
+    }
+    return out;
+}

package/dist/core/math.d.ts

@@ -0,0 +1,7 @@
+export declare function isNum(value: unknown): value is number;
+export declare function assertSameLength(...series: number[][]): void;
+export declare function makeSeries(length: number): Array<number | null>;
+export declare function sum(values: number[], start: number, end: number): number;
+export declare function mean(values: number[], start: number, end: number): number;
+export declare function variance(values: number[], start: number, end: number): number;
+export declare function stdev(values: number[], start: number, end: number): number;

package/dist/core/math.js

@@ -0,0 +1,37 @@
+export function isNum(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+export function assertSameLength(...series) {
+    if (series.length === 0)
+        return;
+    const len = series[0].length;
+    for (const s of series) {
+        if (s.length !== len) {
+            throw new Error("All series must have the same length");
+        }
+    }
+}
+export function makeSeries(length) {
+    return Array.from({ length }, () => null);
+}
+export function sum(values, start, end) {
+    let acc = 0;
+    for (let i = start; i <= end; i++)
+        acc += values[i];
+    return acc;
+}
+export function mean(values, start, end) {
+    return sum(values, start, end) / (end - start + 1);
+}
+export function variance(values, start, end) {
+    const m = mean(values, start, end);
+    let acc = 0;
+    for (let i = start; i <= end; i++) {
+        const d = values[i] - m;
+        acc += d * d;
+    }
+    return acc / (end - start + 1);
+}
+export function stdev(values, start, end) {
+    return Math.sqrt(variance(values, start, end));
+}

package/dist/core/momentum.d.ts

@@ -0,0 +1,10 @@
+export declare function macd(values: number[], fast?: number, slow?: number, signal?: number): {
+    macd: (number | null)[];
+    signal: (number | null)[];
+    histogram: (number | null)[];
+};
+export declare function rsi(values: number[], length?: number): Array<number | null>;
+export declare function stoch(high: number[], low: number[], close: number[], kLength?: number, dLength?: number): {
+    k: (number | null)[];
+    d: (number | null)[];
+};

package/dist/core/momentum.js

@@ -0,0 +1,81 @@
+import { makeSeries } from "./math";
+import { ema } from "./overlap";
+export function macd(values, fast = 12, slow = 26, signal = 9) {
+    const fastEma = ema(values, fast);
+    const slowEma = ema(values, slow);
+    const macdLine = makeSeries(values.length);
+    for (let i = 0; i < values.length; i++) {
+        if (fastEma[i] === null || slowEma[i] === null)
+            continue;
+        macdLine[i] = fastEma[i] - slowEma[i];
+    }
+    const signalLine = ema(macdLine.map(v => (v === null ? 0 : v)), signal);
+    const histogram = makeSeries(values.length);
+    for (let i = 0; i < values.length; i++) {
+        if (macdLine[i] === null || signalLine[i] === null)
+            continue;
+        histogram[i] = macdLine[i] - signalLine[i];
+    }
+    return { macd: macdLine, signal: signalLine, histogram };
+}
+export function rsi(values, length = 14) {
+    const out = makeSeries(values.length);
+    if (length <= 0 || values.length < length + 1)
+        return out;
+    let gain = 0;
+    let loss = 0;
+    for (let i = 1; i <= length; i++) {
+        const diff = values[i] - values[i - 1];
+        if (diff >= 0)
+            gain += diff;
+        else
+            loss -= diff;
+    }
+    gain /= length;
+    loss /= length;
+    const rs = loss === 0 ? 0 : gain / loss;
+    out[length] = loss === 0 ? 100 : 100 - 100 / (1 + rs);
+    for (let i = length + 1; i < values.length; i++) {
+        const diff = values[i] - values[i - 1];
+        const g = diff > 0 ? diff : 0;
+        const l = diff < 0 ? -diff : 0;
+        gain = (gain * (length - 1) + g) / length;
+        loss = (loss * (length - 1) + l) / length;
+        const r = loss === 0 ? 0 : gain / loss;
+        out[i] = loss === 0 ? 100 : 100 - 100 / (1 + r);
+    }
+    return out;
+}
+export function stoch(high, low, close, kLength = 14, dLength = 3) {
+    const len = close.length;
+    if (high.length !== len || low.length !== len) {
+        throw new Error("All series must have the same length");
+    }
+    const k = makeSeries(len);
+    const d = makeSeries(len);
+    for (let i = kLength - 1; i < len; i++) {
+        let hh = -Infinity;
+        let ll = Infinity;
+        for (let j = i - kLength + 1; j <= i; j++) {
+            if (high[j] > hh)
+                hh = high[j];
+            if (low[j] < ll)
+                ll = low[j];
+        }
+        const range = hh - ll;
+        k[i] = range === 0 ? 0 : ((close[i] - ll) / range) * 100;
+    }
+    for (let i = kLength - 1 + dLength - 1; i < len; i++) {
+        let acc = 0;
+        let ok = true;
+        for (let j = i - dLength + 1; j <= i; j++) {
+            if (k[j] === null) {
+                ok = false;
+                break;
+            }
+            acc += k[j];
+        }
+        d[i] = ok ? acc / dLength : null;
+    }
+    return { k, d };
+}

package/dist/core/overlap.d.ts

@@ -0,0 +1,12 @@
+export declare function sma(values: number[], length?: number): Array<number | null>;
+export declare function ema(values: number[], length?: number): Array<number | null>;
+export declare function rma(values: number[], length?: number): Array<number | null>;
+export declare function hl2(high: number[], low: number[]): Array<number | null>;
+export declare function hlc3(high: number[], low: number[], close: number[]): Array<number | null>;
+export declare function ohlc4(open: number[], high: number[], low: number[], close: number[]): Array<number | null>;
+export declare function vwap(high: number[], low: number[], close: number[], volume: number[], length?: number): Array<number | null>;
+export declare function bbands(values: number[], length?: number, std?: number): {
+    basis: (number | null)[];
+    upper: (number | null)[];
+    lower: (number | null)[];
+};

package/dist/core/overlap.js

@@ -0,0 +1,102 @@
+import { assertSameLength, isNum, makeSeries, mean, stdev } from "./math";
+export function sma(values, length = 14) {
+    const out = makeSeries(values.length);
+    if (length <= 0)
+        return out;
+    for (let i = length - 1; i < values.length; i++) {
+        out[i] = mean(values, i - length + 1, i);
+    }
+    return out;
+}
+export function ema(values, length = 14) {
+    const out = makeSeries(values.length);
+    if (length <= 0)
+        return out;
+    const k = 2 / (length + 1);
+    let prev = 0;
+    for (let i = 0; i < values.length; i++) {
+        if (i === length - 1) {
+            prev = mean(values, 0, i);
+            out[i] = prev;
+        }
+        else if (i >= length) {
+            prev = (values[i] - prev) * k + prev;
+            out[i] = prev;
+        }
+    }
+    return out;
+}
+export function rma(values, length = 14) {
+    const out = makeSeries(values.length);
+    if (length <= 0)
+        return out;
+    let prev = 0;
+    for (let i = 0; i < values.length; i++) {
+        if (i === length - 1) {
+            prev = mean(values, 0, i);
+            out[i] = prev;
+        }
+        else if (i >= length) {
+            prev = (prev * (length - 1) + values[i]) / length;
+            out[i] = prev;
+        }
+    }
+    return out;
+}
+export function hl2(high, low) {
+    assertSameLength(high, low);
+    const out = makeSeries(high.length);
+    for (let i = 0; i < high.length; i++)
+        out[i] = (high[i] + low[i]) / 2;
+    return out;
+}
+export function hlc3(high, low, close) {
+    assertSameLength(high, low, close);
+    const out = makeSeries(high.length);
+    for (let i = 0; i < high.length; i++)
+        out[i] = (high[i] + low[i] + close[i]) / 3;
+    return out;
+}
+export function ohlc4(open, high, low, close) {
+    assertSameLength(open, high, low, close);
+    const out = makeSeries(open.length);
+    for (let i = 0; i < open.length; i++)
+        out[i] = (open[i] + high[i] + low[i] + close[i]) / 4;
+    return out;
+}
+export function vwap(high, low, close, volume, length) {
+    assertSameLength(high, low, close, volume);
+    const typical = hlc3(high, low, close).map(v => (isNum(v) ? v : 0));
+    const out = makeSeries(high.length);
+    if (!length || length <= 0) {
+        let cumPV = 0;
+        let cumV = 0;
+        for (let i = 0; i < high.length; i++) {
+            cumPV += typical[i] * volume[i];
+            cumV += volume[i];
+            out[i] = cumV === 0 ? null : cumPV / cumV;
+        }
+        return out;
+    }
+    for (let i = length - 1; i < high.length; i++) {
+        let pv = 0;
+        let v = 0;
+        for (let j = i - length + 1; j <= i; j++) {
+            pv += typical[j] * volume[j];
+            v += volume[j];
+        }
+        out[i] = v === 0 ? null : pv / v;
+    }
+    return out;
+}
+export function bbands(values, length = 20, std = 2) {
+    const basis = sma(values, length);
+    const upper = makeSeries(values.length);
+    const lower = makeSeries(values.length);
+    for (let i = length - 1; i < values.length; i++) {
+        const s = stdev(values, i - length + 1, i);
+        upper[i] = basis[i] + std * s;
+        lower[i] = basis[i] - std * s;
+    }
+    return { basis, upper, lower };
+}

package/dist/core/performance.d.ts

@@ -0,0 +1,3 @@
+export declare function logReturn(values: number[], cumulative?: boolean): Array<number | null>;
+export declare function percentReturn(values: number[], cumulative?: boolean): Array<number | null>;
+export declare function realizedVolatility(values: number[], length?: number, periodsPerYear?: number): Array<number | null>;

package/dist/core/performance.js

@@ -0,0 +1,40 @@
+import { makeSeries, stdev } from "./math";
+export function logReturn(values, cumulative = false) {
+    const out = makeSeries(values.length);
+    let acc = 0;
+    for (let i = 1; i < values.length; i++) {
+        const r = Math.log(values[i] / values[i - 1]);
+        if (cumulative) {
+            acc += r;
+            out[i] = acc;
+        }
+        else {
+            out[i] = r;
+        }
+    }
+    return out;
+}
+export function percentReturn(values, cumulative = false) {
+    const out = makeSeries(values.length);
+    let acc = 0;
+    for (let i = 1; i < values.length; i++) {
+        const r = values[i] / values[i - 1] - 1;
+        if (cumulative) {
+            acc += r;
+            out[i] = acc;
+        }
+        else {
+            out[i] = r;
+        }
+    }
+    return out;
+}
+export function realizedVolatility(values, length = 30, periodsPerYear = 365) {
+    const rets = logReturn(values).map(v => (v === null ? 0 : v));
+    const out = makeSeries(values.length);
+    for (let i = length; i < values.length; i++) {
+        const s = stdev(rets, i - length + 1, i);
+        out[i] = s * Math.sqrt(periodsPerYear);
+    }
+    return out;
+}

package/dist/core/trend.d.ts

@@ -0,0 +1,5 @@
+export declare function adx(high: number[], low: number[], close: number[], length?: number): {
+    adx: (number | null)[];
+    plusDI: (number | null)[];
+    minusDI: (number | null)[];
+};

package/dist/core/trend.js

@@ -0,0 +1,41 @@
+import { makeSeries } from "./math";
+import { rma } from "./overlap";
+import { trueRange } from "./volatility";
+export function adx(high, low, close, length = 14) {
+    const len = close.length;
+    if (high.length !== len || low.length !== len) {
+        throw new Error("All series must have the same length");
+    }
+    const plusDM = new Array(len).fill(0);
+    const minusDM = new Array(len).fill(0);
+    for (let i = 1; i < len; i++) {
+        const up = high[i] - high[i - 1];
+        const down = low[i - 1] - low[i];
+        plusDM[i] = up > down && up > 0 ? up : 0;
+        minusDM[i] = down > up && down > 0 ? down : 0;
+    }
+    const tr = trueRange(high, low, close).map(v => (v === null ? 0 : v));
+    const atr = rma(tr, length);
+    const plus = rma(plusDM, length);
+    const minus = rma(minusDM, length);
+    const plusDI = makeSeries(len);
+    const minusDI = makeSeries(len);
+    const dx = makeSeries(len);
+    for (let i = 0; i < len; i++) {
+        if (atr[i] === null)
+            continue;
+        const atrv = atr[i];
+        plusDI[i] = atrv === 0 ? 0 : (plus[i] / atrv) * 100;
+        minusDI[i] = atrv === 0 ? 0 : (minus[i] / atrv) * 100;
+        const denom = plusDI[i] + minusDI[i];
+        dx[i] = denom === 0 ? 0 : (Math.abs(plusDI[i] - minusDI[i]) / denom) * 100;
+    }
+    const adxRaw = rma(dx.map(v => (v === null ? 0 : v)), length);
+    const adx = makeSeries(len);
+    for (let i = 0; i < len; i++) {
+        if (dx[i] === null)
+            continue;
+        adx[i] = adxRaw[i];
+    }
+    return { adx, plusDI, minusDI };
+}

package/dist/core/volatility.d.ts

@@ -0,0 +1,3 @@
+export declare function trueRange(high: number[], low: number[], close: number[]): Array<number | null>;
+export declare function atr(high: number[], low: number[], close: number[], length?: number): Array<number | null>;
+export declare function natr(high: number[], low: number[], close: number[], length?: number): Array<number | null>;

package/dist/core/volatility.js

@@ -0,0 +1,30 @@
+import { assertSameLength, makeSeries } from "./math";
+import { rma } from "./overlap";
+export function trueRange(high, low, close) {
+    assertSameLength(high, low, close);
+    const out = makeSeries(high.length);
+    for (let i = 0; i < high.length; i++) {
+        if (i === 0) {
+            out[i] = high[i] - low[i];
+        }
+        else {
+            const tr = Math.max(high[i] - low[i], Math.abs(high[i] - close[i - 1]), Math.abs(low[i] - close[i - 1]));
+            out[i] = tr;
+        }
+    }
+    return out;
+}
+export function atr(high, low, close, length = 14) {
+    const tr = trueRange(high, low, close).map(v => (v === null ? 0 : v));
+    return rma(tr, length);
+}
+export function natr(high, low, close, length = 14) {
+    const atrv = atr(high, low, close, length);
+    const out = makeSeries(close.length);
+    for (let i = 0; i < close.length; i++) {
+        if (atrv[i] === null)
+            continue;
+        out[i] = atrv[i] / close[i] * 100;
+    }
+    return out;
+}

package/dist/core/volume.d.ts

@@ -0,0 +1,2 @@
+export declare function obv(close: number[], volume: number[]): Array<number | null>;
+export declare function mfi(high: number[], low: number[], close: number[], volume: number[], length?: number): Array<number | null>;

package/dist/core/volume.js

@@ -0,0 +1,52 @@
+import { makeSeries } from "./math";
+export function obv(close, volume) {
+    if (close.length !== volume.length) {
+        throw new Error("All series must have the same length");
+    }
+    const out = makeSeries(close.length);
+    let acc = 0;
+    for (let i = 0; i < close.length; i++) {
+        if (i === 0) {
+            out[i] = acc;
+            continue;
+        }
+        if (close[i] > close[i - 1])
+            acc += volume[i];
+        else if (close[i] < close[i - 1])
+            acc -= volume[i];
+        out[i] = acc;
+    }
+    return out;
+}
+export function mfi(high, low, close, volume, length = 14) {
+    const len = close.length;
+    if (high.length !== len || low.length !== len || volume.length !== len) {
+        throw new Error("All series must have the same length");
+    }
+    const out = makeSeries(len);
+    if (length <= 0)
+        return out;
+    const tp = new Array(len);
+    const mf = new Array(len);
+    for (let i = 0; i < len; i++) {
+        tp[i] = (high[i] + low[i] + close[i]) / 3;
+        mf[i] = tp[i] * volume[i];
+    }
+    for (let i = length; i < len; i++) {
+        let pos = 0;
+        let neg = 0;
+        for (let j = i - length + 1; j <= i; j++) {
+            if (tp[j] > tp[j - 1])
+                pos += mf[j];
+            else if (tp[j] < tp[j - 1])
+                neg += mf[j];
+        }
+        if (pos + neg === 0) {
+            out[i] = 50;
+            continue;
+        }
+        const ratio = neg === 0 ? 0 : pos / neg;
+        out[i] = neg === 0 ? 100 : 100 - 100 / (1 + ratio);
+    }
+    return out;
+}

package/dist/index.d.ts

@@ -0,0 +1,52 @@
+export { sma, ema, rma, hl2, hlc3, ohlc4, vwap, bbands } from "./core/overlap";
+export { rsi, macd, stoch } from "./core/momentum";
+export { trueRange, atr, natr } from "./core/volatility";
+export { logReturn, percentReturn, realizedVolatility } from "./core/performance";
+export { obv, mfi } from "./core/volume";
+export { adx } from "./core/trend";
+export { vwapSession, fundingRateCumulative, fundingRateAPR, volatilityRegime, signedVolume, volumeDelta, orderflowImbalance } from "./core/crypto";
+export * from "./types";
+export declare const ta: {
+    vwapSession(high: number[], low: number[], close: number[], volume: number[], session: Array<string | number>): Array<number | null>;
+    fundingRateCumulative(values: number[]): Array<number | null>;
+    fundingRateAPR(values: number[], periodsPerYear?: number): Array<number | null>;
+    volatilityRegime(values: number[], length?: number, periodsPerYear?: number, lowZ?: number, highZ?: number): Array<number | null>;
+    signedVolume(open: number[], close: number[], volume: number[]): Array<number | null>;
+    volumeDelta(open: number[], close: number[], volume: number[], length?: number): Array<number | null>;
+    orderflowImbalance(open: number[], close: number[], volume: number[], length?: number): Array<number | null>;
+    adx(high: number[], low: number[], close: number[], length?: number): {
+        adx: (number | null)[];
+        plusDI: (number | null)[];
+        minusDI: (number | null)[];
+    };
+    obv(close: number[], volume: number[]): Array<number | null>;
+    mfi(high: number[], low: number[], close: number[], volume: number[], length?: number): Array<number | null>;
+    logReturn(values: number[], cumulative?: boolean): Array<number | null>;
+    percentReturn(values: number[], cumulative?: boolean): Array<number | null>;
+    realizedVolatility(values: number[], length?: number, periodsPerYear?: number): Array<number | null>;
+    trueRange(high: number[], low: number[], close: number[]): Array<number | null>;
+    atr(high: number[], low: number[], close: number[], length?: number): Array<number | null>;
+    natr(high: number[], low: number[], close: number[], length?: number): Array<number | null>;
+    macd(values: number[], fast?: number, slow?: number, signal?: number): {
+        macd: (number | null)[];
+        signal: (number | null)[];
+        histogram: (number | null)[];
+    };
+    rsi(values: number[], length?: number): Array<number | null>;
+    stoch(high: number[], low: number[], close: number[], kLength?: number, dLength?: number): {
+        k: (number | null)[];
+        d: (number | null)[];
+    };
+    sma(values: number[], length?: number): Array<number | null>;
+    ema(values: number[], length?: number): Array<number | null>;
+    rma(values: number[], length?: number): Array<number | null>;
+    hl2(high: number[], low: number[]): Array<number | null>;
+    hlc3(high: number[], low: number[], close: number[]): Array<number | null>;
+    ohlc4(open: number[], high: number[], low: number[], close: number[]): Array<number | null>;
+    vwap(high: number[], low: number[], close: number[], volume: number[], length?: number): Array<number | null>;
+    bbands(values: number[], length?: number, std?: number): {
+        basis: (number | null)[];
+        upper: (number | null)[];
+        lower: (number | null)[];
+    };
+};

package/dist/index.js

@@ -0,0 +1,24 @@
+export { sma, ema, rma, hl2, hlc3, ohlc4, vwap, bbands } from "./core/overlap";
+export { rsi, macd, stoch } from "./core/momentum";
+export { trueRange, atr, natr } from "./core/volatility";
+export { logReturn, percentReturn, realizedVolatility } from "./core/performance";
+export { obv, mfi } from "./core/volume";
+export { adx } from "./core/trend";
+export { vwapSession, fundingRateCumulative, fundingRateAPR, volatilityRegime, signedVolume, volumeDelta, orderflowImbalance } from "./core/crypto";
+export * from "./types";
+import * as overlap from "./core/overlap";
+import * as momentum from "./core/momentum";
+import * as volatility from "./core/volatility";
+import * as performance from "./core/performance";
+import * as volume from "./core/volume";
+import * as trend from "./core/trend";
+import * as crypto from "./core/crypto";
+export const ta = {
+    ...overlap,
+    ...momentum,
+    ...volatility,
+    ...performance,
+    ...volume,
+    ...trend,
+    ...crypto
+};

package/dist/types.d.ts

@@ -0,0 +1,10 @@
+export type NumericSeries = number[];
+export type Series = Array<number | null>;
+export type Candle = {
+    time?: number | string | Date;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "ta-crypto",
+  "version": "0.1.0",
+  "description": "Technical analysis for crypto markets in Node.js",
+  "type": "module",
+  "license": "MIT",
+  "author": "",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "types": "dist/index.d.ts",
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rimraf dist",
+    "prepublishOnly": "npm run clean && npm run build",
+    "test": "node -e \"console.log('no tests yet')\""
+  },
+  "devDependencies": {
+    "rimraf": "^5.0.5",
+    "typescript": "^5.4.5"
+  },
+  "keywords": [
+    "crypto",
+    "bitcoin",
+    "technical-analysis",
+    "indicators",
+    "trading",
+    "ohlcv"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tdamiao/pandas-btc.git"
+  },
+  "bugs": {
+    "url": "https://github.com/tdamiao/pandas-btc/issues"
+  },
+  "homepage": "https://github.com/tdamiao/pandas-btc#readme"
+}