@visactor/vseed 0.1.40 → 0.1.42

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) {
@@ -2300,22 +2306,6 @@
             ];
             return e.sort(t), e;
         }
-        const sortXBandAxis = (advancedVSeed, context)=>{
-            const result = {
-                ...advancedVSeed
-            };
-            const { vseed } = context;
-            const { sort: sortAxis } = vseed;
-            const { datasetReshapeInfo, dataset } = advancedVSeed;
-            const { unfoldInfo } = datasetReshapeInfo[0];
-            const xField = unfoldInfo.encodingX;
-            if (!sortAxis || !xField) return advancedVSeed;
-            if (!result.analysis) result.analysis = {};
-            if (!result.analysis.orderMapping) result.analysis.orderMapping = {};
-            const axisOrderResult = calcOrder(sortAxis, xField, dataset.flat(2));
-            result.analysis.orderMapping[xField] = axisOrderResult;
-            return result;
-        };
         const calcOrder = (sortConfig, id, dataset)=>{
             if (sortConfig.customOrder) return sortConfig.customOrder;
             const order = sortConfig.order || 'asc';
@@ -2334,6 +2324,22 @@
             });
             return chunk_QJLMYOTX_i(res.map((item)=>item[id]));
         };
+        const sortXBandAxis = (advancedVSeed, context)=>{
+            const result = {
+                ...advancedVSeed
+            };
+            const { vseed } = context;
+            const { sort: sortAxis } = vseed;
+            const { datasetReshapeInfo, dataset } = advancedVSeed;
+            const { unfoldInfo } = datasetReshapeInfo[0];
+            const xField = unfoldInfo.encodingX;
+            if (!sortAxis || !xField) return advancedVSeed;
+            if (!result.analysis) result.analysis = {};
+            if (!result.analysis.orderMapping) result.analysis.orderMapping = {};
+            const axisOrderResult = calcOrder(sortAxis, xField, dataset.flat(2));
+            result.analysis.orderMapping[xField] = axisOrderResult;
+            return result;
+        };
         const sortLegend_sortLegend = (advancedVSeed, context)=>{
             const result = {
                 ...advancedVSeed
@@ -2356,28 +2362,10 @@
                 result.analysis.orderMapping[colorId] = orderRes;
                 return result;
             }
-            const orderRes = sortLegend_calcOrder(sortLegend, colorId, dataset?.flat(2) || []);
+            const orderRes = calcOrder(sortLegend, colorId, dataset?.flat(2) || []);
             result.analysis.orderMapping[colorId] = orderRes;
             return result;
         };
-        const sortLegend_calcOrder = (sortConfig, id, dataset)=>{
-            if (sortConfig.customOrder) return sortConfig.customOrder;
-            const order = sortConfig.order || 'asc';
-            const orderBy = sortConfig.orderBy;
-            const res = chunk_NFFV4IQT_m(dataset, (a, b)=>{
-                const aValue = a[orderBy || id];
-                const bValue = b[orderBy || id];
-                if ('asc' === order) {
-                    if (aValue < bValue) return -1;
-                    if (aValue > bValue) return 1;
-                    return 0;
-                }
-                if (aValue > bValue) return -1;
-                if (aValue < bValue) return 1;
-                return 0;
-            });
-            return chunk_QJLMYOTX_i(res.map((item)=>item[id]));
-        };
         function chunk_3ZJAREUD_i(...e) {
             return chunk_WIMGWYZL_u(chunk_3ZJAREUD_o, e);
         }
@@ -2395,7 +2383,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 +2460,7 @@
             ]),
             sortXBandAxis,
             sortLegend_sortLegend,
-            lineConfig,
+            line_lineConfig,
             theme_theme,
             markStyle_markStyle,
             annotation_annotation
@@ -3453,23 +3441,23 @@
                     title: {
                         visible: true
                     },
-                    content: createDimensionContent(measures, foldInfo, unfoldInfo)
+                    content: createDimensionContent(dimensions, measures, foldInfo, unfoldInfo)
                 }
             };
             return result;
         };
-        const createDimensionContent = (measures, foldInfo, unfoldInfo)=>{
-            const { measureId, measureValue } = foldInfo;
+        const createDimensionContent = (dimensions, measures, foldInfo, unfoldInfo)=>{
+            const { measureId, measureValue, foldMap } = foldInfo;
             const { encodingColor } = unfoldInfo;
             return [
                 {
                     visible: true,
                     shapeType: 'rectRound',
                     hasShape: true,
-                    key: (v)=>{
+                    key: dimensions.some((d)=>'color' === d.encoding) ? (v)=>{
                         const datum = v;
                         return datum && datum[encodingColor] || '';
-                    },
+                    } : Object.values(foldMap)[0],
                     value: (v)=>{
                         const datum = v;
                         if (!datum) return '';
@@ -3970,6 +3958,550 @@
                 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
+            ] : [];
+        }
+        const isNumber = (value, fuzzy = !1)=>{
+            const type = typeof value;
+            return fuzzy ? "number" === type : "number" === type || isType(value, "Number");
+        };
+        const common_isNumber = isNumber;
+        const isNil = (value)=>null == value;
+        const common_isNil = isNil;
+        const clamp_clamp = function(input, min, max) {
+            return input < min ? min : input > max ? max : input;
+        };
+        const clamp = clamp_clamp;
+        function hslToRgb(h, s, l) {
+            s /= 100, l /= 100;
+            const c = (1 - Math.abs(2 * l - 1)) * s, x = c * (1 - Math.abs(h / 60 % 2 - 1)), m = l - c / 2;
+            let r = 0, g = 0, b = 0;
+            return 0 <= h && h < 60 ? (r = c, g = x, b = 0) : 60 <= h && h < 120 ? (r = x, g = c, b = 0) : 120 <= h && h < 180 ? (r = 0, g = c, b = x) : 180 <= h && h < 240 ? (r = 0, g = x, b = c) : 240 <= h && h < 300 ? (r = x, g = 0, b = c) : 300 <= h && h < 360 && (r = c, g = 0, b = x), r = Math.round(255 * (r + m)), g = Math.round(255 * (g + m)), b = Math.round(255 * (b + m)), {
+                r: r,
+                g: g,
+                b: b
+            };
+        }
+        function rgbToHsl(r, g, b) {
+            r /= 255, g /= 255, b /= 255;
+            const cMin = Math.min(r, g, b), cMax = Math.max(r, g, b), delta = cMax - cMin;
+            let h = 0, s = 0, l = 0;
+            return h = 0 === delta ? 0 : cMax === r ? (g - b) / delta % 6 : cMax === g ? (b - r) / delta + 2 : (r - g) / delta + 4, h = Math.round(60 * h), h < 0 && (h += 360), l = (cMax + cMin) / 2, s = 0 === delta ? 0 : delta / (1 - Math.abs(2 * l - 1)), s = +(100 * s).toFixed(1), l = +(100 * l).toFixed(1), {
+                h: h,
+                s: s,
+                l: l
+            };
+        }
+        const REG_HEX = /^#([0-9a-f]{3,8})$/, DEFAULT_COLORS_OPACITY = {
+            transparent: 4294967040
+        };
+        const DEFAULT_COLORS = {
+            aliceblue: 15792383,
+            antiquewhite: 16444375,
+            aqua: 65535,
+            aquamarine: 8388564,
+            azure: 15794175,
+            beige: 16119260,
+            bisque: 16770244,
+            black: 0,
+            blanchedalmond: 16772045,
+            blue: 255,
+            blueviolet: 9055202,
+            brown: 10824234,
+            burlywood: 14596231,
+            cadetblue: 6266528,
+            chartreuse: 8388352,
+            chocolate: 13789470,
+            coral: 16744272,
+            cornflowerblue: 6591981,
+            cornsilk: 16775388,
+            crimson: 14423100,
+            cyan: 65535,
+            darkblue: 139,
+            darkcyan: 35723,
+            darkgoldenrod: 12092939,
+            darkgray: 11119017,
+            darkgreen: 25600,
+            darkgrey: 11119017,
+            darkkhaki: 12433259,
+            darkmagenta: 9109643,
+            darkolivegreen: 5597999,
+            darkorange: 16747520,
+            darkorchid: 10040012,
+            darkred: 9109504,
+            darksalmon: 15308410,
+            darkseagreen: 9419919,
+            darkslateblue: 4734347,
+            darkslategray: 3100495,
+            darkslategrey: 3100495,
+            darkturquoise: 52945,
+            darkviolet: 9699539,
+            deeppink: 16716947,
+            deepskyblue: 49151,
+            dimgray: 6908265,
+            dimgrey: 6908265,
+            dodgerblue: 2003199,
+            firebrick: 11674146,
+            floralwhite: 16775920,
+            forestgreen: 2263842,
+            fuchsia: 16711935,
+            gainsboro: 14474460,
+            ghostwhite: 16316671,
+            gold: 16766720,
+            goldenrod: 14329120,
+            gray: 8421504,
+            green: 32768,
+            greenyellow: 11403055,
+            grey: 8421504,
+            honeydew: 15794160,
+            hotpink: 16738740,
+            indianred: 13458524,
+            indigo: 4915330,
+            ivory: 16777200,
+            khaki: 15787660,
+            lavender: 15132410,
+            lavenderblush: 16773365,
+            lawngreen: 8190976,
+            lemonchiffon: 16775885,
+            lightblue: 11393254,
+            lightcoral: 15761536,
+            lightcyan: 14745599,
+            lightgoldenrodyellow: 16448210,
+            lightgray: 13882323,
+            lightgreen: 9498256,
+            lightgrey: 13882323,
+            lightpink: 16758465,
+            lightsalmon: 16752762,
+            lightseagreen: 2142890,
+            lightskyblue: 8900346,
+            lightslategray: 7833753,
+            lightslategrey: 7833753,
+            lightsteelblue: 11584734,
+            lightyellow: 16777184,
+            lime: 65280,
+            limegreen: 3329330,
+            linen: 16445670,
+            magenta: 16711935,
+            maroon: 8388608,
+            mediumaquamarine: 6737322,
+            mediumblue: 205,
+            mediumorchid: 12211667,
+            mediumpurple: 9662683,
+            mediumseagreen: 3978097,
+            mediumslateblue: 8087790,
+            mediumspringgreen: 64154,
+            mediumturquoise: 4772300,
+            mediumvioletred: 13047173,
+            midnightblue: 1644912,
+            mintcream: 16121850,
+            mistyrose: 16770273,
+            moccasin: 16770229,
+            navajowhite: 16768685,
+            navy: 128,
+            oldlace: 16643558,
+            olive: 8421376,
+            olivedrab: 7048739,
+            orange: 16753920,
+            orangered: 16729344,
+            orchid: 14315734,
+            palegoldenrod: 15657130,
+            palegreen: 10025880,
+            paleturquoise: 11529966,
+            palevioletred: 14381203,
+            papayawhip: 16773077,
+            peachpuff: 16767673,
+            peru: 13468991,
+            pink: 16761035,
+            plum: 14524637,
+            powderblue: 11591910,
+            purple: 8388736,
+            rebeccapurple: 6697881,
+            red: 16711680,
+            rosybrown: 12357519,
+            royalblue: 4286945,
+            saddlebrown: 9127187,
+            salmon: 16416882,
+            sandybrown: 16032864,
+            seagreen: 3050327,
+            seashell: 16774638,
+            sienna: 10506797,
+            silver: 12632256,
+            skyblue: 8900331,
+            slateblue: 6970061,
+            slategray: 7372944,
+            slategrey: 7372944,
+            snow: 16775930,
+            springgreen: 65407,
+            steelblue: 4620980,
+            tan: 13808780,
+            teal: 32896,
+            thistle: 14204888,
+            tomato: 16737095,
+            turquoise: 4251856,
+            violet: 15631086,
+            wheat: 16113331,
+            white: 16777215,
+            whitesmoke: 16119285,
+            yellow: 16776960,
+            yellowgreen: 10145074
+        };
+        function Color_hex(value) {
+            return ((value = Math.max(0, Math.min(255, Math.round(value) || 0))) < 16 ? "0" : "") + value.toString(16);
+        }
+        function Color_rgb(value) {
+            return common_isNumber(value) ? new RGB(value >> 16, value >> 8 & 255, 255 & value, 1) : common_isArray(value) ? new RGB(value[0], value[1], value[2]) : new RGB(255, 255, 255);
+        }
+        function rgba(value) {
+            return common_isNumber(value) ? new RGB(value >>> 24, value >>> 16 & 255, value >>> 8 & 255, 255 & value) : common_isArray(value) ? new RGB(value[0], value[1], value[2], value[3]) : new RGB(255, 255, 255, 1);
+        }
+        function SRGBToLinear(c) {
+            return c < .04045 ? .0773993808 * c : Math.pow(.9478672986 * c + .0521327014, 2.4);
+        }
+        function LinearToSRGB(c) {
+            return c < .0031308 ? 12.92 * c : 1.055 * Math.pow(c, .41666) - .055;
+        }
+        const setHex = (formatValue, forceHex)=>{
+            const isHex = REG_HEX.exec(formatValue);
+            if (forceHex || isHex) {
+                const hex = parseInt(isHex[1], 16), hexLength = isHex[1].length;
+                return 3 === hexLength ? new RGB((hex >> 8 & 15) + ((hex >> 8 & 15) << 4), (hex >> 4 & 15) + ((hex >> 4 & 15) << 4), (15 & hex) + ((15 & hex) << 4), 1) : 6 === hexLength ? Color_rgb(hex) : 8 === hexLength ? new RGB(hex >> 24 & 255, hex >> 16 & 255, hex >> 8 & 255, (255 & hex) / 255) : null;
+            }
+        };
+        class Color {
+            static Brighter(source, b = 1) {
+                return 1 === b ? source : new Color(source).brighter(b).toRGBA();
+            }
+            static SetOpacity(source, o = 1) {
+                return 1 === o ? source : new Color(source).setOpacity(o).toRGBA();
+            }
+            static getColorBrightness(source, model = "hsl") {
+                const color = source instanceof Color ? source : new Color(source);
+                switch(model){
+                    case "hsv":
+                    default:
+                        return color.getHSVBrightness();
+                    case "hsl":
+                        return color.getHSLBrightness();
+                    case "lum":
+                        return color.getLuminance();
+                    case "lum2":
+                        return color.getLuminance2();
+                    case "lum3":
+                        return color.getLuminance3();
+                    case "wcag":
+                        return color.getLuminanceWCAG();
+                }
+            }
+            static parseColorString(value) {
+                if (common_isValid(DEFAULT_COLORS_OPACITY[value])) return rgba(DEFAULT_COLORS_OPACITY[value]);
+                if (common_isValid(DEFAULT_COLORS[value])) return Color_rgb(DEFAULT_COLORS[value]);
+                const formatValue = `${value}`.trim().toLowerCase(), hexRes = setHex(formatValue);
+                if (void 0 !== hexRes) return hexRes;
+                if (/^(rgb|RGB|rgba|RGBA)/.test(formatValue)) {
+                    const aColor = formatValue.replace(/(?:\(|\)|rgba|RGBA|rgb|RGB)*/g, "").split(",");
+                    return new RGB(parseInt(aColor[0], 10), parseInt(aColor[1], 10), parseInt(aColor[2], 10), parseFloat(aColor[3]));
+                }
+                if (/^(hsl|HSL|hsla|HSLA)/.test(formatValue)) {
+                    const aColor = formatValue.replace(/(?:\(|\)|hsla|HSLA|hsl|HSL)*/g, "").split(","), rgb = hslToRgb(parseInt(aColor[0], 10), parseInt(aColor[1], 10), parseInt(aColor[2], 10));
+                    return new RGB(rgb.r, rgb.g, rgb.b, parseFloat(aColor[3]));
+                }
+            }
+            constructor(value){
+                const color = Color.parseColorString(value);
+                color ? this.color = color : (console.warn(`Warn: 传入${value}无法解析为Color`), this.color = new RGB(255, 255, 255));
+            }
+            toRGBA() {
+                return this.color.formatRgb();
+            }
+            toString() {
+                return this.color.formatRgb();
+            }
+            toHex() {
+                return this.color.formatHex();
+            }
+            toHsl() {
+                return this.color.formatHsl();
+            }
+            brighter(k) {
+                const { r: r, g: g, b: b } = this.color;
+                return this.color.r = Math.max(0, Math.min(255, Math.floor(r * k))), this.color.g = Math.max(0, Math.min(255, Math.floor(g * k))), this.color.b = Math.max(0, Math.min(255, Math.floor(b * k))), this;
+            }
+            add(color) {
+                const { r: r, g: g, b: b } = this.color;
+                return this.color.r += Math.min(255, r + color.color.r), this.color.g += Math.min(255, g + color.color.g), this.color.b += Math.min(255, b + color.color.b), this;
+            }
+            sub(color) {
+                return this.color.r = Math.max(0, this.color.r - color.color.r), this.color.g = Math.max(0, this.color.g - color.color.g), this.color.b = Math.max(0, this.color.b - color.color.b), this;
+            }
+            multiply(color) {
+                const { r: r, g: g, b: b } = this.color;
+                return this.color.r = Math.max(0, Math.min(255, Math.floor(r * color.color.r))), this.color.g = Math.max(0, Math.min(255, Math.floor(g * color.color.g))), this.color.b = Math.max(0, Math.min(255, Math.floor(b * color.color.b))), this;
+            }
+            getHSVBrightness() {
+                return Math.max(this.color.r, this.color.g, this.color.b) / 255;
+            }
+            getHSLBrightness() {
+                return .5 * (Math.max(this.color.r, this.color.g, this.color.b) / 255 + Math.min(this.color.r, this.color.g, this.color.b) / 255);
+            }
+            setHsl(h, s, l) {
+                const opacity = this.color.opacity, hsl = rgbToHsl(this.color.r, this.color.g, this.color.b), rgb = hslToRgb(common_isNil(h) ? hsl.h : clamp(h, 0, 360), common_isNil(s) ? hsl.s : s >= 0 && s <= 1 ? 100 * s : s, common_isNil(l) ? hsl.l : l <= 1 && l >= 0 ? 100 * l : l);
+                return this.color = new RGB(rgb.r, rgb.g, rgb.b, opacity), this;
+            }
+            setRGB(r, g, b) {
+                return common_isNil(r) || (this.color.r = r), common_isNil(g) || (this.color.g = g), common_isNil(b) || (this.color.b = b), this;
+            }
+            setHex(value) {
+                const formatValue = `${value}`.trim().toLowerCase(), res = setHex(formatValue, !0);
+                return null != res ? res : this;
+            }
+            setColorName(name) {
+                const hex = DEFAULT_COLORS[name.toLowerCase()];
+                return void 0 !== hex ? this.setHex(hex) : console.warn("THREE.Color: Unknown color " + name), this;
+            }
+            setScalar(scalar) {
+                return this.color.r = scalar, this.color.g = scalar, this.color.b = scalar, this;
+            }
+            setOpacity(o = 1) {
+                return this.color.opacity = o, this;
+            }
+            getLuminance() {
+                return (.2126 * this.color.r + .7152 * this.color.g + .0722 * this.color.b) / 255;
+            }
+            getLuminance2() {
+                return (.2627 * this.color.r + .678 * this.color.g + .0593 * this.color.b) / 255;
+            }
+            getLuminance3() {
+                return (.299 * this.color.r + .587 * this.color.g + .114 * this.color.b) / 255;
+            }
+            getLuminanceWCAG() {
+                const RsRGB = this.color.r / 255, GsRGB = this.color.g / 255, BsRGB = this.color.b / 255;
+                let R, G, B;
+                R = RsRGB <= .03928 ? RsRGB / 12.92 : Math.pow((RsRGB + .055) / 1.055, 2.4), G = GsRGB <= .03928 ? GsRGB / 12.92 : Math.pow((GsRGB + .055) / 1.055, 2.4), B = BsRGB <= .03928 ? BsRGB / 12.92 : Math.pow((BsRGB + .055) / 1.055, 2.4);
+                return .2126 * R + .7152 * G + .0722 * B;
+            }
+            clone() {
+                return new Color(this.color.toString());
+            }
+            copyGammaToLinear(color, gammaFactor = 2) {
+                return this.color.r = Math.pow(color.color.r, gammaFactor), this.color.g = Math.pow(color.color.g, gammaFactor), this.color.b = Math.pow(color.color.b, gammaFactor), this;
+            }
+            copyLinearToGamma(color, gammaFactor = 2) {
+                const safeInverse = gammaFactor > 0 ? 1 / gammaFactor : 1;
+                return this.color.r = Math.pow(color.color.r, safeInverse), this.color.g = Math.pow(color.color.g, safeInverse), this.color.b = Math.pow(color.color.b, safeInverse), this;
+            }
+            convertGammaToLinear(gammaFactor) {
+                return this.copyGammaToLinear(this, gammaFactor), this;
+            }
+            convertLinearToGamma(gammaFactor) {
+                return this.copyLinearToGamma(this, gammaFactor), this;
+            }
+            copySRGBToLinear(color) {
+                return this.color.r = SRGBToLinear(color.color.r), this.color.g = SRGBToLinear(color.color.g), this.color.b = SRGBToLinear(color.color.b), this;
+            }
+            copyLinearToSRGB(color) {
+                return this.color.r = LinearToSRGB(color.color.r), this.color.g = LinearToSRGB(color.color.g), this.color.b = LinearToSRGB(color.color.b), this;
+            }
+            convertSRGBToLinear() {
+                return this.copySRGBToLinear(this), this;
+            }
+            convertLinearToSRGB() {
+                return this.copyLinearToSRGB(this), this;
+            }
+        }
+        class RGB {
+            constructor(r, g, b, opacity){
+                this.r = isNaN(+r) ? 255 : Math.max(0, Math.min(255, +r)), this.g = isNaN(+g) ? 255 : Math.max(0, Math.min(255, +g)), this.b = isNaN(+b) ? 255 : Math.max(0, Math.min(255, +b)), common_isValid(opacity) ? this.opacity = isNaN(+opacity) ? 1 : Math.max(0, Math.min(1, +opacity)) : this.opacity = 1;
+            }
+            formatHex() {
+                return `#${Color_hex(this.r) + Color_hex(this.g) + Color_hex(this.b) + (1 === this.opacity ? "" : Color_hex(255 * this.opacity))}`;
+            }
+            formatRgb() {
+                const opacity = this.opacity;
+                return `${1 === opacity ? "rgb(" : "rgba("}${this.r},${this.g},${this.b}${1 === opacity ? ")" : `,${opacity})`}`;
+            }
+            formatHsl() {
+                const opacity = this.opacity, { h: h, s: s, l: l } = rgbToHsl(this.r, this.g, this.b);
+                return `${1 === opacity ? "hsl(" : "hsla("}${h},${s}%,${l}%${1 === opacity ? ")" : `,${opacity})`}`;
+            }
+            toString() {
+                return this.formatHex();
+            }
+        }
+        const splitLine = (spec, context)=>{
+            const { advancedVSeed } = context;
+            const { annotation, chartType, datasetReshapeInfo } = advancedVSeed;
+            if (!annotation || !annotation.annotationHorizontalLine) return spec;
+            const baseConfig = advancedVSeed.config[chartType];
+            const splitLineConfig = array_array(annotation.annotationHorizontalLine).find((item)=>!!item.splitLine);
+            const splitValue = +splitLineConfig?.yValue;
+            if (Number.isNaN(splitValue) || !chunk_6GTAPB47_e(splitValue)) return spec;
+            const result = {
+                ...spec
+            };
+            const colorTheme = baseConfig?.color ?? {};
+            const colorConfig = {
+                positiveColor: colorTheme.positiveColor || 'red',
+                negativeColor: colorTheme.negativeColor || 'green',
+                ...chunk_BZNENX2T_r(splitLineConfig?.splitLine) ? splitLineConfig?.splitLine : {}
+            };
+            const groupMark = {
+                type: 'group',
+                name: 'annotationHorizontalLine-splitLine',
+                zIndex: 300,
+                style: {
+                    splitConfig: (datum, ctx)=>{
+                        const vchart = ctx.vchart;
+                        const chart = vchart.getChart();
+                        const lineSeries = chart.getAllSeries().find((s)=>'line' === s.type || 'area' === s.type);
+                        if (!lineSeries) return;
+                        const lineMark = lineSeries.getMarkInName('line') ?? lineSeries.getMarkInName('area');
+                        if (!lineMark) return;
+                        const lineGraphics = lineMark.getGraphics();
+                        if (!lineGraphics || 1 !== lineGraphics.length || !lineGraphics[0]) return;
+                        const points = lineGraphics[0].attribute.points ?? [];
+                        if (lineGraphics[0].attribute.segments?.length) lineGraphics[0].attribute.segments.forEach((seg)=>{
+                            seg.points.forEach((pt)=>{
+                                points.push({
+                                    x: pt.x,
+                                    y: pt.y
+                                });
+                            });
+                        });
+                        if (!points || !points.length) return;
+                        const splitCoordinate = lineSeries.getYAxisHelper().getScale(0).scale(splitValue);
+                        const minY = Math.min(...points.map((p)=>p.y));
+                        const maxY = Math.max(...points.map((p)=>p.y));
+                        const ratio = (splitCoordinate - minY) / (maxY - minY);
+                        const lineStroke = {
+                            gradient: 'linear',
+                            x0: 0,
+                            x1: 0,
+                            y0: 0,
+                            y1: 1,
+                            stops: [
+                                {
+                                    color: colorConfig.positiveColor,
+                                    offset: 0
+                                },
+                                {
+                                    color: colorConfig.positiveColor,
+                                    offset: ratio
+                                },
+                                {
+                                    color: colorConfig.negativeColor,
+                                    offset: ratio + 0.0000001
+                                },
+                                {
+                                    color: colorConfig.negativeColor,
+                                    offset: 1
+                                }
+                            ]
+                        };
+                        const areaFill = {
+                            gradient: 'linear',
+                            x0: 0,
+                            x1: 0,
+                            y0: 0,
+                            y1: 1,
+                            stops: [
+                                {
+                                    color: colorConfig.positiveColor,
+                                    offset: 0
+                                },
+                                {
+                                    color: new Color(colorConfig.positiveColor).setOpacity(0).toRGBA(),
+                                    offset: ratio
+                                },
+                                {
+                                    offset: ratio + 0.0000001,
+                                    color: new Color(colorConfig.negativeColor).setOpacity(0).toRGBA()
+                                },
+                                {
+                                    color: colorConfig.negativeColor,
+                                    offset: 1
+                                }
+                            ]
+                        };
+                        const attrs = {
+                            segments: null,
+                            points
+                        };
+                        if ('area' === lineGraphics[0].type) {
+                            attrs.stroke = lineStroke;
+                            attrs.fill = areaFill;
+                        } else attrs.stroke = lineStroke;
+                        lineGraphics[0].setAttributes(attrs);
+                        lineGraphics[0].setFinalAttributes?.(attrs);
+                        const start = lineSeries.getRegion().getLayoutStartPoint();
+                        return {
+                            points: points.map((entry)=>({
+                                    x: entry.x + start.x,
+                                    y: entry.y + start.y
+                                })),
+                            splitCoordinate,
+                            areaFill,
+                            lineStroke
+                        };
+                    }
+                },
+                children: [
+                    {
+                        type: 'area',
+                        interactive: false,
+                        zIndex: 500,
+                        style: {
+                            fillOpacity: 0.5,
+                            points: (datum, ctx, opt)=>{
+                                const parentNode = opt.mark?._product?.parent;
+                                if (parentNode?.attribute?.splitConfig) {
+                                    const { points, splitCoordinate } = parentNode.attribute.splitConfig;
+                                    return points.map((entry)=>({
+                                            ...entry,
+                                            y1: splitCoordinate
+                                        }));
+                                }
+                                return [];
+                            },
+                            fill: (datum, ctx, opt)=>{
+                                const parentNode = opt.mark?._product?.parent;
+                                if (parentNode?.attribute?.splitConfig) {
+                                    const { areaFill } = parentNode.attribute.splitConfig;
+                                    return areaFill;
+                                }
+                            }
+                        }
+                    }
+                ]
+            };
+            if (!result.customMark) result.customMark = [];
+            result.customMark.push(groupMark);
+            const seriesSpec = 'line' === result.type || 'area' === result.type ? result : result.series?.find((s)=>'line' === s.type || 'area' === s.type);
+            if (seriesSpec) {
+                if (!seriesSpec.point) seriesSpec.point = {};
+                if (!seriesSpec.line) seriesSpec.line = {};
+                if (!seriesSpec.point.style) seriesSpec.point.style = {};
+                if (!seriesSpec.line.style) seriesSpec.line.style = {};
+                const measureValueKey = datasetReshapeInfo[0].foldInfo.measureValue;
+                seriesSpec.point.style.fill = (datum)=>{
+                    console.log(datum);
+                    return datum?.[measureValueKey] >= splitValue ? colorConfig.positiveColor : colorConfig.negativeColor;
+                };
+                seriesSpec.line.style.stroke = (datum)=>datum?.[measureValueKey] >= splitValue ? colorConfig.positiveColor : colorConfig.negativeColor;
+                if (seriesSpec.label && seriesSpec.label.visible && chunk_JK3VNB42_n(seriesSpec.label.style?.fill)) seriesSpec.label.style = {
+                    ...seriesSpec.label.style,
+                    fill: (datum)=>datum?.[measureValueKey] >= splitValue ? colorConfig.positiveColor : colorConfig.negativeColor
+                };
+            }
+            return result;
+        };
         const initPivot = (spec)=>{
             const result = {
                 ...spec
@@ -4001,7 +4533,7 @@
                     isShowOverflowTextTooltip: true
                 },
                 corner: {
-                    titleOnDimension: 'all'
+                    titleOnDimension: 'row'
                 },
                 animationAppear: {
                     duration: 600,
@@ -4012,13 +4544,14 @@
         };
         const pivotGridStyle = (spec, context)=>{
             const { vseed, advancedVSeed } = context;
-            const { config, chartType } = advancedVSeed;
+            const { config, chartType, dimensions } = advancedVSeed;
             const themConfig = config?.[chartType]?.pivotGrid ?? {};
             const onlyCombination = !isPivot(vseed) && isCombination(vseed);
             const result = {
                 ...spec
             };
             const transparent = 'rgba(0,0,0,0)';
+            const hasColumnDimension = dimensions.some((dim)=>'column' === dim.encoding);
             const borderColor = themConfig.borderColor ?? '#e3e5eb';
             const bodyFontColor = themConfig.bodyFontColor ?? '#141414';
             const headerFontColor = themConfig.headerFontColor ?? '#21252c';
@@ -4036,12 +4569,12 @@
                     bodyStyle: {
                         borderColor,
                         color: bodyFontColor,
-                        borderLineWidth: [
-                            1,
-                            outlineBorderLineWidth,
-                            0,
-                            1
-                        ],
+                        borderLineWidth: (arg)=>[
+                                0 === arg.row ? outlineBorderLineWidth : 1,
+                                outlineBorderLineWidth,
+                                0,
+                                0 === arg.col ? outlineBorderLineWidth : 1
+                            ],
                         bgColor: transparent,
                         hover: {
                             cellBgColor: 'transparent'
@@ -4050,12 +4583,12 @@
                     headerStyle: {
                         borderColor,
                         fontSize: 12,
-                        borderLineWidth: [
-                            outlineBorderLineWidth,
-                            outlineBorderLineWidth,
-                            1,
-                            1
-                        ],
+                        borderLineWidth: (arg)=>[
+                                outlineBorderLineWidth,
+                                outlineBorderLineWidth,
+                                1,
+                                0 === arg.col ? outlineBorderLineWidth : 1
+                            ],
                         color: headerFontColor,
                         textAlign: 'center',
                         bgColor: headerBackgroundColor,
@@ -4075,12 +4608,12 @@
                             0,
                             4
                         ],
-                        borderLineWidth: [
-                            1,
-                            1,
-                            1,
-                            outlineBorderLineWidth
-                        ],
+                        borderLineWidth: (arg)=>[
+                                0 === arg.row ? outlineBorderLineWidth : 1,
+                                1,
+                                0,
+                                outlineBorderLineWidth
+                            ],
                         bgColor: headerBackgroundColor,
                         hover: {
                             cellBgColor: hoverHeaderBackgroundColor,
@@ -4108,13 +4641,7 @@
                         ],
                         bgColor: headerBackgroundColor,
                         frameStyle: {
-                            borderColor,
-                            borderLineWidth: [
-                                outlineBorderLineWidth,
-                                0,
-                                0,
-                                outlineBorderLineWidth
-                            ]
+                            borderColor
                         },
                         hover: {
                             cellBgColor: hoverHeaderBackgroundColor,
@@ -4128,9 +4655,9 @@
                         frameStyle: {
                             borderColor,
                             borderLineWidth: [
+                                outlineBorderLineWidth,
                                 outlineBorderLineWidth,
                                 1,
-                                0,
                                 1
                             ]
                         },
@@ -4142,7 +4669,7 @@
                     cornerLeftBottomCellStyle: {
                         borderColor,
                         borderLineWidth: [
-                            1,
+                            outlineBorderLineWidth,
                             0,
                             outlineBorderLineWidth,
                             outlineBorderLineWidth
@@ -4163,14 +4690,19 @@
                     },
                     cornerRightBottomCellStyle: {
                         borderColor,
-                        borderLineWidth: 0,
                         bgColor: headerBackgroundColor,
+                        borderLineWidth: [
+                            1,
+                            outlineBorderLineWidth,
+                            outlineBorderLineWidth,
+                            1
+                        ],
                         frameStyle: {
                             borderColor,
                             borderLineWidth: [
                                 1,
-                                1,
-                                1,
+                                outlineBorderLineWidth,
+                                outlineBorderLineWidth,
                                 1
                             ]
                         },
@@ -4180,9 +4712,15 @@
                     },
                     rightFrozenStyle: {
                         borderColor,
-                        borderLineWidth: 1,
                         bgColor: headerBackgroundColor,
+                        borderLineWidth: (arg)=>[
+                                0 === arg.row || hasColumnDimension && 1 === arg.row ? outlineBorderLineWidth : 1,
+                                outlineBorderLineWidth,
+                                0,
+                                1
+                            ],
                         hover: {
+                            borderLineWidth: 0,
                             cellBgColor: hoverHeaderBackgroundColor
                         }
                     },
@@ -4294,6 +4832,16 @@
                 records: records
             };
         };
+        const pivotAxisStyle = (axisStyle)=>(spec, context)=>{
+                const result = axisStyle(spec, context);
+                if (result.axes) result.axes.forEach((axis)=>{
+                    axis.domainLine = {
+                        visible: false
+                    };
+                    if (axis.grid && axis.grid.visible && axis.grid.style) axis.grid.style.strokeOpacity = 0.3;
+                });
+                return result;
+            };
         const pivotRowDimensions = (spec, context)=>{
             const result = {
                 ...spec
@@ -4328,6 +4876,31 @@
                 columns: columns
             };
         };
+        const pivotTitle = (spec, context)=>{
+            const result = {
+                ...spec
+            };
+            const { advancedVSeed } = context;
+            const { config, chartType } = advancedVSeed;
+            const themConfig = config?.[chartType]?.pivotGrid ?? {};
+            if (result.columns && result.columns.length > 0) result.title = {
+                text: spec.columns.map((entry)=>entry.title).join('/'),
+                align: 'center',
+                orient: 'top',
+                padding: [
+                    2,
+                    0,
+                    0,
+                    0
+                ],
+                textStyle: {
+                    fontSize: themConfig.titleFontSize ?? 12,
+                    fill: themConfig.titleFontColor ?? '#000',
+                    fontWeight: themConfig.titleFontWeight ?? 'bold'
+                }
+            };
+            return result;
+        };
         const pivotDiscreteLegend = (spec, context)=>{
             const result = {
                 ...spec
@@ -4546,7 +5119,8 @@
             annotationPoint_annotationPoint,
             annotationVerticalLine_annotationVerticalLine,
             annotationHorizontalLine_annotationHorizontalLine,
-            annotationArea_annotationArea
+            annotationArea_annotationArea,
+            splitLine
         ];
         const pivotLine = [
             initPivot,
@@ -4560,7 +5134,7 @@
                 datasetXY,
                 progressive,
                 xBand,
-                yLinear,
+                pivotAxisStyle(yLinear),
                 verticalCrosshairLine,
                 colorPointStyleFill(pointStyle_pointStyle),
                 pointStateDimensionHover,
@@ -4570,10 +5144,12 @@
                 annotationPoint_annotationPoint,
                 annotationVerticalLine_annotationVerticalLine,
                 annotationHorizontalLine_annotationHorizontalLine,
-                annotationArea_annotationArea
+                annotationArea_annotationArea,
+                splitLine
             ]),
             pivotRowDimensions,
             pivotColumnDimensions,
+            pivotTitle,
             colorAdapter(pivotDiscreteLegend, pivotColorLegend)
         ];
         const lineSpecPipeline = [
@@ -4680,6 +5256,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 +5316,8 @@
             columnConfig,
             theme_theme,
             markStyle_markStyle,
-            annotation_annotation
+            annotation_annotation,
+            regressionLine_regressionLine
         ];
         const initColumn = (spec, context)=>{
             const result = {
@@ -5031,7 +5640,442 @@
                 markArea: markArea
             };
         };
-        const column = [
+        function clamper(a, b) {
+            let t;
+            return a > b && (t = a, a = b, b = t), (x)=>Math.max(a, Math.min(b, x));
+        }
+        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,
             barMaxWidth_barMaxWidth,
@@ -5050,7 +6094,8 @@
             annotationPoint_annotationPoint,
             annotationVerticalLine_annotationVerticalLine,
             annotationHorizontalLine_annotationHorizontalLine,
-            annotationAreaBand
+            annotationAreaBand,
+            columnPolynomialRegressionLine
         ];
         const pivotColumn = [
             initPivot,
@@ -5060,13 +6105,14 @@
             pivotIndicators_pivotIndicators([
                 initColumn,
                 stackCornerRadius_stackCornerRadius,
+                barMaxWidth_barMaxWidth,
                 stackInverse,
                 colorAdapter(color_color, linearColor),
                 background_backgroundColor,
                 datasetXY,
                 progressive,
                 xBand,
-                yLinear,
+                pivotAxisStyle(yLinear),
                 label_label,
                 tooltip_tooltip,
                 verticalCrosshairRect,
@@ -5074,10 +6120,12 @@
                 annotationPoint_annotationPoint,
                 annotationVerticalLine_annotationVerticalLine,
                 annotationHorizontalLine_annotationHorizontalLine,
-                annotationAreaBand
+                annotationAreaBand,
+                columnPolynomialRegressionLine
             ]),
             pivotRowDimensions,
             pivotColumnDimensions,
+            pivotTitle,
             colorAdapter(pivotDiscreteLegend, pivotColorLegend)
         ];
         const columnSpecPipeline = [
@@ -5109,8 +6157,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;
@@ -5259,12 +6307,13 @@
             pivotIndicators_pivotIndicators([
                 initColumnParallel,
                 stackCornerRadius_stackCornerRadius,
+                barMaxWidth_barMaxWidth,
                 colorAdapter(color_color, linearColor),
                 background_backgroundColor,
                 datasetXY,
                 progressive,
                 xBand,
-                yLinear,
+                pivotAxisStyle(yLinear),
                 label_label,
                 tooltip_tooltip,
                 verticalCrosshairRect,
@@ -5276,6 +6325,7 @@
             ]),
             pivotRowDimensions,
             pivotColumnDimensions,
+            pivotTitle,
             colorAdapter(pivotDiscreteLegend, pivotColorLegend)
         ];
         const columnParallelSpecPipeline = [
@@ -5353,13 +6403,14 @@
                 initColumn,
                 stackCornerRadius_stackCornerRadius,
                 stackInverse,
+                barMaxWidth_barMaxWidth,
                 colorAdapter(color_color, linearColor),
                 percent_percent,
                 background_backgroundColor,
                 datasetXY,
                 progressive,
                 xBand,
-                yLinear,
+                pivotAxisStyle(yLinear),
                 label_label,
                 tooltip_tooltip,
                 verticalCrosshairRect,
@@ -5371,6 +6422,7 @@
             ]),
             pivotRowDimensions,
             pivotColumnDimensions,
+            pivotTitle,
             colorAdapter(pivotDiscreteLegend, pivotColorLegend)
         ];
         const columnPercentSpecPipeline = [
@@ -5793,12 +6845,13 @@
             pivotIndicators_pivotIndicators([
                 initBar,
                 stackCornerRadius_stackCornerRadius,
+                barMaxWidth_barMaxWidth,
                 colorAdapter(color_color, linearColor),
                 background_backgroundColor,
                 datasetYX,
                 progressive,
                 xLinear,
-                yBand,
+                pivotAxisStyle(yBand),
                 label_label,
                 tooltip_tooltip,
                 colorBarStyleFill(barStyle_barStyle),
@@ -5810,6 +6863,7 @@
             ]),
             pivotRowDimensions,
             pivotColumnDimensions,
+            pivotTitle,
             colorAdapter(pivotDiscreteLegend, pivotColorLegend)
         ];
         const barSpecPipeline = [
@@ -5906,11 +6960,12 @@
             pivotIndicators_pivotIndicators([
                 initBarParallel,
                 stackCornerRadius_stackCornerRadius,
+                barMaxWidth_barMaxWidth,
                 colorAdapter(color_color, linearColor),
                 background_backgroundColor,
                 datasetYX,
                 xLinear,
-                yBand,
+                pivotAxisStyle(yBand),
                 label_label,
                 tooltip_tooltip,
                 colorBarStyleFill(barStyle_barStyle),
@@ -5922,6 +6977,7 @@
             ]),
             pivotRowDimensions,
             pivotColumnDimensions,
+            pivotTitle,
             colorAdapter(pivotDiscreteLegend, pivotColorLegend)
         ];
         const barParallelSpecPipeline = [
@@ -5990,12 +7046,13 @@
             pivotIndicators_pivotIndicators([
                 initBar,
                 stackCornerRadius_stackCornerRadius,
+                barMaxWidth_barMaxWidth,
                 colorAdapter(color_color, linearColor),
                 background_backgroundColor,
                 percent_percent,
                 datasetYX,
-                yBand,
                 xLinear,
+                pivotAxisStyle(yBand),
                 label_label,
                 tooltip_tooltip,
                 colorBarStyleFill(barStyle_barStyle),
@@ -6007,6 +7064,7 @@
             ]),
             pivotRowDimensions,
             pivotColumnDimensions,
+            pivotTitle,
             colorAdapter(pivotDiscreteLegend, pivotColorLegend)
         ];
         const barPercentSpecPipeline = [
@@ -6171,7 +7229,8 @@
             annotationPoint_annotationPoint,
             annotationVerticalLine_annotationVerticalLine,
             annotationHorizontalLine_annotationHorizontalLine,
-            annotationArea_annotationArea
+            annotationArea_annotationArea,
+            splitLine
         ];
         const pivotArea = [
             initPivot,
@@ -6186,7 +7245,7 @@
                 datasetXY,
                 progressive,
                 xBand,
-                yLinear,
+                pivotAxisStyle(yLinear),
                 label_label,
                 tooltip_tooltip,
                 verticalCrosshairLine,
@@ -6197,10 +7256,12 @@
                 annotationPoint_annotationPoint,
                 annotationVerticalLine_annotationVerticalLine,
                 annotationHorizontalLine_annotationHorizontalLine,
-                annotationArea_annotationArea
+                annotationArea_annotationArea,
+                splitLine
             ]),
             pivotRowDimensions,
             pivotColumnDimensions,
+            pivotTitle,
             colorAdapter(pivotDiscreteLegend, pivotColorLegend)
         ];
         const areaSpecPipeline = [
@@ -6277,7 +7338,7 @@
                 datasetXY,
                 progressive,
                 xBand,
-                yLinear,
+                pivotAxisStyle(yLinear),
                 label_label,
                 tooltip_tooltip,
                 verticalCrosshairLine,
@@ -6292,6 +7353,7 @@
             ]),
             pivotRowDimensions,
             pivotColumnDimensions,
+            pivotTitle,
             colorAdapter(pivotDiscreteLegend, pivotColorLegend)
         ];
         const areaPercentSpecPipeline = [
@@ -6645,7 +7707,8 @@
             scatterConfig,
             theme_theme,
             markStyle_markStyle,
-            annotation_annotation
+            annotation_annotation,
+            regressionLine_regressionLine
         ];
         const initScatter = (spec, context)=>{
             const result = {
@@ -6779,12 +7842,7 @@
                     visible: true,
                     hasShape: true,
                     shapeType: 'rectRound',
-                    key: (v)=>{
-                        const { measureId, foldMap } = foldInfo;
-                        const datum = v;
-                        const id = datum[measureId];
-                        return foldMap[id] || id;
-                    },
+                    key: Object.values(foldInfo.foldMap)[0],
                     value: (v)=>{
                         const { measureId, measureValue } = foldInfo;
                         const datum = v;
@@ -6806,46 +7864,430 @@
             const result = {
                 ...spec
             };
-            const { advancedVSeed, vseed } = context;
-            const { chartType } = vseed;
-            const config = advancedVSeed.config?.[chartType]?.crosshairLine;
-            if (!config) return result;
-            if (!result.crosshair) result.crosshair = {};
-            const visible = config.visible || true;
-            const lineColor = config.lineColor || void 0;
-            const labelColor = config.labelColor || void 0;
-            const labelVisible = config.labelVisible || void 0;
-            const labelBackgroundColor = config.labelBackgroundColor || void 0;
-            const crosshair = result.crosshair;
-            crosshair.yField = {
-                visible,
-                line: {
-                    type: 'line',
-                    style: {
-                        lineWidth: 1,
-                        opacity: 1,
-                        stroke: lineColor,
-                        lineDash: config.lineDash ?? [
-                            4,
-                            2
-                        ]
+            const { advancedVSeed, vseed } = context;
+            const { chartType } = vseed;
+            const config = advancedVSeed.config?.[chartType]?.crosshairLine;
+            if (!config) return result;
+            if (!result.crosshair) result.crosshair = {};
+            const visible = config.visible || true;
+            const lineColor = config.lineColor || void 0;
+            const labelColor = config.labelColor || void 0;
+            const labelVisible = config.labelVisible || void 0;
+            const labelBackgroundColor = config.labelBackgroundColor || void 0;
+            const crosshair = result.crosshair;
+            crosshair.yField = {
+                visible,
+                line: {
+                    type: 'line',
+                    style: {
+                        lineWidth: 1,
+                        opacity: 1,
+                        stroke: lineColor,
+                        lineDash: config.lineDash ?? [
+                            4,
+                            2
+                        ]
+                    }
+                },
+                label: {
+                    visible: labelVisible,
+                    labelBackground: {
+                        visible: labelVisible,
+                        style: {
+                            fill: labelBackgroundColor
+                        }
+                    },
+                    style: {
+                        fill: labelColor
+                    }
+                }
+            };
+            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;
                 },
-                label: {
-                    visible: labelVisible,
-                    labelBackground: {
-                        visible: labelVisible,
-                        style: {
-                            fill: labelBackgroundColor
-                        }
-                    },
-                    style: {
-                        fill: labelColor
+                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;
                 }
             };
-            return result;
-        };
+        }
+        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 +8307,11 @@
             annotationPoint_annotationPoint,
             annotationVerticalLine_annotationVerticalLine,
             annotationHorizontalLine_annotationHorizontalLine,
-            annotationArea_annotationArea
+            annotationArea_annotationArea,
+            linearRegressionLine,
+            lowessRegressionLine,
+            polynomialRegressionLine,
+            logisticRegressionLine
         ];
         const pivotScatter = [
             initPivot,
@@ -6879,7 +8325,7 @@
                 datasetScatter,
                 progressive,
                 xLinear,
-                yLinear,
+                pivotAxisStyle(yLinear),
                 scatterSize,
                 labelScatter,
                 tooltipScatter,
@@ -6890,10 +8336,13 @@
                 annotationPoint_annotationPoint,
                 annotationVerticalLine_annotationVerticalLine,
                 annotationHorizontalLine_annotationHorizontalLine,
-                annotationArea_annotationArea
+                annotationArea_annotationArea,
+                linearRegressionLine,
+                lowessRegressionLine
             ]),
             pivotRowDimensions,
             pivotColumnDimensions,
+            pivotTitle,
             colorAdapter(pivotDiscreteLegend, pivotColorLegend)
         ];
         const scatterSpecPipeline = [
@@ -7577,7 +9026,7 @@
                     title: {
                         visible: true
                     },
-                    content: createDimensionContent(measures, foldInfoList[0], unfoldInfo)
+                    content: createDimensionContent(dimensions, measures, foldInfoList[0], unfoldInfo)
                 }
             };
             return result;
@@ -7608,7 +9057,7 @@
                     title: {
                         visible: true
                     },
-                    content: createDimensionContent(measures, foldInfoList[1], unfoldInfo)
+                    content: createDimensionContent(dimensions, measures, foldInfoList[1], unfoldInfo)
                 }
             };
             return result;
@@ -7907,7 +9356,7 @@
                 ]),
                 xBand,
                 yLinearPrimary,
-                yLinearSecondary,
+                pivotAxisStyle(yLinearSecondary),
                 colorAdapter(color_color, linearColor),
                 background_backgroundColor,
                 verticalCrosshairRect,
@@ -7918,6 +9367,7 @@
             ]),
             pivotRowDimensions,
             pivotColumnDimensions,
+            pivotTitle,
             colorAdapter(pivotDiscreteLegend, pivotColorLegend)
         ];
         const dualAxisSpecPipeline = [
@@ -8098,6 +9548,13 @@
                 ...spec,
                 hideIndicatorName: true
             });
+        const addRegionPadding = (spec)=>{
+            const result = {
+                ...spec
+            };
+            if (result.region && result.region.length > 0) result.region[0].padding = 10;
+            return result;
+        };
         const pie = [
             initPie,
             colorAdapter(color_color, linearColor),
@@ -8131,10 +9588,12 @@
                 annotationPoint_annotationPoint,
                 annotationVerticalLine_annotationVerticalLine,
                 annotationHorizontalLine_annotationHorizontalLine,
-                annotationArea_annotationArea
+                annotationArea_annotationArea,
+                addRegionPadding
             ]),
             pivotRowDimensions,
             pivotColumnDimensions,
+            pivotTitle,
             colorAdapter(pivotDiscreteLegend, pivotColorLegend)
         ];
         const pieSpecPipeline = [
@@ -8215,6 +9674,7 @@
             datasetPivot,
             pivotIndicators_pivotIndicators([
                 initDonut,
+                addRegionPadding,
                 colorAdapter(color_color, linearColor),
                 background_backgroundColor,
                 datasetXY,
@@ -8229,6 +9689,7 @@
             ]),
             pivotRowDimensions,
             pivotColumnDimensions,
+            pivotTitle,
             colorAdapter(pivotDiscreteLegend, pivotColorLegend)
         ];
         const donutSpecPipeline = [
@@ -8435,6 +9896,7 @@
             datasetPivot,
             pivotIndicators_pivotIndicators([
                 initRose,
+                addRegionPadding,
                 stackCornerRadius_stackCornerRadius,
                 stackInverse,
                 colorAdapter(color_color, linearColor),
@@ -8449,6 +9911,7 @@
             ]),
             pivotRowDimensions,
             pivotColumnDimensions,
+            pivotTitle,
             colorAdapter(pivotDiscreteLegend, pivotColorLegend)
         ];
         const roseSpecPipeline = [
@@ -8555,6 +10018,7 @@
             datasetPivot,
             pivotIndicators_pivotIndicators([
                 initRoseParallel,
+                addRegionPadding,
                 stackCornerRadius_stackCornerRadius,
                 colorAdapter(color_color, linearColor),
                 background_backgroundColor,
@@ -8572,6 +10036,7 @@
             ]),
             pivotRowDimensions,
             pivotColumnDimensions,
+            pivotTitle,
             colorAdapter(pivotDiscreteLegend, pivotColorLegend)
         ];
         const roseParallelSpecPipeline = [
@@ -8772,6 +10237,7 @@
             datasetPivot,
             pivotIndicators_pivotIndicators([
                 initRadar,
+                addRegionPadding,
                 colorAdapter(color_color, linearColor),
                 background_backgroundColor,
                 datasetXY,
@@ -8788,6 +10254,7 @@
             ]),
             pivotRowDimensions,
             pivotColumnDimensions,
+            pivotTitle,
             colorAdapter(pivotDiscreteLegend, pivotColorLegend)
         ];
         const radarSpecPipeline = [
@@ -9004,6 +10471,7 @@
             ]),
             pivotRowDimensions,
             pivotColumnDimensions,
+            pivotTitle,
             colorAdapter(pivotDiscreteLegend, pivotColorLegend)
         ];
         const funnelSpecPipeline = [
@@ -9310,7 +10778,7 @@
             pivotIndicatorsAsRow,
             datasetPivot,
             pivotIndicators_pivotIndicators([
-                initHeatmap,
+                pivotAxisStyle(initHeatmap),
                 background_backgroundColor,
                 datasetXY,
                 colorAdapter(color_color, linearColor),
@@ -9324,6 +10792,7 @@
             ]),
             pivotRowDimensions,
             pivotColumnDimensions,
+            pivotTitle,
             colorAdapter(pivotDiscreteLegend, pivotColorLegend)
         ];
         const heatmapSpecPipeline = [
@@ -9432,16 +10901,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;
-        };
-        const clamp = clamp_clamp;
         function toNumber(a) {
             return Number(a);
         }
@@ -9669,7 +11128,6 @@
                 datasets.push(newDatasets);
                 datasetReshapeInfo.push(reshapeInfo);
             });
-            console.log(datasets);
             return {
                 ...result,
                 dataset: datasets,
@@ -9874,7 +11332,7 @@
                 datasetBoxplot,
                 progressive,
                 xBand,
-                yLinear,
+                pivotAxisStyle(yLinear),
                 label_label,
                 tooltipBoxplot,
                 colorBarStyleFill(barStyle_barStyle),
@@ -9886,6 +11344,7 @@
             ]),
             pivotRowDimensions,
             pivotColumnDimensions,
+            pivotTitle,
             colorAdapter(pivotDiscreteLegend, pivotColorLegend)
         ];
         const boxplotSpecPipeline = [
@@ -10259,11 +11718,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 +11746,7 @@
             theme_theme,
             markStyle_markStyle,
             annotation_annotation,
-            regressionLine
+            regressionLine_regressionLine
         ];
         const initHistogram = (spec)=>{
             const result = {
@@ -10495,6 +11949,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 +12085,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 +12117,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 +12135,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 +12194,8 @@
             annotationVerticalLine_annotationVerticalLine,
             annotationHorizontalLine_annotationHorizontalLine,
             annotationAreaBand,
-            histogramRegressionLine_histogramRegressionLine
+            kdeRegressionLine,
+            ecdfRegressionLine
         ];
         const pivotHistogram = [
             initPivot,
@@ -10690,7 +12208,7 @@
                 datasetHistogram,
                 progressive,
                 xLinear,
-                yLinear,
+                pivotAxisStyle(yLinear),
                 label_label,
                 tooltipHistogram,
                 colorBarStyleFill(barStyle_barStyle),
@@ -10699,10 +12217,12 @@
                 annotationVerticalLine_annotationVerticalLine,
                 annotationHorizontalLine_annotationHorizontalLine,
                 annotationAreaBand,
-                histogramRegressionLine_histogramRegressionLine
+                kdeRegressionLine,
+                ecdfRegressionLine
             ]),
             pivotRowDimensions,
             pivotColumnDimensions,
+            pivotTitle,
             colorAdapter(pivotDiscreteLegend, pivotColorLegend)
         ];
         const histogramSpecPipeline = [
@@ -10774,11 +12294,15 @@
             ];
         const getLightColor = ()=>({
                 linearColorScheme: getLightLinearColorScheme(),
-                colorScheme: getLightColorScheme()
+                colorScheme: getLightColorScheme(),
+                positiveColor: '#7E5DFF',
+                negativeColor: '#EB3373'
             });
         const getDarkColor = ()=>({
                 linearColorScheme: getDarkLinearColorScheme(),
-                colorScheme: getDarkColorScheme()
+                colorScheme: getDarkColorScheme(),
+                positiveColor: '#7E5DFF',
+                negativeColor: '#EB3373'
             });
         const getDefaultLabel = ()=>({
                 enable: true,
@@ -10846,7 +12370,10 @@
                 headerFontColor: tableConfig.headerFontColor,
                 headerBackgroundColor: 'transparent',
                 hoverHeaderBackgroundColor: tableConfig.hoverHeaderBackgroundColor,
-                hoverHeaderInlineBackgroundColor: tableConfig.hoverHeaderInlineBackgroundColor
+                hoverHeaderInlineBackgroundColor: tableConfig.hoverHeaderInlineBackgroundColor,
+                titleFontColor: tableConfig.headerFontColor,
+                titleFontSize: tableConfig.headerFontSize,
+                titleFontWeight: 'bold'
             });
         const getLightPivotChartGridConfig = ()=>pickPivotChartGridConfig(getLightTableConfig());
         const getDarkPivotChartGridConfig = ()=>pickPivotChartGridConfig(getDarkTableConfig());
@@ -11130,18 +12657,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 +12772,8 @@
                             0
                         ],
                         pivotGrid: getLightPivotChartGridConfig(),
-                        annotation: getLightAnnotation()
+                        annotation: getLightAnnotation(),
+                        regressionLine: getLightRegressionLine()
                     },
                     columnParallel: {
                         ...baseConfig,
@@ -11314,7 +12894,8 @@
                             showValuePercent: false
                         },
                         pivotGrid: getLightPivotChartGridConfig(),
-                        annotation: getLightAnnotation()
+                        annotation: getLightAnnotation(),
+                        regressionLine: getLightRegressionLine()
                     },
                     dualAxis: {
                         ...baseConfig,
@@ -11339,7 +12920,7 @@
                         label: {
                             ...baseConfig.label,
                             showValuePercent: true,
-                            labelLayout: 'labelLine',
+                            labelLayout: 'arc',
                             showDimension: true
                         },
                         pivotGrid: getLightPivotChartGridConfig()
@@ -11349,7 +12930,7 @@
                         label: {
                             ...baseConfig.label,
                             showValuePercent: true,
-                            labelLayout: 'labelLine',
+                            labelLayout: 'arc',
                             showDimension: true
                         },
                         pivotGrid: getLightPivotChartGridConfig()
@@ -11397,7 +12978,7 @@
                         crosshairRect,
                         pivotGrid: getLightPivotChartGridConfig(),
                         annotation: getLightAnnotation(),
-                        histogramRegressionLine: getLightHistogramRegressionLine()
+                        regressionLine: getLightRegressionLine()
                     },
                     boxPlot: {
                         ...baseConfig,
@@ -11460,7 +13041,8 @@
                             0
                         ],
                         pivotGrid: getDarkPivotChartGridConfig(),
-                        annotation: getDarkAnnotation()
+                        annotation: getDarkAnnotation(),
+                        regressionLine: getDarkRegressionLine()
                     },
                     columnParallel: {
                         ...baseConfig,
@@ -11575,7 +13157,8 @@
                             showValuePercent: false
                         },
                         pivotGrid: getDarkPivotChartGridConfig(),
-                        annotation: getDarkAnnotation()
+                        annotation: getDarkAnnotation(),
+                        regressionLine: getDarkRegressionLine()
                     },
                     dualAxis: {
                         ...baseConfig,
@@ -11600,7 +13183,7 @@
                         label: {
                             ...baseConfig.label,
                             showValuePercent: true,
-                            labelLayout: 'labelLine',
+                            labelLayout: 'arc',
                             showDimension: true
                         },
                         pivotGrid: getDarkPivotChartGridConfig()
@@ -11610,7 +13193,7 @@
                         label: {
                             ...baseConfig.label,
                             showValuePercent: true,
-                            labelLayout: 'labelLine',
+                            labelLayout: 'arc',
                             showDimension: true
                         },
                         pivotGrid: getDarkPivotChartGridConfig()
@@ -11658,7 +13241,7 @@
                         crosshairRect: crosshairRect,
                         pivotGrid: getDarkPivotChartGridConfig(),
                         annotation: getDarkAnnotation(),
-                        histogramRegressionLine: getDarkHistogramRegressionLine()
+                        regressionLine: getDarkRegressionLine()
                     },
                     boxPlot: {
                         ...baseConfig,
@@ -15731,7 +17314,10 @@
             outlineBorderLineWidth: schemas_number().nullish(),
             frameCornerRadius: schemas_number().nullish(),
             minChartWidth: schemas_number().nullish(),
-            minChartHeight: schemas_number().nullish()
+            minChartHeight: schemas_number().nullish(),
+            titleFontColor: schemas_string().nullish(),
+            titleFontSize: schemas_number().nullish(),
+            titleFontWeight: schemas_string().nullish()
         });
         const zLineConfig = schemas_object({
             backgroundColor: zBackgroundColor.nullish(),
@@ -15753,7 +17339,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 +17382,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 +17426,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 +17513,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 +17528,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 +17803,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 +17999,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 +18060,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 +18223,7 @@
             customTheme: zCustomThemeConfig,
             annotation: zAnnotation,
             locale: zLocale,
-            histogramRegressionLine: zHistogramRegressionLine.or(schemas_array(zHistogramRegressionLine)).nullish()
+            regressionLine: zRegressionLine
         });
         return __webpack_exports__;
     })());