wickra-wasm 0.5.1 → 0.5.3

package/wickra_wasm_bg.js

@@ -682,6 +682,96 @@ export class AbandonedBaby {
 }
 if (Symbol.dispose) AbandonedBaby.prototype[Symbol.dispose] = AbandonedBaby.prototype.free;
 
+export class Abcd {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AbcdFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_abcd_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.abcd_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.abcd_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.abcd_new();
+        this.__wbg_ptr = ret;
+        AbcdFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.abcd_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.abcd_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.abcd_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) Abcd.prototype[Symbol.dispose] = Abcd.prototype.free;
+
 export class AbsoluteBreadthIndex {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -1992,6 +2082,87 @@ export class AtrTrailingStop {
 }
 if (Symbol.dispose) AtrTrailingStop.prototype[Symbol.dispose] = AtrTrailingStop.prototype.free;
 
+export class AutoFib {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AutoFibFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_autofib_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @returns {Float64Array}
+     */
+    batch(high, low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.autofib_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.autofib_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.autofib_new();
+        this.__wbg_ptr = ret;
+        AutoFibFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.autofib_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} high
+     * @param {number} low
+     * @returns {any}
+     */
+    update(high, low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.autofib_update(retptr, this.__wbg_ptr, high, low);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.autofib_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) AutoFib.prototype[Symbol.dispose] = AutoFib.prototype.free;
+
 export class Autocorrelation {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -2493,6 +2664,96 @@ export class BalanceOfPower {
 }
 if (Symbol.dispose) BalanceOfPower.prototype[Symbol.dispose] = BalanceOfPower.prototype.free;
 
+export class Bat {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BatFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_bat_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.bat_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.bat_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.bat_new();
+        this.__wbg_ptr = ret;
+        BatFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.bat_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.bat_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.bat_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) Bat.prototype[Symbol.dispose] = Bat.prototype.free;
+
 export class BeltHold {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -3146,33 +3407,36 @@ export class BullishPercentIndex {
 }
 if (Symbol.dispose) BullishPercentIndex.prototype[Symbol.dispose] = BullishPercentIndex.prototype.free;
 
-export class CCI {
+export class Butterfly {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        CCIFinalization.unregister(this);
+        ButterflyFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_cci_free(ptr, 0);
+        wasm.__wbg_butterfly_free(ptr, 0);
     }
     /**
+     * @param {Float64Array} open
      * @param {Float64Array} high
      * @param {Float64Array} low
      * @param {Float64Array} close
      * @returns {Float64Array}
      */
-    batch(high, low, close) {
+    batch(open, high, low, close) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const ptr0 = passArrayF64ToWasm0(open, wasm.__wbindgen_export3);
             const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const ptr1 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
             const len1 = WASM_VECTOR_LEN;
-            const ptr2 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
+            const ptr2 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
             const len2 = WASM_VECTOR_LEN;
-            wasm.cci_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            const ptr3 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.butterfly_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);
@@ -3188,11 +3452,98 @@ export class CCI {
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.cci_isReady(this.__wbg_ptr);
+        const ret = wasm.butterfly_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
+    constructor() {
+        const ret = wasm.butterfly_new();
+        this.__wbg_ptr = ret;
+        ButterflyFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.butterfly_reset(this.__wbg_ptr);
+    }
     /**
-     * @param {number} period
+     * @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.butterfly_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.butterfly_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) Butterfly.prototype[Symbol.dispose] = Butterfly.prototype.free;
+
+export class CCI {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CCIFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_cci_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.cci_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.cci_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
      */
     constructor(period) {
         try {
@@ -4972,6 +5323,96 @@ export class Counterattack {
 }
 if (Symbol.dispose) Counterattack.prototype[Symbol.dispose] = Counterattack.prototype.free;
 
+export class Crab {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CrabFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_crab_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.crab_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.crab_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.crab_new();
+        this.__wbg_ptr = ret;
+        CrabFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.crab_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.crab_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.crab_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) Crab.prototype[Symbol.dispose] = Crab.prototype.free;
+
 export class CumulativeVolumeDelta {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -5099,92 +5540,106 @@ export class CumulativeVolumeIndex {
 }
 if (Symbol.dispose) CumulativeVolumeIndex.prototype[Symbol.dispose] = CumulativeVolumeIndex.prototype.free;
 
-export class CyberneticCycle {
+export class CupAndHandle {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        CyberneticCycleFinalization.unregister(this);
+        CupAndHandleFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_cyberneticcycle_free(ptr, 0);
+        wasm.__wbg_cupandhandle_free(ptr, 0);
     }
     /**
-     * @param {Float64Array} prices
+     * @param {Float64Array} open
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @param {Float64Array} close
      * @returns {Float64Array}
      */
-    batch(prices) {
-        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.cyberneticcycle_batch(this.__wbg_ptr, ptr0, len0);
-        return takeObject(ret);
-    }
-    /**
-     * @returns {boolean}
-     */
-    isReady() {
-        const ret = wasm.cyberneticcycle_isReady(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * @param {number} period
-     */
-    constructor(period) {
+    batch(open, high, low, close) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.cyberneticcycle_new(retptr, period);
+            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.cupandhandle_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);
             }
-            this.__wbg_ptr = r0;
-            CyberneticCycleFinalization.register(this, this.__wbg_ptr, this);
-            return this;
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.cupandhandle_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.cupandhandle_new();
+        this.__wbg_ptr = ret;
+        CupAndHandleFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
     reset() {
-        wasm.cyberneticcycle_reset(this.__wbg_ptr);
+        wasm.cupandhandle_reset(this.__wbg_ptr);
     }
     /**
-     * @param {number} value
+     * @param {number} open
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
      * @returns {number | undefined}
      */
-    update(value) {
+    update(open, high, low, close) {
         try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.cyberneticcycle_update(retptr, this.__wbg_ptr, value);
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.cupandhandle_update(retptr, this.__wbg_ptr, open, high, low, close);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
             return r0 === 0 ? undefined : r2;
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_add_to_stack_pointer(32);
         }
     }
     /**
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.cyberneticcycle_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.cupandhandle_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) CyberneticCycle.prototype[Symbol.dispose] = CyberneticCycle.prototype.free;
+if (Symbol.dispose) CupAndHandle.prototype[Symbol.dispose] = CupAndHandle.prototype.free;
 
-export class DEMA {
+export class CyberneticCycle {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        DEMAFinalization.unregister(this);
+        CyberneticCycleFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_dema_free(ptr, 0);
+        wasm.__wbg_cyberneticcycle_free(ptr, 0);
     }
     /**
      * @param {Float64Array} prices
@@ -5193,14 +5648,14 @@ export class DEMA {
     batch(prices) {
         const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.dema_batch(this.__wbg_ptr, ptr0, len0);
+        const ret = wasm.cyberneticcycle_batch(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.dema_isReady(this.__wbg_ptr);
+        const ret = wasm.cyberneticcycle_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
@@ -5209,7 +5664,7 @@ export class DEMA {
     constructor(period) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.dema_new(retptr, period);
+            wasm.cyberneticcycle_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);
@@ -5217,14 +5672,14 @@ export class DEMA {
                 throw takeObject(r1);
             }
             this.__wbg_ptr = r0;
-            DEMAFinalization.register(this, this.__wbg_ptr, this);
+            CyberneticCycleFinalization.register(this, this.__wbg_ptr, this);
             return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     reset() {
-        wasm.dema_reset(this.__wbg_ptr);
+        wasm.cyberneticcycle_reset(this.__wbg_ptr);
     }
     /**
      * @param {number} value
@@ -5233,7 +5688,7 @@ export class DEMA {
     update(value) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.dema_update(retptr, this.__wbg_ptr, value);
+            wasm.cyberneticcycle_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;
@@ -5245,34 +5700,200 @@ export class DEMA {
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.dema_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.cyberneticcycle_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) DEMA.prototype[Symbol.dispose] = DEMA.prototype.free;
+if (Symbol.dispose) CyberneticCycle.prototype[Symbol.dispose] = CyberneticCycle.prototype.free;
 
-export class DPO {
+export class Cypher {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        DPOFinalization.unregister(this);
+        CypherFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_dpo_free(ptr, 0);
+        wasm.__wbg_cypher_free(ptr, 0);
     }
     /**
-     * @param {Float64Array} prices
+     * @param {Float64Array} open
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @param {Float64Array} close
      * @returns {Float64Array}
      */
-    batch(prices) {
-        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.dpo_batch(this.__wbg_ptr, ptr0, len0);
-        return takeObject(ret);
-    }
-    /**
+    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.cypher_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.cypher_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.cypher_new();
+        this.__wbg_ptr = ret;
+        CypherFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.cypher_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.cypher_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.cypher_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) Cypher.prototype[Symbol.dispose] = Cypher.prototype.free;
+
+export class DEMA {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DEMAFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_dema_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.dema_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.dema_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.dema_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;
+            DEMAFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.dema_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.dema_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.dema_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) DEMA.prototype[Symbol.dispose] = DEMA.prototype.free;
+
+export class DPO {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DPOFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_dpo_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.dpo_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
      * @returns {boolean}
      */
     isReady() {
@@ -6494,6 +7115,96 @@ export class DoubleBollinger {
 }
 if (Symbol.dispose) DoubleBollinger.prototype[Symbol.dispose] = DoubleBollinger.prototype.free;
 
+export class DoubleTopBottom {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DoubleTopBottomFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_doubletopbottom_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.doubletopbottom_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.doubletopbottom_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.doubletopbottom_new();
+        this.__wbg_ptr = ret;
+        DoubleTopBottomFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.doubletopbottom_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.doubletopbottom_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.doubletopbottom_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) DoubleTopBottom.prototype[Symbol.dispose] = DoubleTopBottom.prototype.free;
+
 export class DownsideGapThreeMethods {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -7703,33 +8414,30 @@ export class FallingThreeMethods {
 }
 if (Symbol.dispose) FallingThreeMethods.prototype[Symbol.dispose] = FallingThreeMethods.prototype.free;
 
-export class FibonacciPivots {
+export class FibArcs {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        FibonacciPivotsFinalization.unregister(this);
+        FibArcsFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_fibonaccipivots_free(ptr, 0);
+        wasm.__wbg_fibarcs_free(ptr, 0);
     }
     /**
      * @param {Float64Array} high
      * @param {Float64Array} low
-     * @param {Float64Array} close
      * @returns {Float64Array}
      */
-    batch(high, low, close) {
+    batch(high, low) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
             const len0 = WASM_VECTOR_LEN;
             const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
             const len1 = WASM_VECTOR_LEN;
-            const ptr2 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
-            const len2 = WASM_VECTOR_LEN;
-            wasm.fibonaccipivots_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            wasm.fibarcs_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -7745,25 +8453,676 @@ export class FibonacciPivots {
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.fibonaccipivots_isReady(this.__wbg_ptr);
+        const ret = wasm.fibarcs_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
     constructor() {
-        const ret = wasm.fibonaccipivots_new();
+        const ret = wasm.fibarcs_new();
         this.__wbg_ptr = ret;
-        FibonacciPivotsFinalization.register(this, this.__wbg_ptr, this);
+        FibArcsFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     reset() {
-        wasm.fibonaccipivots_reset(this.__wbg_ptr);
+        wasm.fibarcs_reset(this.__wbg_ptr);
     }
     /**
      * @param {number} high
      * @param {number} low
-     * @param {number} close
      * @returns {any}
      */
-    update(high, low, close) {
+    update(high, low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.fibarcs_update(retptr, this.__wbg_ptr, high, low);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.fibarcs_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) FibArcs.prototype[Symbol.dispose] = FibArcs.prototype.free;
+
+export class FibChannel {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FibChannelFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_fibchannel_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @returns {Float64Array}
+     */
+    batch(high, low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.fibchannel_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.fibchannel_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.fibchannel_new();
+        this.__wbg_ptr = ret;
+        FibChannelFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.fibchannel_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} high
+     * @param {number} low
+     * @returns {any}
+     */
+    update(high, low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.fibchannel_update(retptr, this.__wbg_ptr, high, low);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.fibchannel_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) FibChannel.prototype[Symbol.dispose] = FibChannel.prototype.free;
+
+export class FibConfluence {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FibConfluenceFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_fibconfluence_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @returns {Float64Array}
+     */
+    batch(high, low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.fibconfluence_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.fibconfluence_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.fibconfluence_new();
+        this.__wbg_ptr = ret;
+        FibConfluenceFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.fibconfluence_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} high
+     * @param {number} low
+     * @returns {any}
+     */
+    update(high, low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.fibconfluence_update(retptr, this.__wbg_ptr, high, low);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.fibconfluence_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) FibConfluence.prototype[Symbol.dispose] = FibConfluence.prototype.free;
+
+export class FibExtension {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FibExtensionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_fibextension_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @returns {Float64Array}
+     */
+    batch(high, low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.fibextension_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.fibextension_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.fibextension_new();
+        this.__wbg_ptr = ret;
+        FibExtensionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.fibextension_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} high
+     * @param {number} low
+     * @returns {any}
+     */
+    update(high, low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.fibextension_update(retptr, this.__wbg_ptr, high, low);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.fibextension_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) FibExtension.prototype[Symbol.dispose] = FibExtension.prototype.free;
+
+export class FibFan {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FibFanFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_fibfan_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @returns {Float64Array}
+     */
+    batch(high, low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.fibfan_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.fibfan_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.fibfan_new();
+        this.__wbg_ptr = ret;
+        FibFanFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.fibfan_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} high
+     * @param {number} low
+     * @returns {any}
+     */
+    update(high, low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.fibfan_update(retptr, this.__wbg_ptr, high, low);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.fibfan_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) FibFan.prototype[Symbol.dispose] = FibFan.prototype.free;
+
+export class FibProjection {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FibProjectionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_fibprojection_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @returns {Float64Array}
+     */
+    batch(high, low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.fibprojection_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.fibprojection_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.fibprojection_new();
+        this.__wbg_ptr = ret;
+        FibProjectionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.fibprojection_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} high
+     * @param {number} low
+     * @returns {any}
+     */
+    update(high, low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.fibprojection_update(retptr, this.__wbg_ptr, high, low);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.fibprojection_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) FibProjection.prototype[Symbol.dispose] = FibProjection.prototype.free;
+
+export class FibRetracement {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FibRetracementFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_fibretracement_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @returns {Float64Array}
+     */
+    batch(high, low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.fibretracement_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.fibretracement_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.fibretracement_new();
+        this.__wbg_ptr = ret;
+        FibRetracementFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.fibretracement_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} high
+     * @param {number} low
+     * @returns {any}
+     */
+    update(high, low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.fibretracement_update(retptr, this.__wbg_ptr, high, low);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.fibretracement_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) FibRetracement.prototype[Symbol.dispose] = FibRetracement.prototype.free;
+
+export class FibTimeZones {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FibTimeZonesFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_fibtimezones_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @returns {Float64Array}
+     */
+    batch(high, low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.fibtimezones_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.fibtimezones_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.fibtimezones_new();
+        this.__wbg_ptr = ret;
+        FibTimeZonesFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.fibtimezones_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} high
+     * @param {number} low
+     * @returns {any}
+     */
+    update(high, low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.fibtimezones_update(retptr, this.__wbg_ptr, high, low);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.fibtimezones_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) FibTimeZones.prototype[Symbol.dispose] = FibTimeZones.prototype.free;
+
+export class FibonacciPivots {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FibonacciPivotsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_fibonaccipivots_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.fibonaccipivots_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.fibonaccipivots_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.fibonaccipivots_new();
+        this.__wbg_ptr = ret;
+        FibonacciPivotsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.fibonaccipivots_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @returns {any}
+     */
+    update(high, low, close) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             wasm.fibonaccipivots_update(retptr, this.__wbg_ptr, high, low, close);
@@ -7788,81 +9147,171 @@ export class FibonacciPivots {
 }
 if (Symbol.dispose) FibonacciPivots.prototype[Symbol.dispose] = FibonacciPivots.prototype.free;
 
-export class FisherTransform {
+export class FisherTransform {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FisherTransformFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_fishertransform_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.fishertransform_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.fishertransform_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.fishertransform_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;
+            FisherTransformFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.fishertransform_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.fishertransform_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.fishertransform_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) FisherTransform.prototype[Symbol.dispose] = FisherTransform.prototype.free;
+
+export class FlagPennant {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        FisherTransformFinalization.unregister(this);
+        FlagPennantFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_fishertransform_free(ptr, 0);
+        wasm.__wbg_flagpennant_free(ptr, 0);
     }
     /**
-     * @param {Float64Array} prices
+     * @param {Float64Array} open
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @param {Float64Array} close
      * @returns {Float64Array}
      */
-    batch(prices) {
-        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.fishertransform_batch(this.__wbg_ptr, ptr0, len0);
-        return takeObject(ret);
-    }
-    /**
-     * @returns {boolean}
-     */
-    isReady() {
-        const ret = wasm.fishertransform_isReady(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * @param {number} period
-     */
-    constructor(period) {
+    batch(open, high, low, close) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.fishertransform_new(retptr, period);
+            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.flagpennant_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);
             }
-            this.__wbg_ptr = r0;
-            FisherTransformFinalization.register(this, this.__wbg_ptr, this);
-            return this;
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.flagpennant_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.flagpennant_new();
+        this.__wbg_ptr = ret;
+        FlagPennantFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
     reset() {
-        wasm.fishertransform_reset(this.__wbg_ptr);
+        wasm.flagpennant_reset(this.__wbg_ptr);
     }
     /**
-     * @param {number} value
+     * @param {number} open
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
      * @returns {number | undefined}
      */
-    update(value) {
+    update(open, high, low, close) {
         try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.fishertransform_update(retptr, this.__wbg_ptr, value);
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.flagpennant_update(retptr, this.__wbg_ptr, open, high, low, close);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
             return r0 === 0 ? undefined : r2;
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_add_to_stack_pointer(32);
         }
     }
     /**
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.fishertransform_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.flagpennant_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) FisherTransform.prototype[Symbol.dispose] = FisherTransform.prototype.free;
+if (Symbol.dispose) FlagPennant.prototype[Symbol.dispose] = FlagPennant.prototype.free;
 
 export class Footprint {
     __destroy_into_raw() {
@@ -8420,43 +9869,238 @@ export class GainLossRatio {
         }
     }
     reset() {
-        wasm.gainlossratio_reset(this.__wbg_ptr);
+        wasm.gainlossratio_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.gainlossratio_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.gainlossratio_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) GainLossRatio.prototype[Symbol.dispose] = GainLossRatio.prototype.free;
+
+export class GapSideBySideWhite {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GapSideBySideWhiteFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_gapsidebysidewhite_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.gapsidebysidewhite_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.gapsidebysidewhite_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.gapsidebysidewhite_new();
+        this.__wbg_ptr = ret;
+        GapSideBySideWhiteFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.gapsidebysidewhite_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.gapsidebysidewhite_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.gapsidebysidewhite_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) GapSideBySideWhite.prototype[Symbol.dispose] = GapSideBySideWhite.prototype.free;
+
+export class GarmanKlassVolatility {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GarmanKlassVolatilityFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_garmanklassvolatility_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.garmanklassvolatility_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.garmanklassvolatility_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     * @param {number} trading_periods
+     */
+    constructor(period, trading_periods) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.garmanklassvolatility_new(retptr, period, trading_periods);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            GarmanKlassVolatilityFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.garmanklassvolatility_reset(this.__wbg_ptr);
     }
     /**
-     * @param {number} value
+     * @param {number} open
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
      * @returns {number | undefined}
      */
-    update(value) {
+    update(open, high, low, close) {
         try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.gainlossratio_update(retptr, this.__wbg_ptr, value);
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.garmanklassvolatility_update(retptr, this.__wbg_ptr, open, high, low, close);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
             return r0 === 0 ? undefined : r2;
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_add_to_stack_pointer(32);
         }
     }
     /**
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.gainlossratio_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.garmanklassvolatility_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) GainLossRatio.prototype[Symbol.dispose] = GainLossRatio.prototype.free;
+if (Symbol.dispose) GarmanKlassVolatility.prototype[Symbol.dispose] = GarmanKlassVolatility.prototype.free;
 
-export class GapSideBySideWhite {
+export class Gartley {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        GapSideBySideWhiteFinalization.unregister(this);
+        GartleyFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_gapsidebysidewhite_free(ptr, 0);
+        wasm.__wbg_gartley_free(ptr, 0);
     }
     /**
      * @param {Float64Array} open
@@ -8476,7 +10120,7 @@ export class GapSideBySideWhite {
             const len2 = WASM_VECTOR_LEN;
             const ptr3 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
             const len3 = WASM_VECTOR_LEN;
-            wasm.gapsidebysidewhite_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            wasm.gartley_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -8492,17 +10136,17 @@ export class GapSideBySideWhite {
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.gapsidebysidewhite_isReady(this.__wbg_ptr);
+        const ret = wasm.gartley_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
     constructor() {
-        const ret = wasm.gapsidebysidewhite_new();
+        const ret = wasm.gartley_new();
         this.__wbg_ptr = ret;
-        GapSideBySideWhiteFinalization.register(this, this.__wbg_ptr, this);
+        GartleyFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     reset() {
-        wasm.gapsidebysidewhite_reset(this.__wbg_ptr);
+        wasm.gartley_reset(this.__wbg_ptr);
     }
     /**
      * @param {number} open
@@ -8514,7 +10158,7 @@ export class GapSideBySideWhite {
     update(open, high, low, close) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
-            wasm.gapsidebysidewhite_update(retptr, this.__wbg_ptr, open, high, low, close);
+            wasm.gartley_update(retptr, this.__wbg_ptr, open, high, low, close);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
             var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
@@ -8531,42 +10175,36 @@ export class GapSideBySideWhite {
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.gapsidebysidewhite_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.gartley_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) GapSideBySideWhite.prototype[Symbol.dispose] = GapSideBySideWhite.prototype.free;
+if (Symbol.dispose) Gartley.prototype[Symbol.dispose] = Gartley.prototype.free;
 
-export class GarmanKlassVolatility {
+export class GoldenPocket {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        GarmanKlassVolatilityFinalization.unregister(this);
+        GoldenPocketFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_garmanklassvolatility_free(ptr, 0);
+        wasm.__wbg_goldenpocket_free(ptr, 0);
     }
     /**
-     * @param {Float64Array} open
      * @param {Float64Array} high
      * @param {Float64Array} low
-     * @param {Float64Array} close
      * @returns {Float64Array}
      */
-    batch(open, high, low, close) {
+    batch(high, low) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passArrayF64ToWasm0(open, wasm.__wbindgen_export3);
+            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
             const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
             const len1 = WASM_VECTOR_LEN;
-            const ptr2 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
-            const len2 = WASM_VECTOR_LEN;
-            const ptr3 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
-            const len3 = WASM_VECTOR_LEN;
-            wasm.garmanklassvolatility_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            wasm.goldenpocket_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -8582,65 +10220,47 @@ export class GarmanKlassVolatility {
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.garmanklassvolatility_isReady(this.__wbg_ptr);
+        const ret = wasm.goldenpocket_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
+    constructor() {
+        const ret = wasm.goldenpocket_new();
+        this.__wbg_ptr = ret;
+        GoldenPocketFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.goldenpocket_reset(this.__wbg_ptr);
+    }
     /**
-     * @param {number} period
-     * @param {number} trading_periods
+     * @param {number} high
+     * @param {number} low
+     * @returns {any}
      */
-    constructor(period, trading_periods) {
+    update(high, low) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.garmanklassvolatility_new(retptr, period, trading_periods);
+            wasm.goldenpocket_update(retptr, this.__wbg_ptr, high, low);
             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;
-            GarmanKlassVolatilityFinalization.register(this, this.__wbg_ptr, this);
-            return this;
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-    reset() {
-        wasm.garmanklassvolatility_reset(this.__wbg_ptr);
-    }
-    /**
-     * @param {number} open
-     * @param {number} high
-     * @param {number} low
-     * @param {number} close
-     * @returns {number | undefined}
-     */
-    update(open, high, low, close) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
-            wasm.garmanklassvolatility_update(retptr, this.__wbg_ptr, open, high, low, close);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
-            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
-            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
-            if (r5) {
-                throw takeObject(r4);
-            }
-            return r0 === 0 ? undefined : r2;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(32);
-        }
-    }
     /**
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.garmanklassvolatility_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.goldenpocket_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) GarmanKlassVolatility.prototype[Symbol.dispose] = GarmanKlassVolatility.prototype.free;
+if (Symbol.dispose) GoldenPocket.prototype[Symbol.dispose] = GoldenPocket.prototype.free;
 
 export class GrangerCausality {
     __destroy_into_raw() {
@@ -9338,6 +10958,96 @@ export class Harami {
 }
 if (Symbol.dispose) Harami.prototype[Symbol.dispose] = Harami.prototype.free;
 
+export class HeadAndShoulders {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        HeadAndShouldersFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_headandshoulders_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.headandshoulders_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.headandshoulders_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.headandshoulders_new();
+        this.__wbg_ptr = ret;
+        HeadAndShouldersFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.headandshoulders_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.headandshoulders_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.headandshoulders_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) HeadAndShoulders.prototype[Symbol.dispose] = HeadAndShoulders.prototype.free;
+
 export class HeikinAshi {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -18797,18 +20507,108 @@ export class RecoveryFactor {
             var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
             return r0 === 0 ? undefined : r2;
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.recoveryfactor_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) RecoveryFactor.prototype[Symbol.dispose] = RecoveryFactor.prototype.free;
+
+export class RectangleRange {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RectangleRangeFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rectanglerange_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.rectanglerange_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.rectanglerange_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.rectanglerange_new();
+        this.__wbg_ptr = ret;
+        RectangleRangeFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.rectanglerange_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.rectanglerange_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.recoveryfactor_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.rectanglerange_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) RecoveryFactor.prototype[Symbol.dispose] = RecoveryFactor.prototype.free;
+if (Symbol.dispose) RectangleRange.prototype[Symbol.dispose] = RectangleRange.prototype.free;
 
 export class RelativeStrengthAB {
     __destroy_into_raw() {
@@ -20492,6 +22292,96 @@ export class SessionVwap {
 }
 if (Symbol.dispose) SessionVwap.prototype[Symbol.dispose] = SessionVwap.prototype.free;
 
+export class Shark {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SharkFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_shark_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.shark_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.shark_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.shark_new();
+        this.__wbg_ptr = ret;
+        SharkFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.shark_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.shark_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.shark_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) Shark.prototype[Symbol.dispose] = Shark.prototype.free;
+
 export class SharpeRatio {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -24399,6 +26289,96 @@ export class TermStructureBasis {
 }
 if (Symbol.dispose) TermStructureBasis.prototype[Symbol.dispose] = TermStructureBasis.prototype.free;
 
+export class ThreeDrives {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ThreeDrivesFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_threedrives_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.threedrives_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.threedrives_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.threedrives_new();
+        this.__wbg_ptr = ret;
+        ThreeDrivesFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.threedrives_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.threedrives_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.threedrives_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) ThreeDrives.prototype[Symbol.dispose] = ThreeDrives.prototype.free;
+
 export class ThreeInside {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -25247,43 +27227,141 @@ export class TradeImbalance {
             }
             return r0 === 0 ? undefined : r2;
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(32);
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.tradeimbalance_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) TradeImbalance.prototype[Symbol.dispose] = TradeImbalance.prototype.free;
+
+export class TreynorRatio {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TreynorRatioFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_treynorratio_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} asset
+     * @param {Float64Array} benchmark
+     * @returns {Float64Array}
+     */
+    batch(asset, benchmark) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(asset, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(benchmark, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.treynorratio_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.treynorratio_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     * @param {number} risk_free
+     */
+    constructor(period, risk_free) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.treynorratio_new(retptr, period, risk_free);
+            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;
+            TreynorRatioFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.treynorratio_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} asset
+     * @param {number} benchmark
+     * @returns {number | undefined}
+     */
+    update(asset, benchmark) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.treynorratio_update(retptr, this.__wbg_ptr, asset, benchmark);
+            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.tradeimbalance_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.treynorratio_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) TradeImbalance.prototype[Symbol.dispose] = TradeImbalance.prototype.free;
+if (Symbol.dispose) TreynorRatio.prototype[Symbol.dispose] = TreynorRatio.prototype.free;
 
-export class TreynorRatio {
+export class Triangle {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        TreynorRatioFinalization.unregister(this);
+        TriangleFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_treynorratio_free(ptr, 0);
+        wasm.__wbg_triangle_free(ptr, 0);
     }
     /**
-     * @param {Float64Array} asset
-     * @param {Float64Array} benchmark
+     * @param {Float64Array} open
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @param {Float64Array} close
      * @returns {Float64Array}
      */
-    batch(asset, benchmark) {
+    batch(open, high, low, close) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passArrayF64ToWasm0(asset, wasm.__wbindgen_export3);
+            const ptr0 = passArrayF64ToWasm0(open, wasm.__wbindgen_export3);
             const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passArrayF64ToWasm0(benchmark, wasm.__wbindgen_export3);
+            const ptr1 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
             const len1 = WASM_VECTOR_LEN;
-            wasm.treynorratio_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            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.triangle_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);
@@ -25299,58 +27377,50 @@ export class TreynorRatio {
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.treynorratio_isReady(this.__wbg_ptr);
+        const ret = wasm.triangle_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
-    /**
-     * @param {number} period
-     * @param {number} risk_free
-     */
-    constructor(period, risk_free) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.treynorratio_new(retptr, period, risk_free);
-            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;
-            TreynorRatioFinalization.register(this, this.__wbg_ptr, this);
-            return this;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
+    constructor() {
+        const ret = wasm.triangle_new();
+        this.__wbg_ptr = ret;
+        TriangleFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     reset() {
-        wasm.treynorratio_reset(this.__wbg_ptr);
+        wasm.triangle_reset(this.__wbg_ptr);
     }
     /**
-     * @param {number} asset
-     * @param {number} benchmark
+     * @param {number} open
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
      * @returns {number | undefined}
      */
-    update(asset, benchmark) {
+    update(open, high, low, close) {
         try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.treynorratio_update(retptr, this.__wbg_ptr, asset, benchmark);
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.triangle_update(retptr, this.__wbg_ptr, open, high, low, close);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
             return r0 === 0 ? undefined : r2;
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_add_to_stack_pointer(32);
         }
     }
     /**
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.treynorratio_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.triangle_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) TreynorRatio.prototype[Symbol.dispose] = TreynorRatio.prototype.free;
+if (Symbol.dispose) Triangle.prototype[Symbol.dispose] = Triangle.prototype.free;
 
 export class Trin {
     __destroy_into_raw() {
@@ -25420,6 +27490,96 @@ export class Trin {
 }
 if (Symbol.dispose) Trin.prototype[Symbol.dispose] = Trin.prototype.free;
 
+export class TripleTopBottom {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TripleTopBottomFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tripletopbottom_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.tripletopbottom_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.tripletopbottom_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.tripletopbottom_new();
+        this.__wbg_ptr = ret;
+        TripleTopBottomFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.tripletopbottom_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.tripletopbottom_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.tripletopbottom_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) TripleTopBottom.prototype[Symbol.dispose] = TripleTopBottom.prototype.free;
+
 export class TrueRange {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -27977,6 +30137,96 @@ export class WaveTrend {
 }
 if (Symbol.dispose) WaveTrend.prototype[Symbol.dispose] = WaveTrend.prototype.free;
 
+export class Wedge {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WedgeFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wedge_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.wedge_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.wedge_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.wedge_new();
+        this.__wbg_ptr = ret;
+        WedgeFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.wedge_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.wedge_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.wedge_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) Wedge.prototype[Symbol.dispose] = Wedge.prototype.free;
+
 export class WeightedClose {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -29008,6 +31258,9 @@ export function __wbindgen_object_drop_ref(arg0) {
 const AbandonedBabyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_abandonedbaby_free(ptr, 1));
+const AbcdFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_abcd_free(ptr, 1));
 const AbsoluteBreadthIndexFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_absolutebreadthindex_free(ptr, 1));
@@ -29083,6 +31336,9 @@ const AtrBandsFinalization = (typeof FinalizationRegistry === 'undefined')
 const AtrTrailingStopFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_atrtrailingstop_free(ptr, 1));
+const AutoFibFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_autofib_free(ptr, 1));
 const AutocorrelationFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_autocorrelation_free(ptr, 1));
@@ -29098,6 +31354,9 @@ const AVGPRICEFinalization = (typeof FinalizationRegistry === 'undefined')
 const BalanceOfPowerFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_balanceofpower_free(ptr, 1));
+const BatFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_bat_free(ptr, 1));
 const BollingerBandsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_bollingerbands_free(ptr, 1));
@@ -29122,6 +31381,9 @@ const BreakawayFinalization = (typeof FinalizationRegistry === 'undefined')
 const BullishPercentIndexFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_bullishpercentindex_free(ptr, 1));
+const ButterflyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_butterfly_free(ptr, 1));
 const CalendarSpreadFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_calendarspread_free(ptr, 1));
@@ -29188,15 +31450,24 @@ const CoppockFinalization = (typeof FinalizationRegistry === 'undefined')
 const CounterattackFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_counterattack_free(ptr, 1));
+const CrabFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_crab_free(ptr, 1));
 const CumulativeVolumeDeltaFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_cumulativevolumedelta_free(ptr, 1));
 const CumulativeVolumeIndexFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_cumulativevolumeindex_free(ptr, 1));
+const CupAndHandleFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_cupandhandle_free(ptr, 1));
 const CyberneticCycleFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_cyberneticcycle_free(ptr, 1));
+const CypherFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_cypher_free(ptr, 1));
 const DayOfWeekProfileFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_dayofweekprofile_free(ptr, 1));
@@ -29239,6 +31510,9 @@ const DonchianStopFinalization = (typeof FinalizationRegistry === 'undefined')
 const DoubleBollingerFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_doublebollinger_free(ptr, 1));
+const DoubleTopBottomFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_doubletopbottom_free(ptr, 1));
 const DownsideGapThreeMethodsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_downsidegapthreemethods_free(ptr, 1));
@@ -29287,12 +31561,39 @@ const FallingThreeMethodsFinalization = (typeof FinalizationRegistry === 'undefi
 const FAMAFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_fama_free(ptr, 1));
+const FibArcsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_fibarcs_free(ptr, 1));
+const FibChannelFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_fibchannel_free(ptr, 1));
+const FibConfluenceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_fibconfluence_free(ptr, 1));
+const FibExtensionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_fibextension_free(ptr, 1));
+const FibFanFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_fibfan_free(ptr, 1));
+const FibProjectionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_fibprojection_free(ptr, 1));
+const FibRetracementFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_fibretracement_free(ptr, 1));
+const FibTimeZonesFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_fibtimezones_free(ptr, 1));
 const FibonacciPivotsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_fibonaccipivots_free(ptr, 1));
 const FisherTransformFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_fishertransform_free(ptr, 1));
+const FlagPennantFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_flagpennant_free(ptr, 1));
 const FootprintFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_footprint_free(ptr, 1));
@@ -29326,6 +31627,12 @@ const GapSideBySideWhiteFinalization = (typeof FinalizationRegistry === 'undefin
 const GarmanKlassVolatilityFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_garmanklassvolatility_free(ptr, 1));
+const GartleyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_gartley_free(ptr, 1));
+const GoldenPocketFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_goldenpocket_free(ptr, 1));
 const GrangerCausalityFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_grangercausality_free(ptr, 1));
@@ -29341,6 +31648,9 @@ const HangingManFinalization = (typeof FinalizationRegistry === 'undefined')
 const HaramiFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_harami_free(ptr, 1));
+const HeadAndShouldersFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_headandshoulders_free(ptr, 1));
 const HeikinAshiFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_heikinashi_free(ptr, 1));
@@ -29680,6 +31990,9 @@ const RealizedSpreadFinalization = (typeof FinalizationRegistry === 'undefined')
 const RecoveryFactorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_recoveryfactor_free(ptr, 1));
+const RectangleRangeFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rectanglerange_free(ptr, 1));
 const RelativeStrengthABFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_relativestrengthab_free(ptr, 1));
@@ -29752,6 +32065,9 @@ const SessionRangeFinalization = (typeof FinalizationRegistry === 'undefined')
 const SessionVwapFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sessionvwap_free(ptr, 1));
+const SharkFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_shark_free(ptr, 1));
 const SharpeRatioFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sharperatio_free(ptr, 1));
@@ -29884,6 +32200,9 @@ const TEMAFinalization = (typeof FinalizationRegistry === 'undefined')
 const TermStructureBasisFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_termstructurebasis_free(ptr, 1));
+const ThreeDrivesFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_threedrives_free(ptr, 1));
 const ThreeInsideFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_threeinside_free(ptr, 1));
@@ -29920,12 +32239,18 @@ const TradeImbalanceFinalization = (typeof FinalizationRegistry === 'undefined')
 const TreynorRatioFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_treynorratio_free(ptr, 1));
+const TriangleFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_triangle_free(ptr, 1));
 const TRIMAFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_trima_free(ptr, 1));
 const TrinFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_trin_free(ptr, 1));
+const TripleTopBottomFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tripletopbottom_free(ptr, 1));
 const TRIXFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_trix_free(ptr, 1));
@@ -30025,6 +32350,9 @@ const VZOFinalization = (typeof FinalizationRegistry === 'undefined')
 const WaveTrendFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wavetrend_free(ptr, 1));
+const WedgeFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wedge_free(ptr, 1));
 const WeightedCloseFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_weightedclose_free(ptr, 1));