zengeld-canvas 0.1.6 → 0.1.8

package/zengeld_canvas_wasm.js

@@ -1,5 +1,27 @@
 let wasm;
 
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
 function getStringFromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return decodeText(ptr, len);
@@ -10,43 +32,1724 @@ function getUint8ArrayMemory0() {
     if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
         cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
     }
-    return cachedUint8ArrayMemory0;
-}
-
-let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-cachedTextDecoder.decode();
-const MAX_SAFARI_DECODE_BYTES = 2146435072;
-let numBytesDecoded = 0;
-function decodeText(ptr, len) {
-    numBytesDecoded += len;
-    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
-        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-        cachedTextDecoder.decode();
-        numBytesDecoded = len;
+    return cachedUint8ArrayMemory0;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function passArrayF64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getFloat64ArrayMemory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    }
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const ChartFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_chart_free(ptr >>> 0, 1));
+
+const JsBarFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsbar_free(ptr >>> 0, 1));
+
+const JsChartConfigFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jschartconfig_free(ptr >>> 0, 1));
+
+const JsThemeFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jstheme_free(ptr >>> 0, 1));
+
+const JsViewportFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsviewport_free(ptr >>> 0, 1));
+
+/**
+ * High-level chart builder for creating financial charts.
+ */
+export class Chart {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ChartFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_chart_free(ptr, 0);
+    }
+    /**
+     * Arrow down
+     * @param {number} x
+     * @param {number} y
+     */
+    arrowDown(x, y) {
+        wasm.chart_arrowDown(this.__wbg_ptr, x, y);
+    }
+    /**
+     * Arrow line
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    arrowLine(x1, y1, x2, y2) {
+        wasm.chart_arrowLine(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Buy signal
+     * @param {number} bar_index
+     * @param {number} price
+     * @param {string | null} [label]
+     */
+    buySignal(bar_index, price, label) {
+        var ptr0 = isLikeNone(label) ? 0 : passStringToWasm0(label, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.chart_buySignal(this.__wbg_ptr, bar_index, price, ptr0, len0);
+    }
+    /**
+     * Choppiness Index
+     * @param {number} period
+     */
+    choppiness(period) {
+        wasm.chart_choppiness(this.__wbg_ptr, period);
+    }
+    /**
+     * Cross line at position
+     * @param {number} x
+     * @param {number} y
+     */
+    crossLine(x, y) {
+        wasm.chart_crossLine(this.__wbg_ptr, x, y);
+    }
+    /**
+     * Apply dark theme
+     */
+    darkTheme() {
+        wasm.chart_darkTheme(this.__wbg_ptr);
+    }
+    /**
+     * Date range
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    dateRange(x1, y1, x2, y2) {
+        wasm.chart_dateRange(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Fibonacci spiral
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    fibSpiral(x1, y1, x2, y2) {
+        wasm.chart_fibSpiral(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Mass Index
+     */
+    massIndex() {
+        wasm.chart_massIndex(this.__wbg_ptr);
+    }
+    /**
+     * Price note
+     * @param {number} x
+     * @param {number} y
+     * @param {string} content
+     */
+    priceNote(x, y, content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_priceNote(this.__wbg_ptr, x, y, ptr0, len0);
+    }
+    /**
+     * Projection
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    projection(x1, y1, x2, y2) {
+        wasm.chart_projection(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Render chart to SVG string
+     * @returns {string}
+     */
+    renderSvg() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.chart_renderSvg(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Set up/down colors
+     * @param {string} up
+     * @param {string} down
+     */
+    setColors(up, down) {
+        const ptr0 = passStringToWasm0(up, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(down, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.chart_setColors(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    }
+    /**
+     * Stochastic Oscillator
+     * @param {number} k
+     * @param {number} d
+     */
+    stochastic(k, d) {
+        wasm.chart_stochastic(this.__wbg_ptr, k, d);
+    }
+    /**
+     * Supertrend
+     * @param {number} period
+     * @param {number} multiplier
+     */
+    supertrend(period, multiplier) {
+        wasm.chart_supertrend(this.__wbg_ptr, period, multiplier);
+    }
+    /**
+     * Trend line between two points
+     * @param {number} start_x
+     * @param {number} start_y
+     * @param {number} end_x
+     * @param {number} end_y
+     */
+    trendLine(start_x, start_y, end_x, end_y) {
+        wasm.chart_trendLine(this.__wbg_ptr, start_x, start_y, end_x, end_y);
+    }
+    /**
+     * Williams %R
+     * @param {number} period
+     */
+    williamsR(period) {
+        wasm.chart_williamsR(this.__wbg_ptr, period);
+    }
+    /**
+     * Custom overlay with pre-calculated values
+     * @param {string} name
+     * @param {Float64Array} values
+     * @param {string} color
+     */
+    addOverlay(name, values, color) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.chart_addOverlay(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+    }
+    /**
+     * Connors RSI
+     */
+    connorsRsi() {
+        wasm.chart_connorsRsi(this.__wbg_ptr);
+    }
+    /**
+     * Cycle lines
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    cycleLines(x1, y1, x2, y2) {
+        wasm.chart_cycleLines(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Exit signal
+     * @param {number} bar_index
+     * @param {number} price
+     * @param {string | null} [label]
+     */
+    exitSignal(bar_index, price, label) {
+        var ptr0 = isLikeNone(label) ? 0 : passStringToWasm0(label, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.chart_exitSignal(this.__wbg_ptr, bar_index, price, ptr0, len0);
+    }
+    /**
+     * Fibonacci channel
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     * @param {number} x3
+     * @param {number} y3
+     */
+    fibChannel(x1, y1, x2, y2, x3, y3) {
+        wasm.chart_fibChannel(this.__wbg_ptr, x1, y1, x2, y2, x3, y3);
+    }
+    /**
+     * Fibonacci circles
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    fibCircles(x1, y1, x2, y2) {
+        wasm.chart_fibCircles(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Force Index
+     * @param {number} period
+     */
+    forceIndex(period) {
+        wasm.chart_forceIndex(this.__wbg_ptr, period);
+    }
+    /**
+     * Gann Square
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    gannSquare(x1, y1, x2, y2) {
+        wasm.chart_gannSquare(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Highlighter
+     * @param {Float64Array} points
+     */
+    highlighter(points) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_highlighter(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Apply light theme
+     */
+    lightTheme() {
+        wasm.chart_lightTheme(this.__wbg_ptr);
+    }
+    /**
+     * Price label
+     * @param {number} x
+     * @param {number} y
+     */
+    priceLabel(x, y) {
+        wasm.chart_priceLabel(this.__wbg_ptr, x, y);
+    }
+    /**
+     * Price range
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    priceRange(x1, y1, x2, y2) {
+        wasm.chart_priceRange(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Sell signal
+     * @param {number} bar_index
+     * @param {number} price
+     * @param {string | null} [label]
+     */
+    sellSignal(bar_index, price, label) {
+        var ptr0 = isLikeNone(label) ? 0 : passStringToWasm0(label, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.chart_sellSignal(this.__wbg_ptr, bar_index, price, ptr0, len0);
+    }
+    /**
+     * SMI Ergodic
+     */
+    smiErgodic() {
+        wasm.chart_smiErgodic(this.__wbg_ptr);
+    }
+    /**
+     * Time cycles
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    timeCycles(x1, y1, x2, y2) {
+        wasm.chart_timeCycles(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Trend angle
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    trendAngle(x1, y1, x2, y2) {
+        wasm.chart_trendAngle(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Ulcer Index
+     * @param {number} period
+     */
+    ulcerIndex(period) {
+        wasm.chart_ulcerIndex(this.__wbg_ptr, period);
+    }
+    /**
+     * ABCD Pattern
+     * @param {Float64Array} points
+     */
+    abcdPattern(points) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_abcdPattern(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Arrow marker
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    arrowMarker(x1, y1, x2, y2) {
+        wasm.chart_arrowMarker(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Bars pattern
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    barsPattern(x1, y1, x2, y2) {
+        wasm.chart_barsPattern(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Candlestick chart (default)
+     */
+    candlesticks() {
+        wasm.chart_candlesticks(this.__wbg_ptr);
+    }
+    /**
+     * Double curve
+     * @param {Float64Array} points
+     */
+    doubleCurve(points) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_doubleCurve(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Entry signal
+     * @param {number} bar_index
+     * @param {number} price
+     * @param {string | null} [label]
+     */
+    entrySignal(bar_index, price, label) {
+        var ptr0 = isLikeNone(label) ? 0 : passStringToWasm0(label, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.chart_entrySignal(this.__wbg_ptr, bar_index, price, ptr0, len0);
+    }
+    /**
+     * MACD with default settings (12, 26, 9)
+     */
+    macdDefault() {
+        wasm.chart_macdDefault(this.__wbg_ptr);
+    }
+    /**
+     * Pivot Points
+     */
+    pivotPoints() {
+        wasm.chart_pivotPoints(this.__wbg_ptr);
+    }
+    /**
+     * Three Drives
+     * @param {Float64Array} points
+     */
+    threeDrives(points) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_threeDrives(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Anchored text
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     * @param {string} content
+     */
+    anchoredText(x1, y1, x2, y2, content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_anchoredText(this.__wbg_ptr, x1, y1, x2, y2, ptr0, len0);
+    }
+    /**
+     * Anchored VWAP
+     * @param {number} x
+     * @param {number} y
+     */
+    anchoredVwap(x, y) {
+        wasm.chart_anchoredVwap(this.__wbg_ptr, x, y);
+    }
+    /**
+     * Coppock Curve
+     */
+    coppockCurve() {
+        wasm.chart_coppockCurve(this.__wbg_ptr);
+    }
+    /**
+     * Custom signal
+     * @param {number} bar_index
+     * @param {number} price
+     * @param {string} label
+     */
+    customSignal(bar_index, price, label) {
+        const ptr0 = passStringToWasm0(label, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_customSignal(this.__wbg_ptr, bar_index, price, ptr0, len0);
+    }
+    /**
+     * Extended line (infinite in both directions)
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    extendedLine(x1, y1, x2, y2) {
+        wasm.chart_extendedLine(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Fibonacci extension
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     * @param {number} x3
+     * @param {number} y3
+     */
+    fibExtension(x1, y1, x2, y2, x3, y3) {
+        wasm.chart_fibExtension(this.__wbg_ptr, x1, y1, x2, y2, x3, y3);
+    }
+    /**
+     * Long position
+     * @param {number} ex
+     * @param {number} ey
+     * @param {number} tpx
+     * @param {number} tpy
+     * @param {number} slx
+     * @param {number} sly
+     */
+    longPosition(ex, ey, tpx, tpy, slx, sly) {
+        wasm.chart_longPosition(this.__wbg_ptr, ex, ey, tpx, tpy, slx, sly);
+    }
+    /**
+     * Price Channel
+     * @param {number} period
+     */
+    priceChannel(period) {
+        wasm.chart_priceChannel(this.__wbg_ptr, period);
+    }
+    /**
+     * Vertical line at bar index
+     * @param {number} bar_index
+     */
+    verticalLine(bar_index) {
+        wasm.chart_verticalLine(this.__wbg_ptr, bar_index);
+    }
+    /**
+     * XABCD Pattern
+     * @param {Float64Array} points
+     */
+    xabcdPattern(points) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_xabcdPattern(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Cypher Pattern
+     * @param {Float64Array} points
+     */
+    cypherPattern(points) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_cypherPattern(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Fibonacci time zones
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    fibTimeZones(x1, y1, x2, y2) {
+        wasm.chart_fibTimeZones(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Fibonacci trend time
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     * @param {number} x3
+     * @param {number} y3
+     */
+    fibTrendTime(x1, y1, x2, y2, x3, y3) {
+        wasm.chart_fibTrendTime(this.__wbg_ptr, x1, y1, x2, y2, x3, y3);
+    }
+    /**
+     * Head and Shoulders
+     * @param {Float64Array} points
+     */
+    headShoulders(points) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_headShoulders(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Horizontal ray
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    horizontalRay(x1, y1, x2, y2) {
+        wasm.chart_horizontalRay(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Set background color
+     * @param {string} color
+     */
+    setBackground(color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_setBackground(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Short position
+     * @param {number} ex
+     * @param {number} ey
+     * @param {number} tpx
+     * @param {number} tpy
+     * @param {number} slx
+     * @param {number} sly
+     */
+    shortPosition(ex, ey, tpx, tpy, slx, sly) {
+        wasm.chart_shortPosition(this.__wbg_ptr, ex, ey, tpx, tpy, slx, sly);
+    }
+    /**
+     * Elliott Impulse Wave
+     * @param {Float64Array} points
+     */
+    elliottImpulse(points) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_elliottImpulse(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Fibonacci retracement
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    fibRetracement(x1, y1, x2, y2) {
+        wasm.chart_fibRetracement(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Flat top/bottom channel
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     * @param {number} x3
+     * @param {number} y3
+     */
+    flatTopBottom(x1, y1, x2, y2, x3, y3) {
+        wasm.chart_flatTopBottom(this.__wbg_ptr, x1, y1, x2, y2, x3, y3);
+    }
+    /**
+     * Horizontal line at price level
+     * @param {number} price
+     */
+    horizontalLine(price) {
+        wasm.chart_horizontalLine(this.__wbg_ptr, price);
+    }
+    /**
+     * Modified Schiff Pitchfork
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     * @param {number} x3
+     * @param {number} y3
+     */
+    modifiedSchiff(x1, y1, x2, y2, x3, y3) {
+        wasm.chart_modifiedSchiff(this.__wbg_ptr, x1, y1, x2, y2, x3, y3);
+    }
+    /**
+     * Aroon Oscillator
+     * @param {number} period
+     */
+    aroonOscillator(period) {
+        wasm.chart_aroonOscillator(this.__wbg_ptr, period);
+    }
+    /**
+     * Balance of Power
+     */
+    balanceOfPower() {
+        wasm.chart_balanceOfPower(this.__wbg_ptr);
+    }
+    /**
+     * Bollinger Bands with filled cloud
+     * @param {number} period
+     */
+    bollingerFilled(period) {
+        wasm.chart_bollingerFilled(this.__wbg_ptr, period);
+    }
+    /**
+     * Disjoint channel
+     * @param {Float64Array} points
+     */
+    disjointChannel(points) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_disjointChannel(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Elliott Triangle
+     * @param {Float64Array} points
+     */
+    elliottTriangle(points) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_elliottTriangle(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Fisher Transform
+     * @param {number} period
+     */
+    fisherTransform(period) {
+        wasm.chart_fisherTransform(this.__wbg_ptr, period);
+    }
+    /**
+     * Inside Pitchfork
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     * @param {number} x3
+     * @param {number} y3
+     */
+    insidePitchfork(x1, y1, x2, y2, x3, y3) {
+        wasm.chart_insidePitchfork(this.__wbg_ptr, x1, y1, x2, y2, x3, y3);
+    }
+    /**
+     * Parallel channel
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     * @param {number} x3
+     * @param {number} y3
+     */
+    parallelChannel(x1, y1, x2, y2, x3, y3) {
+        wasm.chart_parallelChannel(this.__wbg_ptr, x1, y1, x2, y2, x3, y3);
+    }
+    /**
+     * Price and date range
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    priceDateRange(x1, y1, x2, y2) {
+        wasm.chart_priceDateRange(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Price projection
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     * @param {number} x3
+     * @param {number} y3
+     */
+    priceProjection(x1, y1, x2, y2, x3, y3) {
+        wasm.chart_priceProjection(this.__wbg_ptr, x1, y1, x2, y2, x3, y3);
+    }
+    /**
+     * Regression trend channel
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    regressionTrend(x1, y1, x2, y2) {
+        wasm.chart_regressionTrend(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Schiff Pitchfork
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     * @param {number} x3
+     * @param {number} y3
+     */
+    schiffPitchfork(x1, y1, x2, y2, x3, y3) {
+        wasm.chart_schiffPitchfork(this.__wbg_ptr, x1, y1, x2, y2, x3, y3);
+    }
+    /**
+     * Stop loss signal
+     * @param {number} bar_index
+     * @param {number} price
+     * @param {string | null} [label]
+     */
+    stopLossSignal(bar_index, price, label) {
+        var ptr0 = isLikeNone(label) ? 0 : passStringToWasm0(label, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.chart_stopLossSignal(this.__wbg_ptr, bar_index, price, ptr0, len0);
+    }
+    /**
+     * Triangle Pattern
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     * @param {number} x3
+     * @param {number} y3
+     */
+    trianglePattern(x1, y1, x2, y2, x3, y3) {
+        wasm.chart_trianglePattern(this.__wbg_ptr, x1, y1, x2, y2, x3, y3);
+    }
+    /**
+     * Chande Kroll Stop
+     */
+    chandeKrollStop() {
+        wasm.chart_chandeKrollStop(this.__wbg_ptr);
+    }
+    /**
+     * Gann Square Fixed
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    gannSquareFixed(x1, y1, x2, y2) {
+        wasm.chart_gannSquareFixed(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Linear Regression
+     * @param {number} period
+     * @param {string} color
+     */
+    linearRegression(period, color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_linearRegression(this.__wbg_ptr, period, ptr0, len0);
+    }
+    /**
+     * Rotated rectangle
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     * @param {number} x3
+     * @param {number} y3
+     */
+    rotatedRectangle(x1, y1, x2, y2, x3, y3) {
+        wasm.chart_rotatedRectangle(this.__wbg_ptr, x1, y1, x2, y2, x3, y3);
+    }
+    /**
+     * Awesome Oscillator
+     */
+    awesomeOscillator() {
+        wasm.chart_awesomeOscillator(this.__wbg_ptr);
+    }
+    /**
+     * Chaikin Oscillator
+     */
+    chaikinOscillator() {
+        wasm.chart_chaikinOscillator(this.__wbg_ptr);
+    }
+    /**
+     * Elliott Correction Wave
+     * @param {Float64Array} points
+     */
+    elliottCorrection(points) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_elliottCorrection(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Schaff Trend Cycle
+     */
+    schaffTrendCycle() {
+        wasm.chart_schaffTrendCycle(this.__wbg_ptr);
+    }
+    /**
+     * Take profit signal
+     * @param {number} bar_index
+     * @param {number} price
+     * @param {string | null} [label]
+     */
+    takeProfitSignal(bar_index, price, label) {
+        var ptr0 = isLikeNone(label) ? 0 : passStringToWasm0(label, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.chart_takeProfitSignal(this.__wbg_ptr, bar_index, price, ptr0, len0);
+    }
+    /**
+     * Ultimate Oscillator
+     */
+    ultimateOscillator() {
+        wasm.chart_ultimateOscillator(this.__wbg_ptr);
+    }
+    /**
+     * Elliott Double Combo
+     * @param {Float64Array} points
+     */
+    elliottDoubleCombo(points) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_elliottDoubleCombo(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Elliott Triple Combo
+     * @param {Float64Array} points
+     */
+    elliottTripleCombo(points) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_elliottTripleCombo(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Fibonacci speed/resistance
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    fibSpeedResistance(x1, y1, x2, y2) {
+        wasm.chart_fibSpeedResistance(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Fixed volume profile
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    fixedVolumeProfile(x1, y1, x2, y2) {
+        wasm.chart_fixedVolumeProfile(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Historical Volatility
+     * @param {number} period
+     */
+    historicalVolatility(period) {
+        wasm.chart_historicalVolatility(this.__wbg_ptr, period);
+    }
+    /**
+     * Accelerator Oscillator
+     */
+    acceleratorOscillator() {
+        wasm.chart_acceleratorOscillator(this.__wbg_ptr);
+    }
+    /**
+     * Anchored volume profile
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    anchoredVolumeProfile(x1, y1, x2, y2) {
+        wasm.chart_anchoredVolumeProfile(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Linear Regression Slope
+     * @param {number} period
+     */
+    linearRegressionSlope(period) {
+        wasm.chart_linearRegressionSlope(this.__wbg_ptr, period);
+    }
+    /**
+     * Average Directional Index
+     * @param {number} period
+     */
+    adx(period) {
+        wasm.chart_adx(this.__wbg_ptr, period);
+    }
+    /**
+     * Arc
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     * @param {number} x3
+     * @param {number} y3
+     */
+    arc(x1, y1, x2, y2, x3, y3) {
+        wasm.chart_arc(this.__wbg_ptr, x1, y1, x2, y2, x3, y3);
+    }
+    /**
+     * Average True Range
+     * @param {number} period
+     */
+    atr(period) {
+        wasm.chart_atr(this.__wbg_ptr, period);
+    }
+    /**
+     * Commodity Channel Index
+     * @param {number} period
+     */
+    cci(period) {
+        wasm.chart_cci(this.__wbg_ptr, period);
+    }
+    /**
+     * Chaikin Money Flow
+     * @param {number} period
+     */
+    cmf(period) {
+        wasm.chart_cmf(this.__wbg_ptr, period);
+    }
+    /**
+     * Chande Momentum Oscillator
+     * @param {number} period
+     */
+    cmo(period) {
+        wasm.chart_cmo(this.__wbg_ptr, period);
+    }
+    /**
+     * Detrended Price Oscillator
+     * @param {number} period
+     */
+    dpo(period) {
+        wasm.chart_dpo(this.__wbg_ptr, period);
+    }
+    /**
+     * Exponential Moving Average
+     * @param {number} period
+     * @param {string} color
+     */
+    ema(period, color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_ema(this.__wbg_ptr, period, ptr0, len0);
+    }
+    /**
+     * Ease of Movement
+     * @param {number} period
+     */
+    eom(period) {
+        wasm.chart_eom(this.__wbg_ptr, period);
+    }
+    /**
+     * Hull Moving Average
+     * @param {number} period
+     * @param {string} color
+     */
+    hma(period, color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_hma(this.__wbg_ptr, period, ptr0, len0);
+    }
+    /**
+     * Know Sure Thing
+     */
+    kst() {
+        wasm.chart_kst(this.__wbg_ptr);
+    }
+    /**
+     * Money Flow Index
+     * @param {number} period
+     */
+    mfi(period) {
+        wasm.chart_mfi(this.__wbg_ptr, period);
+    }
+    /**
+     * Create a new chart with specified dimensions.
+     * @param {number} width
+     * @param {number} height
+     */
+    constructor(width, height) {
+        const ret = wasm.chart_new(width, height);
+        this.__wbg_ptr = ret >>> 0;
+        ChartFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Negative Volume Index
+     */
+    nvi() {
+        wasm.chart_nvi(this.__wbg_ptr);
+    }
+    /**
+     * On Balance Volume
+     */
+    obv() {
+        wasm.chart_obv(this.__wbg_ptr);
+    }
+    /**
+     * Pretty Good Oscillator
+     * @param {number} period
+     */
+    pgo(period) {
+        wasm.chart_pgo(this.__wbg_ptr, period);
+    }
+    /**
+     * Positive Volume Index
+     */
+    pvi() {
+        wasm.chart_pvi(this.__wbg_ptr);
+    }
+    /**
+     * Ray from p1 through p2
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    ray(x1, y1, x2, y2) {
+        wasm.chart_ray(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Rate of Change
+     * @param {number} period
+     */
+    roc(period) {
+        wasm.chart_roc(this.__wbg_ptr, period);
+    }
+    /**
+     * Relative Strength Index
+     * @param {number} period
+     */
+    rsi(period) {
+        wasm.chart_rsi(this.__wbg_ptr, period);
+    }
+    /**
+     * Relative Vigor Index
+     * @param {number} period
+     */
+    rvi(period) {
+        wasm.chart_rvi(this.__wbg_ptr, period);
+    }
+    /**
+     * Simple Moving Average
+     * @param {number} period
+     * @param {string} color
+     */
+    sma(period, color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_sma(this.__wbg_ptr, period, ptr0, len0);
+    }
+    /**
+     * True Strength Index
+     * @param {number} r
+     * @param {number} s
+     */
+    tsi(r, s) {
+        wasm.chart_tsi(this.__wbg_ptr, r, s);
+    }
+    /**
+     * Volume Price Trend
+     */
+    vpt() {
+        wasm.chart_vpt(this.__wbg_ptr);
+    }
+    /**
+     * Weighted Moving Average
+     * @param {number} period
+     * @param {string} color
+     */
+    wma(period, color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_wma(this.__wbg_ptr, period, ptr0, len0);
+    }
+    /**
+     * Area chart (filled)
+     */
+    area() {
+        wasm.chart_area(this.__wbg_ptr);
+    }
+    /**
+     * Double Exponential Moving Average
+     * @param {number} period
+     * @param {string} color
+     */
+    dema(period, color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_dema(this.__wbg_ptr, period, ptr0, len0);
+    }
+    /**
+     * Flag
+     * @param {number} x
+     * @param {number} y
+     */
+    flag(x, y) {
+        wasm.chart_flag(this.__wbg_ptr, x, y);
+    }
+    /**
+     * Kaufman Adaptive Moving Average
+     * @param {number} period
+     * @param {string} color
+     */
+    kama(period, color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_kama(this.__wbg_ptr, period, ptr0, len0);
+    }
+    /**
+     * Line chart (close prices)
+     */
+    line() {
+        wasm.chart_line(this.__wbg_ptr);
+    }
+    /**
+     * MACD
+     * @param {number} fast
+     * @param {number} slow
+     * @param {number} signal
+     */
+    macd(fast, slow, signal) {
+        wasm.chart_macd(this.__wbg_ptr, fast, slow, signal);
+    }
+    /**
+     * Note
+     * @param {number} x
+     * @param {number} y
+     * @param {string} content
+     */
+    note(x, y, content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_note(this.__wbg_ptr, x, y, ptr0, len0);
+    }
+    /**
+     * Path (closed polygon)
+     * @param {Float64Array} points
+     */
+    path(points) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_path(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Parabolic SAR
+     */
+    psar() {
+        wasm.chart_psar(this.__wbg_ptr);
+    }
+    /**
+     * Sign
+     * @param {number} x
+     * @param {number} y
+     */
+    sign(x, y) {
+        wasm.chart_sign(this.__wbg_ptr, x, y);
+    }
+    /**
+     * Triple Exponential Moving Average
+     * @param {number} period
+     * @param {string} color
+     */
+    tema(period, color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_tema(this.__wbg_ptr, period, ptr0, len0);
+    }
+    /**
+     * Text annotation
+     * @param {number} x
+     * @param {number} y
+     * @param {string} content
+     */
+    text(x, y, content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_text(this.__wbg_ptr, x, y, ptr0, len0);
+    }
+    /**
+     * TRIX
+     * @param {number} period
+     */
+    trix(period) {
+        wasm.chart_trix(this.__wbg_ptr, period);
+    }
+    /**
+     * VWAP
+     */
+    vwap() {
+        wasm.chart_vwap(this.__wbg_ptr);
+    }
+    /**
+     * Aroon
+     * @param {number} period
+     */
+    aroon(period) {
+        wasm.chart_aroon(this.__wbg_ptr, period);
+    }
+    /**
+     * Brush
+     * @param {Float64Array} points
+     */
+    brush(points) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_brush(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Curve
+     * @param {Float64Array} points
+     */
+    curve(points) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_curve(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Table
+     * @param {number} x
+     * @param {number} y
+     */
+    table(x, y) {
+        wasm.chart_table(this.__wbg_ptr, x, y);
+    }
+    /**
+     * Triangular Moving Average
+     * @param {number} period
+     * @param {string} color
+     */
+    trima(period, color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_trima(this.__wbg_ptr, period, ptr0, len0);
+    }
+    /**
+     * Zero Lag EMA
+     * @param {number} period
+     * @param {string} color
+     */
+    zlema(period, color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_zlema(this.__wbg_ptr, period, ptr0, len0);
+    }
+    /**
+     * Circle
+     * @param {number} cx
+     * @param {number} cy
+     * @param {number} ex
+     * @param {number} ey
+     */
+    circle(cx, cy, ex, ey) {
+        wasm.chart_circle(this.__wbg_ptr, cx, cy, ex, ey);
+    }
+    /**
+     * QStick
+     * @param {number} period
+     */
+    qstick(period) {
+        wasm.chart_qstick(this.__wbg_ptr, period);
+    }
+    /**
+     * Standard Deviation
+     * @param {number} period
+     */
+    stddev(period) {
+        wasm.chart_stddev(this.__wbg_ptr, period);
+    }
+    /**
+     * Volume (subpane)
+     */
+    volume() {
+        wasm.chart_volume(this.__wbg_ptr);
+    }
+    /**
+     * Vortex Indicator
+     * @param {number} period
+     */
+    vortex(period) {
+        wasm.chart_vortex(this.__wbg_ptr, period);
+    }
+    /**
+     * ZigZag
+     * @param {number} deviation
+     */
+    zigzag(deviation) {
+        wasm.chart_zigzag(this.__wbg_ptr, deviation);
+    }
+    /**
+     * Accumulation/Distribution Line
+     */
+    adLine() {
+        wasm.chart_adLine(this.__wbg_ptr);
+    }
+    /**
+     * Callout
+     * @param {number} x
+     * @param {number} y
+     * @param {string} content
+     */
+    callout(x, y, content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_callout(this.__wbg_ptr, x, y, ptr0, len0);
+    }
+    /**
+     * Comment
+     * @param {number} x
+     * @param {number} y
+     * @param {string} content
+     */
+    comment(x, y, content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_comment(this.__wbg_ptr, x, y, ptr0, len0);
+    }
+    /**
+     * Ellipse
+     * @param {number} cx
+     * @param {number} cy
+     * @param {number} ex
+     * @param {number} ey
+     */
+    ellipse(cx, cy, ex, ey) {
+        wasm.chart_ellipse(this.__wbg_ptr, cx, cy, ex, ey);
+    }
+    /**
+     * Fibonacci fan
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    fibFan(x1, y1, x2, y2) {
+        wasm.chart_fibFan(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Keltner Channel
+     * @param {number} period
+     */
+    keltner(period) {
+        wasm.chart_keltner(this.__wbg_ptr, period);
+    }
+    /**
+     * Set device pixel ratio for high-DPI displays
+     * @param {number} dpr
+     */
+    setDpr(dpr) {
+        wasm.chart_setDpr(this.__wbg_ptr, dpr);
+    }
+    /**
+     * Arrow up
+     * @param {number} x
+     * @param {number} y
+     */
+    arrowUp(x, y) {
+        wasm.chart_arrowUp(this.__wbg_ptr, x, y);
+    }
+    /**
+     * Donchian Channel
+     * @param {number} period
+     */
+    donchian(period) {
+        wasm.chart_donchian(this.__wbg_ptr, period);
+    }
+    /**
+     * Fibonacci arcs
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    fibArcs(x1, y1, x2, y2) {
+        wasm.chart_fibArcs(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Forecast
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    forecast(x1, y1, x2, y2) {
+        wasm.chart_forecast(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Gann Box
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    gannBox(x1, y1, x2, y2) {
+        wasm.chart_gannBox(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Gann Fan
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    gannFan(x1, y1, x2, y2) {
+        wasm.chart_gannFan(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Ichimoku Cloud
+     */
+    ichimoku() {
+        wasm.chart_ichimoku(this.__wbg_ptr);
+    }
+    /**
+     * McGinley Dynamic
+     * @param {number} period
+     * @param {string} color
+     */
+    mcginley(period, color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_mcginley(this.__wbg_ptr, period, ptr0, len0);
+    }
+    /**
+     * Momentum
+     * @param {number} period
+     */
+    momentum(period) {
+        wasm.chart_momentum(this.__wbg_ptr, period);
+    }
+    /**
+     * Polyline
+     * @param {Float64Array} points
+     */
+    polyline(points) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_polyline(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Set OHLCV bar data
+     * @param {JsBar[]} bars
+     */
+    setBars(bars) {
+        const ptr0 = passArrayJsValueToWasm0(bars, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_setBars(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Enable/disable grid
+     * @param {boolean} show
+     */
+    setGrid(show) {
+        wasm.chart_setGrid(this.__wbg_ptr, show);
+    }
+    /**
+     * Signpost
+     * @param {number} x
+     * @param {number} y
+     * @param {string} content
+     */
+    signpost(x, y, content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.chart_signpost(this.__wbg_ptr, x, y, ptr0, len0);
+    }
+    /**
+     * Triangle
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     * @param {number} x3
+     * @param {number} y3
+     */
+    triangle(x1, y1, x2, y2, x3, y3) {
+        wasm.chart_triangle(this.__wbg_ptr, x1, y1, x2, y2, x3, y3);
+    }
+    /**
+     * ATR Bands
+     * @param {number} period
+     * @param {number} multiplier
+     */
+    atrBands(period, multiplier) {
+        wasm.chart_atrBands(this.__wbg_ptr, period, multiplier);
+    }
+    /**
+     * Bollinger Bands
+     * @param {number} period
+     * @param {number} multiplier
+     */
+    bollinger(period, multiplier) {
+        wasm.chart_bollinger(this.__wbg_ptr, period, multiplier);
+    }
+    /**
+     * Elder Ray
+     * @param {number} period
+     */
+    elderRay(period) {
+        wasm.chart_elderRay(this.__wbg_ptr, period);
+    }
+    /**
+     * Envelopes
+     * @param {number} period
+     * @param {number} percent
+     */
+    envelopes(period, percent) {
+        wasm.chart_envelopes(this.__wbg_ptr, period, percent);
+    }
+    /**
+     * Fibonacci wedge
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    fibWedge(x1, y1, x2, y2) {
+        wasm.chart_fibWedge(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Info line with measurements
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    infoLine(x1, y1, x2, y2) {
+        wasm.chart_infoLine(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Pitchfork
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     * @param {number} x3
+     * @param {number} y3
+     */
+    pitchfork(x1, y1, x2, y2, x3, y3) {
+        wasm.chart_pitchfork(this.__wbg_ptr, x1, y1, x2, y2, x3, y3);
+    }
+    /**
+     * Rectangle
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    rectangle(x1, y1, x2, y2) {
+        wasm.chart_rectangle(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Sine wave
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     */
+    sineWave(x1, y1, x2, y2) {
+        wasm.chart_sineWave(this.__wbg_ptr, x1, y1, x2, y2);
+    }
+    /**
+     * Stochastic RSI
+     * @param {number} period
+     */
+    stochRsi(period) {
+        wasm.chart_stochRsi(this.__wbg_ptr, period);
     }
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
-
-const JsBarFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_jsbar_free(ptr >>> 0, 1));
-
-const JsChartConfigFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_jschartconfig_free(ptr >>> 0, 1));
-
-const JsThemeFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_jstheme_free(ptr >>> 0, 1));
-
-const JsViewportFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_jsviewport_free(ptr >>> 0, 1));
+if (Symbol.dispose) Chart.prototype[Symbol.dispose] = Chart.prototype.free;
 
 /**
- * A single OHLCV bar
+ * A single OHLCV bar representing one time period of price data.
  */
 export class JsBar {
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof JsBar)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -72,6 +1775,7 @@ export class JsBar {
         return ret;
     }
     /**
+     * Create a new OHLCV bar.
      * @param {bigint} timestamp
      * @param {number} open
      * @param {number} high
@@ -124,7 +1828,7 @@ export class JsBar {
 if (Symbol.dispose) JsBar.prototype[Symbol.dispose] = JsBar.prototype.free;
 
 /**
- * Chart configuration
+ * Low-level chart configuration.
  */
 export class JsChartConfig {
     __destroy_into_raw() {
@@ -147,7 +1851,7 @@ export class JsChartConfig {
 if (Symbol.dispose) JsChartConfig.prototype[Symbol.dispose] = JsChartConfig.prototype.free;
 
 /**
- * Chart theme (colors)
+ * Chart theme with predefined color schemes.
  */
 export class JsTheme {
     static __wrap(ptr) {
@@ -260,7 +1964,7 @@ export class JsTheme {
 if (Symbol.dispose) JsTheme.prototype[Symbol.dispose] = JsTheme.prototype.free;
 
 /**
- * Chart viewport managing visible area
+ * Chart viewport managing visible area and scrolling.
  */
 export class JsViewport {
     __destroy_into_raw() {
@@ -327,7 +2031,7 @@ export class JsViewport {
 if (Symbol.dispose) JsViewport.prototype[Symbol.dispose] = JsViewport.prototype.free;
 
 /**
- * Get library version
+ * Get library version.
  * @returns {string}
  */
 export function version() {
@@ -381,6 +2085,10 @@ function __wbg_get_imports() {
     imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
         throw new Error(getStringFromWasm0(arg0, arg1));
     };
+    imports.wbg.__wbg_jsbar_unwrap = function(arg0) {
+        const ret = JsBar.__unwrap(arg0);
+        return ret;
+    };
     imports.wbg.__wbindgen_init_externref_table = function() {
         const table = wasm.__wbindgen_externrefs;
         const offset = table.grow(4);
@@ -397,6 +2105,8 @@ function __wbg_get_imports() {
 function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     __wbg_init.__wbindgen_wasm_module = module;
+    cachedDataViewMemory0 = null;
+    cachedFloat64ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;