velo-plot 2.0.0 → 2.20.0

package/dist/plugins/forecasting/types.d.ts

@@ -1,6 +1,6 @@
 import { SeriesData } from '../../types';
 
-export type ForecastingMethod = 'sma' | 'ema' | 'wma' | 'linear' | 'expSmoothing' | 'holt' | 'holtWinters';
+export type ForecastingMethod = 'sma' | 'ema' | 'wma' | 'linear' | 'expSmoothing' | 'holt' | 'holtWinters' | 'arima';
 export interface ForecastingOptions {
     /** Method to use for forecasting */
     method: ForecastingMethod;
@@ -24,6 +24,12 @@ export interface ForecastingParams {
     period?: number;
     /** Polynomial order for trend fitting (default: 1) */
     polynomialOrder?: number;
+    /** ARIMA autoregressive order (p, default: 1) */
+    p?: number;
+    /** ARIMA differencing order (d, default: 1) */
+    d?: number;
+    /** ARIMA moving-average order (q, default: 0) */
+    q?: number;
 }
 export interface ForecastingResult {
     /** Forecasted points (X values) */
@@ -39,9 +45,12 @@ export interface ForecastingResult {
     /** Metadata and fit statistics */
     metadata: {
         mse?: number;
+        rmse?: number;
         mae?: number;
         r2?: number;
         aic?: number;
+        /** Confidence level used to build the prediction band (e.g. 0.95) */
+        confidence?: number;
     };
 }
 export interface ForecastingVisualizationConfig {
@@ -69,9 +78,10 @@ export interface PluginForecastingConfig {
 }
 export interface ForecastingAPI {
     /**
-     * Forecast future values for a given dataset
+     * Forecast future values for a given dataset, or for a series by id when a
+     * string is passed (e.g. `forecast('s1', { method: 'arima', horizon: 50 })`).
      */
-    forecast(data: SeriesData | number[] | Float32Array, options: ForecastingOptions): ForecastingResult;
+    forecast(data: SeriesData | number[] | Float32Array | string, options: ForecastingOptions): ForecastingResult;
     /**
      * Forecast future values for a series by ID
      */

package/dist/plugins/forecasting.js

@@ -1,236 +1,416 @@
-function p(n, s, r, o, l = {}) {
-  const t = n.length;
-  if (t === 0) throw new Error("Dataset is empty");
-  const c = t > 1 ? (n[t - 1] - n[0]) / (t - 1) : 1, a = n[t - 1];
-  let e;
-  switch (r) {
+function E(l) {
+  return Array.from(l);
+}
+function D(l) {
+  const a = [
+    [0.5, 0.674],
+    [0.68, 0.994],
+    [0.8, 1.282],
+    [0.9, 1.645],
+    [0.95, 1.96],
+    [0.975, 2.241],
+    [0.99, 2.576],
+    [0.995, 2.807]
+  ];
+  let o = a[0], e = 1 / 0;
+  for (const c of a) {
+    const t = Math.abs(c[0] - l);
+    t < e && (e = t, o = c);
+  }
+  return o[1];
+}
+function C(l, a, o, e, c = {}, t = 0.95) {
+  const r = l.length;
+  if (r === 0) throw new Error("Dataset is empty");
+  const s = E(a), n = E(l), i = r > 1 ? (n[r - 1] - n[0]) / (r - 1) : 1, m = n[r - 1];
+  let f;
+  switch (o) {
     case "sma":
-      e = L(s, o, l.windowSize || 10);
+      f = X(s, e, c.windowSize || 10);
       break;
     case "ema":
-      e = W(s, o, l.alpha || 0.3);
+      f = R(s, e, c.alpha ?? 0.3);
       break;
     case "linear":
-      e = F(n, s, o);
+      f = j(n, s, e);
       break;
     case "expSmoothing":
-      e = x(s, o, l.alpha || 0.3);
+      f = B(s, e, c.alpha ?? 0.3);
       break;
     case "holt":
-      e = k(s, o, l.alpha || 0.3, l.beta || 0.1);
+      f = F(s, e, c.alpha ?? 0.3, c.beta ?? 0.1);
       break;
     case "wma":
-      e = E(s, o, l.windowSize || 10);
+      f = W(s, e, c.windowSize || 10);
       break;
     case "holtWinters":
-      e = C(
+      f = Y(
+        s,
+        e,
+        c.period || 12,
+        c.alpha ?? 0.3,
+        c.beta ?? 0.1,
+        c.gamma ?? 0.1
+      );
+      break;
+    case "arima":
+      f = H(
         s,
-        o,
-        l.period || 12,
-        l.alpha || 0.3,
-        l.beta || 0.1,
-        l.gamma || 0.1
+        e,
+        c.p ?? 1,
+        c.d ?? 1,
+        c.q ?? 0
       );
       break;
     default:
-      throw new Error(`Method ${r} not implemented yet`);
+      throw new Error(`Method ${o} not implemented yet`);
   }
-  const u = new Array(o);
-  for (let w = 0; w < o; w++)
-    u[w] = a + (w + 1) * c;
+  const w = new Array(e);
+  for (let S = 0; S < e; S++)
+    w[S] = m + (S + 1) * i;
+  const u = J(s, f.fitted), y = D(t), h = u.rmse, { lower: v, upper: x } = I(
+    f.yValues,
+    h,
+    y,
+    f.accumulates
+  );
   return {
-    xValues: u,
-    yValues: e.yValues,
-    lowerBound: e.lower,
-    upperBound: e.upper,
-    method: r,
-    metadata: Y(s, e.yValues)
-    // Simplified for now
+    xValues: w,
+    yValues: f.yValues,
+    lowerBound: v,
+    upperBound: x,
+    method: o,
+    metadata: { ...u, confidence: t }
   };
 }
-function E(n, s, r) {
-  const o = n.length, l = Math.min(r, o);
-  let t = 0, c = 0;
-  for (let e = 0; e < l; e++) {
-    const u = e + 1;
-    t += n[o - l + e] * u, c += u;
-  }
-  const a = t / c;
-  return { yValues: new Array(s).fill(a) };
-}
-function L(n, s, r) {
-  const o = n.length, l = Math.min(r, o);
-  let t = 0;
-  for (let a = o - l; a < o; a++)
-    t += n[a];
-  const c = t / l;
-  return {
-    yValues: new Array(s).fill(c)
-  };
+function I(l, a, o, e) {
+  const c = new Array(l.length), t = new Array(l.length);
+  for (let r = 0; r < l.length; r++) {
+    const s = e ? Math.sqrt(r + 1) : 1, n = o * a * s;
+    c[r] = l[r] - n, t[r] = l[r] + n;
+  }
+  return { lower: c, upper: t };
 }
-function W(n, s, r) {
-  const o = n.length;
-  let l = n[0];
-  for (let t = 1; t < o; t++)
-    l = r * n[t] + (1 - r) * l;
-  return {
-    yValues: new Array(s).fill(l)
-  };
+function W(l, a, o) {
+  const e = l.length, c = Math.min(o, e), t = (n) => {
+    const i = Math.min(c, n);
+    let m = 0, f = 0;
+    for (let w = 0; w < i; w++) {
+      const u = w + 1;
+      m += l[n - i + w] * u, f += u;
+    }
+    return m / f;
+  }, r = new Array(e).fill(null);
+  for (let n = 1; n < e; n++) r[n] = t(n);
+  const s = t(e);
+  return { yValues: new Array(a).fill(s), fitted: r, accumulates: !1 };
 }
-function F(n, s, r) {
-  const o = n.length;
-  let l = 0, t = 0, c = 0, a = 0;
-  for (let f = 0; f < o; f++)
-    l += n[f], t += s[f], c += n[f] * s[f], a += n[f] * n[f];
-  const e = (o * c - l * t) / (o * a - l * l), u = (t - e * l) / o, w = n[o - 1], h = o > 1 ? (n[o - 1] - n[0]) / (o - 1) : 1, i = new Array(r);
-  for (let f = 0; f < r; f++) {
-    const g = w + (f + 1) * h;
-    i[f] = e * g + u;
-  }
-  return { yValues: i };
-}
-function x(n, s, r) {
-  const o = n.length;
-  let l = n[0];
-  for (let t = 1; t < o; t++)
-    l = r * n[t] + (1 - r) * l;
-  return {
-    yValues: new Array(s).fill(l)
-  };
+function X(l, a, o) {
+  const e = l.length, c = Math.min(o, e), t = (n) => {
+    const i = Math.min(c, n);
+    let m = 0;
+    for (let f = n - i; f < n; f++) m += l[f];
+    return m / i;
+  }, r = new Array(e).fill(null);
+  for (let n = 1; n < e; n++) r[n] = t(n);
+  const s = t(e);
+  return { yValues: new Array(a).fill(s), fitted: r, accumulates: !1 };
+}
+function R(l, a, o) {
+  const e = l.length;
+  let c = l[0];
+  const t = new Array(e).fill(null);
+  for (let r = 1; r < e; r++)
+    t[r] = c, c = o * l[r] + (1 - o) * c;
+  return { yValues: new Array(a).fill(c), fitted: t, accumulates: !1 };
+}
+function j(l, a, o) {
+  const e = l.length;
+  let c = 0, t = 0, r = 0, s = 0;
+  for (let h = 0; h < e; h++)
+    c += l[h], t += a[h], r += l[h] * a[h], s += l[h] * l[h];
+  const n = e * s - c * c, i = n !== 0 ? (e * r - c * t) / n : 0, m = (t - i * c) / e, f = new Array(e);
+  for (let h = 0; h < e; h++) f[h] = i * l[h] + m;
+  const w = l[e - 1], u = e > 1 ? (l[e - 1] - l[0]) / (e - 1) : 1, y = new Array(o);
+  for (let h = 0; h < o; h++) {
+    const v = w + (h + 1) * u;
+    y[h] = i * v + m;
+  }
+  return { yValues: y, fitted: f, accumulates: !0 };
+}
+function B(l, a, o) {
+  const e = l.length;
+  let c = l[0];
+  const t = new Array(e).fill(null);
+  for (let r = 1; r < e; r++)
+    t[r] = c, c = o * l[r] + (1 - o) * c;
+  return { yValues: new Array(a).fill(c), fitted: t, accumulates: !1 };
+}
+function F(l, a, o, e) {
+  const c = l.length;
+  if (c < 2)
+    return { yValues: new Array(a).fill(l[0] || 0), fitted: [], accumulates: !0 };
+  let t = l[0], r = l[1] - l[0];
+  const s = new Array(c).fill(null);
+  for (let i = 1; i < c; i++) {
+    s[i] = t + r;
+    const m = t;
+    t = o * l[i] + (1 - o) * (t + r), r = e * (t - m) + (1 - e) * r;
+  }
+  const n = new Array(a);
+  for (let i = 0; i < a; i++) n[i] = t + (i + 1) * r;
+  return { yValues: n, fitted: s, accumulates: !0 };
+}
+function Y(l, a, o, e, c, t) {
+  const r = l.length;
+  if (r < o * 2)
+    return F(l, a, e, c);
+  const s = new Array(o), n = new Array(Math.floor(r / o));
+  for (let u = 0; u < n.length; u++) {
+    let y = 0;
+    for (let h = 0; h < o; h++) y += l[u * o + h];
+    n[u] = y / o;
+  }
+  for (let u = 0; u < o; u++) {
+    let y = 0;
+    for (let h = 0; h < n.length; h++)
+      y += l[h * o + u] - n[h];
+    s[u] = y / n.length;
+  }
+  let i = n[0], m = (n[n.length - 1] - n[0]) / ((n.length - 1) * o);
+  const f = new Array(r).fill(null);
+  for (let u = 0; u < r; u++) {
+    const y = s[u % o];
+    u > 0 && (f[u] = i + m + y);
+    const h = i, v = l[u];
+    i = e * (v - y) + (1 - e) * (i + m), m = c * (i - h) + (1 - c) * m, s[u % o] = t * (v - i) + (1 - t) * y;
+  }
+  const w = new Array(a);
+  for (let u = 0; u < a; u++) {
+    const y = u + 1;
+    w[u] = i + y * m + s[(r + u) % o];
+  }
+  return { yValues: w, fitted: f, accumulates: !0 };
+}
+function H(l, a, o, e, c) {
+  const t = l.length, r = Math.max(o, c);
+  if (t < e + r + 2 || t < 4)
+    return F(l, a, 0.3, 0.1);
+  const s = [l.slice()];
+  for (let g = 0; g < e; g++)
+    s.push($(s[g]));
+  const n = s[e], i = n.length, m = n.reduce((g, A) => g + A, 0) / i, f = n.map((g) => g - m);
+  let w = new Array(i).fill(0);
+  if (c > 0) {
+    const g = Math.min(Math.max(o + c + 2, 5), Math.floor(i / 2)), { residuals: A } = _(f, g);
+    w = A;
+  }
+  const u = Math.max(o, c), y = [], h = [];
+  for (let g = u; g < i; g++) {
+    const A = [];
+    for (let d = 1; d <= o; d++) A.push(f[g - d]);
+    for (let d = 1; d <= c; d++) A.push(w[g - d]);
+    y.push(A), h.push(f[g]);
+  }
+  let v = [];
+  if (y.length > 0 && y[0].length > 0 && (v = L(y, h)), v.length !== o + c || v.some((g) => !Number.isFinite(g)))
+    return F(l, a, 0.3, 0.1);
+  const x = v.slice(0, o), S = v.slice(o, o + c), k = new Array(t).fill(null), T = new Array(i).fill(0);
+  for (let g = u; g < i; g++) {
+    let A = 0;
+    for (let d = 1; d <= o; d++) A += x[d - 1] * f[g - d];
+    for (let d = 1; d <= c; d++) A += S[d - 1] * T[g - d];
+    T[g] = f[g] - A, k[g + (t - i)] = O(s, e, g, A + m);
+  }
+  const V = f.slice(), b = T.slice(), p = [];
+  for (let g = 0; g < a; g++) {
+    let A = 0;
+    for (let d = 1; d <= o; d++)
+      A += x[d - 1] * V[V.length - d];
+    for (let d = 1; d <= c; d++)
+      A += S[d - 1] * b[b.length - d];
+    V.push(A), b.push(0), p.push(A + m);
+  }
+  return { yValues: N(s, e, p), fitted: k, accumulates: !0 };
+}
+function $(l) {
+  const a = new Array(l.length - 1);
+  for (let o = 1; o < l.length; o++) a[o - 1] = l[o] - l[o - 1];
+  return a;
+}
+function N(l, a, o) {
+  let e = o.slice();
+  for (let c = a; c >= 1; c--) {
+    const t = l[c - 1];
+    let r = t[t.length - 1];
+    const s = new Array(e.length);
+    for (let n = 0; n < e.length; n++)
+      r += e[n], s[n] = r;
+    e = s;
+  }
+  return e;
 }
-function k(n, s, r, o) {
-  const l = n.length;
-  if (l < 2) return { yValues: new Array(s).fill(n[0] || 0) };
-  let t = n[0], c = n[1] - n[0];
-  for (let e = 1; e < l; e++) {
-    const u = t;
-    t = r * n[e] + (1 - r) * (t + c), c = o * (t - u) + (1 - o) * c;
-  }
-  const a = new Array(s);
-  for (let e = 0; e < s; e++)
-    a[e] = t + (e + 1) * c;
-  return { yValues: a };
-}
-function C(n, s, r, o, l, t) {
-  const c = n.length;
-  if (c < r * 2)
-    return k(n, s, o, l);
-  const a = new Array(r), e = new Array(Math.floor(c / r));
-  for (let i = 0; i < e.length; i++) {
-    let f = 0;
-    for (let g = 0; g < r; g++)
-      f += n[i * r + g];
-    e[i] = f / r;
-  }
-  for (let i = 0; i < r; i++) {
-    let f = 0;
-    for (let g = 0; g < e.length; g++)
-      f += n[g * r + i] - e[g];
-    a[i] = f / e.length;
-  }
-  let u = e[0], w = (e[e.length - 1] - e[0]) / ((e.length - 1) * r);
-  for (let i = 0; i < c; i++) {
-    const f = u, g = n[i];
-    u = o * (g - a[i % r]) + (1 - o) * (u + w), w = l * (u - f) + (1 - l) * w, a[i % r] = t * (g - u) + (1 - t) * a[i % r];
-  }
-  const h = new Array(s);
-  for (let i = 0; i < s; i++) {
-    const f = i + 1;
-    h[i] = u + f * w + a[(c + i) % r];
-  }
-  return { yValues: h };
-}
-function Y(n, s) {
+function O(l, a, o, e) {
+  return a === 0 ? e : l[a - 1][o] + e;
+}
+function _(l, a) {
+  const o = l.length, e = [], c = [];
+  for (let s = a; s < o; s++) {
+    const n = [];
+    for (let i = 1; i <= a; i++) n.push(l[s - i]);
+    e.push(n), c.push(l[s]);
+  }
+  const t = e.length > 0 ? L(e, c) : new Array(a).fill(0), r = new Array(o).fill(0);
+  for (let s = a; s < o; s++) {
+    let n = 0;
+    for (let i = 1; i <= a; i++) n += (t[i - 1] || 0) * l[s - i];
+    r[s] = l[s] - n;
+  }
+  return { coeffs: t, residuals: r };
+}
+function L(l, a) {
+  const o = l.length, e = l[0].length, c = Array.from({ length: e }, () => new Array(e).fill(0)), t = new Array(e).fill(0);
+  for (let r = 0; r < o; r++)
+    for (let s = 0; s < e; s++) {
+      t[s] += l[r][s] * a[r];
+      for (let n = 0; n < e; n++)
+        c[s][n] += l[r][s] * l[r][n];
+    }
+  for (let r = 0; r < e; r++) c[r][r] += 1e-8;
+  return G(c, t);
+}
+function G(l, a) {
+  const o = a.length, e = l.map((t, r) => [...t, a[r]]);
+  for (let t = 0; t < o; t++) {
+    let r = t;
+    for (let s = t + 1; s < o; s++)
+      Math.abs(e[s][t]) > Math.abs(e[r][t]) && (r = s);
+    if (Math.abs(e[r][t]) < 1e-12) return [];
+    [e[t], e[r]] = [e[r], e[t]];
+    for (let s = 0; s < o; s++) {
+      if (s === t) continue;
+      const n = e[s][t] / e[t][t];
+      for (let i = t; i <= o; i++) e[s][i] -= n * e[t][i];
+    }
+  }
+  const c = new Array(o);
+  for (let t = 0; t < o; t++) c[t] = e[t][o] / e[t][t];
+  return c;
+}
+function J(l, a) {
+  if (!a || a.length === 0)
+    return { mse: 0, rmse: 0, mae: 0, r2: 0 };
+  let o = 0, e = 0, c = 0;
+  const t = [];
+  for (let w = 0; w < a.length && w < l.length; w++) {
+    const u = a[w];
+    if (u == null || !Number.isFinite(u)) continue;
+    const y = l[w] - u;
+    o += y * y, e += Math.abs(y), t.push(l[w]), c++;
+  }
+  if (c === 0) return { mse: 0, rmse: 0, mae: 0, r2: 0 };
+  const r = o / c, s = Math.sqrt(r), n = e / c, i = t.reduce((w, u) => w + u, 0) / t.length, m = t.reduce((w, u) => w + (u - i) * (u - i), 0), f = m > 0 ? 1 - o / m : 0;
   return {
-    mse: 0,
-    mae: 0,
-    r2: 1
+    mse: P(r),
+    rmse: P(s),
+    mae: P(n),
+    r2: P(f)
   };
 }
-const B = {
+function P(l) {
+  return Math.round(l * 1e6) / 1e6;
+}
+const K = {
   name: "velo-plot-forecasting",
   version: "1.0.0",
   description: "Time series forecasting for velo-plot",
   provides: ["analysis", "forecasting"],
   tags: ["statistics", "forecasting", "analysis"]
 };
-function D(n = {}) {
-  let s = null;
-  const r = /* @__PURE__ */ new Map(), o = {
-    forecast(t, c) {
-      let a, e;
-      if (Array.isArray(t))
-        e = t, a = t.map((u, w) => w);
+function Q(l = {}) {
+  let a = null;
+  const o = /* @__PURE__ */ new Map(), e = {
+    forecast(t, r) {
+      let s, n;
+      if (typeof t == "string") {
+        if (!a) throw new Error("Plugin not initialized");
+        const i = a.data.getAllSeries().find((f) => f.getId() === t);
+        if (!i) throw new Error(`Series not found: ${t}`);
+        const m = i.getData();
+        s = m.x, n = m.y;
+      } else if (Array.isArray(t))
+        n = t, s = t.map((i, m) => m);
       else if (t.x && t.y)
-        a = t.x, e = t.y;
+        s = t.x, n = t.y;
       else
         throw new Error("Invalid data format for forecasting");
-      return p(a, e, c.method, c.horizon, c.params);
+      return C(s, n, r.method, r.horizon, r.params, r.confidence);
     },
-    async forecastSeries(t, c) {
-      if (!s) throw new Error("Plugin not initialized");
-      const a = s.data.getAllSeries().find((u) => u.getId() === t);
-      if (!a) throw new Error(`Series not found: ${t}`);
-      const e = a.getData();
-      return this.forecast(e, c);
+    async forecastSeries(t, r) {
+      if (!a) throw new Error("Plugin not initialized");
+      const s = a.data.getAllSeries().find((i) => i.getId() === t);
+      if (!s) throw new Error(`Series not found: ${t}`);
+      const n = s.getData();
+      return this.forecast(n, r);
     },
-    visualize(t, c = {}) {
-      const a = `forecast-${Math.random().toString(36).substr(2, 9)}`, e = {
+    visualize(t, r = {}) {
+      const s = `forecast-${Math.random().toString(36).substr(2, 9)}`, n = {
         showLine: !0,
         showConfidenceInterval: !0,
-        ...n.defaultVisualization,
-        ...c
+        ...l.defaultVisualization,
+        ...r
       };
-      return r.set(a, { result: t, config: e }), s == null || s.requestRender(), a;
+      return o.set(s, { result: t, config: n }), a == null || a.requestRender(), s;
     },
     clear(t) {
-      t ? r.delete(t) : r.clear(), s == null || s.requestRender();
+      t ? o.delete(t) : o.clear(), a == null || a.requestRender();
     }
   };
-  function l(t) {
-    const { render: c, coords: a } = t, { ctx2d: e } = c;
-    e && r.forEach((u) => {
-      var V, T, b, M, P, X;
-      const { result: w, config: h } = u, { xValues: i, yValues: f, lowerBound: g, upperBound: A } = w;
-      if (e.save(), h.showConfidenceInterval && g && A) {
-        e.beginPath();
-        const v = ((V = h.intervalStyle) == null ? void 0 : V.opacity) ?? 0.15, m = ((T = h.intervalStyle) == null ? void 0 : T.fillColor) || ((b = h.lineStyle) == null ? void 0 : b.color) || "#3b82f6";
-        e.fillStyle = m.startsWith("rgba") ? m : m + Math.floor(v * 255).toString(16).padStart(2, "0");
-        for (let d = 0; d < i.length; d++) {
-          const y = a.dataToPixelX(i[d]), S = a.dataToPixelY(A[d]);
-          d === 0 ? e.moveTo(y, S) : e.lineTo(y, S);
+  function c(t) {
+    const { render: r, coords: s } = t, { ctx2d: n } = r;
+    n && o.forEach((i) => {
+      var v, x, S, k, T, V;
+      const { result: m, config: f } = i, { xValues: w, yValues: u, lowerBound: y, upperBound: h } = m;
+      if (n.save(), f.showConfidenceInterval && y && h) {
+        n.beginPath();
+        const b = ((v = f.intervalStyle) == null ? void 0 : v.opacity) ?? 0.15, p = ((x = f.intervalStyle) == null ? void 0 : x.fillColor) || ((S = f.lineStyle) == null ? void 0 : S.color) || "#3b82f6";
+        n.fillStyle = p.startsWith("rgba") ? p : p + Math.floor(b * 255).toString(16).padStart(2, "0");
+        for (let M = 0; M < w.length; M++) {
+          const g = s.dataToPixelX(w[M]), A = s.dataToPixelY(h[M]);
+          M === 0 ? n.moveTo(g, A) : n.lineTo(g, A);
         }
-        for (let d = i.length - 1; d >= 0; d--) {
-          const y = a.dataToPixelX(i[d]), S = a.dataToPixelY(g[d]);
-          e.lineTo(y, S);
+        for (let M = w.length - 1; M >= 0; M--) {
+          const g = s.dataToPixelX(w[M]), A = s.dataToPixelY(y[M]);
+          n.lineTo(g, A);
         }
-        e.closePath(), e.fill();
+        n.closePath(), n.fill();
       }
-      if (h.showLine) {
-        e.beginPath(), e.strokeStyle = ((M = h.lineStyle) == null ? void 0 : M.color) || "#3b82f6", e.lineWidth = ((P = h.lineStyle) == null ? void 0 : P.width) || 2, (X = h.lineStyle) != null && X.dash ? e.setLineDash(h.lineStyle.dash) : e.setLineDash([5, 5]);
-        for (let v = 0; v < i.length; v++) {
-          const m = a.dataToPixelX(i[v]), d = a.dataToPixelY(f[v]);
-          v === 0 ? e.moveTo(m, d) : e.lineTo(m, d);
+      if (f.showLine) {
+        n.beginPath(), n.strokeStyle = ((k = f.lineStyle) == null ? void 0 : k.color) || "#3b82f6", n.lineWidth = ((T = f.lineStyle) == null ? void 0 : T.width) || 2, (V = f.lineStyle) != null && V.dash ? n.setLineDash(f.lineStyle.dash) : n.setLineDash([5, 5]);
+        for (let b = 0; b < w.length; b++) {
+          const p = s.dataToPixelX(w[b]), M = s.dataToPixelY(u[b]);
+          b === 0 ? n.moveTo(p, M) : n.lineTo(p, M);
         }
-        e.stroke();
+        n.stroke();
       }
-      e.restore();
+      n.restore();
     });
   }
   return {
-    manifest: B,
+    manifest: K,
     onInit(t) {
-      s = t;
+      a = t;
     },
-    onRenderOverlay(t, c) {
-      l(t);
+    onRenderOverlay(t, r) {
+      c(t);
     },
-    api: o
+    api: e
   };
 }
 export {
-  D as PluginForecasting,
-  p as calculateForecast,
-  B as manifestForecasting
+  Q as PluginForecasting,
+  C as calculateForecast,
+  G as gaussianSolve,
+  K as manifestForecasting
 };
 //# sourceMappingURL=forecasting.js.map