@visactor/vtable 0.25.2 → 0.25.3

package/dist/vtable.js

@@ -32089,390 +32089,563 @@
 
     const DEFAULT_CONTINUOUS_TICK_COUNT$1 = 5;
 
-    const initTextMeasure$1 = (textSpec, option, useNaiveCanvas, defaultFontParams) => new TextMeasure(Object.assign({
-      defaultFontParams: Object.assign({
-        fontFamily: "PingFang SC,Helvetica Neue,Microsoft Yahei,system-ui,-apple-system,segoe ui,Roboto,Helvetica,Arial,sans-serif,apple color emoji,segoe ui emoji,segoe ui symbol",
-        fontSize: 14
-      }, defaultFontParams),
-      getTextBounds: useNaiveCanvas ? void 0 : getTextBounds,
-      specialCharSet: "-/: .,@%'\"~" + TextMeasure.ALPHABET_CHAR_SET + TextMeasure.ALPHABET_CHAR_SET.toUpperCase()
-    }, null != option ? option : {}), textSpec);
+    const initTextMeasure$1 = (textSpec, option, useNaiveCanvas, defaultFontParams) => {
+        return new TextMeasure({
+            defaultFontParams: {
+                fontFamily: 'PingFang SC,Helvetica Neue,Microsoft Yahei,system-ui,-apple-system,segoe ui,Roboto,Helvetica,Arial,sans-serif,apple color emoji,segoe ui emoji,segoe ui symbol',
+                fontSize: 14,
+                ...defaultFontParams
+            },
+            getTextBounds: useNaiveCanvas ? undefined : getTextBounds,
+            specialCharSet: '-/: .,@%\'"~' + TextMeasure.ALPHABET_CHAR_SET + TextMeasure.ALPHABET_CHAR_SET.toUpperCase(),
+            ...(option ?? {})
+        }, textSpec);
+    };
 
     function getLabelPosition(angle, center, radius, labelOffset, inside, text, style) {
-      const point = polarToCartesian({
-          x: 0,
-          y: 0
-        }, radius, angle),
-        labelPoint = getVerticalCoord(point, getCircleVerticalVector(labelOffset, point, center, inside)),
-        vector = getCircleVerticalVector(labelOffset || 1, labelPoint, center, inside);
-      return getCircleLabelPosition(labelPoint, vector, text, style);
-    }
-
-    const convertDomainToTickData = domain => domain.map((t, index) => ({
-      index: index,
-      value: t
-    }));
-    const labelOverlap = function (prevLabel, nextLabel) {
-      let gap = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-      const prevBounds = new AABBBounds(prevLabel).expand(gap / 2),
-        nextBounds = new AABBBounds(nextLabel).expand(gap / 2);
-      return prevBounds.intersects(nextBounds);
+        const point = polarToCartesian({ x: 0, y: 0 }, radius, angle);
+        const labelPoint = getVerticalCoord(point, getCircleVerticalVector(labelOffset, point, center, inside));
+        const vector = getCircleVerticalVector(labelOffset || 1, labelPoint, center, inside);
+        return getCircleLabelPosition(labelPoint, vector, text, style);
+    }
+
+    const convertDomainToTickData = (domain) => {
+        const ticks = domain.map((t, index) => {
+            return {
+                index,
+                value: t
+            };
+        });
+        return ticks;
+    };
+    const labelOverlap = (prevLabel, nextLabel, gap = 0) => {
+        const prevBounds = new AABBBounds(prevLabel).expand(gap / 2);
+        const nextBounds = new AABBBounds(nextLabel).expand(gap / 2);
+        return prevBounds.intersects(nextBounds);
     };
     function intersect(a, b, sep) {
-      return sep > Math.max(b.x1 - a.x2, a.x1 - b.x2, b.y1 - a.y2, a.y1 - b.y2);
+        return sep > Math.max(b.x1 - a.x2, a.x1 - b.x2, b.y1 - a.y2, a.y1 - b.y2);
     }
     function hasOverlap(items, pad) {
-      for (let b, i = 1, n = items.length, a = items[0]; i < n; a = b, ++i) if (b = items[i], intersect(a.AABBBounds, b.AABBBounds, pad)) return !0;
-      return !1;
+        for (let i = 1, n = items.length, a = items[0], b; i < n; a = b, ++i) {
+            b = items[i];
+            if (intersect(a.AABBBounds, b.AABBBounds, pad)) {
+                return true;
+            }
+        }
+        return false;
     }
+    const MIN_TICK_GAP = 12;
     const getCartesianLabelBounds = (scale, domain, op) => {
-      var _a;
-      const {
-        labelStyle: labelStyle,
-        axisOrientType: axisOrientType,
-        labelFlush: labelFlush,
-        labelFormatter: labelFormatter,
-        startAngle = 0
-      } = op;
-      let labelAngle = null !== (_a = labelStyle.angle) && void 0 !== _a ? _a : 0;
-      "vertical" === labelStyle.direction && (labelAngle += degreeToRadian(90));
-      const isHorizontal = ["bottom", "top"].includes(axisOrientType),
-        isVertical = ["left", "right"].includes(axisOrientType);
-      let scaleX = 1,
-        scaleY = 0;
-      isHorizontal || (isVertical ? (scaleX = 0, scaleY = 1) : startAngle && (scaleX = Math.cos(startAngle), scaleY = -Math.sin(startAngle)));
-      const textMeasure = initTextMeasure$1(labelStyle),
-        labelBoundsList = domain.map((v, i) => {
-          var _a, _b;
-          const str = labelFormatter ? labelFormatter(v) : `${v}`,
-            {
-              width: width,
-              height: height
-            } = textMeasure.quickMeasure(str),
-            textWidth = Math.max(width, 12),
-            textHeight = Math.max(height, 12),
-            pos = scale.scale(v),
-            baseTextX = scaleX * pos,
-            baseTextY = scaleY * pos;
-          let align,
-            baseline,
-            textX = baseTextX,
-            textY = baseTextY;
-          align = labelFlush && isHorizontal && 0 === i ? "left" : labelFlush && isHorizontal && i === domain.length - 1 ? "right" : null !== (_a = labelStyle.textAlign) && void 0 !== _a ? _a : "center", "right" === align ? textX -= textWidth : "center" === align && (textX -= textWidth / 2), baseline = labelFlush && isVertical && 0 === i ? "top" : labelFlush && isVertical && i === domain.length - 1 ? "bottom" : null !== (_b = labelStyle.textBaseline) && void 0 !== _b ? _b : "middle", "bottom" === baseline ? textY -= textHeight : "middle" === baseline && (textY -= textHeight / 2);
-          const bounds = new AABBBounds().set(textX, textY, textX + textWidth, textY + textHeight);
-          return labelAngle && bounds.rotate(labelAngle, baseTextX, baseTextY), bounds;
+        const { labelStyle, axisOrientType, labelFlush, labelFormatter, startAngle = 0 } = op;
+        let labelAngle = labelStyle.angle ?? 0;
+        if (labelStyle.direction === 'vertical') {
+            labelAngle += degreeToRadian(90);
+        }
+        const isHorizontal = ['bottom', 'top'].includes(axisOrientType);
+        const isVertical = ['left', 'right'].includes(axisOrientType);
+        let scaleX = 1;
+        let scaleY = 0;
+        if (isHorizontal) ;
+        else if (isVertical) {
+            scaleX = 0;
+            scaleY = 1;
+        }
+        else if (startAngle) {
+            scaleX = Math.cos(startAngle);
+            scaleY = -Math.sin(startAngle);
+        }
+        const textMeasure = initTextMeasure$1(labelStyle);
+        const labelBoundsList = domain.map((v, i) => {
+            const str = labelFormatter ? labelFormatter(v) : `${v}`;
+            const { width, height } = textMeasure.quickMeasure(str);
+            const textWidth = Math.max(width, MIN_TICK_GAP);
+            const textHeight = Math.max(height, MIN_TICK_GAP);
+            const pos = scale.scale(v);
+            const baseTextX = scaleX * pos;
+            const baseTextY = scaleY * pos;
+            let textX = baseTextX;
+            let textY = baseTextY;
+            let align;
+            if (labelFlush && isHorizontal && i === 0) {
+                align = 'left';
+            }
+            else if (labelFlush && isHorizontal && i === domain.length - 1) {
+                align = 'right';
+            }
+            else {
+                align = labelStyle.textAlign ?? 'center';
+            }
+            if (align === 'right') {
+                textX -= textWidth;
+            }
+            else if (align === 'center') {
+                textX -= textWidth / 2;
+            }
+            let baseline;
+            if (labelFlush && isVertical && i === 0) {
+                baseline = 'top';
+            }
+            else if (labelFlush && isVertical && i === domain.length - 1) {
+                baseline = 'bottom';
+            }
+            else {
+                baseline = labelStyle.textBaseline ?? 'middle';
+            }
+            if (baseline === 'bottom') {
+                textY -= textHeight;
+            }
+            else if (baseline === 'middle') {
+                textY -= textHeight / 2;
+            }
+            const bounds = new AABBBounds().set(textX, textY, textX + textWidth, textY + textHeight);
+            if (labelAngle) {
+                bounds.rotate(labelAngle, baseTextX, baseTextY);
+            }
+            return bounds;
         });
-      return labelBoundsList;
+        return labelBoundsList;
     };
     const getPolarAngleLabelBounds = (scale, domain, op) => {
-      var _a;
-      const {
-          labelStyle: labelStyle,
-          getRadius: getRadius,
-          labelOffset: labelOffset,
-          labelFormatter: labelFormatter,
-          inside: inside
-        } = op,
-        radius = null == getRadius ? void 0 : getRadius(),
-        labelAngle = null !== (_a = labelStyle.angle) && void 0 !== _a ? _a : 0,
-        textMeasure = initTextMeasure$1(labelStyle),
-        labelBoundsList = domain.map(v => {
-          var _a, _b;
-          const str = labelFormatter ? labelFormatter(v) : `${v}`,
-            {
-              width: width,
-              height: height
-            } = textMeasure.quickMeasure(str),
-            textWidth = Math.max(width, 12),
-            textHeight = Math.max(height, 12),
-            angle = scale.scale(v);
-          let textX = 0,
-            textY = 0;
-          const orient_align = null !== (_a = labelStyle.textAlign) && void 0 !== _a ? _a : "center",
-            orient_baseline = null !== (_b = labelStyle.textBaseline) && void 0 !== _b ? _b : "middle",
-            {
-              x: x,
-              y: y
-            } = getLabelPosition(angle, {
-              x: 0,
-              y: 0
-            }, radius, labelOffset, inside, str, labelStyle);
-          textX = x + ("right" === orient_align ? -textWidth : "center" === orient_align ? -textWidth / 2 : 0), textY = y + ("bottom" === orient_baseline ? -textHeight : "middle" === orient_baseline ? -textHeight / 2 : 0);
-          return new AABBBounds().set(textX, textY, textX + textWidth, textY + textHeight).rotate(labelAngle, textX + textWidth / 2, textY + textHeight / 2);
+        const { labelStyle, getRadius, labelOffset, labelFormatter, inside } = op;
+        const radius = getRadius?.();
+        const labelAngle = labelStyle.angle ?? 0;
+        const textMeasure = initTextMeasure$1(labelStyle);
+        const labelBoundsList = domain.map((v) => {
+            const str = labelFormatter ? labelFormatter(v) : `${v}`;
+            const { width, height } = textMeasure.quickMeasure(str);
+            const textWidth = Math.max(width, MIN_TICK_GAP);
+            const textHeight = Math.max(height, MIN_TICK_GAP);
+            const angle = scale.scale(v);
+            let textX = 0;
+            let textY = 0;
+            const orient = {
+                align: labelStyle.textAlign ?? 'center',
+                baseline: labelStyle.textBaseline ?? 'middle'
+            };
+            const { x, y } = getLabelPosition(angle, { x: 0, y: 0 }, radius, labelOffset, inside, str, labelStyle);
+            textX = x + (orient.align === 'right' ? -textWidth : orient.align === 'center' ? -textWidth / 2 : 0);
+            textY = y + (orient.baseline === 'bottom' ? -textHeight : orient.baseline === 'middle' ? -textHeight / 2 : 0);
+            const bounds = new AABBBounds()
+                .set(textX, textY, textX + textWidth, textY + textHeight)
+                .rotate(labelAngle, textX + textWidth / 2, textY + textHeight / 2);
+            return bounds;
         });
-      return labelBoundsList;
+        return labelBoundsList;
+    };
+    const isAxisHorizontal = (axisOrientType) => {
+        return ['bottom', 'top', 'z'].includes(axisOrientType);
     };
-    const isAxisHorizontal = axisOrientType => ["bottom", "top", "z"].includes(axisOrientType);
 
     const continuousTicks = (scale, op) => {
-      if (!isContinuous(scale.type)) return convertDomainToTickData(scale.domain());
-      const range = scale.range(),
-        rangeSize = Math.abs(range[range.length - 1] - range[0]);
-      if (rangeSize < 2) return convertDomainToTickData([scale.domain()[0]]);
-      const {
-        tickCount: tickCount,
-        forceTickCount: forceTickCount,
-        tickStep: tickStep,
-        noDecimals = !1,
-        labelStyle: labelStyle
-      } = op;
-      let scaleTicks;
-      if (isValid$3(tickStep)) scaleTicks = scale.stepTicks(tickStep);else if (isValid$3(forceTickCount)) scaleTicks = scale.forceTicks(forceTickCount);else if ("d3" === op.tickMode) {
-        const count = isFunction$1(tickCount) ? tickCount({
-          axisLength: rangeSize,
-          labelStyle: labelStyle
-        }) : tickCount;
-        scaleTicks = scale.d3Ticks(null != count ? count : DEFAULT_CONTINUOUS_TICK_COUNT$1, {
-          noDecimals: noDecimals
-        });
-      } else {
-        const count = isFunction$1(tickCount) ? tickCount({
-          axisLength: rangeSize,
-          labelStyle: labelStyle
-        }) : tickCount;
-        scaleTicks = scale.ticks(null != count ? count : DEFAULT_CONTINUOUS_TICK_COUNT$1, {
-          noDecimals: noDecimals
-        });
-      }
-      if (op.sampling && ("cartesian" === op.coordinateType || "polar" === op.coordinateType && "radius" === op.axisOrientType)) {
-        const {
-          labelGap = 4,
-          labelFlush: labelFlush
-        } = op;
-        let items = getCartesianLabelBounds(scale, scaleTicks, op).map((bounds, i) => ({
-          AABBBounds: bounds,
-          value: scaleTicks[i]
-        }));
-        for (; items.length >= 3 && hasOverlap(items, labelGap);) items = methods.parity(items);
-        const ticks = items.map(item => item.value);
-        ticks.length < 3 && labelFlush && (ticks.length > 1 && ticks.pop(), last(ticks) !== last(scaleTicks) && ticks.push(last(scaleTicks))), scaleTicks = ticks;
-      }
-      return convertDomainToTickData(scaleTicks);
+        if (!isContinuous(scale.type)) {
+            return convertDomainToTickData(scale.domain());
+        }
+        const range = scale.range();
+        const rangeSize = Math.abs(range[range.length - 1] - range[0]);
+        if (rangeSize < 2) {
+            return convertDomainToTickData([scale.domain()[0]]);
+        }
+        const { tickCount, forceTickCount, tickStep, noDecimals = false, labelStyle } = op;
+        let scaleTicks;
+        if (isValid$3(tickStep)) {
+            scaleTicks = scale.stepTicks(tickStep);
+        }
+        else if (isValid$3(forceTickCount)) {
+            scaleTicks = scale.forceTicks(forceTickCount);
+        }
+        else if (op.tickMode === 'd3') {
+            const count = isFunction$1(tickCount) ? tickCount({ axisLength: rangeSize, labelStyle }) : tickCount;
+            scaleTicks = scale.d3Ticks(count ?? DEFAULT_CONTINUOUS_TICK_COUNT$1, { noDecimals });
+        }
+        else {
+            const count = isFunction$1(tickCount) ? tickCount({ axisLength: rangeSize, labelStyle }) : tickCount;
+            scaleTicks = scale.ticks(count ?? DEFAULT_CONTINUOUS_TICK_COUNT$1, { noDecimals });
+        }
+        if (op.sampling) {
+            if (op.coordinateType === 'cartesian' || (op.coordinateType === 'polar' && op.axisOrientType === 'radius')) {
+                const { labelGap = 4, labelFlush } = op;
+                let items = getCartesianLabelBounds(scale, scaleTicks, op).map((bounds, i) => ({
+                    AABBBounds: bounds,
+                    value: scaleTicks[i]
+                }));
+                while (items.length >= 3 && hasOverlap(items, labelGap)) {
+                    items = methods.parity(items);
+                }
+                const ticks = items.map(item => item.value);
+                if (ticks.length < 3 && labelFlush) {
+                    if (ticks.length > 1) {
+                        ticks.pop();
+                    }
+                    if (last(ticks) !== last(scaleTicks)) {
+                        ticks.push(last(scaleTicks));
+                    }
+                }
+                scaleTicks = ticks;
+            }
+        }
+        return convertDomainToTickData(scaleTicks);
     };
     const methods = {
-      parity: function (items) {
-        return items.filter((item, i) => i % 2 == 0);
-      },
-      greedy: function (items, sep) {
-        let a;
-        return items.filter((b, i) => (!i || !intersect(a.AABBBounds, b.AABBBounds, sep)) && (a = b, !0));
-      }
+        parity: function (items) {
+            return items.filter((item, i) => i % 2 === 0);
+        },
+        greedy: function (items, sep) {
+            let a;
+            return items.filter((b, i) => {
+                if (!i || !intersect(a.AABBBounds, b.AABBBounds, sep)) {
+                    a = b;
+                    return true;
+                }
+                return false;
+            });
+        }
     };
 
     const binaryFuzzySearchInNumberRange = (x1, x2, compareFn) => {
-      let left = x1,
-        right = x2;
-      for (; left < right;) {
-        const mid = Math.floor((left + right) / 2);
-        compareFn(mid) >= 0 ? right = mid : left = mid + 1;
-      }
-      return left;
+        let left = x1;
+        let right = x2;
+        while (left < right) {
+            const mid = Math.floor((left + right) / 2);
+            if (compareFn(mid) >= 0) {
+                right = mid;
+            }
+            else {
+                left = mid + 1;
+            }
+        }
+        return left;
     };
 
-    const getOneDimensionalLabelBounds = (scale, domain, op, isHorizontal) => getCartesianLabelBounds(scale, domain, op).map(bounds => isHorizontal ? [bounds.x1, bounds.x2, bounds.width()] : [bounds.y1, bounds.y2, bounds.height()]),
-      boundsOverlap = function (prevBounds, nextBounds) {
-        let gap = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    const getOneDimensionalLabelBounds = (scale, domain, op, isHorizontal) => {
+        const labelBoundsList = getCartesianLabelBounds(scale, domain, op);
+        return labelBoundsList.map(bounds => {
+            if (isHorizontal) {
+                return [bounds.x1, bounds.x2, bounds.width()];
+            }
+            return [bounds.y1, bounds.y2, bounds.height()];
+        });
+    };
+    const boundsOverlap = (prevBounds, nextBounds, gap = 0) => {
         return Math.max(prevBounds[0], nextBounds[0]) - gap / 2 <= Math.min(prevBounds[1], nextBounds[1]) + gap / 2;
-      };
-    const boundsDistance = (prevBounds, nextBounds) => prevBounds[1] < nextBounds[0] ? nextBounds[0] - prevBounds[1] : nextBounds[1] < prevBounds[0] ? prevBounds[0] - nextBounds[1] : 0;
+    };
+    const boundsDistance = (prevBounds, nextBounds) => {
+        if (prevBounds[1] < nextBounds[0]) {
+            return nextBounds[0] - prevBounds[1];
+        }
+        else if (nextBounds[1] < prevBounds[0]) {
+            return prevBounds[0] - nextBounds[1];
+        }
+        return 0;
+    };
     const linearDiscreteTicks = (scale, op) => {
-      var _a;
-      const domain = scale.domain();
-      if (!domain.length) return [];
-      const {
-          tickCount: tickCount,
-          forceTickCount: forceTickCount,
-          tickStep: tickStep,
-          labelGap = 4,
-          axisOrientType: axisOrientType,
-          labelStyle: labelStyle
-        } = op,
-        isHorizontal = isAxisHorizontal(axisOrientType),
-        range = scale.range(),
-        rangeSize = scale.calculateWholeRangeSize();
-      if (rangeSize < 2) return op.labelLastVisible ? convertDomainToTickData([domain[domain.length - 1]]) : convertDomainToTickData([domain[0]]);
-      let scaleTicks;
-      if (isValid$3(tickStep)) scaleTicks = scale.stepTicks(tickStep);else if (isValid$3(forceTickCount)) scaleTicks = scale.forceTicks(forceTickCount);else if (isValid$3(tickCount)) {
-        const count = isFunction$1(tickCount) ? tickCount({
-          axisLength: rangeSize,
-          labelStyle: labelStyle
-        }) : tickCount;
-        scaleTicks = scale.ticks(count);
-      } else if (op.sampling) {
-        const fontSize = (null !== (_a = op.labelStyle.fontSize) && void 0 !== _a ? _a : 12) + 2,
-          rangeStart = minInArray(range),
-          rangeEnd = maxInArray(range);
-        if (domain.length <= rangeSize / fontSize) {
-          const incrementUnit = (rangeEnd - rangeStart) / domain.length,
-            labelBoundsList = getOneDimensionalLabelBounds(scale, domain, op, isHorizontal),
-            minBoundsLength = Math.min(...labelBoundsList.map(bounds => bounds[2])),
-            stepResult = getStep$1(domain, labelBoundsList, labelGap, op.labelLastVisible, Math.floor(minBoundsLength / incrementUnit), !1);
-          scaleTicks = scale.stepTicks(stepResult.step), op.labelLastVisible && (stepResult.delCount && (scaleTicks = scaleTicks.slice(0, scaleTicks.length - stepResult.delCount)), scaleTicks.push(domain[domain.length - 1]));
-        } else {
-          const tempDomain = [domain[0], domain[Math.floor(domain.length / 2)], domain[domain.length - 1]],
-            tempList = getOneDimensionalLabelBounds(scale, tempDomain, op, isHorizontal);
-          let maxBounds = null;
-          tempList.forEach(current => {
-            maxBounds ? maxBounds[2] < current[2] && (maxBounds = current) : maxBounds = current;
-          });
-          const step = rangeEnd - rangeStart - labelGap > 0 ? Math.ceil(domain.length * (labelGap + maxBounds[2]) / (rangeEnd - rangeStart - labelGap)) : domain.length - 1;
-          scaleTicks = scale.stepTicks(step), !op.labelLastVisible || scaleTicks.length && scaleTicks[scaleTicks.length - 1] === domain[domain.length - 1] || (scaleTicks.length && Math.abs(scale.scale(scaleTicks[scaleTicks.length - 1]) - scale.scale(domain[domain.length - 1])) < maxBounds[2] && (scaleTicks = scaleTicks.slice(0, -1)), scaleTicks.push(domain[domain.length - 1]));
+        const domain = scale.domain();
+        if (!domain.length) {
+            return [];
+        }
+        const { tickCount, forceTickCount, tickStep, labelGap = 4, axisOrientType, labelStyle } = op;
+        const isHorizontal = isAxisHorizontal(axisOrientType);
+        const range = scale.range();
+        const rangeSize = scale.calculateWholeRangeSize();
+        if (rangeSize < 2) {
+            if (op.labelLastVisible) {
+                return convertDomainToTickData([domain[domain.length - 1]]);
+            }
+            return convertDomainToTickData([domain[0]]);
+        }
+        let scaleTicks;
+        if (isValid$3(tickStep)) {
+            scaleTicks = scale.stepTicks(tickStep);
+        }
+        else if (isValid$3(forceTickCount)) {
+            scaleTicks = scale.forceTicks(forceTickCount);
+        }
+        else if (isValid$3(tickCount)) {
+            const count = isFunction$1(tickCount) ? tickCount({ axisLength: rangeSize, labelStyle }) : tickCount;
+            scaleTicks = scale.ticks(count);
+        }
+        else if (op.sampling) {
+            const fontSize = (op.labelStyle.fontSize ?? 12) + 2;
+            const rangeStart = minInArray(range);
+            const rangeEnd = maxInArray(range);
+            if (domain.length <= rangeSize / fontSize) {
+                const incrementUnit = (rangeEnd - rangeStart) / domain.length;
+                const labelBoundsList = getOneDimensionalLabelBounds(scale, domain, op, isHorizontal);
+                const minBoundsLength = Math.min(...labelBoundsList.map(bounds => bounds[2]));
+                const stepResult = getStep$1(domain, labelBoundsList, labelGap, op.labelLastVisible, Math.floor(minBoundsLength / incrementUnit), false);
+                scaleTicks = scale.stepTicks(stepResult.step);
+                if (op.labelLastVisible) {
+                    if (stepResult.delCount) {
+                        scaleTicks = scaleTicks.slice(0, scaleTicks.length - stepResult.delCount);
+                    }
+                    scaleTicks.push(domain[domain.length - 1]);
+                }
+            }
+            else {
+                const tempDomain = [domain[0], domain[Math.floor(domain.length / 2)], domain[domain.length - 1]];
+                const tempList = getOneDimensionalLabelBounds(scale, tempDomain, op, isHorizontal);
+                let maxBounds = null;
+                tempList.forEach(current => {
+                    if (!maxBounds) {
+                        maxBounds = current;
+                        return;
+                    }
+                    if (maxBounds[2] < current[2]) {
+                        maxBounds = current;
+                    }
+                });
+                const step = rangeEnd - rangeStart - labelGap > 0
+                    ? Math.ceil((domain.length * (labelGap + maxBounds[2])) / (rangeEnd - rangeStart - labelGap))
+                    : domain.length - 1;
+                scaleTicks = scale.stepTicks(step);
+                if (op.labelLastVisible &&
+                    (!scaleTicks.length || scaleTicks[scaleTicks.length - 1] !== domain[domain.length - 1])) {
+                    if (scaleTicks.length &&
+                        Math.abs(scale.scale(scaleTicks[scaleTicks.length - 1]) - scale.scale(domain[domain.length - 1])) <
+                            maxBounds[2]) {
+                        scaleTicks = scaleTicks.slice(0, -1);
+                    }
+                    scaleTicks.push(domain[domain.length - 1]);
+                }
+            }
         }
-      } else scaleTicks = scale.domain();
-      return convertDomainToTickData(scaleTicks);
+        else {
+            scaleTicks = scale.domain();
+        }
+        return convertDomainToTickData(scaleTicks);
     };
     const getStep$1 = (domain, labelBoundsList, labelGap, labelLastVisible, defaultStep, areAllBoundsSame) => {
-      let resultDelCount = 0,
-        resultStep = 0,
-        resultTickCount = -1,
-        minDiff = Number.MAX_VALUE;
-      const validateStep = step => {
-          let success = !0,
-            ptr = 0;
-          do {
-            ptr + step < domain.length && boundsOverlap(labelBoundsList[ptr], labelBoundsList[ptr + step], labelGap) && (success = !1), ptr += step;
-          } while (success && ptr < domain.length);
-          return success;
-        },
-        minValidStep = binaryFuzzySearchInNumberRange(defaultStep, domain.length, step => validateStep(step) ? 1 : -1);
-      let step = minValidStep;
-      do {
-        if (step > minValidStep && !areAllBoundsSame && !validateStep(step)) step++;else {
-          if (!labelLastVisible) {
-            resultStep = step;
-            break;
-          }
-          {
-            const lastIndex = domain.length - 1;
-            let ptr,
-              delCount = 0;
-            ptr = domain.length % step > 0 ? domain.length - domain.length % step + step : domain.length;
+        let resultDelCount = 0;
+        let resultStep = 0;
+        let resultTickCount = -1;
+        let minDiff = Number.MAX_VALUE;
+        const validateStep = (step) => {
+            let success = true;
+            let ptr = 0;
             do {
-              if (ptr -= step, ptr !== lastIndex && !boundsOverlap(labelBoundsList[ptr], labelBoundsList[lastIndex], labelGap)) break;
-              delCount++;
-            } while (ptr > 0);
-            if (ptr === lastIndex) {
-              resultStep = step, resultDelCount = delCount;
-              break;
+                if (ptr + step < domain.length && boundsOverlap(labelBoundsList[ptr], labelBoundsList[ptr + step], labelGap)) {
+                    success = false;
+                }
+                ptr += step;
+            } while (success && ptr < domain.length);
+            return success;
+        };
+        const minValidStep = binaryFuzzySearchInNumberRange(defaultStep, domain.length, step => validateStep(step) ? 1 : -1);
+        let step = minValidStep;
+        do {
+            if (step > minValidStep && !areAllBoundsSame) {
+                if (!validateStep(step)) {
+                    step++;
+                    continue;
+                }
             }
-            {
-              const tickCount = Math.floor(domain.length / step) - delCount + 1;
-              if (tickCount < resultTickCount) break;
-              {
-                resultTickCount = tickCount;
-                const distance1 = boundsDistance(labelBoundsList[ptr], labelBoundsList[lastIndex]),
-                  distance2 = ptr - step >= 0 ? boundsDistance(labelBoundsList[ptr - step], labelBoundsList[ptr]) : distance1,
-                  diff = Math.abs(distance1 - distance2);
-                if (diff < minDiff && (minDiff = diff, resultStep = step, resultDelCount = delCount), distance1 <= distance2) break;
-              }
+            if (labelLastVisible) {
+                const lastIndex = domain.length - 1;
+                let delCount = 0;
+                let ptr;
+                if (domain.length % step > 0) {
+                    ptr = domain.length - (domain.length % step) + step;
+                }
+                else {
+                    ptr = domain.length;
+                }
+                do {
+                    ptr -= step;
+                    if (ptr === lastIndex || boundsOverlap(labelBoundsList[ptr], labelBoundsList[lastIndex], labelGap)) {
+                        delCount++;
+                    }
+                    else {
+                        break;
+                    }
+                } while (ptr > 0);
+                if (ptr === lastIndex) {
+                    resultStep = step;
+                    resultDelCount = delCount;
+                    break;
+                }
+                else {
+                    const tickCount = Math.floor(domain.length / step) - delCount + 1;
+                    if (tickCount < resultTickCount) {
+                        break;
+                    }
+                    else {
+                        resultTickCount = tickCount;
+                        const distance1 = boundsDistance(labelBoundsList[ptr], labelBoundsList[lastIndex]);
+                        const distance2 = ptr - step >= 0 ? boundsDistance(labelBoundsList[ptr - step], labelBoundsList[ptr]) : distance1;
+                        const diff = Math.abs(distance1 - distance2);
+                        if (diff < minDiff) {
+                            minDiff = diff;
+                            resultStep = step;
+                            resultDelCount = delCount;
+                        }
+                        if (distance1 <= distance2) {
+                            break;
+                        }
+                    }
+                }
             }
-          }
-          step++;
-        }
-      } while (step <= domain.length);
-      return {
-        step: resultStep,
-        delCount: resultDelCount
-      };
+            else {
+                resultStep = step;
+                break;
+            }
+            step++;
+        } while (step <= domain.length);
+        return {
+            step: resultStep,
+            delCount: resultDelCount
+        };
     };
 
     const polarAngleAxisDiscreteTicks = (scale, op) => {
-      const {
-          tickCount: tickCount,
-          forceTickCount: forceTickCount,
-          tickStep: tickStep,
-          getRadius: getRadius,
-          labelOffset: labelOffset,
-          labelGap = 0,
-          labelStyle: labelStyle
-        } = op,
-        radius = null == getRadius ? void 0 : getRadius();
-      if (!radius) return convertDomainToTickData(scale.domain());
-      let scaleTicks;
-      if (isValid$3(tickStep)) scaleTicks = scale.stepTicks(tickStep);else if (isValid$3(forceTickCount)) scaleTicks = scale.forceTicks(forceTickCount);else if (isValid$3(tickCount)) {
-        const range = scale.range(),
-          rangeSize = Math.abs(range[range.length - 1] - range[0]),
-          count = isFunction$1(tickCount) ? tickCount({
-            axisLength: rangeSize,
-            labelStyle: labelStyle
-          }) : tickCount;
-        scaleTicks = scale.ticks(count);
-      } else if (op.sampling) {
-        const domain = scale.domain(),
-          range = scale.range(),
-          labelBoundsList = getPolarAngleLabelBounds(scale, domain, op),
-          rangeStart = minInArray(range),
-          rangeEnd = maxInArray(range),
-          incrementUnit = Math.abs(rangeEnd - rangeStart) * (radius + labelOffset) / domain.length,
-          {
-            step: step,
-            delCount: delCount
-          } = getStep(domain, labelBoundsList, labelGap, Math.floor(labelBoundsList.reduce((min, curBounds) => Math.min(min, curBounds.width(), curBounds.height()), Number.MAX_VALUE) / incrementUnit));
-        scaleTicks = scale.stepTicks(step), scaleTicks = scaleTicks.slice(0, scaleTicks.length - delCount);
-      } else scaleTicks = scale.domain();
-      return convertDomainToTickData(scaleTicks);
+        const { tickCount, forceTickCount, tickStep, getRadius, labelOffset, labelGap = 0, labelStyle } = op;
+        const radius = getRadius?.();
+        if (!radius) {
+            return convertDomainToTickData(scale.domain());
+        }
+        let scaleTicks;
+        if (isValid$3(tickStep)) {
+            scaleTicks = scale.stepTicks(tickStep);
+        }
+        else if (isValid$3(forceTickCount)) {
+            scaleTicks = scale.forceTicks(forceTickCount);
+        }
+        else if (isValid$3(tickCount)) {
+            const range = scale.range();
+            const rangeSize = Math.abs(range[range.length - 1] - range[0]);
+            const count = isFunction$1(tickCount) ? tickCount({ axisLength: rangeSize, labelStyle }) : tickCount;
+            scaleTicks = scale.ticks(count);
+        }
+        else if (op.sampling) {
+            const domain = scale.domain();
+            const range = scale.range();
+            const labelBoundsList = getPolarAngleLabelBounds(scale, domain, op);
+            const rangeStart = minInArray(range);
+            const rangeEnd = maxInArray(range);
+            const axisLength = Math.abs(rangeEnd - rangeStart) * (radius + labelOffset);
+            const incrementUnit = axisLength / domain.length;
+            const { step, delCount } = getStep(domain, labelBoundsList, labelGap, Math.floor(labelBoundsList.reduce((min, curBounds) => {
+                return Math.min(min, curBounds.width(), curBounds.height());
+            }, Number.MAX_VALUE) / incrementUnit));
+            scaleTicks = scale.stepTicks(step);
+            scaleTicks = scaleTicks.slice(0, scaleTicks.length - delCount);
+        }
+        else {
+            scaleTicks = scale.domain();
+        }
+        return convertDomainToTickData(scaleTicks);
     };
     const getStep = (domain, labelBoundsList, labelGap, defaultStep) => {
-      let step = defaultStep;
-      do {
-        let success = !0;
-        step++;
-        let ptr = 0;
+        let step = defaultStep;
         do {
-          ptr + step < domain.length && labelOverlap(labelBoundsList[ptr], labelBoundsList[ptr + step], labelGap) && (success = !1), ptr += step;
-        } while (success && ptr < domain.length);
-        if (success) break;
-      } while (step <= domain.length);
-      let delCount = 0;
-      if (domain.length > 2) {
-        let ptr = domain.length - domain.length % step;
-        for (ptr >= domain.length && (ptr -= step); ptr > 0 && labelOverlap(labelBoundsList[0], labelBoundsList[ptr]);) delCount++, ptr -= step;
-      }
-      return {
-        step: step,
-        delCount: delCount
-      };
+            let success = true;
+            step++;
+            let ptr = 0;
+            do {
+                if (ptr + step < domain.length && labelOverlap(labelBoundsList[ptr], labelBoundsList[ptr + step], labelGap)) {
+                    success = false;
+                }
+                ptr += step;
+            } while (success && ptr < domain.length);
+            if (success) {
+                break;
+            }
+        } while (step <= domain.length);
+        let delCount = 0;
+        if (domain.length > 2) {
+            let ptr = domain.length - (domain.length % step);
+            if (ptr >= domain.length) {
+                ptr -= step;
+            }
+            while (ptr > 0 && labelOverlap(labelBoundsList[0], labelBoundsList[ptr])) {
+                delCount++;
+                ptr -= step;
+            }
+        }
+        return {
+            step,
+            delCount
+        };
     };
 
     const ticks = (scale, op) => {
-      if (isContinuous(scale.type)) return continuousTicks(scale, op);
-      if (isDiscrete(scale.type)) {
-        if ("cartesian" === op.coordinateType) return linearDiscreteTicks(scale, op);
-        if ("polar" === op.coordinateType && "angle" === op.axisOrientType) return polarAngleAxisDiscreteTicks(scale, op);
-      }
-      return convertDomainToTickData(scale.domain());
+        if (isContinuous(scale.type)) {
+            return continuousTicks(scale, op);
+        }
+        else if (isDiscrete(scale.type)) {
+            if (op.coordinateType === 'cartesian') {
+                return linearDiscreteTicks(scale, op);
+            }
+            else if (op.coordinateType === 'polar') {
+                if (op.axisOrientType === 'angle') {
+                    return polarAngleAxisDiscreteTicks(scale, op);
+                }
+            }
+        }
+        return convertDomainToTickData(scale.domain());
     };
 
     function isDataView(obj) {
-      return obj instanceof DataView;
+        return obj instanceof DataView;
     }
     function isHTMLElement(obj) {
-      try {
-        return obj instanceof Element;
-      } catch (_a) {
-        const htmlElementKeys = ["children", "innerHTML", "classList", "setAttribute", "tagName", "getBoundingClientRect"],
-          keys = Object.keys(obj);
-        return htmlElementKeys.every(key => keys.includes(key));
-      }
+        try {
+            return obj instanceof Element;
+        }
+        catch {
+            const htmlElementKeys = [
+                'children',
+                'innerHTML',
+                'classList',
+                'setAttribute',
+                'tagName',
+                'getBoundingClientRect'
+            ];
+            const keys = Object.keys(obj);
+            return htmlElementKeys.every(key => keys.includes(key));
+        }
     }
 
-    function cloneDeepSpec(spec) {
-      let excludeKeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ["data"];
-      const value = spec;
-      let result;
-      if (!isValid$3(value) || "object" != typeof value) return value;
-      if (isDataView(value) || isHTMLElement(value)) return value;
-      const isArr = isArray$3(value),
-        length = value.length;
-      result = isArr ? new Array(length) : "object" == typeof value ? {} : isBoolean$2(value) || isNumber$4(value) || isString$2(value) ? value : isDate$1(value) ? new Date(+value) : void 0;
-      const props = isArr ? void 0 : Object.keys(Object(value));
-      let index = -1;
-      if (result) for (; ++index < (props || value).length;) {
-        const key = props ? props[index] : index,
-          subValue = value[key];
-        (null == excludeKeys ? void 0 : excludeKeys.includes(key.toString())) ? result[key] = subValue : result[key] = cloneDeepSpec(subValue, excludeKeys);
-      }
-      return result;
+    function cloneDeepSpec(spec, excludeKeys = ['data']) {
+        const value = spec;
+        let result;
+        if (!isValid$3(value) || typeof value !== 'object') {
+            return value;
+        }
+        if (isDataView(value) || isHTMLElement(value)) {
+            return value;
+        }
+        const isArr = isArray$3(value);
+        const length = value.length;
+        if (isArr) {
+            result = new Array(length);
+        }
+        else if (typeof value === 'object') {
+            result = {};
+        }
+        else if (isBoolean$2(value) || isNumber$4(value) || isString$2(value)) {
+            result = value;
+        }
+        else if (isDate$1(value)) {
+            result = new Date(+value);
+        }
+        else {
+            result = undefined;
+        }
+        const props = isArr ? undefined : Object.keys(Object(value));
+        let index = -1;
+        if (result) {
+            while (++index < (props || value).length) {
+                const key = props ? props[index] : index;
+                const subValue = value[key];
+                if (excludeKeys?.includes(key.toString())) {
+                    result[key] = subValue;
+                }
+                else {
+                    result[key] = cloneDeepSpec(subValue, excludeKeys);
+                }
+            }
+        }
+        return result;
     }
 
     const e10 = Math.sqrt(50);
@@ -58071,7 +58244,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "0.25.2";
+        version = "0.25.3";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -70734,7 +70907,7 @@
     }
 
     registerForVrender();
-    const version = "0.25.2";
+    const version = "0.25.3";
     function getIcons() {
         return get$2();
     }