velo-plot 1.15.0 → 2.0.0

package/dist/velo-plot.full.js

@@ -1,56 +1,61 @@
-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 xe = Object.defineProperty;
+var ve = (n, e, t) => e in n ? xe(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var Y = (n, e, t) => ve(n, typeof e != "symbol" ? e + "" : e, t);
+import { D as ee, j as O, s as te, O as Pe } from "./ChartCore-BhQ4j7f5.js";
+import { A as St, C as Tt, l as bt, G as At, f as Mt, E as Ct, L as Ft, u as Dt, z as Et, N as It, a5 as Lt, H as kt, S as Rt, U as Xt, a as Yt, Z as Bt, a0 as _t, b as Gt, g as Wt, a3 as zt, K as Ut, e as $t, d as Ot, a1 as Ht, c as qt, $ as Nt, N as Vt, a4 as Kt, v as jt, B as Jt, J as Qt, P as Zt, _ as en, a2 as tn, k as nn, X as an, I as on, p as rn, o as sn, F as ln, x as cn, Y as dn, n as un, m as fn, y as gn, q as pn, t as hn, V as mn, W as yn, Q as xn, R as vn, T as Pn, w as wn } from "./ChartCore-BhQ4j7f5.js";
+import { E as Tn, c as bn, b as An, f as Mn, i as Cn, a as Fn, m as Dn } from "./axisFormat-SPX-CD5s.js";
+import { AnnotationManager as In, PluginAnnotations as Ln } from "./plugins/annotations.js";
+import { d as G } from "./index.core-fpZ1dYN0.js";
+import { e as Rn, h as Xn, f as Yn, c as Bn, a as _n, g as Gn, b as Wn, l as zn, r as Un, v as $n } from "./index.core-fpZ1dYN0.js";
+import { G as Hn, S as qn, a as Nn, W as Vn, c as Kn, p as jn } from "./gpuRenderer-BpaMYz-k.js";
+import { P as Qn, a as Zn, T as ea, g as ta } from "./index-CWipqOLP.js";
+import { P as aa, c as oa, e as ra, d as ia, g as sa, a as la, l as ca, m as da, b as ua, o as fa, s as ga, u as pa } from "./index-D7dTq6VB.js";
+import { W as ma, n as ya } from "./pool-15HMCNv8.js";
+import { PluginAnalysis as va, analyzeComplexSpectrum as Pa, analyzeSpectrum as wa, arraysToComplex as Sa, autoCorrelation as Ta, bandPassFilter as ba, bandStopFilter as Aa, blackmanWindow as Ma, butterworth as Ca, complexToArrays as Fa, crossCorrelation as Da, detectAnomalies as Ea, dominantFrequency as Ia, exponentialMovingAverage as La, fft as ka, fftFromComplexInput as Ra, gaussianSmooth as Xa, getPositiveFrequencies as Ya, hammingWindow as Ba, hanningWindow as _a, highPassFilter as Ga, ifft as Wa, ifftComplex as za, ifftFromArrays as Ua, lowPassFilter as $a, medianFilter as Oa, nextPowerOf2 as Ha, powerSpectrum as qa, savitzkyGolay as Na, simpsonsIntegration as Va, singleFrequencyFilter as Ka, tTest as ja, trapezoidalIntegration as Ja } from "./plugins/analysis.js";
+import { B as Za, C as eo, P as to, a as no, e as ao, g as oo, b as ro, d as io, f as so, c as lo } from "./index-BMiZoKmm.js";
+import { S as uo, u as fo } from "./SciPlot-GJvw7GJo.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 { a as po, S as ho, c as mo } from "./createStackedChart-DJSmqerD.js";
+import { BaseBufferStore as xo, BaseTextureStore as vo, GpuBenchmark as Po, GpuCompute as wo, PipelineCache as So, PluginGpu as To } from "./plugins/gpu.js";
+import { b as Ao, L as Mo, a as Co, c as Fo, f as Do, d as Eo, e as Io, i as Lo, g as ko, h as Ro, r as Xo, s as Yo } from "./index-x4stH3jD.js";
+import { D as _o, K as Go, P as Wo, c as zo, p as Uo } from "./index-DoYxf1cV.js";
+import { ClipboardManager as Oo, PluginClipboard as Ho, copyToClipboard as qo, formatData as No, getClipboardManager as Vo } from "./plugins/clipboard.js";
+import { DebugOverlay as jo, PluginDebug as Jo, createDebugOverlay as Qo, enableDebugMode as Zo } from "./plugins/debug.js";
+import { L as tr, P as nr, c as ar, s as or, a as rr } from "./index-qhscKTDy.js";
+import { C as sr, c as lr, a as cr, l as dr } from "./index-CUGS98p4.js";
+import { P as fr, a as gr, b as pr, c as hr } from "./mockDatafeed-Cdg5hKEo.js";
+import { P as yr, b as xr, T as vr, c as Pr, a as wr, g as Sr } from "./index-Dag88bW4.js";
+import { c as br, a as Ar, b as Mr, d as Cr, h as Fr, e as Dr, f as Er, g as Ir, i as Lr, m as kr, s as Rr, v as Xr } from "./utils-BK5UUXxj.js";
+import { a as Br, c as _r, d as Gr, i as Wr, s as zr } from "./math-Ddm2EZjj.js";
+import { i as $r, j as Or, g as Hr, f as qr, k as Nr, d as Vr, e as Kr, m as jr, c as Jr, n as Qr, o as Zr, p as ei, b as ti, r as ni, s as ai, h as oi, a as ri, t as ii, v as si, w as li } from "./indicators--eJGmVox.js";
+import { Plugin3D as di } from "./plugins/3d.js";
+import { PluginI18n as fi } from "./plugins/i18n.js";
+import { PluginSync as pi } from "./plugins/sync.js";
+import { PluginDataExport as mi } from "./plugins/data-export.js";
+import { PluginContextMenu as xi } from "./plugins/context-menu.js";
+import { PluginAnomalyDetection as Pi } from "./plugins/anomaly-detection.js";
+import { PluginMLIntegration as Si } from "./plugins/ml-integration.js";
+import { PluginPatternRecognition as bi } from "./plugins/pattern-recognition.js";
+import { PluginRegression as Mi } from "./plugins/regression.js";
+import { PluginRadar as Fi } from "./plugins/radar.js";
+import { PluginSnapshot as Ei } from "./plugins/snapshot.js";
+import { PluginDataTransform as Li } from "./plugins/data-transform.js";
+import { PluginLaTeX as Ri } from "./plugins/latex.js";
+import { PluginCaching as Yi } from "./plugins/caching.js";
+import { PluginLazyLoad as _i } from "./plugins/lazy-load.js";
+import { PluginBrokenAxis as Wi } from "./plugins/broken-axis.js";
+import { PluginVideoRecorder as Ui } from "./plugins/video-recorder.js";
+import { PluginOffscreen as Oi } from "./plugins/offscreen.js";
+import { PluginROI as qi } from "./plugins/roi.js";
+import { PluginForecasting as Vi } from "./plugins/forecasting.js";
+class ae {
   constructor(e, t = {}) {
-    _(this, "available");
-    _(this, "canvas");
-    _(this, "adapter");
-    _(this, "device");
-    _(this, "context");
-    this.canvas = e, this.available = Q.isSupported();
+    Y(this, "available");
+    Y(this, "canvas");
+    Y(this, "adapter");
+    Y(this, "device");
+    Y(this, "context");
+    this.canvas = e, this.available = ae.isSupported();
   }
   static isSupported() {
     return typeof globalThis.navigator < "u" && typeof globalThis.navigator.gpu < "u";
@@ -64,14 +69,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 o = this.canvas.getContext("webgpu");
+    if (!o)
       throw new Error("[SciPlot] Failed to get WebGPU context");
-    this.context = s;
-    const o = e.preferredFormat ?? (t.getPreferredCanvasFormat ? t.getPreferredCanvasFormat() : "bgra8unorm");
+    this.context = o;
+    const r = e.preferredFormat ?? (t.getPreferredCanvasFormat ? t.getPreferredCanvasFormat() : "bgra8unorm");
     this.context.configure({
       device: this.device,
-      format: o,
+      format: r,
       alphaMode: "premultiplied"
     });
   }
@@ -79,128 +84,128 @@ class Q {
     this.device = void 0, this.adapter = void 0, this.context = void 0;
   }
 }
-const ge = {
+const we = {
   name: "crosshair",
   version: "1.0.0",
   description: "Interactive crosshair that follows mouse cursor",
   provides: ["interaction", "visualization"],
   tags: ["cursor", "crosshair", "tooltip"]
-}, pe = O(
-  ge,
-  (r = {}) => {
+}, Se = G(
+  we,
+  (n = {}) => {
     const {
       showVertical: e = !0,
       showHorizontal: t = !0,
-      color: s,
-      lineStyle: o = "dashed",
-      lineWidth: n = 1,
-      snapToData: u = !1,
+      color: o,
+      lineStyle: r = "dashed",
+      lineWidth: a = 1,
+      snapToData: d = !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;
+    } = 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 u = -1, h = -1, S, v = null, p = null;
     return {
-      onInit(d) {
-        b = "crosshair-overlay";
-        const a = d.ui.createOverlay(b, {
+      onInit(f) {
+        S = "crosshair-overlay";
+        const l = f.ui.createOverlay(S, {
           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%;", l.appendChild(v), p = v.getContext("2d"), w(f);
       },
-      onDestroy(d) {
-        d.ui.removeOverlay(b), v = null, p = null;
+      onDestroy(f) {
+        f.ui.removeOverlay(S), v = null, p = null;
       },
-      onResize(d) {
-        S(d);
+      onResize(f) {
+        w(f);
       },
-      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(f, l) {
+        if (l.type === "mousemove") {
+          if (u = l.pixelX, h = l.pixelY, d && l.inPlotArea) {
+            const P = f.coords.pickPoint(u, h);
+            P && (u = P.pixelX, h = P.pixelY);
           }
-          C(d);
+          b(f);
         }
       },
       onViewChange() {
       }
     };
-    function S(d) {
+    function w(f) {
       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 l = f.render.canvasSize, P = f.render.pixelRatio;
+      v.width = l.width * P, v.height = l.height * P, p.setTransform(1, 0, 0, 1, 0, 0), p.scale(P, P);
     }
-    function C(d) {
-      var A;
+    function b(f) {
+      var C;
       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: l, height: P } = f.render.canvasSize;
+      if (p.clearRect(0, 0, l, P), u < 0 || h < 0) return;
+      const x = f.render.plotArea;
+      if (u < x.x || u > x.x + x.width || h < x.y || h > 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 D = o || ((C = f.ui.theme.cursor) == null ? void 0 : C.color) || "#888888";
+      p.save(), p.strokeStyle = D, p.lineWidth = a, r === "dashed" ? p.setLineDash([6, 4]) : r === "dotted" && p.setLineDash([2, 2]), e && (p.beginPath(), p.moveTo(u, x.y), p.lineTo(u, x.y + x.height), p.stroke()), t && (p.beginPath(), p.moveTo(x.x, h), p.lineTo(x.x + x.width, h), p.stroke()), p.restore(), i === "floating" ? g(f, p, u, h, D) : i === "corner" && y(f, p, u, h, D);
     }
-    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(f, l, P, x, D) {
+      const C = f.coords.pixelToDataX(P), B = f.coords.pixelToDataY(x), M = f.render.plotArea;
+      l.save(), l.font = "11px system-ui, sans-serif", l.textAlign = "center", l.textBaseline = "top";
+      const _ = C.toPrecision(c.xPrecision), A = l.measureText(_).width + 8, T = 18, I = P - A / 2, F = M.y + M.height + 2;
+      l.fillStyle = D, l.fillRect(I, F, A, T), l.fillStyle = "#ffffff", l.fillText(_, P, F + 3), l.textAlign = "right", l.textBaseline = "middle";
+      const k = B.toPrecision(c.yPrecision), X = l.measureText(k).width + 8, L = 18, R = M.x - X - 2, U = x - L / 2;
+      l.fillStyle = D, l.fillRect(R, U, X, L), l.fillStyle = "#ffffff", l.fillText(k, M.x - 6, x), l.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(f, l, P, x, D) {
+      const C = f.coords.pixelToDataX(P), B = f.coords.pixelToDataY(x), M = f.render.plotArea;
+      l.save(), l.font = "11px system-ui, sans-serif";
+      const _ = `X: ${C.toPrecision(c.xPrecision)}`, m = `Y: ${B.toPrecision(c.yPrecision)}`, A = l.measureText(_), T = l.measureText(m), I = Math.max(A.width, T.width), F = 6, k = 16, E = I + F * 2, X = k * 2 + F * 2;
+      let L, R;
+      switch (s) {
         case "top-left":
-          L = M.x + 8, X = M.y + 8;
+          L = M.x + 8, R = M.y + 8;
           break;
         case "top-right":
-          L = M.x + M.width - E - 8, X = M.y + 8;
+          L = M.x + M.width - E - 8, R = M.y + 8;
           break;
         case "bottom-left":
-          L = M.x + 8, X = M.y + M.height - Y - 8;
+          L = M.x + 8, R = M.y + M.height - X - 8;
           break;
         case "bottom-right":
-          L = M.x + M.width - E - 8, X = M.y + M.height - Y - 8;
+          L = M.x + M.width - E - 8, R = M.y + M.height - X - 8;
           break;
         default:
-          L = M.x + 8, X = M.y + 8;
+          L = 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();
+      l.fillStyle = D, l.globalAlpha = 0.85, l.fillRect(L, R, E, X), l.globalAlpha = 1, l.strokeStyle = "rgba(255,255,255,0.3)", l.lineWidth = 1, l.strokeRect(L, R, E, X), l.fillStyle = "#ffffff", l.textAlign = "left", l.textBaseline = "top", l.fillText(_, L + F, R + F), l.fillText(m, L + F, R + F + k), l.restore();
     }
   }
-), he = {
+), Te = {
   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 = {}) => {
+}, be = G(
+  Te,
+  (n = {}) => {
     const {
       position: e = "top-right",
       show: t = ["count", "mean", "min", "max"],
-      seriesId: s,
-      autoUpdate: o = !0
-    } = r;
-    let n, u = null;
+      seriesId: o,
+      autoUpdate: r = !0
+    } = n;
+    let a, d = 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) {
+        a = "stats-overlay";
+        const u = {};
+        e.includes("top") && (u.top = "10px"), e.includes("bottom") && (u.bottom = "10px"), e.includes("left") && (u.left = "10px"), e.includes("right") && (u.right = "10px"), d = s.ui.createOverlay(a, {
           zIndex: 800,
-          position: f,
+          position: u,
           pointerEvents: !1
-        }), u.innerHTML = `
+        }), d.innerHTML = `
           <div style="
             background: rgba(0, 0, 0, 0.85);
             color: #fff;
@@ -214,176 +219,176 @@ const ge = {
             <div style="font-weight: bold; margin-bottom: 4px; color: #4ade80;">📊 Statistics</div>
             <div class="stats-content"></div>
           </div>
-        `, c(l);
+        `, c(s);
       },
-      onDestroy(l) {
-        l.ui.removeOverlay(n), u = null;
+      onDestroy(s) {
+        s.ui.removeOverlay(a), d = null;
       },
-      onDataUpdate(l) {
-        o && c(l);
+      onDataUpdate(s) {
+        r && c(s);
       },
-      onSeriesAdd(l) {
-        c(l);
+      onSeriesAdd(s) {
+        c(s);
       },
-      onSeriesRemove(l) {
-        c(l);
+      onSeriesRemove(s) {
+        c(s);
       },
       api: {
-        refresh(l) {
-          c(l);
+        refresh(s) {
+          c(s);
         }
       }
     };
-    function c(l) {
+    function c(s) {
+      if (!d) return;
+      const u = d.querySelector(".stats-content");
       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>";
+      const h = s.data.getAllSeries(), S = o ? h.filter((b) => b.getId() === o) : h;
+      if (S.length === 0) {
+        u.innerHTML = "<div style='color: #888'>No data</div>";
         return;
       }
       let v = [];
-      if (b.forEach((C) => {
-        const g = C.getData();
+      if (S.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>";
+        u.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("");
+      const p = i(v), w = [];
+      t.includes("count") && w.push(`<div>N: <span style="color: #60a5fa">${p.count.toLocaleString()}</span></div>`), t.includes("mean") && w.push(`<div>μ: <span style="color: #60a5fa">${p.mean.toPrecision(4)}</span></div>`), t.includes("min") && w.push(`<div>Min: <span style="color: #60a5fa">${p.min.toPrecision(4)}</span></div>`), t.includes("max") && w.push(`<div>Max: <span style="color: #60a5fa">${p.max.toPrecision(4)}</span></div>`), t.includes("std") && w.push(`<div>σ: <span style="color: #60a5fa">${p.std.toPrecision(4)}</span></div>`), t.includes("range") && w.push(`<div>Range: <span style="color: #60a5fa">${p.range.toPrecision(4)}</span></div>`), u.innerHTML = w.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;
-      let S = 0;
-      for (const g of l)
-        S += (g - p) ** 2;
-      const C = Math.sqrt(S / f);
+    function i(s) {
+      const u = s.length;
+      let h = 0, S = 1 / 0, v = -1 / 0;
+      for (const g of s)
+        h += g, g < S && (S = g), g > v && (v = g);
+      const p = h / u;
+      let w = 0;
+      for (const g of s)
+        w += (g - p) ** 2;
+      const b = Math.sqrt(w / u);
       return {
-        count: f,
+        count: u,
         mean: p,
-        min: b,
+        min: S,
         max: v,
-        std: C,
-        range: v - b
+        std: b,
+        range: v - S
       };
     }
   }
-), ye = {
+), Ae = {
   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))
+}, Me = G(
+  Ae,
+  (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: o = "system-ui, sans-serif",
+      color: r = "rgba(128, 128, 128, 0.15)",
+      position: a = "center",
+      rotation: d = a === "center" ? -30 : 0
+    } = n;
     return {
       onRenderOverlay(c) {
         const i = c.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();
+        const s = c.render.plotArea;
+        i.save(), i.font = `${t}px ${o}`, i.fillStyle = r, i.textAlign = "center", i.textBaseline = "middle";
+        let u, h;
+        a === "center" ? (u = s.x + s.width / 2, h = s.y + s.height / 2) : a === "bottom-right" ? (u = s.x + s.width - t, h = s.y + s.height - t / 2) : (u = s.x + t, h = s.y + s.height - t / 2), i.translate(u, h), i.rotate(d * 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;
+}, Fe = G(
+  Ce,
+  (n = {}) => {
+    const { xIntervals: e = [], yIntervals: t = [], opacity: o = 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(r, a) {
+        const d = r.render.ctx2d;
+        if (!d) return;
+        const c = r.render.plotArea;
+        r.data.getViewBounds(), d.save(), d.beginPath(), d.rect(c.x, c.y, c.width, c.height), d.clip(), d.globalAlpha = o;
         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),
+          const s = r.coords.dataToPixelX(i.start), u = r.coords.dataToPixelX(i.end);
+          d.fillStyle = i.color, d.fillRect(
+            Math.min(s, u),
             c.y,
-            Math.abs(f - l),
+            Math.abs(u - s),
             c.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(
+          const s = r.coords.dataToPixelY(i.start), u = r.coords.dataToPixelY(i.end);
+          d.fillStyle = i.color, d.fillRect(
             c.x,
-            Math.min(l, f),
+            Math.min(s, u),
             c.width,
-            Math.abs(f - l)
+            Math.abs(u - s)
           );
         }
-        u.restore();
+        d.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 = {}) => {
+}, Ee = G(
+  De,
+  (n = {}) => {
     const {
       logDataUpdates: e = !0,
       logViewChanges: t = !0,
-      logInteractions: s = !1,
-      maxEntries: o = 100
-    } = r, n = [];
-    function u(c, i) {
-      n.push({
+      logInteractions: o = !1,
+      maxEntries: r = 100
+    } = n, a = [];
+    function d(c, i) {
+      a.push({
         timestamp: Date.now(),
         type: c,
         data: i
-      }), n.length > o && n.shift();
+      }), a.length > r && a.shift();
     }
     return {
       onInit(c) {
         c.log.info("Data logger initialized");
       },
       onDataUpdate(c, i) {
-        e && (u("dataUpdate", {
+        e && (d("dataUpdate", {
           seriesId: i.seriesId,
           mode: i.mode,
           pointCount: i.pointCount
         }), c.log.debug(`Data update: ${i.seriesId} (${i.mode}, ${i.pointCount} points)`));
       },
       onViewChange(c, i) {
-        t && (u("viewChange", {
+        t && (d("viewChange", {
           trigger: i.trigger,
           bounds: i.current
         }), c.log.debug(`View change: ${i.trigger}`));
       },
       onInteraction(c, i) {
-        s && u("interaction", {
+        o && d("interaction", {
           type: i.type,
           pixelX: i.pixelX,
           pixelY: i.pixelY,
@@ -391,147 +396,147 @@ const ge = {
         });
       },
       onSerialize(c) {
-        return { entries: n };
+        return { entries: a };
       },
       onDeserialize(c, i) {
-        const l = i;
-        l != null && l.entries && (n.length = 0, n.push(...l.entries));
+        const s = i;
+        s != null && s.entries && (a.length = 0, a.push(...s.entries));
       },
       api: {
         getEntries() {
-          return [...n];
+          return [...a];
         },
         clear() {
-          n.length = 0;
+          a.length = 0;
         },
         export() {
-          return JSON.stringify(n, null, 2);
+          return JSON.stringify(a, null, 2);
         }
       }
     };
   }
-), we = {
+), Ie = {
   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 = G(
+  Ie,
+  (n = {}) => {
     const {
       seriesId: e,
       sampleSize: t = 20,
-      color: s,
-      size: o = 40,
-      minVelocity: n = 0.01,
-      historySize: u = 20,
+      color: o,
+      size: r = 40,
+      minVelocity: a = 0.01,
+      historySize: d = 20,
       idleTimeout: c
-    } = r;
-    let i, l = null, f = null, y = null, b = null;
-    const v = [], p = [], S = [];
-    let C = u, g = null, m = Date.now(), d = -1 / 0, a = -1 / 0, P = c;
+    } = n;
+    let i, s = null, u = null, h = null, S = null;
+    const v = [], p = [], w = [];
+    let b = d, g = null, y = Date.now(), f = -1 / 0, l = -1 / 0, P = c;
     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), u = s.getContext("2d"), x(m), e)
+          S = e;
         else {
-          const T = h.data.getAllSeries();
-          T.length > 0 && (b = T[0].getId());
+          const T = m.data.getAllSeries();
+          T.length > 0 && (S = 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, u = null, h = null;
       },
-      onResize(h) {
-        x(h);
+      onResize(m) {
+        x(m);
       },
-      onAfterRender(h) {
-        if (D(h), M(h), P) {
+      onAfterRender(m) {
+        if (D(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 (; w.length > b; ) w.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 || !u) return;
+      const A = m.render.canvasSize, T = m.render.pixelRatio;
+      s.width = A.width * T, s.height = A.height * T, u.setTransform(1, 0, 0, 1, 0, 0), u.scale(T, T);
     }
-    function D(h) {
-      if (!b || !h.data.getSeries(b)) return;
-      const T = h.data.getSeriesData(b);
+    function D(m) {
+      if (!S || !m.data.getSeries(S)) return;
+      const T = m.data.getSeriesData(S);
       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 I = T.x.length;
+      if (I < 2) return;
+      const F = T.x[I - 1], k = T.y[I - 1];
+      (F !== f || k !== l) && (f = F, l = k, y = Date.now());
+      const E = Math.min(t, I), X = I - E;
+      let L = 0, R = 0, U = 0, K = 0, j = 0, J = 0;
+      for (let W = X; W < I; W++) {
+        const z = W - X, me = T.x[W], ye = T.y[W], Q = m.coords.dataToPixelX(me), Z = m.coords.dataToPixelY(ye);
+        L += z, R += Q, U += Z, K += z * Q, j += z * Z, J += z * z;
       }
-      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 $ = L / E, se = R / E, le = U / E, H = J - E * $ * $;
+      if (Math.abs(H) < 1e-10) return;
+      const q = (K - E * $ * se) / H, N = (j - E * $ * le) / H, ce = Math.atan2(N, q), de = m.coords.dataToPixelX(F), ue = m.coords.dataToPixelY(k);
+      v.push(de), p.push(ue), v.length > b && (v.shift(), p.shift()), w.push(ce), w.length > b && w.shift();
+      const fe = C(v), ge = C(p), pe = B(w), he = Math.sqrt(q * q + N * N);
+      h = { angle: pe, magnitude: he, lastX: F, lastY: k, smoothX: fe, smoothY: ge };
     }
-    function A(h) {
-      return h.length === 0 ? 0 : h.reduce((w, T) => w + T, 0) / h.length;
+    function C(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 I of m)
+        A += Math.cos(I), T += Math.sin(I);
+      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 (!u || !s || !h) return;
+      const { width: A, height: T } = m.render.canvasSize;
+      if (u.clearRect(0, 0, A, T), P !== void 0 && Date.now() - y > P || h.magnitude < a) return;
+      const I = h.smoothX, F = h.smoothY, k = o || "#FF9800";
+      u.save(), _(u, I, F, h.angle, r, k), u.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, I, F, k) {
+      const E = F * 0.6, X = F * 0.4;
+      m.save(), m.translate(A, T), m.rotate(I), m.fillStyle = k, m.beginPath(), m.moveTo(E / 2, 0), m.lineTo(-E / 2, -X / 2), m.lineTo(-E / 2, X / 2), m.closePath(), m.fill(), m.restore();
     }
   }
-), Le = {
-  Crosshair: pe,
-  Statistics: me,
-  Watermark: xe,
-  GridHighlight: Pe,
-  DataLogger: Te,
-  DirectionIndicator: be
-}, Ce = {
+), tt = {
+  Crosshair: Se,
+  Statistics: be,
+  Watermark: Me,
+  GridHighlight: Fe,
+  DataLogger: Ee,
+  DirectionIndicator: Le
+}, ke = {
   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 = {
+}, Re = {
   enabled: !0,
   constraint: "both",
   snapToGrid: !1,
@@ -556,89 +561,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 nt(n = {}) {
+  const e = { ...Re, ...n };
+  let t = null, o = !1, r = null, a = 0, d = 0, c = !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 f = t.coords.pickPoint(g, y, e.hitRadius);
+    return !f || e.editableSeries.length > 0 && !e.editableSeries.includes(f.seriesId) ? null : {
+      seriesId: f.seriesId,
+      index: f.index,
+      originalX: f.x,
+      originalY: f.y,
+      currentX: f.x,
+      currentY: f.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 u(g, y) {
+    return Math.round(g / y) * y;
   }
-  function y(g, m, d) {
-    if (!o) return { x: g, y: m };
-    switch (d) {
+  function h(g, y, f) {
+    if (!r) return { x: g, y };
+    switch (f) {
       case "x":
-        return { x: g, y: o.originalY };
+        return { x: g, y: r.originalY };
       case "y":
-        return { x: o.originalX, y: m };
+        return { x: r.originalX, y };
       case "none":
-        return { x: o.originalX, y: o.originalY };
+        return { x: r.originalX, y: r.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 S(g, y) {
+    let f = g, l = y;
+    if (e.snapToGrid && (f = u(g, e.snapIntervalX), l = u(y, e.snapIntervalY)), r && e.validator) {
+      const P = { ...r, currentX: f, currentY: l }, x = e.validator(P);
       if (typeof x == "boolean")
-        return { x: d, y: a, valid: x };
+        return { x: f, y: l, 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: f, y: l, valid: !1 };
+      x.snapX !== void 0 && (f = x.snapX), x.snapY !== void 0 && (l = x.snapY);
     }
-    return { x: d, y: a, valid: !0 };
+    return { x: f, y: l, valid: !0 };
   }
-  function v(g, m, d, a) {
-    var D, A, k;
+  function v(g, y, f, l) {
+    var D, C, B;
     if (!t) return;
-    const P = (A = (D = t.chart).getSeries) == null ? void 0 : A.call(D, g);
+    const P = (C = (D = t.chart).getSeries) == null ? void 0 : C.call(D, 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] = f, x.y[y] = l, (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 r ? {
+      seriesId: r.seriesId,
+      index: r.index,
+      oldX: r.originalX,
+      oldY: r.originalY,
+      newX: r.currentX,
+      newY: r.currentY,
+      deltaX: r.currentX - r.originalX,
+      deltaY: r.currentY - r.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();
+  function w(g) {
+    if (!o || !r || !e.showPreview) return;
+    const { render: y, coords: f } = g, { ctx2d: l } = y;
+    if (!l) return;
+    l.save();
+    const P = f.dataToPixelX(r.originalX), x = f.dataToPixelY(r.originalY), D = f.dataToPixelX(r.currentX), C = f.dataToPixelY(r.currentY);
+    l.strokeStyle = e.previewStyle.color || "#ffffff", l.lineWidth = e.previewStyle.width || 2, l.globalAlpha = e.previewStyle.opacity || 0.5, l.setLineDash(e.previewStyle.dash || [5, 5]), l.beginPath(), l.moveTo(P, x), l.lineTo(D, C), l.stroke(), l.globalAlpha = 1, l.fillStyle = e.highlightColor, l.setLineDash([]), l.beginPath(), l.arc(D, C, 6, 0, Math.PI * 2), l.fill(), l.strokeStyle = "#000000", l.lineWidth = 1, l.stroke(), l.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, o && (r = null, o = !1, c = !1, t == null || t.requestRender());
     },
     isEnabled() {
       return e.enabled;
@@ -647,73 +652,363 @@ function Re(r = {}) {
       e.editableSeries = g;
     },
     getDraggedPoint() {
-      return o;
+      return r;
     },
     cancelDrag() {
-      s && o && (o = null, s = !1, c = !1, t == null || t.requestRender());
+      o && r && (r = null, o = !1, c = !1, t == null || t.requestRender());
     },
     updateConfig(g) {
       Object.assign(e, g);
     }
   };
   return {
-    manifest: Ce,
+    manifest: ke,
     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 f = i(y.pixelX, y.pixelY);
+          f && (r = f, a = y.pixelX, d = y.pixelY, c = !1, o = !1, y.preventDefault());
+        } else if (y.type === "mousemove") {
+          if (!r) return;
+          if (!o) {
+            const C = y.pixelX - a, B = y.pixelY - d;
+            if (Math.sqrt(C * C + B * B) > e.dragThreshold) {
+              o = !0, c = !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);
+          o && y.preventDefault();
+          let { x: f, y: l } = s(y.pixelX, y.pixelY);
+          ({ x: f, y: l } = h(f, l, e.constraint));
+          const { x: P, y: x, valid: D } = S(f, l);
           if (D) {
-            o.currentX = P, o.currentY = x;
-            const A = p();
-            A && e.onDrag(A), t == null || t.requestRender();
+            r.currentX = P, r.currentY = x;
+            const C = p();
+            C && e.onDrag(C), t == null || t.requestRender();
           }
-        } else if (m.type === "mouseup") {
-          if (!o) return;
-          if (s && c) {
+        } else if (y.type === "mouseup") {
+          if (!r) return;
+          if (o && c) {
             v(
-              o.seriesId,
-              o.index,
-              o.currentX,
-              o.currentY
+              r.seriesId,
+              r.index,
+              r.currentX,
+              r.currentY
             );
-            const d = p();
-            d && e.onDragEnd(d), m.preventDefault();
+            const f = p();
+            f && e.onDragEnd(f), y.preventDefault();
           }
-          o = null, s = !1, c = !1, t == null || t.requestRender();
+          r = null, o = !1, c = !1, t == null || t.requestRender();
         }
       }
     },
     onRenderOverlay(g) {
-      S(g);
+      w(g);
     },
-    api: C
+    api: b
+  };
+}
+const Xe = `
+  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);
+  }
+`, Ye = `
+  precision mediump float;
+  uniform vec4 uColor;
+  void main() {
+    gl_FragColor = uColor;
+  }
+`;
+function ne(n, e, t) {
+  const o = n.createShader(e);
+  if (!o) throw new Error("createShader failed");
+  if (n.shaderSource(o, t), n.compileShader(o), !n.getShaderParameter(o, n.COMPILE_STATUS))
+    throw new Error(n.getShaderInfoLog(o) ?? "shader compile failed");
+  return o;
+}
+function Be(n) {
+  const e = ne(n, n.VERTEX_SHADER, Xe), t = ne(n, n.FRAGMENT_SHADER, Ye), o = n.createProgram();
+  if (!o) throw new Error("createProgram failed");
+  if (n.attachShader(o, e), n.attachShader(o, t), n.linkProgram(o), !n.getProgramParameter(o, n.LINK_STATUS))
+    throw new Error(n.getProgramInfoLog(o) ?? "program link failed");
+  return n.deleteShader(e), n.deleteShader(t), o;
+}
+function _e(n) {
+  const { plotArea: e, xLines: t, yLines: o } = n, r = e.y, a = e.y + e.height, d = e.x, c = e.x + e.width, i = (t.length + o.length) * 2, s = new Float32Array(i * 2);
+  let u = 0;
+  for (const h of t)
+    s[u++] = h, s[u++] = r, s[u++] = h, s[u++] = a;
+  for (const h of o)
+    s[u++] = d, s[u++] = h, s[u++] = c, s[u++] = h;
+  return s;
+}
+class Ge {
+  constructor(e) {
+    Y(this, "gl");
+    Y(this, "program");
+    Y(this, "buffer");
+    Y(this, "aPosition");
+    Y(this, "uResolution");
+    Y(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 = Be(t), this.aPosition = t.getAttribLocation(this.program, "aPosition"), this.uResolution = t.getUniformLocation(this.program, "uResolution"), this.uColor = t.getUniformLocation(this.program, "uColor");
+    const o = t.createBuffer();
+    if (!o) throw new Error("createBuffer failed");
+    this.buffer = o;
+  }
+  /** Upload vertices and draw grid lines */
+  draw(e) {
+    const t = this.gl, o = _e(e), r = o.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, o, 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 a = e.color ?? [0.2, 0.22, 0.3, 0.6];
+    return t.uniform4f(this.uColor, a[0], a[1], a[2], a[3]), t.lineWidth(e.lineWidth ?? 1), t.drawArrays(t.LINES, 0, o.length / 2), r;
+  }
+  destroy() {
+    const e = this.gl;
+    e.deleteBuffer(this.buffer), e.deleteProgram(this.program);
+  }
+}
+function We(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 ze(n, e) {
+  const t = document.createElement("canvas");
+  return t.width = n, t.height = e, t.getContext("2d") ?? We(t);
+}
+function oe(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 re(n, e, t, o, r) {
+  const a = e.ticks(o).map((c) => te(e.transform(c))), d = t.ticks(r).map((c) => te(t.transform(c)));
+  return { xLines: a, yLines: d };
+}
+function ie(n, e) {
+  const t = [];
+  for (let a = 0; a < e; a++) {
+    const d = performance.now();
+    n(), t.push((performance.now() - d) * 1e3);
+  }
+  t.sort((a, d) => a - d);
+  const o = t.reduce((a, d) => a + d, 0) / t.length, r = t[Math.floor(t.length * 0.95)] ?? o;
+  return { avg: o, p95: r };
+}
+function Ue(n = {}) {
+  const e = Math.round((n.width ?? 1920) * (n.dpr ?? 1)), t = Math.round((n.height ?? 1080) * (n.dpr ?? 1)), o = n.xTickCount ?? 24, r = n.yTickCount ?? 16, a = n.frames ?? 120, d = ze(e, t), c = {
+    ...ee,
+    grid: {
+      ...ee.grid,
+      visible: !0,
+      showMinor: n.showMinor ?? !0
+    }
+  }, i = oe(e, t), s = new O(), u = new O();
+  s.setDomain(0, 1e6), u.setDomain(-1, 1), s.setRange(i.x, i.x + i.width), u.setRange(i.y + i.height, i.y);
+  const h = new Pe(d, c), { avg: S, p95: v } = ie(() => {
+    d.clearRect(0, 0, e, t), h.drawGrid(i, s, u, { tickCount: o }, { tickCount: r });
+  }, a), { xLines: p, yLines: w } = re(i, s, u, o, r);
+  return {
+    backend: "canvas2d",
+    dpr: n.dpr ?? 1,
+    width: e,
+    height: t,
+    xTicks: o,
+    yTicks: r,
+    lineSegments: p.length + w.length,
+    avgFrameUs: Math.round(S),
+    p95FrameUs: Math.round(v),
+    frames: a
+  };
+}
+function $e(n = {}) {
+  const e = Math.round((n.width ?? 1920) * (n.dpr ?? 1)), t = Math.round((n.height ?? 1080) * (n.dpr ?? 1)), o = n.xTickCount ?? 24, r = n.yTickCount ?? 16, a = n.frames ?? 120, d = document.createElement("canvas");
+  d.width = e, d.height = t;
+  let c;
+  try {
+    c = new Ge(d);
+  } catch {
+    return null;
+  }
+  const i = oe(e, t), s = new O(), u = new O();
+  s.setDomain(0, 1e6), u.setDomain(-1, 1), s.setRange(i.x, i.x + i.width), u.setRange(i.y + i.height, i.y);
+  const { xLines: h, yLines: S } = re(i, s, u, o, r), v = { plotArea: i, xLines: h, yLines: S, width: e, height: t };
+  let p = 0;
+  const { avg: w, p95: b } = ie(() => {
+    p = c.draw(v);
+  }, a);
+  return c.destroy(), {
+    backend: "webgl",
+    dpr: n.dpr ?? 1,
+    width: e,
+    height: t,
+    xTicks: o,
+    yTicks: r,
+    lineSegments: p,
+    avgFrameUs: Math.round(w),
+    p95FrameUs: Math.round(b),
+    frames: a
   };
 }
-class Ae {
+function at(n) {
+  const e = (n == null ? void 0 : n.dpr) ?? 2, t = (n == null ? void 0 : n.frames) ?? 120, o = Ue({ dpr: e, frames: t, showMinor: !0 }), r = $e({ dpr: e, frames: t });
+  if (!r)
+    return {
+      canvas2d: o,
+      webgl: null,
+      gainPercent: 0,
+      recommendation: "defer"
+    };
+  const a = (o.avgFrameUs - r.avgFrameUs) / o.avgFrameUs * 100;
+  return {
+    canvas2d: o,
+    webgl: r,
+    gainPercent: Math.round(a * 10) / 10,
+    recommendation: a >= 20 ? "implement" : "defer"
+  };
+}
+const Oe = "1.17.0", He = "2026-07-05", qe = "Stage 1 baselines. Headless CI uses effective FPS (render throughput when rAF throttled) via scripts/benchmark-scenario-eval.mjs smoke floors.", Ne = 0.1, Ve = 0.95, Ke = {
+  "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: Oe,
+  recordedAt: He,
+  notes: qe,
+  regressionThreshold: Ne,
+  webgpuMinFpsRatio: Ve,
+  scenarios: Ke
+};
+function ot() {
+  return V;
+}
+function rt(n, e) {
+  const t = V.scenarios[n];
+  if (!t)
+    return { passed: !0, failures: [] };
+  const o = [], r = V.regressionThreshold ?? 0.1;
+  if ("avgFps" in e && t.minAvgFps !== void 0) {
+    const a = t.minAvgFps * (1 - r);
+    e.avgFps < a && o.push(
+      `FPS ${e.avgFps} < baseline min ${t.minAvgFps} (allowed ${a.toFixed(1)} with ${r * 100}% slack)`
+    );
+  }
+  if ("avgFrameTime" in e && t.maxAvgFrameTimeMs !== void 0) {
+    const a = t.maxAvgFrameTimeMs * (1 + r);
+    e.avgFrameTime > a && o.push(
+      `Frame time ${e.avgFrameTime}ms > baseline max ${t.maxAvgFrameTimeMs}ms`
+    );
+  }
+  if ("avgFrameUs" in e && t.maxAvgFrameUs !== void 0) {
+    const a = t.maxAvgFrameUs * (1 + r);
+    e.avgFrameUs > a && o.push(
+      `Grid frame ${e.avgFrameUs}µs > baseline max ${t.maxAvgFrameUs}µs`
+    );
+  }
+  return { passed: o.length === 0, failures: o };
+}
+function it(n, e, t, o = 0.95) {
+  if (!t || !e)
+    return {
+      webgl: n,
+      webgpu: e,
+      webgpuActive: !1,
+      fpsRatio: 0,
+      meetsTarget: !1,
+      recommendation: "webgpu-unavailable"
+    };
+  const r = n.avgFps > 0 ? e.avgFps / n.avgFps : 0, a = r >= o;
+  return {
+    webgl: n,
+    webgpu: e,
+    webgpuActive: !0,
+    fpsRatio: r,
+    meetsTarget: a,
+    recommendation: a ? "webgpu-ready" : "webgl-faster"
+  };
+}
+class je {
   constructor(e) {
-    _(this, "seed");
+    Y(this, "seed");
     this.seed = e;
   }
   next() {
@@ -724,7 +1019,7 @@ class Ae {
     return e + this.next() * (t - e);
   }
 }
-function Xe(r) {
+function st(n) {
   const e = {
     pointCount: 1e3,
     amplitude: 1,
@@ -734,16 +1029,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), o = new Float32Array(e.pointCount), r = (e.xEnd - e.xStart) / (e.pointCount - 1);
+  for (let a = 0; a < e.pointCount; a++) {
+    t[a] = e.xStart + a * r;
+    const d = e.amplitude * Math.sin(2 * Math.PI * e.frequency * t[a] + e.phase), c = e.noise > 0 ? (Math.random() - 0.5) * 2 * e.noise : 0;
+    o[a] = d + c + e.offset;
   }
-  return { x: t, y: s };
+  return { x: t, y: o };
 }
-function Ye(r) {
+function lt(n) {
   const e = {
     pointCount: 1e3,
     amplitude: 1,
@@ -753,16 +1048,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), o = new Float32Array(e.pointCount), r = (e.xEnd - e.xStart) / (e.pointCount - 1);
+  for (let a = 0; a < e.pointCount; a++) {
+    t[a] = e.xStart + a * r;
+    const d = t[a] * e.frequency + e.phase / (2 * Math.PI), c = Math.sign(Math.sin(2 * Math.PI * d)) * e.amplitude, i = e.noise > 0 ? (Math.random() - 0.5) * 2 * e.noise : 0;
+    o[a] = c + i + e.offset;
   }
-  return { x: t, y: s };
+  return { x: t, y: o };
 }
-function ke(r) {
+function ct(n) {
   const e = {
     pointCount: 1e3,
     amplitude: 1,
@@ -772,16 +1067,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), o = new Float32Array(e.pointCount), r = (e.xEnd - e.xStart) / (e.pointCount - 1);
+  for (let a = 0; a < e.pointCount; a++) {
+    t[a] = e.xStart + a * r;
+    const d = t[a] * e.frequency + e.phase / (2 * Math.PI), c = e.amplitude * 2 * (d - Math.floor(d + 0.5)), i = e.noise > 0 ? (Math.random() - 0.5) * 2 * e.noise : 0;
+    o[a] = c + i + e.offset;
   }
-  return { x: t, y: s };
+  return { x: t, y: o };
 }
-function ze(r) {
+function dt(n) {
   const e = {
     pointCount: 1e3,
     amplitude: 1,
@@ -791,37 +1086,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), o = new Float32Array(e.pointCount), r = (e.xEnd - e.xStart) / (e.pointCount - 1);
+  for (let a = 0; a < e.pointCount; a++) {
+    t[a] = e.xStart + a * r;
+    const d = t[a] * e.frequency + e.phase / (2 * Math.PI), c = e.amplitude * 2 * Math.abs(2 * (d - Math.floor(d + 0.5))) - e.amplitude, i = e.noise > 0 ? (Math.random() - 0.5) * 2 * e.noise : 0;
+    o[a] = c + i + e.offset;
   }
-  return { x: t, y: s };
+  return { x: t, y: o };
 }
-function _e(r) {
+function ut(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 je(e.seed), o = new Float32Array(e.pointCount), r = new Float32Array(e.pointCount);
+  for (let a = 0; a < e.pointCount; a++)
+    o[a] = t.nextRange(e.xRange[0], e.xRange[1]), r[a] = 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 a = Array.from({ length: e.pointCount }, (i, s) => s);
+    a.sort((i, s) => o[i] - o[s]);
+    const d = new Float32Array(e.pointCount), c = 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 };
+      d[i] = o[a[i]], c[i] = r[a[i]];
+    return { x: d, y: c };
   }
-  return { x: s, y: o };
+  return { x: o, y: r };
 }
-function Oe(r) {
+function ft(n) {
   const e = {
     pointCount: 2e3,
     vMin: -0.5,
@@ -830,18 +1125,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;
+    ...n
+  }, t = e.pointCount * e.cycles, o = new Float32Array(t), r = new Float32Array(t), a = e.pointCount, d = a / 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;
+    for (let i = 0; i < a; i++) {
+      const s = c * a + i;
+      i < d ? o[s] = e.vMin + (e.vMax - e.vMin) * (i / d) : o[s] = e.vMax - (e.vMax - e.vMin) * ((i - d) / d);
+      const u = o[s], h = 0, S = i < d ? 1 : -1, v = 0.1, p = -Math.pow(u - h, 2) / (2 * v * v), w = e.peakCurrent * Math.exp(p), b = S * e.peakCurrent * 0.1, g = (Math.random() - 0.5) * 2 * e.noise * e.peakCurrent;
+      r[s] = S * w + b + g;
     }
-  return { x: s, y: o };
+  return { x: o, y: r };
 }
-function $e(r) {
+function gt(n) {
   const e = {
     pointCount: 50,
     rSolution: 100,
@@ -849,380 +1144,397 @@ 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), o = new Float32Array(e.pointCount), r = Math.log10(e.frequency[1]), a = Math.log10(e.frequency[0]);
+  for (let d = 0; d < e.pointCount; d++) {
+    const c = a - (a - r) * (d / (e.pointCount - 1)), i = 2 * Math.PI * Math.pow(10, c), s = e.rCharge * 1e-5, u = e.rSolution + e.rCharge / (1 + Math.pow(i * s, 2)), h = i * s * e.rCharge / (1 + Math.pow(i * s, 2));
+    t[d] = u, o[d] = -h;
   }
-  return { x: t, y: s };
+  return { x: t, y: o };
 }
-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() {
+  }, o = [], r = [];
+  let a = 0;
+  const d = n.getAllSeries().reduce((c, i) => c + i.getPointCount(), 0);
+  return new Promise((c) => {
+    const i = performance.now() + t.warmup + t.duration, s = performance.now() + t.warmup;
+    let u = !1, h = 0;
+    function S() {
       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 = r.length > 0 ? r.reduce((P, x) => P + x, 0) / r.length : 0, g = h > 0 ? v - h : t.duration, y = a > 0 && g > 0 ? a / g * 1e3 : 0, f = o.length > 0 ? o.reduce((P, x) => P + x, 0) / o.length : b > 0 ? 1e3 / b : 0, l = {
+          avgFps: Math.round(y * 100) / 100,
+          minFps: Math.round((o.length > 0 ? Math.min(...o) : y) * 100) / 100,
+          maxFps: Math.round((o.length > 0 ? Math.max(...o) : y) * 100) / 100,
+          avgFrameTime: Math.round(b * 1e3) / 1e3,
+          frameCount: a,
           duration: t.duration,
-          pointsRendered: c,
-          throughput: Math.round(c * p / 1e3) * 1e3
+          pointsRendered: d,
+          throughput: Math.round(d * y / 1e3) * 1e3,
+          /** @internal render-only FPS (not wall clock) */
+          ...f > 0 ? { renderFps: Math.round(f * 100) / 100 } : {}
         };
-        i(m);
+        c(l);
         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 && !u && (u = !0, h = v, a = 0, r.length = 0, o.length = 0);
+      const p = performance.now();
+      n.render();
+      const w = performance.now();
+      if (u) {
+        const b = w - p;
+        r.push(b), a++;
+        const g = r.slice(-30);
+        if (g.length > 0) {
+          const y = g.reduce((f, l) => f + l, 0) / g.length;
+          y > 0 && o.push(1e3 / y);
         }
       }
-      u = v, requestAnimationFrame(b);
+      requestAnimationFrame(S);
     }
-    requestAnimationFrame(b);
+    requestAnimationFrame(S);
   });
 }
-function He(r, e) {
+function ht(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 = {
+  }, o = n.getAllSeries().map((a) => ({
+    id: a.getId(),
+    type: a.getType(),
+    pointCount: a.getPointCount(),
+    ...t.includeStyles ? { style: a.getStyle() } : {}
+  })), r = {
     timestamp: Date.now(),
     config: {},
-    series: s,
-    bounds: r.getViewBounds()
+    series: o,
+    bounds: n.getViewBounds()
   };
-  return t.format === "png" && r.exportImage && (o.image = r.exportImage()), o;
+  return t.format === "png" && n.exportImage && (r.image = n.exportImage()), r;
 }
-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 mt(n, e, t = 1e-6) {
+  const o = [];
+  n.series.length !== e.series.length && o.push(`Series count: ${n.series.length} vs ${e.series.length}`);
+  for (let a = 0; a < Math.min(n.series.length, e.series.length); a++) {
+    const d = n.series[a], c = e.series[a];
+    d.id !== c.id && o.push(`Series[${a}] id: "${d.id}" vs "${c.id}"`), d.type !== c.type && o.push(`Series[${a}] type: "${d.type}" vs "${c.type}"`), d.pointCount !== c.pointCount && o.push(`Series[${a}] pointCount: ${d.pointCount} vs ${c.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 r = ["xMin", "xMax", "yMin", "yMax"];
+  for (const a of r)
+    Math.abs(n.bounds[a] - e.bounds[a]) > t && o.push(`Bounds.${a}: ${n.bounds[a]} vs ${e.bounds[a]}`);
   return {
-    equal: s.length === 0,
-    differences: s
+    equal: o.length === 0,
+    differences: o
   };
 }
-function We(r, e) {
+function yt(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 xt(n = 1) {
   return new Promise((e) => {
-    let t = r;
-    function s() {
-      t--, t <= 0 ? e() : requestAnimationFrame(s);
+    let t = n;
+    function o() {
+      t--, t <= 0 ? e() : requestAnimationFrame(o);
     }
-    requestAnimationFrame(s);
+    requestAnimationFrame(o);
   });
 }
-function Ne(r) {
-  return new Promise((e) => setTimeout(e, r));
-}
-function Ve(r) {
-  const t = {
-    id: r.seriesId ?? `${r.id}-indicator`,
-    data: r.data,
-    style: r.style,
-    name: r.label
-  }, s = fe(t);
-  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
-  };
+function vt(n) {
+  return new Promise((e) => setTimeout(e, n));
 }
 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
+  St as AnimationEngine,
+  In as AnnotationManager,
+  Za as BackpressureManager,
+  xo as BaseBufferStore,
+  vo as BaseTextureStore,
+  tt as BuiltinPlugins,
+  sr as ChartGroup,
+  Tt as ChartInitQueue,
+  eo as CircularBuffer,
+  Oo as ClipboardManager,
+  Se as CrosshairPlugin,
+  ee as DARK_THEME,
+  bt as DEFAULT_ANIMATION_CONFIG,
+  _o as DEFAULT_KEY_BINDINGS,
+  At as DEFAULT_LAYOUT,
+  Mt as DEFAULT_THEME,
+  Ee as DataLoggerPlugin,
+  jo as DebugOverlay,
+  Le as DirectionIndicatorPlugin,
+  Ct as ELECTROCHEM_THEME,
+  Tn as EventEmitter,
+  Po as GpuBenchmark,
+  wo as GpuCompute,
+  Hn as GpuRenderer,
+  Fe as GridHighlightPlugin,
+  Go as KeyBindingManager,
+  Ft as LIGHT_THEME,
+  Ao as LOCALE_DE_DE,
+  Mo as LOCALE_EN_US,
+  Co as LOCALE_ES_ES,
+  Fo as LOCALE_FR_FR,
+  Do as LOCALE_JA_JP,
+  Eo as LOCALE_PT_BR,
+  Io as LOCALE_ZH_CN,
+  O as LinearScale,
+  tr as LoadingIndicator,
+  Dt as LogScale,
+  Et as MIDNIGHT_THEME,
+  It as NativeWebGLRenderer,
+  Pe as OverlayRenderer,
+  So as PipelineCache,
+  di as Plugin3D,
+  va as PluginAnalysis,
+  Ln as PluginAnnotations,
+  Pi as PluginAnomalyDetection,
+  Wi as PluginBrokenAxis,
+  Yi as PluginCaching,
+  Ho as PluginClipboard,
+  xi as PluginContextMenu,
+  mi as PluginDataExport,
+  Li as PluginDataTransform,
+  Jo as PluginDebug,
+  nt as PluginDragEdit,
+  fr as PluginDrawingTools,
+  Vi as PluginForecasting,
+  To as PluginGpu,
+  fi as PluginI18n,
+  Wo as PluginKeyboard,
+  Ri as PluginLaTeX,
+  _i as PluginLazyLoad,
+  nr as PluginLoading,
+  Si as PluginMLIntegration,
+  Lt as PluginManagerImpl,
+  Oi as PluginOffscreen,
+  bi as PluginPatternRecognition,
+  qi as PluginROI,
+  Fi as PluginRadar,
+  Mi as PluginRegression,
+  gr as PluginReplay,
+  Ei as PluginSnapshot,
+  to as PluginStreaming,
+  pi as PluginSync,
+  yr as PluginThemeEditor,
+  Qn as PluginTools,
+  Ui as PluginVideoRecorder,
+  aa as PluginVirtualization,
+  kt as SERIALIZATION_VERSION,
+  po as STACKED_DEFAULT_MIN_PANE_RATIO,
+  ho as STACKED_MAX_PANES,
+  uo as SciPlot,
+  Rt as Series,
+  qn as SeriesAdapter,
+  Xt as StateHistory,
+  be as StatsPlugin,
+  xr as THEME_PRESETS,
+  Zn as TOOLTIP_THEMES,
+  vr as ThemeEditor,
+  ea as TooltipManager,
+  Me as WatermarkPlugin,
+  Nn as WebGLBackend,
+  Vn as WebGPUBackend,
+  ae as WebGPURenderer,
+  ma as WorkerPool,
+  Yt as addIndicatorToChart,
+  $r as adx,
+  Pa as analyzeComplexSpectrum,
+  wa as analyzeSpectrum,
+  bn as applyBusinessDayX,
+  Or as aroon,
+  Sa as arraysToComplex,
+  yt as assertPerformance,
+  Hr as atr,
+  Ta as autoCorrelation,
+  ba as bandPassFilter,
+  Aa as bandStopFilter,
+  pr as barsToOhlc,
+  Ue as benchmarkCanvasGrid,
+  pt as benchmarkRender,
+  $e as benchmarkWebGLGrid,
+  Ma as blackmanWindow,
+  qr as bollingerBands,
+  Bt as bollingerBandsAsync,
+  _t as buildIndicatorPane,
+  Gt as buildIndicatorPaneFromPreset,
+  Wt as buildIndicatorSeries,
+  zt as buildPositionLineAnnotation,
+  An as businessDaySpanMs,
+  Ca as butterworth,
+  Br as calculateR2,
+  br as calculateStats,
+  oa as calculateTargetPoints,
+  Rn as checkPluginCompatibility,
+  at as compareGridBackends,
+  rt as compareScenarioToBaseline,
+  mt as compareSnapshots,
+  Fa as complexToArrays,
+  Ut as compressString,
+  $t as computeHeikinAshi,
+  Ot as computeIndicatorFromSeries,
+  Ht as computeIndicatorPreset,
+  no as connectStreamToChart,
+  qo as copyToClipboard,
+  ao as createBackpressureManager,
+  qt as createChart,
+  lr as createChartGroup,
+  Xn as createConfigurablePlugin,
+  Qo as createDebugOverlay,
+  Kn as createGpuRenderer,
+  Nt as createIndicatorSeries,
+  zo as createKeyBinding,
+  ar as createLoadingIndicator,
+  Lo as createLocaleFormatter,
+  oo as createLosslessBackpressure,
+  cr as createMasterSlave,
+  ro as createMessageParser,
+  hr as createMockDatafeed,
+  io as createMockStream,
+  Vt as createNativeRenderer,
+  Yn as createPlugin,
+  Kt as createPluginContext,
+  so as createRealtimeBackpressure,
+  Bn as createRenderer,
+  jt as createScale,
+  ht as createSnapshot,
+  mo as createStackedChart,
+  Jt as createTheme,
+  Pr as createThemeEditor,
+  lo as createWebSocketStream,
+  Da as crossCorrelation,
+  Nr as cumsum,
+  _r as cumulativeIntegral,
+  Qt as decodeFloat32Array,
+  Zt as decompressString,
+  _n as defineAndRegister,
+  G as definePlugin,
+  Vr as dema,
+  Gr as derivative,
+  ra as destroyDownsamplePool,
+  en as destroyIndicatorPool,
+  Ea as detectAnomalies,
+  Ar as detectCycles,
+  tn as detectIndicatorMarkers,
+  Mr as detectPeaks,
+  Ia as dominantFrequency,
+  ia as downsampleAsync,
+  Cr as downsampleLTTB,
+  nn as easings,
+  Kr as ema,
+  an as emaAsync,
+  Zo as enableDebugMode,
+  on as encodeFloat32Array,
+  it as evaluateRendererCompare,
+  La as exponentialMovingAverage,
+  ka as fft,
+  Ra as fftFromComplexInput,
+  Mn as formatBusinessDayTick,
+  No as formatData,
+  Fr as formatScientific,
+  Dr as formatValue,
+  Er as formatWithPrefix,
+  Xa as gaussianSmooth,
+  ft as generateCVData,
+  Ir as generateCycleColors,
+  gt as generateNyquistData,
+  ut as generateRandomData,
+  ct as generateSawtoothWave,
+  st as generateSineWave,
+  lt as generateSquareWave,
+  dt as generateTriangleWave,
+  ot as getBaseline,
+  Lr as getBestPrefix,
+  rn as getChartInitQueue,
+  Vo as getClipboardManager,
+  sa as getDownsamplePoolSize,
+  ko as getGlobalLocale,
+  Ro as getLocale,
+  Gn as getPluginRegistry,
+  Ya as getPositiveFrequencies,
+  wr as getPresetNames,
+  Sr as getPresetTheme,
+  sn as getSharedAnimationEngine,
+  ln as getThemeByName,
+  ta as getTooltipThemeForChartTheme,
+  Ba as hammingWindow,
+  _a as hanningWindow,
+  Ga as highPassFilter,
+  Wa as ifft,
+  za as ifftComplex,
+  Ua as ifftFromArrays,
+  Wr as integrate,
+  cn as interleaveData,
+  Cn as isBusinessDay,
+  Fn as isBusinessDayScaleActive,
+  dr as linkCharts,
+  Wn as listPluginsByCategory,
+  zn as loadPlugin,
+  $a as lowPassFilter,
+  la as lowerBoundX,
+  ca as lttbDownsample,
+  jr as macd,
+  dn as macdAsync,
+  Dn as mapToBusinessDayScale,
+  Oa as medianFilter,
+  un as mergeAnimationConfig,
+  fn as mergeLayoutOptions,
+  da as minMaxDownsample,
+  Jr as momentum,
+  kr as movingAverage,
+  Ha as nextPowerOf2,
+  ya as nextTaskId,
+  Qr as normalize,
+  Zr as obv,
+  ua as ohlcDownsampleAsync,
+  fa as ohlcMinMaxDownsample,
+  gn as parseColor,
+  jn as parseColorToRGBA,
+  Uo as parseShortcut,
+  ei as percentChange,
+  qa as powerSpectrum,
+  pn as queueChartInit,
+  Xo as registerLocale,
+  Un as registerPlugin,
+  hn as resetChartQueue,
+  ti as roc,
+  ni as rsi,
+  mn as rsiAsync,
+  Na as savitzkyGolay,
+  Yo as setGlobalLocale,
+  or as showLoading,
+  rr as showProgress,
+  Va as simpsonsIntegration,
+  Ka as singleFrequencyFilter,
+  ga as sliceSeriesToViewport,
+  ai as sma,
+  yn as smaAsync,
+  zr as solveLinearSystem,
+  oi as standardDeviation,
+  xn as stateToUrlHash,
+  ri as stochastic,
+  Rr as subtractBaseline,
+  ja as tTest,
+  ii as tema,
+  Ja as trapezoidalIntegration,
+  pa as upperBoundX,
+  vn as urlHashToState,
+  fo as useSciPlot,
+  Pn as validateChartState,
+  Xr as validateData,
+  $n as validateManifest,
+  si as vwap,
+  vt as waitFor,
+  wn as waitForAnimations,
+  xt as waitForFrames,
+  li as wma
 };
 //# sourceMappingURL=velo-plot.full.js.map