wickra-wasm 0.4.7 → 0.5.1

package/wickra_wasm_bg.js

@@ -682,6 +682,74 @@ export class AbandonedBaby {
 }
 if (Symbol.dispose) AbandonedBaby.prototype[Symbol.dispose] = AbandonedBaby.prototype.free;
 
+export class AbsoluteBreadthIndex {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AbsoluteBreadthIndexFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_absolutebreadthindex_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.absolutebreadthindex_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.absolutebreadthindex_new();
+        this.__wbg_ptr = ret;
+        AbsoluteBreadthIndexFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.absolutebreadthindex_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @returns {number | undefined}
+     */
+    update(change, volume, new_high, new_low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.absolutebreadthindex_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.absolutebreadthindex_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) AbsoluteBreadthIndex.prototype[Symbol.dispose] = AbsoluteBreadthIndex.prototype.free;
+
 export class AccelerationBands {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -867,6 +935,74 @@ export class AcceleratorOscillator {
 }
 if (Symbol.dispose) AcceleratorOscillator.prototype[Symbol.dispose] = AcceleratorOscillator.prototype.free;
 
+export class AdVolumeLine {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AdVolumeLineFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_advolumeline_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.advolumeline_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.advolumeline_new();
+        this.__wbg_ptr = ret;
+        AdVolumeLineFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.advolumeline_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @returns {number | undefined}
+     */
+    update(change, volume, new_high, new_low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.advolumeline_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.advolumeline_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) AdVolumeLine.prototype[Symbol.dispose] = AdVolumeLine.prototype.free;
+
 export class AdaptiveCycle {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -1087,6 +1223,74 @@ export class AdvanceDecline {
 }
 if (Symbol.dispose) AdvanceDecline.prototype[Symbol.dispose] = AdvanceDecline.prototype.free;
 
+export class AdvanceDeclineRatio {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AdvanceDeclineRatioFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_advancedeclineratio_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.advancedeclineratio_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.advancedeclineratio_new();
+        this.__wbg_ptr = ret;
+        AdvanceDeclineRatioFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.advancedeclineratio_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @returns {number | undefined}
+     */
+    update(change, volume, new_high, new_low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.advancedeclineratio_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.advancedeclineratio_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) AdvanceDeclineRatio.prototype[Symbol.dispose] = AdvanceDeclineRatio.prototype.free;
+
 export class Alligator {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -1865,6 +2069,83 @@ export class Autocorrelation {
 }
 if (Symbol.dispose) Autocorrelation.prototype[Symbol.dispose] = Autocorrelation.prototype.free;
 
+export class AverageDailyRange {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AverageDailyRangeFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_averagedailyrange_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.averagedailyrange_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     * @param {number} utc_offset_minutes
+     */
+    constructor(period, utc_offset_minutes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.averagedailyrange_new(retptr, period, utc_offset_minutes);
+            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;
+            AverageDailyRangeFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.averagedailyrange_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} open
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @param {number} volume
+     * @param {bigint} timestamp
+     * @returns {number | undefined}
+     */
+    update(open, high, low, close, volume, timestamp) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.averagedailyrange_update(retptr, this.__wbg_ptr, open, high, low, close, volume, timestamp);
+            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.averagedailyrange_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) AverageDailyRange.prototype[Symbol.dispose] = AverageDailyRange.prototype.free;
+
 export class AverageDrawdown {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -2622,6 +2903,88 @@ export class BollingerBandwidth {
 }
 if (Symbol.dispose) BollingerBandwidth.prototype[Symbol.dispose] = BollingerBandwidth.prototype.free;
 
+export class BreadthThrust {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BreadthThrustFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_breadththrust_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.breadththrust_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.breadththrust_new(retptr, period);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            BreadthThrustFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.breadththrust_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @returns {number | undefined}
+     */
+    update(change, volume, new_high, new_low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.breadththrust_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.breadththrust_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) BreadthThrust.prototype[Symbol.dispose] = BreadthThrust.prototype.free;
+
 export class Breakaway {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -2712,6 +3075,77 @@ export class Breakaway {
 }
 if (Symbol.dispose) Breakaway.prototype[Symbol.dispose] = Breakaway.prototype.free;
 
+export class BullishPercentIndex {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BullishPercentIndexFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_bullishpercentindex_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.bullishpercentindex_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.bullishpercentindex_new();
+        this.__wbg_ptr = ret;
+        BullishPercentIndexFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.bullishpercentindex_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @param {Float64Array} on_buy_signal
+     * @returns {number | undefined}
+     */
+    update(change, volume, new_high, new_low, on_buy_signal) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            const ptr4 = passArrayF64ToWasm0(on_buy_signal, wasm.__wbindgen_export3);
+            const len4 = WASM_VECTOR_LEN;
+            wasm.bullishpercentindex_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.bullishpercentindex_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) BullishPercentIndex.prototype[Symbol.dispose] = BullishPercentIndex.prototype.free;
+
 export class CCI {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -4597,6 +5031,74 @@ export class CumulativeVolumeDelta {
 }
 if (Symbol.dispose) CumulativeVolumeDelta.prototype[Symbol.dispose] = CumulativeVolumeDelta.prototype.free;
 
+export class CumulativeVolumeIndex {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CumulativeVolumeIndexFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_cumulativevolumeindex_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.cumulativevolumeindex_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.cumulativevolumeindex_new();
+        this.__wbg_ptr = ret;
+        CumulativeVolumeIndexFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.cumulativevolumeindex_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @returns {number | undefined}
+     */
+    update(change, volume, new_high, new_low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.cumulativevolumeindex_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.cumulativevolumeindex_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) CumulativeVolumeIndex.prototype[Symbol.dispose] = CumulativeVolumeIndex.prototype.free;
+
 export class CyberneticCycle {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -4909,7 +5411,78 @@ export class DX {
         }
     }
 }
-if (Symbol.dispose) DX.prototype[Symbol.dispose] = DX.prototype.free;
+if (Symbol.dispose) DX.prototype[Symbol.dispose] = DX.prototype.free;
+
+export class DayOfWeekProfile {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DayOfWeekProfileFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_dayofweekprofile_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.dayofweekprofile_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} utc_offset_minutes
+     */
+    constructor(utc_offset_minutes) {
+        const ret = wasm.dayofweekprofile_new(utc_offset_minutes);
+        this.__wbg_ptr = ret;
+        DayOfWeekProfileFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.dayofweekprofile_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} open
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @param {number} volume
+     * @param {bigint} timestamp
+     * @returns {any}
+     */
+    update(open, high, low, close, volume, timestamp) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.dayofweekprofile_update(retptr, this.__wbg_ptr, open, high, low, close, volume, timestamp);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    utcOffsetMinutes() {
+        const ret = wasm.dayofweekprofile_utcOffsetMinutes(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.dayofweekprofile_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) DayOfWeekProfile.prototype[Symbol.dispose] = DayOfWeekProfile.prototype.free;
 
 export class Decycler {
     __destroy_into_raw() {
@@ -8943,6 +9516,88 @@ export class HiLoActivator {
 }
 if (Symbol.dispose) HiLoActivator.prototype[Symbol.dispose] = HiLoActivator.prototype.free;
 
+export class HighLowIndex {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        HighLowIndexFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_highlowindex_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.highlowindex_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.highlowindex_new(retptr, period);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            HighLowIndexFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.highlowindex_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @returns {number | undefined}
+     */
+    update(change, volume, new_high, new_low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.highlowindex_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.highlowindex_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) HighLowIndex.prototype[Symbol.dispose] = HighLowIndex.prototype.free;
+
 export class HighWave {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -10280,6 +10935,89 @@ export class InstantaneousTrendline {
 }
 if (Symbol.dispose) InstantaneousTrendline.prototype[Symbol.dispose] = InstantaneousTrendline.prototype.free;
 
+export class IntradayVolatilityProfile {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IntradayVolatilityProfileFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_intradayvolatilityprofile_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.intradayvolatilityprofile_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} buckets
+     * @param {number} utc_offset_minutes
+     */
+    constructor(buckets, utc_offset_minutes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.intradayvolatilityprofile_new(retptr, buckets, utc_offset_minutes);
+            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;
+            IntradayVolatilityProfileFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.intradayvolatilityprofile_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} open
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @param {number} volume
+     * @param {bigint} timestamp
+     * @returns {any}
+     */
+    update(open, high, low, close, volume, timestamp) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.intradayvolatilityprofile_update(retptr, this.__wbg_ptr, open, high, low, close, volume, timestamp);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    utcOffsetMinutes() {
+        const ret = wasm.intradayvolatilityprofile_utcOffsetMinutes(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.intradayvolatilityprofile_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) IntradayVolatilityProfile.prototype[Symbol.dispose] = IntradayVolatilityProfile.prototype.free;
+
 export class InverseFisherTransform {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -13665,56 +14403,192 @@ export class MaxDrawdown {
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.maxdrawdown_isReady(this.__wbg_ptr);
+        const ret = wasm.maxdrawdown_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.maxdrawdown_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;
+            MaxDrawdownFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.maxdrawdown_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.maxdrawdown_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.maxdrawdown_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) MaxDrawdown.prototype[Symbol.dispose] = MaxDrawdown.prototype.free;
+
+export class McClellanOscillator {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        McClellanOscillatorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_mcclellanoscillator_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.mcclellanoscillator_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.mcclellanoscillator_new();
+        this.__wbg_ptr = ret;
+        McClellanOscillatorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.mcclellanoscillator_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @returns {number | undefined}
+     */
+    update(change, volume, new_high, new_low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.mcclellanoscillator_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.mcclellanoscillator_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) McClellanOscillator.prototype[Symbol.dispose] = McClellanOscillator.prototype.free;
+
+export class McClellanSummationIndex {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        McClellanSummationIndexFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_mcclellansummationindex_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.mcclellansummationindex_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
-    /**
-     * @param {number} period
-     */
-    constructor(period) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.maxdrawdown_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;
-            MaxDrawdownFinalization.register(this, this.__wbg_ptr, this);
-            return this;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
+    constructor() {
+        const ret = wasm.mcclellansummationindex_new();
+        this.__wbg_ptr = ret;
+        McClellanSummationIndexFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     reset() {
-        wasm.maxdrawdown_reset(this.__wbg_ptr);
+        wasm.mcclellansummationindex_reset(this.__wbg_ptr);
     }
     /**
-     * @param {number} value
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
      * @returns {number | undefined}
      */
-    update(value) {
+    update(change, volume, new_high, new_low) {
         try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.maxdrawdown_update(retptr, this.__wbg_ptr, value);
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.mcclellansummationindex_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
             return r0 === 0 ? undefined : r2;
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_add_to_stack_pointer(32);
         }
     }
     /**
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.maxdrawdown_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.mcclellansummationindex_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) MaxDrawdown.prototype[Symbol.dispose] = MaxDrawdown.prototype.free;
+if (Symbol.dispose) McClellanSummationIndex.prototype[Symbol.dispose] = McClellanSummationIndex.prototype.free;
 
 export class McGinleyDynamic {
     __destroy_into_raw() {
@@ -14341,6 +15215,74 @@ export class NVI {
 }
 if (Symbol.dispose) NVI.prototype[Symbol.dispose] = NVI.prototype.free;
 
+export class NewHighsNewLows {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        NewHighsNewLowsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_newhighsnewlows_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.newhighsnewlows_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.newhighsnewlows_new();
+        this.__wbg_ptr = ret;
+        NewHighsNewLowsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.newhighsnewlows_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @returns {number | undefined}
+     */
+    update(change, volume, new_high, new_low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.newhighsnewlows_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.newhighsnewlows_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) NewHighsNewLows.prototype[Symbol.dispose] = NewHighsNewLows.prototype.free;
+
 export class OBV {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -15285,6 +16227,142 @@ export class OuHalfLife {
 }
 if (Symbol.dispose) OuHalfLife.prototype[Symbol.dispose] = OuHalfLife.prototype.free;
 
+export class OvernightGap {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OvernightGapFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_overnightgap_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.overnightgap_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} utc_offset_minutes
+     */
+    constructor(utc_offset_minutes) {
+        const ret = wasm.overnightgap_new(utc_offset_minutes);
+        this.__wbg_ptr = ret;
+        OvernightGapFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.overnightgap_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} open
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @param {number} volume
+     * @param {bigint} timestamp
+     * @returns {number | undefined}
+     */
+    update(open, high, low, close, volume, timestamp) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.overnightgap_update(retptr, this.__wbg_ptr, open, high, low, close, volume, timestamp);
+            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}
+     */
+    utcOffsetMinutes() {
+        const ret = wasm.overnightgap_utcOffsetMinutes(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.overnightgap_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) OvernightGap.prototype[Symbol.dispose] = OvernightGap.prototype.free;
+
+export class OvernightIntradayReturn {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OvernightIntradayReturnFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_overnightintradayreturn_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.overnightintradayreturn_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} utc_offset_minutes
+     */
+    constructor(utc_offset_minutes) {
+        const ret = wasm.overnightintradayreturn_new(utc_offset_minutes);
+        this.__wbg_ptr = ret;
+        OvernightIntradayReturnFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.overnightintradayreturn_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} open
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @param {number} volume
+     * @param {bigint} timestamp
+     * @returns {any}
+     */
+    update(open, high, low, close, volume, timestamp) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.overnightintradayreturn_update(retptr, this.__wbg_ptr, open, high, low, close, volume, timestamp);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.overnightintradayreturn_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) OvernightIntradayReturn.prototype[Symbol.dispose] = OvernightIntradayReturn.prototype.free;
+
 export class PGO {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -16309,33 +17387,104 @@ export class PearsonCorrelation {
         }
     }
     reset() {
-        wasm.pearsoncorrelation_reset(this.__wbg_ptr);
+        wasm.pearsoncorrelation_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.pearsoncorrelation_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.pearsoncorrelation_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) PearsonCorrelation.prototype[Symbol.dispose] = PearsonCorrelation.prototype.free;
+
+export class PercentAboveMa {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PercentAboveMaFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_percentabovema_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.percentabovema_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.percentabovema_new();
+        this.__wbg_ptr = ret;
+        PercentAboveMaFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.percentabovema_reset(this.__wbg_ptr);
     }
     /**
-     * @param {number} x
-     * @param {number} y
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @param {Float64Array} above_ma
      * @returns {number | undefined}
      */
-    update(x, y) {
+    update(change, volume, new_high, new_low, above_ma) {
         try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.pearsoncorrelation_update(retptr, this.__wbg_ptr, x, y);
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            const ptr4 = passArrayF64ToWasm0(above_ma, wasm.__wbindgen_export3);
+            const len4 = WASM_VECTOR_LEN;
+            wasm.percentabovema_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
             return r0 === 0 ? undefined : r2;
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_add_to_stack_pointer(32);
         }
     }
     /**
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.pearsoncorrelation_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.percentabovema_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) PearsonCorrelation.prototype[Symbol.dispose] = PearsonCorrelation.prototype.free;
+if (Symbol.dispose) PercentAboveMa.prototype[Symbol.dispose] = PercentAboveMa.prototype.free;
 
 export class PercentB {
     __destroy_into_raw() {
@@ -18936,37 +20085,263 @@ export class STC {
      * @param {number} schaff_period
      * @param {number} factor
      */
-    constructor(fast, slow, schaff_period, factor) {
+    constructor(fast, slow, schaff_period, factor) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.stc_new(retptr, fast, slow, schaff_period, factor);
+            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;
+            STCFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.stc_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.stc_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.stc_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) STC.prototype[Symbol.dispose] = STC.prototype.free;
+
+export class SeasonalZScore {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SeasonalZScoreFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_seasonalzscore_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.seasonalzscore_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} utc_offset_minutes
+     */
+    constructor(utc_offset_minutes) {
+        const ret = wasm.seasonalzscore_new(utc_offset_minutes);
+        this.__wbg_ptr = ret;
+        SeasonalZScoreFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.seasonalzscore_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} open
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @param {number} volume
+     * @param {bigint} timestamp
+     * @returns {number | undefined}
+     */
+    update(open, high, low, close, volume, timestamp) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.seasonalzscore_update(retptr, this.__wbg_ptr, open, high, low, close, volume, timestamp);
+            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}
+     */
+    utcOffsetMinutes() {
+        const ret = wasm.seasonalzscore_utcOffsetMinutes(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.seasonalzscore_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) SeasonalZScore.prototype[Symbol.dispose] = SeasonalZScore.prototype.free;
+
+export class SeparatingLines {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SeparatingLinesFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_separatinglines_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.separatinglines_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.separatinglines_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.separatinglines_new();
+        this.__wbg_ptr = ret;
+        SeparatingLinesFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.separatinglines_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.separatinglines_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.separatinglines_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) SeparatingLines.prototype[Symbol.dispose] = SeparatingLines.prototype.free;
+
+export class SessionHighLow {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SessionHighLowFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_sessionhighlow_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.sessionhighlow_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} utc_offset_minutes
+     */
+    constructor(utc_offset_minutes) {
+        const ret = wasm.sessionhighlow_new(utc_offset_minutes);
+        this.__wbg_ptr = ret;
+        SessionHighLowFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.sessionhighlow_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} open
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @param {number} volume
+     * @param {bigint} timestamp
+     * @returns {any}
+     */
+    update(open, high, low, close, volume, timestamp) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.stc_new(retptr, fast, slow, schaff_period, factor);
+            wasm.sessionhighlow_update(retptr, this.__wbg_ptr, open, high, low, close, volume, timestamp);
             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;
-            STCFinalization.register(this, this.__wbg_ptr, this);
-            return this;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    reset() {
-        wasm.stc_reset(this.__wbg_ptr);
-    }
-    /**
-     * @param {number} value
-     * @returns {number | undefined}
-     */
-    update(value) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.stc_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;
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -18975,42 +20350,55 @@ export class STC {
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.stc_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.sessionhighlow_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) STC.prototype[Symbol.dispose] = STC.prototype.free;
+if (Symbol.dispose) SessionHighLow.prototype[Symbol.dispose] = SessionHighLow.prototype.free;
 
-export class SeparatingLines {
+export class SessionRange {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        SeparatingLinesFinalization.unregister(this);
+        SessionRangeFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_separatinglines_free(ptr, 0);
+        wasm.__wbg_sessionrange_free(ptr, 0);
     }
     /**
-     * @param {Float64Array} open
-     * @param {Float64Array} high
-     * @param {Float64Array} low
-     * @param {Float64Array} close
-     * @returns {Float64Array}
+     * @returns {boolean}
      */
-    batch(open, high, low, close) {
+    isReady() {
+        const ret = wasm.sessionrange_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} utc_offset_minutes
+     */
+    constructor(utc_offset_minutes) {
+        const ret = wasm.sessionrange_new(utc_offset_minutes);
+        this.__wbg_ptr = ret;
+        SessionRangeFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.sessionrange_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} open
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @param {number} volume
+     * @param {bigint} timestamp
+     * @returns {any}
+     */
+    update(open, high, low, close, volume, timestamp) {
         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.separatinglines_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            wasm.sessionrange_update(retptr, this.__wbg_ptr, open, high, low, close, volume, timestamp);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -19022,33 +20410,59 @@ export class SeparatingLines {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.sessionrange_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) SessionRange.prototype[Symbol.dispose] = SessionRange.prototype.free;
+
+export class SessionVwap {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SessionVwapFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_sessionvwap_free(ptr, 0);
+    }
     /**
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.separatinglines_isReady(this.__wbg_ptr);
+        const ret = wasm.sessionvwap_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
-    constructor() {
-        const ret = wasm.separatinglines_new();
+    /**
+     * @param {number} utc_offset_minutes
+     */
+    constructor(utc_offset_minutes) {
+        const ret = wasm.sessionvwap_new(utc_offset_minutes);
         this.__wbg_ptr = ret;
-        SeparatingLinesFinalization.register(this, this.__wbg_ptr, this);
+        SessionVwapFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     reset() {
-        wasm.separatinglines_reset(this.__wbg_ptr);
+        wasm.sessionvwap_reset(this.__wbg_ptr);
     }
     /**
      * @param {number} open
      * @param {number} high
      * @param {number} low
      * @param {number} close
+     * @param {number} volume
+     * @param {bigint} timestamp
      * @returns {number | undefined}
      */
-    update(open, high, low, close) {
+    update(open, high, low, close, volume, timestamp) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
-            wasm.separatinglines_update(retptr, this.__wbg_ptr, open, high, low, close);
+            wasm.sessionvwap_update(retptr, this.__wbg_ptr, open, high, low, close, volume, timestamp);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
             var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
@@ -19061,15 +20475,22 @@ export class SeparatingLines {
             wasm.__wbindgen_add_to_stack_pointer(32);
         }
     }
+    /**
+     * @returns {number}
+     */
+    utcOffsetMinutes() {
+        const ret = wasm.sessionvwap_utcOffsetMinutes(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.separatinglines_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.sessionvwap_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) SeparatingLines.prototype[Symbol.dispose] = SeparatingLines.prototype.free;
+if (Symbol.dispose) SessionVwap.prototype[Symbol.dispose] = SessionVwap.prototype.free;
 
 export class SharpeRatio {
     __destroy_into_raw() {
@@ -23518,6 +24939,157 @@ export class Thrusting {
 }
 if (Symbol.dispose) Thrusting.prototype[Symbol.dispose] = Thrusting.prototype.free;
 
+export class TickIndex {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TickIndexFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tickindex_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.tickindex_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.tickindex_new();
+        this.__wbg_ptr = ret;
+        TickIndexFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.tickindex_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @returns {number | undefined}
+     */
+    update(change, volume, new_high, new_low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.tickindex_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            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.tickindex_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) TickIndex.prototype[Symbol.dispose] = TickIndex.prototype.free;
+
+export class TimeOfDayReturnProfile {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TimeOfDayReturnProfileFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_timeofdayreturnprofile_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.timeofdayreturnprofile_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} buckets
+     * @param {number} utc_offset_minutes
+     */
+    constructor(buckets, utc_offset_minutes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.timeofdayreturnprofile_new(retptr, buckets, utc_offset_minutes);
+            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;
+            TimeOfDayReturnProfileFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.timeofdayreturnprofile_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} open
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @param {number} volume
+     * @param {bigint} timestamp
+     * @returns {any}
+     */
+    update(open, high, low, close, volume, timestamp) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.timeofdayreturnprofile_update(retptr, this.__wbg_ptr, open, high, low, close, volume, timestamp);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    utcOffsetMinutes() {
+        const ret = wasm.timeofdayreturnprofile_utcOffsetMinutes(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.timeofdayreturnprofile_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) TimeOfDayReturnProfile.prototype[Symbol.dispose] = TimeOfDayReturnProfile.prototype.free;
+
 export class TpoProfile {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -23752,33 +25324,101 @@ export class TreynorRatio {
         }
     }
     reset() {
-        wasm.treynorratio_reset(this.__wbg_ptr);
+        wasm.treynorratio_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} asset
+     * @param {number} benchmark
+     * @returns {number | undefined}
+     */
+    update(asset, benchmark) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.treynorratio_update(retptr, this.__wbg_ptr, asset, benchmark);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.treynorratio_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) TreynorRatio.prototype[Symbol.dispose] = TreynorRatio.prototype.free;
+
+export class Trin {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TrinFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_trin_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.trin_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.trin_new();
+        this.__wbg_ptr = ret;
+        TrinFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.trin_reset(this.__wbg_ptr);
     }
     /**
-     * @param {number} asset
-     * @param {number} benchmark
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
      * @returns {number | undefined}
      */
-    update(asset, benchmark) {
+    update(change, volume, new_high, new_low) {
         try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.treynorratio_update(retptr, this.__wbg_ptr, asset, benchmark);
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.trin_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
             return r0 === 0 ? undefined : r2;
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_add_to_stack_pointer(32);
         }
     }
     /**
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.treynorratio_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.trin_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) TreynorRatio.prototype[Symbol.dispose] = TreynorRatio.prototype.free;
+if (Symbol.dispose) Trin.prototype[Symbol.dispose] = Trin.prototype.free;
 
 export class TrueRange {
     __destroy_into_raw() {
@@ -23954,6 +25594,84 @@ export class TtmSqueeze {
 }
 if (Symbol.dispose) TtmSqueeze.prototype[Symbol.dispose] = TtmSqueeze.prototype.free;
 
+export class TurnOfMonth {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TurnOfMonthFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_turnofmonth_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.turnofmonth_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} n_first
+     * @param {number} n_last
+     * @param {number} utc_offset_minutes
+     */
+    constructor(n_first, n_last, utc_offset_minutes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.turnofmonth_new(retptr, n_first, n_last, utc_offset_minutes);
+            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;
+            TurnOfMonthFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.turnofmonth_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} open
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @param {number} volume
+     * @param {bigint} timestamp
+     * @returns {number | undefined}
+     */
+    update(open, high, low, close, volume, timestamp) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.turnofmonth_update(retptr, this.__wbg_ptr, open, high, low, close, volume, timestamp);
+            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.turnofmonth_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) TurnOfMonth.prototype[Symbol.dispose] = TurnOfMonth.prototype.free;
+
 export class Tweezer {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -24460,6 +26178,74 @@ export class UniqueThreeRiver {
 }
 if (Symbol.dispose) UniqueThreeRiver.prototype[Symbol.dispose] = UniqueThreeRiver.prototype.free;
 
+export class UpDownVolumeRatio {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        UpDownVolumeRatioFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_updownvolumeratio_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.updownvolumeratio_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.updownvolumeratio_new();
+        this.__wbg_ptr = ret;
+        UpDownVolumeRatioFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.updownvolumeratio_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {Float64Array} change
+     * @param {Float64Array} volume
+     * @param {Float64Array} new_high
+     * @param {Float64Array} new_low
+     * @returns {number | undefined}
+     */
+    update(change, volume, new_high, new_low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            const ptr0 = passArrayF64ToWasm0(change, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(volume, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(new_high, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(new_low, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.updownvolumeratio_update(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.updownvolumeratio_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) UpDownVolumeRatio.prototype[Symbol.dispose] = UpDownVolumeRatio.prototype.free;
+
 export class UpsideGapThreeMethods {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -25483,6 +27269,89 @@ export class VoltyStop {
 }
 if (Symbol.dispose) VoltyStop.prototype[Symbol.dispose] = VoltyStop.prototype.free;
 
+export class VolumeByTimeProfile {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        VolumeByTimeProfileFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_volumebytimeprofile_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.volumebytimeprofile_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} buckets
+     * @param {number} utc_offset_minutes
+     */
+    constructor(buckets, utc_offset_minutes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.volumebytimeprofile_new(retptr, buckets, utc_offset_minutes);
+            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;
+            VolumeByTimeProfileFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.volumebytimeprofile_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} open
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @param {number} volume
+     * @param {bigint} timestamp
+     * @returns {any}
+     */
+    update(open, high, low, close, volume, timestamp) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.volumebytimeprofile_update(retptr, this.__wbg_ptr, open, high, low, close, volume, timestamp);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    utcOffsetMinutes() {
+        const ret = wasm.volumebytimeprofile_utcOffsetMinutes(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.volumebytimeprofile_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) VolumeByTimeProfile.prototype[Symbol.dispose] = VolumeByTimeProfile.prototype.free;
+
 export class VolumeOscillator {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -27139,6 +29008,9 @@ export function __wbindgen_object_drop_ref(arg0) {
 const AbandonedBabyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_abandonedbaby_free(ptr, 1));
+const AbsoluteBreadthIndexFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_absolutebreadthindex_free(ptr, 1));
 const AccelerationBandsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_accelerationbands_free(ptr, 1));
@@ -27148,6 +29020,9 @@ const AcceleratorOscillatorFinalization = (typeof FinalizationRegistry === 'unde
 const WilliamsADFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_williamsad_free(ptr, 1));
+const AdVolumeLineFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_advolumeline_free(ptr, 1));
 const AdaptiveCycleFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_adaptivecycle_free(ptr, 1));
@@ -27160,6 +29035,9 @@ const AdvanceBlockFinalization = (typeof FinalizationRegistry === 'undefined')
 const AdvanceDeclineFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_advancedecline_free(ptr, 1));
+const AdvanceDeclineRatioFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_advancedeclineratio_free(ptr, 1));
 const ADXFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_adx_free(ptr, 1));
@@ -27208,6 +29086,9 @@ const AtrTrailingStopFinalization = (typeof FinalizationRegistry === 'undefined'
 const AutocorrelationFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_autocorrelation_free(ptr, 1));
+const AverageDailyRangeFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_averagedailyrange_free(ptr, 1));
 const AverageDrawdownFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_averagedrawdown_free(ptr, 1));
@@ -27232,9 +29113,15 @@ const BetaNeutralSpreadFinalization = (typeof FinalizationRegistry === 'undefine
 const BollingerBandwidthFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_bollingerbandwidth_free(ptr, 1));
+const BreadthThrustFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_breadththrust_free(ptr, 1));
 const BreakawayFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_breakaway_free(ptr, 1));
+const BullishPercentIndexFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_bullishpercentindex_free(ptr, 1));
 const CalendarSpreadFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_calendarspread_free(ptr, 1));
@@ -27304,9 +29191,15 @@ const CounterattackFinalization = (typeof FinalizationRegistry === 'undefined')
 const CumulativeVolumeDeltaFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_cumulativevolumedelta_free(ptr, 1));
+const CumulativeVolumeIndexFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_cumulativevolumeindex_free(ptr, 1));
 const CyberneticCycleFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_cyberneticcycle_free(ptr, 1));
+const DayOfWeekProfileFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_dayofweekprofile_free(ptr, 1));
 const DecyclerFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_decycler_free(ptr, 1));
@@ -27454,6 +29347,9 @@ const HeikinAshiFinalization = (typeof FinalizationRegistry === 'undefined')
 const HiLoActivatorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_hiloactivator_free(ptr, 1));
+const HighLowIndexFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_highlowindex_free(ptr, 1));
 const HighWaveFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_highwave_free(ptr, 1));
@@ -27511,6 +29407,9 @@ const InitialBalanceFinalization = (typeof FinalizationRegistry === 'undefined')
 const InstantaneousTrendlineFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_instantaneoustrendline_free(ptr, 1));
+const IntradayVolatilityProfileFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_intradayvolatilityprofile_free(ptr, 1));
 const InverseFisherTransformFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_inversefishertransform_free(ptr, 1));
@@ -27622,6 +29521,12 @@ const MatchingLowFinalization = (typeof FinalizationRegistry === 'undefined')
 const MaxDrawdownFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_maxdrawdown_free(ptr, 1));
+const McClellanOscillatorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_mcclellanoscillator_free(ptr, 1));
+const McClellanSummationIndexFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_mcclellansummationindex_free(ptr, 1));
 const McGinleyDynamicFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_mcginleydynamic_free(ptr, 1));
@@ -27661,6 +29566,9 @@ const MorningEveningStarFinalization = (typeof FinalizationRegistry === 'undefin
 const NATRFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_natr_free(ptr, 1));
+const NewHighsNewLowsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_newhighsnewlows_free(ptr, 1));
 const NVIFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_nvi_free(ptr, 1));
@@ -27700,6 +29608,12 @@ const OrderBookImbalanceTopNFinalization = (typeof FinalizationRegistry === 'und
 const OuHalfLifeFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ouhalflife_free(ptr, 1));
+const OvernightGapFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_overnightgap_free(ptr, 1));
+const OvernightIntradayReturnFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_overnightintradayreturn_free(ptr, 1));
 const PainIndexFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_painindex_free(ptr, 1));
@@ -27715,6 +29629,9 @@ const ParkinsonVolatilityFinalization = (typeof FinalizationRegistry === 'undefi
 const PearsonCorrelationFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_pearsoncorrelation_free(ptr, 1));
+const PercentAboveMaFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_percentabovema_free(ptr, 1));
 const PercentBFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_percentb_free(ptr, 1));
@@ -27820,9 +29737,21 @@ const RWIFinalization = (typeof FinalizationRegistry === 'undefined')
 const SAREXTFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sarext_free(ptr, 1));
+const SeasonalZScoreFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_seasonalzscore_free(ptr, 1));
 const SeparatingLinesFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_separatinglines_free(ptr, 1));
+const SessionHighLowFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sessionhighlow_free(ptr, 1));
+const SessionRangeFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sessionrange_free(ptr, 1));
+const SessionVwapFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sessionvwap_free(ptr, 1));
 const SharpeRatioFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sharperatio_free(ptr, 1));
@@ -27973,9 +29902,15 @@ const ThreeStarsInSouthFinalization = (typeof FinalizationRegistry === 'undefine
 const ThrustingFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_thrusting_free(ptr, 1));
+const TickIndexFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tickindex_free(ptr, 1));
 const TIIFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tii_free(ptr, 1));
+const TimeOfDayReturnProfileFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_timeofdayreturnprofile_free(ptr, 1));
 const TpoProfileFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tpoprofile_free(ptr, 1));
@@ -27988,6 +29923,9 @@ const TreynorRatioFinalization = (typeof FinalizationRegistry === 'undefined')
 const TRIMAFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_trima_free(ptr, 1));
+const TrinFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_trin_free(ptr, 1));
 const TRIXFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_trix_free(ptr, 1));
@@ -28006,6 +29944,9 @@ const TSVFinalization = (typeof FinalizationRegistry === 'undefined')
 const TtmSqueezeFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ttmsqueeze_free(ptr, 1));
+const TurnOfMonthFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_turnofmonth_free(ptr, 1));
 const TweezerFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tweezer_free(ptr, 1));
@@ -28024,6 +29965,9 @@ const UltimateOscillatorFinalization = (typeof FinalizationRegistry === 'undefin
 const UniqueThreeRiverFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_uniquethreeriver_free(ptr, 1));
+const UpDownVolumeRatioFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_updownvolumeratio_free(ptr, 1));
 const UpsideGapThreeMethodsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_upsidegapthreemethods_free(ptr, 1));
@@ -28051,6 +29995,9 @@ const VIDYAFinalization = (typeof FinalizationRegistry === 'undefined')
 const VoltyStopFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_voltystop_free(ptr, 1));
+const VolumeByTimeProfileFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_volumebytimeprofile_free(ptr, 1));
 const VolumeOscillatorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_volumeoscillator_free(ptr, 1));