@visactor/vchart-extension 2.0.7-alpha.2 → 2.0.7-alpha.4

package/build/index.js

@@ -757,6 +757,750 @@
 	  return [min, max];
 	};
 
+	function invNorm(p) {
+	  if (p <= 0 || p >= 1) return 0;
+	  const c1 = -.00778489400243029,
+	    c2 = -.322396458041136,
+	    c3 = -2.40075827716184,
+	    c4 = -2.54973253934373,
+	    c5 = 4.37466414146497,
+	    c6 = 2.93816398269878,
+	    d1 = .00778469570904146,
+	    d2 = .32246712907004,
+	    d3 = 2.445134137143,
+	    d4 = 3.75440866190742;
+	  let q, r;
+	  return p < .02425 ? (q = Math.sqrt(-2 * Math.log(p)), (((((c1 * q + c2) * q + c3) * q + c4) * q + c5) * q + c6) / ((((d1 * q + d2) * q + d3) * q + d4) * q + 1)) : p <= .97575 ? (q = p - .5, r = q * q, (((((-39.6968302866538 * r + 220.946098424521) * r - 275.928510446969) * r + 138.357751867269) * r - 30.6647980661472) * r + 2.50662827745924) * q / (((((-54.4760987982241 * r + 161.585836858041) * r - 155.698979859887) * r + 66.8013118877197) * r - 13.2806815528857) * r + 1)) : (q = Math.sqrt(-2 * Math.log(1 - p)), -(((((c1 * q + c2) * q + c3) * q + c4) * q + c5) * q + c6) / ((((d1 * q + d2) * q + d3) * q + d4) * q + 1));
+	}
+	function computeLinearCIComponents(data, x, y, predict) {
+	  let min = 1 / 0,
+	    max = -1 / 0,
+	    n = 0,
+	    sumX = 0;
+	  for (let i = 0; i < data.length; i++) {
+	    const d = data[i];
+	    let dx = x(d),
+	      dy = y(d);
+	    !isNil$1(dx) && (dx = +dx) >= dx && !isNil$1(dy) && (dy = +dy) >= dy && (dx < min && (min = dx), dx > max && (max = dx), n++, sumX += dx);
+	  }
+	  if (0 === n) return {
+	    min: min,
+	    max: max,
+	    n: n,
+	    X: 0,
+	    SSE: 0,
+	    Sxx: 0
+	  };
+	  const X = sumX / n;
+	  let SSE = 0,
+	    Sxx = 0;
+	  for (let i = 0; i < data.length; i++) {
+	    const d = data[i];
+	    let dx = x(d),
+	      dy = y(d);
+	    if (!isNil$1(dx) && (dx = +dx) >= dx && !isNil$1(dy) && (dy = +dy) >= dy) {
+	      const r = dy - predict(dx);
+	      SSE += r * r;
+	      const dxc = dx - X;
+	      Sxx += dxc * dxc;
+	    }
+	  }
+	  return {
+	    min: min,
+	    max: max,
+	    n: n,
+	    X: X,
+	    SSE: SSE,
+	    Sxx: Sxx
+	  };
+	}
+	function stdErrorsAt(px, comps) {
+	  const {
+	      n: n,
+	      X: X,
+	      Sxx: Sxx,
+	      SSE: SSE
+	    } = comps,
+	    s2 = n > 2 ? SSE / (n - 2) : 0;
+	  return {
+	    seMean: Sxx > 0 ? Math.sqrt(s2 * (1 / n + (px - X) * (px - X) / Sxx)) : Math.sqrt(s2 / n),
+	    sePred: Math.sqrt(s2 * (1 + 1 / n + (Sxx > 0 ? (px - X) * (px - X) / Sxx : 0)))
+	  };
+	}
+
+	function ordinaryLeastSquares(uX, uY, uXY, uX2) {
+	  const denom = uX2 - uX * uX;
+	  if (Math.abs(denom) < Number.EPSILON) return {
+	    a: uY,
+	    b: 0
+	  };
+	  const b = (uXY - uX * uY) / denom;
+	  return {
+	    a: uY - b * uX,
+	    b: b
+	  };
+	}
+	function visitPoints(data, x, y, callback) {
+	  for (let i = 0; i < data.length; i++) {
+	    const d = data[i];
+	    let xi = x(d),
+	      yi = y(d);
+	    !isNil$1(xi) && (xi = +xi) >= xi && !isNil$1(yi) && (yi = +yi) >= yi && callback(xi, yi, i);
+	  }
+	}
+	function rSquared(data, x, y, uY, predict) {
+	  let ssr = 0,
+	    sst = 0;
+	  for (let i = 0; i < data.length; i++) {
+	    const d = data[i];
+	    let yi = y(d);
+	    if (!isNil$1(yi) && (yi = +yi) >= yi) {
+	      const r = yi - predict(x(d));
+	      ssr += r * r;
+	      const t = yi - uY;
+	      sst += t * t;
+	    }
+	  }
+	  return 0 === sst ? 0 : 1 - ssr / sst;
+	}
+	function regressionLinear(data, x = d => d.x, y = d => d.y) {
+	  let n = 0,
+	    meanX = 0,
+	    meanY = 0,
+	    meanXY = 0,
+	    meanX2 = 0;
+	  visitPoints(data, x, y, (xi, yi) => {
+	    n++, meanX += (xi - meanX) / n, meanY += (yi - meanY) / n, meanXY += (xi * yi - meanXY) / n, meanX2 += (xi * xi - meanX2) / n;
+	  });
+	  const {
+	      a: a,
+	      b: b
+	    } = ordinaryLeastSquares(meanX, meanY, meanXY, meanX2),
+	    predict = xx => a + b * xx,
+	    comps = computeLinearCIComponents(data, x, y, predict);
+	  return {
+	    coef: {
+	      a: a,
+	      b: b
+	    },
+	    predict: predict,
+	    rSquared: rSquared(data, x, y, meanY, predict),
+	    evaluateGrid: function (N) {
+	      const out = [];
+	      if (0 === comps.n || N <= 0) return out;
+	      if (comps.min === comps.max) {
+	        for (let i = 0; i < N; i++) out.push({
+	          x: comps.min,
+	          y: predict(comps.min)
+	        });
+	        return out;
+	      }
+	      const step = (comps.max - comps.min) / (N - 1);
+	      for (let i = 0; i < N; i++) {
+	        const px = i === N - 1 ? comps.max : comps.min + step * i;
+	        out.push({
+	          x: px,
+	          y: predict(px)
+	        });
+	      }
+	      return out;
+	    },
+	    confidenceInterval: function (N = 50, alpha = .05) {
+	      const out = [];
+	      if (0 === comps.n || N <= 0) return out;
+	      const z = invNorm(1 - alpha / 2);
+	      if (comps.min === comps.max) {
+	        const m = predict(comps.min),
+	          errs = stdErrorsAt(comps.min, comps);
+	        for (let i = 0; i < N; i++) out.push({
+	          x: comps.min,
+	          mean: m,
+	          lower: m - z * errs.seMean,
+	          upper: m + z * errs.seMean,
+	          predLower: m - z * errs.sePred,
+	          predUpper: m + z * errs.sePred
+	        });
+	        return out;
+	      }
+	      const step = (comps.max - comps.min) / (N - 1);
+	      for (let i = 0; i < N; i++) {
+	        const px = i === N - 1 ? comps.max : comps.min + step * i,
+	          m = predict(px),
+	          errs = stdErrorsAt(px, comps);
+	        out.push({
+	          x: px,
+	          mean: m,
+	          lower: m - z * errs.seMean,
+	          upper: m + z * errs.seMean,
+	          predLower: m - z * errs.sePred,
+	          predUpper: m + z * errs.sePred
+	        });
+	      }
+	      return out;
+	    }
+	  };
+	}
+
+	function regressionLogistic(data, x = d => d.x, y = d => d.y, options) {
+	  var _a, _b;
+	  const maxIter = null !== (_a = null == options ? void 0 : options.maxIteration) && void 0 !== _a ? _a : 25,
+	    tol = null !== (_b = null == options ? void 0 : options.tol) && void 0 !== _b ? _b : 1e-6,
+	    xs = [],
+	    ys = [];
+	  visitPoints(data, x, y, (dx, dy) => {
+	    xs.push(dx), ys.push(dy ? 1 : 0);
+	  });
+	  const n = xs.length;
+	  if (0 === n) return {
+	    coef: [0, 0],
+	    predict: _x => 0,
+	    evaluateGrid: N => [],
+	    confidenceInterval: (N = 50) => []
+	  };
+	  let intercept = 0,
+	    beta = 0;
+	  for (let iter = 0; iter < maxIter; iter++) {
+	    const p = new Array(n);
+	    let converged = !0;
+	    for (let i = 0; i < n; i++) {
+	      const z = intercept + beta * xs[i],
+	        pi = 1 / (1 + Math.exp(-z));
+	      p[i] = pi;
+	    }
+	    let g0 = 0,
+	      g1 = 0,
+	      h00 = 0,
+	      h01 = 0,
+	      h11 = 0;
+	    for (let i = 0; i < n; i++) {
+	      const wi = p[i] * (1 - p[i]),
+	        diff = ys[i] - p[i];
+	      g0 += diff, g1 += diff * xs[i], h00 += wi, h01 += wi * xs[i], h11 += wi * xs[i] * xs[i];
+	    }
+	    const det = h00 * h11 - h01 * h01;
+	    if (Math.abs(det) < 1e-12) break;
+	    const delta0 = (h11 * g0 - h01 * g1) / det,
+	      delta1 = (-h01 * g0 + h00 * g1) / det;
+	    if (intercept += delta0, beta += delta1, (Math.abs(delta0) > tol || Math.abs(delta1) > tol) && (converged = !1), converged) break;
+	  }
+	  const predict = xx => {
+	    const z = intercept + beta * xx;
+	    return 1 / (1 + Math.exp(-z));
+	  };
+	  return {
+	    coef: [intercept, beta],
+	    predict: predict,
+	    evaluateGrid: function (N) {
+	      const out = [];
+	      if (N <= 0) return out;
+	      let min = 1 / 0,
+	        max = -1 / 0;
+	      if (visitPoints(data, x, y, dx => {
+	        dx < min && (min = dx), dx > max && (max = dx);
+	      }), min === 1 / 0 || max === -1 / 0) return out;
+	      if (min === max) {
+	        const v = predict(min);
+	        for (let i = 0; i < N; i++) out.push({
+	          x: min,
+	          y: v
+	        });
+	        return out;
+	      }
+	      const step = (max - min) / (N - 1);
+	      for (let i = 0; i < N; i++) {
+	        const px = i === N - 1 ? max : min + step * i;
+	        out.push({
+	          x: px,
+	          y: predict(px)
+	        });
+	      }
+	      return out;
+	    },
+	    confidenceInterval: function (N = 50, alpha = .05) {
+	      const out = [];
+	      if (N <= 0) return out;
+	      const comps = computeLinearCIComponents(data, x, y, predict);
+	      if (0 === comps.n) return out;
+	      const z = Math.abs(invNorm(1 - alpha / 2));
+	      if (comps.min === comps.max) {
+	        const v = predict(comps.min),
+	          errs = stdErrorsAt(comps.min, comps);
+	        for (let i = 0; i < N; i++) out.push({
+	          x: comps.min,
+	          mean: v,
+	          lower: v - z * errs.seMean,
+	          upper: v + z * errs.seMean,
+	          predLower: v - z * errs.sePred,
+	          predUpper: v + z * errs.sePred
+	        });
+	        return out;
+	      }
+	      const step = (comps.max - comps.min) / (N - 1);
+	      for (let i = 0; i < N; i++) {
+	        const px = i === N - 1 ? comps.max : comps.min + step * i,
+	          yh = predict(px),
+	          errs = stdErrorsAt(px, comps);
+	        out.push({
+	          x: px,
+	          mean: yh,
+	          lower: yh - z * errs.seMean,
+	          upper: yh + z * errs.seMean,
+	          predLower: yh - z * errs.sePred,
+	          predUpper: yh + z * errs.sePred
+	        });
+	      }
+	      return out;
+	    }
+	  };
+	}
+
+	function tricube(u) {
+	  const uu = Math.abs(u);
+	  if (uu >= 1) return 0;
+	  const t = 1 - uu * uu * uu;
+	  return t * t * t;
+	}
+	function regressionLowess(data, x = d => d.x, y = d => d.y, options = {}) {
+	  const span = options.span || .3,
+	    degree = 0 === options.degree ? 0 : 1,
+	    iterations = null == options.iterations ? 2 : options.iterations,
+	    ptsX = [],
+	    ptsY = [];
+	  visitPoints(data, x, y, (dx, dy) => {
+	    ptsX.push(dx), ptsY.push(dy);
+	  });
+	  const n = ptsX.length;
+	  function predictSingle(x0, robustWeights) {
+	    if (0 === n) return 0;
+	    const dists = [];
+	    for (let i = 0; i < n; i++) dists.push({
+	      idx: i,
+	      dist: Math.abs(ptsX[i] - x0)
+	    });
+	    dists.sort((a, b) => a.dist - b.dist);
+	    const m = Math.max(2, Math.min(n, Math.floor(span * n))),
+	      maxDist = dists[m - 1].dist || 0,
+	      w = new Array(m);
+	    let sumw = 0;
+	    for (let i = 0; i < m; i++) {
+	      const idx = dists[i].idx;
+	      let wi = tricube(0 === maxDist ? 0 : dists[i].dist / maxDist);
+	      robustWeights && null != robustWeights[idx] && (wi *= robustWeights[idx]), w[i] = wi, sumw += wi;
+	    }
+	    if (0 === sumw) return ptsY[dists[0].idx];
+	    if (0 === degree) {
+	      let s = 0;
+	      for (let i = 0; i < m; i++) s += w[i] * ptsY[dists[i].idx];
+	      return s / sumw;
+	    }
+	    let sw = 0,
+	      sx = 0,
+	      sy = 0,
+	      sxx = 0,
+	      sxy = 0;
+	    for (let i = 0; i < m; i++) {
+	      const idx = dists[i].idx,
+	        xi = ptsX[idx],
+	        yi = ptsY[idx],
+	        wi = w[i];
+	      sw += wi, sx += wi * xi, sy += wi * yi, sxx += wi * xi * xi, sxy += wi * xi * yi;
+	    }
+	    const meanX = sx / sw,
+	      meanY = sy / sw,
+	      denom = sxx - sx * meanX,
+	      slope = Math.abs(denom) < 1e-12 ? 0 : (sxy - sx * meanY) / denom;
+	    return meanY - slope * meanX + slope * x0;
+	  }
+	  function predict(x0) {
+	    if (Array.isArray(x0)) {
+	      const out = [];
+	      for (let i = 0; i < x0.length; i++) out.push(predictSingle(x0[i]));
+	      return out;
+	    }
+	    return predictSingle(x0);
+	  }
+	  return {
+	    predict: predict,
+	    evaluate: predict,
+	    evaluateGrid: function (N) {
+	      const out = [];
+	      if (N <= 0) return out;
+	      if (0 === n) return out;
+	      let min = 1 / 0,
+	        max = -1 / 0;
+	      for (let i = 0; i < n; i++) ptsX[i] < min && (min = ptsX[i]), ptsX[i] > max && (max = ptsX[i]);
+	      if (min === max) {
+	        const v = predictSingle(min);
+	        for (let i = 0; i < N; i++) out.push({
+	          x: min,
+	          y: v
+	        });
+	        return out;
+	      }
+	      const step = (max - min) / (N - 1);
+	      let robustWeights;
+	      for (let iter = 0; iter < iterations; iter++) {
+	        const fits = [];
+	        for (let i = 0; i < n; i++) fits.push(predictSingle(ptsX[i], robustWeights));
+	        const res = [];
+	        for (let i = 0; i < n; i++) res.push(Math.abs(ptsY[i] - fits[i]));
+	        const med = res.slice().sort((a, b) => a - b)[Math.floor(n / 2)] || 0;
+	        robustWeights = new Array(n);
+	        for (let i = 0; i < n; i++) {
+	          const u = 0 === med ? 0 : res[i] / (6 * med),
+	            w = Math.abs(u) >= 1 ? 0 : (1 - u * u) * (1 - u * u);
+	          robustWeights[i] = w;
+	        }
+	      }
+	      for (let i = 0; i < N; i++) {
+	        const px = i === N - 1 ? max : min + step * i;
+	        out.push({
+	          x: px,
+	          y: predictSingle(px, robustWeights)
+	        });
+	      }
+	      return out;
+	    },
+	    confidenceInterval: function (N = 50, alpha = .05) {
+	      const out = [];
+	      if (N <= 0) return out;
+	      if (0 === n) return out;
+	      let min = 1 / 0,
+	        max = -1 / 0;
+	      for (let i = 0; i < n; i++) ptsX[i] < min && (min = ptsX[i]), ptsX[i] > max && (max = ptsX[i]);
+	      if (min === 1 / 0 || max === -1 / 0) return out;
+	      const comps = computeLinearCIComponents(data, x, y, xx => predictSingle(xx));
+	      if (0 === comps.n) return out;
+	      const z = Math.abs(invNorm(1 - alpha / 2));
+	      if (comps.min === comps.max) {
+	        const v = predictSingle(comps.min),
+	          errs = stdErrorsAt(comps.min, comps);
+	        for (let i = 0; i < N; i++) out.push({
+	          x: comps.min,
+	          mean: v,
+	          lower: v - z * errs.seMean,
+	          upper: v + z * errs.seMean,
+	          predLower: v - z * errs.sePred,
+	          predUpper: v + z * errs.sePred
+	        });
+	        return out;
+	      }
+	      const step = (max - min) / (N - 1);
+	      for (let i = 0; i < N; i++) {
+	        const px = i === N - 1 ? max : min + step * i,
+	          yh = predictSingle(px),
+	          errs = stdErrorsAt(px, comps);
+	        out.push({
+	          x: px,
+	          mean: yh,
+	          lower: yh - z * errs.seMean,
+	          upper: yh + z * errs.seMean,
+	          predLower: yh - z * errs.sePred,
+	          predUpper: yh + z * errs.sePred
+	        });
+	      }
+	      return out;
+	    }
+	  };
+	}
+
+	function solveLinearSystem(A, b) {
+	  const n = b.length,
+	    M = new Array(n);
+	  for (let i = 0; i < n; i++) M[i] = A[i].slice(), M[i].push(b[i]);
+	  for (let k = 0; k < n; k++) {
+	    let maxRow = k,
+	      maxVal = Math.abs(M[k][k]);
+	    for (let i = k + 1; i < n; i++) {
+	      const v = Math.abs(M[i][k]);
+	      v > maxVal && (maxVal = v, maxRow = i);
+	    }
+	    if (maxRow !== k) {
+	      const tmp = M[k];
+	      M[k] = M[maxRow], M[maxRow] = tmp;
+	    }
+	    if (Math.abs(M[k][k]) < 1e-12) {
+	      return new Array(n).fill(0);
+	    }
+	    for (let j = k + 1; j <= n; j++) M[k][j] = M[k][j] / M[k][k];
+	    M[k][k] = 1;
+	    for (let i = 0; i < n; i++) {
+	      if (i === k) continue;
+	      const factor = M[i][k];
+	      if (0 !== factor) {
+	        for (let j = k + 1; j <= n; j++) M[i][j] -= factor * M[k][j];
+	        M[i][k] = 0;
+	      }
+	    }
+	  }
+	  const x = new Array(n);
+	  for (let i = 0; i < n; i++) x[i] = M[i][n];
+	  return x;
+	}
+	function regressionPolynomial(data, x = d => d.x, y = d => d.y, options = {}) {
+	  var _a;
+	  let degree = null !== (_a = options.degree) && void 0 !== _a ? _a : 0;
+	  degree < 0 && (degree = 0);
+	  const m = degree + 1,
+	    sums = new Array(2 * degree + 1).fill(0);
+	  visitPoints(data, x, y, (dx, dy) => {
+	    let xp = 1;
+	    for (let k = 0; k < sums.length; k++) sums[k] += xp, xp *= dx;
+	  });
+	  const A = new Array(m);
+	  for (let i = 0; i < m; i++) {
+	    A[i] = new Array(m).fill(0);
+	    for (let j = 0; j < m; j++) A[i][j] = sums[i + j];
+	  }
+	  const B = new Array(m).fill(0);
+	  visitPoints(data, x, y, (dx, dy) => {
+	    let xp = 1;
+	    for (let k = 0; k < m; k++) B[k] += dy * xp, xp *= dx;
+	  });
+	  const coef = solveLinearSystem(A, B),
+	    predict = xx => {
+	      let xp = 1,
+	        v = 0;
+	      for (let k = 0; k < coef.length; k++) v += coef[k] * xp, xp *= xx;
+	      return v;
+	    };
+	  return {
+	    degree: degree,
+	    coef: coef,
+	    predict: predict,
+	    rSquared: rSquared(data, x, y, (() => {
+	      let sum = 0,
+	        cnt = 0;
+	      return visitPoints(data, x, y, (_dx, dy) => {
+	        sum += dy, cnt++;
+	      }), 0 === cnt ? 0 : sum / cnt;
+	    })(), predict),
+	    evaluateGrid(N) {
+	      const out = [];
+	      if (N <= 0) return out;
+	      let min = 1 / 0,
+	        max = -1 / 0;
+	      if (visitPoints(data, x, y, dx => {
+	        isNil$1(dx) || (dx < min && (min = dx), dx > max && (max = dx));
+	      }), min === 1 / 0 || max === -1 / 0) return out;
+	      if (min === max) {
+	        const v = predict(min);
+	        for (let i = 0; i < N; i++) out.push({
+	          x: min,
+	          y: v
+	        });
+	        return out;
+	      }
+	      const step = (max - min) / (N - 1);
+	      for (let i = 0; i < N; i++) {
+	        const px = i === N - 1 ? max : min + step * i;
+	        out.push({
+	          x: px,
+	          y: predict(px)
+	        });
+	      }
+	      return out;
+	    },
+	    confidenceInterval(N = 50, alpha = .05) {
+	      const out = [];
+	      if (N <= 0) return out;
+	      const comps = computeLinearCIComponents(data, x, y, predict);
+	      if (0 === comps.n) return out;
+	      const z = Math.abs(invNorm(1 - alpha / 2));
+	      if (comps.min === comps.max) {
+	        const v = predict(comps.min),
+	          errs = stdErrorsAt(comps.min, comps);
+	        for (let i = 0; i < N; i++) out.push({
+	          x: comps.min,
+	          mean: v,
+	          lower: v - z * errs.seMean,
+	          upper: v + z * errs.seMean,
+	          predLower: v - z * errs.sePred,
+	          predUpper: v + z * errs.sePred
+	        });
+	        return out;
+	      }
+	      const step = (comps.max - comps.min) / (N - 1);
+	      for (let i = 0; i < N; i++) {
+	        const px = i === N - 1 ? comps.max : comps.min + step * i,
+	          yh = predict(px),
+	          errs = stdErrorsAt(px, comps);
+	        out.push({
+	          x: px,
+	          mean: yh,
+	          lower: yh - z * errs.seMean,
+	          upper: yh + z * errs.seMean,
+	          predLower: yh - z * errs.sePred,
+	          predUpper: yh + z * errs.sePred
+	        });
+	      }
+	      return out;
+	    }
+	  };
+	}
+
+	const gaussian = u => 1 / Math.sqrt(2 * Math.PI) * Math.exp(-.5 * u * u);
+	function scott(n, std, dim = 1) {
+	  return n <= 0 || 0 === std ? 0 : std * Math.pow(n, -1 / (dim + 4));
+	}
+	function silverman(n, std, dim = 1) {
+	  if (n <= 0 || 0 === std) return 0;
+	  return Math.pow(4 / (dim + 2), 1 / (dim + 4)) * std * Math.pow(n, -1 / (dim + 4));
+	}
+	function std(values) {
+	  const n = values.length;
+	  if (0 === n) return 0;
+	  let mean = 0;
+	  for (let i = 0; i < n; i++) mean += values[i];
+	  mean /= n;
+	  let s = 0;
+	  for (let i = 0; i < n; i++) {
+	    const d = values[i] - mean;
+	    s += d * d;
+	  }
+	  return Math.sqrt(s / n);
+	}
+	function kde(data, options = {}) {
+	  const n = data.length,
+	    kernel = options.kernel || gaussian;
+	  let h = options.bandwidth;
+	  if (!h || h <= 0) {
+	    const sd = std(data) || 0,
+	      method = options.bandwidthMethod || "scott";
+	    h = "silverman" === method ? silverman(n, sd, 1) : scott(n, sd, 1);
+	  }
+	  if (!h || h <= 0) {
+	    return {
+	      bandwidth: 0,
+	      kernel: kernel,
+	      evaluate: x => {
+	        if (Array.isArray(x)) {
+	          const out = [];
+	          for (let i = 0; i < x.length; i++) out.push(0);
+	          return out;
+	        }
+	        return 0;
+	      },
+	      evaluateGrid: N => {
+	        const out = [];
+	        if (N <= 0) return out;
+	        let min = 1 / 0,
+	          max = -1 / 0;
+	        for (let j = 0; j < n; j++) {
+	          const v = data[j];
+	          v < min && (min = v), v > max && (max = v);
+	        }
+	        if (min === 1 / 0 || max === -1 / 0) {
+	          for (let i = 0; i < N; i++) out.push({
+	            x: 0,
+	            y: 0
+	          });
+	          return out;
+	        }
+	        for (let i = 0; i < N; i++) out.push({
+	          x: min,
+	          y: 0
+	        });
+	        return out;
+	      }
+	    };
+	  }
+	  const invNh = 1 / (n * h);
+	  function evalPoint(x) {
+	    let sum = 0;
+	    for (let j = 0; j < n; j++) sum += kernel((x - data[j]) / h);
+	    return sum * invNh;
+	  }
+	  return {
+	    bandwidth: h,
+	    kernel: kernel,
+	    evaluate: function (x) {
+	      if (Array.isArray(x)) {
+	        const out = [];
+	        for (let i = 0; i < x.length; i++) out.push(evalPoint(x[i]));
+	        return out;
+	      }
+	      return evalPoint(x);
+	    },
+	    evaluateGrid(N) {
+	      const out = [];
+	      if (N <= 0) return out;
+	      let min = 1 / 0,
+	        max = -1 / 0;
+	      for (let i = 0; i < n; i++) {
+	        const v = data[i];
+	        v < min && (min = v), v > max && (max = v);
+	      }
+	      if (min === 1 / 0 || max === -1 / 0) return out;
+	      if (min === max) {
+	        for (let i = 0; i < N; i++) out.push({
+	          x: min,
+	          y: evalPoint(min)
+	        });
+	        return out;
+	      }
+	      const step = (max - min) / (N - 1);
+	      for (let i = 0; i < N; i++) {
+	        const x = i === N - 1 ? max : min + step * i;
+	        out.push({
+	          x: x,
+	          y: evalPoint(x)
+	        });
+	      }
+	      return out;
+	    }
+	  };
+	}
+
+	function ecdf(data) {
+	  const n = data.length,
+	    sorted = data.slice().sort((a, b) => a - b);
+	  function evaluateSingle(x) {
+	    if (0 === n) return 0;
+	    let lo = 0,
+	      hi = n;
+	    for (; lo < hi;) {
+	      const mid = lo + hi >>> 1;
+	      sorted[mid] <= x ? lo = mid + 1 : hi = mid;
+	    }
+	    return lo / n;
+	  }
+	  return {
+	    evaluate: function (x) {
+	      if (Array.isArray(x)) {
+	        const out = [];
+	        for (let i = 0; i < x.length; i++) out.push(evaluateSingle(x[i]));
+	        return out;
+	      }
+	      return evaluateSingle(x);
+	    },
+	    evaluateGrid: function (N) {
+	      const out = [];
+	      if (N <= 0) return out;
+	      if (0 === n) return out;
+	      const min = sorted[0],
+	        max = sorted[n - 1];
+	      if (min === max) {
+	        for (let i = 0; i < N; i++) out.push({
+	          x: min,
+	          y: 1
+	        });
+	        return out;
+	      }
+	      const step = (max - min) / (N - 1);
+	      for (let i = 0; i < N; i++) {
+	        const x = i === N - 1 ? max : min + step * i;
+	        out.push({
+	          x: x,
+	          y: evaluateSingle(x)
+	        });
+	      }
+	      return out;
+	    },
+	    n: n
+	  };
+	}
+
 	const epsilon = 1e-12;
 	const pi = Math.PI;
 	const halfPi$1 = pi / 2;
@@ -25971,6 +26715,307 @@
 	    }
 	};
 
+	const REGRESSION_LINE = 'regressionLine';
+	class RegressionLine extends AbstractComponent {
+	    constructor() {
+	        super(...arguments);
+	        this.name = REGRESSION_LINE;
+	    }
+	    render() {
+	        this.removeAllChild();
+	        const { data, line = {}, label, name = 'regression-line', confidenceInterval } = this.attribute;
+	        if (isEmpty(data)) {
+	            return;
+	        }
+	        data.forEach(d => {
+	            const { color } = d;
+	            if (d.area && (confidenceInterval === null || confidenceInterval === void 0 ? void 0 : confidenceInterval.visible) !== false) {
+	                const areaShape = createArea(Object.assign(Object.assign({ points: d.area }, (isValid$1(color) ? { fill: color, fillOpacity: 0.12 } : null)), confidenceInterval === null || confidenceInterval === void 0 ? void 0 : confidenceInterval.style));
+	                areaShape.name = 'scatter-regression-area';
+	                this.add(areaShape);
+	            }
+	            if (d.line && (line === null || line === void 0 ? void 0 : line.visible) !== false) {
+	                const lineShape = createLine(Object.assign(Object.assign({ points: d.line, lineWidth: 1 }, (isValid$1(color) ? { stroke: color } : null)), line === null || line === void 0 ? void 0 : line.style));
+	                lineShape.name = `${name}-curve`;
+	                this.add(lineShape);
+	            }
+	            const lastPoint = last(d.line);
+	            if (label && label.visible !== false && label.text && lastPoint) {
+	                const tag = createText(Object.assign(Object.assign(Object.assign({}, lastPoint), { text: label.text, textAlign: 'end', textBaseline: 'middle' }), label.style));
+	                tag.name = `${name}-label`;
+	                this.add(tag);
+	            }
+	        });
+	    }
+	}
+	const registerRegressionLine = () => {
+	    vchart.Factory.registerGraphicComponent(REGRESSION_LINE, (attrs) => new RegressionLine(attrs));
+	};
+
+	const getRegressionByType$1 = (type, data, x = d => d.x, y = d => d.y, degree) => {
+	    switch (type) {
+	        case 'logisitc':
+	            return regressionLogistic(data, x, y);
+	        case 'lowess':
+	            return regressionLowess(data, x, y);
+	        case 'polynomial':
+	            return regressionPolynomial(data, x, y, { degree });
+	        default:
+	            return regressionLinear(data, x, y);
+	    }
+	};
+	function getScatterRegressionLineConfig(type, config) {
+	    const { color, line, confidenceInterval, label } = config;
+	    return {
+	        type: 'component',
+	        componentType: REGRESSION_LINE,
+	        interactive: false,
+	        style: {
+	            data: (datum, ctx) => {
+	                const vchart$1 = ctx.vchart;
+	                const chart = vchart$1.getChart();
+	                const series = chart.getAllSeries().filter((s) => s.type === vchart.SeriesTypeEnum.scatter);
+	                const regressionData = [];
+	                if (series && series.length) {
+	                    series.forEach(s => {
+	                        var _a, _b;
+	                        const start = s.getRegion().getLayoutStartPoint();
+	                        const rect = s.getRegion().getLayoutRect();
+	                        const yClamper = clamper(start.y, start.y + rect.height);
+	                        const colorAttrOptions = s.getColorAttribute();
+	                        const groups = s.getSeriesKeys();
+	                        const data = s.getViewData().latestData;
+	                        const fieldX = (_a = s.fieldX) === null || _a === void 0 ? void 0 : _a[0];
+	                        const fieldY = (_b = s.fieldY) === null || _b === void 0 ? void 0 : _b[0];
+	                        if (!fieldX || !fieldY || !data || data.length <= 2) {
+	                            return;
+	                        }
+	                        groups.forEach(group => {
+	                            var _a;
+	                            const groupData = data.filter((d) => d[colorAttrOptions === null || colorAttrOptions === void 0 ? void 0 : colorAttrOptions.field] === group);
+	                            if (!groupData.length) {
+	                                return;
+	                            }
+	                            const { evaluateGrid, confidenceInterval } = getRegressionByType$1(type, groupData, (datum) => datum === null || datum === void 0 ? void 0 : datum[fieldX], (datum) => datum === null || datum === void 0 ? void 0 : datum[fieldY], config.polynomialDegree);
+	                            const N = Math.max(3, Math.floor(groupData.length / 4));
+	                            const lineData = evaluateGrid(N);
+	                            const confidenceData = confidenceInterval(N);
+	                            regressionData.push({
+	                                color: color !== null && color !== void 0 ? color : (_a = colorAttrOptions === null || colorAttrOptions === void 0 ? void 0 : colorAttrOptions.scale) === null || _a === void 0 ? void 0 : _a.scale(group),
+	                                line: lineData.map((ld) => {
+	                                    const d = { [fieldX]: ld.x, [fieldY]: ld.y };
+	                                    return {
+	                                        x: s.dataToPositionX(d) + start.x,
+	                                        y: yClamper(type === 'logisitc' ? start.y + rect.height * (1 - ld.y) : s.dataToPositionY(d) + start.y)
+	                                    };
+	                                }),
+	                                area: confidenceData.map((c) => {
+	                                    const d = { [fieldX]: c.x, [fieldY]: c.lower };
+	                                    return {
+	                                        x: s.dataToPositionX(d) + start.x,
+	                                        y: yClamper(s.dataToPositionY(d) + start.y),
+	                                        y1: yClamper(s.dataToPositionY({ [fieldY]: c.upper }) + start.y)
+	                                    };
+	                                })
+	                            });
+	                        });
+	                    });
+	                }
+	                return regressionData;
+	            },
+	            line,
+	            confidenceInterval,
+	            label
+	        }
+	    };
+	}
+	function appendScatterRegressionLineConfig(chartSpec, spec) {
+	    var _a, _b;
+	    if (!spec) {
+	        spec =
+	            (_a = get$1(chartSpec, REGRESSION_LINE)) !== null && _a !== void 0 ? _a : get$1((_b = chartSpec.series) === null || _b === void 0 ? void 0 : _b.find(s => s.type === vchart.SeriesTypeEnum.scatter), REGRESSION_LINE);
+	    }
+	    const specs = array(spec);
+	    specs.forEach((s) => {
+	        if (s.visible !== false) {
+	            if (!chartSpec.customMark) {
+	                chartSpec.customMark = [];
+	            }
+	            const { type } = s, rest = __rest$1(s, ["type"]);
+	            chartSpec.customMark.push(getScatterRegressionLineConfig(type, rest));
+	        }
+	    });
+	}
+
+	function getBarRegressionLineConfig(config) {
+	    const { color, line, confidenceInterval, label } = config;
+	    return {
+	        type: 'component',
+	        componentType: REGRESSION_LINE,
+	        interactive: false,
+	        zIndex: 500,
+	        style: {
+	            data: (datum, ctx) => {
+	                const vchart$1 = ctx.vchart;
+	                const chart = vchart$1.getChart();
+	                const series = chart.getAllSeries().filter((s) => s.type === vchart.SeriesTypeEnum.bar);
+	                const regressionData = [];
+	                if (series && series.length) {
+	                    series.forEach(s => {
+	                        var _a, _b, _c;
+	                        const region = s.getRegion().getLayoutStartPoint();
+	                        const start = s.getRegion().getLayoutStartPoint();
+	                        const rect = s.getRegion().getLayoutRect();
+	                        const yClamper = clamper(start.y, start.y + rect.height);
+	                        const data = s.getViewData().latestData;
+	                        const fieldX = (_a = s.fieldX) === null || _a === void 0 ? void 0 : _a[0];
+	                        const fieldY = (_b = s.fieldY) === null || _b === void 0 ? void 0 : _b[0];
+	                        const isHorizontal = s.direction === "horizontal";
+	                        const groups = s.getRawDataStatisticsByField(fieldX).values;
+	                        if (isHorizontal || !fieldX || !fieldY || !data || data.length <= 2 || groups.length <= 2) {
+	                            return;
+	                        }
+	                        const { evaluateGrid, confidenceInterval } = regressionPolynomial(data, (datum) => groups.indexOf(datum === null || datum === void 0 ? void 0 : datum[fieldX]), (datum) => datum === null || datum === void 0 ? void 0 : datum[fieldY], { degree: config.degree });
+	                        const N = groups.length;
+	                        const lineData = evaluateGrid(N);
+	                        const confidenceData = confidenceInterval(N);
+	                        const halfBandWidth = s.getXAxisHelper().getBandwidth(0) / 2;
+	                        regressionData.push({
+	                            color: color !== null && color !== void 0 ? color : (_c = s.getOption().globalScale.getScale('color')) === null || _c === void 0 ? void 0 : _c.scale(s.getSeriesKeys()[0]),
+	                            line: lineData.map((ld) => {
+	                                const d = { [fieldX]: groups[ld.x], [fieldY]: ld.y };
+	                                return {
+	                                    x: s.dataToPositionX(d) + region.x + halfBandWidth,
+	                                    y: yClamper(s.dataToPositionY(d) + region.y)
+	                                };
+	                            }),
+	                            area: confidenceData.map((c) => {
+	                                const d = { [fieldX]: groups[c.x], [fieldY]: c.lower };
+	                                return {
+	                                    x: s.dataToPositionX(d) + region.x + halfBandWidth,
+	                                    y: yClamper(s.dataToPositionY(d) + region.y),
+	                                    y1: yClamper(s.dataToPositionY({ [fieldY]: c.upper }) + region.y)
+	                                };
+	                            })
+	                        });
+	                    });
+	                }
+	                return regressionData;
+	            },
+	            line,
+	            confidenceInterval,
+	            label
+	        }
+	    };
+	}
+	function appendBarRegressionLineConfig(chartSpec, spec) {
+	    var _a, _b;
+	    if (!spec) {
+	        spec =
+	            (_a = get$1(chartSpec, REGRESSION_LINE)) !== null && _a !== void 0 ? _a : get$1((_b = chartSpec.series) === null || _b === void 0 ? void 0 : _b.find(s => s.type === vchart.SeriesTypeEnum.bar), REGRESSION_LINE);
+	    }
+	    const specs = array(spec);
+	    specs.forEach((s) => {
+	        if (s.visible !== false) {
+	            if (!chartSpec.customMark) {
+	                chartSpec.customMark = [];
+	            }
+	            const rest = __rest$1(s, ["visible"]);
+	            chartSpec.customMark.push(getBarRegressionLineConfig(rest));
+	        }
+	    });
+	}
+
+	const getRegressionByType = (type, data, kdeOptions) => {
+	    switch (type) {
+	        case 'kde':
+	            return kde(data, kdeOptions);
+	        case 'ecdf':
+	            return ecdf(data);
+	    }
+	};
+	function getHistogramRegressionLineConfig(type, config) {
+	    const { line, label, color } = config;
+	    return {
+	        type: 'component',
+	        componentType: REGRESSION_LINE,
+	        interactive: false,
+	        zIndex: 500,
+	        style: {
+	            data: (datum, ctx) => {
+	                const vchart$1 = ctx.vchart;
+	                const chart = vchart$1.getChart();
+	                const series = chart.getAllSeries().filter((s) => s.type === vchart.SeriesTypeEnum.bar);
+	                const regressionData = [];
+	                if (series && series.length) {
+	                    series.forEach(s => {
+	                        var _a, _b, _c, _d, _e, _f, _g, _h;
+	                        const region = s.getRegion().getLayoutStartPoint();
+	                        const rawData = s._rawData;
+	                        const data = rawData === null || rawData === void 0 ? void 0 : rawData.rawData;
+	                        const binTransformOptions = (_b = (_a = rawData.transformsArr) === null || _a === void 0 ? void 0 : _a.find((t) => t.type === 'bin')) === null || _b === void 0 ? void 0 : _b.options;
+	                        const fieldX = (_c = s.fieldX) === null || _c === void 0 ? void 0 : _c[0];
+	                        const scaleY = s.getYAxisHelper().getScale(0);
+	                        const viewData = s.getViewData().latestData;
+	                        if (!data || !data.length || !(binTransformOptions === null || binTransformOptions === void 0 ? void 0 : binTransformOptions.field) || !scaleY || !viewData || !viewData.length) {
+	                            return;
+	                        }
+	                        const simpleData = data.map((entry) => entry[binTransformOptions.field]);
+	                        const res = getRegressionByType(type, simpleData, type === 'kde'
+	                            ? {
+	                                bandwidth: viewData[0][(_e = (_d = binTransformOptions.outputNames) === null || _d === void 0 ? void 0 : _d.x1) !== null && _e !== void 0 ? _e : 'x1'] -
+	                                    viewData[0][(_g = (_f = binTransformOptions.outputNames) === null || _f === void 0 ? void 0 : _f.x0) !== null && _g !== void 0 ? _g : 'x0']
+	                            }
+	                            : null);
+	                        const N = Math.max(3, Math.floor(simpleData.length / 4));
+	                        const lineData = res.evaluateGrid(N);
+	                        const yRange = scaleY.range();
+	                        const y0 = yRange[0];
+	                        const y1 = last(yRange);
+	                        const scaleR = type === 'kde'
+	                            ? (k) => {
+	                                return scaleY.scale(k * data.length * res.bandwidth);
+	                            }
+	                            : (e) => {
+	                                return y0 + (y1 - y0) * e;
+	                            };
+	                        regressionData.push({
+	                            color: color !== null && color !== void 0 ? color : (_h = s.getOption().globalScale.getScale('color')) === null || _h === void 0 ? void 0 : _h.scale(s.getSeriesKeys()[0]),
+	                            line: lineData.map((ld) => {
+	                                const d = { [fieldX]: ld.x };
+	                                return {
+	                                    x: s.dataToPositionX(d) + region.x,
+	                                    y: scaleR(ld.y) + region.y
+	                                };
+	                            })
+	                        });
+	                    });
+	                }
+	                return regressionData;
+	            },
+	            line,
+	            label
+	        }
+	    };
+	}
+	function appendHistogramRegressionLineConfig(chartSpec, spec) {
+	    var _a, _b;
+	    if (!spec) {
+	        spec =
+	            (_a = get$1(chartSpec, REGRESSION_LINE)) !== null && _a !== void 0 ? _a : get$1((_b = chartSpec.series) === null || _b === void 0 ? void 0 : _b.find(s => s.type === vchart.SeriesTypeEnum.bar), REGRESSION_LINE);
+	    }
+	    const specs = array(spec);
+	    specs.forEach((s) => {
+	        if (s.visible !== false) {
+	            if (!chartSpec.customMark) {
+	                chartSpec.customMark = [];
+	            }
+	            const { type } = s, rest = __rest$1(s, ["type"]);
+	            chartSpec.customMark.push(getHistogramRegressionLineConfig(type, rest));
+	        }
+	    });
+	}
+
 	exports.BAR_LINK = BAR_LINK;
 	exports.Bar3dChart = Bar3dChart;
 	exports.Bar3dChartSpecTransformer = Bar3dChartSpecTransformer;
@@ -25999,12 +27044,14 @@
 	exports.Pie3dChartSpecTransformer = Pie3dChartSpecTransformer;
 	exports.Pie3dSeries = Pie3dSeries;
 	exports.Pie3dSeriesSpecTransformer = Pie3dSeriesSpecTransformer;
+	exports.REGRESSION_LINE = REGRESSION_LINE;
 	exports.RangeColumn3dChart = RangeColumn3dChart;
 	exports.RangeColumn3dChartSpecTransformer = RangeColumn3dChartSpecTransformer;
 	exports.RangeColumn3dSeries = RangeColumn3dSeries;
 	exports.RangeColumn3dSeriesSpecTransformer = RangeColumn3dSeriesSpecTransformer;
 	exports.RankingBar = RankingBar;
 	exports.RankingList = RankingList;
+	exports.RegressionLine = RegressionLine;
 	exports.SERIES_BREAK = SERIES_BREAK;
 	exports.SequenceScatterKDE = SequenceScatterKDE;
 	exports.SequenceScatterLink = SequenceScatterLink;
@@ -26015,11 +27062,17 @@
 	exports.WordCloud3dChartSpecTransformer = WordCloud3dChartSpecTransformer;
 	exports.WordCloud3dSeries = WordCloud3dSeries;
 	exports.appendBarLinkConfig = appendBarLinkConfig;
+	exports.appendBarRegressionLineConfig = appendBarRegressionLineConfig;
+	exports.appendHistogramRegressionLineConfig = appendHistogramRegressionLineConfig;
+	exports.appendScatterRegressionLineConfig = appendScatterRegressionLineConfig;
 	exports.appendSeriesBreakConfig = appendSeriesBreakConfig;
 	exports.appendSeriesLabelConfig = appendSeriesLabelConfig;
 	exports.clearSVGSource = clearSVGSource;
 	exports.getBarLinkConfig = getBarLinkConfig;
+	exports.getBarRegressionLineConfig = getBarRegressionLineConfig;
+	exports.getHistogramRegressionLineConfig = getHistogramRegressionLineConfig;
 	exports.getSVGSource = getSVGSource;
+	exports.getScatterRegressionLineConfig = getScatterRegressionLineConfig;
 	exports.getSeriesBreakConfig = getSeriesBreakConfig;
 	exports.getSeriesLabelConfig = getSeriesLabelConfig;
 	exports.register3DPlugin = register3DPlugin;
@@ -26044,6 +27097,7 @@
 	exports.registerRangeColumn3dSeries = registerRangeColumn3dSeries;
 	exports.registerRankingBarChart = registerRankingBarChart;
 	exports.registerRankingList = registerRankingList;
+	exports.registerRegressionLine = registerRegressionLine;
 	exports.registerSVGSource = registerSVGSource;
 	exports.registerSequenceScatterKDE = registerSequenceScatterKDE;
 	exports.registerSequenceScatterLink = registerSequenceScatterLink;