zengeld-canvas 0.1.6 → 0.1.9

package/zengeld_canvas_wasm.js

@@ -1,5 +1,38 @@
 let wasm;
 
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
+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);
@@ -13,6 +46,64 @@ function getUint8ArrayMemory0() {
     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;
@@ -27,6 +118,25 @@ function decodeText(ptr, 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));
@@ -35,119 +145,2221 @@ const JsChartConfigFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_jschartconfig_free(ptr >>> 0, 1));
 
+const JsRuntimeThemeFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsruntimetheme_free(ptr >>> 0, 1));
+
 const JsThemeFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_jstheme_free(ptr >>> 0, 1));
 
+const JsUIThemeFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsuitheme_free(ptr >>> 0, 1));
+
 const JsViewportFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_jsviewport_free(ptr >>> 0, 1));
 
 /**
- * A single OHLCV bar
+ * High-level chart builder for creating financial charts.
  */
-export class JsBar {
+export class Chart {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        JsBarFinalization.unregister(this);
+        ChartFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_jsbar_free(ptr, 0);
+        wasm.__wbg_chart_free(ptr, 0);
     }
     /**
-     * @returns {boolean}
+     * Arrow down
+     * @param {number} x
+     * @param {number} y
      */
-    isBullish() {
-        const ret = wasm.jsbar_isBullish(this.__wbg_ptr);
-        return ret !== 0;
+    arrowDown(x, y) {
+        wasm.chart_arrowDown(this.__wbg_ptr, x, y);
     }
     /**
-     * @returns {number}
+     * Arrow line
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
      */
-    get low() {
-        const ret = wasm.jsbar_low(this.__wbg_ptr);
-        return ret;
+    arrowLine(x1, y1, x2, y2) {
+        wasm.chart_arrowLine(this.__wbg_ptr, x1, y1, x2, y2);
     }
     /**
-     * @param {bigint} timestamp
-     * @param {number} open
-     * @param {number} high
-     * @param {number} low
-     * @param {number} close
-     * @param {number} volume
+     * Buy signal
+     * @param {number} bar_index
+     * @param {number} price
+     * @param {string | null} [label]
      */
-    constructor(timestamp, open, high, low, close, volume) {
-        const ret = wasm.jsbar_new(timestamp, open, high, low, close, volume);
-        this.__wbg_ptr = ret >>> 0;
-        JsBarFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    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);
     }
     /**
-     * @returns {number}
+     * Choppiness Index
+     * @param {number} period
      */
-    get high() {
-        const ret = wasm.jsbar_high(this.__wbg_ptr);
-        return ret;
+    choppiness(period) {
+        wasm.chart_choppiness(this.__wbg_ptr, period);
     }
     /**
-     * @returns {number}
+     * Cross line at position
+     * @param {number} x
+     * @param {number} y
      */
-    get open() {
-        const ret = wasm.jsbar_open(this.__wbg_ptr);
-        return ret;
+    crossLine(x, y) {
+        wasm.chart_crossLine(this.__wbg_ptr, x, y);
     }
     /**
-     * @returns {number}
+     * Apply dark theme
      */
-    get close() {
-        const ret = wasm.jsbar_close(this.__wbg_ptr);
-        return ret;
+    darkTheme() {
+        wasm.chart_darkTheme(this.__wbg_ptr);
     }
     /**
-     * @returns {number}
+     * Date range
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
      */
-    get volume() {
-        const ret = wasm.jsbar_volume(this.__wbg_ptr);
-        return ret;
+    dateRange(x1, y1, x2, y2) {
+        wasm.chart_dateRange(this.__wbg_ptr, x1, y1, x2, y2);
     }
     /**
-     * @returns {bigint}
+     * Fibonacci spiral
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
      */
-    get timestamp() {
-        const ret = wasm.jsbar_timestamp(this.__wbg_ptr);
-        return ret;
+    fibSpiral(x1, y1, x2, y2) {
+        wasm.chart_fibSpiral(this.__wbg_ptr, x1, y1, x2, y2);
     }
-}
-if (Symbol.dispose) JsBar.prototype[Symbol.dispose] = JsBar.prototype.free;
-
-/**
- * Chart configuration
- */
-export class JsChartConfig {
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        JsChartConfigFinalization.unregister(this);
-        return ptr;
+    /**
+     * Mass Index
+     */
+    massIndex() {
+        wasm.chart_massIndex(this.__wbg_ptr);
     }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_jschartconfig_free(ptr, 0);
+    /**
+     * 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);
     }
-    constructor() {
-        const ret = wasm.jschartconfig_new();
-        this.__wbg_ptr = ret >>> 0;
-        JsChartConfigFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    /**
+     * 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);
+    }
+}
+if (Symbol.dispose) Chart.prototype[Symbol.dispose] = Chart.prototype.free;
+
+/**
+ * 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;
+        JsBarFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jsbar_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isBullish() {
+        const ret = wasm.jsbar_isBullish(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get low() {
+        const ret = wasm.jsbar_low(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Create a new OHLCV bar.
+     * @param {bigint} timestamp
+     * @param {number} open
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @param {number} volume
+     */
+    constructor(timestamp, open, high, low, close, volume) {
+        const ret = wasm.jsbar_new(timestamp, open, high, low, close, volume);
+        this.__wbg_ptr = ret >>> 0;
+        JsBarFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {number}
+     */
+    get high() {
+        const ret = wasm.jsbar_high(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get open() {
+        const ret = wasm.jsbar_open(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get close() {
+        const ret = wasm.jsbar_close(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get volume() {
+        const ret = wasm.jsbar_volume(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {bigint}
+     */
+    get timestamp() {
+        const ret = wasm.jsbar_timestamp(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) JsBar.prototype[Symbol.dispose] = JsBar.prototype.free;
+
+/**
+ * Low-level chart configuration.
+ */
+export class JsChartConfig {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsChartConfigFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jschartconfig_free(ptr, 0);
+    }
+    constructor() {
+        const ret = wasm.jschartconfig_new();
+        this.__wbg_ptr = ret >>> 0;
+        JsChartConfigFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) JsChartConfig.prototype[Symbol.dispose] = JsChartConfig.prototype.free;
+
+/**
+ * Runtime-modifiable theme with JSON serialization support.
+ * All colors are owned strings that can be modified.
+ */
+export class JsRuntimeTheme {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsRuntimeTheme.prototype);
+        obj.__wbg_ptr = ptr;
+        JsRuntimeThemeFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsRuntimeThemeFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jsruntimetheme_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get background() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsruntimetheme_background(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get lineColor() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsruntimetheme_lineColor(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get scaleText() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsruntimetheme_scaleText(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);
+        }
+    }
+    /**
+     * @param {string} color
+     */
+    set accent(color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.jsruntimetheme_set_accent(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string} color
+     */
+    set danger(color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.jsruntimetheme_set_danger(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {string}
+     */
+    get toolbarBg() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsruntimetheme_toolbarBg(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);
+        }
+    }
+    /**
+     * Create from preset name: "dark", "light", "high_contrast", "cyberpunk"
+     * @param {string} name
+     * @returns {JsRuntimeTheme}
+     */
+    static fromPreset(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jsruntimetheme_fromPreset(ptr0, len0);
+        return JsRuntimeTheme.__wrap(ret);
+    }
+    /**
+     * @param {string} color
+     */
+    set maFast(color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.jsruntimetheme_set_maFast(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string} color
+     */
+    set maSlow(color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.jsruntimetheme_set_maSlow(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string} color
+     */
+    set success(color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.jsruntimetheme_set_success(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string} color
+     */
+    set scaleBg(color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.jsruntimetheme_set_scaleBg(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {string}
+     */
+    get textPrimary() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsruntimetheme_textPrimary(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);
+        }
+    }
+    /**
+     * Create high contrast theme
+     * @returns {JsRuntimeTheme}
+     */
+    static highContrast() {
+        const ret = wasm.jsruntimetheme_highContrast();
+        return JsRuntimeTheme.__wrap(ret);
+    }
+    /**
+     * @param {string} color
+     */
+    set gridLine(color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.jsruntimetheme_set_gridLine(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {string}
+     */
+    get candleUpBody() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsruntimetheme_candleUpBody(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get crosshairLine() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsruntimetheme_crosshairLine(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);
+        }
+    }
+    /**
+     * @param {string} color
+     */
+    set background(color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.jsruntimetheme_set_background(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string} color
+     */
+    set lineColor(color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.jsruntimetheme_set_lineColor(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string} color
+     */
+    set scaleText(color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.jsruntimetheme_set_scaleText(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string} color
+     */
+    set toolbarBg(color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.jsruntimetheme_set_toolbarBg(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Serialize to pretty JSON string
+     * @returns {string}
+     */
+    toJsonPretty() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsruntimetheme_toJsonPretty(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get candleDownBody() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsruntimetheme_candleDownBody(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);
+        }
+    }
+    /**
+     * @param {string} color
+     */
+    set textPrimary(color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.jsruntimetheme_set_textPrimary(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string} color
+     */
+    set candleUpBody(color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.jsruntimetheme_set_candleUpBody(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string} color
+     */
+    set crosshairLine(color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.jsruntimetheme_set_crosshairLine(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string} color
+     */
+    set candleDownBody(color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.jsruntimetheme_set_candleDownBody(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Create dark theme
+     * @returns {JsRuntimeTheme}
+     */
+    static dark() {
+        const ret = wasm.jsruntimetheme_dark();
+        return JsRuntimeTheme.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsruntimetheme_name(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);
+        }
+    }
+    /**
+     * Create light theme
+     * @returns {JsRuntimeTheme}
+     */
+    static light() {
+        const ret = wasm.jsruntimetheme_light();
+        return JsRuntimeTheme.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    get accent() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsruntimetheme_accent(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get danger() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsruntimetheme_danger(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get maFast() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsruntimetheme_maFast(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get maSlow() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsruntimetheme_maSlow(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);
+        }
+    }
+    /**
+     * Get available preset names
+     * @returns {string[]}
+     */
+    static presets() {
+        const ret = wasm.jsruntimetheme_presets();
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {string}
+     */
+    get success() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsruntimetheme_success(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);
+        }
+    }
+    /**
+     * Serialize to JSON string
+     * @returns {string}
+     */
+    toJson() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsruntimetheme_toJson(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get scaleBg() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsruntimetheme_scaleBg(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);
+        }
+    }
+    /**
+     * @param {string} name
+     */
+    set name(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.jsruntimetheme_set_name(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Create cyberpunk theme
+     * @returns {JsRuntimeTheme}
+     */
+    static cyberpunk() {
+        const ret = wasm.jsruntimetheme_cyberpunk();
+        return JsRuntimeTheme.__wrap(ret);
+    }
+    /**
+     * Deserialize from JSON string
+     * @param {string} json
+     * @returns {JsRuntimeTheme | undefined}
+     */
+    static fromJson(json) {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jsruntimetheme_fromJson(ptr0, len0);
+        return ret === 0 ? undefined : JsRuntimeTheme.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    get gridLine() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsruntimetheme_gridLine(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);
+        }
     }
 }
-if (Symbol.dispose) JsChartConfig.prototype[Symbol.dispose] = JsChartConfig.prototype.free;
+if (Symbol.dispose) JsRuntimeTheme.prototype[Symbol.dispose] = JsRuntimeTheme.prototype.free;
 
 /**
- * Chart theme (colors)
+ * Legacy simple theme with basic color properties.
  */
 export class JsTheme {
     static __wrap(ptr) {
@@ -260,7 +2472,304 @@ export class JsTheme {
 if (Symbol.dispose) JsTheme.prototype[Symbol.dispose] = JsTheme.prototype.free;
 
 /**
- * Chart viewport managing visible area
+ * Complete UI theme with all styling options (static, compile-time).
+ * Use JsRuntimeTheme for modifiable themes.
+ */
+export class JsUITheme {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JsUITheme.prototype);
+        obj.__wbg_ptr = ptr;
+        JsUIThemeFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsUIThemeFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jsuitheme_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get background() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsuitheme_background(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get lineColor() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsuitheme_lineColor(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get scaleText() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsuitheme_scaleText(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get toolbarBg() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsuitheme_toolbarBg(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get textPrimary() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsuitheme_textPrimary(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);
+        }
+    }
+    /**
+     * Create high contrast theme (accessibility)
+     * @returns {JsUITheme}
+     */
+    static highContrast() {
+        const ret = wasm.jsuitheme_highContrast();
+        return JsUITheme.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    get candleUpBody() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsuitheme_candleUpBody(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get crosshairLine() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsuitheme_crosshairLine(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get candleDownBody() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsuitheme_candleDownBody(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);
+        }
+    }
+    /**
+     * Create dark theme (TradingView-like)
+     * @returns {JsUITheme}
+     */
+    static dark() {
+        const ret = wasm.jsuitheme_dark();
+        return JsUITheme.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsuitheme_name(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);
+        }
+    }
+    /**
+     * Create light theme
+     * @returns {JsUITheme}
+     */
+    static light() {
+        const ret = wasm.jsuitheme_light();
+        return JsUITheme.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    get accent() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsuitheme_accent(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get danger() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsuitheme_danger(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get maFast() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsuitheme_maFast(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get maSlow() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsuitheme_maSlow(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get success() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsuitheme_success(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get scaleBg() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsuitheme_scaleBg(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);
+        }
+    }
+    /**
+     * Create cyberpunk/neon theme
+     * @returns {JsUITheme}
+     */
+    static cyberpunk() {
+        const ret = wasm.jsuitheme_cyberpunk();
+        return JsUITheme.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    get gridLine() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.jsuitheme_gridLine(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);
+        }
+    }
+}
+if (Symbol.dispose) JsUITheme.prototype[Symbol.dispose] = JsUITheme.prototype.free;
+
+/**
+ * Chart viewport managing visible area and scrolling.
  */
 export class JsViewport {
     __destroy_into_raw() {
@@ -327,7 +2836,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 +2890,15 @@ 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_cast_2241b6af4c4b2941 = function(arg0, arg1) {
+        // Cast intrinsic for `Ref(String) -> Externref`.
+        const ret = getStringFromWasm0(arg0, arg1);
+        return ret;
+    };
     imports.wbg.__wbindgen_init_externref_table = function() {
         const table = wasm.__wbindgen_externrefs;
         const offset = table.grow(4);
@@ -397,6 +2915,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;