velo-plot 2.20.0 → 3.1.0

package/dist/velo-plot.full.js

@@ -1,211 +1,1597 @@
-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-ivzLqxVb.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-ivzLqxVb.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-CzumxpCL.js";
-import { AnnotationManager as In, PluginAnnotations as Ln } from "./plugins/annotations.js";
-import { d as G } from "./index.core-COREBDNq.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-COREBDNq.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-qunX30Xu.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-BBpJwOct.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, generateContours as Ya, getPositiveFrequencies as Ba, hammingWindow as _a, hanningWindow as Ga, highPassFilter as Wa, ifft as za, ifftComplex as Ua, ifftFromArrays as $a, joinSegments as Oa, lowPassFilter as Ha, medianFilter as qa, nextPowerOf2 as Na, powerSpectrum as Va, savitzkyGolay as Ka, simpsonsIntegration as ja, singleFrequencyFilter as Ja, tTest as Qa, trapezoidalIntegration as Za } from "./plugins/analysis.js";
-import { B as to, C as no, P as ao, a as oo, e as ro, g as io, b as so, d as lo, f as co, c as uo } from "./index-BMiZoKmm.js";
-import { S as go, u as po } from "./SciPlot-CEU4ApgD.js";
-import "react";
-import { a as mo, S as yo, c as xo } from "./createStackedChart-DxNW0VkF.js";
-import { BaseBufferStore as Po, BaseTextureStore as wo, GpuBenchmark as So, GpuCompute as To, PipelineCache as bo, PluginGpu as Ao } from "./plugins/gpu.js";
-import { b as Co, L as Fo, a as Do, c as Eo, f as Io, d as Lo, e as ko, i as Ro, g as Xo, h as Yo, r as Bo, s as _o } from "./index-x4stH3jD.js";
-import { D as Wo, K as zo, P as Uo, c as $o, p as Oo } from "./index-DoYxf1cV.js";
-import { ClipboardManager as qo, PluginClipboard as No, copyToClipboard as Vo, formatData as Ko, getClipboardManager as jo } from "./plugins/clipboard.js";
-import { DebugOverlay as Qo, PluginDebug as Zo, createDebugOverlay as er, enableDebugMode as tr } from "./plugins/debug.js";
-import { L as ar, P as or, c as rr, s as ir, a as sr } from "./index-qhscKTDy.js";
-import { C as cr, c as dr, a as ur, l as fr } from "./index-CaXWSOTk.js";
-import { P as pr, a as hr, b as mr, c as yr } from "./mockDatafeed-927foCM4.js";
-import { P as vr, b as Pr, T as wr, c as Sr, a as Tr, g as br } from "./index-Dag88bW4.js";
-import { c as Mr, a as Cr, b as Fr, d as Dr, h as Er, e as Ir, f as Lr, g as kr, i as Rr, m as Xr, s as Yr, v as Br } from "./utils-BK5UUXxj.js";
-import { a as Gr, c as Wr, d as zr, i as Ur, s as $r } from "./math-Ddm2EZjj.js";
-import { i as Hr, j as qr, g as Nr, f as Vr, k as Kr, d as jr, e as Jr, m as Qr, c as Zr, n as ei, o as ti, p as ni, b as ai, r as oi, s as ri, h as ii, a as si, t as li, v as ci, w as di } from "./indicators--eJGmVox.js";
-import { Plugin3D as fi } from "./plugins/3d.js";
-import { PluginI18n as pi } from "./plugins/i18n.js";
-import { PluginSync as mi } from "./plugins/sync.js";
-import { PluginDataExport as xi } from "./plugins/data-export.js";
-import { PluginContextMenu as Pi } from "./plugins/context-menu.js";
-import { PluginAnomalyDetection as Si } from "./plugins/anomaly-detection.js";
-import { PluginMLIntegration as bi } from "./plugins/ml-integration.js";
-import { PluginPatternRecognition as Mi } from "./plugins/pattern-recognition.js";
-import { PluginRegression as Fi } from "./plugins/regression.js";
-import { PluginRadar as Ei } from "./plugins/radar.js";
-import { PluginSnapshot as Li } from "./plugins/snapshot.js";
-import { PluginDataTransform as Ri } from "./plugins/data-transform.js";
-import { PluginLaTeX as Yi } from "./plugins/latex.js";
-import { PluginCaching as _i } from "./plugins/caching.js";
-import { PluginLazyLoad as Wi } from "./plugins/lazy-load.js";
-import { PluginBrokenAxis as Ui } from "./plugins/broken-axis.js";
-import { PluginVideoRecorder as Oi } from "./plugins/video-recorder.js";
-import { PluginOffscreen as qi } from "./plugins/offscreen.js";
-import { PluginROI as Vi } from "./plugins/roi.js";
-import { PluginForecasting as ji } from "./plugins/forecasting.js";
-class ae {
-  constructor(e, t = {}) {
-    Y(this, "available");
-    Y(this, "canvas");
-    Y(this, "adapter");
-    Y(this, "device");
-    Y(this, "context");
-    this.canvas = e, this.available = ae.isSupported();
+var Oe = Object.defineProperty;
+var He = (t, e, r) => e in t ? Oe(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var W = (t, e, r) => He(t, typeof e != "symbol" ? e + "" : e, r);
+import { c as ze } from "./index-Cv6ZDLWf.js";
+import { P as tn, a as rn, b as nn, d as on } from "./index-Cv6ZDLWf.js";
+import { g as Ne, h as Ue, a as ge, c as pe } from "./axisFormat-Sz4WIJfQ.js";
+import { E as sn, b as ln, f as cn, i as un, m as dn } from "./axisFormat-Sz4WIJfQ.js";
+import { a as qe, h as je } from "./createStackedChart-DqcLCFGS.js";
+import { i as hn, S as gn, b as pn, k as mn, f as yn, g as xn, l as bn, j as vn, c as wn, d as Pn, n as Sn, e as Tn, m as An, r as Cn, s as Mn } from "./createStackedChart-DqcLCFGS.js";
+import { r as U, k as De, l as Ke, n as Je, o as Qe, q as Ze, s as et, t as tt, u as oe, p as ae, v as me, w as rt, H as nt, x as ot, C as ue, N as Le, y as Q, z as ye, A as at, B as it, F as st, D as xe, L as se, O as lt } from "./ChartCore-AnR_3Xkb.js";
+import { G as En, R as Dn, J as Ln, X as kn, e as In, E as Rn, d as $n, a as Bn, M as _n, P as Yn, Y as Xn, S as Wn, a4 as Vn, $ as Gn, c as On, h as Hn, b as zn, f as Nn, _ as Un, a0 as qn, I as jn, Z as Kn, T as Jn, Q as Qn, g as Zn, K as eo, m as to, U as ro, W as no, a1 as oo, a2 as ao, a3 as io, V as so } from "./ChartCore-AnR_3Xkb.js";
+import { P as co, c as uo, a as fo, d as ho, g as go, e as po, l as mo, m as yo, o as xo, b as bo, s as vo, u as wo } from "./index-0InEyj0q.js";
+import { W as So, n as To } from "./pool-DZ8shSqv.js";
+import { PluginAnalysis as Co, analyzeComplexSpectrum as Mo, analyzeSpectrum as Fo, arraysToComplex as Eo, autoCorrelation as Do, bandPassFilter as Lo, bandStopFilter as ko, blackmanWindow as Io, butterworth as Ro, complexToArrays as $o, crossCorrelation as Bo, detectAnomalies as _o, dominantFrequency as Yo, exponentialMovingAverage as Xo, fft as Wo, fftFromComplexInput as Vo, gaussianSmooth as Go, generateContours as Oo, getPositiveFrequencies as Ho, hammingWindow as zo, hanningWindow as No, highPassFilter as Uo, ifft as qo, ifftComplex as jo, ifftFromArrays as Ko, joinSegments as Jo, lowPassFilter as Qo, medianFilter as Zo, nextPowerOf2 as ea, powerSpectrum as ta, savitzkyGolay as ra, simpsonsIntegration as na, singleFrequencyFilter as oa, tTest as aa, trapezoidalIntegration as ia } from "./plugins/analysis.js";
+import { SciChart as la, SciPlot as ca, StackedPlot as ua, VeloPlot as da, useChartGroup as fa, useChartSync as ha, useIndicator as ga, useSciChart as pa, useSciPlot as ma, useStackedPlot as ya, useVeloPlot as xa } from "./react.js";
+import { LOCALE_DE_DE as va, LOCALE_EN_US as wa, LOCALE_ES_ES as Pa, LOCALE_FR_FR as Sa, LOCALE_JA_JP as Ta, LOCALE_PT_BR as Aa, LOCALE_ZH_CN as Ca, PluginI18n as Ma, createLocaleFormatter as Fa, getGlobalLocale as Ea, getLocale as Da, registerLocale as La, setGlobalLocale as ka } from "./plugins/i18n.js";
+import { D as Ra, K as $a, c as Ba, p as _a } from "./index-CWxIHdwX.js";
+import { ClipboardManager as Xa, PluginClipboard as Wa, copyToClipboard as Va, formatData as Ga, getClipboardManager as Oa } from "./plugins/clipboard.js";
+import { DebugOverlay as za, PluginDebug as Na, createDebugOverlay as Ua, enableDebugMode as qa } from "./plugins/debug.js";
+import { L as Ka, P as Ja, c as Qa, s as Za, a as ei } from "./index-qhscKTDy.js";
+import { C as ri, c as ni, a as oi, l as ai } from "./index-CaXWSOTk.js";
+import { P as si, b as li, T as ci, c as ui, a as di, g as fi } from "./index-Dag88bW4.js";
+import { B as gi, C as pi, P as mi, a as yi, e as xi, g as bi, b as vi, d as wi, f as Pi, c as Si } from "./index-BgrvqltV.js";
+import { AnnotationManager as Ai, PluginAnnotations as Ci } from "./plugins/annotations.js";
+import { d as Z } from "./PluginRegistry-CzMHebYP.js";
+import { e as Fi, c as Ei, a as Di, g as Li, b as ki, l as Ii, r as Ri, v as $i } from "./PluginRegistry-CzMHebYP.js";
+import { P as _i, a as Yi, T as Xi, g as Wi } from "./index-B7PTX94B.js";
+import { h as Gi, d as Oi, e as Hi, i as zi, b as Ni, a as Ui, f as qi, c as ji, g as Ki, m as Ji, s as Qi, v as Zi } from "./utils-Dx0h0bgQ.js";
+import { a as ts, c as rs, d as ns, i as os, s as as } from "./math-Ddm2EZjj.js";
+import { BaseBufferStore as ss, BaseTextureStore as ls, GpuBenchmark as cs, GpuCompute as us, GpuRenderer as ds, PipelineCache as fs, PluginGpu as hs, SeriesAdapter as gs, WebGLBackend as ps, WebGPUBackend as ms, createGpuRenderer as ys, parseColorToRGBA as xs } from "./plugins/gpu.js";
+import { i as vs, j as ws, g as Ps, f as Ss, k as Ts, d as As, e as Cs, m as Ms, c as Fs, n as Es, o as Ds, p as Ls, b as ks, r as Is, s as Rs, h as $s, a as Bs, t as _s, v as Ys, w as Xs } from "./indicators--eJGmVox.js";
+import { Plugin3D as Vs } from "./plugins/3d.js";
+import { PluginKeyboard as Os } from "./plugins/keyboard.js";
+import { PluginSync as zs } from "./plugins/sync.js";
+import { PluginDataExport as Us } from "./plugins/data-export.js";
+import { PluginContextMenu as js } from "./plugins/context-menu.js";
+import { PluginAnomalyDetection as Js } from "./plugins/anomaly-detection.js";
+import { PluginMLIntegration as Zs } from "./plugins/ml-integration.js";
+import { PluginPatternRecognition as tl } from "./plugins/pattern-recognition.js";
+import { PluginRegression as nl } from "./plugins/regression.js";
+import { PluginRadar as al } from "./plugins/radar.js";
+import { PluginSnapshot as sl } from "./plugins/snapshot.js";
+import { PluginDataTransform as cl } from "./plugins/data-transform.js";
+import { PluginLaTeX as dl } from "./plugins/latex.js";
+import { PluginCaching as hl } from "./plugins/caching.js";
+import { PluginLazyLoad as pl } from "./plugins/lazy-load.js";
+import { PluginBrokenAxis as yl } from "./plugins/broken-axis.js";
+import { PluginVideoRecorder as bl } from "./plugins/video-recorder.js";
+import { PluginOffscreen as wl } from "./plugins/offscreen.js";
+import { PluginROI as Sl } from "./plugins/roi.js";
+import { PluginForecasting as Al } from "./plugins/forecasting.js";
+function ct(t, e, r, n, o, a, i) {
+  const l = t.length, s = i / 2, c = new Float32Array(l * 20), u = new Float32Array(l * 12);
+  let d = 0, y = 0;
+  for (let h = 0; h < l; h++) {
+    const g = t[h], w = e[h], b = r[h], m = n[h], v = o[h], p = a[h];
+    c[d++] = g, c[d++] = w, c[d++] = g, c[d++] = b, c[d++] = g, c[d++] = v, c[d++] = g, c[d++] = p, c[d++] = g - s, c[d++] = m, c[d++] = g + s, c[d++] = m, c[d++] = g - s, c[d++] = b, c[d++] = g + s, c[d++] = b, c[d++] = g - s, c[d++] = v, c[d++] = g + s, c[d++] = v, u[y++] = g - s, u[y++] = b, u[y++] = g + s, u[y++] = b, u[y++] = g + s, u[y++] = v, u[y++] = g - s, u[y++] = b, u[y++] = g + s, u[y++] = v, u[y++] = g - s, u[y++] = v;
+  }
+  return { lines: c, boxes: u };
+}
+function ut(t, e, r, n) {
+  const o = t.length, a = r / 2, i = new Float32Array(o * 12), l = new Float32Array(o * 12), s = new Float32Array(o * 12), c = new Float32Array((o - 1) * 4);
+  let u = 0, d = 0, y = 0, h = 0, g = 0;
+  for (let w = 0; w < o; w++) {
+    const b = t[w], m = e[w], v = (n == null ? void 0 : n[w]) ?? !1;
+    let p, f;
+    if (v ? (p = 0, f = g, s[y++] = b - a, s[y++] = p, s[y++] = b + a, s[y++] = p, s[y++] = b + a, s[y++] = f, s[y++] = b - a, s[y++] = p, s[y++] = b + a, s[y++] = f, s[y++] = b - a, s[y++] = f) : (p = g, f = g + m, g = f, m >= 0 ? (i[u++] = b - a, i[u++] = p, i[u++] = b + a, i[u++] = p, i[u++] = b + a, i[u++] = f, i[u++] = b - a, i[u++] = p, i[u++] = b + a, i[u++] = f, i[u++] = b - a, i[u++] = f) : (l[d++] = b - a, l[d++] = f, l[d++] = b + a, l[d++] = f, l[d++] = b + a, l[d++] = p, l[d++] = b - a, l[d++] = f, l[d++] = b + a, l[d++] = p, l[d++] = b - a, l[d++] = p)), w < o - 1) {
+      const T = t[w + 1];
+      c[h++] = b + a, c[h++] = f, c[h++] = T - a, c[h++] = f;
+    }
+  }
+  return {
+    positiveData: i.subarray(0, u),
+    negativeData: l.subarray(0, d),
+    subtotalData: s.subarray(0, y),
+    connectorData: c.subarray(0, h),
+    positiveCount: u / 2,
+    negativeCount: d / 2,
+    subtotalCount: y / 2
+  };
+}
+function dt(t, e, r) {
+  const n = Math.min(t.length, e.length), o = new Float32Array(n * 6 * 2), a = r * 0.5;
+  for (let i = 0; i < n; i++) {
+    const l = t[i], s = e[i], c = i * 12, u = l - a, d = l + a, y = 0, h = s;
+    o[c + 0] = u, o[c + 1] = y, o[c + 2] = d, o[c + 3] = y, o[c + 4] = u, o[c + 5] = h, o[c + 6] = u, o[c + 7] = h, o[c + 8] = d, o[c + 9] = y, o[c + 10] = d, o[c + 11] = h;
+  }
+  return o;
+}
+function le(t) {
+  if (t.length < 2) return 1;
+  let e = 1 / 0;
+  for (let r = 1; r < t.length; r++) {
+    const n = Math.abs(t[r] - t[r - 1]);
+    n > 0 && n < e && (e = n);
+  }
+  return e === 1 / 0 ? 1 : e * 0.8;
+}
+function ft(t, e, r) {
+  const n = t.length, o = e.length;
+  n * o > r.length && console.warn("[Heatmap] Z array is too small for the specified grid dimensions");
+  const a = (n - 1) * (o - 1), i = new Float32Array(a * 6 * 3);
+  let l = 0;
+  for (let s = 0; s < o - 1; s++)
+    for (let c = 0; c < n - 1; c++) {
+      const u = t[c], d = t[c + 1], y = e[s], h = e[s + 1], g = r[s * n + c], w = r[s * n + (c + 1)], b = r[(s + 1) * n + c], m = r[(s + 1) * n + (c + 1)];
+      i[l++] = u, i[l++] = y, i[l++] = g, i[l++] = d, i[l++] = y, i[l++] = w, i[l++] = u, i[l++] = h, i[l++] = b, i[l++] = u, i[l++] = h, i[l++] = b, i[l++] = d, i[l++] = y, i[l++] = w, i[l++] = d, i[l++] = h, i[l++] = m;
+    }
+  return i;
+}
+function ht(t = "viridis") {
+  const r = new Uint8Array(1024);
+  for (let n = 0; n < 256; n++) {
+    const o = n / 255;
+    let a, i, l;
+    t === "jet" ? (a = Math.min(Math.max(1.5 - Math.abs(o * 4 - 3), 0), 1), i = Math.min(Math.max(1.5 - Math.abs(o * 4 - 2), 0), 1), l = Math.min(Math.max(1.5 - Math.abs(o * 4 - 1), 0), 1)) : t === "grayscale" ? a = i = l = o : t === "plasma" ? (a = 0.5 + 0.5 * Math.sin(Math.PI * (o - 0.5)), i = 0.5 + 0.5 * Math.sin(Math.PI * o), l = 0.8) : (a = 0.267 * (1 - o) + 0.993 * o, i = 5e-3 * (1 - o) + 0.906 * o, l = 0.337 * (1 - o) + 0.144 * o), r[n * 4 + 0] = a * 255, r[n * 4 + 1] = i * 255, r[n * 4 + 2] = l * 255, r[n * 4 + 3] = 255;
+  }
+  return r;
+}
+function gt(t, e, r, n, o, a, i = !1) {
+  const l = t.length, s = [], c = [], u = a / 2, y = a / 10 / 2;
+  for (let h = 0; h < l; h++) {
+    if (!Number.isFinite(t[h])) continue;
+    const g = o[h] >= e[h], w = g ? s : c, b = Math.max(e[h], o[h]), m = Math.min(e[h], o[h]);
+    i && g || be(w, t[h] - u, m, t[h] + u, b), be(w, t[h] - y, n[h], t[h] + y, r[h]);
+  }
+  return {
+    bullish: new Float32Array(s),
+    bearish: new Float32Array(c)
+  };
+}
+function be(t, e, r, n, o) {
+  t.push(e, r, n, r, e, o), t.push(n, r, n, o, e, o);
+}
+function de(t, e) {
+  const r = e.getData(), n = e.getId(), o = e.getType();
+  if (e.hasErrorData()) {
+    const a = Ze(
+      r.x,
+      r.y,
+      {
+        yError: r.yError,
+        yErrorMinus: r.yErrorMinus,
+        yErrorPlus: r.yErrorPlus
+      },
+      {
+        xError: r.xError,
+        xErrorMinus: r.xErrorMinus,
+        xErrorPlus: r.xErrorPlus
+      }
+    );
+    t.renderer.createBuffer(`${n}_errors`, a);
+  }
+  if (o === "step" || o === "step+scatter") {
+    const a = e.getStyle().stepMode ?? "after";
+    t.renderer.createBuffer(
+      `${n}_step`,
+      et(r.x, r.y, a)
+    );
+  }
+}
+function pt(t, e) {
+  const r = e.getData(), n = e.getStyle().barWidth ?? le(r.x);
+  t.renderer.createBuffer(
+    e.getId(),
+    dt(r.x, r.y, n)
+  ), de(t, e), e.resetLastAppendCount();
+}
+function mt(t, e) {
+  var a, i, l;
+  (i = (a = t.renderer) == null ? void 0 : a.installHeatmapProgram) == null || i.call(a);
+  const r = e.getHeatmapData(), n = e.getHeatmapStyle();
+  if (!r || r.xValues.length < 2) return;
+  t.renderer.createBuffer(
+    e.getId(),
+    ft(r.xValues, r.yValues, r.zValues)
+  );
+  const o = ((l = n == null ? void 0 : n.colorScale) == null ? void 0 : l.name) || "viridis";
+  t.renderer.createColormapTexture(
+    `${e.getId()}_colormap`,
+    ht(o)
+  ), e.resetLastAppendCount();
+}
+function yt(t, e) {
+  const r = e.getData(), n = e.getId();
+  if (r.open && r.high && r.low && r.close) {
+    const o = e.getStyle().barWidth ?? le(r.x), a = !!e.getStyle().hollow, { bullish: i, bearish: l } = gt(
+      r.x,
+      r.open,
+      r.high,
+      r.low,
+      r.close,
+      o,
+      a
+    );
+    t.renderer.createBuffer(`${n}_bullish`, i), t.renderer.createBuffer(`${n}_bearish`, l), e.bullishCount = i.length / 2, e.bearishCount = l.length / 2;
+  }
+  e.resetLastAppendCount();
+}
+function xt(t, e) {
+  const r = e.getData(), n = e.getId();
+  if (r.low && r.open && r.median && r.close && r.high) {
+    const o = e.getStyle().barWidth ?? le(r.x), { lines: a, boxes: i } = ct(
+      r.x,
+      r.low,
+      r.open,
+      r.median,
+      r.close,
+      r.high,
+      o
+    );
+    t.renderer.createBuffer(`${n}_box_lines`, a), t.renderer.createBuffer(`${n}_box_faces`, i);
+  }
+  e.resetLastAppendCount();
+}
+function bt(t, e) {
+  const r = e.getData(), n = e.getId(), o = e.getStyle().barWidth ?? le(r.x), a = e.getStyle().isSubtotal, i = ut(r.x, r.y, o, a);
+  t.renderer.createBuffer(`${n}_wf_positive`, i.positiveData), t.renderer.createBuffer(`${n}_wf_negative`, i.negativeData), t.renderer.createBuffer(`${n}_wf_subtotal`, i.subtotalData), t.renderer.createBuffer(`${n}_wf_connectors`, i.connectorData), e.waterfallCounts = {
+    positive: i.positiveCount,
+    negative: i.negativeCount,
+    subtotal: i.subtotalCount,
+    connectors: i.connectorData.length / 2
+  }, e.resetLastAppendCount();
+}
+function vt(t, e) {
+  const r = e.getPolarData();
+  if (!r || r.r.length === 0) return;
+  const n = e.getStyle(), o = n.angleMode || "degrees", a = n.closePath !== !1;
+  if (n.fill || !1) {
+    const l = Ke(r, o, a);
+    t.renderer.createBuffer(e.getId(), l);
+  } else {
+    const l = Je(r, o, a);
+    t.renderer.createBuffer(e.getId(), l);
+  }
+  e.resetLastAppendCount();
+}
+function ve(t, e) {
+  const r = e.getData(), o = e.getType() === "area" ? new Float32Array(r.x.length).fill(0) : r.y2 || new Float32Array(r.x.length).fill(0);
+  t.renderer.createBuffer(e.getId(), Qe(r.x, r.y, o)), de(t, e), e.resetLastAppendCount();
+}
+function wt(t, e) {
+  const r = e.getData();
+  t.renderer.createBuffer(e.getId(), De(r.x, r.y)), de(t, e), e.resetLastAppendCount();
+}
+let we = !1;
+function Pt() {
+  if (!we) {
+    we = !0, U("bar", pt), U("heatmap", mt), U("candlestick", yt), U("boxplot", xt), U("waterfall", bt), U("polar", vt), U("band", ve), U("area", ve), U("heikin-ashi", (t, e) => {
+      var n;
+      const r = e.getData();
+      (n = r == null ? void 0 : r.x) != null && n.length && (t.renderer.createBuffer(e.getId(), De(r.x, r.y)), e.resetLastAppendCount());
+    });
+    for (const t of [
+      "line",
+      "scatter",
+      "line+scatter",
+      "step",
+      "step+scatter"
+    ])
+      U(t, wt);
+  }
+}
+function St(t, e, r, n, o, a = { min: 0, max: 1 }, i) {
+  t.useProgram(e.program), t.bindBuffer(t.ARRAY_BUFFER, r), t.enableVertexAttribArray(e.attributes.position), t.vertexAttribPointer(e.attributes.position, 2, t.FLOAT, !1, 12, 0), e.attributes.value !== void 0 && e.attributes.value !== -1 && (t.enableVertexAttribArray(e.attributes.value), t.vertexAttribPointer(e.attributes.value, 1, t.FLOAT, !1, 12, 8)), t.uniform2f(e.uniforms.uScale, o.scale[0], o.scale[1]), t.uniform2f(
+    e.uniforms.uTranslate,
+    o.translate[0],
+    o.translate[1]
+  ), e.uniforms.uMinValue && t.uniform1f(e.uniforms.uMinValue, a.min), e.uniforms.uMaxValue && t.uniform1f(e.uniforms.uMaxValue, a.max), i && e.uniforms.uColormap ? (t.activeTexture(t.TEXTURE0), t.bindTexture(t.TEXTURE_2D, i), t.uniform1i(e.uniforms.uColormap, 0)) : e.uniforms.uColormap && (t.activeTexture(t.TEXTURE0), t.bindTexture(t.TEXTURE_2D, null)), t.drawArrays(t.TRIANGLES, 0, n), t.disableVertexAttribArray(e.attributes.position), e.attributes.value !== void 0 && e.attributes.value !== -1 && t.disableVertexAttribArray(e.attributes.value);
+}
+function Tt(t, e, r, n, o, a) {
+  t.useProgram(e.program), t.bindBuffer(t.ARRAY_BUFFER, r), t.enableVertexAttribArray(e.attributes.position), t.vertexAttribPointer(e.attributes.position, 2, t.FLOAT, !1, 0, 0), t.uniform2f(e.uniforms.uScale, o.scale[0], o.scale[1]), t.uniform2f(
+    e.uniforms.uTranslate,
+    o.translate[0],
+    o.translate[1]
+  ), t.uniform4f(e.uniforms.uColor, a[0], a[1], a[2], a[3]), t.drawArrays(t.TRIANGLES, 0, n), t.disableVertexAttribArray(e.attributes.position);
+}
+function At(t, e, r, n, o) {
+  const a = tt(o);
+  t.useProgram(e.line.program), t.bindBuffer(t.ARRAY_BUFFER, r.boxBuffer), t.enableVertexAttribArray(e.line.attributes.position), t.vertexAttribPointer(e.line.attributes.position, 2, t.FLOAT, !1, 0, 0), t.uniform2f(e.line.uniforms.uScale, n.scale[0], n.scale[1]), t.uniform2f(
+    e.line.uniforms.uTranslate,
+    n.translate[0],
+    n.translate[1]
+  );
+  const i = [...a];
+  i[3] *= 0.5, t.uniform4f(e.line.uniforms.uColor, i[0], i[1], i[2], i[3]), t.drawArrays(t.TRIANGLES, 0, r.boxCount), t.uniform4f(e.line.uniforms.uColor, a[0], a[1], a[2], a[3]), t.lineWidth(o.width || 1), t.bindBuffer(t.ARRAY_BUFFER, r.linesBuffer), t.vertexAttribPointer(e.line.attributes.position, 2, t.FLOAT, !1, 0, 0), t.drawArrays(t.LINES, 0, r.linesCount), t.disableVertexAttribArray(e.line.attributes.position);
+}
+function Ct(t, e, r) {
+  St(
+    t.gl,
+    t.programs.heatmapProgram,
+    e.buffer,
+    e.count,
+    r,
+    e.zBounds,
+    e.colormapTexture
+  );
+}
+function Mt(t, e, r, n) {
+  Tt(
+    t.gl,
+    t.programs.lineProgram,
+    e.buffer,
+    e.count,
+    r,
+    n
+  );
+}
+function Ft(t, e, r) {
+  e.boxBuffer && e.boxLinesBuffer && At(
+    t.gl,
+    { line: t.programs.lineProgram, point: t.programs.pointProgram },
+    {
+      boxBuffer: e.boxBuffer,
+      boxCount: e.boxCount || 0,
+      linesBuffer: e.boxLinesBuffer,
+      linesCount: e.boxLinesCount || 0
+    },
+    r,
+    e.style
+  );
+}
+function Et(t, e, r) {
+  const { gl: n, programs: o, dpr: a } = t, i = ae(e.style.positiveColor || "#22c55e"), l = ae(e.style.negativeColor || "#ef4444"), s = ae(e.style.subtotalColor || "#3b82f6"), c = ae(e.style.connectorColor || "#64748b");
+  e.wfPositiveBuffer && e.wfPositiveCount && e.wfPositiveCount > 0 && (n.useProgram(o.lineProgram.program), n.bindBuffer(n.ARRAY_BUFFER, e.wfPositiveBuffer), n.enableVertexAttribArray(o.lineProgram.attributes.position), n.vertexAttribPointer(
+    o.lineProgram.attributes.position,
+    2,
+    n.FLOAT,
+    !1,
+    0,
+    0
+  ), n.uniform2f(
+    o.lineProgram.uniforms.uScale,
+    r.scale[0],
+    r.scale[1]
+  ), n.uniform2f(
+    o.lineProgram.uniforms.uTranslate,
+    r.translate[0],
+    r.translate[1]
+  ), n.uniform4f(
+    o.lineProgram.uniforms.uColor,
+    i[0],
+    i[1],
+    i[2],
+    0.9
+  ), n.drawArrays(n.TRIANGLES, 0, e.wfPositiveCount)), e.wfNegativeBuffer && e.wfNegativeCount && e.wfNegativeCount > 0 && (n.useProgram(o.lineProgram.program), n.bindBuffer(n.ARRAY_BUFFER, e.wfNegativeBuffer), n.enableVertexAttribArray(o.lineProgram.attributes.position), n.vertexAttribPointer(
+    o.lineProgram.attributes.position,
+    2,
+    n.FLOAT,
+    !1,
+    0,
+    0
+  ), n.uniform2f(
+    o.lineProgram.uniforms.uScale,
+    r.scale[0],
+    r.scale[1]
+  ), n.uniform2f(
+    o.lineProgram.uniforms.uTranslate,
+    r.translate[0],
+    r.translate[1]
+  ), n.uniform4f(
+    o.lineProgram.uniforms.uColor,
+    l[0],
+    l[1],
+    l[2],
+    0.9
+  ), n.drawArrays(n.TRIANGLES, 0, e.wfNegativeCount)), e.wfSubtotalBuffer && e.wfSubtotalCount && e.wfSubtotalCount > 0 && (n.useProgram(o.lineProgram.program), n.bindBuffer(n.ARRAY_BUFFER, e.wfSubtotalBuffer), n.enableVertexAttribArray(o.lineProgram.attributes.position), n.vertexAttribPointer(
+    o.lineProgram.attributes.position,
+    2,
+    n.FLOAT,
+    !1,
+    0,
+    0
+  ), n.uniform2f(
+    o.lineProgram.uniforms.uScale,
+    r.scale[0],
+    r.scale[1]
+  ), n.uniform2f(
+    o.lineProgram.uniforms.uTranslate,
+    r.translate[0],
+    r.translate[1]
+  ), n.uniform4f(
+    o.lineProgram.uniforms.uColor,
+    s[0],
+    s[1],
+    s[2],
+    0.9
+  ), n.drawArrays(n.TRIANGLES, 0, e.wfSubtotalCount)), e.style.showConnectors !== !1 && e.wfConnectorBuffer && e.wfConnectorCount && e.wfConnectorCount > 0 && (n.useProgram(o.lineProgram.program), n.bindBuffer(n.ARRAY_BUFFER, e.wfConnectorBuffer), n.enableVertexAttribArray(o.lineProgram.attributes.position), n.vertexAttribPointer(
+    o.lineProgram.attributes.position,
+    2,
+    n.FLOAT,
+    !1,
+    0,
+    0
+  ), n.uniform2f(
+    o.lineProgram.uniforms.uScale,
+    r.scale[0],
+    r.scale[1]
+  ), n.uniform2f(
+    o.lineProgram.uniforms.uTranslate,
+    r.translate[0],
+    r.translate[1]
+  ), n.uniform4f(
+    o.lineProgram.uniforms.uColor,
+    c[0],
+    c[1],
+    c[2],
+    0.6
+  ), n.lineWidth(1), n.drawArrays(n.LINES, 0, e.wfConnectorCount)), n.disableVertexAttribArray(o.lineProgram.attributes.position);
+}
+let Pe = !1;
+function Dt() {
+  Pe || (Pe = !0, oe(
+    "heatmap",
+    (t, e, r) => Ct(t, e, r)
+  ), oe(
+    "bar",
+    (t, e, r, n) => Mt(t, e, r, n)
+  ), oe(
+    "boxplot",
+    (t, e, r) => Ft(t, e, r)
+  ), oe(
+    "waterfall",
+    (t, e, r) => Et(t, e, r)
+  ));
+}
+function Lt(t, e, r, n) {
+  const { value: o, min: a, max: i } = e, {
+    needleColor: l = "#333",
+    needleWidth: s = 3,
+    ranges: c = [],
+    radius: u = 0.8,
+    startAngle: d = 135,
+    endAngle: y = 405,
+    showValue: h = !0,
+    valueColor: g = "#fff",
+    valueSize: w = 24,
+    label: b
+  } = r, m = n.x + n.width / 2, v = n.y + n.height / 2, p = Math.min(n.width, n.height) / 2 * u, f = y - d, T = Math.max(0, Math.min(1, (o - a) / (i - a))), S = (d + T * f) * (Math.PI / 180);
+  t.save(), t.beginPath(), t.arc(m, v, p, d * (Math.PI / 180), y * (Math.PI / 180)), t.strokeStyle = "rgba(255, 255, 255, 0.1)", t.lineWidth = p * 0.2, t.lineCap = "round", t.stroke();
+  for (const D of c) {
+    const k = Math.max(0, Math.min(1, (D.from - a) / (i - a))), M = Math.max(0, Math.min(1, (D.to - a) / (i - a)));
+    t.beginPath(), t.arc(
+      m,
+      v,
+      p,
+      (d + k * f) * (Math.PI / 180),
+      (d + M * f) * (Math.PI / 180)
+    ), t.strokeStyle = D.color, t.lineWidth = p * 0.2, t.stroke();
+  }
+  const L = 11;
+  for (let D = 0; D < L; D++) {
+    const k = (d + D / (L - 1) * f) * (Math.PI / 180), M = p * 0.85, B = p * 0.95;
+    t.beginPath(), t.moveTo(m + M * Math.cos(k), v + M * Math.sin(k)), t.lineTo(m + B * Math.cos(k), v + B * Math.sin(k)), t.strokeStyle = "rgba(255, 255, 255, 0.5)", t.lineWidth = 2, t.stroke();
+  }
+  t.beginPath(), t.moveTo(m, v), t.lineTo(m + p * 0.9 * Math.cos(S), v + p * 0.9 * Math.sin(S)), t.strokeStyle = l, t.lineWidth = s, t.lineCap = "round", t.shadowColor = l, t.shadowBlur = 10, t.stroke(), t.shadowBlur = 0, t.beginPath(), t.arc(m, v, 8, 0, Math.PI * 2), t.fillStyle = l, t.fill(), t.strokeStyle = "#fff", t.lineWidth = 2, t.stroke(), h && (t.textAlign = "center", t.textBaseline = "middle", t.font = `bold ${w}px Inter, sans-serif`, t.fillStyle = g, t.fillText(o.toFixed(1), m, v + p * 0.4), b && (t.font = `${w * 0.5}px Inter, sans-serif`, t.fillStyle = "rgba(255, 255, 255, 0.6)", t.fillText(b, m, v + p * 0.6))), t.restore();
+}
+function kt(t, e, r, n) {
+  const { nodes: o, links: a } = e, {
+    nodeWidth: i = 18,
+    nodePadding: l = 12,
+    palette: s = ["#6366f1", "#10b981", "#3b82f6", "#f43f5e", "#f59e0b"],
+    linkOpacity: c = 0.4,
+    showLabels: u = !0
+  } = r;
+  if (!a.length) return;
+  const d = 1.8, y = n.width / d, h = n.height / d, g = (n.width - y) / 2, w = (n.height - h) / 2, m = {
+    x: n.x + g,
+    y: n.y + w,
+    width: y,
+    height: h
+  }, v = /* @__PURE__ */ new Set();
+  a.forEach((x) => {
+    v.add(x.source), v.add(x.target);
+  });
+  const p = Array.from(v), f = /* @__PURE__ */ new Map(), T = new Set(a.map((x) => x.target));
+  p.filter((x) => !T.has(x)).forEach((x) => f.set(x, 0));
+  let L = !0;
+  for (; L; )
+    L = !1, a.forEach((x) => {
+      const A = f.get(x.source);
+      if (A !== void 0) {
+        const E = f.get(x.target), _ = A + 1;
+        (E === void 0 || _ > E) && (f.set(x.target, _), L = !0);
+      }
+    });
+  p.forEach((x) => {
+    f.get(x) === void 0 && f.set(x, 0);
+  });
+  const D = Math.max(...Array.from(f.values())), k = Array.from({ length: D + 1 }, () => []);
+  p.forEach((x) => k[f.get(x)].push(x));
+  const M = /* @__PURE__ */ new Map(), B = /* @__PURE__ */ new Map();
+  a.forEach((x) => {
+    B.set(x.source, (B.get(x.source) || 0) + x.value), M.set(x.target, (M.get(x.target) || 0) + x.value);
+  });
+  const P = (x) => Math.max(M.get(x) || 0, B.get(x) || 0);
+  let F = 0;
+  k.forEach((x) => {
+    let A = 0;
+    x.forEach((E) => A += P(E)), A > F && (F = A);
+  });
+  const C = /* @__PURE__ */ new Map(), $ = k.length, I = (m.width - i) / Math.max(1, $ - 1);
+  k.forEach((x, A) => {
+    const E = m.x + A * I, _ = [];
+    let O = 0;
+    x.forEach((z) => {
+      const G = P(z), V = F > 0 ? G / F * (m.height * 0.9) : 20;
+      _.push(V), O += V;
+    });
+    const q = (x.length - 1) * l, j = O + q;
+    let H = m.y + (m.height - j) / 2;
+    x.forEach((z, G) => {
+      const V = _[G];
+      let N = s[G % s.length];
+      if (o.length > 0) {
+        const X = o.find((K) => K.id === z);
+        X != null && X.color && (N = X.color);
+      }
+      C.set(z, { x: E, y: H, width: i, height: V, color: N, value: P(z) }), H += V + l;
+    });
+  }), t.save();
+  const Y = /* @__PURE__ */ new Map(), R = /* @__PURE__ */ new Map();
+  a.forEach((x) => {
+    const A = C.get(x.source), E = C.get(x.target);
+    if (!A || !E) return;
+    const _ = Y.get(x.source) || 0, O = R.get(x.target) || 0, q = B.get(x.source) || 1, j = M.get(x.target) || 1, H = x.value / q * A.height, z = x.value / j * E.height, G = A.x + A.width, V = A.y + _, N = V + H, X = E.x, K = E.y + O, ee = K + z, J = (X - G) * 0.5, te = t.createLinearGradient(G, (V + N) / 2, X, (K + ee) / 2);
+    te.addColorStop(0, A.color), te.addColorStop(1, E.color), t.beginPath(), t.moveTo(G, V), t.bezierCurveTo(G + J, V, X - J, K, X, K), t.lineTo(X, ee), t.bezierCurveTo(X - J, ee, G + J, N, G, N), t.closePath(), t.fillStyle = te, t.globalAlpha = c, t.fill(), t.strokeStyle = A.color, t.globalAlpha = c * 0.3, t.lineWidth = 0.5, t.stroke(), Y.set(x.source, _ + H), R.set(x.target, O + z);
+  }), t.restore(), t.save(), t.globalAlpha = 1, C.forEach((x) => {
+    t.fillStyle = x.color, t.fillRect(x.x, x.y, x.width, x.height);
+    const A = t.createLinearGradient(x.x, x.y, x.x + x.width, x.y);
+    A.addColorStop(0, "rgba(255, 255, 255, 0.15)"), A.addColorStop(1, "rgba(0, 0, 0, 0.15)"), t.fillStyle = A, t.fillRect(x.x, x.y, x.width, x.height);
+  }), t.restore(), u && (t.save(), t.font = "bold 11px Inter, -apple-system, sans-serif", t.textBaseline = "middle", C.forEach((x, A) => {
+    let E = String(A);
+    const _ = o.find((j) => j.id === A);
+    _ != null && _.name && (E = _.name);
+    const O = x.x <= m.x + 5, q = x.x >= m.x + m.width - i - 5;
+    t.shadowBlur = 3, t.shadowColor = "rgba(0, 0, 0, 0.7)", t.fillStyle = "#ffffff", O ? (t.textAlign = "right", t.fillText(E, x.x - 10, x.y + x.height / 2)) : q ? (t.textAlign = "left", t.fillText(E, x.x + x.width + 10, x.y + x.height / 2)) : (t.textAlign = "center", t.fillText(E, x.x + x.width / 2, x.y - 10));
+  }), t.restore());
+}
+let Se = !1;
+function It() {
+  Se || (Se = !0, me("gauge", (t, e, r) => {
+    const n = e.getGaugeData(), o = e.getGaugeStyle();
+    n && o && Lt(t, n, o, r);
+  }), me("sankey", (t, e, r) => {
+    const n = e.getSankeyData(), o = e.getSankeyStyle();
+    n && o && kt(t, n, o, r);
+  }));
+}
+function Rt(t, e) {
+  e.heatmapProgram = rt(t, ot, nt, "heatmap");
+}
+let Te = !1;
+function $t() {
+  Te || (Te = !0, ue.afterConstruct = (t, e) => {
+    e.renderer === "webgpu" && (t._webgpuInitPromise = Bt(t));
+  });
+}
+async function Bt(t) {
+  var o, a;
+  const e = t, { createGpuChartRenderer: r } = await import("./GpuChartRenderer-Dxc0hrQA.js"), n = await r(e.webglCanvas, {
+    backend: "webgpu",
+    powerPreference: "high-performance"
+  });
+  if (n) {
+    e.renderer = n, e.activeRendererType = n.backend, e.renderer.setDPR(e.dpr), (o = e.renderLoop) == null || o.setRenderer(e.renderer);
+    return;
+  }
+  console.warn(
+    "[VeloPlot] WebGPU unavailable — falling back to WebGL2. See docs/adr/001-webgpu-renderer-strategy.md."
+  ), e.renderer = new Le(e.webglCanvas), e.activeRendererType = "webgl", e.renderer.setDPR(e.dpr), (a = e.renderLoop) == null || a.setRenderer(e.renderer);
+}
+let Ae = !1;
+function _t() {
+  Ae || (Ae = !0, Le.heatmapProgramInstaller = Rt, $t(), Pt(), Dt(), It());
+}
+function Ce(t) {
+  return t.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function ke(t, e) {
+  return e && t.has(e) ? t.get(e) : t.get("default") ?? t.values().next().value;
+}
+function Yt(t, e, r, n, o, a, i, l, s = {}) {
+  const c = ke(o, s.primaryYAxisId);
+  if (!c)
+    throw new Error("SVG export requires at least one Y scale");
+  const u = [
+    `<svg width="${i}" height="${l}" viewBox="0 0 ${i} ${l}" xmlns="http://www.w3.org/2000/svg" font-family="${a.xAxis.fontFamily || "sans-serif"}">`,
+    `<rect width="100%" height="100%" fill="${a.backgroundColor}" />`,
+    '<g transform="translate(0,0)">'
+  ];
+  return Gt(u, r, n, c, a), Xt(u, t, r, n, o, s.primaryYAxisId), Wt(u, r, n, c, a), Vt(u, r, n, c, a, s), u.push("</g>"), u.push("</svg>"), u.join(`
+`);
+}
+function Xt(t, e, r, n, o, a) {
+  for (const i of e) {
+    if (!i.isVisible()) continue;
+    const l = o.get(i.getYAxisId() || a || "default") ?? ke(o, a);
+    if (!l) continue;
+    const s = i.getData();
+    if (!s || s.x.length === 0) continue;
+    const c = i.getStyle(), u = i.getType();
+    if (u === "line" || u === "step") {
+      const d = [], y = c.stepMode || "after";
+      for (let h = 0; h < s.x.length; h++) {
+        const g = n.transform(s.x[h]), w = l.transform(s.y[h]);
+        if (h > 0 && u === "step") {
+          const b = n.transform(s.x[h - 1]), m = l.transform(s.y[h - 1]);
+          if (y === "after") d.push(`${g.toFixed(1)},${m.toFixed(1)}`);
+          else if (y === "before") d.push(`${b.toFixed(1)},${w.toFixed(1)}`);
+          else if (y === "center") {
+            const v = (b + g) / 2;
+            d.push(`${v.toFixed(1)},${m.toFixed(1)}`), d.push(`${v.toFixed(1)},${w.toFixed(1)}`);
+          }
+        }
+        d.push(`${g.toFixed(1)},${w.toFixed(1)}`);
+      }
+      t.push(
+        `<polyline points="${d.join(" ")}" fill="none" stroke="${c.color}" stroke-width="${c.width || 1.5}" stroke-opacity="${c.opacity || 1}" stroke-linejoin="round" />`
+      );
+    } else if (u === "scatter")
+      for (let d = 0; d < s.x.length; d++) {
+        const y = n.transform(s.x[d]), h = l.transform(s.y[d]);
+        t.push(
+          `<circle cx="${y.toFixed(1)}" cy="${h.toFixed(1)}" r="${((c.pointSize || 4) / 2).toFixed(1)}" fill="${c.color}" fill-opacity="${c.opacity || 1}" />`
+        );
+      }
+    else if (u === "bar") {
+      const d = (c.barWidth || 5) * (r.width / (n.domain[1] - n.domain[0]));
+      for (let y = 0; y < s.x.length; y++) {
+        const h = n.transform(s.x[y]), g = l.transform(s.y[y]), w = l.transform(0), b = Math.min(g, w), m = Math.abs(g - w);
+        t.push(
+          `<rect x="${(h - d / 2).toFixed(1)}" y="${b.toFixed(1)}" width="${d.toFixed(1)}" height="${m.toFixed(1)}" fill="${c.color}" fill-opacity="${c.opacity || 1}" />`
+        );
+      }
+    } else if (u === "band" || u === "area") {
+      const d = u === "area" ? new Float32Array(s.x.length).fill(0) : s.y2 || new Float32Array(s.x.length).fill(0), y = [];
+      for (let h = 0; h < s.x.length; h++)
+        y.push(
+          `${n.transform(s.x[h]).toFixed(1)},${l.transform(s.y[h]).toFixed(1)}`
+        );
+      for (let h = s.x.length - 1; h >= 0; h--)
+        y.push(
+          `${n.transform(s.x[h]).toFixed(1)},${l.transform(d[h]).toFixed(1)}`
+        );
+      t.push(
+        `<polygon points="${y.join(" ")}" fill="${c.color}" fill-opacity="${(Number(c.opacity) || 1) * 0.3}" stroke="${c.color}" stroke-width="${c.width || 1}" />`
+      );
+    } else if (u === "candlestick") {
+      const d = (c.barWidth || 5) * (r.width / (n.domain[1] - n.domain[0])), y = c.bullishColor || "#26a69a", h = c.bearishColor || "#ef5350";
+      if (s.open && s.high && s.low && s.close)
+        for (let g = 0; g < s.x.length; g++) {
+          const w = s.close[g] >= s.open[g], b = n.transform(s.x[g]), m = l.transform(s.open[g]), v = l.transform(s.close[g]), p = l.transform(s.high[g]), f = l.transform(s.low[g]), T = w ? y : h;
+          t.push(
+            `<line x1="${b.toFixed(1)}" y1="${p.toFixed(1)}" x2="${b.toFixed(1)}" y2="${f.toFixed(1)}" stroke="${T}" stroke-width="1" />`
+          );
+          const S = Math.min(m, v), L = Math.max(1, Math.abs(m - v));
+          t.push(
+            `<rect x="${(b - d / 2).toFixed(1)}" y="${S.toFixed(1)}" width="${d.toFixed(1)}" height="${L.toFixed(1)}" fill="${T}" />`
+          );
+        }
+    }
+  }
+}
+function Wt(t, e, r, n, o) {
+  const a = Q(e.y + e.height), i = Q(e.x);
+  t.push(
+    `<line x1="${e.x}" y1="${a}" x2="${e.x + e.width}" y2="${a}" stroke="${o.xAxis.lineColor}" stroke-width="${o.xAxis.lineWidth || 2}" />`
+  ), t.push(
+    `<line x1="${i}" y1="${e.y}" x2="${i}" y2="${e.y + e.height}" stroke="${o.yAxis.lineColor}" stroke-width="${o.yAxis.lineWidth || 2}" />`
+  );
+}
+function Vt(t, e, r, n, o, a) {
+  const i = a.xAxis, l = a.yAxis, s = (i == null ? void 0 : i.tickCount) ?? 8, c = (l == null ? void 0 : l.tickCount) ?? 6, u = r.domain[1] - r.domain[0], d = e.y + e.height, y = e.x, h = o.xAxis, g = o.yAxis;
+  (i == null ? void 0 : i.showLabels) !== !1 && r.ticks(s).forEach((w) => {
+    const b = ye(r.transform(w));
+    if (b < e.x || b > e.x + e.width) return;
+    const m = Ne(w, i, u), v = d + (h.tickLength ?? 4) + h.labelSize * 0.75;
+    t.push(
+      `<text x="${b.toFixed(1)}" y="${v.toFixed(1)}" fill="${h.labelColor}" font-size="${h.labelSize}" text-anchor="middle">${Ce(m)}</text>`
+    );
+  }), (l == null ? void 0 : l.showLabels) !== !1 && n.ticks(c).forEach((w) => {
+    const b = ye(n.transform(w));
+    if (b < e.y || b > e.y + e.height) return;
+    const m = Ue(w, l), v = y - (g.tickLength ?? 4) - 4;
+    t.push(
+      `<text x="${v.toFixed(1)}" y="${(b + g.labelSize * 0.35).toFixed(1)}" fill="${g.labelColor}" font-size="${g.labelSize}" text-anchor="end">${Ce(m)}</text>`
+    );
+  });
+}
+function Gt(t, e, r, n, o) {
+  o.grid.visible && (r.ticks(10).forEach((a) => {
+    const i = Q(r.transform(a));
+    i >= e.x && i <= e.x + e.width && t.push(
+      `<line x1="${i.toFixed(1)}" y1="${e.y}" x2="${i.toFixed(1)}" y2="${e.y + e.height}" stroke="${o.grid.majorColor}" stroke-opacity="0.1" stroke-dasharray="2,2" />`
+    );
+  }), n.ticks(10).forEach((a) => {
+    const i = Q(n.transform(a));
+    i >= e.y && i <= e.y + e.height && t.push(
+      `<line x1="${e.x}" y1="${i.toFixed(1)}" x2="${e.x + e.width}" y2="${i.toFixed(1)}" stroke="${o.grid.majorColor}" stroke-opacity="0.1" stroke-dasharray="2,2" />`
+    );
+  }));
+}
+let Me = !1;
+function Ot() {
+  Me || (Me = !0, ue.prototype.exportSVG = function() {
+    const t = this, e = t.container.getBoundingClientRect();
+    return Yt(
+      t.getAllSeries(),
+      t.viewBounds,
+      t.getPlotArea(),
+      t.xScale,
+      t.yScales,
+      t.theme,
+      e.width || t.container.clientWidth,
+      e.height || t.container.clientHeight,
+      {
+        xAxis: t.xAxisOptions,
+        yAxis: t.yAxisOptionsMap.get(t.primaryYAxisId),
+        primaryYAxisId: t.primaryYAxisId
+      }
+    );
+  });
+}
+class Ht {
+  constructor(e, r) {
+    W(this, "alerts", /* @__PURE__ */ new Map());
+    W(this, "idCounter", 0);
+    this.events = e, this.getSeries = r;
+  }
+  addAlert(e) {
+    const r = e.id ?? `alert_${++this.idCounter}`;
+    return this.alerts.set(r, { ...e, id: r }), r;
+  }
+  removeAlert(e) {
+    return this.alerts.delete(e);
+  }
+  clearAlerts() {
+    this.alerts.clear();
+  }
+  getAlerts() {
+    return Array.from(this.alerts.values());
+  }
+  /** Call after data updates / render tick. */
+  evaluate() {
+    for (const [e, r] of [...this.alerts.entries()]) {
+      const n = this.getSeries(r.seriesId);
+      if (!n) continue;
+      const o = n.getData(), a = o.close ?? o.y;
+      if (!(a != null && a.length)) continue;
+      const i = a[a.length - 1];
+      if (!Number.isFinite(i)) continue;
+      const l = a.length > 1 ? a[a.length - 2] : i;
+      let s = !1;
+      switch (r.direction) {
+        case "above":
+          s = i >= r.price;
+          break;
+        case "below":
+          s = i <= r.price;
+          break;
+        case "cross":
+          s = l < r.price && i >= r.price || l > r.price && i <= r.price;
+          break;
+      }
+      if (!s) continue;
+      const c = {
+        id: e,
+        price: r.price,
+        direction: r.direction,
+        seriesId: r.seriesId ?? n.getId(),
+        triggeredAt: Date.now(),
+        triggerPrice: i
+      };
+      this.events.emit("alert", c), r.once !== !1 && this.alerts.delete(e);
+    }
+  }
+  destroy() {
+    this.alerts.clear();
+  }
+}
+const zt = {
+  entry: "#38bdf8",
+  sl: "#ef4444",
+  tp: "#22c55e"
+}, Nt = {
+  entry: "Entry",
+  sl: "SL",
+  tp: "TP"
+};
+function Ut(t, e) {
+  const r = t.style ?? "entry";
+  return {
+    id: e,
+    type: "horizontal-line",
+    y: t.price,
+    color: t.color ?? zt[r],
+    label: t.label ?? Nt[r],
+    labelPosition: "right",
+    lineDash: r === "sl" ? [6, 4] : r === "tp" ? [4, 4] : void 0,
+    interactive: t.interactive ?? !1
+  };
+}
+let Fe = !1;
+function qt() {
+  at((t, e) => {
+    var n, o;
+    if (e.type === "heatmap" || e.type === "indicator")
+      return e;
+    let r = { ...e };
+    if (r.type === "heikin-ashi") {
+      const a = r.data;
+      if (a != null && a.open && a.high && a.low && a.close) {
+        const i = ze({
+          open: a.open,
+          high: a.high,
+          low: a.low,
+          close: a.close
+        });
+        r = {
+          ...r,
+          type: "candlestick",
+          data: { ...a, ...i }
+        };
+      }
+    }
+    if (ge(t.xAxisOptions) && ((o = (n = r.data) == null ? void 0 : n.x) != null && o.length)) {
+      const { displayX: a, mapping: i } = pe(
+        r.data.x,
+        t.xAxisOptions
+      );
+      t.setTimeScaleMapping(i), r = {
+        ...r,
+        data: { ...r.data, x: a }
+      };
+    }
+    return r;
+  }), it((t) => t.type === "indicator" ? je(t) : [t]), st((t, e) => {
+    if (e.x && ge(t.xAxisOptions)) {
+      const { displayX: r, mapping: n } = pe(e.x, t.xAxisOptions);
+      return t.setTimeScaleMapping(n), { ...e, x: r };
+    }
+    return e;
+  });
+}
+function jt() {
+  const t = ue.prototype;
+  if (t._tradingPatched) return;
+  t._tradingPatched = !0, t.addIndicator = async function(r, n) {
+    return qe(this, r, n);
+  }, t.addAlert = function(r) {
+    return ie(this).addAlert(r);
+  }, t.removeAlert = function(r) {
+    return ie(this).removeAlert(r);
+  }, t.clearAlerts = function() {
+    ie(this).clearAlerts();
+  }, t.getAlerts = function() {
+    return ie(this).getAlerts();
+  }, t.addPositionLine = function(r) {
+    const n = this;
+    n._positionLineCounter === void 0 && (n._positionLineCounter = 0);
+    const o = r.id ?? `position-${++n._positionLineCounter}`;
+    return n.addAnnotation(Ut(r, o)), o;
+  }, t.setDrawingMode = function(r) {
+    var o;
+    const n = this.getPlugin(
+      "velo-plot-drawing-tools"
+    );
+    (o = n == null ? void 0 : n.setMode) == null || o.call(n, r);
+  };
+  const e = t.destroy;
+  t.destroy = function() {
+    var n;
+    const r = this;
+    return (n = r._alertManager) == null || n.destroy(), r._alertManager = void 0, r.setFeatureHooks(null), e.call(this);
+  };
+}
+function ie(t) {
+  const e = t;
+  return e._alertManager || (e._alertManager = new Ht(t.events, (r) => {
+    const n = r ? t.series.get(r) : void 0;
+    return n || t.series.values().next().value;
+  }), t.setFeatureHooks({
+    onDataUpdate: () => {
+      var r;
+      return (r = e._alertManager) == null ? void 0 : r.evaluate();
+    },
+    getAlerts: () => {
+      var r;
+      return ((r = e._alertManager) == null ? void 0 : r.getAlerts()) ?? [];
+    },
+    destroy: () => {
+      var r;
+      return (r = e._alertManager) == null ? void 0 : r.destroy();
+    }
+  })), e._alertManager;
+}
+function Ie() {
+  Fe || (Fe = !0, _t(), qt(), jt(), Ot());
+}
+Ie();
+class Re {
+  constructor(e, r = {}) {
+    W(this, "available");
+    W(this, "canvas");
+    W(this, "adapter");
+    W(this, "device");
+    W(this, "context");
+    this.canvas = e, this.available = Re.isSupported();
   }
   static isSupported() {
     return typeof globalThis.navigator < "u" && typeof globalThis.navigator.gpu < "u";
   }
   async init(e = {}) {
     if (!this.available)
-      throw new Error("[SciPlot] WebGPU is not supported in this environment");
-    const t = globalThis.navigator.gpu;
-    if (this.adapter = await t.requestAdapter({
+      throw new Error("[VeloPlot] WebGPU is not supported in this environment");
+    const r = globalThis.navigator.gpu;
+    if (this.adapter = await r.requestAdapter({
       powerPreference: e.powerPreference ?? "high-performance"
     }), !this.adapter)
-      throw new Error("[SciPlot] Failed to request WebGPU adapter");
+      throw new Error("[VeloPlot] Failed to request WebGPU adapter");
     this.device = await this.adapter.requestDevice();
-    const o = this.canvas.getContext("webgpu");
-    if (!o)
-      throw new Error("[SciPlot] Failed to get WebGPU context");
-    this.context = o;
-    const r = e.preferredFormat ?? (t.getPreferredCanvasFormat ? t.getPreferredCanvasFormat() : "bgra8unorm");
+    const n = this.canvas.getContext("webgpu");
+    if (!n)
+      throw new Error("[VeloPlot] Failed to get WebGPU context");
+    this.context = n;
+    const o = e.preferredFormat ?? (r.getPreferredCanvasFormat ? r.getPreferredCanvasFormat() : "bgra8unorm");
     this.context.configure({
       device: this.device,
-      format: r,
+      format: o,
       alphaMode: "premultiplied"
     });
   }
-  destroy() {
-    this.device = void 0, this.adapter = void 0, this.context = void 0;
+  destroy() {
+    this.device = void 0, this.adapter = void 0, this.context = void 0;
+  }
+}
+const Kt = `
+  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);
+  }
+`, Jt = `
+  precision mediump float;
+  uniform vec4 uColor;
+  void main() {
+    gl_FragColor = uColor;
+  }
+`;
+function Ee(t, e, r) {
+  const n = t.createShader(e);
+  if (!n) throw new Error("createShader failed");
+  if (t.shaderSource(n, r), t.compileShader(n), !t.getShaderParameter(n, t.COMPILE_STATUS))
+    throw new Error(t.getShaderInfoLog(n) ?? "shader compile failed");
+  return n;
+}
+function Qt(t) {
+  const e = Ee(t, t.VERTEX_SHADER, Kt), r = Ee(t, t.FRAGMENT_SHADER, Jt), n = t.createProgram();
+  if (!n) throw new Error("createProgram failed");
+  if (t.attachShader(n, e), t.attachShader(n, r), t.linkProgram(n), !t.getProgramParameter(n, t.LINK_STATUS))
+    throw new Error(t.getProgramInfoLog(n) ?? "program link failed");
+  return t.deleteShader(e), t.deleteShader(r), n;
+}
+function Zt(t) {
+  const { plotArea: e, xLines: r, yLines: n } = t, o = e.y, a = e.y + e.height, i = e.x, l = e.x + e.width, s = (r.length + n.length) * 2, c = new Float32Array(s * 2);
+  let u = 0;
+  for (const d of r)
+    c[u++] = d, c[u++] = o, c[u++] = d, c[u++] = a;
+  for (const d of n)
+    c[u++] = i, c[u++] = d, c[u++] = l, c[u++] = d;
+  return c;
+}
+class er {
+  constructor(e) {
+    W(this, "gl");
+    W(this, "program");
+    W(this, "buffer");
+    W(this, "aPosition");
+    W(this, "uResolution");
+    W(this, "uColor");
+    const r = e.getContext("webgl", {
+      alpha: !0,
+      antialias: !1,
+      preserveDrawingBuffer: !0
+    });
+    if (!r) throw new Error("WebGL not available for grid spike");
+    this.gl = r, this.program = Qt(r), this.aPosition = r.getAttribLocation(this.program, "aPosition"), this.uResolution = r.getUniformLocation(this.program, "uResolution"), this.uColor = r.getUniformLocation(this.program, "uColor");
+    const n = r.createBuffer();
+    if (!n) throw new Error("createBuffer failed");
+    this.buffer = n;
+  }
+  /** Upload vertices and draw grid lines */
+  draw(e) {
+    const r = this.gl, n = Zt(e), o = n.length / 4;
+    r.viewport(0, 0, e.width, e.height), r.clearColor(0.04, 0.05, 0.08, 1), r.clear(r.COLOR_BUFFER_BIT), r.useProgram(this.program), r.bindBuffer(r.ARRAY_BUFFER, this.buffer), r.bufferData(r.ARRAY_BUFFER, n, r.DYNAMIC_DRAW), r.enableVertexAttribArray(this.aPosition), r.vertexAttribPointer(this.aPosition, 2, r.FLOAT, !1, 0, 0), r.uniform2f(this.uResolution, e.width, e.height);
+    const a = e.color ?? [0.2, 0.22, 0.3, 0.6];
+    return r.uniform4f(this.uColor, a[0], a[1], a[2], a[3]), r.lineWidth(e.lineWidth ?? 1), r.drawArrays(r.LINES, 0, n.length / 2), o;
+  }
+  destroy() {
+    const e = this.gl;
+    e.deleteBuffer(this.buffer), e.deleteProgram(this.program);
+  }
+}
+function tr(t) {
+  const e = () => {
+  };
+  return {
+    canvas: t,
+    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: (r) => ({ width: r.length * 7 })
+  };
+}
+function rr(t, e) {
+  const r = document.createElement("canvas");
+  return r.width = t, r.height = e, r.getContext("2d") ?? tr(r);
+}
+function $e(t, e) {
+  const r = { top: 40, right: 40, bottom: 50, left: 60 };
+  return {
+    x: r.left,
+    y: r.top,
+    width: t - r.left - r.right,
+    height: e - r.top - r.bottom
+  };
+}
+function Be(t, e, r, n, o) {
+  const a = e.ticks(n).map((l) => Q(e.transform(l))), i = r.ticks(o).map((l) => Q(r.transform(l)));
+  return { xLines: a, yLines: i };
+}
+function _e(t, e) {
+  const r = [];
+  for (let a = 0; a < e; a++) {
+    const i = performance.now();
+    t(), r.push((performance.now() - i) * 1e3);
+  }
+  r.sort((a, i) => a - i);
+  const n = r.reduce((a, i) => a + i, 0) / r.length, o = r[Math.floor(r.length * 0.95)] ?? n;
+  return { avg: n, p95: o };
+}
+function nr(t = {}) {
+  const e = Math.round((t.width ?? 1920) * (t.dpr ?? 1)), r = Math.round((t.height ?? 1080) * (t.dpr ?? 1)), n = t.xTickCount ?? 24, o = t.yTickCount ?? 16, a = t.frames ?? 120, i = rr(e, r), l = {
+    ...xe,
+    grid: {
+      ...xe.grid,
+      visible: !0,
+      showMinor: t.showMinor ?? !0
+    }
+  }, s = $e(e, r), c = new se(), u = new se();
+  c.setDomain(0, 1e6), u.setDomain(-1, 1), c.setRange(s.x, s.x + s.width), u.setRange(s.y + s.height, s.y);
+  const d = new lt(i, l), { avg: y, p95: h } = _e(() => {
+    i.clearRect(0, 0, e, r), d.drawGrid(s, c, u, { tickCount: n }, { tickCount: o });
+  }, a), { xLines: g, yLines: w } = Be(s, c, u, n, o);
+  return {
+    backend: "canvas2d",
+    dpr: t.dpr ?? 1,
+    width: e,
+    height: r,
+    xTicks: n,
+    yTicks: o,
+    lineSegments: g.length + w.length,
+    avgFrameUs: Math.round(y),
+    p95FrameUs: Math.round(h),
+    frames: a
+  };
+}
+function or(t = {}) {
+  const e = Math.round((t.width ?? 1920) * (t.dpr ?? 1)), r = Math.round((t.height ?? 1080) * (t.dpr ?? 1)), n = t.xTickCount ?? 24, o = t.yTickCount ?? 16, a = t.frames ?? 120, i = document.createElement("canvas");
+  i.width = e, i.height = r;
+  let l;
+  try {
+    l = new er(i);
+  } catch {
+    return null;
+  }
+  const s = $e(e, r), c = new se(), u = new se();
+  c.setDomain(0, 1e6), u.setDomain(-1, 1), c.setRange(s.x, s.x + s.width), u.setRange(s.y + s.height, s.y);
+  const { xLines: d, yLines: y } = Be(s, c, u, n, o), h = { plotArea: s, xLines: d, yLines: y, width: e, height: r };
+  let g = 0;
+  const { avg: w, p95: b } = _e(() => {
+    g = l.draw(h);
+  }, a);
+  return l.destroy(), {
+    backend: "webgl",
+    dpr: t.dpr ?? 1,
+    width: e,
+    height: r,
+    xTicks: n,
+    yTicks: o,
+    lineSegments: g,
+    avgFrameUs: Math.round(w),
+    p95FrameUs: Math.round(b),
+    frames: a
+  };
+}
+function kr(t) {
+  const e = (t == null ? void 0 : t.dpr) ?? 2, r = (t == null ? void 0 : t.frames) ?? 120, n = nr({ dpr: e, frames: r, showMinor: !0 }), o = or({ dpr: e, frames: r });
+  if (!o)
+    return {
+      canvas2d: n,
+      webgl: null,
+      gainPercent: 0,
+      recommendation: "defer"
+    };
+  const a = (n.avgFrameUs - o.avgFrameUs) / n.avgFrameUs * 100;
+  return {
+    canvas2d: n,
+    webgl: o,
+    gainPercent: Math.round(a * 10) / 10,
+    recommendation: a >= 20 ? "implement" : "defer"
+  };
+}
+const ar = "1.17.0", ir = "2026-07-05", sr = "Stage 1 baselines. Headless CI uses effective FPS (render throughput when rAF throttled) via scripts/benchmark-scenario-eval.mjs smoke floors.", lr = 0.1, cr = 0.95, ur = {
+  "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"
+  }
+}, ce = {
+  version: ar,
+  recordedAt: ir,
+  notes: sr,
+  regressionThreshold: lr,
+  webgpuMinFpsRatio: cr,
+  scenarios: ur
+};
+function Ir() {
+  return ce;
+}
+function Rr(t, e) {
+  const r = ce.scenarios[t];
+  if (!r)
+    return { passed: !0, failures: [] };
+  const n = [], o = ce.regressionThreshold ?? 0.1;
+  if ("avgFps" in e && r.minAvgFps !== void 0) {
+    const a = r.minAvgFps * (1 - o);
+    e.avgFps < a && n.push(
+      `FPS ${e.avgFps} < baseline min ${r.minAvgFps} (allowed ${a.toFixed(1)} with ${o * 100}% slack)`
+    );
+  }
+  if ("avgFrameTime" in e && r.maxAvgFrameTimeMs !== void 0) {
+    const a = r.maxAvgFrameTimeMs * (1 + o);
+    e.avgFrameTime > a && n.push(
+      `Frame time ${e.avgFrameTime}ms > baseline max ${r.maxAvgFrameTimeMs}ms`
+    );
+  }
+  if ("avgFrameUs" in e && r.maxAvgFrameUs !== void 0) {
+    const a = r.maxAvgFrameUs * (1 + o);
+    e.avgFrameUs > a && n.push(
+      `Grid frame ${e.avgFrameUs}µs > baseline max ${r.maxAvgFrameUs}µs`
+    );
+  }
+  return { passed: n.length === 0, failures: n };
+}
+function $r(t, e, r, n = 0.95) {
+  if (!r || !e)
+    return {
+      webgl: t,
+      webgpu: e,
+      webgpuActive: !1,
+      fpsRatio: 0,
+      meetsTarget: !1,
+      recommendation: "webgpu-unavailable"
+    };
+  const o = t.avgFps > 0 ? e.avgFps / t.avgFps : 0, a = o >= n;
+  return {
+    webgl: t,
+    webgpu: e,
+    webgpuActive: !0,
+    fpsRatio: o,
+    meetsTarget: a,
+    recommendation: a ? "webgpu-ready" : "webgl-faster"
+  };
+}
+class dr {
+  constructor(e) {
+    W(this, "seed");
+    this.seed = e;
+  }
+  next() {
+    let e = this.seed += 1831565813;
+    return e = Math.imul(e ^ e >>> 15, e | 1), e ^= e + Math.imul(e ^ e >>> 7, e | 61), ((e ^ e >>> 14) >>> 0) / 4294967296;
+  }
+  nextRange(e, r) {
+    return e + this.next() * (r - e);
+  }
+}
+function Br(t) {
+  const e = {
+    pointCount: 1e3,
+    amplitude: 1,
+    frequency: 1,
+    phase: 0,
+    noise: 0,
+    xStart: 0,
+    xEnd: 10,
+    offset: 0,
+    ...t
+  }, r = new Float32Array(e.pointCount), n = new Float32Array(e.pointCount), o = (e.xEnd - e.xStart) / (e.pointCount - 1);
+  for (let a = 0; a < e.pointCount; a++) {
+    r[a] = e.xStart + a * o;
+    const i = e.amplitude * Math.sin(2 * Math.PI * e.frequency * r[a] + e.phase), l = e.noise > 0 ? (Math.random() - 0.5) * 2 * e.noise : 0;
+    n[a] = i + l + e.offset;
+  }
+  return { x: r, y: n };
+}
+function _r(t) {
+  const e = {
+    pointCount: 1e3,
+    amplitude: 1,
+    frequency: 1,
+    phase: 0,
+    noise: 0,
+    xStart: 0,
+    xEnd: 10,
+    offset: 0,
+    ...t
+  }, r = new Float32Array(e.pointCount), n = new Float32Array(e.pointCount), o = (e.xEnd - e.xStart) / (e.pointCount - 1);
+  for (let a = 0; a < e.pointCount; a++) {
+    r[a] = e.xStart + a * o;
+    const i = r[a] * e.frequency + e.phase / (2 * Math.PI), l = Math.sign(Math.sin(2 * Math.PI * i)) * e.amplitude, s = e.noise > 0 ? (Math.random() - 0.5) * 2 * e.noise : 0;
+    n[a] = l + s + e.offset;
+  }
+  return { x: r, y: n };
+}
+function Yr(t) {
+  const e = {
+    pointCount: 1e3,
+    amplitude: 1,
+    frequency: 1,
+    phase: 0,
+    noise: 0,
+    xStart: 0,
+    xEnd: 10,
+    offset: 0,
+    ...t
+  }, r = new Float32Array(e.pointCount), n = new Float32Array(e.pointCount), o = (e.xEnd - e.xStart) / (e.pointCount - 1);
+  for (let a = 0; a < e.pointCount; a++) {
+    r[a] = e.xStart + a * o;
+    const i = r[a] * e.frequency + e.phase / (2 * Math.PI), l = e.amplitude * 2 * (i - Math.floor(i + 0.5)), s = e.noise > 0 ? (Math.random() - 0.5) * 2 * e.noise : 0;
+    n[a] = l + s + e.offset;
+  }
+  return { x: r, y: n };
+}
+function Xr(t) {
+  const e = {
+    pointCount: 1e3,
+    amplitude: 1,
+    frequency: 1,
+    phase: 0,
+    noise: 0,
+    xStart: 0,
+    xEnd: 10,
+    offset: 0,
+    ...t
+  }, r = new Float32Array(e.pointCount), n = new Float32Array(e.pointCount), o = (e.xEnd - e.xStart) / (e.pointCount - 1);
+  for (let a = 0; a < e.pointCount; a++) {
+    r[a] = e.xStart + a * o;
+    const i = r[a] * e.frequency + e.phase / (2 * Math.PI), l = e.amplitude * 2 * Math.abs(2 * (i - Math.floor(i + 0.5))) - e.amplitude, s = e.noise > 0 ? (Math.random() - 0.5) * 2 * e.noise : 0;
+    n[a] = l + s + e.offset;
+  }
+  return { x: r, y: n };
+}
+function Wr(t) {
+  const e = {
+    pointCount: 1e3,
+    xRange: [0, 100],
+    yRange: [-1, 1],
+    sorted: !0,
+    seed: Date.now(),
+    ...t
+  }, r = new dr(e.seed), n = new Float32Array(e.pointCount), o = new Float32Array(e.pointCount);
+  for (let a = 0; a < e.pointCount; a++)
+    n[a] = r.nextRange(e.xRange[0], e.xRange[1]), o[a] = r.nextRange(e.yRange[0], e.yRange[1]);
+  if (e.sorted) {
+    const a = Array.from({ length: e.pointCount }, (s, c) => c);
+    a.sort((s, c) => n[s] - n[c]);
+    const i = new Float32Array(e.pointCount), l = new Float32Array(e.pointCount);
+    for (let s = 0; s < e.pointCount; s++)
+      i[s] = n[a[s]], l[s] = o[a[s]];
+    return { x: i, y: l };
+  }
+  return { x: n, y: o };
+}
+function Vr(t) {
+  const e = {
+    pointCount: 2e3,
+    vMin: -0.5,
+    vMax: 0.5,
+    cycles: 1,
+    peakCurrent: 1e-5,
+    // 10 µA
+    noise: 0.02,
+    ...t
+  }, r = e.pointCount * e.cycles, n = new Float32Array(r), o = new Float32Array(r), a = e.pointCount, i = a / 2;
+  for (let l = 0; l < e.cycles; l++)
+    for (let s = 0; s < a; s++) {
+      const c = l * a + s;
+      s < i ? n[c] = e.vMin + (e.vMax - e.vMin) * (s / i) : n[c] = e.vMax - (e.vMax - e.vMin) * ((s - i) / i);
+      const u = n[c], d = 0, y = s < i ? 1 : -1, h = 0.1, g = -Math.pow(u - d, 2) / (2 * h * h), w = e.peakCurrent * Math.exp(g), b = y * e.peakCurrent * 0.1, m = (Math.random() - 0.5) * 2 * e.noise * e.peakCurrent;
+      o[c] = y * w + b + m;
+    }
+  return { x: n, y: o };
+}
+function Gr(t) {
+  const e = {
+    pointCount: 50,
+    rSolution: 100,
+    // Ohms
+    rCharge: 1e3,
+    // Ohms
+    frequency: [1e5, 0.01],
+    ...t
+  }, r = new Float32Array(e.pointCount), n = new Float32Array(e.pointCount), o = Math.log10(e.frequency[1]), a = Math.log10(e.frequency[0]);
+  for (let i = 0; i < e.pointCount; i++) {
+    const l = a - (a - o) * (i / (e.pointCount - 1)), s = 2 * Math.PI * Math.pow(10, l), c = e.rCharge * 1e-5, u = e.rSolution + e.rCharge / (1 + Math.pow(s * c, 2)), d = s * c * e.rCharge / (1 + Math.pow(s * c, 2));
+    r[i] = u, n[i] = -d;
+  }
+  return { x: r, y: n };
+}
+async function Or(t, e) {
+  const r = {
+    duration: 5e3,
+    warmup: 1e3,
+    ...e
+  }, n = [], o = [];
+  let a = 0;
+  const i = t.getAllSeries().reduce((l, s) => l + s.getPointCount(), 0);
+  return new Promise((l) => {
+    const s = performance.now() + r.warmup + r.duration, c = performance.now() + r.warmup;
+    let u = !1, d = 0;
+    function y() {
+      const h = performance.now();
+      if (h >= s) {
+        const b = o.length > 0 ? o.reduce((T, S) => T + S, 0) / o.length : 0, m = d > 0 ? h - d : r.duration, v = a > 0 && m > 0 ? a / m * 1e3 : 0, p = n.length > 0 ? n.reduce((T, S) => T + S, 0) / n.length : b > 0 ? 1e3 / b : 0, f = {
+          avgFps: Math.round(v * 100) / 100,
+          minFps: Math.round((n.length > 0 ? Math.min(...n) : v) * 100) / 100,
+          maxFps: Math.round((n.length > 0 ? Math.max(...n) : v) * 100) / 100,
+          avgFrameTime: Math.round(b * 1e3) / 1e3,
+          frameCount: a,
+          duration: r.duration,
+          pointsRendered: i,
+          throughput: Math.round(i * v / 1e3) * 1e3,
+          /** @internal render-only FPS (not wall clock) */
+          ...p > 0 ? { renderFps: Math.round(p * 100) / 100 } : {}
+        };
+        l(f);
+        return;
+      }
+      h >= c && !u && (u = !0, d = h, a = 0, o.length = 0, n.length = 0);
+      const g = performance.now();
+      t.render();
+      const w = performance.now();
+      if (u) {
+        const b = w - g;
+        o.push(b), a++;
+        const m = o.slice(-30);
+        if (m.length > 0) {
+          const v = m.reduce((p, f) => p + f, 0) / m.length;
+          v > 0 && n.push(1e3 / v);
+        }
+      }
+      requestAnimationFrame(y);
+    }
+    requestAnimationFrame(y);
+  });
+}
+function Hr(t, e) {
+  const r = {
+    format: "json",
+    includeStyles: !0,
+    ...e
+  }, n = t.getAllSeries().map((a) => ({
+    id: a.getId(),
+    type: a.getType(),
+    pointCount: a.getPointCount(),
+    ...r.includeStyles ? { style: a.getStyle() } : {}
+  })), o = {
+    timestamp: Date.now(),
+    config: {},
+    series: n,
+    bounds: t.getViewBounds()
+  };
+  return r.format === "png" && t.exportImage && (o.image = t.exportImage()), o;
+}
+function zr(t, e, r = 1e-6) {
+  const n = [];
+  t.series.length !== e.series.length && n.push(`Series count: ${t.series.length} vs ${e.series.length}`);
+  for (let a = 0; a < Math.min(t.series.length, e.series.length); a++) {
+    const i = t.series[a], l = e.series[a];
+    i.id !== l.id && n.push(`Series[${a}] id: "${i.id}" vs "${l.id}"`), i.type !== l.type && n.push(`Series[${a}] type: "${i.type}" vs "${l.type}"`), i.pointCount !== l.pointCount && n.push(`Series[${a}] pointCount: ${i.pointCount} vs ${l.pointCount}`);
   }
+  const o = ["xMin", "xMax", "yMin", "yMax"];
+  for (const a of o)
+    Math.abs(t.bounds[a] - e.bounds[a]) > r && n.push(`Bounds.${a}: ${t.bounds[a]} vs ${e.bounds[a]}`);
+  return {
+    equal: n.length === 0,
+    differences: n
+  };
+}
+function Nr(t, e) {
+  const r = [];
+  return e.minFps && t.avgFps < e.minFps && r.push(`FPS ${t.avgFps} < required ${e.minFps}`), e.maxFrameTime && t.avgFrameTime > e.maxFrameTime && r.push(`Frame time ${t.avgFrameTime}ms > required ${e.maxFrameTime}ms`), e.minThroughput && t.throughput < e.minThroughput && r.push(`Throughput ${t.throughput} < required ${e.minThroughput}`), {
+    passed: r.length === 0,
+    failures: r
+  };
 }
-const we = {
+function Ur(t = 1) {
+  return new Promise((e) => {
+    let r = t;
+    function n() {
+      r--, r <= 0 ? e() : requestAnimationFrame(n);
+    }
+    requestAnimationFrame(n);
+  });
+}
+function qr(t) {
+  return new Promise((e) => setTimeout(e, t));
+}
+const fr = {
   name: "crosshair",
   version: "1.0.0",
   description: "Interactive crosshair that follows mouse cursor",
   provides: ["interaction", "visualization"],
   tags: ["cursor", "crosshair", "tooltip"]
-}, Se = G(
-  we,
-  (n = {}) => {
+}, hr = Z(
+  fr,
+  (t = {}) => {
     const {
       showVertical: e = !0,
-      showHorizontal: t = !0,
-      color: o,
-      lineStyle: r = "dashed",
+      showHorizontal: r = !0,
+      color: n,
+      lineStyle: o = "dashed",
       lineWidth: a = 1,
-      snapToData: d = !1,
-      valueFormat: c = { 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 u = -1, h = -1, S, v = null, p = null;
+      snapToData: i = !1,
+      valueFormat: l = { xPrecision: 4, yPrecision: 4 }
+    } = t;
+    let s = t.valueDisplayMode ?? "disabled";
+    t.showAxisLabels !== void 0 && t.valueDisplayMode === void 0 && (s = t.showAxisLabels ? "floating" : "disabled");
+    const c = t.cornerPosition ?? "top-left";
+    let u = -1, d = -1, y, h = null, g = null;
     return {
-      onInit(f) {
-        S = "crosshair-overlay";
-        const l = f.ui.createOverlay(S, {
+      onInit(p) {
+        y = "crosshair-overlay";
+        const f = p.ui.createOverlay(y, {
           zIndex: 500,
           position: { top: "0", left: "0", right: "0", bottom: "0" }
         });
-        v = document.createElement("canvas"), v.style.cssText = "width: 100%; height: 100%;", l.appendChild(v), p = v.getContext("2d"), w(f);
+        h = document.createElement("canvas"), h.style.cssText = "width: 100%; height: 100%;", f.appendChild(h), g = h.getContext("2d"), w(p);
       },
-      onDestroy(f) {
-        f.ui.removeOverlay(S), v = null, p = null;
+      onDestroy(p) {
+        p.ui.removeOverlay(y), h = null, g = null;
       },
-      onResize(f) {
-        w(f);
+      onResize(p) {
+        w(p);
       },
-      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);
+      onInteraction(p, f) {
+        if (f.type === "mousemove") {
+          if (u = f.pixelX, d = f.pixelY, i && f.inPlotArea) {
+            const T = p.coords.pickPoint(u, d);
+            T && (u = T.pixelX, d = T.pixelY);
           }
-          b(f);
+          b(p);
         }
       },
       onViewChange() {
       }
     };
-    function w(f) {
-      if (!v || !p) return;
-      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 w(p) {
+      if (!h || !g) return;
+      const f = p.render.canvasSize, T = p.render.pixelRatio;
+      h.width = f.width * T, h.height = f.height * T, g.setTransform(1, 0, 0, 1, 0, 0), g.scale(T, T);
     }
-    function b(f) {
-      var C;
-      if (!p || !v) return;
-      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)
+    function b(p) {
+      var D;
+      if (!g || !h) return;
+      const { width: f, height: T } = p.render.canvasSize;
+      if (g.clearRect(0, 0, f, T), u < 0 || d < 0) return;
+      const S = p.render.plotArea;
+      if (u < S.x || u > S.x + S.width || d < S.y || d > S.y + S.height)
         return;
-      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);
+      const L = n || ((D = p.ui.theme.cursor) == null ? void 0 : D.color) || "#888888";
+      g.save(), g.strokeStyle = L, g.lineWidth = a, o === "dashed" ? g.setLineDash([6, 4]) : o === "dotted" && g.setLineDash([2, 2]), e && (g.beginPath(), g.moveTo(u, S.y), g.lineTo(u, S.y + S.height), g.stroke()), r && (g.beginPath(), g.moveTo(S.x, d), g.lineTo(S.x + S.width, d), g.stroke()), g.restore(), s === "floating" ? m(p, g, u, d, L) : s === "corner" && v(p, g, u, d, L);
     }
-    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(p, f, T, S, L) {
+      const D = p.coords.pixelToDataX(T), k = p.coords.pixelToDataY(S), M = p.render.plotArea;
+      f.save(), f.font = "11px system-ui, sans-serif", f.textAlign = "center", f.textBaseline = "top";
+      const B = D.toPrecision(l.xPrecision), F = f.measureText(B).width + 8, C = 18, $ = T - F / 2, I = M.y + M.height + 2;
+      f.fillStyle = L, f.fillRect($, I, F, C), f.fillStyle = "#ffffff", f.fillText(B, T, I + 3), f.textAlign = "right", f.textBaseline = "middle";
+      const Y = k.toPrecision(l.yPrecision), x = f.measureText(Y).width + 8, A = 18, E = M.x - x - 2, _ = S - A / 2;
+      f.fillStyle = L, f.fillRect(E, _, x, A), f.fillStyle = "#ffffff", f.fillText(Y, M.x - 6, S), f.restore();
     }
-    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) {
+    function v(p, f, T, S, L) {
+      const D = p.coords.pixelToDataX(T), k = p.coords.pixelToDataY(S), M = p.render.plotArea;
+      f.save(), f.font = "11px system-ui, sans-serif";
+      const B = `X: ${D.toPrecision(l.xPrecision)}`, P = `Y: ${k.toPrecision(l.yPrecision)}`, F = f.measureText(B), C = f.measureText(P), $ = Math.max(F.width, C.width), I = 6, Y = 16, R = $ + I * 2, x = Y * 2 + I * 2;
+      let A, E;
+      switch (c) {
         case "top-left":
-          L = M.x + 8, R = M.y + 8;
+          A = M.x + 8, E = M.y + 8;
           break;
         case "top-right":
-          L = M.x + M.width - E - 8, R = M.y + 8;
+          A = M.x + M.width - R - 8, E = M.y + 8;
           break;
         case "bottom-left":
-          L = M.x + 8, R = M.y + M.height - X - 8;
+          A = M.x + 8, E = M.y + M.height - x - 8;
           break;
         case "bottom-right":
-          L = M.x + M.width - E - 8, R = M.y + M.height - X - 8;
+          A = M.x + M.width - R - 8, E = M.y + M.height - x - 8;
           break;
         default:
-          L = M.x + 8, R = M.y + 8;
+          A = M.x + 8, E = M.y + 8;
       }
-      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();
+      f.fillStyle = L, f.globalAlpha = 0.85, f.fillRect(A, E, R, x), f.globalAlpha = 1, f.strokeStyle = "rgba(255,255,255,0.3)", f.lineWidth = 1, f.strokeRect(A, E, R, x), f.fillStyle = "#ffffff", f.textAlign = "left", f.textBaseline = "top", f.fillText(B, A + I, E + I), f.fillText(P, A + I, E + I + Y), f.restore();
     }
   }
-), Te = {
+), gr = {
   name: "statistics-overlay",
   version: "1.0.0",
   description: "Displays real-time statistics for chart data",
   provides: ["visualization", "analysis"],
   tags: ["statistics", "overlay", "analytics"]
-}, be = G(
-  Te,
-  (n = {}) => {
+}, pr = Z(
+  gr,
+  (t = {}) => {
     const {
       position: e = "top-right",
-      show: t = ["count", "mean", "min", "max"],
-      seriesId: o,
-      autoUpdate: r = !0
-    } = n;
-    let a, d = null;
+      show: r = ["count", "mean", "min", "max"],
+      seriesId: n,
+      autoUpdate: o = !0
+    } = t;
+    let a, i = null;
     return {
-      onInit(s) {
+      onInit(c) {
         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, {
+        e.includes("top") && (u.top = "10px"), e.includes("bottom") && (u.bottom = "10px"), e.includes("left") && (u.left = "10px"), e.includes("right") && (u.right = "10px"), i = c.ui.createOverlay(a, {
           zIndex: 800,
           position: u,
           pointerEvents: !1
-        }), d.innerHTML = `
+        }), i.innerHTML = `
           <div style="
             background: rgba(0, 0, 0, 0.85);
             color: #fff;
@@ -219,188 +1605,188 @@ const we = {
             <div style="font-weight: bold; margin-bottom: 4px; color: #4ade80;">📊 Statistics</div>
             <div class="stats-content"></div>
           </div>
-        `, c(s);
+        `, l(c);
       },
-      onDestroy(s) {
-        s.ui.removeOverlay(a), d = null;
+      onDestroy(c) {
+        c.ui.removeOverlay(a), i = null;
       },
-      onDataUpdate(s) {
-        r && c(s);
+      onDataUpdate(c) {
+        o && l(c);
       },
-      onSeriesAdd(s) {
-        c(s);
+      onSeriesAdd(c) {
+        l(c);
       },
-      onSeriesRemove(s) {
-        c(s);
+      onSeriesRemove(c) {
+        l(c);
       },
       api: {
-        refresh(s) {
-          c(s);
+        refresh(c) {
+          l(c);
         }
       }
     };
-    function c(s) {
-      if (!d) return;
-      const u = d.querySelector(".stats-content");
+    function l(c) {
+      if (!i) return;
+      const u = i.querySelector(".stats-content");
       if (!u) return;
-      const h = s.data.getAllSeries(), S = o ? h.filter((b) => b.getId() === o) : h;
-      if (S.length === 0) {
+      const d = c.data.getAllSeries(), y = n ? d.filter((b) => b.getId() === n) : d;
+      if (y.length === 0) {
         u.innerHTML = "<div style='color: #888'>No data</div>";
         return;
       }
-      let v = [];
-      if (S.forEach((b) => {
-        const g = b.getData();
-        g != null && g.y && (v = v.concat(Array.from(g.y)));
-      }), v.length === 0) {
+      let h = [];
+      if (y.forEach((b) => {
+        const m = b.getData();
+        m != null && m.y && (h = h.concat(Array.from(m.y)));
+      }), h.length === 0) {
         u.innerHTML = "<div style='color: #888'>No data</div>";
         return;
       }
-      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("");
+      const g = s(h), w = [];
+      r.includes("count") && w.push(`<div>N: <span style="color: #60a5fa">${g.count.toLocaleString()}</span></div>`), r.includes("mean") && w.push(`<div>μ: <span style="color: #60a5fa">${g.mean.toPrecision(4)}</span></div>`), r.includes("min") && w.push(`<div>Min: <span style="color: #60a5fa">${g.min.toPrecision(4)}</span></div>`), r.includes("max") && w.push(`<div>Max: <span style="color: #60a5fa">${g.max.toPrecision(4)}</span></div>`), r.includes("std") && w.push(`<div>σ: <span style="color: #60a5fa">${g.std.toPrecision(4)}</span></div>`), r.includes("range") && w.push(`<div>Range: <span style="color: #60a5fa">${g.range.toPrecision(4)}</span></div>`), u.innerHTML = w.join("");
     }
-    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;
+    function s(c) {
+      const u = c.length;
+      let d = 0, y = 1 / 0, h = -1 / 0;
+      for (const m of c)
+        d += m, m < y && (y = m), m > h && (h = m);
+      const g = d / u;
       let w = 0;
-      for (const g of s)
-        w += (g - p) ** 2;
+      for (const m of c)
+        w += (m - g) ** 2;
       const b = Math.sqrt(w / u);
       return {
         count: u,
-        mean: p,
-        min: S,
-        max: v,
+        mean: g,
+        min: y,
+        max: h,
         std: b,
-        range: v - S
+        range: h - y
       };
     }
   }
-), Ae = {
+), mr = {
   name: "watermark",
   version: "1.0.0",
   description: "Adds a customizable watermark to the chart",
   provides: ["visualization"],
   tags: ["watermark", "branding", "overlay"]
-}, Me = G(
-  Ae,
-  (n) => {
-    if (!(n != null && n.text))
+}, yr = Z(
+  mr,
+  (t) => {
+    if (!(t != null && t.text))
       throw new Error("WatermarkPlugin requires 'text' configuration");
     const {
       text: e,
-      fontSize: t = 48,
-      fontFamily: o = "system-ui, sans-serif",
-      color: r = "rgba(128, 128, 128, 0.15)",
+      fontSize: r = 48,
+      fontFamily: n = "system-ui, sans-serif",
+      color: o = "rgba(128, 128, 128, 0.15)",
       position: a = "center",
-      rotation: d = a === "center" ? -30 : 0
-    } = n;
+      rotation: i = a === "center" ? -30 : 0
+    } = t;
     return {
-      onRenderOverlay(c) {
-        const i = c.render.ctx2d;
-        if (!i) return;
-        c.render.canvasSize;
-        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();
+      onRenderOverlay(l) {
+        const s = l.render.ctx2d;
+        if (!s) return;
+        l.render.canvasSize;
+        const c = l.render.plotArea;
+        s.save(), s.font = `${r}px ${n}`, s.fillStyle = o, s.textAlign = "center", s.textBaseline = "middle";
+        let u, d;
+        a === "center" ? (u = c.x + c.width / 2, d = c.y + c.height / 2) : a === "bottom-right" ? (u = c.x + c.width - r, d = c.y + c.height - r / 2) : (u = c.x + r, d = c.y + c.height - r / 2), s.translate(u, d), s.rotate(i * Math.PI / 180), s.fillText(e, 0, 0), s.restore();
       }
     };
   }
-), Ce = {
+), xr = {
   name: "grid-highlight",
   version: "1.0.0",
   description: "Highlights specific regions of the chart grid",
   provides: ["visualization"],
   tags: ["grid", "highlight", "regions"]
-}, Fe = G(
-  Ce,
-  (n = {}) => {
-    const { xIntervals: e = [], yIntervals: t = [], opacity: o = 0.1 } = n;
+}, br = Z(
+  xr,
+  (t = {}) => {
+    const { xIntervals: e = [], yIntervals: r = [], opacity: n = 0.1 } = t;
     return {
-      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 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(u - s),
-            c.height
+      onRenderOverlay(o, a) {
+        const i = o.render.ctx2d;
+        if (!i) return;
+        const l = o.render.plotArea;
+        o.data.getViewBounds(), i.save(), i.beginPath(), i.rect(l.x, l.y, l.width, l.height), i.clip(), i.globalAlpha = n;
+        for (const s of e) {
+          const c = o.coords.dataToPixelX(s.start), u = o.coords.dataToPixelX(s.end);
+          i.fillStyle = s.color, i.fillRect(
+            Math.min(c, u),
+            l.y,
+            Math.abs(u - c),
+            l.height
           );
         }
-        for (const i of t) {
-          const s = r.coords.dataToPixelY(i.start), u = r.coords.dataToPixelY(i.end);
-          d.fillStyle = i.color, d.fillRect(
-            c.x,
-            Math.min(s, u),
-            c.width,
-            Math.abs(u - s)
+        for (const s of r) {
+          const c = o.coords.dataToPixelY(s.start), u = o.coords.dataToPixelY(s.end);
+          i.fillStyle = s.color, i.fillRect(
+            l.x,
+            Math.min(c, u),
+            l.width,
+            Math.abs(u - c)
           );
         }
-        d.restore();
+        i.restore();
       }
     };
   }
-), De = {
+), vr = {
   name: "data-logger",
   version: "1.0.0",
   description: "Logs chart events for debugging and analysis",
   provides: ["analysis"],
   tags: ["debug", "logging", "events"]
-}, Ee = G(
-  De,
-  (n = {}) => {
+}, wr = Z(
+  vr,
+  (t = {}) => {
     const {
       logDataUpdates: e = !0,
-      logViewChanges: t = !0,
-      logInteractions: o = !1,
-      maxEntries: r = 100
-    } = n, a = [];
-    function d(c, i) {
+      logViewChanges: r = !0,
+      logInteractions: n = !1,
+      maxEntries: o = 100
+    } = t, a = [];
+    function i(l, s) {
       a.push({
         timestamp: Date.now(),
-        type: c,
-        data: i
-      }), a.length > r && a.shift();
+        type: l,
+        data: s
+      }), a.length > o && a.shift();
     }
     return {
-      onInit(c) {
-        c.log.info("Data logger initialized");
+      onInit(l) {
+        l.log.info("Data logger initialized");
       },
-      onDataUpdate(c, i) {
-        e && (d("dataUpdate", {
-          seriesId: i.seriesId,
-          mode: i.mode,
-          pointCount: i.pointCount
-        }), c.log.debug(`Data update: ${i.seriesId} (${i.mode}, ${i.pointCount} points)`));
+      onDataUpdate(l, s) {
+        e && (i("dataUpdate", {
+          seriesId: s.seriesId,
+          mode: s.mode,
+          pointCount: s.pointCount
+        }), l.log.debug(`Data update: ${s.seriesId} (${s.mode}, ${s.pointCount} points)`));
       },
-      onViewChange(c, i) {
-        t && (d("viewChange", {
-          trigger: i.trigger,
-          bounds: i.current
-        }), c.log.debug(`View change: ${i.trigger}`));
+      onViewChange(l, s) {
+        r && (i("viewChange", {
+          trigger: s.trigger,
+          bounds: s.current
+        }), l.log.debug(`View change: ${s.trigger}`));
       },
-      onInteraction(c, i) {
-        o && d("interaction", {
-          type: i.type,
-          pixelX: i.pixelX,
-          pixelY: i.pixelY,
-          inPlotArea: i.inPlotArea
+      onInteraction(l, s) {
+        n && i("interaction", {
+          type: s.type,
+          pixelX: s.pixelX,
+          pixelY: s.pixelY,
+          inPlotArea: s.inPlotArea
         });
       },
-      onSerialize(c) {
+      onSerialize(l) {
         return { entries: a };
       },
-      onDeserialize(c, i) {
-        const s = i;
-        s != null && s.entries && (a.length = 0, a.push(...s.entries));
+      onDeserialize(l, s) {
+        const c = s;
+        c != null && c.entries && (a.length = 0, a.push(...c.entries));
       },
       api: {
         getEntries() {
@@ -415,1128 +1801,612 @@ const we = {
       }
     };
   }
-), Ie = {
+), Pr = {
   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"]
-}, Le = G(
-  Ie,
-  (n = {}) => {
+}, Sr = Z(
+  Pr,
+  (t = {}) => {
     const {
       seriesId: e,
-      sampleSize: t = 20,
-      color: o,
-      size: r = 40,
-      minVelocity: a = 0.01,
-      historySize: d = 20,
-      idleTimeout: 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(m) {
-        i = "direction-indicator-overlay";
-        const A = m.ui.createOverlay(i, {
-          zIndex: 600,
-          position: { top: "0", left: "0", right: "0", bottom: "0" },
-          pointerEvents: !1
-        });
-        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 = m.data.getAllSeries();
-          T.length > 0 && (S = T[0].getId());
-        }
-      },
-      onDestroy(m) {
-        m.ui.removeOverlay(i), g && clearTimeout(g), s = null, u = null, h = null;
-      },
-      onResize(m) {
-        x(m);
-      },
-      onAfterRender(m) {
-        if (D(m), M(m), P) {
-          g && clearTimeout(g);
-          const A = Date.now() - y;
-          A < P && (g = setTimeout(() => {
-            m.requestRender();
-          }, P - A + 10));
-        }
-      },
-      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();
-        }
-        A.idleTimeout !== void 0 && (P = A.idleTimeout);
-      }
-    };
-    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(m) {
-      if (!S || !m.data.getSeries(S)) return;
-      const T = m.data.getSeriesData(S);
-      if (!T || !T.x || !T.y) return;
-      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 $ = 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 C(m) {
-      return m.length === 0 ? 0 : m.reduce((A, T) => A + T, 0) / m.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(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 _(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();
-    }
-  }
-), 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"]
-}, Re = {
-  enabled: !0,
-  constraint: "both",
-  snapToGrid: !1,
-  snapIntervalX: 1,
-  snapIntervalY: 1,
-  dragThreshold: 5,
-  hitRadius: 10,
-  editableSeries: [],
-  validator: () => ({ valid: !0 }),
-  onDragStart: () => {
-  },
-  onDrag: () => {
-  },
-  onDragEnd: () => {
-  },
-  highlightColor: "#ffff00",
-  showPreview: !0,
-  previewStyle: {
-    color: "#ffffff",
-    width: 2,
-    dash: [5, 5],
-    opacity: 0.5
-  }
-};
-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 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 s(g, y) {
-    return t ? {
-      x: t.coords.pixelToDataX(g),
-      y: t.coords.pixelToDataY(y)
-    } : { x: 0, y: 0 };
-  }
-  function u(g, y) {
-    return Math.round(g / y) * y;
-  }
-  function h(g, y, f) {
-    if (!r) return { x: g, y };
-    switch (f) {
-      case "x":
-        return { x: g, y: r.originalY };
-      case "y":
-        return { x: r.originalX, y };
-      case "none":
-        return { x: r.originalX, y: r.originalY };
-      default:
-        return { x: g, y };
-    }
-  }
-  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: f, y: l, valid: x };
-      if (!x.valid)
-        return { x: f, y: l, valid: !1 };
-      x.snapX !== void 0 && (f = x.snapX), x.snapY !== void 0 && (l = x.snapY);
-    }
-    return { x: f, y: l, valid: !0 };
-  }
-  function v(g, y, f, l) {
-    var D, C, B;
-    if (!t) return;
-    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[y] = f, x.y[y] = l, (B = P.invalidateBuffers) == null || B.call(P), t.requestRender());
-  }
-  function p() {
-    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 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 b = {
-    enable() {
-      e.enabled = !0;
-    },
-    disable() {
-      e.enabled = !1, o && (r = null, o = !1, c = !1, t == null || t.requestRender());
-    },
-    isEnabled() {
-      return e.enabled;
-    },
-    setEditableSeries(g) {
-      e.editableSeries = g;
-    },
-    getDraggedPoint() {
-      return r;
-    },
-    cancelDrag() {
-      o && r && (r = null, o = !1, c = !1, t == null || t.requestRender());
-    },
-    updateConfig(g) {
-      Object.assign(e, g);
-    }
-  };
-  return {
-    manifest: ke,
-    onInit(g) {
-      t = g, t.chart.dragEdit = b;
-    },
-    onDestroy(g) {
-      delete g.chart.dragEdit, t = null;
-    },
-    onInteraction(g, y) {
-      if (e.enabled) {
-        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;
-          }
-          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) {
-            r.currentX = P, r.currentY = x;
-            const C = p();
-            C && e.onDrag(C), t == null || t.requestRender();
-          }
-        } else if (y.type === "mouseup") {
-          if (!r) return;
-          if (o && c) {
-            v(
-              r.seriesId,
-              r.index,
-              r.currentX,
-              r.currentY
-            );
-            const f = p();
-            f && e.onDragEnd(f), y.preventDefault();
-          }
-          r = null, o = !1, c = !1, t == null || t.requestRender();
-        }
-      }
-    },
-    onRenderOverlay(g) {
-      w(g);
-    },
-    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
-  };
-}
-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)
+      sampleSize: r = 20,
+      color: n,
+      size: o = 40,
+      minVelocity: a = 0.01,
+      historySize: i = 20,
+      idleTimeout: l
+    } = t;
+    let s, c = null, u = null, d = null, y = null;
+    const h = [], g = [], w = [];
+    let b = i, m = null, v = Date.now(), p = -1 / 0, f = -1 / 0, T = l;
     return {
-      canvas2d: o,
-      webgl: null,
-      gainPercent: 0,
-      recommendation: "defer"
+      onInit(P) {
+        s = "direction-indicator-overlay";
+        const F = P.ui.createOverlay(s, {
+          zIndex: 600,
+          position: { top: "0", left: "0", right: "0", bottom: "0" },
+          pointerEvents: !1
+        });
+        if (c = document.createElement("canvas"), c.style.cssText = "width: 100%; height: 100%; pointer-events: none;", F.appendChild(c), u = c.getContext("2d"), S(P), e)
+          y = e;
+        else {
+          const C = P.data.getAllSeries();
+          C.length > 0 && (y = C[0].getId());
+        }
+      },
+      onDestroy(P) {
+        P.ui.removeOverlay(s), m && clearTimeout(m), c = null, u = null, d = null;
+      },
+      onResize(P) {
+        S(P);
+      },
+      onAfterRender(P) {
+        if (L(P), M(P), T) {
+          m && clearTimeout(m);
+          const F = Date.now() - v;
+          F < T && (m = setTimeout(() => {
+            P.requestRender();
+          }, T - F + 10));
+        }
+      },
+      onConfigChange(P, F) {
+        if (F.historySize !== void 0) {
+          for (b = F.historySize; h.length > b; ) h.shift();
+          for (; g.length > b; ) g.shift();
+          for (; w.length > b; ) w.shift();
+        }
+        F.idleTimeout !== void 0 && (T = F.idleTimeout);
+      }
     };
-  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"
+    function S(P) {
+      if (!c || !u) return;
+      const F = P.render.canvasSize, C = P.render.pixelRatio;
+      c.width = F.width * C, c.height = F.height * C, u.setTransform(1, 0, 0, 1, 0, 0), u.scale(C, C);
+    }
+    function L(P) {
+      if (!y || !P.data.getSeries(y)) return;
+      const C = P.data.getSeriesData(y);
+      if (!C || !C.x || !C.y) return;
+      const $ = C.x.length;
+      if ($ < 2) return;
+      const I = C.x[$ - 1], Y = C.y[$ - 1];
+      (I !== p || Y !== f) && (p = I, f = Y, v = Date.now());
+      const R = Math.min(r, $), x = $ - R;
+      let A = 0, E = 0, _ = 0, O = 0, q = 0, j = 0;
+      for (let re = x; re < $; re++) {
+        const ne = re - x, Ve = C.x[re], Ge = C.y[re], fe = P.coords.dataToPixelX(Ve), he = P.coords.dataToPixelY(Ge);
+        A += ne, E += fe, _ += he, O += ne * fe, q += ne * he, j += ne * ne;
+      }
+      const H = A / R, z = E / R, G = _ / R, V = j - R * H * H;
+      if (Math.abs(V) < 1e-10) return;
+      const N = (O - R * H * z) / V, X = (q - R * H * G) / V, K = Math.atan2(X, N), ee = P.coords.dataToPixelX(I), J = P.coords.dataToPixelY(Y);
+      h.push(ee), g.push(J), h.length > b && (h.shift(), g.shift()), w.push(K), w.length > b && w.shift();
+      const te = D(h), Ye = D(g), Xe = k(w), We = Math.sqrt(N * N + X * X);
+      d = { angle: Xe, magnitude: We, lastX: I, lastY: Y, smoothX: te, smoothY: Ye };
+    }
+    function D(P) {
+      return P.length === 0 ? 0 : P.reduce((F, C) => F + C, 0) / P.length;
+    }
+    function k(P) {
+      if (P.length === 0) return 0;
+      let F = 0, C = 0;
+      for (const $ of P)
+        F += Math.cos($), C += Math.sin($);
+      return Math.atan2(C / P.length, F / P.length);
+    }
+    function M(P) {
+      if (!u || !c || !d) return;
+      const { width: F, height: C } = P.render.canvasSize;
+      if (u.clearRect(0, 0, F, C), T !== void 0 && Date.now() - v > T || d.magnitude < a) return;
+      const $ = d.smoothX, I = d.smoothY, Y = n || "#FF9800";
+      u.save(), B(u, $, I, d.angle, o, Y), u.restore();
+    }
+    function B(P, F, C, $, I, Y) {
+      const R = I * 0.6, x = I * 0.4;
+      P.save(), P.translate(F, C), P.rotate($), P.fillStyle = Y, P.beginPath(), P.moveTo(R / 2, 0), P.lineTo(-R / 2, -x / 2), P.lineTo(-R / 2, x / 2), P.closePath(), P.fill(), P.restore();
+    }
+  }
+), jr = {
+  Crosshair: hr,
+  Statistics: pr,
+  Watermark: yr,
+  GridHighlight: br,
+  DataLogger: wr,
+  DirectionIndicator: Sr
+}, Tr = {
+  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"]
+}, Ar = {
+  enabled: !0,
+  constraint: "both",
+  snapToGrid: !1,
+  snapIntervalX: 1,
+  snapIntervalY: 1,
+  dragThreshold: 5,
+  hitRadius: 10,
+  editableSeries: [],
+  validator: () => ({ valid: !0 }),
+  onDragStart: () => {
   },
-  "boxplot-5k-webgpu": {
-    minAvgFps: 50,
-    description: "5k boxplot series on WebGPU chart path"
+  onDrag: () => {
   },
-  "grid-canvas2d-dpr2": {
-    maxAvgFrameUs: 1200,
-    dpr: 2,
-    description: "Canvas 2D grid+minor at 1920×1080 @2x"
+  onDragEnd: () => {
   },
-  "grid-webgl-dpr2": {
-    maxAvgFrameUs: 400,
-    dpr: 2,
-    description: "WebGL grid spike lines only @2x"
+  highlightColor: "#ffff00",
+  showPreview: !0,
+  previewStyle: {
+    color: "#ffffff",
+    width: 2,
+    dash: [5, 5],
+    opacity: 0.5
   }
-}, 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"
+function Kr(t = {}) {
+  const e = { ...Ar, ...t };
+  let r = null, n = !1, o = null, a = 0, i = 0, l = !1;
+  function s(m, v) {
+    if (!r) return null;
+    const p = r.coords.pickPoint(m, v, e.hitRadius);
+    return !p || e.editableSeries.length > 0 && !e.editableSeries.includes(p.seriesId) ? null : {
+      seriesId: p.seriesId,
+      index: p.index,
+      originalX: p.x,
+      originalY: p.y,
+      currentX: p.x,
+      currentY: p.y
     };
-  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) {
-    Y(this, "seed");
-    this.seed = e;
-  }
-  next() {
-    let e = this.seed += 1831565813;
-    return e = Math.imul(e ^ e >>> 15, e | 1), e ^= e + Math.imul(e ^ e >>> 7, e | 61), ((e ^ e >>> 14) >>> 0) / 4294967296;
   }
-  nextRange(e, t) {
-    return e + this.next() * (t - e);
+  function c(m, v) {
+    return r ? {
+      x: r.coords.pixelToDataX(m),
+      y: r.coords.pixelToDataY(v)
+    } : { x: 0, y: 0 };
   }
-}
-function st(n) {
-  const e = {
-    pointCount: 1e3,
-    amplitude: 1,
-    frequency: 1,
-    phase: 0,
-    noise: 0,
-    xStart: 0,
-    xEnd: 10,
-    offset: 0,
-    ...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;
+  function u(m, v) {
+    return Math.round(m / v) * v;
   }
-  return { x: t, y: o };
-}
-function lt(n) {
-  const e = {
-    pointCount: 1e3,
-    amplitude: 1,
-    frequency: 1,
-    phase: 0,
-    noise: 0,
-    xStart: 0,
-    xEnd: 10,
-    offset: 0,
-    ...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;
+  function d(m, v, p) {
+    if (!o) return { x: m, y: v };
+    switch (p) {
+      case "x":
+        return { x: m, y: o.originalY };
+      case "y":
+        return { x: o.originalX, y: v };
+      case "none":
+        return { x: o.originalX, y: o.originalY };
+      default:
+        return { x: m, y: v };
+    }
   }
-  return { x: t, y: o };
-}
-function ct(n) {
-  const e = {
-    pointCount: 1e3,
-    amplitude: 1,
-    frequency: 1,
-    phase: 0,
-    noise: 0,
-    xStart: 0,
-    xEnd: 10,
-    offset: 0,
-    ...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;
+  function y(m, v) {
+    let p = m, f = v;
+    if (e.snapToGrid && (p = u(m, e.snapIntervalX), f = u(v, e.snapIntervalY)), o && e.validator) {
+      const T = { ...o, currentX: p, currentY: f }, S = e.validator(T);
+      if (typeof S == "boolean")
+        return { x: p, y: f, valid: S };
+      if (!S.valid)
+        return { x: p, y: f, valid: !1 };
+      S.snapX !== void 0 && (p = S.snapX), S.snapY !== void 0 && (f = S.snapY);
+    }
+    return { x: p, y: f, valid: !0 };
   }
-  return { x: t, y: o };
-}
-function dt(n) {
-  const e = {
-    pointCount: 1e3,
-    amplitude: 1,
-    frequency: 1,
-    phase: 0,
-    noise: 0,
-    xStart: 0,
-    xEnd: 10,
-    offset: 0,
-    ...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;
+  function h(m, v, p, f) {
+    var L, D, k;
+    if (!r) return;
+    const T = (D = (L = r.chart).getSeries) == null ? void 0 : D.call(L, m);
+    if (!T) return;
+    const S = T.getData();
+    !S || !S.x || !S.y || (S.x[v] = p, S.y[v] = f, (k = T.invalidateBuffers) == null || k.call(T), r.requestRender());
   }
-  return { x: t, y: o };
-}
-function ut(n) {
-  const e = {
-    pointCount: 1e3,
-    xRange: [0, 100],
-    yRange: [-1, 1],
-    sorted: !0,
-    seed: Date.now(),
-    ...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 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++)
-      d[i] = o[a[i]], c[i] = r[a[i]];
-    return { x: d, y: c };
+  function g() {
+    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
+    } : null;
   }
-  return { x: o, y: r };
-}
-function ft(n) {
-  const e = {
-    pointCount: 2e3,
-    vMin: -0.5,
-    vMax: 0.5,
-    cycles: 1,
-    peakCurrent: 1e-5,
-    // 10 µA
-    noise: 0.02,
-    ...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 < 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: o, y: r };
-}
-function gt(n) {
-  const e = {
-    pointCount: 50,
-    rSolution: 100,
-    // Ohms
-    rCharge: 1e3,
-    // Ohms
-    frequency: [1e5, 0.01],
-    ...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;
+  function w(m) {
+    if (!n || !o || !e.showPreview) return;
+    const { render: v, coords: p } = m, { ctx2d: f } = v;
+    if (!f) return;
+    f.save();
+    const T = p.dataToPixelX(o.originalX), S = p.dataToPixelY(o.originalY), L = p.dataToPixelX(o.currentX), D = p.dataToPixelY(o.currentY);
+    f.strokeStyle = e.previewStyle.color || "#ffffff", f.lineWidth = e.previewStyle.width || 2, f.globalAlpha = e.previewStyle.opacity || 0.5, f.setLineDash(e.previewStyle.dash || [5, 5]), f.beginPath(), f.moveTo(T, S), f.lineTo(L, D), f.stroke(), f.globalAlpha = 1, f.fillStyle = e.highlightColor, f.setLineDash([]), f.beginPath(), f.arc(L, D, 6, 0, Math.PI * 2), f.fill(), f.strokeStyle = "#000000", f.lineWidth = 1, f.stroke(), f.restore();
   }
-  return { x: t, y: o };
-}
-async function pt(n, e) {
-  const t = {
-    duration: 5e3,
-    warmup: 1e3,
-    ...e
-  }, 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 >= 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: d,
-          throughput: Math.round(d * y / 1e3) * 1e3,
-          /** @internal render-only FPS (not wall clock) */
-          ...f > 0 ? { renderFps: Math.round(f * 100) / 100 } : {}
-        };
-        c(l);
-        return;
-      }
-      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);
-        }
-      }
-      requestAnimationFrame(S);
+  const b = {
+    enable() {
+      e.enabled = !0;
+    },
+    disable() {
+      e.enabled = !1, n && (o = null, n = !1, l = !1, r == null || r.requestRender());
+    },
+    isEnabled() {
+      return e.enabled;
+    },
+    setEditableSeries(m) {
+      e.editableSeries = m;
+    },
+    getDraggedPoint() {
+      return o;
+    },
+    cancelDrag() {
+      n && o && (o = null, n = !1, l = !1, r == null || r.requestRender());
+    },
+    updateConfig(m) {
+      Object.assign(e, m);
     }
-    requestAnimationFrame(S);
-  });
-}
-function ht(n, e) {
-  const t = {
-    format: "json",
-    includeStyles: !0,
-    ...e
-  }, 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: o,
-    bounds: n.getViewBounds()
   };
-  return t.format === "png" && n.exportImage && (r.image = n.exportImage()), r;
-}
-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 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: o.length === 0,
-    differences: o
+    manifest: Tr,
+    onInit(m) {
+      r = m, r.chart.dragEdit = b;
+    },
+    onDestroy(m) {
+      delete m.chart.dragEdit, r = null;
+    },
+    onInteraction(m, v) {
+      if (e.enabled) {
+        if (v.type === "mousedown") {
+          const p = s(v.pixelX, v.pixelY);
+          p && (o = p, a = v.pixelX, i = v.pixelY, l = !1, n = !1, v.preventDefault());
+        } else if (v.type === "mousemove") {
+          if (!o) return;
+          if (!n) {
+            const D = v.pixelX - a, k = v.pixelY - i;
+            if (Math.sqrt(D * D + k * k) > e.dragThreshold) {
+              n = !0, l = !0;
+              const B = g();
+              B && e.onDragStart(B);
+            } else
+              return;
+          }
+          n && v.preventDefault();
+          let { x: p, y: f } = c(v.pixelX, v.pixelY);
+          ({ x: p, y: f } = d(p, f, e.constraint));
+          const { x: T, y: S, valid: L } = y(p, f);
+          if (L) {
+            o.currentX = T, o.currentY = S;
+            const D = g();
+            D && e.onDrag(D), r == null || r.requestRender();
+          }
+        } else if (v.type === "mouseup") {
+          if (!o) return;
+          if (n && l) {
+            h(
+              o.seriesId,
+              o.index,
+              o.currentX,
+              o.currentY
+            );
+            const p = g();
+            p && e.onDragEnd(p), v.preventDefault();
+          }
+          o = null, n = !1, l = !1, r == null || r.requestRender();
+        }
+      }
+    },
+    onRenderOverlay(m) {
+      w(m);
+    },
+    api: b
   };
 }
-function yt(n, e) {
-  const t = [];
-  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 Jr(t) {
+  return t;
 }
-function xt(n = 1) {
-  return new Promise((e) => {
-    let t = n;
-    function o() {
-      t--, t <= 0 ? e() : requestAnimationFrame(o);
-    }
-    requestAnimationFrame(o);
+function Qr(t, e) {
+  return (r) => ({
+    ...e(r),
+    manifest: t
   });
 }
-function vt(n) {
-  return new Promise((e) => setTimeout(e, n));
-}
+Ie();
 export {
-  St as AnimationEngine,
-  In as AnnotationManager,
-  to as BackpressureManager,
-  Po as BaseBufferStore,
-  wo as BaseTextureStore,
-  tt as BuiltinPlugins,
-  cr as ChartGroup,
-  Tt as ChartInitQueue,
-  no as CircularBuffer,
-  qo as ClipboardManager,
-  Se as CrosshairPlugin,
-  ee as DARK_THEME,
-  bt as DEFAULT_ANIMATION_CONFIG,
-  Wo as DEFAULT_KEY_BINDINGS,
-  At as DEFAULT_LAYOUT,
-  Mt as DEFAULT_THEME,
-  Ee as DataLoggerPlugin,
-  Qo as DebugOverlay,
-  Le as DirectionIndicatorPlugin,
-  Ct as ELECTROCHEM_THEME,
-  Tn as EventEmitter,
-  So as GpuBenchmark,
-  To as GpuCompute,
-  Hn as GpuRenderer,
-  Fe as GridHighlightPlugin,
-  zo as KeyBindingManager,
-  Ft as LIGHT_THEME,
-  Co as LOCALE_DE_DE,
-  Fo as LOCALE_EN_US,
-  Do as LOCALE_ES_ES,
-  Eo as LOCALE_FR_FR,
-  Io as LOCALE_JA_JP,
-  Lo as LOCALE_PT_BR,
-  ko as LOCALE_ZH_CN,
-  O as LinearScale,
-  ar as LoadingIndicator,
-  Dt as LogScale,
-  Et as MIDNIGHT_THEME,
-  It as NativeWebGLRenderer,
-  Pe as OverlayRenderer,
-  bo as PipelineCache,
-  fi as Plugin3D,
-  va as PluginAnalysis,
-  Ln as PluginAnnotations,
-  Si as PluginAnomalyDetection,
-  Ui as PluginBrokenAxis,
-  _i as PluginCaching,
-  No as PluginClipboard,
-  Pi as PluginContextMenu,
-  xi as PluginDataExport,
-  Ri as PluginDataTransform,
-  Zo as PluginDebug,
-  nt as PluginDragEdit,
-  pr as PluginDrawingTools,
-  ji as PluginForecasting,
-  Ao as PluginGpu,
-  pi as PluginI18n,
-  Uo as PluginKeyboard,
-  Yi as PluginLaTeX,
-  Wi as PluginLazyLoad,
-  or as PluginLoading,
-  bi as PluginMLIntegration,
-  Lt as PluginManagerImpl,
-  qi as PluginOffscreen,
-  Mi as PluginPatternRecognition,
-  Vi as PluginROI,
-  Ei as PluginRadar,
-  Fi as PluginRegression,
-  hr as PluginReplay,
-  Li as PluginSnapshot,
-  ao as PluginStreaming,
-  mi as PluginSync,
-  vr as PluginThemeEditor,
-  Qn as PluginTools,
-  Oi as PluginVideoRecorder,
-  aa as PluginVirtualization,
-  kt as SERIALIZATION_VERSION,
-  mo as STACKED_DEFAULT_MIN_PANE_RATIO,
-  yo as STACKED_MAX_PANES,
-  go as SciPlot,
-  Rt as Series,
-  qn as SeriesAdapter,
-  Xt as StateHistory,
-  be as StatsPlugin,
-  Pr as THEME_PRESETS,
-  Zn as TOOLTIP_THEMES,
-  wr as ThemeEditor,
-  ea as TooltipManager,
-  Me as WatermarkPlugin,
-  Nn as WebGLBackend,
-  Vn as WebGPUBackend,
-  ae as WebGPURenderer,
-  ma as WorkerPool,
-  Yt as addIndicatorToChart,
-  Hr as adx,
-  Pa as analyzeComplexSpectrum,
-  wa as analyzeSpectrum,
-  bn as applyBusinessDayX,
-  qr as aroon,
-  Sa as arraysToComplex,
-  yt as assertPerformance,
-  Nr as atr,
-  Ta as autoCorrelation,
-  ba as bandPassFilter,
-  Aa as bandStopFilter,
-  mr as barsToOhlc,
-  Ue as benchmarkCanvasGrid,
-  pt as benchmarkRender,
-  $e as benchmarkWebGLGrid,
-  Ma as blackmanWindow,
-  Vr as bollingerBands,
-  Bt as bollingerBandsAsync,
-  _t as buildIndicatorPane,
-  Gt as buildIndicatorPaneFromPreset,
-  Wt as buildIndicatorSeries,
-  zt as buildPositionLineAnnotation,
-  An as businessDaySpanMs,
-  Ca as butterworth,
-  Gr as calculateR2,
-  Mr 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,
-  oo as connectStreamToChart,
-  Vo as copyToClipboard,
-  ro as createBackpressureManager,
-  qt as createChart,
-  dr as createChartGroup,
-  Xn as createConfigurablePlugin,
-  er as createDebugOverlay,
-  Kn as createGpuRenderer,
-  Nt as createIndicatorSeries,
-  $o as createKeyBinding,
-  rr as createLoadingIndicator,
-  Ro as createLocaleFormatter,
-  io as createLosslessBackpressure,
-  ur as createMasterSlave,
-  so as createMessageParser,
-  yr as createMockDatafeed,
-  lo as createMockStream,
-  Vt as createNativeRenderer,
-  Yn as createPlugin,
-  Kt as createPluginContext,
-  co as createRealtimeBackpressure,
-  Bn as createRenderer,
-  jt as createScale,
-  ht as createSnapshot,
-  xo as createStackedChart,
-  Jt as createTheme,
-  Sr as createThemeEditor,
-  uo as createWebSocketStream,
-  Da as crossCorrelation,
-  Kr as cumsum,
-  Wr as cumulativeIntegral,
-  Qt as decodeFloat32Array,
-  Zt as decompressString,
-  _n as defineAndRegister,
-  G as definePlugin,
-  jr as dema,
-  zr as derivative,
-  ra as destroyDownsamplePool,
-  en as destroyIndicatorPool,
-  Ea as detectAnomalies,
-  Cr as detectCycles,
-  tn as detectIndicatorMarkers,
-  Fr as detectPeaks,
-  Ia as dominantFrequency,
-  ia as downsampleAsync,
-  Dr as downsampleLTTB,
-  nn as easings,
-  Jr as ema,
-  an as emaAsync,
-  tr as enableDebugMode,
-  on as encodeFloat32Array,
-  it as evaluateRendererCompare,
-  La as exponentialMovingAverage,
-  ka as fft,
-  Ra as fftFromComplexInput,
-  Mn as formatBusinessDayTick,
-  Ko as formatData,
-  Er as formatScientific,
-  Ir as formatValue,
-  Lr as formatWithPrefix,
-  Xa as gaussianSmooth,
-  ft as generateCVData,
-  Ya as generateContours,
-  kr as generateCycleColors,
-  gt as generateNyquistData,
-  ut as generateRandomData,
-  ct as generateSawtoothWave,
-  st as generateSineWave,
-  lt as generateSquareWave,
-  dt as generateTriangleWave,
-  ot as getBaseline,
-  Rr as getBestPrefix,
-  rn as getChartInitQueue,
-  jo as getClipboardManager,
-  sa as getDownsamplePoolSize,
-  Xo as getGlobalLocale,
-  Yo as getLocale,
-  Gn as getPluginRegistry,
-  Ba as getPositiveFrequencies,
-  Tr as getPresetNames,
-  br as getPresetTheme,
-  sn as getSharedAnimationEngine,
-  ln as getThemeByName,
-  ta as getTooltipThemeForChartTheme,
-  _a as hammingWindow,
-  Ga as hanningWindow,
-  Wa as highPassFilter,
-  za as ifft,
-  Ua as ifftComplex,
-  $a as ifftFromArrays,
-  Ur as integrate,
-  cn as interleaveData,
-  Cn as isBusinessDay,
-  Fn as isBusinessDayScaleActive,
-  Oa as joinSegments,
-  fr as linkCharts,
-  Wn as listPluginsByCategory,
-  zn as loadPlugin,
-  Ha as lowPassFilter,
-  la as lowerBoundX,
-  ca as lttbDownsample,
-  Qr as macd,
-  dn as macdAsync,
-  Dn as mapToBusinessDayScale,
-  qa as medianFilter,
-  un as mergeAnimationConfig,
-  fn as mergeLayoutOptions,
-  da as minMaxDownsample,
-  Zr as momentum,
-  Xr as movingAverage,
-  Na as nextPowerOf2,
-  ya as nextTaskId,
-  ei as normalize,
-  ti as obv,
-  ua as ohlcDownsampleAsync,
-  fa as ohlcMinMaxDownsample,
-  gn as parseColor,
-  jn as parseColorToRGBA,
-  Oo as parseShortcut,
-  ni as percentChange,
-  Va as powerSpectrum,
-  pn as queueChartInit,
-  Bo as registerLocale,
-  Un as registerPlugin,
-  hn as resetChartQueue,
-  ai as roc,
-  oi as rsi,
-  mn as rsiAsync,
-  Ka as savitzkyGolay,
-  _o as setGlobalLocale,
-  ir as showLoading,
-  sr as showProgress,
-  ja as simpsonsIntegration,
-  Ja as singleFrequencyFilter,
-  ga as sliceSeriesToViewport,
-  ri as sma,
-  yn as smaAsync,
-  $r as solveLinearSystem,
-  ii as standardDeviation,
-  xn as stateToUrlHash,
-  si as stochastic,
-  Yr as subtractBaseline,
-  Qa as tTest,
-  li as tema,
-  Za as trapezoidalIntegration,
-  pa as upperBoundX,
-  vn as urlHashToState,
-  po as useSciPlot,
-  Pn as validateChartState,
-  Br as validateData,
-  $n as validateManifest,
-  ci as vwap,
-  vt as waitFor,
-  wn as waitForAnimations,
-  xt as waitForFrames,
-  di as wma
+  En as AnimationEngine,
+  Ai as AnnotationManager,
+  gi as BackpressureManager,
+  ss as BaseBufferStore,
+  ls as BaseTextureStore,
+  jr as BuiltinPlugins,
+  ri as ChartGroup,
+  Dn as ChartInitQueue,
+  pi as CircularBuffer,
+  Xa as ClipboardManager,
+  hr as CrosshairPlugin,
+  xe as DARK_THEME,
+  Ln as DEFAULT_ANIMATION_CONFIG,
+  Ra as DEFAULT_KEY_BINDINGS,
+  kn as DEFAULT_LAYOUT,
+  In as DEFAULT_THEME,
+  wr as DataLoggerPlugin,
+  za as DebugOverlay,
+  Sr as DirectionIndicatorPlugin,
+  Rn as ELECTROCHEM_THEME,
+  sn as EventEmitter,
+  cs as GpuBenchmark,
+  us as GpuCompute,
+  ds as GpuRenderer,
+  br as GridHighlightPlugin,
+  $a as KeyBindingManager,
+  $n as LIGHT_THEME,
+  va as LOCALE_DE_DE,
+  wa as LOCALE_EN_US,
+  Pa as LOCALE_ES_ES,
+  Sa as LOCALE_FR_FR,
+  Ta as LOCALE_JA_JP,
+  Aa as LOCALE_PT_BR,
+  Ca as LOCALE_ZH_CN,
+  se as LinearScale,
+  Ka as LoadingIndicator,
+  Bn as LogScale,
+  _n as MIDNIGHT_THEME,
+  Le as NativeWebGLRenderer,
+  lt as OverlayRenderer,
+  fs as PipelineCache,
+  Vs as Plugin3D,
+  Co as PluginAnalysis,
+  Ci as PluginAnnotations,
+  Js as PluginAnomalyDetection,
+  yl as PluginBrokenAxis,
+  hl as PluginCaching,
+  Wa as PluginClipboard,
+  js as PluginContextMenu,
+  Us as PluginDataExport,
+  cl as PluginDataTransform,
+  Na as PluginDebug,
+  Kr as PluginDragEdit,
+  tn as PluginDrawingTools,
+  Al as PluginForecasting,
+  hs as PluginGpu,
+  Ma as PluginI18n,
+  Os as PluginKeyboard,
+  dl as PluginLaTeX,
+  pl as PluginLazyLoad,
+  Ja as PluginLoading,
+  Zs as PluginMLIntegration,
+  Yn as PluginManagerImpl,
+  wl as PluginOffscreen,
+  tl as PluginPatternRecognition,
+  Sl as PluginROI,
+  al as PluginRadar,
+  nl as PluginRegression,
+  rn as PluginReplay,
+  sl as PluginSnapshot,
+  mi as PluginStreaming,
+  zs as PluginSync,
+  si as PluginThemeEditor,
+  _i as PluginTools,
+  bl as PluginVideoRecorder,
+  co as PluginVirtualization,
+  Xn as SERIALIZATION_VERSION,
+  hn as STACKED_DEFAULT_MIN_PANE_RATIO,
+  gn as STACKED_MAX_PANES,
+  la as SciChart,
+  ca as SciPlot,
+  Wn as Series,
+  gs as SeriesAdapter,
+  ua as StackedPlot,
+  Vn as StateHistory,
+  pr as StatsPlugin,
+  li as THEME_PRESETS,
+  Yi as TOOLTIP_THEMES,
+  ci as ThemeEditor,
+  Xi as TooltipManager,
+  da as VeloPlot,
+  yr as WatermarkPlugin,
+  ps as WebGLBackend,
+  ms as WebGPUBackend,
+  Re as WebGPURenderer,
+  So as WorkerPool,
+  qe as addIndicatorToChart,
+  vs as adx,
+  Mo as analyzeComplexSpectrum,
+  Fo as analyzeSpectrum,
+  pe as applyBusinessDayX,
+  ws as aroon,
+  Eo as arraysToComplex,
+  Nr as assertPerformance,
+  Ps as atr,
+  Do as autoCorrelation,
+  Lo as bandPassFilter,
+  ko as bandStopFilter,
+  nn as barsToOhlc,
+  nr as benchmarkCanvasGrid,
+  Or as benchmarkRender,
+  or as benchmarkWebGLGrid,
+  Io as blackmanWindow,
+  Ss as bollingerBands,
+  pn as bollingerBandsAsync,
+  mn as buildIndicatorPane,
+  yn as buildIndicatorPaneFromPreset,
+  je as buildIndicatorSeries,
+  Ut as buildPositionLineAnnotation,
+  ln as businessDaySpanMs,
+  Ro as butterworth,
+  ts as calculateR2,
+  Gi as calculateStats,
+  uo as calculateTargetPoints,
+  Fi as checkPluginCompatibility,
+  kr as compareGridBackends,
+  Rr as compareScenarioToBaseline,
+  zr as compareSnapshots,
+  $o as complexToArrays,
+  Gn as compressString,
+  ze as computeHeikinAshi,
+  xn as computeIndicatorFromSeries,
+  bn as computeIndicatorPreset,
+  yi as connectStreamToChart,
+  Va as copyToClipboard,
+  xi as createBackpressureManager,
+  On as createChart,
+  ni as createChartGroup,
+  Qr as createConfigurablePlugin,
+  Ua as createDebugOverlay,
+  ys as createGpuRenderer,
+  vn as createIndicatorSeries,
+  Ba as createKeyBinding,
+  Qa as createLoadingIndicator,
+  Fa as createLocaleFormatter,
+  bi as createLosslessBackpressure,
+  oi as createMasterSlave,
+  vi as createMessageParser,
+  on as createMockDatafeed,
+  wi as createMockStream,
+  Le as createNativeRenderer,
+  Jr as createPlugin,
+  Hn as createPluginContext,
+  Pi as createRealtimeBackpressure,
+  Ei as createRenderer,
+  zn as createScale,
+  Hr as createSnapshot,
+  wn as createStackedChart,
+  Nn as createTheme,
+  ui as createThemeEditor,
+  Si as createWebSocketStream,
+  Bo as crossCorrelation,
+  Ts as cumsum,
+  rs as cumulativeIntegral,
+  Un as decodeFloat32Array,
+  qn as decompressString,
+  Di as defineAndRegister,
+  Z as definePlugin,
+  As as dema,
+  ns as derivative,
+  fo as destroyDownsamplePool,
+  Pn as destroyIndicatorPool,
+  _o as detectAnomalies,
+  Oi as detectCycles,
+  Sn as detectIndicatorMarkers,
+  Hi as detectPeaks,
+  Yo as dominantFrequency,
+  ho as downsampleAsync,
+  zi as downsampleLTTB,
+  jn as easings,
+  Cs as ema,
+  Tn as emaAsync,
+  qa as enableDebugMode,
+  Kn as encodeFloat32Array,
+  $r as evaluateRendererCompare,
+  Xo as exponentialMovingAverage,
+  Wo as fft,
+  Vo as fftFromComplexInput,
+  cn as formatBusinessDayTick,
+  Ga as formatData,
+  Ni as formatScientific,
+  Ui as formatValue,
+  qi as formatWithPrefix,
+  Go as gaussianSmooth,
+  Vr as generateCVData,
+  Oo as generateContours,
+  ji as generateCycleColors,
+  Gr as generateNyquistData,
+  Wr as generateRandomData,
+  Yr as generateSawtoothWave,
+  Br as generateSineWave,
+  _r as generateSquareWave,
+  Xr as generateTriangleWave,
+  Ir as getBaseline,
+  Ki as getBestPrefix,
+  Jn as getChartInitQueue,
+  Oa as getClipboardManager,
+  go as getDownsamplePoolSize,
+  Ea as getGlobalLocale,
+  Da as getLocale,
+  Li as getPluginRegistry,
+  Ho as getPositiveFrequencies,
+  di as getPresetNames,
+  fi as getPresetTheme,
+  Qn as getSharedAnimationEngine,
+  Zn as getThemeByName,
+  Wi as getTooltipThemeForChartTheme,
+  zo as hammingWindow,
+  No as hanningWindow,
+  Uo as highPassFilter,
+  qo as ifft,
+  jo as ifftComplex,
+  Ko as ifftFromArrays,
+  os as integrate,
+  De as interleaveData,
+  un as isBusinessDay,
+  ge as isBusinessDayScaleActive,
+  Jo as joinSegments,
+  ai as linkCharts,
+  ki as listPluginsByCategory,
+  Ii as loadPlugin,
+  Qo as lowPassFilter,
+  po as lowerBoundX,
+  mo as lttbDownsample,
+  Ms as macd,
+  An as macdAsync,
+  dn as mapToBusinessDayScale,
+  Zo as medianFilter,
+  eo as mergeAnimationConfig,
+  to as mergeLayoutOptions,
+  yo as minMaxDownsample,
+  Fs as momentum,
+  Ji as movingAverage,
+  ea as nextPowerOf2,
+  To as nextTaskId,
+  Es as normalize,
+  Ds as obv,
+  xo as ohlcDownsampleAsync,
+  bo as ohlcMinMaxDownsample,
+  ae as parseColor,
+  xs as parseColorToRGBA,
+  _a as parseShortcut,
+  Ls as percentChange,
+  ta as powerSpectrum,
+  ro as queueChartInit,
+  La as registerLocale,
+  Ri as registerPlugin,
+  no as resetChartQueue,
+  ks as roc,
+  Is as rsi,
+  Cn as rsiAsync,
+  ra as savitzkyGolay,
+  ka as setGlobalLocale,
+  Za as showLoading,
+  ei as showProgress,
+  na as simpsonsIntegration,
+  oa as singleFrequencyFilter,
+  vo as sliceSeriesToViewport,
+  Rs as sma,
+  Mn as smaAsync,
+  as as solveLinearSystem,
+  $s as standardDeviation,
+  oo as stateToUrlHash,
+  Bs as stochastic,
+  Qi as subtractBaseline,
+  aa as tTest,
+  _s as tema,
+  ia as trapezoidalIntegration,
+  wo as upperBoundX,
+  ao as urlHashToState,
+  fa as useChartGroup,
+  ha as useChartSync,
+  ga as useIndicator,
+  pa as useSciChart,
+  ma as useSciPlot,
+  ya as useStackedPlot,
+  xa as useVeloPlot,
+  io as validateChartState,
+  Zi as validateData,
+  $i as validateManifest,
+  Ys as vwap,
+  qr as waitFor,
+  so as waitForAnimations,
+  Ur as waitForFrames,
+  Xs as wma
 };
 //# sourceMappingURL=velo-plot.full.js.map