wickra-wasm 0.4.5 → 0.4.7

package/wickra_wasm_bg.js

@@ -516,6 +516,82 @@ export class ATR {
 }
 if (Symbol.dispose) ATR.prototype[Symbol.dispose] = ATR.prototype.free;
 
+export class AVGPRICE {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AVGPRICEFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_avgprice_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.avgprice_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);
+        }
+    }
+    constructor() {
+        const ret = wasm.avgprice_new();
+        this.__wbg_ptr = ret;
+        AVGPRICEFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.avgprice_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.avgprice_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);
+        }
+    }
+}
+if (Symbol.dispose) AVGPRICE.prototype[Symbol.dispose] = AVGPRICE.prototype.free;
+
 export class AbandonedBaby {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -943,6 +1019,74 @@ 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 Alligator {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -2251,6 +2395,99 @@ export class Beta {
 }
 if (Symbol.dispose) Beta.prototype[Symbol.dispose] = Beta.prototype.free;
 
+export class BetaNeutralSpread {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BetaNeutralSpreadFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_betaneutralspread_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.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);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.betaneutralspread_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            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);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            BetaNeutralSpreadFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.betaneutralspread_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.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;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.betaneutralspread_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) BetaNeutralSpread.prototype[Symbol.dispose] = BetaNeutralSpread.prototype.free;
+
 export class BollingerBands {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -4588,33 +4825,43 @@ export class DPO {
 }
 if (Symbol.dispose) DPO.prototype[Symbol.dispose] = DPO.prototype.free;
 
-export class Decycler {
+export class DX {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        DecyclerFinalization.unregister(this);
+        DXFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_decycler_free(ptr, 0);
+        wasm.__wbg_dx_free(ptr, 0);
     }
     /**
-     * @param {Float64Array} prices
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @param {Float64Array} close
      * @returns {Float64Array}
      */
-    batch(prices) {
-        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.decycler_batch(this.__wbg_ptr, ptr0, len0);
-        return takeObject(ret);
-    }
-    /**
-     * @returns {boolean}
-     */
-    isReady() {
-        const ret = wasm.decycler_isReady(this.__wbg_ptr);
-        return ret !== 0;
+    batch(high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.dx_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
      * @param {number} period
@@ -4622,7 +4869,7 @@ export class Decycler {
     constructor(period) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.decycler_new(retptr, period);
+            wasm.dx_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);
@@ -4630,28 +4877,104 @@ export class Decycler {
                 throw takeObject(r1);
             }
             this.__wbg_ptr = r0;
-            DecyclerFinalization.register(this, this.__wbg_ptr, this);
+            DXFinalization.register(this, this.__wbg_ptr, this);
             return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     reset() {
-        wasm.decycler_reset(this.__wbg_ptr);
+        wasm.dx_reset(this.__wbg_ptr);
     }
     /**
-     * @param {number} value
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
      * @returns {number | undefined}
      */
-    update(value) {
+    update(high, low, close) {
         try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.decycler_update(retptr, this.__wbg_ptr, value);
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.dx_update(retptr, this.__wbg_ptr, high, low, close);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
             return r0 === 0 ? undefined : r2;
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+}
+if (Symbol.dispose) DX.prototype[Symbol.dispose] = DX.prototype.free;
+
+export class Decycler {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DecyclerFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_decycler_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.decycler_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.decycler_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.decycler_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;
+            DecyclerFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.decycler_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.decycler_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);
         }
     }
     /**
@@ -5064,6 +5387,99 @@ export class DetrendedStdDev {
 }
 if (Symbol.dispose) DetrendedStdDev.prototype[Symbol.dispose] = DetrendedStdDev.prototype.free;
 
+export class DistanceSsd {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DistanceSsdFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_distancessd_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.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.distancessd_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            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);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            DistanceSsdFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.distancessd_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.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;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.distancessd_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) DistanceSsd.prototype[Symbol.dispose] = DistanceSsd.prototype.free;
+
 export class Doji {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -7653,6 +8069,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;
@@ -7819,38 +8329,204 @@ export class HMA {
 }
 if (Symbol.dispose) HMA.prototype[Symbol.dispose] = HMA.prototype.free;
 
-export class Hammer {
+export class HT_DCPHASE {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        HammerFinalization.unregister(this);
+        HT_DCPHASEFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_hammer_free(ptr, 0);
+        wasm.__wbg_ht_dcphase_free(ptr, 0);
     }
     /**
-     * @param {Float64Array} open
-     * @param {Float64Array} high
-     * @param {Float64Array} low
-     * @param {Float64Array} close
+     * @param {Float64Array} prices
      * @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.hammer_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);
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ht_dcphase_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.ht_dcphase_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.ht_dcphase_new();
+        this.__wbg_ptr = ret;
+        HT_DCPHASEFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.ht_dcphase_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ht_dcphase_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.ht_dcphase_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) HT_DCPHASE.prototype[Symbol.dispose] = HT_DCPHASE.prototype.free;
+
+export class HT_PHASOR {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        HT_PHASORFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ht_phasor_free(ptr, 0);
+    }
+    /**
+     * Returns a flat `Float64Array` of length `2 * n`: `[inphase0, quad0, ...]`.
+     * @param {Float64Array} prices
+     * @returns {Float64Array}
+     */
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ht_phasor_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    constructor() {
+        const ret = wasm.ht_phasor_new();
+        this.__wbg_ptr = ret;
+        HT_PHASORFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.ht_phasor_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {any}
+     */
+    update(value) {
+        const ret = wasm.ht_phasor_update(this.__wbg_ptr, value);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) HT_PHASOR.prototype[Symbol.dispose] = HT_PHASOR.prototype.free;
+
+export class HT_TRENDMODE {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        HT_TRENDMODEFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ht_trendmode_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.ht_trendmode_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.ht_trendmode_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.ht_trendmode_new();
+        this.__wbg_ptr = ret;
+        HT_TRENDMODEFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.ht_trendmode_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ht_trendmode_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.ht_trendmode_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) HT_TRENDMODE.prototype[Symbol.dispose] = HT_TRENDMODE.prototype.free;
+
+export class Hammer {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        HammerFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_hammer_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.hammer_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);
@@ -10179,6 +10855,94 @@ export class KagiBars {
 }
 if (Symbol.dispose) KagiBars.prototype[Symbol.dispose] = KagiBars.prototype.free;
 
+export class KalmanHedgeRatio {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        KalmanHedgeRatioFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_kalmanhedgeratio_free(ptr, 0);
+    }
+    /**
+     * Flat `Float64Array` of length `3 * n`:
+     * `[hedgeRatio0, intercept0, spread0, hedgeRatio1, ...]`. Warmup rows are NaN.
+     * @param {Float64Array} a
+     * @param {Float64Array} b
+     * @returns {Float64Array}
+     */
+    batch(a, b) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(a, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(b, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.kalmanhedgeratio_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.kalmanhedgeratio_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} delta
+     * @param {number} observation_var
+     */
+    constructor(delta, observation_var) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.kalmanhedgeratio_new(retptr, delta, observation_var);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            KalmanHedgeRatioFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.kalmanhedgeratio_reset(this.__wbg_ptr);
+    }
+    /**
+     * Returns `{ hedgeRatio, intercept, spread }`, or `null` during warmup.
+     * @param {number} a
+     * @param {number} b
+     * @returns {any}
+     */
+    update(a, b) {
+        const ret = wasm.kalmanhedgeratio_update(this.__wbg_ptr, a, b);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.kalmanhedgeratio_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) KalmanHedgeRatio.prototype[Symbol.dispose] = KalmanHedgeRatio.prototype.free;
+
 export class KellyCriterion {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -10687,33 +11451,109 @@ export class KylesLambda {
 }
 if (Symbol.dispose) KylesLambda.prototype[Symbol.dispose] = KylesLambda.prototype.free;
 
-export class LadderBottom {
+export class LINEARREG_INTERCEPT {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        LadderBottomFinalization.unregister(this);
+        LINEARREG_INTERCEPTFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_ladderbottom_free(ptr, 0);
+        wasm.__wbg_linearreg_intercept_free(ptr, 0);
     }
     /**
-     * @param {Float64Array} open
-     * @param {Float64Array} high
-     * @param {Float64Array} low
-     * @param {Float64Array} close
+     * @param {Float64Array} prices
      * @returns {Float64Array}
      */
-    batch(open, high, low, close) {
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.linearreg_intercept_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.linearreg_intercept_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
         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;
+            wasm.linearreg_intercept_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;
+            LINEARREG_INTERCEPTFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.linearreg_intercept_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.linearreg_intercept_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.linearreg_intercept_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) LINEARREG_INTERCEPT.prototype[Symbol.dispose] = LINEARREG_INTERCEPT.prototype.free;
+
+export class LadderBottom {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        LadderBottomFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ladderbottom_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.ladderbottom_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
@@ -11601,6 +12441,124 @@ export class MACD {
 }
 if (Symbol.dispose) MACD.prototype[Symbol.dispose] = MACD.prototype.free;
 
+export class MACDEXT {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MACDEXTFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_macdext_free(ptr, 0);
+    }
+    /**
+     * Returns a flat `Float64Array` of length `3 * n`: `[macd0, sig0, hist0, ...]`.
+     * @param {Float64Array} prices
+     * @returns {Float64Array}
+     */
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.macdext_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Moving-average types are TA-Lib `MA_Type` codes `0..=5`.
+     * @param {number} fast
+     * @param {number} fast_matype
+     * @param {number} slow
+     * @param {number} slow_matype
+     * @param {number} signal
+     * @param {number} signal_matype
+     */
+    constructor(fast, fast_matype, slow, slow_matype, signal, signal_matype) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.macdext_new(retptr, fast, fast_matype, slow, slow_matype, signal, signal_matype);
+            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;
+            MACDEXTFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.macdext_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {any}
+     */
+    update(value) {
+        const ret = wasm.macdext_update(this.__wbg_ptr, value);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) MACDEXT.prototype[Symbol.dispose] = MACDEXT.prototype.free;
+
+export class MACDFIX {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MACDFIXFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_macdfix_free(ptr, 0);
+    }
+    /**
+     * Returns a flat `Float64Array` of length `3 * n`: `[macd0, sig0, hist0, ...]`.
+     * @param {Float64Array} prices
+     * @returns {Float64Array}
+     */
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.macdfix_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @param {number} signal
+     */
+    constructor(signal) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.macdfix_new(retptr, signal);
+            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;
+            MACDFIXFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.macdfix_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {any}
+     */
+    update(value) {
+        const ret = wasm.macdfix_update(this.__wbg_ptr, value);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) MACDFIX.prototype[Symbol.dispose] = MACDFIX.prototype.free;
+
 export class MAMA {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -11776,16 +12734,16 @@ export class MFI {
 }
 if (Symbol.dispose) MFI.prototype[Symbol.dispose] = MFI.prototype.free;
 
-export class MOM {
+export class MIDPOINT {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        MOMFinalization.unregister(this);
+        MIDPOINTFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_mom_free(ptr, 0);
+        wasm.__wbg_midpoint_free(ptr, 0);
     }
     /**
      * @param {Float64Array} prices
@@ -11794,14 +12752,14 @@ export class MOM {
     batch(prices) {
         const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.mom_batch(this.__wbg_ptr, ptr0, len0);
+        const ret = wasm.midpoint_batch(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.mom_isReady(this.__wbg_ptr);
+        const ret = wasm.midpoint_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
@@ -11810,7 +12768,7 @@ export class MOM {
     constructor(period) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.mom_new(retptr, period);
+            wasm.midpoint_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);
@@ -11818,14 +12776,14 @@ export class MOM {
                 throw takeObject(r1);
             }
             this.__wbg_ptr = r0;
-            MOMFinalization.register(this, this.__wbg_ptr, this);
+            MIDPOINTFinalization.register(this, this.__wbg_ptr, this);
             return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     reset() {
-        wasm.mom_reset(this.__wbg_ptr);
+        wasm.midpoint_reset(this.__wbg_ptr);
     }
     /**
      * @param {number} value
@@ -11834,7 +12792,7 @@ export class MOM {
     update(value) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.mom_update(retptr, this.__wbg_ptr, value);
+            wasm.midpoint_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;
@@ -11846,49 +12804,57 @@ export class MOM {
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.mom_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.midpoint_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) MOM.prototype[Symbol.dispose] = MOM.prototype.free;
+if (Symbol.dispose) MIDPOINT.prototype[Symbol.dispose] = MIDPOINT.prototype.free;
 
-export class MaEnvelope {
+export class MIDPRICE {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        MaEnvelopeFinalization.unregister(this);
+        MIDPRICEFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_maenvelope_free(ptr, 0);
+        wasm.__wbg_midprice_free(ptr, 0);
     }
     /**
-     * Flat `[upper0, middle0, lower0, upper1, ...]`, length `3 * n`.
-     * @param {Float64Array} prices
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @param {Float64Array} close
      * @returns {Float64Array}
      */
-    batch(prices) {
-        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.maenvelope_batch(this.__wbg_ptr, ptr0, len0);
-        return takeObject(ret);
-    }
-    /**
-     * @returns {boolean}
-     */
-    isReady() {
-        const ret = wasm.maenvelope_isReady(this.__wbg_ptr);
-        return ret !== 0;
+    batch(high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.midprice_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
      * @param {number} period
-     * @param {number} percent
      */
-    constructor(period, percent) {
+    constructor(period) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.maenvelope_new(retptr, period, percent);
+            wasm.midprice_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);
@@ -11896,60 +12862,67 @@ export class MaEnvelope {
                 throw takeObject(r1);
             }
             this.__wbg_ptr = r0;
-            MaEnvelopeFinalization.register(this, this.__wbg_ptr, this);
+            MIDPRICEFinalization.register(this, this.__wbg_ptr, this);
             return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     reset() {
-        wasm.maenvelope_reset(this.__wbg_ptr);
-    }
-    /**
-     * @param {number} value
-     * @returns {any}
-     */
-    update(value) {
-        const ret = wasm.maenvelope_update(this.__wbg_ptr, value);
-        return takeObject(ret);
+        wasm.midprice_reset(this.__wbg_ptr);
     }
     /**
-     * @returns {number}
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @returns {number | undefined}
      */
-    warmupPeriod() {
-        const ret = wasm.maenvelope_warmupPeriod(this.__wbg_ptr);
-        return ret >>> 0;
+    update(high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.midprice_update(retptr, this.__wbg_ptr, high, low, close);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
     }
 }
-if (Symbol.dispose) MaEnvelope.prototype[Symbol.dispose] = MaEnvelope.prototype.free;
+if (Symbol.dispose) MIDPRICE.prototype[Symbol.dispose] = MIDPRICE.prototype.free;
 
-export class MarketFacilitationIndex {
+export class MINUS_DI {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        MarketFacilitationIndexFinalization.unregister(this);
+        MINUS_DIFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_marketfacilitationindex_free(ptr, 0);
+        wasm.__wbg_minus_di_free(ptr, 0);
     }
     /**
      * @param {Float64Array} high
      * @param {Float64Array} low
-     * @param {Float64Array} volume
+     * @param {Float64Array} close
      * @returns {Float64Array}
      */
-    batch(high, low, volume) {
+    batch(high, low, close) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
             const len0 = WASM_VECTOR_LEN;
             const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
             const len1 = WASM_VECTOR_LEN;
-            const ptr2 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const ptr2 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
             const len2 = WASM_VECTOR_LEN;
-            wasm.marketfacilitationindex_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            wasm.minus_di_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -11961,25 +12934,39 @@ export class MarketFacilitationIndex {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-    constructor() {
-        const ret = wasm.marketfacilitationindex_new();
-        this.__wbg_ptr = ret;
-        MarketFacilitationIndexFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.minus_di_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;
+            MINUS_DIFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     reset() {
-        wasm.marketfacilitationindex_reset(this.__wbg_ptr);
+        wasm.minus_di_reset(this.__wbg_ptr);
     }
     /**
      * @param {number} high
      * @param {number} low
-     * @param {number} volume
+     * @param {number} close
      * @returns {number | undefined}
      */
-    update(high, low, volume) {
+    update(high, low, close) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
-            wasm.marketfacilitationindex_update(retptr, this.__wbg_ptr, high, low, volume);
+            wasm.minus_di_update(retptr, this.__wbg_ptr, high, low, close);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
             var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
@@ -11993,38 +12980,35 @@ export class MarketFacilitationIndex {
         }
     }
 }
-if (Symbol.dispose) MarketFacilitationIndex.prototype[Symbol.dispose] = MarketFacilitationIndex.prototype.free;
+if (Symbol.dispose) MINUS_DI.prototype[Symbol.dispose] = MINUS_DI.prototype.free;
 
-export class Marubozu {
+export class MINUS_DM {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        MarubozuFinalization.unregister(this);
+        MINUS_DMFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_marubozu_free(ptr, 0);
+        wasm.__wbg_minus_dm_free(ptr, 0);
     }
     /**
-     * @param {Float64Array} open
      * @param {Float64Array} high
      * @param {Float64Array} low
      * @param {Float64Array} close
      * @returns {Float64Array}
      */
-    batch(open, high, low, close) {
+    batch(high, low, close) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passArrayF64ToWasm0(open, wasm.__wbindgen_export3);
+            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
             const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
             const len1 = WASM_VECTOR_LEN;
-            const ptr2 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const ptr2 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
             const len2 = WASM_VECTOR_LEN;
-            const ptr3 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
-            const len3 = WASM_VECTOR_LEN;
-            wasm.marubozu_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            wasm.minus_dm_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -12037,32 +13021,38 @@ export class Marubozu {
         }
     }
     /**
-     * @returns {boolean}
+     * @param {number} period
      */
-    isReady() {
-        const ret = wasm.marubozu_isReady(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    constructor() {
-        const ret = wasm.marubozu_new();
-        this.__wbg_ptr = ret;
-        MarubozuFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.minus_dm_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;
+            MINUS_DMFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     reset() {
-        wasm.marubozu_reset(this.__wbg_ptr);
+        wasm.minus_dm_reset(this.__wbg_ptr);
     }
     /**
-     * @param {number} open
      * @param {number} high
      * @param {number} low
      * @param {number} close
      * @returns {number | undefined}
      */
-    update(open, high, low, close) {
+    update(high, low, close) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
-            wasm.marubozu_update(retptr, this.__wbg_ptr, open, high, low, close);
+            wasm.minus_dm_update(retptr, this.__wbg_ptr, high, low, close);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
             var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
@@ -12075,84 +13065,213 @@ export class Marubozu {
             wasm.__wbindgen_add_to_stack_pointer(32);
         }
     }
+}
+if (Symbol.dispose) MINUS_DM.prototype[Symbol.dispose] = MINUS_DM.prototype.free;
+
+export class MOM {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MOMFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_mom_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.mom_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.mom_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.mom_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;
+            MOMFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.mom_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.mom_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.marubozu_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.mom_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) Marubozu.prototype[Symbol.dispose] = Marubozu.prototype.free;
+if (Symbol.dispose) MOM.prototype[Symbol.dispose] = MOM.prototype.free;
 
-export class MassIndex {
+export class MaEnvelope {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        MassIndexFinalization.unregister(this);
+        MaEnvelopeFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_massindex_free(ptr, 0);
+        wasm.__wbg_maenvelope_free(ptr, 0);
     }
     /**
-     * @param {Float64Array} high
-     * @param {Float64Array} low
+     * Flat `[upper0, middle0, lower0, upper1, ...]`, length `3 * n`.
+     * @param {Float64Array} prices
      * @returns {Float64Array}
      */
-    batch(high, low) {
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.maenvelope_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.maenvelope_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     * @param {number} percent
+     */
+    constructor(period, percent) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
-            const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
-            const len1 = WASM_VECTOR_LEN;
-            wasm.massindex_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            wasm.maenvelope_new(retptr, period, percent);
             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;
+            MaEnvelopeFinalization.register(this, this.__wbg_ptr, this);
+            return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    reset() {
+        wasm.maenvelope_reset(this.__wbg_ptr);
+    }
     /**
-     * @param {number} ema_period
-     * @param {number} sum_period
+     * @param {number} value
+     * @returns {any}
      */
-    constructor(ema_period, sum_period) {
+    update(value) {
+        const ret = wasm.maenvelope_update(this.__wbg_ptr, value);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.maenvelope_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) MaEnvelope.prototype[Symbol.dispose] = MaEnvelope.prototype.free;
+
+export class MarketFacilitationIndex {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MarketFacilitationIndexFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_marketfacilitationindex_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @param {Float64Array} volume
+     * @returns {Float64Array}
+     */
+    batch(high, low, volume) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.massindex_new(retptr, ema_period, sum_period);
+            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.marketfacilitationindex_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
             if (r2) {
                 throw takeObject(r1);
             }
-            this.__wbg_ptr = r0;
-            MassIndexFinalization.register(this, this.__wbg_ptr, this);
-            return this;
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    constructor() {
+        const ret = wasm.marketfacilitationindex_new();
+        this.__wbg_ptr = ret;
+        MarketFacilitationIndexFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
     reset() {
-        wasm.massindex_reset(this.__wbg_ptr);
+        wasm.marketfacilitationindex_reset(this.__wbg_ptr);
     }
     /**
      * @param {number} high
      * @param {number} low
+     * @param {number} volume
      * @returns {number | undefined}
      */
-    update(high, low) {
+    update(high, low, volume) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
-            wasm.massindex_update(retptr, this.__wbg_ptr, high, low);
+            wasm.marketfacilitationindex_update(retptr, this.__wbg_ptr, high, low, volume);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
             var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
@@ -12166,18 +13285,18 @@ export class MassIndex {
         }
     }
 }
-if (Symbol.dispose) MassIndex.prototype[Symbol.dispose] = MassIndex.prototype.free;
+if (Symbol.dispose) MarketFacilitationIndex.prototype[Symbol.dispose] = MarketFacilitationIndex.prototype.free;
 
-export class MatHold {
+export class Marubozu {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        MatHoldFinalization.unregister(this);
+        MarubozuFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_mathold_free(ptr, 0);
+        wasm.__wbg_marubozu_free(ptr, 0);
     }
     /**
      * @param {Float64Array} open
@@ -12197,7 +13316,180 @@ export class MatHold {
             const len2 = WASM_VECTOR_LEN;
             const ptr3 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
             const len3 = WASM_VECTOR_LEN;
-            wasm.mathold_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            wasm.marubozu_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.marubozu_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.marubozu_new();
+        this.__wbg_ptr = ret;
+        MarubozuFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.marubozu_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.marubozu_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.marubozu_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) Marubozu.prototype[Symbol.dispose] = Marubozu.prototype.free;
+
+export class MassIndex {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MassIndexFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_massindex_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @returns {Float64Array}
+     */
+    batch(high, low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.massindex_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);
+        }
+    }
+    /**
+     * @param {number} ema_period
+     * @param {number} sum_period
+     */
+    constructor(ema_period, sum_period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.massindex_new(retptr, ema_period, sum_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;
+            MassIndexFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.massindex_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} high
+     * @param {number} low
+     * @returns {number | undefined}
+     */
+    update(high, low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.massindex_update(retptr, this.__wbg_ptr, high, low);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+}
+if (Symbol.dispose) MassIndex.prototype[Symbol.dispose] = MassIndex.prototype.free;
+
+export class MatHold {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MatHoldFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_mathold_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.mathold_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);
@@ -13866,18 +15158,304 @@ export class OrderBookImbalanceTopN {
      * @param {Float64Array} ask_sz
      * @returns {number | undefined}
      */
-    update(bid_px, bid_sz, ask_px, ask_sz) {
+    update(bid_px, bid_sz, ask_px, ask_sz) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(bid_px, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(bid_sz, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(ask_px, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(ask_sz, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.orderbookimbalancetopn_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.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.ouhalflife_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) OuHalfLife.prototype[Symbol.dispose] = OuHalfLife.prototype.free;
+
+export class PGO {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PGOFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_pgo_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @param {Float64Array} close
+     * @returns {Float64Array}
+     */
+    batch(high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.pgo_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.pgo_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.pgo_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;
+            PGOFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.pgo_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @returns {number | undefined}
+     */
+    update(high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.pgo_update(retptr, this.__wbg_ptr, high, low, close);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.pgo_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) PGO.prototype[Symbol.dispose] = PGO.prototype.free;
+
+export class PLUS_DI {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PLUS_DIFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_plus_di_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @param {Float64Array} close
+     * @returns {Float64Array}
+     */
+    batch(high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.plus_di_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.plus_di_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;
+            PLUS_DIFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.plus_di_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @returns {number | undefined}
+     */
+    update(high, low, close) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
-            const ptr0 = passArrayF64ToWasm0(bid_px, wasm.__wbindgen_export3);
-            const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passArrayF64ToWasm0(bid_sz, wasm.__wbindgen_export3);
-            const len1 = WASM_VECTOR_LEN;
-            const ptr2 = passArrayF64ToWasm0(ask_px, wasm.__wbindgen_export3);
-            const len2 = WASM_VECTOR_LEN;
-            const ptr3 = passArrayF64ToWasm0(ask_sz, wasm.__wbindgen_export3);
-            const len3 = WASM_VECTOR_LEN;
-            wasm.orderbookimbalancetopn_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            wasm.plus_di_update(retptr, this.__wbg_ptr, high, low, close);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
             var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
@@ -13890,26 +15468,19 @@ export class OrderBookImbalanceTopN {
             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;
+if (Symbol.dispose) PLUS_DI.prototype[Symbol.dispose] = PLUS_DI.prototype.free;
 
-export class PGO {
+export class PLUS_DM {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        PGOFinalization.unregister(this);
+        PLUS_DMFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_pgo_free(ptr, 0);
+        wasm.__wbg_plus_dm_free(ptr, 0);
     }
     /**
      * @param {Float64Array} high
@@ -13926,7 +15497,7 @@ export class PGO {
             const len1 = WASM_VECTOR_LEN;
             const ptr2 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
             const len2 = WASM_VECTOR_LEN;
-            wasm.pgo_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            wasm.plus_dm_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -13938,20 +15509,13 @@ export class PGO {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-    /**
-     * @returns {boolean}
-     */
-    isReady() {
-        const ret = wasm.pgo_isReady(this.__wbg_ptr);
-        return ret !== 0;
-    }
     /**
      * @param {number} period
      */
     constructor(period) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.pgo_new(retptr, period);
+            wasm.plus_dm_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);
@@ -13959,14 +15523,14 @@ export class PGO {
                 throw takeObject(r1);
             }
             this.__wbg_ptr = r0;
-            PGOFinalization.register(this, this.__wbg_ptr, this);
+            PLUS_DMFinalization.register(this, this.__wbg_ptr, this);
             return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     reset() {
-        wasm.pgo_reset(this.__wbg_ptr);
+        wasm.plus_dm_reset(this.__wbg_ptr);
     }
     /**
      * @param {number} high
@@ -13977,7 +15541,7 @@ export class PGO {
     update(high, low, close) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
-            wasm.pgo_update(retptr, this.__wbg_ptr, high, low, close);
+            wasm.plus_dm_update(retptr, this.__wbg_ptr, high, low, close);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
             var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
@@ -13990,15 +15554,8 @@ export class PGO {
             wasm.__wbindgen_add_to_stack_pointer(32);
         }
     }
-    /**
-     * @returns {number}
-     */
-    warmupPeriod() {
-        const ret = wasm.pgo_warmupPeriod(this.__wbg_ptr);
-        return ret >>> 0;
-    }
 }
-if (Symbol.dispose) PGO.prototype[Symbol.dispose] = PGO.prototype.free;
+if (Symbol.dispose) PLUS_DM.prototype[Symbol.dispose] = PLUS_DM.prototype.free;
 
 export class PMO {
     __destroy_into_raw() {
@@ -15144,14 +16701,234 @@ export class ProfitFactor {
                 throw takeObject(r1);
             }
             this.__wbg_ptr = r0;
-            ProfitFactorFinalization.register(this, this.__wbg_ptr, this);
+            ProfitFactorFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.profitfactor_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.profitfactor_update(retptr, this.__wbg_ptr, value);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.profitfactor_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) ProfitFactor.prototype[Symbol.dispose] = ProfitFactor.prototype.free;
+
+export class QuotedSpread {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        QuotedSpreadFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_quotedspread_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.quotedspread_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.quotedspread_new();
+        this.__wbg_ptr = ret;
+        QuotedSpreadFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.quotedspread_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} bid_px
+     * @param {Float64Array} bid_sz
+     * @param {Float64Array} ask_px
+     * @param {Float64Array} ask_sz
+     * @returns {number | undefined}
+     */
+    update(bid_px, bid_sz, ask_px, ask_sz) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(bid_px, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(bid_sz, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(ask_px, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(ask_sz, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.quotedspread_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.quotedspread_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) QuotedSpread.prototype[Symbol.dispose] = QuotedSpread.prototype.free;
+
+export class ROC {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ROCFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_roc_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.roc_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.roc_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.roc_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;
+            ROCFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.roc_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.roc_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.roc_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) ROC.prototype[Symbol.dispose] = ROC.prototype.free;
+
+export class ROCP {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ROCPFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rocp_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.rocp_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.rocp_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rocp_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;
+            ROCPFinalization.register(this, this.__wbg_ptr, this);
             return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     reset() {
-        wasm.profitfactor_reset(this.__wbg_ptr);
+        wasm.rocp_reset(this.__wbg_ptr);
     }
     /**
      * @param {number} value
@@ -15160,7 +16937,7 @@ export class ProfitFactor {
     update(value) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.profitfactor_update(retptr, this.__wbg_ptr, value);
+            wasm.rocp_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;
@@ -15172,90 +16949,98 @@ export class ProfitFactor {
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.profitfactor_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.rocp_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) ProfitFactor.prototype[Symbol.dispose] = ProfitFactor.prototype.free;
+if (Symbol.dispose) ROCP.prototype[Symbol.dispose] = ROCP.prototype.free;
 
-export class QuotedSpread {
+export class ROCR {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        QuotedSpreadFinalization.unregister(this);
+        ROCRFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_quotedspread_free(ptr, 0);
+        wasm.__wbg_rocr_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.rocr_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
     }
     /**
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.quotedspread_isReady(this.__wbg_ptr);
+        const ret = wasm.rocr_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
-    constructor() {
-        const ret = wasm.quotedspread_new();
-        this.__wbg_ptr = ret;
-        QuotedSpreadFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rocr_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;
+            ROCRFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     reset() {
-        wasm.quotedspread_reset(this.__wbg_ptr);
+        wasm.rocr_reset(this.__wbg_ptr);
     }
     /**
-     * @param {Float64Array} bid_px
-     * @param {Float64Array} bid_sz
-     * @param {Float64Array} ask_px
-     * @param {Float64Array} ask_sz
+     * @param {number} value
      * @returns {number | undefined}
      */
-    update(bid_px, bid_sz, ask_px, ask_sz) {
+    update(value) {
         try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
-            const ptr0 = passArrayF64ToWasm0(bid_px, wasm.__wbindgen_export3);
-            const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passArrayF64ToWasm0(bid_sz, wasm.__wbindgen_export3);
-            const len1 = WASM_VECTOR_LEN;
-            const ptr2 = passArrayF64ToWasm0(ask_px, wasm.__wbindgen_export3);
-            const len2 = WASM_VECTOR_LEN;
-            const ptr3 = passArrayF64ToWasm0(ask_sz, wasm.__wbindgen_export3);
-            const len3 = WASM_VECTOR_LEN;
-            wasm.quotedspread_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rocr_update(retptr, this.__wbg_ptr, value);
             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.quotedspread_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.rocr_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) QuotedSpread.prototype[Symbol.dispose] = QuotedSpread.prototype.free;
+if (Symbol.dispose) ROCR.prototype[Symbol.dispose] = ROCR.prototype.free;
 
-export class ROC {
+export class ROCR100 {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        ROCFinalization.unregister(this);
+        ROCR100Finalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_roc_free(ptr, 0);
+        wasm.__wbg_rocr100_free(ptr, 0);
     }
     /**
      * @param {Float64Array} prices
@@ -15264,14 +17049,14 @@ export class ROC {
     batch(prices) {
         const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.roc_batch(this.__wbg_ptr, ptr0, len0);
+        const ret = wasm.rocr100_batch(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.roc_isReady(this.__wbg_ptr);
+        const ret = wasm.rocr100_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
@@ -15280,7 +17065,7 @@ export class ROC {
     constructor(period) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.roc_new(retptr, period);
+            wasm.rocr100_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);
@@ -15288,14 +17073,14 @@ export class ROC {
                 throw takeObject(r1);
             }
             this.__wbg_ptr = r0;
-            ROCFinalization.register(this, this.__wbg_ptr, this);
+            ROCR100Finalization.register(this, this.__wbg_ptr, this);
             return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     reset() {
-        wasm.roc_reset(this.__wbg_ptr);
+        wasm.rocr100_reset(this.__wbg_ptr);
     }
     /**
      * @param {number} value
@@ -15304,7 +17089,7 @@ export class ROC {
     update(value) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.roc_update(retptr, this.__wbg_ptr, value);
+            wasm.rocr100_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;
@@ -15316,11 +17101,11 @@ export class ROC {
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.roc_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.rocr100_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) ROC.prototype[Symbol.dispose] = ROC.prototype.free;
+if (Symbol.dispose) ROCR100.prototype[Symbol.dispose] = ROCR100.prototype.free;
 
 export class RSI {
     __destroy_into_raw() {
@@ -16336,17 +18121,210 @@ export class RogersSatchellVolatility {
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.rogerssatchellvolatility_isReady(this.__wbg_ptr);
+        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} x
+     * @param {number} y
+     * @returns {number | undefined}
+     */
+    update(x, y) {
+        try {
+            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);
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.rollingcorrelation_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) RollingCorrelation.prototype[Symbol.dispose] = RollingCorrelation.prototype.free;
+
+export class RollingCovariance {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RollingCovarianceFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rollingcovariance_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.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);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        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);
@@ -16354,47 +18332,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() {
@@ -16584,6 +18555,99 @@ export class RoofingFilter {
 }
 if (Symbol.dispose) RoofingFilter.prototype[Symbol.dispose] = RoofingFilter.prototype.free;
 
+export class SAREXT {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SAREXTFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_sarext_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @param {Float64Array} close
+     * @returns {Float64Array}
+     */
+    batch(high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.sarext_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @param {number} start_value
+     * @param {number} offset_on_reverse
+     * @param {number} accel_init_long
+     * @param {number} accel_long
+     * @param {number} accel_max_long
+     * @param {number} accel_init_short
+     * @param {number} accel_short
+     * @param {number} accel_max_short
+     */
+    constructor(start_value, offset_on_reverse, accel_init_long, accel_long, accel_max_long, accel_init_short, accel_short, accel_max_short) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.sarext_new(retptr, start_value, offset_on_reverse, accel_init_long, accel_long, accel_max_long, accel_init_short, accel_short, accel_max_short);
+            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;
+            SAREXTFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.sarext_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @returns {number | undefined}
+     */
+    update(high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.sarext_update(retptr, this.__wbg_ptr, high, low, close);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+}
+if (Symbol.dispose) SAREXT.prototype[Symbol.dispose] = SAREXT.prototype.free;
+
 export class SMA {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -17632,42 +19696,216 @@ export class SpearmanCorrelation {
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.spearmancorrelation_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.spearmancorrelation_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) SpearmanCorrelation.prototype[Symbol.dispose] = SpearmanCorrelation.prototype.free;
+
+export class SpinningTop {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SpinningTopFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_spinningtop_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.spinningtop_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.spinningtop_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.spinningtop_new();
+        this.__wbg_ptr = ret;
+        SpinningTopFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.spinningtop_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.spinningtop_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.spinningtop_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+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) SpearmanCorrelation.prototype[Symbol.dispose] = SpearmanCorrelation.prototype.free;
+if (Symbol.dispose) SpreadBollingerBands.prototype[Symbol.dispose] = SpreadBollingerBands.prototype.free;
 
-export class SpinningTop {
+export class SpreadHurst {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        SpinningTopFinalization.unregister(this);
+        SpreadHurstFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_spinningtop_free(ptr, 0);
+        wasm.__wbg_spreadhurst_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.spinningtop_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            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);
@@ -17683,50 +19921,57 @@ export class SpinningTop {
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.spinningtop_isReady(this.__wbg_ptr);
+        const ret = wasm.spreadhurst_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
-    constructor() {
-        const ret = wasm.spinningtop_new();
-        this.__wbg_ptr = ret;
-        SpinningTopFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    /**
+     * @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.spinningtop_reset(this.__wbg_ptr);
+        wasm.spreadhurst_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.spinningtop_update(retptr, this.__wbg_ptr, open, high, low, close);
+            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);
-            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.spinningtop_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.spreadhurst_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) SpinningTop.prototype[Symbol.dispose] = SpinningTop.prototype.free;
+if (Symbol.dispose) SpreadHurst.prototype[Symbol.dispose] = SpreadHurst.prototype.free;
 
 export class StalledPattern {
     __destroy_into_raw() {
@@ -20202,6 +22447,82 @@ export class TRIX {
 }
 if (Symbol.dispose) TRIX.prototype[Symbol.dispose] = TRIX.prototype.free;
 
+export class TSF {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TSFFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tsf_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.tsf_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.tsf_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.tsf_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;
+            TSFFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.tsf_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.tsf_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.tsf_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) TSF.prototype[Symbol.dispose] = TSF.prototype.free;
+
 export class TSI {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -22905,6 +25226,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;
@@ -24742,6 +27157,9 @@ 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 ADXFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_adx_free(ptr, 1));
@@ -24793,6 +27211,9 @@ const AutocorrelationFinalization = (typeof FinalizationRegistry === 'undefined'
 const AverageDrawdownFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_averagedrawdown_free(ptr, 1));
+const AVGPRICEFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_avgprice_free(ptr, 1));
 const BalanceOfPowerFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_balanceofpower_free(ptr, 1));
@@ -24805,6 +27226,9 @@ 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));
@@ -24904,6 +27328,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));
@@ -24931,6 +27358,9 @@ const DragonflyDojiFinalization = (typeof FinalizationRegistry === 'undefined')
 const DrawdownDurationFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_drawdownduration_free(ptr, 1));
+const DXFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_dx_free(ptr, 1));
 const EaseOfMovementFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_easeofmovement_free(ptr, 1));
@@ -25003,6 +27433,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));
@@ -25042,6 +27475,15 @@ const HMAFinalization = (typeof FinalizationRegistry === 'undefined')
 const HomingPigeonFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_homingpigeon_free(ptr, 1));
+const HT_DCPHASEFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ht_dcphase_free(ptr, 1));
+const HT_PHASORFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ht_phasor_free(ptr, 1));
+const HT_TRENDMODEFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ht_trendmode_free(ptr, 1));
 const HurstChannelFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_hurstchannel_free(ptr, 1));
@@ -25081,6 +27523,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));
@@ -25123,6 +27568,9 @@ const LinRegAngleFinalization = (typeof FinalizationRegistry === 'undefined')
 const LinRegChannelFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_linregchannel_free(ptr, 1));
+const LINEARREG_INTERCEPTFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_linearreg_intercept_free(ptr, 1));
 const LinRegSlopeFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_linregslope_free(ptr, 1));
@@ -25147,6 +27595,12 @@ const MaEnvelopeFinalization = (typeof FinalizationRegistry === 'undefined')
 const MACDFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_macd_free(ptr, 1));
+const MACDEXTFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_macdext_free(ptr, 1));
+const MACDFIXFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_macdfix_free(ptr, 1));
 const MAMAFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_mama_free(ptr, 1));
@@ -25183,6 +27637,18 @@ const MFIFinalization = (typeof FinalizationRegistry === 'undefined')
 const MicropriceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_microprice_free(ptr, 1));
+const MIDPOINTFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_midpoint_free(ptr, 1));
+const MIDPRICEFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_midprice_free(ptr, 1));
+const MINUS_DIFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_minus_di_free(ptr, 1));
+const MINUS_DMFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_minus_dm_free(ptr, 1));
 const MOMFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_mom_free(ptr, 1));
@@ -25231,6 +27697,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));
@@ -25258,6 +27727,12 @@ const PGOFinalization = (typeof FinalizationRegistry === 'undefined')
 const PiercingDarkCloudFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_piercingdarkcloud_free(ptr, 1));
+const PLUS_DIFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_plus_di_free(ptr, 1));
+const PLUS_DMFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_plus_dm_free(ptr, 1));
 const PMOFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_pmo_free(ptr, 1));
@@ -25306,9 +27781,24 @@ const RisingThreeMethodsFinalization = (typeof FinalizationRegistry === 'undefin
 const ROCFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_roc_free(ptr, 1));
+const ROCPFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rocp_free(ptr, 1));
+const ROCRFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rocr_free(ptr, 1));
+const ROCR100Finalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rocr100_free(ptr, 1));
 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));
@@ -25327,6 +27817,9 @@ const RVIVolatilityFinalization = (typeof FinalizationRegistry === 'undefined')
 const RWIFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rwi_free(ptr, 1));
+const SAREXTFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sarext_free(ptr, 1));
 const SeparatingLinesFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_separatinglines_free(ptr, 1));
@@ -25366,6 +27859,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));
@@ -25495,6 +27994,9 @@ const TRIXFinalization = (typeof FinalizationRegistry === 'undefined')
 const TrueRangeFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_truerange_free(ptr, 1));
+const TSFFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tsf_free(ptr, 1));
 const TSIFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tsi_free(ptr, 1));
@@ -25537,6 +28039,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));