wickra-wasm 0.4.6 → 0.5.0

package/wickra_wasm_bg.js

@@ -682,6 +682,74 @@ export class AbandonedBaby {
 }
 if (Symbol.dispose) AbandonedBaby.prototype[Symbol.dispose] = AbandonedBaby.prototype.free;
 
+export class AbsoluteBreadthIndex {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AbsoluteBreadthIndexFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_absolutebreadthindex_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.absolutebreadthindex_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.absolutebreadthindex_new();
+        this.__wbg_ptr = ret;
+        AbsoluteBreadthIndexFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.absolutebreadthindex_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @returns {number | undefined}
+     */
+    update(change, volume, new_high, new_low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.absolutebreadthindex_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            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.absolutebreadthindex_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) AbsoluteBreadthIndex.prototype[Symbol.dispose] = AbsoluteBreadthIndex.prototype.free;
+
 export class AccelerationBands {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -867,6 +935,74 @@ export class AcceleratorOscillator {
 }
 if (Symbol.dispose) AcceleratorOscillator.prototype[Symbol.dispose] = AcceleratorOscillator.prototype.free;
 
+export class AdVolumeLine {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AdVolumeLineFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_advolumeline_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.advolumeline_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.advolumeline_new();
+        this.__wbg_ptr = ret;
+        AdVolumeLineFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.advolumeline_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @returns {number | undefined}
+     */
+    update(change, volume, new_high, new_low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.advolumeline_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            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.advolumeline_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) AdVolumeLine.prototype[Symbol.dispose] = AdVolumeLine.prototype.free;
+
 export class AdaptiveCycle {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -1019,6 +1155,142 @@ export class AdvanceBlock {
 }
 if (Symbol.dispose) AdvanceBlock.prototype[Symbol.dispose] = AdvanceBlock.prototype.free;
 
+export class AdvanceDecline {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AdvanceDeclineFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_advancedecline_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.advancedecline_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.advancedecline_new();
+        this.__wbg_ptr = ret;
+        AdvanceDeclineFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.advancedecline_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @returns {number | undefined}
+     */
+    update(change, volume, new_high, new_low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.advancedecline_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            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.advancedecline_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) AdvanceDecline.prototype[Symbol.dispose] = AdvanceDecline.prototype.free;
+
+export class AdvanceDeclineRatio {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AdvanceDeclineRatioFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_advancedeclineratio_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.advancedeclineratio_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.advancedeclineratio_new();
+        this.__wbg_ptr = ret;
+        AdvanceDeclineRatioFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.advancedeclineratio_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @returns {number | undefined}
+     */
+    update(change, volume, new_high, new_low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.advancedeclineratio_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            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.advancedeclineratio_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) AdvanceDeclineRatio.prototype[Symbol.dispose] = AdvanceDeclineRatio.prototype.free;
+
 export class Alligator {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -2232,18 +2504,111 @@ export class BeltHold {
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) BeltHold.prototype[Symbol.dispose] = BeltHold.prototype.free;
+if (Symbol.dispose) BeltHold.prototype[Symbol.dispose] = BeltHold.prototype.free;
+
+export class Beta {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BetaFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_beta_free(ptr, 0);
+    }
+    /**
+     * Batch over two equally-sized arrays. Returns one `f64` per
+     * input position (`NaN` during warmup).
+     * @param {Float64Array} x
+     * @param {Float64Array} y
+     * @returns {Float64Array}
+     */
+    batch(x, y) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(y, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.beta_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.beta_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.beta_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;
+            BetaFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.beta_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} x
+     * @param {number} y
+     * @returns {number | undefined}
+     */
+    update(x, y) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.beta_update(retptr, this.__wbg_ptr, x, y);
+            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.beta_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) Beta.prototype[Symbol.dispose] = Beta.prototype.free;
 
-export class Beta {
+export class BetaNeutralSpread {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        BetaFinalization.unregister(this);
+        BetaNeutralSpreadFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_beta_free(ptr, 0);
+        wasm.__wbg_betaneutralspread_free(ptr, 0);
     }
     /**
      * Batch over two equally-sized arrays. Returns one `f64` per
@@ -2259,7 +2624,7 @@ export class Beta {
             const len0 = WASM_VECTOR_LEN;
             const ptr1 = passArrayF64ToWasm0(y, wasm.__wbindgen_export3);
             const len1 = WASM_VECTOR_LEN;
-            wasm.beta_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            wasm.betaneutralspread_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);
@@ -2275,7 +2640,7 @@ export class Beta {
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.beta_isReady(this.__wbg_ptr);
+        const ret = wasm.betaneutralspread_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
@@ -2284,7 +2649,7 @@ export class Beta {
     constructor(period) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.beta_new(retptr, period);
+            wasm.betaneutralspread_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);
@@ -2292,14 +2657,14 @@ export class Beta {
                 throw takeObject(r1);
             }
             this.__wbg_ptr = r0;
-            BetaFinalization.register(this, this.__wbg_ptr, this);
+            BetaNeutralSpreadFinalization.register(this, this.__wbg_ptr, this);
             return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     reset() {
-        wasm.beta_reset(this.__wbg_ptr);
+        wasm.betaneutralspread_reset(this.__wbg_ptr);
     }
     /**
      * @param {number} x
@@ -2309,7 +2674,7 @@ export class Beta {
     update(x, y) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.beta_update(retptr, this.__wbg_ptr, x, y);
+            wasm.betaneutralspread_update(retptr, this.__wbg_ptr, x, y);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
             return r0 === 0 ? undefined : r2;
@@ -2321,11 +2686,11 @@ export class Beta {
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.beta_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.betaneutralspread_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) Beta.prototype[Symbol.dispose] = Beta.prototype.free;
+if (Symbol.dispose) BetaNeutralSpread.prototype[Symbol.dispose] = BetaNeutralSpread.prototype.free;
 
 export class BollingerBands {
     __destroy_into_raw() {
@@ -2461,6 +2826,88 @@ export class BollingerBandwidth {
 }
 if (Symbol.dispose) BollingerBandwidth.prototype[Symbol.dispose] = BollingerBandwidth.prototype.free;
 
+export class BreadthThrust {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BreadthThrustFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_breadththrust_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.breadththrust_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.breadththrust_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;
+            BreadthThrustFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.breadththrust_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @returns {number | undefined}
+     */
+    update(change, volume, new_high, new_low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.breadththrust_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            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.breadththrust_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) BreadthThrust.prototype[Symbol.dispose] = BreadthThrust.prototype.free;
+
 export class Breakaway {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -2551,6 +2998,77 @@ export class Breakaway {
 }
 if (Symbol.dispose) Breakaway.prototype[Symbol.dispose] = Breakaway.prototype.free;
 
+export class BullishPercentIndex {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BullishPercentIndexFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_bullishpercentindex_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.bullishpercentindex_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.bullishpercentindex_new();
+        this.__wbg_ptr = ret;
+        BullishPercentIndexFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.bullishpercentindex_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @param {Float64Array} on_buy_signal
+     * @returns {number | undefined}
+     */
+    update(change, volume, new_high, new_low, on_buy_signal) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            const ptr4 = passArrayF64ToWasm0(on_buy_signal, wasm.__wbindgen_export3);
+            const len4 = WASM_VECTOR_LEN;
+            wasm.bullishpercentindex_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
+            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.bullishpercentindex_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) BullishPercentIndex.prototype[Symbol.dispose] = BullishPercentIndex.prototype.free;
+
 export class CCI {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -4436,6 +4954,74 @@ export class CumulativeVolumeDelta {
 }
 if (Symbol.dispose) CumulativeVolumeDelta.prototype[Symbol.dispose] = CumulativeVolumeDelta.prototype.free;
 
+export class CumulativeVolumeIndex {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CumulativeVolumeIndexFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_cumulativevolumeindex_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.cumulativevolumeindex_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.cumulativevolumeindex_new();
+        this.__wbg_ptr = ret;
+        CumulativeVolumeIndexFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.cumulativevolumeindex_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @returns {number | undefined}
+     */
+    update(change, volume, new_high, new_low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.cumulativevolumeindex_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            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.cumulativevolumeindex_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) CumulativeVolumeIndex.prototype[Symbol.dispose] = CumulativeVolumeIndex.prototype.free;
+
 export class CyberneticCycle {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -5137,45 +5723,137 @@ export class DepthSlope {
             }
             return r0 === 0 ? undefined : r2;
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(32);
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.depthslope_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) DepthSlope.prototype[Symbol.dispose] = DepthSlope.prototype.free;
+
+export class DetrendedStdDev {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DetrendedStdDevFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_detrendedstddev_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.detrendedstddev_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.detrendedstddev_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.detrendedstddev_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;
+            DetrendedStdDevFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.detrendedstddev_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.detrendedstddev_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.depthslope_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.detrendedstddev_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) DepthSlope.prototype[Symbol.dispose] = DepthSlope.prototype.free;
+if (Symbol.dispose) DetrendedStdDev.prototype[Symbol.dispose] = DetrendedStdDev.prototype.free;
 
-export class DetrendedStdDev {
+export class DistanceSsd {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        DetrendedStdDevFinalization.unregister(this);
+        DistanceSsdFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_detrendedstddev_free(ptr, 0);
+        wasm.__wbg_distancessd_free(ptr, 0);
     }
     /**
-     * @param {Float64Array} prices
+     * Batch over two equally-sized arrays. Returns one `f64` per
+     * input position (`NaN` during warmup).
+     * @param {Float64Array} x
+     * @param {Float64Array} y
      * @returns {Float64Array}
      */
-    batch(prices) {
-        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.detrendedstddev_batch(this.__wbg_ptr, ptr0, len0);
-        return takeObject(ret);
+    batch(x, y) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(y, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.distancessd_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.detrendedstddev_isReady(this.__wbg_ptr);
+        const ret = wasm.distancessd_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
@@ -5184,7 +5862,7 @@ export class DetrendedStdDev {
     constructor(period) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.detrendedstddev_new(retptr, period);
+            wasm.distancessd_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);
@@ -5192,23 +5870,24 @@ export class DetrendedStdDev {
                 throw takeObject(r1);
             }
             this.__wbg_ptr = r0;
-            DetrendedStdDevFinalization.register(this, this.__wbg_ptr, this);
+            DistanceSsdFinalization.register(this, this.__wbg_ptr, this);
             return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     reset() {
-        wasm.detrendedstddev_reset(this.__wbg_ptr);
+        wasm.distancessd_reset(this.__wbg_ptr);
     }
     /**
-     * @param {number} value
+     * @param {number} x
+     * @param {number} y
      * @returns {number | undefined}
      */
-    update(value) {
+    update(x, y) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.detrendedstddev_update(retptr, this.__wbg_ptr, value);
+            wasm.distancessd_update(retptr, this.__wbg_ptr, x, y);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
             return r0 === 0 ? undefined : r2;
@@ -5220,11 +5899,11 @@ export class DetrendedStdDev {
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.detrendedstddev_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.distancessd_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) DetrendedStdDev.prototype[Symbol.dispose] = DetrendedStdDev.prototype.free;
+if (Symbol.dispose) DistanceSsd.prototype[Symbol.dispose] = DistanceSsd.prototype.free;
 
 export class Doji {
     __destroy_into_raw() {
@@ -7815,6 +8494,100 @@ export class GarmanKlassVolatility {
 }
 if (Symbol.dispose) GarmanKlassVolatility.prototype[Symbol.dispose] = GarmanKlassVolatility.prototype.free;
 
+export class GrangerCausality {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GrangerCausalityFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_grangercausality_free(ptr, 0);
+    }
+    /**
+     * Batch over two equally-sized arrays of prices. Returns one `f64` per
+     * input position (`NaN` during warmup).
+     * @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.grangercausality_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.grangercausality_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     * @param {number} lag
+     */
+    constructor(period, lag) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.grangercausality_new(retptr, period, lag);
+            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;
+            GrangerCausalityFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.grangercausality_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} a
+     * @param {number} b
+     * @returns {number | undefined}
+     */
+    update(a, b) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.grangercausality_update(retptr, this.__wbg_ptr, a, b);
+            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.grangercausality_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) GrangerCausality.prototype[Symbol.dispose] = GrangerCausality.prototype.free;
+
 export class GravestoneDoji {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -8595,6 +9368,88 @@ export class HiLoActivator {
 }
 if (Symbol.dispose) HiLoActivator.prototype[Symbol.dispose] = HiLoActivator.prototype.free;
 
+export class HighLowIndex {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        HighLowIndexFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_highlowindex_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.highlowindex_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.highlowindex_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;
+            HighLowIndexFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.highlowindex_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @returns {number | undefined}
+     */
+    update(change, volume, new_high, new_low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.highlowindex_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            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.highlowindex_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) HighLowIndex.prototype[Symbol.dispose] = HighLowIndex.prototype.free;
+
 export class HighWave {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -10489,23 +11344,111 @@ export class KagiBars {
      * @param {number} close
      * @returns {Array<any>}
      */
-    update(close) {
+    update(close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.kagibars_update(retptr, this.__wbg_ptr, 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);
+        }
+    }
+}
+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.kagibars_update(retptr, this.__wbg_ptr, close);
+            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);
             }
-            return takeObject(r0);
+            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) KagiBars.prototype[Symbol.dispose] = KagiBars.prototype.free;
+if (Symbol.dispose) KalmanHedgeRatio.prototype[Symbol.dispose] = KalmanHedgeRatio.prototype.free;
 
 export class KellyCriterion {
     __destroy_into_raw() {
@@ -13280,6 +14223,142 @@ export class MaxDrawdown {
 }
 if (Symbol.dispose) MaxDrawdown.prototype[Symbol.dispose] = MaxDrawdown.prototype.free;
 
+export class McClellanOscillator {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        McClellanOscillatorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_mcclellanoscillator_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.mcclellanoscillator_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.mcclellanoscillator_new();
+        this.__wbg_ptr = ret;
+        McClellanOscillatorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.mcclellanoscillator_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @returns {number | undefined}
+     */
+    update(change, volume, new_high, new_low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.mcclellanoscillator_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            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.mcclellanoscillator_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) McClellanOscillator.prototype[Symbol.dispose] = McClellanOscillator.prototype.free;
+
+export class McClellanSummationIndex {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        McClellanSummationIndexFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_mcclellansummationindex_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.mcclellansummationindex_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.mcclellansummationindex_new();
+        this.__wbg_ptr = ret;
+        McClellanSummationIndexFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.mcclellansummationindex_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @returns {number | undefined}
+     */
+    update(change, volume, new_high, new_low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.mcclellansummationindex_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            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.mcclellansummationindex_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) McClellanSummationIndex.prototype[Symbol.dispose] = McClellanSummationIndex.prototype.free;
+
 export class McGinleyDynamic {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -13905,6 +14984,74 @@ export class NVI {
 }
 if (Symbol.dispose) NVI.prototype[Symbol.dispose] = NVI.prototype.free;
 
+export class NewHighsNewLows {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        NewHighsNewLowsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_newhighsnewlows_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.newhighsnewlows_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.newhighsnewlows_new();
+        this.__wbg_ptr = ret;
+        NewHighsNewLowsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.newhighsnewlows_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @returns {number | undefined}
+     */
+    update(change, volume, new_high, new_low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.newhighsnewlows_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            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.newhighsnewlows_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) NewHighsNewLows.prototype[Symbol.dispose] = NewHighsNewLows.prototype.free;
+
 export class OBV {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -14743,18 +15890,111 @@ export class OrderBookImbalanceTopN {
             }
             return r0 === 0 ? undefined : r2;
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(32);
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.orderbookimbalancetopn_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) OrderBookImbalanceTopN.prototype[Symbol.dispose] = OrderBookImbalanceTopN.prototype.free;
+
+export class OuHalfLife {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OuHalfLifeFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ouhalflife_free(ptr, 0);
+    }
+    /**
+     * Batch over two equally-sized arrays. Returns one `f64` per
+     * input position (`NaN` during warmup).
+     * @param {Float64Array} x
+     * @param {Float64Array} y
+     * @returns {Float64Array}
+     */
+    batch(x, y) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(y, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.ouhalflife_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.ouhalflife_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ouhalflife_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;
+            OuHalfLifeFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.ouhalflife_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} x
+     * @param {number} y
+     * @returns {number | undefined}
+     */
+    update(x, y) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ouhalflife_update(retptr, this.__wbg_ptr, x, y);
+            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.orderbookimbalancetopn_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.ouhalflife_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) OrderBookImbalanceTopN.prototype[Symbol.dispose] = OrderBookImbalanceTopN.prototype.free;
+if (Symbol.dispose) OuHalfLife.prototype[Symbol.dispose] = OuHalfLife.prototype.free;
 
 export class PGO {
     __destroy_into_raw() {
@@ -15808,6 +17048,77 @@ export class PearsonCorrelation {
 }
 if (Symbol.dispose) PearsonCorrelation.prototype[Symbol.dispose] = PearsonCorrelation.prototype.free;
 
+export class PercentAboveMa {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PercentAboveMaFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_percentabovema_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.percentabovema_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.percentabovema_new();
+        this.__wbg_ptr = ret;
+        PercentAboveMaFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.percentabovema_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @param {Float64Array} above_ma
+     * @returns {number | undefined}
+     */
+    update(change, volume, new_high, new_low, above_ma) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            const ptr4 = passArrayF64ToWasm0(above_ma, wasm.__wbindgen_export3);
+            const len4 = WASM_VECTOR_LEN;
+            wasm.percentabovema_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
+            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.percentabovema_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) PercentAboveMa.prototype[Symbol.dispose] = PercentAboveMa.prototype.free;
+
 export class PercentB {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -17512,71 +18823,265 @@ export class RisingThreeMethods {
         return this;
     }
     reset() {
-        wasm.risingthreemethods_reset(this.__wbg_ptr);
+        wasm.risingthreemethods_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.risingthreemethods_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.risingthreemethods_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) RisingThreeMethods.prototype[Symbol.dispose] = RisingThreeMethods.prototype.free;
+
+export class RogersSatchellVolatility {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RogersSatchellVolatilityFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rogerssatchellvolatility_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.rogerssatchellvolatility_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.rogerssatchellvolatility_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     * @param {number} trading_periods
+     */
+    constructor(period, trading_periods) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rogerssatchellvolatility_new(retptr, period, trading_periods);
+            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;
+            RogersSatchellVolatilityFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.rogerssatchellvolatility_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.rogerssatchellvolatility_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.rogerssatchellvolatility_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) RogersSatchellVolatility.prototype[Symbol.dispose] = RogersSatchellVolatility.prototype.free;
+
+export class RollingCorrelation {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RollingCorrelationFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rollingcorrelation_free(ptr, 0);
+    }
+    /**
+     * Batch over two equally-sized arrays. Returns one `f64` per
+     * input position (`NaN` during warmup).
+     * @param {Float64Array} x
+     * @param {Float64Array} y
+     * @returns {Float64Array}
+     */
+    batch(x, y) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(y, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.rollingcorrelation_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.rollingcorrelation_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rollingcorrelation_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;
+            RollingCorrelationFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.rollingcorrelation_reset(this.__wbg_ptr);
     }
     /**
-     * @param {number} open
-     * @param {number} high
-     * @param {number} low
-     * @param {number} close
+     * @param {number} x
+     * @param {number} y
      * @returns {number | undefined}
      */
-    update(open, high, low, close) {
+    update(x, y) {
         try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
-            wasm.risingthreemethods_update(retptr, this.__wbg_ptr, open, high, low, close);
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rollingcorrelation_update(retptr, this.__wbg_ptr, x, y);
             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);
+            wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.risingthreemethods_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.rollingcorrelation_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) RisingThreeMethods.prototype[Symbol.dispose] = RisingThreeMethods.prototype.free;
+if (Symbol.dispose) RollingCorrelation.prototype[Symbol.dispose] = RollingCorrelation.prototype.free;
 
-export class RogersSatchellVolatility {
+export class RollingCovariance {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        RogersSatchellVolatilityFinalization.unregister(this);
+        RollingCovarianceFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_rogerssatchellvolatility_free(ptr, 0);
+        wasm.__wbg_rollingcovariance_free(ptr, 0);
     }
     /**
-     * @param {Float64Array} open
-     * @param {Float64Array} high
-     * @param {Float64Array} low
-     * @param {Float64Array} close
+     * Batch over two equally-sized arrays. Returns one `f64` per
+     * input position (`NaN` during warmup).
+     * @param {Float64Array} x
+     * @param {Float64Array} y
      * @returns {Float64Array}
      */
-    batch(open, high, low, close) {
+    batch(x, y) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passArrayF64ToWasm0(open, wasm.__wbindgen_export3);
+            const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_export3);
             const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const ptr1 = passArrayF64ToWasm0(y, 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.rogerssatchellvolatility_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            wasm.rollingcovariance_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);
@@ -17592,17 +19097,16 @@ export class RogersSatchellVolatility {
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.rogerssatchellvolatility_isReady(this.__wbg_ptr);
+        const ret = wasm.rollingcovariance_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
      * @param {number} period
-     * @param {number} trading_periods
      */
-    constructor(period, trading_periods) {
+    constructor(period) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.rogerssatchellvolatility_new(retptr, period, trading_periods);
+            wasm.rollingcovariance_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);
@@ -17610,47 +19114,40 @@ export class RogersSatchellVolatility {
                 throw takeObject(r1);
             }
             this.__wbg_ptr = r0;
-            RogersSatchellVolatilityFinalization.register(this, this.__wbg_ptr, this);
+            RollingCovarianceFinalization.register(this, this.__wbg_ptr, this);
             return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     reset() {
-        wasm.rogerssatchellvolatility_reset(this.__wbg_ptr);
+        wasm.rollingcovariance_reset(this.__wbg_ptr);
     }
     /**
-     * @param {number} open
-     * @param {number} high
-     * @param {number} low
-     * @param {number} close
+     * @param {number} x
+     * @param {number} y
      * @returns {number | undefined}
      */
-    update(open, high, low, close) {
+    update(x, y) {
         try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
-            wasm.rogerssatchellvolatility_update(retptr, this.__wbg_ptr, open, high, low, close);
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rollingcovariance_update(retptr, this.__wbg_ptr, x, y);
             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);
+            wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.rogerssatchellvolatility_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.rollingcovariance_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) RogersSatchellVolatility.prototype[Symbol.dispose] = RogersSatchellVolatility.prototype.free;
+if (Symbol.dispose) RollingCovariance.prototype[Symbol.dispose] = RollingCovariance.prototype.free;
 
 export class RollingVWAP {
     __destroy_into_raw() {
@@ -19077,6 +20574,187 @@ export class SpinningTop {
 }
 if (Symbol.dispose) SpinningTop.prototype[Symbol.dispose] = SpinningTop.prototype.free;
 
+export class SpreadBollingerBands {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SpreadBollingerBandsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_spreadbollingerbands_free(ptr, 0);
+    }
+    /**
+     * Flat `Float64Array` of length `4 * n`:
+     * `[middle0, upper0, lower0, percentB0, middle1, ...]`. 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.spreadbollingerbands_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.spreadbollingerbands_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     * @param {number} num_std
+     */
+    constructor(period, num_std) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.spreadbollingerbands_new(retptr, period, num_std);
+            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;
+            SpreadBollingerBandsFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.spreadbollingerbands_reset(this.__wbg_ptr);
+    }
+    /**
+     * Returns `{ middle, upper, lower, percentB }`, or `null` during warmup.
+     * @param {number} a
+     * @param {number} b
+     * @returns {any}
+     */
+    update(a, b) {
+        const ret = wasm.spreadbollingerbands_update(this.__wbg_ptr, a, b);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.spreadbollingerbands_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) SpreadBollingerBands.prototype[Symbol.dispose] = SpreadBollingerBands.prototype.free;
+
+export class SpreadHurst {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SpreadHurstFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_spreadhurst_free(ptr, 0);
+    }
+    /**
+     * Batch over two equally-sized arrays. Returns one `f64` per
+     * input position (`NaN` during warmup).
+     * @param {Float64Array} x
+     * @param {Float64Array} y
+     * @returns {Float64Array}
+     */
+    batch(x, y) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(y, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.spreadhurst_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.spreadhurst_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.spreadhurst_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;
+            SpreadHurstFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.spreadhurst_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} x
+     * @param {number} y
+     * @returns {number | undefined}
+     */
+    update(x, y) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.spreadhurst_update(retptr, this.__wbg_ptr, x, y);
+            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.spreadhurst_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) SpreadHurst.prototype[Symbol.dispose] = SpreadHurst.prototype.free;
+
 export class StalledPattern {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -22568,38 +24246,106 @@ export class Thrusting {
             if (r2) {
                 throw takeObject(r1);
             }
-            return takeObject(r0);
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.thrusting_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.thrusting_new();
+        this.__wbg_ptr = ret;
+        ThrustingFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.thrusting_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.thrusting_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(16);
+            wasm.__wbindgen_add_to_stack_pointer(32);
         }
     }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.thrusting_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) Thrusting.prototype[Symbol.dispose] = Thrusting.prototype.free;
+
+export class TickIndex {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TickIndexFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tickindex_free(ptr, 0);
+    }
     /**
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.thrusting_isReady(this.__wbg_ptr);
+        const ret = wasm.tickindex_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
     constructor() {
-        const ret = wasm.thrusting_new();
+        const ret = wasm.tickindex_new();
         this.__wbg_ptr = ret;
-        ThrustingFinalization.register(this, this.__wbg_ptr, this);
+        TickIndexFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     reset() {
-        wasm.thrusting_reset(this.__wbg_ptr);
+        wasm.tickindex_reset(this.__wbg_ptr);
     }
     /**
-     * @param {number} open
-     * @param {number} high
-     * @param {number} low
-     * @param {number} close
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
      * @returns {number | undefined}
      */
-    update(open, high, low, close) {
+    update(change, volume, new_high, new_low) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
-            wasm.thrusting_update(retptr, this.__wbg_ptr, open, high, low, close);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.tickindex_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
             var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
@@ -22616,11 +24362,11 @@ export class Thrusting {
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.thrusting_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.tickindex_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) Thrusting.prototype[Symbol.dispose] = Thrusting.prototype.free;
+if (Symbol.dispose) TickIndex.prototype[Symbol.dispose] = TickIndex.prototype.free;
 
 export class TpoProfile {
     __destroy_into_raw() {
@@ -22884,6 +24630,74 @@ export class TreynorRatio {
 }
 if (Symbol.dispose) TreynorRatio.prototype[Symbol.dispose] = TreynorRatio.prototype.free;
 
+export class Trin {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TrinFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_trin_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.trin_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.trin_new();
+        this.__wbg_ptr = ret;
+        TrinFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.trin_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @returns {number | undefined}
+     */
+    update(change, volume, new_high, new_low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.trin_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            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.trin_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) Trin.prototype[Symbol.dispose] = Trin.prototype.free;
+
 export class TrueRange {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -23564,6 +25378,74 @@ export class UniqueThreeRiver {
 }
 if (Symbol.dispose) UniqueThreeRiver.prototype[Symbol.dispose] = UniqueThreeRiver.prototype.free;
 
+export class UpDownVolumeRatio {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        UpDownVolumeRatioFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_updownvolumeratio_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.updownvolumeratio_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.updownvolumeratio_new();
+        this.__wbg_ptr = ret;
+        UpDownVolumeRatioFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.updownvolumeratio_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @returns {number | undefined}
+     */
+    update(change, volume, new_high, new_low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.updownvolumeratio_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            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.updownvolumeratio_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) UpDownVolumeRatio.prototype[Symbol.dispose] = UpDownVolumeRatio.prototype.free;
+
 export class UpsideGapThreeMethods {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -24330,6 +26212,100 @@ export class Variance {
 }
 if (Symbol.dispose) Variance.prototype[Symbol.dispose] = Variance.prototype.free;
 
+export class VarianceRatio {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        VarianceRatioFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_varianceratio_free(ptr, 0);
+    }
+    /**
+     * Batch over two equally-sized arrays of prices. Returns one `f64` per
+     * input position (`NaN` during warmup).
+     * @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.varianceratio_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.varianceratio_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     * @param {number} q
+     */
+    constructor(period, q) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.varianceratio_new(retptr, period, q);
+            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;
+            VarianceRatioFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.varianceratio_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} a
+     * @param {number} b
+     * @returns {number | undefined}
+     */
+    update(a, b) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.varianceratio_update(retptr, this.__wbg_ptr, a, b);
+            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.varianceratio_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) VarianceRatio.prototype[Symbol.dispose] = VarianceRatio.prototype.free;
+
 export class VerticalHorizontalFilter {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -26149,6 +28125,9 @@ export function __wbindgen_object_drop_ref(arg0) {
 const AbandonedBabyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_abandonedbaby_free(ptr, 1));
+const AbsoluteBreadthIndexFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_absolutebreadthindex_free(ptr, 1));
 const AccelerationBandsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_accelerationbands_free(ptr, 1));
@@ -26158,6 +28137,9 @@ const AcceleratorOscillatorFinalization = (typeof FinalizationRegistry === 'unde
 const WilliamsADFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_williamsad_free(ptr, 1));
+const AdVolumeLineFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_advolumeline_free(ptr, 1));
 const AdaptiveCycleFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_adaptivecycle_free(ptr, 1));
@@ -26167,6 +28149,12 @@ const ADLFinalization = (typeof FinalizationRegistry === 'undefined')
 const AdvanceBlockFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_advanceblock_free(ptr, 1));
+const AdvanceDeclineFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_advancedecline_free(ptr, 1));
+const AdvanceDeclineRatioFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_advancedeclineratio_free(ptr, 1));
 const ADXFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_adx_free(ptr, 1));
@@ -26233,12 +28221,21 @@ const BeltHoldFinalization = (typeof FinalizationRegistry === 'undefined')
 const BetaFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_beta_free(ptr, 1));
+const BetaNeutralSpreadFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_betaneutralspread_free(ptr, 1));
 const BollingerBandwidthFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_bollingerbandwidth_free(ptr, 1));
+const BreadthThrustFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_breadththrust_free(ptr, 1));
 const BreakawayFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_breakaway_free(ptr, 1));
+const BullishPercentIndexFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_bullishpercentindex_free(ptr, 1));
 const CalendarSpreadFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_calendarspread_free(ptr, 1));
@@ -26308,6 +28305,9 @@ const CounterattackFinalization = (typeof FinalizationRegistry === 'undefined')
 const CumulativeVolumeDeltaFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_cumulativevolumedelta_free(ptr, 1));
+const CumulativeVolumeIndexFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_cumulativevolumeindex_free(ptr, 1));
 const CyberneticCycleFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_cyberneticcycle_free(ptr, 1));
@@ -26332,6 +28332,9 @@ const DepthSlopeFinalization = (typeof FinalizationRegistry === 'undefined')
 const DetrendedStdDevFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_detrendedstddev_free(ptr, 1));
+const DistanceSsdFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_distancessd_free(ptr, 1));
 const DojiFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_doji_free(ptr, 1));
@@ -26434,6 +28437,9 @@ const GapSideBySideWhiteFinalization = (typeof FinalizationRegistry === 'undefin
 const GarmanKlassVolatilityFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_garmanklassvolatility_free(ptr, 1));
+const GrangerCausalityFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_grangercausality_free(ptr, 1));
 const GravestoneDojiFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_gravestonedoji_free(ptr, 1));
@@ -26452,6 +28458,9 @@ const HeikinAshiFinalization = (typeof FinalizationRegistry === 'undefined')
 const HiLoActivatorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_hiloactivator_free(ptr, 1));
+const HighLowIndexFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_highlowindex_free(ptr, 1));
 const HighWaveFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_highwave_free(ptr, 1));
@@ -26521,6 +28530,9 @@ const JMAFinalization = (typeof FinalizationRegistry === 'undefined')
 const KagiBarsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_kagibars_free(ptr, 1));
+const KalmanHedgeRatioFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_kalmanhedgeratio_free(ptr, 1));
 const KAMAFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_kama_free(ptr, 1));
@@ -26617,6 +28629,12 @@ const MatchingLowFinalization = (typeof FinalizationRegistry === 'undefined')
 const MaxDrawdownFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_maxdrawdown_free(ptr, 1));
+const McClellanOscillatorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_mcclellanoscillator_free(ptr, 1));
+const McClellanSummationIndexFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_mcclellansummationindex_free(ptr, 1));
 const McGinleyDynamicFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_mcginleydynamic_free(ptr, 1));
@@ -26656,6 +28674,9 @@ const MorningEveningStarFinalization = (typeof FinalizationRegistry === 'undefin
 const NATRFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_natr_free(ptr, 1));
+const NewHighsNewLowsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_newhighsnewlows_free(ptr, 1));
 const NVIFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_nvi_free(ptr, 1));
@@ -26692,6 +28713,9 @@ const OrderBookImbalanceTop1Finalization = (typeof FinalizationRegistry === 'und
 const OrderBookImbalanceTopNFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_orderbookimbalancetopn_free(ptr, 1));
+const OuHalfLifeFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ouhalflife_free(ptr, 1));
 const PainIndexFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_painindex_free(ptr, 1));
@@ -26707,6 +28731,9 @@ const ParkinsonVolatilityFinalization = (typeof FinalizationRegistry === 'undefi
 const PearsonCorrelationFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_pearsoncorrelation_free(ptr, 1));
+const PercentAboveMaFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_percentabovema_free(ptr, 1));
 const PercentBFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_percentb_free(ptr, 1));
@@ -26785,6 +28812,12 @@ const ROCR100Finalization = (typeof FinalizationRegistry === 'undefined')
 const RogersSatchellVolatilityFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rogerssatchellvolatility_free(ptr, 1));
+const RollingCorrelationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rollingcorrelation_free(ptr, 1));
+const RollingCovarianceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rollingcovariance_free(ptr, 1));
 const RollingVWAPFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rollingvwap_free(ptr, 1));
@@ -26845,6 +28878,12 @@ const SpearmanCorrelationFinalization = (typeof FinalizationRegistry === 'undefi
 const SpinningTopFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_spinningtop_free(ptr, 1));
+const SpreadBollingerBandsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_spreadbollingerbands_free(ptr, 1));
+const SpreadHurstFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_spreadhurst_free(ptr, 1));
 const StalledPatternFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_stalledpattern_free(ptr, 1));
@@ -26953,6 +28992,9 @@ const ThreeStarsInSouthFinalization = (typeof FinalizationRegistry === 'undefine
 const ThrustingFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_thrusting_free(ptr, 1));
+const TickIndexFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tickindex_free(ptr, 1));
 const TIIFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tii_free(ptr, 1));
@@ -26968,6 +29010,9 @@ const TreynorRatioFinalization = (typeof FinalizationRegistry === 'undefined')
 const TRIMAFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_trima_free(ptr, 1));
+const TrinFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_trin_free(ptr, 1));
 const TRIXFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_trix_free(ptr, 1));
@@ -27004,6 +29049,9 @@ const UltimateOscillatorFinalization = (typeof FinalizationRegistry === 'undefin
 const UniqueThreeRiverFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_uniquethreeriver_free(ptr, 1));
+const UpDownVolumeRatioFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_updownvolumeratio_free(ptr, 1));
 const UpsideGapThreeMethodsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_upsidegapthreemethods_free(ptr, 1));
@@ -27019,6 +29067,9 @@ const ValueAtRiskFinalization = (typeof FinalizationRegistry === 'undefined')
 const VarianceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_variance_free(ptr, 1));
+const VarianceRatioFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_varianceratio_free(ptr, 1));
 const VerticalHorizontalFilterFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_verticalhorizontalfilter_free(ptr, 1));