@fecp/mobile 1.0.79 → 1.1.0

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/coord/Axis.mjs

@@ -0,0 +1,176 @@
+import { map, each } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { getPixelPrecision, linearMap, round } from "../util/number.mjs";
+import { createAxisTicks, createAxisLabels, calculateCategoryInterval } from "./axisTickLabelBuilder.mjs";
+var NORMALIZED_EXTENT = [0, 1];
+var Axis = (
+  /** @class */
+  function() {
+    function Axis2(dim, scale, extent) {
+      this.onBand = false;
+      this.inverse = false;
+      this.dim = dim;
+      this.scale = scale;
+      this._extent = extent || [0, 0];
+    }
+    Axis2.prototype.contain = function(coord) {
+      var extent = this._extent;
+      var min = Math.min(extent[0], extent[1]);
+      var max = Math.max(extent[0], extent[1]);
+      return coord >= min && coord <= max;
+    };
+    Axis2.prototype.containData = function(data) {
+      return this.scale.contain(data);
+    };
+    Axis2.prototype.getExtent = function() {
+      return this._extent.slice();
+    };
+    Axis2.prototype.getPixelPrecision = function(dataExtent) {
+      return getPixelPrecision(dataExtent || this.scale.getExtent(), this._extent);
+    };
+    Axis2.prototype.setExtent = function(start, end) {
+      var extent = this._extent;
+      extent[0] = start;
+      extent[1] = end;
+    };
+    Axis2.prototype.dataToCoord = function(data, clamp) {
+      var extent = this._extent;
+      var scale = this.scale;
+      data = scale.normalize(data);
+      if (this.onBand && scale.type === "ordinal") {
+        extent = extent.slice();
+        fixExtentWithBands(extent, scale.count());
+      }
+      return linearMap(data, NORMALIZED_EXTENT, extent, clamp);
+    };
+    Axis2.prototype.coordToData = function(coord, clamp) {
+      var extent = this._extent;
+      var scale = this.scale;
+      if (this.onBand && scale.type === "ordinal") {
+        extent = extent.slice();
+        fixExtentWithBands(extent, scale.count());
+      }
+      var t = linearMap(coord, extent, NORMALIZED_EXTENT, clamp);
+      return this.scale.scale(t);
+    };
+    Axis2.prototype.pointToData = function(point, clamp) {
+      return;
+    };
+    Axis2.prototype.getTicksCoords = function(opt) {
+      opt = opt || {};
+      var tickModel = opt.tickModel || this.getTickModel();
+      var result = createAxisTicks(this, tickModel);
+      var ticks = result.ticks;
+      var ticksCoords = map(ticks, function(tickVal) {
+        return {
+          coord: this.dataToCoord(this.scale.type === "ordinal" ? this.scale.getRawOrdinalNumber(tickVal) : tickVal),
+          tickValue: tickVal
+        };
+      }, this);
+      var alignWithLabel = tickModel.get("alignWithLabel");
+      fixOnBandTicksCoords(this, ticksCoords, alignWithLabel, opt.clamp);
+      return ticksCoords;
+    };
+    Axis2.prototype.getMinorTicksCoords = function() {
+      if (this.scale.type === "ordinal") {
+        return [];
+      }
+      var minorTickModel = this.model.getModel("minorTick");
+      var splitNumber = minorTickModel.get("splitNumber");
+      if (!(splitNumber > 0 && splitNumber < 100)) {
+        splitNumber = 5;
+      }
+      var minorTicks = this.scale.getMinorTicks(splitNumber);
+      var minorTicksCoords = map(minorTicks, function(minorTicksGroup) {
+        return map(minorTicksGroup, function(minorTick) {
+          return {
+            coord: this.dataToCoord(minorTick),
+            tickValue: minorTick
+          };
+        }, this);
+      }, this);
+      return minorTicksCoords;
+    };
+    Axis2.prototype.getViewLabels = function() {
+      return createAxisLabels(this).labels;
+    };
+    Axis2.prototype.getLabelModel = function() {
+      return this.model.getModel("axisLabel");
+    };
+    Axis2.prototype.getTickModel = function() {
+      return this.model.getModel("axisTick");
+    };
+    Axis2.prototype.getBandWidth = function() {
+      var axisExtent = this._extent;
+      var dataExtent = this.scale.getExtent();
+      var len = dataExtent[1] - dataExtent[0] + (this.onBand ? 1 : 0);
+      len === 0 && (len = 1);
+      var size = Math.abs(axisExtent[1] - axisExtent[0]);
+      return Math.abs(size) / len;
+    };
+    Axis2.prototype.calculateCategoryInterval = function() {
+      return calculateCategoryInterval(this);
+    };
+    return Axis2;
+  }()
+);
+function fixExtentWithBands(extent, nTick) {
+  var size = extent[1] - extent[0];
+  var len = nTick;
+  var margin = size / len / 2;
+  extent[0] += margin;
+  extent[1] -= margin;
+}
+function fixOnBandTicksCoords(axis, ticksCoords, alignWithLabel, clamp) {
+  var ticksLen = ticksCoords.length;
+  if (!axis.onBand || alignWithLabel || !ticksLen) {
+    return;
+  }
+  var axisExtent = axis.getExtent();
+  var last;
+  var diffSize;
+  if (ticksLen === 1) {
+    ticksCoords[0].coord = axisExtent[0];
+    last = ticksCoords[1] = {
+      coord: axisExtent[1],
+      tickValue: ticksCoords[0].tickValue
+    };
+  } else {
+    var crossLen = ticksCoords[ticksLen - 1].tickValue - ticksCoords[0].tickValue;
+    var shift_1 = (ticksCoords[ticksLen - 1].coord - ticksCoords[0].coord) / crossLen;
+    each(ticksCoords, function(ticksItem) {
+      ticksItem.coord -= shift_1 / 2;
+    });
+    var dataExtent = axis.scale.getExtent();
+    diffSize = 1 + dataExtent[1] - ticksCoords[ticksLen - 1].tickValue;
+    last = {
+      coord: ticksCoords[ticksLen - 1].coord + shift_1 * diffSize,
+      tickValue: dataExtent[1] + 1
+    };
+    ticksCoords.push(last);
+  }
+  var inverse = axisExtent[0] > axisExtent[1];
+  if (littleThan(ticksCoords[0].coord, axisExtent[0])) {
+    clamp ? ticksCoords[0].coord = axisExtent[0] : ticksCoords.shift();
+  }
+  if (clamp && littleThan(axisExtent[0], ticksCoords[0].coord)) {
+    ticksCoords.unshift({
+      coord: axisExtent[0]
+    });
+  }
+  if (littleThan(axisExtent[1], last.coord)) {
+    clamp ? last.coord = axisExtent[1] : ticksCoords.pop();
+  }
+  if (clamp && littleThan(last.coord, axisExtent[1])) {
+    ticksCoords.push({
+      coord: axisExtent[1]
+    });
+  }
+  function littleThan(a, b) {
+    a = round(a);
+    b = round(b);
+    return inverse ? a > b : a < b;
+  }
+}
+export {
+  Axis as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/coord/CoordinateSystem.mjs

@@ -0,0 +1,6 @@
+function isCoordinateSystemType(coordSys, type) {
+  return coordSys.type === type;
+}
+export {
+  isCoordinateSystemType
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/coord/axisAlignTicks.mjs

@@ -0,0 +1,76 @@
+import { round } from "../util/number.mjs";
+import IntervalScale from "../scale/Interval.mjs";
+import { getScaleExtent } from "./axisHelper.mjs";
+import { increaseInterval } from "../scale/helper.mjs";
+var mathLog = Math.log;
+function alignScaleTicks(scale, axisModel, alignToScale) {
+  var intervalScaleProto = IntervalScale.prototype;
+  var alignToTicks = intervalScaleProto.getTicks.call(alignToScale);
+  var alignToNicedTicks = intervalScaleProto.getTicks.call(alignToScale, true);
+  var alignToSplitNumber = alignToTicks.length - 1;
+  var alignToInterval = intervalScaleProto.getInterval.call(alignToScale);
+  var scaleExtent = getScaleExtent(scale, axisModel);
+  var rawExtent = scaleExtent.extent;
+  var isMinFixed = scaleExtent.fixMin;
+  var isMaxFixed = scaleExtent.fixMax;
+  if (scale.type === "log") {
+    var logBase = mathLog(scale.base);
+    rawExtent = [mathLog(rawExtent[0]) / logBase, mathLog(rawExtent[1]) / logBase];
+  }
+  scale.setExtent(rawExtent[0], rawExtent[1]);
+  scale.calcNiceExtent({
+    splitNumber: alignToSplitNumber,
+    fixMin: isMinFixed,
+    fixMax: isMaxFixed
+  });
+  var extent = intervalScaleProto.getExtent.call(scale);
+  if (isMinFixed) {
+    rawExtent[0] = extent[0];
+  }
+  if (isMaxFixed) {
+    rawExtent[1] = extent[1];
+  }
+  var interval = intervalScaleProto.getInterval.call(scale);
+  var min = rawExtent[0];
+  var max = rawExtent[1];
+  if (isMinFixed && isMaxFixed) {
+    interval = (max - min) / alignToSplitNumber;
+  } else if (isMinFixed) {
+    max = rawExtent[0] + interval * alignToSplitNumber;
+    while (max < rawExtent[1] && isFinite(max) && isFinite(rawExtent[1])) {
+      interval = increaseInterval(interval);
+      max = rawExtent[0] + interval * alignToSplitNumber;
+    }
+  } else if (isMaxFixed) {
+    min = rawExtent[1] - interval * alignToSplitNumber;
+    while (min > rawExtent[0] && isFinite(min) && isFinite(rawExtent[0])) {
+      interval = increaseInterval(interval);
+      min = rawExtent[1] - interval * alignToSplitNumber;
+    }
+  } else {
+    var nicedSplitNumber = scale.getTicks().length - 1;
+    if (nicedSplitNumber > alignToSplitNumber) {
+      interval = increaseInterval(interval);
+    }
+    var range = interval * alignToSplitNumber;
+    max = Math.ceil(rawExtent[1] / interval) * interval;
+    min = round(max - range);
+    if (min < 0 && rawExtent[0] >= 0) {
+      min = 0;
+      max = round(range);
+    } else if (max > 0 && rawExtent[1] <= 0) {
+      max = 0;
+      min = -round(range);
+    }
+  }
+  var t0 = (alignToTicks[0].value - alignToNicedTicks[0].value) / alignToInterval;
+  var t1 = (alignToTicks[alignToSplitNumber].value - alignToNicedTicks[alignToSplitNumber].value) / alignToInterval;
+  intervalScaleProto.setExtent.call(scale, min + interval * t0, max + interval * t1);
+  intervalScaleProto.setInterval.call(scale, interval);
+  if (t0 || t1) {
+    intervalScaleProto.setNiceExtent.call(scale, min + interval, max - interval);
+  }
+}
+export {
+  alignScaleTicks
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/coord/axisCommonTypes.mjs

@@ -0,0 +1,9 @@
+var AXIS_TYPES = {
+  value: 1,
+  category: 1,
+  time: 1,
+  log: 1
+};
+export {
+  AXIS_TYPES
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/coord/axisDefault.mjs

@@ -0,0 +1,164 @@
+import { defaults, merge } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+var defaultOption = {
+  show: true,
+  // zlevel: 0,
+  z: 0,
+  // Inverse the axis.
+  inverse: false,
+  // Axis name displayed.
+  name: "",
+  // 'start' | 'middle' | 'end'
+  nameLocation: "end",
+  // By degree. By default auto rotate by nameLocation.
+  nameRotate: null,
+  nameTruncate: {
+    maxWidth: null,
+    ellipsis: "...",
+    placeholder: "."
+  },
+  // Use global text style by default.
+  nameTextStyle: {},
+  // The gap between axisName and axisLine.
+  nameGap: 15,
+  // Default `false` to support tooltip.
+  silent: false,
+  // Default `false` to avoid legacy user event listener fail.
+  triggerEvent: false,
+  tooltip: {
+    show: false
+  },
+  axisPointer: {},
+  axisLine: {
+    show: true,
+    onZero: true,
+    onZeroAxisIndex: null,
+    lineStyle: {
+      color: "#6E7079",
+      width: 1,
+      type: "solid"
+    },
+    // The arrow at both ends the the axis.
+    symbol: ["none", "none"],
+    symbolSize: [10, 15]
+  },
+  axisTick: {
+    show: true,
+    // Whether axisTick is inside the grid or outside the grid.
+    inside: false,
+    // The length of axisTick.
+    length: 5,
+    lineStyle: {
+      width: 1
+    }
+  },
+  axisLabel: {
+    show: true,
+    // Whether axisLabel is inside the grid or outside the grid.
+    inside: false,
+    rotate: 0,
+    // true | false | null/undefined (auto)
+    showMinLabel: null,
+    // true | false | null/undefined (auto)
+    showMaxLabel: null,
+    margin: 8,
+    // formatter: null,
+    fontSize: 12
+  },
+  splitLine: {
+    show: true,
+    showMinLine: true,
+    showMaxLine: true,
+    lineStyle: {
+      color: ["#E0E6F1"],
+      width: 1,
+      type: "solid"
+    }
+  },
+  splitArea: {
+    show: false,
+    areaStyle: {
+      color: ["rgba(250,250,250,0.2)", "rgba(210,219,238,0.2)"]
+    }
+  }
+};
+var categoryAxis = merge({
+  // The gap at both ends of the axis. For categoryAxis, boolean.
+  boundaryGap: true,
+  // Set false to faster category collection.
+  deduplication: null,
+  // splitArea: {
+  // show: false
+  // },
+  splitLine: {
+    show: false
+  },
+  axisTick: {
+    // If tick is align with label when boundaryGap is true
+    alignWithLabel: false,
+    interval: "auto"
+  },
+  axisLabel: {
+    interval: "auto"
+  }
+}, defaultOption);
+var valueAxis = merge({
+  boundaryGap: [0, 0],
+  axisLine: {
+    // Not shown when other axis is categoryAxis in cartesian
+    show: "auto"
+  },
+  axisTick: {
+    // Not shown when other axis is categoryAxis in cartesian
+    show: "auto"
+  },
+  // TODO
+  // min/max: [30, datamin, 60] or [20, datamin] or [datamin, 60]
+  splitNumber: 5,
+  minorTick: {
+    // Minor tick, not available for cateogry axis.
+    show: false,
+    // Split number of minor ticks. The value should be in range of (0, 100)
+    splitNumber: 5,
+    // Length of minor tick
+    length: 3,
+    // Line style
+    lineStyle: {
+      // Default to be same with axisTick
+    }
+  },
+  minorSplitLine: {
+    show: false,
+    lineStyle: {
+      color: "#F4F7FD",
+      width: 1
+    }
+  }
+}, defaultOption);
+var timeAxis = merge({
+  splitNumber: 6,
+  axisLabel: {
+    // To eliminate labels that are not nice
+    showMinLabel: false,
+    showMaxLabel: false,
+    rich: {
+      primary: {
+        fontWeight: "bold"
+      }
+    }
+  },
+  splitLine: {
+    show: false
+  }
+}, valueAxis);
+var logAxis = defaults({
+  logBase: 10
+}, valueAxis);
+const axisDefault = {
+  category: categoryAxis,
+  value: valueAxis,
+  time: timeAxis,
+  log: logAxis
+};
+export {
+  axisDefault as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/coord/axisHelper.mjs

@@ -0,0 +1,233 @@
+import { isString, isFunction, each, keys } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import OrdinalScale from "../scale/Ordinal.mjs";
+import IntervalScale from "../scale/Interval.mjs";
+import Scale from "../scale/Scale.mjs";
+import { prepareLayoutBarSeries, makeColumnLayout, retrieveColumnLayout } from "../layout/barGrid.mjs";
+import BoundingRect from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/BoundingRect.mjs";
+import TimeScale from "../scale/Time.mjs";
+import LogScale from "../scale/Log.mjs";
+import { getStackedDimension } from "../data/helper/dataStackHelper.mjs";
+import { ensureScaleRawExtentInfo } from "./scaleRawExtentInfo.mjs";
+function getScaleExtent(scale, model) {
+  var scaleType = scale.type;
+  var rawExtentResult = ensureScaleRawExtentInfo(scale, model, scale.getExtent()).calculate();
+  scale.setBlank(rawExtentResult.isBlank);
+  var min = rawExtentResult.min;
+  var max = rawExtentResult.max;
+  var ecModel = model.ecModel;
+  if (ecModel && scaleType === "time") {
+    var barSeriesModels = prepareLayoutBarSeries("bar", ecModel);
+    var isBaseAxisAndHasBarSeries_1 = false;
+    each(barSeriesModels, function(seriesModel) {
+      isBaseAxisAndHasBarSeries_1 = isBaseAxisAndHasBarSeries_1 || seriesModel.getBaseAxis() === model.axis;
+    });
+    if (isBaseAxisAndHasBarSeries_1) {
+      var barWidthAndOffset = makeColumnLayout(barSeriesModels);
+      var adjustedScale = adjustScaleForOverflow(min, max, model, barWidthAndOffset);
+      min = adjustedScale.min;
+      max = adjustedScale.max;
+    }
+  }
+  return {
+    extent: [min, max],
+    // "fix" means "fixed", the value should not be
+    // changed in the subsequent steps.
+    fixMin: rawExtentResult.minFixed,
+    fixMax: rawExtentResult.maxFixed
+  };
+}
+function adjustScaleForOverflow(min, max, model, barWidthAndOffset) {
+  var axisExtent = model.axis.getExtent();
+  var axisLength = Math.abs(axisExtent[1] - axisExtent[0]);
+  var barsOnCurrentAxis = retrieveColumnLayout(barWidthAndOffset, model.axis);
+  if (barsOnCurrentAxis === void 0) {
+    return {
+      min,
+      max
+    };
+  }
+  var minOverflow = Infinity;
+  each(barsOnCurrentAxis, function(item) {
+    minOverflow = Math.min(item.offset, minOverflow);
+  });
+  var maxOverflow = -Infinity;
+  each(barsOnCurrentAxis, function(item) {
+    maxOverflow = Math.max(item.offset + item.width, maxOverflow);
+  });
+  minOverflow = Math.abs(minOverflow);
+  maxOverflow = Math.abs(maxOverflow);
+  var totalOverFlow = minOverflow + maxOverflow;
+  var oldRange = max - min;
+  var oldRangePercentOfNew = 1 - (minOverflow + maxOverflow) / axisLength;
+  var overflowBuffer = oldRange / oldRangePercentOfNew - oldRange;
+  max += overflowBuffer * (maxOverflow / totalOverFlow);
+  min -= overflowBuffer * (minOverflow / totalOverFlow);
+  return {
+    min,
+    max
+  };
+}
+function niceScaleExtent(scale, inModel) {
+  var model = inModel;
+  var extentInfo = getScaleExtent(scale, model);
+  var extent = extentInfo.extent;
+  var splitNumber = model.get("splitNumber");
+  if (scale instanceof LogScale) {
+    scale.base = model.get("logBase");
+  }
+  var scaleType = scale.type;
+  var interval = model.get("interval");
+  var isIntervalOrTime = scaleType === "interval" || scaleType === "time";
+  scale.setExtent(extent[0], extent[1]);
+  scale.calcNiceExtent({
+    splitNumber,
+    fixMin: extentInfo.fixMin,
+    fixMax: extentInfo.fixMax,
+    minInterval: isIntervalOrTime ? model.get("minInterval") : null,
+    maxInterval: isIntervalOrTime ? model.get("maxInterval") : null
+  });
+  if (interval != null) {
+    scale.setInterval && scale.setInterval(interval);
+  }
+}
+function createScaleByModel(model, axisType) {
+  axisType = axisType || model.get("type");
+  if (axisType) {
+    switch (axisType) {
+      // Buildin scale
+      case "category":
+        return new OrdinalScale({
+          ordinalMeta: model.getOrdinalMeta ? model.getOrdinalMeta() : model.getCategories(),
+          extent: [Infinity, -Infinity]
+        });
+      case "time":
+        return new TimeScale({
+          locale: model.ecModel.getLocaleModel(),
+          useUTC: model.ecModel.get("useUTC")
+        });
+      default:
+        return new (Scale.getClass(axisType) || IntervalScale)();
+    }
+  }
+}
+function ifAxisCrossZero(axis) {
+  var dataExtent = axis.scale.getExtent();
+  var min = dataExtent[0];
+  var max = dataExtent[1];
+  return !(min > 0 && max > 0 || min < 0 && max < 0);
+}
+function makeLabelFormatter(axis) {
+  var labelFormatter = axis.getLabelModel().get("formatter");
+  var categoryTickStart = axis.type === "category" ? axis.scale.getExtent()[0] : null;
+  if (axis.scale.type === "time") {
+    return /* @__PURE__ */ function(tpl) {
+      return function(tick, idx) {
+        return axis.scale.getFormattedLabel(tick, idx, tpl);
+      };
+    }(labelFormatter);
+  } else if (isString(labelFormatter)) {
+    return /* @__PURE__ */ function(tpl) {
+      return function(tick) {
+        var label = axis.scale.getLabel(tick);
+        var text = tpl.replace("{value}", label != null ? label : "");
+        return text;
+      };
+    }(labelFormatter);
+  } else if (isFunction(labelFormatter)) {
+    return /* @__PURE__ */ function(cb) {
+      return function(tick, idx) {
+        if (categoryTickStart != null) {
+          idx = tick.value - categoryTickStart;
+        }
+        return cb(getAxisRawValue(axis, tick), idx, tick.level != null ? {
+          level: tick.level
+        } : null);
+      };
+    }(labelFormatter);
+  } else {
+    return function(tick) {
+      return axis.scale.getLabel(tick);
+    };
+  }
+}
+function getAxisRawValue(axis, tick) {
+  return axis.type === "category" ? axis.scale.getLabel(tick) : tick.value;
+}
+function estimateLabelUnionRect(axis) {
+  var axisModel = axis.model;
+  var scale = axis.scale;
+  if (!axisModel.get(["axisLabel", "show"]) || scale.isBlank()) {
+    return;
+  }
+  var realNumberScaleTicks;
+  var tickCount;
+  var categoryScaleExtent = scale.getExtent();
+  if (scale instanceof OrdinalScale) {
+    tickCount = scale.count();
+  } else {
+    realNumberScaleTicks = scale.getTicks();
+    tickCount = realNumberScaleTicks.length;
+  }
+  var axisLabelModel = axis.getLabelModel();
+  var labelFormatter = makeLabelFormatter(axis);
+  var rect;
+  var step = 1;
+  if (tickCount > 40) {
+    step = Math.ceil(tickCount / 40);
+  }
+  for (var i = 0; i < tickCount; i += step) {
+    var tick = realNumberScaleTicks ? realNumberScaleTicks[i] : {
+      value: categoryScaleExtent[0] + i
+    };
+    var label = labelFormatter(tick, i);
+    var unrotatedSingleRect = axisLabelModel.getTextRect(label);
+    var singleRect = rotateTextRect(unrotatedSingleRect, axisLabelModel.get("rotate") || 0);
+    rect ? rect.union(singleRect) : rect = singleRect;
+  }
+  return rect;
+}
+function rotateTextRect(textRect, rotate) {
+  var rotateRadians = rotate * Math.PI / 180;
+  var beforeWidth = textRect.width;
+  var beforeHeight = textRect.height;
+  var afterWidth = beforeWidth * Math.abs(Math.cos(rotateRadians)) + Math.abs(beforeHeight * Math.sin(rotateRadians));
+  var afterHeight = beforeWidth * Math.abs(Math.sin(rotateRadians)) + Math.abs(beforeHeight * Math.cos(rotateRadians));
+  var rotatedRect = new BoundingRect(textRect.x, textRect.y, afterWidth, afterHeight);
+  return rotatedRect;
+}
+function getOptionCategoryInterval(model) {
+  var interval = model.get("interval");
+  return interval == null ? "auto" : interval;
+}
+function shouldShowAllLabels(axis) {
+  return axis.type === "category" && getOptionCategoryInterval(axis.getLabelModel()) === 0;
+}
+function getDataDimensionsOnAxis(data, axisDim) {
+  var dataDimMap = {};
+  each(data.mapDimensionsAll(axisDim), function(dataDim) {
+    dataDimMap[getStackedDimension(data, dataDim)] = true;
+  });
+  return keys(dataDimMap);
+}
+function unionAxisExtentFromData(dataExtent, data, axisDim) {
+  if (data) {
+    each(getDataDimensionsOnAxis(data, axisDim), function(dim) {
+      var seriesExtent = data.getApproximateExtent(dim);
+      seriesExtent[0] < dataExtent[0] && (dataExtent[0] = seriesExtent[0]);
+      seriesExtent[1] > dataExtent[1] && (dataExtent[1] = seriesExtent[1]);
+    });
+  }
+}
+export {
+  createScaleByModel,
+  estimateLabelUnionRect,
+  getAxisRawValue,
+  getDataDimensionsOnAxis,
+  getOptionCategoryInterval,
+  getScaleExtent,
+  ifAxisCrossZero,
+  makeLabelFormatter,
+  niceScaleExtent,
+  shouldShowAllLabels,
+  unionAxisExtentFromData
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/coord/axisModelCommonMixin.mjs

@@ -0,0 +1,18 @@
+var AxisModelCommonMixin = (
+  /** @class */
+  function() {
+    function AxisModelCommonMixin2() {
+    }
+    AxisModelCommonMixin2.prototype.getNeedCrossZero = function() {
+      var option = this.option;
+      return !option.scale;
+    };
+    AxisModelCommonMixin2.prototype.getCoordSysModel = function() {
+      return;
+    };
+    return AxisModelCommonMixin2;
+  }()
+);
+export {
+  AxisModelCommonMixin
+};