wickra-wasm 0.5.3 → 0.5.4

package/wickra_wasm_bg.js

@@ -1572,6 +1572,79 @@ export class Alpha {
 }
 if (Symbol.dispose) Alpha.prototype[Symbol.dispose] = Alpha.prototype.free;
 
+export class AmihudIlliquidity {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AmihudIlliquidityFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_amihudilliquidity_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.amihudilliquidity_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.amihudilliquidity_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;
+            AmihudIlliquidityFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.amihudilliquidity_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} price
+     * @param {number} size
+     * @param {boolean} is_buy
+     * @returns {number | undefined}
+     */
+    update(price, size, is_buy) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.amihudilliquidity_update(retptr, this.__wbg_ptr, price, size, is_buy);
+            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.amihudilliquidity_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) AmihudIlliquidity.prototype[Symbol.dispose] = AmihudIlliquidity.prototype.free;
+
 export class AnchoredRSI {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -3030,6 +3103,82 @@ export class BetaNeutralSpread {
 }
 if (Symbol.dispose) BetaNeutralSpread.prototype[Symbol.dispose] = BetaNeutralSpread.prototype.free;
 
+export class BodySizePct {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BodySizePctFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_bodysizepct_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.bodysizepct_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    constructor() {
+        const ret = wasm.bodysizepct_new();
+        this.__wbg_ptr = ret;
+        BodySizePctFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.bodysizepct_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.bodysizepct_update(retptr, this.__wbg_ptr, open, high, low, close);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+}
+if (Symbol.dispose) BodySizePct.prototype[Symbol.dispose] = BodySizePct.prototype.free;
+
 export class BollingerBands {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -4656,6 +4805,82 @@ export class ClassicPivots {
 }
 if (Symbol.dispose) ClassicPivots.prototype[Symbol.dispose] = ClassicPivots.prototype.free;
 
+export class CloseVsOpen {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CloseVsOpenFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_closevsopen_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.closevsopen_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    constructor() {
+        const ret = wasm.closevsopen_new();
+        this.__wbg_ptr = ret;
+        CloseVsOpenFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.closevsopen_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.closevsopen_update(retptr, this.__wbg_ptr, open, high, low, close);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+}
+if (Symbol.dispose) CloseVsOpen.prototype[Symbol.dispose] = CloseVsOpen.prototype.free;
+
 export class ClosingMarubozu {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -8171,16 +8396,16 @@ export class EveningDojiStar {
 }
 if (Symbol.dispose) EveningDojiStar.prototype[Symbol.dispose] = EveningDojiStar.prototype.free;
 
-export class FAMA {
+export class Expectancy {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        FAMAFinalization.unregister(this);
+        ExpectancyFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_fama_free(ptr, 0);
+        wasm.__wbg_expectancy_free(ptr, 0);
     }
     /**
      * @param {Float64Array} prices
@@ -8189,24 +8414,23 @@ export class FAMA {
     batch(prices) {
         const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.fama_batch(this.__wbg_ptr, ptr0, len0);
+        const ret = wasm.expectancy_batch(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.fama_isReady(this.__wbg_ptr);
+        const ret = wasm.expectancy_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
-     * @param {number} fast_limit
-     * @param {number} slow_limit
+     * @param {number} period
      */
-    constructor(fast_limit, slow_limit) {
+    constructor(period) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.fama_new(retptr, fast_limit, slow_limit);
+            wasm.expectancy_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);
@@ -8214,14 +8438,14 @@ export class FAMA {
                 throw takeObject(r1);
             }
             this.__wbg_ptr = r0;
-            FAMAFinalization.register(this, this.__wbg_ptr, this);
+            ExpectancyFinalization.register(this, this.__wbg_ptr, this);
             return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     reset() {
-        wasm.fama_reset(this.__wbg_ptr);
+        wasm.expectancy_reset(this.__wbg_ptr);
     }
     /**
      * @param {number} value
@@ -8230,7 +8454,7 @@ export class FAMA {
     update(value) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.fama_update(retptr, this.__wbg_ptr, value);
+            wasm.expectancy_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;
@@ -8242,22 +8466,22 @@ export class FAMA {
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.fama_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.expectancy_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) FAMA.prototype[Symbol.dispose] = FAMA.prototype.free;
+if (Symbol.dispose) Expectancy.prototype[Symbol.dispose] = Expectancy.prototype.free;
 
-export class FRAMA {
+export class FAMA {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        FRAMAFinalization.unregister(this);
+        FAMAFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_frama_free(ptr, 0);
+        wasm.__wbg_fama_free(ptr, 0);
     }
     /**
      * @param {Float64Array} prices
@@ -8266,23 +8490,24 @@ export class FRAMA {
     batch(prices) {
         const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.frama_batch(this.__wbg_ptr, ptr0, len0);
+        const ret = wasm.fama_batch(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.frama_isReady(this.__wbg_ptr);
+        const ret = wasm.fama_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
-     * @param {number} period
+     * @param {number} fast_limit
+     * @param {number} slow_limit
      */
-    constructor(period) {
+    constructor(fast_limit, slow_limit) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.frama_new(retptr, period);
+            wasm.fama_new(retptr, fast_limit, slow_limit);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -8290,14 +8515,14 @@ export class FRAMA {
                 throw takeObject(r1);
             }
             this.__wbg_ptr = r0;
-            FRAMAFinalization.register(this, this.__wbg_ptr, this);
+            FAMAFinalization.register(this, this.__wbg_ptr, this);
             return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     reset() {
-        wasm.frama_reset(this.__wbg_ptr);
+        wasm.fama_reset(this.__wbg_ptr);
     }
     /**
      * @param {number} value
@@ -8306,7 +8531,7 @@ export class FRAMA {
     update(value) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.frama_update(retptr, this.__wbg_ptr, value);
+            wasm.fama_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;
@@ -8318,35 +8543,111 @@ export class FRAMA {
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.frama_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.fama_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) FRAMA.prototype[Symbol.dispose] = FRAMA.prototype.free;
+if (Symbol.dispose) FAMA.prototype[Symbol.dispose] = FAMA.prototype.free;
 
-export class FallingThreeMethods {
+export class FRAMA {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        FallingThreeMethodsFinalization.unregister(this);
+        FRAMAFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_fallingthreemethods_free(ptr, 0);
+        wasm.__wbg_frama_free(ptr, 0);
     }
     /**
-     * @param {Float64Array} open
-     * @param {Float64Array} high
-     * @param {Float64Array} low
-     * @param {Float64Array} close
+     * @param {Float64Array} prices
      * @returns {Float64Array}
      */
-    batch(open, high, low, close) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passArrayF64ToWasm0(open, wasm.__wbindgen_export3);
-            const len0 = WASM_VECTOR_LEN;
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.frama_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.frama_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.frama_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;
+            FRAMAFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.frama_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.frama_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.frama_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) FRAMA.prototype[Symbol.dispose] = FRAMA.prototype.free;
+
+export class FallingThreeMethods {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FallingThreeMethodsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_fallingthreemethods_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);
@@ -11308,6 +11609,82 @@ export class HighLowIndex {
 }
 if (Symbol.dispose) HighLowIndex.prototype[Symbol.dispose] = HighLowIndex.prototype.free;
 
+export class HighLowRange {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        HighLowRangeFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_highlowrange_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.highlowrange_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    constructor() {
+        const ret = wasm.highlowrange_new();
+        this.__wbg_ptr = ret;
+        HighLowRangeFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.highlowrange_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.highlowrange_update(retptr, this.__wbg_ptr, open, high, low, close);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+}
+if (Symbol.dispose) HighLowRange.prototype[Symbol.dispose] = HighLowRange.prototype.free;
+
 export class HighWave {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -12972,6 +13349,83 @@ export class JMA {
 }
 if (Symbol.dispose) JMA.prototype[Symbol.dispose] = JMA.prototype.free;
 
+export class JumpIndicator {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JumpIndicatorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jumpindicator_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.jumpindicator_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.jumpindicator_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     * @param {number} threshold
+     */
+    constructor(period, threshold) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.jumpindicator_new(retptr, period, threshold);
+            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;
+            JumpIndicatorFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.jumpindicator_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.jumpindicator_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.jumpindicator_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) JumpIndicator.prototype[Symbol.dispose] = JumpIndicator.prototype.free;
+
 export class KAMA {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -14585,49 +15039,125 @@ export class LiquidationFeatures {
 }
 if (Symbol.dispose) LiquidationFeatures.prototype[Symbol.dispose] = LiquidationFeatures.prototype.free;
 
-export class LongLeggedDoji {
+export class LogReturn {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        LongLeggedDojiFinalization.unregister(this);
+        LogReturnFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_longleggeddoji_free(ptr, 0);
+        wasm.__wbg_logreturn_free(ptr, 0);
     }
     /**
-     * @param {Float64Array} open
-     * @param {Float64Array} high
-     * @param {Float64Array} low
-     * @param {Float64Array} close
+     * @param {Float64Array} prices
      * @returns {Float64Array}
      */
-    batch(open, high, low, close) {
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.logreturn_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.logreturn_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passArrayF64ToWasm0(open, wasm.__wbindgen_export3);
-            const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
-            const len1 = WASM_VECTOR_LEN;
-            const ptr2 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
-            const len2 = WASM_VECTOR_LEN;
-            const ptr3 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
-            const len3 = WASM_VECTOR_LEN;
-            wasm.longleggeddoji_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            wasm.logreturn_new(retptr, period);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
             if (r2) {
                 throw takeObject(r1);
             }
-            return takeObject(r0);
+            this.__wbg_ptr = r0;
+            LogReturnFinalization.register(this, this.__wbg_ptr, this);
+            return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    reset() {
+        wasm.logreturn_reset(this.__wbg_ptr);
+    }
     /**
-     * @returns {boolean}
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.logreturn_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.logreturn_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) LogReturn.prototype[Symbol.dispose] = LogReturn.prototype.free;
+
+export class LongLeggedDoji {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        LongLeggedDojiFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_longleggeddoji_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.longleggeddoji_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.longleggeddoji_isReady(this.__wbg_ptr);
@@ -17844,6 +18374,88 @@ export class OrderBookImbalanceTopN {
 }
 if (Symbol.dispose) OrderBookImbalanceTopN.prototype[Symbol.dispose] = OrderBookImbalanceTopN.prototype.free;
 
+export class OrderFlowImbalance {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OrderFlowImbalanceFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_orderflowimbalance_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.orderflowimbalance_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.orderflowimbalance_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;
+            OrderFlowImbalanceFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.orderflowimbalance_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} bid_px
+     * @param {Float64Array} bid_sz
+     * @param {Float64Array} ask_px
+     * @param {Float64Array} ask_sz
+     * @returns {number | undefined}
+     */
+    update(bid_px, bid_sz, ask_px, ask_sz) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(bid_px, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(bid_sz, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(ask_px, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(ask_sz, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.orderflowimbalance_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.orderflowimbalance_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) OrderFlowImbalance.prototype[Symbol.dispose] = OrderFlowImbalance.prototype.free;
+
 export class OuHalfLife {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -20458,6 +21070,82 @@ export class RealizedSpread {
 }
 if (Symbol.dispose) RealizedSpread.prototype[Symbol.dispose] = RealizedSpread.prototype.free;
 
+export class RealizedVolatility {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RealizedVolatilityFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_realizedvolatility_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.realizedvolatility_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.realizedvolatility_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.realizedvolatility_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;
+            RealizedVolatilityFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.realizedvolatility_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.realizedvolatility_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.realizedvolatility_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) RealizedVolatility.prototype[Symbol.dispose] = RealizedVolatility.prototype.free;
+
 export class RecoveryFactor {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -20610,58 +21298,42 @@ export class RectangleRange {
 }
 if (Symbol.dispose) RectangleRange.prototype[Symbol.dispose] = RectangleRange.prototype.free;
 
-export class RelativeStrengthAB {
+export class RegimeLabel {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        RelativeStrengthABFinalization.unregister(this);
+        RegimeLabelFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_relativestrengthab_free(ptr, 0);
+        wasm.__wbg_regimelabel_free(ptr, 0);
     }
     /**
-     * Flat `Float64Array` of length `3 * n`:
-     * `[ratio0, ratioMa0, ratioRsi0, ratio1, ...]`. Warmup rows are NaN.
-     * @param {Float64Array} a
-     * @param {Float64Array} b
+     * @param {Float64Array} prices
      * @returns {Float64Array}
      */
-    batch(a, b) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passArrayF64ToWasm0(a, wasm.__wbindgen_export3);
-            const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passArrayF64ToWasm0(b, wasm.__wbindgen_export3);
-            const len1 = WASM_VECTOR_LEN;
-            wasm.relativestrengthab_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);
-        }
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.regimelabel_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
     }
     /**
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.relativestrengthab_isReady(this.__wbg_ptr);
+        const ret = wasm.regimelabel_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
-     * @param {number} ma_period
-     * @param {number} rsi_period
+     * @param {number} vol_period
+     * @param {number} lookback
      */
-    constructor(ma_period, rsi_period) {
+    constructor(vol_period, lookback) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.relativestrengthab_new(retptr, ma_period, rsi_period);
+            wasm.regimelabel_new(retptr, vol_period, lookback);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -20669,32 +21341,125 @@ export class RelativeStrengthAB {
                 throw takeObject(r1);
             }
             this.__wbg_ptr = r0;
-            RelativeStrengthABFinalization.register(this, this.__wbg_ptr, this);
+            RegimeLabelFinalization.register(this, this.__wbg_ptr, this);
             return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     reset() {
-        wasm.relativestrengthab_reset(this.__wbg_ptr);
-    }
-    /**
-     * Returns `{ ratio, ratioMa, ratioRsi }`, or `null` during warmup.
-     * @param {number} a
-     * @param {number} b
-     * @returns {any}
-     */
-    update(a, b) {
-        const ret = wasm.relativestrengthab_update(this.__wbg_ptr, a, b);
-        return takeObject(ret);
+        wasm.regimelabel_reset(this.__wbg_ptr);
     }
     /**
-     * @returns {number}
+     * @param {number} value
+     * @returns {number | undefined}
      */
-    warmupPeriod() {
-        const ret = wasm.relativestrengthab_warmupPeriod(this.__wbg_ptr);
-        return ret >>> 0;
-    }
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.regimelabel_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.regimelabel_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) RegimeLabel.prototype[Symbol.dispose] = RegimeLabel.prototype.free;
+
+export class RelativeStrengthAB {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RelativeStrengthABFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_relativestrengthab_free(ptr, 0);
+    }
+    /**
+     * Flat `Float64Array` of length `3 * n`:
+     * `[ratio0, ratioMa0, ratioRsi0, ratio1, ...]`. Warmup rows are NaN.
+     * @param {Float64Array} a
+     * @param {Float64Array} b
+     * @returns {Float64Array}
+     */
+    batch(a, b) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(a, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(b, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.relativestrengthab_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.relativestrengthab_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} ma_period
+     * @param {number} rsi_period
+     */
+    constructor(ma_period, rsi_period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.relativestrengthab_new(retptr, ma_period, rsi_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;
+            RelativeStrengthABFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.relativestrengthab_reset(this.__wbg_ptr);
+    }
+    /**
+     * Returns `{ ratio, ratioMa, ratioRsi }`, or `null` during warmup.
+     * @param {number} a
+     * @param {number} b
+     * @returns {any}
+     */
+    update(a, b) {
+        const ret = wasm.relativestrengthab_update(this.__wbg_ptr, a, b);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.relativestrengthab_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
 }
 if (Symbol.dispose) RelativeStrengthAB.prototype[Symbol.dispose] = RelativeStrengthAB.prototype.free;
 
@@ -21104,74 +21869,393 @@ export class RogersSatchellVolatility {
      * @param {number} close
      * @returns {number | undefined}
      */
-    update(open, high, low, close) {
+    update(open, high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.rogerssatchellvolatility_update(retptr, this.__wbg_ptr, open, high, low, close);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.rogerssatchellvolatility_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) RogersSatchellVolatility.prototype[Symbol.dispose] = RogersSatchellVolatility.prototype.free;
+
+export class RollMeasure {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RollMeasureFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rollmeasure_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.rollmeasure_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rollmeasure_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;
+            RollMeasureFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.rollmeasure_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} price
+     * @param {number} size
+     * @param {boolean} is_buy
+     * @returns {number | undefined}
+     */
+    update(price, size, is_buy) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.rollmeasure_update(retptr, this.__wbg_ptr, price, size, is_buy);
+            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.rollmeasure_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) RollMeasure.prototype[Symbol.dispose] = RollMeasure.prototype.free;
+
+export class RollingCorrelation {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RollingCorrelationFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rollingcorrelation_free(ptr, 0);
+    }
+    /**
+     * Batch over two equally-sized arrays. Returns one `f64` per
+     * input position (`NaN` during warmup).
+     * @param {Float64Array} x
+     * @param {Float64Array} y
+     * @returns {Float64Array}
+     */
+    batch(x, y) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(y, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.rollingcorrelation_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.rollingcorrelation_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rollingcorrelation_new(retptr, period);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            RollingCorrelationFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.rollingcorrelation_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} x
+     * @param {number} y
+     * @returns {number | undefined}
+     */
+    update(x, y) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rollingcorrelation_update(retptr, this.__wbg_ptr, x, y);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.rollingcorrelation_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) RollingCorrelation.prototype[Symbol.dispose] = RollingCorrelation.prototype.free;
+
+export class RollingCovariance {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RollingCovarianceFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rollingcovariance_free(ptr, 0);
+    }
+    /**
+     * Batch over two equally-sized arrays. Returns one `f64` per
+     * input position (`NaN` during warmup).
+     * @param {Float64Array} x
+     * @param {Float64Array} y
+     * @returns {Float64Array}
+     */
+    batch(x, y) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(y, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.rollingcovariance_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.rollingcovariance_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rollingcovariance_new(retptr, period);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            RollingCovarianceFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.rollingcovariance_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} x
+     * @param {number} y
+     * @returns {number | undefined}
+     */
+    update(x, y) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rollingcovariance_update(retptr, this.__wbg_ptr, x, y);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.rollingcovariance_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) RollingCovariance.prototype[Symbol.dispose] = RollingCovariance.prototype.free;
+
+export class RollingIqr {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RollingIqrFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rollingiqr_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.rollingiqr_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.rollingiqr_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rollingiqr_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;
+            RollingIqrFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.rollingiqr_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
         try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
-            wasm.rogerssatchellvolatility_update(retptr, this.__wbg_ptr, open, high, low, close);
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rollingiqr_update(retptr, this.__wbg_ptr, value);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
-            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
-            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
-            if (r5) {
-                throw takeObject(r4);
-            }
             return r0 === 0 ? undefined : r2;
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(32);
+            wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.rogerssatchellvolatility_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.rollingiqr_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) RogersSatchellVolatility.prototype[Symbol.dispose] = RogersSatchellVolatility.prototype.free;
+if (Symbol.dispose) RollingIqr.prototype[Symbol.dispose] = RollingIqr.prototype.free;
 
-export class RollingCorrelation {
+export class RollingPercentileRank {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        RollingCorrelationFinalization.unregister(this);
+        RollingPercentileRankFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_rollingcorrelation_free(ptr, 0);
+        wasm.__wbg_rollingpercentilerank_free(ptr, 0);
     }
     /**
-     * Batch over two equally-sized arrays. Returns one `f64` per
-     * input position (`NaN` during warmup).
-     * @param {Float64Array} x
-     * @param {Float64Array} y
+     * @param {Float64Array} prices
      * @returns {Float64Array}
      */
-    batch(x, y) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_export3);
-            const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passArrayF64ToWasm0(y, wasm.__wbindgen_export3);
-            const len1 = WASM_VECTOR_LEN;
-            wasm.rollingcorrelation_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-            if (r2) {
-                throw takeObject(r1);
-            }
-            return takeObject(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rollingpercentilerank_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
     }
     /**
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.rollingcorrelation_isReady(this.__wbg_ptr);
+        const ret = wasm.rollingpercentilerank_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
@@ -21180,7 +22264,7 @@ export class RollingCorrelation {
     constructor(period) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.rollingcorrelation_new(retptr, period);
+            wasm.rollingpercentilerank_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);
@@ -21188,24 +22272,23 @@ export class RollingCorrelation {
                 throw takeObject(r1);
             }
             this.__wbg_ptr = r0;
-            RollingCorrelationFinalization.register(this, this.__wbg_ptr, this);
+            RollingPercentileRankFinalization.register(this, this.__wbg_ptr, this);
             return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     reset() {
-        wasm.rollingcorrelation_reset(this.__wbg_ptr);
+        wasm.rollingpercentilerank_reset(this.__wbg_ptr);
     }
     /**
-     * @param {number} x
-     * @param {number} y
+     * @param {number} value
      * @returns {number | undefined}
      */
-    update(x, y) {
+    update(value) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.rollingcorrelation_update(retptr, this.__wbg_ptr, x, y);
+            wasm.rollingpercentilerank_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;
@@ -21217,63 +22300,48 @@ export class RollingCorrelation {
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.rollingcorrelation_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.rollingpercentilerank_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) RollingCorrelation.prototype[Symbol.dispose] = RollingCorrelation.prototype.free;
+if (Symbol.dispose) RollingPercentileRank.prototype[Symbol.dispose] = RollingPercentileRank.prototype.free;
 
-export class RollingCovariance {
+export class RollingQuantile {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        RollingCovarianceFinalization.unregister(this);
+        RollingQuantileFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_rollingcovariance_free(ptr, 0);
+        wasm.__wbg_rollingquantile_free(ptr, 0);
     }
     /**
-     * Batch over two equally-sized arrays. Returns one `f64` per
-     * input position (`NaN` during warmup).
-     * @param {Float64Array} x
-     * @param {Float64Array} y
+     * @param {Float64Array} prices
      * @returns {Float64Array}
      */
-    batch(x, y) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_export3);
-            const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passArrayF64ToWasm0(y, wasm.__wbindgen_export3);
-            const len1 = WASM_VECTOR_LEN;
-            wasm.rollingcovariance_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-            if (r2) {
-                throw takeObject(r1);
-            }
-            return takeObject(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rollingquantile_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
     }
     /**
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.rollingcovariance_isReady(this.__wbg_ptr);
+        const ret = wasm.rollingquantile_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
      * @param {number} period
+     * @param {number} quantile
      */
-    constructor(period) {
+    constructor(period, quantile) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.rollingcovariance_new(retptr, period);
+            wasm.rollingquantile_new(retptr, period, quantile);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -21281,24 +22349,23 @@ export class RollingCovariance {
                 throw takeObject(r1);
             }
             this.__wbg_ptr = r0;
-            RollingCovarianceFinalization.register(this, this.__wbg_ptr, this);
+            RollingQuantileFinalization.register(this, this.__wbg_ptr, this);
             return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     reset() {
-        wasm.rollingcovariance_reset(this.__wbg_ptr);
+        wasm.rollingquantile_reset(this.__wbg_ptr);
     }
     /**
-     * @param {number} x
-     * @param {number} y
+     * @param {number} value
      * @returns {number | undefined}
      */
-    update(x, y) {
+    update(value) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.rollingcovariance_update(retptr, this.__wbg_ptr, x, y);
+            wasm.rollingquantile_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;
@@ -21310,11 +22377,11 @@ export class RollingCovariance {
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.rollingcovariance_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.rollingquantile_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) RollingCovariance.prototype[Symbol.dispose] = RollingCovariance.prototype.free;
+if (Symbol.dispose) RollingQuantile.prototype[Symbol.dispose] = RollingQuantile.prototype.free;
 
 export class RollingVWAP {
     __destroy_into_raw() {
@@ -23103,6 +24170,99 @@ export class SpinningTop {
 }
 if (Symbol.dispose) SpinningTop.prototype[Symbol.dispose] = SpinningTop.prototype.free;
 
+export class SpreadAr1Coefficient {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SpreadAr1CoefficientFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_spreadar1coefficient_free(ptr, 0);
+    }
+    /**
+     * Batch over two equally-sized arrays. Returns one `f64` per
+     * input position (`NaN` during warmup).
+     * @param {Float64Array} x
+     * @param {Float64Array} y
+     * @returns {Float64Array}
+     */
+    batch(x, y) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(y, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.spreadar1coefficient_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.spreadar1coefficient_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.spreadar1coefficient_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;
+            SpreadAr1CoefficientFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.spreadar1coefficient_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} x
+     * @param {number} y
+     * @returns {number | undefined}
+     */
+    update(x, y) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.spreadar1coefficient_update(retptr, this.__wbg_ptr, x, y);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.spreadar1coefficient_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) SpreadAr1Coefficient.prototype[Symbol.dispose] = SpreadAr1Coefficient.prototype.free;
+
 export class SpreadBollingerBands {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -27154,44 +28314,127 @@ export class TpoProfile {
             }
             return takeObject(r0);
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.tpoprofile_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) TpoProfile.prototype[Symbol.dispose] = TpoProfile.prototype.free;
+
+export class TradeImbalance {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TradeImbalanceFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tradeimbalance_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.tradeimbalance_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} window
+     */
+    constructor(window) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.tradeimbalance_new(retptr, window);
+            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;
+            TradeImbalanceFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.tradeimbalance_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} price
+     * @param {number} size
+     * @param {boolean} is_buy
+     * @returns {number | undefined}
+     */
+    update(price, size, is_buy) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.tradeimbalance_update(retptr, this.__wbg_ptr, price, size, is_buy);
+            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.tpoprofile_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.tradeimbalance_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) TpoProfile.prototype[Symbol.dispose] = TpoProfile.prototype.free;
+if (Symbol.dispose) TradeImbalance.prototype[Symbol.dispose] = TradeImbalance.prototype.free;
 
-export class TradeImbalance {
+export class TrendLabel {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        TradeImbalanceFinalization.unregister(this);
+        TrendLabelFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_tradeimbalance_free(ptr, 0);
+        wasm.__wbg_trendlabel_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.trendlabel_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
     }
     /**
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.tradeimbalance_isReady(this.__wbg_ptr);
+        const ret = wasm.trendlabel_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
-     * @param {number} window
+     * @param {number} period
      */
-    constructor(window) {
+    constructor(period) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.tradeimbalance_new(retptr, window);
+            wasm.trendlabel_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);
@@ -27199,46 +28442,39 @@ export class TradeImbalance {
                 throw takeObject(r1);
             }
             this.__wbg_ptr = r0;
-            TradeImbalanceFinalization.register(this, this.__wbg_ptr, this);
+            TrendLabelFinalization.register(this, this.__wbg_ptr, this);
             return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     reset() {
-        wasm.tradeimbalance_reset(this.__wbg_ptr);
+        wasm.trendlabel_reset(this.__wbg_ptr);
     }
     /**
-     * @param {number} price
-     * @param {number} size
-     * @param {boolean} is_buy
+     * @param {number} value
      * @returns {number | undefined}
      */
-    update(price, size, is_buy) {
+    update(value) {
         try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
-            wasm.tradeimbalance_update(retptr, this.__wbg_ptr, price, size, is_buy);
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.trendlabel_update(retptr, this.__wbg_ptr, value);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
-            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
-            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
-            if (r5) {
-                throw takeObject(r4);
-            }
             return r0 === 0 ? undefined : r2;
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(32);
+            wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.tradeimbalance_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.trendlabel_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) TradeImbalance.prototype[Symbol.dispose] = TradeImbalance.prototype.free;
+if (Symbol.dispose) TrendLabel.prototype[Symbol.dispose] = TrendLabel.prototype.free;
 
 export class TreynorRatio {
     __destroy_into_raw() {
@@ -29846,6 +31082,80 @@ export class Vortex {
 }
 if (Symbol.dispose) Vortex.prototype[Symbol.dispose] = Vortex.prototype.free;
 
+export class Vpin {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        VpinFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_vpin_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.vpin_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} bucket_volume
+     * @param {number} num_buckets
+     */
+    constructor(bucket_volume, num_buckets) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.vpin_new(retptr, bucket_volume, num_buckets);
+            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;
+            VpinFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.vpin_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} price
+     * @param {number} size
+     * @param {boolean} is_buy
+     * @returns {number | undefined}
+     */
+    update(price, size, is_buy) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.vpin_update(retptr, this.__wbg_ptr, price, size, is_buy);
+            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.vpin_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) Vpin.prototype[Symbol.dispose] = Vpin.prototype.free;
+
 export class VwapStdDevBands {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -30299,6 +31609,82 @@ export class WeightedClose {
 }
 if (Symbol.dispose) WeightedClose.prototype[Symbol.dispose] = WeightedClose.prototype.free;
 
+export class WickRatio {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WickRatioFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wickratio_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.wickratio_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    constructor() {
+        const ret = wasm.wickratio_new();
+        this.__wbg_ptr = ret;
+        WickRatioFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.wickratio_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.wickratio_update(retptr, this.__wbg_ptr, open, high, low, close);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+}
+if (Symbol.dispose) WickRatio.prototype[Symbol.dispose] = WickRatio.prototype.free;
+
 export class WilliamsAD {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -30555,6 +31941,82 @@ export class WilliamsR {
 }
 if (Symbol.dispose) WilliamsR.prototype[Symbol.dispose] = WilliamsR.prototype.free;
 
+export class WinRate {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WinRateFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_winrate_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.winrate_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.winrate_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.winrate_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;
+            WinRateFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.winrate_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.winrate_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.winrate_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) WinRate.prototype[Symbol.dispose] = WinRate.prototype.free;
+
 export class WoodiePivots {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -31306,6 +32768,9 @@ const ALMAFinalization = (typeof FinalizationRegistry === 'undefined')
 const AlphaFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_alpha_free(ptr, 1));
+const AmihudIlliquidityFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_amihudilliquidity_free(ptr, 1));
 const AnchoredRSIFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_anchoredrsi_free(ptr, 1));
@@ -31369,6 +32834,9 @@ const BetaFinalization = (typeof FinalizationRegistry === 'undefined')
 const BetaNeutralSpreadFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_betaneutralspread_free(ptr, 1));
+const BodySizePctFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_bodysizepct_free(ptr, 1));
 const BollingerBandwidthFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_bollingerbandwidth_free(ptr, 1));
@@ -31423,6 +32891,9 @@ const ChoppinessIndexFinalization = (typeof FinalizationRegistry === 'undefined'
 const ClassicPivotsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_classicpivots_free(ptr, 1));
+const CloseVsOpenFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_closevsopen_free(ptr, 1));
 const ClosingMarubozuFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_closingmarubozu_free(ptr, 1));
@@ -31555,6 +33026,9 @@ const EveningDojiStarFinalization = (typeof FinalizationRegistry === 'undefined'
 const EVWMAFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_evwma_free(ptr, 1));
+const ExpectancyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_expectancy_free(ptr, 1));
 const FallingThreeMethodsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_fallingthreemethods_free(ptr, 1));
@@ -31660,6 +33134,9 @@ const HiLoActivatorFinalization = (typeof FinalizationRegistry === 'undefined')
 const HighLowIndexFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_highlowindex_free(ptr, 1));
+const HighLowRangeFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_highlowrange_free(ptr, 1));
 const HighWaveFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_highwave_free(ptr, 1));
@@ -31729,6 +33206,9 @@ const InvertedHammerFinalization = (typeof FinalizationRegistry === 'undefined')
 const JMAFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_jma_free(ptr, 1));
+const JumpIndicatorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jumpindicator_free(ptr, 1));
 const KagiBarsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_kagibars_free(ptr, 1));
@@ -31789,6 +33269,9 @@ const LinearRegressionFinalization = (typeof FinalizationRegistry === 'undefined
 const LiquidationFeaturesFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_liquidationfeatures_free(ptr, 1));
+const LogReturnFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_logreturn_free(ptr, 1));
 const LongLeggedDojiFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_longleggeddoji_free(ptr, 1));
@@ -31915,6 +33398,9 @@ const OrderBookImbalanceTop1Finalization = (typeof FinalizationRegistry === 'und
 const OrderBookImbalanceTopNFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_orderbookimbalancetopn_free(ptr, 1));
+const OrderFlowImbalanceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_orderflowimbalance_free(ptr, 1));
 const OuHalfLifeFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ouhalflife_free(ptr, 1));
@@ -31987,12 +33473,18 @@ const RSquaredFinalization = (typeof FinalizationRegistry === 'undefined')
 const RealizedSpreadFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_realizedspread_free(ptr, 1));
+const RealizedVolatilityFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_realizedvolatility_free(ptr, 1));
 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 RegimeLabelFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_regimelabel_free(ptr, 1));
 const RelativeStrengthABFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_relativestrengthab_free(ptr, 1));
@@ -32023,12 +33515,24 @@ const ROCR100Finalization = (typeof FinalizationRegistry === 'undefined')
 const RogersSatchellVolatilityFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rogerssatchellvolatility_free(ptr, 1));
+const RollMeasureFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rollmeasure_free(ptr, 1));
 const RollingCorrelationFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rollingcorrelation_free(ptr, 1));
 const RollingCovarianceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rollingcovariance_free(ptr, 1));
+const RollingIqrFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rollingiqr_free(ptr, 1));
+const RollingPercentileRankFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rollingpercentilerank_free(ptr, 1));
+const RollingQuantileFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rollingquantile_free(ptr, 1));
 const RollingVWAPFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rollingvwap_free(ptr, 1));
@@ -32104,6 +33608,9 @@ const SpearmanCorrelationFinalization = (typeof FinalizationRegistry === 'undefi
 const SpinningTopFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_spinningtop_free(ptr, 1));
+const SpreadAr1CoefficientFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_spreadar1coefficient_free(ptr, 1));
 const SpreadBollingerBandsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_spreadbollingerbands_free(ptr, 1));
@@ -32236,6 +33743,9 @@ const TpoProfileFinalization = (typeof FinalizationRegistry === 'undefined')
 const TradeImbalanceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tradeimbalance_free(ptr, 1));
+const TrendLabelFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_trendlabel_free(ptr, 1));
 const TreynorRatioFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_treynorratio_free(ptr, 1));
@@ -32335,6 +33845,9 @@ const VolumeProfileFinalization = (typeof FinalizationRegistry === 'undefined')
 const VortexFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_vortex_free(ptr, 1));
+const VpinFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_vpin_free(ptr, 1));
 const VWAPFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_vwap_free(ptr, 1));
@@ -32356,12 +33869,18 @@ const WedgeFinalization = (typeof FinalizationRegistry === 'undefined')
 const WeightedCloseFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_weightedclose_free(ptr, 1));
+const WickRatioFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wickratio_free(ptr, 1));
 const WilliamsFractalsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_williamsfractals_free(ptr, 1));
 const WilliamsRFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_williamsr_free(ptr, 1));
+const WinRateFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_winrate_free(ptr, 1));
 const WMAFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wma_free(ptr, 1));