velo-plot 1.11.1

package/dist/index-D8ifudJH.js

@@ -0,0 +1,2431 @@
+var st = Object.defineProperty;
+var nt = (f, t, i) => t in f ? st(f, t, { enumerable: !0, configurable: !0, writable: !0, value: i }) : f[t] = i;
+var u = (f, t, i) => nt(f, typeof t != "symbol" ? t + "" : t, i);
+import { E as at } from "./EventEmitter-DAbs2K1C.js";
+class lt {
+  constructor(t, i) {
+    u(this, "ctx");
+    u(this, "options");
+    u(this, "state", {
+      enabled: !1,
+      selectionState: "idle",
+      point1: null,
+      point2: null,
+      hoveredPoint: null,
+      lastMeasurement: null
+    });
+    u(this, "overlayCanvas", null);
+    u(this, "overlayCtx", null);
+    // Label dragging
+    u(this, "labelOffset", { x: 15, y: 0 });
+    u(this, "isDraggingLabel", !1);
+    u(this, "labelBounds", null);
+    u(this, "dragStart", { x: 0, y: 0 });
+    u(this, "crosshairPosition", null);
+    // Bound handlers
+    u(this, "boundMouseMove");
+    u(this, "boundClick");
+    u(this, "boundKeyDown");
+    u(this, "boundMouseDown");
+    u(this, "boundMouseUp");
+    u(this, "boundResize");
+    this.ctx = t, this.options = {
+      lineColor: "#ff6b6b",
+      lineWidth: 2,
+      showLabels: !0,
+      labelFontSize: 12,
+      labelBackground: "rgba(0, 0, 0, 0.85)",
+      labelColor: "#ffffff",
+      showDelta: !0,
+      precision: 4,
+      showSlope: !0,
+      showDistance: !0,
+      className: "velo-plot-delta-tool",
+      highlightSize: 12,
+      highlightColor: "#00f2ff",
+      snapRadius: 30,
+      ...i
+    }, this.boundMouseMove = this.handleMouseMove.bind(this), this.boundClick = this.handleClick.bind(this), this.boundKeyDown = this.handleKeyDown.bind(this), this.boundMouseDown = this.handleLabelMouseDown.bind(this), this.boundMouseUp = this.handleLabelMouseUp.bind(this), this.boundResize = this.resizeOverlay.bind(this);
+  }
+  /**
+   * Enable the delta measurement tool
+   */
+  enable() {
+    this.state.enabled || (this.state.enabled = !0, this.state.selectionState = "idle", this.createOverlay(), this.attachListeners(), this.ctx.container.style.cursor = "crosshair");
+  }
+  /**
+   * Disable the delta measurement tool
+   */
+  disable() {
+    this.state.enabled && (this.state.enabled = !1, this.state.selectionState = "idle", this.state.point1 = null, this.state.point2 = null, this.state.hoveredPoint = null, this.detachListeners(), this.destroyOverlay(), this.ctx.container.style.cursor = "");
+  }
+  /**
+   * Toggle the tool on/off
+   */
+  toggle() {
+    this.state.enabled ? this.disable() : this.enable();
+  }
+  /**
+   * Check if tool is enabled
+   */
+  isEnabled() {
+    return this.state.enabled;
+  }
+  /**
+   * Get the current state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Get the last completed measurement
+   */
+  getMeasurement() {
+    return this.state.lastMeasurement;
+  }
+  /**
+   * Clear the current measurement
+   */
+  clear() {
+    this.state.point1 = null, this.state.point2 = null, this.state.selectionState = "idle", this.state.lastMeasurement = null, this.labelBounds = null, this.labelOffset = { x: 15, y: 0 }, this.renderOverlay();
+  }
+  /**
+   * Destroy the tool and cleanup
+   */
+  destroy() {
+    this.disable(), this.state.lastMeasurement = null;
+  }
+  /**
+   * Recalculate measurements (useful if data changes)
+   */
+  recalculate() {
+    if (!this.state.point1 || !this.state.point2) return;
+    const t = this.ctx.getSeries ? this.ctx.getSeries() : [], i = (o) => {
+      const s = t.find((l) => l.id === o.seriesId);
+      if (s && o.index < s.x.length) {
+        o.x = s.x[o.index], o.y = s.y[o.index], o.yAxisId = s.yAxisId;
+        const l = this.ctx.getPlotArea(), h = this.ctx.getViewBounds(), a = this.ctx.getYBounds ? this.ctx.getYBounds(s.yAxisId) : { yMin: h.yMin, yMax: h.yMax };
+        return o.pixelX = l.x + (o.x - h.xMin) / (h.xMax - h.xMin) * l.width, o.pixelY = l.y + (1 - (o.y - a.yMin) / (a.yMax - a.yMin)) * l.height, !0;
+      }
+      return !1;
+    }, e = i(this.state.point1), n = i(this.state.point2);
+    e && n ? (this.state.lastMeasurement = this.calculateMeasurement(), this.ctx.onMeasure && this.ctx.onMeasure(this.state.lastMeasurement)) : this.clear(), this.renderOverlay();
+  }
+  // ============================================
+  // Private Methods
+  // ============================================
+  createOverlay() {
+    this.overlayCanvas || (this.overlayCanvas = document.createElement("canvas"), this.overlayCanvas.className = this.options.className, this.overlayCanvas.style.cssText = `
+      position: absolute;
+      top: 0;
+      left: 0;
+      width: 100%;
+      height: 100%;
+      pointer-events: none;
+      z-index: 1000;
+    `, this.resizeOverlay(), this.overlayCtx = this.overlayCanvas.getContext("2d"), this.ctx.container.appendChild(this.overlayCanvas));
+  }
+  resizeOverlay() {
+    if (!this.overlayCanvas) return;
+    const t = this.ctx.container.getBoundingClientRect(), i = window.devicePixelRatio || 1;
+    this.overlayCanvas.width = t.width * i, this.overlayCanvas.height = t.height * i, this.overlayCtx && (this.overlayCtx.setTransform(1, 0, 0, 1, 0, 0), this.overlayCtx.scale(i, i));
+  }
+  destroyOverlay() {
+    this.overlayCanvas && this.overlayCanvas.parentNode && this.overlayCanvas.parentNode.removeChild(this.overlayCanvas), this.overlayCanvas = null, this.overlayCtx = null;
+  }
+  attachListeners() {
+    this.ctx.container.addEventListener("mousemove", this.boundMouseMove, !0), this.ctx.container.addEventListener("mousedown", this.boundClick, !0), this.ctx.container.addEventListener("mousedown", this.boundMouseDown, !0), this.ctx.container.addEventListener("mouseup", this.boundMouseUp, !0), window.addEventListener("resize", this.boundResize), document.addEventListener("keydown", this.boundKeyDown);
+  }
+  detachListeners() {
+    this.ctx.container.removeEventListener("mousemove", this.boundMouseMove, !0), this.ctx.container.removeEventListener("mousedown", this.boundClick, !0), this.ctx.container.removeEventListener("mousedown", this.boundMouseDown, !0), this.ctx.container.removeEventListener("mouseup", this.boundMouseUp, !0), window.removeEventListener("resize", this.boundResize), document.removeEventListener("keydown", this.boundKeyDown);
+  }
+  handleMouseMove(t) {
+    if (!this.state.enabled) return;
+    const i = this.ctx.container.getBoundingClientRect(), e = this.ctx.getPlotArea(), n = this.ctx.getViewBounds(), o = t.clientX - i.left, s = t.clientY - i.top;
+    if (this.isDraggingLabel) {
+      this.labelOffset.x += o - this.dragStart.x, this.labelOffset.y += s - this.dragStart.y, this.dragStart = { x: o, y: s }, this.renderOverlay();
+      return;
+    }
+    if (this.labelBounds && o >= this.labelBounds.x && o <= this.labelBounds.x + this.labelBounds.width && s >= this.labelBounds.y && s <= this.labelBounds.y + this.labelBounds.height ? this.ctx.container.style.cursor = "move" : this.ctx.container.style.cursor = "crosshair", o < e.x || o > e.x + e.width || s < e.y || s > e.y + e.height) {
+      this.state.hoveredPoint = null, this.crosshairPosition = null, this.renderOverlay();
+      return;
+    }
+    this.crosshairPosition = { x: o, y: s };
+    const l = this.findNearestPoint(o, s, e, n);
+    this.state.hoveredPoint = l, this.renderOverlay();
+  }
+  handleLabelMouseDown(t) {
+    if (!this.state.enabled || !this.labelBounds) return;
+    const i = this.ctx.container.getBoundingClientRect(), e = t.clientX - i.left, n = t.clientY - i.top;
+    e >= this.labelBounds.x && e <= this.labelBounds.x + this.labelBounds.width && n >= this.labelBounds.y && n <= this.labelBounds.y + this.labelBounds.height && (this.isDraggingLabel = !0, this.dragStart = { x: e, y: n }, t.stopPropagation(), t.preventDefault());
+  }
+  handleLabelMouseUp() {
+    this.isDraggingLabel = !1;
+  }
+  async handleClick(t) {
+    var h;
+    if (!this.state.enabled) return;
+    (h = this.ctx.animationEngine) != null && h.isAnimating() && await this.ctx.animationEngine.waitForIdle(), t.stopPropagation(), t.preventDefault();
+    const i = this.ctx.container.getBoundingClientRect(), e = this.ctx.getPlotArea(), n = this.ctx.getViewBounds(), o = t.clientX - i.left, s = t.clientY - i.top;
+    if (o < e.x || o > e.x + e.width || s < e.y || s > e.y + e.height)
+      return;
+    const l = this.findNearestPoint(o, s, e, n);
+    if (l) {
+      if (t.preventDefault(), t.stopPropagation(), this.state.selectionState === "idle" || this.state.selectionState === "complete")
+        this.state.point1 = l, this.state.point2 = null, this.state.selectionState = "waitingSecond", this.state.lastMeasurement = null;
+      else if (this.state.selectionState === "waitingSecond") {
+        this.state.point2 = l, this.state.selectionState = "complete";
+        const a = this.calculateMeasurement();
+        this.state.lastMeasurement = a, this.ctx.onMeasure && this.ctx.onMeasure(a);
+      }
+      this.renderOverlay();
+    }
+  }
+  handleKeyDown(t) {
+    t.key === "Escape" && this.state.enabled && this.clear();
+  }
+  findNearestPoint(t, i, e, n) {
+    if (!this.ctx.getSeries) return null;
+    const o = this.ctx.getSeries();
+    let s = null, l = this.options.snapRadius;
+    for (const h of o) {
+      const a = h.x, r = h.y, d = Math.min(a.length, r.length), p = this.ctx.getYBounds ? this.ctx.getYBounds(h.yAxisId) : { yMin: n.yMin, yMax: n.yMax };
+      for (let c = 0; c < d; c++) {
+        const g = a[c], y = r[c], b = e.x + (g - n.xMin) / (n.xMax - n.xMin) * e.width, x = e.y + (1 - (y - p.yMin) / (p.yMax - p.yMin)) * e.height;
+        if (b < e.x || b > e.x + e.width || x < e.y || x > e.y + e.height) continue;
+        const S = Math.sqrt((t - b) ** 2 + (i - x) ** 2);
+        S < l && (l = S, s = {
+          x: g,
+          y,
+          seriesId: h.id,
+          yAxisId: h.yAxisId,
+          index: c,
+          pixelX: b,
+          pixelY: x
+        });
+      }
+    }
+    return s;
+  }
+  calculateMeasurement() {
+    const t = this.state.point1, i = this.state.point2, e = i.x - t.x, n = i.y - t.y, o = e !== 0 ? n / e : 1 / 0, s = Math.sqrt(e * e + n * n);
+    return {
+      x1: t.x,
+      y1: t.y,
+      x2: i.x,
+      y2: i.y,
+      deltaX: e,
+      deltaY: n,
+      slope: o,
+      distance: s,
+      pixelX1: t.pixelX,
+      pixelY1: t.pixelY,
+      pixelX2: i.pixelX,
+      pixelY2: i.pixelY
+    };
+  }
+  renderOverlay() {
+    if (!this.overlayCtx || !this.overlayCanvas) return;
+    this.resizeOverlay();
+    const t = this.ctx.container.getBoundingClientRect();
+    this.overlayCtx.clearRect(0, 0, t.width, t.height);
+    const i = this.options, e = this.overlayCtx, n = this.ctx.getPlotArea(), o = this.ctx.getViewBounds();
+    if (this.state.point1) {
+      const s = this.state.point1, l = this.ctx.getYBounds ? this.ctx.getYBounds(s.yAxisId) : { yMin: o.yMin, yMax: o.yMax };
+      s.pixelX = n.x + (s.x - o.xMin) / (o.xMax - o.xMin) * n.width, s.pixelY = n.y + (1 - (s.y - l.yMin) / (l.yMax - l.yMin)) * n.height;
+    }
+    if (this.state.point2) {
+      const s = this.state.point2, l = this.ctx.getYBounds ? this.ctx.getYBounds(s.yAxisId) : { yMin: o.yMin, yMax: o.yMax };
+      s.pixelX = n.x + (s.x - o.xMin) / (o.xMax - o.xMin) * n.width, s.pixelY = n.y + (1 - (s.y - l.yMin) / (l.yMax - l.yMin)) * n.height;
+    }
+    if (this.crosshairPosition && this.state.selectionState !== "complete") {
+      const s = this.crosshairPosition.x, l = this.crosshairPosition.y;
+      e.save(), e.setLineDash([4, 4]), e.strokeStyle = "rgba(150, 150, 150, 0.7)", e.lineWidth = 1, e.beginPath(), e.moveTo(s, n.y), e.lineTo(s, n.y + n.height), e.stroke(), e.beginPath(), e.moveTo(n.x, l), e.lineTo(n.x + n.width, l), e.stroke(), e.restore();
+    }
+    if (this.state.hoveredPoint && this.state.selectionState !== "complete") {
+      const s = this.state.hoveredPoint;
+      e.beginPath(), e.arc(s.pixelX, s.pixelY, i.highlightSize + 4, 0, Math.PI * 2), e.fillStyle = i.highlightColor + "30", e.fill(), e.beginPath(), e.arc(s.pixelX, s.pixelY, i.highlightSize, 0, Math.PI * 2), e.strokeStyle = i.highlightColor, e.lineWidth = 2, e.stroke(), e.beginPath(), e.arc(s.pixelX, s.pixelY, 4, 0, Math.PI * 2), e.fillStyle = i.highlightColor, e.fill(), this.drawPointTooltip(e, s, "Hover");
+    }
+    if (this.state.point1) {
+      const s = this.state.point1;
+      e.beginPath(), e.arc(s.pixelX, s.pixelY, i.highlightSize, 0, Math.PI * 2), e.fillStyle = i.lineColor, e.fill(), e.beginPath(), e.arc(s.pixelX, s.pixelY, i.highlightSize - 3, 0, Math.PI * 2), e.fillStyle = "#ffffff", e.fill(), e.beginPath(), e.arc(s.pixelX, s.pixelY, 3, 0, Math.PI * 2), e.fillStyle = i.lineColor, e.fill(), this.drawPointLabel(e, s.pixelX, s.pixelY - i.highlightSize - 8, "P1", i.lineColor);
+    }
+    if (this.state.point2) {
+      const s = this.state.point2;
+      e.beginPath(), e.arc(s.pixelX, s.pixelY, i.highlightSize, 0, Math.PI * 2), e.fillStyle = "#4ade80", e.fill(), e.beginPath(), e.arc(s.pixelX, s.pixelY, i.highlightSize - 3, 0, Math.PI * 2), e.fillStyle = "#ffffff", e.fill(), e.beginPath(), e.arc(s.pixelX, s.pixelY, 3, 0, Math.PI * 2), e.fillStyle = "#4ade80", e.fill(), this.drawPointLabel(e, s.pixelX, s.pixelY - i.highlightSize - 8, "P2", "#4ade80");
+    }
+    if (this.state.point1 && this.state.point2) {
+      const s = this.state.point1, l = this.state.point2;
+      e.beginPath(), e.moveTo(s.pixelX, s.pixelY), e.lineTo(l.pixelX, l.pixelY), e.strokeStyle = i.lineColor, e.lineWidth = i.lineWidth, e.setLineDash([6, 4]), e.stroke(), e.setLineDash([]), e.beginPath(), e.moveTo(s.pixelX, s.pixelY), e.lineTo(l.pixelX, s.pixelY), e.lineTo(l.pixelX, l.pixelY), e.strokeStyle = "rgba(255, 107, 107, 0.4)", e.lineWidth = 1, e.setLineDash([3, 3]), e.stroke(), e.setLineDash([]), i.showLabels && this.state.lastMeasurement && this.drawMeasurementLabel(e, s, l, this.state.lastMeasurement);
+    }
+    this.drawStatusIndicator(e);
+  }
+  drawPointTooltip(t, i, e) {
+    const n = this.options, o = `${e}: (${this.formatValue(i.x)}, ${this.formatValue(i.y)})`;
+    t.font = `${n.labelFontSize}px system-ui, sans-serif`;
+    const s = t.measureText(o), l = 6, h = s.width + l * 2, a = n.labelFontSize + l * 2;
+    let r = i.pixelX + 15, d = i.pixelY - a / 2;
+    const p = this.ctx.container.getBoundingClientRect();
+    r + h > p.width && (r = i.pixelX - h - 15), d < 0 && (d = 5), d + a > p.height && (d = p.height - a - 5), t.fillStyle = n.labelBackground, this.roundRect(t, r, d, h, a, 4), t.fill(), t.fillStyle = n.labelColor, t.textAlign = "left", t.textBaseline = "middle", t.fillText(o, r + l, d + a / 2);
+  }
+  drawPointLabel(t, i, e, n, o) {
+    const s = this.options;
+    t.font = `bold ${s.labelFontSize}px system-ui, sans-serif`, t.textAlign = "center", t.textBaseline = "bottom";
+    const l = t.measureText(n), h = 4, a = l.width + h * 2, r = s.labelFontSize + h;
+    t.fillStyle = o, this.roundRect(t, i - a / 2, e - r, a, r, 3), t.fill(), t.fillStyle = "#ffffff", t.fillText(n, i, e - 2);
+  }
+  drawMeasurementLabel(t, i, e, n) {
+    const o = this.options, s = (i.pixelX + e.pixelX) / 2, l = (i.pixelY + e.pixelY) / 2, h = [];
+    o.showDelta && (h.push(`ΔX: ${this.formatValue(n.deltaX)}`), h.push(`ΔY: ${this.formatValue(n.deltaY)}`)), o.showSlope && isFinite(n.slope) && h.push(`Slope: ${this.formatValue(n.slope)}`), o.showDistance && h.push(`Distance: ${this.formatValue(n.distance)}`);
+    const a = o.labelFontSize + 4, r = 10, d = 170, p = h.length * a + r * 2;
+    let c = s + this.labelOffset.x, g = l + this.labelOffset.y;
+    const y = this.ctx.container.getBoundingClientRect();
+    c < 0 && (c = 0), c + d > y.width && (c = y.width - d), g < 0 && (g = 0), g + p > y.height && (g = y.height - p), this.labelBounds = { x: c, y: g, width: d, height: p }, t.fillStyle = o.labelBackground, t.strokeStyle = o.lineColor, t.lineWidth = 2, this.roundRect(t, c, g, d, p, 8), t.fill(), t.stroke(), t.fillStyle = o.labelColor, t.font = `${o.labelFontSize}px system-ui, sans-serif`, t.textAlign = "left", t.textBaseline = "top", h.forEach((b, x) => {
+      t.fillText(b, c + r, g + r + x * a);
+    });
+  }
+  drawStatusIndicator(t) {
+    const i = this.options, e = this.ctx.getPlotArea();
+    let n = "", o = "#666";
+    if (this.state.selectionState === "idle" ? (n = "📏 Click a point to start measuring", o = i.highlightColor) : this.state.selectionState === "waitingSecond" ? (n = "📏 Click second point to complete", o = "#f59e0b") : this.state.selectionState === "complete" && (n = "📏 Measurement complete (ESC to clear)", o = "#4ade80"), !n) return;
+    t.font = "12px system-ui, sans-serif";
+    const h = t.measureText(n).width + 8 * 2, a = 24, r = e.x + 10, d = e.y + 10;
+    t.fillStyle = "rgba(0, 0, 0, 0.75)", this.roundRect(t, r, d, h, a, 4), t.fill(), t.beginPath(), t.arc(r + 16, d + a / 2, 4, 0, Math.PI * 2), t.fillStyle = o, t.fill(), t.fillStyle = "#fff", t.textAlign = "left", t.textBaseline = "middle", t.fillText(n, r + 26, d + a / 2);
+  }
+  roundRect(t, i, e, n, o, s) {
+    t.beginPath(), t.moveTo(i + s, e), t.lineTo(i + n - s, e), t.quadraticCurveTo(i + n, e, i + n, e + s), t.lineTo(i + n, e + o - s), t.quadraticCurveTo(i + n, e + o, i + n - s, e + o), t.lineTo(i + s, e + o), t.quadraticCurveTo(i, e + o, i, e + o - s), t.lineTo(i, e + s), t.quadraticCurveTo(i, e, i + s, e), t.closePath();
+  }
+  formatValue(t) {
+    const i = Math.abs(t);
+    return i === 0 ? "0" : i >= 1e6 || i < 1e-3 ? t.toExponential(this.options.precision - 1) : t.toPrecision(this.options.precision);
+  }
+}
+class rt {
+  constructor(t, i) {
+    u(this, "ctx");
+    u(this, "options");
+    u(this, "state", {
+      enabled: !1,
+      selectionState: "idle",
+      point1: null,
+      point2: null,
+      hoveredPoint: null,
+      lastMeasurement: null
+    });
+    u(this, "overlayCanvas", null);
+    u(this, "overlayCtx", null);
+    // Label dragging
+    u(this, "labelOffset", { x: 15, y: 0 });
+    u(this, "isDraggingLabel", !1);
+    u(this, "labelBounds", null);
+    u(this, "dragStart", { x: 0, y: 0 });
+    u(this, "crosshairPosition", null);
+    // Bound handlers
+    u(this, "boundMouseMove");
+    u(this, "boundClick");
+    u(this, "boundKeyDown");
+    u(this, "boundMouseDown");
+    u(this, "boundMouseUp");
+    u(this, "boundResize");
+    this.ctx = t, this.options = {
+      lineColor: "#ff6b6b",
+      lineWidth: 2,
+      showLabels: !0,
+      labelFontSize: 12,
+      labelBackground: "rgba(0, 0, 0, 0.85)",
+      labelColor: "#ffffff",
+      showPeak: !0,
+      precision: 4,
+      className: "velo-plot-peak-tool",
+      highlightSize: 12,
+      highlightColor: "#00f2ff",
+      snapRadius: 30,
+      baselineWindow: 10,
+      areaFill: "rgba(255, 107, 107, 0.3)",
+      ...i
+    }, this.boundMouseMove = this.handleMouseMove.bind(this), this.boundClick = this.handleClick.bind(this), this.boundKeyDown = this.handleKeyDown.bind(this), this.boundMouseDown = this.handleLabelMouseDown.bind(this), this.boundMouseUp = this.handleLabelMouseUp.bind(this), this.boundResize = this.resizeOverlay.bind(this);
+  }
+  /**
+   * Enable the peak measurement tool
+   */
+  enable() {
+    this.state.enabled || (this.state.enabled = !0, this.state.selectionState = "idle", this.createOverlay(), this.attachListeners(), this.ctx.container.style.cursor = "crosshair");
+  }
+  /**
+   * Disable the peak measurement tool
+   */
+  disable() {
+    this.state.enabled && (this.state.enabled = !1, this.state.selectionState = "idle", this.state.point1 = null, this.state.point2 = null, this.state.hoveredPoint = null, this.detachListeners(), this.destroyOverlay(), this.ctx.container.style.cursor = "");
+  }
+  /**
+   * Toggle the tool on/off
+   */
+  toggle() {
+    this.state.enabled ? this.disable() : this.enable();
+  }
+  /**
+   * Check if tool is enabled
+   */
+  isEnabled() {
+    return this.state.enabled;
+  }
+  /**
+   * Get the current state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Get the last completed measurement
+   */
+  getMeasurement() {
+    return this.state.lastMeasurement;
+  }
+  /**
+   * Clear the current measurement
+   */
+  clear() {
+    this.state.point1 = null, this.state.point2 = null, this.state.selectionState = "idle", this.state.lastMeasurement = null, this.labelBounds = null, this.labelOffset = { x: 15, y: 0 }, this.renderOverlay();
+  }
+  /**
+   * Destroy the tool and cleanup
+   */
+  destroy() {
+    this.disable(), this.state.lastMeasurement = null;
+  }
+  /**
+   * Recalculate measurements (useful if data changes)
+   */
+  recalculate() {
+    if (!this.state.point1 || !this.state.point2) return;
+    const t = this.ctx.getSeries ? this.ctx.getSeries() : [], i = (o) => {
+      const s = t.find((l) => l.id === o.seriesId);
+      if (s && o.index < s.x.length) {
+        o.x = s.x[o.index], o.y = s.y[o.index], o.yAxisId = s.yAxisId;
+        const l = this.ctx.getPlotArea(), h = this.ctx.getViewBounds(), a = this.ctx.getYBounds ? this.ctx.getYBounds(s.yAxisId) : { yMin: h.yMin, yMax: h.yMax };
+        return o.pixelX = l.x + (o.x - h.xMin) / (h.xMax - h.xMin) * l.width, o.pixelY = l.y + (1 - (o.y - a.yMin) / (a.yMax - a.yMin)) * l.height, !0;
+      }
+      return !1;
+    }, e = i(this.state.point1), n = i(this.state.point2);
+    e && n ? (this.state.lastMeasurement = this.calculateMeasurement(), this.ctx.onMeasure && this.ctx.onMeasure(this.state.lastMeasurement)) : this.clear(), this.renderOverlay();
+  }
+  // ============================================
+  // Private Methods
+  // ============================================
+  createOverlay() {
+    this.overlayCanvas || (this.overlayCanvas = document.createElement("canvas"), this.overlayCanvas.className = this.options.className, this.overlayCanvas.style.cssText = `
+      position: absolute;
+      top: 0;
+      left: 0;
+      width: 100%;
+      height: 100%;
+      pointer-events: none;
+      z-index: 1000;
+    `, this.resizeOverlay(), this.overlayCtx = this.overlayCanvas.getContext("2d"), this.ctx.container.appendChild(this.overlayCanvas));
+  }
+  resizeOverlay() {
+    if (!this.overlayCanvas) return;
+    const t = this.ctx.container.getBoundingClientRect(), i = window.devicePixelRatio || 1;
+    this.overlayCanvas.width = t.width * i, this.overlayCanvas.height = t.height * i, this.overlayCtx && (this.overlayCtx.setTransform(1, 0, 0, 1, 0, 0), this.overlayCtx.scale(i, i));
+  }
+  destroyOverlay() {
+    this.overlayCanvas && this.overlayCanvas.parentNode && this.overlayCanvas.parentNode.removeChild(this.overlayCanvas), this.overlayCanvas = null, this.overlayCtx = null;
+  }
+  attachListeners() {
+    this.ctx.container.addEventListener("mousemove", this.boundMouseMove, !0), this.ctx.container.addEventListener("mousedown", this.boundClick, !0), this.ctx.container.addEventListener("mousedown", this.boundMouseDown, !0), this.ctx.container.addEventListener("mouseup", this.boundMouseUp, !0), window.addEventListener("resize", this.boundResize), document.addEventListener("keydown", this.boundKeyDown);
+  }
+  detachListeners() {
+    this.ctx.container.removeEventListener("mousemove", this.boundMouseMove, !0), this.ctx.container.removeEventListener("mousedown", this.boundClick, !0), this.ctx.container.removeEventListener("mousedown", this.boundMouseDown, !0), this.ctx.container.removeEventListener("mouseup", this.boundMouseUp, !0), window.removeEventListener("resize", this.boundResize), document.removeEventListener("keydown", this.boundKeyDown);
+  }
+  handleMouseMove(t) {
+    if (!this.state.enabled) return;
+    const i = this.ctx.container.getBoundingClientRect(), e = this.ctx.getPlotArea(), n = this.ctx.getViewBounds(), o = t.clientX - i.left, s = t.clientY - i.top;
+    if (this.isDraggingLabel) {
+      this.labelOffset.x += o - this.dragStart.x, this.labelOffset.y += s - this.dragStart.y, this.dragStart = { x: o, y: s }, this.renderOverlay();
+      return;
+    }
+    if (this.labelBounds && o >= this.labelBounds.x && o <= this.labelBounds.x + this.labelBounds.width && s >= this.labelBounds.y && s <= this.labelBounds.y + this.labelBounds.height ? this.ctx.container.style.cursor = "move" : this.ctx.container.style.cursor = "crosshair", o < e.x || o > e.x + e.width || s < e.y || s > e.y + e.height) {
+      this.state.hoveredPoint = null, this.crosshairPosition = null, this.renderOverlay();
+      return;
+    }
+    this.crosshairPosition = { x: o, y: s };
+    const l = this.state.selectionState === "waitingSecond" && this.state.point1 ? this.state.point1.seriesId : void 0, h = this.findNearestPoint(o, s, e, n, l);
+    this.state.hoveredPoint = h, this.renderOverlay();
+  }
+  handleLabelMouseDown(t) {
+    if (!this.state.enabled || !this.labelBounds) return;
+    const i = this.ctx.container.getBoundingClientRect(), e = t.clientX - i.left, n = t.clientY - i.top;
+    e >= this.labelBounds.x && e <= this.labelBounds.x + this.labelBounds.width && n >= this.labelBounds.y && n <= this.labelBounds.y + this.labelBounds.height && (this.isDraggingLabel = !0, this.dragStart = { x: e, y: n }, t.stopPropagation(), t.preventDefault());
+  }
+  handleLabelMouseUp() {
+    this.isDraggingLabel = !1;
+  }
+  async handleClick(t) {
+    var a;
+    if (!this.state.enabled) return;
+    (a = this.ctx.animationEngine) != null && a.isAnimating() && await this.ctx.animationEngine.waitForIdle(), t.stopPropagation(), t.preventDefault();
+    const i = this.ctx.container.getBoundingClientRect(), e = this.ctx.getPlotArea(), n = this.ctx.getViewBounds(), o = t.clientX - i.left, s = t.clientY - i.top;
+    if (o < e.x || o > e.x + e.width || s < e.y || s > e.y + e.height)
+      return;
+    const l = this.state.selectionState === "waitingSecond" && this.state.point1 ? this.state.point1.seriesId : void 0, h = this.findNearestPoint(o, s, e, n, l);
+    if (h) {
+      if (t.preventDefault(), t.stopPropagation(), this.state.selectionState === "idle" || this.state.selectionState === "complete")
+        this.state.point1 = h, this.state.point2 = null, this.state.selectionState = "waitingSecond", this.state.lastMeasurement = null;
+      else if (this.state.selectionState === "waitingSecond") {
+        if (this.state.point1 && h.seriesId !== this.state.point1.seriesId)
+          return;
+        this.state.point2 = h, this.state.selectionState = "complete";
+        const r = this.calculateMeasurement();
+        this.state.lastMeasurement = r, this.ctx.onMeasure && this.ctx.onMeasure(r);
+      }
+      this.renderOverlay();
+    }
+  }
+  handleKeyDown(t) {
+    t.key === "Escape" && this.state.enabled && this.clear();
+  }
+  findNearestPoint(t, i, e, n, o) {
+    if (!this.ctx.getSeries) return null;
+    const s = this.ctx.getSeries();
+    let l = null, h = this.options.snapRadius;
+    for (const a of s) {
+      if (o && a.id !== o) continue;
+      const r = a.x, d = a.y, p = Math.min(r.length, d.length), c = this.ctx.getYBounds ? this.ctx.getYBounds(a.yAxisId) : { yMin: n.yMin, yMax: n.yMax };
+      for (let g = 0; g < p; g++) {
+        const y = r[g], b = d[g], x = e.x + (y - n.xMin) / (n.xMax - n.xMin) * e.width, S = e.y + (1 - (b - c.yMin) / (c.yMax - c.yMin)) * e.height;
+        if (x < e.x || x > e.x + e.width || S < e.y || S > e.y + e.height) continue;
+        const w = Math.sqrt((t - x) ** 2 + (i - S) ** 2);
+        w < h && (h = w, l = {
+          x: y,
+          y: b,
+          seriesId: a.id,
+          yAxisId: a.yAxisId,
+          index: g,
+          pixelX: x,
+          pixelY: S
+        });
+      }
+    }
+    return l;
+  }
+  calculateMeasurement() {
+    const t = this.state.point1, i = this.state.point2, n = (this.ctx.getSeries ? this.ctx.getSeries() : []).find((T) => T.id === t.seriesId);
+    if (!n)
+      return {
+        x1: t.x,
+        y1: t.y,
+        x2: i.x,
+        y2: i.y,
+        area: 0,
+        integral: 0,
+        baselineSlope: 0,
+        baselineIntercept: 0,
+        peakHeight: 0,
+        peakX: 0,
+        peakY: 0,
+        pixelX1: t.pixelX,
+        pixelY1: t.pixelY,
+        pixelX2: i.pixelX,
+        pixelY2: i.pixelY
+      };
+    const o = n.x, s = n.y, l = Math.min(t.index, i.index), h = Math.max(t.index, i.index), a = this.options.baselineWindow, r = [], d = [];
+    for (let T = Math.max(0, l - Math.floor(a / 2)); T <= Math.min(o.length - 1, l + Math.floor(a / 2)); T++)
+      r.push(o[T]), d.push(s[T]);
+    for (let T = Math.max(0, h - Math.floor(a / 2)); T <= Math.min(o.length - 1, h + Math.floor(a / 2)); T++)
+      r.push(o[T]), d.push(s[T]);
+    const p = r.length;
+    let c = 0, g = 0, y = 0, b = 0;
+    for (let T = 0; T < p; T++)
+      c += r[T], g += d[T], y += r[T] * d[T], b += r[T] * r[T];
+    const x = (p * y - c * g) / (p * b - c * c), S = (g - x * c) / p;
+    let w = 0, C = 0, m = -1 / 0, I = 0, v = 0;
+    for (let T = l; T < h; T++) {
+      const z = o[T], $ = s[T], D = o[T + 1], B = s[T + 1], V = D - z, _ = ($ + B) / 2;
+      C += _ * V;
+      const K = x * z + S, it = x * D + S, ot = (K + it) / 2;
+      w += (_ - ot) * V;
+      const U = $ - K;
+      U > m && (m = U, I = z, v = $);
+    }
+    return {
+      x1: t.x,
+      y1: t.y,
+      x2: i.x,
+      y2: i.y,
+      area: w,
+      integral: C,
+      baselineSlope: x,
+      baselineIntercept: S,
+      peakHeight: m,
+      peakX: I,
+      peakY: v,
+      pixelX1: t.pixelX,
+      pixelY1: t.pixelY,
+      pixelX2: i.pixelX,
+      pixelY2: i.pixelY
+    };
+  }
+  renderOverlay() {
+    if (!this.overlayCtx || !this.overlayCanvas) return;
+    this.resizeOverlay();
+    const t = this.ctx.container.getBoundingClientRect();
+    this.overlayCtx.clearRect(0, 0, t.width, t.height);
+    const i = this.options, e = this.overlayCtx, n = this.ctx.getPlotArea(), o = this.ctx.getViewBounds();
+    if (this.state.point1) {
+      const s = this.state.point1, l = this.ctx.getYBounds ? this.ctx.getYBounds(s.yAxisId) : { yMin: o.yMin, yMax: o.yMax };
+      s.pixelX = n.x + (s.x - o.xMin) / (o.xMax - o.xMin) * n.width, s.pixelY = n.y + (1 - (s.y - l.yMin) / (l.yMax - l.yMin)) * n.height;
+    }
+    if (this.state.point2) {
+      const s = this.state.point2, l = this.ctx.getYBounds ? this.ctx.getYBounds(s.yAxisId) : { yMin: o.yMin, yMax: o.yMax };
+      s.pixelX = n.x + (s.x - o.xMin) / (o.xMax - o.xMin) * n.width, s.pixelY = n.y + (1 - (s.y - l.yMin) / (l.yMax - l.yMin)) * n.height;
+    }
+    if (this.crosshairPosition && this.state.selectionState !== "complete") {
+      const s = this.crosshairPosition.x, l = this.crosshairPosition.y;
+      e.save(), e.setLineDash([4, 4]), e.strokeStyle = "rgba(150, 150, 150, 0.7)", e.lineWidth = 1, e.beginPath(), e.moveTo(s, n.y), e.lineTo(s, n.y + n.height), e.stroke(), e.beginPath(), e.moveTo(n.x, l), e.lineTo(n.x + n.width, l), e.stroke(), e.restore();
+    }
+    if (this.state.hoveredPoint && this.state.selectionState !== "complete") {
+      const s = this.state.hoveredPoint;
+      e.beginPath(), e.arc(s.pixelX, s.pixelY, i.highlightSize + 4, 0, Math.PI * 2), e.fillStyle = i.highlightColor + "30", e.fill(), e.beginPath(), e.arc(s.pixelX, s.pixelY, i.highlightSize, 0, Math.PI * 2), e.strokeStyle = i.highlightColor, e.lineWidth = 2, e.stroke(), e.beginPath(), e.arc(s.pixelX, s.pixelY, 4, 0, Math.PI * 2), e.fillStyle = i.highlightColor, e.fill(), this.drawPointTooltip(e, s, "Hover");
+    }
+    if (this.state.point1) {
+      const s = this.state.point1;
+      e.beginPath(), e.arc(s.pixelX, s.pixelY, i.highlightSize, 0, Math.PI * 2), e.fillStyle = i.lineColor, e.fill(), e.beginPath(), e.arc(s.pixelX, s.pixelY, i.highlightSize - 3, 0, Math.PI * 2), e.fillStyle = "#ffffff", e.fill(), e.beginPath(), e.arc(s.pixelX, s.pixelY, 3, 0, Math.PI * 2), e.fillStyle = i.lineColor, e.fill(), this.drawPointLabel(e, s.pixelX, s.pixelY - i.highlightSize - 8, "P1", i.lineColor);
+    }
+    if (this.state.point2) {
+      const s = this.state.point2;
+      e.beginPath(), e.arc(s.pixelX, s.pixelY, i.highlightSize, 0, Math.PI * 2), e.fillStyle = "#4ade80", e.fill(), e.beginPath(), e.arc(s.pixelX, s.pixelY, i.highlightSize - 3, 0, Math.PI * 2), e.fillStyle = "#ffffff", e.fill(), e.beginPath(), e.arc(s.pixelX, s.pixelY, 3, 0, Math.PI * 2), e.fillStyle = "#4ade80", e.fill(), this.drawPointLabel(e, s.pixelX, s.pixelY - i.highlightSize - 8, "P2", "#4ade80");
+    }
+    if (this.state.point1 && this.state.point2 && this.state.lastMeasurement) {
+      const s = this.state.point1, l = this.state.point2, h = this.state.lastMeasurement, a = this.ctx.getPlotArea(), r = this.ctx.getViewBounds(), p = (this.ctx.getSeries ? this.ctx.getSeries() : []).find((S) => S.id === s.seriesId);
+      if (p) {
+        const S = p.x, w = p.y, C = Math.min(s.index, l.index), m = Math.max(s.index, l.index), I = this.ctx.getYBounds ? this.ctx.getYBounds(p.yAxisId) : { yMin: r.yMin, yMax: r.yMax };
+        e.beginPath(), e.moveTo(s.pixelX, s.pixelY);
+        for (let v = C; v <= m; v++) {
+          const T = a.x + (S[v] - r.xMin) / (r.xMax - r.xMin) * a.width, z = a.y + (1 - (w[v] - I.yMin) / (I.yMax - I.yMin)) * a.height;
+          e.lineTo(T, z);
+        }
+        e.lineTo(l.pixelX, l.pixelY), e.closePath(), e.fillStyle = i.areaFill, e.fill();
+      }
+      e.beginPath(), e.moveTo(s.pixelX, s.pixelY), e.lineTo(l.pixelX, l.pixelY), e.strokeStyle = i.lineColor, e.lineWidth = 1, e.stroke();
+      const c = this.ctx.getYBounds ? this.ctx.getYBounds(s.yAxisId) : { yMin: r.yMin, yMax: r.yMax }, g = a.x + (h.peakX - r.xMin) / (r.xMax - r.xMin) * a.width, y = a.y + (1 - (h.peakY - c.yMin) / (c.yMax - c.yMin)) * a.height, b = h.baselineSlope * h.peakX + h.baselineIntercept, x = a.y + (1 - (b - c.yMin) / (c.yMax - c.yMin)) * a.height;
+      e.beginPath(), e.moveTo(g, y), e.lineTo(g, x), e.strokeStyle = i.lineColor, e.setLineDash([2, 2]), e.stroke(), e.setLineDash([]), i.showLabels && this.drawMeasurementLabel(e, s, l, h);
+    }
+    this.drawStatusIndicator(e);
+  }
+  drawPointTooltip(t, i, e) {
+    const n = this.options, o = `${e}: (${this.formatValue(i.x)}, ${this.formatValue(i.y)})`;
+    t.font = `${n.labelFontSize}px system-ui, sans-serif`;
+    const s = t.measureText(o), l = 6, h = s.width + l * 2, a = n.labelFontSize + l * 2;
+    let r = i.pixelX + 15, d = i.pixelY - a / 2;
+    const p = this.ctx.container.getBoundingClientRect();
+    r + h > p.width && (r = i.pixelX - h - 15), d < 0 && (d = 5), d + a > p.height && (d = p.height - a - 5), t.fillStyle = n.labelBackground, this.roundRect(t, r, d, h, a, 4), t.fill(), t.fillStyle = n.labelColor, t.textAlign = "left", t.textBaseline = "middle", t.fillText(o, r + l, d + a / 2);
+  }
+  drawPointLabel(t, i, e, n, o) {
+    const s = this.options;
+    t.font = `bold ${s.labelFontSize}px system-ui, sans-serif`, t.textAlign = "center", t.textBaseline = "bottom";
+    const l = t.measureText(n), h = 4, a = l.width + h * 2, r = s.labelFontSize + h;
+    t.fillStyle = o, this.roundRect(t, i - a / 2, e - r, a, r, 3), t.fill(), t.fillStyle = "#ffffff", t.fillText(n, i, e - 2);
+  }
+  drawMeasurementLabel(t, i, e, n) {
+    const o = this.options, s = (i.pixelX + e.pixelX) / 2, l = (i.pixelY + e.pixelY) / 2, h = [];
+    o.showPeak && (h.push(`Peak Area: ${this.formatValue(n.area)}`), h.push(`Peak Height: ${this.formatValue(n.peakHeight)}`), h.push(`Integral: ${this.formatValue(n.integral)}`));
+    const a = o.labelFontSize + 4, r = 10, d = 170, p = h.length * a + r * 2;
+    let c = s + this.labelOffset.x, g = l + this.labelOffset.y;
+    const y = this.ctx.container.getBoundingClientRect();
+    c < 0 && (c = 0), c + d > y.width && (c = y.width - d), g < 0 && (g = 0), g + p > y.height && (g = y.height - p), this.labelBounds = { x: c, y: g, width: d, height: p }, t.fillStyle = o.labelBackground, t.strokeStyle = o.lineColor, t.lineWidth = 2, this.roundRect(t, c, g, d, p, 8), t.fill(), t.stroke(), t.fillStyle = o.labelColor, t.font = `${o.labelFontSize}px system-ui, sans-serif`, t.textAlign = "left", t.textBaseline = "top", h.forEach((b, x) => {
+      t.fillText(b, c + r, g + r + x * a);
+    });
+  }
+  drawStatusIndicator(t) {
+    const i = this.options, e = this.ctx.getPlotArea();
+    let n = "", o = "#666";
+    if (this.state.selectionState === "idle" ? (n = "📏 Click a point to start measuring", o = i.highlightColor) : this.state.selectionState === "waitingSecond" ? (n = "📏 Click second point to complete", o = "#f59e0b") : this.state.selectionState === "complete" && (n = "📏 Measurement complete (ESC to clear)", o = "#4ade80"), !n) return;
+    t.font = "12px system-ui, sans-serif";
+    const h = t.measureText(n).width + 8 * 2, a = 24, r = e.x + 10, d = e.y + 10;
+    t.fillStyle = "rgba(0, 0, 0, 0.75)", this.roundRect(t, r, d, h, a, 4), t.fill(), t.beginPath(), t.arc(r + 16, d + a / 2, 4, 0, Math.PI * 2), t.fillStyle = o, t.fill(), t.fillStyle = "#fff", t.textAlign = "left", t.textBaseline = "middle", t.fillText(n, r + 26, d + a / 2);
+  }
+  roundRect(t, i, e, n, o, s) {
+    t.beginPath(), t.moveTo(i + s, e), t.lineTo(i + n - s, e), t.quadraticCurveTo(i + n, e, i + n, e + s), t.lineTo(i + n, e + o - s), t.quadraticCurveTo(i + n, e + o, i + n - s, e + o), t.lineTo(i + s, e + o), t.quadraticCurveTo(i, e + o, i, e + o - s), t.lineTo(i, e + s), t.quadraticCurveTo(i, e, i + s, e), t.closePath();
+  }
+  formatValue(t) {
+    const i = Math.abs(t);
+    return i === 0 ? "0" : i >= 1e6 || i < 1e-3 ? t.toExponential(this.options.precision - 1) : t.toPrecision(this.options.precision);
+  }
+}
+const W = {
+  top: 10,
+  right: 12,
+  bottom: 10,
+  left: 12
+}, L = {
+  // Container
+  backgroundColor: "rgba(15, 18, 25, 0.95)",
+  backgroundGradient: "rgba(25, 30, 40, 0.90)",
+  borderColor: "rgba(255, 255, 255, 0.12)",
+  borderWidth: 1,
+  borderRadius: 8,
+  backdropBlur: 12,
+  shadow: {
+    color: "rgba(0, 0, 0, 0.4)",
+    offsetX: 0,
+    offsetY: 4,
+    blur: 16
+  },
+  // Typography
+  fontFamily: "Inter, system-ui, -apple-system, BlinkMacSystemFont, sans-serif",
+  textColor: "#ffffff",
+  textSecondaryColor: "rgba(255, 255, 255, 0.6)",
+  titleFontSize: 12,
+  titleFontWeight: 600,
+  contentFontSize: 11,
+  lineHeight: 1.4,
+  // Spacing
+  padding: W,
+  itemGap: 4,
+  headerGap: 8,
+  // Decorations
+  showSeriesIndicator: !0,
+  seriesIndicatorSize: 8,
+  showHeaderSeparator: !0,
+  separatorColor: "rgba(255, 255, 255, 0.1)",
+  showArrow: !0,
+  arrowSize: 6
+}, J = {
+  // Container
+  backgroundColor: "rgba(255, 255, 255, 0.98)",
+  borderColor: "rgba(0, 0, 0, 0.12)",
+  borderWidth: 1,
+  borderRadius: 8,
+  backdropBlur: 8,
+  shadow: {
+    color: "rgba(0, 0, 0, 0.12)",
+    offsetX: 0,
+    offsetY: 4,
+    blur: 12
+  },
+  // Typography
+  fontFamily: "Inter, system-ui, -apple-system, BlinkMacSystemFont, sans-serif",
+  textColor: "#1a1a1a",
+  textSecondaryColor: "rgba(0, 0, 0, 0.55)",
+  titleFontSize: 12,
+  titleFontWeight: 600,
+  contentFontSize: 11,
+  lineHeight: 1.4,
+  // Spacing
+  padding: W,
+  itemGap: 4,
+  headerGap: 8,
+  // Decorations
+  showSeriesIndicator: !0,
+  seriesIndicatorSize: 8,
+  showHeaderSeparator: !0,
+  separatorColor: "rgba(0, 0, 0, 0.08)",
+  showArrow: !0,
+  arrowSize: 6
+}, ht = {
+  // Container
+  backgroundColor: "rgba(255, 255, 255, 0.08)",
+  backgroundGradient: "rgba(255, 255, 255, 0.04)",
+  borderColor: "rgba(255, 255, 255, 0.2)",
+  borderWidth: 1,
+  borderRadius: 12,
+  backdropBlur: 20,
+  shadow: {
+    color: "rgba(0, 0, 0, 0.3)",
+    offsetX: 0,
+    offsetY: 8,
+    blur: 32
+  },
+  // Typography
+  fontFamily: "Inter, system-ui, sans-serif",
+  textColor: "rgba(255, 255, 255, 0.95)",
+  textSecondaryColor: "rgba(255, 255, 255, 0.6)",
+  titleFontSize: 12,
+  titleFontWeight: 600,
+  contentFontSize: 11,
+  lineHeight: 1.5,
+  // Spacing
+  padding: { top: 12, right: 14, bottom: 12, left: 14 },
+  itemGap: 5,
+  headerGap: 10,
+  // Decorations
+  showSeriesIndicator: !0,
+  seriesIndicatorSize: 8,
+  showHeaderSeparator: !0,
+  separatorColor: "rgba(255, 255, 255, 0.15)",
+  showArrow: !0,
+  arrowSize: 7
+}, Q = {
+  // Container
+  backgroundColor: "rgba(10, 15, 30, 0.95)",
+  backgroundGradient: "rgba(20, 25, 50, 0.90)",
+  borderColor: "rgba(100, 120, 255, 0.25)",
+  borderWidth: 1,
+  borderRadius: 8,
+  backdropBlur: 15,
+  shadow: {
+    color: "rgba(50, 70, 150, 0.25)",
+    offsetX: 0,
+    offsetY: 4,
+    blur: 20
+  },
+  // Typography
+  fontFamily: "Inter, system-ui, sans-serif",
+  textColor: "#e0e8ff",
+  textSecondaryColor: "rgba(180, 190, 255, 0.6)",
+  titleFontSize: 12,
+  titleFontWeight: 600,
+  contentFontSize: 11,
+  lineHeight: 1.4,
+  // Spacing
+  padding: W,
+  itemGap: 4,
+  headerGap: 8,
+  // Decorations
+  showSeriesIndicator: !0,
+  seriesIndicatorSize: 8,
+  showHeaderSeparator: !0,
+  separatorColor: "rgba(100, 120, 255, 0.15)",
+  showArrow: !0,
+  arrowSize: 6
+}, Z = {
+  // Container
+  backgroundColor: "rgba(8, 20, 40, 0.96)",
+  backgroundGradient: "rgba(15, 35, 60, 0.92)",
+  borderColor: "rgba(30, 136, 229, 0.35)",
+  borderWidth: 1,
+  borderRadius: 6,
+  backdropBlur: 10,
+  shadow: {
+    color: "rgba(30, 136, 229, 0.2)",
+    offsetX: 0,
+    offsetY: 4,
+    blur: 16
+  },
+  // Typography
+  fontFamily: '"JetBrains Mono", "Fira Code", monospace',
+  textColor: "#bbdefb",
+  textSecondaryColor: "rgba(144, 202, 249, 0.7)",
+  titleFontSize: 11,
+  titleFontWeight: 600,
+  contentFontSize: 11,
+  lineHeight: 1.5,
+  // Spacing
+  padding: { top: 8, right: 10, bottom: 8, left: 10 },
+  itemGap: 3,
+  headerGap: 6,
+  // Decorations
+  showSeriesIndicator: !0,
+  seriesIndicatorSize: 6,
+  showHeaderSeparator: !0,
+  separatorColor: "rgba(30, 136, 229, 0.2)",
+  showArrow: !0,
+  arrowSize: 5
+}, dt = {
+  // Container
+  backgroundColor: "rgba(0, 0, 0, 0.92)",
+  borderColor: "#00ffff",
+  borderWidth: 1,
+  borderRadius: 4,
+  backdropBlur: 0,
+  shadow: {
+    color: "rgba(0, 255, 255, 0.35)",
+    offsetX: 0,
+    offsetY: 0,
+    blur: 20
+  },
+  // Typography
+  fontFamily: '"Orbitron", "Exo 2", sans-serif',
+  textColor: "#00ffff",
+  textSecondaryColor: "rgba(0, 255, 255, 0.6)",
+  titleFontSize: 11,
+  titleFontWeight: 700,
+  contentFontSize: 10,
+  lineHeight: 1.4,
+  // Spacing
+  padding: { top: 8, right: 12, bottom: 8, left: 12 },
+  itemGap: 4,
+  headerGap: 6,
+  // Decorations
+  showSeriesIndicator: !0,
+  seriesIndicatorSize: 6,
+  showHeaderSeparator: !0,
+  separatorColor: "rgba(0, 255, 255, 0.3)",
+  showArrow: !1,
+  arrowSize: 0
+}, ct = {
+  // Container
+  backgroundColor: "rgba(30, 35, 45, 0.9)",
+  borderColor: "transparent",
+  borderWidth: 0,
+  borderRadius: 4,
+  backdropBlur: 8,
+  shadow: {
+    color: "rgba(0, 0, 0, 0.3)",
+    offsetX: 0,
+    offsetY: 2,
+    blur: 8
+  },
+  // Typography
+  fontFamily: "Inter, system-ui, sans-serif",
+  textColor: "#ffffff",
+  textSecondaryColor: "rgba(255, 255, 255, 0.7)",
+  titleFontSize: 10,
+  titleFontWeight: 500,
+  contentFontSize: 10,
+  lineHeight: 1.3,
+  // Spacing
+  padding: { top: 6, right: 8, bottom: 6, left: 8 },
+  itemGap: 2,
+  headerGap: 4,
+  // Decorations
+  showSeriesIndicator: !1,
+  seriesIndicatorSize: 0,
+  showHeaderSeparator: !1,
+  separatorColor: "transparent",
+  showArrow: !1,
+  arrowSize: 0
+}, ut = {
+  dark: L,
+  light: J,
+  glass: ht,
+  midnight: Q,
+  electrochemistry: Z,
+  neon: dt,
+  minimal: ct
+};
+function ft(f) {
+  const t = ut[f];
+  return t || (console.warn(`[Tooltip] Unknown theme "${f}", using dark`), L);
+}
+function pt(f, t) {
+  const i = typeof f == "string" ? ft(f) : f;
+  return {
+    ...i,
+    ...t,
+    padding: { ...i.padding, ...t.padding },
+    shadow: { ...i.shadow, ...t.shadow }
+  };
+}
+function k(f) {
+  switch (f.toLowerCase()) {
+    case "light":
+      return J;
+    case "midnight":
+      return Q;
+    case "electrochemistry":
+    case "electrochem":
+      return Z;
+    case "dark":
+    default:
+      return L;
+  }
+}
+const gt = L, yt = {
+  offset: { x: 12, y: 12 },
+  preferredPosition: "auto",
+  constrainToPlotArea: !0,
+  constrainToContainer: !0,
+  autoFlip: !0,
+  showArrow: !0,
+  arrowSize: 6
+};
+class xt {
+  constructor(t = {}) {
+    u(this, "config");
+    u(this, "containerWidth", 0);
+    u(this, "containerHeight", 0);
+    u(this, "plotArea", null);
+    this.config = { ...yt, ...t };
+  }
+  /**
+   * Update container dimensions
+   */
+  setContainerSize(t, i) {
+    this.containerWidth = t, this.containerHeight = i;
+  }
+  /**
+   * Update plot area bounds
+   */
+  setPlotArea(t) {
+    this.plotArea = t;
+  }
+  /**
+   * Update configuration
+   */
+  configure(t) {
+    this.config = { ...this.config, ...t };
+  }
+  /**
+   * Calculate optimal tooltip position
+   * 
+   * @param targetX - Target X coordinate (where tooltip points to)
+   * @param targetY - Target Y coordinate
+   * @param measurement - Tooltip dimensions
+   * @returns Calculated position with arrow configuration
+   */
+  calculatePosition(t, i, e) {
+    const { offset: n, preferredPosition: o, autoFlip: s, showArrow: l, arrowSize: h } = this.config, a = e.width + e.padding.left + e.padding.right, r = e.height + e.padding.top + e.padding.bottom;
+    let d = this.determinePosition(
+      t,
+      i,
+      a,
+      r,
+      o
+    ), { x: p, y: c, arrowPosition: g } = this.calculateCoordinates(
+      t,
+      i,
+      a,
+      r,
+      d,
+      n,
+      l ? h : 0
+    ), y = !1;
+    if (s && !this.fitsInBounds(p, c, a, r)) {
+      const S = this.flipPosition(d), w = this.calculateCoordinates(
+        t,
+        i,
+        a,
+        r,
+        S,
+        n,
+        l ? h : 0
+      );
+      this.fitsInBounds(w.x, w.y, a, r) && (p = w.x, c = w.y, g = w.arrowPosition, y = !0);
+    }
+    const b = this.constrainToBounds(p, c, a, r);
+    let x = 0;
+    if (l) {
+      if (g === "top" || g === "bottom") {
+        const S = t - b.x;
+        x = Math.max(h + 4, Math.min(a - h - 4, S));
+      } else if (g === "left" || g === "right") {
+        const S = i - b.y;
+        x = Math.max(h + 4, Math.min(r - h - 4, S));
+      }
+    }
+    return {
+      x: b.x,
+      y: b.y,
+      arrowPosition: l ? g : "none",
+      arrowOffset: x,
+      wasFlipped: y
+    };
+  }
+  /**
+   * Determine best position based on available space
+   */
+  determinePosition(t, i, e, n, o) {
+    if (o !== "auto")
+      return o;
+    const s = this.getConstraintBounds(), l = i - s.top, h = s.bottom - i, a = t - s.left, r = s.right - t, d = l >= n + this.config.offset.y, p = h >= n + this.config.offset.y, c = r >= e + this.config.offset.x, g = a >= e + this.config.offset.x;
+    return d && l >= h ? "top" : p ? "bottom" : c && r >= a ? "right" : g ? "left" : [
+      { pos: "top", space: l },
+      { pos: "bottom", space: h },
+      { pos: "right", space: r },
+      { pos: "left", space: a }
+    ].sort((b, x) => x.space - b.space)[0].pos;
+  }
+  /**
+   * Calculate tooltip coordinates for a given position
+   */
+  calculateCoordinates(t, i, e, n, o, s, l) {
+    let h, a, r;
+    switch (o) {
+      case "top":
+        h = t - e / 2, a = i - n - s.y - l, r = "bottom";
+        break;
+      case "bottom":
+        h = t - e / 2, a = i + s.y + l, r = "top";
+        break;
+      case "right":
+        h = t + s.x + l, a = i - n / 2, r = "left";
+        break;
+      case "left":
+        h = t - e - s.x - l, a = i - n / 2, r = "right";
+        break;
+    }
+    return { x: h, y: a, arrowPosition: r };
+  }
+  /**
+   * Get the opposite position for flipping
+   */
+  flipPosition(t) {
+    switch (t) {
+      case "top":
+        return "bottom";
+      case "bottom":
+        return "top";
+      case "left":
+        return "right";
+      case "right":
+        return "left";
+    }
+  }
+  /**
+   * Check if tooltip fits within bounds
+   */
+  fitsInBounds(t, i, e, n) {
+    const o = this.getConstraintBounds();
+    return t >= o.left && i >= o.top && t + e <= o.right && i + n <= o.bottom;
+  }
+  /**
+   * Constrain position to stay within bounds
+   */
+  constrainToBounds(t, i, e, n) {
+    const o = this.getConstraintBounds(), s = 4;
+    let l = t, h = i;
+    return l < o.left + s ? l = o.left + s : l + e > o.right - s && (l = o.right - e - s), h < o.top + s ? h = o.top + s : h + n > o.bottom - s && (h = o.bottom - n - s), { x: l, y: h };
+  }
+  /**
+   * Get the bounds to constrain tooltip within
+   */
+  getConstraintBounds() {
+    let t = {
+      top: 0,
+      left: 0,
+      right: this.containerWidth,
+      bottom: this.containerHeight
+    };
+    return this.config.constrainToPlotArea && this.plotArea && (t = {
+      top: Math.max(t.top, this.plotArea.y),
+      left: Math.max(t.left, this.plotArea.x),
+      right: Math.min(t.right, this.plotArea.x + this.plotArea.width),
+      bottom: Math.min(t.bottom, this.plotArea.y + this.plotArea.height)
+    }), t;
+  }
+  /**
+   * Calculate position for crosshair tooltip (follows cursor vertically)
+   */
+  calculateCrosshairPosition(t, i, e) {
+    const { offset: n } = this.config, o = this.getConstraintBounds(), s = e.width + e.padding.left + e.padding.right, l = e.height + e.padding.top + e.padding.bottom;
+    let h = t + n.x, a = "left";
+    h + s > o.right - 4 && (h = t - s - n.x, a = "right");
+    let r = i - l / 2;
+    r = Math.max(o.top + 4, Math.min(o.bottom - l - 4, r));
+    const d = i - r;
+    return {
+      x: h,
+      y: r,
+      arrowPosition: a,
+      arrowOffset: Math.max(8, Math.min(l - 8, d)),
+      wasFlipped: a === "right"
+    };
+  }
+}
+class bt {
+  constructor(t, i) {
+    u(this, "ctx");
+    u(this, "theme");
+    this.ctx = t, this.theme = i;
+  }
+  /**
+   * Update the theme
+   */
+  setTheme(t) {
+    this.theme = t;
+  }
+  /**
+   * Render a tooltip with the given template
+   */
+  render(t, i, e) {
+    const n = e.measure(this.ctx, t, this.theme), o = n.width + n.padding.left + n.padding.right, s = n.height + n.padding.top + n.padding.bottom;
+    this.ctx.save(), this.drawBackground(i.x, i.y, o, s, i.arrowPosition || "none"), i.arrowPosition && i.arrowPosition !== "none" && this.drawArrow(
+      i.x,
+      i.y,
+      o,
+      s,
+      i.arrowPosition,
+      i.arrowOffset || 0
+    ), e.render(this.ctx, t, i, n, this.theme), this.ctx.restore();
+  }
+  /**
+   * Draw tooltip background with all effects
+   */
+  drawBackground(t, i, e, n, o) {
+    const { ctx: s, theme: l } = this, h = l.borderRadius;
+    if (s.save(), l.shadow.blur > 0 && (s.shadowColor = l.shadow.color, s.shadowOffsetX = l.shadow.offsetX, s.shadowOffsetY = l.shadow.offsetY, s.shadowBlur = l.shadow.blur), s.beginPath(), this.roundRect(t, i, e, n, h), l.backgroundGradient) {
+      const a = s.createLinearGradient(t, i, t, i + n);
+      a.addColorStop(0, l.backgroundColor), a.addColorStop(1, l.backgroundGradient), s.fillStyle = a;
+    } else
+      s.fillStyle = l.backgroundColor;
+    s.fill(), s.shadowColor = "transparent", l.borderWidth > 0 && (s.strokeStyle = l.borderColor, s.lineWidth = l.borderWidth, s.stroke()), s.restore();
+  }
+  /**
+   * Draw arrow pointing to target
+   */
+  drawArrow(t, i, e, n, o, s) {
+    const { ctx: l, theme: h } = this, a = h.arrowSize;
+    if (!(a <= 0 || o === "none")) {
+      switch (l.save(), l.fillStyle = h.backgroundColor, l.strokeStyle = h.borderColor, l.lineWidth = h.borderWidth, l.beginPath(), o) {
+        case "top":
+          const r = t + s;
+          l.moveTo(r - a, i), l.lineTo(r, i - a), l.lineTo(r + a, i);
+          break;
+        case "bottom":
+          const d = t + s, p = i + n;
+          l.moveTo(d - a, p), l.lineTo(d, p + a), l.lineTo(d + a, p);
+          break;
+        case "left":
+          const c = i + s;
+          l.moveTo(t, c - a), l.lineTo(t - a, c), l.lineTo(t, c + a);
+          break;
+        case "right":
+          const g = t + e, y = i + s;
+          l.moveTo(g, y - a), l.lineTo(g + a, y), l.lineTo(g, y + a);
+          break;
+      }
+      l.closePath(), l.fill(), h.borderWidth > 0 && l.stroke(), l.restore();
+    }
+  }
+  /**
+   * Draw a rounded rectangle path
+   */
+  roundRect(t, i, e, n, o) {
+    const { ctx: s } = this, l = Math.min(o, e / 2, n / 2);
+    s.moveTo(t + l, i), s.lineTo(t + e - l, i), s.arcTo(t + e, i, t + e, i + l, l), s.lineTo(t + e, i + n - l), s.arcTo(t + e, i + n, t + e - l, i + n, l), s.lineTo(t + l, i + n), s.arcTo(t, i + n, t, i + n - l, l), s.lineTo(t, i + l), s.arcTo(t, i, t + l, i, l), s.closePath();
+  }
+  /**
+   * Draw a horizontal separator line
+   */
+  drawSeparator(t, i, e) {
+    const { ctx: n, theme: o } = this;
+    o.showHeaderSeparator && (n.save(), n.strokeStyle = o.separatorColor, n.lineWidth = 1, n.beginPath(), n.moveTo(t, i), n.lineTo(t + e, i), n.stroke(), n.restore());
+  }
+  /**
+   * Draw a series color indicator (small circle or square)
+   */
+  drawSeriesIndicator(t, i, e) {
+    const { ctx: n, theme: o } = this;
+    if (!o.showSeriesIndicator) return;
+    const l = o.seriesIndicatorSize / 2;
+    n.save(), n.fillStyle = e, n.beginPath(), n.arc(t + l, i, l, 0, Math.PI * 2), n.fill(), n.restore();
+  }
+  /**
+   * Measure text width
+   */
+  measureText(t, i, e = 400) {
+    const { ctx: n, theme: o } = this;
+    return n.font = `${e} ${i}px ${o.fontFamily}`, n.measureText(t).width;
+  }
+  /**
+   * Draw text with theme styling
+   */
+  drawText(t, i, e, n = {}) {
+    const { ctx: o, theme: s } = this, {
+      fontSize: l = s.contentFontSize,
+      fontWeight: h = 400,
+      color: a = s.textColor,
+      align: r = "left",
+      baseline: d = "top"
+    } = n;
+    o.save(), o.font = `${h} ${l}px ${s.fontFamily}`, o.fillStyle = a, o.textAlign = r, o.textBaseline = d, o.fillText(t, i, e), o.restore();
+  }
+  /**
+   * Draw a label-value pair
+   */
+  drawLabelValue(t, i, e, n, o) {
+    const { theme: s } = this;
+    this.drawText(e, t, i, {
+      color: s.textSecondaryColor,
+      fontSize: s.contentFontSize
+    }), this.drawText(n, t + o, i, {
+      color: s.textColor,
+      fontSize: s.contentFontSize,
+      align: "right"
+    });
+  }
+  /**
+   * Get theme for external use
+   */
+  getTheme() {
+    return this.theme;
+  }
+}
+function Y(f, t = 4) {
+  if (f == null || isNaN(f))
+    return "N/A";
+  const i = Math.abs(f);
+  return i !== 0 && (i < 1e-4 || i >= 1e4) ? f.toExponential(2) : i < 0.01 ? f.toPrecision(t) : i < 1 ? f.toFixed(4) : i < 100 ? f.toFixed(3) : f.toFixed(1);
+}
+class St {
+  constructor() {
+    u(this, "id", "default");
+    u(this, "name", "Default Data Point");
+    u(this, "supportedTypes", ["datapoint"]);
+    // Cached measurements
+    u(this, "cachedKey", "");
+    u(this, "cachedMeasurement", null);
+  }
+  /**
+   * Measure tooltip dimensions
+   */
+  measure(t, i, e) {
+    const n = `${i.seriesId}-${i.dataIndex}-${i.dataX}-${i.dataY}`;
+    if (n === this.cachedKey && this.cachedMeasurement)
+      return this.cachedMeasurement;
+    t.font = `${e.titleFontWeight} ${e.titleFontSize}px ${e.fontFamily}`;
+    const o = t.measureText(i.seriesName).width;
+    t.font = `400 ${e.contentFontSize}px ${e.fontFamily}`;
+    const s = 35, l = t.measureText(Y(i.dataX)).width, h = t.measureText(Y(i.dataY)).width;
+    let a = s + Math.max(l, h), r = e.contentFontSize * e.lineHeight * 2;
+    if (i.yError) {
+      const g = `± ${Y(i.yError[0])} / ${Y(i.yError[1])}`;
+      a = Math.max(a, t.measureText(g).width), r += e.contentFontSize * e.lineHeight;
+    }
+    if (i.cycle !== void 0) {
+      const g = `Cycle: ${i.cycle}`;
+      a = Math.max(a, t.measureText(g).width), r += e.contentFontSize * e.lineHeight;
+    }
+    const d = e.showSeriesIndicator ? e.seriesIndicatorSize + 6 : 0, p = Math.max(o + d, a), c = e.titleFontSize * e.lineHeight + e.headerGap + r;
+    return this.cachedMeasurement = {
+      width: p + 2,
+      // Tiny buffer
+      height: c + 4,
+      padding: e.padding,
+      arrow: e.showArrow ? { width: e.arrowSize * 2, height: e.arrowSize } : void 0
+    }, this.cachedKey = n, this.cachedMeasurement;
+  }
+  /**
+   * Render the tooltip
+   */
+  render(t, i, e, n, o) {
+    const { x: s, y: l } = e, { padding: h } = o;
+    let a = s + h.left, r = l + h.top;
+    if (t.save(), t.textAlign = "left", t.textBaseline = "top", o.showSeriesIndicator) {
+      const p = r + o.titleFontSize / 2;
+      t.save(), t.fillStyle = i.seriesColor, t.beginPath(), t.arc(a + o.seriesIndicatorSize / 2, p, o.seriesIndicatorSize / 2, 0, Math.PI * 2), t.fill(), t.restore(), a += o.seriesIndicatorSize + 6;
+    }
+    if (t.font = `${o.titleFontWeight} ${o.titleFontSize}px ${o.fontFamily}`, t.fillStyle = o.textColor, t.fillText(i.seriesName, a, r), r += o.titleFontSize * o.lineHeight + 2, o.showHeaderSeparator) {
+      const p = n.width;
+      t.save(), t.strokeStyle = o.separatorColor, t.lineWidth = 1, t.globalAlpha = 0.4, t.beginPath(), t.moveTo(s + h.left, r + o.headerGap / 2), t.lineTo(s + h.left + p, r + o.headerGap / 2), t.stroke(), t.restore();
+    }
+    r += o.headerGap + 2, a = s + h.left, t.font = `400 ${o.contentFontSize}px ${o.fontFamily}`, t.fillStyle = o.textSecondaryColor, t.fillText("X:", a, r), t.fillStyle = o.textColor;
+    const d = 35;
+    if (t.fillText(Y(i.dataX), a + d, r), r += o.contentFontSize * o.lineHeight + 2, t.fillStyle = o.textSecondaryColor, t.fillText("Y:", a, r), t.fillStyle = o.textColor, t.fillText(Y(i.dataY), a + d, r), r += o.contentFontSize * o.lineHeight + 2, i.yError) {
+      t.fillStyle = o.textSecondaryColor;
+      const p = `± ${Y(i.yError[0])} / +${Y(i.yError[1])}`;
+      t.fillText(p, a, r), r += o.contentFontSize * o.lineHeight;
+    }
+    i.cycle !== void 0 && (t.fillStyle = o.textSecondaryColor, t.fillText("Cycle:", a, r), t.fillStyle = o.textColor, t.fillText(String(i.cycle), a + 45, r)), t.restore();
+  }
+}
+const E = new St();
+function H(f) {
+  if (f == null || isNaN(f))
+    return "N/A";
+  const t = Math.abs(f);
+  return t === 0 ? "0" : t >= 1e9 ? (f / 1e9).toFixed(1) + "G" : t >= 1e6 ? (f / 1e6).toFixed(1) + "M" : t >= 1e3 ? (f / 1e3).toFixed(1) + "k" : t >= 1 ? f.toFixed(2) : t >= 1e-3 ? (f * 1e3).toFixed(1) + "m" : t >= 1e-6 ? (f * 1e6).toFixed(1) + "µ" : t >= 1e-9 ? (f * 1e9).toFixed(1) + "n" : f.toExponential(1);
+}
+class Tt {
+  constructor() {
+    u(this, "id", "minimal");
+    u(this, "name", "Minimal");
+    u(this, "supportedTypes", ["datapoint"]);
+    // Cached measurements
+    u(this, "cachedKey", "");
+    u(this, "cachedMeasurement", null);
+  }
+  /**
+   * Measure tooltip dimensions
+   */
+  measure(t, i, e) {
+    const n = `${i.seriesId}-${i.dataIndex}-${i.dataX}-${i.dataY}-${e.fontFamily}`;
+    if (n === this.cachedKey && this.cachedMeasurement)
+      return this.cachedMeasurement;
+    t.font = `${e.contentFontSize}px ${e.fontFamily}`;
+    const o = `${H(i.dataX)} ▪ ${H(i.dataY)}`, s = t.measureText(o).width;
+    return this.cachedMeasurement = {
+      width: s,
+      height: e.contentFontSize * e.lineHeight,
+      padding: {
+        top: 6,
+        right: 8,
+        bottom: 6,
+        left: 8
+      }
+    }, this.cachedKey = n, this.cachedMeasurement;
+  }
+  /**
+   * Render the tooltip
+   */
+  render(t, i, e, n, o) {
+    const { padding: s } = n, l = e.x + s.left, h = e.y + s.top, a = H(i.dataX), r = H(i.dataY);
+    t.save(), t.font = `${o.contentFontSize}px ${o.fontFamily}`, t.textAlign = "left", t.textBaseline = "top", t.fillStyle = o.textSecondaryColor, t.fillText(a, l, h);
+    const d = t.measureText(a).width;
+    t.fillStyle = i.seriesColor, t.fillText(" ▪ ", l + d, h);
+    const p = t.measureText(" ▪ ").width;
+    t.fillStyle = o.textColor, t.fillText(r, l + d + p, h), t.restore();
+  }
+}
+const tt = new Tt(), F = {
+  INDICATOR_MARGIN: 8,
+  MIN_LABEL_WIDTH: 60,
+  LINE_SPACING: 2,
+  SAFETY_BUFFER: 4,
+  HEADER_SPACING: 2,
+  GAP_SPACING: 2
+};
+function q(f) {
+  if (f == null || isNaN(f))
+    return "N/A";
+  const t = Math.abs(f);
+  return t === 0 ? "0" : t < 1e-4 || t >= 1e4 ? f.toExponential(2) : t < 0.01 ? f.toPrecision(3) : t < 1 ? f.toFixed(4) : t < 100 ? f.toFixed(3) : f.toFixed(1);
+}
+class wt {
+  constructor() {
+    u(this, "id", "crosshair");
+    u(this, "name", "Multi-Series Crosshair");
+    u(this, "supportedTypes", ["crosshair"]);
+    // Cached measurements
+    u(this, "cachedKey", "");
+    u(this, "cachedMeasurement", null);
+    u(this, "formattedData", null);
+  }
+  /**
+   * Generate cache key from data and theme
+   */
+  getCacheKey(t, i) {
+    const e = t.interpolatedValues.map((n) => `${n.seriesName}-${n.y}`).join("|");
+    return [
+      t.dataX,
+      e,
+      i.fontFamily,
+      i.titleFontSize,
+      i.contentFontSize,
+      i.showSeriesIndicator,
+      i.seriesIndicatorSize,
+      `${i.padding.top}-${i.padding.right}-${i.padding.bottom}-${i.padding.left}`
+    ].join(":");
+  }
+  /**
+   * Format data for rendering
+   */
+  formatData(t) {
+    return {
+      header: `⌖ X = ${q(t.dataX)}`,
+      series: t.interpolatedValues.map((i) => ({
+        name: i.seriesName,
+        value: q(i.y),
+        color: i.seriesColor,
+        isInterpolated: i.isInterpolated
+      }))
+    };
+  }
+  /**
+   * Measure tooltip dimensions
+   */
+  measure(t, i, e) {
+    if (!i.interpolatedValues || i.interpolatedValues.length === 0)
+      return {
+        width: 100,
+        height: e.titleFontSize * e.lineHeight,
+        padding: e.padding
+      };
+    const n = this.getCacheKey(i, e);
+    if (n === this.cachedKey && this.cachedMeasurement)
+      return this.cachedMeasurement;
+    this.formattedData = this.formatData(i), t.font = `${e.titleFontWeight} ${e.titleFontSize}px ${e.fontFamily}`;
+    let o = t.measureText(this.formattedData.header).width;
+    t.font = `400 ${e.contentFontSize}px ${e.fontFamily}`;
+    const s = e.showSeriesIndicator ? e.seriesIndicatorSize + F.INDICATOR_MARGIN : 0;
+    for (const r of this.formattedData.series) {
+      const d = t.measureText(`${r.name}:`).width, p = t.measureText(r.value).width, c = s + Math.max(d, F.MIN_LABEL_WIDTH) + p;
+      o = Math.max(o, c);
+    }
+    const l = e.titleFontSize * e.lineHeight, a = this.formattedData.series.length * (e.contentFontSize * e.lineHeight + F.LINE_SPACING);
+    return this.cachedMeasurement = {
+      width: o + F.SAFETY_BUFFER,
+      height: l + e.headerGap + a,
+      padding: e.padding
+    }, this.cachedKey = n, this.cachedMeasurement;
+  }
+  /**
+   * Render the tooltip
+   */
+  render(t, i, e, n, o) {
+    if (!i.interpolatedValues || i.interpolatedValues.length === 0)
+      return;
+    const s = this.formattedData || this.formatData(i), { x: l, y: h } = e, { padding: a } = o;
+    let r = h + a.top;
+    const d = l + a.left;
+    t.save(), t.textAlign = "left", t.textBaseline = "top", t.font = `${o.titleFontWeight} ${o.titleFontSize}px ${o.fontFamily}`, t.fillStyle = o.textColor, t.fillText(s.header, d, r), r += o.titleFontSize * o.lineHeight + F.HEADER_SPACING, o.showHeaderSeparator && (t.strokeStyle = o.separatorColor, t.lineWidth = 1, t.globalAlpha = 0.4, t.beginPath(), t.moveTo(d, r + o.headerGap / 2), t.lineTo(d + n.width, r + o.headerGap / 2), t.stroke(), t.globalAlpha = 1), r += o.headerGap + F.GAP_SPACING, t.font = `400 ${o.contentFontSize}px ${o.fontFamily}`;
+    for (const p of s.series) {
+      let c = d;
+      if (o.showSeriesIndicator && o.seriesIndicatorSize > 0) {
+        const b = r + o.contentFontSize / 2, x = o.seriesIndicatorSize / 2;
+        t.save(), t.beginPath(), t.arc(c + x, b, x, 0, Math.PI * 2), p.isInterpolated ? (t.strokeStyle = p.color, t.lineWidth = 1.5, t.stroke()) : (t.fillStyle = p.color, t.fill()), t.restore(), c += o.seriesIndicatorSize + F.INDICATOR_MARGIN;
+      }
+      t.fillStyle = o.textSecondaryColor, t.fillText(`${p.name}:`, c, r);
+      const g = t.measureText(`${p.name}: `).width, y = Math.max(g, F.MIN_LABEL_WIDTH);
+      t.fillStyle = o.textColor, t.fillText(p.value, c + y, r), r += o.contentFontSize * o.lineHeight + F.LINE_SPACING;
+    }
+    t.restore();
+  }
+}
+const R = new wt();
+function P(f) {
+  if (f == null || isNaN(f))
+    return "N/A";
+  const t = Math.abs(f);
+  return t === 0 ? "0" : t < 1e-4 || t >= 1e4 ? f.toExponential(3) : t < 0.01 ? f.toPrecision(4) : t < 1 ? f.toFixed(4) : t < 100 ? f.toFixed(3) : f.toFixed(2);
+}
+class mt {
+  constructor() {
+    u(this, "id", "heatmap");
+    u(this, "name", "Heatmap Value");
+    u(this, "supportedTypes", ["heatmap"]);
+    // Color swatch dimensions
+    u(this, "swatchSize", 14);
+    u(this, "swatchGap", 8);
+    // Cached measurements
+    u(this, "cachedKey", "");
+    u(this, "cachedMeasurement", null);
+  }
+  /**
+   * Measure tooltip dimensions
+   */
+  measure(t, i, e) {
+    const n = `${i.seriesId}-${i.xIndex}-${i.yIndex}-${e.fontFamily}-${e.titleFontSize}`;
+    if (n === this.cachedKey && this.cachedMeasurement)
+      return this.cachedMeasurement;
+    t.font = `${e.titleFontWeight} ${e.titleFontSize}px ${e.fontFamily}`;
+    const o = `Grid [${i.xIndex}, ${i.yIndex}]`;
+    let s = t.measureText(o).width;
+    t.font = `400 ${e.contentFontSize}px ${e.fontFamily}`;
+    const l = `Value: ${P(i.zValue)}`, h = this.swatchSize + this.swatchGap + t.measureText(l).width;
+    if (s = Math.max(s, h), i.colorScale) {
+      const y = `Min: ${P(i.colorScale.min)}  Max: ${P(i.colorScale.max)}`;
+      s = Math.max(s, this.swatchSize + this.swatchGap + t.measureText(y).width);
+    }
+    const a = 25, r = a + t.measureText(P(i.dataX)).width, d = a + t.measureText(P(i.dataY)).width;
+    s = Math.max(s, r, d);
+    const p = e.titleFontSize * e.lineHeight, g = (i.colorScale ? 4 : 3) * e.contentFontSize * e.lineHeight;
+    return this.cachedMeasurement = {
+      width: s + 4,
+      // Small buffer
+      height: p + e.headerGap + g + e.itemGap,
+      padding: e.padding
+    }, this.cachedKey = n, this.cachedMeasurement;
+  }
+  /**
+   * Render the tooltip
+   */
+  render(t, i, e, n, o) {
+    const { x: s, y: l } = e, { padding: h } = o;
+    let a = l + h.top;
+    const r = s + h.left;
+    t.save(), t.textAlign = "left", t.textBaseline = "top", t.font = `${o.titleFontWeight} ${o.titleFontSize}px ${o.fontFamily}`, t.fillStyle = o.textColor;
+    const d = `Grid [${i.xIndex}, ${i.yIndex}]`;
+    t.fillText(d, r, a), a += o.titleFontSize * o.lineHeight + 2, o.showHeaderSeparator && (t.strokeStyle = o.separatorColor, t.lineWidth = 1, t.globalAlpha = 0.4, t.beginPath(), t.moveTo(r, a + o.headerGap / 2), t.lineTo(r + n.width, a + o.headerGap / 2), t.stroke(), t.globalAlpha = 1), a += o.headerGap + 2, t.font = `400 ${o.contentFontSize}px ${o.fontFamily}`;
+    const p = a + (o.contentFontSize * o.lineHeight - this.swatchSize) / 2;
+    t.fillStyle = i.mappedColor || o.textColor, t.fillRect(r, p, this.swatchSize, this.swatchSize), t.strokeStyle = o.separatorColor, t.lineWidth = 1, t.strokeRect(r, p, this.swatchSize, this.swatchSize), t.fillStyle = o.textSecondaryColor, t.fillText("Value:", r + this.swatchSize + this.swatchGap, a), t.fillStyle = o.textColor;
+    const c = t.measureText("Value: ").width;
+    if (t.fillText(P(i.zValue), r + this.swatchSize + this.swatchGap + c, a), a += o.contentFontSize * o.lineHeight, i.colorScale) {
+      t.fillStyle = o.textSecondaryColor, t.font = `400 ${o.contentFontSize - 1}px ${o.fontFamily}`;
+      const g = `Min: ${P(i.colorScale.min)}  Max: ${P(i.colorScale.max)}`;
+      t.fillText(g, r + this.swatchSize + this.swatchGap, a), a += o.contentFontSize * o.lineHeight;
+    }
+    a += o.itemGap + 2, t.font = `400 ${o.contentFontSize}px ${o.fontFamily}`, t.fillStyle = o.textSecondaryColor, t.fillText("X:", r, a), t.fillStyle = o.textColor, t.fillText(P(i.dataX), r + 25, a), a += o.contentFontSize * o.lineHeight + 2, t.fillStyle = o.textSecondaryColor, t.fillText("Y:", r, a), t.fillStyle = o.textColor, t.fillText(P(i.dataY), r + 25, a), t.restore();
+  }
+}
+const N = new mt();
+function X(f, t = 3) {
+  if (f == null || isNaN(f))
+    return "N/A";
+  if (f === 0) return "0";
+  const i = Math.floor(Math.log10(Math.abs(f))), e = f / Math.pow(10, i);
+  if (Math.abs(i) <= 2)
+    return f.toPrecision(t);
+  const n = {
+    0: "⁰",
+    1: "¹",
+    2: "²",
+    3: "³",
+    4: "⁴",
+    5: "⁵",
+    6: "⁶",
+    7: "⁷",
+    8: "⁸",
+    9: "⁹",
+    "-": "⁻",
+    "+": "⁺"
+  }, o = i.toString();
+  let s = "";
+  for (const l of o)
+    s += n[l] || l;
+  return `${e.toFixed(t - 1)} × 10${s}`;
+}
+class Mt {
+  constructor() {
+    u(this, "id", "scientific");
+    u(this, "name", "Scientific Notation");
+    u(this, "supportedTypes", ["datapoint"]);
+    // Cached measurements
+    u(this, "cachedKey", "");
+    u(this, "cachedMeasurement", null);
+  }
+  /**
+   * Measure tooltip dimensions
+   */
+  measure(t, i, e) {
+    const n = `${i.seriesId}-${i.dataIndex}-${i.dataX}-${i.dataY}-${e.fontFamily}-${e.titleFontSize}`;
+    if (n === this.cachedKey && this.cachedMeasurement)
+      return this.cachedMeasurement;
+    t.font = `${e.titleFontWeight} ${e.titleFontSize}px ${e.fontFamily}`;
+    const o = t.measureText(i.seriesName).width + (e.showSeriesIndicator ? e.seriesIndicatorSize + 8 : 0);
+    t.font = `400 ${e.contentFontSize}px ${e.fontFamily}`;
+    const s = 28, l = X(i.dataX);
+    let h = Math.max(o, s + t.measureText(l).width);
+    const a = X(i.dataY);
+    let r = s + t.measureText(a).width;
+    i.yError && (r += t.measureText(` ± ${X(i.yError[0])}`).width), h = Math.max(h, r);
+    let d = `Index: ${i.dataIndex}`;
+    i.cycle !== void 0 && (d += `  │  Cycle: ${i.cycle}`), h = Math.max(h, t.measureText(d).width);
+    let p = 3;
+    (i.cycle !== void 0 || i.yError) && (p += 1);
+    const c = e.titleFontSize * e.lineHeight + e.headerGap, g = (p - 1) * e.contentFontSize * e.lineHeight, y = i.cycle !== void 0 ? e.itemGap : 0;
+    return this.cachedMeasurement = {
+      width: h,
+      height: c + g + y,
+      padding: e.padding
+    }, this.cachedKey = n, this.cachedMeasurement;
+  }
+  /**
+   * Render the tooltip
+   */
+  render(t, i, e, n, o) {
+    const { x: s, y: l } = e, { padding: h } = o;
+    let a = l + h.top, r = s + h.left;
+    if (t.save(), t.textAlign = "left", t.textBaseline = "top", o.showSeriesIndicator) {
+      const c = a + o.titleFontSize / 2;
+      t.fillStyle = i.seriesColor, t.beginPath(), t.arc(r + o.seriesIndicatorSize / 2, c, o.seriesIndicatorSize / 2, 0, Math.PI * 2), t.fill(), r += o.seriesIndicatorSize + 8;
+    }
+    t.font = `${o.titleFontWeight} ${o.titleFontSize}px ${o.fontFamily}`, t.fillStyle = o.textColor, t.fillText(i.seriesName, r, a), a += o.titleFontSize * o.lineHeight + 2, r = s + h.left, o.showHeaderSeparator && (t.strokeStyle = o.separatorColor, t.lineWidth = 1, t.globalAlpha = 0.4, t.beginPath(), t.moveTo(r, a + o.headerGap / 2), t.lineTo(r + n.width, a + o.headerGap / 2), t.stroke(), t.globalAlpha = 1), a += o.headerGap + 2, t.font = `400 ${o.contentFontSize}px ${o.fontFamily}`;
+    const d = 28;
+    t.fillStyle = o.textSecondaryColor, t.fillText("X:", r, a), t.fillStyle = o.textColor, t.fillText(X(i.dataX), r + d, a), a += o.contentFontSize * o.lineHeight + 2, t.fillStyle = o.textSecondaryColor, t.fillText("Y:", r, a), t.fillStyle = o.textColor;
+    let p = X(i.dataY);
+    if (t.fillText(p, r + d, a), i.yError) {
+      const c = t.measureText(p).width;
+      t.fillStyle = o.textSecondaryColor, t.fillText(` ± ${X(i.yError[0])}`, r + d + c, a);
+    }
+    if (a += o.contentFontSize * o.lineHeight + 2, i.cycle !== void 0) {
+      a += o.itemGap, t.strokeStyle = o.separatorColor, t.globalAlpha = 0.3, t.beginPath(), t.moveTo(r, a - o.itemGap / 2), t.lineTo(r + n.width, a - o.itemGap / 2), t.stroke(), t.globalAlpha = 1, t.fillStyle = o.textSecondaryColor, t.font = `400 ${o.contentFontSize - 1}px ${o.fontFamily}`;
+      let c = `Index: ${i.dataIndex}`;
+      i.cycle !== void 0 && (c += `  │  Cycle: ${i.cycle}`), t.fillText(c, r, a);
+    }
+    t.restore();
+  }
+}
+const et = new Mt();
+function A(f) {
+  if (f == null || isNaN(f))
+    return "N/A";
+  const t = Math.abs(f);
+  return t === 0 ? "0" : t < 1e-4 || t >= 1e4 ? f.toExponential(2) : t < 1 ? f.toFixed(4) : f.toFixed(2);
+}
+class Ct {
+  constructor() {
+    u(this, "id", "annotation");
+    u(this, "name", "Annotation Info");
+    u(this, "supportedTypes", ["annotation"]);
+    // Cache
+    u(this, "cachedKey", "");
+    u(this, "cachedMeasurement", null);
+  }
+  /**
+   * Measure tooltip dimensions
+   */
+  measure(t, i, e) {
+    const n = `${i.annotationId}-${i.label}-${e.fontFamily}-${e.titleFontSize}`;
+    if (n === this.cachedKey && this.cachedMeasurement)
+      return this.cachedMeasurement;
+    t.font = `${e.titleFontWeight} ${e.titleFontSize}px ${e.fontFamily}`;
+    const o = i.label || `Annotation: ${i.annotationType}`;
+    let s = t.measureText(o).width;
+    t.font = `400 ${e.contentFontSize}px ${e.fontFamily}`;
+    let l = 0;
+    const h = 50;
+    if (i.value !== void 0) {
+      const r = A(i.value);
+      s = Math.max(s, h + t.measureText(r).width), l += e.contentFontSize * e.lineHeight;
+    }
+    if (i.valueX !== void 0 && i.valueY !== void 0) {
+      const r = A(i.valueX), d = A(i.valueY);
+      s = Math.max(s, h + t.measureText(r).width, h + t.measureText(d).width), l += e.contentFontSize * e.lineHeight * 2;
+    }
+    const a = e.titleFontSize * e.lineHeight + e.headerGap;
+    return this.cachedMeasurement = {
+      width: s + 10,
+      height: a + l + 4,
+      padding: e.padding
+    }, this.cachedKey = n, this.cachedMeasurement;
+  }
+  /**
+   * Render the tooltip
+   */
+  render(t, i, e, n, o) {
+    const { x: s, y: l } = e, { padding: h } = o;
+    let a = l + h.top;
+    const r = s + h.left;
+    t.save(), t.textAlign = "left", t.textBaseline = "top", t.font = `${o.titleFontWeight} ${o.titleFontSize}px ${o.fontFamily}`, t.fillStyle = o.textColor;
+    const d = i.label || `${i.annotationType.toUpperCase()}`;
+    t.fillText(d, r, a), a += o.titleFontSize * o.lineHeight + 2, o.showHeaderSeparator && (t.strokeStyle = o.separatorColor, t.globalAlpha = 0.4, t.beginPath(), t.moveTo(r, a + o.headerGap / 2), t.lineTo(r + n.width, a + o.headerGap / 2), t.stroke(), t.globalAlpha = 1), a += o.headerGap + 2, t.font = `400 ${o.contentFontSize}px ${o.fontFamily}`;
+    const p = 50;
+    i.value !== void 0 && (t.fillStyle = o.textSecondaryColor, t.fillText("Value:", r, a), t.fillStyle = o.textColor, t.fillText(A(i.value), r + p, a), a += o.contentFontSize * o.lineHeight), i.valueX !== void 0 && i.valueY !== void 0 && (t.fillStyle = o.textSecondaryColor, t.fillText("X:", r, a), t.fillStyle = o.textColor, t.fillText(A(i.valueX), r + p, a), a += o.contentFontSize * o.lineHeight, t.fillStyle = o.textSecondaryColor, t.fillText("Y:", r, a), t.fillStyle = o.textColor, t.fillText(A(i.valueY), r + p, a)), t.restore();
+  }
+}
+const O = new Ct();
+function M(f) {
+  if (f == null || isNaN(f))
+    return "N/A";
+  const t = Math.abs(f);
+  return t === 0 ? "0" : t < 1e-4 || t >= 1e4 ? f.toExponential(3) : t < 1 ? f.toFixed(4) : f.toFixed(3);
+}
+class vt {
+  constructor() {
+    u(this, "id", "range");
+    u(this, "name", "Range Statistics");
+    u(this, "supportedTypes", ["range"]);
+    // Cache
+    u(this, "cachedKey", "");
+    u(this, "cachedMeasurement", null);
+  }
+  /**
+   * Measure tooltip dimensions
+   */
+  measure(t, i, e) {
+    const n = i.statistics, o = `${i.xMin}-${i.xMax}-${n.count}-${n.mean}-${e.fontFamily}`;
+    if (o === this.cachedKey && this.cachedMeasurement)
+      return this.cachedMeasurement;
+    t.font = `${e.titleFontWeight} ${e.titleFontSize}px ${e.fontFamily}`;
+    let l = t.measureText("Range Statistics").width;
+    t.font = `400 ${e.contentFontSize}px ${e.fontFamily}`;
+    let h = e.contentFontSize * e.lineHeight * 2;
+    const a = [
+      `Range: ${M(i.xMin)} to ${M(i.xMax)}`,
+      `Count: ${n.count}`
+    ];
+    n.min !== void 0 && a.push(`Min: ${M(n.min)}`), n.max !== void 0 && a.push(`Max: ${M(n.max)}`), n.mean !== void 0 && a.push(`Mean: ${M(n.mean)}`), n.area !== void 0 && a.push(`Area: ${M(n.area)}`);
+    for (const d of a)
+      l = Math.max(l, t.measureText(d).width + 10);
+    h = a.length * e.contentFontSize * e.lineHeight;
+    const r = e.titleFontSize * e.lineHeight + e.headerGap;
+    return this.cachedMeasurement = {
+      width: Math.max(l, 140),
+      height: r + h + 10,
+      padding: e.padding
+    }, this.cachedKey = o, this.cachedMeasurement;
+  }
+  /**
+   * Render the tooltip
+   */
+  render(t, i, e, n, o) {
+    const { x: s, y: l } = e, { padding: h } = o, a = i.statistics;
+    let r = l + h.top;
+    const d = s + h.left;
+    t.save(), t.textAlign = "left", t.textBaseline = "top", t.font = `${o.titleFontWeight} ${o.titleFontSize}px ${o.fontFamily}`, t.fillStyle = o.textColor, t.fillText("Range Statistics", d, r), r += o.titleFontSize * o.lineHeight + 2, o.showHeaderSeparator && (t.strokeStyle = o.separatorColor, t.globalAlpha = 0.4, t.beginPath(), t.moveTo(d, r + o.headerGap / 2), t.lineTo(d + n.width, r + o.headerGap / 2), t.stroke(), t.globalAlpha = 1), r += o.headerGap + 2, t.font = `400 ${o.contentFontSize}px ${o.fontFamily}`;
+    const p = 60, c = (g, y) => {
+      t.fillStyle = o.textSecondaryColor, t.fillText(g, d, r), t.fillStyle = o.textColor, t.fillText(String(y), d + p, r), r += o.contentFontSize * o.lineHeight;
+    };
+    c("Points:", a.count), a.min !== void 0 && c("Min:", M(a.min)), a.max !== void 0 && c("Max:", M(a.max)), a.mean !== void 0 && c("Mean:", M(a.mean)), a.stdDev !== void 0 && c("StdDev:", M(a.stdDev)), a.area !== void 0 && c("Area:", M(a.area)), a.peakX !== void 0 && (r += 4, t.fillStyle = o.textSecondaryColor, t.font = `italic ${o.contentFontSize - 1}px ${o.fontFamily}`, t.fillText(`Peak: ${M(a.peakY ?? 0)} at X=${M(a.peakX)}`, d, r)), t.restore();
+  }
+}
+const G = new vt(), Pt = [
+  E,
+  tt,
+  R,
+  N,
+  et,
+  O,
+  G
+];
+function It(f) {
+  return Pt.find((t) => t.id === f);
+}
+function j(f) {
+  switch (f) {
+    case "datapoint":
+      return E;
+    case "crosshair":
+      return R;
+    case "heatmap":
+      return N;
+    case "annotation":
+      return O;
+    case "range":
+      return G;
+    default:
+      return E;
+  }
+}
+class Ft {
+  constructor(t) {
+    u(this, "ctx");
+    u(this, "getPlotArea");
+    u(this, "getSeries");
+    u(this, "pixelToDataX");
+    u(this, "pixelToDataY");
+    u(this, "getXScale");
+    u(this, "getYScales");
+    u(this, "options");
+    u(this, "theme");
+    u(this, "positioner");
+    u(this, "renderer");
+    u(this, "templates", /* @__PURE__ */ new Map());
+    u(this, "events", new at());
+    u(this, "activeTooltips", /* @__PURE__ */ new Map());
+    u(this, "tooltipIdCounter", 0);
+    u(this, "showTimeoutId", null);
+    u(this, "hideTimeoutId", null);
+    u(this, "lastCursorX", null);
+    u(this, "lastCursorY", null);
+    u(this, "hoveredSeriesId", null);
+    u(this, "hoveredDataIndex", null);
+    u(this, "cachedNearestResult", null);
+    // Large dataset optimizations
+    u(this, "snapMode", "auto");
+    u(this, "largeDatasetThreshold", 5e4);
+    u(this, "lastKnownDataSize", 0);
+    // Hysteresis factor: new point must be this much closer to switch (2 = 2x closer)
+    u(this, "hysteresisRatio", 2);
+    // Suspended state - used during drag operations to hide tooltip
+    u(this, "suspended", !1);
+    var i;
+    this.ctx = t.overlayCtx, this.getPlotArea = t.getPlotArea, this.getSeries = t.getSeries, this.pixelToDataX = t.pixelToDataX, this.pixelToDataY = t.pixelToDataY, this.getXScale = t.getXScale, this.getYScales = t.getYScales, this.options = {
+      enabled: !0,
+      showDelay: 50,
+      hideDelay: 100,
+      followCursor: !1,
+      offset: { x: 12, y: 12 },
+      dataPoint: {
+        enabled: !0,
+        templateId: "default",
+        snapToPoint: !0,
+        hitRadius: 20
+      },
+      crosshair: {
+        enabled: !1,
+        templateId: "crosshair",
+        interpolate: !0,
+        visibleSeriesOnly: !0
+      },
+      range: {
+        enabled: !1,
+        templateId: "default",
+        calculateStats: !0
+      },
+      annotation: {
+        enabled: !0,
+        templateId: "default"
+      },
+      heatmap: {
+        enabled: !0,
+        templateId: "heatmap",
+        showColorInfo: !0
+      },
+      positioning: "auto",
+      preferredPosition: "auto",
+      constrainToPlotArea: !0,
+      constrainToContainer: !0,
+      autoFlip: !0
+    }, this.theme = (i = t.options) != null && i.theme ? typeof t.options.theme == "string" ? k(t.options.theme) : pt(gt, t.options.theme) : k(t.chartTheme.name), this.positioner = new xt({
+      offset: this.options.offset,
+      preferredPosition: this.options.preferredPosition,
+      constrainToPlotArea: this.options.constrainToPlotArea,
+      constrainToContainer: this.options.constrainToContainer,
+      autoFlip: this.options.autoFlip,
+      showArrow: this.theme.showArrow,
+      arrowSize: this.theme.arrowSize
+    }), this.renderer = new bt(this.ctx, this.theme), this.registerBuiltinTemplates(), t.options && this.configure(t.options);
+  }
+  /**
+   * Register built-in templates
+   */
+  registerBuiltinTemplates() {
+    this.templates.set(
+      "default",
+      E
+    ), this.templates.set(
+      "minimal",
+      tt
+    ), this.templates.set(
+      "crosshair",
+      R
+    ), this.templates.set(
+      "heatmap",
+      N
+    ), this.templates.set(
+      "scientific",
+      et
+    ), this.templates.set(
+      "annotation",
+      O
+    ), this.templates.set(
+      "range",
+      G
+    );
+  }
+  /**
+   * Configure tooltip options
+   */
+  configure(t) {
+    t.enabled !== void 0 && (this.options.enabled = t.enabled), t.showDelay !== void 0 && (this.options.showDelay = t.showDelay), t.hideDelay !== void 0 && (this.options.hideDelay = t.hideDelay), t.followCursor !== void 0 && (this.options.followCursor = t.followCursor), t.offset && (this.options.offset = { ...this.options.offset, ...t.offset }), t.dataPoint && (this.options.dataPoint = {
+      ...this.options.dataPoint,
+      ...t.dataPoint
+    }), t.crosshair && (this.options.crosshair = {
+      ...this.options.crosshair,
+      ...t.crosshair
+    }), t.heatmap && (this.options.heatmap = { ...this.options.heatmap, ...t.heatmap }), t.preferredPosition && (this.options.preferredPosition = t.preferredPosition), t.constrainToPlotArea !== void 0 && (this.options.constrainToPlotArea = t.constrainToPlotArea), t.constrainToContainer !== void 0 && (this.options.constrainToContainer = t.constrainToContainer), t.autoFlip !== void 0 && (this.options.autoFlip = t.autoFlip), t.snapMode !== void 0 && (this.snapMode = t.snapMode), t.largeDatasetThreshold !== void 0 && (this.largeDatasetThreshold = Math.max(
+      1e3,
+      t.largeDatasetThreshold
+    )), this.positioner.configure({
+      offset: this.options.offset,
+      preferredPosition: this.options.preferredPosition,
+      constrainToPlotArea: this.options.constrainToPlotArea,
+      constrainToContainer: this.options.constrainToContainer,
+      autoFlip: this.options.autoFlip
+    });
+  }
+  /**
+   * Get current options
+   */
+  getOptions() {
+    return { ...this.options };
+  }
+  /**
+   * Enable/disable tooltips
+   */
+  setEnabled(t) {
+    this.options.enabled = t, t || this.hideAll();
+  }
+  /**
+   * Check if tooltips are enabled
+   */
+  isEnabled() {
+    return this.options.enabled;
+  }
+  /**
+   * Suspend tooltip display (used during drag operations)
+   * When suspended, tooltips are immediately hidden and cursor movements are ignored
+   */
+  setSuspended(t) {
+    this.suspended = t, t && this.hideAll();
+  }
+  /**
+   * Check if tooltips are suspended
+   */
+  isSuspended() {
+    return this.suspended;
+  }
+  /**
+   * Set tooltip theme
+   */
+  setTheme(t) {
+    this.theme = typeof t == "string" ? k(t) : t, this.renderer.setTheme(this.theme), this.positioner.configure({
+      showArrow: this.theme.showArrow,
+      arrowSize: this.theme.arrowSize
+    });
+  }
+  /**
+   * Update theme based on chart theme
+   */
+  updateChartTheme(t) {
+    this.options.theme || (this.theme = k(t.name), this.renderer.setTheme(this.theme));
+  }
+  /**
+   * Get current theme
+   */
+  getTheme() {
+    return this.theme;
+  }
+  /**
+   * Register a custom template
+   */
+  registerTemplate(t) {
+    this.templates.set(t.id, t);
+  }
+  /**
+   * Get a template by ID
+   */
+  getTemplate(t) {
+    return this.templates.get(t) || It(t);
+  }
+  /**
+   * Handle cursor movement - main entry point for hover detection
+   * Optimized with hysteresis to prevent jumping between nearby points
+   */
+  handleCursorMove(t, i) {
+    if (!this.options.enabled || this.suspended) return;
+    this.lastCursorX = t, this.lastCursorY = i;
+    const e = this.getPlotArea();
+    if (!(t >= e.x && t <= e.x + e.width && i >= e.y && i <= e.y + e.height)) {
+      this.cachedNearestResult = null, this.scheduleHide();
+      return;
+    }
+    this.positioner.setContainerSize(
+      this.ctx.canvas.width / (window.devicePixelRatio || 1),
+      this.ctx.canvas.height / (window.devicePixelRatio || 1)
+    ), this.positioner.setPlotArea(e), this.lastKnownDataSize = this.getTotalDataPoints(), this.performTooltipUpdateWithHysteresis(t, i);
+  }
+  /**
+   * Handle cursor leave
+   */
+  handleCursorLeave() {
+    this.lastCursorX = null, this.lastCursorY = null, this.cachedNearestResult = null, this.scheduleHide();
+  }
+  /**
+   * Get total number of data points across all visible series
+   */
+  getTotalDataPoints() {
+    let t = 0;
+    const i = this.getSeries();
+    for (const e of i) {
+      if (!e.isVisible()) continue;
+      const n = e.getData();
+      n.x && (t += n.x.length);
+    }
+    return t;
+  }
+  /**
+   * Determine the effective snap mode based on configuration and data size
+   */
+  getEffectiveSnapMode() {
+    return this.snapMode === "x-only" ? "x-only" : this.snapMode === "nearest" ? "nearest" : this.lastKnownDataSize > this.largeDatasetThreshold ? "x-only" : "nearest";
+  }
+  /**
+   * Perform tooltip update with hysteresis to prevent jumping.
+   * The tooltip "sticks" to the current point unless the cursor is
+   * significantly closer to a new point.
+   */
+  performTooltipUpdateWithHysteresis(t, i) {
+    var o;
+    if (!((o = this.options.dataPoint) != null && o.enabled)) {
+      this.performFallbackTooltipUpdate(t, i);
+      return;
+    }
+    const n = this.getEffectiveSnapMode() === "x-only" ? this.findDataPointByXOnly(t) : this.findNearestDataPointOptimized(t, i);
+    if (!n) {
+      this.performFallbackTooltipUpdate(t, i);
+      return;
+    }
+    if (this.cachedNearestResult && this.hoveredSeriesId !== null) {
+      const s = this.cachedNearestResult, l = s.pixelX - t, h = s.pixelY - i, a = l * l + h * h, r = n.pixelX - t, d = n.pixelY - i;
+      if ((r * r + d * d) * this.hysteresisRatio >= a) {
+        this.updateTooltipPosition(this.cachedNearestResult);
+        return;
+      }
+    }
+    this.cachedNearestResult = n, this.scheduleShow(n);
+  }
+  /**
+   * Handle heatmap and crosshair tooltip types (fallback)
+   */
+  performFallbackTooltipUpdate(t, i) {
+    var e, n;
+    if ((e = this.options.heatmap) != null && e.enabled) {
+      const o = this.findHeatmapCell(t, i);
+      if (o) {
+        this.scheduleShow(o);
+        return;
+      }
+    }
+    if ((n = this.options.crosshair) != null && n.enabled) {
+      const o = this.buildCrosshairTooltip(t, i);
+      if (o) {
+        this.scheduleShow(o);
+        return;
+      }
+    }
+    this.cachedNearestResult = null, this.scheduleHide();
+  }
+  /**
+   * Find data point by X coordinate only (O(log n) - fastest method)
+   * Best for very large datasets where precision is less important than speed
+   */
+  findDataPointByXOnly(t) {
+    var h, a;
+    const i = this.getSeries().filter(
+      (r) => r.isVisible() && r.getType() !== "heatmap"
+    );
+    if (i.length === 0) return null;
+    const e = this.getXScale(), n = this.getYScales(), o = this.pixelToDataX(t);
+    let s = null, l = 1 / 0;
+    for (const r of i) {
+      const d = r.getData();
+      if (!d.x || d.x.length === 0) continue;
+      const p = n.get(((h = r.getYAxisId) == null ? void 0 : h.call(r)) || "default") || n.values().next().value;
+      if (!p) continue;
+      const c = this.binarySearchClosest(d.x, o), g = Math.abs(d.x[c] - o);
+      if (g < l) {
+        l = g;
+        const y = r.getStyle(), b = e.transform(d.x[c]), x = p.transform(d.y[c]);
+        s = {
+          type: "datapoint",
+          seriesId: r.getId(),
+          seriesName: r.getId(),
+          seriesColor: y.color || "#ff0055",
+          dataIndex: c,
+          dataX: d.x[c],
+          dataY: d.y[c],
+          pixelX: b,
+          pixelY: x,
+          cycle: (a = r.getCycle) == null ? void 0 : a.call(r)
+        };
+        const S = r.getYError(c);
+        S && (s.yError = S);
+      }
+    }
+    return s;
+  }
+  /**
+   * Optimized nearest data point finder
+   */
+  findNearestDataPointOptimized(t, i) {
+    var r, d, p;
+    const e = this.getSeries().filter((c) => c.isVisible()), n = ((r = this.options.dataPoint) == null ? void 0 : r.hitRadius) ?? 20, o = this.getXScale(), s = this.getYScales();
+    let l = n * n, h = null;
+    const a = this.pixelToDataX(t);
+    for (const c of e) {
+      if (c.getType() === "heatmap") continue;
+      const g = c.getData(), y = s.get(((d = c.getYAxisId) == null ? void 0 : d.call(c)) || "default") || s.values().next().value;
+      if (!y || !g.x || g.x.length === 0) continue;
+      const b = this.binarySearchClosest(g.x, a), x = g.x.length, S = x > 1e5 ? 2 : x > 1e4 ? 3 : 5, w = Math.max(0, b - S), C = Math.min(x, b + S + 1);
+      for (let m = w; m < C; m++) {
+        const I = o.transform(g.x[m]), v = y.transform(g.y[m]), T = I - t, z = v - i, $ = T * T + z * z;
+        if ($ < l) {
+          l = $;
+          const D = c.getStyle();
+          h = {
+            type: "datapoint",
+            seriesId: c.getId(),
+            seriesName: c.getId(),
+            seriesColor: D.color || "#ff0055",
+            dataIndex: m,
+            dataX: g.x[m],
+            dataY: g.y[m],
+            pixelX: I,
+            pixelY: v,
+            cycle: (p = c.getCycle) == null ? void 0 : p.call(c)
+          };
+          const B = c.getYError(m);
+          B && (h.yError = B);
+        }
+      }
+    }
+    return h;
+  }
+  /**
+   * Find heatmap cell under cursor
+   */
+  findHeatmapCell(t, i) {
+    var h, a;
+    const e = this.getSeries().filter(
+      (r) => r.isVisible() && r.getType() === "heatmap"
+    );
+    if (e.length === 0) return null;
+    const n = this.getXScale(), o = this.getYScales(), s = this.pixelToDataX(t), l = this.pixelToDataY(i);
+    for (const r of e) {
+      const d = r.getHeatmapData();
+      if (!d || !d.xValues || !d.yValues || !d.zValues) continue;
+      const p = this.binarySearchClosest(d.xValues, s), c = this.binarySearchClosest(d.yValues, l), g = d.xValues[p], y = d.yValues[c], b = o.get(((h = r.getYAxisId) == null ? void 0 : h.call(r)) || "default") || o.values().next().value;
+      if (!b) continue;
+      const x = n.transform(g), S = b.transform(y), w = d.zValues[c * d.xValues.length + p], C = ((a = r.getHeatmapStyle) == null ? void 0 : a.call(r)) || {};
+      return {
+        type: "heatmap",
+        seriesId: r.getId(),
+        seriesName: r.getId(),
+        xIndex: p,
+        yIndex: c,
+        dataX: g,
+        dataY: y,
+        zValue: w,
+        pixelX: x,
+        pixelY: S,
+        colorScale: C.colorScale
+      };
+    }
+    return null;
+  }
+  /**
+   * Binary search for closest value
+   */
+  binarySearchClosest(t, i) {
+    let e = 0, n = t.length - 1;
+    for (; e < n; ) {
+      const o = Math.floor((e + n) / 2);
+      t[o] < i ? e = o + 1 : n = o;
+    }
+    return e > 0 && Math.abs(t[e - 1] - i) < Math.abs(t[e] - i) ? e - 1 : e;
+  }
+  /**
+   * Build crosshair tooltip data
+   */
+  buildCrosshairTooltip(t, i) {
+    var l, h;
+    const e = this.getSeries().filter(
+      (a) => a.isVisible() && a.getType() !== "heatmap"
+    );
+    if (e.length === 0) return null;
+    const n = this.pixelToDataX(t), o = this.getYScales(), s = [];
+    for (const a of e) {
+      const r = a.getData();
+      if (!r.x || r.x.length === 0 || !(o.get(((l = a.getYAxisId) == null ? void 0 : l.call(a)) || "default") || o.values().next().value)) continue;
+      const p = this.binarySearchClosest(r.x, n);
+      let c, g = !1;
+      if (p === 0 || p >= r.x.length - 1 || r.x[p] === n)
+        c = r.y[p];
+      else if ((h = this.options.crosshair) != null && h.interpolate) {
+        const b = r.x[p - 1], x = r.x[p], S = r.y[p - 1], w = r.y[p], C = (n - b) / (x - b);
+        c = S + C * (w - S), g = !0;
+      } else
+        c = r.y[p];
+      const y = a.getStyle();
+      s.push({
+        seriesId: a.getId(),
+        seriesName: a.getId(),
+        seriesColor: y.color || "#ff0055",
+        x: n,
+        y: c,
+        isInterpolated: g
+      });
+    }
+    return s.length === 0 ? null : {
+      type: "crosshair",
+      cursorX: t,
+      cursorY: i,
+      dataX: n,
+      interpolatedValues: s
+    };
+  }
+  /**
+   * Schedule showing a tooltip
+   */
+  scheduleShow(t) {
+    if (this.clearHideTimeout(), t.type === "datapoint") {
+      const e = t;
+      if (this.hoveredSeriesId === e.seriesId && this.hoveredDataIndex === e.dataIndex) {
+        this.updateTooltipPosition(t);
+        return;
+      }
+      this.hoveredSeriesId = e.seriesId, this.hoveredDataIndex = e.dataIndex;
+    }
+    this.clearShowTimeout();
+    const i = this.activeTooltips.size > 0 ? 0 : this.options.showDelay;
+    i > 0 ? this.showTimeoutId = window.setTimeout(() => {
+      this.showTooltip(t);
+    }, i) : this.showTooltip(t);
+  }
+  /**
+   * Schedule hiding tooltips
+   */
+  scheduleHide() {
+    this.clearShowTimeout(), this.hoveredSeriesId = null, this.hoveredDataIndex = null, this.options.hideDelay > 0 ? this.hideTimeoutId = window.setTimeout(() => {
+      this.hideAll();
+    }, this.options.hideDelay) : this.hideAll();
+  }
+  clearShowTimeout() {
+    this.showTimeoutId !== null && (clearTimeout(this.showTimeoutId), this.showTimeoutId = null);
+  }
+  clearHideTimeout() {
+    this.hideTimeoutId !== null && (clearTimeout(this.hideTimeoutId), this.hideTimeoutId = null);
+  }
+  /**
+   * Show a tooltip with the given data
+   */
+  showTooltip(t) {
+    const i = this.getTemplateIdForType(t.type), e = this.templates.get(i) || j(t.type), n = t.pixelX ?? this.lastCursorX ?? 0, o = t.pixelY ?? this.lastCursorY ?? 0, s = e.measure(this.ctx, t, this.theme), l = this.positioner.calculatePosition(
+      n,
+      o,
+      s
+    ), h = "main";
+    this.activeTooltips.set(h, {
+      id: h,
+      data: t,
+      position: l,
+      template: e
+    });
+  }
+  /**
+   * Update tooltip position
+   */
+  updateTooltipPosition(t) {
+    const i = this.activeTooltips.get("main");
+    if (!i) return;
+    const e = t || i.data, n = e.pixelX ?? this.lastCursorX ?? 0, o = e.pixelY ?? this.lastCursorY ?? 0, s = i.template.measure(
+      this.ctx,
+      e,
+      this.theme
+    );
+    i.position = this.positioner.calculatePosition(
+      n,
+      o,
+      s
+    ), i.data = e;
+  }
+  /**
+   * Get template ID for a tooltip type
+   */
+  getTemplateIdForType(t) {
+    var i, e, n;
+    switch (t) {
+      case "datapoint":
+        return ((i = this.options.dataPoint) == null ? void 0 : i.templateId) || "default";
+      case "crosshair":
+        return ((e = this.options.crosshair) == null ? void 0 : e.templateId) || "crosshair";
+      case "heatmap":
+        return ((n = this.options.heatmap) == null ? void 0 : n.templateId) || "heatmap";
+      default:
+        return "default";
+    }
+  }
+  /**
+   * Show a tooltip programmatically
+   */
+  show(t, i) {
+    const e = `tooltip-${++this.tooltipIdCounter}`, n = (i == null ? void 0 : i.templateId) || this.getTemplateIdForType(t.type), o = this.templates.get(n) || j(t.type);
+    let s;
+    if (i != null && i.position) {
+      const l = o.measure(this.ctx, t, this.theme);
+      s = this.positioner.calculatePosition(
+        i.position.x,
+        i.position.y,
+        l
+      );
+    } else {
+      const l = t.pixelX ?? 0, h = t.pixelY ?? 0, a = o.measure(this.ctx, t, this.theme);
+      s = this.positioner.calculatePosition(
+        l,
+        h,
+        a
+      );
+    }
+    return this.activeTooltips.set(e, {
+      id: e,
+      data: t,
+      position: s,
+      template: o
+    }), i != null && i.duration && i.duration > 0 && setTimeout(() => this.hide(e), i.duration), e;
+  }
+  /**
+   * Hide a specific tooltip
+   */
+  hide(t) {
+    this.activeTooltips.delete(t);
+  }
+  /**
+   * Hide all tooltips immediately
+   */
+  hideAll() {
+    this.activeTooltips.clear(), this.hoveredSeriesId = null, this.hoveredDataIndex = null;
+  }
+  /**
+   * Render all active tooltips
+   */
+  render() {
+    if (!(!this.options.enabled || this.activeTooltips.size === 0))
+      for (const t of this.activeTooltips.values())
+        this.renderer.render(t.data, t.position, t.template);
+  }
+  /**
+   * Check if any tooltip is currently visible
+   */
+  hasActiveTooltip() {
+    return this.activeTooltips.size > 0;
+  }
+  /**
+   * Subscribe to tooltip events
+   */
+  on(t, i) {
+    this.events.on(t, i);
+  }
+  /**
+   * Unsubscribe from tooltip events
+   */
+  off(t, i) {
+    this.events.off(t, i);
+  }
+  /**
+   * Destroy the tooltip manager
+   */
+  destroy() {
+    this.clearShowTimeout(), this.clearHideTimeout(), this.activeTooltips.clear(), this.templates.clear(), this.events.clear();
+  }
+}
+const zt = {
+  name: "velo-plot-tools",
+  version: "1.0.0",
+  description: "Advanced interaction and measurement tools for velo-plot",
+  provides: ["interaction"],
+  tags: ["delta-tool", "peak-tool", "tooltip"]
+};
+function Xt(f = {}) {
+  let t = null, i = null, e = null;
+  return {
+    manifest: zt,
+    onInit(n) {
+      var s;
+      const o = {
+        container: n.ui.container,
+        getPlotArea: () => n.render.plotArea,
+        getViewBounds: () => n.data.getViewBounds(),
+        getYBounds: (l) => n.data.getYAxisBounds(l),
+        requestRender: () => n.requestRender(),
+        getSeries: () => n.data.getAllSeries().map((l) => {
+          var a;
+          const h = l.getData();
+          return {
+            id: l.getId(),
+            x: h.x,
+            y: h.y,
+            yAxisId: ((a = l.getYAxisId) == null ? void 0 : a.call(l)) || void 0
+          };
+        }),
+        onMeasure: (l) => n.events.emit("measure", l)
+      };
+      if ((f.enableDeltaTool ?? !0) && (t = new lt(o)), (f.enablePeakTool ?? !0) && (i = new rt(o)), f.useEnhancedTooltips ?? !0) {
+        const l = n.chart;
+        n.log.debug("TooltipManager init - checking deps:", {
+          hasCtx2d: !!n.render.ctx2d,
+          hasXScale: !!l.xScale,
+          hasYScales: !!l.yScales,
+          seriesCount: n.data.getAllSeries().length
+        }), n.render.ctx2d ? e = new Ft({
+          overlayCtx: n.render.ctx2d,
+          chartTheme: n.ui.theme,
+          getPlotArea: () => n.render.plotArea,
+          getSeries: () => n.data.getAllSeries(),
+          pixelToDataX: (h) => n.coords.pixelToDataX(h),
+          pixelToDataY: (h) => n.coords.pixelToDataY(h),
+          getXScale: () => l.xScale,
+          getYScales: () => l.yScales,
+          getViewBounds: () => n.data.getViewBounds(),
+          options: (s = l.initialOptions) == null ? void 0 : s.tooltip
+        }) : n.log.warn("TooltipManager: No 2D context available, tooltips disabled");
+      }
+    },
+    onRenderOverlay(n) {
+      e == null || e.render(), t == null || t.renderOverlay(), i == null || i.renderOverlay();
+    },
+    onDestroy(n) {
+      t == null || t.destroy(), i == null || i.destroy(), e == null || e.destroy(), t = null, i = null, e = null;
+    },
+    api: {
+      setMode(n) {
+        t == null || t.disable(), i == null || i.disable(), n === "delta" && (t == null || t.enable()), n === "peak" && (i == null || i.enable());
+      },
+      getDeltaTool: () => t,
+      getPeakTool: () => i,
+      getTooltipManager: () => e
+    }
+  };
+}
+export {
+  lt as D,
+  Xt as P,
+  Ft as T,
+  ut as a,
+  rt as b,
+  k as g
+};
+//# sourceMappingURL=index-D8ifudJH.js.map