@wick-charts/vue 0.1.0

package/dist/index.js

@@ -0,0 +1,3452 @@
+import { inject as xe, defineComponent as Z, ref as tt, onMounted as q, onUnmounted as et, watch as st, createCommentVNode as K, shallowRef as ne, provide as le, computed as P, openBlock as R, createElementBlock as T, normalizeStyle as z, renderSlot as Oe, unref as W, Fragment as O, createElementVNode as _, toDisplayString as I, renderList as ct, createVNode as $e } from "vue";
+var Xe = Object.defineProperty, Ce = (r) => {
+  throw TypeError(r);
+}, He = (r, t, e) => t in r ? Xe(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e, x = (r, t, e) => He(r, typeof t != "symbol" ? t + "" : t, e), Jt = (r, t, e) => t.has(r) || Ce("Cannot " + e), h = (r, t, e) => (Jt(r, t, "read from private field"), e ? e.call(r) : t.get(r)), A = (r, t, e) => t.has(r) ? Ce("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(r) : t.set(r, e), M = (r, t, e, o) => (Jt(r, t, "write to private field"), t.set(r, e), e), It = (r, t, e) => (Jt(r, t, "access private method"), e), he = (r, t, e, o) => ({
+  set _(i) {
+    M(r, t, i);
+  },
+  get _() {
+    return h(r, t, o);
+  }
+});
+class Pt {
+  constructor() {
+    x(this, "listeners", /* @__PURE__ */ new Map());
+  }
+  on(t, e) {
+    let o = this.listeners.get(t);
+    o || (o = /* @__PURE__ */ new Set(), this.listeners.set(t, o)), o.add(e);
+  }
+  off(t, e) {
+    var o;
+    (o = this.listeners.get(t)) == null || o.delete(e);
+  }
+  emit(t, ...e) {
+    var o;
+    (o = this.listeners.get(t)) == null || o.forEach((i) => i(...e));
+  }
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+}
+function ce(r, t, e) {
+  const o = document.createElement("canvas");
+  return o.style.position = "absolute", o.style.inset = "0", o.style.width = "100%", o.style.height = "100%", o.style.display = "block", o.style.zIndex = String(t), r.appendChild(o), o;
+}
+class Ge extends Pt {
+  constructor(t) {
+    super(), x(this, "mainCanvas"), x(this, "mainCtx"), x(this, "overlayCanvas"), x(this, "overlayCtx"), x(this, "resizeObserver"), x(this, "_size"), x(this, "supportsDevicePixelContentBox", !1), this.mainCanvas = ce(t, 0), this.overlayCanvas = ce(t, 1), this.mainCtx = this.mainCanvas.getContext("2d", { alpha: !0 }), this.overlayCtx = this.overlayCanvas.getContext("2d", { alpha: !0 });
+    const e = window.devicePixelRatio || 1;
+    this._size = {
+      media: { width: 0, height: 0 },
+      bitmap: { width: 0, height: 0 },
+      horizontalPixelRatio: e,
+      verticalPixelRatio: e
+    }, this.resizeObserver = new ResizeObserver((i) => {
+      this.handleResize(i[0]);
+    });
+    try {
+      this.resizeObserver.observe(t, { box: "device-pixel-content-box" }), this.supportsDevicePixelContentBox = !0;
+    } catch {
+      this.resizeObserver.observe(t, { box: "content-box" });
+    }
+    const o = t.getBoundingClientRect();
+    if (o.width > 0 && o.height > 0) {
+      const i = window.devicePixelRatio || 1, a = i, s = Math.round(o.width * i), n = Math.round(o.height * a);
+      this.mainCanvas.width = s, this.mainCanvas.height = n, this.overlayCanvas.width = s, this.overlayCanvas.height = n, this._size = {
+        media: { width: o.width, height: o.height },
+        bitmap: { width: s, height: n },
+        horizontalPixelRatio: s / o.width,
+        verticalPixelRatio: n / o.height
+      };
+    }
+  }
+  handleResize(t) {
+    var e, o;
+    let i, a, s, n;
+    if (this.supportsDevicePixelContentBox && (e = t.devicePixelContentBoxSize) != null && e[0]) {
+      const d = t.devicePixelContentBoxSize[0];
+      i = d.inlineSize, a = d.blockSize;
+      const u = t.contentBoxSize[0];
+      s = u.inlineSize, n = u.blockSize;
+    } else {
+      const d = (o = t.contentBoxSize) == null ? void 0 : o[0];
+      if (d)
+        s = d.inlineSize, n = d.blockSize;
+      else {
+        const b = t.contentRect;
+        s = b.width, n = b.height;
+      }
+      const u = window.devicePixelRatio || 1;
+      i = Math.round(s * u), a = Math.round(n * u);
+    }
+    if (i === 0 || a === 0) return;
+    this.mainCanvas.width = i, this.mainCanvas.height = a, this.overlayCanvas.width = i, this.overlayCanvas.height = a;
+    const l = i / s, c = a / n;
+    this._size = {
+      media: { width: s, height: n },
+      bitmap: { width: i, height: a },
+      horizontalPixelRatio: l,
+      verticalPixelRatio: c
+    }, this.emit("resize", this._size);
+  }
+  get size() {
+    return this._size;
+  }
+  /** Draw on the main (bottom) layer — series, grid, background */
+  useMainLayer(t) {
+    this.mainCtx.save(), t({
+      context: this.mainCtx,
+      bitmapSize: this._size.bitmap,
+      mediaSize: this._size.media,
+      horizontalPixelRatio: this._size.horizontalPixelRatio,
+      verticalPixelRatio: this._size.verticalPixelRatio
+    }), this.mainCtx.restore();
+  }
+  /** Draw on the overlay (top) layer — crosshair */
+  useOverlayLayer(t) {
+    const { width: e, height: o } = this._size.bitmap;
+    this.overlayCtx.clearRect(0, 0, e, o), this.overlayCtx.save(), t({
+      context: this.overlayCtx,
+      bitmapSize: this._size.bitmap,
+      mediaSize: this._size.media,
+      horizontalPixelRatio: this._size.horizontalPixelRatio,
+      verticalPixelRatio: this._size.verticalPixelRatio
+    }), this.overlayCtx.restore();
+  }
+  // Keep backward compat for now
+  get canvas() {
+    return this.overlayCanvas;
+  }
+  destroy() {
+    this.resizeObserver.disconnect(), this.mainCanvas.remove(), this.overlayCanvas.remove(), this.removeAllListeners();
+  }
+}
+function Ne(r, t, e, o) {
+  const { context: i, bitmapSize: a, horizontalPixelRatio: s } = r;
+  i.strokeStyle = o.crosshair.color, i.lineWidth = 1, i.setLineDash([4 * s, 4 * s]);
+  const n = Math.round(t) + 0.5, l = Math.round(e) + 0.5;
+  i.beginPath(), i.moveTo(n, 0), i.lineTo(n, a.height), i.moveTo(0, l), i.lineTo(a.width, l), i.stroke(), i.setLineDash([]);
+}
+function Je(r, t, e, o, i) {
+  const { context: a, bitmapSize: s, horizontalPixelRatio: n, verticalPixelRatio: l } = r;
+  a.strokeStyle = o.grid.color, a.lineWidth = 1, o.grid.style === "dashed" ? a.setLineDash([4 * n, 4 * n]) : o.grid.style === "dotted" && a.setLineDash([1 * n, 3 * n]);
+  const c = e.niceTickValues();
+  a.beginPath();
+  for (const u of c) {
+    const b = Math.round(e.valueToBitmapY(u)) + 0.5;
+    a.moveTo(0, b), a.lineTo(s.width, b);
+  }
+  a.stroke();
+  const { ticks: d } = t.niceTickValues(i);
+  a.beginPath();
+  for (const u of d) {
+    const b = Math.round(t.timeToBitmapX(u)) + 0.5;
+    a.moveTo(b, 0), a.lineTo(b, s.height);
+  }
+  a.stroke(), a.setLineDash([]);
+}
+function de(r, t, e) {
+  return r + (t - r) * e;
+}
+function Xt(r, t, e) {
+  let o = 0, i = r.length - 1;
+  for (; o <= i; ) {
+    const a = o + i >>> 1, s = e(r[a]);
+    if (s < t) o = a + 1;
+    else if (s > t) i = a - 1;
+    else return a;
+  }
+  return o;
+}
+class jt extends Pt {
+  constructor() {
+    super(...arguments), x(this, "data", []), x(this, "_visible", !0), x(this, "cachedRange", null), x(this, "cachedResult", []);
+  }
+  setVisible(t) {
+    this._visible = t;
+  }
+  isVisible() {
+    return this._visible;
+  }
+  setData(t) {
+    let e = !0;
+    for (let o = 1; o < t.length; o++)
+      if (t[o].time < t[o - 1].time) {
+        e = !1;
+        break;
+      }
+    this.data = e ? t.slice() : [...t].sort((o, i) => o.time - i.time), this.cachedRange = null, this.emit("update");
+  }
+  append(t) {
+    if (this.data.length > 0 && t.time <= this.data[this.data.length - 1].time) {
+      this.updateLast(t);
+      return;
+    }
+    this.data.push(t), this.cachedRange = null, this.emit("update");
+  }
+  updateLast(t) {
+    this.data.length !== 0 && (this.data[this.data.length - 1] = t, this.cachedRange = null, this.emit("update"));
+  }
+  getAll() {
+    return this.data;
+  }
+  getVisibleData(t, e) {
+    if (this.data.length === 0) return [];
+    if (this.cachedRange && this.cachedRange.from === t && this.cachedRange.to === e) return this.cachedResult;
+    const o = Math.max(0, Xt(this.data, t, (a) => a.time) - 1), i = Math.min(this.data.length, Xt(this.data, e, (a) => a.time) + 1);
+    return this.cachedResult = this.data.slice(o, i), this.cachedRange = { from: t, to: e }, this.cachedResult;
+  }
+  first() {
+    return this.data[0];
+  }
+  last() {
+    return this.data[this.data.length - 1];
+  }
+  get length() {
+    return this.data.length;
+  }
+  isEmpty() {
+    return this.data.length === 0;
+  }
+  findNearest(t, e) {
+    if (this.data.length === 0) return null;
+    const o = Xt(this.data, t, (s) => s.time);
+    let i = null, a = e;
+    for (let s = Math.max(0, o - 1); s <= Math.min(this.data.length - 1, o + 1); s++) {
+      const n = Math.abs(this.data[s].time - t);
+      n <= a && (a = n, i = this.data[s]);
+    }
+    return i;
+  }
+}
+class je {
+  constructor(t, e, o) {
+    x(this, "dragging", !1), x(this, "lastX", 0), this.viewport = t, this.timeScale = e, this.canvas = o;
+  }
+  handleMouseDown(t) {
+    t.button === 0 && (this.dragging = !0, this.lastX = t.clientX, this.canvas.style.cursor = "grabbing");
+  }
+  handleMouseMove(t) {
+    if (!this.dragging) return;
+    const e = t.clientX - this.lastX;
+    this.lastX = t.clientX;
+    const o = this.timeScale.pixelDeltaToTimeDelta(-e);
+    this.viewport.pan(o);
+  }
+  handleMouseUp() {
+    this.dragging && (this.dragging = !1, this.canvas.style.cursor = "crosshair");
+  }
+  isDragging() {
+    return this.dragging;
+  }
+}
+class Ke {
+  constructor(t, e) {
+    this.viewport = t, this.timeScale = e;
+  }
+  handleWheel(t) {
+    t.preventDefault();
+    const e = qe(t.deltaY, t.deltaMode), o = Math.exp(e * 5e-3), i = this.timeScale.getMediaWidth(), a = Math.min(t.offsetX, i), s = this.timeScale.xToTime(a);
+    this.viewport.zoomAt(s, o);
+  }
+}
+function qe(r, t) {
+  return t === WheelEvent.DOM_DELTA_LINE ? r * 8 : t === WheelEvent.DOM_DELTA_PAGE ? r * 24 : r;
+}
+class Qe extends Pt {
+  constructor(t, e, o, i) {
+    super(), x(this, "zoom"), x(this, "pan"), x(this, "canvas"), x(this, "timeScale"), x(this, "yScale"), x(this, "viewport"), x(this, "onWheel", (a) => {
+      this.zoom.handleWheel(a);
+    }), x(this, "onMouseDown", (a) => {
+      this.pan.handleMouseDown(a);
+    }), x(this, "onMouseMove", (a) => {
+      this.pan.isDragging() && this.pan.handleMouseMove(a), this.emitCrosshair(a.offsetX, a.offsetY);
+    }), x(this, "onMouseUp", () => {
+      this.pan.handleMouseUp();
+    }), x(this, "onMouseLeave", () => {
+      this.pan.handleMouseUp(), this.emit("crosshairMove", null);
+    }), x(this, "onDblClick", () => {
+    }), x(this, "lastTouchDist", 0), x(this, "lastTouchCenter", 0), x(this, "touchCount", 0), x(this, "onTouchStart", (a) => {
+      a.preventDefault(), this.touchCount = a.touches.length, a.touches.length === 1 ? this.pan.handleMouseDown({
+        button: 0,
+        clientX: a.touches[0].clientX
+      }) : a.touches.length === 2 && (this.lastTouchDist = Math.abs(a.touches[0].clientX - a.touches[1].clientX), this.lastTouchCenter = (a.touches[0].clientX + a.touches[1].clientX) / 2);
+    }), x(this, "onTouchMove", (a) => {
+      if (a.preventDefault(), a.touches.length === 1 && this.touchCount === 1) {
+        this.pan.handleMouseMove({
+          clientX: a.touches[0].clientX
+        });
+        const s = this.canvas.getBoundingClientRect();
+        this.emitCrosshair(a.touches[0].clientX - s.left, a.touches[0].clientY - s.top);
+      } else if (a.touches.length === 2) {
+        const s = Math.abs(a.touches[0].clientX - a.touches[1].clientX), n = (a.touches[0].clientX + a.touches[1].clientX) / 2, l = this.canvas.getBoundingClientRect();
+        if (this.lastTouchDist > 0) {
+          const c = this.lastTouchDist / s, d = this.timeScale.xToTime(n - l.left);
+          this.viewport.zoomAt(d, c);
+        }
+        this.lastTouchDist = s, this.lastTouchCenter = n;
+      }
+    }), x(this, "onTouchEnd", (a) => {
+      a.touches.length === 0 && (this.pan.handleMouseUp(), this.touchCount = 0, this.lastTouchDist = 0);
+    }), this.canvas = t, this.viewport = e, this.timeScale = o, this.yScale = i, this.zoom = new Ke(e, o), this.pan = new je(e, o, t), t.style.cursor = "crosshair", t.style.touchAction = "none", t.addEventListener("wheel", this.onWheel, { passive: !1 }), t.addEventListener("mousedown", this.onMouseDown), t.addEventListener("mousemove", this.onMouseMove), t.addEventListener("mouseup", this.onMouseUp), t.addEventListener("mouseleave", this.onMouseLeave), t.addEventListener("dblclick", this.onDblClick), t.addEventListener("touchstart", this.onTouchStart, { passive: !1 }), t.addEventListener("touchmove", this.onTouchMove, { passive: !1 }), t.addEventListener("touchend", this.onTouchEnd);
+  }
+  emitCrosshair(t, e) {
+    const o = this.timeScale.xToTime(t), i = this.yScale.yToValue(e);
+    this.emit("crosshairMove", {
+      mediaX: t,
+      mediaY: e,
+      time: o,
+      y: i
+    });
+  }
+  destroy() {
+    this.canvas.removeEventListener("wheel", this.onWheel), this.canvas.removeEventListener("mousedown", this.onMouseDown), this.canvas.removeEventListener("mousemove", this.onMouseMove), this.canvas.removeEventListener("mouseup", this.onMouseUp), this.canvas.removeEventListener("mouseleave", this.onMouseLeave), this.canvas.removeEventListener("dblclick", this.onDblClick), this.canvas.removeEventListener("touchstart", this.onTouchStart), this.canvas.removeEventListener("touchmove", this.onTouchMove), this.canvas.removeEventListener("touchend", this.onTouchEnd), this.removeAllListeners();
+  }
+}
+class ue {
+  constructor(t) {
+    x(this, "dirty", !1), x(this, "rafId", null), x(this, "callback"), x(this, "render", (e) => {
+      this.dirty = !1, this.rafId = null, this.callback(e);
+    }), this.callback = t;
+  }
+  markDirty() {
+    this.dirty || (this.dirty = !0, this.rafId = requestAnimationFrame(this.render));
+  }
+  destroy() {
+    this.rafId !== null && (cancelAnimationFrame(this.rafId), this.rafId = null), this.dirty = !1;
+  }
+}
+const xt = 6e4, vt = 36e5, ft = 864e5;
+function fe(r) {
+  return r instanceof Date ? r.getTime() : r;
+}
+function Ze(r) {
+  return r.length === 0 || typeof r[0].time == "number" ? r : r.map((t) => ({ ...t, time: t.time.getTime() }));
+}
+function to(r) {
+  return r.length === 0 || typeof r[0].time == "number" ? r : r.map((t) => ({ ...t, time: t.time.getTime() }));
+}
+function eo(r) {
+  if (r.length < 2) return ft;
+  const t = [];
+  for (let e = 1; e < Math.min(r.length, 20); e++)
+    t.push(r[e] - r[e - 1]);
+  return t.sort((e, o) => e - o), t[Math.floor(t.length / 2)];
+}
+function Yt(r, t) {
+  const e = new Date(r);
+  return t >= ft ? e.toLocaleDateString("en-US", { month: "short", day: "numeric" }) : t >= vt ? e.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", hour12: !1 }) : e.toLocaleTimeString("en-US", {
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: !1
+  });
+}
+function oo(r) {
+  return new Date(r).toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" });
+}
+function io(r) {
+  const t = [1e3, 5e3, 1e4, 15e3, 3e4], e = [xt, 5 * xt, 10 * xt, 15 * xt, 30 * xt], o = [vt, 2 * vt, 4 * vt, 6 * vt, 12 * vt], i = [ft, 7 * ft, 30 * ft, 90 * ft, 365 * ft];
+  return r < xt ? [...t, ...e, ...o, ...i] : r < vt ? [...e, ...o, ...i] : r < ft ? [...o, ...i] : i;
+}
+class ao {
+  constructor() {
+    x(this, "from", 0), x(this, "to", 0), x(this, "width", 1), x(this, "pixelRatio", 1);
+  }
+  update(t, e, o) {
+    this.from = t.from, this.to = t.to, this.width = e, this.pixelRatio = o;
+  }
+  timeToX(t) {
+    return this.to <= this.from ? 0 : (t - this.from) / (this.to - this.from) * this.width;
+  }
+  timeToBitmapX(t) {
+    return Math.round(this.timeToX(t) * this.pixelRatio);
+  }
+  xToTime(t) {
+    return this.to <= this.from ? this.from : this.from + t / this.width * (this.to - this.from);
+  }
+  pixelDeltaToTimeDelta(t) {
+    return this.to <= this.from ? 0 : t / this.width * (this.to - this.from);
+  }
+  barWidthMedia(t) {
+    return this.to <= this.from ? 0 : t / (this.to - this.from) * this.width;
+  }
+  barWidthBitmap(t) {
+    return Math.max(1, Math.round(this.barWidthMedia(t) * this.pixelRatio));
+  }
+  niceTickValues(t) {
+    if (this.to <= this.from) return { ticks: [], tickInterval: 0 };
+    const e = io(t), o = (this.to - this.from) / this.width * 80;
+    let i = e[e.length - 1];
+    for (const n of e)
+      if (n >= o) {
+        i = n;
+        break;
+      }
+    const a = [], s = Math.ceil(this.from / i) * i;
+    for (let n = s; n <= this.to; n += i)
+      a.push(n);
+    return { ticks: a, tickInterval: i };
+  }
+  getRange() {
+    return { from: this.from, to: this.to };
+  }
+  getMediaWidth() {
+    return this.width;
+  }
+}
+const Ht = [
+  1e-4,
+  2e-4,
+  5e-4,
+  1e-3,
+  2e-3,
+  5e-3,
+  0.01,
+  0.02,
+  0.05,
+  0.1,
+  0.2,
+  0.5,
+  1,
+  2,
+  5,
+  10,
+  20,
+  50,
+  100,
+  200,
+  500,
+  1e3,
+  2e3,
+  5e3,
+  1e4,
+  2e4,
+  5e4
+];
+class so {
+  constructor() {
+    x(this, "min", 0), x(this, "max", 0), x(this, "height", 1), x(this, "pixelRatio", 1);
+  }
+  /** Recalculate the scale with a new Y range, chart height, and device pixel ratio. */
+  update(t, e, o) {
+    this.min = t.min, this.max = t.max, this.height = e, this.pixelRatio = o;
+  }
+  /** Convert a value to a Y position in CSS (media) pixels. */
+  valueToY(t) {
+    return (1 - (t - this.min) / (this.max - this.min)) * this.height;
+  }
+  /** Convert a value to a Y position in physical (bitmap) pixels. */
+  valueToBitmapY(t) {
+    return Math.round(this.valueToY(t) * this.pixelRatio);
+  }
+  /** Convert a Y position in CSS pixels back to a value. */
+  yToValue(t) {
+    return this.max - t / this.height * (this.max - this.min);
+  }
+  /** Generate evenly spaced "nice" tick values that fit the current range and chart height. */
+  niceTickValues() {
+    if (this.max <= this.min) return [];
+    const t = (this.max - this.min) / this.height * 50;
+    let e = Ht[Ht.length - 1];
+    for (const a of Ht)
+      if (a >= t) {
+        e = a;
+        break;
+      }
+    const o = [], i = Math.ceil(this.min / e) * e;
+    for (let a = i; a <= this.max; a += e)
+      o.push(a);
+    return o;
+  }
+  getRange() {
+    return { min: this.min, max: this.max };
+  }
+  getMediaHeight() {
+    return this.height;
+  }
+  /** Format a value for display, adapting decimal places to the visible range magnitude. */
+  formatY(t) {
+    const e = this.max - this.min;
+    return e < 0.01 ? t.toFixed(6) : e < 0.1 ? t.toFixed(4) : e < 10 ? t.toFixed(2) : e < 1e3 ? t.toFixed(1) : t.toFixed(0);
+  }
+}
+const ro = {
+  colors: ["#26a69a", "#ef5350"],
+  barWidthRatio: 0.6,
+  stacking: "off"
+};
+class nt {
+  constructor(t, e) {
+    x(this, "stores"), x(this, "options"), this.stores = Array.from({ length: t }, () => new jt()), this.options = { ...ro, ...e };
+  }
+  /** For chart compatibility — returns first store */
+  get store() {
+    return this.stores[0];
+  }
+  updateOptions(t) {
+    this.options = { ...this.options, ...t };
+  }
+  getColor() {
+    return this.options.colors[0];
+  }
+  getColors() {
+    return this.options.colors;
+  }
+  getValueRange(t, e) {
+    if (this.options.stacking === "percent")
+      return { min: 0, max: 100 };
+    if (this.stores.length <= 1)
+      return null;
+    const o = this.stores.map((n) => n.isVisible() ? n.getVisibleData(t, e) : []);
+    if (this.options.stacking === "off") {
+      let n = 1 / 0, l = -1 / 0;
+      for (const c of o)
+        for (const d of c)
+          d.value < n && (n = d.value), d.value > l && (l = d.value);
+      return n < 1 / 0 ? { min: n, max: l } : null;
+    }
+    const i = /* @__PURE__ */ new Map();
+    for (let n = 0; n < o.length; n++)
+      for (const l of o[n])
+        i.has(l.time) || i.set(l.time, new Array(o.length).fill(0)), i.get(l.time)[n] = l.value;
+    let a = 0, s = 0;
+    for (const n of i.values()) {
+      let l = 0, c = 0;
+      for (const d of n)
+        d > 0 ? l += d : c += d;
+      l > s && (s = l), c < a && (a = c);
+    }
+    return s > a ? { min: a, max: s } : null;
+  }
+  render(t) {
+    switch (this.options.stacking) {
+      case "normal":
+        this.renderStacked(t, !1);
+        break;
+      case "percent":
+        this.renderStacked(t, !0);
+        break;
+      default:
+        this.renderOff(t);
+        break;
+    }
+  }
+  /** Stacking off — each layer drawn independently from zero, overlapping */
+  renderOff(t) {
+    const { scope: e, timeScale: o, yScale: i, dataInterval: a } = t, { context: s } = e, n = o.getRange(), l = o.barWidthBitmap(a), c = Math.max(1, Math.round(l * this.options.barWidthRatio) - 2), d = Math.floor(c / 2), u = i.getRange().min < 0, b = u ? i.valueToBitmapY(0) : e.bitmapSize.height;
+    if (this.stores.length === 1) {
+      if (!this.stores[0].isVisible()) return;
+      const v = this.options.colors[0], C = this.options.colors.length > 1 ? this.options.colors[1] : v, w = this.stores[0].getVisibleData(n.from, n.to);
+      for (const g of w) {
+        const p = o.timeToBitmapX(g.time);
+        if (g.value >= 0) {
+          const m = i.valueToBitmapY(g.value), f = Math.max(1, b - m);
+          this.fillBar(s, p - d, m, c, f, v);
+        } else {
+          const m = i.valueToBitmapY(g.value), f = Math.max(1, m - b);
+          this.fillBar(s, p - d, b, c, f, C);
+        }
+      }
+    } else {
+      const v = this.stores.map((w) => w.isVisible() ? w.getVisibleData(n.from, n.to) : []), C = /* @__PURE__ */ new Map();
+      for (let w = 0; w < v.length; w++)
+        for (const g of v[w]) {
+          let p = C.get(g.time);
+          p || (p = [], C.set(g.time, p)), p.push({ layer: w, value: g.value });
+        }
+      for (const [w, g] of C) {
+        g.sort((m, f) => Math.abs(f.value) - Math.abs(m.value));
+        const p = o.timeToBitmapX(w);
+        for (const { layer: m, value: f } of g) {
+          const y = this.options.colors[m % this.options.colors.length];
+          if (f >= 0) {
+            const F = i.valueToBitmapY(f), k = Math.max(1, b - F);
+            this.fillBar(s, p - d, F, c, k, y);
+          } else {
+            const F = i.valueToBitmapY(f), k = Math.max(1, F - b);
+            this.fillBar(s, p - d, b, c, k, y);
+          }
+        }
+      }
+    }
+    if (u) {
+      s.strokeStyle = t.theme.grid.color, s.lineWidth = 1;
+      const v = Math.round(b) + 0.5;
+      s.beginPath(), s.moveTo(0, v), s.lineTo(e.bitmapSize.width, v), s.stroke();
+    }
+  }
+  /** Stacked (normal or percent) rendering */
+  renderStacked(t, e) {
+    const { scope: o, timeScale: i, yScale: a, dataInterval: s } = t, { context: n } = o, l = i.getRange(), c = i.barWidthBitmap(s), d = Math.max(1, Math.round(c * this.options.barWidthRatio) - 2), u = Math.floor(d / 2), b = this.stores.map(
+      (C) => C.isVisible() ? C.getVisibleData(l.from, l.to) : []
+    );
+    if (b.every((C) => C.length === 0)) return;
+    const v = /* @__PURE__ */ new Map();
+    for (let C = 0; C < b.length; C++)
+      for (const w of b[C])
+        v.has(w.time) || v.set(w.time, new Array(b.length).fill(0)), v.get(w.time)[C] = this.stores[C].isVisible() ? w.value : 0;
+    for (let C = 0; C < b.length; C++) {
+      const w = this.options.colors[C % this.options.colors.length];
+      for (const [g, p] of v) {
+        const m = p[C];
+        if (m === 0) continue;
+        const f = i.timeToBitmapX(g);
+        let y = 0, F = 0;
+        for (let k = 0; k < C; k++) {
+          const B = p[k];
+          B > 0 ? y += B : F += B;
+        }
+        if (e) {
+          let k = 0, B = 0;
+          for (const L of p)
+            L > 0 ? k += L : B += L;
+          if (m > 0 && k > 0) {
+            const L = y / k * 100, N = (y + m) / k * 100, $ = a.valueToBitmapY(N), Q = a.valueToBitmapY(L), G = Math.max(1, Q - $);
+            this.fillBar(n, f - u, $, d, G, w);
+          } else if (m < 0 && B < 0) {
+            const L = F / B * -100, N = (F + m) / B * -100, $ = a.valueToBitmapY(L), Q = a.valueToBitmapY(N), G = Math.max(1, Q - $);
+            n.fillStyle = w, n.fillRect(f - u, $, d, G);
+          }
+        } else if (m > 0) {
+          const k = a.valueToBitmapY(y + m), B = a.valueToBitmapY(y), L = Math.max(1, B - k);
+          this.fillBar(n, f - u, k, d, L, w);
+        } else {
+          const k = a.valueToBitmapY(F), B = a.valueToBitmapY(F + m), L = Math.max(1, B - k);
+          n.fillStyle = w, n.fillRect(f - u, k, d, L);
+        }
+      }
+    }
+  }
+  fillBar(t, e, o, i, a, s) {
+    t.fillStyle = s, t.fillRect(e, o, i, a);
+  }
+}
+function pe(r, t) {
+  return r.length <= t ? r : lo(
+    r,
+    t,
+    (e) => e.time,
+    (e) => e.value
+  );
+}
+function no(r, t) {
+  if (r.length <= t) return r;
+  const e = Math.ceil(r.length / t), o = [];
+  for (let i = 0; i < r.length; i += e) {
+    const a = Math.min(i + e, r.length);
+    let s = -1 / 0, n = 1 / 0, l = 0;
+    for (let c = i; c < a; c++)
+      r[c].high > s && (s = r[c].high), r[c].low < n && (n = r[c].low), l += r[c].volume ?? 0;
+    o.push({
+      time: r[i].time,
+      open: r[i].open,
+      high: s,
+      low: n,
+      close: r[a - 1].close,
+      volume: l
+    });
+  }
+  return o;
+}
+function lo(r, t, e, o) {
+  if (t >= r.length || t < 3) return r;
+  const i = [r[0]], a = (r.length - 2) / (t - 2);
+  let s = 0;
+  for (let n = 0; n < t - 2; n++) {
+    const l = Math.floor((n + 1) * a) + 1, c = Math.min(Math.floor((n + 2) * a) + 1, r.length - 1);
+    let d = 0, u = 0;
+    const b = c, v = Math.min(Math.floor((n + 3) * a) + 1, r.length), C = v - b;
+    if (C > 0) {
+      for (let f = b; f < v; f++)
+        d += e(r[f]), u += o(r[f]);
+      d /= C, u /= C;
+    }
+    let w = -1, g = l;
+    const p = e(r[s]), m = o(r[s]);
+    for (let f = l; f < c; f++) {
+      const y = Math.abs((p - d) * (o(r[f]) - m) - (p - e(r[f])) * (u - m));
+      y > w && (w = y, g = f);
+    }
+    i.push(r[g]), s = g;
+  }
+  return i.push(r[r.length - 1]), i;
+}
+const ge = /* @__PURE__ */ new Map(), me = /* @__PURE__ */ new Map(), be = /* @__PURE__ */ new Map();
+function Kt(r) {
+  return [parseInt(r.slice(1, 3), 16), parseInt(r.slice(3, 5), 16), parseInt(r.slice(5, 7), 16)];
+}
+function we(r, t, e) {
+  return `#${r.toString(16).padStart(2, "0")}${t.toString(16).padStart(2, "0")}${e.toString(16).padStart(2, "0")}`;
+}
+function Mt(r, t) {
+  if (r.startsWith("rgba")) return r.replace(/[\d.]+\)\s*$/, `${t})`);
+  if (r.startsWith("rgb(")) return r.replace(/^rgb\((.*)\)$/i, `rgba($1, ${t})`);
+  const e = r + t;
+  let o = ge.get(e);
+  if (o) return o;
+  const [i, a, s] = Kt(r);
+  return o = `rgba(${i}, ${a}, ${s}, ${t})`, ge.set(e, o), o;
+}
+function ho(r, t) {
+  const e = r + t;
+  let o = me.get(e);
+  if (o) return o;
+  const [i, a, s] = Kt(r);
+  return o = we(
+    Math.min(255, Math.round(i + (255 - i) * t)),
+    Math.min(255, Math.round(a + (255 - a) * t)),
+    Math.min(255, Math.round(s + (255 - s) * t))
+  ), me.set(e, o), o;
+}
+function co(r, t) {
+  const e = r + t;
+  let o = be.get(e);
+  if (o) return o;
+  const [i, a, s] = Kt(r);
+  return o = we(
+    Math.max(0, Math.round(i * (1 - t))),
+    Math.max(0, Math.round(a * (1 - t))),
+    Math.max(0, Math.round(s * (1 - t)))
+  ), be.set(e, o), o;
+}
+const uo = {
+  upColor: "#26a69a",
+  downColor: "#ef5350",
+  wickUpColor: "#26a69a",
+  wickDownColor: "#ef5350",
+  bodyWidthRatio: 0.6
+};
+class Gt {
+  constructor(t, e) {
+    x(this, "store"), x(this, "options"), this.store = t, this.options = { ...uo, ...e };
+  }
+  updateOptions(t) {
+    this.options = { ...this.options, ...t };
+  }
+  getColor() {
+    return this.options.upColor;
+  }
+  render(t) {
+    const { scope: e, timeScale: o, yScale: i, dataInterval: a } = t, { context: s, horizontalPixelRatio: n } = e, l = o.getRange();
+    let c = this.store.getVisibleData(l.from, l.to);
+    const d = e.mediaSize.width;
+    if (c.length > d * 2 && (c = no(c, Math.round(d * 1.5))), c.length === 0) return;
+    const u = o.barWidthBitmap(a), b = Math.max(1, Math.round(u * this.options.bodyWidthRatio) - 2), v = Math.floor(b / 2), C = Math.max(1, Math.round(n)), w = Math.round(i.getMediaHeight() * e.verticalPixelRatio);
+    this.drawVolume(s, c, o, w, u, a);
+    const g = [], p = [];
+    for (const m of c)
+      m.close >= m.open ? g.push(m) : p.push(m);
+    this.drawCandles(
+      s,
+      g,
+      o,
+      i,
+      v,
+      b,
+      C,
+      this.options.upColor,
+      this.options.wickUpColor
+    ), this.drawCandles(
+      s,
+      p,
+      o,
+      i,
+      v,
+      b,
+      C,
+      this.options.downColor,
+      this.options.wickDownColor
+    );
+  }
+  drawVolume(t, e, o, i, a, s) {
+    let n = 0;
+    for (const v of e)
+      v.volume !== void 0 && v.volume > n && (n = v.volume);
+    if (n === 0) return;
+    const l = i * 0.2, c = Math.max(1, a - 2), d = Math.floor(c / 2), u = Mt(this.options.upColor, 0.2), b = Mt(this.options.downColor, 0.2);
+    for (const v of e) {
+      if (v.volume === void 0 || v.volume === 0) continue;
+      const C = o.timeToBitmapX(v.time), w = Math.max(1, v.volume / n * l), g = v.close >= v.open;
+      t.fillStyle = g ? u : b, t.fillRect(C - d, i - w, c, w);
+    }
+  }
+  drawCandles(t, e, o, i, a, s, n, l, c) {
+    if (e.length === 0) return;
+    t.fillStyle = c;
+    for (const v of e) {
+      const C = o.timeToBitmapX(v.time), w = i.valueToBitmapY(v.high), g = i.valueToBitmapY(v.low), p = C - Math.floor(n / 2);
+      t.fillRect(p, w, n, g - w);
+    }
+    const d = this.options.candleGradient !== !1, u = d ? ho(l, 0.2) : l, b = d ? co(l, 0.15) : l;
+    d || (t.fillStyle = l);
+    for (const v of e) {
+      const C = o.timeToBitmapX(v.time), w = i.valueToBitmapY(v.open), g = i.valueToBitmapY(v.close), p = Math.min(w, g), m = Math.max(1, Math.abs(g - w));
+      if (d && m > 2) {
+        const f = t.createLinearGradient(0, p, 0, p + m);
+        f.addColorStop(0, u), f.addColorStop(0.5, l), f.addColorStop(1, b), t.fillStyle = f;
+      }
+      t.fillRect(C - a, p, s, m);
+    }
+  }
+}
+const fo = {
+  colors: ["#2962FF"],
+  lineWidth: 1,
+  areaFill: !0,
+  pulse: !0,
+  stacking: "off"
+};
+class j {
+  constructor(t, e) {
+    x(this, "stores"), x(this, "options"), x(this, "areaGradientCache", /* @__PURE__ */ new Map()), this.stores = Array.from({ length: t }, () => new jt()), this.options = { ...fo, ...e };
+  }
+  get store() {
+    return this.stores[0];
+  }
+  updateOptions(t) {
+    this.options = { ...this.options, ...t };
+  }
+  getColor() {
+    return this.options.colors[0];
+  }
+  getColors() {
+    return this.options.colors;
+  }
+  getStacking() {
+    return this.options.stacking;
+  }
+  get needsAnimation() {
+    return !1;
+  }
+  get hasPulse() {
+    return this.options.pulse && this.stores.some((t) => t.isVisible() && t.length > 0);
+  }
+  getValueRange(t, e) {
+    if (this.options.stacking === "percent")
+      return { min: 0, max: 100 };
+    if (this.stores.length <= 1)
+      return null;
+    const o = this.stores.map((n) => n.isVisible() ? n.getVisibleData(t, e) : []);
+    if (this.options.stacking === "off") {
+      let n = 1 / 0, l = -1 / 0;
+      for (const c of o)
+        for (const d of c)
+          d.value < n && (n = d.value), d.value > l && (l = d.value);
+      return n < 1 / 0 ? { min: n, max: l } : null;
+    }
+    const i = /* @__PURE__ */ new Map();
+    for (let n = 0; n < o.length; n++)
+      for (const l of o[n])
+        i.has(l.time) || i.set(l.time, new Array(o.length).fill(0)), i.get(l.time)[n] = l.value;
+    let a = 0, s = 0;
+    for (const n of i.values()) {
+      let l = 0, c = 0;
+      for (const d of n)
+        d > 0 ? l += d : c += d;
+      l > s && (s = l), c < a && (a = c);
+    }
+    return s > a ? { min: a, max: s } : null;
+  }
+  render(t) {
+    this.options.stacking === "off" ? this.renderOff(t) : this.renderStacked(t, this.options.stacking === "percent");
+  }
+  /** Each layer drawn independently */
+  renderOff(t) {
+    const { scope: e, timeScale: o, yScale: i } = t, { context: a } = e, s = o.getRange(), { verticalPixelRatio: n, horizontalPixelRatio: l } = e, c = Math.max(1, Math.round(this.options.lineWidth * n));
+    for (let d = 0; d < this.stores.length; d++) {
+      if (!this.stores[d].isVisible()) continue;
+      let u = this.stores[d].getVisibleData(s.from, s.to);
+      const b = e.mediaSize.width;
+      if (u.length > b * 2 && (u = pe(u, Math.round(b * 1.5))), u.length < 2) continue;
+      const v = this.options.colors[d % this.options.colors.length];
+      a.beginPath(), a.moveTo(o.timeToBitmapX(u[0].time), i.valueToBitmapY(u[0].value));
+      for (let C = 1; C < u.length; C++)
+        a.lineTo(o.timeToBitmapX(u[C].time), i.valueToBitmapY(u[C].value));
+      if (a.strokeStyle = v, a.lineWidth = c, a.lineJoin = "round", a.lineCap = "round", a.stroke(), this.options.areaFill) {
+        const C = o.timeToBitmapX(u[0].time), w = o.timeToBitmapX(u[u.length - 1].time), g = e.bitmapSize.height;
+        a.lineTo(w, g), a.lineTo(C, g), a.closePath();
+        const p = String(d), m = this.areaGradientCache.get(p);
+        let f;
+        m && m.bottomY === g && m.color === v ? f = m.gradient : (f = a.createLinearGradient(0, 0, 0, g), f.addColorStop(0, Mt(v, 0.12)), f.addColorStop(1, Mt(v, 0.01)), this.areaGradientCache.set(p, { gradient: f, bottomY: g, color: v })), a.fillStyle = f, a.fill();
+      }
+    }
+  }
+  /** Stacked area rendering */
+  renderStacked(t, e) {
+    const { scope: o, timeScale: i, yScale: a } = t, { context: s } = o, n = i.getRange(), { verticalPixelRatio: l } = o, c = Math.max(1, Math.round(this.options.lineWidth * l)), d = o.mediaSize.width, u = this.stores.map((g) => {
+      let p = g.getVisibleData(n.from, n.to);
+      return p.length > d * 2 && (p = pe(p, Math.round(d * 1.5))), p;
+    }), b = /* @__PURE__ */ new Set();
+    for (const g of u)
+      for (const p of g) b.add(p.time);
+    const v = Array.from(b).sort((g, p) => g - p);
+    if (v.length < 2) return;
+    const C = u.map((g) => {
+      const p = /* @__PURE__ */ new Map();
+      for (const m of g) p.set(m.time, m.value);
+      return p;
+    }), w = Array.from({ length: this.stores.length }, () => new Array(v.length).fill(0));
+    for (let g = 0; g < v.length; g++) {
+      const p = v[g];
+      let m = 0;
+      if (e)
+        for (let y = 0; y < this.stores.length; y++)
+          this.stores[y].isVisible() && (m += C[y].get(p) ?? 0);
+      let f = 0;
+      for (let y = 0; y < this.stores.length; y++) {
+        const F = this.stores[y].isVisible() ? C[y].get(p) ?? 0 : 0;
+        f += e && m > 0 ? F / m * 100 : F, w[y][g] = f;
+      }
+    }
+    for (let g = this.stores.length - 1; g >= 0; g--) {
+      if (!this.stores[g].isVisible()) continue;
+      const p = this.options.colors[g % this.options.colors.length], m = [];
+      for (let y = 0; y < v.length; y++)
+        m.push([i.timeToBitmapX(v[y]), a.valueToBitmapY(w[g][y])]);
+      const f = [];
+      for (let y = 0; y < v.length; y++) {
+        const F = g > 0 ? w[g - 1][y] : 0;
+        f.push([i.timeToBitmapX(v[y]), a.valueToBitmapY(F)]);
+      }
+      if (this.options.areaFill) {
+        s.beginPath(), s.moveTo(m[0][0], m[0][1]);
+        for (let y = 1; y < m.length; y++)
+          s.lineTo(m[y][0], m[y][1]);
+        for (let y = f.length - 1; y >= 0; y--)
+          s.lineTo(f[y][0], f[y][1]);
+        s.closePath(), s.fillStyle = Mt(p, 0.25), s.fill();
+      }
+      s.beginPath(), s.moveTo(m[0][0], m[0][1]);
+      for (let y = 1; y < m.length; y++)
+        s.lineTo(m[y][0], m[y][1]);
+      s.strokeStyle = p, s.lineWidth = c, s.lineJoin = "round", s.lineCap = "round", s.stroke();
+    }
+  }
+  drawPulseOverlay(t, e, o, i) {
+    if (this.options.pulse)
+      for (let a = 0; a < this.stores.length; a++) {
+        if (!this.stores[a].isVisible()) continue;
+        const s = this.stores[a].last();
+        if (!s) continue;
+        const n = this.options.colors[a % this.options.colors.length];
+        this.drawPulse(
+          t,
+          e.timeToBitmapX(s.time),
+          o.valueToBitmapY(s.value),
+          n,
+          i
+        );
+      }
+  }
+  drawPulse(t, e, o, i, a) {
+    const s = 3 * a, n = 0.4 + 0.6 * Math.abs(Math.sin(performance.now() / 600)), l = s + 4 * a * n;
+    t.beginPath(), t.arc(e, o, l, 0, Math.PI * 2), t.fillStyle = Mt(i, n * 0.3), t.fill(), t.beginPath(), t.arc(e, o, s, 0, Math.PI * 2), t.fillStyle = i, t.fill();
+  }
+}
+const po = {
+  innerRadiusRatio: 0,
+  padAngle: 0.02,
+  strokeColor: "transparent",
+  strokeWidth: 0
+}, Wt = Math.PI * 2;
+function go(r) {
+  if (!r.startsWith("#")) return !1;
+  const t = parseInt(r.slice(1, 3), 16), e = parseInt(r.slice(3, 5), 16), o = parseInt(r.slice(5, 7), 16);
+  return t * 0.299 + e * 0.587 + o * 0.114 > 150;
+}
+function mo(r, t) {
+  if (!r.startsWith("#")) return r;
+  const e = Math.min(255, parseInt(r.slice(1, 3), 16) + Math.round(255 * t)), o = Math.min(255, parseInt(r.slice(3, 5), 16) + Math.round(255 * t)), i = Math.min(255, parseInt(r.slice(5, 7), 16) + Math.round(255 * t));
+  return `#${e.toString(16).padStart(2, "0")}${o.toString(16).padStart(2, "0")}${i.toString(16).padStart(2, "0")}`;
+}
+function bo(r, t, e) {
+  return r + (t - r) * Math.min(1, e);
+}
+class bt {
+  constructor(t) {
+    x(this, "data", []), x(this, "options"), x(this, "hoverIndex", -1), x(this, "sliceOffsets", []), x(this, "lastRenderTime", 0), this.options = { ...po, ...t };
+  }
+  getData() {
+    return this.data;
+  }
+  setData(t) {
+    this.data = t, this.sliceOffsets = new Array(t.length).fill(0);
+  }
+  updateOptions(t) {
+    this.options = { ...this.options, ...t };
+  }
+  getColor() {
+    var t, e;
+    return ((t = this.data[0]) == null ? void 0 : t.color) ?? ((e = this.options.colors) == null ? void 0 : e[0]) ?? "#888";
+  }
+  /** Hit-test: which slice is at this bitmap coordinate? Returns index or -1. */
+  hitTest(t, e, o, i) {
+    if (this.data.length === 0) return -1;
+    const a = this.data.reduce((w, g) => w + g.value, 0);
+    if (a <= 0) return -1;
+    const s = o / 2, n = i / 2, l = Math.min(o, i) / 2 * 0.85, c = l * this.options.innerRadiusRatio, d = t - s, u = e - n, b = Math.sqrt(d * d + u * u);
+    if (b > l || b < c) return -1;
+    let v = Math.atan2(u, d) + Math.PI / 2;
+    v < 0 && (v += Wt);
+    let C = 0;
+    for (let w = 0; w < this.data.length; w++) {
+      const g = this.data[w].value / a * Wt;
+      if (v >= C && v < C + g) return w;
+      C += g;
+    }
+    return -1;
+  }
+  /** Returns true if animation is still in progress. */
+  get needsAnimation() {
+    for (let t = 0; t < this.sliceOffsets.length; t++) {
+      const e = t === this.hoverIndex ? 1 : 0;
+      if (Math.abs(this.sliceOffsets[t] - e) > 0.01) return !0;
+    }
+    return !1;
+  }
+  render(t) {
+    if (this.data.length === 0) return;
+    const { scope: e, theme: o } = t, { context: i, bitmapSize: a, horizontalPixelRatio: s } = e, n = performance.now(), l = this.lastRenderTime ? (n - this.lastRenderTime) / 1e3 : 0;
+    this.lastRenderTime = n;
+    const c = this.data.reduce((k, B) => k + B.value, 0);
+    if (c <= 0) return;
+    const d = 10;
+    for (; this.sliceOffsets.length < this.data.length; ) this.sliceOffsets.push(0);
+    for (let k = 0; k < this.data.length; k++) {
+      const B = k === this.hoverIndex ? 1 : 0;
+      this.sliceOffsets[k] = bo(this.sliceOffsets[k], B, d * l);
+    }
+    const u = this.options.colors ?? o.seriesColors, b = a.width / 2, v = a.height / 2, C = Math.min(a.width, a.height) / 2 * 0.85, w = C * this.options.innerRadiusRatio, g = this.options.padAngle, { strokeColor: p, strokeWidth: m } = this.options, f = 8 * s;
+    let y = -Math.PI / 2;
+    for (let k = 0; k < this.data.length; k++) {
+      const B = this.data[k], L = B.value / c * Wt, N = y + g / 2, $ = y + L - g / 2, Q = y + L / 2, G = B.color ?? u[k % u.length], pt = this.sliceOffsets[k] * f, J = Math.cos(Q) * pt, Ft = Math.sin(Q) * pt, gt = b + J, mt = v + Ft;
+      i.beginPath(), i.arc(gt, mt, C, N, $), w > 0 ? i.arc(gt, mt, w, $, N, !0) : i.lineTo(gt, mt), i.closePath();
+      const X = i.createRadialGradient(gt, mt, w || 0, gt, mt, C);
+      X.addColorStop(0, mo(G, 0.15)), X.addColorStop(1, G), i.fillStyle = X, this.sliceOffsets[k] > 0.01 && (i.shadowColor = "rgba(0,0,0,0.25)", i.shadowBlur = 12 * s * this.sliceOffsets[k], i.shadowOffsetX = J * 0.3, i.shadowOffsetY = Ft * 0.3), i.fill(), i.shadowColor = "transparent", i.shadowBlur = 0, i.shadowOffsetX = 0, i.shadowOffsetY = 0, m > 0 && p !== "transparent" && (i.strokeStyle = p, i.lineWidth = m, i.stroke()), y += L;
+    }
+    y = -Math.PI / 2;
+    const F = w > 0 ? (C + w) / 2 : C * 0.65;
+    i.textAlign = "center", i.textBaseline = "middle", i.font = `${11 * s}px ${o.typography.fontFamily}`;
+    for (let k = 0; k < this.data.length; k++) {
+      const B = this.data[k], L = B.value / c * Wt;
+      if (L > 0.3) {
+        const N = y + L / 2, $ = this.sliceOffsets[k] * f, Q = b + Math.cos(N) * (F + $), G = v + Math.sin(N) * (F + $), pt = B.color ?? u[k % u.length];
+        i.fillStyle = go(pt) ? "#000000" : "#ffffff", i.fillText(B.label, Q, G);
+      }
+      y += L;
+    }
+  }
+}
+const ke = {
+  background: "#131722",
+  chartGradient: ["#1a1f2e", "#101318"],
+  typography: {
+    fontFamily: "'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif",
+    fontSize: 12,
+    axisFontSize: 10,
+    yFontSize: 11,
+    tooltipFontSize: 12
+  },
+  grid: {
+    color: "rgba(42, 46, 57, 0.6)",
+    style: "dashed"
+  },
+  candlestick: {
+    upColor: "#26a69a",
+    downColor: "#ef5350",
+    wickUpColor: "#26a69a",
+    wickDownColor: "#ef5350"
+  },
+  line: {
+    color: "#2962FF",
+    width: 1,
+    areaTopColor: "rgba(41, 98, 255, 0.08)",
+    areaBottomColor: "rgba(41, 98, 255, 0.01)"
+  },
+  seriesColors: [
+    "#2962FF",
+    "#FF6D00",
+    "#26a69a",
+    "#AB47BC",
+    "#ef5350",
+    "#FFCA28",
+    "#66BB6A",
+    "#EC407A",
+    "#42A5F5",
+    "#B388FF"
+  ],
+  bands: {
+    upper: "#42A5F5",
+    lower: "#EC407A"
+  },
+  crosshair: {
+    color: "rgba(150, 150, 150, 0.5)",
+    labelBackground: "#363a45",
+    labelTextColor: "#d1d4dc"
+  },
+  axis: { textColor: "#787b86" },
+  yLabel: {
+    upBackground: "#26a69a",
+    downBackground: "#ef5350",
+    neutralBackground: "#363a45",
+    textColor: "#ffffff"
+  },
+  tooltip: {
+    background: "rgba(19, 23, 34, 0.9)",
+    textColor: "#d1d4dc",
+    borderColor: "rgba(42, 46, 57, 0.8)"
+  }
+}, dt = {
+  top: 20,
+  bottom: 20,
+  right: { intervals: 3 },
+  left: { intervals: 0 }
+};
+class vo extends Pt {
+  constructor({ padding: t } = {}) {
+    super(), x(this, "_visibleRange", { from: 0, to: 0 }), x(this, "_yRange", { min: 0, max: 0 }), x(this, "_autoScroll", !0), x(this, "padding"), x(this, "dataInterval", 6e4), x(this, "_dataStart", null), x(this, "_dataEnd", null), x(this, "_animating", !1), x(this, "animStartTime", 0), x(this, "animDuration", 0), x(this, "animFrom", { from: 0, to: 0 }), x(this, "animTo", { from: 0, to: 0 }), this.padding = {
+      top: (t == null ? void 0 : t.top) ?? dt.top,
+      bottom: (t == null ? void 0 : t.bottom) ?? dt.bottom,
+      right: (t == null ? void 0 : t.right) ?? dt.right,
+      left: (t == null ? void 0 : t.left) ?? dt.left
+    };
+  }
+  /**
+   * Resolve a HorizontalPadding value to a time offset.
+   * - `{ intervals: N }` → N * dataInterval (zoom-independent bar count)
+   * - `number` (pixels) → (px / chartWidth) * visibleRange (zoom-dependent)
+   */
+  resolveHPad(t, e, o) {
+    return typeof t == "object" ? t.intervals * this.dataInterval : o <= 0 ? 0 : t / o * e;
+  }
+  get visibleRange() {
+    return this._visibleRange;
+  }
+  get yRange() {
+    return this._yRange;
+  }
+  get autoScroll() {
+    return this._autoScroll;
+  }
+  get animating() {
+    return this._animating;
+  }
+  setDataInterval(t) {
+    this.dataInterval = t;
+  }
+  /** Replace padding configuration. Only updates fields that are provided; others keep defaults. */
+  setPadding(t) {
+    this.padding = {
+      top: (t == null ? void 0 : t.top) ?? dt.top,
+      bottom: (t == null ? void 0 : t.bottom) ?? dt.bottom,
+      right: (t == null ? void 0 : t.right) ?? dt.right,
+      left: (t == null ? void 0 : t.left) ?? dt.left
+    };
+  }
+  setDataStart(t) {
+    this._dataStart = t;
+  }
+  setDataEnd(t) {
+    this._dataEnd = t;
+  }
+  cancelAnimation() {
+    this._animating = !1;
+  }
+  /** Validate and apply a new visible range. When clampToData is true, reject zoom beyond data extent. */
+  applyRange(t, e, o = !1) {
+    if (e <= t) return;
+    const i = e - t;
+    if (!(i / this.dataInterval < 2)) {
+      if (o && this._dataStart !== null && this._dataEnd !== null) {
+        const a = this._dataEnd - this._dataStart + this.dataInterval * 5;
+        if (i > a && a > 0) return;
+      }
+      this._visibleRange = { from: t, to: e }, this.emit("change");
+    }
+  }
+  /** Start animation — will be advanced by tick() calls from the render loop */
+  animateTo(t, e, o = 400) {
+    this.animFrom = { ...this._visibleRange }, this.animTo = { from: t, to: e }, this.animDuration = o, this.animStartTime = performance.now(), this._animating = !0;
+  }
+  /** Called by the render loop before each frame. Returns true if still animating. */
+  tick(t) {
+    if (!this._animating) return !1;
+    const e = t - this.animStartTime, o = Math.min(1, e / this.animDuration), i = 1 - (1 - o) ** 3, a = de(this.animFrom.from, this.animTo.from, i), s = de(this.animFrom.to, this.animTo.to, i);
+    return s > a && this.applyRange(a, s), o >= 1 && (this._animating = !1), this._animating;
+  }
+  /** Set the Y-axis range. Adds pixel-based padding unless a side has a fixed (explicit) bound. */
+  setYRange(t, e, o, i = !1, a = !1) {
+    const s = e - t, n = o > 0 ? this.padding.top / o * s : 0, l = o > 0 ? this.padding.bottom / o * s : 0;
+    this._yRange = {
+      min: i ? t : t - l,
+      max: a ? e : e + n
+    };
+  }
+  /** Zoom in/out around a time anchor point. Factor < 1 zooms in, > 1 zooms out. */
+  zoomAt(t, e) {
+    this.cancelAnimation();
+    const { from: o, to: i } = this._visibleRange, a = i - o, s = a * e, n = (t - o) / a, l = t - n * s, c = l + s;
+    if (!(s / this.dataInterval < 10)) {
+      if (e > 1 && this._dataStart !== null && this._dataEnd !== null && l <= this._dataStart && c >= this._dataEnd) {
+        this._autoScroll = !0, this.applyRange(l, c, !0);
+        return;
+      }
+      this._autoScroll = !1, this.applyRange(l, c, !0);
+    }
+  }
+  /** Shift the visible range by a time delta. Disables auto-scroll. */
+  pan(t) {
+    this.cancelAnimation();
+    const { from: e, to: o } = this._visibleRange, i = e + t, a = o + t;
+    this._autoScroll = !1, this.applyRange(i, a);
+  }
+  /** Fit the viewport to show data from first to last timestamp, with optional animation. */
+  fitToData(t, e, o = 0, i = !1) {
+    this._autoScroll = !0;
+    const a = 400 * this.dataInterval, s = e - t, n = s > 0 ? s : this.dataInterval * 10, l = this.resolveHPad(this.padding.right, n, o), c = this.resolveHPad(this.padding.left, n, o);
+    let d = e + l, u = t - c;
+    d - u > a && (d = e + l, u = d - a), i && this._visibleRange.from !== 0 && this._visibleRange.to !== 0 ? this.animateTo(u, d, 450) : this.applyRange(u, d);
+  }
+  /** Keep the right edge pinned to the latest data (real-time auto-scroll). */
+  scrollToEnd(t, e = 0) {
+    const o = this._visibleRange.to - this._visibleRange.from, i = this.resolveHPad(this.padding.right, o, e), a = t + i, s = a - o;
+    this._autoScroll = !0, this._animating ? (this.animFrom = { ...this._visibleRange }, this.animTo = { from: s, to: a }, this.animDuration = 150, this.animStartTime = performance.now()) : this.animateTo(s, a, 150);
+  }
+  /** Return the number of data bars (candles/points) currently visible. */
+  getVisibleBarsCount() {
+    return (this._visibleRange.to - this._visibleRange.from) / this.dataInterval;
+  }
+  destroy() {
+    this.cancelAnimation(), this.removeAllListeners();
+  }
+}
+let yo = 0;
+var E, D, U, Ct, _t, S, V, Bt, ot, ht, H, lt, Nt, wt, ut, Dt, yt, kt, zt, Vt, it, at, St;
+class xo extends Pt {
+  constructor(t, e) {
+    var o, i, a;
+    super(), A(this, kt), A(this, E), A(this, D), A(this, U), A(this, Ct), x(this, "timeScale"), x(this, "yScale"), A(this, _t), A(this, S, []), A(this, V), A(this, Bt), A(this, ot, 6e4), A(this, ht, null), A(this, H, {}), A(this, lt, null), A(this, Nt, !1), A(this, wt, {}), A(this, ut, 0), A(this, Dt, !1), A(this, yt, !1), A(this, Vt, 0), A(this, it, 0), A(this, at, 0), A(this, St, !1), e != null && e.axis && (M(this, wt, e.axis), M(this, H, { min: (o = e.axis.y) == null ? void 0 : o.min, max: (i = e.axis.y) == null ? void 0 : i.max })), M(this, V, (e == null ? void 0 : e.theme) ?? ke), M(this, Bt, (e == null ? void 0 : e.grid) !== !1), M(this, E, new Ge(t)), M(this, D, new vo({ padding: e == null ? void 0 : e.padding })), this.timeScale = new ao(), this.yScale = new so(), M(this, U, new ue(() => this.renderMain())), M(this, Ct, new ue(() => this.renderOverlay()));
+    const s = (e == null ? void 0 : e.interactive) !== !1;
+    M(this, _t, s ? new Qe(h(this, E).canvas, h(this, D), this.timeScale, this.yScale) : null), h(this, D).on("change", () => {
+      this.syncScales(), h(this, U).markDirty(), this.emit("viewportChange");
+    }), h(this, E).on("resize", () => {
+      this.updateScales(!0), this.renderMain(), this.emit("viewportChange");
+    }), (a = h(this, _t)) == null || a.on("crosshairMove", (n) => {
+      M(this, ht, n), h(this, Ct).markDirty(), this.emit("crosshairMove", n), this.updatePieHover(n);
+    });
+  }
+  get yAxisWidth() {
+    const t = h(this, wt).y;
+    return (t == null ? void 0 : t.visible) === !1 ? 0 : (t == null ? void 0 : t.width) ?? 55;
+  }
+  get xAxisHeight() {
+    const t = h(this, wt).x;
+    return (t == null ? void 0 : t.visible) === !1 ? 0 : (t == null ? void 0 : t.height) ?? 30;
+  }
+  /** Add a candlestick (OHLC) series and return its unique ID. */
+  addCandlestickSeries(t) {
+    const e = new jt(), o = new Gt(e, {
+      upColor: h(this, V).candlestick.upColor,
+      downColor: h(this, V).candlestick.downColor,
+      wickUpColor: h(this, V).candlestick.wickUpColor,
+      wickDownColor: h(this, V).candlestick.wickDownColor,
+      bodyWidthRatio: 0.6,
+      ...t
+    }), i = It(this, kt, zt).call(this, t == null ? void 0 : t.id);
+    return e.on("update", () => {
+      this.onDataChanged();
+    }), h(this, S).push({ id: i, renderer: o, store: e, visible: !0 }), M(this, lt, null), this.updateViewportPadding(), this.emit("seriesChange"), i;
+  }
+  addLineSeries(t, e) {
+    let o, i;
+    if (typeof t == "number")
+      o = t, i = e;
+    else {
+      const { layers: n, ...l } = t ?? {};
+      o = n ?? 1, i = l;
+    }
+    const a = new j(o, {
+      colors: o === 1 ? [h(this, V).line.color] : h(this, V).seriesColors.slice(0, o),
+      lineWidth: h(this, V).line.width,
+      areaFill: !0,
+      ...i
+    }), s = It(this, kt, zt).call(this, i == null ? void 0 : i.id);
+    for (const n of a.stores)
+      n.on("update", () => this.onDataChanged());
+    return h(this, S).push({ id: s, label: i == null ? void 0 : i.label, renderer: a, store: a.stores[0], visible: !0 }), M(this, lt, null), this.updateViewportPadding(), this.emit("seriesChange"), s;
+  }
+  /** Set data for a specific layer within a line series. */
+  setLineLayerData(t, e, o) {
+    const i = h(this, S).find((s) => s.id === t);
+    if (!i || !(i.renderer instanceof j)) return;
+    const a = i.renderer.stores[e];
+    a && a.setData(o);
+  }
+  addBarSeries(t, e) {
+    let o, i;
+    if (typeof t == "number")
+      o = t, i = e;
+    else {
+      const { layers: n, ...l } = t ?? {};
+      o = n ?? 1, i = l;
+    }
+    const a = new nt(o, {
+      colors: h(this, V).seriesColors.slice(0, o),
+      barWidthRatio: 0.6,
+      ...i
+    }), s = It(this, kt, zt).call(this, i == null ? void 0 : i.id);
+    for (const n of a.stores)
+      n.on("update", () => this.onDataChanged());
+    return h(this, S).push({ id: s, label: i == null ? void 0 : i.label, renderer: a, store: a.stores[0], visible: !0 }), M(this, lt, null), this.updateViewportPadding(), this.emit("seriesChange"), s;
+  }
+  /** Set data for a specific layer within a bar series. */
+  setBarLayerData(t, e, o) {
+    const i = h(this, S).find((s) => s.id === t);
+    if (!i || !(i.renderer instanceof nt)) return;
+    const a = i.renderer.stores[e];
+    a && a.setData(o);
+  }
+  /** Add a pie/donut series. Set `innerRadiusRatio > 0` for donut. */
+  addPieSeries(t) {
+    const e = new bt(t), o = It(this, kt, zt).call(this, t == null ? void 0 : t.id);
+    return h(this, S).push({ id: o, label: t == null ? void 0 : t.label, renderer: e, store: null, visible: !0 }), M(this, lt, null), this.updateViewportPadding(), this.emit("seriesChange"), o;
+  }
+  /** Set data for a pie/donut series. */
+  setPieData(t, e) {
+    const o = h(this, S).find((i) => i.id === t);
+    !o || !(o.renderer instanceof bt) || (o.renderer.setData(e), h(this, U).markDirty(), this.emit("dataUpdate"));
+  }
+  /** Remove a series by ID and clean up its resources. */
+  removeSeries(t) {
+    const e = h(this, S).findIndex((o) => o.id === t);
+    if (e >= 0) {
+      const { renderer: o, store: i } = h(this, S)[e];
+      if (o instanceof j || o instanceof nt)
+        for (const a of o.stores) a.removeAllListeners();
+      else
+        i == null || i.removeAllListeners();
+      h(this, S).splice(e, 1), M(this, lt, null), this.updateViewportPadding(), h(this, U).markDirty(), this.emit("seriesChange");
+    }
+  }
+  /** Replace all data for a series (batch load). Accepts `Date` objects for time fields. */
+  setSeriesData(t, e) {
+    const o = h(this, S).find((a) => a.id === t);
+    if (!(o != null && o.store)) return;
+    const i = e.length > 0 && "open" in e[0] ? Ze(e) : to(e);
+    o.store.setData(i);
+  }
+  /** Append a new data point to the end of a series (real-time tick). */
+  appendData(t, e) {
+    const o = h(this, S).find((a) => a.id === t);
+    if (!(o != null && o.store)) return;
+    const i = { ...e, time: fe(e.time) };
+    o.store.append(i);
+  }
+  /** Update the last data point of a series in place (e.g. live candle update). */
+  updateData(t, e) {
+    const o = h(this, S).find((a) => a.id === t);
+    if (!(o != null && o.store)) return;
+    const i = { ...e, time: fe(e.time) };
+    o.store.updateLast(i);
+  }
+  /** Update visual options (color, width, etc.) for an existing series. */
+  updateSeriesOptions(t, e) {
+    const o = h(this, S).find((i) => i.id === t);
+    o && ((o.renderer instanceof Gt || o.renderer instanceof j || o.renderer instanceof nt || o.renderer instanceof bt) && o.renderer.updateOptions(e), "label" in e && typeof e.label == "string" && (o.label = e.label), h(this, U).markDirty());
+  }
+  /**
+   * Batch multiple updates: suppress recomputes until `fn` returns.
+   * Equivalent to `beginUpdate()` / `endUpdate()` but safer (always calls endUpdate even on throw).
+   */
+  batch(t) {
+    this.beginUpdate();
+    try {
+      t();
+    } finally {
+      this.endUpdate();
+    }
+  }
+  /** @deprecated Use {@link batch} instead. */
+  beginUpdate() {
+    he(this, ut)._++;
+  }
+  /** @deprecated Use {@link batch} instead. */
+  endUpdate() {
+    --he(this, ut)._ <= 0 && (M(this, ut, 0), h(this, Dt) ? (M(this, Dt, !1), M(this, yt, !1), this.onDataChanged()) : h(this, yt) && (M(this, yt, !1), this.updateYRange(!0), h(this, U).markDirty()));
+  }
+  /** Show or hide a series. Hidden series are not rendered and excluded from Y-range. */
+  setSeriesVisible(t, e) {
+    const o = h(this, S).find((i) => i.id === t);
+    if (!(!o || o.visible === e)) {
+      if (o.visible = e, h(this, ut) > 0) {
+        M(this, yt, !0);
+        return;
+      }
+      this.updateYRange(!0), h(this, U).markDirty();
+    }
+  }
+  isSeriesVisible(t) {
+    var e;
+    return ((e = h(this, S).find((o) => o.id === t)) == null ? void 0 : e.visible) ?? !0;
+  }
+  /** Show or hide a specific layer within a multi-layer series. */
+  setLayerVisible(t, e, o) {
+    const i = h(this, S).find((s) => s.id === t);
+    if (!i) return;
+    const a = i.renderer;
+    if (a instanceof nt || a instanceof j) {
+      const s = a.stores[e];
+      if (s) {
+        if (s.isVisible() === o) return;
+        if (s.setVisible(o), h(this, ut) > 0) {
+          M(this, yt, !0);
+          return;
+        }
+        this.updateYRange(!0), h(this, U).markDirty();
+      }
+    }
+  }
+  isLayerVisible(t, e) {
+    var o;
+    const i = h(this, S).find((s) => s.id === t);
+    if (!i) return !0;
+    const a = i.renderer;
+    return a instanceof nt || a instanceof j ? ((o = a.stores[e]) == null ? void 0 : o.isVisible()) ?? !0 : !0;
+  }
+  /** Auto-fit the viewport to show all data across every series. */
+  fitContent() {
+    const { first: t, last: e } = this.getDataBounds();
+    if (t === void 0 || e === void 0) return;
+    const o = h(this, E).size.media.width - this.yAxisWidth;
+    h(this, D).fitToData(t, e, o, !0);
+  }
+  getVisibleRange() {
+    return h(this, D).visibleRange;
+  }
+  getYRange() {
+    return h(this, D).yRange;
+  }
+  getCrosshairPosition() {
+    return h(this, ht);
+  }
+  /** Get the last visible value and whether the absolute last point is on screen. */
+  getLastValue(t) {
+    const e = h(this, S).find((l) => l.id === t);
+    if (!(e != null && e.store)) return null;
+    const o = e.store.last();
+    if (!o) return null;
+    const i = (l) => "close" in l ? l.close : l.value, { from: a, to: s } = h(this, D).visibleRange;
+    if (o.time >= a && o.time <= s)
+      return { value: i(o), isLive: !0 };
+    const n = e.store.getVisibleData(a, s);
+    return n.length === 0 ? null : { value: i(n[n.length - 1]), isLive: !1 };
+  }
+  /** Get the second-to-last value, useful for computing change. */
+  getPreviousClose(t) {
+    const e = h(this, S).find((a) => a.id === t);
+    if (!(e != null && e.store)) return null;
+    const o = e.store.getAll();
+    if (o.length < 2) return null;
+    const i = o[o.length - 2];
+    return "close" in i ? i.close : i.value;
+  }
+  getLastData(t) {
+    const e = h(this, S).find((o) => o.id === t);
+    return e != null && e.store ? e.store.last() ?? null : null;
+  }
+  /** Find the data point closest to the given timestamp within one data interval. */
+  getDataAtTime(t, e) {
+    const o = h(this, S).find((n) => n.id === t);
+    if (!(o != null && o.store)) return null;
+    const i = o.store.getVisibleData(e - h(this, ot), e + h(this, ot));
+    if (i.length === 0) return null;
+    let a = i[0], s = Math.abs(i[0].time - e);
+    for (let n = 1; n < i.length; n++) {
+      const l = Math.abs(i[n].time - e);
+      l < s && (s = l, a = i[n]);
+    }
+    return a;
+  }
+  /** Get all layers' data at a given time for multi-layer series (Bar/Line with stacking). */
+  getLayerSnapshots(t, e) {
+    const o = h(this, S).find((n) => n.id === t);
+    if (!o || !o.visible) return null;
+    const i = o.renderer;
+    if (!(i instanceof nt) && !(i instanceof j) || i.stores.length <= 1) return null;
+    const a = i.getColors(), s = [];
+    for (let n = 0; n < i.stores.length; n++) {
+      if (!i.stores[n].isVisible()) continue;
+      const l = i.stores[n].getVisibleData(e - h(this, ot), e + h(this, ot));
+      if (l.length === 0) continue;
+      let c = l[0], d = Math.abs(l[0].time - e);
+      for (let u = 1; u < l.length; u++) {
+        const b = Math.abs(l[u].time - e);
+        b < d && (d = b, c = l[u]);
+      }
+      s.push({
+        value: c.value,
+        color: (a == null ? void 0 : a[n % ((a == null ? void 0 : a.length) ?? 1)]) ?? h(this, V).seriesColors[n % h(this, V).seriesColors.length]
+      });
+    }
+    return s.length > 0 ? s : null;
+  }
+  getSeriesIds() {
+    return h(this, lt) || M(this, lt, h(this, S).map((t) => t.id)), h(this, lt).slice();
+  }
+  /** Get the primary display color for a series. */
+  getSeriesColor(t) {
+    const e = h(this, S).find((o) => o.id === t);
+    return e ? "getColor" in e.renderer && typeof e.renderer.getColor == "function" ? e.renderer.getColor() : h(this, V).line.color : null;
+  }
+  getSeriesLabel(t) {
+    var e;
+    return (e = h(this, S).find((o) => o.id === t)) == null ? void 0 : e.label;
+  }
+  /** Get per-layer colors for a series. Returns null for non-bar/line series (e.g. candlestick, pie). */
+  getSeriesLayers(t) {
+    const e = h(this, S).find((a) => a.id === t);
+    if (!e) return null;
+    const o = e.renderer;
+    if (!(o instanceof nt) && !(o instanceof j)) return null;
+    const i = o.getColors();
+    return o.stores.map((a, s) => ({
+      color: i[s % i.length]
+    }));
+  }
+  /** Get all pie slices with computed colors and percentages. Returns null for non-pie series. */
+  getPieSlices(t) {
+    const e = h(this, S).find((s) => s.id === t);
+    if (!e || !(e.renderer instanceof bt)) return null;
+    const o = e.renderer.getData();
+    if (o.length === 0) return null;
+    const i = o.reduce((s, n) => s + n.value, 0), a = h(this, V).seriesColors;
+    return o.map((s, n) => ({
+      label: s.label,
+      value: s.value,
+      percent: i > 0 ? s.value / i * 100 : 0,
+      color: s.color ?? a[n % a.length]
+    }));
+  }
+  /** Get the hovered pie slice info (label, value, percentage, color). Returns null if no hover. */
+  getPieHoverInfo(t) {
+    const e = h(this, S).find((l) => l.id === t);
+    if (!e || !(e.renderer instanceof bt)) return null;
+    const o = e.renderer;
+    if (o.hoverIndex < 0) return null;
+    const i = o.getData(), a = i[o.hoverIndex];
+    if (!a) return null;
+    const s = i.reduce((l, c) => l + c.value, 0), n = h(this, V).seriesColors;
+    return {
+      label: a.label,
+      value: a.value,
+      percent: s > 0 ? a.value / s * 100 : 0,
+      color: a.color ?? n[o.hoverIndex % n.length]
+    };
+  }
+  /** Apply a new theme and update candlestick series colors. Line series keep their individual colors. */
+  setTheme(t) {
+    const e = h(this, V).line.color;
+    M(this, V, t);
+    for (const o of h(this, S))
+      o.renderer instanceof Gt ? o.renderer.updateOptions({
+        upColor: t.candlestick.upColor,
+        downColor: t.candlestick.downColor,
+        wickUpColor: t.candlestick.wickUpColor,
+        wickDownColor: t.candlestick.wickDownColor
+      }) : o.renderer instanceof nt ? o.renderer.updateOptions({
+        colors: t.seriesColors.slice(0, o.renderer.stores.length)
+      }) : o.renderer instanceof j && (o.renderer.stores.length === 1 ? o.renderer.getColor() === e && o.renderer.updateOptions({ colors: [t.line.color] }) : o.renderer.updateOptions({
+        colors: t.seriesColors.slice(0, o.renderer.stores.length)
+      }));
+    h(this, U).markDirty();
+  }
+  getTheme() {
+    return h(this, V);
+  }
+  /** Update axis configuration and re-render. */
+  setAxis(t) {
+    var e, o;
+    const i = this.yAxisWidth, a = this.xAxisHeight;
+    M(this, wt, t);
+    const s = { min: (e = t.y) == null ? void 0 : e.min, max: (o = t.y) == null ? void 0 : o.max };
+    M(this, H, s), M(this, St, !1), this.updateYRange(!0), (this.yAxisWidth !== i || this.xAxisHeight !== a) && this.updateScales(!0), h(this, U).markDirty();
+  }
+  getMediaSize() {
+    return h(this, E).size.media;
+  }
+  /** Returns layout metrics for the chart area, Y axis, and time axis. */
+  getLayout() {
+    const t = h(this, E).size.media, e = this.yAxisWidth, o = this.xAxisHeight;
+    return {
+      chartArea: { x: 0, y: 0, width: t.width - e, height: t.height - o },
+      yAxisWidth: e,
+      xAxisHeight: o
+    };
+  }
+  getDataInterval() {
+    return h(this, ot);
+  }
+  /** Update viewport padding at runtime. Refits the visible range to current data bounds. */
+  setPadding(t) {
+    h(this, D).setPadding(t);
+    const { first: e, last: o } = this.getDataBounds();
+    if (e !== void 0 && o !== void 0) {
+      const i = h(this, E).size.media.width - this.yAxisWidth;
+      h(this, D).fitToData(e, o, i, !1);
+    }
+    this.syncScales(), h(this, U).markDirty();
+  }
+  /** Show or hide the background grid. Takes effect on the next render frame. */
+  setGrid(t) {
+    M(this, Bt, t), h(this, U).markDirty();
+  }
+  /** Notify chart that a YLabel is present (affects right padding). */
+  setYLabel(t) {
+    M(this, Nt, t), this.updateViewportPadding();
+  }
+  updatePieHover(t) {
+    const e = h(this, E).size;
+    for (const o of h(this, S))
+      if (o.renderer instanceof bt) {
+        const i = o.renderer.hoverIndex;
+        if (t) {
+          const a = t.mediaX * e.horizontalPixelRatio, s = t.mediaY * e.verticalPixelRatio;
+          o.renderer.hoverIndex = o.renderer.hitTest(a, s, e.bitmap.width, e.bitmap.height);
+        } else
+          o.renderer.hoverIndex = -1;
+        o.renderer.hoverIndex !== i && h(this, U).markDirty();
+      }
+  }
+  updateViewportPadding() {
+  }
+  /** Tear down the chart: cancel animations, remove listeners, and detach the canvas. */
+  destroy() {
+    var t;
+    h(this, D).destroy(), h(this, U).destroy(), h(this, Ct).destroy(), (t = h(this, _t)) == null || t.destroy(), h(this, E).destroy(), this.removeAllListeners();
+  }
+  /** Compute the earliest and latest timestamps across all series. */
+  getDataBounds() {
+    let t, e;
+    for (const o of h(this, S)) {
+      if (!o.visible || !o.store) continue;
+      const i = o.store.first(), a = o.store.last();
+      i && (t === void 0 || i.time < t) && (t = i.time), a && (e === void 0 || a.time > e) && (e = a.time);
+    }
+    return { first: t, last: e };
+  }
+  onDataChanged() {
+    if (h(this, ut) > 0) {
+      M(this, Dt, !0);
+      return;
+    }
+    this.updateDataInterval();
+    const { first: t, last: e } = this.getDataBounds();
+    t !== void 0 && h(this, D).setDataStart(t), e !== void 0 && h(this, D).setDataEnd(e);
+    let o = 0;
+    for (const a of h(this, S))
+      if (a.renderer instanceof j || a.renderer instanceof nt)
+        for (const s of a.renderer.stores) o += s.length;
+      else a.store && (o += a.store.length);
+    const i = o - h(this, Vt) > 5;
+    if (M(this, Vt, o), t !== void 0 && e !== void 0) {
+      const { from: a, to: s } = h(this, D).visibleRange, n = a === 0 && s === 0, l = h(this, E).size.media.width - this.yAxisWidth;
+      n ? h(this, D).fitToData(t, e, l, !1) : i && h(this, D).autoScroll ? h(this, D).fitToData(t, e, l, !0) : !i && this.isLastPointVisible() && h(this, D).scrollToEnd(e, l);
+    }
+    this.updateYRange(i), this.syncScales(), h(this, U).markDirty(), this.emit("dataUpdate");
+  }
+  /** Check whether the last data point of any series falls within the visible time range. */
+  isLastPointVisible() {
+    const { from: t, to: e } = h(this, D).visibleRange;
+    for (const o of h(this, S)) {
+      if (!o.visible || !o.store) continue;
+      const i = o.store.last();
+      if (i && i.time >= t && i.time <= e) return !0;
+    }
+    return !1;
+  }
+  updateDataInterval() {
+    for (const t of h(this, S)) {
+      if (!t.store) continue;
+      const e = t.store.getAll();
+      if (e.length >= 2) {
+        const o = e.slice(0, 20).map((i) => i.time);
+        M(this, ot, eo(o)), h(this, D).setDataInterval(h(this, ot));
+        break;
+      }
+    }
+  }
+  updateYRange(t = !1) {
+    let e = 1 / 0, o = -1 / 0;
+    const i = h(this, D).visibleRange;
+    let a = h(this, H).min !== void 0 && h(this, H).min !== "auto" && typeof h(this, H).min != "number" || h(this, H).max !== void 0 && h(this, H).max !== "auto" && typeof h(this, H).max != "number" ? [] : null;
+    for (const c of h(this, S)) {
+      if (!c.visible) continue;
+      if (c.renderer.getValueRange) {
+        const u = c.renderer.getValueRange(i.from, i.to);
+        if (u) {
+          u.max > o && (o = u.max), u.min < e && (e = u.min), a == null || a.push(u.min, u.max);
+          continue;
+        }
+      }
+      if (!c.store) continue;
+      const d = c.store.getVisibleData(i.from, i.to);
+      for (const u of d)
+        if ("high" in u) {
+          const b = u;
+          b.high > o && (o = b.high), b.low < e && (e = b.low), a == null || a.push(b.high, b.low);
+        } else {
+          const b = u;
+          b.value > o && (o = b.value), b.value < e && (e = b.value), a == null || a.push(b.value);
+        }
+    }
+    if (e === 1 / 0 || o === -1 / 0) {
+      M(this, St, !1);
+      return;
+    }
+    if (e = this.resolveBound(h(this, H).min, e, o, a ?? [], "min"), o = this.resolveBound(h(this, H).max, o, e, a ?? [], "max"), !h(this, St) || t)
+      M(this, it, e), M(this, at, o), M(this, St, !0);
+    else {
+      M(this, it, h(this, it) + (e - h(this, it)) * 0.2), M(this, at, h(this, at) + (o - h(this, at)) * 0.2), e < h(this, it) && M(this, it, e), o > h(this, at) && M(this, at, o);
+      const c = Math.max(Math.abs(h(this, at) - h(this, it)) * 1e-4, 1e-3);
+      (Math.abs(h(this, it) - e) > c || Math.abs(h(this, at) - o) > c) && h(this, U).markDirty();
+    }
+    const s = h(this, H).min !== void 0 && h(this, H).min !== "auto", n = h(this, H).max !== void 0 && h(this, H).max !== "auto", l = h(this, E).size.media.height - this.xAxisHeight;
+    h(this, D).setYRange(h(this, it), h(this, at), l, s, n);
+  }
+  /** Resolve an {@link AxisBound} to a concrete numeric value. */
+  resolveBound(t, e, o, i, a) {
+    if (t === void 0 || t === "auto") return e;
+    if (typeof t == "number") return t;
+    if (typeof t == "function") return t(i);
+    const s = String(t).match(/^([+-]?)\s*(\d+(?:\.\d+)?)\s*%$/);
+    if (s) {
+      const n = s[1] === "-" ? -1 : 1, l = parseFloat(s[2]) / 100, c = Math.abs(o - e) || Math.abs(e) || 1;
+      return e + n * l * c * (a === "max" ? 1 : -1);
+    }
+    return e;
+  }
+  /**
+   * Lightweight scale sync: updates timeScale/yScale from current viewport state
+   * without advancing the Y smoothing animation. Called from the viewport 'change'
+   * handler so DOM axis components always read fresh coordinates on re-render.
+   */
+  syncScales() {
+    const t = h(this, E).size;
+    if (t.media.width === 0 || t.media.height === 0) return;
+    const e = t.media.width - this.yAxisWidth, o = t.media.height - this.xAxisHeight;
+    this.timeScale.update(h(this, D).visibleRange, e, t.horizontalPixelRatio), this.yScale.update(h(this, D).yRange, o, t.verticalPixelRatio);
+  }
+  updateScales(t = !1) {
+    const e = h(this, E).size;
+    if (e.media.width === 0 || e.media.height === 0) return;
+    const o = e.media.width - this.yAxisWidth, i = e.media.height - this.xAxisHeight;
+    this.timeScale.update(h(this, D).visibleRange, o, e.horizontalPixelRatio), this.yScale.update(h(this, D).yRange, i, e.verticalPixelRatio), this.updateYRange(t), this.yScale.update(h(this, D).yRange, i, e.verticalPixelRatio);
+  }
+  /** Expensive: background, grid, all series. Only on data/viewport/resize change. */
+  renderMain() {
+    const t = h(this, E).size;
+    if (!(t.media.width === 0 || t.media.height === 0)) {
+      h(this, D).tick(performance.now()) && h(this, U).markDirty(), this.updateScales(), h(this, E).useMainLayer((e) => {
+        const { context: o, bitmapSize: i } = e, a = (t.media.width - this.yAxisWidth) * t.horizontalPixelRatio, s = (t.media.height - this.xAxisHeight) * t.verticalPixelRatio;
+        o.clearRect(0, 0, i.width, i.height), o.save(), o.beginPath(), o.rect(0, 0, a, s), o.clip(), h(this, Bt) && Je(e, this.timeScale, this.yScale, h(this, V), h(this, ot));
+        for (const n of h(this, S))
+          n.visible && n.renderer.render({
+            scope: e,
+            timeScale: this.timeScale,
+            yScale: this.yScale,
+            theme: h(this, V),
+            dataInterval: h(this, ot)
+          });
+        o.restore();
+      });
+      for (const e of h(this, S))
+        if (e.renderer instanceof bt && e.renderer.needsAnimation) {
+          h(this, U).markDirty();
+          break;
+        }
+      this.renderOverlay();
+    }
+  }
+  /** Cheap overlay: crosshair, nearest-point dots, pulse animation. */
+  renderOverlay() {
+    const t = h(this, E).size;
+    if (t.media.width === 0 || t.media.height === 0) return;
+    let e = !1;
+    for (const o of h(this, S))
+      if (o.visible && o.renderer instanceof j && o.renderer.hasPulse) {
+        e = !0;
+        break;
+      }
+    if (h(this, E).useOverlayLayer((o) => {
+      if (!h(this, ht) && !e) return;
+      const i = (t.media.width - this.yAxisWidth) * t.horizontalPixelRatio, a = (t.media.height - this.xAxisHeight) * t.verticalPixelRatio;
+      if (o.context.save(), o.context.beginPath(), o.context.rect(0, 0, i, a), o.context.clip(), h(this, ht)) {
+        const s = h(this, ht).mediaX * t.horizontalPixelRatio, n = h(this, ht).mediaY * t.verticalPixelRatio;
+        Ne(o, s, n, h(this, V));
+        for (const l of h(this, S))
+          if (l.visible && l.renderer instanceof j) {
+            const c = l.renderer, d = c.getColors(), u = c.getStacking(), b = 4 * t.horizontalPixelRatio, v = [], C = [];
+            for (let g = 0; g < c.stores.length; g++) {
+              const p = c.stores[g].findNearest(h(this, ht).time, h(this, ot));
+              p ? (v.push(p.value), C.push(p.time)) : (v.push(0), C.push(0));
+            }
+            const w = [];
+            if (u === "off")
+              for (const g of v) w.push(g);
+            else {
+              let g = 0;
+              if (u === "percent")
+                for (const m of v) g += m;
+              let p = 0;
+              for (const m of v)
+                p += u === "percent" && g > 0 ? m / g * 100 : m, w.push(p);
+            }
+            for (let g = 0; g < c.stores.length; g++) {
+              if (C[g] === 0 || !c.stores[g].isVisible()) continue;
+              const p = d[g % d.length], m = this.timeScale.timeToBitmapX(C[g]), f = this.yScale.valueToBitmapY(w[g]);
+              o.context.beginPath(), o.context.arc(m, f, b + 3 * t.horizontalPixelRatio, 0, Math.PI * 2);
+              const y = p.startsWith("#") ? p + "40" : /^rgb\(/i.test(p) ? p.replace(/^rgb\((.*)\)$/i, "rgba($1, 0.25)") : p.replace(/[\d.]+\)\s*$/, "0.25)");
+              o.context.fillStyle = y, o.context.fill(), o.context.beginPath(), o.context.arc(m, f, b, 0, Math.PI * 2), o.context.fillStyle = p, o.context.fill();
+            }
+          }
+      }
+      for (const s of h(this, S))
+        s.visible && s.renderer instanceof j && s.renderer.hasPulse && s.renderer.drawPulseOverlay(
+          o.context,
+          this.timeScale,
+          this.yScale,
+          t.horizontalPixelRatio
+        );
+      o.context.restore();
+    }), e) {
+      const { from: o, to: i } = this.timeScale.getRange();
+      let a = !1;
+      for (const s of h(this, S))
+        if (!(!s.visible || !(s.renderer instanceof j) || !s.renderer.hasPulse)) {
+          for (const n of s.renderer.stores) {
+            const l = n.last();
+            if (l && l.time >= o && l.time <= i) {
+              a = !0;
+              break;
+            }
+          }
+          if (a) break;
+        }
+      a && h(this, Ct).markDirty();
+    }
+  }
+}
+E = /* @__PURE__ */ new WeakMap(), D = /* @__PURE__ */ new WeakMap(), U = /* @__PURE__ */ new WeakMap(), Ct = /* @__PURE__ */ new WeakMap(), _t = /* @__PURE__ */ new WeakMap(), S = /* @__PURE__ */ new WeakMap(), V = /* @__PURE__ */ new WeakMap(), Bt = /* @__PURE__ */ new WeakMap(), ot = /* @__PURE__ */ new WeakMap(), ht = /* @__PURE__ */ new WeakMap(), H = /* @__PURE__ */ new WeakMap(), lt = /* @__PURE__ */ new WeakMap(), Nt = /* @__PURE__ */ new WeakMap(), wt = /* @__PURE__ */ new WeakMap(), ut = /* @__PURE__ */ new WeakMap(), Dt = /* @__PURE__ */ new WeakMap(), yt = /* @__PURE__ */ new WeakMap(), kt = /* @__PURE__ */ new WeakSet(), /**
+* Return a series ID: use the provided hint if it's non-empty and not already taken,
+* otherwise generate a new auto ID. Auto-generated IDs never collide with each other
+* or with user-provided IDs because they use a monotonically increasing counter.
+*/
+zt = function(r) {
+  if (r && !h(this, S).some((e) => e.id === r))
+    return r;
+  let t;
+  do
+    t = `series_${++yo}`;
+  while (h(this, S).some((e) => e.id === t));
+  return t;
+}, Vt = /* @__PURE__ */ new WeakMap(), it = /* @__PURE__ */ new WeakMap(), at = /* @__PURE__ */ new WeakMap(), St = /* @__PURE__ */ new WeakMap();
+const wi = {
+  background: "#ffffff",
+  chartGradient: ["#ffffff", "#f5f6f8"],
+  typography: {
+    fontFamily: "'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif",
+    fontSize: 12,
+    axisFontSize: 10,
+    yFontSize: 11,
+    tooltipFontSize: 12
+  },
+  grid: {
+    color: "rgba(0, 0, 0, 0.06)",
+    style: "solid"
+  },
+  candlestick: {
+    upColor: "#089981",
+    downColor: "#f23645",
+    wickUpColor: "#089981",
+    wickDownColor: "#f23645"
+  },
+  line: {
+    color: "#2962FF",
+    width: 1,
+    areaTopColor: "rgba(41, 98, 255, 0.08)",
+    areaBottomColor: "rgba(41, 98, 255, 0.01)"
+  },
+  seriesColors: [
+    "#2962FF",
+    "#FF6D00",
+    "#089981",
+    "#AB47BC",
+    "#f23645",
+    "#E6A700",
+    "#43A047",
+    "#D81B60",
+    "#1E88E5",
+    "#7E57C2"
+  ],
+  bands: { upper: "#1E88E5", lower: "#D81B60" },
+  crosshair: {
+    color: "rgba(0, 0, 0, 0.2)",
+    labelBackground: "#4c525e",
+    labelTextColor: "#ffffff"
+  },
+  axis: { textColor: "#787b86" },
+  yLabel: {
+    upBackground: "#089981",
+    downBackground: "#f23645",
+    neutralBackground: "#4c525e",
+    textColor: "#ffffff"
+  },
+  tooltip: {
+    background: "rgba(255, 255, 255, 0.95)",
+    textColor: "#131722",
+    borderColor: "rgba(0, 0, 0, 0.1)"
+  }
+};
+function Co(r) {
+  return parseInt(r.slice(1, 3), 16) * 0.299 + parseInt(r.slice(3, 5), 16) * 0.587 + parseInt(r.slice(5, 7), 16) * 0.114 < 128;
+}
+function Y(r) {
+  var t, e, o, i, a, s, n, l, c, d, u, b, v, C, w, g, p, m, f, y, F, k, B, L, N, $, Q, G, pt;
+  const { background: J, name: Ft = "Custom", description: gt, fontUrl: mt = null } = r, X = Co(J), ze = X ? "#d1d4dc" : "#24292f", Pe = X ? "#787b86" : "#8b949e", ie = X ? "#26a69a" : "#2da44e", ae = X ? "#ef5350" : "#cf222e", Fe = X ? "#2962ff" : "#0969da", Le = X ? "rgba(42,46,57,0.6)" : "rgba(200,200,200,0.5)", Ie = X ? "rgba(150,150,150,0.5)" : "rgba(170,170,170,0.3)", se = X ? At(J, 0.1) : ve(J, 0.05), We = X ? Tt(J, 0.92) : Tt(J, 0.95), Ae = X ? Tt(At(J, 0.15), 0.6) : "rgba(200,200,200,0.5)", Ve = Ot, $t = ((t = r.candlestick) == null ? void 0 : t.upColor) ?? ie, Lt = ((e = r.candlestick) == null ? void 0 : e.downColor) ?? ae, Rt = ((o = r.line) == null ? void 0 : o.color) ?? Fe, re = ((i = r.tooltip) == null ? void 0 : i.textColor) ?? ze, Ye = ((a = r.axis) == null ? void 0 : a.textColor) ?? Pe, Ue = ((s = r.typography) == null ? void 0 : s.fontFamily) ?? Ve, Ee = {
+    background: J,
+    chartGradient: r.chartGradient ?? (X ? [At(J, 0.04), ve(J, 0.06)] : [At(J, 0.06), J]),
+    typography: {
+      fontFamily: Ue,
+      fontSize: ((n = r.typography) == null ? void 0 : n.fontSize) ?? 12,
+      axisFontSize: ((l = r.typography) == null ? void 0 : l.axisFontSize) ?? 10,
+      yFontSize: ((c = r.typography) == null ? void 0 : c.yFontSize) ?? 11,
+      tooltipFontSize: ((d = r.typography) == null ? void 0 : d.tooltipFontSize) ?? ((u = r.typography) == null ? void 0 : u.fontSize) ?? 12
+    },
+    grid: {
+      color: ((b = r.grid) == null ? void 0 : b.color) ?? Le,
+      style: ((v = r.grid) == null ? void 0 : v.style) ?? "dashed"
+    },
+    candlestick: {
+      upColor: $t,
+      downColor: Lt,
+      wickUpColor: ((C = r.candlestick) == null ? void 0 : C.wickUpColor) ?? $t,
+      wickDownColor: ((w = r.candlestick) == null ? void 0 : w.wickDownColor) ?? Lt
+    },
+    line: {
+      color: Rt,
+      width: ((g = r.line) == null ? void 0 : g.width) ?? 1,
+      areaTopColor: ((p = r.line) == null ? void 0 : p.areaTopColor) ?? Tt(Rt, 0.08),
+      areaBottomColor: ((m = r.line) == null ? void 0 : m.areaBottomColor) ?? Tt(Rt, 0.01)
+    },
+    seriesColors: r.seriesColors ?? [Rt, ie, ae],
+    bands: {
+      upper: ((f = r.bands) == null ? void 0 : f.upper) ?? Rt,
+      lower: ((y = r.bands) == null ? void 0 : y.lower) ?? Lt
+    },
+    crosshair: {
+      color: ((F = r.crosshair) == null ? void 0 : F.color) ?? Ie,
+      labelBackground: ((k = r.crosshair) == null ? void 0 : k.labelBackground) ?? se,
+      labelTextColor: ((B = r.crosshair) == null ? void 0 : B.labelTextColor) ?? re
+    },
+    axis: { textColor: Ye },
+    yLabel: {
+      upBackground: ((L = r.yLabel) == null ? void 0 : L.upBackground) ?? $t,
+      downBackground: ((N = r.yLabel) == null ? void 0 : N.downBackground) ?? Lt,
+      neutralBackground: (($ = r.yLabel) == null ? void 0 : $.neutralBackground) ?? se,
+      textColor: ((Q = r.yLabel) == null ? void 0 : Q.textColor) ?? "#ffffff"
+    },
+    tooltip: {
+      background: ((G = r.tooltip) == null ? void 0 : G.background) ?? We,
+      textColor: re,
+      borderColor: ((pt = r.tooltip) == null ? void 0 : pt.borderColor) ?? Ae
+    }
+  };
+  return { name: Ft, description: gt, fontUrl: mt, dark: X, theme: Ee };
+}
+function Tt(r, t) {
+  const e = parseInt(r.slice(1, 3), 16), o = parseInt(r.slice(3, 5), 16), i = parseInt(r.slice(5, 7), 16);
+  return `rgba(${e}, ${o}, ${i}, ${t})`;
+}
+function At(r, t) {
+  if (!r.startsWith("#")) return r;
+  const e = Math.min(255, Math.round(parseInt(r.slice(1, 3), 16) + 255 * t)), o = Math.min(255, Math.round(parseInt(r.slice(3, 5), 16) + 255 * t)), i = Math.min(255, Math.round(parseInt(r.slice(5, 7), 16) + 255 * t));
+  return `#${e.toString(16).padStart(2, "0")}${o.toString(16).padStart(2, "0")}${i.toString(16).padStart(2, "0")}`;
+}
+function ve(r, t) {
+  if (!r.startsWith("#")) return r;
+  const e = Math.max(0, Math.round(parseInt(r.slice(1, 3), 16) * (1 - t))), o = Math.max(0, Math.round(parseInt(r.slice(3, 5), 16) * (1 - t))), i = Math.max(0, Math.round(parseInt(r.slice(5, 7), 16) * (1 - t)));
+  return `#${e.toString(16).padStart(2, "0")}${o.toString(16).padStart(2, "0")}${i.toString(16).padStart(2, "0")}`;
+}
+const Ut = "'JetBrains Mono', 'Fira Code', monospace", Et = "https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;600&display=swap", Ot = "'Outfit', -apple-system, BlinkMacSystemFont, sans-serif", qt = "https://fonts.googleapis.com/css2?family=Outfit:wght@400;500;600&display=swap", Se = "'Roboto Mono', monospace", Me = "https://fonts.googleapis.com/css2?family=Roboto+Mono:wght@400;500;600&display=swap", wo = "'IBM Plex Mono', monospace", ko = "https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@400;500;600&display=swap", Qt = "'Fira Code', monospace", Zt = "https://fonts.googleapis.com/css2?family=Fira+Code:wght@400;500;600&display=swap", Re = "'Source Code Pro', monospace", Te = "https://fonts.googleapis.com/css2?family=Source+Code+Pro:wght@400;500;600&display=swap", So = "'Space Mono', monospace", Mo = "https://fonts.googleapis.com/css2?family=Space+Mono:wght@400;700&display=swap", te = "'Plus Jakarta Sans', sans-serif", ee = "https://fonts.googleapis.com/css2?family=Plus+Jakarta+Sans:wght@400;500;600;700&display=swap", Ro = "'Caveat', 'Comic Sans MS', cursive", To = "https://fonts.googleapis.com/css2?family=Caveat:wght@400;500;600;700&display=swap", _o = Y({
+  name: "Andromeda",
+  description: "Deep space purples and cosmic blues",
+  background: "#23262e",
+  grid: { color: "rgba(50,48,56,0.8)" },
+  candlestick: { upColor: "#96e072", downColor: "#ee5d43" },
+  line: { color: "#00e8c6" },
+  seriesColors: [
+    "#00e8c6",
+    "#f39c12",
+    "#96e072",
+    "#c74ded",
+    "#ee5d43",
+    "#ffe66d",
+    "#00e8c6",
+    "#ee5d43",
+    "#7cb7ff",
+    "#c74ded"
+  ],
+  bands: { upper: "#7cb7ff", lower: "#c74ded" },
+  crosshair: { color: "rgba(102,94,110,0.4)", labelBackground: "#2e3038" },
+  axis: { textColor: "#665e6e" },
+  tooltip: { background: "rgba(35,38,46,0.92)", textColor: "#d5ced9", borderColor: "rgba(50,48,56,0.6)" },
+  typography: { fontFamily: Se },
+  fontUrl: Me
+}), Bo = Y({
+  name: "Ayu Mirage",
+  description: "Warm dark with amber accents",
+  background: "#1f2430",
+  grid: { color: "rgba(42,48,60,0.8)" },
+  candlestick: { upColor: "#bae67e", downColor: "#f27983" },
+  line: { color: "#73d0ff" },
+  seriesColors: [
+    "#73d0ff",
+    "#ffad66",
+    "#bae67e",
+    "#d4bfff",
+    "#f27983",
+    "#ffd580",
+    "#95e6cb",
+    "#f28779",
+    "#5ccfe6",
+    "#d4bfff"
+  ],
+  bands: { upper: "#5ccfe6", lower: "#f28779" },
+  crosshair: { color: "rgba(92,103,115,0.4)", labelBackground: "#2a3040" },
+  axis: { textColor: "#5c6773" },
+  tooltip: { background: "rgba(31,36,48,0.92)", textColor: "#cbccc6", borderColor: "rgba(42,48,60,0.6)" },
+  typography: { fontFamily: Ot },
+  fontUrl: qt
+}), Do = Y({
+  name: "Catppuccin",
+  description: "Pastel tones on a mocha base",
+  background: "#1e1e2e",
+  grid: { color: "rgba(49,50,68,0.8)" },
+  candlestick: { upColor: "#a6e3a1", downColor: "#f38ba8" },
+  line: { color: "#89b4fa" },
+  seriesColors: [
+    "#89b4fa",
+    "#fab387",
+    "#a6e3a1",
+    "#cba6f7",
+    "#f38ba8",
+    "#f9e2af",
+    "#94e2d5",
+    "#eba0ac",
+    "#74c7ec",
+    "#cba6f7"
+  ],
+  bands: { upper: "#74c7ec", lower: "#f38ba8" },
+  crosshair: { color: "rgba(108,112,134,0.4)", labelBackground: "#313244" },
+  axis: { textColor: "#6c7086" },
+  tooltip: { background: "rgba(30,30,46,0.92)", textColor: "#cdd6f4", borderColor: "rgba(49,50,68,0.6)" },
+  typography: { fontFamily: Ot },
+  fontUrl: qt
+}), zo = Y({
+  name: "Dracula",
+  description: "Classic dark with vibrant highlights",
+  background: "#282a36",
+  grid: { color: "rgba(68,71,90,0.8)" },
+  candlestick: { upColor: "#45c868", downColor: "#d04848" },
+  line: { color: "#a080d8" },
+  seriesColors: [
+    "#a080d8",
+    "#d49858",
+    "#45c868",
+    "#d068a0",
+    "#d04848",
+    "#c8d070",
+    "#70c0d8",
+    "#d04848",
+    "#6272a4",
+    "#d068a0"
+  ],
+  bands: { upper: "#70c0d8", lower: "#d068a0" },
+  crosshair: { color: "rgba(98,114,164,0.4)", labelBackground: "#44475a" },
+  axis: { textColor: "#6272a4" },
+  tooltip: { background: "rgba(40,42,54,0.92)", textColor: "#f8f8f2", borderColor: "rgba(68,71,90,0.6)" },
+  typography: { fontFamily: Qt },
+  fontUrl: Zt
+}), Po = Y({
+  name: "GitHub Light",
+  description: "Clean and familiar, GitHub-inspired",
+  background: "#fafbfc",
+  chartGradient: ["#ffffff", "#fafbfc"],
+  grid: { color: "rgba(208,215,222,0.4)" },
+  candlestick: { upColor: "#2da44e", downColor: "#cf222e" },
+  line: { color: "#0969da", areaTopColor: "rgba(9,105,218,0.05)", areaBottomColor: "rgba(9,105,218,0.005)" },
+  seriesColors: [
+    "#0969da",
+    "#c4820e",
+    "#2da44e",
+    "#8250df",
+    "#cf222e",
+    "#c4820e",
+    "#0550ae",
+    "#cf222e",
+    "#2da44e",
+    "#8250df"
+  ],
+  bands: { upper: "#0550ae", lower: "#cf222e" },
+  crosshair: { color: "rgba(208,215,222,0.3)", labelBackground: "#f0f3f6" },
+  axis: { textColor: "#8b949e" },
+  tooltip: { background: "rgba(250,251,252,0.95)", textColor: "#24292f", borderColor: "rgba(216,222,228,0.5)" },
+  typography: { fontFamily: wo },
+  fontUrl: ko
+}), Fo = Y({
+  name: "Gruvbox",
+  description: "Retro warm with earthy tones",
+  background: "#282828",
+  grid: { color: "rgba(60,56,54,0.8)" },
+  candlestick: { upColor: "#b8bb26", downColor: "#fb4934" },
+  line: { color: "#83a598" },
+  seriesColors: [
+    "#83a598",
+    "#fe8019",
+    "#b8bb26",
+    "#d3869b",
+    "#fb4934",
+    "#fabd2f",
+    "#8ec07c",
+    "#fb4934",
+    "#458588",
+    "#d3869b"
+  ],
+  bands: { upper: "#83a598", lower: "#d3869b" },
+  crosshair: { color: "rgba(146,131,116,0.4)", labelBackground: "#3c3836" },
+  axis: { textColor: "#928374" },
+  tooltip: { background: "rgba(40,40,40,0.92)", textColor: "#ebdbb2", borderColor: "rgba(60,56,54,0.6)" },
+  typography: { fontFamily: Ut },
+  fontUrl: Et
+}), Lo = {
+  name: "Handwritten",
+  description: "Sketch-style with a personal touch",
+  fontUrl: To,
+  dark: !1,
+  theme: {
+    background: "#fdf5e6",
+    chartGradient: ["#fef6e3", "#fdf5e6"],
+    typography: {
+      fontFamily: Ro,
+      fontSize: 18,
+      axisFontSize: 13,
+      yFontSize: 15,
+      tooltipFontSize: 14
+    },
+    grid: {
+      color: "rgba(180,170,150,0.3)",
+      style: "dashed"
+    },
+    candlestick: {
+      upColor: "#7a9a5e",
+      downColor: "#b07060",
+      wickUpColor: "#7a9a5e",
+      wickDownColor: "#b07060"
+    },
+    line: {
+      color: "#6a8fa0",
+      width: 1,
+      areaTopColor: "rgba(106,143,160,0.08)",
+      areaBottomColor: "rgba(106,143,160,0.01)"
+    },
+    seriesColors: [
+      "#6a8fa0",
+      "#c09050",
+      "#7a9a5e",
+      "#8a7098",
+      "#b07060",
+      "#a09030",
+      "#508878",
+      "#a06878",
+      "#6888a0",
+      "#8870a0"
+    ],
+    bands: {
+      upper: "#6888a0",
+      lower: "#a06878"
+    },
+    crosshair: {
+      color: "rgba(160,152,128,0.3)",
+      labelBackground: "#f5edd8",
+      labelTextColor: "#5c5040"
+    },
+    axis: { textColor: "#a09880" },
+    yLabel: {
+      upBackground: "#7a9a5e",
+      downBackground: "#b07060",
+      neutralBackground: "#e8dcc8",
+      textColor: "#fdf5e6"
+    },
+    tooltip: {
+      background: "rgba(253,245,230,0.95)",
+      textColor: "#5c5040",
+      borderColor: "rgba(180,170,150,0.4)"
+    }
+  }
+}, Io = "'Silkscreen', cursive", Wo = "https://fonts.googleapis.com/css2?family=Silkscreen:wght@400;700&display=swap", Ao = Y({
+  name: "Matrix",
+  background: "#000000",
+  candlestick: { upColor: "#00ff41", downColor: "#00802a" },
+  line: { color: "#00ff41" },
+  seriesColors: [
+    "#00ff41",
+    "#00cc33",
+    "#00992a",
+    "#33ff66",
+    "#66ff88",
+    "#00e639",
+    "#00b830",
+    "#4dff78",
+    "#00ff41",
+    "#00cc33"
+  ],
+  bands: { upper: "#33ff66", lower: "#00802a" },
+  grid: { color: "rgba(0,255,65,0.06)" },
+  axis: { textColor: "#00cc33" },
+  crosshair: { color: "rgba(0,255,65,0.3)", labelBackground: "#0a1a0a" },
+  tooltip: { background: "rgba(0,10,0,0.95)", textColor: "#00ff41", borderColor: "rgba(0,255,65,0.2)" },
+  typography: { fontFamily: Io },
+  fontUrl: Wo,
+  chartGradient: ["#010a01", "#000000"]
+}), Vo = Y({
+  name: "Lavender Mist",
+  background: "#f5f0f4",
+  candlestick: { upColor: "#6b8e5e", downColor: "#b85468" },
+  line: { color: "#7c6bc4" },
+  seriesColors: [
+    "#7c6bc4",
+    "#d4885a",
+    "#6b8e5e",
+    "#c46b8e",
+    "#b85468",
+    "#8e7a4e",
+    "#4e8e8a",
+    "#b85468",
+    "#7c6bc4",
+    "#c46b8e"
+  ],
+  bands: { upper: "#4e8e8a", lower: "#b85468" },
+  grid: { color: "rgba(150,130,155,0.12)" },
+  axis: { textColor: "#9a88a0" },
+  crosshair: { color: "rgba(150,130,155,0.2)", labelBackground: "#ebe4e8" },
+  tooltip: { background: "rgba(245,240,244,0.95)", textColor: "#3a3050", borderColor: "rgba(150,130,155,0.25)" },
+  typography: { fontFamily: te },
+  fontUrl: ee,
+  chartGradient: ["#f8f4f7", "#f5f0f4"]
+}), Yo = Y({
+  name: "Love",
+  description: "Soft romantic pinks and roses",
+  background: "#fef7f8",
+  chartGradient: ["#fffafb", "#fef7f8"],
+  grid: { color: "rgba(200,160,175,0.25)" },
+  candlestick: { upColor: "#6a9a6e", downColor: "#c45070" },
+  line: { color: "#a05080" },
+  seriesColors: [
+    "#a05080",
+    "#d08850",
+    "#6a9a6e",
+    "#7868a8",
+    "#c45070",
+    "#c89040",
+    "#508890",
+    "#c45070",
+    "#a05080",
+    "#7868a8"
+  ],
+  bands: { upper: "#508890", lower: "#c45070" },
+  crosshair: { color: "rgba(180,140,155,0.3)", labelBackground: "#f0dce2" },
+  axis: { textColor: "#b08898" },
+  tooltip: { background: "rgba(253,242,244,0.95)", textColor: "#4a3040", borderColor: "rgba(200,160,175,0.35)" },
+  typography: { fontFamily: Ot },
+  fontUrl: qt
+}), Uo = Y({
+  name: "Material Palenight",
+  description: "Material Design in moonlit hues",
+  background: "#292d3e",
+  grid: { color: "rgba(55,59,75,0.8)" },
+  candlestick: { upColor: "#c3e88d", downColor: "#f07178" },
+  line: { color: "#82aaff" },
+  seriesColors: [
+    "#82aaff",
+    "#f78c6c",
+    "#c3e88d",
+    "#c792ea",
+    "#f07178",
+    "#ffcb6b",
+    "#89ddff",
+    "#ff5370",
+    "#82aaff",
+    "#c792ea"
+  ],
+  bands: { upper: "#89ddff", lower: "#f07178" },
+  crosshair: { color: "rgba(103,110,149,0.4)", labelBackground: "#34324a" },
+  axis: { textColor: "#676e95" },
+  tooltip: { background: "rgba(41,45,62,0.92)", textColor: "#a6accd", borderColor: "rgba(55,59,75,0.6)" },
+  typography: { fontFamily: Se },
+  fontUrl: Me
+}), Eo = "'Silkscreen', cursive", Oo = "https://fonts.googleapis.com/css2?family=Silkscreen:wght@400;700&display=swap", $o = Y({
+  name: "Monochrome",
+  description: "Pure black and white, pixel font",
+  background: "#ffffff",
+  chartGradient: ["#ffffff", "#fafafa"],
+  grid: { color: "rgba(0,0,0,0.06)", style: "solid" },
+  candlestick: { upColor: "#111111", downColor: "#bbbbbb" },
+  line: { color: "#111111" },
+  seriesColors: [
+    "#111111",
+    "#888888",
+    "#bbbbbb",
+    "#555555",
+    "#999999",
+    "#333333",
+    "#aaaaaa",
+    "#666666",
+    "#cccccc",
+    "#444444"
+  ],
+  bands: { upper: "#555555", lower: "#bbbbbb" },
+  crosshair: { color: "rgba(0,0,0,0.08)", labelBackground: "#f0f0f0" },
+  axis: { textColor: "#b0b0b0" },
+  tooltip: { background: "rgba(255,255,255,0.97)", textColor: "#222222", borderColor: "rgba(0,0,0,0.08)" },
+  typography: { fontFamily: Eo, tooltipFontSize: 9 },
+  fontUrl: Oo
+}), Xo = Y({
+  name: "Mint Breeze",
+  background: "#f6f5ee",
+  candlestick: { upColor: "#2e9070", downColor: "#d04848" },
+  line: { color: "#2a8a80" },
+  seriesColors: [
+    "#2a8a80",
+    "#d0884a",
+    "#2e9070",
+    "#7a68b0",
+    "#d04848",
+    "#a09040",
+    "#3a7a9a",
+    "#d04848",
+    "#2a8a80",
+    "#7a68b0"
+  ],
+  bands: { upper: "#3a7a9a", lower: "#d04848" },
+  grid: { color: "rgba(100,150,140,0.1)" },
+  axis: { textColor: "#80a098" },
+  crosshair: { color: "rgba(120,140,120,0.18)", labelBackground: "#ece8de" },
+  tooltip: { background: "rgba(246,245,238,0.95)", textColor: "#2a3530", borderColor: "rgba(130,140,115,0.2)" },
+  typography: { fontFamily: So },
+  fontUrl: Mo,
+  chartGradient: ["#f8f7f0", "#f6f5ee"]
+}), Ho = Y({
+  name: "Monokai Pro",
+  description: "Bold syntax colors on dark gray",
+  background: "#2d2a2e",
+  grid: { color: "rgba(64,60,62,0.8)" },
+  candlestick: { upColor: "#8ab862", downColor: "#d05470" },
+  line: { color: "#62b8c8" },
+  seriesColors: [
+    "#62b8c8",
+    "#d08050",
+    "#8ab862",
+    "#9080c8",
+    "#d05470",
+    "#d0b850",
+    "#62b8c8",
+    "#d05470",
+    "#8ab862",
+    "#9080c8"
+  ],
+  bands: { upper: "#62b8c8", lower: "#d05470" },
+  crosshair: { color: "rgba(114,112,114,0.4)", labelBackground: "#403e42" },
+  axis: { textColor: "#727072" },
+  tooltip: { background: "rgba(45,42,46,0.92)", textColor: "#fcfcfa", borderColor: "rgba(64,60,62,0.6)" },
+  typography: { fontFamily: Qt },
+  fontUrl: Zt
+}), Go = Y({
+  name: "Night Owl",
+  description: "Crafted for late-night coding",
+  background: "#011627",
+  grid: { color: "rgba(31,52,72,0.8)" },
+  candlestick: { upColor: "#7ec699", downColor: "#e06c75" },
+  line: { color: "#82aaff" },
+  seriesColors: [
+    "#82aaff",
+    "#d49a6a",
+    "#7ec699",
+    "#b48ead",
+    "#e06c75",
+    "#d4b568",
+    "#5fb3a1",
+    "#d47084",
+    "#6bc5e0",
+    "#b48ead"
+  ],
+  bands: { upper: "#6bc5e0", lower: "#d47084" },
+  crosshair: { color: "rgba(99,119,119,0.4)", labelBackground: "#1d3b53" },
+  axis: { textColor: "#495a5a" },
+  tooltip: { background: "rgba(1,22,39,0.92)", textColor: "#d6deeb", borderColor: "rgba(31,52,72,0.6)" },
+  typography: { fontFamily: Ut },
+  fontUrl: Et
+}), No = Y({
+  name: "One Dark Pro",
+  description: "Atom editor's iconic dark palette",
+  background: "#282c34",
+  grid: { color: "rgba(59,64,72,0.8)" },
+  candlestick: { upColor: "#98c379", downColor: "#e06c75" },
+  line: { color: "#61afef" },
+  seriesColors: [
+    "#61afef",
+    "#e5c07b",
+    "#98c379",
+    "#c678dd",
+    "#e06c75",
+    "#56b6c2",
+    "#d19a66",
+    "#be5046",
+    "#61afef",
+    "#c678dd"
+  ],
+  bands: { upper: "#56b6c2", lower: "#c678dd" },
+  crosshair: { color: "rgba(99,110,123,0.4)", labelBackground: "#3e4451" },
+  axis: { textColor: "#5c6370" },
+  tooltip: { background: "rgba(40,44,52,0.92)", textColor: "#abb2bf", borderColor: "rgba(59,64,72,0.6)" },
+  typography: { fontFamily: Ut },
+  fontUrl: Et
+}), Jo = Y({
+  name: "Panda",
+  description: "Playful neons on charcoal",
+  background: "#292a2b",
+  grid: { color: "rgba(58,58,60,0.8)" },
+  candlestick: { upColor: "#19f9d8", downColor: "#ff75b5" },
+  line: { color: "#6fc1ff" },
+  seriesColors: [
+    "#6fc1ff",
+    "#ffb86c",
+    "#19f9d8",
+    "#b084eb",
+    "#ff75b5",
+    "#ffcc95",
+    "#19f9d8",
+    "#ff4b82",
+    "#45a9f9",
+    "#b084eb"
+  ],
+  bands: { upper: "#45a9f9", lower: "#ff75b5" },
+  crosshair: { color: "rgba(117,117,117,0.4)", labelBackground: "#3a3a3c" },
+  axis: { textColor: "#757575" },
+  tooltip: { background: "rgba(41,42,43,0.92)", textColor: "#e6e6e6", borderColor: "rgba(58,58,60,0.6)" },
+  typography: { fontFamily: Qt },
+  fontUrl: Zt
+}), jo = Y({
+  name: "Peach Cream",
+  background: "#fef6f0",
+  candlestick: { upColor: "#5a9a68", downColor: "#d06848" },
+  line: { color: "#d07040" },
+  seriesColors: [
+    "#d07040",
+    "#5a9a68",
+    "#8a6aaa",
+    "#c0884a",
+    "#d06848",
+    "#4a8a9a",
+    "#9a7a4a",
+    "#d06848",
+    "#d07040",
+    "#8a6aaa"
+  ],
+  bands: { upper: "#4a8a9a", lower: "#d06848" },
+  grid: { color: "rgba(180,140,120,0.12)" },
+  axis: { textColor: "#b09080" },
+  crosshair: { color: "rgba(180,140,120,0.2)", labelBackground: "#f0e4d8" },
+  tooltip: { background: "rgba(254,246,240,0.95)", textColor: "#4a3028", borderColor: "rgba(180,140,120,0.25)" },
+  typography: { fontFamily: te },
+  fontUrl: ee,
+  chartGradient: ["#fff8f2", "#fef6f0"]
+}), Ko = Y({
+  name: "Quiet Light",
+  description: "Subdued and easy on the eyes",
+  background: "#f5f5f5",
+  grid: { color: "rgba(200,200,200,0.5)" },
+  candlestick: { upColor: "#448c27", downColor: "#aa3731" },
+  line: { color: "#4b69c6" },
+  seriesColors: [
+    "#4b69c6",
+    "#c47820",
+    "#448c27",
+    "#7a3e9d",
+    "#aa3731",
+    "#c47820",
+    "#2d8fa1",
+    "#aa3731",
+    "#448c27",
+    "#7a3e9d"
+  ],
+  bands: { upper: "#2d8fa1", lower: "#aa3731" },
+  crosshair: { color: "rgba(170,170,170,0.3)", labelBackground: "#e8e8e8" },
+  axis: { textColor: "#aaaaaa" },
+  tooltip: { background: "rgba(245,245,245,0.95)", textColor: "#333333", borderColor: "rgba(200,200,200,0.5)" },
+  typography: { fontFamily: te },
+  fontUrl: ee
+}), qo = Y({
+  name: "Rosé Pine Dawn",
+  description: "Dawn-inspired warm neutrals",
+  background: "#faf4ed",
+  grid: { color: "rgba(152,147,165,0.2)" },
+  candlestick: { upColor: "#56949f", downColor: "#b4637a" },
+  line: { color: "#907aa9" },
+  seriesColors: [
+    "#907aa9",
+    "#ea9d34",
+    "#56949f",
+    "#d7827e",
+    "#b4637a",
+    "#ea9d34",
+    "#286983",
+    "#b4637a",
+    "#907aa9",
+    "#d7827e"
+  ],
+  bands: { upper: "#286983", lower: "#b4637a" },
+  crosshair: { color: "rgba(152,147,165,0.3)", labelBackground: "#f2e9e1" },
+  axis: { textColor: "#9893a5" },
+  tooltip: { background: "rgba(250,244,237,0.95)", textColor: "#575279", borderColor: "rgba(152,147,165,0.3)" },
+  typography: { fontFamily: Re },
+  fontUrl: Te
+}), Qo = Y({
+  name: "Sand Dune",
+  background: "#f4f0e8",
+  candlestick: { upColor: "#5a8a50", downColor: "#b85040" },
+  line: { color: "#8a6a3a" },
+  seriesColors: [
+    "#8a6a3a",
+    "#b87a40",
+    "#5a8a50",
+    "#7a5a70",
+    "#b85040",
+    "#a09030",
+    "#4a7a7a",
+    "#b85040",
+    "#8a6a3a",
+    "#7a5a70"
+  ],
+  bands: { upper: "#4a7a7a", lower: "#b85040" },
+  grid: { color: "rgba(150,130,100,0.15)" },
+  axis: { textColor: "#9a8a70" },
+  crosshair: { color: "rgba(150,130,100,0.2)", labelBackground: "#e8e0d0" },
+  tooltip: { background: "rgba(244,240,232,0.95)", textColor: "#3a3020", borderColor: "rgba(150,130,100,0.3)" },
+  typography: { fontFamily: Re },
+  fontUrl: Te,
+  chartGradient: ["#f8f4ec", "#f4f0e8"]
+}), Zo = Y({
+  name: "Solarized Light",
+  description: "Ethan Schoonover's precision palette",
+  background: "#fdf6e3",
+  chartGradient: ["#fef8e8", "#fdf6e3"],
+  grid: { color: "rgba(238,232,213,0.8)" },
+  candlestick: { upColor: "#859900", downColor: "#dc322f" },
+  line: { color: "#268bd2" },
+  seriesColors: [
+    "#268bd2",
+    "#cb4b16",
+    "#859900",
+    "#6c71c4",
+    "#dc322f",
+    "#b58900",
+    "#2aa198",
+    "#d33682",
+    "#268bd2",
+    "#6c71c4"
+  ],
+  bands: { upper: "#2aa198", lower: "#d33682" },
+  crosshair: { color: "rgba(147,161,161,0.3)", labelBackground: "#eee8d5" },
+  axis: { textColor: "#93a1a1" },
+  tooltip: { background: "rgba(253,246,227,0.95)", textColor: "#586e75", borderColor: "rgba(238,232,213,0.6)" },
+  typography: { fontFamily: Ut },
+  fontUrl: Et
+}), ye = {
+  Dracula: zo,
+  "One Dark Pro": No,
+  "Monokai Pro": Ho,
+  "Night Owl": Go,
+  "Material Palenight": Uo,
+  Gruvbox: Fo,
+  Catppuccin: Do,
+  "Ayu Mirage": Bo,
+  Panda: Jo,
+  Andromeda: _o,
+  Matrix: Ao,
+  Handwritten: Lo,
+  "GitHub Light": Po,
+  "Solarized Light": Zo,
+  "Rosé Pine Dawn": qo,
+  "Quiet Light": Ko,
+  "Lavender Mist": Vo,
+  "Mint Breeze": Xo,
+  "Sand Dune": Qo,
+  "Peach Cream": jo,
+  Monochrome: $o,
+  Love: Yo
+};
+function ki(r) {
+  return (ye[r] ?? ye["One Dark Pro"]).theme;
+}
+const _e = Symbol("wick-chart"), Be = Symbol("wick-theme");
+function rt() {
+  const r = xe(_e);
+  if (!r || !r.value)
+    throw new Error("useChartInstance must be used within <ChartContainer>");
+  return r.value;
+}
+function ti() {
+  const r = xe(Be);
+  if (!r)
+    throw new Error("useTheme must be used within <ChartContainer>");
+  return r;
+}
+const Si = /* @__PURE__ */ Z({
+  __name: "BarSeries",
+  props: {
+    data: {},
+    options: {},
+    label: {}
+  },
+  emits: ["seriesId"],
+  setup(r, { emit: t }) {
+    const e = r, o = t, i = rt(), a = tt(null);
+    return q(() => {
+      var n;
+      const s = i.addBarSeries({ ...e.options, label: e.label ?? ((n = e.options) == null ? void 0 : n.label), layers: e.data.length });
+      a.value = s, o("seriesId", s);
+    }), et(() => {
+      a.value && i.removeSeries(a.value);
+    }), st(
+      () => e.data,
+      (s) => {
+        a.value && i.batch(() => {
+          for (let n = 0; n < s.length; n++)
+            i.setBarLayerData(a.value, n, s[n]);
+        });
+      }
+    ), st(
+      () => e.options,
+      (s) => {
+        a.value && s && i.updateSeriesOptions(a.value, s);
+      },
+      { deep: !0 }
+    ), (s, n) => K("", !0);
+  }
+}), Mi = /* @__PURE__ */ Z({
+  __name: "CandlestickSeries",
+  props: {
+    data: {},
+    options: {}
+  },
+  emits: ["seriesId"],
+  setup(r, { emit: t }) {
+    const e = r, o = t, i = rt(), a = tt(null);
+    let s = 0;
+    return q(() => {
+      const n = i.addCandlestickSeries(e.options);
+      a.value = n, o("seriesId", n);
+    }), et(() => {
+      a.value && i.removeSeries(a.value);
+    }), st(
+      () => e.data,
+      (n) => {
+        const l = a.value;
+        if (l) {
+          if (n.length === 0) {
+            i.setSeriesData(l, []), s = 0;
+            return;
+          }
+          if (s === 0 || n.length < s || n.length - s > 5)
+            i.setSeriesData(l, n);
+          else if (n.length === s)
+            i.updateData(l, n[n.length - 1]);
+          else
+            for (let c = s; c < n.length; c++)
+              i.appendData(l, n[c]);
+          s = n.length;
+        }
+      }
+    ), st(
+      () => e.options,
+      (n) => {
+        a.value && n && i.updateSeriesOptions(a.value, n);
+      },
+      { deep: !0 }
+    ), (n, l) => K("", !0);
+  }
+}), ei = {
+  key: 0,
+  style: { position: "absolute", inset: "0", "pointer-events": "none", "z-index": "2" }
+}, Ri = /* @__PURE__ */ Z({
+  __name: "ChartContainer",
+  props: {
+    theme: { default: () => ke },
+    axis: {}
+  },
+  setup(r) {
+    const t = r, e = tt(), o = ne(null), i = ne(t.theme);
+    le(_e, o), le(Be, i), q(() => {
+      if (!e.value) return;
+      const s = {};
+      t.axis && (s.axis = t.axis), t.theme && (s.theme = t.theme), o.value = new xo(e.value, s);
+    }), et(() => {
+      var s;
+      (s = o.value) == null || s.destroy(), o.value = null;
+    }), st(
+      () => t.theme,
+      (s) => {
+        o.value && s && (o.value.setTheme(s), i.value = s);
+      }
+    ), st(
+      () => t.axis,
+      (s) => {
+        o.value && s && o.value.setAxis(s);
+      },
+      { deep: !0 }
+    );
+    const a = P(() => {
+      const s = i.value, [n, l] = (s == null ? void 0 : s.chartGradient) ?? ["transparent", "transparent"], c = (s == null ? void 0 : s.background) ?? "transparent";
+      return `position: relative; width: 100%; height: 100%; overflow: hidden; background: linear-gradient(to bottom, ${n} 0%, ${c} 70%, ${l} 100%)`;
+    });
+    return (s, n) => (R(), T("div", {
+      ref_key: "containerRef",
+      ref: e,
+      style: z(a.value)
+    }, [
+      o.value ? (R(), T("div", ei, [
+        Oe(s.$slots, "default")
+      ])) : K("", !0)
+    ], 4));
+  }
+});
+function De(r) {
+  const t = tt(r.getVisibleRange()), e = () => {
+    t.value = r.getVisibleRange();
+  };
+  return q(() => r.on("viewportChange", e)), et(() => r.off("viewportChange", e)), t;
+}
+function Ti(r) {
+  const t = tt(r.getYRange()), e = () => {
+    t.value = r.getYRange();
+  };
+  return q(() => r.on("viewportChange", e)), et(() => r.off("viewportChange", e)), t;
+}
+function oi(r, t) {
+  const e = tt(r.getLastValue(t)), o = () => {
+    var a, s;
+    const i = r.getLastValue(t);
+    ((a = e.value) == null ? void 0 : a.value) === (i == null ? void 0 : i.value) && ((s = e.value) == null ? void 0 : s.isLive) === (i == null ? void 0 : i.isLive) || (e.value = i);
+  };
+  return q(() => {
+    r.on("dataUpdate", o), r.on("viewportChange", o);
+  }), et(() => {
+    r.off("dataUpdate", o), r.off("viewportChange", o);
+  }), e;
+}
+function ii(r, t) {
+  const e = tt(r.getPreviousClose(t)), o = () => {
+    e.value = r.getPreviousClose(t);
+  };
+  return q(() => r.on("dataUpdate", o)), et(() => r.off("dataUpdate", o)), e;
+}
+function oe(r) {
+  const t = tt(r.getCrosshairPosition()), e = () => {
+    t.value = r.getCrosshairPosition();
+  };
+  return q(() => r.on("crosshairMove", e)), et(() => r.off("crosshairMove", e)), t;
+}
+const _i = /* @__PURE__ */ Z({
+  __name: "LineSeries",
+  props: {
+    data: {},
+    options: {},
+    label: {}
+  },
+  emits: ["seriesId"],
+  setup(r, { emit: t }) {
+    const e = r, o = t, i = rt(), a = tt(null);
+    return q(() => {
+      var n;
+      const s = i.addLineSeries({ ...e.options, label: e.label ?? ((n = e.options) == null ? void 0 : n.label), layers: e.data.length });
+      a.value = s, o("seriesId", s);
+    }), et(() => {
+      a.value && i.removeSeries(a.value);
+    }), st(
+      () => e.data,
+      (s) => {
+        a.value && i.batch(() => {
+          for (let n = 0; n < s.length; n++)
+            i.setLineLayerData(a.value, n, s[n]);
+        });
+      }
+    ), st(
+      () => e.options,
+      (s) => {
+        a.value && s && i.updateSeriesOptions(a.value, s);
+      },
+      { deep: !0 }
+    ), (s, n) => K("", !0);
+  }
+}), Bi = /* @__PURE__ */ Z({
+  __name: "PieSeries",
+  props: {
+    data: {},
+    options: {}
+  },
+  emits: ["seriesId"],
+  setup(r, { emit: t }) {
+    const e = r, o = t, i = rt(), a = tt(null);
+    return q(() => {
+      const s = i.addPieSeries(e.options);
+      a.value = s, o("seriesId", s);
+    }), et(() => {
+      a.value && i.removeSeries(a.value);
+    }), st(
+      () => e.data,
+      (s) => {
+        a.value && s.length > 0 && i.setPieData(a.value, s);
+      }
+    ), st(
+      () => e.options,
+      (s) => {
+        a.value && s && i.updateSeriesOptions(a.value, s);
+      },
+      { deep: !0 }
+    ), (s, n) => K("", !0);
+  }
+}), Di = /* @__PURE__ */ Z({
+  __name: "Crosshair",
+  setup(r) {
+    const t = rt(), e = oe(t), o = P(() => t.getTheme()), i = P(() => t.getDataInterval()), a = P(() => ({
+      background: o.value.crosshair.labelBackground,
+      color: o.value.crosshair.labelTextColor,
+      fontSize: o.value.typography.axisFontSize + "px",
+      fontFamily: o.value.typography.fontFamily,
+      padding: "2px 6px",
+      borderRadius: "2px",
+      whiteSpace: "nowrap",
+      pointerEvents: "none"
+    }));
+    return (s, n) => W(e) ? (R(), T(O, { key: 0 }, [
+      _("div", {
+        style: z({
+          position: "absolute",
+          right: "0",
+          top: W(e).mediaY + "px",
+          transform: "translateY(-50%)",
+          ...a.value
+        })
+      }, I(W(t).yScale.formatY(W(e).y)), 5),
+      _("div", {
+        style: z({
+          position: "absolute",
+          bottom: "0",
+          left: W(e).mediaX + "px",
+          transform: "translateX(-50%)",
+          ...a.value
+        })
+      }, I(W(Yt)(W(e).time, i.value)), 5)
+    ], 64)) : K("", !0);
+  }
+}), ai = { style: {
+  display: "inline-flex",
+  fontVariantNumeric: "tabular-nums",
+  lineHeight: 1.2
+} }, si = {
+  key: 0,
+  style: {
+    display: "inline-block",
+    height: "1.2em",
+    overflow: "hidden",
+    position: "relative"
+  }
+}, ri = {
+  key: 1,
+  style: { display: "inline-block" }
+}, ni = /* @__PURE__ */ Z({
+  __name: "NumberFlow",
+  props: {
+    value: {},
+    format: {},
+    locale: { default: "en-US" },
+    spinDuration: { default: 350 }
+  },
+  setup(r) {
+    const t = r, e = tt(!1);
+    q(() => {
+      e.value = !0;
+    });
+    const o = P(() => new Intl.NumberFormat(t.locale, t.format)), i = P(() => {
+      const s = o.value.format(t.value), n = [];
+      for (const l of s)
+        l >= "0" && l <= "9" ? n.push({ type: "digit", value: l }) : n.push({ type: "symbol", value: l });
+      return n;
+    }), a = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"];
+    return (s, n) => (R(), T("span", ai, [
+      (R(!0), T(O, null, ct(i.value, (l, c) => (R(), T(O, { key: c }, [
+        l.type === "digit" ? (R(), T("span", si, [
+          _("span", {
+            style: z({
+              display: "flex",
+              flexDirection: "column",
+              transform: "translateY(" + -parseInt(l.value) * 1.2 + "em)",
+              transition: e.value ? "transform " + r.spinDuration + "ms cubic-bezier(0.16, 1, 0.3, 1)" : "none"
+            })
+          }, [
+            (R(), T(O, null, ct(a, (d) => _("span", {
+              key: d,
+              style: {
+                display: "flex",
+                alignItems: "center",
+                justifyContent: "center",
+                height: "1.2em"
+              }
+            }, I(d), 1)), 64))
+          ], 4)
+        ])) : (R(), T("span", ri, I(l.value), 1))
+      ], 64))), 128))
+    ]));
+  }
+}), li = { style: { flex: 1, opacity: 0.8 } }, hi = {
+  key: 0,
+  style: { fontWeight: 600, fontVariantNumeric: "tabular-nums" }
+}, zi = /* @__PURE__ */ Z({
+  __name: "PieLegend",
+  props: {
+    seriesId: {},
+    format: { default: "value" }
+  },
+  setup(r) {
+    const t = r, e = rt(), o = ti(), i = tt(0), a = () => {
+      i.value++;
+    };
+    q(() => {
+      e.on("dataUpdate", a);
+    }), et(() => {
+      e.off("dataUpdate", a);
+    });
+    const s = P(() => o.value), n = P(() => (i.value, e.getPieSlices(t.seriesId) ?? []));
+    function l(c) {
+      return c >= 1e9 ? (c / 1e9).toFixed(1) + "B" : c >= 1e6 ? (c / 1e6).toFixed(1) + "M" : c >= 1e3 ? (c / 1e3).toFixed(1) + "K" : c.toLocaleString();
+    }
+    return (c, d) => n.value.length > 0 ? (R(), T("div", {
+      key: 0,
+      style: z({
+        display: "flex",
+        flexDirection: "column",
+        gap: "6px",
+        padding: "8px 12px",
+        fontFamily: s.value.typography.fontFamily,
+        fontSize: s.value.typography.fontSize + "px",
+        color: s.value.tooltip.textColor,
+        pointerEvents: "auto"
+      })
+    }, [
+      (R(!0), T(O, null, ct(n.value, (u, b) => (R(), T("div", {
+        key: b,
+        style: { display: "flex", alignItems: "center", gap: "10px" }
+      }, [
+        _("span", {
+          style: z({ width: "10px", height: "10px", borderRadius: "50%", background: u.color, flexShrink: 0 })
+        }, null, 4),
+        _("span", li, I(u.label), 1),
+        r.format === "value" ? (R(), T("span", hi, I(l(u.value)), 1)) : K("", !0),
+        _("span", {
+          style: z({
+            opacity: r.format === "percent" ? 1 : 0.5,
+            fontWeight: r.format === "percent" ? 600 : 400,
+            fontSize: (r.format === "percent" ? s.value.typography.fontSize : s.value.typography.axisFontSize) + "px",
+            fontVariantNumeric: "tabular-nums",
+            minWidth: "40px",
+            textAlign: "right"
+          })
+        }, I(u.percent.toFixed(1)) + "% ", 5)
+      ]))), 128))
+    ], 4)) : K("", !0);
+  }
+}), ci = { style: { display: "flex", alignItems: "center", gap: "8px" } }, di = { style: { fontWeight: 600 } }, ui = { style: { display: "flex", justifyContent: "space-between", gap: "16px" } }, fi = { style: { opacity: 0.6 } }, pi = { style: { fontWeight: 600 } }, Pi = /* @__PURE__ */ Z({
+  __name: "PieTooltip",
+  props: {
+    seriesId: {}
+  },
+  setup(r) {
+    const t = r, e = rt(), o = oe(e), i = P(() => e.getTheme()), a = P(() => (o.value, e.getPieHoverInfo(t.seriesId))), s = P(() => {
+      if (!o.value || !a.value) return null;
+      const n = e.getMediaSize(), l = 160, c = 70, d = 16, u = 16, b = o.value.mediaX + d + l > n.width ? o.value.mediaX - d - l : o.value.mediaX + d, v = o.value.mediaY + u + c > n.height ? o.value.mediaY - u - c : o.value.mediaY + u;
+      return { left: b, top: v };
+    });
+    return (n, l) => a.value && W(o) && s.value ? (R(), T("div", {
+      key: 0,
+      style: z({
+        position: "absolute",
+        left: s.value.left + "px",
+        top: s.value.top + "px",
+        pointerEvents: "none",
+        background: i.value.tooltip.background,
+        backdropFilter: "blur(12px)",
+        WebkitBackdropFilter: "blur(12px)",
+        border: "1px solid " + i.value.tooltip.borderColor,
+        borderRadius: "8px",
+        padding: "10px 14px",
+        boxShadow: "0 4px 16px rgba(0,0,0,0.1), 0 1px 4px rgba(0,0,0,0.06)",
+        fontSize: i.value.typography.fontSize + "px",
+        fontFamily: i.value.typography.fontFamily,
+        color: i.value.tooltip.textColor,
+        zIndex: 10,
+        display: "flex",
+        flexDirection: "column",
+        gap: "6px"
+      })
+    }, [
+      _("div", ci, [
+        _("span", {
+          style: z({
+            width: "10px",
+            height: "10px",
+            borderRadius: "50%",
+            background: a.value.color,
+            flexShrink: 0
+          })
+        }, null, 4),
+        _("span", di, I(a.value.label), 1)
+      ]),
+      _("div", ui, [
+        _("span", fi, I(a.value.value.toLocaleString()), 1),
+        _("span", pi, I(a.value.percent.toFixed(1)) + "%", 1)
+      ])
+    ], 4)) : K("", !0);
+  }
+}), Fi = /* @__PURE__ */ Z({
+  __name: "TimeAxis",
+  setup(r) {
+    const t = rt(), e = De(t), o = /* @__PURE__ */ new Map(), i = P(() => t.getTheme()), a = P(() => {
+      e.value;
+      const s = t.getDataInterval(), { ticks: n, tickInterval: l } = t.timeScale.niceTickValues(s), c = new Set(n), d = performance.now();
+      for (const u of n)
+        o.has(u) ? o.get(u).opacity = 1 : o.set(u, { opacity: 1, addedAt: d });
+      for (const [u, b] of o)
+        c.has(u) || (b.opacity = 0);
+      for (const [u, b] of o)
+        b.opacity === 0 && d - b.addedAt > 5e3 && o.delete(u);
+      return {
+        allTicks: Array.from(o.entries()),
+        tickInterval: l
+      };
+    });
+    return (s, n) => (R(), T("div", {
+      style: z({
+        position: "absolute",
+        left: "0",
+        bottom: "0",
+        right: W(t).yAxisWidth + "px",
+        height: W(t).xAxisHeight + "px",
+        pointerEvents: "none",
+        display: "flex",
+        alignItems: "center"
+      })
+    }, [
+      (R(!0), T(O, null, ct(a.value.allTicks, ([l, c]) => (R(), T("span", {
+        key: l,
+        style: z({
+          position: "absolute",
+          left: W(t).timeScale.timeToX(l) + "px",
+          transform: "translateX(-50%)",
+          color: i.value.axis.textColor,
+          fontSize: i.value.typography.axisFontSize + "px",
+          fontFamily: i.value.typography.fontFamily,
+          userSelect: "none",
+          whiteSpace: "nowrap",
+          opacity: c.opacity,
+          transition: "opacity 0.3s ease",
+          willChange: "opacity"
+        })
+      }, I(W(Yt)(l, a.value.tickInterval)), 5))), 128))
+    ], 4));
+  }
+}), gi = {
+  key: 0,
+  style: { display: "inline-flex", alignItems: "center", gap: "4px" }
+}, mi = {
+  key: 1,
+  style: { display: "inline-flex", alignItems: "center", gap: "3px" }
+}, bi = {
+  key: 0,
+  style: { display: "grid", gridTemplateColumns: "auto 1fr", gap: "4px 12px" }
+}, vi = { style: { opacity: 0.5 } }, yi = {
+  key: 1,
+  style: { display: "flex", alignItems: "center", gap: "8px", padding: "2px 0" }
+}, xi = { style: { opacity: 0.6, flex: "1" } }, Li = /* @__PURE__ */ Z({
+  __name: "Tooltip",
+  props: {
+    seriesId: {},
+    sort: { default: "none" }
+  },
+  setup(r) {
+    const t = r, e = rt(), o = oe(e), i = P(() => t.seriesId ? [t.seriesId] : e.getSeriesIds()), a = P(() => i.value[0] ?? ""), s = tt(
+      a.value ? e.getLastValue(a.value) : null
+    ), n = () => {
+      const p = a.value;
+      s.value = p ? e.getLastValue(p) : null;
+    };
+    q(() => e.on("dataUpdate", n)), et(() => e.off("dataUpdate", n)), st(a, () => n());
+    const l = P(() => e.getTheme()), c = P(() => e.getDataInterval());
+    function d(p, m) {
+      return m === "none" || p.length <= 1 ? p : [...p].sort((f, y) => {
+        const F = "value" in f.data ? f.data.value : f.data.close, k = "value" in y.data ? y.data.value : y.data.close;
+        return m === "asc" ? F - k : k - F;
+      });
+    }
+    function u(p) {
+      return p >= 1e9 ? (p / 1e9).toFixed(2) + "B" : p >= 1e6 ? (p / 1e6).toFixed(2) + "M" : p >= 1e3 ? (p / 1e3).toFixed(1) + "K" : p.toFixed(0);
+    }
+    const b = P(() => {
+      if (!o.value) return [];
+      const p = [];
+      for (const m of i.value) {
+        const f = e.getDataAtTime(m, o.value.time);
+        f && p.push({
+          id: m,
+          label: e.getSeriesLabel(m),
+          data: f,
+          color: e.getSeriesColor(m) ?? "#888"
+        });
+      }
+      return p;
+    }), v = P(() => {
+      if (s.value, b.value.length > 0)
+        return d(b.value, t.sort);
+      const p = [];
+      for (const m of i.value) {
+        const f = e.getLastData(m);
+        f && p.push({
+          id: m,
+          label: e.getSeriesLabel(m),
+          data: f,
+          color: e.getSeriesColor(m) ?? "#888"
+        });
+      }
+      return d(p, t.sort);
+    }), C = P(() => v.value.length === 0 ? 0 : v.value[0].data.time), w = P(() => {
+      if (!o.value || b.value.length === 0) return null;
+      const p = e.getMediaSize(), m = b.value.some((G) => "open" in G.data), f = b.value.filter((G) => !("open" in G.data)).length, y = 160, F = m ? 140 : 40 + f * 22, k = 16, B = 16, L = p.width - e.yAxisWidth, N = p.height - e.xAxisHeight, $ = o.value.mediaX + k + y > L ? o.value.mediaX - k - y : o.value.mediaX + k, Q = o.value.mediaY + B + F > N ? o.value.mediaY - B - F : o.value.mediaY + B;
+      return { left: $, top: Q };
+    });
+    function g(p) {
+      return "open" in p;
+    }
+    return (p, m) => v.value.length > 0 ? (R(), T(O, { key: 0 }, [
+      _("div", {
+        style: z({
+          position: "absolute",
+          top: "24px",
+          left: "8px",
+          pointerEvents: "none",
+          display: "flex",
+          alignItems: "center",
+          gap: "4px",
+          flexWrap: "wrap",
+          maxWidth: "70%",
+          fontSize: l.value.typography.fontSize + "px",
+          fontFamily: l.value.typography.fontFamily,
+          fontVariantNumeric: "tabular-nums",
+          opacity: W(o) ? 1 : 0.6,
+          transition: "opacity 0.2s ease"
+        })
+      }, [
+        _("span", {
+          style: z({ color: l.value.axis.textColor, marginRight: "2px" })
+        }, I(W(Yt)(C.value, c.value)), 5),
+        (R(!0), T(O, null, ct(v.value, (f) => (R(), T(O, {
+          key: f.id
+        }, [
+          g(f.data) ? (R(), T("span", gi, [
+            (R(), T(O, null, ct(["O", "H", "L", "C"], (y) => (R(), T(O, { key: y }, [
+              _("span", {
+                style: z({ color: l.value.axis.textColor, opacity: 0.5, marginLeft: "5px" })
+              }, I(y), 5),
+              _("span", {
+                style: z({
+                  color: f.data.close >= f.data.open ? l.value.candlestick.upColor : l.value.candlestick.downColor,
+                  fontWeight: 500,
+                  marginLeft: "2px"
+                })
+              }, I({ O: f.data.open, H: f.data.high, L: f.data.low, C: f.data.close }[y].toFixed(2)), 5)
+            ], 64))), 64)),
+            f.data.volume != null ? (R(), T(O, { key: 0 }, [
+              _("span", {
+                style: z({ color: l.value.axis.textColor, opacity: 0.5, marginLeft: "5px" })
+              }, "V", 4),
+              _("span", {
+                style: z({ color: l.value.axis.textColor, fontWeight: 500, marginLeft: "2px" })
+              }, I(u(f.data.volume)), 5)
+            ], 64)) : K("", !0)
+          ])) : (R(), T("span", mi, [
+            _("span", {
+              style: z({
+                width: "6px",
+                height: "6px",
+                borderRadius: "50%",
+                background: f.color,
+                flexShrink: 0
+              })
+            }, null, 4),
+            _("span", {
+              style: z({ color: f.color, fontWeight: 500 })
+            }, I(f.data.value.toFixed(2)), 5)
+          ]))
+        ], 64))), 128))
+      ], 4),
+      W(o) && b.value.length > 0 && w.value ? (R(), T("div", {
+        key: 0,
+        style: z({
+          position: "absolute",
+          left: w.value.left + "px",
+          top: w.value.top + "px",
+          pointerEvents: "none",
+          background: l.value.tooltip.background,
+          backdropFilter: "blur(12px)",
+          WebkitBackdropFilter: "blur(12px)",
+          border: "1px solid " + l.value.tooltip.borderColor,
+          borderRadius: "8px",
+          padding: "10px 14px",
+          boxShadow: "0 4px 16px rgba(0,0,0,0.1), 0 1px 4px rgba(0,0,0,0.06)",
+          fontSize: l.value.typography.tooltipFontSize + "px",
+          fontFamily: l.value.typography.fontFamily,
+          fontVariantNumeric: "tabular-nums",
+          color: l.value.tooltip.textColor,
+          minWidth: "140px",
+          zIndex: 10,
+          transition: "opacity 0.15s ease"
+        })
+      }, [
+        _("div", {
+          style: z({
+            fontSize: l.value.typography.axisFontSize + "px",
+            color: l.value.axis.textColor,
+            marginBottom: "8px",
+            paddingBottom: "6px",
+            borderBottom: "1px solid " + l.value.tooltip.borderColor,
+            letterSpacing: "0.02em"
+          })
+        }, I(W(oo)(C.value)) + " " + I(W(Yt)(C.value, c.value)), 5),
+        (R(!0), T(O, null, ct(v.value, (f) => (R(), T(O, {
+          key: f.id
+        }, [
+          g(f.data) ? (R(), T("div", bi, [
+            (R(!0), T(O, null, ct([
+              { label: "Open", val: f.data.open },
+              { label: "High", val: f.data.high },
+              { label: "Low", val: f.data.low },
+              { label: "Close", val: f.data.close }
+            ], (y) => (R(), T(O, {
+              key: y.label
+            }, [
+              _("span", vi, I(y.label), 1),
+              _("span", {
+                style: z({
+                  fontWeight: 600,
+                  color: f.data.close >= f.data.open ? l.value.candlestick.upColor : l.value.candlestick.downColor,
+                  textAlign: "right"
+                })
+              }, I(y.val.toFixed(2)), 5)
+            ], 64))), 128)),
+            f.data.volume != null ? (R(), T(O, { key: 0 }, [
+              m[0] || (m[0] = _("span", { style: { opacity: 0.5 } }, "Volume", -1)),
+              _("span", {
+                style: z({ fontWeight: 600, color: l.value.tooltip.textColor, textAlign: "right" })
+              }, I(u(f.data.volume)), 5)
+            ], 64)) : K("", !0)
+          ])) : (R(), T("div", yi, [
+            _("span", {
+              style: z({
+                width: "8px",
+                height: "8px",
+                borderRadius: "50%",
+                background: f.color,
+                flexShrink: 0
+              })
+            }, null, 4),
+            _("span", xi, I(f.label ?? "Value"), 1),
+            _("span", {
+              style: z({ fontWeight: 600, color: f.color })
+            }, I(f.data.value.toFixed(2)), 5)
+          ]))
+        ], 64))), 128))
+      ], 4)) : K("", !0)
+    ], 64)) : K("", !0);
+  }
+}), Ii = /* @__PURE__ */ Z({
+  __name: "YAxis",
+  setup(r) {
+    const t = rt(), e = De(t), o = /* @__PURE__ */ new Map(), i = P(() => t.getTheme()), a = P(() => {
+      e.value;
+      const s = t.yScale.niceTickValues(), n = new Set(s), l = performance.now();
+      for (const c of s)
+        o.has(c) ? o.get(c).opacity = 1 : o.set(c, { opacity: 1, addedAt: l });
+      for (const [c, d] of o)
+        n.has(c) || (d.opacity = 0);
+      for (const [c, d] of o)
+        d.opacity === 0 && l - d.addedAt > 5e3 && o.delete(c);
+      return Array.from(o.entries());
+    });
+    return (s, n) => (R(), T("div", {
+      style: z({
+        position: "absolute",
+        right: "0",
+        top: "0",
+        bottom: W(t).xAxisHeight + "px",
+        width: W(t).yAxisWidth + "px",
+        pointerEvents: "none"
+      })
+    }, [
+      (R(!0), T(O, null, ct(a.value, ([l, c]) => (R(), T("span", {
+        key: l,
+        style: z({
+          position: "absolute",
+          right: "8px",
+          top: W(t).yScale.valueToY(l) + "px",
+          transform: "translateY(-50%)",
+          color: i.value.axis.textColor,
+          fontSize: i.value.typography.axisFontSize + "px",
+          fontFamily: i.value.typography.fontFamily,
+          fontVariantNumeric: "tabular-nums",
+          userSelect: "none",
+          opacity: c.opacity,
+          transition: "opacity 0.3s ease",
+          willChange: "opacity"
+        })
+      }, I(W(t).yScale.formatY(l)), 5))), 128))
+    ], 4));
+  }
+}), Wi = /* @__PURE__ */ Z({
+  __name: "YLabel",
+  props: {
+    seriesId: {},
+    color: {}
+  },
+  setup(r) {
+    const t = r, e = rt(), o = oi(e, t.seriesId), i = ii(e, t.seriesId);
+    q(() => e.setYLabel(!0)), et(() => e.setYLabel(!1));
+    const a = P(() => e.getTheme()), s = P(() => {
+      const d = o.value;
+      return d === null ? 0 : e.yScale.valueToY(d.value);
+    }), n = P(() => {
+      if (t.color) return t.color;
+      const d = a.value, u = o.value;
+      return i.value === null || u === null ? d.yLabel.neutralBackground : u.value > i.value ? d.yLabel.upBackground : u.value < i.value ? d.yLabel.downBackground : d.yLabel.neutralBackground;
+    }), l = P(() => {
+      const d = e.yScale.getRange(), u = d.max - d.min;
+      return u < 0.1 ? 6 : u < 10 ? 4 : u < 1e3 ? 2 : 0;
+    }), c = P(() => ({
+      minimumFractionDigits: l.value,
+      maximumFractionDigits: l.value,
+      useGrouping: !1
+    }));
+    return (d, u) => W(o) !== null ? (R(), T(O, { key: 0 }, [
+      _("div", {
+        style: z({
+          position: "absolute",
+          left: "0",
+          right: W(e).yAxisWidth + "px",
+          top: s.value + "px",
+          height: "0",
+          borderTop: "1px dashed " + n.value,
+          opacity: 0.5,
+          pointerEvents: "none",
+          zIndex: 2
+        })
+      }, null, 4),
+      _("div", {
+        style: z({
+          position: "absolute",
+          right: "4px",
+          top: s.value + "px",
+          transform: "translateY(-50%)",
+          pointerEvents: "auto",
+          zIndex: 3,
+          background: n.value,
+          color: a.value.yLabel.textColor,
+          fontSize: a.value.typography.yFontSize + "px",
+          fontFamily: a.value.typography.fontFamily,
+          padding: "3px 8px",
+          borderRadius: "3px",
+          whiteSpace: "nowrap",
+          transition: "background-color 0.3s ease"
+        })
+      }, [
+        $e(ni, {
+          value: W(o).value,
+          format: c.value,
+          "spin-duration": 350
+        }, null, 8, ["value", "format"])
+      ], 4)
+    ], 64)) : K("", !0);
+  }
+});
+export {
+  Si as BarSeries,
+  Mi as CandlestickSeries,
+  Ri as ChartContainer,
+  xo as ChartInstance,
+  Di as Crosshair,
+  _i as LineSeries,
+  ni as NumberFlow,
+  zi as PieLegend,
+  Bi as PieSeries,
+  Pi as PieTooltip,
+  Fi as TimeAxis,
+  Li as Tooltip,
+  Ii as YAxis,
+  Wi as YLabel,
+  _o as andromeda,
+  Bo as ayuMirage,
+  ki as buildTheme,
+  Do as catppuccin,
+  Y as createTheme,
+  ke as darkTheme,
+  eo as detectInterval,
+  zo as dracula,
+  oo as formatDate,
+  Yt as formatTime,
+  Po as githubLight,
+  Fo as gruvbox,
+  Lo as handwritten,
+  Ao as highContrast,
+  Vo as lavenderMist,
+  Yo as lightPink,
+  wi as lightTheme,
+  Uo as materialPalenight,
+  $o as minimalLight,
+  Xo as mintBreeze,
+  Ho as monokaiPro,
+  Go as nightOwl,
+  fe as normalizeTime,
+  No as oneDarkPro,
+  Jo as panda,
+  jo as peachCream,
+  Ko as quietLight,
+  qo as rosePineDawn,
+  Qo as sandDune,
+  Zo as solarizedLight,
+  ye as themes,
+  rt as useChartInstance,
+  oe as useCrosshairPosition,
+  oi as useLastYValue,
+  ii as usePreviousClose,
+  ti as useTheme,
+  De as useVisibleRange,
+  Ti as useYRange
+};