@visactor/vseed 0.1.40 → 0.1.41

package/dist/umd/index.js

@@ -85,11 +85,11 @@
             isRadar: ()=>isRadar,
             zSortLegend: ()=>zSortLegend,
             pivotTableAdvancedPipeline: ()=>pivotTableAdvancedPipeline,
+            zLogisticRegressionLine: ()=>zLogisticRegressionLine,
             zAnnotationHorizontalLine: ()=>zAnnotationHorizontalLine,
             zYLinearAxis: ()=>zYLinearAxis,
             zMarkStyle: ()=>zMarkStyle,
             registerFunnel: ()=>registerFunnel,
-            zHistogramRegressionLine: ()=>zHistogramRegressionLine,
             columnAdvancedPipeline: ()=>columnAdvancedPipeline,
             zLabel: ()=>zLabel,
             registerColumn: ()=>registerColumn,
@@ -138,6 +138,7 @@
             registerAll: ()=>registerAll,
             isVChart: ()=>isVChart,
             registerBar: ()=>registerBar,
+            zPolynomialRegressionLine: ()=>zPolynomialRegressionLine,
             zColor: ()=>zColor,
             registerDonut: ()=>registerDonut,
             BinStartMeasureId: ()=>BinStartMeasureId,
@@ -172,6 +173,7 @@
             areaPercentAdvancedPipeline: ()=>areaPercentAdvancedPipeline,
             zBackgroundColor: ()=>zBackgroundColor,
             zAreaPercentConfig: ()=>zAreaPercentConfig,
+            zLowessRegressionLine: ()=>zLowessRegressionLine,
             registerRadar: ()=>registerRadar,
             zMeasure: ()=>zMeasure,
             zLocale: ()=>zLocale,
@@ -193,6 +195,7 @@
             isPivotTable: ()=>isPivotTable,
             registerPie: ()=>registerPie,
             zDimensionEncoding: ()=>zDimensionEncoding,
+            zEcdfRegressionLine: ()=>zEcdfRegressionLine,
             zBarParallelConfig: ()=>zBarParallelConfig,
             lineAdvancedPipeline: ()=>lineAdvancedPipeline,
             FoldMeasureValue: ()=>FoldMeasureValue,
@@ -216,10 +219,12 @@
             findFirstMeasure: ()=>findFirstMeasure,
             scatterAdvancedPipeline: ()=>scatterAdvancedPipeline,
             zFunnelTransform: ()=>zFunnelTransform,
+            zLinearRegressionLine: ()=>zLinearRegressionLine,
             zRoseConfig: ()=>zRoseConfig,
             zScatterMeasures: ()=>zScatterMeasures,
             zAnnotation: ()=>zAnnotation,
             selector: ()=>selector_selector,
+            zKdeRegressionLine: ()=>zKdeRegressionLine,
             isMeasures: ()=>isMeasures,
             zYBandAxis: ()=>zYBandAxis,
             BinPercentageMeasureId: ()=>BinPercentageMeasureId,
@@ -232,6 +237,7 @@
             registerHistogram: ()=>registerHistogram,
             zRoseParallel: ()=>zRoseParallel,
             MeasureName: ()=>MeasureName,
+            zRegressionLine: ()=>zRegressionLine,
             zNumFormat: ()=>zNumFormat,
             FoldYMeasureValue: ()=>FoldYMeasureValue,
             zPivotTableConfig: ()=>zPivotTableConfig,
@@ -425,7 +431,7 @@
         function C(t, ...o) {
             let n = t, u = o.map((e)=>"lazy" in e ? chunk_3GOCSNFN_y(e) : void 0), p = 0;
             for(; p < o.length;){
-                if (void 0 === u[p] || !B(n)) {
+                if (void 0 === u[p] || !chunk_3GOCSNFN_B(n)) {
                     let i = o[p];
                     n = i(n), p += 1;
                     continue;
@@ -467,7 +473,7 @@
                 items: []
             });
         }
-        function B(t) {
+        function chunk_3GOCSNFN_B(t) {
             return "string" == typeof t || "object" == typeof t && null !== t && Symbol.iterator in t;
         }
         function chunk_LFJW7BOT_y(t, i) {
@@ -2395,7 +2401,7 @@
             if (chunk_BZNENX2T_r(obj)) return C(obj, chunk_3ZJAREUD_i((value)=>replaceNullToUndefined(value)));
             return obj;
         };
-        const lineConfig = (advancedVSeed, context)=>{
+        const line_lineConfig = (advancedVSeed, context)=>{
             const { vseed } = context;
             const { chartType } = vseed;
             const result = {
@@ -2472,7 +2478,7 @@
             ]),
             sortXBandAxis,
             sortLegend_sortLegend,
-            lineConfig,
+            line_lineConfig,
             theme_theme,
             markStyle_markStyle,
             annotation_annotation
@@ -4680,6 +4686,38 @@
             };
             return result;
         };
+        const regressionLine_regressionLine = (advancedVSeed, context)=>{
+            const { vseed } = context;
+            let keys = [];
+            if ('histogram' === vseed.chartType) keys = [
+                'kdeRegressionLine',
+                'ecdfRegressionLine'
+            ];
+            else if ('scatter' === vseed.chartType) keys = [
+                'linearRegressionLine',
+                'lowessRegressionLine',
+                'polynomialRegressionLine',
+                'logisticRegressionLine'
+            ];
+            else if ('column' === vseed.chartType) keys = [
+                'polynomialRegressionLine'
+            ];
+            if (keys.length) {
+                const regressionLineConfig = {};
+                let hasLine = false;
+                keys.forEach((key)=>{
+                    if (vseed[key]) {
+                        hasLine = true;
+                        regressionLineConfig[key] = true === vseed[key] ? {} : vseed[key];
+                    }
+                });
+                return hasLine ? {
+                    ...advancedVSeed,
+                    regressionLine: regressionLineConfig
+                } : advancedVSeed;
+            }
+            return advancedVSeed;
+        };
         const columnAdvancedPipeline = [
             initAdvancedVSeed_initAdvancedVSeed,
             default_defaultMeasures_defaultMeasures,
@@ -4708,7 +4746,8 @@
             columnConfig,
             theme_theme,
             markStyle_markStyle,
-            annotation_annotation
+            annotation_annotation,
+            regressionLine_regressionLine
         ];
         const initColumn = (spec, context)=>{
             const result = {
@@ -5031,6 +5070,454 @@
                 markArea: markArea
             };
         };
+        const isType_isType = (value, type)=>Object.prototype.toString.call(value) === `[object ${type}]`;
+        const isType = isType_isType;
+        const isArray_isArray = (value)=>Array.isArray ? Array.isArray(value) : isType(value, "Array");
+        const common_isArray = isArray_isArray;
+        const isValid = (value)=>null != value;
+        const common_isValid = isValid;
+        function array_array(arr) {
+            return common_isValid(arr) ? common_isArray(arr) ? arr : [
+                arr
+            ] : [];
+        }
+        function clamper(a, b) {
+            let t;
+            return a > b && (t = a, a = b, b = t), (x)=>Math.max(a, Math.min(b, x));
+        }
+        const isNil = (value)=>null == value;
+        const common_isNil = isNil;
+        function invNorm(p) {
+            if (p <= 0 || p >= 1) return 0;
+            const c1 = -0.00778489400243029, c2 = -0.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);
+                !common_isNil(dx) && (dx *= 1) >= dx && !common_isNil(dy) && (dy *= 1) >= 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 (!common_isNil(dx) && (dx *= 1) >= dx && !common_isNil(dy) && (dy *= 1) >= 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);
+                !common_isNil(xi) && (xi *= 1) >= xi && !common_isNil(yi) && (yi *= 1) >= 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 (!common_isNil(yi) && (yi *= 1) >= 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 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) ? _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)=>{
+                        common_isNil(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 defaultRegressionLineColor = (datum, ctx, opt)=>{
+            const parentNode = opt.mark?._product?.parent;
+            if (parentNode?.attribute?.data) return parentNode.attribute.data.color;
+        };
+        const defaultRegressionLineLabelX = (datum, ctx, opt)=>{
+            const parentNode = opt.mark?._product?.parent;
+            if (parentNode?.attribute?.data?.linePoints) {
+                const points = parentNode.attribute.data.linePoints;
+                return points[points.length - 1]?.x;
+            }
+        };
+        const defaultRegressionLineLabelY = (datum, ctx, opt)=>{
+            const parentNode = opt.mark?._product?.parent;
+            if (parentNode?.attribute?.data?.linePoints) {
+                const points = parentNode.attribute.data.linePoints;
+                return points[points.length - 1]?.y;
+            }
+        };
+        const columnPolynomialRegressionLine = (spec, context)=>{
+            const result = {
+                ...spec
+            };
+            const { advancedVSeed } = context;
+            const { chartType, regressionLine } = advancedVSeed;
+            const lineTheme = advancedVSeed.config[chartType]?.regressionLine;
+            if (!regressionLine || !regressionLine.polynomialRegressionLine) return result;
+            const lineList = array_array(regressionLine.polynomialRegressionLine);
+            if (!result.customMark) result.customMark = [];
+            lineList.forEach((line, lineIndex)=>{
+                const theme = lineTheme.linearRegressionLine ?? {};
+                const { color, lineWidth, lineDash, text, textColor, textFontSize, textFontWeight, confidenceIntervalOpacity, confidenceIntervalVisible = theme.confidenceIntervalVisible } = line;
+                const childrenMarks = [];
+                result.customMark.push({
+                    type: 'group',
+                    interactive: false,
+                    zIndex: 500,
+                    name: `polynomialRegressionLine-${lineIndex}`,
+                    style: {
+                        data: (datum, ctx)=>{
+                            const vchart = ctx.vchart;
+                            const chart = vchart.getChart();
+                            const s = chart.getAllSeries()[0];
+                            if (s) {
+                                const rect = s.getRegion().getLayoutRect();
+                                if (0 === rect.width || 0 === rect.height) return null;
+                                const start = s.getRegion().getLayoutStartPoint();
+                                const yClamper = clamper(start.y, start.y + rect.height);
+                                const data = s.getViewData()?.latestData;
+                                const fieldX = s.fieldX?.[0];
+                                const fieldY = s.fieldY?.[0];
+                                const xValues = s.getRawDataStatisticsByField(fieldX).values;
+                                if (!fieldX || !fieldY || !data || data.length <= 2 || xValues.length <= 2) return null;
+                                const { confidenceInterval, evaluateGrid } = regressionPolynomial(xValues.map((xVal, index)=>{
+                                    const filteredData = data.filter((d)=>d[fieldX] === xVal);
+                                    return {
+                                        x: index,
+                                        y: Math.max(...filteredData.map((d)=>d[fieldY]))
+                                    };
+                                }), void 0, void 0, {
+                                    degree: line.degree ?? 2
+                                });
+                                const N = xValues.length;
+                                const xAxisHelper = s.getXAxisHelper();
+                                const halfBandWidth = xAxisHelper ? xAxisHelper.getBandwidth(0) / 2 : 0;
+                                const lineData = evaluateGrid(N);
+                                const linePoints = lineData.map((datum, index)=>{
+                                    const d = {
+                                        [fieldX]: xValues[index],
+                                        [fieldY]: datum.y
+                                    };
+                                    return {
+                                        x: s.dataToPositionX(d) + start.x + halfBandWidth,
+                                        y: yClamper(s.dataToPositionY(d) + start.y)
+                                    };
+                                });
+                                const result = {
+                                    linePoints,
+                                    color: s.getOption().globalScale.getScale('color')?.scale(s.getSeriesKeys()[0])
+                                };
+                                if (confidenceIntervalVisible) {
+                                    const intervalData = confidenceInterval(N);
+                                    result.areaPoints = intervalData.map((datum, index)=>{
+                                        const d = {
+                                            [fieldX]: xValues[index],
+                                            [fieldY]: datum.lower
+                                        };
+                                        return {
+                                            x: s.dataToPositionX(d) + start.x + halfBandWidth,
+                                            y: yClamper(s.dataToPositionY(d) + start.y),
+                                            y1: yClamper(s.dataToPositionY({
+                                                [fieldY]: datum.upper
+                                            }) + start.y)
+                                        };
+                                    });
+                                }
+                                return result;
+                            }
+                            return null;
+                        }
+                    },
+                    children: childrenMarks
+                });
+                if (confidenceIntervalVisible) childrenMarks.push({
+                    type: 'area',
+                    interactive: false,
+                    zIndex: 500,
+                    style: {
+                        lineWidth: lineWidth ?? theme.lineWidth,
+                        lineDash: lineDash ?? theme.lineDash,
+                        fillOpacity: confidenceIntervalOpacity ?? theme.confidenceIntervalOpacity,
+                        fill: color ?? defaultRegressionLineColor,
+                        points: (datum, ctx, opt)=>{
+                            const parentNode = opt.mark?._product?.parent;
+                            if (parentNode?.attribute?.data) return parentNode.attribute.data.areaPoints;
+                            return [];
+                        }
+                    }
+                });
+                childrenMarks.push({
+                    type: 'line',
+                    interactive: false,
+                    zIndex: 500,
+                    style: {
+                        lineWidth: lineWidth ?? theme.lineWidth,
+                        lineDash: lineDash ?? theme.lineDash,
+                        stroke: color ?? defaultRegressionLineColor,
+                        points: (datum, ctx, opt)=>{
+                            const parentNode = opt.mark?._product?.parent;
+                            if (parentNode?.attribute?.data) return parentNode.attribute.data.linePoints;
+                            return [];
+                        }
+                    }
+                });
+                if (!chunk_JK3VNB42_n(text)) childrenMarks.push({
+                    type: 'text',
+                    interactive: false,
+                    zIndex: 500,
+                    style: {
+                        textAlign: 'end',
+                        fill: textColor ?? theme.textColor,
+                        fontSize: textFontSize ?? theme.textFontSize,
+                        fontWeight: textFontWeight ?? theme.textFontWeight,
+                        text: text,
+                        x: (datum, ctx, opt)=>{
+                            const parentNode = opt.mark?._product?.parent;
+                            if (parentNode?.attribute?.data?.linePoints) {
+                                const points = parentNode.attribute.data.linePoints;
+                                return points[points.length - 1]?.x;
+                            }
+                        },
+                        y: (datum, ctx, opt)=>{
+                            const parentNode = opt.mark?._product?.parent;
+                            if (parentNode?.attribute?.data?.linePoints) {
+                                const points = parentNode.attribute.data.linePoints;
+                                return points[points.length - 1]?.y;
+                            }
+                        }
+                    }
+                });
+            });
+            return result;
+        };
         const column = [
             initColumn,
             stackCornerRadius_stackCornerRadius,
@@ -5050,7 +5537,8 @@
             annotationPoint_annotationPoint,
             annotationVerticalLine_annotationVerticalLine,
             annotationHorizontalLine_annotationHorizontalLine,
-            annotationAreaBand
+            annotationAreaBand,
+            columnPolynomialRegressionLine
         ];
         const pivotColumn = [
             initPivot,
@@ -5074,7 +5562,8 @@
                 annotationPoint_annotationPoint,
                 annotationVerticalLine_annotationVerticalLine,
                 annotationHorizontalLine_annotationHorizontalLine,
-                annotationAreaBand
+                annotationAreaBand,
+                columnPolynomialRegressionLine
             ]),
             pivotRowDimensions,
             pivotColumnDimensions,
@@ -5109,8 +5598,8 @@
             };
             return result;
         };
-        const areaConfig = lineConfig;
-        const areaPercentConfig = lineConfig;
+        const areaConfig = line_lineConfig;
+        const areaPercentConfig = line_lineConfig;
         const barConfig = columnConfig;
         const barParallelConfig = columnConfig;
         const barPercentConfig = columnConfig;
@@ -6645,7 +7134,8 @@
             scatterConfig,
             theme_theme,
             markStyle_markStyle,
-            annotation_annotation
+            annotation_annotation,
+            regressionLine_regressionLine
         ];
         const initScatter = (spec, context)=>{
             const result = {
@@ -6846,6 +7336,390 @@
             };
             return result;
         };
+        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 regressionLogistic(data, x = (d)=>d.x, y = (d)=>d.y, options) {
+            var _a, _b;
+            const maxIter = null != (_a = null == options ? void 0 : options.maxIteration) ? _a : 25, tol = null != (_b = null == options ? void 0 : options.tol) ? _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;
+                }
+            };
+        }
+        const generateRegressionLinePipe = (type, regressionFunction, getOptions)=>(spec, context)=>{
+                const result = {
+                    ...spec
+                };
+                const { advancedVSeed } = context;
+                const { chartType, regressionLine } = advancedVSeed;
+                const lineTheme = advancedVSeed.config[chartType]?.regressionLine;
+                if (!regressionLine || !regressionLine[type]) return result;
+                const lineList = array_array(regressionLine[type]);
+                if (!result.customMark) result.customMark = [];
+                lineList.forEach((line, lineIndex)=>{
+                    const theme = lineTheme.linearRegressionLine ?? {};
+                    const { color, lineWidth, lineDash, text, textColor, textFontSize, textFontWeight, confidenceIntervalOpacity, confidenceIntervalVisible = theme.confidenceIntervalVisible } = line;
+                    const childrenMarks = [];
+                    result.customMark.push({
+                        type: 'group',
+                        interactive: false,
+                        zIndex: 500,
+                        name: `${type}-${lineIndex}`,
+                        style: {
+                            data: (datum, ctx)=>{
+                                const vchart = ctx.vchart;
+                                const chart = vchart.getChart();
+                                const s = chart.getAllSeries()[0];
+                                if (s) {
+                                    const rect = s.getRegion().getLayoutRect();
+                                    const segments = [];
+                                    if (0 === rect.width || 0 === rect.height) return segments;
+                                    const start = s.getRegion().getLayoutStartPoint();
+                                    const yClamper = clamper(start.y, start.y + rect.height);
+                                    const colorAttrOptions = s.getColorAttribute();
+                                    const groups = s.getSeriesKeys();
+                                    const data = s.getViewData()?.latestData;
+                                    const fieldX = s.fieldX?.[0];
+                                    const fieldY = s.fieldY?.[0];
+                                    if (!groups.length) groups.push(void 0);
+                                    groups.forEach((group)=>{
+                                        const groupData = data.filter((d)=>d[colorAttrOptions?.field] === group);
+                                        if (!groupData.length) return;
+                                        const { confidenceInterval, evaluateGrid } = regressionFunction(groupData, (datum)=>datum?.[fieldX], (datum)=>datum?.[fieldY], getOptions?.(line));
+                                        const N = Math.max(3, Math.floor(groupData.length / 4));
+                                        const mainColor = color ?? colorAttrOptions?.scale?.scale(group);
+                                        const lineData = evaluateGrid(N);
+                                        const linePoints = lineData.map((ld)=>{
+                                            const d = {
+                                                [fieldX]: ld.x,
+                                                [fieldY]: ld.y
+                                            };
+                                            return {
+                                                x: s.dataToPositionX(d) + start.x,
+                                                y: yClamper(s.dataToPositionY(d) + start.y)
+                                            };
+                                        });
+                                        segments.push({
+                                            color: mainColor,
+                                            linePoints
+                                        });
+                                        if (confidenceIntervalVisible) {
+                                            const intervalData = confidenceInterval(N);
+                                            const areaPoints = intervalData.map((datum)=>{
+                                                const d = {
+                                                    [fieldX]: datum.x,
+                                                    [fieldY]: datum.lower
+                                                };
+                                                return {
+                                                    x: s.dataToPositionX(d) + start.x,
+                                                    y: yClamper(s.dataToPositionY(d) + start.y),
+                                                    y1: yClamper(s.dataToPositionY({
+                                                        [fieldY]: datum.upper
+                                                    }) + start.y)
+                                                };
+                                            });
+                                            segments[segments.length - 1].areaPoints = areaPoints;
+                                        }
+                                    });
+                                    return segments;
+                                }
+                                return [];
+                            }
+                        },
+                        children: childrenMarks
+                    });
+                    if (confidenceIntervalVisible) childrenMarks.push({
+                        type: 'area',
+                        interactive: false,
+                        zIndex: 500,
+                        style: {
+                            lineWidth: lineWidth ?? theme.lineWidth,
+                            lineDash: lineDash ?? theme.lineDash,
+                            fillOpacity: confidenceIntervalOpacity ?? theme.confidenceIntervalOpacity,
+                            fill: 'red',
+                            segments: (datum, ctx, opt)=>{
+                                const parentNode = opt.mark?._product?.parent;
+                                if (parentNode?.attribute?.data?.length) return parentNode.attribute.data.map((d)=>({
+                                        points: d.areaPoints ?? [],
+                                        fill: d.color
+                                    }));
+                                return [];
+                            }
+                        }
+                    });
+                    childrenMarks.push({
+                        type: 'line',
+                        interactive: false,
+                        zIndex: 500,
+                        style: {
+                            lineWidth: lineWidth ?? theme.lineWidth,
+                            lineDash: lineDash ?? theme.lineDash,
+                            stroke: 'red',
+                            segments: (datum, ctx, opt)=>{
+                                const parentNode = opt.mark?._product?.parent;
+                                if (parentNode?.attribute?.data?.length) return parentNode.attribute.data.map((d)=>({
+                                        points: d.linePoints,
+                                        stroke: d.color
+                                    }));
+                                return [];
+                            }
+                        }
+                    });
+                    if (!chunk_JK3VNB42_n(text)) childrenMarks.push({
+                        type: 'text',
+                        interactive: false,
+                        zIndex: 500,
+                        style: {
+                            textAlign: 'end',
+                            fill: textColor ?? theme.textColor,
+                            fontSize: textFontSize ?? theme.textFontSize,
+                            fontWeight: textFontWeight ?? theme.textFontWeight,
+                            text: text,
+                            x: (datum, ctx, opt)=>{
+                                const parentNode = opt.mark?._product?.parent;
+                                if (parentNode?.attribute?.data?.length) {
+                                    const point = parentNode.attribute.data[parentNode.attribute.data.length - 1].linePoints;
+                                    return point[point.length - 1]?.x;
+                                }
+                            },
+                            y: (datum, ctx, opt)=>{
+                                const parentNode = opt.mark?._product?.parent;
+                                if (parentNode?.attribute?.data?.length) {
+                                    const point = parentNode.attribute.data[parentNode.attribute.data.length - 1].linePoints;
+                                    return point[point.length - 1]?.y;
+                                }
+                            }
+                        }
+                    });
+                });
+                return result;
+            };
+        const linearRegressionLine = generateRegressionLinePipe('linearRegressionLine', regressionLinear);
+        const lowessRegressionLine = generateRegressionLinePipe('lowessRegressionLine', regressionLowess);
+        const polynomialRegressionLine = generateRegressionLinePipe('polynomialRegressionLine', regressionPolynomial, (lineConfig)=>({
+                degree: lineConfig.degree ?? 2
+            }));
+        const logisticRegressionLine = generateRegressionLinePipe('logisticRegressionLine', regressionLogistic);
         const scatter = [
             initScatter,
             colorAdapter(color_color, linearColor),
@@ -6865,7 +7739,11 @@
             annotationPoint_annotationPoint,
             annotationVerticalLine_annotationVerticalLine,
             annotationHorizontalLine_annotationHorizontalLine,
-            annotationArea_annotationArea
+            annotationArea_annotationArea,
+            linearRegressionLine,
+            lowessRegressionLine,
+            polynomialRegressionLine,
+            logisticRegressionLine
         ];
         const pivotScatter = [
             initPivot,
@@ -6890,7 +7768,9 @@
                 annotationPoint_annotationPoint,
                 annotationVerticalLine_annotationVerticalLine,
                 annotationHorizontalLine_annotationHorizontalLine,
-                annotationArea_annotationArea
+                annotationArea_annotationArea,
+                linearRegressionLine,
+                lowessRegressionLine
             ]),
             pivotRowDimensions,
             pivotColumnDimensions,
@@ -9432,12 +10312,6 @@
                 ...tooltip
             ]);
         };
-        const isType_isType = (value, type)=>Object.prototype.toString.call(value) === `[object ${type}]`;
-        const isType = isType_isType;
-        const isArray = (value)=>Array.isArray ? Array.isArray(value) : isType(value, "Array");
-        const common_isArray = isArray;
-        const isNil = (value)=>null == value;
-        const common_isNil = isNil;
         const clamp_clamp = function(input, min, max) {
             return input < min ? min : input > max ? max : input;
         };
@@ -9669,7 +10543,6 @@
                 datasets.push(newDatasets);
                 datasetReshapeInfo.push(reshapeInfo);
             });
-            console.log(datasets);
             return {
                 ...result,
                 dataset: datasets,
@@ -10259,11 +11132,6 @@
                 datasetReshapeInfo: datasetReshapeInfo
             };
         };
-        const regressionLine = (advancedVSeed, context)=>{
-            const { vseed } = context;
-            if ('histogramRegressionLine' in vseed && 'histogram' === vseed.chartType) advancedVSeed.histogramRegressionLine = vseed.histogramRegressionLine;
-            return advancedVSeed;
-        };
         const histogramAdvancedPipeline = [
             initAdvancedVSeed_initAdvancedVSeed,
             default_defaultMeasures_defaultMeasures,
@@ -10292,7 +11160,7 @@
             theme_theme,
             markStyle_markStyle,
             annotation_annotation,
-            regressionLine
+            regressionLine_regressionLine
         ];
         const initHistogram = (spec)=>{
             const result = {
@@ -10495,6 +11363,97 @@
                 }
             };
         }
+        const kdeRegressionLine = (spec, context)=>{
+            const result = {
+                ...spec
+            };
+            const { advancedVSeed, vseed } = context;
+            const { chartType, encoding = {}, dimensions, regressionLine } = advancedVSeed;
+            const { dataset } = vseed;
+            const lineTheme = advancedVSeed.config[chartType]?.regressionLine;
+            if (!regressionLine || !regressionLine.kdeRegressionLine) return result;
+            const rowColumnFields = T(dimensions.filter((dim)=>'row' === dim.encoding || 'column' === dim.encoding), (item)=>item.id);
+            const lineList = array_array(regressionLine.kdeRegressionLine);
+            if (!result.customMark) result.customMark = [];
+            lineList.forEach((line, lineIndex)=>{
+                const theme = lineTheme.kdeRegressionLine ?? {};
+                const { color, lineWidth, lineDash, text, textColor, textFontSize, textFontWeight } = line;
+                const childrenMarks = [];
+                result.customMark.push({
+                    type: 'group',
+                    interactive: false,
+                    zIndex: 500,
+                    name: `kdeRegressionLine-${lineIndex}`,
+                    style: {
+                        data: (datum, ctx)=>{
+                            const vchart = ctx.vchart;
+                            const chart = vchart.getChart();
+                            const series = chart.getAllSeries().filter((s)=>'bar' === s.type);
+                            if (series && series.length) {
+                                const s = series[0];
+                                const region = s.getRegion().getLayoutStartPoint();
+                                const fieldX = s.fieldX?.[0];
+                                const scaleY = s.getYAxisHelper().getScale?.(0);
+                                const viewData = s.getViewData()?.latestData;
+                                if (!dataset || !dataset.length || !viewData || !viewData.length || !scaleY) return null;
+                                const simpleData = dataset.filter((entry)=>rowColumnFields.length ? rowColumnFields.every((dim)=>entry[dim.id] === viewData[0][dim.id]) : true).map((d)=>d[encoding.value?.[0]]);
+                                const res = kde_kde(simpleData, {
+                                    bandwidth: Math.abs(viewData[0][BinEndMeasureId] - viewData[0][BinStartMeasureId])
+                                });
+                                const N = Math.max(3, Math.floor(simpleData.length / 4));
+                                const lineData = res.evaluateGrid(N);
+                                const scaleR = (k)=>scaleY.scale(k * simpleData.length * res.bandwidth);
+                                const linePoints = lineData.map((ld)=>{
+                                    const d = {
+                                        [fieldX]: ld.x
+                                    };
+                                    return {
+                                        x: s.dataToPositionX(d) + region.x,
+                                        y: scaleR(ld.y) + region.y
+                                    };
+                                });
+                                return {
+                                    linePoints,
+                                    color: color ?? s.getOption().globalScale.getScale('color')?.scale(s.getSeriesKeys()[0])
+                                };
+                            }
+                            return null;
+                        }
+                    },
+                    children: childrenMarks
+                });
+                childrenMarks.push({
+                    type: 'line',
+                    interactive: false,
+                    zIndex: 500,
+                    style: {
+                        lineWidth: lineWidth ?? theme.lineWidth,
+                        lineDash: lineDash ?? theme.lineDash,
+                        stroke: color ?? defaultRegressionLineColor,
+                        points: (datum, ctx, opt)=>{
+                            const parentNode = opt.mark?._product?.parent;
+                            if (parentNode?.attribute?.data) return parentNode.attribute.data.linePoints;
+                            return [];
+                        }
+                    }
+                });
+                if (!chunk_JK3VNB42_n(text)) childrenMarks.push({
+                    type: 'text',
+                    interactive: false,
+                    zIndex: 500,
+                    style: {
+                        textAlign: 'end',
+                        fill: textColor ?? theme.textColor,
+                        fontSize: textFontSize ?? theme.textFontSize,
+                        fontWeight: textFontWeight ?? theme.textFontWeight,
+                        text: text,
+                        x: defaultRegressionLineLabelX,
+                        y: defaultRegressionLineLabelY
+                    }
+                });
+            });
+            return result;
+        };
         function ecdf(data) {
             const n = data.length, sorted = data.slice().sort((a, b)=>a - b);
             function evaluateSingle(x) {
@@ -10540,44 +11499,29 @@
                 n: n
             };
         }
-        const getRegressionByType = (type, data, kdeOptions)=>{
-            switch(type){
-                case 'kde':
-                    return kde_kde(data, kdeOptions);
-                case 'ecdf':
-                    return ecdf(data);
-            }
-        };
-        const histogramRegressionLine_histogramRegressionLine = (spec, context)=>{
+        const ecdfRegressionLine = (spec, context)=>{
             const result = {
                 ...spec
             };
             const { advancedVSeed, vseed } = context;
-            const { chartType, encoding = {}, dimensions, histogramRegressionLine } = advancedVSeed;
+            const { chartType, encoding = {}, dimensions, regressionLine } = advancedVSeed;
             const { dataset } = vseed;
-            const theme = advancedVSeed.config[chartType]?.histogramRegressionLine;
-            if (!histogramRegressionLine) return result;
+            const lineTheme = advancedVSeed.config[chartType]?.regressionLine;
+            if (!regressionLine || !regressionLine.ecdfRegressionLine) return result;
             const rowColumnFields = T(dimensions.filter((dim)=>'row' === dim.encoding || 'column' === dim.encoding), (item)=>item.id);
-            const lineList = Array.isArray(histogramRegressionLine) ? histogramRegressionLine : [
-                histogramRegressionLine
-            ];
+            const lineList = array_array(regressionLine.ecdfRegressionLine);
             if (!result.customMark) result.customMark = [];
-            lineList.forEach((line)=>{
-                const { color, type, lineWidth, lineDash, text, textColor, textFontSize, textFontWeight } = line;
+            lineList.forEach((line, lineIndex)=>{
+                const theme = lineTheme?.ecdfRegressionLine ?? {};
+                const { color, lineWidth, lineDash, text, textColor, textFontSize, textFontWeight } = line;
+                const childrenMarks = [];
                 result.customMark.push({
-                    type: 'line',
+                    type: 'group',
                     interactive: false,
                     zIndex: 500,
+                    name: `ecdfRegressionLine-${lineIndex}`,
                     style: {
-                        lineWidth: lineWidth ?? theme?.lineWidth,
-                        lineDash: lineDash ?? theme?.lineDash,
-                        stroke: color ?? ((datum, ctx)=>{
-                            const vchart = ctx.vchart;
-                            const chart = vchart.getChart();
-                            const series = chart.getAllSeries().filter((s)=>'bar' === s.type);
-                            return series.length ? series[0].getOption().globalScale.getScale('color')?.scale(series[0].getSeriesKeys()[0]) : void 0;
-                        }),
-                        points: (datum, ctx)=>{
+                        data: (datum, ctx)=>{
                             const vchart = ctx.vchart;
                             const chart = vchart.getChart();
                             const series = chart.getAllSeries().filter((s)=>'bar' === s.type);
@@ -10587,18 +11531,16 @@
                                 const fieldX = s.fieldX?.[0];
                                 const scaleY = s.getYAxisHelper().getScale?.(0);
                                 const viewData = s.getViewData()?.latestData;
-                                if (!dataset || !dataset.length || !viewData || !viewData.length || !scaleY) return;
+                                if (!dataset || !dataset.length || !viewData || !viewData.length || !scaleY) return null;
                                 const simpleData = dataset.filter((entry)=>rowColumnFields.length ? rowColumnFields.every((dim)=>entry[dim.id] === viewData[0][dim.id]) : true).map((d)=>d[encoding.value?.[0]]);
-                                const res = getRegressionByType(type, simpleData, 'kde' === type ? {
-                                    bandwidth: Math.abs(viewData[0][BinEndMeasureId] - viewData[0][BinStartMeasureId])
-                                } : void 0);
+                                const res = ecdf(simpleData);
                                 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 = yRange[yRange.length - 1];
-                                const scaleR = 'kde' === type ? (k)=>scaleY.scale(k * simpleData.length * res.bandwidth) : (e)=>y0 + (y1 - y0) * e;
-                                return lineData.map((ld)=>{
+                                const scaleR = (e)=>y0 + (y1 - y0) * e;
+                                const linePoints = lineData.map((ld)=>{
                                     const d = {
                                         [fieldX]: ld.x
                                     };
@@ -10607,54 +11549,43 @@
                                         y: scaleR(ld.y) + region.y
                                     };
                                 });
+                                return {
+                                    linePoints,
+                                    color: color ?? s.getOption().globalScale.getScale('color')?.scale(s.getSeriesKeys()[0])
+                                };
                             }
+                            return null;
+                        }
+                    },
+                    children: childrenMarks
+                });
+                childrenMarks.push({
+                    type: 'line',
+                    interactive: false,
+                    zIndex: 500,
+                    style: {
+                        lineWidth: lineWidth ?? theme.lineWidth,
+                        lineDash: lineDash ?? theme.lineDash,
+                        stroke: color ?? defaultRegressionLineColor,
+                        points: (datum, ctx, opt)=>{
+                            const parentNode = opt.mark?._product?.parent;
+                            if (parentNode?.attribute?.data) return parentNode.attribute.data.linePoints;
                             return [];
                         }
                     }
                 });
-                if (!chunk_JK3VNB42_n(text)) result.customMark.push({
+                if (!chunk_JK3VNB42_n(text)) childrenMarks.push({
                     type: 'text',
                     interactive: false,
                     zIndex: 500,
                     style: {
                         textAlign: 'end',
-                        fill: textColor ?? theme?.textColor,
-                        fontSize: textFontSize ?? theme?.textFontSize,
-                        fontWeight: textFontWeight ?? theme?.textFontWeight,
+                        fill: textColor ?? theme.textColor,
+                        fontSize: textFontSize ?? theme.textFontSize,
+                        fontWeight: textFontWeight ?? theme.textFontWeight,
                         text: text,
-                        x: (datum, ctx)=>{
-                            const vchart = ctx.vchart;
-                            const chart = vchart.getChart();
-                            const series = chart.getAllSeries().filter((s)=>'bar' === s.type);
-                            if (series && series.length) {
-                                const s = series[0];
-                                const startPoint = s.getRegion().getLayoutStartPoint();
-                                const fieldX = s.fieldX[0];
-                                const fieldX2 = s.fieldX2;
-                                const scaleY = s.getYAxisHelper().getScale?.(0);
-                                const viewData = s.getViewData()?.latestData;
-                                if (!dataset || !dataset.length || !viewData || !viewData.length || !scaleY) return;
-                                const maxX = Math.max.apply(null, viewData.map((d)=>Math.max(d[fieldX], d[fieldX2])));
-                                return startPoint.x + s.dataToPositionX({
-                                    [fieldX]: maxX
-                                });
-                            }
-                        },
-                        y: (datum, ctx)=>{
-                            const vchart = ctx.vchart;
-                            const chart = vchart.getChart();
-                            const series = chart.getAllSeries().filter((s)=>'bar' === s.type);
-                            if (series && series.length) {
-                                const s = series[0];
-                                const startPoint = s.getRegion().getLayoutStartPoint();
-                                const fieldY = s.fieldY[0];
-                                const viewData = s.getViewData()?.latestData;
-                                if (!viewData || !viewData.length) return;
-                                return 'ecdf' === type ? startPoint.y + 12 : startPoint.y + s.dataToPositionY({
-                                    [fieldY]: viewData[viewData.length - 1]?.[fieldY]
-                                });
-                            }
-                        }
+                        x: defaultRegressionLineLabelX,
+                        y: defaultRegressionLineLabelY
                     }
                 });
             });
@@ -10677,7 +11608,8 @@
             annotationVerticalLine_annotationVerticalLine,
             annotationHorizontalLine_annotationHorizontalLine,
             annotationAreaBand,
-            histogramRegressionLine_histogramRegressionLine
+            kdeRegressionLine,
+            ecdfRegressionLine
         ];
         const pivotHistogram = [
             initPivot,
@@ -10699,7 +11631,8 @@
                 annotationVerticalLine_annotationVerticalLine,
                 annotationHorizontalLine_annotationHorizontalLine,
                 annotationAreaBand,
-                histogramRegressionLine_histogramRegressionLine
+                kdeRegressionLine,
+                ecdfRegressionLine
             ]),
             pivotRowDimensions,
             pivotColumnDimensions,
@@ -11130,18 +12063,70 @@
         const getDarkHeatmapCellTheme = ()=>({
                 stroke: '#404349'
             });
-        const getDefaultHistogramRegressionLine = ()=>({
+        const getDefaultRegressionLine = ()=>({
                 lineWidth: 2,
                 textFontSize: 12,
                 textFontWeight: 400
             });
-        const getLightHistogramRegressionLine = ()=>({
-                ...getDefaultHistogramRegressionLine(),
-                textColor: '#364159'
+        const getLightRegressionLine = ()=>({
+                kdeRegressionLine: {
+                    ...getDefaultRegressionLine(),
+                    textColor: '#364159'
+                },
+                ecdfRegressionLine: {
+                    ...getDefaultRegressionLine(),
+                    textColor: '#364159'
+                },
+                linearRegressionLine: {
+                    ...getDefaultRegressionLine(),
+                    textColor: '#364159',
+                    confidenceIntervalOpacity: 0.2
+                },
+                lowessRegressionLine: {
+                    ...getDefaultRegressionLine(),
+                    textColor: '#364159',
+                    confidenceIntervalOpacity: 0.2
+                },
+                polynomialRegressionLine: {
+                    ...getDefaultRegressionLine(),
+                    textColor: '#364159',
+                    confidenceIntervalOpacity: 0.2
+                },
+                logisticRegressionLine: {
+                    ...getDefaultRegressionLine(),
+                    textColor: '#364159',
+                    confidenceIntervalOpacity: 0.2
+                }
             });
-        const getDarkHistogramRegressionLine = ()=>({
-                ...getDefaultHistogramRegressionLine(),
-                textColor: '#ffffff'
+        const getDarkRegressionLine = ()=>({
+                kdeRegressionLine: {
+                    ...getDefaultRegressionLine(),
+                    textColor: '#FFFFFF'
+                },
+                ecdfRegressionLine: {
+                    ...getDefaultRegressionLine(),
+                    textColor: '#FFFFFF'
+                },
+                linearRegressionLine: {
+                    ...getDefaultRegressionLine(),
+                    textColor: '#FFFFFF',
+                    confidenceIntervalOpacity: 0.2
+                },
+                lowessRegressionLine: {
+                    ...getDefaultRegressionLine(),
+                    textColor: '#FFFFFF',
+                    confidenceIntervalOpacity: 0.2
+                },
+                polynomialRegressionLine: {
+                    ...getDefaultRegressionLine(),
+                    textColor: '#FFFFFF',
+                    confidenceIntervalOpacity: 0.2
+                },
+                logisticRegressionLine: {
+                    ...getDefaultRegressionLine(),
+                    textColor: '#FFFFFF',
+                    confidenceIntervalOpacity: 0.2
+                }
             });
         const lightTheme = ()=>{
             const linearAxis = getLightLinearAxis();
@@ -11193,7 +12178,8 @@
                             0
                         ],
                         pivotGrid: getLightPivotChartGridConfig(),
-                        annotation: getLightAnnotation()
+                        annotation: getLightAnnotation(),
+                        regressionLine: getLightRegressionLine()
                     },
                     columnParallel: {
                         ...baseConfig,
@@ -11314,7 +12300,8 @@
                             showValuePercent: false
                         },
                         pivotGrid: getLightPivotChartGridConfig(),
-                        annotation: getLightAnnotation()
+                        annotation: getLightAnnotation(),
+                        regressionLine: getLightRegressionLine()
                     },
                     dualAxis: {
                         ...baseConfig,
@@ -11397,7 +12384,7 @@
                         crosshairRect,
                         pivotGrid: getLightPivotChartGridConfig(),
                         annotation: getLightAnnotation(),
-                        histogramRegressionLine: getLightHistogramRegressionLine()
+                        regressionLine: getLightRegressionLine()
                     },
                     boxPlot: {
                         ...baseConfig,
@@ -11460,7 +12447,8 @@
                             0
                         ],
                         pivotGrid: getDarkPivotChartGridConfig(),
-                        annotation: getDarkAnnotation()
+                        annotation: getDarkAnnotation(),
+                        regressionLine: getDarkRegressionLine()
                     },
                     columnParallel: {
                         ...baseConfig,
@@ -11575,7 +12563,8 @@
                             showValuePercent: false
                         },
                         pivotGrid: getDarkPivotChartGridConfig(),
-                        annotation: getDarkAnnotation()
+                        annotation: getDarkAnnotation(),
+                        regressionLine: getDarkRegressionLine()
                     },
                     dualAxis: {
                         ...baseConfig,
@@ -11658,7 +12647,7 @@
                         crosshairRect: crosshairRect,
                         pivotGrid: getDarkPivotChartGridConfig(),
                         annotation: getDarkAnnotation(),
-                        histogramRegressionLine: getDarkHistogramRegressionLine()
+                        regressionLine: getDarkRegressionLine()
                     },
                     boxPlot: {
                         ...baseConfig,
@@ -15753,7 +16742,35 @@
         ]);
         const zBarMaxWidth = schemas_number().or(schemas_string());
         const zBarGapInGroup = schemas_number().or(schemas_string());
-        const zColumnConfig = schemas_object({
+        const zEcdfRegressionLine = schemas_object({
+            color: schemas_string().nullish(),
+            lineWidth: schemas_number().nullish(),
+            lineDash: schemas_array(schemas_number()).nullish(),
+            text: schemas_string().nullish(),
+            textColor: schemas_string().nullish(),
+            textFontSize: schemas_number().nullish(),
+            textFontWeight: schemas_number().nullish()
+        });
+        const zKdeRegressionLine = zEcdfRegressionLine.extend({});
+        const zLinearRegressionLine = zEcdfRegressionLine.extend({
+            confidenceIntervalVisible: schemas_boolean().nullish(),
+            confidenceIntervalColor: schemas_string().nullish(),
+            confidenceIntervalOpacity: schemas_number().nullish()
+        });
+        const zLogisticRegressionLine = zLinearRegressionLine.extend({});
+        const zLowessRegressionLine = zLinearRegressionLine.extend({});
+        const zPolynomialRegressionLine = zLinearRegressionLine.extend({
+            degree: schemas_number().nullish()
+        });
+        const zRegressionLine = schemas_object({
+            ecdfRegressionLine: zEcdfRegressionLine.or(schemas_array(zEcdfRegressionLine)).nullish(),
+            kdeRegressionLine: zKdeRegressionLine.or(schemas_array(zKdeRegressionLine)).nullish(),
+            linearRegressionLine: zLinearRegressionLine.or(schemas_array(zLinearRegressionLine)).nullish(),
+            lowessRegressionLine: zLowessRegressionLine.or(schemas_array(zLowessRegressionLine)).nullish(),
+            polynomialRegressionLine: zPolynomialRegressionLine.or(schemas_array(zPolynomialRegressionLine)).nullish(),
+            logisticRegressionLine: zLogisticRegressionLine.or(schemas_array(zLogisticRegressionLine)).nullish()
+        });
+        const zColumnParallelConfig = schemas_object({
             backgroundColor: zBackgroundColor.nullish(),
             label: zLabel.nullish(),
             color: zColor.nullish(),
@@ -15768,8 +16785,10 @@
             pivotGrid: zPivotChartGridConfig.nullish(),
             annotation: zAnnotationConfig.nullish()
         });
-        const zColumnParallelConfig = zColumnConfig;
-        const zColumnPercentConfig = zColumnConfig;
+        const zColumnConfig = zColumnParallelConfig.extend({
+            regressionLine: zRegressionLine.nullish()
+        });
+        const zColumnPercentConfig = zColumnParallelConfig.extend({});
         const zBarConfig = schemas_object({
             backgroundColor: zBackgroundColor.nullish(),
             label: zLabel.nullish(),
@@ -15810,7 +16829,8 @@
             size: schemas_number().or(schemas_array(schemas_number())).nullish(),
             sizeRange: schemas_number().or(schemas_array(schemas_number())).nullish(),
             pivotGrid: zPivotChartGridConfig.nullish(),
-            annotation: zAnnotationConfig.nullish()
+            annotation: zAnnotationConfig.nullish(),
+            regressionLine: zRegressionLine.nullish()
         });
         const zDualAxisConfig = schemas_object({
             backgroundColor: zBackgroundColor.nullish(),
@@ -15896,19 +16916,6 @@
             annotation: zAnnotationConfig.nullish(),
             whiskers: zWhiskersConfig.nullish()
         });
-        const zHistogramRegressionLine = schemas_object({
-            type: union([
-                literal('kde'),
-                literal('ecdf')
-            ]).nullish(),
-            color: schemas_string().nullish(),
-            lineWidth: schemas_number().nullish(),
-            lineDash: schemas_array(schemas_number()).nullish(),
-            text: schemas_string().nullish(),
-            textColor: schemas_string().nullish(),
-            textFontSize: schemas_number().nullish(),
-            textFontWeight: schemas_number().nullish()
-        });
         const zHistogramConfig = schemas_object({
             backgroundColor: zBackgroundColor.nullish(),
             label: zLabel.nullish(),
@@ -15924,7 +16931,7 @@
             binCount: schemas_number().positive().nullish(),
             binStep: schemas_number().positive().nullish(),
             binValueType: literal('count').or(literal('percentage')).nullish(),
-            histogramRegressionLine: zHistogramRegressionLine.nullish()
+            regressionLine: zRegressionLine.nullish()
         });
         const zConfig = schemas_object({
             table: zTableConfig.nullish(),
@@ -16199,6 +17206,7 @@
             annotationVerticalLine: schemas_array(zAnnotationVerticalLine).or(zAnnotationVerticalLine).nullish(),
             annotationHorizontalLine: schemas_array(zAnnotationHorizontalLine).or(zAnnotationHorizontalLine).nullish(),
             annotationArea: schemas_array(zAnnotationArea).or(zAnnotationArea).nullish(),
+            polynomialRegressionLine: schemas_array(zPolynomialRegressionLine).or(zPolynomialRegressionLine).or(schemas_boolean()).nullish(),
             locale: zLocale.nullish()
         });
         const zColumnParallel = schemas_object({
@@ -16394,6 +17402,10 @@
             annotationVerticalLine: schemas_array(zAnnotationVerticalLine).or(zAnnotationVerticalLine).nullish(),
             annotationHorizontalLine: schemas_array(zAnnotationHorizontalLine).or(zAnnotationHorizontalLine).nullish(),
             annotationArea: schemas_array(zAnnotationArea).or(zAnnotationArea).nullish(),
+            linearRegressionLine: schemas_array(zLinearRegressionLine).or(zLinearRegressionLine).or(schemas_boolean()).nullish(),
+            lowessRegressionLine: schemas_array(zLowessRegressionLine).or(zLowessRegressionLine).or(schemas_boolean()).nullish(),
+            polynomialRegressionLine: schemas_array(zPolynomialRegressionLine).or(zPolynomialRegressionLine).or(schemas_boolean()).nullish(),
+            logisticRegressionLine: schemas_array(zLogisticRegressionLine).or(zLogisticRegressionLine).or(schemas_boolean()).nullish(),
             locale: zLocale.nullish()
         });
         const zDualAxis = schemas_object({
@@ -16451,7 +17463,8 @@
             annotationVerticalLine: schemas_array(zAnnotationVerticalLine).or(zAnnotationVerticalLine).nullish(),
             annotationHorizontalLine: schemas_array(zAnnotationHorizontalLine).or(zAnnotationHorizontalLine).nullish(),
             annotationArea: schemas_array(zAnnotationArea).or(zAnnotationArea).nullish(),
-            histogramRegressionLine: schemas_array(zHistogramRegressionLine).or(zHistogramRegressionLine).nullish(),
+            ecdfRegressionLine: schemas_array(zEcdfRegressionLine).or(zEcdfRegressionLine).or(schemas_boolean()).nullish(),
+            kdeRegressionLine: schemas_array(zKdeRegressionLine).or(zKdeRegressionLine).or(schemas_boolean()).nullish(),
             locale: zLocale.nullish()
         });
         const zRose = schemas_object({
@@ -16613,7 +17626,7 @@
             customTheme: zCustomThemeConfig,
             annotation: zAnnotation,
             locale: zLocale,
-            histogramRegressionLine: zHistogramRegressionLine.or(schemas_array(zHistogramRegressionLine)).nullish()
+            regressionLine: zRegressionLine
         });
         return __webpack_exports__;
     })());