wickra-wasm 0.5.5 → 0.5.7

package/wickra_wasm_bg.js

@@ -6806,6 +6806,85 @@ export class DepthSlope {
 }
 if (Symbol.dispose) DepthSlope.prototype[Symbol.dispose] = DepthSlope.prototype.free;
 
+export class DerivativeOscillator {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DerivativeOscillatorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_derivativeoscillator_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} prices
+     * @returns {Float64Array}
+     */
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.derivativeoscillator_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.derivativeoscillator_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} rsi_period
+     * @param {number} smooth1
+     * @param {number} smooth2
+     * @param {number} signal_period
+     */
+    constructor(rsi_period, smooth1, smooth2, signal_period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.derivativeoscillator_new(retptr, rsi_period, smooth1, smooth2, signal_period);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            DerivativeOscillatorFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.derivativeoscillator_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.derivativeoscillator_update(retptr, this.__wbg_ptr, value);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.derivativeoscillator_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) DerivativeOscillator.prototype[Symbol.dispose] = DerivativeOscillator.prototype.free;
+
 export class DetrendedStdDev {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -6882,6 +6961,82 @@ export class DetrendedStdDev {
 }
 if (Symbol.dispose) DetrendedStdDev.prototype[Symbol.dispose] = DetrendedStdDev.prototype.free;
 
+export class DisparityIndex {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DisparityIndexFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_disparityindex_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} prices
+     * @returns {Float64Array}
+     */
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.disparityindex_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.disparityindex_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.disparityindex_new(retptr, period);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            DisparityIndexFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.disparityindex_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.disparityindex_update(retptr, this.__wbg_ptr, value);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.disparityindex_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) DisparityIndex.prototype[Symbol.dispose] = DisparityIndex.prototype.free;
+
 export class DistanceSsd {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -7741,6 +7896,82 @@ export class DrawdownDuration {
 }
 if (Symbol.dispose) DrawdownDuration.prototype[Symbol.dispose] = DrawdownDuration.prototype.free;
 
+export class DynamicMomentumIndex {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DynamicMomentumIndexFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_dynamicmomentumindex_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} prices
+     * @returns {Float64Array}
+     */
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.dynamicmomentumindex_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.dynamicmomentumindex_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.dynamicmomentumindex_new(retptr, period);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            DynamicMomentumIndexFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.dynamicmomentumindex_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.dynamicmomentumindex_update(retptr, this.__wbg_ptr, value);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.dynamicmomentumindex_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) DynamicMomentumIndex.prototype[Symbol.dispose] = DynamicMomentumIndex.prototype.free;
+
 export class EHMA {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -8291,6 +8522,107 @@ export class ElderImpulse {
 }
 if (Symbol.dispose) ElderImpulse.prototype[Symbol.dispose] = ElderImpulse.prototype.free;
 
+export class ElderRay {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ElderRayFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_elderray_free(ptr, 0);
+    }
+    /**
+     * Returns `[bull0, bear0, bull1, bear1, ...]`, length `2 * n`.
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @param {Float64Array} close
+     * @returns {Float64Array}
+     */
+    batch(high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.elderray_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.elderray_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.elderray_new(retptr, period);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            ElderRayFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.elderray_reset(this.__wbg_ptr);
+    }
+    /**
+     * Streaming update. Returns `{ bullPower, bearPower }` once warm, else `null`.
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @returns {any}
+     */
+    update(high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.elderray_update(retptr, this.__wbg_ptr, high, low, close);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.elderray_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) ElderRay.prototype[Symbol.dispose] = ElderRay.prototype.free;
+
 export class EmpiricalModeDecomposition {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -9600,6 +9932,82 @@ export class FibonacciPivots {
 }
 if (Symbol.dispose) FibonacciPivots.prototype[Symbol.dispose] = FibonacciPivots.prototype.free;
 
+export class FisherRSI {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FisherRSIFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_fisherrsi_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} prices
+     * @returns {Float64Array}
+     */
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.fisherrsi_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.fisherrsi_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.fisherrsi_new(retptr, period);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            FisherRSIFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.fisherrsi_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.fisherrsi_update(retptr, this.__wbg_ptr, value);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.fisherrsi_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) FisherRSI.prototype[Symbol.dispose] = FisherRSI.prototype.free;
+
 export class FisherTransform {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -10662,7 +11070,97 @@ export class GarmanKlassVolatility {
         }
     }
     reset() {
-        wasm.garmanklassvolatility_reset(this.__wbg_ptr);
+        wasm.garmanklassvolatility_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} open
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @returns {number | undefined}
+     */
+    update(open, high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.garmanklassvolatility_update(retptr, this.__wbg_ptr, open, high, low, close);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.garmanklassvolatility_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) GarmanKlassVolatility.prototype[Symbol.dispose] = GarmanKlassVolatility.prototype.free;
+
+export class Gartley {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GartleyFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_gartley_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} open
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @param {Float64Array} close
+     * @returns {Float64Array}
+     */
+    batch(open, high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(open, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.gartley_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.gartley_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.gartley_new();
+        this.__wbg_ptr = ret;
+        GartleyFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.gartley_reset(this.__wbg_ptr);
     }
     /**
      * @param {number} open
@@ -10674,7 +11172,7 @@ export class GarmanKlassVolatility {
     update(open, high, low, close) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
-            wasm.garmanklassvolatility_update(retptr, this.__wbg_ptr, open, high, low, close);
+            wasm.gartley_update(retptr, this.__wbg_ptr, open, high, low, close);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
             var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
@@ -10691,42 +11189,40 @@ export class GarmanKlassVolatility {
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.garmanklassvolatility_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.gartley_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) GarmanKlassVolatility.prototype[Symbol.dispose] = GarmanKlassVolatility.prototype.free;
+if (Symbol.dispose) Gartley.prototype[Symbol.dispose] = Gartley.prototype.free;
 
-export class Gartley {
+export class GatorOscillator {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        GartleyFinalization.unregister(this);
+        GatorOscillatorFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_gartley_free(ptr, 0);
+        wasm.__wbg_gatoroscillator_free(ptr, 0);
     }
     /**
-     * @param {Float64Array} open
+     * Returns `[upper0, lower0, upper1, lower1, ...]`, length `2 * n`.
      * @param {Float64Array} high
      * @param {Float64Array} low
      * @param {Float64Array} close
      * @returns {Float64Array}
      */
-    batch(open, high, low, close) {
+    batch(high, low, close) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passArrayF64ToWasm0(open, wasm.__wbindgen_export3);
+            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
             const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
             const len1 = WASM_VECTOR_LEN;
-            const ptr2 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const ptr2 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
             const len2 = WASM_VECTOR_LEN;
-            const ptr3 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
-            const len3 = WASM_VECTOR_LEN;
-            wasm.gartley_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            wasm.gatoroscillator_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -10742,50 +11238,65 @@ export class Gartley {
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.gartley_isReady(this.__wbg_ptr);
+        const ret = wasm.gatoroscillator_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
-    constructor() {
-        const ret = wasm.gartley_new();
-        this.__wbg_ptr = ret;
-        GartleyFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    /**
+     * @param {number} jaw_period
+     * @param {number} teeth_period
+     * @param {number} lips_period
+     */
+    constructor(jaw_period, teeth_period, lips_period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.gatoroscillator_new(retptr, jaw_period, teeth_period, lips_period);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            GatorOscillatorFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     reset() {
-        wasm.gartley_reset(this.__wbg_ptr);
+        wasm.gatoroscillator_reset(this.__wbg_ptr);
     }
     /**
-     * @param {number} open
+     * Streaming update. Returns `{ upper, lower }` once warm, else `null`.
      * @param {number} high
      * @param {number} low
      * @param {number} close
-     * @returns {number | undefined}
+     * @returns {any}
      */
-    update(open, high, low, close) {
+    update(high, low, close) {
         try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
-            wasm.gartley_update(retptr, this.__wbg_ptr, open, high, low, close);
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.gatoroscillator_update(retptr, this.__wbg_ptr, high, low, close);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
-            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
-            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
-            if (r5) {
-                throw takeObject(r4);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
             }
-            return r0 === 0 ? undefined : r2;
+            return takeObject(r0);
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(32);
+            wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.gartley_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.gatoroscillator_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) Gartley.prototype[Symbol.dispose] = Gartley.prototype.free;
+if (Symbol.dispose) GatorOscillator.prototype[Symbol.dispose] = GatorOscillator.prototype.free;
 
 export class GoldenPocket {
     __destroy_into_raw() {
@@ -12743,6 +13254,112 @@ export class HurstExponent {
 }
 if (Symbol.dispose) HurstExponent.prototype[Symbol.dispose] = HurstExponent.prototype.free;
 
+export class IMI {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IMIFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_imi_free(ptr, 0);
+    }
+    /**
+     * Batch over open/high/low/close arrays; `NaN` during warmup.
+     * @param {Float64Array} open
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @param {Float64Array} close
+     * @returns {Float64Array}
+     */
+    batch(open, high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(open, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.imi_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.imi_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.imi_new(retptr, period);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            IMIFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.imi_reset(this.__wbg_ptr);
+    }
+    /**
+     * Streaming update over one candle's open/high/low/close.
+     * @param {number} open
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @returns {number | undefined}
+     */
+    update(open, high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.imi_update(retptr, this.__wbg_ptr, open, high, low, close);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.imi_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) IMI.prototype[Symbol.dispose] = IMI.prototype.free;
+
 export class Ichimoku {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -14137,34 +14754,124 @@ export class KagiBars {
         }
     }
 }
-if (Symbol.dispose) KagiBars.prototype[Symbol.dispose] = KagiBars.prototype.free;
+if (Symbol.dispose) KagiBars.prototype[Symbol.dispose] = KagiBars.prototype.free;
+
+export class KalmanHedgeRatio {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        KalmanHedgeRatioFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_kalmanhedgeratio_free(ptr, 0);
+    }
+    /**
+     * Flat `Float64Array` of length `3 * n`:
+     * `[hedgeRatio0, intercept0, spread0, hedgeRatio1, ...]`. Warmup rows are NaN.
+     * @param {Float64Array} a
+     * @param {Float64Array} b
+     * @returns {Float64Array}
+     */
+    batch(a, b) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(a, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(b, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.kalmanhedgeratio_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.kalmanhedgeratio_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} delta
+     * @param {number} observation_var
+     */
+    constructor(delta, observation_var) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.kalmanhedgeratio_new(retptr, delta, observation_var);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            KalmanHedgeRatioFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.kalmanhedgeratio_reset(this.__wbg_ptr);
+    }
+    /**
+     * Returns `{ hedgeRatio, intercept, spread }`, or `null` during warmup.
+     * @param {number} a
+     * @param {number} b
+     * @returns {any}
+     */
+    update(a, b) {
+        const ret = wasm.kalmanhedgeratio_update(this.__wbg_ptr, a, b);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.kalmanhedgeratio_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) KalmanHedgeRatio.prototype[Symbol.dispose] = KalmanHedgeRatio.prototype.free;
 
-export class KalmanHedgeRatio {
+export class KasePermissionStochastic {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        KalmanHedgeRatioFinalization.unregister(this);
+        KasePermissionStochasticFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_kalmanhedgeratio_free(ptr, 0);
+        wasm.__wbg_kasepermissionstochastic_free(ptr, 0);
     }
     /**
-     * Flat `Float64Array` of length `3 * n`:
-     * `[hedgeRatio0, intercept0, spread0, hedgeRatio1, ...]`. Warmup rows are NaN.
-     * @param {Float64Array} a
-     * @param {Float64Array} b
+     * Returns `[fast0, slow0, fast1, slow1, ...]`, length `2 * n`.
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @param {Float64Array} close
      * @returns {Float64Array}
      */
-    batch(a, b) {
+    batch(high, low, close) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passArrayF64ToWasm0(a, wasm.__wbindgen_export3);
+            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
             const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passArrayF64ToWasm0(b, wasm.__wbindgen_export3);
+            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
             const len1 = WASM_VECTOR_LEN;
-            wasm.kalmanhedgeratio_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            const ptr2 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.kasepermissionstochastic_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -14180,17 +14887,17 @@ export class KalmanHedgeRatio {
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.kalmanhedgeratio_isReady(this.__wbg_ptr);
+        const ret = wasm.kasepermissionstochastic_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
-     * @param {number} delta
-     * @param {number} observation_var
+     * @param {number} length
+     * @param {number} smooth
      */
-    constructor(delta, observation_var) {
+    constructor(length, smooth) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.kalmanhedgeratio_new(retptr, delta, observation_var);
+            wasm.kasepermissionstochastic_new(retptr, length, smooth);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -14198,34 +14905,46 @@ export class KalmanHedgeRatio {
                 throw takeObject(r1);
             }
             this.__wbg_ptr = r0;
-            KalmanHedgeRatioFinalization.register(this, this.__wbg_ptr, this);
+            KasePermissionStochasticFinalization.register(this, this.__wbg_ptr, this);
             return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     reset() {
-        wasm.kalmanhedgeratio_reset(this.__wbg_ptr);
+        wasm.kasepermissionstochastic_reset(this.__wbg_ptr);
     }
     /**
-     * Returns `{ hedgeRatio, intercept, spread }`, or `null` during warmup.
-     * @param {number} a
-     * @param {number} b
+     * Streaming update. Returns `{ fast, slow }` once warm, else `null`.
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
      * @returns {any}
      */
-    update(a, b) {
-        const ret = wasm.kalmanhedgeratio_update(this.__wbg_ptr, a, b);
-        return takeObject(ret);
+    update(high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.kasepermissionstochastic_update(retptr, this.__wbg_ptr, high, low, close);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.kalmanhedgeratio_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.kasepermissionstochastic_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) KalmanHedgeRatio.prototype[Symbol.dispose] = KalmanHedgeRatio.prototype.free;
+if (Symbol.dispose) KasePermissionStochastic.prototype[Symbol.dispose] = KasePermissionStochastic.prototype.free;
 
 export class KellyCriterion {
     __destroy_into_raw() {
@@ -19492,6 +20211,83 @@ export class PMO {
 }
 if (Symbol.dispose) PMO.prototype[Symbol.dispose] = PMO.prototype.free;
 
+export class POLARIZED_FRACTAL_EFFICIENCY {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        POLARIZED_FRACTAL_EFFICIENCYFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_polarized_fractal_efficiency_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} prices
+     * @returns {Float64Array}
+     */
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.polarized_fractal_efficiency_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.polarized_fractal_efficiency_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     * @param {number} smoothing
+     */
+    constructor(period, smoothing) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.polarized_fractal_efficiency_new(retptr, period, smoothing);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            POLARIZED_FRACTAL_EFFICIENCYFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.polarized_fractal_efficiency_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.polarized_fractal_efficiency_update(retptr, this.__wbg_ptr, value);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.polarized_fractal_efficiency_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) POLARIZED_FRACTAL_EFFICIENCY.prototype[Symbol.dispose] = POLARIZED_FRACTAL_EFFICIENCY.prototype.free;
+
 export class PPO {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -20603,17 +21399,181 @@ export class ProfitFactor {
      * @param {Float64Array} prices
      * @returns {Float64Array}
      */
-    batch(prices) {
-        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.profitfactor_batch(this.__wbg_ptr, ptr0, len0);
-        return takeObject(ret);
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.profitfactor_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.profitfactor_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.profitfactor_new(retptr, period);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            ProfitFactorFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.profitfactor_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.profitfactor_update(retptr, this.__wbg_ptr, value);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.profitfactor_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) ProfitFactor.prototype[Symbol.dispose] = ProfitFactor.prototype.free;
+
+export class QQE {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        QQEFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_qqe_free(ptr, 0);
+    }
+    /**
+     * Returns `[rsiMa0, trailing0, rsiMa1, trailing1, ...]`, length `2 * n`.
+     * @param {Float64Array} prices
+     * @returns {Float64Array}
+     */
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.qqe_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.qqe_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} rsi_period
+     * @param {number} smoothing
+     * @param {number} factor
+     */
+    constructor(rsi_period, smoothing, factor) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.qqe_new(retptr, rsi_period, smoothing, factor);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            QQEFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.qqe_reset(this.__wbg_ptr);
+    }
+    /**
+     * Streaming update. Returns `{ rsiMa, trailingLine }` once warm, else `null`.
+     * @param {number} value
+     * @returns {any}
+     */
+    update(value) {
+        const ret = wasm.qqe_update(this.__wbg_ptr, value);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.qqe_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) QQE.prototype[Symbol.dispose] = QQE.prototype.free;
+
+export class Qstick {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        QstickFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_qstick_free(ptr, 0);
+    }
+    /**
+     * Batch over open/close arrays; `NaN` during warmup.
+     * @param {Float64Array} open
+     * @param {Float64Array} close
+     * @returns {Float64Array}
+     */
+    batch(open, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(open, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.qstick_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.profitfactor_isReady(this.__wbg_ptr);
+        const ret = wasm.qstick_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
@@ -20622,7 +21582,7 @@ export class ProfitFactor {
     constructor(period) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.profitfactor_new(retptr, period);
+            wasm.qstick_new(retptr, period);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -20630,39 +21590,46 @@ export class ProfitFactor {
                 throw takeObject(r1);
             }
             this.__wbg_ptr = r0;
-            ProfitFactorFinalization.register(this, this.__wbg_ptr, this);
+            QstickFinalization.register(this, this.__wbg_ptr, this);
             return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     reset() {
-        wasm.profitfactor_reset(this.__wbg_ptr);
+        wasm.qstick_reset(this.__wbg_ptr);
     }
     /**
-     * @param {number} value
+     * Streaming update over one candle's open and close.
+     * @param {number} open
+     * @param {number} close
      * @returns {number | undefined}
      */
-    update(value) {
+    update(open, close) {
         try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.profitfactor_update(retptr, this.__wbg_ptr, value);
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.qstick_update(retptr, this.__wbg_ptr, open, close);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
             return r0 === 0 ? undefined : r2;
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_add_to_stack_pointer(32);
         }
     }
     /**
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.profitfactor_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.qstick_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) ProfitFactor.prototype[Symbol.dispose] = ProfitFactor.prototype.free;
+if (Symbol.dispose) Qstick.prototype[Symbol.dispose] = Qstick.prototype.free;
 
 export class QuotedSpread {
     __destroy_into_raw() {
@@ -20732,6 +21699,83 @@ export class QuotedSpread {
 }
 if (Symbol.dispose) QuotedSpread.prototype[Symbol.dispose] = QuotedSpread.prototype.free;
 
+export class RMI {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RMIFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rmi_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} prices
+     * @returns {Float64Array}
+     */
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rmi_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.rmi_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     * @param {number} momentum
+     */
+    constructor(period, momentum) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rmi_new(retptr, period, momentum);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            RMIFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.rmi_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rmi_update(retptr, this.__wbg_ptr, value);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.rmi_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) RMI.prototype[Symbol.dispose] = RMI.prototype.free;
+
 export class ROC {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -21112,6 +22156,82 @@ export class RSI {
 }
 if (Symbol.dispose) RSI.prototype[Symbol.dispose] = RSI.prototype.free;
 
+export class RSX {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RSXFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rsx_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} prices
+     * @returns {Float64Array}
+     */
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rsx_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.rsx_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rsx_new(retptr, period);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            RSXFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.rsx_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rsx_update(retptr, this.__wbg_ptr, value);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.rsx_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) RSX.prototype[Symbol.dispose] = RSX.prototype.free;
+
 export class RSquared {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -25670,10 +26790,103 @@ export class Stochastic {
      * @param {number} k_period
      * @param {number} d_period
      */
-    constructor(k_period, d_period) {
+    constructor(k_period, d_period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.stochastic_new(retptr, k_period, d_period);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            StochasticFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.stochastic_reset(this.__wbg_ptr);
+    }
+    /**
+     * Streaming update. Returns `{ k, d }` once warm, else `null`.
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @returns {any}
+     */
+    update(high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.stochastic_update(retptr, this.__wbg_ptr, high, low, close);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.stochastic_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) Stochastic.prototype[Symbol.dispose] = Stochastic.prototype.free;
+
+export class StochasticCCI {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        StochasticCCIFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_stochasticcci_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @param {Float64Array} close
+     * @returns {Float64Array}
+     */
+    batch(high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.stochasticcci_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.stochastic_new(retptr, k_period, d_period);
+            wasm.stochasticcci_new(retptr, period);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -25681,46 +26894,39 @@ export class Stochastic {
                 throw takeObject(r1);
             }
             this.__wbg_ptr = r0;
-            StochasticFinalization.register(this, this.__wbg_ptr, this);
+            StochasticCCIFinalization.register(this, this.__wbg_ptr, this);
             return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     reset() {
-        wasm.stochastic_reset(this.__wbg_ptr);
+        wasm.stochasticcci_reset(this.__wbg_ptr);
     }
     /**
-     * Streaming update. Returns `{ k, d }` once warm, else `null`.
      * @param {number} high
      * @param {number} low
      * @param {number} close
-     * @returns {any}
+     * @returns {number | undefined}
      */
     update(high, low, close) {
         try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.stochastic_update(retptr, this.__wbg_ptr, high, low, close);
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.stochasticcci_update(retptr, this.__wbg_ptr, high, low, close);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-            if (r2) {
-                throw takeObject(r1);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
             }
-            return takeObject(r0);
+            return r0 === 0 ? undefined : r2;
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_add_to_stack_pointer(32);
         }
     }
-    /**
-     * @returns {number}
-     */
-    warmupPeriod() {
-        const ret = wasm.stochastic_warmupPeriod(this.__wbg_ptr);
-        return ret >>> 0;
-    }
 }
-if (Symbol.dispose) Stochastic.prototype[Symbol.dispose] = Stochastic.prototype.free;
+if (Symbol.dispose) StochasticCCI.prototype[Symbol.dispose] = StochasticCCI.prototype.free;
 
 export class SuperSmoother {
     __destroy_into_raw() {
@@ -27300,6 +28506,82 @@ export class TII {
 }
 if (Symbol.dispose) TII.prototype[Symbol.dispose] = TII.prototype.free;
 
+export class TREND_STRENGTH_INDEX {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TREND_STRENGTH_INDEXFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_trend_strength_index_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} prices
+     * @returns {Float64Array}
+     */
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.trend_strength_index_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.trend_strength_index_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.trend_strength_index_new(retptr, period);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            TREND_STRENGTH_INDEXFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.trend_strength_index_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.trend_strength_index_update(retptr, this.__wbg_ptr, value);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.trend_strength_index_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) TREND_STRENGTH_INDEX.prototype[Symbol.dispose] = TREND_STRENGTH_INDEX.prototype.free;
+
 export class TRIMA {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -27687,6 +28969,92 @@ export class TSV {
 }
 if (Symbol.dispose) TSV.prototype[Symbol.dispose] = TSV.prototype.free;
 
+export class TTM_TREND {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TTM_TRENDFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ttm_trend_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @param {Float64Array} close
+     * @returns {Float64Array}
+     */
+    batch(high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.ttm_trend_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ttm_trend_new(retptr, period);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            TTM_TRENDFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.ttm_trend_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @returns {number | undefined}
+     */
+    update(high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.ttm_trend_update(retptr, this.__wbg_ptr, high, low, close);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+}
+if (Symbol.dispose) TTM_TREND.prototype[Symbol.dispose] = TTM_TREND.prototype.free;
+
 export class TakerBuySellRatio {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -31794,6 +33162,83 @@ export class VwapStdDevBands {
 }
 if (Symbol.dispose) VwapStdDevBands.prototype[Symbol.dispose] = VwapStdDevBands.prototype.free;
 
+export class WAVE_PM {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WAVE_PMFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wave_pm_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} prices
+     * @returns {Float64Array}
+     */
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wave_pm_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.wave_pm_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} length
+     * @param {number} smoothing
+     */
+    constructor(length, smoothing) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wave_pm_new(retptr, length, smoothing);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            WAVE_PMFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.wave_pm_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wave_pm_update(retptr, this.__wbg_ptr, value);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.wave_pm_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) WAVE_PM.prototype[Symbol.dispose] = WAVE_PM.prototype.free;
+
 export class WMA {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -33497,9 +34942,15 @@ const DemarkPivotsFinalization = (typeof FinalizationRegistry === 'undefined')
 const DepthSlopeFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_depthslope_free(ptr, 1));
+const DerivativeOscillatorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_derivativeoscillator_free(ptr, 1));
 const DetrendedStdDevFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_detrendedstddev_free(ptr, 1));
+const DisparityIndexFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_disparityindex_free(ptr, 1));
 const DistanceSsdFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_distancessd_free(ptr, 1));
@@ -33536,6 +34987,9 @@ const DrawdownDurationFinalization = (typeof FinalizationRegistry === 'undefined
 const DXFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_dx_free(ptr, 1));
+const DynamicMomentumIndexFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_dynamicmomentumindex_free(ptr, 1));
 const EaseOfMovementFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_easeofmovement_free(ptr, 1));
@@ -33551,6 +35005,9 @@ const EHMAFinalization = (typeof FinalizationRegistry === 'undefined')
 const ElderImpulseFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_elderimpulse_free(ptr, 1));
+const ElderRayFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_elderray_free(ptr, 1));
 const EMAFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ema_free(ptr, 1));
@@ -33602,6 +35059,9 @@ const FibTimeZonesFinalization = (typeof FinalizationRegistry === 'undefined')
 const FibonacciPivotsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_fibonaccipivots_free(ptr, 1));
+const FisherRSIFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_fisherrsi_free(ptr, 1));
 const FisherTransformFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_fishertransform_free(ptr, 1));
@@ -33644,6 +35104,9 @@ const GarmanKlassVolatilityFinalization = (typeof FinalizationRegistry === 'unde
 const GartleyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_gartley_free(ptr, 1));
+const GatorOscillatorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_gatoroscillator_free(ptr, 1));
 const GDFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_gd_free(ptr, 1));
@@ -33728,6 +35191,9 @@ const IchimokuFinalization = (typeof FinalizationRegistry === 'undefined')
 const IdenticalThreeCrowsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_identicalthreecrows_free(ptr, 1));
+const IMIFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_imi_free(ptr, 1));
 const InNeckFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_inneck_free(ptr, 1));
@@ -33767,6 +35233,9 @@ const KalmanHedgeRatioFinalization = (typeof FinalizationRegistry === 'undefined
 const KAMAFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_kama_free(ptr, 1));
+const KasePermissionStochasticFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_kasepermissionstochastic_free(ptr, 1));
 const KellyCriterionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_kellycriterion_free(ptr, 1));
@@ -34004,6 +35473,9 @@ const PMOFinalization = (typeof FinalizationRegistry === 'undefined')
 const PointAndFigureBarsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_pointandfigurebars_free(ptr, 1));
+const POLARIZED_FRACTAL_EFFICIENCYFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_polarized_fractal_efficiency_free(ptr, 1));
 const PPOFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ppo_free(ptr, 1));
@@ -34016,6 +35488,12 @@ const PSARFinalization = (typeof FinalizationRegistry === 'undefined')
 const PVIFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_pvi_free(ptr, 1));
+const QQEFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_qqe_free(ptr, 1));
+const QstickFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_qstick_free(ptr, 1));
 const QuotedSpreadFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_quotedspread_free(ptr, 1));
@@ -34052,6 +35530,9 @@ const RickshawManFinalization = (typeof FinalizationRegistry === 'undefined')
 const RisingThreeMethodsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_risingthreemethods_free(ptr, 1));
+const RMIFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rmi_free(ptr, 1));
 const ROCFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_roc_free(ptr, 1));
@@ -34094,6 +35575,9 @@ const RoofingFilterFinalization = (typeof FinalizationRegistry === 'undefined')
 const RSIFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rsi_free(ptr, 1));
+const RSXFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rsx_free(ptr, 1));
 const RVIFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rvi_free(ptr, 1));
@@ -34202,6 +35686,9 @@ const StochasticFinalization = (typeof FinalizationRegistry === 'undefined')
 const StochRSIFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_stochrsi_free(ptr, 1));
+const StochasticCCIFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_stochasticcci_free(ptr, 1));
 const SuperSmootherFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_supersmoother_free(ptr, 1));
@@ -34301,6 +35788,9 @@ const TradeImbalanceFinalization = (typeof FinalizationRegistry === 'undefined')
 const TrendLabelFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_trendlabel_free(ptr, 1));
+const TREND_STRENGTH_INDEXFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_trend_strength_index_free(ptr, 1));
 const TreynorRatioFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_treynorratio_free(ptr, 1));
@@ -34334,6 +35824,9 @@ const TSVFinalization = (typeof FinalizationRegistry === 'undefined')
 const TtmSqueezeFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ttmsqueeze_free(ptr, 1));
+const TTM_TRENDFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ttm_trend_free(ptr, 1));
 const TurnOfMonthFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_turnofmonth_free(ptr, 1));
@@ -34415,6 +35908,9 @@ const VWMAFinalization = (typeof FinalizationRegistry === 'undefined')
 const VZOFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_vzo_free(ptr, 1));
+const WAVE_PMFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wave_pm_free(ptr, 1));
 const WaveTrendFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wavetrend_free(ptr, 1));