@wick-charts/react 0.1.0

package/dist/index.js

@@ -0,0 +1,3807 @@
+import { createContext as ye, useContext as Gt, useRef as et, useLayoutEffect as it, useEffect as j, useState as Rt, Children as Ye, isValidElement as _e, useMemo as dt, useSyncExternalStore as Tt } from "react";
+import { jsx as S, jsxs as F, Fragment as Dt } from "react/jsx-runtime";
+var Ue = Object.defineProperty, xe = (r) => {
+  throw TypeError(r);
+}, Ee = (r, t, i) => t in r ? Ue(r, t, { enumerable: !0, configurable: !0, writable: !0, value: i }) : r[t] = i, w = (r, t, i) => Ee(r, typeof t != "symbol" ? t + "" : t, i), Nt = (r, t, i) => t.has(r) || xe("Cannot " + i), c = (r, t, i) => (Nt(r, t, "read from private field"), i ? i.call(r) : t.get(r)), L = (r, t, i) => t.has(r) ? xe("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(r) : t.set(r, i), R = (r, t, i, e) => (Nt(r, t, "write to private field"), t.set(r, i), i), Ft = (r, t, i) => (Nt(r, t, "access private method"), i), ne = (r, t, i, e) => ({
+  set _(a) {
+    R(r, t, a);
+  },
+  get _() {
+    return c(r, t, e);
+  }
+});
+class Bt {
+  constructor() {
+    w(this, "listeners", /* @__PURE__ */ new Map());
+  }
+  on(t, i) {
+    let e = this.listeners.get(t);
+    e || (e = /* @__PURE__ */ new Set(), this.listeners.set(t, e)), e.add(i);
+  }
+  off(t, i) {
+    var e;
+    (e = this.listeners.get(t)) == null || e.delete(i);
+  }
+  emit(t, ...i) {
+    var e;
+    (e = this.listeners.get(t)) == null || e.forEach((a) => a(...i));
+  }
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+}
+function le(r, t, i) {
+  const e = document.createElement("canvas");
+  return e.style.position = "absolute", e.style.inset = "0", e.style.width = "100%", e.style.height = "100%", e.style.display = "block", e.style.zIndex = String(t), r.appendChild(e), e;
+}
+class Oe extends Bt {
+  constructor(t) {
+    super(), w(this, "mainCanvas"), w(this, "mainCtx"), w(this, "overlayCanvas"), w(this, "overlayCtx"), w(this, "resizeObserver"), w(this, "_size"), w(this, "supportsDevicePixelContentBox", !1), this.mainCanvas = le(t, 0), this.overlayCanvas = le(t, 1), this.mainCtx = this.mainCanvas.getContext("2d", { alpha: !0 }), this.overlayCtx = this.overlayCanvas.getContext("2d", { alpha: !0 });
+    const i = window.devicePixelRatio || 1;
+    this._size = {
+      media: { width: 0, height: 0 },
+      bitmap: { width: 0, height: 0 },
+      horizontalPixelRatio: i,
+      verticalPixelRatio: i
+    }, this.resizeObserver = new ResizeObserver((a) => {
+      this.handleResize(a[0]);
+    });
+    try {
+      this.resizeObserver.observe(t, { box: "device-pixel-content-box" }), this.supportsDevicePixelContentBox = !0;
+    } catch {
+      this.resizeObserver.observe(t, { box: "content-box" });
+    }
+    const e = t.getBoundingClientRect();
+    if (e.width > 0 && e.height > 0) {
+      const a = window.devicePixelRatio || 1, o = a, s = Math.round(e.width * a), n = Math.round(e.height * o);
+      this.mainCanvas.width = s, this.mainCanvas.height = n, this.overlayCanvas.width = s, this.overlayCanvas.height = n, this._size = {
+        media: { width: e.width, height: e.height },
+        bitmap: { width: s, height: n },
+        horizontalPixelRatio: s / e.width,
+        verticalPixelRatio: n / e.height
+      };
+    }
+  }
+  handleResize(t) {
+    var i, e;
+    let a, o, s, n;
+    if (this.supportsDevicePixelContentBox && (i = t.devicePixelContentBoxSize) != null && i[0]) {
+      const d = t.devicePixelContentBoxSize[0];
+      a = d.inlineSize, o = d.blockSize;
+      const g = t.contentBoxSize[0];
+      s = g.inlineSize, n = g.blockSize;
+    } else {
+      const d = (e = t.contentBoxSize) == null ? void 0 : e[0];
+      if (d)
+        s = d.inlineSize, n = d.blockSize;
+      else {
+        const f = t.contentRect;
+        s = f.width, n = f.height;
+      }
+      const g = window.devicePixelRatio || 1;
+      a = Math.round(s * g), o = Math.round(n * g);
+    }
+    if (a === 0 || o === 0) return;
+    this.mainCanvas.width = a, this.mainCanvas.height = o, this.overlayCanvas.width = a, this.overlayCanvas.height = o;
+    const l = a / s, h = o / n;
+    this._size = {
+      media: { width: s, height: n },
+      bitmap: { width: a, height: o },
+      horizontalPixelRatio: l,
+      verticalPixelRatio: h
+    }, 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: i, height: e } = this._size.bitmap;
+    this.overlayCtx.clearRect(0, 0, i, e), 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 $e(r, t, i, e) {
+  const { context: a, bitmapSize: o, horizontalPixelRatio: s } = r;
+  a.strokeStyle = e.crosshair.color, a.lineWidth = 1, a.setLineDash([4 * s, 4 * s]);
+  const n = Math.round(t) + 0.5, l = Math.round(i) + 0.5;
+  a.beginPath(), a.moveTo(n, 0), a.lineTo(n, o.height), a.moveTo(0, l), a.lineTo(o.width, l), a.stroke(), a.setLineDash([]);
+}
+function Xe(r, t, i, e, a) {
+  const { context: o, bitmapSize: s, horizontalPixelRatio: n, verticalPixelRatio: l } = r;
+  o.strokeStyle = e.grid.color, o.lineWidth = 1, e.grid.style === "dashed" ? o.setLineDash([4 * n, 4 * n]) : e.grid.style === "dotted" && o.setLineDash([1 * n, 3 * n]);
+  const h = i.niceTickValues();
+  o.beginPath();
+  for (const g of h) {
+    const f = Math.round(i.valueToBitmapY(g)) + 0.5;
+    o.moveTo(0, f), o.lineTo(s.width, f);
+  }
+  o.stroke();
+  const { ticks: d } = t.niceTickValues(a);
+  o.beginPath();
+  for (const g of d) {
+    const f = Math.round(t.timeToBitmapX(g)) + 0.5;
+    o.moveTo(f, 0), o.lineTo(f, s.height);
+  }
+  o.stroke(), o.setLineDash([]);
+}
+function ce(r, t, i) {
+  return r + (t - r) * i;
+}
+function Et(r, t, i) {
+  let e = 0, a = r.length - 1;
+  for (; e <= a; ) {
+    const o = e + a >>> 1, s = i(r[o]);
+    if (s < t) e = o + 1;
+    else if (s > t) a = o - 1;
+    else return o;
+  }
+  return e;
+}
+class jt extends Bt {
+  constructor() {
+    super(...arguments), w(this, "data", []), w(this, "_visible", !0), w(this, "cachedRange", null), w(this, "cachedResult", []);
+  }
+  setVisible(t) {
+    this._visible = t;
+  }
+  isVisible() {
+    return this._visible;
+  }
+  setData(t) {
+    let i = !0;
+    for (let e = 1; e < t.length; e++)
+      if (t[e].time < t[e - 1].time) {
+        i = !1;
+        break;
+      }
+    this.data = i ? t.slice() : [...t].sort((e, a) => e.time - a.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, i) {
+    if (this.data.length === 0) return [];
+    if (this.cachedRange && this.cachedRange.from === t && this.cachedRange.to === i) return this.cachedResult;
+    const e = Math.max(0, Et(this.data, t, (o) => o.time) - 1), a = Math.min(this.data.length, Et(this.data, i, (o) => o.time) + 1);
+    return this.cachedResult = this.data.slice(e, a), this.cachedRange = { from: t, to: i }, 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, i) {
+    if (this.data.length === 0) return null;
+    const e = Et(this.data, t, (s) => s.time);
+    let a = null, o = i;
+    for (let s = Math.max(0, e - 1); s <= Math.min(this.data.length - 1, e + 1); s++) {
+      const n = Math.abs(this.data[s].time - t);
+      n <= o && (o = n, a = this.data[s]);
+    }
+    return a;
+  }
+}
+class He {
+  constructor(t, i, e) {
+    w(this, "dragging", !1), w(this, "lastX", 0), this.viewport = t, this.timeScale = i, this.canvas = e;
+  }
+  handleMouseDown(t) {
+    t.button === 0 && (this.dragging = !0, this.lastX = t.clientX, this.canvas.style.cursor = "grabbing");
+  }
+  handleMouseMove(t) {
+    if (!this.dragging) return;
+    const i = t.clientX - this.lastX;
+    this.lastX = t.clientX;
+    const e = this.timeScale.pixelDeltaToTimeDelta(-i);
+    this.viewport.pan(e);
+  }
+  handleMouseUp() {
+    this.dragging && (this.dragging = !1, this.canvas.style.cursor = "crosshair");
+  }
+  isDragging() {
+    return this.dragging;
+  }
+}
+class Ge {
+  constructor(t, i) {
+    this.viewport = t, this.timeScale = i;
+  }
+  handleWheel(t) {
+    t.preventDefault();
+    const i = Ne(t.deltaY, t.deltaMode), e = Math.exp(i * 5e-3), a = this.timeScale.getMediaWidth(), o = Math.min(t.offsetX, a), s = this.timeScale.xToTime(o);
+    this.viewport.zoomAt(s, e);
+  }
+}
+function Ne(r, t) {
+  return t === WheelEvent.DOM_DELTA_LINE ? r * 8 : t === WheelEvent.DOM_DELTA_PAGE ? r * 24 : r;
+}
+class je extends Bt {
+  constructor(t, i, e, a) {
+    super(), w(this, "zoom"), w(this, "pan"), w(this, "canvas"), w(this, "timeScale"), w(this, "yScale"), w(this, "viewport"), w(this, "onWheel", (o) => {
+      this.zoom.handleWheel(o);
+    }), w(this, "onMouseDown", (o) => {
+      this.pan.handleMouseDown(o);
+    }), w(this, "onMouseMove", (o) => {
+      this.pan.isDragging() && this.pan.handleMouseMove(o), this.emitCrosshair(o.offsetX, o.offsetY);
+    }), w(this, "onMouseUp", () => {
+      this.pan.handleMouseUp();
+    }), w(this, "onMouseLeave", () => {
+      this.pan.handleMouseUp(), this.emit("crosshairMove", null);
+    }), w(this, "onDblClick", () => {
+    }), w(this, "lastTouchDist", 0), w(this, "lastTouchCenter", 0), w(this, "touchCount", 0), w(this, "onTouchStart", (o) => {
+      o.preventDefault(), this.touchCount = o.touches.length, o.touches.length === 1 ? this.pan.handleMouseDown({
+        button: 0,
+        clientX: o.touches[0].clientX
+      }) : o.touches.length === 2 && (this.lastTouchDist = Math.abs(o.touches[0].clientX - o.touches[1].clientX), this.lastTouchCenter = (o.touches[0].clientX + o.touches[1].clientX) / 2);
+    }), w(this, "onTouchMove", (o) => {
+      if (o.preventDefault(), o.touches.length === 1 && this.touchCount === 1) {
+        this.pan.handleMouseMove({
+          clientX: o.touches[0].clientX
+        });
+        const s = this.canvas.getBoundingClientRect();
+        this.emitCrosshair(o.touches[0].clientX - s.left, o.touches[0].clientY - s.top);
+      } else if (o.touches.length === 2) {
+        const s = Math.abs(o.touches[0].clientX - o.touches[1].clientX), n = (o.touches[0].clientX + o.touches[1].clientX) / 2, l = this.canvas.getBoundingClientRect();
+        if (this.lastTouchDist > 0) {
+          const h = this.lastTouchDist / s, d = this.timeScale.xToTime(n - l.left);
+          this.viewport.zoomAt(d, h);
+        }
+        this.lastTouchDist = s, this.lastTouchCenter = n;
+      }
+    }), w(this, "onTouchEnd", (o) => {
+      o.touches.length === 0 && (this.pan.handleMouseUp(), this.touchCount = 0, this.lastTouchDist = 0);
+    }), this.canvas = t, this.viewport = i, this.timeScale = e, this.yScale = a, this.zoom = new Ge(i, e), this.pan = new He(i, e, 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, i) {
+    const e = this.timeScale.xToTime(t), a = this.yScale.yToValue(i);
+    this.emit("crosshairMove", {
+      mediaX: t,
+      mediaY: i,
+      time: e,
+      y: a
+    });
+  }
+  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 he {
+  constructor(t) {
+    w(this, "dirty", !1), w(this, "rafId", null), w(this, "callback"), w(this, "render", (i) => {
+      this.dirty = !1, this.rafId = null, this.callback(i);
+    }), 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 ut = 6e4, ct = 36e5, st = 864e5;
+function de(r) {
+  return r instanceof Date ? r.getTime() : r;
+}
+function Je(r) {
+  return r.length === 0 || typeof r[0].time == "number" ? r : r.map((t) => ({ ...t, time: t.time.getTime() }));
+}
+function Ke(r) {
+  return r.length === 0 || typeof r[0].time == "number" ? r : r.map((t) => ({ ...t, time: t.time.getTime() }));
+}
+function qe(r) {
+  if (r.length < 2) return st;
+  const t = [];
+  for (let i = 1; i < Math.min(r.length, 20); i++)
+    t.push(r[i] - r[i - 1]);
+  return t.sort((i, e) => i - e), t[Math.floor(t.length / 2)];
+}
+function At(r, t) {
+  const i = new Date(r);
+  return t >= st ? i.toLocaleDateString("en-US", { month: "short", day: "numeric" }) : t >= ct ? i.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", hour12: !1 }) : i.toLocaleTimeString("en-US", {
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: !1
+  });
+}
+function Qe(r) {
+  return new Date(r).toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" });
+}
+function Ze(r) {
+  const t = [1e3, 5e3, 1e4, 15e3, 3e4], i = [ut, 5 * ut, 10 * ut, 15 * ut, 30 * ut], e = [ct, 2 * ct, 4 * ct, 6 * ct, 12 * ct], a = [st, 7 * st, 30 * st, 90 * st, 365 * st];
+  return r < ut ? [...t, ...i, ...e, ...a] : r < ct ? [...i, ...e, ...a] : r < st ? [...e, ...a] : a;
+}
+class ti {
+  constructor() {
+    w(this, "from", 0), w(this, "to", 0), w(this, "width", 1), w(this, "pixelRatio", 1);
+  }
+  update(t, i, e) {
+    this.from = t.from, this.to = t.to, this.width = i, this.pixelRatio = e;
+  }
+  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 i = Ze(t), e = (this.to - this.from) / this.width * 80;
+    let a = i[i.length - 1];
+    for (const n of i)
+      if (n >= e) {
+        a = n;
+        break;
+      }
+    const o = [], s = Math.ceil(this.from / a) * a;
+    for (let n = s; n <= this.to; n += a)
+      o.push(n);
+    return { ticks: o, tickInterval: a };
+  }
+  getRange() {
+    return { from: this.from, to: this.to };
+  }
+  getMediaWidth() {
+    return this.width;
+  }
+}
+const Ot = [
+  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 ei {
+  constructor() {
+    w(this, "min", 0), w(this, "max", 0), w(this, "height", 1), w(this, "pixelRatio", 1);
+  }
+  /** Recalculate the scale with a new Y range, chart height, and device pixel ratio. */
+  update(t, i, e) {
+    this.min = t.min, this.max = t.max, this.height = i, this.pixelRatio = e;
+  }
+  /** 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 i = Ot[Ot.length - 1];
+    for (const o of Ot)
+      if (o >= t) {
+        i = o;
+        break;
+      }
+    const e = [], a = Math.ceil(this.min / i) * i;
+    for (let o = a; o <= this.max; o += i)
+      e.push(o);
+    return e;
+  }
+  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 i = this.max - this.min;
+    return i < 0.01 ? t.toFixed(6) : i < 0.1 ? t.toFixed(4) : i < 10 ? t.toFixed(2) : i < 1e3 ? t.toFixed(1) : t.toFixed(0);
+  }
+}
+const ii = {
+  colors: ["#26a69a", "#ef5350"],
+  barWidthRatio: 0.6,
+  stacking: "off"
+};
+class Z {
+  constructor(t, i) {
+    w(this, "stores"), w(this, "options"), this.stores = Array.from({ length: t }, () => new jt()), this.options = { ...ii, ...i };
+  }
+  /** 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, i) {
+    if (this.options.stacking === "percent")
+      return { min: 0, max: 100 };
+    if (this.stores.length <= 1)
+      return null;
+    const e = this.stores.map((n) => n.isVisible() ? n.getVisibleData(t, i) : []);
+    if (this.options.stacking === "off") {
+      let n = 1 / 0, l = -1 / 0;
+      for (const h of e)
+        for (const d of h)
+          d.value < n && (n = d.value), d.value > l && (l = d.value);
+      return n < 1 / 0 ? { min: n, max: l } : null;
+    }
+    const a = /* @__PURE__ */ new Map();
+    for (let n = 0; n < e.length; n++)
+      for (const l of e[n])
+        a.has(l.time) || a.set(l.time, new Array(e.length).fill(0)), a.get(l.time)[n] = l.value;
+    let o = 0, s = 0;
+    for (const n of a.values()) {
+      let l = 0, h = 0;
+      for (const d of n)
+        d > 0 ? l += d : h += d;
+      l > s && (s = l), h < o && (o = h);
+    }
+    return s > o ? { min: o, 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: i, timeScale: e, yScale: a, dataInterval: o } = t, { context: s } = i, n = e.getRange(), l = e.barWidthBitmap(o), h = Math.max(1, Math.round(l * this.options.barWidthRatio) - 2), d = Math.floor(h / 2), g = a.getRange().min < 0, f = g ? a.valueToBitmapY(0) : i.bitmapSize.height;
+    if (this.stores.length === 1) {
+      if (!this.stores[0].isVisible()) return;
+      const p = this.options.colors[0], m = this.options.colors.length > 1 ? this.options.colors[1] : p, b = this.stores[0].getVisibleData(n.from, n.to);
+      for (const u of b) {
+        const v = e.timeToBitmapX(u.time);
+        if (u.value >= 0) {
+          const y = a.valueToBitmapY(u.value), x = Math.max(1, f - y);
+          this.fillBar(s, v - d, y, h, x, p);
+        } else {
+          const y = a.valueToBitmapY(u.value), x = Math.max(1, y - f);
+          this.fillBar(s, v - d, f, h, x, m);
+        }
+      }
+    } else {
+      const p = this.stores.map((b) => b.isVisible() ? b.getVisibleData(n.from, n.to) : []), m = /* @__PURE__ */ new Map();
+      for (let b = 0; b < p.length; b++)
+        for (const u of p[b]) {
+          let v = m.get(u.time);
+          v || (v = [], m.set(u.time, v)), v.push({ layer: b, value: u.value });
+        }
+      for (const [b, u] of m) {
+        u.sort((y, x) => Math.abs(x.value) - Math.abs(y.value));
+        const v = e.timeToBitmapX(b);
+        for (const { layer: y, value: x } of u) {
+          const C = this.options.colors[y % this.options.colors.length];
+          if (x >= 0) {
+            const T = a.valueToBitmapY(x), k = Math.max(1, f - T);
+            this.fillBar(s, v - d, T, h, k, C);
+          } else {
+            const T = a.valueToBitmapY(x), k = Math.max(1, T - f);
+            this.fillBar(s, v - d, f, h, k, C);
+          }
+        }
+      }
+    }
+    if (g) {
+      s.strokeStyle = t.theme.grid.color, s.lineWidth = 1;
+      const p = Math.round(f) + 0.5;
+      s.beginPath(), s.moveTo(0, p), s.lineTo(i.bitmapSize.width, p), s.stroke();
+    }
+  }
+  /** Stacked (normal or percent) rendering */
+  renderStacked(t, i) {
+    const { scope: e, timeScale: a, yScale: o, dataInterval: s } = t, { context: n } = e, l = a.getRange(), h = a.barWidthBitmap(s), d = Math.max(1, Math.round(h * this.options.barWidthRatio) - 2), g = Math.floor(d / 2), f = this.stores.map(
+      (m) => m.isVisible() ? m.getVisibleData(l.from, l.to) : []
+    );
+    if (f.every((m) => m.length === 0)) return;
+    const p = /* @__PURE__ */ new Map();
+    for (let m = 0; m < f.length; m++)
+      for (const b of f[m])
+        p.has(b.time) || p.set(b.time, new Array(f.length).fill(0)), p.get(b.time)[m] = this.stores[m].isVisible() ? b.value : 0;
+    for (let m = 0; m < f.length; m++) {
+      const b = this.options.colors[m % this.options.colors.length];
+      for (const [u, v] of p) {
+        const y = v[m];
+        if (y === 0) continue;
+        const x = a.timeToBitmapX(u);
+        let C = 0, T = 0;
+        for (let k = 0; k < m; k++) {
+          const D = v[k];
+          D > 0 ? C += D : T += D;
+        }
+        if (i) {
+          let k = 0, D = 0;
+          for (const z of v)
+            z > 0 ? k += z : D += z;
+          if (y > 0 && k > 0) {
+            const z = C / k * 100, _ = (C + y) / k * 100, P = o.valueToBitmapY(_), X = o.valueToBitmapY(z), H = Math.max(1, X - P);
+            this.fillBar(n, x - g, P, d, H, b);
+          } else if (y < 0 && D < 0) {
+            const z = T / D * -100, _ = (T + y) / D * -100, P = o.valueToBitmapY(z), X = o.valueToBitmapY(_), H = Math.max(1, X - P);
+            n.fillStyle = b, n.fillRect(x - g, P, d, H);
+          }
+        } else if (y > 0) {
+          const k = o.valueToBitmapY(C + y), D = o.valueToBitmapY(C), z = Math.max(1, D - k);
+          this.fillBar(n, x - g, k, d, z, b);
+        } else {
+          const k = o.valueToBitmapY(T), D = o.valueToBitmapY(T + y), z = Math.max(1, D - k);
+          n.fillStyle = b, n.fillRect(x - g, k, d, z);
+        }
+      }
+    }
+  }
+  fillBar(t, i, e, a, o, s) {
+    t.fillStyle = s, t.fillRect(i, e, a, o);
+  }
+}
+function ue(r, t) {
+  return r.length <= t ? r : ri(
+    r,
+    t,
+    (i) => i.time,
+    (i) => i.value
+  );
+}
+function oi(r, t) {
+  if (r.length <= t) return r;
+  const i = Math.ceil(r.length / t), e = [];
+  for (let a = 0; a < r.length; a += i) {
+    const o = Math.min(a + i, r.length);
+    let s = -1 / 0, n = 1 / 0, l = 0;
+    for (let h = a; h < o; h++)
+      r[h].high > s && (s = r[h].high), r[h].low < n && (n = r[h].low), l += r[h].volume ?? 0;
+    e.push({
+      time: r[a].time,
+      open: r[a].open,
+      high: s,
+      low: n,
+      close: r[o - 1].close,
+      volume: l
+    });
+  }
+  return e;
+}
+function ri(r, t, i, e) {
+  if (t >= r.length || t < 3) return r;
+  const a = [r[0]], o = (r.length - 2) / (t - 2);
+  let s = 0;
+  for (let n = 0; n < t - 2; n++) {
+    const l = Math.floor((n + 1) * o) + 1, h = Math.min(Math.floor((n + 2) * o) + 1, r.length - 1);
+    let d = 0, g = 0;
+    const f = h, p = Math.min(Math.floor((n + 3) * o) + 1, r.length), m = p - f;
+    if (m > 0) {
+      for (let x = f; x < p; x++)
+        d += i(r[x]), g += e(r[x]);
+      d /= m, g /= m;
+    }
+    let b = -1, u = l;
+    const v = i(r[s]), y = e(r[s]);
+    for (let x = l; x < h; x++) {
+      const C = Math.abs((v - d) * (e(r[x]) - y) - (v - i(r[x])) * (g - y));
+      C > b && (b = C, u = x);
+    }
+    a.push(r[u]), s = u;
+  }
+  return a.push(r[r.length - 1]), a;
+}
+const fe = /* @__PURE__ */ new Map(), ge = /* @__PURE__ */ new Map(), pe = /* @__PURE__ */ new Map();
+function Jt(r) {
+  return [parseInt(r.slice(1, 3), 16), parseInt(r.slice(3, 5), 16), parseInt(r.slice(5, 7), 16)];
+}
+function Ce(r, t, i) {
+  return `#${r.toString(16).padStart(2, "0")}${t.toString(16).padStart(2, "0")}${i.toString(16).padStart(2, "0")}`;
+}
+function bt(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 i = r + t;
+  let e = fe.get(i);
+  if (e) return e;
+  const [a, o, s] = Jt(r);
+  return e = `rgba(${a}, ${o}, ${s}, ${t})`, fe.set(i, e), e;
+}
+function ai(r, t) {
+  const i = r + t;
+  let e = ge.get(i);
+  if (e) return e;
+  const [a, o, s] = Jt(r);
+  return e = Ce(
+    Math.min(255, Math.round(a + (255 - a) * t)),
+    Math.min(255, Math.round(o + (255 - o) * t)),
+    Math.min(255, Math.round(s + (255 - s) * t))
+  ), ge.set(i, e), e;
+}
+function si(r, t) {
+  const i = r + t;
+  let e = pe.get(i);
+  if (e) return e;
+  const [a, o, s] = Jt(r);
+  return e = Ce(
+    Math.max(0, Math.round(a * (1 - t))),
+    Math.max(0, Math.round(o * (1 - t))),
+    Math.max(0, Math.round(s * (1 - t)))
+  ), pe.set(i, e), e;
+}
+const ni = {
+  upColor: "#26a69a",
+  downColor: "#ef5350",
+  wickUpColor: "#26a69a",
+  wickDownColor: "#ef5350",
+  bodyWidthRatio: 0.6
+};
+class $t {
+  constructor(t, i) {
+    w(this, "store"), w(this, "options"), this.store = t, this.options = { ...ni, ...i };
+  }
+  updateOptions(t) {
+    this.options = { ...this.options, ...t };
+  }
+  getColor() {
+    return this.options.upColor;
+  }
+  render(t) {
+    const { scope: i, timeScale: e, yScale: a, dataInterval: o } = t, { context: s, horizontalPixelRatio: n } = i, l = e.getRange();
+    let h = this.store.getVisibleData(l.from, l.to);
+    const d = i.mediaSize.width;
+    if (h.length > d * 2 && (h = oi(h, Math.round(d * 1.5))), h.length === 0) return;
+    const g = e.barWidthBitmap(o), f = Math.max(1, Math.round(g * this.options.bodyWidthRatio) - 2), p = Math.floor(f / 2), m = Math.max(1, Math.round(n)), b = Math.round(a.getMediaHeight() * i.verticalPixelRatio);
+    this.drawVolume(s, h, e, b, g, o);
+    const u = [], v = [];
+    for (const y of h)
+      y.close >= y.open ? u.push(y) : v.push(y);
+    this.drawCandles(
+      s,
+      u,
+      e,
+      a,
+      p,
+      f,
+      m,
+      this.options.upColor,
+      this.options.wickUpColor
+    ), this.drawCandles(
+      s,
+      v,
+      e,
+      a,
+      p,
+      f,
+      m,
+      this.options.downColor,
+      this.options.wickDownColor
+    );
+  }
+  drawVolume(t, i, e, a, o, s) {
+    let n = 0;
+    for (const p of i)
+      p.volume !== void 0 && p.volume > n && (n = p.volume);
+    if (n === 0) return;
+    const l = a * 0.2, h = Math.max(1, o - 2), d = Math.floor(h / 2), g = bt(this.options.upColor, 0.2), f = bt(this.options.downColor, 0.2);
+    for (const p of i) {
+      if (p.volume === void 0 || p.volume === 0) continue;
+      const m = e.timeToBitmapX(p.time), b = Math.max(1, p.volume / n * l), u = p.close >= p.open;
+      t.fillStyle = u ? g : f, t.fillRect(m - d, a - b, h, b);
+    }
+  }
+  drawCandles(t, i, e, a, o, s, n, l, h) {
+    if (i.length === 0) return;
+    t.fillStyle = h;
+    for (const p of i) {
+      const m = e.timeToBitmapX(p.time), b = a.valueToBitmapY(p.high), u = a.valueToBitmapY(p.low), v = m - Math.floor(n / 2);
+      t.fillRect(v, b, n, u - b);
+    }
+    const d = this.options.candleGradient !== !1, g = d ? ai(l, 0.2) : l, f = d ? si(l, 0.15) : l;
+    d || (t.fillStyle = l);
+    for (const p of i) {
+      const m = e.timeToBitmapX(p.time), b = a.valueToBitmapY(p.open), u = a.valueToBitmapY(p.close), v = Math.min(b, u), y = Math.max(1, Math.abs(u - b));
+      if (d && y > 2) {
+        const x = t.createLinearGradient(0, v, 0, v + y);
+        x.addColorStop(0, g), x.addColorStop(0.5, l), x.addColorStop(1, f), t.fillStyle = x;
+      }
+      t.fillRect(m - o, v, s, y);
+    }
+  }
+}
+const li = {
+  colors: ["#2962FF"],
+  lineWidth: 1,
+  areaFill: !0,
+  pulse: !0,
+  stacking: "off"
+};
+class G {
+  constructor(t, i) {
+    w(this, "stores"), w(this, "options"), w(this, "areaGradientCache", /* @__PURE__ */ new Map()), this.stores = Array.from({ length: t }, () => new jt()), this.options = { ...li, ...i };
+  }
+  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, i) {
+    if (this.options.stacking === "percent")
+      return { min: 0, max: 100 };
+    if (this.stores.length <= 1)
+      return null;
+    const e = this.stores.map((n) => n.isVisible() ? n.getVisibleData(t, i) : []);
+    if (this.options.stacking === "off") {
+      let n = 1 / 0, l = -1 / 0;
+      for (const h of e)
+        for (const d of h)
+          d.value < n && (n = d.value), d.value > l && (l = d.value);
+      return n < 1 / 0 ? { min: n, max: l } : null;
+    }
+    const a = /* @__PURE__ */ new Map();
+    for (let n = 0; n < e.length; n++)
+      for (const l of e[n])
+        a.has(l.time) || a.set(l.time, new Array(e.length).fill(0)), a.get(l.time)[n] = l.value;
+    let o = 0, s = 0;
+    for (const n of a.values()) {
+      let l = 0, h = 0;
+      for (const d of n)
+        d > 0 ? l += d : h += d;
+      l > s && (s = l), h < o && (o = h);
+    }
+    return s > o ? { min: o, 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: i, timeScale: e, yScale: a } = t, { context: o } = i, s = e.getRange(), { verticalPixelRatio: n, horizontalPixelRatio: l } = i, h = 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 g = this.stores[d].getVisibleData(s.from, s.to);
+      const f = i.mediaSize.width;
+      if (g.length > f * 2 && (g = ue(g, Math.round(f * 1.5))), g.length < 2) continue;
+      const p = this.options.colors[d % this.options.colors.length];
+      o.beginPath(), o.moveTo(e.timeToBitmapX(g[0].time), a.valueToBitmapY(g[0].value));
+      for (let m = 1; m < g.length; m++)
+        o.lineTo(e.timeToBitmapX(g[m].time), a.valueToBitmapY(g[m].value));
+      if (o.strokeStyle = p, o.lineWidth = h, o.lineJoin = "round", o.lineCap = "round", o.stroke(), this.options.areaFill) {
+        const m = e.timeToBitmapX(g[0].time), b = e.timeToBitmapX(g[g.length - 1].time), u = i.bitmapSize.height;
+        o.lineTo(b, u), o.lineTo(m, u), o.closePath();
+        const v = String(d), y = this.areaGradientCache.get(v);
+        let x;
+        y && y.bottomY === u && y.color === p ? x = y.gradient : (x = o.createLinearGradient(0, 0, 0, u), x.addColorStop(0, bt(p, 0.12)), x.addColorStop(1, bt(p, 0.01)), this.areaGradientCache.set(v, { gradient: x, bottomY: u, color: p })), o.fillStyle = x, o.fill();
+      }
+    }
+  }
+  /** Stacked area rendering */
+  renderStacked(t, i) {
+    const { scope: e, timeScale: a, yScale: o } = t, { context: s } = e, n = a.getRange(), { verticalPixelRatio: l } = e, h = Math.max(1, Math.round(this.options.lineWidth * l)), d = e.mediaSize.width, g = this.stores.map((u) => {
+      let v = u.getVisibleData(n.from, n.to);
+      return v.length > d * 2 && (v = ue(v, Math.round(d * 1.5))), v;
+    }), f = /* @__PURE__ */ new Set();
+    for (const u of g)
+      for (const v of u) f.add(v.time);
+    const p = Array.from(f).sort((u, v) => u - v);
+    if (p.length < 2) return;
+    const m = g.map((u) => {
+      const v = /* @__PURE__ */ new Map();
+      for (const y of u) v.set(y.time, y.value);
+      return v;
+    }), b = Array.from({ length: this.stores.length }, () => new Array(p.length).fill(0));
+    for (let u = 0; u < p.length; u++) {
+      const v = p[u];
+      let y = 0;
+      if (i)
+        for (let C = 0; C < this.stores.length; C++)
+          this.stores[C].isVisible() && (y += m[C].get(v) ?? 0);
+      let x = 0;
+      for (let C = 0; C < this.stores.length; C++) {
+        const T = this.stores[C].isVisible() ? m[C].get(v) ?? 0 : 0;
+        x += i && y > 0 ? T / y * 100 : T, b[C][u] = x;
+      }
+    }
+    for (let u = this.stores.length - 1; u >= 0; u--) {
+      if (!this.stores[u].isVisible()) continue;
+      const v = this.options.colors[u % this.options.colors.length], y = [];
+      for (let C = 0; C < p.length; C++)
+        y.push([a.timeToBitmapX(p[C]), o.valueToBitmapY(b[u][C])]);
+      const x = [];
+      for (let C = 0; C < p.length; C++) {
+        const T = u > 0 ? b[u - 1][C] : 0;
+        x.push([a.timeToBitmapX(p[C]), o.valueToBitmapY(T)]);
+      }
+      if (this.options.areaFill) {
+        s.beginPath(), s.moveTo(y[0][0], y[0][1]);
+        for (let C = 1; C < y.length; C++)
+          s.lineTo(y[C][0], y[C][1]);
+        for (let C = x.length - 1; C >= 0; C--)
+          s.lineTo(x[C][0], x[C][1]);
+        s.closePath(), s.fillStyle = bt(v, 0.25), s.fill();
+      }
+      s.beginPath(), s.moveTo(y[0][0], y[0][1]);
+      for (let C = 1; C < y.length; C++)
+        s.lineTo(y[C][0], y[C][1]);
+      s.strokeStyle = v, s.lineWidth = h, s.lineJoin = "round", s.lineCap = "round", s.stroke();
+    }
+  }
+  drawPulseOverlay(t, i, e, a) {
+    if (this.options.pulse)
+      for (let o = 0; o < this.stores.length; o++) {
+        if (!this.stores[o].isVisible()) continue;
+        const s = this.stores[o].last();
+        if (!s) continue;
+        const n = this.options.colors[o % this.options.colors.length];
+        this.drawPulse(
+          t,
+          i.timeToBitmapX(s.time),
+          e.valueToBitmapY(s.value),
+          n,
+          a
+        );
+      }
+  }
+  drawPulse(t, i, e, a, o) {
+    const s = 3 * o, n = 0.4 + 0.6 * Math.abs(Math.sin(performance.now() / 600)), l = s + 4 * o * n;
+    t.beginPath(), t.arc(i, e, l, 0, Math.PI * 2), t.fillStyle = bt(a, n * 0.3), t.fill(), t.beginPath(), t.arc(i, e, s, 0, Math.PI * 2), t.fillStyle = a, t.fill();
+  }
+}
+const ci = {
+  innerRadiusRatio: 0,
+  padAngle: 0.02,
+  strokeColor: "transparent",
+  strokeWidth: 0
+}, Pt = Math.PI * 2;
+function hi(r) {
+  if (!r.startsWith("#")) return !1;
+  const t = parseInt(r.slice(1, 3), 16), i = parseInt(r.slice(3, 5), 16), e = parseInt(r.slice(5, 7), 16);
+  return t * 0.299 + i * 0.587 + e * 0.114 > 150;
+}
+function di(r, t) {
+  if (!r.startsWith("#")) return r;
+  const i = Math.min(255, parseInt(r.slice(1, 3), 16) + Math.round(255 * t)), e = Math.min(255, parseInt(r.slice(3, 5), 16) + Math.round(255 * t)), a = Math.min(255, parseInt(r.slice(5, 7), 16) + Math.round(255 * t));
+  return `#${i.toString(16).padStart(2, "0")}${e.toString(16).padStart(2, "0")}${a.toString(16).padStart(2, "0")}`;
+}
+function ui(r, t, i) {
+  return r + (t - r) * Math.min(1, i);
+}
+class lt {
+  constructor(t) {
+    w(this, "data", []), w(this, "options"), w(this, "hoverIndex", -1), w(this, "sliceOffsets", []), w(this, "lastRenderTime", 0), this.options = { ...ci, ...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, i;
+    return ((t = this.data[0]) == null ? void 0 : t.color) ?? ((i = this.options.colors) == null ? void 0 : i[0]) ?? "#888";
+  }
+  /** Hit-test: which slice is at this bitmap coordinate? Returns index or -1. */
+  hitTest(t, i, e, a) {
+    if (this.data.length === 0) return -1;
+    const o = this.data.reduce((b, u) => b + u.value, 0);
+    if (o <= 0) return -1;
+    const s = e / 2, n = a / 2, l = Math.min(e, a) / 2 * 0.85, h = l * this.options.innerRadiusRatio, d = t - s, g = i - n, f = Math.sqrt(d * d + g * g);
+    if (f > l || f < h) return -1;
+    let p = Math.atan2(g, d) + Math.PI / 2;
+    p < 0 && (p += Pt);
+    let m = 0;
+    for (let b = 0; b < this.data.length; b++) {
+      const u = this.data[b].value / o * Pt;
+      if (p >= m && p < m + u) return b;
+      m += u;
+    }
+    return -1;
+  }
+  /** Returns true if animation is still in progress. */
+  get needsAnimation() {
+    for (let t = 0; t < this.sliceOffsets.length; t++) {
+      const i = t === this.hoverIndex ? 1 : 0;
+      if (Math.abs(this.sliceOffsets[t] - i) > 0.01) return !0;
+    }
+    return !1;
+  }
+  render(t) {
+    if (this.data.length === 0) return;
+    const { scope: i, theme: e } = t, { context: a, bitmapSize: o, horizontalPixelRatio: s } = i, n = performance.now(), l = this.lastRenderTime ? (n - this.lastRenderTime) / 1e3 : 0;
+    this.lastRenderTime = n;
+    const h = this.data.reduce((k, D) => k + D.value, 0);
+    if (h <= 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 D = k === this.hoverIndex ? 1 : 0;
+      this.sliceOffsets[k] = ui(this.sliceOffsets[k], D, d * l);
+    }
+    const g = this.options.colors ?? e.seriesColors, f = o.width / 2, p = o.height / 2, m = Math.min(o.width, o.height) / 2 * 0.85, b = m * this.options.innerRadiusRatio, u = this.options.padAngle, { strokeColor: v, strokeWidth: y } = this.options, x = 8 * s;
+    let C = -Math.PI / 2;
+    for (let k = 0; k < this.data.length; k++) {
+      const D = this.data[k], z = D.value / h * Pt, _ = C + u / 2, P = C + z - u / 2, X = C + z / 2, H = D.color ?? g[k % g.length], Q = this.sliceOffsets[k] * x, U = Math.cos(X) * Q, nt = Math.sin(X) * Q, E = f + U, O = p + nt;
+      a.beginPath(), a.arc(E, O, m, _, P), b > 0 ? a.arc(E, O, b, P, _, !0) : a.lineTo(E, O), a.closePath();
+      const A = a.createRadialGradient(E, O, b || 0, E, O, m);
+      A.addColorStop(0, di(H, 0.15)), A.addColorStop(1, H), a.fillStyle = A, this.sliceOffsets[k] > 0.01 && (a.shadowColor = "rgba(0,0,0,0.25)", a.shadowBlur = 12 * s * this.sliceOffsets[k], a.shadowOffsetX = U * 0.3, a.shadowOffsetY = nt * 0.3), a.fill(), a.shadowColor = "transparent", a.shadowBlur = 0, a.shadowOffsetX = 0, a.shadowOffsetY = 0, y > 0 && v !== "transparent" && (a.strokeStyle = v, a.lineWidth = y, a.stroke()), C += z;
+    }
+    C = -Math.PI / 2;
+    const T = b > 0 ? (m + b) / 2 : m * 0.65;
+    a.textAlign = "center", a.textBaseline = "middle", a.font = `${11 * s}px ${e.typography.fontFamily}`;
+    for (let k = 0; k < this.data.length; k++) {
+      const D = this.data[k], z = D.value / h * Pt;
+      if (z > 0.3) {
+        const _ = C + z / 2, P = this.sliceOffsets[k] * x, X = f + Math.cos(_) * (T + P), H = p + Math.sin(_) * (T + P), Q = D.color ?? g[k % g.length];
+        a.fillStyle = hi(Q) ? "#000000" : "#ffffff", a.fillText(D.label, X, H);
+      }
+      C += z;
+    }
+  }
+}
+const fi = {
+  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)"
+  }
+}, rt = {
+  top: 20,
+  bottom: 20,
+  right: { intervals: 3 },
+  left: { intervals: 0 }
+};
+class gi extends Bt {
+  constructor({ padding: t } = {}) {
+    super(), w(this, "_visibleRange", { from: 0, to: 0 }), w(this, "_yRange", { min: 0, max: 0 }), w(this, "_autoScroll", !0), w(this, "padding"), w(this, "dataInterval", 6e4), w(this, "_dataStart", null), w(this, "_dataEnd", null), w(this, "_animating", !1), w(this, "animStartTime", 0), w(this, "animDuration", 0), w(this, "animFrom", { from: 0, to: 0 }), w(this, "animTo", { from: 0, to: 0 }), this.padding = {
+      top: (t == null ? void 0 : t.top) ?? rt.top,
+      bottom: (t == null ? void 0 : t.bottom) ?? rt.bottom,
+      right: (t == null ? void 0 : t.right) ?? rt.right,
+      left: (t == null ? void 0 : t.left) ?? rt.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, i, e) {
+    return typeof t == "object" ? t.intervals * this.dataInterval : e <= 0 ? 0 : t / e * i;
+  }
+  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) ?? rt.top,
+      bottom: (t == null ? void 0 : t.bottom) ?? rt.bottom,
+      right: (t == null ? void 0 : t.right) ?? rt.right,
+      left: (t == null ? void 0 : t.left) ?? rt.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, i, e = !1) {
+    if (i <= t) return;
+    const a = i - t;
+    if (!(a / this.dataInterval < 2)) {
+      if (e && this._dataStart !== null && this._dataEnd !== null) {
+        const o = this._dataEnd - this._dataStart + this.dataInterval * 5;
+        if (a > o && o > 0) return;
+      }
+      this._visibleRange = { from: t, to: i }, this.emit("change");
+    }
+  }
+  /** Start animation — will be advanced by tick() calls from the render loop */
+  animateTo(t, i, e = 400) {
+    this.animFrom = { ...this._visibleRange }, this.animTo = { from: t, to: i }, this.animDuration = e, 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 i = t - this.animStartTime, e = Math.min(1, i / this.animDuration), a = 1 - (1 - e) ** 3, o = ce(this.animFrom.from, this.animTo.from, a), s = ce(this.animFrom.to, this.animTo.to, a);
+    return s > o && this.applyRange(o, s), e >= 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, i, e, a = !1, o = !1) {
+    const s = i - t, n = e > 0 ? this.padding.top / e * s : 0, l = e > 0 ? this.padding.bottom / e * s : 0;
+    this._yRange = {
+      min: a ? t : t - l,
+      max: o ? i : i + n
+    };
+  }
+  /** Zoom in/out around a time anchor point. Factor < 1 zooms in, > 1 zooms out. */
+  zoomAt(t, i) {
+    this.cancelAnimation();
+    const { from: e, to: a } = this._visibleRange, o = a - e, s = o * i, n = (t - e) / o, l = t - n * s, h = l + s;
+    if (!(s / this.dataInterval < 10)) {
+      if (i > 1 && this._dataStart !== null && this._dataEnd !== null && l <= this._dataStart && h >= this._dataEnd) {
+        this._autoScroll = !0, this.applyRange(l, h, !0);
+        return;
+      }
+      this._autoScroll = !1, this.applyRange(l, h, !0);
+    }
+  }
+  /** Shift the visible range by a time delta. Disables auto-scroll. */
+  pan(t) {
+    this.cancelAnimation();
+    const { from: i, to: e } = this._visibleRange, a = i + t, o = e + t;
+    this._autoScroll = !1, this.applyRange(a, o);
+  }
+  /** Fit the viewport to show data from first to last timestamp, with optional animation. */
+  fitToData(t, i, e = 0, a = !1) {
+    this._autoScroll = !0;
+    const o = 400 * this.dataInterval, s = i - t, n = s > 0 ? s : this.dataInterval * 10, l = this.resolveHPad(this.padding.right, n, e), h = this.resolveHPad(this.padding.left, n, e);
+    let d = i + l, g = t - h;
+    d - g > o && (d = i + l, g = d - o), a && this._visibleRange.from !== 0 && this._visibleRange.to !== 0 ? this.animateTo(g, d, 450) : this.applyRange(g, d);
+  }
+  /** Keep the right edge pinned to the latest data (real-time auto-scroll). */
+  scrollToEnd(t, i = 0) {
+    const e = this._visibleRange.to - this._visibleRange.from, a = this.resolveHPad(this.padding.right, e, i), o = t + a, s = o - e;
+    this._autoScroll = !0, this._animating ? (this.animFrom = { ...this._visibleRange }, this.animTo = { from: s, to: o }, this.animDuration = 150, this.animStartTime = performance.now()) : this.animateTo(s, o, 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 pi = 0;
+var Y, B, V, ft, wt, M, W, St, N, ot, $, tt, Xt, gt, at, kt, ht, pt, Mt, Wt, K, q, mt;
+class mi extends Bt {
+  constructor(t, i) {
+    var e, a, o;
+    super(), L(this, pt), L(this, Y), L(this, B), L(this, V), L(this, ft), w(this, "timeScale"), w(this, "yScale"), L(this, wt), L(this, M, []), L(this, W), L(this, St), L(this, N, 6e4), L(this, ot, null), L(this, $, {}), L(this, tt, null), L(this, Xt, !1), L(this, gt, {}), L(this, at, 0), L(this, kt, !1), L(this, ht, !1), L(this, Wt, 0), L(this, K, 0), L(this, q, 0), L(this, mt, !1), i != null && i.axis && (R(this, gt, i.axis), R(this, $, { min: (e = i.axis.y) == null ? void 0 : e.min, max: (a = i.axis.y) == null ? void 0 : a.max })), R(this, W, (i == null ? void 0 : i.theme) ?? fi), R(this, St, (i == null ? void 0 : i.grid) !== !1), R(this, Y, new Oe(t)), R(this, B, new gi({ padding: i == null ? void 0 : i.padding })), this.timeScale = new ti(), this.yScale = new ei(), R(this, V, new he(() => this.renderMain())), R(this, ft, new he(() => this.renderOverlay()));
+    const s = (i == null ? void 0 : i.interactive) !== !1;
+    R(this, wt, s ? new je(c(this, Y).canvas, c(this, B), this.timeScale, this.yScale) : null), c(this, B).on("change", () => {
+      this.syncScales(), c(this, V).markDirty(), this.emit("viewportChange");
+    }), c(this, Y).on("resize", () => {
+      this.updateScales(!0), this.renderMain(), this.emit("viewportChange");
+    }), (o = c(this, wt)) == null || o.on("crosshairMove", (n) => {
+      R(this, ot, n), c(this, ft).markDirty(), this.emit("crosshairMove", n), this.updatePieHover(n);
+    });
+  }
+  get yAxisWidth() {
+    const t = c(this, gt).y;
+    return (t == null ? void 0 : t.visible) === !1 ? 0 : (t == null ? void 0 : t.width) ?? 55;
+  }
+  get xAxisHeight() {
+    const t = c(this, gt).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 i = new jt(), e = new $t(i, {
+      upColor: c(this, W).candlestick.upColor,
+      downColor: c(this, W).candlestick.downColor,
+      wickUpColor: c(this, W).candlestick.wickUpColor,
+      wickDownColor: c(this, W).candlestick.wickDownColor,
+      bodyWidthRatio: 0.6,
+      ...t
+    }), a = Ft(this, pt, Mt).call(this, t == null ? void 0 : t.id);
+    return i.on("update", () => {
+      this.onDataChanged();
+    }), c(this, M).push({ id: a, renderer: e, store: i, visible: !0 }), R(this, tt, null), this.updateViewportPadding(), this.emit("seriesChange"), a;
+  }
+  addLineSeries(t, i) {
+    let e, a;
+    if (typeof t == "number")
+      e = t, a = i;
+    else {
+      const { layers: n, ...l } = t ?? {};
+      e = n ?? 1, a = l;
+    }
+    const o = new G(e, {
+      colors: e === 1 ? [c(this, W).line.color] : c(this, W).seriesColors.slice(0, e),
+      lineWidth: c(this, W).line.width,
+      areaFill: !0,
+      ...a
+    }), s = Ft(this, pt, Mt).call(this, a == null ? void 0 : a.id);
+    for (const n of o.stores)
+      n.on("update", () => this.onDataChanged());
+    return c(this, M).push({ id: s, label: a == null ? void 0 : a.label, renderer: o, store: o.stores[0], visible: !0 }), R(this, tt, null), this.updateViewportPadding(), this.emit("seriesChange"), s;
+  }
+  /** Set data for a specific layer within a line series. */
+  setLineLayerData(t, i, e) {
+    const a = c(this, M).find((s) => s.id === t);
+    if (!a || !(a.renderer instanceof G)) return;
+    const o = a.renderer.stores[i];
+    o && o.setData(e);
+  }
+  addBarSeries(t, i) {
+    let e, a;
+    if (typeof t == "number")
+      e = t, a = i;
+    else {
+      const { layers: n, ...l } = t ?? {};
+      e = n ?? 1, a = l;
+    }
+    const o = new Z(e, {
+      colors: c(this, W).seriesColors.slice(0, e),
+      barWidthRatio: 0.6,
+      ...a
+    }), s = Ft(this, pt, Mt).call(this, a == null ? void 0 : a.id);
+    for (const n of o.stores)
+      n.on("update", () => this.onDataChanged());
+    return c(this, M).push({ id: s, label: a == null ? void 0 : a.label, renderer: o, store: o.stores[0], visible: !0 }), R(this, tt, null), this.updateViewportPadding(), this.emit("seriesChange"), s;
+  }
+  /** Set data for a specific layer within a bar series. */
+  setBarLayerData(t, i, e) {
+    const a = c(this, M).find((s) => s.id === t);
+    if (!a || !(a.renderer instanceof Z)) return;
+    const o = a.renderer.stores[i];
+    o && o.setData(e);
+  }
+  /** Add a pie/donut series. Set `innerRadiusRatio > 0` for donut. */
+  addPieSeries(t) {
+    const i = new lt(t), e = Ft(this, pt, Mt).call(this, t == null ? void 0 : t.id);
+    return c(this, M).push({ id: e, label: t == null ? void 0 : t.label, renderer: i, store: null, visible: !0 }), R(this, tt, null), this.updateViewportPadding(), this.emit("seriesChange"), e;
+  }
+  /** Set data for a pie/donut series. */
+  setPieData(t, i) {
+    const e = c(this, M).find((a) => a.id === t);
+    !e || !(e.renderer instanceof lt) || (e.renderer.setData(i), c(this, V).markDirty(), this.emit("dataUpdate"));
+  }
+  /** Remove a series by ID and clean up its resources. */
+  removeSeries(t) {
+    const i = c(this, M).findIndex((e) => e.id === t);
+    if (i >= 0) {
+      const { renderer: e, store: a } = c(this, M)[i];
+      if (e instanceof G || e instanceof Z)
+        for (const o of e.stores) o.removeAllListeners();
+      else
+        a == null || a.removeAllListeners();
+      c(this, M).splice(i, 1), R(this, tt, null), this.updateViewportPadding(), c(this, V).markDirty(), this.emit("seriesChange");
+    }
+  }
+  /** Replace all data for a series (batch load). Accepts `Date` objects for time fields. */
+  setSeriesData(t, i) {
+    const e = c(this, M).find((o) => o.id === t);
+    if (!(e != null && e.store)) return;
+    const a = i.length > 0 && "open" in i[0] ? Je(i) : Ke(i);
+    e.store.setData(a);
+  }
+  /** Append a new data point to the end of a series (real-time tick). */
+  appendData(t, i) {
+    const e = c(this, M).find((o) => o.id === t);
+    if (!(e != null && e.store)) return;
+    const a = { ...i, time: de(i.time) };
+    e.store.append(a);
+  }
+  /** Update the last data point of a series in place (e.g. live candle update). */
+  updateData(t, i) {
+    const e = c(this, M).find((o) => o.id === t);
+    if (!(e != null && e.store)) return;
+    const a = { ...i, time: de(i.time) };
+    e.store.updateLast(a);
+  }
+  /** Update visual options (color, width, etc.) for an existing series. */
+  updateSeriesOptions(t, i) {
+    const e = c(this, M).find((a) => a.id === t);
+    e && ((e.renderer instanceof $t || e.renderer instanceof G || e.renderer instanceof Z || e.renderer instanceof lt) && e.renderer.updateOptions(i), "label" in i && typeof i.label == "string" && (e.label = i.label), c(this, V).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() {
+    ne(this, at)._++;
+  }
+  /** @deprecated Use {@link batch} instead. */
+  endUpdate() {
+    --ne(this, at)._ <= 0 && (R(this, at, 0), c(this, kt) ? (R(this, kt, !1), R(this, ht, !1), this.onDataChanged()) : c(this, ht) && (R(this, ht, !1), this.updateYRange(!0), c(this, V).markDirty()));
+  }
+  /** Show or hide a series. Hidden series are not rendered and excluded from Y-range. */
+  setSeriesVisible(t, i) {
+    const e = c(this, M).find((a) => a.id === t);
+    if (!(!e || e.visible === i)) {
+      if (e.visible = i, c(this, at) > 0) {
+        R(this, ht, !0);
+        return;
+      }
+      this.updateYRange(!0), c(this, V).markDirty();
+    }
+  }
+  isSeriesVisible(t) {
+    var i;
+    return ((i = c(this, M).find((e) => e.id === t)) == null ? void 0 : i.visible) ?? !0;
+  }
+  /** Show or hide a specific layer within a multi-layer series. */
+  setLayerVisible(t, i, e) {
+    const a = c(this, M).find((s) => s.id === t);
+    if (!a) return;
+    const o = a.renderer;
+    if (o instanceof Z || o instanceof G) {
+      const s = o.stores[i];
+      if (s) {
+        if (s.isVisible() === e) return;
+        if (s.setVisible(e), c(this, at) > 0) {
+          R(this, ht, !0);
+          return;
+        }
+        this.updateYRange(!0), c(this, V).markDirty();
+      }
+    }
+  }
+  isLayerVisible(t, i) {
+    var e;
+    const a = c(this, M).find((s) => s.id === t);
+    if (!a) return !0;
+    const o = a.renderer;
+    return o instanceof Z || o instanceof G ? ((e = o.stores[i]) == null ? void 0 : e.isVisible()) ?? !0 : !0;
+  }
+  /** Auto-fit the viewport to show all data across every series. */
+  fitContent() {
+    const { first: t, last: i } = this.getDataBounds();
+    if (t === void 0 || i === void 0) return;
+    const e = c(this, Y).size.media.width - this.yAxisWidth;
+    c(this, B).fitToData(t, i, e, !0);
+  }
+  getVisibleRange() {
+    return c(this, B).visibleRange;
+  }
+  getYRange() {
+    return c(this, B).yRange;
+  }
+  getCrosshairPosition() {
+    return c(this, ot);
+  }
+  /** Get the last visible value and whether the absolute last point is on screen. */
+  getLastValue(t) {
+    const i = c(this, M).find((l) => l.id === t);
+    if (!(i != null && i.store)) return null;
+    const e = i.store.last();
+    if (!e) return null;
+    const a = (l) => "close" in l ? l.close : l.value, { from: o, to: s } = c(this, B).visibleRange;
+    if (e.time >= o && e.time <= s)
+      return { value: a(e), isLive: !0 };
+    const n = i.store.getVisibleData(o, s);
+    return n.length === 0 ? null : { value: a(n[n.length - 1]), isLive: !1 };
+  }
+  /** Get the second-to-last value, useful for computing change. */
+  getPreviousClose(t) {
+    const i = c(this, M).find((o) => o.id === t);
+    if (!(i != null && i.store)) return null;
+    const e = i.store.getAll();
+    if (e.length < 2) return null;
+    const a = e[e.length - 2];
+    return "close" in a ? a.close : a.value;
+  }
+  getLastData(t) {
+    const i = c(this, M).find((e) => e.id === t);
+    return i != null && i.store ? i.store.last() ?? null : null;
+  }
+  /** Find the data point closest to the given timestamp within one data interval. */
+  getDataAtTime(t, i) {
+    const e = c(this, M).find((n) => n.id === t);
+    if (!(e != null && e.store)) return null;
+    const a = e.store.getVisibleData(i - c(this, N), i + c(this, N));
+    if (a.length === 0) return null;
+    let o = a[0], s = Math.abs(a[0].time - i);
+    for (let n = 1; n < a.length; n++) {
+      const l = Math.abs(a[n].time - i);
+      l < s && (s = l, o = a[n]);
+    }
+    return o;
+  }
+  /** Get all layers' data at a given time for multi-layer series (Bar/Line with stacking). */
+  getLayerSnapshots(t, i) {
+    const e = c(this, M).find((n) => n.id === t);
+    if (!e || !e.visible) return null;
+    const a = e.renderer;
+    if (!(a instanceof Z) && !(a instanceof G) || a.stores.length <= 1) return null;
+    const o = a.getColors(), s = [];
+    for (let n = 0; n < a.stores.length; n++) {
+      if (!a.stores[n].isVisible()) continue;
+      const l = a.stores[n].getVisibleData(i - c(this, N), i + c(this, N));
+      if (l.length === 0) continue;
+      let h = l[0], d = Math.abs(l[0].time - i);
+      for (let g = 1; g < l.length; g++) {
+        const f = Math.abs(l[g].time - i);
+        f < d && (d = f, h = l[g]);
+      }
+      s.push({
+        value: h.value,
+        color: (o == null ? void 0 : o[n % ((o == null ? void 0 : o.length) ?? 1)]) ?? c(this, W).seriesColors[n % c(this, W).seriesColors.length]
+      });
+    }
+    return s.length > 0 ? s : null;
+  }
+  getSeriesIds() {
+    return c(this, tt) || R(this, tt, c(this, M).map((t) => t.id)), c(this, tt).slice();
+  }
+  /** Get the primary display color for a series. */
+  getSeriesColor(t) {
+    const i = c(this, M).find((e) => e.id === t);
+    return i ? "getColor" in i.renderer && typeof i.renderer.getColor == "function" ? i.renderer.getColor() : c(this, W).line.color : null;
+  }
+  getSeriesLabel(t) {
+    var i;
+    return (i = c(this, M).find((e) => e.id === t)) == null ? void 0 : i.label;
+  }
+  /** Get per-layer colors for a series. Returns null for non-bar/line series (e.g. candlestick, pie). */
+  getSeriesLayers(t) {
+    const i = c(this, M).find((o) => o.id === t);
+    if (!i) return null;
+    const e = i.renderer;
+    if (!(e instanceof Z) && !(e instanceof G)) return null;
+    const a = e.getColors();
+    return e.stores.map((o, s) => ({
+      color: a[s % a.length]
+    }));
+  }
+  /** Get all pie slices with computed colors and percentages. Returns null for non-pie series. */
+  getPieSlices(t) {
+    const i = c(this, M).find((s) => s.id === t);
+    if (!i || !(i.renderer instanceof lt)) return null;
+    const e = i.renderer.getData();
+    if (e.length === 0) return null;
+    const a = e.reduce((s, n) => s + n.value, 0), o = c(this, W).seriesColors;
+    return e.map((s, n) => ({
+      label: s.label,
+      value: s.value,
+      percent: a > 0 ? s.value / a * 100 : 0,
+      color: s.color ?? o[n % o.length]
+    }));
+  }
+  /** Get the hovered pie slice info (label, value, percentage, color). Returns null if no hover. */
+  getPieHoverInfo(t) {
+    const i = c(this, M).find((l) => l.id === t);
+    if (!i || !(i.renderer instanceof lt)) return null;
+    const e = i.renderer;
+    if (e.hoverIndex < 0) return null;
+    const a = e.getData(), o = a[e.hoverIndex];
+    if (!o) return null;
+    const s = a.reduce((l, h) => l + h.value, 0), n = c(this, W).seriesColors;
+    return {
+      label: o.label,
+      value: o.value,
+      percent: s > 0 ? o.value / s * 100 : 0,
+      color: o.color ?? n[e.hoverIndex % n.length]
+    };
+  }
+  /** Apply a new theme and update candlestick series colors. Line series keep their individual colors. */
+  setTheme(t) {
+    const i = c(this, W).line.color;
+    R(this, W, t);
+    for (const e of c(this, M))
+      e.renderer instanceof $t ? e.renderer.updateOptions({
+        upColor: t.candlestick.upColor,
+        downColor: t.candlestick.downColor,
+        wickUpColor: t.candlestick.wickUpColor,
+        wickDownColor: t.candlestick.wickDownColor
+      }) : e.renderer instanceof Z ? e.renderer.updateOptions({
+        colors: t.seriesColors.slice(0, e.renderer.stores.length)
+      }) : e.renderer instanceof G && (e.renderer.stores.length === 1 ? e.renderer.getColor() === i && e.renderer.updateOptions({ colors: [t.line.color] }) : e.renderer.updateOptions({
+        colors: t.seriesColors.slice(0, e.renderer.stores.length)
+      }));
+    c(this, V).markDirty();
+  }
+  getTheme() {
+    return c(this, W);
+  }
+  /** Update axis configuration and re-render. */
+  setAxis(t) {
+    var i, e;
+    const a = this.yAxisWidth, o = this.xAxisHeight;
+    R(this, gt, t);
+    const s = { min: (i = t.y) == null ? void 0 : i.min, max: (e = t.y) == null ? void 0 : e.max };
+    R(this, $, s), R(this, mt, !1), this.updateYRange(!0), (this.yAxisWidth !== a || this.xAxisHeight !== o) && this.updateScales(!0), c(this, V).markDirty();
+  }
+  getMediaSize() {
+    return c(this, Y).size.media;
+  }
+  /** Returns layout metrics for the chart area, Y axis, and time axis. */
+  getLayout() {
+    const t = c(this, Y).size.media, i = this.yAxisWidth, e = this.xAxisHeight;
+    return {
+      chartArea: { x: 0, y: 0, width: t.width - i, height: t.height - e },
+      yAxisWidth: i,
+      xAxisHeight: e
+    };
+  }
+  getDataInterval() {
+    return c(this, N);
+  }
+  /** Update viewport padding at runtime. Refits the visible range to current data bounds. */
+  setPadding(t) {
+    c(this, B).setPadding(t);
+    const { first: i, last: e } = this.getDataBounds();
+    if (i !== void 0 && e !== void 0) {
+      const a = c(this, Y).size.media.width - this.yAxisWidth;
+      c(this, B).fitToData(i, e, a, !1);
+    }
+    this.syncScales(), c(this, V).markDirty();
+  }
+  /** Show or hide the background grid. Takes effect on the next render frame. */
+  setGrid(t) {
+    R(this, St, t), c(this, V).markDirty();
+  }
+  /** Notify chart that a YLabel is present (affects right padding). */
+  setYLabel(t) {
+    R(this, Xt, t), this.updateViewportPadding();
+  }
+  updatePieHover(t) {
+    const i = c(this, Y).size;
+    for (const e of c(this, M))
+      if (e.renderer instanceof lt) {
+        const a = e.renderer.hoverIndex;
+        if (t) {
+          const o = t.mediaX * i.horizontalPixelRatio, s = t.mediaY * i.verticalPixelRatio;
+          e.renderer.hoverIndex = e.renderer.hitTest(o, s, i.bitmap.width, i.bitmap.height);
+        } else
+          e.renderer.hoverIndex = -1;
+        e.renderer.hoverIndex !== a && c(this, V).markDirty();
+      }
+  }
+  updateViewportPadding() {
+  }
+  /** Tear down the chart: cancel animations, remove listeners, and detach the canvas. */
+  destroy() {
+    var t;
+    c(this, B).destroy(), c(this, V).destroy(), c(this, ft).destroy(), (t = c(this, wt)) == null || t.destroy(), c(this, Y).destroy(), this.removeAllListeners();
+  }
+  /** Compute the earliest and latest timestamps across all series. */
+  getDataBounds() {
+    let t, i;
+    for (const e of c(this, M)) {
+      if (!e.visible || !e.store) continue;
+      const a = e.store.first(), o = e.store.last();
+      a && (t === void 0 || a.time < t) && (t = a.time), o && (i === void 0 || o.time > i) && (i = o.time);
+    }
+    return { first: t, last: i };
+  }
+  onDataChanged() {
+    if (c(this, at) > 0) {
+      R(this, kt, !0);
+      return;
+    }
+    this.updateDataInterval();
+    const { first: t, last: i } = this.getDataBounds();
+    t !== void 0 && c(this, B).setDataStart(t), i !== void 0 && c(this, B).setDataEnd(i);
+    let e = 0;
+    for (const o of c(this, M))
+      if (o.renderer instanceof G || o.renderer instanceof Z)
+        for (const s of o.renderer.stores) e += s.length;
+      else o.store && (e += o.store.length);
+    const a = e - c(this, Wt) > 5;
+    if (R(this, Wt, e), t !== void 0 && i !== void 0) {
+      const { from: o, to: s } = c(this, B).visibleRange, n = o === 0 && s === 0, l = c(this, Y).size.media.width - this.yAxisWidth;
+      n ? c(this, B).fitToData(t, i, l, !1) : a && c(this, B).autoScroll ? c(this, B).fitToData(t, i, l, !0) : !a && this.isLastPointVisible() && c(this, B).scrollToEnd(i, l);
+    }
+    this.updateYRange(a), this.syncScales(), c(this, V).markDirty(), this.emit("dataUpdate");
+  }
+  /** Check whether the last data point of any series falls within the visible time range. */
+  isLastPointVisible() {
+    const { from: t, to: i } = c(this, B).visibleRange;
+    for (const e of c(this, M)) {
+      if (!e.visible || !e.store) continue;
+      const a = e.store.last();
+      if (a && a.time >= t && a.time <= i) return !0;
+    }
+    return !1;
+  }
+  updateDataInterval() {
+    for (const t of c(this, M)) {
+      if (!t.store) continue;
+      const i = t.store.getAll();
+      if (i.length >= 2) {
+        const e = i.slice(0, 20).map((a) => a.time);
+        R(this, N, qe(e)), c(this, B).setDataInterval(c(this, N));
+        break;
+      }
+    }
+  }
+  updateYRange(t = !1) {
+    let i = 1 / 0, e = -1 / 0;
+    const a = c(this, B).visibleRange;
+    let o = c(this, $).min !== void 0 && c(this, $).min !== "auto" && typeof c(this, $).min != "number" || c(this, $).max !== void 0 && c(this, $).max !== "auto" && typeof c(this, $).max != "number" ? [] : null;
+    for (const h of c(this, M)) {
+      if (!h.visible) continue;
+      if (h.renderer.getValueRange) {
+        const g = h.renderer.getValueRange(a.from, a.to);
+        if (g) {
+          g.max > e && (e = g.max), g.min < i && (i = g.min), o == null || o.push(g.min, g.max);
+          continue;
+        }
+      }
+      if (!h.store) continue;
+      const d = h.store.getVisibleData(a.from, a.to);
+      for (const g of d)
+        if ("high" in g) {
+          const f = g;
+          f.high > e && (e = f.high), f.low < i && (i = f.low), o == null || o.push(f.high, f.low);
+        } else {
+          const f = g;
+          f.value > e && (e = f.value), f.value < i && (i = f.value), o == null || o.push(f.value);
+        }
+    }
+    if (i === 1 / 0 || e === -1 / 0) {
+      R(this, mt, !1);
+      return;
+    }
+    if (i = this.resolveBound(c(this, $).min, i, e, o ?? [], "min"), e = this.resolveBound(c(this, $).max, e, i, o ?? [], "max"), !c(this, mt) || t)
+      R(this, K, i), R(this, q, e), R(this, mt, !0);
+    else {
+      R(this, K, c(this, K) + (i - c(this, K)) * 0.2), R(this, q, c(this, q) + (e - c(this, q)) * 0.2), i < c(this, K) && R(this, K, i), e > c(this, q) && R(this, q, e);
+      const h = Math.max(Math.abs(c(this, q) - c(this, K)) * 1e-4, 1e-3);
+      (Math.abs(c(this, K) - i) > h || Math.abs(c(this, q) - e) > h) && c(this, V).markDirty();
+    }
+    const s = c(this, $).min !== void 0 && c(this, $).min !== "auto", n = c(this, $).max !== void 0 && c(this, $).max !== "auto", l = c(this, Y).size.media.height - this.xAxisHeight;
+    c(this, B).setYRange(c(this, K), c(this, q), l, s, n);
+  }
+  /** Resolve an {@link AxisBound} to a concrete numeric value. */
+  resolveBound(t, i, e, a, o) {
+    if (t === void 0 || t === "auto") return i;
+    if (typeof t == "number") return t;
+    if (typeof t == "function") return t(a);
+    const s = String(t).match(/^([+-]?)\s*(\d+(?:\.\d+)?)\s*%$/);
+    if (s) {
+      const n = s[1] === "-" ? -1 : 1, l = parseFloat(s[2]) / 100, h = Math.abs(e - i) || Math.abs(i) || 1;
+      return i + n * l * h * (o === "max" ? 1 : -1);
+    }
+    return i;
+  }
+  /**
+   * 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 = c(this, Y).size;
+    if (t.media.width === 0 || t.media.height === 0) return;
+    const i = t.media.width - this.yAxisWidth, e = t.media.height - this.xAxisHeight;
+    this.timeScale.update(c(this, B).visibleRange, i, t.horizontalPixelRatio), this.yScale.update(c(this, B).yRange, e, t.verticalPixelRatio);
+  }
+  updateScales(t = !1) {
+    const i = c(this, Y).size;
+    if (i.media.width === 0 || i.media.height === 0) return;
+    const e = i.media.width - this.yAxisWidth, a = i.media.height - this.xAxisHeight;
+    this.timeScale.update(c(this, B).visibleRange, e, i.horizontalPixelRatio), this.yScale.update(c(this, B).yRange, a, i.verticalPixelRatio), this.updateYRange(t), this.yScale.update(c(this, B).yRange, a, i.verticalPixelRatio);
+  }
+  /** Expensive: background, grid, all series. Only on data/viewport/resize change. */
+  renderMain() {
+    const t = c(this, Y).size;
+    if (!(t.media.width === 0 || t.media.height === 0)) {
+      c(this, B).tick(performance.now()) && c(this, V).markDirty(), this.updateScales(), c(this, Y).useMainLayer((i) => {
+        const { context: e, bitmapSize: a } = i, o = (t.media.width - this.yAxisWidth) * t.horizontalPixelRatio, s = (t.media.height - this.xAxisHeight) * t.verticalPixelRatio;
+        e.clearRect(0, 0, a.width, a.height), e.save(), e.beginPath(), e.rect(0, 0, o, s), e.clip(), c(this, St) && Xe(i, this.timeScale, this.yScale, c(this, W), c(this, N));
+        for (const n of c(this, M))
+          n.visible && n.renderer.render({
+            scope: i,
+            timeScale: this.timeScale,
+            yScale: this.yScale,
+            theme: c(this, W),
+            dataInterval: c(this, N)
+          });
+        e.restore();
+      });
+      for (const i of c(this, M))
+        if (i.renderer instanceof lt && i.renderer.needsAnimation) {
+          c(this, V).markDirty();
+          break;
+        }
+      this.renderOverlay();
+    }
+  }
+  /** Cheap overlay: crosshair, nearest-point dots, pulse animation. */
+  renderOverlay() {
+    const t = c(this, Y).size;
+    if (t.media.width === 0 || t.media.height === 0) return;
+    let i = !1;
+    for (const e of c(this, M))
+      if (e.visible && e.renderer instanceof G && e.renderer.hasPulse) {
+        i = !0;
+        break;
+      }
+    if (c(this, Y).useOverlayLayer((e) => {
+      if (!c(this, ot) && !i) return;
+      const a = (t.media.width - this.yAxisWidth) * t.horizontalPixelRatio, o = (t.media.height - this.xAxisHeight) * t.verticalPixelRatio;
+      if (e.context.save(), e.context.beginPath(), e.context.rect(0, 0, a, o), e.context.clip(), c(this, ot)) {
+        const s = c(this, ot).mediaX * t.horizontalPixelRatio, n = c(this, ot).mediaY * t.verticalPixelRatio;
+        $e(e, s, n, c(this, W));
+        for (const l of c(this, M))
+          if (l.visible && l.renderer instanceof G) {
+            const h = l.renderer, d = h.getColors(), g = h.getStacking(), f = 4 * t.horizontalPixelRatio, p = [], m = [];
+            for (let u = 0; u < h.stores.length; u++) {
+              const v = h.stores[u].findNearest(c(this, ot).time, c(this, N));
+              v ? (p.push(v.value), m.push(v.time)) : (p.push(0), m.push(0));
+            }
+            const b = [];
+            if (g === "off")
+              for (const u of p) b.push(u);
+            else {
+              let u = 0;
+              if (g === "percent")
+                for (const y of p) u += y;
+              let v = 0;
+              for (const y of p)
+                v += g === "percent" && u > 0 ? y / u * 100 : y, b.push(v);
+            }
+            for (let u = 0; u < h.stores.length; u++) {
+              if (m[u] === 0 || !h.stores[u].isVisible()) continue;
+              const v = d[u % d.length], y = this.timeScale.timeToBitmapX(m[u]), x = this.yScale.valueToBitmapY(b[u]);
+              e.context.beginPath(), e.context.arc(y, x, f + 3 * t.horizontalPixelRatio, 0, Math.PI * 2);
+              const C = v.startsWith("#") ? v + "40" : /^rgb\(/i.test(v) ? v.replace(/^rgb\((.*)\)$/i, "rgba($1, 0.25)") : v.replace(/[\d.]+\)\s*$/, "0.25)");
+              e.context.fillStyle = C, e.context.fill(), e.context.beginPath(), e.context.arc(y, x, f, 0, Math.PI * 2), e.context.fillStyle = v, e.context.fill();
+            }
+          }
+      }
+      for (const s of c(this, M))
+        s.visible && s.renderer instanceof G && s.renderer.hasPulse && s.renderer.drawPulseOverlay(
+          e.context,
+          this.timeScale,
+          this.yScale,
+          t.horizontalPixelRatio
+        );
+      e.context.restore();
+    }), i) {
+      const { from: e, to: a } = this.timeScale.getRange();
+      let o = !1;
+      for (const s of c(this, M))
+        if (!(!s.visible || !(s.renderer instanceof G) || !s.renderer.hasPulse)) {
+          for (const n of s.renderer.stores) {
+            const l = n.last();
+            if (l && l.time >= e && l.time <= a) {
+              o = !0;
+              break;
+            }
+          }
+          if (o) break;
+        }
+      o && c(this, ft).markDirty();
+    }
+  }
+}
+Y = /* @__PURE__ */ new WeakMap(), B = /* @__PURE__ */ new WeakMap(), V = /* @__PURE__ */ new WeakMap(), ft = /* @__PURE__ */ new WeakMap(), wt = /* @__PURE__ */ new WeakMap(), M = /* @__PURE__ */ new WeakMap(), W = /* @__PURE__ */ new WeakMap(), St = /* @__PURE__ */ new WeakMap(), N = /* @__PURE__ */ new WeakMap(), ot = /* @__PURE__ */ new WeakMap(), $ = /* @__PURE__ */ new WeakMap(), tt = /* @__PURE__ */ new WeakMap(), Xt = /* @__PURE__ */ new WeakMap(), gt = /* @__PURE__ */ new WeakMap(), at = /* @__PURE__ */ new WeakMap(), kt = /* @__PURE__ */ new WeakMap(), ht = /* @__PURE__ */ new WeakMap(), pt = /* @__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.
+*/
+Mt = function(r) {
+  if (r && !c(this, M).some((i) => i.id === r))
+    return r;
+  let t;
+  do
+    t = `series_${++pi}`;
+  while (c(this, M).some((i) => i.id === t));
+  return t;
+}, Wt = /* @__PURE__ */ new WeakMap(), K = /* @__PURE__ */ new WeakMap(), q = /* @__PURE__ */ new WeakMap(), mt = /* @__PURE__ */ new WeakMap();
+const yo = {
+  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 bi(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 I(r) {
+  var t, i, e, a, o, s, n, l, h, d, g, f, p, m, b, u, v, y, x, C, T, k, D, z, _, P, X, H, Q;
+  const { background: U, name: nt = "Custom", description: E, fontUrl: O = null } = r, A = bi(U), Te = A ? "#d1d4dc" : "#24292f", De = A ? "#787b86" : "#8b949e", oe = A ? "#26a69a" : "#2da44e", re = A ? "#ef5350" : "#cf222e", Be = A ? "#2962ff" : "#0969da", ze = A ? "rgba(42,46,57,0.6)" : "rgba(200,200,200,0.5)", Fe = A ? "rgba(150,150,150,0.5)" : "rgba(170,170,170,0.3)", ae = A ? Lt(U, 0.1) : me(U, 0.05), Pe = A ? yt(U, 0.92) : yt(U, 0.95), Le = A ? yt(Lt(U, 0.15), 0.6) : "rgba(200,200,200,0.5)", We = Yt, Ut = ((t = r.candlestick) == null ? void 0 : t.upColor) ?? oe, zt = ((i = r.candlestick) == null ? void 0 : i.downColor) ?? re, vt = ((e = r.line) == null ? void 0 : e.color) ?? Be, se = ((a = r.tooltip) == null ? void 0 : a.textColor) ?? Te, Ae = ((o = r.axis) == null ? void 0 : o.textColor) ?? De, Ie = ((s = r.typography) == null ? void 0 : s.fontFamily) ?? We, Ve = {
+    background: U,
+    chartGradient: r.chartGradient ?? (A ? [Lt(U, 0.04), me(U, 0.06)] : [Lt(U, 0.06), U]),
+    typography: {
+      fontFamily: Ie,
+      fontSize: ((n = r.typography) == null ? void 0 : n.fontSize) ?? 12,
+      axisFontSize: ((l = r.typography) == null ? void 0 : l.axisFontSize) ?? 10,
+      yFontSize: ((h = r.typography) == null ? void 0 : h.yFontSize) ?? 11,
+      tooltipFontSize: ((d = r.typography) == null ? void 0 : d.tooltipFontSize) ?? ((g = r.typography) == null ? void 0 : g.fontSize) ?? 12
+    },
+    grid: {
+      color: ((f = r.grid) == null ? void 0 : f.color) ?? ze,
+      style: ((p = r.grid) == null ? void 0 : p.style) ?? "dashed"
+    },
+    candlestick: {
+      upColor: Ut,
+      downColor: zt,
+      wickUpColor: ((m = r.candlestick) == null ? void 0 : m.wickUpColor) ?? Ut,
+      wickDownColor: ((b = r.candlestick) == null ? void 0 : b.wickDownColor) ?? zt
+    },
+    line: {
+      color: vt,
+      width: ((u = r.line) == null ? void 0 : u.width) ?? 1,
+      areaTopColor: ((v = r.line) == null ? void 0 : v.areaTopColor) ?? yt(vt, 0.08),
+      areaBottomColor: ((y = r.line) == null ? void 0 : y.areaBottomColor) ?? yt(vt, 0.01)
+    },
+    seriesColors: r.seriesColors ?? [vt, oe, re],
+    bands: {
+      upper: ((x = r.bands) == null ? void 0 : x.upper) ?? vt,
+      lower: ((C = r.bands) == null ? void 0 : C.lower) ?? zt
+    },
+    crosshair: {
+      color: ((T = r.crosshair) == null ? void 0 : T.color) ?? Fe,
+      labelBackground: ((k = r.crosshair) == null ? void 0 : k.labelBackground) ?? ae,
+      labelTextColor: ((D = r.crosshair) == null ? void 0 : D.labelTextColor) ?? se
+    },
+    axis: { textColor: Ae },
+    yLabel: {
+      upBackground: ((z = r.yLabel) == null ? void 0 : z.upBackground) ?? Ut,
+      downBackground: ((_ = r.yLabel) == null ? void 0 : _.downBackground) ?? zt,
+      neutralBackground: ((P = r.yLabel) == null ? void 0 : P.neutralBackground) ?? ae,
+      textColor: ((X = r.yLabel) == null ? void 0 : X.textColor) ?? "#ffffff"
+    },
+    tooltip: {
+      background: ((H = r.tooltip) == null ? void 0 : H.background) ?? Pe,
+      textColor: se,
+      borderColor: ((Q = r.tooltip) == null ? void 0 : Q.borderColor) ?? Le
+    }
+  };
+  return { name: nt, description: E, fontUrl: O, dark: A, theme: Ve };
+}
+function yt(r, t) {
+  const i = parseInt(r.slice(1, 3), 16), e = parseInt(r.slice(3, 5), 16), a = parseInt(r.slice(5, 7), 16);
+  return `rgba(${i}, ${e}, ${a}, ${t})`;
+}
+function Lt(r, t) {
+  if (!r.startsWith("#")) return r;
+  const i = Math.min(255, Math.round(parseInt(r.slice(1, 3), 16) + 255 * t)), e = Math.min(255, Math.round(parseInt(r.slice(3, 5), 16) + 255 * t)), a = Math.min(255, Math.round(parseInt(r.slice(5, 7), 16) + 255 * t));
+  return `#${i.toString(16).padStart(2, "0")}${e.toString(16).padStart(2, "0")}${a.toString(16).padStart(2, "0")}`;
+}
+function me(r, t) {
+  if (!r.startsWith("#")) return r;
+  const i = Math.max(0, Math.round(parseInt(r.slice(1, 3), 16) * (1 - t))), e = Math.max(0, Math.round(parseInt(r.slice(3, 5), 16) * (1 - t))), a = Math.max(0, Math.round(parseInt(r.slice(5, 7), 16) * (1 - t)));
+  return `#${i.toString(16).padStart(2, "0")}${e.toString(16).padStart(2, "0")}${a.toString(16).padStart(2, "0")}`;
+}
+const It = "'JetBrains Mono', 'Fira Code', monospace", Vt = "https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;600&display=swap", Yt = "'Outfit', -apple-system, BlinkMacSystemFont, sans-serif", Kt = "https://fonts.googleapis.com/css2?family=Outfit:wght@400;500;600&display=swap", we = "'Roboto Mono', monospace", Se = "https://fonts.googleapis.com/css2?family=Roboto+Mono:wght@400;500;600&display=swap", vi = "'IBM Plex Mono', monospace", yi = "https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@400;500;600&display=swap", qt = "'Fira Code', monospace", Qt = "https://fonts.googleapis.com/css2?family=Fira+Code:wght@400;500;600&display=swap", ke = "'Source Code Pro', monospace", Me = "https://fonts.googleapis.com/css2?family=Source+Code+Pro:wght@400;500;600&display=swap", xi = "'Space Mono', monospace", Ci = "https://fonts.googleapis.com/css2?family=Space+Mono:wght@400;700&display=swap", Zt = "'Plus Jakarta Sans', sans-serif", te = "https://fonts.googleapis.com/css2?family=Plus+Jakarta+Sans:wght@400;500;600;700&display=swap", wi = "'Caveat', 'Comic Sans MS', cursive", Si = "https://fonts.googleapis.com/css2?family=Caveat:wght@400;500;600;700&display=swap", ki = I({
+  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: we },
+  fontUrl: Se
+}), Mi = I({
+  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: Yt },
+  fontUrl: Kt
+}), Ri = I({
+  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: Yt },
+  fontUrl: Kt
+}), Ti = I({
+  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: Qt
+}), Di = I({
+  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: vi },
+  fontUrl: yi
+}), Bi = I({
+  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: It },
+  fontUrl: Vt
+}), zi = {
+  name: "Handwritten",
+  description: "Sketch-style with a personal touch",
+  fontUrl: Si,
+  dark: !1,
+  theme: {
+    background: "#fdf5e6",
+    chartGradient: ["#fef6e3", "#fdf5e6"],
+    typography: {
+      fontFamily: wi,
+      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)"
+    }
+  }
+}, Fi = "'Silkscreen', cursive", Pi = "https://fonts.googleapis.com/css2?family=Silkscreen:wght@400;700&display=swap", Li = I({
+  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: Fi },
+  fontUrl: Pi,
+  chartGradient: ["#010a01", "#000000"]
+}), Wi = I({
+  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: Zt },
+  fontUrl: te,
+  chartGradient: ["#f8f4f7", "#f5f0f4"]
+}), Ai = I({
+  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: Yt },
+  fontUrl: Kt
+}), Ii = I({
+  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: we },
+  fontUrl: Se
+}), Vi = "'Silkscreen', cursive", Yi = "https://fonts.googleapis.com/css2?family=Silkscreen:wght@400;700&display=swap", _i = I({
+  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: Vi, tooltipFontSize: 9 },
+  fontUrl: Yi
+}), Ui = I({
+  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: xi },
+  fontUrl: Ci,
+  chartGradient: ["#f8f7f0", "#f6f5ee"]
+}), Ei = I({
+  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: Qt
+}), Oi = I({
+  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: It },
+  fontUrl: Vt
+}), $i = I({
+  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: It },
+  fontUrl: Vt
+}), Xi = I({
+  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: Qt
+}), Hi = I({
+  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: Zt },
+  fontUrl: te,
+  chartGradient: ["#fff8f2", "#fef6f0"]
+}), Gi = I({
+  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: Zt },
+  fontUrl: te
+}), Ni = I({
+  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: ke },
+  fontUrl: Me
+}), ji = I({
+  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: ke },
+  fontUrl: Me,
+  chartGradient: ["#f8f4ec", "#f4f0e8"]
+}), Ji = I({
+  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: It },
+  fontUrl: Vt
+}), be = {
+  Dracula: Ti,
+  "One Dark Pro": $i,
+  "Monokai Pro": Ei,
+  "Night Owl": Oi,
+  "Material Palenight": Ii,
+  Gruvbox: Bi,
+  Catppuccin: Ri,
+  "Ayu Mirage": Mi,
+  Panda: Xi,
+  Andromeda: ki,
+  Matrix: Li,
+  Handwritten: zi,
+  "GitHub Light": Di,
+  "Solarized Light": Ji,
+  "Rosé Pine Dawn": Ni,
+  "Quiet Light": Gi,
+  "Lavender Mist": Wi,
+  "Mint Breeze": Ui,
+  "Sand Dune": ji,
+  "Peach Cream": Hi,
+  Monochrome: _i,
+  Love: Ai
+};
+function xo(r) {
+  return (be[r] ?? be["One Dark Pro"]).theme;
+}
+const Ht = ye(null);
+function J() {
+  const r = Gt(Ht);
+  if (!r)
+    throw new Error("useChartInstance must be used within <ChartContainer>");
+  return r;
+}
+function Ki({ data: r, options: t, label: i, id: e, onSeriesId: a }) {
+  var n;
+  const o = J(), s = et(null);
+  return it(() => {
+    const l = o.addBarSeries({ ...t, label: i ?? (t == null ? void 0 : t.label), layers: r.length, id: e });
+    return s.current = l, a == null || a(l), () => {
+      o.removeSeries(l), s.current = null;
+    };
+  }, [o, r.length, e]), it(() => {
+    const l = s.current;
+    l && o.batch(() => {
+      for (let h = 0; h < r.length; h++)
+        o.setBarLayerData(l, h, r[h]);
+    });
+  }, [o, r]), j(() => {
+    s.current && t && o.updateSeriesOptions(s.current, t);
+  }, [o, (n = t == null ? void 0 : t.colors) == null ? void 0 : n.join(","), t == null ? void 0 : t.barWidthRatio, t == null ? void 0 : t.stacking]), null;
+}
+function Co({ data: r, options: t, id: i, onSeriesId: e }) {
+  const a = J(), o = et(null), s = et(0);
+  return it(() => {
+    const n = a.addCandlestickSeries({ ...t, id: i });
+    return o.current = n, e == null || e(n), () => {
+      a.removeSeries(n), o.current = null, s.current = 0;
+    };
+  }, [a, i]), it(() => {
+    const n = o.current;
+    if (!n) return;
+    if (r.length === 0) {
+      a.setSeriesData(n, []), s.current = 0;
+      return;
+    }
+    const l = s.current;
+    if (l === 0 || r.length < l || r.length - l > 5)
+      a.setSeriesData(n, r);
+    else if (r.length === l)
+      a.updateData(n, r[r.length - 1]);
+    else
+      for (let h = l; h < r.length; h++)
+        a.appendData(n, r[h]);
+    s.current = r.length;
+  }, [a, r]), j(() => {
+    o.current && t && a.updateSeriesOptions(o.current, t);
+  }, [
+    a,
+    t == null ? void 0 : t.upColor,
+    t == null ? void 0 : t.downColor,
+    t == null ? void 0 : t.wickUpColor,
+    t == null ? void 0 : t.wickDownColor,
+    t == null ? void 0 : t.bodyWidthRatio,
+    t == null ? void 0 : t.candleGradient
+  ]), null;
+}
+const ee = ye(null), ve = ee.Provider;
+function qi() {
+  const r = Gt(ee);
+  if (!r)
+    throw new Error("useTheme must be used within <ThemeProvider>");
+  return r;
+}
+function Qi() {
+  return Gt(ee);
+}
+function Zi({ items: r, position: t = "bottom", mode: i = "toggle" }) {
+  const e = J(), a = qi(), [o, s] = Rt(/* @__PURE__ */ new Set()), [, n] = Rt(0);
+  it(() => {
+    const f = () => {
+      n((m) => m + 1), s(/* @__PURE__ */ new Set());
+    }, p = () => n((m) => m + 1);
+    return e.on("seriesChange", f), e.on("dataUpdate", p), e.getSeriesIds().length > 0 && n((m) => m + 1), () => {
+      e.off("seriesChange", f), e.off("dataUpdate", p);
+    };
+  }, [e]);
+  const l = (r == null ? void 0 : r.map((f, p) => ({ ...f, seriesId: "", layerIndex: p, isLayer: !1 }))) ?? (() => {
+    const f = [];
+    for (const p of e.getSeriesIds()) {
+      const m = e.getSeriesLayers(p);
+      if (m) {
+        const b = e.getSeriesLabel(p);
+        for (let u = 0; u < m.length; u++)
+          f.push({
+            label: b ? `${b} ${u + 1}` : `Series ${u + 1}`,
+            color: m[u].color,
+            seriesId: p,
+            layerIndex: u,
+            isLayer: !0
+          });
+      } else {
+        const b = e.getSeriesColor(p), u = e.getSeriesLabel(p);
+        b && f.push({ label: u ?? "Series", color: b, seriesId: p, layerIndex: 0, isLayer: !1 });
+      }
+    }
+    return f;
+  })();
+  if (l.length === 0) return null;
+  const h = (f) => {
+    s(f), e.beginUpdate();
+    for (let p = 0; p < l.length; p++) {
+      const m = l[p];
+      m.seriesId && (m.isLayer ? e.setLayerVisible(m.seriesId, m.layerIndex, !f.has(p)) : e.setSeriesVisible(m.seriesId, !f.has(p)));
+    }
+    e.endUpdate();
+  }, d = (f) => {
+    if (i === "solo")
+      if (l.every((m, b) => b === f || o.has(b)))
+        h(/* @__PURE__ */ new Set());
+      else {
+        const m = new Set(l.map((b, u) => u));
+        m.delete(f), h(m);
+      }
+    else {
+      const p = new Set(o);
+      p.has(f) ? p.delete(f) : p.add(f), h(p);
+    }
+  }, g = t === "right";
+  return /* @__PURE__ */ S(
+    "div",
+    {
+      "data-legend": t,
+      style: {
+        display: "flex",
+        flexDirection: g ? "column" : "row",
+        flexWrap: "wrap",
+        gap: g ? 6 : 14,
+        padding: g ? "8px 6px" : "6px 8px",
+        alignItems: g ? "flex-start" : "center",
+        justifyContent: g ? "flex-start" : "center",
+        fontFamily: a.typography.fontFamily,
+        fontSize: a.typography.axisFontSize,
+        color: a.axis.textColor,
+        pointerEvents: "auto",
+        flexShrink: 0
+      },
+      children: l.map((f, p) => {
+        const m = o.has(p), b = !!f.seriesId;
+        return /* @__PURE__ */ F(
+          "div",
+          {
+            onClick: b ? () => d(p) : void 0,
+            style: {
+              display: "flex",
+              alignItems: "center",
+              gap: 4,
+              cursor: b ? "pointer" : "default",
+              opacity: m ? 0.35 : 1,
+              transition: "opacity 0.15s ease",
+              userSelect: "none"
+            },
+            children: [
+              /* @__PURE__ */ S(
+                "span",
+                {
+                  style: {
+                    width: 8,
+                    height: 8,
+                    borderRadius: 2,
+                    background: f.color,
+                    flexShrink: 0
+                  }
+                }
+              ),
+              /* @__PURE__ */ S("span", { style: { whiteSpace: "nowrap" }, children: f.label })
+            ]
+          },
+          p
+        );
+      })
+    }
+  );
+}
+function to({ children: r, theme: t, axis: i, padding: e, gradient: a = !0, interactive: o, grid: s, style: n, className: l }) {
+  var _, P, X, H, Q, U, nt;
+  const h = Qi(), d = t ?? h ?? void 0, g = et(null), f = et(null), [p, m] = Rt(0);
+  it(() => {
+    if (!g.current || f.current) return;
+    const E = {};
+    return i && (E.axis = i), d && (E.theme = d), e && (E.padding = e), o !== void 0 && (E.interactive = o), s !== void 0 && (E.grid = s), f.current = new mi(g.current, E), m((O) => O + 1), () => {
+      const O = f.current;
+      f.current = null, setTimeout(() => {
+        f.current || O == null || O.destroy();
+      }, 0);
+    };
+  }, []), j(() => {
+    f.current && d && f.current.setTheme(d);
+  }, [d]), j(() => {
+    f.current && i && f.current.setAxis(i);
+  }, [(_ = i == null ? void 0 : i.y) == null ? void 0 : _.width, (P = i == null ? void 0 : i.y) == null ? void 0 : P.min, (X = i == null ? void 0 : i.y) == null ? void 0 : X.max, (H = i == null ? void 0 : i.y) == null ? void 0 : H.visible, (Q = i == null ? void 0 : i.x) == null ? void 0 : Q.height, (U = i == null ? void 0 : i.x) == null ? void 0 : U.visible]), j(() => {
+    f.current && e && f.current.setPadding(e);
+  }, [
+    e == null ? void 0 : e.top,
+    e == null ? void 0 : e.bottom,
+    typeof (e == null ? void 0 : e.right) == "object" ? e.right.intervals : e == null ? void 0 : e.right,
+    typeof (e == null ? void 0 : e.left) == "object" ? e.left.intervals : e == null ? void 0 : e.left
+  ]), j(() => {
+    f.current && s !== void 0 && f.current.setGrid(s);
+  }, [s]);
+  const b = f.current, { legendEl: u, overlay: v } = (() => {
+    let E = null;
+    const O = [];
+    return Ye.forEach(r, (A) => {
+      _e(A) && A.type === Zi ? E = A : O.push(A);
+    }), { legendEl: E, overlay: O };
+  })(), x = (((nt = u == null ? void 0 : u.props) == null ? void 0 : nt.position) ?? "bottom") === "right", C = d ?? (b == null ? void 0 : b.getTheme()), [T, k] = (C == null ? void 0 : C.chartGradient) ?? ["transparent", "transparent"], D = (C == null ? void 0 : C.background) ?? "transparent", z = a ? `linear-gradient(to bottom, ${T} 0%, ${D} 70%, ${k} 100%)` : D;
+  return /* @__PURE__ */ F(
+    "div",
+    {
+      className: l,
+      style: {
+        display: "flex",
+        flexDirection: x ? "row" : "column",
+        width: "100%",
+        height: "100%",
+        overflow: "hidden",
+        background: z,
+        ...n
+      },
+      children: [
+        /* @__PURE__ */ S(
+          "div",
+          {
+            ref: g,
+            style: {
+              position: "relative",
+              flex: 1,
+              minWidth: 0,
+              minHeight: 0,
+              overflow: "hidden"
+            },
+            children: b && /* @__PURE__ */ S(Ht.Provider, { value: b, children: /* @__PURE__ */ S(ve, { value: d ?? b.getTheme(), children: /* @__PURE__ */ S(
+              "div",
+              {
+                style: {
+                  position: "absolute",
+                  inset: 0,
+                  pointerEvents: "none",
+                  zIndex: 2
+                },
+                children: v
+              }
+            ) }) })
+          }
+        ),
+        b && u && /* @__PURE__ */ S(Ht.Provider, { value: b, children: /* @__PURE__ */ S(ve, { value: d ?? b.getTheme(), children: u }) })
+      ]
+    }
+  );
+}
+function eo({ data: r, options: t, label: i, id: e, onSeriesId: a }) {
+  var n;
+  const o = J(), s = et(null);
+  return it(() => {
+    const l = o.addLineSeries({ ...t, label: i ?? (t == null ? void 0 : t.label), layers: r.length, id: e });
+    return s.current = l, a == null || a(l), () => {
+      o.removeSeries(l), s.current = null;
+    };
+  }, [o, r.length, e]), it(() => {
+    const l = s.current;
+    l && o.batch(() => {
+      for (let h = 0; h < r.length; h++)
+        o.setLineLayerData(l, h, r[h]);
+    });
+  }, [o, r]), j(() => {
+    s.current && t && o.updateSeriesOptions(s.current, t);
+  }, [o, (n = t == null ? void 0 : t.colors) == null ? void 0 : n.join(","), t == null ? void 0 : t.lineWidth, t == null ? void 0 : t.areaFill, t == null ? void 0 : t.pulse, t == null ? void 0 : t.stacking]), null;
+}
+function wo({ data: r, options: t, id: i, onSeriesId: e }) {
+  const a = J(), o = et(null);
+  return it(() => {
+    const s = a.addPieSeries({ ...t, id: i });
+    return o.current = s, e == null || e(s), () => {
+      a.removeSeries(s), o.current = null;
+    };
+  }, [a, i]), j(() => {
+    o.current && t && a.updateSeriesOptions(o.current, t);
+  }, [
+    a,
+    t == null ? void 0 : t.innerRadiusRatio,
+    t == null ? void 0 : t.padAngle,
+    t == null ? void 0 : t.strokeColor,
+    t == null ? void 0 : t.strokeWidth,
+    t == null ? void 0 : t.colors
+  ]), it(() => {
+    o.current && a.setPieData(o.current, r);
+  }, [a, r]), null;
+}
+function _t(r, t, i) {
+  const e = Array.isArray(t) ? t : [t];
+  return {
+    subscribe: (a) => {
+      for (const o of e) r.on(o, a);
+      return () => {
+        for (const o of e) r.off(o, a);
+      };
+    },
+    getSnapshot: i
+  };
+}
+function io(r) {
+  const t = dt(() => _t(r, ["viewportChange", "dataUpdate", "seriesChange"], () => r.getVisibleRange()), [r]);
+  return Tt(t.subscribe, t.getSnapshot);
+}
+function oo(r) {
+  const t = dt(() => _t(r, ["viewportChange", "dataUpdate", "seriesChange"], () => r.getYRange()), [r]);
+  return Tt(t.subscribe, t.getSnapshot);
+}
+function ro(r, t) {
+  const i = dt(() => {
+    let e = r.getLastValue(t);
+    return {
+      subscribe: (o) => {
+        const s = () => {
+          const l = r.getLastValue(t);
+          (e == null ? void 0 : e.value) === (l == null ? void 0 : l.value) && (e == null ? void 0 : e.isLive) === (l == null ? void 0 : l.isLive) || (e = l, o());
+        }, n = () => {
+          const l = r.getLastValue(t), h = l ? r.yScale.valueToY(l.value) : null, d = e ? r.yScale.valueToY(e.value) : null;
+          h === d && (e == null ? void 0 : e.value) === (l == null ? void 0 : l.value) && (e == null ? void 0 : e.isLive) === (l == null ? void 0 : l.isLive) || (e = l, o());
+        };
+        return r.on("dataUpdate", s), r.on("viewportChange", n), () => {
+          r.off("dataUpdate", s), r.off("viewportChange", n);
+        };
+      },
+      getSnapshot: () => e
+    };
+  }, [r, t]);
+  return Tt(i.subscribe, i.getSnapshot);
+}
+function ao(r, t) {
+  const i = dt(
+    () => _t(r, "dataUpdate", () => r.getPreviousClose(t)),
+    [r, t]
+  );
+  return Tt(i.subscribe, i.getSnapshot);
+}
+function ie(r) {
+  const t = dt(() => _t(r, "crosshairMove", () => r.getCrosshairPosition()), [r]);
+  return Tt(t.subscribe, t.getSnapshot);
+}
+function So() {
+  const r = J(), t = ie(r);
+  if (!t) return null;
+  const i = r.getTheme(), e = r.getDataInterval(), a = {
+    background: i.crosshair.labelBackground,
+    color: i.crosshair.labelTextColor,
+    fontSize: i.typography.axisFontSize,
+    fontFamily: i.typography.fontFamily,
+    padding: "2px 6px",
+    borderRadius: 2,
+    whiteSpace: "nowrap",
+    pointerEvents: "none"
+  };
+  return /* @__PURE__ */ F(Dt, { children: [
+    /* @__PURE__ */ S(
+      "div",
+      {
+        style: {
+          position: "absolute",
+          right: 0,
+          top: t.mediaY,
+          transform: "translateY(-50%)",
+          ...a
+        },
+        children: r.yScale.formatY(t.y)
+      }
+    ),
+    /* @__PURE__ */ S(
+      "div",
+      {
+        style: {
+          position: "absolute",
+          bottom: 0,
+          left: t.mediaX,
+          transform: "translateX(-50%)",
+          ...a
+        },
+        children: At(t.time, e)
+      }
+    )
+  ] });
+}
+const so = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"];
+function no(r) {
+  const t = [];
+  for (const i of r)
+    i >= "0" && i <= "9" ? t.push({ type: "digit", value: i }) : t.push({ type: "symbol", value: i });
+  return t;
+}
+function lo({ value: r, format: t, locale: i = "en-US", spinDuration: e = 350, className: a, style: o }) {
+  const n = dt(() => new Intl.NumberFormat(i, t), [i, t]).format(r), l = no(n);
+  return /* @__PURE__ */ S(
+    "span",
+    {
+      className: a,
+      style: {
+        display: "inline-flex",
+        fontVariantNumeric: "tabular-nums",
+        lineHeight: 1.2,
+        ...o
+      },
+      children: l.map(
+        (h, d) => h.type === "digit" ? /* @__PURE__ */ S(co, { digit: parseInt(h.value), duration: e }, `d${d}`) : /* @__PURE__ */ S("span", { style: { display: "inline-block" }, children: h.value }, `s${d}`)
+      )
+    }
+  );
+}
+function co({ digit: r, duration: t }) {
+  const i = et(!1);
+  return j(() => {
+    i.current = !0;
+  }, []), /* @__PURE__ */ S(
+    "span",
+    {
+      style: {
+        display: "inline-block",
+        height: "1.2em",
+        overflow: "hidden",
+        position: "relative"
+      },
+      children: /* @__PURE__ */ S(
+        "span",
+        {
+          style: {
+            display: "flex",
+            flexDirection: "column",
+            transform: `translateY(${-r * 1.2}em)`,
+            transition: i.current ? `transform ${t}ms cubic-bezier(0.16, 1, 0.3, 1)` : "none"
+          },
+          children: so.map((e) => /* @__PURE__ */ S(
+            "span",
+            {
+              style: {
+                display: "flex",
+                alignItems: "center",
+                justifyContent: "center",
+                height: "1.2em"
+              },
+              children: e
+            },
+            e
+          ))
+        }
+      )
+    }
+  );
+}
+function ho(r) {
+  return r >= 1e9 ? (r / 1e9).toFixed(1) + "B" : r >= 1e6 ? (r / 1e6).toFixed(1) + "M" : r >= 1e3 ? (r / 1e3).toFixed(1) + "K" : r.toLocaleString();
+}
+function ko({ seriesId: r, format: t = "value" }) {
+  const i = J(), e = i.getTheme(), [, a] = Rt(0);
+  j(() => {
+    const s = () => a((n) => n + 1);
+    return i.on("dataUpdate", s), () => {
+      i.off("dataUpdate", s);
+    };
+  }, [i]);
+  const o = i.getPieSlices(r);
+  return !o || o.length === 0 ? null : /* @__PURE__ */ S(
+    "div",
+    {
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        gap: 6,
+        padding: "8px 12px",
+        fontFamily: e.typography.fontFamily,
+        fontSize: e.typography.fontSize,
+        color: e.tooltip.textColor,
+        pointerEvents: "auto"
+      },
+      children: o.map((s, n) => /* @__PURE__ */ F(
+        "div",
+        {
+          style: {
+            display: "flex",
+            alignItems: "center",
+            gap: 10
+          },
+          children: [
+            /* @__PURE__ */ S(
+              "span",
+              {
+                style: {
+                  width: 10,
+                  height: 10,
+                  borderRadius: "50%",
+                  background: s.color,
+                  flexShrink: 0
+                }
+              }
+            ),
+            /* @__PURE__ */ S("span", { style: { flex: 1, opacity: 0.8 }, children: s.label }),
+            t === "value" && /* @__PURE__ */ S("span", { style: { fontWeight: 600, fontVariantNumeric: "tabular-nums" }, children: ho(s.value) }),
+            /* @__PURE__ */ F(
+              "span",
+              {
+                style: {
+                  opacity: t === "percent" ? 1 : 0.5,
+                  fontWeight: t === "percent" ? 600 : 400,
+                  fontSize: t === "percent" ? e.typography.fontSize : e.typography.axisFontSize,
+                  fontVariantNumeric: "tabular-nums",
+                  minWidth: 40,
+                  textAlign: "right"
+                },
+                children: [
+                  s.percent.toFixed(1),
+                  "%"
+                ]
+              }
+            )
+          ]
+        },
+        n
+      ))
+    }
+  );
+}
+function Mo({ seriesId: r }) {
+  const t = J(), i = ie(t), e = t.getPieHoverInfo(r);
+  if (!e || !i) return null;
+  const a = t.getTheme(), o = t.getMediaSize(), s = 160, n = 70, l = 16, h = 16, d = i.mediaX + l + s > o.width ? i.mediaX - l - s : i.mediaX + l, g = i.mediaY + h + n > o.height ? i.mediaY - h - n : i.mediaY + h;
+  return /* @__PURE__ */ F(
+    "div",
+    {
+      style: {
+        position: "absolute",
+        left: d,
+        top: g,
+        pointerEvents: "none",
+        background: a.tooltip.background,
+        backdropFilter: "blur(12px)",
+        WebkitBackdropFilter: "blur(12px)",
+        border: `1px solid ${a.tooltip.borderColor}`,
+        borderRadius: 8,
+        padding: "10px 14px",
+        boxShadow: "0 4px 16px rgba(0,0,0,0.1), 0 1px 4px rgba(0,0,0,0.06)",
+        fontSize: a.typography.fontSize,
+        fontFamily: a.typography.fontFamily,
+        color: a.tooltip.textColor,
+        zIndex: 10,
+        display: "flex",
+        flexDirection: "column",
+        gap: 6
+      },
+      children: [
+        /* @__PURE__ */ F("div", { style: { display: "flex", alignItems: "center", gap: 8 }, children: [
+          /* @__PURE__ */ S(
+            "span",
+            {
+              style: {
+                width: 10,
+                height: 10,
+                borderRadius: "50%",
+                background: e.color,
+                flexShrink: 0
+              }
+            }
+          ),
+          /* @__PURE__ */ S("span", { style: { fontWeight: 600 }, children: e.label })
+        ] }),
+        /* @__PURE__ */ F("div", { style: { display: "flex", justifyContent: "space-between", gap: 16 }, children: [
+          /* @__PURE__ */ S("span", { style: { opacity: 0.6 }, children: e.value.toLocaleString() }),
+          /* @__PURE__ */ F("span", { style: { fontWeight: 600 }, children: [
+            e.percent.toFixed(1),
+            "%"
+          ] })
+        ] })
+      ]
+    }
+  );
+}
+function uo(r, t) {
+  if (r.startsWith("rgba") || !r.startsWith("#")) return r;
+  const i = parseInt(r.slice(1, 3), 16), e = parseInt(r.slice(3, 5), 16), a = parseInt(r.slice(5, 7), 16);
+  return `rgba(${i}, ${e}, ${a}, ${t})`;
+}
+function fo(r) {
+  return Math.abs(r) >= 1e6 ? `${(r / 1e6).toFixed(1)}M` : Math.abs(r) >= 1e4 ? `${(r / 1e3).toFixed(1)}K` : Math.abs(r) >= 1e3 ? `${(r / 1e3).toFixed(2)}K` : Math.abs(r) < 1 ? r.toFixed(4) : Math.abs(r) < 10 ? r.toFixed(2) : r.toFixed(1);
+}
+function go(r) {
+  if (r.length < 2) return { value: 0, pct: 0, positive: !0 };
+  const t = r[0].value, e = r[r.length - 1].value - t, a = t !== 0 ? e / t * 100 : 0;
+  return { value: e, pct: a, positive: e >= 0 };
+}
+function Ro({
+  data: r,
+  theme: t,
+  variant: i = "line",
+  valuePosition: e = "right",
+  formatValue: a = fo,
+  label: o,
+  sublabel: s,
+  color: n,
+  negativeColor: l,
+  areaFill: h = !0,
+  width: d = 140,
+  height: g = 48,
+  lineWidth: f = 1.5,
+  gradient: p = !0,
+  style: m
+}) {
+  const b = r.length > 0 ? r[r.length - 1].value : 0, u = dt(() => go(r), [r]), v = n ?? t.seriesColors[0], y = l ?? t.candlestick.downColor, x = u.positive ? t.candlestick.upColor : t.candlestick.downColor, C = e !== "none" && /* @__PURE__ */ F(
+    "div",
+    {
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        justifyContent: "center",
+        gap: 1,
+        minWidth: 0,
+        flexShrink: 0
+      },
+      children: [
+        o && /* @__PURE__ */ S(
+          "div",
+          {
+            style: {
+              fontSize: t.typography.axisFontSize,
+              color: t.axis.textColor,
+              lineHeight: 1.2,
+              whiteSpace: "nowrap",
+              overflow: "hidden",
+              textOverflow: "ellipsis"
+            },
+            children: o
+          }
+        ),
+        /* @__PURE__ */ S(
+          "div",
+          {
+            style: {
+              fontSize: t.typography.fontSize + 3,
+              fontWeight: 700,
+              color: t.tooltip.textColor,
+              lineHeight: 1.1,
+              whiteSpace: "nowrap",
+              fontVariantNumeric: "tabular-nums"
+            },
+            children: a(b)
+          }
+        ),
+        s !== void 0 ? /* @__PURE__ */ S(
+          "div",
+          {
+            style: {
+              fontSize: t.typography.axisFontSize - 1,
+              color: t.axis.textColor,
+              lineHeight: 1.2,
+              whiteSpace: "nowrap"
+            },
+            children: s
+          }
+        ) : /* @__PURE__ */ F(
+          "div",
+          {
+            style: {
+              fontSize: t.typography.axisFontSize - 1,
+              fontWeight: 500,
+              color: x,
+              lineHeight: 1.2,
+              whiteSpace: "nowrap",
+              fontVariantNumeric: "tabular-nums"
+            },
+            children: [
+              u.positive ? "+" : "",
+              u.pct.toFixed(1),
+              "%"
+            ]
+          }
+        )
+      ]
+    }
+  ), T = /* @__PURE__ */ S("div", { style: { width: d, height: g, flexShrink: 0, borderRadius: 4, overflow: "hidden" }, children: /* @__PURE__ */ S(
+    to,
+    {
+      theme: t,
+      axis: {
+        y: { visible: !1, width: 0 },
+        x: { visible: !1, height: 0 }
+      },
+      padding: { top: 5, right: 0, bottom: 0, left: 0 },
+      gradient: p,
+      interactive: !1,
+      grid: !1,
+      children: i === "line" ? /* @__PURE__ */ S(
+        eo,
+        {
+          data: [r],
+          options: {
+            colors: [v],
+            lineWidth: f,
+            areaFill: h,
+            pulse: !1,
+            stacking: "off"
+          }
+        }
+      ) : /* @__PURE__ */ S(
+        Ki,
+        {
+          data: [r],
+          options: {
+            colors: [v, y],
+            barWidthRatio: 0.7,
+            stacking: "off"
+          }
+        }
+      )
+    }
+  ) });
+  return /* @__PURE__ */ F(
+    "div",
+    {
+      style: {
+        display: "inline-flex",
+        alignItems: "center",
+        gap: 12,
+        padding: "8px 12px",
+        borderRadius: 8,
+        background: uo(t.tooltip.background, 0.7),
+        border: `1px solid ${t.tooltip.borderColor}`,
+        fontFamily: t.typography.fontFamily,
+        ...m
+      },
+      children: [
+        e === "left" && C,
+        T,
+        e === "right" && C
+      ]
+    }
+  );
+}
+function To() {
+  const r = J();
+  io(r);
+  const t = r.getTheme(), i = r.getDataInterval(), { ticks: e, tickInterval: a } = r.timeScale.niceTickValues(i), o = new Set(e), n = et(/* @__PURE__ */ new Map()).current, l = performance.now();
+  for (const d of e)
+    n.has(d) ? n.get(d).opacity = 1 : n.set(d, { opacity: 1, addedAt: l });
+  for (const [d, g] of n)
+    o.has(d) || g.opacity !== 0 && (g.opacity = 0, g.fadedAt = l);
+  for (const [d, g] of n)
+    g.opacity === 0 && g.fadedAt !== void 0 && l - g.fadedAt > 600 && n.delete(d);
+  const h = Array.from(n.entries());
+  return /* @__PURE__ */ S(
+    "div",
+    {
+      style: {
+        position: "absolute",
+        left: 0,
+        bottom: 0,
+        right: r.yAxisWidth,
+        height: r.xAxisHeight,
+        pointerEvents: "none",
+        display: "flex",
+        alignItems: "center"
+      },
+      children: h.map(([d, g]) => {
+        const f = r.timeScale.timeToX(d);
+        return /* @__PURE__ */ S(
+          "span",
+          {
+            style: {
+              position: "absolute",
+              left: f,
+              transform: "translateX(-50%)",
+              color: t.axis.textColor,
+              fontSize: t.typography.axisFontSize,
+              fontFamily: t.typography.fontFamily,
+              userSelect: "none",
+              whiteSpace: "nowrap",
+              opacity: g.opacity,
+              transition: "opacity 0.3s ease",
+              willChange: "opacity"
+            },
+            children: At(d, a)
+          },
+          d
+        );
+      })
+    }
+  );
+}
+function po(r, t) {
+  return t === "none" || r.length <= 1 ? r : [...r].sort((i, e) => {
+    const a = "value" in i.data ? i.data.value : i.data.close, o = "value" in e.data ? e.data.value : e.data.close;
+    return t === "asc" ? a - o : o - a;
+  });
+}
+function Do({ seriesId: r, sort: t = "none", showLegend: i, legend: e }) {
+  const a = i ?? e ?? !0, o = J(), s = ie(o), n = r ? [r] : o.getSeriesIds(), [, l] = Rt(0);
+  j(() => {
+    const u = () => l((v) => v + 1);
+    return o.on("dataUpdate", u), () => o.off("dataUpdate", u);
+  }, [o]);
+  const h = [];
+  if (s)
+    for (const u of n) {
+      const v = o.getLayerSnapshots(u, s.time);
+      if (v)
+        for (let y = 0; y < v.length; y++)
+          h.push({
+            id: `${u}_layer${y}`,
+            label: o.getSeriesLabel(u),
+            data: { time: s.time, value: v[y].value },
+            color: v[y].color
+          });
+      else {
+        const y = o.getDataAtTime(u, s.time);
+        y && h.push({
+          id: u,
+          label: o.getSeriesLabel(u),
+          data: y,
+          color: o.getSeriesColor(u) ?? "#888"
+        });
+      }
+    }
+  let d;
+  if (h.length > 0)
+    d = h;
+  else {
+    const u = [];
+    for (const v of n) {
+      const y = o.getLastData(v);
+      if (!y) continue;
+      const x = o.getLayerSnapshots(v, y.time);
+      if (x)
+        for (let C = 0; C < x.length; C++)
+          u.push({
+            id: `${v}_layer${C}`,
+            label: o.getSeriesLabel(v),
+            data: { time: y.time, value: x[C].value },
+            color: x[C].color
+          });
+      else
+        u.push({ id: v, label: o.getSeriesLabel(v), data: y, color: o.getSeriesColor(v) ?? "#888" });
+    }
+    d = u;
+  }
+  const g = po(d, t), f = o.getTheme();
+  if (g.length === 0) return null;
+  const p = o.getDataInterval(), m = o.getMediaSize(), b = g[0].data.time;
+  return /* @__PURE__ */ F(Dt, { children: [
+    a && /* @__PURE__ */ F(
+      "div",
+      {
+        style: {
+          position: "absolute",
+          top: 24,
+          left: 8,
+          pointerEvents: "none",
+          display: "flex",
+          alignItems: "center",
+          gap: 4,
+          flexWrap: "wrap",
+          maxWidth: "70%",
+          fontSize: f.typography.fontSize,
+          fontFamily: f.typography.fontFamily,
+          fontVariantNumeric: "tabular-nums",
+          opacity: s ? 1 : 0.6,
+          transition: "opacity 0.2s ease"
+        },
+        children: [
+          /* @__PURE__ */ S("span", { style: { color: f.axis.textColor, marginRight: 2 }, children: At(b, p) }),
+          g.map((u) => {
+            if ("open" in u.data) {
+              const x = u.data, T = x.close >= x.open ? f.candlestick.upColor : f.candlestick.downColor;
+              return /* @__PURE__ */ F("span", { style: { display: "inline-flex", alignItems: "center", gap: 4 }, children: [
+                /* @__PURE__ */ S(xt, { label: "O", value: x.open, color: T, dim: f.axis.textColor }),
+                /* @__PURE__ */ S(xt, { label: "H", value: x.high, color: T, dim: f.axis.textColor }),
+                /* @__PURE__ */ S(xt, { label: "L", value: x.low, color: T, dim: f.axis.textColor }),
+                /* @__PURE__ */ S(xt, { label: "C", value: x.close, color: T, dim: f.axis.textColor }),
+                x.volume != null && /* @__PURE__ */ S(
+                  xt,
+                  {
+                    label: "V",
+                    value: x.volume,
+                    color: f.axis.textColor,
+                    dim: f.axis.textColor,
+                    volume: !0
+                  }
+                )
+              ] }, u.id);
+            }
+            const y = u.data;
+            return /* @__PURE__ */ F("span", { style: { display: "inline-flex", alignItems: "center", gap: 3 }, children: [
+              /* @__PURE__ */ S(
+                "span",
+                {
+                  style: {
+                    width: 6,
+                    height: 6,
+                    borderRadius: "50%",
+                    background: u.color,
+                    flexShrink: 0
+                  }
+                }
+              ),
+              /* @__PURE__ */ S("span", { style: { color: u.color, fontWeight: 500 }, children: y.value.toFixed(2) })
+            ] }, u.id);
+          })
+        ]
+      }
+    ),
+    s && h.length > 0 && /* @__PURE__ */ S(
+      mo,
+      {
+        snapshots: g,
+        x: s.mediaX,
+        y: s.mediaY,
+        chartWidth: m.width - o.yAxisWidth,
+        chartHeight: m.height - o.xAxisHeight,
+        theme: f,
+        dataInterval: p
+      }
+    )
+  ] });
+}
+function xt({
+  label: r,
+  value: t,
+  color: i,
+  dim: e,
+  volume: a
+}) {
+  return /* @__PURE__ */ F(Dt, { children: [
+    /* @__PURE__ */ S("span", { style: { color: e, opacity: 0.5, marginLeft: 5 }, children: r }),
+    /* @__PURE__ */ S("span", { style: { color: i, fontWeight: 500, marginLeft: 2 }, children: a ? Re(t) : t.toFixed(2) })
+  ] });
+}
+function mo({
+  snapshots: r,
+  x: t,
+  y: i,
+  chartWidth: e,
+  chartHeight: a,
+  theme: o,
+  dataInterval: s
+}) {
+  const n = r.some((x) => "open" in x.data), l = r.filter((x) => !("open" in x.data)).length, h = 160, d = n ? 140 : 40 + l * 22, g = 16, f = 16, p = t + g + h > e ? t - g - h : t + g, m = i + f + d > a ? i - f - d : i + f, b = o.tooltip.background, u = o.tooltip.borderColor, v = "0 4px 16px rgba(0,0,0,0.1), 0 1px 4px rgba(0,0,0,0.06)", y = r[0].data.time;
+  return /* @__PURE__ */ F(
+    "div",
+    {
+      style: {
+        position: "absolute",
+        left: p,
+        top: m,
+        pointerEvents: "none",
+        background: b,
+        backdropFilter: "blur(12px)",
+        WebkitBackdropFilter: "blur(12px)",
+        border: `1px solid ${u}`,
+        borderRadius: 8,
+        padding: "10px 14px",
+        boxShadow: v,
+        fontSize: o.typography.tooltipFontSize,
+        fontFamily: o.typography.fontFamily,
+        fontVariantNumeric: "tabular-nums",
+        color: o.tooltip.textColor,
+        minWidth: 140,
+        zIndex: 10,
+        transition: "opacity 0.15s ease"
+      },
+      children: [
+        /* @__PURE__ */ F(
+          "div",
+          {
+            style: {
+              fontSize: o.typography.axisFontSize,
+              color: o.axis.textColor,
+              marginBottom: 8,
+              paddingBottom: 6,
+              borderBottom: `1px solid ${u}`,
+              letterSpacing: "0.02em"
+            },
+            children: [
+              Qe(y),
+              " ",
+              At(y, s)
+            ]
+          }
+        ),
+        r.map((x) => {
+          if ("open" in x.data) {
+            const k = x.data, D = k.close >= k.open, z = o.candlestick.upColor, _ = o.candlestick.downColor, P = D ? z : _;
+            return /* @__PURE__ */ F("div", { style: { display: "grid", gridTemplateColumns: "auto 1fr", gap: "4px 12px" }, children: [
+              /* @__PURE__ */ S(Ct, { label: "Open", value: k.open, color: P }),
+              /* @__PURE__ */ S(Ct, { label: "High", value: k.high, color: P }),
+              /* @__PURE__ */ S(Ct, { label: "Low", value: k.low, color: P }),
+              /* @__PURE__ */ S(Ct, { label: "Close", value: k.close, color: P }),
+              k.volume != null && /* @__PURE__ */ S(Ct, { label: "Volume", value: k.volume, color: o.tooltip.textColor, volume: !0 })
+            ] }, x.id);
+          }
+          const T = x.data;
+          return /* @__PURE__ */ F("div", { style: { display: "flex", alignItems: "center", gap: 8, padding: "2px 0" }, children: [
+            /* @__PURE__ */ S(
+              "span",
+              {
+                style: {
+                  width: 8,
+                  height: 8,
+                  borderRadius: "50%",
+                  background: x.color,
+                  flexShrink: 0
+                }
+              }
+            ),
+            /* @__PURE__ */ S("span", { style: { opacity: 0.6, flex: 1 }, children: x.label ?? "Value" }),
+            /* @__PURE__ */ S("span", { style: { fontWeight: 600, color: x.color }, children: T.value.toFixed(2) })
+          ] }, x.id);
+        })
+      ]
+    }
+  );
+}
+function Ct({
+  label: r,
+  value: t,
+  color: i,
+  volume: e
+}) {
+  return /* @__PURE__ */ F(Dt, { children: [
+    /* @__PURE__ */ S("span", { style: { opacity: 0.5 }, children: r }),
+    /* @__PURE__ */ S("span", { style: { fontWeight: 600, color: i, textAlign: "right" }, children: e ? Re(t) : t.toFixed(2) })
+  ] });
+}
+function Re(r) {
+  return r >= 1e9 ? (r / 1e9).toFixed(2) + "B" : r >= 1e6 ? (r / 1e6).toFixed(2) + "M" : r >= 1e3 ? (r / 1e3).toFixed(1) + "K" : r.toFixed(0);
+}
+function Bo() {
+  const r = J();
+  oo(r);
+  const t = r.getTheme(), i = r.yScale.niceTickValues(), e = new Set(i), o = et(/* @__PURE__ */ new Map()).current, s = performance.now();
+  for (const l of i)
+    o.has(l) ? o.get(l).opacity = 1 : o.set(l, { opacity: 1, addedAt: s });
+  for (const [l, h] of o)
+    e.has(l) || h.opacity !== 0 && (h.opacity = 0, h.fadedAt = s);
+  for (const [l, h] of o)
+    h.opacity === 0 && h.fadedAt !== void 0 && s - h.fadedAt > 600 && o.delete(l);
+  const n = Array.from(o.entries());
+  return /* @__PURE__ */ S(
+    "div",
+    {
+      style: {
+        position: "absolute",
+        right: 0,
+        top: 0,
+        bottom: r.xAxisHeight,
+        width: r.yAxisWidth,
+        pointerEvents: "none"
+      },
+      children: n.map(([l, h]) => {
+        const d = r.yScale.valueToY(l);
+        return /* @__PURE__ */ S(
+          "span",
+          {
+            style: {
+              position: "absolute",
+              right: 8,
+              top: d,
+              transform: "translateY(-50%)",
+              color: t.axis.textColor,
+              fontSize: t.typography.axisFontSize,
+              fontFamily: t.typography.fontFamily,
+              fontVariantNumeric: "tabular-nums",
+              userSelect: "none",
+              opacity: h.opacity,
+              transition: "opacity 0.3s ease",
+              willChange: "opacity"
+            },
+            children: r.yScale.formatY(l)
+          },
+          l
+        );
+      })
+    }
+  );
+}
+function zo({ seriesId: r, color: t }) {
+  const i = J();
+  j(() => (i.setYLabel(!0), () => i.setYLabel(!1)), [i]);
+  const e = ro(i, r), a = ao(i, r);
+  if (!e) return null;
+  const { value: o, isLive: s } = e, n = i.getTheme(), l = i.yScale.valueToY(o);
+  let h;
+  if (!s)
+    h = n.axis.textColor;
+  else if (t)
+    h = t;
+  else {
+    const p = a === null ? "neutral" : o > a ? "up" : o < a ? "down" : "neutral";
+    h = p === "up" ? n.yLabel.upBackground : p === "down" ? n.yLabel.downBackground : n.yLabel.neutralBackground;
+  }
+  const d = i.yScale.getRange(), g = d.max - d.min, f = g < 0.1 ? 6 : g < 10 ? 4 : g < 1e3 ? 2 : 0;
+  return /* @__PURE__ */ F(Dt, { children: [
+    /* @__PURE__ */ S(
+      "div",
+      {
+        style: {
+          position: "absolute",
+          left: 0,
+          right: i.yAxisWidth,
+          top: l,
+          height: 0,
+          borderTop: `1px dashed ${h}`,
+          opacity: 0.5,
+          pointerEvents: "none",
+          zIndex: 2
+        }
+      }
+    ),
+    /* @__PURE__ */ S(
+      "div",
+      {
+        style: {
+          position: "absolute",
+          right: 4,
+          top: l,
+          transform: "translateY(-50%)",
+          pointerEvents: "auto",
+          zIndex: 3,
+          background: h,
+          color: n.yLabel.textColor,
+          fontSize: n.typography.yFontSize,
+          fontFamily: n.typography.fontFamily,
+          padding: "3px 8px",
+          borderRadius: 3,
+          whiteSpace: "nowrap",
+          transition: "background-color 0.3s ease"
+        },
+        children: /* @__PURE__ */ S(
+          lo,
+          {
+            value: o,
+            format: { minimumFractionDigits: f, maximumFractionDigits: f, useGrouping: !1 },
+            spinDuration: 350
+          }
+        )
+      }
+    )
+  ] });
+}
+export {
+  Ki as BarSeries,
+  Co as CandlestickSeries,
+  to as ChartContainer,
+  mi as ChartInstance,
+  So as Crosshair,
+  Zi as Legend,
+  eo as LineSeries,
+  lo as NumberFlow,
+  ko as PieLegend,
+  wo as PieSeries,
+  Mo as PieTooltip,
+  Ro as Sparkline,
+  ve as ThemeProvider,
+  To as TimeAxis,
+  Do as Tooltip,
+  To as XAxis,
+  Bo as YAxis,
+  zo as YLabel,
+  ki as andromeda,
+  Mi as ayuMirage,
+  xo as buildTheme,
+  Ri as catppuccin,
+  I as createTheme,
+  fi as darkTheme,
+  qe as detectInterval,
+  Ti as dracula,
+  Qe as formatDate,
+  At as formatTime,
+  Di as githubLight,
+  Bi as gruvbox,
+  zi as handwritten,
+  Li as highContrast,
+  Wi as lavenderMist,
+  Ai as lightPink,
+  yo as lightTheme,
+  Ii as materialPalenight,
+  _i as minimalLight,
+  Ui as mintBreeze,
+  Ei as monokaiPro,
+  Oi as nightOwl,
+  de as normalizeTime,
+  $i as oneDarkPro,
+  Xi as panda,
+  Hi as peachCream,
+  Gi as quietLight,
+  Ni as rosePineDawn,
+  ji as sandDune,
+  Ji as solarizedLight,
+  be as themes,
+  J as useChartInstance,
+  ie as useCrosshairPosition,
+  ro as useLastYValue,
+  ao as usePreviousClose,
+  qi as useTheme,
+  io as useVisibleRange,
+  oo as useYRange
+};