@invinite-org/chartlang-runtime 1.0.2

package/dist/ta/kst.js

@@ -0,0 +1,139 @@
+// Copyright (c) 2026 Invinite. Licensed under the MIT License.
+// See the LICENSE file in the repo root for full license text.
+//
+// Ported from invinite/src/components/trading-chart/indicators/kst.ts
+//   (commit 078f41fe2569d659d5aba726da8bcb5d3e2ced02, © Invinite).
+// Re-licensed MIT for chartlang. See PLAN.md §3.1 for the
+// provenance contract; the math is the reference, the code style is not.
+// Structural choices (callsite-id slot, Series<T> proxy, replaceHead
+// mode) follow chartlang's primitive shape — NOT invinite's
+// IndicatorPlugin shape. Composition: four `ta.sma` sub-slots (one per
+// smoothed ROC) + one `ta.sma` sub-slot for the signal line. The four
+// percentage ROCs are computed inline against the parent's source
+// ring (same convention as `coppock.ts` — `ta.change` emits absolute
+// deltas, while KST needs percentage rate-of-change).
+import { Float64RingBuffer } from "../ringBuffer.js";
+import { ACTIVE_RUNTIME_CONTEXT } from "../runtimeContext.js";
+import { makeSeriesView } from "../seriesView.js";
+import { sma } from "./sma.js";
+import { readSourceValue } from "./lib/sourceValue.js";
+const DEFAULT_ROC1_LENGTH = 10;
+const DEFAULT_ROC2_LENGTH = 15;
+const DEFAULT_ROC3_LENGTH = 20;
+const DEFAULT_ROC4_LENGTH = 30;
+const DEFAULT_ROC1_SMOOTH = 10;
+const DEFAULT_ROC2_SMOOTH = 10;
+const DEFAULT_ROC3_SMOOTH = 10;
+const DEFAULT_ROC4_SMOOTH = 15;
+const DEFAULT_SIGNAL_LENGTH = 9;
+function getCtx() {
+    const ctx = ACTIVE_RUNTIME_CONTEXT.current;
+    if (ctx === null) {
+        throw new Error("ta.kst called outside an active script step");
+    }
+    return ctx;
+}
+function pctRoc(current, lookback) {
+    if (!Number.isFinite(lookback) || lookback === 0 || !Number.isFinite(current)) {
+        return Number.NaN;
+    }
+    return (100 * (current - lookback)) / lookback;
+}
+function rocFromWindow(window, src, length) {
+    if (window.length <= length)
+        return Number.NaN;
+    return pctRoc(src, window.at(length));
+}
+/**
+ * Know Sure Thing (Martin Pring, 1992). Weighted sum of four SMA-
+ * smoothed percentage rate-of-change series plus an SMA signal line.
+ * Defaults `(10, 15, 20, 30, 10, 10, 10, 15, 9)` match Pring's
+ * canonical settings. Composes 4 `ta.sma` sub-slots
+ * (`${slotId}/r1Sma` .. `${slotId}/r4Sma`) for the smoothing layer
+ * plus one `ta.sma` sub-slot (`${slotId}/signalSma`) for the signal
+ * line. The percentage-ROC math is inline (mirrors `ta.coppock` —
+ * `ta.change` emits absolute deltas, not percentages).
+ *
+ * The user-facing `signal` Series IS the signalSma sub-slot's own
+ * Series view (no extra output buffer on the parent slot). The
+ * `kst` Series wraps the parent's own `kstBuf` ring. Result identity
+ * is captured on the first call and returned by reference thereafter.
+ *
+ * @formula  rN[t] = sma(pctRoc(source[t], source[t − rocNLength]), rocNSmooth) for N in 1..4 ;
+ *           kst[t] = r1 + 2·r2 + 3·r3 + 4·r4 ; NaN if any rN NaN ;
+ *           signal = sma(kst, signalLength)
+ * @warmup   max_N(rocNLength + rocNSmooth) + signalLength − 2
+ * @since 0.2
+ * @stable
+ *
+ * @example
+ *     // import { ta } from "@invinite-org/chartlang-runtime";
+ *     // const k = ta.kst("slot", bar.close);
+ *     // plot(k.kst); plot(k.signal);
+ */
+export function kst(slotId, source, opts) {
+    const ctx = getCtx();
+    const roc1Length = opts?.roc1Length ?? DEFAULT_ROC1_LENGTH;
+    const roc2Length = opts?.roc2Length ?? DEFAULT_ROC2_LENGTH;
+    const roc3Length = opts?.roc3Length ?? DEFAULT_ROC3_LENGTH;
+    const roc4Length = opts?.roc4Length ?? DEFAULT_ROC4_LENGTH;
+    const roc1Smooth = opts?.roc1Smooth ?? DEFAULT_ROC1_SMOOTH;
+    const roc2Smooth = opts?.roc2Smooth ?? DEFAULT_ROC2_SMOOTH;
+    const roc3Smooth = opts?.roc3Smooth ?? DEFAULT_ROC3_SMOOTH;
+    const roc4Smooth = opts?.roc4Smooth ?? DEFAULT_ROC4_SMOOTH;
+    const signalLength = opts?.signalLength ?? DEFAULT_SIGNAL_LENGTH;
+    const src = readSourceValue(source);
+    let slot = ctx.stream.taSlots.get(slotId);
+    if (slot === undefined) {
+        const capacity = ctx.stream.ohlcv.close.capacity;
+        const kstBuf = new Float64RingBuffer(capacity);
+        const lookbackCap = Math.max(roc1Length, roc2Length, roc3Length, roc4Length) + 1;
+        slot = {
+            result: null,
+            kstBuf,
+            kstSeries: makeSeriesView(kstBuf),
+            roc1Length,
+            roc2Length,
+            roc3Length,
+            roc4Length,
+            sourceWindow: new Float64RingBuffer(lookbackCap),
+        };
+        ctx.stream.taSlots.set(slotId, slot);
+    }
+    if (ctx.isTick) {
+        slot.sourceWindow.replaceHead(src);
+    }
+    else {
+        slot.sourceWindow.append(src);
+    }
+    const roc1 = rocFromWindow(slot.sourceWindow, src, slot.roc1Length);
+    const roc2 = rocFromWindow(slot.sourceWindow, src, slot.roc2Length);
+    const roc3 = rocFromWindow(slot.sourceWindow, src, slot.roc3Length);
+    const roc4 = rocFromWindow(slot.sourceWindow, src, slot.roc4Length);
+    const r1Series = sma(`${slotId}/r1Sma`, roc1, roc1Smooth);
+    const r2Series = sma(`${slotId}/r2Sma`, roc2, roc2Smooth);
+    const r3Series = sma(`${slotId}/r3Sma`, roc3, roc3Smooth);
+    const r4Series = sma(`${slotId}/r4Sma`, roc4, roc4Smooth);
+    const r1 = r1Series.current;
+    const r2 = r2Series.current;
+    const r3 = r3Series.current;
+    const r4 = r4Series.current;
+    const kstValue = Number.isFinite(r1) && Number.isFinite(r2) && Number.isFinite(r3) && Number.isFinite(r4)
+        ? r1 + 2 * r2 + 3 * r3 + 4 * r4
+        : Number.NaN;
+    if (ctx.isTick) {
+        slot.kstBuf.replaceHead(kstValue);
+    }
+    else {
+        slot.kstBuf.append(kstValue);
+    }
+    const signalSeries = sma(`${slotId}/signalSma`, kstValue, signalLength);
+    if (slot.result === null) {
+        slot.result = Object.freeze({
+            kst: slot.kstSeries,
+            signal: signalSeries,
+        });
+    }
+    return slot.result;
+}
+//# sourceMappingURL=kst.js.map

package/dist/ta/kst.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kst.js","sourceRoot":"","sources":["../../src/ta/kst.ts"],"names":[],"mappings":"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"}

package/dist/ta/lib/adxFromDi.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Wilder ADX from a pre-computed `+DI` / `-DI` pair. Computes
+ * `DX = 100 * |+DI - -DI| / (+DI + -DI)` per bar (falls back to `0`
+ * when both DIs are zero), then Wilder-smooths `DX` over `length`
+ * via the shared `wilderStep`.
+ *
+ * Warmup: `2 * length - 1`. Slots `[0, length - 1]` carry the DI
+ * warmup (callers feed NaN there); slots `[length, 2*length - 2]`
+ * accumulate the ADX seed sum; `out[2*length - 1]` is the first
+ * defined ADX value (mean of the first `length` DX samples).
+ *
+ * Mismatched input lengths or `length <= 0` yields an all-NaN
+ * buffer. Any non-finite DI in the seed window leaves the output
+ * NaN past the warmup — the Wilder recurrence cannot resume past
+ * a NaN seed.
+ *
+ * @formula  dx[i]  = 100 * |+DI - -DI| / (+DI + -DI) ;
+ *           seed   = mean(dx[length .. 2*length - 1]) ;
+ *           out[i] = wilderStep(out[i-1], dx[i], length) ;
+ *           outputs are clamped to [0, 100]
+ * @warmup   2 * length - 1
+ * @since 0.2
+ * @stable
+ * @example
+ *     // import { adxFromDi } from "./adxFromDi";
+ *     // const adx = adxFromDi(plusDi, minusDi, 14);
+ */
+export declare function adxFromDi(plusDi: Float64Array, minusDi: Float64Array, length: number): Float64Array;
+//# sourceMappingURL=adxFromDi.d.ts.map

package/dist/ta/lib/adxFromDi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adxFromDi.d.ts","sourceRoot":"","sources":["../../../src/ta/lib/adxFromDi.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,SAAS,CACrB,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,MAAM,GACf,YAAY,CAoCd"}

package/dist/ta/lib/adxFromDi.js

@@ -0,0 +1,72 @@
+// Copyright (c) 2026 Invinite. Licensed under the MIT License.
+// See the LICENSE file in the repo root for full license text.
+//
+// Ported from invinite/src/components/trading-chart/indicators/lib/adx-from-di.ts
+//   (commit 078f41fe2569d659d5aba726da8bcb5d3e2ced02, © Invinite).
+// Re-licensed MIT for chartlang. See PLAN.md §3.1 for the
+// provenance contract; the math is the reference, the code style is not.
+import { wilderStep } from "./wilderSmoothing.js";
+/**
+ * Wilder ADX from a pre-computed `+DI` / `-DI` pair. Computes
+ * `DX = 100 * |+DI - -DI| / (+DI + -DI)` per bar (falls back to `0`
+ * when both DIs are zero), then Wilder-smooths `DX` over `length`
+ * via the shared `wilderStep`.
+ *
+ * Warmup: `2 * length - 1`. Slots `[0, length - 1]` carry the DI
+ * warmup (callers feed NaN there); slots `[length, 2*length - 2]`
+ * accumulate the ADX seed sum; `out[2*length - 1]` is the first
+ * defined ADX value (mean of the first `length` DX samples).
+ *
+ * Mismatched input lengths or `length <= 0` yields an all-NaN
+ * buffer. Any non-finite DI in the seed window leaves the output
+ * NaN past the warmup — the Wilder recurrence cannot resume past
+ * a NaN seed.
+ *
+ * @formula  dx[i]  = 100 * |+DI - -DI| / (+DI + -DI) ;
+ *           seed   = mean(dx[length .. 2*length - 1]) ;
+ *           out[i] = wilderStep(out[i-1], dx[i], length) ;
+ *           outputs are clamped to [0, 100]
+ * @warmup   2 * length - 1
+ * @since 0.2
+ * @stable
+ * @example
+ *     // import { adxFromDi } from "./adxFromDi";
+ *     // const adx = adxFromDi(plusDi, minusDi, 14);
+ */
+export function adxFromDi(plusDi, minusDi, length) {
+    const n = plusDi.length;
+    const out = new Float64Array(n);
+    out.fill(Number.NaN);
+    if (length <= 0 || n === 0 || minusDi.length !== n || n < 2 * length) {
+        return out;
+    }
+    const dx = new Float64Array(n);
+    dx.fill(Number.NaN);
+    for (let i = 0; i < n; i += 1) {
+        const p = plusDi[i];
+        const m = minusDi[i];
+        if (!Number.isFinite(p) || !Number.isFinite(m))
+            continue;
+        const sum = p + m;
+        dx[i] = sum === 0 ? 0 : (100 * Math.abs(p - m)) / sum;
+    }
+    const firstSeedIdx = 2 * length - 1;
+    let seedSum = 0;
+    for (let i = length; i <= firstSeedIdx; i += 1) {
+        const v = dx[i];
+        if (!Number.isFinite(v))
+            return out;
+        seedSum += v;
+    }
+    // dx is bounded by [0, 100] in exact arithmetic, but the seed mean
+    // and the Wilder recurrence can overshoot 100 by a few ulps — clamp.
+    out[firstSeedIdx] = Math.min(100, seedSum / length);
+    for (let i = firstSeedIdx + 1; i < n; i += 1) {
+        const v = dx[i];
+        if (!Number.isFinite(v))
+            return out;
+        out[i] = Math.min(100, wilderStep(out[i - 1], v, length));
+    }
+    return out;
+}
+//# sourceMappingURL=adxFromDi.js.map

package/dist/ta/lib/adxFromDi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adxFromDi.js","sourceRoot":"","sources":["../../../src/ta/lib/adxFromDi.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAC/D,EAAE;AACF,kFAAkF;AAClF,mEAAmE;AACnE,0DAA0D;AAC1D,yEAAyE;AAEzE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,SAAS,CACrB,MAAoB,EACpB,OAAqB,EACrB,MAAc;IAEd,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC;IACxB,MAAM,GAAG,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC;IAChC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACrB,IAAI,MAAM,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,EAAE,CAAC;QACnE,OAAO,GAAG,CAAC;IACf,CAAC;IAED,MAAM,EAAE,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC;IAC/B,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACpB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QAC5B,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QACpB,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;QACrB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;YAAE,SAAS;QACzD,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC;QAClB,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC;IAC1D,CAAC;IAED,MAAM,YAAY,GAAG,CAAC,GAAG,MAAM,GAAG,CAAC,CAAC;IACpC,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,KAAK,IAAI,CAAC,GAAG,MAAM,EAAE,CAAC,IAAI,YAAY,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QAC7C,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QAChB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;YAAE,OAAO,GAAG,CAAC;QACpC,OAAO,IAAI,CAAC,CAAC;IACjB,CAAC;IACD,mEAAmE;IACnE,qEAAqE;IACrE,GAAG,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAAC,CAAC;IAEpD,KAAK,IAAI,CAAC,GAAG,YAAY,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QAC3C,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QAChB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;YAAE,OAAO,GAAG,CAAC;QACpC,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;IAC9D,CAAC;IAED,OAAO,GAAG,CAAC;AACf,CAAC"}

package/dist/ta/lib/applyOffset.d.ts

@@ -0,0 +1,19 @@
+/**
+ * TradingView-parity bar-shift helper. `offset === 0` returns the
+ * same array reference so callers can keep a no-shift call in the
+ * fast path without an allocation. Positive `offset` shifts forward
+ * in time (output[i] = values[i − offset], NaN where out of range);
+ * negative shifts backward.
+ *
+ * Phase 1 always passes `offset = 0` — the helper exists so Phase 4's
+ * universal `opts.offset` (§9.1) is a zero-line wire-up.
+ *
+ * @formula  out[i] = values[i − offset] (NaN when i − offset ∉ [0, n))
+ * @since 0.1
+ * @stable
+ * @example
+ *     // import { applyOffsetToSeries } from "./applyOffset";
+ *     // const shifted = applyOffsetToSeries(values, 2);
+ */
+export declare function applyOffsetToSeries(values: Float64Array, offset: number): Float64Array;
+//# sourceMappingURL=applyOffset.d.ts.map

package/dist/ta/lib/applyOffset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"applyOffset.d.ts","sourceRoot":"","sources":["../../../src/ta/lib/applyOffset.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,YAAY,CAUtF"}

package/dist/ta/lib/applyOffset.js

@@ -0,0 +1,38 @@
+// Copyright (c) 2026 Invinite. Licensed under the MIT License.
+// See the LICENSE file in the repo root for full license text.
+//
+// Ported from invinite/src/components/trading-chart/indicators/lib/apply-offset.ts
+//   (commit d2d1043c1b039f66d2f3674526d303d31cf2f1e0, © Invinite).
+// Re-licensed MIT for chartlang. See PLAN.md §3.1 for the
+// provenance contract; the math is the reference, the code style is not.
+/**
+ * TradingView-parity bar-shift helper. `offset === 0` returns the
+ * same array reference so callers can keep a no-shift call in the
+ * fast path without an allocation. Positive `offset` shifts forward
+ * in time (output[i] = values[i − offset], NaN where out of range);
+ * negative shifts backward.
+ *
+ * Phase 1 always passes `offset = 0` — the helper exists so Phase 4's
+ * universal `opts.offset` (§9.1) is a zero-line wire-up.
+ *
+ * @formula  out[i] = values[i − offset] (NaN when i − offset ∉ [0, n))
+ * @since 0.1
+ * @stable
+ * @example
+ *     // import { applyOffsetToSeries } from "./applyOffset";
+ *     // const shifted = applyOffsetToSeries(values, 2);
+ */
+export function applyOffsetToSeries(values, offset) {
+    if (offset === 0 || values.length === 0)
+        return values;
+    const n = values.length;
+    const out = new Float64Array(n);
+    out.fill(Number.NaN);
+    for (let i = 0; i < n; i += 1) {
+        const src = i - offset;
+        if (src >= 0 && src < n)
+            out[i] = values[src];
+    }
+    return out;
+}
+//# sourceMappingURL=applyOffset.js.map

package/dist/ta/lib/applyOffset.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"applyOffset.js","sourceRoot":"","sources":["../../../src/ta/lib/applyOffset.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAC/D,EAAE;AACF,mFAAmF;AACnF,mEAAmE;AACnE,0DAA0D;AAC1D,yEAAyE;AAEzE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAoB,EAAE,MAAc;IACpE,IAAI,MAAM,KAAK,CAAC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,MAAM,CAAC;IACvD,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC;IACxB,MAAM,GAAG,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC;IAChC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACrB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QAC5B,MAAM,GAAG,GAAG,CAAC,GAAG,MAAM,CAAC;QACvB,IAAI,GAAG,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC;YAAE,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IAClD,CAAC;IACD,OAAO,GAAG,CAAC;AACf,CAAC"}

package/dist/ta/lib/computeMa.d.ts

@@ -0,0 +1,25 @@
+import type { MaType } from "./maTypes.js";
+/**
+ * Volume-aware MA dispatcher over a `Float64Array` input. Routes
+ * `"vwma"` through {@link vwmaFloat64} (requires a parallel volume
+ * array); every other kind routes through {@link computeMaOfFloat64}.
+ * Mirrors invinite's `computeMaSeries`, but operates on flat
+ * `Float64Array` source + volume instead of `ChartCandle[]` so the
+ * helper stays decoupled from the bar-shape.
+ *
+ * Throws a `TypeError` with `code = "ta-lib-vwma-requires-volume"` if
+ * `kind === "vwma"` and `volume === null` — calling VWMA without a
+ * volume stream is a programmer error, not a runtime data condition.
+ * For non-VWMA kinds, `volume` is ignored.
+ *
+ * @formula  kind === "vwma" → vwmaFloat64(source, volume, length) ;
+ *           otherwise         → computeMaOfFloat64(kind, source, length)
+ * @since 0.2
+ * @stable
+ * @example
+ *     // import { computeMa } from "./computeMa";
+ *     // const ma = computeMa("vwma", close, volume, 20);
+ *     // const sma20 = computeMa("sma", close, null, 20);
+ */
+export declare function computeMa(kind: MaType, source: Float64Array, length: number, volume: Float64Array | null): Float64Array;
+//# sourceMappingURL=computeMa.d.ts.map

package/dist/ta/lib/computeMa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeMa.d.ts","sourceRoot":"","sources":["../../../src/ta/lib/computeMa.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAU3C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,CACrB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,YAAY,GAAG,IAAI,GAC5B,YAAY,CAYd"}

package/dist/ta/lib/computeMa.js

@@ -0,0 +1,43 @@
+// Copyright (c) 2026 Invinite. Licensed under the MIT License.
+// See the LICENSE file in the repo root for full license text.
+//
+// Ported from invinite/src/components/trading-chart/indicators/lib/compute-ma.ts
+//   (commit 078f41fe2569d659d5aba726da8bcb5d3e2ced02, © Invinite).
+// Re-licensed MIT for chartlang. See PLAN.md §3.1 for the
+// provenance contract; the math is the reference, the code style is not.
+import { computeMaOfFloat64 } from "./computeMaOfFloat64.js";
+import { vwmaFloat64 } from "./vwmaFloat64.js";
+/**
+ * Volume-aware MA dispatcher over a `Float64Array` input. Routes
+ * `"vwma"` through {@link vwmaFloat64} (requires a parallel volume
+ * array); every other kind routes through {@link computeMaOfFloat64}.
+ * Mirrors invinite's `computeMaSeries`, but operates on flat
+ * `Float64Array` source + volume instead of `ChartCandle[]` so the
+ * helper stays decoupled from the bar-shape.
+ *
+ * Throws a `TypeError` with `code = "ta-lib-vwma-requires-volume"` if
+ * `kind === "vwma"` and `volume === null` — calling VWMA without a
+ * volume stream is a programmer error, not a runtime data condition.
+ * For non-VWMA kinds, `volume` is ignored.
+ *
+ * @formula  kind === "vwma" → vwmaFloat64(source, volume, length) ;
+ *           otherwise         → computeMaOfFloat64(kind, source, length)
+ * @since 0.2
+ * @stable
+ * @example
+ *     // import { computeMa } from "./computeMa";
+ *     // const ma = computeMa("vwma", close, volume, 20);
+ *     // const sma20 = computeMa("sma", close, null, 20);
+ */
+export function computeMa(kind, source, length, volume) {
+    if (kind === "vwma") {
+        if (volume === null) {
+            const err = new TypeError("computeMa: vwma requires a non-null volume array");
+            err.code = "ta-lib-vwma-requires-volume";
+            throw err;
+        }
+        return vwmaFloat64(source, volume, length);
+    }
+    return computeMaOfFloat64(kind, source, length);
+}
+//# sourceMappingURL=computeMa.js.map

package/dist/ta/lib/computeMa.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeMa.js","sourceRoot":"","sources":["../../../src/ta/lib/computeMa.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAC/D,EAAE;AACF,iFAAiF;AACjF,mEAAmE;AACnE,0DAA0D;AAC1D,yEAAyE;AAEzE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAE7D,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAS/C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,SAAS,CACrB,IAAY,EACZ,MAAoB,EACpB,MAAc,EACd,MAA2B;IAE3B,IAAI,IAAI,KAAK,MAAM,EAAE,CAAC;QAClB,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;YAClB,MAAM,GAAG,GAAG,IAAI,SAAS,CACrB,kDAAkD,CAC1B,CAAC;YAC7B,GAAG,CAAC,IAAI,GAAG,6BAA6B,CAAC;YACzC,MAAM,GAAG,CAAC;QACd,CAAC;QACD,OAAO,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/C,CAAC;IACD,OAAO,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AACpD,CAAC"}

package/dist/ta/lib/computeMaOfFloat64.d.ts

@@ -0,0 +1,24 @@
+import type { MaTypeNoVolume } from "./maTypes.js";
+/**
+ * Chained-MA dispatcher over a `Float64Array` input. Routes by
+ * `MaTypeNoVolume` to the matching per-kind core — never re-implements
+ * the math. Consumed by chained MAs (MACD signal-of-MACD, PPO /
+ * PVO signal-of-oscillator, RSI smoothing-MA over RSI) and by every
+ * primitive that exposes an `maType` opt over a derived Float64 source
+ * (BB middle override, Keltner middle, Envelope middle, Chop
+ * denominator, Donchian midpoint).
+ *
+ * `"vwma"` is excluded at the type level: VWMA needs a parallel
+ * volume array and derived Float64 chain inputs carry no matching
+ * volume stream. Volume-aware callers route through {@link computeMa}.
+ *
+ * @formula  kind switch over MaTypeNoVolume → delegates to
+ *           {sma,ema,wma,smma}Float64(source, length)
+ * @since 0.2
+ * @stable
+ * @example
+ *     // import { computeMaOfFloat64 } from "./computeMaOfFloat64";
+ *     // const sig = computeMaOfFloat64("ema", macdLine, 9);
+ */
+export declare function computeMaOfFloat64(kind: MaTypeNoVolume, source: Float64Array, length: number): Float64Array;
+//# sourceMappingURL=computeMaOfFloat64.d.ts.map

package/dist/ta/lib/computeMaOfFloat64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeMaOfFloat64.d.ts","sourceRoot":"","sources":["../../../src/ta/lib/computeMaOfFloat64.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAKnD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,kBAAkB,CAC9B,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,MAAM,GACf,YAAY,CAWd"}

package/dist/ta/lib/computeMaOfFloat64.js

@@ -0,0 +1,45 @@
+// Copyright (c) 2026 Invinite. Licensed under the MIT License.
+// See the LICENSE file in the repo root for full license text.
+//
+// Ported from invinite/src/components/trading-chart/indicators/lib/compute-ma-of-float64.ts
+//   (commit 078f41fe2569d659d5aba726da8bcb5d3e2ced02, © Invinite).
+// Re-licensed MIT for chartlang. See PLAN.md §3.1 for the
+// provenance contract; the math is the reference, the code style is not.
+import { computeEmaOfFloat64 } from "./emaFloat64.js";
+import { computeSmaOfFloat64 } from "./smaFloat64.js";
+import { smmaFloat64 } from "./smmaFloat64.js";
+import { wmaFloat64 } from "./wmaFloat64.js";
+/**
+ * Chained-MA dispatcher over a `Float64Array` input. Routes by
+ * `MaTypeNoVolume` to the matching per-kind core — never re-implements
+ * the math. Consumed by chained MAs (MACD signal-of-MACD, PPO /
+ * PVO signal-of-oscillator, RSI smoothing-MA over RSI) and by every
+ * primitive that exposes an `maType` opt over a derived Float64 source
+ * (BB middle override, Keltner middle, Envelope middle, Chop
+ * denominator, Donchian midpoint).
+ *
+ * `"vwma"` is excluded at the type level: VWMA needs a parallel
+ * volume array and derived Float64 chain inputs carry no matching
+ * volume stream. Volume-aware callers route through {@link computeMa}.
+ *
+ * @formula  kind switch over MaTypeNoVolume → delegates to
+ *           {sma,ema,wma,smma}Float64(source, length)
+ * @since 0.2
+ * @stable
+ * @example
+ *     // import { computeMaOfFloat64 } from "./computeMaOfFloat64";
+ *     // const sig = computeMaOfFloat64("ema", macdLine, 9);
+ */
+export function computeMaOfFloat64(kind, source, length) {
+    switch (kind) {
+        case "sma":
+            return computeSmaOfFloat64(source, length);
+        case "ema":
+            return computeEmaOfFloat64(source, length);
+        case "wma":
+            return wmaFloat64(source, length);
+        case "smma":
+            return smmaFloat64(source, length);
+    }
+}
+//# sourceMappingURL=computeMaOfFloat64.js.map

package/dist/ta/lib/computeMaOfFloat64.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeMaOfFloat64.js","sourceRoot":"","sources":["../../../src/ta/lib/computeMaOfFloat64.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAC/D,EAAE;AACF,4FAA4F;AAC5F,mEAAmE;AACnE,0DAA0D;AAC1D,yEAAyE;AAEzE,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAEtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,kBAAkB,CAC9B,IAAoB,EACpB,MAAoB,EACpB,MAAc;IAEd,QAAQ,IAAI,EAAE,CAAC;QACX,KAAK,KAAK;YACN,OAAO,mBAAmB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC/C,KAAK,KAAK;YACN,OAAO,mBAAmB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC/C,KAAK,KAAK;YACN,OAAO,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACtC,KAAK,MAAM;YACP,OAAO,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3C,CAAC;AACL,CAAC"}

package/dist/ta/lib/directionalState.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Incremental Wilder-directional state shared by `ta.dmi` and
+ * `ta.adx`. Tracks the seed-window accumulators + the smoothed
+ * running values, plus the "previous-previous" snapshots the tick
+ * replay needs to recompute the head against the prior closed bar.
+ *
+ * @formula  N/A — record type for {@link initDirectionalState}
+ * @since 0.2
+ * @stable
+ * @example
+ *     // const s: DirectionalState = initDirectionalState(14);
+ */
+export type DirectionalState = {
+    readonly length: number;
+    /** Number of CLOSED bars seen so far (counts every close-side step). */
+    barCount: number;
+    prevHigh: number;
+    prevLow: number;
+    prevClose: number;
+    /** `prevHigh` / `prevLow` / `prevClose` as of the bar before the
+     * current bar — frozen by the prior close-side advance so tick
+     * replay can recompute against the previous closed state. */
+    prevPrevHigh: number;
+    prevPrevLow: number;
+    prevPrevClose: number;
+    seedPlusDm: number;
+    seedMinusDm: number;
+    seedTr: number;
+    smoothedPlusDm: number;
+    smoothedMinusDm: number;
+    smoothedTr: number;
+    /** Smoothed state captured at the prior close — used by tick replay. */
+    prevClosedSmoothedPlusDm: number;
+    prevClosedSmoothedMinusDm: number;
+    prevClosedSmoothedTr: number;
+    plusDi: number;
+    minusDi: number;
+};
+/**
+ * Allocate a fresh directional-state record. Shared by `ta.dmi` and
+ * `ta.adx`. Exported so the ADX primitive can fold onto the same
+ * recurrence without duplicating the field set.
+ *
+ * @formula  N/A — state constructor (zero / NaN initializers)
+ * @since 0.2
+ * @stable
+ * @example
+ *     // const s = initDirectionalState(14);
+ */
+export declare function initDirectionalState(length: number): DirectionalState;
+/**
+ * Fold the new closed bar into the directional state. Mutates
+ * `dirState` in place and returns the freshly computed `+DI` /
+ * `-DI` pair (NaN until the seed window completes). Shared by
+ * `ta.dmi` and `ta.adx`. The returned pair is also written back
+ * to `dirState.plusDi` / `dirState.minusDi` for the consumer's
+ * downstream DX computation.
+ *
+ * @formula  See {@link wilderDirectional} (lib/) for the per-step
+ *           +DM / -DM / TR formulas; this routine inlines the same
+ *           recurrence in a single-pass mutable form.
+ * @warmup   length + 1 (first defined DI at barCount === length + 1)
+ * @since 0.2
+ * @stable
+ * @example
+ *     // const { plusDi, minusDi } = advanceDirectionalClose(s, h, l, c);
+ */
+export declare function advanceDirectionalClose(dirState: DirectionalState, high: number, low: number, close: number): {
+    plusDi: number;
+    minusDi: number;
+};
+/**
+ * Replay the latest TR / DM / DI against the FROZEN prior-closed
+ * smoothed state. Does NOT mutate `dirState` (the consumer's
+ * close-side advance owns mutation). Returns the head DI pair the
+ * primitive should write to its output buffer.
+ *
+ * @formula  Same recurrence as {@link advanceDirectionalClose}, but
+ *           applied against `prevClosedSmoothed*` snapshots so the
+ *           current bar can be replaced rather than appended.
+ * @since 0.2
+ * @stable
+ * @example
+ *     // const di = tickDirectional(s, h, l, c);
+ */
+export declare function tickDirectional(dirState: DirectionalState, high: number, low: number, close: number): {
+    plusDi: number;
+    minusDi: number;
+};
+//# sourceMappingURL=directionalState.d.ts.map

package/dist/ta/lib/directionalState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directionalState.d.ts","sourceRoot":"","sources":["../../../src/ta/lib/directionalState.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wEAAwE;IACxE,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB;;iEAE6D;IAC7D,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,wEAAwE;IACxE,wBAAwB,EAAE,MAAM,CAAC;IACjC,yBAAyB,EAAE,MAAM,CAAC;IAClC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,CAsBrE;AAyBD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,uBAAuB,CACnC,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,GACd;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAqFrC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC3B,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,GACd;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAwCrC"}