tvcharts 0.6.63 → 0.6.65

package/dist/echarts.js

@@ -11434,6 +11434,16 @@ var setCommonECData = (seriesIndex, dataType, dataIdx, el) => {
   }
 };
 
+// src/util/seriesType.ts
+var candleArr = ["candlestick", "candlePlot", "barPlot"];
+function isCandle(type) {
+  return candleArr.includes(type);
+}
+var plotsArr = ["labels", "linesPlot", "charPlot", "arrowsPlot"];
+function isPlot(type) {
+  return plotsArr.includes(type);
+}
+
 // src/chart/helper/createRenderPlanner.ts
 function createRenderPlanner() {
   const inner24 = makeInner();
@@ -11461,10 +11471,10 @@ var candlestickVisual = {
   plan: createRenderPlanner(),
   performRawSeries: true,
   reset: function(seriesModel, ecModel) {
-    function getColor(sign, model) {
+    function getColor3(sign, model) {
       return model.get(sign > 0 ? positiveColorQuery : negativeColorQuery);
     }
-    function getBorderColor(sign, model) {
+    function getBorderColor2(sign, model) {
       return model.get(sign === 0 ? dojiBorderColorQuery : sign > 0 ? positiveBorderColorQuery : negativeBorderColorQuery);
     }
     if (ecModel.isSeriesFiltered(seriesModel)) {
@@ -11478,8 +11488,8 @@ var candlestickVisual = {
           const itemModel = data.getItemModel(dataIndex);
           const sign = data.getItemLayout(dataIndex).sign;
           const style = itemModel.getItemStyle();
-          style.fill = getColor(sign, itemModel);
-          style.stroke = getBorderColor(sign, itemModel) || style.fill;
+          style.fill = getColor3(sign, itemModel);
+          style.stroke = getBorderColor2(sign, itemModel) || style.fill;
           const existsStyle = data.ensureUniqueItemVisual(dataIndex, "style");
           extend(existsStyle, style);
         }
@@ -11947,8 +11957,8 @@ function getSeriesPointData(ecModel, payload = {}) {
     index = Math.min(lastIndex, index);
     let values = isRaw ? data.getValuesByRawIndex(index) : data.getValues(index);
     let color2 = data.getItemVisual(index, "style")?.fill;
-    const isCandlesStick = seriesModel.subType === "candlestick";
-    const dim = seriesModel.subType === "candlestick" ? "close" : "y";
+    const isCandlesStick = isCandle(seriesModel.subType);
+    const dim = isCandlesStick ? "close" : "y";
     const fnKey = isRaw ? "getByRawIndex" : "get";
     if (isCandlesStick) {
       const closeValue = data[fnKey]("close", index);
@@ -11959,7 +11969,7 @@ function getSeriesPointData(ecModel, payload = {}) {
       if (fill) {
         color2 = fill;
       }
-    } else if (["linesPlot", "labels"].includes(seriesModel.subType)) {
+    } else if (isPlot(seriesModel.subType)) {
       const isLinesPlot = seriesModel.subType === "linesPlot";
       const dataItem = data.getItemModel(index, isRaw);
       const fill = dataItem.get([isLinesPlot ? "lineStyle" : "itemStyle", "color"]);
@@ -16283,6 +16293,9 @@ var BUILTIN_CHARTS_MAP = {
   labels: "LabelsChart",
   hlines: "HLinesChart",
   fills: "FillsChart",
+  arrowsPlot: "ArrowsPlotChart",
+  candlePlot: "CandlePlotChart",
+  barPlot: "BarPlotChart",
   bgcolor: "BgColorChart",
   heatmap: "HeatmapChart",
   pictorialBar: "PictorialBarChart",
@@ -16380,7 +16393,7 @@ var GlobalModel = class extends Model_default {
         return;
       }
       if (!Component_default.hasClass(mainType)) {
-        option[mainType] = option[mainType] == null ? clone(componentOption) : merge(option[mainType], componentOption, true);
+        option[mainType] = option[mainType] == null && ~mainType.indexOf("custom") ? clone(componentOption) : merge(option[mainType], componentOption, true);
       } else if (mainType) {
         newCmptTypes.push(mainType);
         newCmptTypeMap.set(mainType, true);
@@ -38626,7 +38639,7 @@ var Cartesian2D = class extends Cartesian_default {
     const seriesModal = this.seriesModal;
     if (seriesModal) {
       const seriesData = seriesModal.getData();
-      const dim = seriesModal.subType === "candlestick" ? "close" : "y";
+      const dim = isCandle(seriesModal.subType) ? "close" : "y";
       baseValue = seriesData.get(dim, 0);
     }
     return baseValue;
@@ -49289,7 +49302,7 @@ var GaugeView2 = class extends Chart_default {
     }
     sectors.reverse();
     each(sectors, (sector) => group.add(sector));
-    const getColor = function(percent) {
+    const getColor3 = function(percent) {
       if (percent <= 0) {
         return colorList[0][1];
       }
@@ -49301,12 +49314,12 @@ var GaugeView2 = class extends Chart_default {
       }
       return colorList[i - 1][1];
     };
-    this._renderTicks(seriesModel, ecModel, api2, getColor, posInfo, startAngle, endAngle, clockwise, axisLineWidth);
-    this._renderTitleAndDetail(seriesModel, ecModel, api2, getColor, posInfo);
+    this._renderTicks(seriesModel, ecModel, api2, getColor3, posInfo, startAngle, endAngle, clockwise, axisLineWidth);
+    this._renderTitleAndDetail(seriesModel, ecModel, api2, getColor3, posInfo);
     this._renderAnchor(seriesModel, posInfo);
-    this._renderPointer(seriesModel, ecModel, api2, getColor, posInfo, startAngle, endAngle, clockwise, axisLineWidth);
+    this._renderPointer(seriesModel, ecModel, api2, getColor3, posInfo, startAngle, endAngle, clockwise, axisLineWidth);
   }
-  _renderTicks(seriesModel, ecModel, api2, getColor, posInfo, startAngle, endAngle, clockwise, axisLineWidth) {
+  _renderTicks(seriesModel, ecModel, api2, getColor3, posInfo, startAngle, endAngle, clockwise, axisLineWidth) {
     const group = this.group;
     const cx = posInfo.cx;
     const cy = posInfo.cy;
@@ -49345,7 +49358,7 @@ var GaugeView2 = class extends Chart_default {
         });
         if (splitLineStyle.stroke === "auto") {
           splitLine.setStyle({
-            stroke: getColor(i / splitNumber)
+            stroke: getColor3(i / splitNumber)
           });
         }
         group.add(splitLine);
@@ -49353,7 +49366,7 @@ var GaugeView2 = class extends Chart_default {
       if (labelModel.get("show")) {
         const distance2 = labelModel.get("distance") + splitLineDistance;
         const label = formatLabel(round(i / splitNumber * (maxVal - minVal) + minVal), labelModel.get("formatter"));
-        const autoColor = getColor(i / splitNumber);
+        const autoColor = getColor3(i / splitNumber);
         const textStyleX = unitX * (r - splitLineLen - distance2) + cx;
         const textStyleY = unitY * (r - splitLineLen - distance2) + cy;
         const rotateType = labelModel.get("rotate");
@@ -49417,7 +49430,7 @@ var GaugeView2 = class extends Chart_default {
           });
           if (tickLineStyle.stroke === "auto") {
             tickLine.setStyle({
-              stroke: getColor((i + j / subSplitNumber) / splitNumber)
+              stroke: getColor3((i + j / subSplitNumber) / splitNumber)
             });
           }
           group.add(tickLine);
@@ -49429,7 +49442,7 @@ var GaugeView2 = class extends Chart_default {
       }
     }
   }
-  _renderPointer(seriesModel, ecModel, api2, getColor, posInfo, startAngle, endAngle, clockwise, axisLineWidth) {
+  _renderPointer(seriesModel, ecModel, api2, getColor3, posInfo, startAngle, endAngle, clockwise, axisLineWidth) {
     const group = this.group;
     const oldData = this._data;
     const oldProgressData = this._progressEls;
@@ -49569,7 +49582,7 @@ var GaugeView2 = class extends Chart_default {
           }
           pointer.setStyle(itemModel.getModel(["pointer", "itemStyle"]).getItemStyle());
           if (pointer.style.fill === "auto") {
-            pointer.setStyle("fill", getColor(linearMap(data.get(valueDim, idx), valueExtent, [0, 1], true)));
+            pointer.setStyle("fill", getColor3(linearMap(data.get(valueDim, idx), valueExtent, [0, 1], true)));
           }
           pointer.z2EmphasisLift = 0;
           setStatesStylesFromModel(pointer, itemModel);
@@ -49601,7 +49614,7 @@ var GaugeView2 = class extends Chart_default {
       this.group.add(anchor);
     }
   }
-  _renderTitleAndDetail(seriesModel, ecModel, api2, getColor, posInfo) {
+  _renderTitleAndDetail(seriesModel, ecModel, api2, getColor3, posInfo) {
     const data = seriesModel.getData();
     const valueDim = data.mapDimension("value");
     const minVal = +seriesModel.get("min");
@@ -49626,7 +49639,7 @@ var GaugeView2 = class extends Chart_default {
       const itemModel = data.getItemModel(idx);
       const value = data.get(valueDim, idx);
       const itemGroup = new Group_default();
-      const autoColor = getColor(linearMap(value, [minVal, maxVal], [0, 1], true));
+      const autoColor = getColor3(linearMap(value, [minVal, maxVal], [0, 1], true));
       const itemTitleModel = itemModel.getModel("title");
       if (itemTitleModel.get("show")) {
         const titleOffsetCenter = itemTitleModel.get("offsetCenter");
@@ -56400,7 +56413,8 @@ MineLinesSeriesModel.defaultOption = {
   },
   large: true,
   largeThreshold: 600,
-  clip: true
+  clip: true,
+  statusLineInvisible: true
 };
 var MineLinesSeries_default = MineLinesSeriesModel;
 
@@ -56628,7 +56642,8 @@ LineFillsSeriesModel.defaultOption = {
   large: true,
   largeThreshold: 600,
   clip: true,
-  notFilterData: true
+  notFilterData: true,
+  statusLineInvisible: true
 };
 var LineFillsSeries_default = LineFillsSeriesModel;
 
@@ -56901,7 +56916,8 @@ BoxesSeriesModel.defaultOption = {
   },
   large: true,
   largeThreshold: 600,
-  clip: true
+  clip: true,
+  statusLineInvisible: true
 };
 var BoxesSeries_default = BoxesSeriesModel;
 
@@ -57164,11 +57180,9 @@ var CharPlotView2 = class extends Chart_default {
       textGroup.add(el);
     });
     const location = seriesModel.get("location");
-    let vAlign = "top";
+    let vAlign = "middle";
     if (["abovebar", "bottom", "absolute"].includes(location)) {
       vAlign = "bottom";
-    } else if (location === "belowbar" || location === "top") {
-      return fontSize;
     }
     each(textList, function(item) {
       const el = new Text_default({
@@ -57278,7 +57292,7 @@ var CharPlotLayout = {
             continue;
           }
           const itemModel = data.getItemModel(i);
-          const {color: color2, text_color} = itemModel.get("itemStyle");
+          const {color: color2, textcolor} = itemModel.get("itemStyle");
           const point = coordSys.dataToPoint(tmpIn);
           const x = point[0];
           const y = price ?? point[1] + distance2;
@@ -57289,7 +57303,7 @@ var CharPlotLayout = {
               textColor: color2
             });
           }
-          const textColor = text_color || color2;
+          const textColor = textcolor || color2;
           if (text && textColor) {
             textList.push({
               x,
@@ -57316,6 +57330,781 @@ function install29(registers) {
   registers.registerLayout(CharPlotLayout_default);
 }
 
+// src/chart/candlePlot/NormalBoxPath.ts
+var NormalBoxPathShape2 = class {
+};
+var NormalBoxPath2 = class extends Path_default {
+  constructor(opts) {
+    super(opts);
+    this.type = "normalCandlePlotBox";
+  }
+  getDefaultShape() {
+    return new NormalBoxPathShape2();
+  }
+  buildPath(ctx2, shape) {
+    const {points: points4, isSimpleBox} = shape;
+    for (let index = 0; index < points4.length; ) {
+      const point1 = points4[index++];
+      const point2 = points4[index++];
+      const point3 = points4[index++];
+      const point4 = points4[index++];
+      if (isSimpleBox) {
+        const x = point1[0];
+        ctx2.moveTo(x, point1[1]);
+        ctx2.lineTo(x, point3[1]);
+      } else {
+        ctx2.moveTo(point1[0], point1[1]);
+        ctx2.lineTo(point2[0], point2[1]);
+        ctx2.lineTo(point3[0], point3[1]);
+        ctx2.lineTo(point4[0], point4[1]);
+        ctx2.closePath();
+      }
+    }
+  }
+};
+var NormalBoxPath_default = NormalBoxPath2;
+
+// src/chart/candlePlot/WickPath.ts
+var WickPathShape = class {
+};
+var WickPath = class extends Path_default {
+  constructor(opts) {
+    super(opts);
+    this.type = "wickPath";
+  }
+  getDefaultShape() {
+    return new WickPathShape();
+  }
+  buildPath(ctx2, shape) {
+    const {points: points4} = shape;
+    for (let index = 0; index < points4.length; ) {
+      const point1 = points4[index++];
+      const point2 = points4[index++];
+      const point3 = points4[index++];
+      const point4 = points4[index++];
+      ctx2.moveTo(point1[0], point1[1]);
+      ctx2.lineTo(point2[0], point2[1]);
+      ctx2.moveTo(point3[0], point3[1]);
+      ctx2.lineTo(point4[0], point4[1]);
+    }
+  }
+};
+var WickPath_default = WickPath;
+
+// src/chart/candlePlot/CandlePlotView.ts
+var CandlePlotView2 = class extends Chart_default {
+  constructor() {
+    super(...arguments);
+    this.type = CandlePlotView2.type;
+  }
+  render(seriesModel, ecModel, api2) {
+    this._progressiveEls = null;
+    this._renderNormal(seriesModel);
+  }
+  eachRendered(cb) {
+    traverseElements(this._progressiveEls || this.group, cb);
+  }
+  _renderNormal(seriesModel) {
+    const data = seriesModel.getData();
+    const group = this.group;
+    group.removeAll();
+    const isSimpleBox = data.getLayout("isSimpleBox");
+    const bodyPointsByColor = data.getLayout("bodyPointsByColor");
+    const wickPointsByColor = data.getLayout("wickPointsByColor");
+    each(bodyPointsByColor, function(points4, key) {
+      const [fill, stroke] = key.split(":");
+      const el = new NormalBoxPath_default({
+        shape: {
+          points: points4,
+          isSimpleBox
+        },
+        style: {
+          fill,
+          stroke
+        }
+      });
+      group.add(el);
+    });
+    each(wickPointsByColor, function(points4, key) {
+      const [stroke] = key.split(":");
+      const el = new WickPath_default({
+        shape: {
+          points: points4
+        },
+        style: {
+          stroke
+        }
+      });
+      group.add(el);
+    });
+    const clipPath = seriesModel.get("clip", true) ? createClipPath(seriesModel.coordinateSystem, false, seriesModel) : null;
+    if (clipPath) {
+      this.group.setClipPath(clipPath);
+    } else {
+      this.group.removeClipPath();
+    }
+  }
+  remove(ecModel) {
+    this._clear();
+  }
+  _clear() {
+    this.group.removeAll();
+  }
+};
+var CandlePlotView = CandlePlotView2;
+CandlePlotView.type = "candlePlot";
+var CandlePlotView_default = CandlePlotView;
+
+// src/chart/candlePlot/CandlePlotSeries.ts
+var CandlePlotSeriesModel2 = class extends Series_default {
+  constructor() {
+    super(...arguments);
+    this.type = CandlePlotSeriesModel2.type;
+    this.defaultValueDimensions = [
+      {name: "open", defaultTooltip: true},
+      {name: "close", defaultTooltip: true},
+      {name: "lowest", defaultTooltip: true},
+      {name: "highest", defaultTooltip: true}
+    ];
+  }
+  getShadowDim() {
+    return "open";
+  }
+};
+var CandlePlotSeriesModel = CandlePlotSeriesModel2;
+CandlePlotSeriesModel.type = "series.candlePlot";
+CandlePlotSeriesModel.dependencies = ["xAxis", "yAxis", "grid"];
+CandlePlotSeriesModel.defaultOption = {
+  z: 2,
+  coordinateSystem: "cartesian2d",
+  legendHoverLink: true,
+  layout: null,
+  clip: true,
+  itemStyle: {
+    color: "#eb5454",
+    color0: "#47b262",
+    borderColor: "#eb5454",
+    borderColor0: "#47b262",
+    wickColor: "#eb5454",
+    wickColor0: "#47b262",
+    borderColorDoji: null,
+    borderWidth: 1
+  },
+  emphasis: {
+    scale: true,
+    itemStyle: {
+      borderWidth: 2
+    }
+  },
+  barMaxWidth: null,
+  barMinWidth: null,
+  barWidth: null,
+  large: true,
+  largeThreshold: 600,
+  progressive: 3e3,
+  progressiveThreshold: 1e4,
+  progressiveChunkMode: "mod",
+  animationEasing: "linear",
+  animationDuration: 300
+};
+mixin(CandlePlotSeriesModel, WhiskerBoxCommonMixin, true);
+var CandlePlotSeries_default = CandlePlotSeriesModel;
+
+// src/chart/candlePlot/candlePlotLayout.ts
+var positiveBorderColorQuery2 = ["itemStyle", "borderColor"];
+var negativeBorderColorQuery2 = ["itemStyle", "borderColor0"];
+var dojiBorderColorQuery2 = ["itemStyle", "borderColorDoji"];
+var positiveColorQuery2 = ["itemStyle", "color"];
+var negativeColorQuery2 = ["itemStyle", "color0"];
+var positiveWickColorQuery = ["itemStyle", "wickColor"];
+var negativeWickColorQuery = ["itemStyle", "wickColor0"];
+function getColor(sign, model) {
+  return model.get(sign > 0 ? positiveColorQuery2 : negativeColorQuery2);
+}
+function getBorderColor(sign, model) {
+  return model.get(sign === 0 ? dojiBorderColorQuery2 : sign > 0 ? positiveBorderColorQuery2 : negativeBorderColorQuery2);
+}
+function getWickColor(sign, model) {
+  return model.get(sign === 0 ? dojiBorderColorQuery2 : sign > 0 ? positiveWickColorQuery : negativeWickColorQuery);
+}
+var candlePlotLayout = {
+  seriesType: "candlePlot",
+  plan: createRenderPlanner(),
+  reset: function(seriesModel) {
+    const coordSys = seriesModel.coordinateSystem;
+    const data = seriesModel.getData();
+    const candleWidth = calculateCandleWidth2(seriesModel, data);
+    const cDimIdx = 0;
+    const vDimIdx = 1;
+    const coordDims = ["x", "y"];
+    const cDimI = data.getDimensionIndex(data.mapDimension(coordDims[cDimIdx]));
+    const vDimsI = map(data.mapDimensionsAll(coordDims[vDimIdx]), data.getDimensionIndex, data);
+    const openDimI = vDimsI[0];
+    const closeDimI = vDimsI[1];
+    const lowestDimI = vDimsI[2];
+    const highestDimI = vDimsI[3];
+    const isSimpleBox = candleWidth <= 1.3;
+    if (cDimI < 0 || vDimsI.length < 4) {
+      return;
+    }
+    const showLast = seriesModel.get("showLast");
+    return {
+      progress: normalProgress
+    };
+    function normalProgress(params, data2) {
+      let dataIndex;
+      const store = data2.getStore();
+      const bodyPointsByColor = {};
+      const wickPointsByColor = {};
+      const lastIndex = data2.count(true) - 1;
+      while ((dataIndex = params.next()) != null) {
+        if (showLast && lastIndex - data2.getRawIndex(dataIndex) >= showLast) {
+          continue;
+        }
+        const axisDimVal = store.get(cDimI, dataIndex);
+        const openVal = store.get(openDimI, dataIndex);
+        const closeVal = store.get(closeDimI, dataIndex);
+        const lowestVal = store.get(lowestDimI, dataIndex);
+        const highestVal = store.get(highestDimI, dataIndex);
+        const ocLow = Math.min(openVal, closeVal);
+        const ocHigh = Math.max(openVal, closeVal);
+        const ocLowPoint = getPoint(ocLow, axisDimVal);
+        const ocHighPoint = getPoint(ocHigh, axisDimVal);
+        const lowestPoint = getPoint(lowestVal, axisDimVal);
+        const highestPoint = getPoint(highestVal, axisDimVal);
+        const itemModel = data2.getItemModel(dataIndex);
+        const hasDojiColor = !!itemModel.get(["itemStyle", "borderColorDoji"]);
+        const sign = getSign2(store, dataIndex, openVal, closeVal, closeDimI, hasDojiColor);
+        const key = `${getColor(sign, itemModel) || "none"}:${getBorderColor(sign, itemModel) || "none"}`;
+        const bodyPoints = bodyPointsByColor[key] || [];
+        addBodyEnd(bodyPoints, ocHighPoint, 0);
+        addBodyEnd(bodyPoints, ocLowPoint, 1);
+        bodyPointsByColor[key] = bodyPoints;
+        const wickKey = getWickColor(sign, itemModel);
+        if (wickKey) {
+          const wickPoint = wickPointsByColor[wickKey] || [];
+          wickPoint.push(subPixelOptimizePoint(highestPoint), subPixelOptimizePoint(ocHighPoint), subPixelOptimizePoint(lowestPoint), subPixelOptimizePoint(ocLowPoint));
+          wickPointsByColor[wickKey] = wickPoint;
+        }
+      }
+      data2.setLayout({
+        candleWidth,
+        bodyPointsByColor,
+        wickPointsByColor,
+        isSimpleBox
+      });
+      function getPoint(val, axisDimVal) {
+        const p = [];
+        p[cDimIdx] = axisDimVal;
+        p[vDimIdx] = val;
+        const points4 = isNaN(axisDimVal) || isNaN(val) ? [NaN, NaN] : coordSys.dataToPoint(p);
+        if (!isNaN(points4[0])) {
+          points4[0] = points4[0] + 0.5;
+        }
+        if (!isNaN(points4[1])) {
+          points4[1] = Math.floor(points4[1]);
+        }
+        return points4;
+      }
+      function addBodyEnd(ends, point, start2) {
+        const point1 = point.slice();
+        const point2 = point.slice();
+        point1[cDimIdx] = subPixelOptimize2(point1[cDimIdx] + candleWidth / 2, 1, false);
+        point2[cDimIdx] = subPixelOptimize2(point2[cDimIdx] - candleWidth / 2, 1, true);
+        if (point1[cDimIdx] === point2[cDimIdx]) {
+          point1[0] = start2 ? point1[0] - 0.5 : point1[0] + 0.5;
+          point2[0] = start2 ? point1[0] + 0.5 : point1[0] - 0.5;
+        }
+        point1[1] += 0.5;
+        point2[1] += 0.5;
+        start2 ? ends.push(point1, point2) : ends.push(point2, point1);
+      }
+      function subPixelOptimizePoint(point) {
+        point[cDimIdx] = subPixelOptimize2(point[cDimIdx], 1);
+        return point;
+      }
+    }
+  }
+};
+function getSign2(store, dataIndex, openVal, closeVal, closeDimI, hasDojiColor) {
+  let sign;
+  if (openVal > closeVal) {
+    sign = -1;
+  } else if (openVal < closeVal) {
+    sign = 1;
+  } else {
+    sign = hasDojiColor ? 0 : dataIndex > 0 ? store.get(closeDimI, dataIndex - 1) <= closeVal ? 1 : -1 : 1;
+  }
+  return sign;
+}
+function calculateCandleWidth2(seriesModel, data) {
+  const baseAxis = seriesModel.getBaseAxis();
+  let extent3;
+  const bandWidth = baseAxis.type === "category" ? baseAxis.getBandWidth() : (extent3 = baseAxis.getExtent(), Math.abs(extent3[1] - extent3[0]) / data.count());
+  return Math.max(bandWidth * 0.7, 1);
+}
+var candlePlotLayout_default = candlePlotLayout;
+
+// src/chart/candlePlot/install.ts
+function install30(registers) {
+  registers.registerChartView(CandlePlotView_default);
+  registers.registerSeriesModel(CandlePlotSeries_default);
+  registers.registerLayout(candlePlotLayout_default);
+}
+
+// src/chart/barPlot/BarPath.ts
+var BarPathShape = class {
+};
+var BarPath = class extends Path_default {
+  constructor(opts) {
+    super(opts);
+    this.type = "BarPath";
+  }
+  getDefaultShape() {
+    return new BarPathShape();
+  }
+  buildPath(ctx2, shape) {
+    const {points: points4, isSimpleBox, candleWidth} = shape;
+    const width = Math.floor(candleWidth / 2) + 0.5;
+    for (let index = 0; index < points4.length; ) {
+      const point1 = points4[index++];
+      const point2 = points4[index++];
+      const point3 = points4[index++];
+      const point4 = points4[index++];
+      if (isSimpleBox) {
+        const x = point3[0];
+        ctx2.moveTo(x, point3[1]);
+        ctx2.lineTo(x, point4[1]);
+      } else {
+        ctx2.moveTo(point3[0], point3[1]);
+        ctx2.lineTo(point4[0], point4[1]);
+        ctx2.moveTo(point1[0], point1[1]);
+        ctx2.lineTo(point1[0] - width, point1[1]);
+        ctx2.moveTo(point2[0], point2[1]);
+        ctx2.lineTo(point2[0] + width, point2[1]);
+      }
+    }
+  }
+};
+var BarPath_default2 = BarPath;
+
+// src/chart/barPlot/BarPlotView.ts
+var BarPlotView2 = class extends Chart_default {
+  constructor() {
+    super(...arguments);
+    this.type = BarPlotView2.type;
+  }
+  render(seriesModel, ecModel, api2) {
+    this._progressiveEls = null;
+    this._renderNormal(seriesModel);
+  }
+  eachRendered(cb) {
+    traverseElements(this._progressiveEls || this.group, cb);
+  }
+  _renderNormal(seriesModel) {
+    const data = seriesModel.getData();
+    const group = this.group;
+    group.removeAll();
+    const candleWidth = data.getLayout("candleWidth");
+    const isSimpleBox = data.getLayout("isSimpleBox");
+    const bodyPointsByColor = data.getLayout("bodyPointsByColor");
+    each(bodyPointsByColor, function(points4, stroke) {
+      const el = new BarPath_default2({
+        shape: {
+          points: points4,
+          isSimpleBox,
+          candleWidth
+        },
+        style: {
+          stroke,
+          fill: "none"
+        }
+      });
+      group.add(el);
+    });
+    const clipPath = seriesModel.get("clip", true) ? createClipPath(seriesModel.coordinateSystem, false, seriesModel) : null;
+    if (clipPath) {
+      this.group.setClipPath(clipPath);
+    } else {
+      this.group.removeClipPath();
+    }
+  }
+  remove(ecModel) {
+    this._clear();
+  }
+  _clear() {
+    this.group.removeAll();
+  }
+};
+var BarPlotView = BarPlotView2;
+BarPlotView.type = "barPlot";
+var BarPlotView_default = BarPlotView;
+
+// src/chart/barPlot/BarPlotSeries.ts
+var BarPlotSeriesModel2 = class extends Series_default {
+  constructor() {
+    super(...arguments);
+    this.type = BarPlotSeriesModel2.type;
+    this.defaultValueDimensions = [
+      {name: "open", defaultTooltip: true},
+      {name: "close", defaultTooltip: true},
+      {name: "lowest", defaultTooltip: true},
+      {name: "highest", defaultTooltip: true}
+    ];
+  }
+  getShadowDim() {
+    return "open";
+  }
+};
+var BarPlotSeriesModel = BarPlotSeriesModel2;
+BarPlotSeriesModel.type = "series.barPlot";
+BarPlotSeriesModel.dependencies = ["xAxis", "yAxis", "grid"];
+BarPlotSeriesModel.defaultOption = {
+  z: 2,
+  coordinateSystem: "cartesian2d",
+  legendHoverLink: true,
+  layout: null,
+  clip: true,
+  itemStyle: {
+    color: "#eb5454",
+    color0: "#47b262",
+    borderWidth: 1
+  },
+  emphasis: {
+    scale: true,
+    itemStyle: {
+      borderWidth: 2
+    }
+  },
+  barMaxWidth: null,
+  barMinWidth: null,
+  barWidth: null,
+  large: true,
+  largeThreshold: 600,
+  progressive: 3e3,
+  progressiveThreshold: 1e4,
+  progressiveChunkMode: "mod",
+  animationEasing: "linear",
+  animationDuration: 300
+};
+mixin(BarPlotSeriesModel, WhiskerBoxCommonMixin, true);
+var BarPlotSeries_default = BarPlotSeriesModel;
+
+// src/chart/barPlot/barPlotLayout.ts
+var positiveColorQuery3 = ["itemStyle", "color"];
+var negativeColorQuery3 = ["itemStyle", "color0"];
+function getColor2(sign, model) {
+  return model.get(sign > 0 ? positiveColorQuery3 : negativeColorQuery3);
+}
+var barPlotLayout = {
+  seriesType: "barPlot",
+  plan: createRenderPlanner(),
+  reset: function(seriesModel) {
+    const coordSys = seriesModel.coordinateSystem;
+    const data = seriesModel.getData();
+    const candleWidth = calculateCandleWidth3(seriesModel, data);
+    const cDimIdx = 0;
+    const vDimIdx = 1;
+    const coordDims = ["x", "y"];
+    const cDimI = data.getDimensionIndex(data.mapDimension(coordDims[cDimIdx]));
+    const vDimsI = map(data.mapDimensionsAll(coordDims[vDimIdx]), data.getDimensionIndex, data);
+    const openDimI = vDimsI[0];
+    const closeDimI = vDimsI[1];
+    const lowestDimI = vDimsI[2];
+    const highestDimI = vDimsI[3];
+    const isSimpleBox = candleWidth <= 1.3;
+    if (cDimI < 0 || vDimsI.length < 4) {
+      return;
+    }
+    const showLast = seriesModel.get("showLast");
+    return {
+      progress: normalProgress
+    };
+    function normalProgress(params, data2) {
+      let dataIndex;
+      const store = data2.getStore();
+      const bodyPointsByColor = {};
+      const lastIndex = data2.count(true) - 1;
+      while ((dataIndex = params.next()) != null) {
+        if (showLast && lastIndex - data2.getRawIndex(dataIndex) >= showLast) {
+          continue;
+        }
+        const axisDimVal = store.get(cDimI, dataIndex);
+        const openVal = store.get(openDimI, dataIndex);
+        const closeVal = store.get(closeDimI, dataIndex);
+        const lowestVal = store.get(lowestDimI, dataIndex);
+        const highestVal = store.get(highestDimI, dataIndex);
+        const ocLowPoint = getPoint(openVal, axisDimVal, 0.5);
+        const ocHighPoint = getPoint(closeVal, axisDimVal, 0.5);
+        const lowestPoint = getPoint(lowestVal, axisDimVal);
+        const highestPoint = getPoint(highestVal, axisDimVal);
+        const itemModel = data2.getItemModel(dataIndex);
+        const sign = getSign3(store, dataIndex, openVal, closeVal, closeDimI);
+        const key = getColor2(sign, itemModel);
+        if (key) {
+          const bodyPoints = bodyPointsByColor[key] || [];
+          bodyPoints.push(ocLowPoint, ocHighPoint, lowestPoint, highestPoint);
+          bodyPointsByColor[key] = bodyPoints;
+        }
+      }
+      data2.setLayout({
+        candleWidth,
+        bodyPointsByColor,
+        isSimpleBox
+      });
+      function getPoint(val, axisDimVal, yOffset = 0) {
+        const p = [];
+        p[cDimIdx] = axisDimVal;
+        p[vDimIdx] = val;
+        const points4 = isNaN(axisDimVal) || isNaN(val) ? [NaN, NaN] : coordSys.dataToPoint(p);
+        if (!isNaN(points4[0])) {
+          points4[0] = points4[0] + 0.5;
+        }
+        if (!isNaN(points4[1])) {
+          points4[1] = Math.floor(points4[1]) + yOffset;
+        }
+        return points4;
+      }
+    }
+  }
+};
+function getSign3(store, dataIndex, openVal, closeVal, closeDimI) {
+  let sign;
+  if (openVal > closeVal) {
+    sign = -1;
+  } else {
+    sign = 1;
+  }
+  return sign;
+}
+function calculateCandleWidth3(seriesModel, data) {
+  const baseAxis = seriesModel.getBaseAxis();
+  let extent3;
+  const bandWidth = baseAxis.type === "category" ? baseAxis.getBandWidth() : (extent3 = baseAxis.getExtent(), Math.abs(extent3[1] - extent3[0]) / data.count());
+  return Math.max(bandWidth * 0.7, 1);
+}
+var barPlotLayout_default = barPlotLayout;
+
+// src/chart/barPlot/install.ts
+function install31(registers) {
+  registers.registerChartView(BarPlotView_default);
+  registers.registerSeriesModel(BarPlotSeries_default);
+  registers.registerLayout(barPlotLayout_default);
+}
+
+// src/chart/arrowsPlot/ArrowsPlotSeries.ts
+var ArrowsPlotSeriesModel2 = class extends Series_default {
+  constructor() {
+    super(...arguments);
+    this.type = ArrowsPlotSeriesModel2.type;
+  }
+  getInitialData(option, ecModel) {
+    return createSeriesData_default(null, this, {
+      useEncodeDefaulter: true
+    });
+  }
+};
+var ArrowsPlotSeriesModel = ArrowsPlotSeriesModel2;
+ArrowsPlotSeriesModel.type = "series.arrowsPlot";
+ArrowsPlotSeriesModel.dependencies = ["grid", "polar"];
+ArrowsPlotSeriesModel.defaultOption = {
+  coordinateSystem: "cartesian2d",
+  z: 2,
+  large: false,
+  largeThreshold: 2e3,
+  emphasis: {
+    scale: true
+  },
+  clip: true
+};
+var ArrowsPlotSeries_default = ArrowsPlotSeriesModel;
+
+// src/chart/arrowsPlot/ArrowSymbolPath.ts
+var ArrowSymbolPathShape = class {
+};
+var ArrowSymbolPath = class extends Path_default {
+  constructor(opts) {
+    super(opts);
+  }
+  getDefaultShape() {
+    return new ArrowSymbolPathShape();
+  }
+  buildPath(path, shape) {
+    const {points: points4, barWidth, valueLength, minHeight} = shape;
+    const symbolProxy = this.symbolProxy;
+    const symbolProxyShape = symbolProxy.shape;
+    const isUp = symbolProxyShape.symbolType === "arrowUp";
+    const w = barWidth * 0.7;
+    const triangleWidth = Math.floor(w * 0.3);
+    const triangleHeight = w / 2;
+    for (let i = 0; i < points4.length; i++) {
+      const {x, y, value} = points4[i];
+      const height = Math.max(Math.round(value * valueLength), minHeight, triangleHeight);
+      symbolProxyShape.x = x;
+      symbolProxyShape.y = y + (isUp ? height / 2 + 10 : -height / 2 - 10);
+      symbolProxyShape.width = w;
+      symbolProxyShape.height = height;
+      symbolProxyShape.triangleWidth = triangleWidth;
+      symbolProxyShape.triangleHeight = triangleHeight;
+      symbolProxy.buildPath(path, symbolProxyShape, true);
+    }
+  }
+};
+var ArrowSymbolPath_default = ArrowSymbolPath;
+
+// src/chart/arrowsPlot/ArrowPlotView.ts
+var ArrowsPlotView2 = class extends Chart_default {
+  constructor() {
+    super(...arguments);
+    this.type = ArrowsPlotView2.type;
+  }
+  render(seriesModel, ecModel, api2) {
+    const data = seriesModel.getData();
+    this._renderArrows(data, seriesModel);
+    this._finished = true;
+  }
+  _renderArrows(data, seriesModel) {
+    if (!this._symbolGroup) {
+      this._symbolGroup = new Group_default();
+      this.group.add(this._symbolGroup);
+    } else {
+      this._symbolGroup.removeAll();
+    }
+    const symbolGroup = this._symbolGroup;
+    const bandWidth = seriesModel.coordinateSystem.getAxesByScale("ordinal")[0].scale.barSpace;
+    const maxheight = seriesModel.get("maxheight");
+    const minheight = seriesModel.get("minheight");
+    const upArrowsByColor = data.getLayout("upArrowsByColor");
+    const maxValue = data.getLayout("maxValue");
+    each(upArrowsByColor, function(item, color2) {
+      const el = new ArrowSymbolPath_default({
+        shape: {
+          points: item,
+          barWidth: bandWidth,
+          minHeight: minheight,
+          valueLength: maxheight / maxValue
+        },
+        style: {
+          fill: color2
+        }
+      });
+      el.symbolProxy = createSymbol("arrowUp", 0, 0, 0, 0);
+      symbolGroup.add(el);
+    });
+    const downArrowsByColor = data.getLayout("downArrowsByColor");
+    const minValue = data.getLayout("minValue");
+    each(downArrowsByColor, function(item, color2) {
+      const el = new ArrowSymbolPath_default({
+        shape: {
+          points: item,
+          barWidth: bandWidth,
+          minHeight: minheight,
+          valueLength: maxheight / minValue
+        },
+        style: {
+          fill: color2
+        }
+      });
+      el.symbolProxy = createSymbol("arrowDown", 0, 0, 0, 0);
+      symbolGroup.add(el);
+    });
+  }
+  _getClipShape(seriesModel) {
+    if (!seriesModel.get("clip", true)) {
+      return;
+    }
+    const coordSys = seriesModel.coordinateSystem;
+    return coordSys && coordSys.getArea && coordSys.getArea(0.1);
+  }
+  remove(ecModel, api2) {
+    this._symbolGroup && this._symbolGroup.removeAll();
+    this._symbolGroup = null;
+  }
+  dispose() {
+  }
+};
+var ArrowsPlotView = ArrowsPlotView2;
+ArrowsPlotView.type = "arrowsPlot";
+var ArrowPlotView_default = ArrowsPlotView;
+
+// src/chart/arrowsPlot/ArrowsPlotLayout.ts
+var ArrowsPlotLayout = {
+  seriesType: "arrowsPlot",
+  plan: createRenderPlanner(),
+  reset: function(seriesModel) {
+    const data = seriesModel.getData();
+    const coordSys = seriesModel.coordinateSystem;
+    if (!coordSys) {
+      return;
+    }
+    const dims = map(coordSys.dimensions, function(dim) {
+      return data.mapDimension(dim);
+    }).slice(0, 2);
+    const store = data.getStore();
+    const dimIdx0 = data.getDimensionIndex(dims[0]);
+    const dimIdx1 = data.getDimensionIndex(dims[1]);
+    const xOffset = seriesModel.get("offset") || 0;
+    const showLast = seriesModel.get("showLast");
+    return {
+      progress(params, arrowsPlotData) {
+        const upArrowsByColor = {};
+        const downArrowsByColor = {};
+        let maxValue = 0;
+        let minValue = 0;
+        const lastIndex = data.count(true) - 1;
+        const tmpIn = [];
+        for (let i = params.start; i < params.end; i++) {
+          if (showLast && lastIndex - data.getRawIndex(i) >= showLast) {
+            continue;
+          }
+          tmpIn[0] = store.get(dimIdx0, i) + xOffset;
+          tmpIn[1] = store.get(dimIdx1, i);
+          if (isNaN(tmpIn[1])) {
+            continue;
+          }
+          const itemModel = data.getItemModel(i);
+          const {upColor, downColor, value} = itemModel.get("itemStyle");
+          const point = coordSys.dataToPoint(tmpIn);
+          if (value > 0) {
+            const upArrows = upArrowsByColor[upColor] || [];
+            upArrows.push({
+              x: point[0],
+              y: point[1],
+              value
+            });
+            upArrowsByColor[upColor] = upArrows;
+            maxValue = Math.max(maxValue, value);
+          } else {
+            const downArrows = downArrowsByColor[downColor] || [];
+            downArrows.push({
+              x: point[0],
+              y: point[1],
+              value
+            });
+            downArrowsByColor[downColor] = downArrows;
+            minValue = Math.min(minValue, value);
+          }
+          downArrowsByColor[downColor];
+        }
+        arrowsPlotData.setLayout({
+          upArrowsByColor,
+          downArrowsByColor,
+          maxValue,
+          minValue
+        });
+      }
+    };
+  }
+};
+var ArrowsPlotLayout_default = ArrowsPlotLayout;
+
+// src/chart/arrowsPlot/install.ts
+function install32(registers) {
+  registers.registerSeriesModel(ArrowsPlotSeries_default);
+  registers.registerChartView(ArrowPlotView_default);
+  registers.registerLayout(ArrowsPlotLayout_default);
+}
+
 // src/chart/labels/LabelsSeries.ts
 var LabelsSeriesModel2 = class extends Series_default {
   constructor() {
@@ -57948,7 +58737,7 @@ var labelsLayout = {
 var labelsLayout_default = labelsLayout;
 
 // src/chart/labels/install.ts
-function install30(registers) {
+function install33(registers) {
   registers.registerSeriesModel(LabelsSeries_default);
   registers.registerChartView(LabelsView_default);
   registers.registerLayout(labelsLayout_default);
@@ -58083,7 +58872,7 @@ var hLinesLayout = {
 var hLinesLayout_default = hLinesLayout;
 
 // src/chart/hlines/install.ts
-function install31(registers) {
+function install34(registers) {
   registers.registerChartView(HLinesView_default);
   registers.registerSeriesModel(HLinesSeries_default);
   registers.registerLayout(hLinesLayout_default);
@@ -58366,7 +59155,7 @@ var fillsLayout = {
 var fillsLayout_default = fillsLayout;
 
 // src/chart/fills/install.ts
-function install32(registers) {
+function install35(registers) {
   registers.registerChartView(FillsView_default);
   registers.registerSeriesModel(FillsSeries_default);
   registers.registerLayout(fillsLayout_default);
@@ -58570,7 +59359,7 @@ var bgColorLayout = {
 var BgColorLayout_default = bgColorLayout;
 
 // src/chart/bgColor/install.ts
-function install33(registers) {
+function install36(registers) {
   registers.registerChartView(BgColorView_default);
   registers.registerSeriesModel(BgColorSeries_default);
   registers.registerLayout(BgColorLayout_default);
@@ -58968,7 +59757,7 @@ HeatmapSeriesModel.defaultOption = {
 var HeatmapSeries_default = HeatmapSeriesModel;
 
 // src/chart/heatmap/install.ts
-function install34(registers) {
+function install37(registers) {
   registers.registerChartView(HeatmapView_default);
   registers.registerSeriesModel(HeatmapSeries_default);
 }
@@ -59531,7 +60320,7 @@ PictorialBarSeriesModel.defaultOption = inheritDefaultOption(BaseBarSeries_defau
 var PictorialBarSeries_default = PictorialBarSeriesModel;
 
 // src/chart/bar/installPictorialBar.ts
-function install35(registers) {
+function install38(registers) {
   registers.registerChartView(PictorialBarView_default);
   registers.registerSeriesModel(PictorialBarSeries_default);
   registers.registerLayout(registers.PRIORITY.VISUAL.LAYOUT, curry(layout2, "pictorialBar"));
@@ -59932,7 +60721,7 @@ function computeBaseline(data) {
 }
 
 // src/chart/themeRiver/install.ts
-function install36(registers) {
+function install39(registers) {
   registers.registerChartView(ThemeRiverView_default);
   registers.registerSeriesModel(ThemeRiverSeries_default);
   registers.registerLayout(themeRiverLayout);
@@ -60570,7 +61359,7 @@ function sunburstVisual(ecModel) {
 }
 
 // src/chart/sunburst/install.ts
-function install37(registers) {
+function install40(registers) {
   registers.registerChartView(SunburstView_default);
   registers.registerSeriesModel(SunburstSeries_default);
   registers.registerLayout(curry(sunburstLayout, "sunburst"));
@@ -62018,7 +62807,7 @@ function hasOwnPathData(shape) {
 }
 
 // src/chart/custom/install.ts
-function install38(registers) {
+function install41(registers) {
   registers.registerChartView(CustomView_default);
   registers.registerSeriesModel(CustomSeries_default);
 }
@@ -62746,7 +63535,7 @@ var AxisPointerModel_default = AxisPointerModel;
 
 // src/component/axisPointer/globalListener.ts
 var inner12 = makeInner();
-var each11 = each;
+var each12 = each;
 function register(key, api2, handler) {
   if (env_default.node) {
     return;
@@ -62770,7 +63559,7 @@ function initGlobalListeners(zr, api2) {
   function useHandler(eventType, cb) {
     zr.on(eventType, function(e2) {
       const dis = makeDispatchAction(api2);
-      each11(inner12(zr).records, function(record) {
+      each12(inner12(zr).records, function(record) {
         record && cb(record, e2, dis.dispatchAction);
       });
       dispatchTooltipFinally(dis.pendings, api2);
@@ -63239,7 +64028,7 @@ function illegalPoint(point) {
 }
 
 // src/component/axisPointer/install.ts
-function install39(registers) {
+function install42(registers) {
   AxisView_default.registerAxisPointerClass("CartesianAxisPointer", CartesianAxisPointer_default);
   registers.registerComponentModel(AxisPointerModel_default);
   registers.registerComponentView(AxisPointerView_default);
@@ -63268,9 +64057,9 @@ function install39(registers) {
 }
 
 // src/component/grid/install.ts
-function install40(registers) {
+function install43(registers) {
   use(install6);
-  use(install39);
+  use(install42);
 }
 
 // src/component/axisPointer/PolarAxisPointer.ts
@@ -64324,8 +65113,8 @@ var PolarView2 = class extends Component_default2 {
 };
 var PolarView = PolarView2;
 PolarView.type = "polar";
-function install41(registers) {
-  use(install39);
+function install44(registers) {
+  use(install42);
   AxisView_default.registerAxisPointerClass("PolarAxisPointer", PolarAxisPointer_default);
   registers.registerCoordinateSystem("polar", polarCreator_default);
   registers.registerComponentModel(PolarModel_default);
@@ -64788,8 +65577,8 @@ var SingleView2 = class extends Component_default2 {
 };
 var SingleView = SingleView2;
 SingleView.type = "single";
-function install42(registers) {
-  use(install39);
+function install45(registers) {
+  use(install42);
   AxisView_default.registerAxisPointerClass("SingleAxisPointer", SingleAxisPointer_default);
   registers.registerComponentView(SingleView);
   registers.registerComponentView(SingleAxisView_default);
@@ -65479,7 +66268,7 @@ function getCoordSys5(finder) {
 var Calendar_default = Calendar;
 
 // src/component/calendar/install.ts
-function install43(registers) {
+function install46(registers) {
   registers.registerComponentModel(CalendarModel_default);
   registers.registerComponentView(CalendarView_default);
   registers.registerCoordinateSystem("calendar", Calendar_default);
@@ -65868,7 +66657,7 @@ function setEventData(el, graphicModel, elOption) {
 }
 
 // src/component/graphic/install.ts
-function install44(registers) {
+function install47(registers) {
   registers.registerComponentModel(GraphicComponentModel);
   registers.registerComponentView(GraphicComponentView);
   registers.registerPreprocessor(function(option) {
@@ -66212,8 +67001,11 @@ var DataZoomModel2 = class extends Component_default {
     if (opt.lastBarRightSideDiffBarCount) {
       thisOption.lastBarRightSideDiffBarCount = opt.lastBarRightSideDiffBarCount;
     }
-    if (!isLocal && opt.barSpace && opt.lastBarRightSideDiffBarCount) {
-      this._distanceRange = [opt.barSpace, opt.lastBarRightSideDiffBarCount];
+    if (!isLocal && (typeof opt.barSpace === "number" || typeof opt.lastBarRightSideDiffBarCount === "number")) {
+      this._distanceRange = [
+        opt.barSpace || thisOption.barSpace,
+        opt.lastBarRightSideDiffBarCount || thisOption.lastBarRightSideDiffBarCount
+      ];
     }
     this._updateRangeUse(opt);
   }
@@ -66350,7 +67142,7 @@ SelectDataZoomView.type = "dataZoom.select";
 var SelectZoomView_default = SelectDataZoomView;
 
 // src/component/dataZoom/AxisProxy.ts
-var each12 = each;
+var each13 = each;
 var asc2 = asc;
 var leftMinVisibleBarCount = 2;
 var rightMinVisibleBarCount = 2;
@@ -66405,7 +67197,7 @@ var AxisProxy = class {
     const percentWindow = [];
     const valueWindow = [];
     let hasPropModeValue;
-    each12(["start", "end"], function(prop, idx) {
+    each13(["start", "end"], function(prop, idx) {
       let boundPercent = opt[prop];
       let boundValue = opt[prop + "Value"];
       if (rangePropMode[idx] === "percent") {
@@ -66503,7 +67295,7 @@ var AxisProxy = class {
     if (filterMode === "none") {
       return;
     }
-    each12(seriesModels, function(seriesModel) {
+    each13(seriesModels, function(seriesModel) {
       let seriesData = seriesModel.getData();
       const dataDims = seriesData.mapDimensionsAll(axisDim);
       if (!dataDims.length || seriesModel.get("notFilterData")) {
@@ -66541,7 +67333,7 @@ var AxisProxy = class {
         });
       } else {
         const offset = seriesModel.get("offset");
-        each12(dataDims, function(dim) {
+        each13(dataDims, function(dim) {
           if (filterMode === "empty") {
             seriesModel.setData(seriesData = seriesData.map(dim, function(value) {
               return !isInWindow(value) ? NaN : value;
@@ -66567,7 +67359,7 @@ var AxisProxy = class {
           }
         });
       }
-      each12(dataDims, function(dim) {
+      each13(dataDims, function(dim) {
         seriesData.setApproximateExtent(valueWindow, dim);
       });
     });
@@ -66582,7 +67374,7 @@ var AxisProxy = class {
     const minMaxSpan = this._minMaxSpan = {};
     const dataZoomModel = this._dataZoomModel;
     const dataExtent = this._dataExtent;
-    each12(["min", "max"], function(minMax) {
+    each13(["min", "max"], function(minMax) {
       let percentSpan = dataZoomModel.get(minMax + "Span");
       let valueSpan = dataZoomModel.get(minMax + "ValueSpan");
       valueSpan != null && (valueSpan = this.getAxisModel().axis.scale.parse(valueSpan));
@@ -66618,14 +67410,14 @@ function calculateDataExtent(axisProxy, axisDim, seriesModels) {
   const dataExtent = [Infinity, -Infinity];
   const axisModel = axisProxy.getAxisModel();
   const dataFromSeriesName = axisModel.axis.model.get("dataFromSeriesName");
-  each12(seriesModels, function(seriesModel) {
+  each13(seriesModels, function(seriesModel) {
     if (dataFromSeriesName && seriesModel.name !== dataFromSeriesName) {
       return;
     }
     const seriesData = seriesModel.getData();
     let baseValue = void 0;
     if (axisModel.axis.type === "percentage") {
-      baseValue = seriesData.get(seriesModel.subType === "candlestick" ? "close" : "y", 0);
+      baseValue = seriesData.get(isCandle(seriesModel.subType) ? "close" : "y", 0);
     }
     unionAxisExtentFromData(dataExtent, seriesData, axisDim, baseValue);
   });
@@ -66751,7 +67543,7 @@ function installCommon(registers) {
 }
 
 // src/component/dataZoom/installDataZoomSelect.ts
-function install45(registers) {
+function install48(registers) {
   registers.registerComponentModel(SelectZoomModel_default);
   registers.registerComponentView(SelectZoomView_default);
   installCommon(registers);
@@ -67638,11 +68430,11 @@ registerAction({
 var DataView_default = DataView;
 
 // src/component/dataZoom/history.ts
-var each13 = each;
+var each14 = each;
 var inner16 = makeInner();
 function push(ecModel, newSnapshot) {
   const storedSnapshots = getStoreSnapshots(ecModel);
-  each13(newSnapshot, function(batchItem, dataZoomId) {
+  each14(newSnapshot, function(batchItem, dataZoomId) {
     let i = storedSnapshots.length - 1;
     for (; i >= 0; i--) {
       const snapshot = storedSnapshots[i];
@@ -67669,7 +68461,7 @@ function pop(ecModel) {
   const head = storedSnapshots[storedSnapshots.length - 1];
   storedSnapshots.length > 1 && storedSnapshots.pop();
   const snapshot = {};
-  each13(head, function(batchItem, dataZoomId) {
+  each14(head, function(batchItem, dataZoomId) {
     for (let i = storedSnapshots.length - 1; i >= 0; i--) {
       batchItem = storedSnapshots[i][dataZoomId];
       if (batchItem) {
@@ -67982,7 +68774,7 @@ function getSize2(xyMinMax) {
 var BrushTargetManager_default = BrushTargetManager;
 
 // src/component/toolbox/feature/DataZoom.ts
-var each14 = each;
+var each15 = each;
 var DATA_ZOOM_ID_BASE = makeInternalComponentId("toolbox-dataZoom_");
 var DataZoomFeature = class extends ToolboxFeature {
   render(featureModel, ecModel, api2, payload) {
@@ -68050,7 +68842,7 @@ var DataZoomFeature = class extends ToolboxFeature {
   }
   _dispatchZoomAction(snapshot) {
     const batch = [];
-    each14(snapshot, function(batchItem, dataZoomId) {
+    each15(snapshot, function(batchItem, dataZoomId) {
       batch.push(clone(batchItem));
     });
     batch.length && this.api.dispatchAction({
@@ -68133,8 +68925,8 @@ registerInternalOptionCreator("dataZoom", function(ecModel) {
   const dzOptions = [];
   const finder = makeAxisFinder(dzFeatureModel);
   const finderResult = parseFinder(ecModel, finder);
-  each14(finderResult.xAxisModels, (axisModel) => buildInternalOptions(axisModel, "xAxis", "xAxisIndex"));
-  each14(finderResult.yAxisModels, (axisModel) => buildInternalOptions(axisModel, "yAxis", "yAxisIndex"));
+  each15(finderResult.xAxisModels, (axisModel) => buildInternalOptions(axisModel, "xAxis", "xAxisIndex"));
+  each15(finderResult.yAxisModels, (axisModel) => buildInternalOptions(axisModel, "yAxis", "yAxisIndex"));
   function buildInternalOptions(axisModel, axisMainType, axisIndexPropName) {
     const axisIndex = axisModel.componentIndex;
     const newOpt = {
@@ -68151,7 +68943,7 @@ registerInternalOptionCreator("dataZoom", function(ecModel) {
 var DataZoom_default = DataZoomFeature;
 
 // src/component/toolbox/install.ts
-function install46(registers) {
+function install49(registers) {
   registers.registerComponentModel(ToolboxModel_default);
   registers.registerComponentView(ToolboxView_default);
   registerFeature("saveAsImage", SaveAsImage_default);
@@ -68159,7 +68951,7 @@ function install46(registers) {
   registerFeature("dataView", DataView_default);
   registerFeature("dataZoom", DataZoom_default);
   registerFeature("restore", Restore_default);
-  use(install45);
+  use(install48);
 }
 
 // src/component/tooltip/TooltipModel.ts
@@ -69327,8 +70119,8 @@ function findComponentReference(payload, ecModel, api2) {
 var TooltipView_default = TooltipView;
 
 // src/component/tooltip/install.ts
-function install47(registers) {
-  use(install39);
+function install50(registers) {
+  use(install42);
   registers.registerComponentModel(TooltipModel_default);
   registers.registerComponentView(TooltipView_default);
   registers.registerAction({
@@ -69386,7 +70178,7 @@ function removeDuplicate(arr) {
 }
 
 // src/visual/visualSolution.ts
-var each15 = each;
+var each16 = each;
 function hasKeys(obj) {
   if (obj) {
     for (const name in obj) {
@@ -69398,9 +70190,9 @@ function hasKeys(obj) {
 }
 function createVisualMappings(option, stateList, supplementVisualOption) {
   const visualMappings = {};
-  each15(stateList, function(state) {
+  each16(stateList, function(state) {
     const mappings = visualMappings[state] = createMappings();
-    each15(option[state], function(visualData, visualType) {
+    each16(option[state], function(visualData, visualType) {
       if (!VisualMapping_default.isValidType(visualType)) {
         return;
       }
@@ -69944,7 +70736,7 @@ var BrushFeature = class extends ToolboxFeature {
 var Brush_default = BrushFeature;
 
 // src/component/brush/install.ts
-function install48(registers) {
+function install51(registers) {
   registers.registerComponentView(BrushView_default);
   registers.registerComponentModel(BrushModel_default);
   registers.registerPreprocessor(brushPreprocessor);
@@ -70091,7 +70883,7 @@ var TitleView2 = class extends Component_default2 {
 };
 var TitleView = TitleView2;
 TitleView.type = "title";
-function install49(registers) {
+function install52(registers) {
   registers.registerComponentModel(TitleModel);
   registers.registerComponentView(TitleView);
 }
@@ -70456,7 +71248,7 @@ TableView.type = "table";
 var TableView_default = TableView;
 
 // src/component/table/install.ts
-function install50(registers) {
+function install53(registers) {
   registers.registerComponentModel(TableModel_default);
   registers.registerComponentView(TableView_default);
 }
@@ -71310,7 +72102,7 @@ function has(obj, attr) {
 }
 
 // src/component/timeline/install.ts
-function install51(registers) {
+function install54(registers) {
   registers.registerComponentModel(SliderTimelineModel_default);
   registers.registerComponentView(SliderTimelineView_default);
   registers.registerSubTypeDefaulter("timeline", function() {
@@ -71751,7 +72543,7 @@ function createData(coordSys, seriesModel, mpModel) {
 var MarkPointView_default = MarkPointView;
 
 // src/component/marker/installMarkPoint.ts
-function install52(registers) {
+function install55(registers) {
   registers.registerComponentModel(MarkPointModel_default);
   registers.registerComponentView(MarkPointView_default);
   registers.registerPreprocessor(function(opt) {
@@ -72069,7 +72861,7 @@ function createList2(coordSys, seriesModel, mlModel) {
 var MarkLineView_default = MarkLineView;
 
 // src/component/marker/installMarkLine.ts
-function install53(registers) {
+function install56(registers) {
   registers.registerComponentModel(MarkLineModel_default);
   registers.registerComponentView(MarkLineView_default);
   registers.registerPreprocessor(function(opt) {
@@ -72383,7 +73175,7 @@ function createList3(coordSys, seriesModel, maModel) {
 var MarkAreaView_default = MarkAreaView;
 
 // src/component/marker/installMarkArea.ts
-function install54(registers) {
+function install57(registers) {
   registers.registerComponentModel(MarkAreaModel_default);
   registers.registerComponentView(MarkAreaView_default);
   registers.registerPreprocessor(function(opt) {
@@ -72530,13 +73322,13 @@ var markerTypeCalculator2 = {
     const seriesData = seriesModel.getData();
     const lastIndex = seriesData.count(true) - 1;
     let fill = seriesData.getItemVisual(lastIndex, "style")?.fill;
-    if (seriesModel.subType === "candlestick") {
+    if (isCandle(seriesModel.subType)) {
       const dataItem = seriesData.getItemModel(lastIndex, true);
       const closeValue = seriesData.getByRawIndex("close", lastIndex);
       const openValue = seriesData.getByRawIndex("open", lastIndex);
       const sign = openValue > closeValue ? -1 : 1;
       fill = dataItem.get(sign > 0 ? positiveBorderColorQuery : negativeBorderColorQuery);
-    } else if (["linesPlot", "labels"].includes(seriesModel.subType)) {
+    } else if (isPlot(seriesModel.subType)) {
       const isLinesPlot = seriesModel.subType === "linesPlot";
       const dataItem = seriesData.getItemModel(lastIndex, true);
       fill = dataItem.get([isLinesPlot ? "lineStyle" : "itemStyle", "color"]);
@@ -72561,8 +73353,8 @@ var markerTypeCalculator2 = {
     }
     const backgroundColor2 = seriesModel.ecModel.get("backgroundColor");
     const lastItem = seriesData.count() - 1;
-    let fill = seriesModel.subType === "candlestick" ? seriesData.getItemVisual(lastItem, "style")?.stroke : seriesData.getItemVisual(lastItem, "style")?.fill;
-    if (["linesPlot", "labels"].includes(seriesModel.subType)) {
+    let fill = isCandle(seriesModel.subType) ? seriesData.getItemVisual(lastItem, "style")?.stroke : seriesData.getItemVisual(lastItem, "style")?.fill;
+    if (isPlot(seriesModel.subType)) {
       const isLinesPlot = seriesModel.subType === "linesPlot";
       const dataItem = seriesData.getItemModel(lastItem);
       fill = dataItem.get([isLinesPlot ? "lineStyle" : "itemStyle", "color"]);
@@ -73026,7 +73818,7 @@ function updateLabel({x, y, labelData, markerModel, gridRect, position: position
 var MarkLabelView_default = MarkLabelView;
 
 // src/component/marker/installMarkLabel.ts
-function install55(registers) {
+function install58(registers) {
   registers.registerComponentModel(MarkLabelModal_default);
   registers.registerComponentView(MarkLabelView_default);
   registers.registerPreprocessor(function(opt) {
@@ -73269,7 +74061,7 @@ var LegendModel_default = LegendModel;
 
 // src/component/legend/LegendView.ts
 var curry2 = curry;
-var each16 = each;
+var each17 = each;
 var Group3 = Group_default;
 var LegendView2 = class extends Component_default2 {
   constructor() {
@@ -73333,7 +74125,7 @@ var LegendView2 = class extends Component_default2 {
     ecModel.eachRawSeries(function(seriesModel) {
       !seriesModel.get("legendHoverLink") && excludeSeriesId.push(seriesModel.id);
     });
-    each16(legendModel.getData(), function(legendItemModel, dataIndex) {
+    each17(legendModel.getData(), function(legendItemModel, dataIndex) {
       const name = legendItemModel.get("name");
       if (!this.newlineDisabled && (name === "" || name === "\n")) {
         const g = new Group3();
@@ -73405,7 +74197,7 @@ var LegendView2 = class extends Component_default2 {
   }
   _createSelector(selector2, legendModel, api2, orient, selectorPosition) {
     const selectorGroup = this.getSelectorGroup();
-    each16(selector2, function createSelectorButton(selectorItem) {
+    each17(selector2, function createSelectorButton(selectorItem) {
       const type = selectorItem.type;
       const labelText = new Text_default({
         style: {
@@ -73558,7 +74350,7 @@ function getLegendStyle(iconType, legendItemModel, lineVisualStyle, itemVisualSt
     if (style.lineWidth === "auto") {
       style.lineWidth = visualStyle.lineWidth > 0 ? 2 : 0;
     }
-    each16(style, (propVal, propName) => {
+    each17(style, (propVal, propName) => {
       style[propName] === "inherit" && (style[propName] = visualStyle[propName]);
     });
   }
@@ -73708,7 +74500,7 @@ function installLegendAction(registers) {
 }
 
 // src/component/legend/installLegendPlain.ts
-function install56(registers) {
+function install59(registers) {
   registers.registerComponentModel(LegendModel_default);
   registers.registerComponentView(LegendView_default);
   registers.registerProcessor(registers.PRIORITY.PROCESSOR.SERIES_FILTER, legendFilter);
@@ -74038,17 +74830,17 @@ function installScrollableLegendAction(registers) {
 }
 
 // src/component/legend/installLegendScroll.ts
-function install57(registers) {
-  use(install56);
+function install60(registers) {
+  use(install59);
   registers.registerComponentModel(ScrollableLegendModel_default);
   registers.registerComponentView(ScrollableLegendView_default);
   installScrollableLegendAction(registers);
 }
 
 // src/component/legend/install.ts
-function install58(registers) {
-  use(install56);
-  use(install57);
+function install61(registers) {
+  use(install59);
+  use(install60);
 }
 
 // src/component/dataZoom/InsideZoomModel.ts
@@ -74475,7 +75267,7 @@ var getDirectionInfo = {
 var InsideZoomView_default = InsideZoomView;
 
 // src/component/dataZoom/installDataZoomInside.ts
-function install59(registers) {
+function install62(registers) {
   installCommon(registers);
   registers.registerComponentModel(InsideZoomModel_default);
   registers.registerComponentView(InsideZoomView_default);
@@ -75231,16 +76023,16 @@ function getCursor(orient) {
 var SliderZoomView_default = SliderZoomView;
 
 // src/component/dataZoom/installDataZoomSlider.ts
-function install60(registers) {
+function install63(registers) {
   registers.registerComponentModel(SliderZoomModel_default);
   registers.registerComponentView(SliderZoomView_default);
   installCommon(registers);
 }
 
 // src/component/dataZoom/install.ts
-function install61(registers) {
-  use(install59);
-  use(install60);
+function install64(registers) {
+  use(install62);
+  use(install63);
 }
 
 // src/visual/visualDefault.ts
@@ -75290,7 +76082,7 @@ var visualDefault_default = visualDefault;
 var mapVisual2 = VisualMapping_default.mapVisual;
 var eachVisual = VisualMapping_default.eachVisual;
 var isArray2 = isArray;
-var each17 = each;
+var each18 = each;
 var asc3 = asc;
 var linearMap2 = linearMap;
 var VisualMapModel2 = class extends Component_default {
@@ -75440,7 +76232,7 @@ var VisualMapModel2 = class extends Component_default {
       let optAbsent = base3[stateAbsent];
       if (optExist && !optAbsent) {
         optAbsent = base3[stateAbsent] = {};
-        each17(optExist, function(visualData, visualType) {
+        each18(optExist, function(visualData, visualType) {
           if (!VisualMapping_default.isValidType(visualType)) {
             return;
           }
@@ -75460,7 +76252,7 @@ var VisualMapModel2 = class extends Component_default {
       const inactiveColor = this.get("inactiveColor");
       const itemSymbol = this.getItemSymbol();
       const defaultSymbol = itemSymbol || "roundRect";
-      each17(this.stateList, function(state) {
+      each18(this.stateList, function(state) {
         const itemSize = this.itemSize;
         let visuals = controller2[state];
         if (!visuals) {
@@ -75820,7 +76612,7 @@ function makeHighDownBatch(batch, visualMapModel) {
 
 // src/component/visualMap/ContinuousView.ts
 var linearMap3 = linearMap;
-var each18 = each;
+var each19 = each;
 var mathMin11 = Math.min;
 var mathMax11 = Math.max;
 var HOVER_LINK_SIZE = 12;
@@ -76148,7 +76940,7 @@ var ContinuousView2 = class extends VisualMapView_default {
     const handleLabels = shapes.handleLabels;
     const itemSize = visualMapModel.itemSize;
     const dataExtent = visualMapModel.getExtent();
-    each18([0, 1], function(handleIndex) {
+    each19([0, 1], function(handleIndex) {
       const handleThumb = handleThumbs[handleIndex];
       handleThumb.setStyle("fill", visualInRange.handlesColor[handleIndex]);
       handleThumb.y = handleEnds[handleIndex];
@@ -76454,13 +77246,13 @@ function getColorVisual(seriesModel, visualMapModel, value, valueState) {
 }
 
 // src/component/visualMap/preprocessor.ts
-var each19 = each;
+var each20 = each;
 function visualMapPreprocessor(option) {
   let visualMap = option && option.visualMap;
   if (!isArray(visualMap)) {
     visualMap = visualMap ? [visualMap] : [];
   }
-  each19(visualMap, function(opt) {
+  each20(visualMap, function(opt) {
     if (!opt) {
       return;
     }
@@ -76470,7 +77262,7 @@ function visualMapPreprocessor(option) {
     }
     const pieces = opt.pieces;
     if (pieces && isArray(pieces)) {
-      each19(pieces, function(piece) {
+      each20(pieces, function(piece) {
         if (isObject(piece)) {
           if (has2(piece, "start") && !has2(piece, "min")) {
             piece.min = piece.start;
@@ -76505,7 +77297,7 @@ function installCommon2(registers) {
 }
 
 // src/component/visualMap/installVisualMapContinuous.ts
-function install62(registers) {
+function install65(registers) {
   registers.registerComponentModel(ContinuousModel_default);
   registers.registerComponentView(ContinuousView_default);
   installCommon2(registers);
@@ -76945,16 +77737,16 @@ PiecewiseVisualMapView.type = "visualMap.piecewise";
 var PiecewiseView_default = PiecewiseVisualMapView;
 
 // src/component/visualMap/installVisualMapPiecewise.ts
-function install63(registers) {
+function install66(registers) {
   registers.registerComponentModel(PiecewiseModel_default);
   registers.registerComponentView(PiecewiseView_default);
   installCommon2(registers);
 }
 
 // src/component/visualMap/install.ts
-function install64(registers) {
-  use(install62);
-  use(install63);
+function install67(registers) {
+  use(install65);
+  use(install66);
 }
 
 // src/visual/aria.ts
@@ -77150,7 +77942,7 @@ function ariaPreprocessor(option) {
 }
 
 // src/component/aria/install.ts
-function install65(registers) {
+function install68(registers) {
   registers.registerPreprocessor(ariaPreprocessor);
   registers.registerVisual(registers.PRIORITY.VISUAL.ARIA, ariaVisual);
 }
@@ -77488,7 +78280,7 @@ var sortTransform = {
 };
 
 // src/component/transform/install.ts
-function install66(registers) {
+function install69(registers) {
   registers.registerTransform(filterTransform);
   registers.registerTransform(sortTransform);
 }
@@ -77526,7 +78318,7 @@ var DatasetView = class extends Component_default2 {
   }
 };
 DatasetView.type = "dataset";
-function install67(registers) {
+function install70(registers) {
   registers.registerComponentModel(DatasetModel);
   registers.registerComponentView(DatasetView);
 }
@@ -79253,44 +80045,47 @@ use([
   install26,
   install27,
   install28,
-  install30,
-  install31,
   install33,
   install32,
+  install30,
+  install31,
   install34,
-  install35,
   install36,
+  install35,
   install37,
-  install38
+  install38,
+  install39,
+  install40,
+  install41
 ]);
-use(install40);
-use(install41);
-use(install10);
-use(install42);
-use(install17);
 use(install43);
 use(install44);
+use(install10);
+use(install45);
+use(install17);
 use(install46);
 use(install47);
-use(install39);
-use(install48);
 use(install49);
 use(install50);
+use(install42);
 use(install51);
 use(install52);
 use(install53);
 use(install54);
 use(install55);
+use(install56);
+use(install57);
 use(install58);
 use(install61);
-use(install59);
-use(install60);
 use(install64);
 use(install62);
 use(install63);
+use(install67);
 use(install65);
 use(install66);
-use(install67);
+use(install68);
+use(install69);
+use(install70);
 use(installUniversalTransition);
 use(installLabelLayout);