@visactor/vtable 0.13.0-alpha.4 → 0.13.0

package/dist/vtable.js

@@ -1979,7 +1979,7 @@
         }
     };
 
-    let defaultStyle$6;
+    let defaultStyle$7;
     const STYLE_EVENT_TYPE = {
         CHANGE_STYLE: 'change_style'
     };
@@ -2014,7 +2014,7 @@
             return STYLE_EVENT_TYPE;
         }
         static get DEFAULT() {
-            return defaultStyle$6 ? defaultStyle$6 : (defaultStyle$6 = new Style());
+            return defaultStyle$7 ? defaultStyle$7 : (defaultStyle$7 = new Style());
         }
         constructor(style = {}, bodyStyle = {}) {
             super();
@@ -2199,10 +2199,10 @@
         }
     };
 
-    let defaultStyle$5;
+    let defaultStyle$6;
     let ImageStyle$1 = class ImageStyle extends Style$1 {
         static get DEFAULT() {
-            return defaultStyle$5 ? defaultStyle$5 : (defaultStyle$5 = new ImageStyle());
+            return defaultStyle$6 ? defaultStyle$6 : (defaultStyle$6 = new ImageStyle());
         }
         constructor(style = {}, bodyStyle = {}) {
             super(style, bodyStyle);
@@ -2212,12 +2212,12 @@
         }
     };
 
-    let defaultStyle$4;
+    let defaultStyle$5;
     class TextStyle extends Style$1 {
         _autoWrapText;
         _lineClamp;
         static get DEFAULT() {
-            return defaultStyle$4 ? defaultStyle$4 : (defaultStyle$4 = new TextStyle());
+            return defaultStyle$5 ? defaultStyle$5 : (defaultStyle$5 = new TextStyle());
         }
         constructor(style = {}, bodyStyle = {}) {
             super(style, bodyStyle);
@@ -2260,7 +2260,7 @@
         return StyleClassDef.DEFAULT;
     }
 
-    let defaultStyle$3;
+    let defaultStyle$4;
     const EVENT_TYPE$1 = {
         CHANGE_STYLE: 'change_style'
     };
@@ -2295,7 +2295,7 @@
             return EVENT_TYPE$1;
         }
         static get DEFAULT() {
-            return defaultStyle$3 ? defaultStyle$3 : (defaultStyle$3 = new Style());
+            return defaultStyle$4 ? defaultStyle$4 : (defaultStyle$4 = new Style());
         }
         constructor(style = {}, headerStyle = {}) {
             super();
@@ -2480,12 +2480,12 @@
         }
     }
 
-    let defaultStyle$2;
+    let defaultStyle$3;
     class TextHeaderStyle extends Style {
         _autoWrapText;
         _lineClamp;
         static get DEFAULT() {
-            return defaultStyle$2 ? defaultStyle$2 : (defaultStyle$2 = new TextHeaderStyle());
+            return defaultStyle$3 ? defaultStyle$3 : (defaultStyle$3 = new TextHeaderStyle());
         }
         constructor(style = {}, headerStyle = null) {
             super(style, headerStyle);
@@ -2528,7 +2528,79 @@
         return StyleClass.DEFAULT;
     }
 
+    class Env {
+        static _mode;
+        static get mode() {
+            if (!Env._mode) {
+                Env._mode = defaultMode();
+            }
+            return Env._mode;
+        }
+        static set mode(mode) {
+            Env._mode = mode;
+        }
+        static dpr = 0;
+        static CreateCanvas;
+        static LoadImage;
+        static RequestAnimationFrame;
+        static CancelAnimationFrame;
+        static RegisterCreateCanvas(func) {
+            Env.CreateCanvas = func;
+        }
+        static RegisterLoadImage(func) {
+            Env.LoadImage = func;
+        }
+        static GetCreateCanvasFunc() {
+            if (Env.CreateCanvas) {
+                return Env.CreateCanvas;
+            }
+            if (Env.mode === 'worker') {
+                return (width = 200, height = 200) => new OffscreenCanvas(width, height);
+            }
+            return undefined;
+        }
+        static RegisterRequestAnimationFrame(func) {
+            Env.RequestAnimationFrame = func();
+        }
+        static GetRequestAnimationFrame() {
+            if (Env.RequestAnimationFrame) {
+                return Env.RequestAnimationFrame;
+            }
+            return undefined;
+        }
+        static RegisterCancelAnimationFrame(func) {
+            Env.CancelAnimationFrame = func();
+        }
+        static GetCancelAnimationFrame() {
+            if (Env.CancelAnimationFrame) {
+                return Env.CancelAnimationFrame;
+            }
+            return undefined;
+        }
+    }
+    function defaultMode() {
+        let mode = 'browser';
+        try {
+            if (window.type === 'node') {
+                mode = 'node';
+            }
+            else if (typeof window !== 'undefined' && !window.performance) {
+                mode = 'miniApp';
+            }
+            else if (typeof window === 'undefined') {
+                mode = 'node';
+            }
+        }
+        catch (err) {
+            mode = 'node';
+        }
+        return mode;
+    }
+
     function importStyle$2() {
+        if (Env.mode === 'node') {
+            return;
+        }
         const styleElement = document.createElement('style');
         styleElement.id = 'vtable-style-styleSheet';
         styleElement.textContent = `
@@ -3040,6 +3112,7 @@
         LEGEND_CHANGE: 'legend_change',
         MOUSEENTER_AXIS: 'mouseenter_axis',
         MOUSELEAVE_AXIS: 'mouseleave_axis',
+        CHECKBOX_STATE_CHANGE: 'checkbox_state_change',
         AFTER_RENDER: 'after_render',
         INITIALIZED: 'initialized'
     };
@@ -3178,75 +3251,6 @@
         return debounced;
     }
 
-    class Env {
-        static _mode;
-        static get mode() {
-            if (!Env._mode) {
-                Env._mode = defaultMode();
-            }
-            return Env._mode;
-        }
-        static set mode(mode) {
-            Env._mode = mode;
-        }
-        static dpr = 0;
-        static CreateCanvas;
-        static LoadImage;
-        static RequestAnimationFrame;
-        static CancelAnimationFrame;
-        static RegisterCreateCanvas(func) {
-            Env.CreateCanvas = func;
-        }
-        static RegisterLoadImage(func) {
-            Env.LoadImage = func;
-        }
-        static GetCreateCanvasFunc() {
-            if (Env.CreateCanvas) {
-                return Env.CreateCanvas;
-            }
-            if (Env.mode === 'worker') {
-                return (width = 200, height = 200) => new OffscreenCanvas(width, height);
-            }
-            return undefined;
-        }
-        static RegisterRequestAnimationFrame(func) {
-            Env.RequestAnimationFrame = func();
-        }
-        static GetRequestAnimationFrame() {
-            if (Env.RequestAnimationFrame) {
-                return Env.RequestAnimationFrame;
-            }
-            return undefined;
-        }
-        static RegisterCancelAnimationFrame(func) {
-            Env.CancelAnimationFrame = func();
-        }
-        static GetCancelAnimationFrame() {
-            if (Env.CancelAnimationFrame) {
-                return Env.CancelAnimationFrame;
-            }
-            return undefined;
-        }
-    }
-    function defaultMode() {
-        let mode = 'browser';
-        try {
-            if (window.type === 'node') {
-                mode = 'node';
-            }
-            else if (typeof window !== 'undefined' && !window.performance) {
-                mode = 'miniApp';
-            }
-            else if (typeof window === 'undefined') {
-                mode = 'node';
-            }
-        }
-        catch (err) {
-            mode = 'node';
-        }
-        return mode;
-    }
-
     let idCount = 1;
     class ResizeObserver {
         resizeTime = 100;
@@ -3693,14 +3697,6 @@
                 endColor: 'rgba(00, 24, 47, 0)'
             }
         },
-        menuStyle: {
-            color: '#000',
-            highlightColor: '#2E68CF',
-            fontSize: 12,
-            fontFamily: 'sans-serif',
-            highlightFont: '12px sans-serif',
-            hoverBgColor: '#EEE'
-        },
         selectionStyle: {
             cellBgColor: 'rgba(255, 255, 255, 0.1)',
             cellBorderColor: '#4284FF',
@@ -3765,14 +3761,6 @@
                 endColor: '#CBDCFE'
             }
         },
-        menuStyle: {
-            color: '#000',
-            highlightColor: '#2E68CF',
-            fontSize: 12,
-            fontFamily: 'sans-serif',
-            highlightFont: '12px sans-serif',
-            hoverBgColor: '#EEE'
-        },
         selectionStyle: {
             cellBgColor: 'rgba(0, 0, 255,0.1)'
         }
@@ -3876,14 +3864,6 @@
                 endColor: 'rgba(00, 24, 47, 0)'
             }
         },
-        menuStyle: {
-            color: '#000',
-            highlightColor: '#2E68CF',
-            fontSize: 12,
-            fontFamily: 'sans-serif',
-            highlightFont: '12px sans-serif',
-            hoverBgColor: '#EEE'
-        },
         selectionStyle: {
             cellBgColor: 'rgba(0, 0, 255,0.1)',
             cellBorderLineWidth: 2,
@@ -3962,14 +3942,6 @@
                 endColor: 'rgba(225, 228, 232, 0.6)'
             }
         },
-        menuStyle: {
-            color: '#000',
-            highlightColor: '#2E68CF',
-            fontSize: 12,
-            fontFamily: 'sans-serif',
-            highlightFont: '12px sans-serif',
-            hoverBgColor: '#EEE'
-        },
         selectionStyle: {
             cellBgColor: 'rgba(0, 0, 255,0.1)',
             cellBorderLineWidth: 2,
@@ -4027,9 +3999,8 @@
 
     const themes$2 = {};
 
-    const DEFAULTFONT = '16px sans-serif';
     const DEFAULTFONTSIZE = 16;
-    const DEFAULTFONTFAMILY = 'sans-serif';
+    const DEFAULTFONTFAMILY = 'Arial,sans-serif';
     const DEFAULTBGCOLOR = '#FFF';
     const DEFAULTBORDERCOLOR = '#000';
     const DEFAULTBORDERLINEWIDTH = 1;
@@ -4343,8 +4314,11 @@
                 const { obj, superTheme } = this.internalTheme;
                 const tooltip = ingoreNoneValueMerge({}, superTheme.tooltipStyle, obj.tooltipStyle);
                 this._tooltip = {
-                    get font() {
-                        return tooltip.font ?? DEFAULTFONT;
+                    get fontFamily() {
+                        return tooltip.fontFamily ?? DEFAULTFONTFAMILY;
+                    },
+                    get fontSize() {
+                        return tooltip.fontSize ?? DEFAULTFONTSIZE;
                     },
                     get bgColor() {
                         return tooltip.bgColor ?? '#000';
@@ -28729,6 +28703,13 @@
     function identity(x) {
       return x;
     }
+    const logNegative = x => -Math.log(-x);
+    const expNegative = x => -Math.exp(-x);
+    const pow10 = x => isFinite(x) ? Math.pow(10, x) : x < 0 ? 0 : x;
+    const powp = base => 10 === base ? pow10 : base === Math.E ? Math.exp : x => Math.pow(base, x);
+    const logp = base => base === Math.E ? Math.log : 10 === base ? Math.log10 : 2 === base ? Math.log2 : (base = Math.log(base), x => Math.log(x) / base);
+    const symlog = c => x => Math.sign(x) * Math.log1p(Math.abs(x / c));
+    const symexp = c => x => Math.sign(x) * Math.expm1(Math.abs(x)) * c;
     function normalize(a, b) {
       if (a = Number(a), b = Number(b), b -= a) return x => (x - a) / b;
       const result = Number.isNaN(b) ? NaN : .5;
@@ -28767,6 +28748,25 @@
         return r[i](d[i](x));
       };
     }
+    const nice = (domain, options) => {
+      const newDomain = domain.slice();
+      let startIndex = 0,
+        endIndex = newDomain.length - 1,
+        x0 = newDomain[startIndex],
+        x1 = newDomain[endIndex];
+      return x1 < x0 && ([startIndex, endIndex] = [endIndex, startIndex], [x0, x1] = [x1, x0]), newDomain[startIndex] = options.floor(x0), newDomain[endIndex] = options.ceil(x1), newDomain;
+    };
+    const niceNumber = function (value) {
+      let round = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : !1;
+      const exponent = Math.floor(Math.log10(value)),
+        fraction = value / Math.pow(10, exponent);
+      let niceFraction;
+      return niceFraction = round ? fraction < 1.5 ? 1 : fraction < 3 ? 2 : fraction < 7 ? 5 : 10 : fraction <= 1 ? 1 : fraction <= 2 ? 2 : fraction <= 5 ? 5 : 10, niceFraction * Math.pow(10, exponent);
+    };
+    const restrictNumber = (value, domain) => {
+      let min, max;
+      return domain[0] < domain[1] ? (min = domain[0], max = domain[1]) : (min = domain[1], max = domain[0]), Math.min(Math.max(value, min), max);
+    };
 
     function ticks$2(start, stop, count, allowExcessive) {
       let reverse;
@@ -29199,6 +29199,25 @@
         domainValidator: domainValidator
       };
     }
+    const fixPrecision = (start, stop, value) => Math.abs(stop - start) < 1 ? +value.toFixed(1) : Math.round(+value);
+    const ticksBaseTransform = memoize((start, stop, count, base, transformer, untransformer) => {
+      const ticksResult = [],
+        ticksMap = {},
+        startExp = transformer(start),
+        stopExp = transformer(stop);
+      let ticksExp = [];
+      if (Number.isInteger(base)) ticksExp = ticks$1(startExp, stopExp, count);else {
+        const stepExp = (stopExp - startExp) / (count - 1);
+        for (let i = 0; i < count; i++) ticksExp.push(startExp + i * stepExp);
+      }
+      return ticksExp.forEach(tl => {
+        const power = untransformer(tl),
+          nicePower = Number.isInteger(base) ? fixPrecision(start, stop, power) : fixPrecision(start, stop, niceNumber(power)),
+          scopePower = fixPrecision(start, stop, restrictNumber(nicePower, [start, stop]));
+        !ticksMap[scopePower] && !isNaN(scopePower) && ticksExp.length > 1 && (ticksMap[scopePower] = 1, ticksResult.push(scopePower));
+      }), ticksResult;
+    });
+    const forceTicksBaseTransform = memoize((start, stop, count, transformer, untransformer) => forceTicks(transformer(start), transformer(stop), count).map(te => niceNumber(untransformer(te))));
 
     class LinearScale extends ContinuousScale {
       constructor() {
@@ -29278,12 +29297,166 @@
       }
     }
 
+    function reflect(f) {
+      return x => -f(-x);
+    }
+    class LogScale extends ContinuousScale {
+      constructor() {
+        super(logp(10), powp(10)), this.type = ScaleEnum$1.Log, this._logs = this.transformer, this._pows = this.untransformer, this._domain = [1, 10], this._base = 10;
+      }
+      clone() {
+        return new LogScale().domain(this._domain, !0).range(this._range, !0).unknown(this._unknown).clamp(this.clamp(), null, !0).interpolate(this._interpolate, !0).base(this._base);
+      }
+      rescale(slience) {
+        var _a;
+        if (slience) return this;
+        super.rescale();
+        const logs = logp(this._base),
+          pows = powp(this._base);
+        return (null !== (_a = this._niceDomain) && void 0 !== _a ? _a : this._domain)[0] < 0 ? (this._logs = reflect(logs), this._pows = reflect(pows), this.transformer = logNegative, this.untransformer = expNegative) : (this._logs = logs, this._pows = pows, this.transformer = logs, this.untransformer = pows), this;
+      }
+      base(_, slience) {
+        return arguments.length ? (this._base = _, this.rescale(slience)) : this._base;
+      }
+      tickFormat() {
+        return identity;
+      }
+      d3Ticks() {
+        let count = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 10;
+        const d = this.domain();
+        let u = d[0],
+          v = d[d.length - 1];
+        const r = v < u;
+        r && ([u, v] = [v, u]);
+        let k,
+          t,
+          i = this._logs(u),
+          j = this._logs(v),
+          z = [];
+        if (!(this._base % 1) && j - i < count) {
+          if (i = Math.floor(i), j = Math.ceil(j), u > 0) {
+            for (; i <= j; ++i) for (k = 1; k < this._base; ++k) if (t = i < 0 ? k / this._pows(-i) : k * this._pows(i), !(t < u)) {
+              if (t > v) break;
+              z.push(t);
+            }
+          } else for (; i <= j; ++i) for (k = this._base - 1; k >= 1; --k) if (t = i > 0 ? k / this._pows(-i) : k * this._pows(i), !(t < u)) {
+            if (t > v) break;
+            z.push(t);
+          }
+          2 * z.length < count && (z = ticks$1(u, v, count));
+        } else z = ticks$1(i, j, Math.min(j - i, count)).map(this._pows);
+        return r ? z.reverse() : z;
+      }
+      ticks() {
+        let count = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 10;
+        const d = this.calculateVisibleDomain(this._range);
+        return ticksBaseTransform(d[0], d[d.length - 1], count, this._base, this.transformer, this.untransformer);
+      }
+      forceTicks() {
+        let count = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 10;
+        const d = this.calculateVisibleDomain(this._range);
+        return forceTicksBaseTransform(d[0], d[d.length - 1], count, this.transformer, this.untransformer);
+      }
+      stepTicks(step) {
+        const d = this.calculateVisibleDomain(this._range);
+        return forceTicksBaseTransform(d[0], d[d.length - 1], step, this.transformer, this.untransformer);
+      }
+      nice() {
+        let option = arguments.length > 1 ? arguments[1] : undefined;
+        var _a, _b;
+        const originalDomain = this._domain;
+        let niceMinMax = [],
+          niceType = null;
+        if (option) {
+          const res = parseNiceOptions(originalDomain, option);
+          if (niceMinMax = res.niceMinMax, this._domainValidator = res.domainValidator, niceType = res.niceType, res.niceDomain) return this._niceDomain = res.niceDomain, this.rescale(), this;
+        } else niceType = "all";
+        if (niceType) {
+          const niceDomain = nice(originalDomain.slice(), {
+            floor: x => this._pows(Math.floor(this._logs(x))),
+            ceil: x => this._pows(Math.ceil(this._logs(x)))
+          });
+          return "min" === niceType ? niceDomain[niceDomain.length - 1] = null !== (_a = niceMinMax[1]) && void 0 !== _a ? _a : niceDomain[niceDomain.length - 1] : "max" === niceType && (niceDomain[0] = null !== (_b = niceMinMax[0]) && void 0 !== _b ? _b : niceDomain[0]), this._niceDomain = niceDomain, this.rescale(), this;
+        }
+        return this;
+      }
+      niceMin() {
+        const maxD = this._domain[this._domain.length - 1];
+        this.nice();
+        const niceDomain = this._domain.slice();
+        return this._domain && (niceDomain[niceDomain.length - 1] = maxD, this._niceDomain = niceDomain, this.rescale()), this;
+      }
+      niceMax() {
+        const minD = this._domain[0];
+        this.nice();
+        const niceDomain = this._domain.slice();
+        return this._domain && (niceDomain[0] = minD, this._niceDomain = niceDomain, this.rescale()), this;
+      }
+    }
+
     class PointScale extends BandScale {
       constructor(slience) {
         super(!1), this.type = ScaleEnum$1.Point, this._padding = 0, this.paddingInner(1, slience), this.padding = this.paddingOuter, this.paddingInner = void 0, this.paddingOuter = void 0;
       }
     }
 
+    class SymlogScale extends LinearScale {
+      constructor() {
+        super(symlog(1), symexp(1)), this.type = ScaleEnum$1.Symlog, this._const = 1;
+      }
+      clone() {
+        return new SymlogScale().domain(this._domain, !0).range(this._range, !0).unknown(this._unknown).clamp(this.clamp(), null, !0).interpolate(this._interpolate, !0).constant(this._const);
+      }
+      constant(_, slience) {
+        return arguments.length ? (this._const = _, this.transformer = symlog(_), this.untransformer = symexp(_), this.rescale(slience)) : this._const;
+      }
+      ticks() {
+        let count = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 10;
+        const d = this.calculateVisibleDomain(this._range);
+        return ticksBaseTransform(d[0], d[d.length - 1], count, this._const, this.transformer, this.untransformer);
+      }
+      forceTicks() {
+        let count = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 10;
+        const d = this.calculateVisibleDomain(this._range);
+        return forceTicksBaseTransform(d[0], d[d.length - 1], count, this.transformer, this.untransformer);
+      }
+      stepTicks(step) {
+        const d = this.calculateVisibleDomain(this._range);
+        return forceTicksBaseTransform(d[0], d[d.length - 1], step, this.transformer, this.untransformer);
+      }
+      nice() {
+        let option = arguments.length > 1 ? arguments[1] : undefined;
+        var _a, _b;
+        const originalDomain = this._domain;
+        let niceMinMax = [],
+          niceType = null;
+        if (option) {
+          const res = parseNiceOptions(originalDomain, option);
+          if (niceMinMax = res.niceMinMax, this._domainValidator = res.domainValidator, niceType = res.niceType, res.niceDomain) return this._niceDomain = res.niceDomain, this.rescale(), this;
+        } else niceType = "all";
+        if (niceType) {
+          const niceDomain = nice(originalDomain.slice(), {
+            floor: x => this.untransformer(Math.floor(this.transformer(x))),
+            ceil: x => this.untransformer(Math.ceil(this.transformer(x)))
+          });
+          return "min" === niceType ? niceDomain[niceDomain.length - 1] = null !== (_a = niceMinMax[1]) && void 0 !== _a ? _a : niceDomain[niceDomain.length - 1] : "max" === niceType && (niceDomain[0] = null !== (_b = niceMinMax[0]) && void 0 !== _b ? _b : niceDomain[0]), this._niceDomain = niceDomain, this.rescale(), this;
+        }
+        return this;
+      }
+      niceMin() {
+        const maxD = this._domain[this._domain.length - 1];
+        this.nice();
+        const niceDomain = this._domain.slice();
+        return this._domain && (niceDomain[niceDomain.length - 1] = maxD, this._niceDomain = niceDomain, this.rescale()), this;
+      }
+      niceMax() {
+        const minD = this._domain[0];
+        this.nice();
+        const niceDomain = this._domain.slice();
+        return this._domain && (niceDomain[0] = minD, this._niceDomain = niceDomain, this.rescale()), this;
+      }
+    }
+
     var SLIDER_ELEMENT_NAME;
     !function (SLIDER_ELEMENT_NAME) {
       SLIDER_ELEMENT_NAME.innerView = "innerView", SLIDER_ELEMENT_NAME.railContainer = "sliderRailContainer", SLIDER_ELEMENT_NAME.rail = "sliderRail", SLIDER_ELEMENT_NAME.startText = "sliderStartText", SLIDER_ELEMENT_NAME.endText = "sliderEndText", SLIDER_ELEMENT_NAME.startHandler = "sliderStartHandler", SLIDER_ELEMENT_NAME.startHandlerText = "startHandlerText", SLIDER_ELEMENT_NAME.endHandler = "sliderEndHandler", SLIDER_ELEMENT_NAME.endHandlerText = "sliderEndHandlerText", SLIDER_ELEMENT_NAME.track = "sliderTrack", SLIDER_ELEMENT_NAME.trackContainer = "sliderTrackContainer";
@@ -30168,6 +30341,106 @@
       }
     };
 
+    const svg = '<svg width="200" height="200" viewBox="0 0 1024 1024" fill="#fff" xmlns="http://www.w3.org/2000/svg"><path d="M877.44815445 206.10060629a64.72691371 64.72691371 0 0 0-95.14856334 4.01306852L380.73381888 685.46812814 235.22771741 533.48933518a64.72691371 64.72691371 0 0 0-92.43003222-1.03563036l-45.82665557 45.82665443a64.72691371 64.72691371 0 0 0-0.90617629 90.61767965l239.61903446 250.10479331a64.72691371 64.72691371 0 0 0 71.19960405 15.14609778 64.33855261 64.33855261 0 0 0 35.08198741-21.23042702l36.24707186-42.71976334 40.5190474-40.77795556-3.36579926-3.49525333 411.40426297-486.74638962a64.72691371 64.72691371 0 0 0-3.88361443-87.64024149l-45.3088404-45.43829334z"></path></svg>';
+    class CheckBox extends AbstractComponent {
+      constructor(attributes) {
+        super(merge$1({}, CheckBox.defaultAttributes, attributes)), this.renderGroup(), this.onBeforeAttributeUpdate = (val, attributes, key) => {
+          "interactive" in val && this.setAttribute("pickable", val.interactive), "disabled" in val && this.setAttribute("cursor", val.disable ? this.attribute.disableCursor : this.attribute.cursor);
+        }, this.addEventListener("click", this.handleClick);
+      }
+      render() {
+        this.removeAllChild(), this.renderBox(), this.renderIcon(), this.renderText(), this.layout();
+      }
+      renderBox() {
+        this._box = new Rect$1(merge$1({}, this.attribute.box)), this.attribute.checked && this.attribute.disabled ? this._box.setAttributes({
+          fill: this.attribute.box.disableCheckedFill,
+          stroke: this.attribute.box.disableCheckedStroke
+        }) : this.attribute.checked && this._box.setAttributes({
+          fill: this.attribute.box.checkedFill,
+          stroke: this.attribute.box.checkedStroke
+        }), this.appendChild(this._box);
+      }
+      renderIcon() {
+        this._icon = new Image$3(merge$1({}, this.attribute.icon)), this.attribute.checked || this._icon.setAttribute("visible", !1), this.appendChild(this._icon);
+      }
+      renderText() {
+        this._text = new WrapText(merge$1({}, this.attribute.text)), this.attribute.disabled && this._text.setAttribute("fill", this.attribute.text.disableFill), this.appendChild(this._text);
+      }
+      renderGroup() {
+        this.attribute.interactive || this.setAttribute("pickable", !1), this.attribute.disabled && this.setAttribute("cursor", this.attribute.disableCursor);
+      }
+      layout() {
+        const boxHeight = this.attribute.box.height,
+          iconHeight = this.attribute.icon.height,
+          textHeight = this._text.AABBBounds.height(),
+          maxHeight = Math.max(boxHeight, iconHeight, textHeight),
+          boxY = maxHeight / 2 - boxHeight / 2,
+          iconY = maxHeight / 2 - iconHeight / 2,
+          textY = maxHeight / 2 - textHeight / 2,
+          boxWidth = this.attribute.box.width,
+          iconWidth = this.attribute.icon.width,
+          maxWidth = Math.max(boxWidth, iconWidth),
+          boxX = maxWidth / 2 - boxWidth / 2,
+          iconX = maxWidth / 2 - iconWidth / 2,
+          textX = maxWidth + this.attribute.spaceBetweenTextAndIcon;
+        this._box.setAttributes({
+          x: boxX,
+          y: boxY
+        }), this._icon.setAttributes({
+          x: iconX,
+          y: iconY
+        }), this._text.setAttributes({
+          x: textX,
+          y: textY
+        });
+      }
+      handleClick() {
+        var _a;
+        if (this.attribute.disabled) return;
+        this.attribute.checked ? this.setAttribute("checked", !1) : this.setAttribute("checked", !0);
+        const changeEvent = new CustomEvent$1("checkbox_state_change", {
+          eventType: "checkbox_state_change",
+          checked: this.attribute.checked
+        });
+        changeEvent.manager = null === (_a = this.stage) || void 0 === _a ? void 0 : _a.eventSystem.manager, this.dispatchEvent(changeEvent);
+      }
+    }
+    CheckBox.defaultAttributes = {
+      interactive: !0,
+      disabled: !1,
+      checked: !1,
+      cursor: "pointer",
+      disableCursor: "not-allowed",
+      spaceBetweenTextAndIcon: 8,
+      text: {
+        text: "text",
+        fontSize: 14,
+        fill: "#000",
+        disableFill: "rgb(201,205,212)",
+        textBaseline: "top",
+        pickable: !1
+      },
+      icon: {
+        image: svg,
+        width: 10,
+        height: 10,
+        pickable: !1
+      },
+      box: {
+        width: 14,
+        height: 14,
+        cornerRadius: 2,
+        fill: "#fff",
+        stroke: "rgb(229,230,235)",
+        disableFill: "rgb(242,243,245)",
+        checkedFill: "rgb(22, 93, 255)",
+        checkedStroke: "rgb(22, 93, 255)",
+        disableCheckedFill: "rgb(148, 191, 255)",
+        disableCheckedStroke: "rgb(148, 191, 255)",
+        pickable: !1
+      }
+    };
+
     function transformLegendTitleAttributes(title) {
         const transformedTitle = {
             ...title
@@ -35751,11 +36024,21 @@
         forceTickCount;
         tickCount;
         niceType;
-        constructor() {
-            this._scale = new LinearScale();
+        type;
+        constructor(type) {
+            this.type = type ?? 'linear';
+            if (type === 'log') {
+                this._scale = new LogScale();
+            }
+            else if (type === 'symlog') {
+                this._scale = new SymlogScale();
+            }
+            else {
+                this._scale = new LinearScale();
+            }
             this._scales = [this._scale];
         }
-        setExtraAttrFromSpec(nice, zero, range, expand) {
+        setExtraAttrFromSpec(nice, zero, range, expand, base, constant) {
             this.nice = false;
             this.zero = zero;
             if (this.zero) {
@@ -35764,11 +36047,39 @@
             }
             this.domain = range;
             this.expand = expand;
+            if (this.type === 'log') {
+                this._scale.base(base ?? 10);
+            }
+            else if (this.type === 'symlog') {
+                this._scale.constant(constant ?? 10);
+            }
         }
         transformScaleDomain() {
-            this.setScaleNice();
+            if (this.type === 'symlog' || this.type === 'log') ;
+            else {
+                this.setScaleNice();
+            }
         }
         setScaleNice() {
+            if (this.type === 'log') {
+                this.setLogScaleNice();
+            }
+            else {
+                this.setLinearScaleNice();
+            }
+        }
+        setLogScaleNice() {
+            if (isNil$5(this.domain?.min) && isNil$5(this.domain?.max)) {
+                this.nice && this._scale.nice();
+            }
+            else if (isValid$6(this.domain?.min) && isNil$5(this.domain?.max)) {
+                this.nice && this._scale.niceMax();
+            }
+            else if (isNil$5(this.domain?.min) && isValid$6(this.domain?.max)) {
+                this.nice && this._scale.niceMin();
+            }
+        }
+        setLinearScaleNice() {
             let tickCount = this.forceTickCount ?? this.tickCount ?? 10;
             if (this.niceType === 'accurateFirst') {
                 tickCount = Math.max(10, tickCount);
@@ -36067,7 +36378,7 @@
         }
         initScale() {
             const option = this.option;
-            if (this.type === 'band') {
+            if (this.type === 'band' || this.type === 'point') {
                 this.scale = new BandAxisScale();
                 this.scale.bandPadding = option.bandPadding;
                 this.scale.paddingInner = option.paddingInner;
@@ -36076,9 +36387,9 @@
                 this.scale.updateScaleDomain(this.data);
                 this.updateScaleRange();
             }
-            else if (this.type === 'linear' || this.type === 'time') {
-                this.scale = new LinearAxisScale();
-                this.scale.setExtraAttrFromSpec(option.nice, option.zero, option.range, option.expand);
+            else if (this.type === 'linear' || this.type === 'time' || this.type === 'log' || this.type === 'symlog') {
+                this.scale = new LinearAxisScale(this.type);
+                this.scale.setExtraAttrFromSpec(option.nice, option.zero, option.range, option.expand, option.base, option.constant);
                 this.scale.transformScaleDomain();
                 this.scale.updateScaleDomain();
                 this.updateScaleRange();
@@ -39744,7 +40055,24 @@
             min = Math.min(min, 0);
             max = Math.max(max, 0);
         }
-        const scale = new LinearScale();
+        if (isNumber$6(axisOption?.min)) {
+            min = axisOption.min;
+        }
+        if (isNumber$6(axisOption?.max)) {
+            max = axisOption.max;
+        }
+        let scale;
+        if (axisOption?.type === 'log') {
+            scale = new LogScale();
+            scale.base(axisOption?.base ?? 10);
+        }
+        else if (axisOption?.type === 'symlog') {
+            scale = new SymlogScale();
+            scale.constant(axisOption?.constant ?? 10);
+        }
+        else {
+            scale = new LinearScale();
+        }
         scale.domain([min, max], !!axisOption?.nice);
         if (axisOption?.nice && !isZeroAlign) {
             let tickCount = axisOption.tick?.forceTickCount ?? axisOption.tick?.tickCount ?? 10;
@@ -39802,15 +40130,21 @@
                 range.max = !isNaN(niceRange[1]) ? niceRange[1] : 1;
                 if (isNumber$6(axisOption?.min)) {
                     range.min = axisOption.min;
+                    if (range.min > 0) {
+                        axisOption.zero = false;
+                    }
                 }
                 if (isNumber$6(axisOption?.max)) {
                     range.max = axisOption.max;
+                    if (range.max < 0) {
+                        axisOption.zero = false;
+                    }
                 }
                 return merge$1({
                     range: range
                 }, axisOption, {
                     orient: 'top',
-                    type: 'linear',
+                    type: axisOption?.type || 'linear',
                     label: {
                         flush: true
                     },
@@ -39846,9 +40180,15 @@
                 range.max = !isNaN(niceRange[1]) ? niceRange[1] : 1;
                 if (isNumber$6(axisOption?.min)) {
                     range.min = axisOption.min;
+                    if (range.min > 0) {
+                        axisOption.zero = false;
+                    }
                 }
                 if (isNumber$6(axisOption?.max)) {
                     range.max = axisOption.max;
+                    if (range.max < 0) {
+                        axisOption.zero = false;
+                    }
                 }
                 return merge$1({
                     title: {
@@ -39858,7 +40198,7 @@
                     range: range
                 }, axisOption, {
                     orient: 'bottom',
-                    type: 'linear',
+                    type: axisOption?.type || 'linear',
                     label: {
                         flush: true
                     },
@@ -39920,9 +40260,15 @@
                 range.max = !isNaN(niceRange[1]) ? niceRange[1] : 1;
                 if (isNumber$6(axisOption?.min)) {
                     range.min = axisOption.min;
+                    if (range.min > 0) {
+                        axisOption.zero = false;
+                    }
                 }
                 if (isNumber$6(axisOption?.max)) {
                     range.max = axisOption.max;
+                    if (range.max < 0) {
+                        axisOption.zero = false;
+                    }
                 }
                 return merge$1({
                     title: {
@@ -39933,7 +40279,7 @@
                     range: range
                 }, axisOption, {
                     orient: 'left',
-                    type: 'linear',
+                    type: axisOption?.type || 'linear',
                     label: {
                         flush: true
                     },
@@ -39962,9 +40308,15 @@
                 range.max = !isNaN(niceRange[1]) ? niceRange[1] : 1;
                 if (isNumber$6(axisOption?.min)) {
                     range.min = axisOption.min;
+                    if (range.min > 0) {
+                        axisOption.zero = false;
+                    }
                 }
                 if (isNumber$6(axisOption?.max)) {
                     range.max = axisOption.max;
+                    if (range.max < 0) {
+                        axisOption.zero = false;
+                    }
                 }
                 return merge$1({
                     range: range,
@@ -39973,7 +40325,7 @@
                     }
                 }, axisOption, {
                     orient: 'right',
-                    type: 'linear',
+                    type: axisOption?.type || 'linear',
                     label: {
                         flush: true
                     },
@@ -41101,6 +41453,7 @@
     })(MenuType || (MenuType = {}));
     const menuStyle = {
         fontSize: 12,
+        fontFamily: 'Arial,sans-serif',
         color: '#000',
         highlightColor: '#2E68CF',
         hoverBgColor: '#EEE',
@@ -41242,6 +41595,7 @@
                     text,
                     textBaseline: 'top',
                     fontSize: menuStyle.fontSize,
+                    fontFamily: menuStyle.fontFamily,
                     pickable: false,
                     maxLineWidth: menuStyle.maxLineWidth,
                     ellipsis: '…'
@@ -42094,7 +42448,8 @@
             if (!params.chartInstance) {
                 params.chartInstance = this.chartInstance = new params.ClassType(params.spec, {
                     renderCanvas: params.canvas,
-                    mode: 'desktop-browser',
+                    mode: this.attribute.mode === 'node' ? 'node' : 'desktop-browser',
+                    modeParams: this.attribute.modeParams,
                     canvasControled: false,
                     viewBox: { x1: 0, x2: 0, y1: 0, y2: 0 },
                     interactive: false,
@@ -42168,6 +42523,12 @@
         static temp = 1;
         deactivate() {
             this.active = false;
+            this.activeChartInstance.updateViewBox({
+                x1: -1000,
+                x2: -800,
+                y1: -1000,
+                y2: -800
+            }, false, false);
             this.activeChartInstance.release();
             this.activeChartInstance = null;
         }
@@ -43321,6 +43682,8 @@
             x: padding[3],
             y: padding[0],
             canvas: table.canvas,
+            mode: table.options.mode,
+            modeParams: table.options.modeParams,
             spec: chartSpec,
             ClassType,
             width: width - padding[3] - padding[1],
@@ -43505,6 +43868,111 @@
         });
     }
 
+    function createCheckboxCellGroup(cellGroup, columnGroup, xOrigin, yOrigin, col, row, colWidth, width, height, padding, textAlign, textBaseline, table, cellTheme, define) {
+        if (!cellGroup) {
+            cellGroup = new Group({
+                x: xOrigin,
+                y: yOrigin,
+                width,
+                height,
+                lineWidth: cellTheme?.group?.lineWidth ?? undefined,
+                fill: cellTheme?.group?.fill ?? undefined,
+                stroke: cellTheme?.group?.stroke ?? undefined,
+                strokeArrayWidth: cellTheme?.group?.strokeArrayWidth ?? undefined,
+                strokeArrayColor: cellTheme?.group?.strokeArrayColor ?? undefined,
+                cursor: cellTheme?.group?.cursor ?? undefined,
+                lineCap: 'square',
+                clip: true
+            });
+            cellGroup.role = 'cell';
+            cellGroup.col = col;
+            cellGroup.row = row;
+            columnGroup?.addChild(cellGroup);
+        }
+        const checkboxComponent = createCheckbox(col, row, colWidth, width, height, padding, cellTheme, define, table);
+        if (checkboxComponent) {
+            cellGroup.appendChild(checkboxComponent);
+        }
+        checkboxComponent.render();
+        width -= padding[1] + padding[3];
+        height -= padding[0] + padding[2];
+        if (textAlign === 'center') {
+            checkboxComponent.setAttribute('x', padding[3] + (width - checkboxComponent.AABBBounds.width()) / 2);
+        }
+        else if (textAlign === 'right') {
+            checkboxComponent.setAttribute('x', padding[3] + width - checkboxComponent.AABBBounds.width());
+        }
+        else {
+            checkboxComponent.setAttribute('x', padding[3]);
+        }
+        if (textBaseline === 'middle') {
+            checkboxComponent.setAttribute('y', padding[0] + (height - checkboxComponent.AABBBounds.height()) / 2);
+        }
+        else if (textBaseline === 'bottom') {
+            checkboxComponent.setAttribute('y', padding[0] + height - checkboxComponent.AABBBounds.height());
+        }
+        else {
+            checkboxComponent.setAttribute('y', padding[0]);
+        }
+        return cellGroup;
+    }
+    function createCheckbox(col, row, colWidth, cellWidth, cellHeight, padding, cellTheme, define, table) {
+        const value = table.getCellValue(col, row);
+        const dataValue = table.getCellOriginValue(col, row);
+        let isChecked;
+        let isDisabled;
+        let text = value;
+        if (isObject$4(value)) {
+            isChecked = value.checked;
+            isDisabled = value.disable;
+            text = value.text;
+        }
+        const hierarchyOffset = getHierarchyOffset(col, row, table);
+        const cellStyle = table._getCellStyle(col, row);
+        const autoWrapText = cellStyle.autoWrapText ?? table.internalProps.autoWrapText;
+        const { lineClamp } = cellStyle;
+        const { checked, disable } = define;
+        const globalChecked = getOrApply(checked, {
+            col,
+            row,
+            table,
+            context: null,
+            value,
+            dataValue
+        });
+        const globalDisable = getOrApply(disable, {
+            col,
+            row,
+            table,
+            context: null,
+            value,
+            dataValue
+        });
+        const autoColWidth = colWidth === 'auto';
+        const autoRowHeight = table.heightMode === 'autoHeight';
+        const attribute = {
+            text: text.length === 1 && !autoWrapText ? text[0] : text,
+            maxLineWidth: autoColWidth ? Infinity : cellWidth - (padding[1] + padding[3] + hierarchyOffset),
+            textBaseline: 'top',
+            autoWrapText,
+            lineClamp,
+            wordBreak: 'break-word',
+            heightLimit: autoRowHeight ? -1 : cellHeight - (padding[0] + padding[2]),
+            pickable: false,
+            dx: hierarchyOffset
+        };
+        const testAttribute = cellTheme.text ? Object.assign({}, cellTheme.text, attribute) : attribute;
+        const checkbox = new CheckBox({
+            x: 0,
+            y: 0,
+            text: testAttribute,
+            checked: isChecked ?? globalChecked ?? false,
+            disabled: isDisabled ?? globalDisable ?? false
+        });
+        checkbox.name = 'checkbox';
+        return checkbox;
+    }
+
     function createCell(type, define, table, col, row, colWidth, cellWidth, cellHeight, columnGroup, y, padding, textAlign, textBaseline, mayHaveIcon, isMerge, range, cellTheme) {
         let bgColorFunc;
         if (table.internalProps?.dataConfig?.mappingRules && !table.isHeader(col, row)) {
@@ -43619,47 +44087,13 @@
         else if (type === 'sparkline') {
             cellGroup = createSparkLineCellGroup(null, columnGroup, 0, y, col, row, cellWidth, cellHeight, padding, table, cellTheme);
         }
+        else if (type === 'checkbox') {
+            cellGroup = createCheckboxCellGroup(null, columnGroup, 0, y, col, row, colWidth, cellWidth, cellHeight, padding, textAlign, textBaseline, table, cellTheme, define);
+        }
         return cellGroup;
     }
     function updateCell$1(col, row, table, addNew) {
         const oldCellGroup = table.scenegraph.highPerformanceGetCell(col, row, true);
-        const cellStyle = table._getCellStyle(col, row);
-        const autoWrapText = cellStyle.autoWrapText ?? table.internalProps.autoWrapText;
-        const cellTheme = getStyleTheme(cellStyle, table, col, row, getProp).theme;
-        if (!addNew && canUseFastUpdate(col, row, oldCellGroup, autoWrapText, table)) {
-            const cellWidth = table.getColWidth(col);
-            const cellHeight = table.getRowHeight(row);
-            oldCellGroup.setAttributes({
-                width: cellWidth,
-                height: cellHeight,
-                lineWidth: cellTheme?.group?.lineWidth ?? undefined,
-                fill: cellTheme?.group?.fill ?? undefined,
-                stroke: cellTheme?.group?.stroke ?? undefined,
-                strokeArrayWidth: cellTheme?.group?.strokeArrayWidth ?? undefined,
-                strokeArrayColor: cellTheme?.group?.strokeArrayColor ?? undefined,
-                cursor: cellTheme?.group?.cursor ?? undefined
-            });
-            const textMark = oldCellGroup.getChildByName('text');
-            if (textMark) {
-                const text = table.getCellValue(col, row);
-                const hierarchyOffset = getHierarchyOffset(col, row, table);
-                const lineClamp = cellStyle.lineClamp;
-                const padding = getQuadProps(getProp('padding', cellStyle, col, row, table)) ?? [0, 0, 0, 0];
-                const attribute = {
-                    text: text.length === 1 && !autoWrapText ? text[0] : text,
-                    maxLineWidth: cellWidth - (padding[1] + padding[3] + hierarchyOffset),
-                    textBaseline: 'top',
-                    autoWrapText,
-                    lineClamp,
-                    wordBreak: 'break-word',
-                    heightLimit: cellHeight - (padding[0] + padding[2]),
-                    pickable: false,
-                    dx: hierarchyOffset
-                };
-                textMark.setAttributes(cellTheme.text ? Object.assign({}, cellTheme.text, attribute) : attribute);
-            }
-            return oldCellGroup;
-        }
         if (!addNew && oldCellGroup.role === 'empty') {
             return undefined;
         }
@@ -43697,6 +44131,8 @@
         }
         else {
             const mayHaveIcon = cellLocation !== 'body' ? true : !!define?.icon || !!define?.tree;
+            const headerStyle = table._getCellStyle(col, row);
+            const cellTheme = getStyleTheme(headerStyle, table, col, row, getProp).theme;
             const padding = cellTheme._vtable.padding;
             const textAlign = cellTheme._vtable.textAlign;
             const textBaseline = cellTheme._vtable.textBaseline;
@@ -43750,21 +44186,6 @@
         }
         return newCellGroup;
     }
-    function canUseFastUpdate(col, row, oldCellGroup, autoWrapText, table) {
-        const define = table.getBodyColumnDefine(col, row);
-        const mayHaveIcon = !!define?.icon || !!define?.tree;
-        const cellType = table.getBodyColumnType(col, row);
-        const autoRowHeight = table.heightMode === 'autoHeight';
-        if (!table.isHeader(col, row) &&
-            oldCellGroup.role === 'cell' &&
-            cellType === 'text' &&
-            !autoWrapText &&
-            !autoRowHeight &&
-            !mayHaveIcon) {
-            return true;
-        }
-        return false;
-    }
 
     function createComplexColumn(columnGroup, col, colWidth, rowStart, rowEnd, mergeMap, defaultRowHeight, table, cellLocation, rowLimit) {
         let maxWidth = 0;
@@ -43948,7 +44369,7 @@
             createColGroup(rightBottomCornerGroup, xOrigin, yOrigin, table.colCount - 1 - table.rightFrozenColCount + 1, table.colCount - 1, table.rowCount - 1 - table.bottomFrozenRowCount + 1, table.rowCount - 1, 'body', table);
         }
         createColGroup(bodyGroup, xOrigin, yOrigin, table.frozenColCount, Math.min(proxy.firstScreenColLimit, table.colCount - 1 - table.rightFrozenColCount), table.columnHeaderLevelCount, Math.min(proxy.firstScreenRowLimit, table.rowCount - 1 - table.bottomFrozenRowCount), 'body', table);
-        if (!bodyGroup.firstChild) {
+        if (!bodyGroup.firstChild && !colHeaderGroup.firstChild) {
             proxy.currentRow = proxy.totalRow;
             proxy.rowEnd = proxy.currentRow;
             proxy.rowUpdatePos = proxy.rowEnd;
@@ -43963,7 +44384,8 @@
             proxy.rowEnd = proxy.currentRow;
             proxy.rowUpdatePos = proxy.rowEnd;
             proxy.referenceRow = proxy.rowStart + Math.floor((proxy.rowEnd - proxy.rowStart) / 2);
-            proxy.currentCol = bodyGroup.lastChild?.col ?? proxy.totalCol;
+            proxy.currentCol =
+                bodyGroup.lastChild?.col ?? colHeaderGroup.lastChild?.col ?? proxy.totalCol;
             proxy.colEnd = proxy.currentCol;
             proxy.colUpdatePos = proxy.colEnd;
             proxy.referenceCol = proxy.colStart + Math.floor((proxy.colEnd - proxy.colStart) / 2);
@@ -44179,7 +44601,7 @@
             updateColContent(syncLeftCol, syncRightCol, proxy);
             checkFirstColMerge(distStartCol, proxy);
             updateAutoColumn(syncLeftCol, syncRightCol, proxy.table, direction);
-            const colGroup = proxy.table.scenegraph.getColGroup(screenLeftCol);
+            const colGroup = proxy.table.scenegraph.getColGroup(screenLeftCol) || proxy.table.scenegraph.getColGroup(screenLeftCol, true);
             const deltaX = screenLeftX - (colGroup.attribute.x + proxy.table.getFrozenColsWidth() + proxy.table.scenegraph.proxy.deltaX);
             proxy.table.scenegraph.proxy.deltaX += deltaX;
             proxy.currentCol = direction === 'left' ? proxy.currentCol + count : proxy.currentCol - count;
@@ -44445,27 +44867,18 @@
     function updatePartRowPosition(startRow, endRow, direction, proxy) {
         for (let col = 0; col < proxy.table.frozenColCount; col++) {
             const colGroup = proxy.table.scenegraph.getColGroup(col);
-            if (!colGroup) {
-                continue;
-            }
             for (let row = startRow; row <= endRow; row++) {
                 updateCellGroupPosition(colGroup, direction, proxy);
             }
         }
         for (let col = proxy.table.colCount - proxy.table.rightFrozenColCount; col < proxy.table.colCount; col++) {
             const colGroup = proxy.table.scenegraph.getColGroup(col);
-            if (!colGroup) {
-                continue;
-            }
             for (let row = startRow; row <= endRow; row++) {
                 updateCellGroupPosition(colGroup, direction, proxy);
             }
         }
         for (let col = proxy.bodyLeftCol; col <= proxy.bodyRightCol; col++) {
             const colGroup = proxy.table.scenegraph.getColGroup(col);
-            if (!colGroup) {
-                continue;
-            }
             for (let row = startRow; row <= endRow; row++) {
                 updateCellGroupPosition(colGroup, direction, proxy);
             }
@@ -44583,7 +44996,7 @@
         isRelease = false;
         mode = 'column';
         isProgressing;
-        rowLimit = 200;
+        rowLimit = 1000;
         currentRow = 0;
         totalRow;
         yLimitTop;
@@ -44655,7 +45068,7 @@
             this.xLimitRight = totalWidth - totalBodyWidth / 2;
             const widthLimit = this.table.tableNoFrameWidth * 5;
             this.screenColCount = Math.ceil(this.table.tableNoFrameWidth / defaultColWidth);
-            this.firstScreenColLimit = this.bodyLeftCol + Math.ceil(widthLimit / defaultColWidth);
+            this.firstScreenColLimit = this.bodyLeftCol + Math.min(this.colLimit, Math.ceil(widthLimit / defaultColWidth));
             this.colUpdatePos = this.bodyRightCol;
         }
         setParamsForRow() {
@@ -44672,7 +45085,7 @@
             this.yLimitBottom = totalHeight - totalBodyHeight / 2;
             const heightLimit = this.table.tableNoFrameHeight * 5;
             this.screenRowCount = Math.ceil(this.table.tableNoFrameHeight / defaultRowHeight);
-            this.firstScreenRowLimit = this.bodyTopRow + Math.ceil(heightLimit / defaultRowHeight);
+            this.firstScreenRowLimit = this.bodyTopRow + Math.min(this.rowLimit, Math.ceil(heightLimit / defaultRowHeight));
             this.rowUpdatePos = this.bodyBottomRow;
         }
         async createGroupForFirstScreen(cornerHeaderGroup, colHeaderGroup, rowHeaderGroup, rightFrozenGroup, bottomFrozenGroup, bodyGroup, xOrigin, yOrigin) {
@@ -44787,9 +45200,17 @@
                 const yOrigin = lastColumnGroup.attribute.y;
                 createColGroup(this.table.scenegraph.bottomFrozenGroup, xOrigin, yOrigin, this.currentCol + 1, endCol, this.table.rowCount - this.table.bottomFrozenRowCount, this.table.rowCount - 1, 'columnHeader', this.table);
             }
-            const lastColumnGroup = (this.table.scenegraph.bodyGroup.lastChild instanceof Group
-                ? this.table.scenegraph.bodyGroup.lastChild
-                : this.table.scenegraph.bodyGroup.lastChild._prev);
+            let lastColumnGroup = this.table.scenegraph.bodyGroup.lastChild &&
+                (this.table.scenegraph.bodyGroup.lastChild instanceof Group
+                    ? this.table.scenegraph.bodyGroup.lastChild
+                    : this.table.scenegraph.bodyGroup.lastChild._prev);
+            if (!lastColumnGroup) {
+                lastColumnGroup =
+                    this.table.scenegraph.colHeaderGroup.lastChild &&
+                        (this.table.scenegraph.colHeaderGroup.lastChild instanceof Group
+                            ? this.table.scenegraph.colHeaderGroup.lastChild
+                            : this.table.scenegraph.colHeaderGroup.lastChild._prev);
+            }
             const xOrigin = lastColumnGroup.attribute.x + lastColumnGroup.attribute.width;
             const yOrigin = lastColumnGroup.attribute.y;
             createColGroup(this.table.scenegraph.bodyGroup, xOrigin, yOrigin, this.currentCol + 1, endCol, this.rowStart, this.rowEnd, 'body', this.table);
@@ -45812,7 +46233,7 @@
     function updateChartSize(scenegraph, col) {
         for (let c = col; c <= scenegraph.proxy.colEnd; c++) {
             const columnGroup = scenegraph.getColGroup(c);
-            columnGroup.getChildren()?.forEach((cellNode) => {
+            columnGroup?.getChildren()?.forEach((cellNode) => {
                 const width = scenegraph.table.getColWidth(cellNode.col);
                 const height = scenegraph.table.getRowHeight(cellNode.row);
                 cellNode.children.forEach((node) => {
@@ -45828,7 +46249,7 @@
     function clearChartCacheImage(scenegraph) {
         for (let c = scenegraph.proxy.colStart; c <= scenegraph.proxy.colEnd; c++) {
             const columnGroup = scenegraph.getColGroup(c);
-            columnGroup.getChildren()?.forEach((cellNode) => {
+            columnGroup?.getChildren()?.forEach((cellNode) => {
                 cellNode.children.forEach((node) => {
                     if (node.type === 'chart') {
                         node.cacheCanvas = null;
@@ -45842,7 +46263,7 @@
         const table = scenegraph.table;
         for (let c = scenegraph.proxy.colStart; c <= scenegraph.proxy.colEnd; c++) {
             const columnGroup = scenegraph.getColGroup(c);
-            columnGroup.getChildren()?.forEach((cellNode) => {
+            columnGroup?.getChildren()?.forEach((cellNode) => {
                 const col = cellNode.col;
                 const row = cellNode.row;
                 cellNode.children.forEach((node) => {
@@ -46057,13 +46478,13 @@
     }
     class FastTextMeasureContribution extends DefaultTextMeasureContribution {
         measureTextWidth(text, options) {
-            const { fontSize, fontFamily = 'sans-serif', fontWeight = 'normal', fontStyle = 'normal' } = options;
+            const { fontSize, fontFamily = 'Arial,sans-serif', fontWeight = 'normal', fontStyle = 'normal' } = options;
             const fastTextMeasure = getFastTextMeasure(fontSize, fontWeight, fontFamily, fontStyle);
             const textMeasure = fastTextMeasure.measure(text);
             return textMeasure.width;
         }
         measureText(text, options) {
-            const { fontSize, fontFamily = 'sans-serif', fontWeight = 'normal', fontStyle = 'normal' } = options;
+            const { fontSize, fontFamily = 'Arial,sans-serif', fontWeight = 'normal', fontStyle = 'normal' } = options;
             const fastTextMeasure = getFastTextMeasure(fontSize, fontWeight, fontFamily, fontStyle);
             const textMeasure = fastTextMeasure.measure(text);
             return textMeasure;
@@ -46071,13 +46492,13 @@
     }
     class TextMeasureTool {
         measureText(text, options) {
-            const { fontSize, fontFamily = 'sans-serif', fontWeight = 'normal', fontStyle = 'normal' } = options;
+            const { fontSize, fontFamily = 'Arial,sans-serif', fontWeight = 'normal', fontStyle = 'normal' } = options;
             const fastTextMeasure = getFastTextMeasure(fontSize, fontWeight, fontFamily, fontStyle);
             const textMeasure = fastTextMeasure.measure(text);
             return textMeasure;
         }
         measureTextWidth(text, options) {
-            const { fontSize, fontFamily = 'sans-serif', fontWeight = 'normal', fontStyle = 'normal' } = options;
+            const { fontSize, fontFamily = 'Arial,sans-serif', fontWeight = 'normal', fontStyle = 'normal' } = options;
             const fastTextMeasure = getFastTextMeasure(fontSize, fontWeight, fontFamily, fontStyle);
             const textMeasure = fastTextMeasure.measure(text);
             return textMeasure.width;
@@ -46211,11 +46632,22 @@
             this.clear = true;
             this.mergeMap = new Map();
             setPoptipTheme(poptipStyle);
-            vglobal.setEnv('browser');
+            let width;
+            let height;
+            if (Env.mode === 'node') {
+                vglobal.setEnv('node', table.options.modeParams);
+                width = table.canvasWidth;
+                height = table.canvasHeight;
+            }
+            else {
+                vglobal.setEnv('browser');
+                width = table.canvas.width;
+                height = table.canvas.height;
+            }
             this.stage = createStage({
                 canvas: table.canvas,
-                width: table.canvas.width,
-                height: table.canvas.height,
+                width,
+                height,
                 disableDirtyBounds: false,
                 background: table.theme.underlayBackgroundColor,
                 dpr: table.internalProps.pixelRatio,
@@ -49380,6 +49812,18 @@
                 table.fireListeners(TABLE_EVENT_TYPE.DBLCLICK_CELL, cellsEvent);
             }
         });
+        table.scenegraph.tableGroup.addEventListener('checkbox_state_change', (e) => {
+            const eventArgsSet = getCellEventArgsSet(e);
+            const { col, row } = eventArgsSet.eventArgs;
+            const cellInfo = table.getCellInfo(col, row);
+            const cellsEvent = {
+                ...cellInfo,
+                event: e.nativeEvent,
+                target: eventArgsSet?.eventArgs?.target,
+                checked: e.detail.checked
+            };
+            table.fireListeners(TABLE_EVENT_TYPE.CHECKBOX_STATE_CHANGE, cellsEvent);
+        });
     }
     function endResizeCol(table) {
         table.stateManeger.endResizeCol();
@@ -49493,7 +49937,8 @@
         }
         state.resetInteractionState();
         if (event.cancelable &&
-            ((deltaY !== 0 && isVerticalScrollable(deltaY, state)) || (deltaX !== 0 && isHorizontalScrollable(deltaX, state)))) {
+            ((Math.abs(deltaY) >= Math.abs(deltaX) && deltaY !== 0 && isVerticalScrollable(deltaY, state)) ||
+                (Math.abs(deltaY) <= Math.abs(deltaX) && deltaX !== 0 && isHorizontalScrollable(deltaX, state)))) {
             event.preventDefault();
         }
     }
@@ -49622,8 +50067,8 @@
                 eventManeger.touchMovePoints[eventManeger.touchMovePoints.length - 2].y;
             handleWhell({ deltaX, deltaY }, stateManeger);
             if (e.cancelable &&
-                ((deltaY !== 0 && isVerticalScrollable(deltaY, stateManeger)) ||
-                    (deltaX !== 0 && isHorizontalScrollable(deltaX, stateManeger)))) {
+                ((Math.abs(deltaY) >= Math.abs(deltaX) && deltaY !== 0 && isVerticalScrollable(deltaY, stateManeger)) ||
+                    (Math.abs(deltaY) <= Math.abs(deltaX) && deltaX !== 0 && isHorizontalScrollable(deltaX, stateManeger)))) {
                 e.preventDefault();
             }
         }, { passive: false });
@@ -49830,6 +50275,9 @@
         touchMove;
         constructor(table) {
             this.table = table;
+            if (Env.mode === 'node') {
+                return;
+            }
             this.bindOuterEvent();
             setTimeout(() => {
                 this.bindSelfEvent();
@@ -49921,6 +50369,9 @@
             }
             const { eventArgs } = eventArgsSet;
             if (eventArgs) {
+                if (eventArgs.target.name === 'checkbox') {
+                    return false;
+                }
                 if (this.table.isPivotChart() &&
                     (eventArgsSet?.eventArgs?.target.name === 'axis-label' || eventArgsSet?.eventArgs?.target.type === 'chart')) {
                     this.table.stateManeger.updateSelectPos(-1, -1);
@@ -50009,7 +50460,7 @@
         }
     }
 
-    let defaultStyle$1;
+    let defaultStyle$2;
     const DEFAULT_BAR_COLOR = (args) => {
         const num = args.value;
         if (Number(num) > 80) {
@@ -50040,7 +50491,7 @@
         _barMarkPosition;
         _barRightToLeft;
         static get DEFAULT() {
-            return defaultStyle$1 ? defaultStyle$1 : (defaultStyle$1 = new ProgressBarStyle());
+            return defaultStyle$2 ? defaultStyle$2 : (defaultStyle$2 = new ProgressBarStyle());
         }
         constructor(style = {}, bodyStyle = {}) {
             super(style, bodyStyle);
@@ -50178,6 +50629,19 @@
     ];
     const iconPropKeys = ICON_PROP_KEYS;
 
+    let defaultStyle$1;
+    class CheckboxStyle extends Style$1 {
+        static get DEFAULT() {
+            return defaultStyle$1 ? defaultStyle$1 : (defaultStyle$1 = new CheckboxStyle());
+        }
+        constructor(style = {}, bodyStyle = {}) {
+            super(style, bodyStyle);
+        }
+        clone() {
+            return new CheckboxStyle(this, null);
+        }
+    }
+
     class BodyHelper {
         expandIcon;
         collapseIcon;
@@ -50256,6 +50720,8 @@
                     return Style$1;
                 case 'progressbar':
                     return ProgressBarStyle;
+                case 'checkbox':
+                    return CheckboxStyle;
             }
         }
         getCellIconFromRecordValue(icon, col, row) {
@@ -50301,6 +50767,9 @@
     }
 
     function importStyle$1() {
+        if (Env.mode === 'node') {
+            return;
+        }
         const styleElement = document.createElement('style');
         styleElement.id = 'vtable-menu-styleSheet';
         styleElement.textContent = `
@@ -51236,6 +51705,9 @@
     }
 
     function importStyle() {
+        if (Env.mode === 'node') {
+            return;
+        }
         const styleElement = document.createElement('style');
         styleElement.id = 'vtable-tooltip-styleSheet';
         styleElement.textContent = `
@@ -51341,7 +51813,10 @@
                     (messageElement.style.backgroundColor = tooltipInstanceInfo?.style?.bgColor);
                 tooltipInstanceInfo?.style?.bgColor && (triangle.style.backgroundColor = tooltipInstanceInfo?.style?.bgColor);
                 triangle.style.display = tooltipInstanceInfo?.style?.arrowMark === true ? 'block' : 'none';
-                tooltipInstanceInfo?.style?.font && (messageElement.style.font = tooltipInstanceInfo?.style?.font);
+                tooltipInstanceInfo?.style?.fontSize &&
+                    (messageElement.style.fontSize = (tooltipInstanceInfo?.style?.fontSize ?? 12) + 'px');
+                tooltipInstanceInfo?.style?.fontFamily &&
+                    (messageElement.style.fontFamily = tooltipInstanceInfo?.style?.fontFamily);
                 tooltipInstanceInfo?.style?.color && (messageElement.style.color = tooltipInstanceInfo?.style?.color);
                 tooltipInstanceInfo?.style?.padding &&
                     (messageElement.style.padding = `${tooltipInstanceInfo?.style?.padding.join('px ')}px`);
@@ -52793,7 +53268,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "0.13.0-alpha.4";
+        version = "0.13.0";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -52802,10 +53277,10 @@
         isReleased = false;
         constructor(container, options = {}) {
             super();
-            if (!container) {
+            if (!container && options.mode !== 'node') {
                 throw new Error("vtable's container is undefined");
             }
-            const { frozenColCount = 0, defaultRowHeight = 40, defaultHeaderRowHeight, defaultColWidth = 80, defaultHeaderColWidth, widthMode = 'standard', heightMode = 'standard', autoFillWidth = false, autoFillHeight = false, keyboardOptions, columnResizeMode, dragHeaderMode, showFrozenIcon, allowFrozenColCount, padding, hover, menu, select: click, customRender, pixelRatio = defaultPixelRatio, renderChartAsync, renderChartAsyncBatchCount } = options;
+            const { frozenColCount = 0, defaultRowHeight = 40, defaultHeaderRowHeight, defaultColWidth = 80, defaultHeaderColWidth, widthMode = 'standard', heightMode = 'standard', autoFillWidth = false, autoFillHeight = false, keyboardOptions, columnResizeMode, dragHeaderMode, showFrozenIcon, allowFrozenColCount, padding, hover, menu, select: click, customRender, pixelRatio = defaultPixelRatio, renderChartAsync, renderChartAsyncBatchCount, mode, modeParams, canvasWidth, canvasHeight } = options;
             this.container = container;
             this.options = options;
             this.options.container = container;
@@ -52831,18 +53306,22 @@
             }
             this.tableNoFrameWidth = 0;
             this.tableNoFrameHeight = 0;
+            this.canvasWidth = canvasWidth;
+            this.canvasHeight = canvasHeight;
             const internalProps = (this.internalProps = {});
             showFrozenIcon !== undefined && (this.showFrozenIcon = showFrozenIcon);
             if (typeof allowFrozenColCount === 'number' && allowFrozenColCount <= 0) {
                 this.showFrozenIcon = false;
             }
+            if (Env.mode !== 'node') {
+                internalProps.element = createRootElement(this.padding);
+                internalProps.focusControl = new FocusInput(this, internalProps.element);
+                internalProps.canvas = document.createElement('canvas');
+                internalProps.element.appendChild(internalProps.canvas);
+                internalProps.context = internalProps.canvas.getContext('2d');
+            }
             internalProps.handler = new EventHandler();
-            internalProps.element = createRootElement(this.padding);
-            internalProps.focusControl = new FocusInput(this, internalProps.element);
             internalProps.pixelRatio = pixelRatio;
-            internalProps.canvas = document.createElement('canvas');
-            internalProps.element.appendChild(internalProps.canvas);
-            internalProps.context = internalProps.canvas.getContext('2d');
             internalProps.frozenColCount = frozenColCount;
             internalProps.defaultRowHeight = defaultRowHeight;
             internalProps.defaultHeaderRowHeight = defaultHeaderRowHeight ?? defaultRowHeight;
@@ -52863,6 +53342,9 @@
             internalProps.calcWidthContext = {
                 _: internalProps,
                 get full() {
+                    if (Env.mode === 'node') {
+                        return canvasWidth / (pixelRatio ?? 1);
+                    }
                     return this._.canvas.width / (this._.context.pixelRatio ?? window.devicePixelRatio);
                 }
             };
@@ -54849,6 +55331,29 @@
             }
             return base64Image;
         }
+        exportCanvas() {
+            const c = this.scenegraph.stage.toCanvas();
+            return c;
+        }
+        getImageBuffer(type = 'image/png') {
+            if (this.options.mode !== 'node') {
+                return;
+            }
+            const stage = this.scenegraph.stage;
+            if (stage) {
+                const contentWidth = this.tableX + this.getAllColsWidth();
+                const contentHeight = this.tableY + this.getAllRowsHeight();
+                if (contentWidth >= this.canvasWidth && contentHeight >= this.canvasHeight) {
+                    stage.render();
+                    const buffer = stage.window.getImageBuffer(type);
+                    return buffer;
+                }
+                const newCanvas = this.scenegraph.stage.toCanvas(false, new AABBBounds().set(0, 0, Math.min(this.canvasWidth, contentWidth), Math.min(this.canvasHeight, contentHeight)));
+                const buffer = newCanvas.toBuffer(type);
+                return buffer;
+            }
+            return null;
+        }
     }
 
     var core = /*#__PURE__*/Object.freeze({
@@ -55045,7 +55550,7 @@
                 axes.push(merge$1({
                     range
                 }, axisOption, {
-                    type: 'linear',
+                    type: axisOption?.type || 'linear',
                     orient: index === 0 ? 'bottom' : 'top',
                     label: { visible: false },
                     title: { visible: false },
@@ -55106,7 +55611,7 @@
                 axes.push(merge$1({
                     range
                 }, axisOption, {
-                    type: 'linear',
+                    type: axisOption?.type || 'linear',
                     orient: index === 0 ? 'left' : 'right',
                     label: { visible: false },
                     title: { visible: false },
@@ -56019,7 +56524,11 @@
     class ListTable extends BaseTable {
         showHeader = true;
         constructor(container, options) {
-            if (!(container instanceof HTMLElement)) {
+            if (Env.mode === 'node') {
+                options = container;
+                container = null;
+            }
+            else if (!(container instanceof HTMLElement)) {
                 options = container;
                 if (container.container) {
                     container = container.container;
@@ -57536,7 +58045,13 @@
             return this.columnDimensionTree.tree.size + this.rowHeaderLevelCount + this.rightFrozenColCount;
         }
         get rowCount() {
-            return (this._rowHeaderCellIds?.length ?? 0) + this.columnHeaderLevelCount + this.bottomFrozenRowCount;
+            return (((Array.isArray(this._table.records) ? this._table.records.length > 0 : true) &&
+                this._indicators?.length > 0 &&
+                !this._rowHeaderCellIds?.length
+                ? 1
+                : this._rowHeaderCellIds?.length ?? 0) +
+                this.columnHeaderLevelCount +
+                this.bottomFrozenRowCount);
         }
         get bodyRowCount() {
             return this.rowDimensionTree.tree.size;
@@ -59473,9 +59988,7 @@
                             (indicatorsAsCol && this.rows.length === 0), this.rowGrandTotalLabel);
                     }
                     else {
-                        this.rowHeaderTree = this.ArrToTree(this.rowKeys, this.rows, indicatorsAsCol ? undefined : indicators, this.rowsIsTotal, this?.totals?.row?.showGrandTotals ||
-                            (!indicatorsAsCol && this.columns.length === 0) ||
-                            (indicatorsAsCol && this.rows.length === 0), this.rowGrandTotalLabel, this.rowSubTotalLabel);
+                        this.rowHeaderTree = this.ArrToTree(this.rowKeys, this.rows, indicatorsAsCol ? undefined : indicators, this.rowsIsTotal, this?.totals?.row?.showGrandTotals || (indicatorsAsCol && this.rows.length === 0), this.rowGrandTotalLabel, this.rowSubTotalLabel);
                     }
                 }
                 if (customColTree) {
@@ -59485,7 +59998,7 @@
                     this.colHeaderTree = customColTree;
                 }
                 else {
-                    this.colHeaderTree = this.ArrToTree(this.colKeys, this.columns, indicatorsAsCol ? indicators : undefined, this.colsIsTotal, this.totals?.column?.showGrandTotals, this.colGrandTotalLabel, this.colSubTotalLabel);
+                    this.colHeaderTree = this.ArrToTree(this.colKeys, this.columns, indicatorsAsCol ? indicators : undefined, this.colsIsTotal, this.totals?.column?.showGrandTotals || (!indicatorsAsCol && this.columns.length === 0), this.colGrandTotalLabel, this.colSubTotalLabel);
                 }
                 typeof window !== 'undefined' ? window.performance.now() : 0;
                 if (this.dataConfig?.isPivotChart) {
@@ -60363,7 +60876,11 @@
         dataset;
         flatDataToObjects;
         constructor(container, options) {
-            if (!(container instanceof HTMLElement)) {
+            if (Env.mode === 'node') {
+                options = container;
+                container = null;
+            }
+            else if (!(container instanceof HTMLElement)) {
                 options = container;
                 if (container.container) {
                     container = container.container;
@@ -60887,7 +61404,11 @@
         _chartEventMap = {};
         _axes;
         constructor(container, options) {
-            if (!(container instanceof HTMLElement)) {
+            if (Env.mode === 'node') {
+                options = container;
+                container = null;
+            }
+            else if (!(container instanceof HTMLElement)) {
                 options = container;
                 if (container.container) {
                     container = container.container;
@@ -61552,6 +62073,9 @@
             updateChartData(this.scenegraph);
             this.render();
         }
+        getLegendSelected() {
+            return this.internalProps.legends.legendComponent._getSelectedLegends().map((d) => d.label);
+        }
         setLegendSelected(selectedData) {
             this.internalProps.legends.legendComponent.setSelected(selectedData);
         }
@@ -62177,7 +62701,7 @@
             super(options);
             this.text = options.text;
             this.fontSize = options.fontSize || 12;
-            this.fontFamily = options.fontFamily || 'sans-serif';
+            this.fontFamily = options.fontFamily || 'Arial,sans-serif';
             this.fill = options.color || options.fill || 'black';
             this.textBaseline = options.textBaseline || 'top';
             this.textAlign = options.textAlign || 'left';
@@ -62505,7 +63029,7 @@
         return new Tag(params ? params.attribute : {});
     }
 
-    const version = "0.13.0-alpha.4";
+    const version = "0.13.0";
     function getIcons() {
         return get$1();
     }