wickra-wasm 0.4.5 → 0.4.6

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;
@@ -4588,6 +4664,92 @@ export class DPO {
 }
 if (Symbol.dispose) DPO.prototype[Symbol.dispose] = DPO.prototype.free;
 
+export class DX {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DXFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_dx_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.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
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            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);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            DXFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.dx_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.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(32);
+        }
+    }
+}
+if (Symbol.dispose) DX.prototype[Symbol.dispose] = DX.prototype.free;
+
 export class Decycler {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -7819,164 +7981,330 @@ 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);
-            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-            if (r2) {
-                throw takeObject(r1);
-            }
-            return takeObject(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
+    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.hammer_isReady(this.__wbg_ptr);
+        const ret = wasm.ht_dcphase_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
     constructor() {
-        const ret = wasm.hammer_new();
+        const ret = wasm.ht_dcphase_new();
         this.__wbg_ptr = ret;
-        HammerFinalization.register(this, this.__wbg_ptr, this);
+        HT_DCPHASEFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     reset() {
-        wasm.hammer_reset(this.__wbg_ptr);
+        wasm.ht_dcphase_reset(this.__wbg_ptr);
     }
     /**
-     * @param {number} open
-     * @param {number} high
-     * @param {number} low
-     * @param {number} close
+     * @param {number} value
      * @returns {number | undefined}
      */
-    update(open, high, low, close) {
+    update(value) {
         try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
-            wasm.hammer_update(retptr, this.__wbg_ptr, open, high, low, close);
+            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);
-            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.hammer_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.ht_dcphase_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) Hammer.prototype[Symbol.dispose] = Hammer.prototype.free;
+if (Symbol.dispose) HT_DCPHASE.prototype[Symbol.dispose] = HT_DCPHASE.prototype.free;
 
-export class HangingMan {
+export class HT_PHASOR {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        HangingManFinalization.unregister(this);
+        HT_PHASORFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_hangingman_free(ptr, 0);
+        wasm.__wbg_ht_phasor_free(ptr, 0);
     }
     /**
-     * @param {Float64Array} open
-     * @param {Float64Array} high
-     * @param {Float64Array} low
-     * @param {Float64Array} close
+     * Returns a flat `Float64Array` of length `2 * n`: `[inphase0, quad0, ...]`.
+     * @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.hangingman_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.hangingman_isReady(this.__wbg_ptr);
-        return ret !== 0;
+    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.hangingman_new();
+        const ret = wasm.ht_phasor_new();
         this.__wbg_ptr = ret;
-        HangingManFinalization.register(this, this.__wbg_ptr, this);
+        HT_PHASORFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     reset() {
-        wasm.hangingman_reset(this.__wbg_ptr);
+        wasm.ht_phasor_reset(this.__wbg_ptr);
     }
     /**
-     * @param {number} open
-     * @param {number} high
-     * @param {number} low
-     * @param {number} close
-     * @returns {number | undefined}
+     * @param {number} value
+     * @returns {any}
      */
-    update(open, high, low, close) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
-            wasm.hangingman_update(retptr, this.__wbg_ptr, open, high, low, close);
+    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);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.hammer_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.hammer_new();
+        this.__wbg_ptr = ret;
+        HammerFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.hammer_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.hammer_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.hammer_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) Hammer.prototype[Symbol.dispose] = Hammer.prototype.free;
+
+export class HangingMan {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        HangingManFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_hangingman_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.hangingman_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.hangingman_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.hangingman_new();
+        this.__wbg_ptr = ret;
+        HangingManFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.hangingman_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.hangingman_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);
@@ -10687,51 +11015,127 @@ 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;
-            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);
+            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);
             }
-            return takeObject(r0);
+            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);
+    }
     /**
-     * @returns {boolean}
+     * @param {number} value
+     * @returns {number | undefined}
      */
-    isReady() {
+    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);
+            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.ladderbottom_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
@@ -11601,6 +12005,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;
@@ -11637,7 +12159,352 @@ export class MAMA {
     constructor(fast_limit, slow_limit) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.mama_new(retptr, fast_limit, slow_limit);
+            wasm.mama_new(retptr, fast_limit, slow_limit);
+            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;
+            MAMAFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.mama_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {any}
+     */
+    update(value) {
+        const ret = wasm.mama_update(this.__wbg_ptr, value);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.mama_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) MAMA.prototype[Symbol.dispose] = MAMA.prototype.free;
+
+export class MFI {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MFIFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_mfi_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @param {Float64Array} close
+     * @param {Float64Array} volume
+     * @returns {Float64Array}
+     */
+    batch(high, low, close, volume) {
+        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;
+            const ptr3 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.mfi_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.mfi_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.mfi_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;
+            MFIFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.mfi_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @param {number} volume
+     * @returns {number | undefined}
+     */
+    update(high, low, close, volume) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.mfi_update(retptr, this.__wbg_ptr, high, low, close, 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);
+            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.mfi_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) MFI.prototype[Symbol.dispose] = MFI.prototype.free;
+
+export class MIDPOINT {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MIDPOINTFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_midpoint_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.midpoint_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.midpoint_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            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);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            MIDPOINTFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.midpoint_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            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;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.midpoint_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) MIDPOINT.prototype[Symbol.dispose] = MIDPOINT.prototype.free;
+
+export class MIDPRICE {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MIDPRICEFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_midprice_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.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
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            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);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            MIDPRICEFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.midprice_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.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) MIDPRICE.prototype[Symbol.dispose] = MIDPRICE.prototype.free;
+
+export class MINUS_DI {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MINUS_DIFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_minus_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.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);
+            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.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);
@@ -11645,52 +12512,58 @@ export class MAMA {
                 throw takeObject(r1);
             }
             this.__wbg_ptr = r0;
-            MAMAFinalization.register(this, this.__wbg_ptr, this);
+            MINUS_DIFinalization.register(this, this.__wbg_ptr, this);
             return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     reset() {
-        wasm.mama_reset(this.__wbg_ptr);
-    }
-    /**
-     * @param {number} value
-     * @returns {any}
-     */
-    update(value) {
-        const ret = wasm.mama_update(this.__wbg_ptr, value);
-        return takeObject(ret);
+        wasm.minus_di_reset(this.__wbg_ptr);
     }
     /**
-     * @returns {number}
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @returns {number | undefined}
      */
-    warmupPeriod() {
-        const ret = wasm.mama_warmupPeriod(this.__wbg_ptr);
-        return ret >>> 0;
+    update(high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            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);
+            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) MAMA.prototype[Symbol.dispose] = MAMA.prototype.free;
+if (Symbol.dispose) MINUS_DI.prototype[Symbol.dispose] = MINUS_DI.prototype.free;
 
-export class MFI {
+export class MINUS_DM {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        MFIFinalization.unregister(this);
+        MINUS_DMFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_mfi_free(ptr, 0);
+        wasm.__wbg_minus_dm_free(ptr, 0);
     }
     /**
      * @param {Float64Array} high
      * @param {Float64Array} low
      * @param {Float64Array} close
-     * @param {Float64Array} volume
      * @returns {Float64Array}
      */
-    batch(high, low, close, volume) {
+    batch(high, low, close) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
@@ -11699,9 +12572,7 @@ export class MFI {
             const len1 = WASM_VECTOR_LEN;
             const ptr2 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
             const len2 = WASM_VECTOR_LEN;
-            const ptr3 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
-            const len3 = WASM_VECTOR_LEN;
-            wasm.mfi_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);
@@ -11713,20 +12584,13 @@ export class MFI {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-    /**
-     * @returns {boolean}
-     */
-    isReady() {
-        const ret = wasm.mfi_isReady(this.__wbg_ptr);
-        return ret !== 0;
-    }
     /**
      * @param {number} period
      */
     constructor(period) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.mfi_new(retptr, period);
+            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);
@@ -11734,26 +12598,25 @@ export class MFI {
                 throw takeObject(r1);
             }
             this.__wbg_ptr = r0;
-            MFIFinalization.register(this, this.__wbg_ptr, this);
+            MINUS_DMFinalization.register(this, this.__wbg_ptr, this);
             return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     reset() {
-        wasm.mfi_reset(this.__wbg_ptr);
+        wasm.minus_dm_reset(this.__wbg_ptr);
     }
     /**
      * @param {number} high
      * @param {number} low
      * @param {number} close
-     * @param {number} volume
      * @returns {number | undefined}
      */
-    update(high, low, close, volume) {
+    update(high, low, close) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
-            wasm.mfi_update(retptr, this.__wbg_ptr, high, low, close, volume);
+            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);
@@ -11766,15 +12629,8 @@ export class MFI {
             wasm.__wbindgen_add_to_stack_pointer(32);
         }
     }
-    /**
-     * @returns {number}
-     */
-    warmupPeriod() {
-        const ret = wasm.mfi_warmupPeriod(this.__wbg_ptr);
-        return ret >>> 0;
-    }
 }
-if (Symbol.dispose) MFI.prototype[Symbol.dispose] = MFI.prototype.free;
+if (Symbol.dispose) MINUS_DM.prototype[Symbol.dispose] = MINUS_DM.prototype.free;
 
 export class MOM {
     __destroy_into_raw() {
@@ -13866,18 +14722,211 @@ 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 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 +14939,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 +14968,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 +14980,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 +14994,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 +15012,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 +15025,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() {
@@ -15100,18 +16128,238 @@ export class PointAndFigureBars {
         }
     }
 }
-if (Symbol.dispose) PointAndFigureBars.prototype[Symbol.dispose] = PointAndFigureBars.prototype.free;
+if (Symbol.dispose) PointAndFigureBars.prototype[Symbol.dispose] = PointAndFigureBars.prototype.free;
+
+export class ProfitFactor {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ProfitFactorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_profitfactor_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.profitfactor_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.profitfactor_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.profitfactor_new(retptr, period);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            ProfitFactorFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.profitfactor_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.profitfactor_update(retptr, this.__wbg_ptr, value);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.profitfactor_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) ProfitFactor.prototype[Symbol.dispose] = ProfitFactor.prototype.free;
+
+export class 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 ProfitFactor {
+export class ROCP {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        ProfitFactorFinalization.unregister(this);
+        ROCPFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_profitfactor_free(ptr, 0);
+        wasm.__wbg_rocp_free(ptr, 0);
     }
     /**
      * @param {Float64Array} prices
@@ -15120,14 +16368,14 @@ export class ProfitFactor {
     batch(prices) {
         const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.profitfactor_batch(this.__wbg_ptr, ptr0, len0);
+        const ret = wasm.rocp_batch(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.profitfactor_isReady(this.__wbg_ptr);
+        const ret = wasm.rocp_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
@@ -15136,7 +16384,7 @@ export class ProfitFactor {
     constructor(period) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.profitfactor_new(retptr, period);
+            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);
@@ -15144,14 +16392,14 @@ export class ProfitFactor {
                 throw takeObject(r1);
             }
             this.__wbg_ptr = r0;
-            ProfitFactorFinalization.register(this, this.__wbg_ptr, this);
+            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 +16408,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 +16420,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 +16520,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 +16536,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 +16544,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 +16560,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 +16572,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() {
@@ -16584,6 +17840,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;
@@ -20202,6 +21551,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;
@@ -24793,6 +26218,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));
@@ -24931,6 +26359,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));
@@ -25042,6 +26473,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));
@@ -25123,6 +26563,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 +26590,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 +26632,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));
@@ -25258,6 +26719,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,6 +26773,15 @@ 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));
@@ -25327,6 +26803,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));
@@ -25495,6 +26974,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));