velo-plot 3.0.0 → 3.1.0

package/dist/plugins/regression.js

@@ -1,200 +1,198 @@
 import { s as P } from "../math-Ddm2EZjj.js";
-function T(f) {
-  return Array.from(f);
+function T(u) {
+  return Array.from(u);
 }
-function v(f) {
-  return new Float32Array(f);
+function v(u) {
+  return new Float32Array(u);
 }
-function _(f) {
-  return f.reduce((h, i) => h + i, 0) / f.length;
+function _(u) {
+  return u.reduce((h, i) => h + i, 0) / u.length;
 }
-function z(f) {
-  const h = _(f);
-  return f.reduce((i, c) => i + Math.pow(c - h, 2), 0) / f.length;
+function z(u) {
+  const h = _(u);
+  return u.reduce((i, l) => i + Math.pow(l - h, 2), 0) / u.length;
 }
-function O(f, h) {
-  const i = _(f);
-  let c = 0, l = 0;
-  for (let g = 0; g < f.length; g++)
-    c += Math.pow(f[g] - h[g], 2), l += Math.pow(f[g] - i, 2);
-  return 1 - c / l;
+function O(u, h) {
+  const i = _(u);
+  let l = 0, c = 0;
+  for (let m = 0; m < u.length; m++)
+    l += Math.pow(u[m] - h[m], 2), c += Math.pow(u[m] - i, 2);
+  return 1 - l / c;
 }
-function C(f, h, i) {
-  return 1 - (1 - f) * (h - 1) / (h - i - 1);
+function C(u, h, i) {
+  return 1 - (1 - u) * (h - 1) / (h - i - 1);
 }
-function E(f, h) {
+function E(u, h) {
   let i = 0;
-  for (let c = 0; c < f.length; c++)
-    i += Math.pow(f[c] - h[c], 2);
-  return Math.sqrt(i / f.length);
+  for (let l = 0; l < u.length; l++)
+    i += Math.pow(u[l] - h[l], 2);
+  return Math.sqrt(i / u.length);
 }
-function V(f, h = {}) {
-  const i = performance.now(), c = T(f.x), l = T(f.y), g = f.weights ? T(f.weights) : null, { forceOrigin: M = !1 } = h, d = c.length;
-  if (M) {
+function V(u, h = {}) {
+  const i = performance.now(), l = T(u.x), c = T(u.y), m = u.weights ? T(u.weights) : null, { forceOrigin: S = !1 } = h, f = l.length;
+  if (S) {
     let w = 0, p = 0;
-    for (let t = 0; t < d; t++) {
-      const e = g ? g[t] : 1;
-      w += e * c[t] * l[t], p += e * c[t] * c[t];
+    for (let t = 0; t < f; t++) {
+      const e = m ? m[t] : 1;
+      w += e * l[t] * c[t], p += e * l[t] * l[t];
     }
-    const R = w / p, $ = c.map((t) => R * t), S = l.map((t, e) => t - $[e]), y = O(l, $), q = C(y, d, 1), x = E(l, $);
+    const R = w / p, $ = l.map((t) => R * t), y = c.map((t, e) => t - $[e]), x = O(c, $), q = C(x, f, 1), M = E(c, $);
     return {
       method: "linear",
       parameters: {
         parameters: [R],
-        uncertainties: [Math.sqrt(p / (d * w))],
+        uncertainties: [Math.sqrt(p / (f * w))],
         // Simplified
         correlationMatrix: [[1]]
       },
       statistics: {
-        rSquared: y,
+        rSquared: x,
         adjustedRSquared: q,
-        rmse: x,
-        rss: S.reduce((t, e) => t + e * e, 0),
-        tss: l.reduce((t, e) => t + Math.pow(e - _(l), 2), 0),
-        n: d,
+        rmse: M,
+        rss: y.reduce((t, e) => t + e * e, 0),
+        tss: c.reduce((t, e) => t + Math.pow(e - _(c), 2), 0),
+        n: f,
         k: 1
       },
       fittedValues: v($),
-      residuals: v(S),
-      goodnessOfFit: y > 0.9 ? "excellent" : y > 0.7 ? "good" : y > 0.5 ? "fair" : "poor",
+      residuals: v(y),
+      goodnessOfFit: x > 0.9 ? "excellent" : x > 0.7 ? "good" : x > 0.5 ? "fair" : "poor",
       converged: !0,
       iterations: 1,
       processingTime: performance.now() - i
     };
   } else {
-    let w = 0, p = 0, R = 0, $ = 0, S = 0, y = 0;
-    for (let u = 0; u < d; u++) {
-      const m = g ? g[u] : 1;
-      w += m * c[u], p += m * l[u], R += m * c[u] * l[u], $ += m * c[u] * c[u], S += m * l[u] * l[u], y += m;
+    let w = 0, p = 0, R = 0, $ = 0, y = 0;
+    for (let r = 0; r < f; r++) {
+      const d = m ? m[r] : 1;
+      w += d * l[r], p += d * c[r], R += d * l[r] * c[r], $ += d * l[r] * l[r], y += d;
     }
-    const q = w / y, x = p / y, t = (R - y * q * x) / ($ - y * q * q), e = x - t * q, s = c.map((u) => t * u + e), o = l.map((u, m) => u - s[m]), r = O(l, s), n = C(r, d, 2), a = E(l, s);
+    const x = w / y, q = p / y, M = (R - y * x * q) / ($ - y * x * x), t = q - M * x, e = l.map((r) => M * r + t), s = c.map((r, d) => r - e[d]), o = O(c, e), n = C(o, f, 2), a = E(c, e);
     return {
       method: "linear",
       parameters: {
-        parameters: [t, e],
+        parameters: [M, t],
         uncertainties: [0.1, 0.1],
         // Simplified
         correlationMatrix: [[1, -0.5], [-0.5, 1]]
         // Simplified
       },
       statistics: {
-        rSquared: r,
+        rSquared: o,
         adjustedRSquared: n,
         rmse: a,
-        rss: o.reduce((u, m) => u + m * m, 0),
-        tss: l.reduce((u, m) => u + Math.pow(m - x, 2), 0),
-        n: d,
+        rss: s.reduce((r, d) => r + d * d, 0),
+        tss: c.reduce((r, d) => r + Math.pow(d - q, 2), 0),
+        n: f,
         k: 2
       },
-      fittedValues: v(s),
-      residuals: v(o),
-      goodnessOfFit: r > 0.9 ? "excellent" : r > 0.7 ? "good" : r > 0.5 ? "fair" : "poor",
+      fittedValues: v(e),
+      residuals: v(s),
+      goodnessOfFit: o > 0.9 ? "excellent" : o > 0.7 ? "good" : o > 0.5 ? "fair" : "poor",
       converged: !0,
       iterations: 1,
       processingTime: performance.now() - i
     };
   }
 }
-function U(f, h) {
-  const i = performance.now(), c = T(f.x), l = T(f.y), { degree: g } = h, M = c.length, d = g + 1, w = [];
-  for (let x = 0; x < M; x++) {
+function U(u, h) {
+  const i = performance.now(), l = T(u.x), c = T(u.y), { degree: m } = h, S = l.length, f = m + 1, w = [];
+  for (let M = 0; M < S; M++) {
     const t = [];
-    for (let e = 0; e <= g; e++)
-      t.push(Math.pow(c[x], e));
+    for (let e = 0; e <= m; e++)
+      t.push(Math.pow(l[M], e));
     w.push(t);
   }
-  const p = Y(w, l, 0), R = c.map((x) => {
+  const p = L(w, c, 0), R = l.map((M) => {
     let t = 0;
-    for (let e = 0; e <= g; e++)
-      t += p[e] * Math.pow(x, e);
+    for (let e = 0; e <= m; e++)
+      t += p[e] * Math.pow(M, e);
     return t;
-  }), $ = l.map((x, t) => x - R[t]), S = O(l, R), y = C(S, M, d), q = E(l, R);
+  }), $ = c.map((M, t) => M - R[t]), y = O(c, R), x = C(y, S, f), q = E(c, R);
   return {
     method: "polynomial",
     parameters: {
       parameters: p,
-      uncertainties: new Array(d).fill(0.1),
+      uncertainties: new Array(f).fill(0.1),
       // Simplified
-      correlationMatrix: Array(d).fill(0).map(() => Array(d).fill(0))
+      correlationMatrix: Array(f).fill(0).map(() => Array(f).fill(0))
       // Simplified
     },
     statistics: {
-      rSquared: S,
-      adjustedRSquared: y,
+      rSquared: y,
+      adjustedRSquared: x,
       rmse: q,
-      rss: $.reduce((x, t) => x + t * t, 0),
-      tss: l.reduce((x, t) => x + Math.pow(t - _(l), 2), 0),
-      n: M,
-      k: d
+      rss: $.reduce((M, t) => M + t * t, 0),
+      tss: c.reduce((M, t) => M + Math.pow(t - _(c), 2), 0),
+      n: S,
+      k: f
     },
     fittedValues: v(R),
     residuals: v($),
-    goodnessOfFit: S > 0.9 ? "excellent" : S > 0.7 ? "good" : S > 0.5 ? "fair" : "poor",
+    goodnessOfFit: y > 0.9 ? "excellent" : y > 0.7 ? "good" : y > 0.5 ? "fair" : "poor",
     converged: !0,
     iterations: 10,
     // Simplified
     processingTime: performance.now() - i
   };
 }
-function N(f, h = {}) {
-  const i = performance.now(), c = T(f.x), l = T(f.y);
-  let g = Math.min(...l) - 1;
-  const M = l.map((t) => {
-    const e = t - g;
+function N(u, h = {}) {
+  const i = performance.now(), l = T(u.x), c = T(u.y), m = Math.min(...c) - 1, S = c.map((t) => {
+    const e = t - m;
     return e > 0 ? Math.log(e) : 0;
-  }), d = V(
-    { x: c, y: M },
+  }), f = V(
+    { x: l, y: S },
     { forceOrigin: !1 }
-  ), [w, p] = d.parameters.parameters, R = Math.exp(p), $ = c.map((t) => R * Math.exp(w * t) + g), S = l.map((t, e) => t - $[e]), y = O(l, $), q = C(y, c.length, 3), x = E(l, $);
+  ), [w, p] = f.parameters.parameters, R = Math.exp(p), $ = l.map((t) => R * Math.exp(w * t) + m), y = c.map((t, e) => t - $[e]), x = O(c, $), q = C(x, l.length, 3), M = E(c, $);
   return {
     method: "exponential",
     parameters: {
-      parameters: [R, w, g],
+      parameters: [R, w, m],
       uncertainties: [0.1, 0.01, 0.1],
       // Simplified
       correlationMatrix: [[1, 0.5, 0.2], [0.5, 1, 0.3], [0.2, 0.3, 1]]
       // Simplified
     },
     statistics: {
-      rSquared: y,
+      rSquared: x,
       adjustedRSquared: q,
-      rmse: x,
-      rss: S.reduce((t, e) => t + e * e, 0),
-      tss: l.reduce((t, e) => t + Math.pow(e - _(l), 2), 0),
-      n: c.length,
+      rmse: M,
+      rss: y.reduce((t, e) => t + e * e, 0),
+      tss: c.reduce((t, e) => t + Math.pow(e - _(c), 2), 0),
+      n: l.length,
       k: 3
     },
     fittedValues: v($),
-    residuals: v(S),
-    goodnessOfFit: y > 0.9 ? "excellent" : y > 0.7 ? "good" : y > 0.5 ? "fair" : "poor",
+    residuals: v(y),
+    goodnessOfFit: x > 0.9 ? "excellent" : x > 0.7 ? "good" : x > 0.5 ? "fair" : "poor",
     converged: !0,
     iterations: 5,
     // Simplified
     processingTime: performance.now() - i
   };
 }
-function X(f, h = {}) {
-  const i = performance.now(), c = T(f.x), l = T(f.y);
-  let g = Math.max(...l), M = c.reduce((e, s) => e + s, 0) / c.length, d = Math.sqrt(z(c)), w = Math.min(...l);
+function X(u, h = {}) {
+  const i = performance.now(), l = T(u.x), c = T(u.y);
+  let m = Math.max(...c), S = l.reduce((e, s) => e + s, 0) / l.length, f = Math.sqrt(z(l)), w = Math.min(...c);
   const p = 1e-3, R = 100, $ = 1e-6;
   for (let e = 0; e < R; e++) {
-    let s = 0, o = 0, r = 0, n = 0, a = 0;
-    for (let u = 0; u < c.length; u++) {
-      const m = c[u], A = l[u], b = -Math.pow(m - M, 2) / (2 * d * d), j = g * Math.exp(b) + w, F = A - j;
-      a += F * F;
+    let s = 0, o = 0, n = 0, a = 0, r = 0;
+    for (let d = 0; d < l.length; d++) {
+      const g = l[d], A = c[d], b = -Math.pow(g - S, 2) / (2 * f * f), j = m * Math.exp(b) + w, F = A - j;
+      r += F * F;
       const k = Math.exp(b);
-      s += F * k, o += F * g * k * (m - M) / (d * d), r += F * g * k * Math.pow(m - M, 2) / Math.pow(d, 3), n += F;
+      s += F * k, o += F * m * k * (g - S) / (f * f), n += F * m * k * Math.pow(g - S, 2) / Math.pow(f, 3), a += F;
     }
-    if (g += p * s, M += p * o, d += p * r, w += p * n, d = Math.max(d, 0.01), a < $) break;
+    if (m += p * s, S += p * o, f += p * n, w += p * a, f = Math.max(f, 0.01), r < $) break;
   }
-  const S = c.map((e) => {
-    const s = -Math.pow(e - M, 2) / (2 * d * d);
-    return g * Math.exp(s) + w;
-  }), y = l.map((e, s) => e - S[s]), q = O(l, S), x = C(q, c.length, 4), t = E(l, S);
+  const y = l.map((e) => {
+    const s = -Math.pow(e - S, 2) / (2 * f * f);
+    return m * Math.exp(s) + w;
+  }), x = c.map((e, s) => e - y[s]), q = O(c, y), M = C(q, l.length, 4), t = E(c, y);
   return {
     method: "gaussian",
     parameters: {
-      parameters: [g, M, d, w],
+      parameters: [m, S, f, w],
       uncertainties: [0.1, 0.1, 0.01, 0.1],
       // Simplified
       correlationMatrix: Array(4).fill(0).map(() => Array(4).fill(0))
@@ -202,35 +200,35 @@ function X(f, h = {}) {
     },
     statistics: {
       rSquared: q,
-      adjustedRSquared: x,
+      adjustedRSquared: M,
       rmse: t,
-      rss: y.reduce((e, s) => e + s * s, 0),
-      tss: l.reduce((e, s) => e + Math.pow(s - _(l), 2), 0),
-      n: c.length,
+      rss: x.reduce((e, s) => e + s * s, 0),
+      tss: c.reduce((e, s) => e + Math.pow(s - _(c), 2), 0),
+      n: l.length,
       k: 4
     },
-    fittedValues: v(S),
-    residuals: v(y),
+    fittedValues: v(y),
+    residuals: v(x),
     goodnessOfFit: q > 0.9 ? "excellent" : q > 0.7 ? "good" : q > 0.5 ? "fair" : "poor",
     converged: !0,
     iterations: R,
     processingTime: performance.now() - i
   };
 }
-function Y(f, h, i = 0) {
-  const c = f.length, l = f[0].length, g = Array(l).fill(0).map(() => Array(l).fill(0)), M = Array(l).fill(0);
-  for (let d = 0; d < c; d++)
-    for (let w = 0; w < l; w++) {
-      for (let p = 0; p < l; p++)
-        g[w][p] += f[d][w] * f[d][p];
-      M[w] += f[d][w] * h[d];
+function L(u, h, i = 0) {
+  const l = u.length, c = u[0].length, m = Array(c).fill(0).map(() => Array(c).fill(0)), S = Array(c).fill(0);
+  for (let f = 0; f < l; f++)
+    for (let w = 0; w < c; w++) {
+      for (let p = 0; p < c; p++)
+        m[w][p] += u[f][w] * u[f][p];
+      S[w] += u[f][w] * h[f];
     }
   if (i > 0)
-    for (let d = 0; d < l; d++)
-      g[d][d] += i;
-  return P(g, M);
+    for (let f = 0; f < c; f++)
+      m[f][f] += i;
+  return P(m, S);
 }
-const L = {
+const Y = {
   name: "regression",
   version: "1.0.0",
   description: "Advanced scientific regression and curve fitting",
@@ -249,87 +247,87 @@ const L = {
   enableParallelProcessing: !1,
   parallelChunkSize: 1e3
 };
-function B(f = {}) {
-  const h = { ...J, ...f };
+function B(u = {}) {
+  const h = { ...J, ...u };
   let i = null;
-  const c = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Set(), g = /* @__PURE__ */ new Map();
-  async function M(t, e, s = h.defaultMethod, o = {}) {
+  const l = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Set(), m = /* @__PURE__ */ new Map();
+  async function S(t, e, s = h.defaultMethod, o = {}) {
     try {
       p.hideVisualization(t);
-      let r;
+      let n;
       switch (s) {
         case "linear":
-          r = V(e, o);
+          n = V(e, o);
           break;
         case "polynomial":
-          r = U(e, o);
+          n = U(e, o);
           break;
         case "exponential":
-          r = N(e, o);
+          n = N(e, o);
           break;
         case "gaussian":
-          r = X(e, o);
+          n = X(e, o);
           break;
         case "logarithmic":
-          const n = Array.from(e.x).map((m) => Math.log(m));
-          r = V({ ...e, x: new Float32Array(n) }, o), r.method = "logarithmic";
+          const a = Array.from(e.x).map((g) => Math.log(g));
+          n = V({ ...e, x: new Float32Array(a) }, o), n.method = "logarithmic";
           break;
         case "power":
-          const a = Array.from(e.y).map((m) => Math.log(m)), u = Array.from(e.x).map((m) => Math.log(m));
-          r = V({ ...e, x: new Float32Array(u), y: new Float32Array(a) }, o), r.method = "power";
+          const r = Array.from(e.y).map((g) => Math.log(g)), d = Array.from(e.x).map((g) => Math.log(g));
+          n = V({ ...e, x: new Float32Array(d), y: new Float32Array(r) }, o), n.method = "power";
           break;
         case "lorentzian":
         case "sigmoid":
         case "custom":
-          r = V(e, o);
+          n = V(e, o);
           break;
         default:
           throw new Error(`Unsupported regression method: ${s}`);
       }
-      return c.set(t, [r]), i && i.events.emit("regression:completed", {
-        result: r,
+      return l.set(t, [n]), i && i.events.emit("regression:completed", {
+        result: n,
         seriesId: t,
         method: s,
         timestamp: Date.now()
-      }), i == null || i.log.info(`Regression completed for ${t}: ${s} (R² = ${r.statistics.rSquared.toFixed(3)})`), r;
-    } catch (r) {
+      }), i == null || i.log.info(`Regression completed for ${t}: ${s} (R² = ${n.statistics.rSquared.toFixed(3)})`), n;
+    } catch (n) {
       throw i && i.events.emit("regression:failed", {
-        error: r,
+        error: n,
         seriesId: t,
         method: s,
-        reason: `Fitting failed: ${r}`,
+        reason: `Fitting failed: ${n}`,
         timestamp: Date.now()
-      }), r;
+      }), n;
     }
   }
-  async function d(t, e, s, o) {
-    const r = [];
-    for (let a = 0; a < s.length; a++) {
-      const u = s[a], m = o ? o[a] : {};
+  async function f(t, e, s, o) {
+    const n = [];
+    for (let r = 0; r < s.length; r++) {
+      const d = s[r], g = o ? o[r] : {};
       try {
-        const A = await M(t, e, u, m);
-        r.push(A);
+        const A = await S(t, e, d, g);
+        n.push(A);
       } catch (A) {
-        i == null || i.log.warn(`Regression failed for ${u}: ${A}`);
+        i == null || i.log.warn(`Regression failed for ${d}: ${A}`);
       }
     }
-    const n = h.modelSelectionCriteria;
-    return r.sort((a, u) => {
-      switch (n) {
+    const a = h.modelSelectionCriteria;
+    return n.sort((r, d) => {
+      switch (a) {
         case "aic":
-          return (a.statistics.aic || 0) - (u.statistics.aic || 0);
+          return (r.statistics.aic || 0) - (d.statistics.aic || 0);
         case "bic":
-          return (a.statistics.bic || 0) - (u.statistics.bic || 0);
+          return (r.statistics.bic || 0) - (d.statistics.bic || 0);
         case "adjusted-r2":
-          return u.statistics.adjustedRSquared - a.statistics.adjustedRSquared;
+          return d.statistics.adjustedRSquared - r.statistics.adjustedRSquared;
         default:
-          return u.statistics.rSquared - a.statistics.rSquared;
+          return d.statistics.rSquared - r.statistics.rSquared;
       }
-    }), r;
+    }), n;
   }
   async function w(t, e, s = ["linear", "polynomial", "exponential", "gaussian"]) {
-    const o = s.map((a) => {
-      switch (a) {
+    const o = s.map((r) => {
+      switch (r) {
         case "polynomial":
           return { degree: 2 };
         case "exponential":
@@ -339,122 +337,122 @@ function B(f = {}) {
         default:
           return {};
       }
-    }), r = await d(t, e, s, o);
-    if (r.length === 0)
+    }), n = await f(t, e, s, o);
+    if (n.length === 0)
       throw new Error("No regression methods succeeded");
-    const n = r[0];
+    const a = n[0];
     return i && i.events.emit("model:selected", {
-      selectedMethod: n.method,
-      candidateResults: r,
+      selectedMethod: a.method,
+      candidateResults: n,
       selectionCriteria: h.modelSelectionCriteria,
       seriesId: t,
       timestamp: Date.now()
-    }), i == null || i.log.info(`Auto-fit selected ${n.method} for ${t} (R² = ${n.statistics.rSquared.toFixed(3)})`), n;
+    }), i == null || i.log.info(`Auto-fit selected ${a.method} for ${t} (R² = ${a.statistics.rSquared.toFixed(3)})`), a;
   }
   const p = {
-    fit: M,
-    fitAndCompare: d,
+    fit: S,
+    fitAndCompare: f,
     autoFit: w,
     getResults(t) {
-      return c.get(t) || [];
+      return l.get(t) || [];
     },
     clearResults(t) {
-      c.delete(t), i == null || i.log.info(`Regression results cleared for series: ${t}`);
+      l.delete(t), i == null || i.log.info(`Regression results cleared for series: ${t}`);
     },
     predict(t, e, s = 0) {
-      const o = c.get(t);
+      const o = l.get(t);
       if (!o || o.length === 0)
         throw new Error(`No regression results found for series: ${t}`);
-      const r = o[Math.min(s, o.length - 1)], n = Array.from(e), a = r.parameters.parameters, u = n.map((m) => {
-        switch (r.method) {
+      const n = o[Math.min(s, o.length - 1)], a = Array.from(e), r = n.parameters.parameters, d = a.map((g) => {
+        switch (n.method) {
           case "linear":
-            return a[0] * m + (a[1] || 0);
+            return r[0] * g + (r[1] || 0);
           case "polynomial":
             let A = 0;
-            for (let j = 0; j < a.length; j++)
-              A += a[j] * Math.pow(m, j);
+            for (let j = 0; j < r.length; j++)
+              A += r[j] * Math.pow(g, j);
             return A;
           case "exponential":
-            return a[0] * Math.exp(a[1] * m) + (a[2] || 0);
+            return r[0] * Math.exp(r[1] * g) + (r[2] || 0);
           case "gaussian":
-            const b = -Math.pow(m - a[1], 2) / (2 * a[2] * a[2]);
-            return a[0] * Math.exp(b) + (a[3] || 0);
+            const b = -Math.pow(g - r[1], 2) / (2 * r[2] * r[2]);
+            return r[0] * Math.exp(b) + (r[3] || 0);
           case "logarithmic":
-            return a[0] * Math.log(m) + (a[1] || 0);
+            return r[0] * Math.log(g) + (r[1] || 0);
           case "power":
-            return a[0] * Math.pow(m, a[1]);
+            return r[0] * Math.pow(g, r[1]);
           default:
             return 0;
         }
       });
-      return new Float32Array(u);
+      return new Float32Array(d);
     },
     getConfidenceIntervals(t, e, s = h.defaultConfidenceLevel, o = 0) {
-      const r = this.predict(t, e, o), n = 0.1, a = r.map((m) => m - n), u = r.map((m) => m + n);
+      const n = this.predict(t, e, o), a = 0.1, r = n.map((g) => g - a), d = n.map((g) => g + a);
       return {
-        lower: new Float32Array(a),
-        upper: new Float32Array(u)
+        lower: new Float32Array(r),
+        upper: new Float32Array(d)
       };
     },
     evaluate(t, e, s = 0) {
-      const o = c.get(t);
+      const o = l.get(t);
       if (!o || o.length === 0)
         throw new Error(`No regression results found for series: ${t}`);
-      const r = o[Math.min(s, o.length - 1)], n = Array.from(e.x), a = Array.from(e.y), u = p.predict(t, n, s), m = Array.from(u), A = $(a, m), b = S(A, a.length, r.parameters.parameters.length), j = y(a, m);
+      const n = o[Math.min(s, o.length - 1)], a = Array.from(e.x), r = Array.from(e.y), d = p.predict(t, a, s), g = Array.from(d), A = $(r, g), b = y(A, r.length, n.parameters.parameters.length), j = x(r, g);
       return {
         rSquared: A,
         adjustedRSquared: b,
         rmse: j,
-        rss: a.reduce((F, k, D) => F + Math.pow(k - m[D], 2), 0),
-        tss: a.reduce((F, k) => F + Math.pow(k - R(a), 2), 0),
-        n: a.length,
-        k: r.parameters.parameters.length
+        rss: r.reduce((F, k, D) => F + Math.pow(k - g[D], 2), 0),
+        tss: r.reduce((F, k) => F + Math.pow(k - R(r), 2), 0),
+        n: r.length,
+        k: n.parameters.parameters.length
       };
     },
     enableRealtimeFitting(t, e = h.defaultMethod, s = {}) {
-      l.add(t);
+      c.add(t);
       const o = i == null ? void 0 : i.chart;
       if (o) {
-        const r = o.getSeries(t);
-        if (r) {
-          const n = r.getData();
-          n && n.x.length > 0 && M(t, {
-            x: n.x,
-            y: n.y
+        const n = o.getSeries(t);
+        if (n) {
+          const a = n.getData();
+          a && a.x.length > 0 && S(t, {
+            x: a.x,
+            y: a.y
           }, e, s);
         }
       }
       i == null || i.log.info(`Real-time regression fitting enabled for series: ${t}`);
     },
     disableRealtimeFitting(t) {
-      l.delete(t);
-      const e = g.get(t);
-      e && (clearTimeout(e), g.delete(t)), i == null || i.log.info(`Real-time regression fitting disabled for series: ${t}`);
+      c.delete(t);
+      const e = m.get(t);
+      e && (clearTimeout(e), m.delete(t)), i == null || i.log.info(`Real-time regression fitting disabled for series: ${t}`);
     },
     getStatistics(t) {
       if (t) {
-        const e = c.get(t) || [], s = {};
+        const e = l.get(t) || [], s = {};
         for (const o of e)
           s[o.method] = (s[o.method] || 0) + 1;
         return {
           totalFittings: e.length,
           methodsUsed: s,
-          averageRSquared: e.length > 0 ? e.reduce((o, r) => o + r.statistics.rSquared, 0) / e.length : 0,
-          averageProcessingTime: e.length > 0 ? e.reduce((o, r) => o + r.processingTime, 0) / e.length : 0
+          averageRSquared: e.length > 0 ? e.reduce((o, n) => o + n.statistics.rSquared, 0) / e.length : 0,
+          averageProcessingTime: e.length > 0 ? e.reduce((o, n) => o + n.processingTime, 0) / e.length : 0
         };
       } else {
         let e = 0;
-        const s = {}, o = [], r = [];
-        for (const n of c.values()) {
-          e += n.length, o.push(...n.map((a) => a.statistics.rSquared)), r.push(...n.map((a) => a.processingTime));
-          for (const a of n)
-            s[a.method] = (s[a.method] || 0) + 1;
+        const s = {}, o = [], n = [];
+        for (const a of l.values()) {
+          e += a.length, o.push(...a.map((r) => r.statistics.rSquared)), n.push(...a.map((r) => r.processingTime));
+          for (const r of a)
+            s[r.method] = (s[r.method] || 0) + 1;
         }
         return {
           totalFittings: e,
           methodsUsed: s,
-          averageRSquared: o.length > 0 ? o.reduce((n, a) => n + a, 0) / o.length : 0,
-          averageProcessingTime: r.length > 0 ? r.reduce((n, a) => n + a, 0) / r.length : 0
+          averageRSquared: o.length > 0 ? o.reduce((a, r) => a + r, 0) / o.length : 0,
+          averageProcessingTime: n.length > 0 ? n.reduce((a, r) => a + r, 0) / n.length : 0
         };
       }
     },
@@ -465,20 +463,20 @@ function B(f = {}) {
     visualizeFit(t, e = 0) {
       const s = i == null ? void 0 : i.chart;
       if (!s) return;
-      const o = c.get(t);
+      const o = l.get(t);
       if (!o || o.length === 0) return;
-      const r = o[Math.min(e, o.length - 1)], n = s.getSeries(t);
-      if (!n) return;
-      const a = n.getData();
+      const n = o[Math.min(e, o.length - 1)], a = s.getSeries(t);
       if (!a) return;
+      const r = a.getData();
+      if (!r) return;
       this.hideVisualization(t);
-      const u = `${t}_fit_${r.method}`, m = p.predict(t, a.x, e);
+      const d = `${t}_fit_${n.method}`, g = p.predict(t, r.x, e);
       s.addSeries({
-        id: u,
+        id: d,
         type: "line",
         data: {
-          x: new Float32Array(Array.from(a.x)),
-          y: new Float32Array(m)
+          x: new Float32Array(Array.from(r.x)),
+          y: new Float32Array(g)
         },
         style: {
           color: "#ff6b6b",
@@ -487,13 +485,13 @@ function B(f = {}) {
           lineDash: [5, 5]
         }
       });
-      const A = q(r), b = `${t}_equation_${r.method}`;
+      const A = q(n), b = `${t}_equation_${n.method}`;
       s.addAnnotation({
         id: b,
         type: "text",
-        text: `${r.method.toUpperCase()}: ${A}\\nR² = ${r.statistics.rSquared.toFixed(3)}`,
-        x: a.x[0],
-        y: Math.max(...Array.from(m)),
+        text: `${n.method.toUpperCase()}: ${A}\\nR² = ${n.statistics.rSquared.toFixed(3)}`,
+        x: r.x[0],
+        y: Math.max(...Array.from(g)),
         style: {
           color: "#ff6b6b",
           fontSize: 12,
@@ -516,35 +514,35 @@ function B(f = {}) {
         "custom"
       ];
       for (const o of s) {
-        const r = `${t}_fit_${o}`;
-        e.getSeries(r) && e.removeSeries(r);
-        const n = `${t}_equation_${o}`;
-        e.getAnnotation(n) && e.removeAnnotation(n);
+        const n = `${t}_fit_${o}`;
+        e.getSeries(n) && e.removeSeries(n);
+        const a = `${t}_equation_${o}`;
+        e.getAnnotation(a) && e.removeAnnotation(a);
       }
     },
     exportResults(t, e = "json") {
-      const s = c.get(t) || [];
+      const s = l.get(t) || [];
       switch (e) {
         case "json":
           return JSON.stringify(s, null, 2);
         case "csv":
           let o = `Method,R²,RMSE,Parameters,ProcessingTime
 `;
-          for (const n of s)
-            o += `${n.method},${n.statistics.rSquared},${n.statistics.rmse},"${n.parameters.parameters.join(", ")}",${n.processingTime}
+          for (const a of s)
+            o += `${a.method},${a.statistics.rSquared},${a.statistics.rmse},"${a.parameters.parameters.join(", ")}",${a.processingTime}
 `;
           return o;
         case "matlab":
-          let r = `% Regression results for ${t}
+          let n = `% Regression results for ${t}
 `;
-          for (let n = 0; n < s.length; n++) {
-            const a = s[n];
-            r += `result${n + 1}.method = '${a.method}';
-`, r += `result${n + 1}.rSquared = ${a.statistics.rSquared};
-`, r += `result${n + 1}.parameters = [${a.parameters.parameters.join(", ")}];
+          for (let a = 0; a < s.length; a++) {
+            const r = s[a];
+            n += `result${a + 1}.method = '${r.method}';
+`, n += `result${a + 1}.rSquared = ${r.statistics.rSquared};
+`, n += `result${a + 1}.parameters = [${r.parameters.parameters.join(", ")}];
 `;
           }
-          return r;
+          return n;
         default:
           return JSON.stringify(s, null, 2);
       }
@@ -555,15 +553,15 @@ function B(f = {}) {
   }
   function $(t, e) {
     const s = R(t);
-    let o = 0, r = 0;
-    for (let n = 0; n < t.length; n++)
-      o += Math.pow(t[n] - e[n], 2), r += Math.pow(t[n] - s, 2);
-    return 1 - o / r;
+    let o = 0, n = 0;
+    for (let a = 0; a < t.length; a++)
+      o += Math.pow(t[a] - e[a], 2), n += Math.pow(t[a] - s, 2);
+    return 1 - o / n;
   }
-  function S(t, e, s) {
+  function y(t, e, s) {
     return 1 - (1 - t) * (e - 1) / (e - s - 1);
   }
-  function y(t, e) {
+  function x(t, e) {
     let s = 0;
     for (let o = 0; o < t.length; o++)
       s += Math.pow(t[o] - e[o], 2);
@@ -576,10 +574,10 @@ function B(f = {}) {
       case "linear":
         return e.length === 1 ? `y = ${e[0].toFixed(3)}x` : `y = ${e[0].toFixed(3)}x + ${e[1].toFixed(3)}`;
       case "polynomial":
-        let r = "y = ";
-        for (let n = e.length - 1; n >= 0; n--)
-          e[n] !== 0 && (n === 0 ? r += e[n].toFixed(3) : n === 1 ? r += `${e[n].toFixed(3)}x + ` : r += `${e[n].toFixed(3)}x^${n} + `);
-        return r.replace(" + ", "").trim();
+        let n = "y = ";
+        for (let a = e.length - 1; a >= 0; a--)
+          e[a] !== 0 && (a === 0 ? n += e[a].toFixed(3) : a === 1 ? n += `${e[a].toFixed(3)}x + ` : n += `${e[a].toFixed(3)}x^${a} + `);
+        return n.replace(" + ", "").trim();
       case "exponential":
         return `y = ${e[0].toFixed(3)} * exp(${e[1].toFixed(3)}x) + ${((s = e[2]) == null ? void 0 : s.toFixed(3)) || 0}`;
       case "gaussian":
@@ -588,29 +586,29 @@ function B(f = {}) {
         return "y = f(x, parameters)";
     }
   }
-  function x(t, e) {
+  function M(t, e) {
     const { seriesId: s } = e;
-    if (l.has(s)) {
-      const o = g.get(s);
+    if (c.has(s)) {
+      const o = m.get(s);
       o && clearTimeout(o);
-      const r = setTimeout(() => {
-        const n = t.chart;
-        if (n) {
-          const a = n.getSeries(s);
-          if (a) {
-            const u = a.getData();
-            u && u.x.length > 0 && (M(s, {
-              x: u.x,
-              y: u.y
+      const n = setTimeout(() => {
+        const a = t.chart;
+        if (a) {
+          const r = a.getSeries(s);
+          if (r) {
+            const d = r.getData();
+            d && d.x.length > 0 && (S(s, {
+              x: d.x,
+              y: d.y
             }), p.visualizeFit(s));
           }
         }
       }, 500);
-      g.set(s, r);
+      m.set(s, n);
     }
   }
   return {
-    manifest: L,
+    manifest: Y,
     onInit(t) {
       i = t, i.log.info("Regression plugin initialized");
     },
@@ -618,11 +616,11 @@ function B(f = {}) {
     },
     onBeforeRender(t, e) {
     },
-    onDataUpdate: x,
+    onDataUpdate: M,
     onDestroy(t) {
-      for (const e of g.values())
+      for (const e of m.values())
         clearTimeout(e);
-      g.clear(), c.clear(), l.clear();
+      m.clear(), l.clear(), c.clear();
     },
     api: p
   };