velo-plot 3.0.0 → 4.0.0-alpha.1

package/dist/velo-plot.full.js

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