velo-plot 1.15.0 → 1.19.0

package/dist/velo-plot.full.js

@@ -1,56 +1,59 @@
-var de = Object.defineProperty;
-var ue = (r, e, t) => e in r ? de(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
-var _ = (r, e, t) => ue(r, typeof e != "symbol" ? e + "" : e, t);
-import { b as fe } from "./ChartCore-BimVvUEg.js";
-import { A as je, C as Je, h as Qe, D as Ze, o as et, k as tt, E as nt, j as at, L as ot, d as rt, M as it, N as st, O as lt, P as ct, t as dt, S as ut, G as ft, x as gt, c as pt, H as ht, N as mt, J as yt, f as xt, l as vt, v as Pt, y as St, I as Tt, e as wt, u as bt, a as Ct, g as Mt, n as At, i as It, m as Dt, s as Et, p as Ft, q as Lt, r as Rt, z as Xt, B as Yt, F as kt, w as zt } from "./ChartCore-BimVvUEg.js";
-import { E as Ot } from "./axisFormat-B7o_uIEA.js";
-import { AnnotationManager as Bt, PluginAnnotations as Ht } from "./plugins/annotations.js";
-import { d as O } from "./index.core-C_-CFftD.js";
-import { e as Wt, h as Gt, f as Nt, c as Vt, a as Ut, g as Kt, b as jt, l as Jt, r as Qt, v as Zt } from "./index.core-C_-CFftD.js";
-import { P as tn, a as nn, T as an, g as on } from "./index-DjeWClO9.js";
-import { P as sn, c as ln, l as cn, m as dn } from "./index-ChgIdk3N.js";
-import { PluginAnalysis as fn, adx as gn, analyzeComplexSpectrum as pn, analyzeSpectrum as hn, aroon as mn, arraysToComplex as yn, atr as xn, autoCorrelation as vn, bandPassFilter as Pn, bandStopFilter as Sn, blackmanWindow as Tn, bollingerBands as wn, butterworth as bn, complexToArrays as Cn, crossCorrelation as Mn, cumsum as An, dema as In, detectAnomalies as Dn, dominantFrequency as En, ema as Fn, exponentialMovingAverage as Ln, fft as Rn, fftFromComplexInput as Xn, gaussianSmooth as Yn, getPositiveFrequencies as kn, hammingWindow as zn, hanningWindow as _n, highPassFilter as On, ifft as $n, ifftComplex as Bn, ifftFromArrays as Hn, lowPassFilter as qn, macd as Wn, medianFilter as Gn, momentum as Nn, nextPowerOf2 as Vn, normalize as Un, obv as Kn, percentChange as jn, powerSpectrum as Jn, roc as Qn, rsi as Zn, savitzkyGolay as ea, simpsonsIntegration as ta, singleFrequencyFilter as na, sma as aa, standardDeviation as oa, stochastic as ra, tTest as ia, tema as sa, trapezoidalIntegration as la, vwap as ca, wma as da } from "./plugins/analysis.js";
-import { B as fa, C as ga, P as pa, a as ha, e as ma, g as ya, b as xa, d as va, f as Pa, c as Sa } from "./index-BMiZoKmm.js";
-import { b as wa, a as ba, S as Ca, c as Ma, u as Aa } from "./createStackedChart-CjsKcOvX.js";
+var ve = Object.defineProperty;
+var we = (n, e, t) => e in n ? ve(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var X = (n, e, t) => we(n, typeof e != "symbol" ? e + "" : e, t);
+import { D as ee, L as O, s as te, O as Pe } from "./ChartCore-DQ691eXH.js";
+import { A as Et, C as Lt, h as Rt, B as Yt, x as Xt, E as Bt, u as _t, n as zt, v as Wt, N as Gt, a3 as Ut, F as $t, S as Ot, R as Ht, a as Nt, X as qt, _ as Vt, d as Kt, b as jt, I as Jt, $ as Qt, a0 as Zt, c as en, Z as tn, N as nn, a2 as on, o as rn, y as an, H as sn, J as ln, Y as cn, a1 as dn, f as un, V as fn, G as hn, k as gn, j as pn, z as mn, p as yn, W as xn, i as vn, m as wn, t as Pn, q as Sn, l as Tn, T as bn, U as An, K as Mn, P as Fn, Q as Cn, w as In } from "./ChartCore-DQ691eXH.js";
+import { E as kn } from "./axisFormat-B7o_uIEA.js";
+import { AnnotationManager as Ln, PluginAnnotations as Rn } from "./plugins/annotations.js";
+import { d as z } from "./index.core-BtGFYMOu.js";
+import { e as Xn, h as Bn, f as _n, c as zn, a as Wn, g as Gn, b as Un, l as $n, r as On, v as Hn } from "./index.core-BtGFYMOu.js";
+import { G as qn, S as Vn, a as Kn, W as jn, c as Jn, p as Qn } from "./gpuRenderer-BpaMYz-k.js";
+import { P as eo, a as to, T as no, g as oo } from "./index-DjeWClO9.js";
+import { P as ao, c as io, e as so, d as lo, g as co, a as uo, l as fo, m as ho, b as go, o as po, s as mo, u as yo } from "./index-D7dTq6VB.js";
+import { W as vo, n as wo } from "./pool-15HMCNv8.js";
+import { PluginAnalysis as So, analyzeComplexSpectrum as To, analyzeSpectrum as bo, arraysToComplex as Ao, autoCorrelation as Mo, bandPassFilter as Fo, bandStopFilter as Co, blackmanWindow as Io, butterworth as Do, complexToArrays as ko, crossCorrelation as Eo, detectAnomalies as Lo, dominantFrequency as Ro, exponentialMovingAverage as Yo, fft as Xo, fftFromComplexInput as Bo, gaussianSmooth as _o, getPositiveFrequencies as zo, hammingWindow as Wo, hanningWindow as Go, highPassFilter as Uo, ifft as $o, ifftComplex as Oo, ifftFromArrays as Ho, lowPassFilter as No, medianFilter as qo, nextPowerOf2 as Vo, powerSpectrum as Ko, savitzkyGolay as jo, simpsonsIntegration as Jo, singleFrequencyFilter as Qo, tTest as Zo, trapezoidalIntegration as er } from "./plugins/analysis.js";
+import { B as nr, C as or, P as rr, a as ar, e as ir, g as sr, b as lr, d as cr, f as dr, c as ur } from "./index-BMiZoKmm.js";
+import { b as hr, a as gr, S as pr, c as mr, u as yr } from "./createStackedChart-BPooTQ9z.js";
 import "react";
-import { BaseBufferStore as Da, BaseTextureStore as Ea, GpuBenchmark as Fa, GpuCompute as La, GpuRenderer as Ra, PipelineCache as Xa, PluginGpu as Ya, SeriesAdapter as ka, WebGLBackend as za, WebGPUBackend as _a, createGpuRenderer as Oa, parseColorToRGBA as $a } from "./plugins/gpu.js";
-import { b as Ha, L as qa, a as Wa, c as Ga, f as Na, d as Va, e as Ua, i as Ka, g as ja, h as Ja, r as Qa, s as Za } from "./index-x4stH3jD.js";
-import { D as to, K as no, P as ao, c as oo, p as ro } from "./index-Ce2JgkH_.js";
-import { ClipboardManager as so, PluginClipboard as lo, copyToClipboard as co, formatData as uo, getClipboardManager as fo } from "./plugins/clipboard.js";
-import { DebugOverlay as po, PluginDebug as ho, createDebugOverlay as mo, enableDebugMode as yo } from "./plugins/debug.js";
-import { L as vo, P as Po, c as So, s as To, a as wo } from "./index-qhscKTDy.js";
-import { C as Co, c as Mo, a as Ao, l as Io } from "./index-CUGS98p4.js";
-import { P as Eo, b as Fo, T as Lo, c as Ro, a as Xo, g as Yo } from "./index-Dag88bW4.js";
-import { c as zo, a as _o, b as Oo, d as $o, h as Bo, e as Ho, f as qo, g as Wo, i as Go, m as No, s as Vo, v as Uo } from "./utils-BK5UUXxj.js";
-import { a as jo, c as Jo, d as Qo, i as Zo, s as er } from "./math-Ddm2EZjj.js";
-import { Plugin3D as nr } from "./plugins/3d.js";
-import { PluginI18n as or } from "./plugins/i18n.js";
-import { PluginSync as ir } from "./plugins/sync.js";
-import { PluginDataExport as lr } from "./plugins/data-export.js";
-import { PluginContextMenu as dr } from "./plugins/context-menu.js";
-import { PluginAnomalyDetection as fr } from "./plugins/anomaly-detection.js";
-import { PluginMLIntegration as pr } from "./plugins/ml-integration.js";
-import { PluginPatternRecognition as mr } from "./plugins/pattern-recognition.js";
-import { PluginRegression as xr } from "./plugins/regression.js";
-import { PluginRadar as Pr } from "./plugins/radar.js";
-import { PluginSnapshot as Tr } from "./plugins/snapshot.js";
-import { PluginDataTransform as br } from "./plugins/data-transform.js";
-import { PluginLaTeX as Mr } from "./plugins/latex.js";
-import { PluginCaching as Ir } from "./plugins/caching.js";
-import { PluginLazyLoad as Er } from "./plugins/lazy-load.js";
-import { PluginBrokenAxis as Lr } from "./plugins/broken-axis.js";
-import { PluginVideoRecorder as Xr } from "./plugins/video-recorder.js";
-import { PluginOffscreen as kr } from "./plugins/offscreen.js";
-import { PluginROI as _r } from "./plugins/roi.js";
-import { PluginForecasting as $r } from "./plugins/forecasting.js";
-class Q {
+import { BaseBufferStore as vr, BaseTextureStore as wr, GpuBenchmark as Pr, GpuCompute as Sr, PipelineCache as Tr, PluginGpu as br } from "./plugins/gpu.js";
+import { b as Mr, L as Fr, a as Cr, c as Ir, f as Dr, d as kr, e as Er, i as Lr, g as Rr, h as Yr, r as Xr, s as Br } from "./index-x4stH3jD.js";
+import { D as zr, K as Wr, P as Gr, c as Ur, p as $r } from "./index-DoYxf1cV.js";
+import { ClipboardManager as Hr, PluginClipboard as Nr, copyToClipboard as qr, formatData as Vr, getClipboardManager as Kr } from "./plugins/clipboard.js";
+import { DebugOverlay as Jr, PluginDebug as Qr, createDebugOverlay as Zr, enableDebugMode as ea } from "./plugins/debug.js";
+import { L as na, P as oa, c as ra, s as aa, a as ia } from "./index-qhscKTDy.js";
+import { C as la, c as ca, a as da, l as ua } from "./index-CUGS98p4.js";
+import { P as ha, b as ga, T as pa, c as ma, a as ya, g as xa } from "./index-Dag88bW4.js";
+import { c as wa, a as Pa, b as Sa, d as Ta, h as ba, e as Aa, f as Ma, g as Fa, i as Ca, m as Ia, s as Da, v as ka } from "./utils-BK5UUXxj.js";
+import { a as La, c as Ra, d as Ya, i as Xa, s as Ba } from "./math-Ddm2EZjj.js";
+import { i as za, j as Wa, g as Ga, f as Ua, k as $a, d as Oa, e as Ha, m as Na, c as qa, n as Va, o as Ka, p as ja, b as Ja, r as Qa, s as Za, h as ei, a as ti, t as ni, v as oi, w as ri } from "./indicators--eJGmVox.js";
+import { Plugin3D as ii } from "./plugins/3d.js";
+import { PluginI18n as li } from "./plugins/i18n.js";
+import { PluginSync as di } from "./plugins/sync.js";
+import { PluginDataExport as fi } from "./plugins/data-export.js";
+import { PluginContextMenu as gi } from "./plugins/context-menu.js";
+import { PluginAnomalyDetection as mi } from "./plugins/anomaly-detection.js";
+import { PluginMLIntegration as xi } from "./plugins/ml-integration.js";
+import { PluginPatternRecognition as wi } from "./plugins/pattern-recognition.js";
+import { PluginRegression as Si } from "./plugins/regression.js";
+import { PluginRadar as bi } from "./plugins/radar.js";
+import { PluginSnapshot as Mi } from "./plugins/snapshot.js";
+import { PluginDataTransform as Ci } from "./plugins/data-transform.js";
+import { PluginLaTeX as Di } from "./plugins/latex.js";
+import { PluginCaching as Ei } from "./plugins/caching.js";
+import { PluginLazyLoad as Ri } from "./plugins/lazy-load.js";
+import { PluginBrokenAxis as Xi } from "./plugins/broken-axis.js";
+import { PluginVideoRecorder as _i } from "./plugins/video-recorder.js";
+import { PluginOffscreen as Wi } from "./plugins/offscreen.js";
+import { PluginROI as Ui } from "./plugins/roi.js";
+import { PluginForecasting as Oi } from "./plugins/forecasting.js";
+class re {
   constructor(e, t = {}) {
-    _(this, "available");
-    _(this, "canvas");
-    _(this, "adapter");
-    _(this, "device");
-    _(this, "context");
-    this.canvas = e, this.available = Q.isSupported();
+    X(this, "available");
+    X(this, "canvas");
+    X(this, "adapter");
+    X(this, "device");
+    X(this, "context");
+    this.canvas = e, this.available = re.isSupported();
   }
   static isSupported() {
     return typeof globalThis.navigator < "u" && typeof globalThis.navigator.gpu < "u";
@@ -64,14 +67,14 @@ class Q {
     }), !this.adapter)
       throw new Error("[SciPlot] Failed to request WebGPU adapter");
     this.device = await this.adapter.requestDevice();
-    const s = this.canvas.getContext("webgpu");
-    if (!s)
+    const r = this.canvas.getContext("webgpu");
+    if (!r)
       throw new Error("[SciPlot] Failed to get WebGPU context");
-    this.context = s;
-    const o = e.preferredFormat ?? (t.getPreferredCanvasFormat ? t.getPreferredCanvasFormat() : "bgra8unorm");
+    this.context = r;
+    const a = e.preferredFormat ?? (t.getPreferredCanvasFormat ? t.getPreferredCanvasFormat() : "bgra8unorm");
     this.context.configure({
       device: this.device,
-      format: o,
+      format: a,
       alphaMode: "premultiplied"
     });
   }
@@ -79,128 +82,128 @@ class Q {
     this.device = void 0, this.adapter = void 0, this.context = void 0;
   }
 }
-const ge = {
+const Se = {
   name: "crosshair",
   version: "1.0.0",
   description: "Interactive crosshair that follows mouse cursor",
   provides: ["interaction", "visualization"],
   tags: ["cursor", "crosshair", "tooltip"]
-}, pe = O(
-  ge,
-  (r = {}) => {
+}, Te = z(
+  Se,
+  (n = {}) => {
     const {
       showVertical: e = !0,
       showHorizontal: t = !0,
-      color: s,
-      lineStyle: o = "dashed",
-      lineWidth: n = 1,
-      snapToData: u = !1,
-      valueFormat: c = { xPrecision: 4, yPrecision: 4 }
-    } = r;
-    let i = r.valueDisplayMode ?? "disabled";
-    r.showAxisLabels !== void 0 && r.valueDisplayMode === void 0 && (i = r.showAxisLabels ? "floating" : "disabled");
-    const l = r.cornerPosition ?? "top-left";
-    let f = -1, y = -1, b, v = null, p = null;
+      color: r,
+      lineStyle: a = "dashed",
+      lineWidth: o = 1,
+      snapToData: l = !1,
+      valueFormat: d = { xPrecision: 4, yPrecision: 4 }
+    } = n;
+    let i = n.valueDisplayMode ?? "disabled";
+    n.showAxisLabels !== void 0 && n.valueDisplayMode === void 0 && (i = n.showAxisLabels ? "floating" : "disabled");
+    const s = n.cornerPosition ?? "top-left";
+    let c = -1, f = -1, w, v = null, p = null;
     return {
-      onInit(d) {
-        b = "crosshair-overlay";
-        const a = d.ui.createOverlay(b, {
+      onInit(h) {
+        w = "crosshair-overlay";
+        const u = h.ui.createOverlay(w, {
           zIndex: 500,
           position: { top: "0", left: "0", right: "0", bottom: "0" }
         });
-        v = document.createElement("canvas"), v.style.cssText = "width: 100%; height: 100%;", a.appendChild(v), p = v.getContext("2d"), S(d);
+        v = document.createElement("canvas"), v.style.cssText = "width: 100%; height: 100%;", u.appendChild(v), p = v.getContext("2d"), S(h);
       },
-      onDestroy(d) {
-        d.ui.removeOverlay(b), v = null, p = null;
+      onDestroy(h) {
+        h.ui.removeOverlay(w), v = null, p = null;
       },
-      onResize(d) {
-        S(d);
+      onResize(h) {
+        S(h);
       },
-      onInteraction(d, a) {
-        if (a.type === "mousemove") {
-          if (f = a.pixelX, y = a.pixelY, u && a.inPlotArea) {
-            const P = d.coords.pickPoint(f, y);
-            P && (f = P.pixelX, y = P.pixelY);
+      onInteraction(h, u) {
+        if (u.type === "mousemove") {
+          if (c = u.pixelX, f = u.pixelY, l && u.inPlotArea) {
+            const P = h.coords.pickPoint(c, f);
+            P && (c = P.pixelX, f = P.pixelY);
           }
-          C(d);
+          b(h);
         }
       },
       onViewChange() {
       }
     };
-    function S(d) {
+    function S(h) {
       if (!v || !p) return;
-      const a = d.render.canvasSize, P = d.render.pixelRatio;
-      v.width = a.width * P, v.height = a.height * P, p.setTransform(1, 0, 0, 1, 0, 0), p.scale(P, P);
+      const u = h.render.canvasSize, P = h.render.pixelRatio;
+      v.width = u.width * P, v.height = u.height * P, p.setTransform(1, 0, 0, 1, 0, 0), p.scale(P, P);
     }
-    function C(d) {
-      var A;
+    function b(h) {
+      var F;
       if (!p || !v) return;
-      const { width: a, height: P } = d.render.canvasSize;
-      if (p.clearRect(0, 0, a, P), f < 0 || y < 0) return;
-      const x = d.render.plotArea;
-      if (f < x.x || f > x.x + x.width || y < x.y || y > x.y + x.height)
+      const { width: u, height: P } = h.render.canvasSize;
+      if (p.clearRect(0, 0, u, P), c < 0 || f < 0) return;
+      const x = h.render.plotArea;
+      if (c < x.x || c > x.x + x.width || f < x.y || f > x.y + x.height)
         return;
-      const D = s || ((A = d.ui.theme.cursor) == null ? void 0 : A.color) || "#888888";
-      p.save(), p.strokeStyle = D, p.lineWidth = n, o === "dashed" ? p.setLineDash([6, 4]) : o === "dotted" && p.setLineDash([2, 2]), e && (p.beginPath(), p.moveTo(f, x.y), p.lineTo(f, x.y + x.height), p.stroke()), t && (p.beginPath(), p.moveTo(x.x, y), p.lineTo(x.x + x.width, y), p.stroke()), p.restore(), i === "floating" ? g(d, p, f, y, D) : i === "corner" && m(d, p, f, y, D);
+      const I = r || ((F = h.ui.theme.cursor) == null ? void 0 : F.color) || "#888888";
+      p.save(), p.strokeStyle = I, p.lineWidth = o, a === "dashed" ? p.setLineDash([6, 4]) : a === "dotted" && p.setLineDash([2, 2]), e && (p.beginPath(), p.moveTo(c, x.y), p.lineTo(c, x.y + x.height), p.stroke()), t && (p.beginPath(), p.moveTo(x.x, f), p.lineTo(x.x + x.width, f), p.stroke()), p.restore(), i === "floating" ? g(h, p, c, f, I) : i === "corner" && y(h, p, c, f, I);
     }
-    function g(d, a, P, x, D) {
-      const A = d.coords.pixelToDataX(P), k = d.coords.pixelToDataY(x), M = d.render.plotArea;
-      a.save(), a.font = "11px system-ui, sans-serif", a.textAlign = "center", a.textBaseline = "top";
-      const z = A.toPrecision(c.xPrecision), w = a.measureText(z).width + 8, T = 18, F = P - w / 2, I = M.y + M.height + 2;
-      a.fillStyle = D, a.fillRect(F, I, w, T), a.fillStyle = "#ffffff", a.fillText(z, P, I + 3), a.textAlign = "right", a.textBaseline = "middle";
-      const R = k.toPrecision(c.yPrecision), Y = a.measureText(R).width + 8, L = 18, X = M.x - Y - 2, H = x - L / 2;
-      a.fillStyle = D, a.fillRect(X, H, Y, L), a.fillStyle = "#ffffff", a.fillText(R, M.x - 6, x), a.restore();
+    function g(h, u, P, x, I) {
+      const F = h.coords.pixelToDataX(P), B = h.coords.pixelToDataY(x), M = h.render.plotArea;
+      u.save(), u.font = "11px system-ui, sans-serif", u.textAlign = "center", u.textBaseline = "top";
+      const _ = F.toPrecision(d.xPrecision), A = u.measureText(_).width + 8, T = 18, k = P - A / 2, C = M.y + M.height + 2;
+      u.fillStyle = I, u.fillRect(k, C, A, T), u.fillStyle = "#ffffff", u.fillText(_, P, C + 3), u.textAlign = "right", u.textBaseline = "middle";
+      const L = B.toPrecision(d.yPrecision), Y = u.measureText(L).width + 8, E = 18, R = M.x - Y - 2, U = x - E / 2;
+      u.fillStyle = I, u.fillRect(R, U, Y, E), u.fillStyle = "#ffffff", u.fillText(L, M.x - 6, x), u.restore();
     }
-    function m(d, a, P, x, D) {
-      const A = d.coords.pixelToDataX(P), k = d.coords.pixelToDataY(x), M = d.render.plotArea;
-      a.save(), a.font = "11px system-ui, sans-serif";
-      const z = `X: ${A.toPrecision(c.xPrecision)}`, h = `Y: ${k.toPrecision(c.yPrecision)}`, w = a.measureText(z), T = a.measureText(h), F = Math.max(w.width, T.width), I = 6, R = 16, E = F + I * 2, Y = R * 2 + I * 2;
-      let L, X;
-      switch (l) {
+    function y(h, u, P, x, I) {
+      const F = h.coords.pixelToDataX(P), B = h.coords.pixelToDataY(x), M = h.render.plotArea;
+      u.save(), u.font = "11px system-ui, sans-serif";
+      const _ = `X: ${F.toPrecision(d.xPrecision)}`, m = `Y: ${B.toPrecision(d.yPrecision)}`, A = u.measureText(_), T = u.measureText(m), k = Math.max(A.width, T.width), C = 6, L = 16, D = k + C * 2, Y = L * 2 + C * 2;
+      let E, R;
+      switch (s) {
         case "top-left":
-          L = M.x + 8, X = M.y + 8;
+          E = M.x + 8, R = M.y + 8;
           break;
         case "top-right":
-          L = M.x + M.width - E - 8, X = M.y + 8;
+          E = M.x + M.width - D - 8, R = M.y + 8;
           break;
         case "bottom-left":
-          L = M.x + 8, X = M.y + M.height - Y - 8;
+          E = M.x + 8, R = M.y + M.height - Y - 8;
           break;
         case "bottom-right":
-          L = M.x + M.width - E - 8, X = M.y + M.height - Y - 8;
+          E = M.x + M.width - D - 8, R = M.y + M.height - Y - 8;
           break;
         default:
-          L = M.x + 8, X = M.y + 8;
+          E = M.x + 8, R = M.y + 8;
       }
-      a.fillStyle = D, a.globalAlpha = 0.85, a.fillRect(L, X, E, Y), a.globalAlpha = 1, a.strokeStyle = "rgba(255,255,255,0.3)", a.lineWidth = 1, a.strokeRect(L, X, E, Y), a.fillStyle = "#ffffff", a.textAlign = "left", a.textBaseline = "top", a.fillText(z, L + I, X + I), a.fillText(h, L + I, X + I + R), a.restore();
+      u.fillStyle = I, u.globalAlpha = 0.85, u.fillRect(E, R, D, Y), u.globalAlpha = 1, u.strokeStyle = "rgba(255,255,255,0.3)", u.lineWidth = 1, u.strokeRect(E, R, D, Y), u.fillStyle = "#ffffff", u.textAlign = "left", u.textBaseline = "top", u.fillText(_, E + C, R + C), u.fillText(m, E + C, R + C + L), u.restore();
     }
   }
-), he = {
+), be = {
   name: "statistics-overlay",
   version: "1.0.0",
   description: "Displays real-time statistics for chart data",
   provides: ["visualization", "analysis"],
   tags: ["statistics", "overlay", "analytics"]
-}, me = O(
-  he,
-  (r = {}) => {
+}, Ae = z(
+  be,
+  (n = {}) => {
     const {
       position: e = "top-right",
       show: t = ["count", "mean", "min", "max"],
-      seriesId: s,
-      autoUpdate: o = !0
-    } = r;
-    let n, u = null;
+      seriesId: r,
+      autoUpdate: a = !0
+    } = n;
+    let o, l = null;
     return {
-      onInit(l) {
-        n = "stats-overlay";
-        const f = {};
-        e.includes("top") && (f.top = "10px"), e.includes("bottom") && (f.bottom = "10px"), e.includes("left") && (f.left = "10px"), e.includes("right") && (f.right = "10px"), u = l.ui.createOverlay(n, {
+      onInit(s) {
+        o = "stats-overlay";
+        const c = {};
+        e.includes("top") && (c.top = "10px"), e.includes("bottom") && (c.bottom = "10px"), e.includes("left") && (c.left = "10px"), e.includes("right") && (c.right = "10px"), l = s.ui.createOverlay(o, {
           zIndex: 800,
-          position: f,
+          position: c,
           pointerEvents: !1
-        }), u.innerHTML = `
+        }), l.innerHTML = `
           <div style="
             background: rgba(0, 0, 0, 0.85);
             color: #fff;
@@ -214,324 +217,324 @@ const ge = {
             <div style="font-weight: bold; margin-bottom: 4px; color: #4ade80;">📊 Statistics</div>
             <div class="stats-content"></div>
           </div>
-        `, c(l);
+        `, d(s);
       },
-      onDestroy(l) {
-        l.ui.removeOverlay(n), u = null;
+      onDestroy(s) {
+        s.ui.removeOverlay(o), l = null;
       },
-      onDataUpdate(l) {
-        o && c(l);
+      onDataUpdate(s) {
+        a && d(s);
       },
-      onSeriesAdd(l) {
-        c(l);
+      onSeriesAdd(s) {
+        d(s);
       },
-      onSeriesRemove(l) {
-        c(l);
+      onSeriesRemove(s) {
+        d(s);
       },
       api: {
-        refresh(l) {
-          c(l);
+        refresh(s) {
+          d(s);
         }
       }
     };
-    function c(l) {
-      if (!u) return;
-      const f = u.querySelector(".stats-content");
-      if (!f) return;
-      const y = l.data.getAllSeries(), b = s ? y.filter((C) => C.getId() === s) : y;
-      if (b.length === 0) {
-        f.innerHTML = "<div style='color: #888'>No data</div>";
+    function d(s) {
+      if (!l) return;
+      const c = l.querySelector(".stats-content");
+      if (!c) return;
+      const f = s.data.getAllSeries(), w = r ? f.filter((b) => b.getId() === r) : f;
+      if (w.length === 0) {
+        c.innerHTML = "<div style='color: #888'>No data</div>";
         return;
       }
       let v = [];
-      if (b.forEach((C) => {
-        const g = C.getData();
+      if (w.forEach((b) => {
+        const g = b.getData();
         g != null && g.y && (v = v.concat(Array.from(g.y)));
       }), v.length === 0) {
-        f.innerHTML = "<div style='color: #888'>No data</div>";
+        c.innerHTML = "<div style='color: #888'>No data</div>";
         return;
       }
       const p = i(v), S = [];
-      t.includes("count") && S.push(`<div>N: <span style="color: #60a5fa">${p.count.toLocaleString()}</span></div>`), t.includes("mean") && S.push(`<div>μ: <span style="color: #60a5fa">${p.mean.toPrecision(4)}</span></div>`), t.includes("min") && S.push(`<div>Min: <span style="color: #60a5fa">${p.min.toPrecision(4)}</span></div>`), t.includes("max") && S.push(`<div>Max: <span style="color: #60a5fa">${p.max.toPrecision(4)}</span></div>`), t.includes("std") && S.push(`<div>σ: <span style="color: #60a5fa">${p.std.toPrecision(4)}</span></div>`), t.includes("range") && S.push(`<div>Range: <span style="color: #60a5fa">${p.range.toPrecision(4)}</span></div>`), f.innerHTML = S.join("");
+      t.includes("count") && S.push(`<div>N: <span style="color: #60a5fa">${p.count.toLocaleString()}</span></div>`), t.includes("mean") && S.push(`<div>μ: <span style="color: #60a5fa">${p.mean.toPrecision(4)}</span></div>`), t.includes("min") && S.push(`<div>Min: <span style="color: #60a5fa">${p.min.toPrecision(4)}</span></div>`), t.includes("max") && S.push(`<div>Max: <span style="color: #60a5fa">${p.max.toPrecision(4)}</span></div>`), t.includes("std") && S.push(`<div>σ: <span style="color: #60a5fa">${p.std.toPrecision(4)}</span></div>`), t.includes("range") && S.push(`<div>Range: <span style="color: #60a5fa">${p.range.toPrecision(4)}</span></div>`), c.innerHTML = S.join("");
     }
-    function i(l) {
-      const f = l.length;
-      let y = 0, b = 1 / 0, v = -1 / 0;
-      for (const g of l)
-        y += g, g < b && (b = g), g > v && (v = g);
-      const p = y / f;
+    function i(s) {
+      const c = s.length;
+      let f = 0, w = 1 / 0, v = -1 / 0;
+      for (const g of s)
+        f += g, g < w && (w = g), g > v && (v = g);
+      const p = f / c;
       let S = 0;
-      for (const g of l)
+      for (const g of s)
         S += (g - p) ** 2;
-      const C = Math.sqrt(S / f);
+      const b = Math.sqrt(S / c);
       return {
-        count: f,
+        count: c,
         mean: p,
-        min: b,
+        min: w,
         max: v,
-        std: C,
-        range: v - b
+        std: b,
+        range: v - w
       };
     }
   }
-), ye = {
+), Me = {
   name: "watermark",
   version: "1.0.0",
   description: "Adds a customizable watermark to the chart",
   provides: ["visualization"],
   tags: ["watermark", "branding", "overlay"]
-}, xe = O(
-  ye,
-  (r) => {
-    if (!(r != null && r.text))
+}, Fe = z(
+  Me,
+  (n) => {
+    if (!(n != null && n.text))
       throw new Error("WatermarkPlugin requires 'text' configuration");
     const {
       text: e,
       fontSize: t = 48,
-      fontFamily: s = "system-ui, sans-serif",
-      color: o = "rgba(128, 128, 128, 0.15)",
-      position: n = "center",
-      rotation: u = n === "center" ? -30 : 0
-    } = r;
+      fontFamily: r = "system-ui, sans-serif",
+      color: a = "rgba(128, 128, 128, 0.15)",
+      position: o = "center",
+      rotation: l = o === "center" ? -30 : 0
+    } = n;
     return {
-      onRenderOverlay(c) {
-        const i = c.render.ctx2d;
+      onRenderOverlay(d) {
+        const i = d.render.ctx2d;
         if (!i) return;
-        c.render.canvasSize;
-        const l = c.render.plotArea;
-        i.save(), i.font = `${t}px ${s}`, i.fillStyle = o, i.textAlign = "center", i.textBaseline = "middle";
-        let f, y;
-        n === "center" ? (f = l.x + l.width / 2, y = l.y + l.height / 2) : n === "bottom-right" ? (f = l.x + l.width - t, y = l.y + l.height - t / 2) : (f = l.x + t, y = l.y + l.height - t / 2), i.translate(f, y), i.rotate(u * Math.PI / 180), i.fillText(e, 0, 0), i.restore();
+        d.render.canvasSize;
+        const s = d.render.plotArea;
+        i.save(), i.font = `${t}px ${r}`, i.fillStyle = a, i.textAlign = "center", i.textBaseline = "middle";
+        let c, f;
+        o === "center" ? (c = s.x + s.width / 2, f = s.y + s.height / 2) : o === "bottom-right" ? (c = s.x + s.width - t, f = s.y + s.height - t / 2) : (c = s.x + t, f = s.y + s.height - t / 2), i.translate(c, f), i.rotate(l * Math.PI / 180), i.fillText(e, 0, 0), i.restore();
       }
     };
   }
-), ve = {
+), Ce = {
   name: "grid-highlight",
   version: "1.0.0",
   description: "Highlights specific regions of the chart grid",
   provides: ["visualization"],
   tags: ["grid", "highlight", "regions"]
-}, Pe = O(
-  ve,
-  (r = {}) => {
-    const { xIntervals: e = [], yIntervals: t = [], opacity: s = 0.1 } = r;
+}, Ie = z(
+  Ce,
+  (n = {}) => {
+    const { xIntervals: e = [], yIntervals: t = [], opacity: r = 0.1 } = n;
     return {
-      onRenderOverlay(o, n) {
-        const u = o.render.ctx2d;
-        if (!u) return;
-        const c = o.render.plotArea;
-        o.data.getViewBounds(), u.save(), u.beginPath(), u.rect(c.x, c.y, c.width, c.height), u.clip(), u.globalAlpha = s;
+      onRenderOverlay(a, o) {
+        const l = a.render.ctx2d;
+        if (!l) return;
+        const d = a.render.plotArea;
+        a.data.getViewBounds(), l.save(), l.beginPath(), l.rect(d.x, d.y, d.width, d.height), l.clip(), l.globalAlpha = r;
         for (const i of e) {
-          const l = o.coords.dataToPixelX(i.start), f = o.coords.dataToPixelX(i.end);
-          u.fillStyle = i.color, u.fillRect(
-            Math.min(l, f),
-            c.y,
-            Math.abs(f - l),
-            c.height
+          const s = a.coords.dataToPixelX(i.start), c = a.coords.dataToPixelX(i.end);
+          l.fillStyle = i.color, l.fillRect(
+            Math.min(s, c),
+            d.y,
+            Math.abs(c - s),
+            d.height
           );
         }
         for (const i of t) {
-          const l = o.coords.dataToPixelY(i.start), f = o.coords.dataToPixelY(i.end);
-          u.fillStyle = i.color, u.fillRect(
-            c.x,
-            Math.min(l, f),
-            c.width,
-            Math.abs(f - l)
+          const s = a.coords.dataToPixelY(i.start), c = a.coords.dataToPixelY(i.end);
+          l.fillStyle = i.color, l.fillRect(
+            d.x,
+            Math.min(s, c),
+            d.width,
+            Math.abs(c - s)
           );
         }
-        u.restore();
+        l.restore();
       }
     };
   }
-), Se = {
+), De = {
   name: "data-logger",
   version: "1.0.0",
   description: "Logs chart events for debugging and analysis",
   provides: ["analysis"],
   tags: ["debug", "logging", "events"]
-}, Te = O(
-  Se,
-  (r = {}) => {
+}, ke = z(
+  De,
+  (n = {}) => {
     const {
       logDataUpdates: e = !0,
       logViewChanges: t = !0,
-      logInteractions: s = !1,
-      maxEntries: o = 100
-    } = r, n = [];
-    function u(c, i) {
-      n.push({
+      logInteractions: r = !1,
+      maxEntries: a = 100
+    } = n, o = [];
+    function l(d, i) {
+      o.push({
         timestamp: Date.now(),
-        type: c,
+        type: d,
         data: i
-      }), n.length > o && n.shift();
+      }), o.length > a && o.shift();
     }
     return {
-      onInit(c) {
-        c.log.info("Data logger initialized");
+      onInit(d) {
+        d.log.info("Data logger initialized");
       },
-      onDataUpdate(c, i) {
-        e && (u("dataUpdate", {
+      onDataUpdate(d, i) {
+        e && (l("dataUpdate", {
           seriesId: i.seriesId,
           mode: i.mode,
           pointCount: i.pointCount
-        }), c.log.debug(`Data update: ${i.seriesId} (${i.mode}, ${i.pointCount} points)`));
+        }), d.log.debug(`Data update: ${i.seriesId} (${i.mode}, ${i.pointCount} points)`));
       },
-      onViewChange(c, i) {
-        t && (u("viewChange", {
+      onViewChange(d, i) {
+        t && (l("viewChange", {
           trigger: i.trigger,
           bounds: i.current
-        }), c.log.debug(`View change: ${i.trigger}`));
+        }), d.log.debug(`View change: ${i.trigger}`));
       },
-      onInteraction(c, i) {
-        s && u("interaction", {
+      onInteraction(d, i) {
+        r && l("interaction", {
           type: i.type,
           pixelX: i.pixelX,
           pixelY: i.pixelY,
           inPlotArea: i.inPlotArea
         });
       },
-      onSerialize(c) {
-        return { entries: n };
+      onSerialize(d) {
+        return { entries: o };
       },
-      onDeserialize(c, i) {
-        const l = i;
-        l != null && l.entries && (n.length = 0, n.push(...l.entries));
+      onDeserialize(d, i) {
+        const s = i;
+        s != null && s.entries && (o.length = 0, o.push(...s.entries));
       },
       api: {
         getEntries() {
-          return [...n];
+          return [...o];
         },
         clear() {
-          n.length = 0;
+          o.length = 0;
         },
         export() {
-          return JSON.stringify(n, null, 2);
+          return JSON.stringify(o, null, 2);
         }
       }
     };
   }
-), we = {
+), Ee = {
   name: "direction-indicator",
   version: "1.0.0",
   description: "Shows an arrow indicating the direction and trend of streaming data",
   provides: ["visualization", "analysis"],
   tags: ["streaming", "direction", "trend", "arrow"]
-}, be = O(
-  we,
-  (r = {}) => {
+}, Le = z(
+  Ee,
+  (n = {}) => {
     const {
       seriesId: e,
       sampleSize: t = 20,
-      color: s,
-      size: o = 40,
-      minVelocity: n = 0.01,
-      historySize: u = 20,
-      idleTimeout: c
-    } = r;
-    let i, l = null, f = null, y = null, b = null;
+      color: r,
+      size: a = 40,
+      minVelocity: o = 0.01,
+      historySize: l = 20,
+      idleTimeout: d
+    } = n;
+    let i, s = null, c = null, f = null, w = null;
     const v = [], p = [], S = [];
-    let C = u, g = null, m = Date.now(), d = -1 / 0, a = -1 / 0, P = c;
+    let b = l, g = null, y = Date.now(), h = -1 / 0, u = -1 / 0, P = d;
     return {
-      onInit(h) {
+      onInit(m) {
         i = "direction-indicator-overlay";
-        const w = h.ui.createOverlay(i, {
+        const A = m.ui.createOverlay(i, {
           zIndex: 600,
           position: { top: "0", left: "0", right: "0", bottom: "0" },
           pointerEvents: !1
         });
-        if (l = document.createElement("canvas"), l.style.cssText = "width: 100%; height: 100%; pointer-events: none;", w.appendChild(l), f = l.getContext("2d"), x(h), e)
-          b = e;
+        if (s = document.createElement("canvas"), s.style.cssText = "width: 100%; height: 100%; pointer-events: none;", A.appendChild(s), c = s.getContext("2d"), x(m), e)
+          w = e;
         else {
-          const T = h.data.getAllSeries();
-          T.length > 0 && (b = T[0].getId());
+          const T = m.data.getAllSeries();
+          T.length > 0 && (w = T[0].getId());
         }
       },
-      onDestroy(h) {
-        h.ui.removeOverlay(i), g && clearTimeout(g), l = null, f = null, y = null;
+      onDestroy(m) {
+        m.ui.removeOverlay(i), g && clearTimeout(g), s = null, c = null, f = null;
       },
-      onResize(h) {
-        x(h);
+      onResize(m) {
+        x(m);
       },
-      onAfterRender(h) {
-        if (D(h), M(h), P) {
+      onAfterRender(m) {
+        if (I(m), M(m), P) {
           g && clearTimeout(g);
-          const w = Date.now() - m;
-          w < P && (g = setTimeout(() => {
-            h.requestRender();
-          }, P - w + 10));
+          const A = Date.now() - y;
+          A < P && (g = setTimeout(() => {
+            m.requestRender();
+          }, P - A + 10));
         }
       },
-      onConfigChange(h, w) {
-        if (w.historySize !== void 0) {
-          for (C = w.historySize; v.length > C; ) v.shift();
-          for (; p.length > C; ) p.shift();
-          for (; S.length > C; ) S.shift();
+      onConfigChange(m, A) {
+        if (A.historySize !== void 0) {
+          for (b = A.historySize; v.length > b; ) v.shift();
+          for (; p.length > b; ) p.shift();
+          for (; S.length > b; ) S.shift();
         }
-        w.idleTimeout !== void 0 && (P = w.idleTimeout);
+        A.idleTimeout !== void 0 && (P = A.idleTimeout);
       }
     };
-    function x(h) {
-      if (!l || !f) return;
-      const w = h.render.canvasSize, T = h.render.pixelRatio;
-      l.width = w.width * T, l.height = w.height * T, f.setTransform(1, 0, 0, 1, 0, 0), f.scale(T, T);
+    function x(m) {
+      if (!s || !c) return;
+      const A = m.render.canvasSize, T = m.render.pixelRatio;
+      s.width = A.width * T, s.height = A.height * T, c.setTransform(1, 0, 0, 1, 0, 0), c.scale(T, T);
     }
-    function D(h) {
-      if (!b || !h.data.getSeries(b)) return;
-      const T = h.data.getSeriesData(b);
+    function I(m) {
+      if (!w || !m.data.getSeries(w)) return;
+      const T = m.data.getSeriesData(w);
       if (!T || !T.x || !T.y) return;
-      const F = T.x.length;
-      if (F < 2) return;
-      const I = T.x[F - 1], R = T.y[F - 1];
-      (I !== d || R !== a) && (d = I, a = R, m = Date.now());
-      const E = Math.min(t, F), Y = F - E;
-      let L = 0, X = 0, H = 0, V = 0, U = 0, K = 0;
-      for (let $ = Y; $ < F; $++) {
-        const B = $ - Y, le = T.x[$], ce = T.y[$], j = h.coords.dataToPixelX(le), J = h.coords.dataToPixelY(ce);
-        L += B, X += j, H += J, V += B * j, U += B * J, K += B * B;
+      const k = T.x.length;
+      if (k < 2) return;
+      const C = T.x[k - 1], L = T.y[k - 1];
+      (C !== h || L !== u) && (h = C, u = L, y = Date.now());
+      const D = Math.min(t, k), Y = k - D;
+      let E = 0, R = 0, U = 0, K = 0, j = 0, J = 0;
+      for (let W = Y; W < k; W++) {
+        const G = W - Y, ye = T.x[W], xe = T.y[W], Q = m.coords.dataToPixelX(ye), Z = m.coords.dataToPixelY(xe);
+        E += G, R += Q, U += Z, K += G * Q, j += G * Z, J += G * G;
       }
-      const q = L / E, Z = X / E, ee = H / E, W = K - E * q * q;
-      if (Math.abs(W) < 1e-10) return;
-      const G = (V - E * q * Z) / W, N = (U - E * q * ee) / W, te = Math.atan2(N, G), ne = h.coords.dataToPixelX(I), ae = h.coords.dataToPixelY(R);
-      v.push(ne), p.push(ae), v.length > C && (v.shift(), p.shift()), S.push(te), S.length > C && S.shift();
-      const oe = A(v), re = A(p), ie = k(S), se = Math.sqrt(G * G + N * N);
-      y = { angle: ie, magnitude: se, lastX: I, lastY: R, smoothX: oe, smoothY: re };
+      const $ = E / D, le = R / D, ce = U / D, H = J - D * $ * $;
+      if (Math.abs(H) < 1e-10) return;
+      const N = (K - D * $ * le) / H, q = (j - D * $ * ce) / H, de = Math.atan2(q, N), ue = m.coords.dataToPixelX(C), fe = m.coords.dataToPixelY(L);
+      v.push(ue), p.push(fe), v.length > b && (v.shift(), p.shift()), S.push(de), S.length > b && S.shift();
+      const he = F(v), ge = F(p), pe = B(S), me = Math.sqrt(N * N + q * q);
+      f = { angle: pe, magnitude: me, lastX: C, lastY: L, smoothX: he, smoothY: ge };
     }
-    function A(h) {
-      return h.length === 0 ? 0 : h.reduce((w, T) => w + T, 0) / h.length;
+    function F(m) {
+      return m.length === 0 ? 0 : m.reduce((A, T) => A + T, 0) / m.length;
     }
-    function k(h) {
-      if (h.length === 0) return 0;
-      let w = 0, T = 0;
-      for (const F of h)
-        w += Math.cos(F), T += Math.sin(F);
-      return Math.atan2(T / h.length, w / h.length);
+    function B(m) {
+      if (m.length === 0) return 0;
+      let A = 0, T = 0;
+      for (const k of m)
+        A += Math.cos(k), T += Math.sin(k);
+      return Math.atan2(T / m.length, A / m.length);
     }
-    function M(h) {
-      if (!f || !l || !y) return;
-      const { width: w, height: T } = h.render.canvasSize;
-      if (f.clearRect(0, 0, w, T), P !== void 0 && Date.now() - m > P || y.magnitude < n) return;
-      const F = y.smoothX, I = y.smoothY, R = s || "#FF9800";
-      f.save(), z(f, F, I, y.angle, o, R), f.restore();
+    function M(m) {
+      if (!c || !s || !f) return;
+      const { width: A, height: T } = m.render.canvasSize;
+      if (c.clearRect(0, 0, A, T), P !== void 0 && Date.now() - y > P || f.magnitude < o) return;
+      const k = f.smoothX, C = f.smoothY, L = r || "#FF9800";
+      c.save(), _(c, k, C, f.angle, a, L), c.restore();
     }
-    function z(h, w, T, F, I, R) {
-      const E = I * 0.6, Y = I * 0.4;
-      h.save(), h.translate(w, T), h.rotate(F), h.fillStyle = R, h.beginPath(), h.moveTo(E / 2, 0), h.lineTo(-E / 2, -Y / 2), h.lineTo(-E / 2, Y / 2), h.closePath(), h.fill(), h.restore();
+    function _(m, A, T, k, C, L) {
+      const D = C * 0.6, Y = C * 0.4;
+      m.save(), m.translate(A, T), m.rotate(k), m.fillStyle = L, m.beginPath(), m.moveTo(D / 2, 0), m.lineTo(-D / 2, -Y / 2), m.lineTo(-D / 2, Y / 2), m.closePath(), m.fill(), m.restore();
     }
   }
-), Le = {
-  Crosshair: pe,
-  Statistics: me,
-  Watermark: xe,
-  GridHighlight: Pe,
-  DataLogger: Te,
-  DirectionIndicator: be
-}, Ce = {
+), it = {
+  Crosshair: Te,
+  Statistics: Ae,
+  Watermark: Fe,
+  GridHighlight: Ie,
+  DataLogger: ke,
+  DirectionIndicator: Le
+}, Re = {
   name: "velo-plot-drag-edit",
   version: "1.0.0",
   description: "Interactive drag & drop editing of data points",
   provides: ["drag-edit", "point-editing"],
   tags: ["interaction", "editing", "ux"]
-}, Me = {
+}, Ye = {
   enabled: !0,
   constraint: "both",
   snapToGrid: !1,
@@ -556,89 +559,89 @@ const ge = {
     opacity: 0.5
   }
 };
-function Re(r = {}) {
-  const e = { ...Me, ...r };
-  let t = null, s = !1, o = null, n = 0, u = 0, c = !1;
-  function i(g, m) {
+function st(n = {}) {
+  const e = { ...Ye, ...n };
+  let t = null, r = !1, a = null, o = 0, l = 0, d = !1;
+  function i(g, y) {
     if (!t) return null;
-    const d = t.coords.pickPoint(g, m, e.hitRadius);
-    return !d || e.editableSeries.length > 0 && !e.editableSeries.includes(d.seriesId) ? null : {
-      seriesId: d.seriesId,
-      index: d.index,
-      originalX: d.x,
-      originalY: d.y,
-      currentX: d.x,
-      currentY: d.y
+    const h = t.coords.pickPoint(g, y, e.hitRadius);
+    return !h || e.editableSeries.length > 0 && !e.editableSeries.includes(h.seriesId) ? null : {
+      seriesId: h.seriesId,
+      index: h.index,
+      originalX: h.x,
+      originalY: h.y,
+      currentX: h.x,
+      currentY: h.y
     };
   }
-  function l(g, m) {
+  function s(g, y) {
     return t ? {
       x: t.coords.pixelToDataX(g),
-      y: t.coords.pixelToDataY(m)
+      y: t.coords.pixelToDataY(y)
     } : { x: 0, y: 0 };
   }
-  function f(g, m) {
-    return Math.round(g / m) * m;
+  function c(g, y) {
+    return Math.round(g / y) * y;
   }
-  function y(g, m, d) {
-    if (!o) return { x: g, y: m };
-    switch (d) {
+  function f(g, y, h) {
+    if (!a) return { x: g, y };
+    switch (h) {
       case "x":
-        return { x: g, y: o.originalY };
+        return { x: g, y: a.originalY };
       case "y":
-        return { x: o.originalX, y: m };
+        return { x: a.originalX, y };
       case "none":
-        return { x: o.originalX, y: o.originalY };
+        return { x: a.originalX, y: a.originalY };
       default:
-        return { x: g, y: m };
+        return { x: g, y };
     }
   }
-  function b(g, m) {
-    let d = g, a = m;
-    if (e.snapToGrid && (d = f(g, e.snapIntervalX), a = f(m, e.snapIntervalY)), o && e.validator) {
-      const P = { ...o, currentX: d, currentY: a }, x = e.validator(P);
+  function w(g, y) {
+    let h = g, u = y;
+    if (e.snapToGrid && (h = c(g, e.snapIntervalX), u = c(y, e.snapIntervalY)), a && e.validator) {
+      const P = { ...a, currentX: h, currentY: u }, x = e.validator(P);
       if (typeof x == "boolean")
-        return { x: d, y: a, valid: x };
+        return { x: h, y: u, valid: x };
       if (!x.valid)
-        return { x: d, y: a, valid: !1 };
-      x.snapX !== void 0 && (d = x.snapX), x.snapY !== void 0 && (a = x.snapY);
+        return { x: h, y: u, valid: !1 };
+      x.snapX !== void 0 && (h = x.snapX), x.snapY !== void 0 && (u = x.snapY);
     }
-    return { x: d, y: a, valid: !0 };
+    return { x: h, y: u, valid: !0 };
   }
-  function v(g, m, d, a) {
-    var D, A, k;
+  function v(g, y, h, u) {
+    var I, F, B;
     if (!t) return;
-    const P = (A = (D = t.chart).getSeries) == null ? void 0 : A.call(D, g);
+    const P = (F = (I = t.chart).getSeries) == null ? void 0 : F.call(I, g);
     if (!P) return;
     const x = P.getData();
-    !x || !x.x || !x.y || (x.x[m] = d, x.y[m] = a, (k = P.invalidateBuffers) == null || k.call(P), t.requestRender());
+    !x || !x.x || !x.y || (x.x[y] = h, x.y[y] = u, (B = P.invalidateBuffers) == null || B.call(P), t.requestRender());
   }
   function p() {
-    return o ? {
-      seriesId: o.seriesId,
-      index: o.index,
-      oldX: o.originalX,
-      oldY: o.originalY,
-      newX: o.currentX,
-      newY: o.currentY,
-      deltaX: o.currentX - o.originalX,
-      deltaY: o.currentY - o.originalY
+    return a ? {
+      seriesId: a.seriesId,
+      index: a.index,
+      oldX: a.originalX,
+      oldY: a.originalY,
+      newX: a.currentX,
+      newY: a.currentY,
+      deltaX: a.currentX - a.originalX,
+      deltaY: a.currentY - a.originalY
     } : null;
   }
   function S(g) {
-    if (!s || !o || !e.showPreview) return;
-    const { render: m, coords: d } = g, { ctx2d: a } = m;
-    if (!a) return;
-    a.save();
-    const P = d.dataToPixelX(o.originalX), x = d.dataToPixelY(o.originalY), D = d.dataToPixelX(o.currentX), A = d.dataToPixelY(o.currentY);
-    a.strokeStyle = e.previewStyle.color || "#ffffff", a.lineWidth = e.previewStyle.width || 2, a.globalAlpha = e.previewStyle.opacity || 0.5, a.setLineDash(e.previewStyle.dash || [5, 5]), a.beginPath(), a.moveTo(P, x), a.lineTo(D, A), a.stroke(), a.globalAlpha = 1, a.fillStyle = e.highlightColor, a.setLineDash([]), a.beginPath(), a.arc(D, A, 6, 0, Math.PI * 2), a.fill(), a.strokeStyle = "#000000", a.lineWidth = 1, a.stroke(), a.restore();
+    if (!r || !a || !e.showPreview) return;
+    const { render: y, coords: h } = g, { ctx2d: u } = y;
+    if (!u) return;
+    u.save();
+    const P = h.dataToPixelX(a.originalX), x = h.dataToPixelY(a.originalY), I = h.dataToPixelX(a.currentX), F = h.dataToPixelY(a.currentY);
+    u.strokeStyle = e.previewStyle.color || "#ffffff", u.lineWidth = e.previewStyle.width || 2, u.globalAlpha = e.previewStyle.opacity || 0.5, u.setLineDash(e.previewStyle.dash || [5, 5]), u.beginPath(), u.moveTo(P, x), u.lineTo(I, F), u.stroke(), u.globalAlpha = 1, u.fillStyle = e.highlightColor, u.setLineDash([]), u.beginPath(), u.arc(I, F, 6, 0, Math.PI * 2), u.fill(), u.strokeStyle = "#000000", u.lineWidth = 1, u.stroke(), u.restore();
   }
-  const C = {
+  const b = {
     enable() {
       e.enabled = !0;
     },
     disable() {
-      e.enabled = !1, s && (o = null, s = !1, c = !1, t == null || t.requestRender());
+      e.enabled = !1, r && (a = null, r = !1, d = !1, t == null || t.requestRender());
     },
     isEnabled() {
       return e.enabled;
@@ -647,73 +650,545 @@ function Re(r = {}) {
       e.editableSeries = g;
     },
     getDraggedPoint() {
-      return o;
+      return a;
     },
     cancelDrag() {
-      s && o && (o = null, s = !1, c = !1, t == null || t.requestRender());
+      r && a && (a = null, r = !1, d = !1, t == null || t.requestRender());
     },
     updateConfig(g) {
       Object.assign(e, g);
     }
   };
   return {
-    manifest: Ce,
+    manifest: Re,
     onInit(g) {
-      t = g, t.chart.dragEdit = C;
+      t = g, t.chart.dragEdit = b;
     },
     onDestroy(g) {
       delete g.chart.dragEdit, t = null;
     },
-    onInteraction(g, m) {
+    onInteraction(g, y) {
       if (e.enabled) {
-        if (m.type === "mousedown") {
-          const d = i(m.pixelX, m.pixelY);
-          d && (o = d, n = m.pixelX, u = m.pixelY, c = !1, s = !1, m.preventDefault());
-        } else if (m.type === "mousemove") {
-          if (!o) return;
-          if (!s) {
-            const A = m.pixelX - n, k = m.pixelY - u;
-            if (Math.sqrt(A * A + k * k) > e.dragThreshold) {
-              s = !0, c = !0;
-              const z = p();
-              z && e.onDragStart(z);
+        if (y.type === "mousedown") {
+          const h = i(y.pixelX, y.pixelY);
+          h && (a = h, o = y.pixelX, l = y.pixelY, d = !1, r = !1, y.preventDefault());
+        } else if (y.type === "mousemove") {
+          if (!a) return;
+          if (!r) {
+            const F = y.pixelX - o, B = y.pixelY - l;
+            if (Math.sqrt(F * F + B * B) > e.dragThreshold) {
+              r = !0, d = !0;
+              const _ = p();
+              _ && e.onDragStart(_);
             } else
               return;
           }
-          s && m.preventDefault();
-          let { x: d, y: a } = l(m.pixelX, m.pixelY);
-          ({ x: d, y: a } = y(d, a, e.constraint));
-          const { x: P, y: x, valid: D } = b(d, a);
-          if (D) {
-            o.currentX = P, o.currentY = x;
-            const A = p();
-            A && e.onDrag(A), t == null || t.requestRender();
+          r && y.preventDefault();
+          let { x: h, y: u } = s(y.pixelX, y.pixelY);
+          ({ x: h, y: u } = f(h, u, e.constraint));
+          const { x: P, y: x, valid: I } = w(h, u);
+          if (I) {
+            a.currentX = P, a.currentY = x;
+            const F = p();
+            F && e.onDrag(F), t == null || t.requestRender();
           }
-        } else if (m.type === "mouseup") {
-          if (!o) return;
-          if (s && c) {
+        } else if (y.type === "mouseup") {
+          if (!a) return;
+          if (r && d) {
             v(
-              o.seriesId,
-              o.index,
-              o.currentX,
-              o.currentY
+              a.seriesId,
+              a.index,
+              a.currentX,
+              a.currentY
             );
-            const d = p();
-            d && e.onDragEnd(d), m.preventDefault();
+            const h = p();
+            h && e.onDragEnd(h), y.preventDefault();
           }
-          o = null, s = !1, c = !1, t == null || t.requestRender();
+          a = null, r = !1, d = !1, t == null || t.requestRender();
         }
       }
     },
     onRenderOverlay(g) {
       S(g);
     },
-    api: C
+    api: b
+  };
+}
+const Xe = {
+  name: "velo-plot-drawing-tools",
+  version: "1.0.0",
+  description: "Interactive trendline, horizontal, vertical, and rectangle drawing",
+  provides: ["drawing"],
+  tags: ["drawing", "annotations", "trading"]
+};
+function lt(n = {}) {
+  let e = null, t = {
+    mode: "none",
+    pending: null,
+    undoStack: [],
+    redoStack: []
+  }, r = null;
+  const a = n.color ?? "#38bdf8";
+  function o() {
+    var i, s;
+    return ((s = e == null ? void 0 : (i = e.chart).getAnnotations) == null ? void 0 : s.call(i)) ?? [];
+  }
+  function l() {
+    t.undoStack.push(o()), t.redoStack = [];
+  }
+  return {
+    manifest: Xe,
+    api: {
+      setMode(i) {
+        t.mode = i, t.pending = null;
+      },
+      getMode() {
+        return t.mode;
+      },
+      undo() {
+        if (!e || t.undoStack.length === 0) return !1;
+        t.redoStack.push(o());
+        const i = t.undoStack.pop(), s = o();
+        for (const c of s) e.chart.removeAnnotation(c.id);
+        for (const c of i) e.chart.addAnnotation(c);
+        return !0;
+      },
+      redo() {
+        if (!e || t.redoStack.length === 0) return !1;
+        t.undoStack.push(o());
+        const i = t.redoStack.pop(), s = o();
+        for (const c of s) e.chart.removeAnnotation(c.id);
+        for (const c of i) e.chart.addAnnotation(c);
+        return !0;
+      },
+      clear() {
+        if (e) {
+          l();
+          for (const i of o()) e.chart.removeAnnotation(i.id);
+        }
+      }
+    },
+    onInit(i) {
+      e = i, r = (s) => {
+        if (!e || t.mode === "none" || t.mode === "pan") return;
+        const { x: c, y: f } = s.point;
+        if (t.mode === "horizontal") {
+          l(), e.chart.addAnnotation({
+            type: "horizontal-line",
+            y: f,
+            color: a,
+            interactive: !0
+          });
+          return;
+        }
+        if (t.mode === "vertical") {
+          l(), e.chart.addAnnotation({
+            type: "vertical-line",
+            x: c,
+            color: a,
+            interactive: !0
+          });
+          return;
+        }
+        if (!t.pending) {
+          t.pending = { x: c, y: f };
+          return;
+        }
+        const w = t.pending;
+        t.pending = null, l(), t.mode === "trendline" ? e.chart.addAnnotation({
+          type: "arrow",
+          x1: w.x,
+          y1: w.y,
+          x2: c,
+          y2: f,
+          color: a,
+          interactive: !0
+        }) : t.mode === "rectangle" && e.chart.addAnnotation({
+          type: "rectangle",
+          xMin: Math.min(w.x, c),
+          xMax: Math.max(w.x, c),
+          yMin: Math.min(w.y, f),
+          yMax: Math.max(w.y, f),
+          strokeColor: a,
+          fillColor: a + "22",
+          interactive: !0
+        });
+      }, e.chart.on("click", r);
+    },
+    onDestroy(i) {
+      r && i.chart.off("click", r), e = null, r = null;
+    }
+  };
+}
+const Be = {
+  name: "velo-plot-replay",
+  version: "1.0.0",
+  description: "Bar-by-bar chart replay with speed control",
+  provides: ["replay"],
+  tags: ["replay", "trading"]
+};
+function ct(n) {
+  let e = null, t = null, r = 0, a = null, o = 1;
+  const l = n.frameMs ?? 250;
+  function d(s) {
+    if (!e || !t) return;
+    const c = Math.min(s + 1, t.x.length), f = (w) => w ? w.subarray(0, c) : void 0;
+    e.chart.updateSeries(n.seriesId, {
+      x: f(t.x),
+      y: f(t.y),
+      open: f(t.open),
+      high: f(t.high),
+      low: f(t.low),
+      close: f(t.close)
+    });
+  }
+  const i = {
+    play(s = 1) {
+      t && (o = Math.max(0.1, s), a && clearInterval(a), a = setInterval(() => {
+        if (r >= t.x.length - 1) {
+          i.pause();
+          return;
+        }
+        r++, d(r);
+      }, l / o));
+    },
+    pause() {
+      a && (clearInterval(a), a = null);
+    },
+    step(s = 1) {
+      t && (r = Math.min(t.x.length - 1, r + s), d(r));
+    },
+    seek(s) {
+      t && (r = Math.max(0, Math.min(t.x.length - 1, s)), d(r));
+    },
+    getIndex() {
+      return r;
+    },
+    getLength() {
+      return (t == null ? void 0 : t.x.length) ?? 0;
+    },
+    isPlaying() {
+      return a != null;
+    }
+  };
+  return {
+    manifest: Be,
+    api: i,
+    onInit(s) {
+      e = s;
+      const c = e.chart.getSeries(n.seriesId);
+      if (!c) {
+        console.warn(`[PluginReplay] Series "${n.seriesId}" not found`);
+        return;
+      }
+      const f = c.getData();
+      t = {
+        x: Float32Array.from(f.x),
+        y: f.y ? Float32Array.from(f.y) : void 0,
+        open: f.open ? Float32Array.from(f.open) : void 0,
+        high: f.high ? Float32Array.from(f.high) : void 0,
+        low: f.low ? Float32Array.from(f.low) : void 0,
+        close: f.close ? Float32Array.from(f.close) : void 0
+      }, r = Math.max(0, t.x.length - 1);
+    },
+    onDestroy() {
+      i.pause(), e = null, t = null;
+    }
+  };
+}
+const _e = `
+  attribute vec2 aPosition;
+  uniform vec2 uResolution;
+  void main() {
+    vec2 clip = (aPosition / uResolution) * 2.0 - 1.0;
+    gl_Position = vec4(clip.x, -clip.y, 0.0, 1.0);
+  }
+`, ze = `
+  precision mediump float;
+  uniform vec4 uColor;
+  void main() {
+    gl_FragColor = uColor;
+  }
+`;
+function ne(n, e, t) {
+  const r = n.createShader(e);
+  if (!r) throw new Error("createShader failed");
+  if (n.shaderSource(r, t), n.compileShader(r), !n.getShaderParameter(r, n.COMPILE_STATUS))
+    throw new Error(n.getShaderInfoLog(r) ?? "shader compile failed");
+  return r;
+}
+function We(n) {
+  const e = ne(n, n.VERTEX_SHADER, _e), t = ne(n, n.FRAGMENT_SHADER, ze), r = n.createProgram();
+  if (!r) throw new Error("createProgram failed");
+  if (n.attachShader(r, e), n.attachShader(r, t), n.linkProgram(r), !n.getProgramParameter(r, n.LINK_STATUS))
+    throw new Error(n.getProgramInfoLog(r) ?? "program link failed");
+  return n.deleteShader(e), n.deleteShader(t), r;
+}
+function Ge(n) {
+  const { plotArea: e, xLines: t, yLines: r } = n, a = e.y, o = e.y + e.height, l = e.x, d = e.x + e.width, i = (t.length + r.length) * 2, s = new Float32Array(i * 2);
+  let c = 0;
+  for (const f of t)
+    s[c++] = f, s[c++] = a, s[c++] = f, s[c++] = o;
+  for (const f of r)
+    s[c++] = l, s[c++] = f, s[c++] = d, s[c++] = f;
+  return s;
+}
+class Ue {
+  constructor(e) {
+    X(this, "gl");
+    X(this, "program");
+    X(this, "buffer");
+    X(this, "aPosition");
+    X(this, "uResolution");
+    X(this, "uColor");
+    const t = e.getContext("webgl", {
+      alpha: !0,
+      antialias: !1,
+      preserveDrawingBuffer: !0
+    });
+    if (!t) throw new Error("WebGL not available for grid spike");
+    this.gl = t, this.program = We(t), this.aPosition = t.getAttribLocation(this.program, "aPosition"), this.uResolution = t.getUniformLocation(this.program, "uResolution"), this.uColor = t.getUniformLocation(this.program, "uColor");
+    const r = t.createBuffer();
+    if (!r) throw new Error("createBuffer failed");
+    this.buffer = r;
+  }
+  /** Upload vertices and draw grid lines */
+  draw(e) {
+    const t = this.gl, r = Ge(e), a = r.length / 4;
+    t.viewport(0, 0, e.width, e.height), t.clearColor(0.04, 0.05, 0.08, 1), t.clear(t.COLOR_BUFFER_BIT), t.useProgram(this.program), t.bindBuffer(t.ARRAY_BUFFER, this.buffer), t.bufferData(t.ARRAY_BUFFER, r, t.DYNAMIC_DRAW), t.enableVertexAttribArray(this.aPosition), t.vertexAttribPointer(this.aPosition, 2, t.FLOAT, !1, 0, 0), t.uniform2f(this.uResolution, e.width, e.height);
+    const o = e.color ?? [0.2, 0.22, 0.3, 0.6];
+    return t.uniform4f(this.uColor, o[0], o[1], o[2], o[3]), t.lineWidth(e.lineWidth ?? 1), t.drawArrays(t.LINES, 0, r.length / 2), a;
+  }
+  destroy() {
+    const e = this.gl;
+    e.deleteBuffer(this.buffer), e.deleteProgram(this.program);
+  }
+}
+function $e(n) {
+  const e = () => {
+  };
+  return {
+    canvas: n,
+    strokeStyle: "",
+    fillStyle: "",
+    lineWidth: 1,
+    font: "",
+    textAlign: "left",
+    textBaseline: "alphabetic",
+    beginPath: e,
+    moveTo: e,
+    lineTo: e,
+    stroke: e,
+    fill: e,
+    clearRect: e,
+    setTransform: e,
+    setLineDash: e,
+    save: e,
+    restore: e,
+    translate: e,
+    rotate: e,
+    fillText: e,
+    measureText: (t) => ({ width: t.length * 7 })
+  };
+}
+function Oe(n, e) {
+  const t = document.createElement("canvas");
+  return t.width = n, t.height = e, t.getContext("2d") ?? $e(t);
+}
+function ae(n, e) {
+  const t = { top: 40, right: 40, bottom: 50, left: 60 };
+  return {
+    x: t.left,
+    y: t.top,
+    width: n - t.left - t.right,
+    height: e - t.top - t.bottom
+  };
+}
+function ie(n, e, t, r, a) {
+  const o = e.ticks(r).map((d) => te(e.transform(d))), l = t.ticks(a).map((d) => te(t.transform(d)));
+  return { xLines: o, yLines: l };
+}
+function se(n, e) {
+  const t = [];
+  for (let o = 0; o < e; o++) {
+    const l = performance.now();
+    n(), t.push((performance.now() - l) * 1e3);
+  }
+  t.sort((o, l) => o - l);
+  const r = t.reduce((o, l) => o + l, 0) / t.length, a = t[Math.floor(t.length * 0.95)] ?? r;
+  return { avg: r, p95: a };
+}
+function He(n = {}) {
+  const e = Math.round((n.width ?? 1920) * (n.dpr ?? 1)), t = Math.round((n.height ?? 1080) * (n.dpr ?? 1)), r = n.xTickCount ?? 24, a = n.yTickCount ?? 16, o = n.frames ?? 120, l = Oe(e, t), d = {
+    ...ee,
+    grid: {
+      ...ee.grid,
+      visible: !0,
+      showMinor: n.showMinor ?? !0
+    }
+  }, i = ae(e, t), s = new O(), c = new O();
+  s.setDomain(0, 1e6), c.setDomain(-1, 1), s.setRange(i.x, i.x + i.width), c.setRange(i.y + i.height, i.y);
+  const f = new Pe(l, d), { avg: w, p95: v } = se(() => {
+    l.clearRect(0, 0, e, t), f.drawGrid(i, s, c, { tickCount: r }, { tickCount: a });
+  }, o), { xLines: p, yLines: S } = ie(i, s, c, r, a);
+  return {
+    backend: "canvas2d",
+    dpr: n.dpr ?? 1,
+    width: e,
+    height: t,
+    xTicks: r,
+    yTicks: a,
+    lineSegments: p.length + S.length,
+    avgFrameUs: Math.round(w),
+    p95FrameUs: Math.round(v),
+    frames: o
   };
 }
-class Ae {
+function Ne(n = {}) {
+  const e = Math.round((n.width ?? 1920) * (n.dpr ?? 1)), t = Math.round((n.height ?? 1080) * (n.dpr ?? 1)), r = n.xTickCount ?? 24, a = n.yTickCount ?? 16, o = n.frames ?? 120, l = document.createElement("canvas");
+  l.width = e, l.height = t;
+  let d;
+  try {
+    d = new Ue(l);
+  } catch {
+    return null;
+  }
+  const i = ae(e, t), s = new O(), c = new O();
+  s.setDomain(0, 1e6), c.setDomain(-1, 1), s.setRange(i.x, i.x + i.width), c.setRange(i.y + i.height, i.y);
+  const { xLines: f, yLines: w } = ie(i, s, c, r, a), v = { plotArea: i, xLines: f, yLines: w, width: e, height: t };
+  let p = 0;
+  const { avg: S, p95: b } = se(() => {
+    p = d.draw(v);
+  }, o);
+  return d.destroy(), {
+    backend: "webgl",
+    dpr: n.dpr ?? 1,
+    width: e,
+    height: t,
+    xTicks: r,
+    yTicks: a,
+    lineSegments: p,
+    avgFrameUs: Math.round(S),
+    p95FrameUs: Math.round(b),
+    frames: o
+  };
+}
+function dt(n) {
+  const e = (n == null ? void 0 : n.dpr) ?? 2, t = (n == null ? void 0 : n.frames) ?? 120, r = He({ dpr: e, frames: t, showMinor: !0 }), a = Ne({ dpr: e, frames: t });
+  if (!a)
+    return {
+      canvas2d: r,
+      webgl: null,
+      gainPercent: 0,
+      recommendation: "defer"
+    };
+  const o = (r.avgFrameUs - a.avgFrameUs) / r.avgFrameUs * 100;
+  return {
+    canvas2d: r,
+    webgl: a,
+    gainPercent: Math.round(o * 10) / 10,
+    recommendation: o >= 20 ? "implement" : "defer"
+  };
+}
+const qe = "1.17.0", Ve = "2026-07-05", Ke = "Stage 1 baselines. Headless CI uses effective FPS (render throughput when rAF throttled) via scripts/benchmark-scenario-eval.mjs smoke floors.", je = 0.1, Je = 0.95, Qe = {
+  "line-1m-pan": {
+    minAvgFps: 50,
+    maxAvgFrameTimeMs: 20,
+    points: 1e6,
+    description: "1M line points, continuous pan/zoom simulation"
+  },
+  "candlestick-500k": {
+    minAvgFps: 45,
+    maxAvgFrameTimeMs: 22,
+    points: 5e5,
+    description: "500k OHLC bars with PluginVirtualization"
+  },
+  "stack-5pane-resize": {
+    minAvgFps: 48,
+    maxAvgFrameTimeMs: 21,
+    description: "5-pane stack divider drag (batched overlay redraw)"
+  },
+  "line-200k-webgl": {
+    minAvgFps: 45,
+    description: "200k line WebGL baseline for renderer compare"
+  },
+  "line-200k-webgpu": {
+    minAvgFps: 42,
+    description: "200k line WebGPU — target ≥95% of WebGL FPS"
+  },
+  "boxplot-5k-webgpu": {
+    minAvgFps: 50,
+    description: "5k boxplot series on WebGPU chart path"
+  },
+  "grid-canvas2d-dpr2": {
+    maxAvgFrameUs: 1200,
+    dpr: 2,
+    description: "Canvas 2D grid+minor at 1920×1080 @2x"
+  },
+  "grid-webgl-dpr2": {
+    maxAvgFrameUs: 400,
+    dpr: 2,
+    description: "WebGL grid spike lines only @2x"
+  }
+}, V = {
+  version: qe,
+  recordedAt: Ve,
+  notes: Ke,
+  regressionThreshold: je,
+  webgpuMinFpsRatio: Je,
+  scenarios: Qe
+};
+function ut() {
+  return V;
+}
+function ft(n, e) {
+  const t = V.scenarios[n];
+  if (!t)
+    return { passed: !0, failures: [] };
+  const r = [], a = V.regressionThreshold ?? 0.1;
+  if ("avgFps" in e && t.minAvgFps !== void 0) {
+    const o = t.minAvgFps * (1 - a);
+    e.avgFps < o && r.push(
+      `FPS ${e.avgFps} < baseline min ${t.minAvgFps} (allowed ${o.toFixed(1)} with ${a * 100}% slack)`
+    );
+  }
+  if ("avgFrameTime" in e && t.maxAvgFrameTimeMs !== void 0) {
+    const o = t.maxAvgFrameTimeMs * (1 + a);
+    e.avgFrameTime > o && r.push(
+      `Frame time ${e.avgFrameTime}ms > baseline max ${t.maxAvgFrameTimeMs}ms`
+    );
+  }
+  if ("avgFrameUs" in e && t.maxAvgFrameUs !== void 0) {
+    const o = t.maxAvgFrameUs * (1 + a);
+    e.avgFrameUs > o && r.push(
+      `Grid frame ${e.avgFrameUs}µs > baseline max ${t.maxAvgFrameUs}µs`
+    );
+  }
+  return { passed: r.length === 0, failures: r };
+}
+function ht(n, e, t, r = 0.95) {
+  if (!t || !e)
+    return {
+      webgl: n,
+      webgpu: e,
+      webgpuActive: !1,
+      fpsRatio: 0,
+      meetsTarget: !1,
+      recommendation: "webgpu-unavailable"
+    };
+  const a = n.avgFps > 0 ? e.avgFps / n.avgFps : 0, o = a >= r;
+  return {
+    webgl: n,
+    webgpu: e,
+    webgpuActive: !0,
+    fpsRatio: a,
+    meetsTarget: o,
+    recommendation: o ? "webgpu-ready" : "webgl-faster"
+  };
+}
+class Ze {
   constructor(e) {
-    _(this, "seed");
+    X(this, "seed");
     this.seed = e;
   }
   next() {
@@ -724,7 +1199,7 @@ class Ae {
     return e + this.next() * (t - e);
   }
 }
-function Xe(r) {
+function gt(n) {
   const e = {
     pointCount: 1e3,
     amplitude: 1,
@@ -734,16 +1209,16 @@ function Xe(r) {
     xStart: 0,
     xEnd: 10,
     offset: 0,
-    ...r
-  }, t = new Float32Array(e.pointCount), s = new Float32Array(e.pointCount), o = (e.xEnd - e.xStart) / (e.pointCount - 1);
-  for (let n = 0; n < e.pointCount; n++) {
-    t[n] = e.xStart + n * o;
-    const u = e.amplitude * Math.sin(2 * Math.PI * e.frequency * t[n] + e.phase), c = e.noise > 0 ? (Math.random() - 0.5) * 2 * e.noise : 0;
-    s[n] = u + c + e.offset;
+    ...n
+  }, t = new Float32Array(e.pointCount), r = new Float32Array(e.pointCount), a = (e.xEnd - e.xStart) / (e.pointCount - 1);
+  for (let o = 0; o < e.pointCount; o++) {
+    t[o] = e.xStart + o * a;
+    const l = e.amplitude * Math.sin(2 * Math.PI * e.frequency * t[o] + e.phase), d = e.noise > 0 ? (Math.random() - 0.5) * 2 * e.noise : 0;
+    r[o] = l + d + e.offset;
   }
-  return { x: t, y: s };
+  return { x: t, y: r };
 }
-function Ye(r) {
+function pt(n) {
   const e = {
     pointCount: 1e3,
     amplitude: 1,
@@ -753,16 +1228,16 @@ function Ye(r) {
     xStart: 0,
     xEnd: 10,
     offset: 0,
-    ...r
-  }, t = new Float32Array(e.pointCount), s = new Float32Array(e.pointCount), o = (e.xEnd - e.xStart) / (e.pointCount - 1);
-  for (let n = 0; n < e.pointCount; n++) {
-    t[n] = e.xStart + n * o;
-    const u = t[n] * e.frequency + e.phase / (2 * Math.PI), c = Math.sign(Math.sin(2 * Math.PI * u)) * e.amplitude, i = e.noise > 0 ? (Math.random() - 0.5) * 2 * e.noise : 0;
-    s[n] = c + i + e.offset;
+    ...n
+  }, t = new Float32Array(e.pointCount), r = new Float32Array(e.pointCount), a = (e.xEnd - e.xStart) / (e.pointCount - 1);
+  for (let o = 0; o < e.pointCount; o++) {
+    t[o] = e.xStart + o * a;
+    const l = t[o] * e.frequency + e.phase / (2 * Math.PI), d = Math.sign(Math.sin(2 * Math.PI * l)) * e.amplitude, i = e.noise > 0 ? (Math.random() - 0.5) * 2 * e.noise : 0;
+    r[o] = d + i + e.offset;
   }
-  return { x: t, y: s };
+  return { x: t, y: r };
 }
-function ke(r) {
+function mt(n) {
   const e = {
     pointCount: 1e3,
     amplitude: 1,
@@ -772,16 +1247,16 @@ function ke(r) {
     xStart: 0,
     xEnd: 10,
     offset: 0,
-    ...r
-  }, t = new Float32Array(e.pointCount), s = new Float32Array(e.pointCount), o = (e.xEnd - e.xStart) / (e.pointCount - 1);
-  for (let n = 0; n < e.pointCount; n++) {
-    t[n] = e.xStart + n * o;
-    const u = t[n] * e.frequency + e.phase / (2 * Math.PI), c = e.amplitude * 2 * (u - Math.floor(u + 0.5)), i = e.noise > 0 ? (Math.random() - 0.5) * 2 * e.noise : 0;
-    s[n] = c + i + e.offset;
+    ...n
+  }, t = new Float32Array(e.pointCount), r = new Float32Array(e.pointCount), a = (e.xEnd - e.xStart) / (e.pointCount - 1);
+  for (let o = 0; o < e.pointCount; o++) {
+    t[o] = e.xStart + o * a;
+    const l = t[o] * e.frequency + e.phase / (2 * Math.PI), d = e.amplitude * 2 * (l - Math.floor(l + 0.5)), i = e.noise > 0 ? (Math.random() - 0.5) * 2 * e.noise : 0;
+    r[o] = d + i + e.offset;
   }
-  return { x: t, y: s };
+  return { x: t, y: r };
 }
-function ze(r) {
+function yt(n) {
   const e = {
     pointCount: 1e3,
     amplitude: 1,
@@ -791,37 +1266,37 @@ function ze(r) {
     xStart: 0,
     xEnd: 10,
     offset: 0,
-    ...r
-  }, t = new Float32Array(e.pointCount), s = new Float32Array(e.pointCount), o = (e.xEnd - e.xStart) / (e.pointCount - 1);
-  for (let n = 0; n < e.pointCount; n++) {
-    t[n] = e.xStart + n * o;
-    const u = t[n] * e.frequency + e.phase / (2 * Math.PI), c = e.amplitude * 2 * Math.abs(2 * (u - Math.floor(u + 0.5))) - e.amplitude, i = e.noise > 0 ? (Math.random() - 0.5) * 2 * e.noise : 0;
-    s[n] = c + i + e.offset;
+    ...n
+  }, t = new Float32Array(e.pointCount), r = new Float32Array(e.pointCount), a = (e.xEnd - e.xStart) / (e.pointCount - 1);
+  for (let o = 0; o < e.pointCount; o++) {
+    t[o] = e.xStart + o * a;
+    const l = t[o] * e.frequency + e.phase / (2 * Math.PI), d = e.amplitude * 2 * Math.abs(2 * (l - Math.floor(l + 0.5))) - e.amplitude, i = e.noise > 0 ? (Math.random() - 0.5) * 2 * e.noise : 0;
+    r[o] = d + i + e.offset;
   }
-  return { x: t, y: s };
+  return { x: t, y: r };
 }
-function _e(r) {
+function xt(n) {
   const e = {
     pointCount: 1e3,
     xRange: [0, 100],
     yRange: [-1, 1],
     sorted: !0,
     seed: Date.now(),
-    ...r
-  }, t = new Ae(e.seed), s = new Float32Array(e.pointCount), o = new Float32Array(e.pointCount);
-  for (let n = 0; n < e.pointCount; n++)
-    s[n] = t.nextRange(e.xRange[0], e.xRange[1]), o[n] = t.nextRange(e.yRange[0], e.yRange[1]);
+    ...n
+  }, t = new Ze(e.seed), r = new Float32Array(e.pointCount), a = new Float32Array(e.pointCount);
+  for (let o = 0; o < e.pointCount; o++)
+    r[o] = t.nextRange(e.xRange[0], e.xRange[1]), a[o] = t.nextRange(e.yRange[0], e.yRange[1]);
   if (e.sorted) {
-    const n = Array.from({ length: e.pointCount }, (i, l) => l);
-    n.sort((i, l) => s[i] - s[l]);
-    const u = new Float32Array(e.pointCount), c = new Float32Array(e.pointCount);
+    const o = Array.from({ length: e.pointCount }, (i, s) => s);
+    o.sort((i, s) => r[i] - r[s]);
+    const l = new Float32Array(e.pointCount), d = new Float32Array(e.pointCount);
     for (let i = 0; i < e.pointCount; i++)
-      u[i] = s[n[i]], c[i] = o[n[i]];
-    return { x: u, y: c };
+      l[i] = r[o[i]], d[i] = a[o[i]];
+    return { x: l, y: d };
   }
-  return { x: s, y: o };
+  return { x: r, y: a };
 }
-function Oe(r) {
+function vt(n) {
   const e = {
     pointCount: 2e3,
     vMin: -0.5,
@@ -830,18 +1305,18 @@ function Oe(r) {
     peakCurrent: 1e-5,
     // 10 µA
     noise: 0.02,
-    ...r
-  }, t = e.pointCount * e.cycles, s = new Float32Array(t), o = new Float32Array(t), n = e.pointCount, u = n / 2;
-  for (let c = 0; c < e.cycles; c++)
-    for (let i = 0; i < n; i++) {
-      const l = c * n + i;
-      i < u ? s[l] = e.vMin + (e.vMax - e.vMin) * (i / u) : s[l] = e.vMax - (e.vMax - e.vMin) * ((i - u) / u);
-      const f = s[l], y = 0, b = i < u ? 1 : -1, v = 0.1, p = -Math.pow(f - y, 2) / (2 * v * v), S = e.peakCurrent * Math.exp(p), C = b * e.peakCurrent * 0.1, g = (Math.random() - 0.5) * 2 * e.noise * e.peakCurrent;
-      o[l] = b * S + C + g;
+    ...n
+  }, t = e.pointCount * e.cycles, r = new Float32Array(t), a = new Float32Array(t), o = e.pointCount, l = o / 2;
+  for (let d = 0; d < e.cycles; d++)
+    for (let i = 0; i < o; i++) {
+      const s = d * o + i;
+      i < l ? r[s] = e.vMin + (e.vMax - e.vMin) * (i / l) : r[s] = e.vMax - (e.vMax - e.vMin) * ((i - l) / l);
+      const c = r[s], f = 0, w = i < l ? 1 : -1, v = 0.1, p = -Math.pow(c - f, 2) / (2 * v * v), S = e.peakCurrent * Math.exp(p), b = w * e.peakCurrent * 0.1, g = (Math.random() - 0.5) * 2 * e.noise * e.peakCurrent;
+      a[s] = w * S + b + g;
     }
-  return { x: s, y: o };
+  return { x: r, y: a };
 }
-function $e(r) {
+function wt(n) {
   const e = {
     pointCount: 50,
     rSolution: 100,
@@ -849,380 +1324,438 @@ function $e(r) {
     rCharge: 1e3,
     // Ohms
     frequency: [1e5, 0.01],
-    ...r
-  }, t = new Float32Array(e.pointCount), s = new Float32Array(e.pointCount), o = Math.log10(e.frequency[1]), n = Math.log10(e.frequency[0]);
-  for (let u = 0; u < e.pointCount; u++) {
-    const c = n - (n - o) * (u / (e.pointCount - 1)), i = 2 * Math.PI * Math.pow(10, c), l = e.rCharge * 1e-5, f = e.rSolution + e.rCharge / (1 + Math.pow(i * l, 2)), y = i * l * e.rCharge / (1 + Math.pow(i * l, 2));
-    t[u] = f, s[u] = -y;
+    ...n
+  }, t = new Float32Array(e.pointCount), r = new Float32Array(e.pointCount), a = Math.log10(e.frequency[1]), o = Math.log10(e.frequency[0]);
+  for (let l = 0; l < e.pointCount; l++) {
+    const d = o - (o - a) * (l / (e.pointCount - 1)), i = 2 * Math.PI * Math.pow(10, d), s = e.rCharge * 1e-5, c = e.rSolution + e.rCharge / (1 + Math.pow(i * s, 2)), f = i * s * e.rCharge / (1 + Math.pow(i * s, 2));
+    t[l] = c, r[l] = -f;
   }
-  return { x: t, y: s };
+  return { x: t, y: r };
 }
-async function Be(r, e) {
+async function Pt(n, e) {
   const t = {
     duration: 5e3,
     warmup: 1e3,
     ...e
-  }, s = [], o = [];
-  let n = 0, u = performance.now();
-  const c = r.getAllSeries().reduce((i, l) => i + l.getPointCount(), 0);
-  return new Promise((i) => {
-    const l = performance.now() + t.warmup + t.duration, f = performance.now() + t.warmup;
-    let y = !1;
-    function b() {
+  }, r = [], a = [];
+  let o = 0;
+  const l = n.getAllSeries().reduce((d, i) => d + i.getPointCount(), 0);
+  return new Promise((d) => {
+    const i = performance.now() + t.warmup + t.duration, s = performance.now() + t.warmup;
+    let c = !1, f = 0;
+    function w() {
       const v = performance.now();
-      if (v >= l) {
-        const p = s.reduce((d, a) => d + a, 0) / s.length, S = Math.min(...s), C = Math.max(...s), g = o.reduce((d, a) => d + a, 0) / o.length, m = {
-          avgFps: Math.round(p * 100) / 100,
-          minFps: S,
-          maxFps: C,
-          avgFrameTime: Math.round(g * 100) / 100,
-          frameCount: n,
+      if (v >= i) {
+        const b = a.length > 0 ? a.reduce((P, x) => P + x, 0) / a.length : 0, g = f > 0 ? v - f : t.duration, y = o > 0 && g > 0 ? o / g * 1e3 : 0, h = r.length > 0 ? r.reduce((P, x) => P + x, 0) / r.length : b > 0 ? 1e3 / b : 0, u = {
+          avgFps: Math.round(y * 100) / 100,
+          minFps: Math.round((r.length > 0 ? Math.min(...r) : y) * 100) / 100,
+          maxFps: Math.round((r.length > 0 ? Math.max(...r) : y) * 100) / 100,
+          avgFrameTime: Math.round(b * 1e3) / 1e3,
+          frameCount: o,
           duration: t.duration,
-          pointsRendered: c,
-          throughput: Math.round(c * p / 1e3) * 1e3
+          pointsRendered: l,
+          throughput: Math.round(l * y / 1e3) * 1e3,
+          /** @internal render-only FPS (not wall clock) */
+          ...h > 0 ? { renderFps: Math.round(h * 100) / 100 } : {}
         };
-        i(m);
+        d(u);
         return;
       }
-      if (v >= f && !y && (y = !0, u = v, n = 0), r.render(), y) {
-        const p = v - u;
-        o.push(p), n++;
-        const S = o.slice(-30);
-        if (S.length > 0) {
-          const C = S.reduce((g, m) => g + m, 0) / S.length;
-          s.push(1e3 / C);
+      v >= s && !c && (c = !0, f = v, o = 0, a.length = 0, r.length = 0);
+      const p = performance.now();
+      n.render();
+      const S = performance.now();
+      if (c) {
+        const b = S - p;
+        a.push(b), o++;
+        const g = a.slice(-30);
+        if (g.length > 0) {
+          const y = g.reduce((h, u) => h + u, 0) / g.length;
+          y > 0 && r.push(1e3 / y);
         }
       }
-      u = v, requestAnimationFrame(b);
+      requestAnimationFrame(w);
     }
-    requestAnimationFrame(b);
+    requestAnimationFrame(w);
   });
 }
-function He(r, e) {
+function St(n, e) {
   const t = {
     format: "json",
     includeStyles: !0,
     ...e
-  }, s = r.getAllSeries().map((n) => ({
-    id: n.getId(),
-    type: n.getType(),
-    pointCount: n.getPointCount(),
-    ...t.includeStyles ? { style: n.getStyle() } : {}
-  })), o = {
+  }, r = n.getAllSeries().map((o) => ({
+    id: o.getId(),
+    type: o.getType(),
+    pointCount: o.getPointCount(),
+    ...t.includeStyles ? { style: o.getStyle() } : {}
+  })), a = {
     timestamp: Date.now(),
     config: {},
-    series: s,
-    bounds: r.getViewBounds()
+    series: r,
+    bounds: n.getViewBounds()
   };
-  return t.format === "png" && r.exportImage && (o.image = r.exportImage()), o;
+  return t.format === "png" && n.exportImage && (a.image = n.exportImage()), a;
 }
-function qe(r, e, t = 1e-6) {
-  const s = [];
-  r.series.length !== e.series.length && s.push(`Series count: ${r.series.length} vs ${e.series.length}`);
-  for (let n = 0; n < Math.min(r.series.length, e.series.length); n++) {
-    const u = r.series[n], c = e.series[n];
-    u.id !== c.id && s.push(`Series[${n}] id: "${u.id}" vs "${c.id}"`), u.type !== c.type && s.push(`Series[${n}] type: "${u.type}" vs "${c.type}"`), u.pointCount !== c.pointCount && s.push(`Series[${n}] pointCount: ${u.pointCount} vs ${c.pointCount}`);
+function Tt(n, e, t = 1e-6) {
+  const r = [];
+  n.series.length !== e.series.length && r.push(`Series count: ${n.series.length} vs ${e.series.length}`);
+  for (let o = 0; o < Math.min(n.series.length, e.series.length); o++) {
+    const l = n.series[o], d = e.series[o];
+    l.id !== d.id && r.push(`Series[${o}] id: "${l.id}" vs "${d.id}"`), l.type !== d.type && r.push(`Series[${o}] type: "${l.type}" vs "${d.type}"`), l.pointCount !== d.pointCount && r.push(`Series[${o}] pointCount: ${l.pointCount} vs ${d.pointCount}`);
   }
-  const o = ["xMin", "xMax", "yMin", "yMax"];
-  for (const n of o)
-    Math.abs(r.bounds[n] - e.bounds[n]) > t && s.push(`Bounds.${n}: ${r.bounds[n]} vs ${e.bounds[n]}`);
+  const a = ["xMin", "xMax", "yMin", "yMax"];
+  for (const o of a)
+    Math.abs(n.bounds[o] - e.bounds[o]) > t && r.push(`Bounds.${o}: ${n.bounds[o]} vs ${e.bounds[o]}`);
   return {
-    equal: s.length === 0,
-    differences: s
+    equal: r.length === 0,
+    differences: r
   };
 }
-function We(r, e) {
+function bt(n, e) {
   const t = [];
-  return e.minFps && r.avgFps < e.minFps && t.push(`FPS ${r.avgFps} < required ${e.minFps}`), e.maxFrameTime && r.avgFrameTime > e.maxFrameTime && t.push(`Frame time ${r.avgFrameTime}ms > required ${e.maxFrameTime}ms`), e.minThroughput && r.throughput < e.minThroughput && t.push(`Throughput ${r.throughput} < required ${e.minThroughput}`), {
+  return e.minFps && n.avgFps < e.minFps && t.push(`FPS ${n.avgFps} < required ${e.minFps}`), e.maxFrameTime && n.avgFrameTime > e.maxFrameTime && t.push(`Frame time ${n.avgFrameTime}ms > required ${e.maxFrameTime}ms`), e.minThroughput && n.throughput < e.minThroughput && t.push(`Throughput ${n.throughput} < required ${e.minThroughput}`), {
     passed: t.length === 0,
     failures: t
   };
 }
-function Ge(r = 1) {
+function At(n = 1) {
   return new Promise((e) => {
-    let t = r;
-    function s() {
-      t--, t <= 0 ? e() : requestAnimationFrame(s);
+    let t = n;
+    function r() {
+      t--, t <= 0 ? e() : requestAnimationFrame(r);
     }
-    requestAnimationFrame(s);
+    requestAnimationFrame(r);
   });
 }
-function Ne(r) {
-  return new Promise((e) => setTimeout(e, r));
+function Mt(n) {
+  return new Promise((e) => setTimeout(e, n));
 }
-function Ve(r) {
-  const t = {
-    id: r.seriesId ?? `${r.id}-indicator`,
-    data: r.data,
-    style: r.style,
-    name: r.label
-  }, s = fe(t);
+const oe = 864e5;
+function et(n) {
+  return new Date(n).getUTCDay();
+}
+function tt(n, e = {}) {
+  const t = et(n);
+  return t !== 0 && t !== 6;
+}
+function Ft(n, e = {}) {
+  const t = e.calendar ?? "business-day", r = n.length, a = new Float32Array(r), o = new Int32Array(r);
+  if (o.fill(-1), t === "continuous") {
+    for (let i = 0; i < r; i++)
+      a[i] = n[i], o[i] = i;
+    return {
+      scaledX: a,
+      timeByIndex: n instanceof Float32Array ? n : Float32Array.from(n),
+      sourceToScaled: o
+    };
+  }
+  const l = [];
+  let d = 0;
+  for (let i = 0; i < r; i++) {
+    const s = n[i];
+    if (!Number.isFinite(s) || !tt(s, e)) {
+      a[i] = Number.NaN;
+      continue;
+    }
+    a[i] = d, l[d] = s, o[i] = d, d++;
+  }
   return {
-    id: r.id,
-    height: r.height ?? 0.25,
-    showXAxis: r.showXAxis,
-    yRange: r.yRange,
-    chart: {
-      yAxis: {
-        label: r.label ?? "Indicator",
-        auto: r.yRange === void 0 || r.yRange === "auto",
-        tickCount: r.tickCount ?? 5,
-        scientific: !1
-      },
-      xAxis: { showLabels: !1, showTicks: !1, showLine: !1 },
-      animations: !1,
-      loading: !1,
-      showLegend: !1
-    },
-    series: s
+    scaledX: a,
+    timeByIndex: Float32Array.from(l),
+    sourceToScaled: o
   };
 }
+function Ct(n, e, t) {
+  const r = Math.max(0, Math.floor(e)), a = Math.min(n.timeByIndex.length - 1, Math.ceil(t)), o = n.timeByIndex[r], l = n.timeByIndex[a];
+  return o == null || l == null ? oe : Math.abs(l - o) || oe;
+}
+function It(n) {
+  const e = n.close.length, t = new Float32Array(e), r = new Float32Array(e), a = new Float32Array(e), o = new Float32Array(e);
+  for (let l = 0; l < e; l++) {
+    const d = n.open[l], i = n.high[l], s = n.low[l], c = n.close[l];
+    o[l] = (d + i + s + c) / 4, t[l] = l === 0 ? (d + c) / 2 : (t[l - 1] + o[l - 1]) / 2, r[l] = Math.max(i, t[l], o[l]), a[l] = Math.min(s, t[l], o[l]);
+  }
+  return { open: t, high: r, low: a, close: o };
+}
 export {
-  je as AnimationEngine,
-  Bt as AnnotationManager,
-  fa as BackpressureManager,
-  Da as BaseBufferStore,
-  Ea as BaseTextureStore,
-  Le as BuiltinPlugins,
-  Co as ChartGroup,
-  Je as ChartInitQueue,
-  ga as CircularBuffer,
-  so as ClipboardManager,
-  pe as CrosshairPlugin,
-  Qe as DARK_THEME,
-  Ze as DEFAULT_ANIMATION_CONFIG,
-  to as DEFAULT_KEY_BINDINGS,
-  et as DEFAULT_LAYOUT,
-  tt as DEFAULT_THEME,
-  Te as DataLoggerPlugin,
-  po as DebugOverlay,
-  be as DirectionIndicatorPlugin,
-  nt as ELECTROCHEM_THEME,
-  Ot as EventEmitter,
-  Fa as GpuBenchmark,
-  La as GpuCompute,
-  Ra as GpuRenderer,
-  Pe as GridHighlightPlugin,
-  no as KeyBindingManager,
-  at as LIGHT_THEME,
-  Ha as LOCALE_DE_DE,
-  qa as LOCALE_EN_US,
-  Wa as LOCALE_ES_ES,
-  Ga as LOCALE_FR_FR,
-  Na as LOCALE_JA_JP,
-  Va as LOCALE_PT_BR,
-  Ua as LOCALE_ZH_CN,
-  ot as LinearScale,
-  vo as LoadingIndicator,
-  rt as LogScale,
-  it as MIDNIGHT_THEME,
-  st as NativeWebGLRenderer,
-  lt as OverlayRenderer,
-  Xa as PipelineCache,
-  nr as Plugin3D,
-  fn as PluginAnalysis,
-  Ht as PluginAnnotations,
-  fr as PluginAnomalyDetection,
-  Lr as PluginBrokenAxis,
-  Ir as PluginCaching,
-  lo as PluginClipboard,
-  dr as PluginContextMenu,
-  lr as PluginDataExport,
-  br as PluginDataTransform,
-  ho as PluginDebug,
-  Re as PluginDragEdit,
-  $r as PluginForecasting,
-  Ya as PluginGpu,
-  or as PluginI18n,
-  ao as PluginKeyboard,
-  Mr as PluginLaTeX,
-  Er as PluginLazyLoad,
-  Po as PluginLoading,
-  pr as PluginMLIntegration,
-  ct as PluginManagerImpl,
-  kr as PluginOffscreen,
-  mr as PluginPatternRecognition,
-  _r as PluginROI,
-  Pr as PluginRadar,
-  xr as PluginRegression,
-  Tr as PluginSnapshot,
-  pa as PluginStreaming,
-  ir as PluginSync,
-  Eo as PluginThemeEditor,
-  tn as PluginTools,
-  Xr as PluginVideoRecorder,
-  sn as PluginVirtualization,
-  dt as SERIALIZATION_VERSION,
-  wa as STACKED_DEFAULT_MIN_PANE_RATIO,
-  ba as STACKED_MAX_PANES,
-  Ca as SciPlot,
-  ut as Series,
-  ka as SeriesAdapter,
-  ft as StateHistory,
-  me as StatsPlugin,
-  Fo as THEME_PRESETS,
-  nn as TOOLTIP_THEMES,
-  Lo as ThemeEditor,
-  an as TooltipManager,
-  xe as WatermarkPlugin,
-  za as WebGLBackend,
-  _a as WebGPUBackend,
-  Q as WebGPURenderer,
-  gn as adx,
-  pn as analyzeComplexSpectrum,
-  hn as analyzeSpectrum,
-  mn as aroon,
-  yn as arraysToComplex,
-  We as assertPerformance,
-  xn as atr,
-  vn as autoCorrelation,
-  Pn as bandPassFilter,
-  Sn as bandStopFilter,
-  Be as benchmarkRender,
-  Tn as blackmanWindow,
-  wn as bollingerBands,
-  Ve as buildIndicatorPane,
-  fe as buildIndicatorSeries,
-  bn as butterworth,
-  jo as calculateR2,
-  zo as calculateStats,
-  ln as calculateTargetPoints,
-  Wt as checkPluginCompatibility,
-  qe as compareSnapshots,
-  Cn as complexToArrays,
-  gt as compressString,
-  ha as connectStreamToChart,
-  co as copyToClipboard,
-  ma as createBackpressureManager,
-  pt as createChart,
-  Mo as createChartGroup,
-  Gt as createConfigurablePlugin,
-  mo as createDebugOverlay,
-  Oa as createGpuRenderer,
-  ht as createIndicatorSeries,
-  oo as createKeyBinding,
-  So as createLoadingIndicator,
-  Ka as createLocaleFormatter,
-  ya as createLosslessBackpressure,
-  Ao as createMasterSlave,
-  xa as createMessageParser,
-  va as createMockStream,
-  mt as createNativeRenderer,
-  Nt as createPlugin,
-  yt as createPluginContext,
-  Pa as createRealtimeBackpressure,
-  Vt as createRenderer,
-  xt as createScale,
-  He as createSnapshot,
-  Ma as createStackedChart,
-  vt as createTheme,
-  Ro as createThemeEditor,
-  Sa as createWebSocketStream,
-  Mn as crossCorrelation,
-  An as cumsum,
-  Jo as cumulativeIntegral,
-  Pt as decodeFloat32Array,
-  St as decompressString,
-  Ut as defineAndRegister,
-  O as definePlugin,
-  In as dema,
-  Qo as derivative,
-  Dn as detectAnomalies,
-  _o as detectCycles,
-  Tt as detectIndicatorMarkers,
-  Oo as detectPeaks,
-  En as dominantFrequency,
-  $o as downsampleLTTB,
-  wt as easings,
-  Fn as ema,
-  yo as enableDebugMode,
-  bt as encodeFloat32Array,
-  Ln as exponentialMovingAverage,
-  Rn as fft,
-  Xn as fftFromComplexInput,
-  uo as formatData,
-  Bo as formatScientific,
-  Ho as formatValue,
-  qo as formatWithPrefix,
-  Yn as gaussianSmooth,
-  Oe as generateCVData,
-  Wo as generateCycleColors,
-  $e as generateNyquistData,
-  _e as generateRandomData,
-  ke as generateSawtoothWave,
-  Xe as generateSineWave,
-  Ye as generateSquareWave,
-  ze as generateTriangleWave,
-  Go as getBestPrefix,
-  Ct as getChartInitQueue,
-  fo as getClipboardManager,
-  ja as getGlobalLocale,
-  Ja as getLocale,
-  Kt as getPluginRegistry,
-  kn as getPositiveFrequencies,
-  Xo as getPresetNames,
-  Yo as getPresetTheme,
-  Mt as getSharedAnimationEngine,
-  At as getThemeByName,
-  on as getTooltipThemeForChartTheme,
-  zn as hammingWindow,
-  _n as hanningWindow,
-  On as highPassFilter,
-  $n as ifft,
-  Bn as ifftComplex,
-  Hn as ifftFromArrays,
-  Zo as integrate,
-  It as interleaveData,
-  Io as linkCharts,
-  jt as listPluginsByCategory,
-  Jt as loadPlugin,
-  qn as lowPassFilter,
-  cn as lttbDownsample,
-  Wn as macd,
-  Gn as medianFilter,
-  Dt as mergeAnimationConfig,
-  Et as mergeLayoutOptions,
-  dn as minMaxDownsample,
-  Nn as momentum,
-  No as movingAverage,
-  Vn as nextPowerOf2,
-  Un as normalize,
-  Kn as obv,
-  Ft as parseColor,
-  $a as parseColorToRGBA,
-  ro as parseShortcut,
-  jn as percentChange,
-  Jn as powerSpectrum,
-  Lt as queueChartInit,
-  Qa as registerLocale,
-  Qt as registerPlugin,
-  Rt as resetChartQueue,
-  Qn as roc,
-  Zn as rsi,
-  ea as savitzkyGolay,
-  Za as setGlobalLocale,
-  To as showLoading,
-  wo as showProgress,
-  ta as simpsonsIntegration,
-  na as singleFrequencyFilter,
-  aa as sma,
-  er as solveLinearSystem,
-  oa as standardDeviation,
-  Xt as stateToUrlHash,
-  ra as stochastic,
-  Vo as subtractBaseline,
-  ia as tTest,
-  sa as tema,
-  la as trapezoidalIntegration,
-  Yt as urlHashToState,
-  Aa as useSciPlot,
-  kt as validateChartState,
-  Uo as validateData,
-  Zt as validateManifest,
-  ca as vwap,
-  Ne as waitFor,
-  zt as waitForAnimations,
-  Ge as waitForFrames,
-  da as wma
+  Et as AnimationEngine,
+  Ln as AnnotationManager,
+  nr as BackpressureManager,
+  vr as BaseBufferStore,
+  wr as BaseTextureStore,
+  it as BuiltinPlugins,
+  la as ChartGroup,
+  Lt as ChartInitQueue,
+  or as CircularBuffer,
+  Hr as ClipboardManager,
+  Te as CrosshairPlugin,
+  ee as DARK_THEME,
+  Rt as DEFAULT_ANIMATION_CONFIG,
+  zr as DEFAULT_KEY_BINDINGS,
+  Yt as DEFAULT_LAYOUT,
+  Xt as DEFAULT_THEME,
+  ke as DataLoggerPlugin,
+  Jr as DebugOverlay,
+  Le as DirectionIndicatorPlugin,
+  Bt as ELECTROCHEM_THEME,
+  kn as EventEmitter,
+  Pr as GpuBenchmark,
+  Sr as GpuCompute,
+  qn as GpuRenderer,
+  Ie as GridHighlightPlugin,
+  Wr as KeyBindingManager,
+  _t as LIGHT_THEME,
+  Mr as LOCALE_DE_DE,
+  Fr as LOCALE_EN_US,
+  Cr as LOCALE_ES_ES,
+  Ir as LOCALE_FR_FR,
+  Dr as LOCALE_JA_JP,
+  kr as LOCALE_PT_BR,
+  Er as LOCALE_ZH_CN,
+  O as LinearScale,
+  na as LoadingIndicator,
+  zt as LogScale,
+  Wt as MIDNIGHT_THEME,
+  Gt as NativeWebGLRenderer,
+  Pe as OverlayRenderer,
+  Tr as PipelineCache,
+  ii as Plugin3D,
+  So as PluginAnalysis,
+  Rn as PluginAnnotations,
+  mi as PluginAnomalyDetection,
+  Xi as PluginBrokenAxis,
+  Ei as PluginCaching,
+  Nr as PluginClipboard,
+  gi as PluginContextMenu,
+  fi as PluginDataExport,
+  Ci as PluginDataTransform,
+  Qr as PluginDebug,
+  st as PluginDragEdit,
+  lt as PluginDrawingTools,
+  Oi as PluginForecasting,
+  br as PluginGpu,
+  li as PluginI18n,
+  Gr as PluginKeyboard,
+  Di as PluginLaTeX,
+  Ri as PluginLazyLoad,
+  oa as PluginLoading,
+  xi as PluginMLIntegration,
+  Ut as PluginManagerImpl,
+  Wi as PluginOffscreen,
+  wi as PluginPatternRecognition,
+  Ui as PluginROI,
+  bi as PluginRadar,
+  Si as PluginRegression,
+  ct as PluginReplay,
+  Mi as PluginSnapshot,
+  rr as PluginStreaming,
+  di as PluginSync,
+  ha as PluginThemeEditor,
+  eo as PluginTools,
+  _i as PluginVideoRecorder,
+  ao as PluginVirtualization,
+  $t as SERIALIZATION_VERSION,
+  hr as STACKED_DEFAULT_MIN_PANE_RATIO,
+  gr as STACKED_MAX_PANES,
+  pr as SciPlot,
+  Ot as Series,
+  Vn as SeriesAdapter,
+  Ht as StateHistory,
+  Ae as StatsPlugin,
+  ga as THEME_PRESETS,
+  to as TOOLTIP_THEMES,
+  pa as ThemeEditor,
+  no as TooltipManager,
+  Fe as WatermarkPlugin,
+  Kn as WebGLBackend,
+  jn as WebGPUBackend,
+  re as WebGPURenderer,
+  vo as WorkerPool,
+  Nt as addIndicatorToChart,
+  za as adx,
+  To as analyzeComplexSpectrum,
+  bo as analyzeSpectrum,
+  Wa as aroon,
+  Ao as arraysToComplex,
+  bt as assertPerformance,
+  Ga as atr,
+  Mo as autoCorrelation,
+  Fo as bandPassFilter,
+  Co as bandStopFilter,
+  He as benchmarkCanvasGrid,
+  Pt as benchmarkRender,
+  Ne as benchmarkWebGLGrid,
+  Io as blackmanWindow,
+  Ua as bollingerBands,
+  qt as bollingerBandsAsync,
+  Vt as buildIndicatorPane,
+  Kt as buildIndicatorPaneFromPreset,
+  jt as buildIndicatorSeries,
+  Ct as businessDaySpanMs,
+  Do as butterworth,
+  La as calculateR2,
+  wa as calculateStats,
+  io as calculateTargetPoints,
+  Xn as checkPluginCompatibility,
+  dt as compareGridBackends,
+  ft as compareScenarioToBaseline,
+  Tt as compareSnapshots,
+  ko as complexToArrays,
+  Jt as compressString,
+  It as computeHeikinAshi,
+  Qt as computeIndicatorFromSeries,
+  Zt as computeIndicatorPreset,
+  ar as connectStreamToChart,
+  qr as copyToClipboard,
+  ir as createBackpressureManager,
+  en as createChart,
+  ca as createChartGroup,
+  Bn as createConfigurablePlugin,
+  Zr as createDebugOverlay,
+  Jn as createGpuRenderer,
+  tn as createIndicatorSeries,
+  Ur as createKeyBinding,
+  ra as createLoadingIndicator,
+  Lr as createLocaleFormatter,
+  sr as createLosslessBackpressure,
+  da as createMasterSlave,
+  lr as createMessageParser,
+  cr as createMockStream,
+  nn as createNativeRenderer,
+  _n as createPlugin,
+  on as createPluginContext,
+  dr as createRealtimeBackpressure,
+  zn as createRenderer,
+  rn as createScale,
+  St as createSnapshot,
+  mr as createStackedChart,
+  an as createTheme,
+  ma as createThemeEditor,
+  ur as createWebSocketStream,
+  Eo as crossCorrelation,
+  $a as cumsum,
+  Ra as cumulativeIntegral,
+  sn as decodeFloat32Array,
+  ln as decompressString,
+  Wn as defineAndRegister,
+  z as definePlugin,
+  Oa as dema,
+  Ya as derivative,
+  so as destroyDownsamplePool,
+  cn as destroyIndicatorPool,
+  Lo as detectAnomalies,
+  Pa as detectCycles,
+  dn as detectIndicatorMarkers,
+  Sa as detectPeaks,
+  Ro as dominantFrequency,
+  lo as downsampleAsync,
+  Ta as downsampleLTTB,
+  un as easings,
+  Ha as ema,
+  fn as emaAsync,
+  ea as enableDebugMode,
+  hn as encodeFloat32Array,
+  ht as evaluateRendererCompare,
+  Yo as exponentialMovingAverage,
+  Xo as fft,
+  Bo as fftFromComplexInput,
+  Vr as formatData,
+  ba as formatScientific,
+  Aa as formatValue,
+  Ma as formatWithPrefix,
+  _o as gaussianSmooth,
+  vt as generateCVData,
+  Fa as generateCycleColors,
+  wt as generateNyquistData,
+  xt as generateRandomData,
+  mt as generateSawtoothWave,
+  gt as generateSineWave,
+  pt as generateSquareWave,
+  yt as generateTriangleWave,
+  ut as getBaseline,
+  Ca as getBestPrefix,
+  gn as getChartInitQueue,
+  Kr as getClipboardManager,
+  co as getDownsamplePoolSize,
+  Rr as getGlobalLocale,
+  Yr as getLocale,
+  Gn as getPluginRegistry,
+  zo as getPositiveFrequencies,
+  ya as getPresetNames,
+  xa as getPresetTheme,
+  pn as getSharedAnimationEngine,
+  mn as getThemeByName,
+  oo as getTooltipThemeForChartTheme,
+  Wo as hammingWindow,
+  Go as hanningWindow,
+  Uo as highPassFilter,
+  $o as ifft,
+  Oo as ifftComplex,
+  Ho as ifftFromArrays,
+  Xa as integrate,
+  yn as interleaveData,
+  tt as isBusinessDay,
+  ua as linkCharts,
+  Un as listPluginsByCategory,
+  $n as loadPlugin,
+  No as lowPassFilter,
+  uo as lowerBoundX,
+  fo as lttbDownsample,
+  Na as macd,
+  xn as macdAsync,
+  Ft as mapToBusinessDayScale,
+  qo as medianFilter,
+  vn as mergeAnimationConfig,
+  wn as mergeLayoutOptions,
+  ho as minMaxDownsample,
+  qa as momentum,
+  Ia as movingAverage,
+  Vo as nextPowerOf2,
+  wo as nextTaskId,
+  Va as normalize,
+  Ka as obv,
+  go as ohlcDownsampleAsync,
+  po as ohlcMinMaxDownsample,
+  Pn as parseColor,
+  Qn as parseColorToRGBA,
+  $r as parseShortcut,
+  ja as percentChange,
+  Ko as powerSpectrum,
+  Sn as queueChartInit,
+  Xr as registerLocale,
+  On as registerPlugin,
+  Tn as resetChartQueue,
+  Ja as roc,
+  Qa as rsi,
+  bn as rsiAsync,
+  jo as savitzkyGolay,
+  Br as setGlobalLocale,
+  aa as showLoading,
+  ia as showProgress,
+  Jo as simpsonsIntegration,
+  Qo as singleFrequencyFilter,
+  mo as sliceSeriesToViewport,
+  Za as sma,
+  An as smaAsync,
+  Ba as solveLinearSystem,
+  ei as standardDeviation,
+  Mn as stateToUrlHash,
+  ti as stochastic,
+  Da as subtractBaseline,
+  Zo as tTest,
+  ni as tema,
+  er as trapezoidalIntegration,
+  yo as upperBoundX,
+  Fn as urlHashToState,
+  yr as useSciPlot,
+  Cn as validateChartState,
+  ka as validateData,
+  Hn as validateManifest,
+  oi as vwap,
+  Mt as waitFor,
+  In as waitForAnimations,
+  At as waitForFrames,
+  ri as wma
 };
 //# sourceMappingURL=velo-plot.full.js.map