@insiderfinance/totalfinance 0.1.0

package/modules/technical-analysis/dist/trend.js

@@ -0,0 +1,1159 @@
+/**
+ * Trend & directional indicators (spec §13.3).
+ *
+ * DMI (+DI/−DI/DX), ADXR, Aroon & Aroon Oscillator, Parabolic SAR, Supertrend, Ichimoku, Vortex,
+ * linear-regression (value / slope / intercept / angle) and Time-Series Forecast, Chandelier exits,
+ * and ZigZag. ADX itself lives in `./bars`. Each indicator is a serializable stream wrapped into the
+ * aligned batch+stream facade; ZigZag is a batch function (its final leg is provisional by nature).
+ */
+import * as builtinMetadata from './builtin-metadata.js';
+import { withBuiltinMetadata } from './indicator-metadata.js';
+import { CONVENTIONS_VERSION, ensureKnownKeys, requireArgumentArray, requireArgumentObject, } from '../../core/dist/index.js';
+import { makeIndicator, snapshotOf, readSnapshot, } from './framework.js';
+import { AtrStream } from './bars.js';
+import { dirtyRows, isDirtySample } from './nan-policy.js';
+import { requireAtMost, requireBars, requireFinite, requirePeriod, requirePositive, } from './validate.js';
+import { requireStreamParameters } from './stream-validation.js';
+const nanNum = () => NaN;
+function maxOf(xs) {
+    let m = xs[0];
+    for (let i = 1; i < xs.length; i++)
+        if (xs[i] > m)
+            m = xs[i];
+    return m;
+}
+function minOf(xs) {
+    let m = xs[0];
+    for (let i = 1; i < xs.length; i++)
+        if (xs[i] < m)
+            m = xs[i];
+    return m;
+}
+// ───────── projection helper: expose one field of a record indicator as a number facade ─────────
+class ProjectStream {
+    inner;
+    field;
+    kind;
+    value = null;
+    constructor(inner, field, kind) {
+        this.inner = inner;
+        this.field = field;
+        this.kind = kind;
+    }
+    next(x) {
+        const r = this.inner.next(x);
+        this.value = r === null ? null : r[this.field];
+        return this.value;
+    }
+    toJSON() {
+        // `field` is NOT serialized: `projected(kind, …, field)` binds it, so a stored copy reads back
+        // as a field nothing consults.
+        return snapshotOf(this.kind, {
+            inner: this.inner.toJSON(),
+            value: this.value,
+        });
+    }
+}
+function projected(kind, makeInner, restoreInner, field) {
+    return makeIndicator((p) => new ProjectStream(makeInner(p), field, kind), (s) => {
+        const state = readSnapshot(s, kind);
+        const x = new ProjectStream(restoreInner(state.child('inner')), field, kind);
+        x.value = state.cached('value');
+        return x;
+    }, nanNum);
+}
+class DmiStream {
+    period;
+    prevHigh = null;
+    prevLow = 0;
+    previousClose = 0;
+    count = 0;
+    trSum = 0;
+    pdmSum = 0;
+    mdmSum = 0;
+    smTr = 0;
+    smPdm = 0;
+    smMdm = 0;
+    smoothed = false;
+    value = null;
+    constructor(period) {
+        this.period = period;
+        requirePeriod(period, 'DmiStream', 'period', 1, 'bars');
+    }
+    next(bar) {
+        if (this.prevHigh === null) {
+            this.prevHigh = bar.high;
+            this.prevLow = bar.low;
+            this.previousClose = bar.close;
+            this.value = null;
+            return null;
+        }
+        const upMove = bar.high - this.prevHigh;
+        const downMove = this.prevLow - bar.low;
+        const pdm = upMove > downMove && upMove > 0 ? upMove : 0;
+        const mdm = downMove > upMove && downMove > 0 ? downMove : 0;
+        const tr = Math.max(bar.high - bar.low, Math.abs(bar.high - this.previousClose), Math.abs(bar.low - this.previousClose));
+        this.prevHigh = bar.high;
+        this.prevLow = bar.low;
+        this.previousClose = bar.close;
+        if (!this.smoothed) {
+            this.count++;
+            this.trSum += tr;
+            this.pdmSum += pdm;
+            this.mdmSum += mdm;
+            if (this.count === this.period) {
+                this.smTr = this.trSum;
+                this.smPdm = this.pdmSum;
+                this.smMdm = this.mdmSum;
+                this.smoothed = true;
+            }
+            else {
+                this.value = null;
+                return null;
+            }
+        }
+        else {
+            this.smTr = this.smTr - this.smTr / this.period + tr;
+            this.smPdm = this.smPdm - this.smPdm / this.period + pdm;
+            this.smMdm = this.smMdm - this.smMdm / this.period + mdm;
+        }
+        const plusDI = this.smTr === 0 ? 0 : (100 * this.smPdm) / this.smTr;
+        const minusDI = this.smTr === 0 ? 0 : (100 * this.smMdm) / this.smTr;
+        const diSum = plusDI + minusDI;
+        const dx = diSum === 0 ? 0 : (100 * Math.abs(plusDI - minusDI)) / diSum;
+        this.value = { plusDI, minusDI, dx, plusDM: this.smPdm, minusDM: this.smMdm };
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('dmi', {
+            period: this.period,
+            prevHigh: this.prevHigh,
+            prevLow: this.prevLow,
+            previousClose: this.previousClose,
+            count: this.count,
+            trSum: this.trSum,
+            pdmSum: this.pdmSum,
+            mdmSum: this.mdmSum,
+            smTr: this.smTr,
+            smPdm: this.smPdm,
+            smMdm: this.smMdm,
+            smoothed: this.smoothed,
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'dmi');
+        const x = new DmiStream(state.lookback('period'));
+        Object.assign(x, {
+            prevHigh: state.numberOrNull('prevHigh'),
+            prevLow: state.number('prevLow'),
+            previousClose: state.number('previousClose'),
+            count: state.number('count'),
+            trSum: state.number('trSum'),
+            pdmSum: state.number('pdmSum'),
+            mdmSum: state.number('mdmSum'),
+            smTr: state.number('smTr'),
+            smPdm: state.number('smPdm'),
+            smMdm: state.number('smMdm'),
+            smoothed: state.boolean('smoothed'),
+        });
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const dmi = withBuiltinMetadata(makeIndicator((p) => new DmiStream(requirePeriod(p.period ?? 14, 'dmi')), DmiStream.fromJSON, () => ({ plusDI: NaN, minusDI: NaN, dx: NaN, plusDM: NaN, minusDM: NaN })), builtinMetadata.dmiMetadata);
+export const plusDI = withBuiltinMetadata(projected('plusDI', (p) => new DmiStream(requirePeriod(p.period ?? 14, 'plusDI')), DmiStream.fromJSON, 'plusDI'), builtinMetadata.plusDIMetadata);
+export const minusDI = withBuiltinMetadata(projected('minusDI', (p) => new DmiStream(requirePeriod(p.period ?? 14, 'minusDI')), DmiStream.fromJSON, 'minusDI'), builtinMetadata.minusDIMetadata);
+export const dx = withBuiltinMetadata(projected('dx', (p) => new DmiStream(requirePeriod(p.period ?? 14, 'dx')), DmiStream.fromJSON, 'dx'), builtinMetadata.dxMetadata);
+export const plusDM = withBuiltinMetadata(projected('plusDM', (p) => new DmiStream(requirePeriod(p.period ?? 14, 'plusDM', 'period', 1, 'bars')), DmiStream.fromJSON, 'plusDM'), builtinMetadata.plusDMMetadata);
+export const minusDM = withBuiltinMetadata(projected('minusDM', (p) => new DmiStream(requirePeriod(p.period ?? 14, 'minusDM', 'period', 1, 'bars')), DmiStream.fromJSON, 'minusDM'), builtinMetadata.minusDMMetadata);
+// ───────────────────────── ADXR ─────────────────────────
+class AdxrStream {
+    period;
+    dmiInner;
+    dxCount = 0;
+    dxSum = 0;
+    adx = null;
+    adxBuf = [];
+    value = null;
+    constructor(period) {
+        this.period = period;
+        requirePeriod(period, 'AdxrStream', 'period', 1, 'bars');
+        this.dmiInner = new DmiStream(period);
+    }
+    next(bar) {
+        const d = this.dmiInner.next(bar);
+        if (d === null) {
+            this.value = null;
+            return null;
+        }
+        const dxv = d.dx;
+        if (this.adx === null) {
+            this.dxCount++;
+            this.dxSum += dxv;
+            if (this.dxCount === this.period)
+                this.adx = this.dxSum / this.period;
+            else {
+                this.value = null;
+                return null;
+            }
+        }
+        else {
+            this.adx = (this.adx * (this.period - 1) + dxv) / this.period;
+        }
+        this.adxBuf.push(this.adx);
+        if (this.adxBuf.length > this.period + 1)
+            this.adxBuf.shift();
+        if (this.adxBuf.length < this.period + 1) {
+            this.value = null;
+            return null;
+        }
+        this.value = (this.adx + this.adxBuf[0]) / 2;
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('adxr', {
+            period: this.period,
+            dmi: this.dmiInner.toJSON(),
+            dxCount: this.dxCount,
+            dxSum: this.dxSum,
+            adx: this.adx,
+            adxBuf: [...this.adxBuf],
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'adxr');
+        const x = new AdxrStream(state.lookback('period'));
+        x.dmiInner = DmiStream.fromJSON(state.child('dmi'));
+        Object.assign(x, {
+            dxCount: state.number('dxCount'),
+            dxSum: state.number('dxSum'),
+            adx: state.numberOrNull('adx'),
+        });
+        x.adxBuf = state.numbers('adxBuf');
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const adxr = withBuiltinMetadata(makeIndicator((p) => new AdxrStream(requirePeriod(p.period ?? 14, 'adxr')), AdxrStream.fromJSON, nanNum), builtinMetadata.adxrMetadata);
+class AroonStream {
+    period;
+    highs = [];
+    lows = [];
+    value = null;
+    constructor(period) {
+        this.period = period;
+        requirePeriod(period, 'AroonStream', 'period', 1, 'bars');
+    }
+    next(bar) {
+        this.highs.push(bar.high);
+        this.lows.push(bar.low);
+        const length = this.period + 1;
+        if (this.highs.length > length) {
+            this.highs.shift();
+            this.lows.shift();
+        }
+        if (this.highs.length < length) {
+            this.value = null;
+            return null;
+        }
+        // bars since the highest high / lowest low within the window
+        let hiIdx = 0;
+        let loIdx = 0;
+        for (let i = 1; i < length; i++) {
+            if (this.highs[i] >= this.highs[hiIdx])
+                hiIdx = i;
+            if (this.lows[i] <= this.lows[loIdx])
+                loIdx = i;
+        }
+        const sinceHigh = length - 1 - hiIdx;
+        const sinceLow = length - 1 - loIdx;
+        this.value = {
+            up: (100 * (this.period - sinceHigh)) / this.period,
+            down: (100 * (this.period - sinceLow)) / this.period,
+        };
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('aroon', {
+            period: this.period,
+            highs: [...this.highs],
+            lows: [...this.lows],
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'aroon');
+        const x = new AroonStream(state.lookback('period'));
+        x.highs = state.numbers('highs');
+        x.lows = state.numbers('lows');
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const aroon = withBuiltinMetadata(makeIndicator((p) => new AroonStream(requirePeriod(p.period ?? 14, 'aroon')), AroonStream.fromJSON, () => ({ up: NaN, down: NaN })), builtinMetadata.aroonMetadata);
+class AroonOscStream {
+    inner;
+    value = null;
+    constructor(period) {
+        this.inner = new AroonStream(period);
+    }
+    next(bar) {
+        const r = this.inner.next(bar);
+        this.value = r === null ? null : r.up - r.down;
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('aroonOsc', { inner: this.inner.toJSON(), value: this.value });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'aroonOsc');
+        const x = new AroonOscStream(1);
+        x.inner = AroonStream.fromJSON(state.child('inner'));
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const aroonOscillator = withBuiltinMetadata(makeIndicator((p) => new AroonOscStream(requirePeriod(p.period ?? 14, 'aroonOscillator', 'period', 1, 'bars')), AroonOscStream.fromJSON, nanNum), builtinMetadata.aroonOscillatorMetadata);
+class PsarStream {
+    count = 0;
+    prevHigh1 = 0;
+    prevHigh2 = 0;
+    prevLow1 = 0;
+    prevLow2 = 0;
+    sar = 0;
+    ep = 0;
+    af = 0;
+    trend = 0;
+    value = null;
+    step;
+    maxAf;
+    constructor(parameters) {
+        requireStreamParameters('PsarStream.constructor#0', 'PsarStream', parameters);
+        const { step, maxAf } = parameters;
+        this.step = step;
+        this.maxAf = maxAf;
+    }
+    next(bar) {
+        this.count++;
+        if (this.count === 1) {
+            this.prevHigh1 = bar.high;
+            this.prevLow1 = bar.low;
+            this.value = null;
+            return null;
+        }
+        if (this.count === 2) {
+            const up = bar.close >= this.prevLow1; // crude initial direction vs first bar
+            this.trend = up ? 1 : -1;
+            if (up) {
+                this.sar = this.prevLow1;
+                this.ep = bar.high;
+            }
+            else {
+                this.sar = this.prevHigh1;
+                this.ep = bar.low;
+            }
+            this.af = this.step;
+            this.prevHigh2 = this.prevHigh1;
+            this.prevLow2 = this.prevLow1;
+            this.prevHigh1 = bar.high;
+            this.prevLow1 = bar.low;
+            this.value = { sar: this.sar, trend: this.trend };
+            return this.value;
+        }
+        let sar = this.sar + this.af * (this.ep - this.sar);
+        if (this.trend === 1) {
+            sar = Math.min(sar, this.prevLow1, this.prevLow2);
+            if (bar.high > this.ep) {
+                this.ep = bar.high;
+                this.af = Math.min(this.af + this.step, this.maxAf);
+            }
+            if (bar.low < sar) {
+                this.trend = -1;
+                sar = this.ep;
+                this.ep = bar.low;
+                this.af = this.step;
+            }
+        }
+        else {
+            sar = Math.max(sar, this.prevHigh1, this.prevHigh2);
+            if (bar.low < this.ep) {
+                this.ep = bar.low;
+                this.af = Math.min(this.af + this.step, this.maxAf);
+            }
+            if (bar.high > sar) {
+                this.trend = 1;
+                sar = this.ep;
+                this.ep = bar.high;
+                this.af = this.step;
+            }
+        }
+        this.sar = sar;
+        this.prevHigh2 = this.prevHigh1;
+        this.prevLow2 = this.prevLow1;
+        this.prevHigh1 = bar.high;
+        this.prevLow1 = bar.low;
+        this.value = { sar, trend: this.trend };
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('psar', {
+            step: this.step,
+            maxAf: this.maxAf,
+            count: this.count,
+            prevHigh1: this.prevHigh1,
+            prevHigh2: this.prevHigh2,
+            prevLow1: this.prevLow1,
+            prevLow2: this.prevLow2,
+            sar: this.sar,
+            ep: this.ep,
+            af: this.af,
+            trend: this.trend,
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'psar');
+        const x = new PsarStream({
+            step: state.number('step'),
+            maxAf: state.number('maxAf'),
+        });
+        Object.assign(x, {
+            count: state.number('count'),
+            prevHigh1: state.number('prevHigh1'),
+            prevHigh2: state.number('prevHigh2'),
+            prevLow1: state.number('prevLow1'),
+            prevLow2: state.number('prevLow2'),
+            sar: state.number('sar'),
+            ep: state.number('ep'),
+            af: state.number('af'),
+            trend: state.number('trend'),
+        });
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const psar = withBuiltinMetadata(makeIndicator((p) => {
+    const step = requirePositive(p.step ?? 0.02, 'psar', 'step');
+    const max = requirePositive(p.max ?? 0.2, 'psar', 'max');
+    requireAtMost(step, max, 'psar', 'step', 'max');
+    return new PsarStream({ step, maxAf: max });
+}, PsarStream.fromJSON, () => ({ sar: NaN, trend: NaN })), builtinMetadata.psarMetadata);
+/**
+ * TA-Lib SAREXT — Parabolic SAR with independent acceleration factors per side and an offset applied
+ * on reversal. Output is signed: positive while long, negative while short.
+ */
+class PsarExtStream {
+    count = 0;
+    prevHigh1 = 0;
+    prevHigh2 = 0;
+    prevLow1 = 0;
+    prevLow2 = 0;
+    sar = 0;
+    ep = 0;
+    af = 0;
+    trend = 0;
+    value = null;
+    startValue;
+    offset;
+    afInitLong;
+    afLong;
+    afMaxLong;
+    afInitShort;
+    afShort;
+    afMaxShort;
+    constructor(parameters) {
+        requireStreamParameters('PsarExtStream.constructor#0', 'PsarExtStream', parameters);
+        const { startValue, offset, afInitLong, afLong, afMaxLong, afInitShort, afShort, afMaxShort } = parameters;
+        this.startValue = startValue;
+        this.offset = offset;
+        this.afInitLong = afInitLong;
+        this.afLong = afLong;
+        this.afMaxLong = afMaxLong;
+        this.afInitShort = afInitShort;
+        this.afShort = afShort;
+        this.afMaxShort = afMaxShort;
+    }
+    next(bar) {
+        this.count++;
+        if (this.count === 1) {
+            this.prevHigh1 = bar.high;
+            this.prevLow1 = bar.low;
+            this.value = null;
+            return null;
+        }
+        if (this.count === 2) {
+            const up = this.startValue !== 0 ? this.startValue > 0 : bar.close >= this.prevLow1;
+            this.trend = up ? 1 : -1;
+            if (up) {
+                this.sar = this.prevLow1;
+                this.ep = bar.high;
+                this.af = this.afInitLong;
+            }
+            else {
+                this.sar = this.prevHigh1;
+                this.ep = bar.low;
+                this.af = this.afInitShort;
+            }
+            this.prevHigh2 = this.prevHigh1;
+            this.prevLow2 = this.prevLow1;
+            this.prevHigh1 = bar.high;
+            this.prevLow1 = bar.low;
+            this.value = this.trend === 1 ? this.sar : -this.sar;
+            return this.value;
+        }
+        let sar = this.sar + this.af * (this.ep - this.sar);
+        if (this.trend === 1) {
+            sar = Math.min(sar, this.prevLow1, this.prevLow2);
+            if (bar.high > this.ep) {
+                this.ep = bar.high;
+                this.af = Math.min(this.af + this.afLong, this.afMaxLong);
+            }
+            if (bar.low < sar) {
+                this.trend = -1;
+                sar = this.ep + this.offset * (this.ep - this.sar);
+                this.ep = bar.low;
+                this.af = this.afInitShort;
+            }
+        }
+        else {
+            sar = Math.max(sar, this.prevHigh1, this.prevHigh2);
+            if (bar.low < this.ep) {
+                this.ep = bar.low;
+                this.af = Math.min(this.af + this.afShort, this.afMaxShort);
+            }
+            if (bar.high > sar) {
+                this.trend = 1;
+                sar = this.ep - this.offset * (this.sar - this.ep);
+                this.ep = bar.high;
+                this.af = this.afInitLong;
+            }
+        }
+        this.sar = sar;
+        this.prevHigh2 = this.prevHigh1;
+        this.prevLow2 = this.prevLow1;
+        this.prevHigh1 = bar.high;
+        this.prevLow1 = bar.low;
+        this.value = this.trend === 1 ? sar : -sar;
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('psarExt', {
+            startValue: this.startValue,
+            offset: this.offset,
+            afInitLong: this.afInitLong,
+            afLong: this.afLong,
+            afMaxLong: this.afMaxLong,
+            afInitShort: this.afInitShort,
+            afShort: this.afShort,
+            afMaxShort: this.afMaxShort,
+            count: this.count,
+            prevHigh1: this.prevHigh1,
+            prevHigh2: this.prevHigh2,
+            prevLow1: this.prevLow1,
+            prevLow2: this.prevLow2,
+            sar: this.sar,
+            ep: this.ep,
+            af: this.af,
+            trend: this.trend,
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'psarExt');
+        const x = new PsarExtStream({
+            startValue: state.number('startValue'),
+            offset: state.number('offset'),
+            afInitLong: state.number('afInitLong'),
+            afLong: state.number('afLong'),
+            afMaxLong: state.number('afMaxLong'),
+            afInitShort: state.number('afInitShort'),
+            afShort: state.number('afShort'),
+            afMaxShort: state.number('afMaxShort'),
+        });
+        Object.assign(x, {
+            count: state.number('count'),
+            prevHigh1: state.number('prevHigh1'),
+            prevHigh2: state.number('prevHigh2'),
+            prevLow1: state.number('prevLow1'),
+            prevLow2: state.number('prevLow2'),
+            sar: state.number('sar'),
+            ep: state.number('ep'),
+            af: state.number('af'),
+            trend: state.number('trend'),
+        });
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const psarExt = withBuiltinMetadata(makeIndicator((p) => {
+    const accelInitLong = requirePositive(p.accelInitLong ?? 0.02, 'psarExt', 'accelInitLong');
+    const accelLong = requirePositive(p.accelLong ?? 0.02, 'psarExt', 'accelLong');
+    const accelMaxLong = requirePositive(p.accelMaxLong ?? 0.2, 'psarExt', 'accelMaxLong');
+    const accelInitShort = requirePositive(p.accelInitShort ?? 0.02, 'psarExt', 'accelInitShort');
+    const accelShort = requirePositive(p.accelShort ?? 0.02, 'psarExt', 'accelShort');
+    const accelMaxShort = requirePositive(p.accelMaxShort ?? 0.2, 'psarExt', 'accelMaxShort');
+    requireAtMost(accelInitLong, accelMaxLong, 'psarExt', 'accelInitLong', 'accelMaxLong');
+    requireAtMost(accelLong, accelMaxLong, 'psarExt', 'accelLong', 'accelMaxLong');
+    requireAtMost(accelInitShort, accelMaxShort, 'psarExt', 'accelInitShort', 'accelMaxShort');
+    requireAtMost(accelShort, accelMaxShort, 'psarExt', 'accelShort', 'accelMaxShort');
+    return new PsarExtStream({
+        startValue: requireFinite(p.startValue ?? 0, 'psarExt', 'startValue'),
+        offset: requireFinite(p.offsetOnReverse ?? 0, 'psarExt', 'offsetOnReverse'),
+        afInitLong: accelInitLong,
+        afLong: accelLong,
+        afMaxLong: accelMaxLong,
+        afInitShort: accelInitShort,
+        afShort: accelShort,
+        afMaxShort: accelMaxShort,
+    });
+}, PsarExtStream.fromJSON, nanNum), builtinMetadata.psarExtMetadata);
+// ───────────────────────── Donchian trend ─────────────────────────
+/**
+ * Donchian breakout trend: +1 once the close makes a new `period`-bar high, −1 on a new `period`-bar
+ * low, holding the prior state between breakouts.
+ */
+class DonchianTrendStream {
+    period;
+    highs = [];
+    lows = [];
+    trend = 0;
+    value = null;
+    constructor(period) {
+        this.period = period;
+        requirePeriod(period, 'DonchianTrendStream', 'period', 1, 'bars');
+    }
+    next(bar) {
+        if (this.highs.length >= this.period) {
+            const upper = maxOf(this.highs);
+            const lower = minOf(this.lows);
+            if (bar.close >= upper)
+                this.trend = 1;
+            else if (bar.close <= lower)
+                this.trend = -1;
+        }
+        this.highs.push(bar.high);
+        this.lows.push(bar.low);
+        if (this.highs.length > this.period) {
+            this.highs.shift();
+            this.lows.shift();
+        }
+        if (this.highs.length < this.period || this.trend === 0) {
+            this.value = this.highs.length < this.period ? null : 0;
+            return this.value;
+        }
+        this.value = this.trend;
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('donchianTrend', {
+            period: this.period,
+            highs: [...this.highs],
+            lows: [...this.lows],
+            trend: this.trend,
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'donchianTrend');
+        const x = new DonchianTrendStream(state.lookback('period'));
+        Object.assign(x, { trend: state.number('trend') });
+        x.highs = state.numbers('highs');
+        x.lows = state.numbers('lows');
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const donchianTrend = withBuiltinMetadata(makeIndicator((p) => new DonchianTrendStream(requirePeriod(p.period ?? 20, 'donchianTrend', 'period', 1, 'bars')), DonchianTrendStream.fromJSON, nanNum), builtinMetadata.donchianTrendMetadata);
+class SupertrendStream {
+    atr;
+    previousClose = 0;
+    prevUpper = 0;
+    prevLower = 0;
+    prevST = 0;
+    started = false;
+    value = null;
+    mult;
+    constructor(parameters) {
+        requireStreamParameters('SupertrendStream.constructor#0', 'SupertrendStream', parameters);
+        const { period, mult } = parameters;
+        this.mult = mult;
+        this.atr = new AtrStream(period);
+    }
+    next(bar) {
+        const atr = this.atr.next(bar);
+        if (atr === null) {
+            this.previousClose = bar.close;
+            this.value = null;
+            return null;
+        }
+        const hl2 = (bar.high + bar.low) / 2;
+        const basicUpper = hl2 + this.mult * atr;
+        const basicLower = hl2 - this.mult * atr;
+        if (!this.started) {
+            this.prevUpper = basicUpper;
+            this.prevLower = basicLower;
+            // Seed LONG (the lower band), matching pandas-ta (`dir_ = [1] * m`) and TradingView: the first
+            // emitted bar reads `direction: +1` with the line under price. Seeding at the upper band
+            // instead made the opening bars unconditionally `-1` regardless of the data, an artifact of
+            // the seed rather than a signal. Both seeds agree from the first genuine flip onward.
+            this.prevST = basicLower;
+            this.started = true;
+        }
+        const finalUpper = basicUpper < this.prevUpper || this.previousClose > this.prevUpper
+            ? basicUpper
+            : this.prevUpper;
+        const finalLower = basicLower > this.prevLower || this.previousClose < this.prevLower
+            ? basicLower
+            : this.prevLower;
+        let st;
+        if (this.prevST === this.prevUpper) {
+            st = bar.close <= finalUpper ? finalUpper : finalLower;
+        }
+        else {
+            st = bar.close >= finalLower ? finalLower : finalUpper;
+        }
+        const direction = st === finalLower ? 1 : -1;
+        this.previousClose = bar.close;
+        this.prevUpper = finalUpper;
+        this.prevLower = finalLower;
+        this.prevST = st;
+        this.value = { supertrend: st, direction };
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('supertrend', {
+            atr: this.atr.toJSON(),
+            mult: this.mult,
+            previousClose: this.previousClose,
+            prevUpper: this.prevUpper,
+            prevLower: this.prevLower,
+            prevST: this.prevST,
+            started: this.started,
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'supertrend');
+        const x = new SupertrendStream({ period: 1, mult: state.number('mult') });
+        x.atr = AtrStream.fromJSON(state.child('atr'));
+        Object.assign(x, {
+            previousClose: state.number('previousClose'),
+            prevUpper: state.number('prevUpper'),
+            prevLower: state.number('prevLower'),
+            prevST: state.number('prevST'),
+            started: state.boolean('started'),
+        });
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const supertrend = withBuiltinMetadata(makeIndicator((p) => new SupertrendStream({
+    period: requirePeriod(p.period, 'supertrend', 'period', 1, 'bars'),
+    mult: requirePositive(p.multiplier ?? 3, 'supertrend', 'multiplier'),
+}), SupertrendStream.fromJSON, () => ({ supertrend: NaN, direction: NaN })), builtinMetadata.supertrendMetadata);
+class IchimokuStream {
+    highs = [];
+    lows = [];
+    value = null;
+    conv;
+    basePeriod;
+    spanBPeriod;
+    displacement;
+    /**
+     * History the components need = the LONGEST of the three lookbacks. Capping at `spanB` (the
+     * longest under the 9/26/52 defaults, but not in general) made `mid(n)` slice from a negative
+     * start for any `conversion`/`base` larger than it — `slice(-k)` returns the last k bars, so
+     * `{ conversion: 60, spanB: 52 }` silently computed the conversion line over the last 8 bars and
+     * reported a clean, wrong number.
+     */
+    capacity;
+    constructor(parameters) {
+        requireStreamParameters('IchimokuStream.constructor#0', 'IchimokuStream', parameters);
+        const { conv, basePeriod, spanBPeriod, displacement } = parameters;
+        this.conv = conv;
+        this.basePeriod = basePeriod;
+        this.spanBPeriod = spanBPeriod;
+        this.displacement = displacement;
+        this.capacity = Math.max(conv, basePeriod, spanBPeriod);
+    }
+    mid(n) {
+        const length = this.highs.length;
+        const h = maxOf(this.highs.slice(length - n));
+        const l = minOf(this.lows.slice(length - n));
+        return (h + l) / 2;
+    }
+    next(bar) {
+        this.highs.push(bar.high);
+        this.lows.push(bar.low);
+        if (this.highs.length > this.capacity) {
+            this.highs.shift();
+            this.lows.shift();
+        }
+        // Every component must have its full lookback before the record is real (warmup is the longest
+        // of them; with the 9/26/52 defaults that is `spanB`, exactly as before).
+        if (this.highs.length < this.capacity) {
+            this.value = null;
+            return null;
+        }
+        const tenkan = this.mid(this.conv);
+        const kijun = this.mid(this.basePeriod);
+        this.value = {
+            tenkan,
+            kijun,
+            senkouA: (tenkan + kijun) / 2,
+            senkouB: this.mid(this.spanBPeriod),
+            chikou: bar.close,
+            displacement: this.displacement,
+        };
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('ichimoku', {
+            conv: this.conv,
+            basePeriod: this.basePeriod,
+            spanBPeriod: this.spanBPeriod,
+            displacement: this.displacement,
+            highs: [...this.highs],
+            lows: [...this.lows],
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'ichimoku');
+        const x = new IchimokuStream({
+            conv: state.number('conv'),
+            basePeriod: state.lookback('basePeriod'),
+            spanBPeriod: state.lookback('spanBPeriod'),
+            displacement: state.number('displacement'),
+        });
+        x.highs = state.numbers('highs');
+        x.lows = state.numbers('lows');
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const ichimoku = withBuiltinMetadata(makeIndicator((p) => new IchimokuStream({
+    conv: requirePeriod(p.conversion ?? 9, 'ichimoku', 'conversion'),
+    basePeriod: requirePeriod(p.base ?? 26, 'ichimoku', 'base'),
+    spanBPeriod: requirePeriod(p.spanB ?? 52, 'ichimoku', 'spanB'),
+    displacement: requirePeriod(p.displacement ?? 26, 'ichimoku', 'displacement'),
+}), IchimokuStream.fromJSON, () => ({ tenkan: NaN, kijun: NaN, senkouA: NaN, senkouB: NaN, chikou: NaN, displacement: NaN })), builtinMetadata.ichimokuMetadata);
+class VortexStream {
+    period;
+    prevHigh = null;
+    prevLow = 0;
+    previousClose = 0;
+    vmP = [];
+    vmM = [];
+    trs = [];
+    sumP = 0;
+    sumM = 0;
+    sumTr = 0;
+    /** Non-finite samples inside the window — the interior-NaN gate (see `./nan-policy`). */
+    nanCount = 0;
+    value = null;
+    constructor(period) {
+        this.period = period;
+        requirePeriod(period, 'VortexStream', 'period', 1, 'bars');
+    }
+    next(bar) {
+        if (this.prevHigh === null) {
+            this.prevHigh = bar.high;
+            this.prevLow = bar.low;
+            this.previousClose = bar.close;
+            this.value = null;
+            return null;
+        }
+        const vmP = Math.abs(bar.high - this.prevLow);
+        const vmM = Math.abs(bar.low - this.prevHigh);
+        const tr = Math.max(bar.high - bar.low, Math.abs(bar.high - this.previousClose), Math.abs(bar.low - this.previousClose));
+        this.prevHigh = bar.high;
+        this.prevLow = bar.low;
+        this.previousClose = bar.close;
+        this.vmP.push(vmP);
+        this.vmM.push(vmM);
+        this.trs.push(tr);
+        // Interior-NaN policy: only finite samples enter the running sums, and a dirty window emits NaN.
+        if (isDirtySample(vmP) || isDirtySample(vmM) || isDirtySample(tr))
+            this.nanCount++;
+        else {
+            this.sumP += vmP;
+            this.sumM += vmM;
+            this.sumTr += tr;
+        }
+        if (this.vmP.length > this.period) {
+            const goneP = this.vmP.shift();
+            const goneM = this.vmM.shift();
+            const goneTr = this.trs.shift();
+            if (isDirtySample(goneP) || isDirtySample(goneM) || isDirtySample(goneTr))
+                this.nanCount--;
+            else {
+                this.sumP -= goneP;
+                this.sumM -= goneM;
+                this.sumTr -= goneTr;
+            }
+        }
+        if (this.vmP.length < this.period) {
+            this.value = null;
+            return null;
+        }
+        if (this.nanCount > 0) {
+            this.value = { viPlus: NaN, viMinus: NaN };
+            return this.value;
+        }
+        this.value = {
+            viPlus: this.sumTr === 0 ? 0 : this.sumP / this.sumTr,
+            viMinus: this.sumTr === 0 ? 0 : this.sumM / this.sumTr,
+        };
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('vortex', {
+            period: this.period,
+            prevHigh: this.prevHigh,
+            prevLow: this.prevLow,
+            previousClose: this.previousClose,
+            vmP: [...this.vmP],
+            vmM: [...this.vmM],
+            trs: [...this.trs],
+            sumP: this.sumP,
+            sumM: this.sumM,
+            sumTr: this.sumTr,
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'vortex');
+        const x = new VortexStream(state.lookback('period'));
+        Object.assign(x, {
+            prevHigh: state.numberOrNull('prevHigh'),
+            prevLow: state.number('prevLow'),
+            previousClose: state.number('previousClose'),
+            sumP: state.number('sumP'),
+            sumM: state.number('sumM'),
+            sumTr: state.number('sumTr'),
+        });
+        x.vmP = state.numbers('vmP');
+        x.vmM = state.numbers('vmM');
+        x.trs = state.numbers('trs');
+        // The gate is derived from the restored window, so no snapshot key (or version bump) is needed.
+        x.nanCount = dirtyRows(x.vmP, x.vmM, x.trs);
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const vortex = withBuiltinMetadata(makeIndicator((p) => new VortexStream(requirePeriod(p.period ?? 14, 'vortex')), VortexStream.fromJSON, () => ({ viPlus: NaN, viMinus: NaN })), builtinMetadata.vortexMetadata);
+class LinregStream {
+    period;
+    buf = [];
+    sumX;
+    sumX2;
+    denom;
+    value = null;
+    constructor(period) {
+        this.period = period;
+        requirePeriod(period, 'LinregStream');
+        const n = period;
+        this.sumX = (n * (n - 1)) / 2;
+        this.sumX2 = ((n - 1) * n * (2 * n - 1)) / 6;
+        this.denom = n * this.sumX2 - this.sumX * this.sumX;
+    }
+    next(value) {
+        this.buf.push(value);
+        if (this.buf.length > this.period)
+            this.buf.shift();
+        if (this.buf.length < this.period) {
+            this.value = null;
+            return null;
+        }
+        const n = this.period;
+        let sumY = 0;
+        let sumXY = 0;
+        for (let i = 0; i < n; i++) {
+            sumY += this.buf[i];
+            sumXY += i * this.buf[i];
+        }
+        const slope = this.denom === 0 ? 0 : (n * sumXY - this.sumX * sumY) / this.denom;
+        const intercept = (sumY - slope * this.sumX) / n;
+        this.value = {
+            value: intercept + slope * (n - 1),
+            slope,
+            intercept,
+            angle: (Math.atan(slope) * 180) / Math.PI,
+            forecast: intercept + slope * n,
+        };
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('linreg', { period: this.period, buf: [...this.buf], value: this.value });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'linreg');
+        const x = new LinregStream(state.lookback('period'));
+        x.buf = state.numbers('buf');
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const linreg = withBuiltinMetadata(makeIndicator((p) => new LinregStream(requirePeriod(p.period, 'linreg')), LinregStream.fromJSON, () => ({ value: NaN, slope: NaN, intercept: NaN, angle: NaN, forecast: NaN })), builtinMetadata.linregMetadata);
+export const linregSlope = withBuiltinMetadata(projected('linregSlope', (p) => new LinregStream(requirePeriod(p.period, 'linreg')), LinregStream.fromJSON, 'slope'), builtinMetadata.linregSlopeMetadata);
+export const linregIntercept = withBuiltinMetadata(projected('linregIntercept', (p) => new LinregStream(requirePeriod(p.period, 'linreg')), LinregStream.fromJSON, 'intercept'), builtinMetadata.linregInterceptMetadata);
+export const linregAngle = withBuiltinMetadata(projected('linregAngle', (p) => new LinregStream(requirePeriod(p.period, 'linreg')), LinregStream.fromJSON, 'angle'), builtinMetadata.linregAngleMetadata);
+export const tsf = withBuiltinMetadata(projected('tsf', (p) => new LinregStream(requirePeriod(p.period, 'linreg')), LinregStream.fromJSON, 'forecast'), builtinMetadata.tsfMetadata);
+class ChandelierStream {
+    atr;
+    highs = [];
+    lows = [];
+    value = null;
+    period;
+    mult;
+    constructor(parameters) {
+        requireStreamParameters('ChandelierStream.constructor#0', 'ChandelierStream', parameters);
+        const { period, mult } = parameters;
+        this.period = period;
+        this.mult = mult;
+        this.atr = new AtrStream(period);
+    }
+    next(bar) {
+        const atr = this.atr.next(bar);
+        this.highs.push(bar.high);
+        this.lows.push(bar.low);
+        if (this.highs.length > this.period) {
+            this.highs.shift();
+            this.lows.shift();
+        }
+        if (atr === null || this.highs.length < this.period) {
+            this.value = null;
+            return null;
+        }
+        const hh = maxOf(this.highs);
+        const ll = minOf(this.lows);
+        this.value = { long: hh - this.mult * atr, short: ll + this.mult * atr };
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('chandelier', {
+            period: this.period,
+            mult: this.mult,
+            atr: this.atr.toJSON(),
+            highs: [...this.highs],
+            lows: [...this.lows],
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'chandelier');
+        const x = new ChandelierStream({
+            period: state.lookback('period'),
+            mult: state.number('mult'),
+        });
+        x.atr = AtrStream.fromJSON(state.child('atr'));
+        x.highs = state.numbers('highs');
+        x.lows = state.numbers('lows');
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const chandelierExit = withBuiltinMetadata(makeIndicator((p) => new ChandelierStream({
+    period: requirePeriod(p.period, 'chandelierExit', 'period', 1, 'bars'),
+    mult: requirePositive(p.multiplier ?? 3, 'chandelierExit', 'multiplier'),
+}), ChandelierStream.fromJSON, () => ({ long: NaN, short: NaN })), builtinMetadata.chandelierExitMetadata);
+const ZIGZAG_KEYS = ['deviation'];
+/**
+ * ZigZag pivots: alternating swing highs and lows that each reverse price by at least `deviation`%.
+ * The last pivot is provisional — a larger move can still extend the final leg — so it is flagged via
+ * `provisional`. ZigZag repaints by nature; it is a batch utility, not a streaming indicator.
+ */
+export function zigzag(bars, parameters) {
+    requireArgumentArray('zigzag', 'bars', bars);
+    requireBars(bars, 'zigzag');
+    requireArgumentObject('zigzag', 'parameters', parameters);
+    // Law 12: an unknown param (a `devation` typo) teaches instead of being silently ignored.
+    ensureKnownKeys('zigzag', 'parameters', parameters, ZIGZAG_KEYS);
+    const deviation = requirePositive(parameters.deviation, 'zigzag', 'deviation', 'bars');
+    const report = (pivots, provisional) => ({
+        pivots,
+        provisional,
+        assumptions: { conventionsVersion: CONVENTIONS_VERSION, deviation },
+        diagnostics: { warnings: [] },
+    });
+    const pivots = [];
+    if (bars.length === 0)
+        return report(pivots, false);
+    const thr = deviation / 100;
+    let dir = 0; // 0 unknown, 1 seeking a swing high, −1 seeking a swing low
+    let extremeIdx = 0;
+    let extremeHigh = bars[0].high;
+    let extremeLow = bars[0].low;
+    let extremeHighIdx = 0;
+    let extremeLowIdx = 0;
+    for (let i = 1; i < bars.length; i++) {
+        const b = bars[i];
+        if (dir === 0) {
+            // anchor running high & low from bar 0; the first confirmed pivot is whichever extreme
+            // price retraces away from by at least the threshold
+            if (b.high >= extremeHigh) {
+                extremeHigh = b.high;
+                extremeHighIdx = i;
+            }
+            if (b.low <= extremeLow) {
+                extremeLow = b.low;
+                extremeLowIdx = i;
+            }
+            if (b.low <= extremeHigh * (1 - thr)) {
+                pivots.push({ index: extremeHighIdx, price: extremeHigh, kind: 'high' });
+                dir = -1;
+                extremeLow = b.low;
+                extremeIdx = i;
+            }
+            else if (b.high >= extremeLow * (1 + thr)) {
+                pivots.push({ index: extremeLowIdx, price: extremeLow, kind: 'low' });
+                dir = 1;
+                extremeHigh = b.high;
+                extremeIdx = i;
+            }
+        }
+        else if (dir === 1) {
+            // seeking a swing high: track the running high, confirm it on a downward reversal
+            if (b.high >= extremeHigh) {
+                extremeHigh = b.high;
+                extremeIdx = i;
+            }
+            if (b.low <= extremeHigh * (1 - thr)) {
+                pivots.push({ index: extremeIdx, price: extremeHigh, kind: 'high' });
+                dir = -1;
+                extremeLow = b.low;
+                extremeIdx = i;
+            }
+        }
+        else {
+            // seeking a swing low: track the running low, confirm it on an upward reversal
+            if (b.low <= extremeLow) {
+                extremeLow = b.low;
+                extremeIdx = i;
+            }
+            if (b.high >= extremeLow * (1 + thr)) {
+                pivots.push({ index: extremeIdx, price: extremeLow, kind: 'low' });
+                dir = 1;
+                extremeHigh = b.high;
+                extremeIdx = i;
+            }
+        }
+    }
+    // close out with the provisional final extreme
+    let provisional = false;
+    if (dir === 1) {
+        pivots.push({ index: extremeIdx, price: extremeHigh, kind: 'high' });
+        provisional = true;
+    }
+    else if (dir === -1) {
+        pivots.push({ index: extremeIdx, price: extremeLow, kind: 'low' });
+        provisional = true;
+    }
+    return report(pivots, provisional);
+}
+export { DmiStream, AdxrStream, AroonStream, PsarStream, PsarExtStream, DonchianTrendStream, SupertrendStream, IchimokuStream, VortexStream, LinregStream, ChandelierStream, };
+export * from './trend-ext.js';
+//# sourceMappingURL=trend.js.map