@fecp/mobile 1.0.79 → 1.1.1

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/preprocessor/helper/compatStyle.mjs

@@ -0,0 +1,239 @@
+import { each as each$1, isObject as isObject$1, isArray, isTypedArray, defaults, merge } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { TEXT_STYLE_OPTIONS } from "../../util/model.mjs";
+var each = each$1;
+var isObject = isObject$1;
+var POSSIBLE_STYLES = ["areaStyle", "lineStyle", "nodeStyle", "linkStyle", "chordStyle", "label", "labelLine"];
+function compatEC2ItemStyle(opt) {
+  var itemStyleOpt = opt && opt.itemStyle;
+  if (!itemStyleOpt) {
+    return;
+  }
+  for (var i = 0, len = POSSIBLE_STYLES.length; i < len; i++) {
+    var styleName = POSSIBLE_STYLES[i];
+    var normalItemStyleOpt = itemStyleOpt.normal;
+    var emphasisItemStyleOpt = itemStyleOpt.emphasis;
+    if (normalItemStyleOpt && normalItemStyleOpt[styleName]) {
+      opt[styleName] = opt[styleName] || {};
+      if (!opt[styleName].normal) {
+        opt[styleName].normal = normalItemStyleOpt[styleName];
+      } else {
+        merge(opt[styleName].normal, normalItemStyleOpt[styleName]);
+      }
+      normalItemStyleOpt[styleName] = null;
+    }
+    if (emphasisItemStyleOpt && emphasisItemStyleOpt[styleName]) {
+      opt[styleName] = opt[styleName] || {};
+      if (!opt[styleName].emphasis) {
+        opt[styleName].emphasis = emphasisItemStyleOpt[styleName];
+      } else {
+        merge(opt[styleName].emphasis, emphasisItemStyleOpt[styleName]);
+      }
+      emphasisItemStyleOpt[styleName] = null;
+    }
+  }
+}
+function convertNormalEmphasis(opt, optType, useExtend) {
+  if (opt && opt[optType] && (opt[optType].normal || opt[optType].emphasis)) {
+    var normalOpt = opt[optType].normal;
+    var emphasisOpt = opt[optType].emphasis;
+    if (normalOpt) {
+      if (useExtend) {
+        opt[optType].normal = opt[optType].emphasis = null;
+        defaults(opt[optType], normalOpt);
+      } else {
+        opt[optType] = normalOpt;
+      }
+    }
+    if (emphasisOpt) {
+      opt.emphasis = opt.emphasis || {};
+      opt.emphasis[optType] = emphasisOpt;
+      if (emphasisOpt.focus) {
+        opt.emphasis.focus = emphasisOpt.focus;
+      }
+      if (emphasisOpt.blurScope) {
+        opt.emphasis.blurScope = emphasisOpt.blurScope;
+      }
+    }
+  }
+}
+function removeEC3NormalStatus(opt) {
+  convertNormalEmphasis(opt, "itemStyle");
+  convertNormalEmphasis(opt, "lineStyle");
+  convertNormalEmphasis(opt, "areaStyle");
+  convertNormalEmphasis(opt, "label");
+  convertNormalEmphasis(opt, "labelLine");
+  convertNormalEmphasis(opt, "upperLabel");
+  convertNormalEmphasis(opt, "edgeLabel");
+}
+function compatTextStyle(opt, propName) {
+  var labelOptSingle = isObject(opt) && opt[propName];
+  var textStyle = isObject(labelOptSingle) && labelOptSingle.textStyle;
+  if (textStyle) {
+    for (var i = 0, len = TEXT_STYLE_OPTIONS.length; i < len; i++) {
+      var textPropName = TEXT_STYLE_OPTIONS[i];
+      if (textStyle.hasOwnProperty(textPropName)) {
+        labelOptSingle[textPropName] = textStyle[textPropName];
+      }
+    }
+  }
+}
+function compatEC3CommonStyles(opt) {
+  if (opt) {
+    removeEC3NormalStatus(opt);
+    compatTextStyle(opt, "label");
+    opt.emphasis && compatTextStyle(opt.emphasis, "label");
+  }
+}
+function processSeries(seriesOpt) {
+  if (!isObject(seriesOpt)) {
+    return;
+  }
+  compatEC2ItemStyle(seriesOpt);
+  removeEC3NormalStatus(seriesOpt);
+  compatTextStyle(seriesOpt, "label");
+  compatTextStyle(seriesOpt, "upperLabel");
+  compatTextStyle(seriesOpt, "edgeLabel");
+  if (seriesOpt.emphasis) {
+    compatTextStyle(seriesOpt.emphasis, "label");
+    compatTextStyle(seriesOpt.emphasis, "upperLabel");
+    compatTextStyle(seriesOpt.emphasis, "edgeLabel");
+  }
+  var markPoint = seriesOpt.markPoint;
+  if (markPoint) {
+    compatEC2ItemStyle(markPoint);
+    compatEC3CommonStyles(markPoint);
+  }
+  var markLine = seriesOpt.markLine;
+  if (markLine) {
+    compatEC2ItemStyle(markLine);
+    compatEC3CommonStyles(markLine);
+  }
+  var markArea = seriesOpt.markArea;
+  if (markArea) {
+    compatEC3CommonStyles(markArea);
+  }
+  var data = seriesOpt.data;
+  if (seriesOpt.type === "graph") {
+    data = data || seriesOpt.nodes;
+    var edgeData = seriesOpt.links || seriesOpt.edges;
+    if (edgeData && !isTypedArray(edgeData)) {
+      for (var i = 0; i < edgeData.length; i++) {
+        compatEC3CommonStyles(edgeData[i]);
+      }
+    }
+    each$1(seriesOpt.categories, function(opt) {
+      removeEC3NormalStatus(opt);
+    });
+  }
+  if (data && !isTypedArray(data)) {
+    for (var i = 0; i < data.length; i++) {
+      compatEC3CommonStyles(data[i]);
+    }
+  }
+  markPoint = seriesOpt.markPoint;
+  if (markPoint && markPoint.data) {
+    var mpData = markPoint.data;
+    for (var i = 0; i < mpData.length; i++) {
+      compatEC3CommonStyles(mpData[i]);
+    }
+  }
+  markLine = seriesOpt.markLine;
+  if (markLine && markLine.data) {
+    var mlData = markLine.data;
+    for (var i = 0; i < mlData.length; i++) {
+      if (isArray(mlData[i])) {
+        compatEC3CommonStyles(mlData[i][0]);
+        compatEC3CommonStyles(mlData[i][1]);
+      } else {
+        compatEC3CommonStyles(mlData[i]);
+      }
+    }
+  }
+  if (seriesOpt.type === "gauge") {
+    compatTextStyle(seriesOpt, "axisLabel");
+    compatTextStyle(seriesOpt, "title");
+    compatTextStyle(seriesOpt, "detail");
+  } else if (seriesOpt.type === "treemap") {
+    convertNormalEmphasis(seriesOpt.breadcrumb, "itemStyle");
+    each$1(seriesOpt.levels, function(opt) {
+      removeEC3NormalStatus(opt);
+    });
+  } else if (seriesOpt.type === "tree") {
+    removeEC3NormalStatus(seriesOpt.leaves);
+  }
+}
+function toArr(o) {
+  return isArray(o) ? o : o ? [o] : [];
+}
+function toObj(o) {
+  return (isArray(o) ? o[0] : o) || {};
+}
+function globalCompatStyle(option, isTheme) {
+  each(toArr(option.series), function(seriesOpt) {
+    isObject(seriesOpt) && processSeries(seriesOpt);
+  });
+  var axes = ["xAxis", "yAxis", "radiusAxis", "angleAxis", "singleAxis", "parallelAxis", "radar"];
+  isTheme && axes.push("valueAxis", "categoryAxis", "logAxis", "timeAxis");
+  each(axes, function(axisName) {
+    each(toArr(option[axisName]), function(axisOpt) {
+      if (axisOpt) {
+        compatTextStyle(axisOpt, "axisLabel");
+        compatTextStyle(axisOpt.axisPointer, "label");
+      }
+    });
+  });
+  each(toArr(option.parallel), function(parallelOpt) {
+    var parallelAxisDefault = parallelOpt && parallelOpt.parallelAxisDefault;
+    compatTextStyle(parallelAxisDefault, "axisLabel");
+    compatTextStyle(parallelAxisDefault && parallelAxisDefault.axisPointer, "label");
+  });
+  each(toArr(option.calendar), function(calendarOpt) {
+    convertNormalEmphasis(calendarOpt, "itemStyle");
+    compatTextStyle(calendarOpt, "dayLabel");
+    compatTextStyle(calendarOpt, "monthLabel");
+    compatTextStyle(calendarOpt, "yearLabel");
+  });
+  each(toArr(option.radar), function(radarOpt) {
+    compatTextStyle(radarOpt, "name");
+    if (radarOpt.name && radarOpt.axisName == null) {
+      radarOpt.axisName = radarOpt.name;
+      delete radarOpt.name;
+    }
+    if (radarOpt.nameGap != null && radarOpt.axisNameGap == null) {
+      radarOpt.axisNameGap = radarOpt.nameGap;
+      delete radarOpt.nameGap;
+    }
+  });
+  each(toArr(option.geo), function(geoOpt) {
+    if (isObject(geoOpt)) {
+      compatEC3CommonStyles(geoOpt);
+      each(toArr(geoOpt.regions), function(regionObj) {
+        compatEC3CommonStyles(regionObj);
+      });
+    }
+  });
+  each(toArr(option.timeline), function(timelineOpt) {
+    compatEC3CommonStyles(timelineOpt);
+    convertNormalEmphasis(timelineOpt, "label");
+    convertNormalEmphasis(timelineOpt, "itemStyle");
+    convertNormalEmphasis(timelineOpt, "controlStyle", true);
+    var data = timelineOpt.data;
+    isArray(data) && each$1(data, function(item) {
+      if (isObject$1(item)) {
+        convertNormalEmphasis(item, "label");
+        convertNormalEmphasis(item, "itemStyle");
+      }
+    });
+  });
+  each(toArr(option.toolbox), function(toolboxOpt) {
+    convertNormalEmphasis(toolboxOpt, "iconStyle");
+    each(toolboxOpt.feature, function(featureOpt) {
+      convertNormalEmphasis(featureOpt, "iconStyle");
+    });
+  });
+  compatTextStyle(toObj(option.axisPointer), "label");
+  compatTextStyle(toObj(option.tooltip).axisPointer, "label");
+}
+export {
+  globalCompatStyle as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/processor/dataFilter.mjs

@@ -0,0 +1,26 @@
+function dataFilter(seriesType) {
+  return {
+    seriesType,
+    reset: function(seriesModel, ecModel) {
+      var legendModels = ecModel.findComponents({
+        mainType: "legend"
+      });
+      if (!legendModels || !legendModels.length) {
+        return;
+      }
+      var data = seriesModel.getData();
+      data.filterSelf(function(idx) {
+        var name = data.getName(idx);
+        for (var i = 0; i < legendModels.length; i++) {
+          if (!legendModels[i].isSelected(name)) {
+            return false;
+          }
+        }
+        return true;
+      });
+    }
+  };
+}
+export {
+  dataFilter as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/processor/dataSample.mjs

@@ -0,0 +1,83 @@
+import { isString, isFunction } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+var samplers = {
+  average: function(frame) {
+    var sum = 0;
+    var count = 0;
+    for (var i = 0; i < frame.length; i++) {
+      if (!isNaN(frame[i])) {
+        sum += frame[i];
+        count++;
+      }
+    }
+    return count === 0 ? NaN : sum / count;
+  },
+  sum: function(frame) {
+    var sum = 0;
+    for (var i = 0; i < frame.length; i++) {
+      sum += frame[i] || 0;
+    }
+    return sum;
+  },
+  max: function(frame) {
+    var max = -Infinity;
+    for (var i = 0; i < frame.length; i++) {
+      frame[i] > max && (max = frame[i]);
+    }
+    return isFinite(max) ? max : NaN;
+  },
+  min: function(frame) {
+    var min = Infinity;
+    for (var i = 0; i < frame.length; i++) {
+      frame[i] < min && (min = frame[i]);
+    }
+    return isFinite(min) ? min : NaN;
+  },
+  // TODO
+  // Median
+  nearest: function(frame) {
+    return frame[0];
+  }
+};
+var indexSampler = function(frame) {
+  return Math.round(frame.length / 2);
+};
+function dataSample(seriesType) {
+  return {
+    seriesType,
+    // FIXME:TS never used, so comment it
+    // modifyOutputEnd: true,
+    reset: function(seriesModel, ecModel, api) {
+      var data = seriesModel.getData();
+      var sampling = seriesModel.get("sampling");
+      var coordSys = seriesModel.coordinateSystem;
+      var count = data.count();
+      if (count > 10 && coordSys.type === "cartesian2d" && sampling) {
+        var baseAxis = coordSys.getBaseAxis();
+        var valueAxis = coordSys.getOtherAxis(baseAxis);
+        var extent = baseAxis.getExtent();
+        var dpr = api.getDevicePixelRatio();
+        var size = Math.abs(extent[1] - extent[0]) * (dpr || 1);
+        var rate = Math.round(count / size);
+        if (isFinite(rate) && rate > 1) {
+          if (sampling === "lttb") {
+            seriesModel.setData(data.lttbDownSample(data.mapDimension(valueAxis.dim), 1 / rate));
+          } else if (sampling === "minmax") {
+            seriesModel.setData(data.minmaxDownSample(data.mapDimension(valueAxis.dim), 1 / rate));
+          }
+          var sampler = void 0;
+          if (isString(sampling)) {
+            sampler = samplers[sampling];
+          } else if (isFunction(sampling)) {
+            sampler = sampling;
+          }
+          if (sampler) {
+            seriesModel.setData(data.downSample(data.mapDimension(valueAxis.dim), 1 / rate, sampler, indexSampler));
+          }
+        }
+      }
+    }
+  };
+}
+export {
+  dataSample as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/processor/dataStack.mjs

@@ -0,0 +1,73 @@
+import { createHashMap, each } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { addSafe } from "../util/number.mjs";
+function dataStack(ecModel) {
+  var stackInfoMap = createHashMap();
+  ecModel.eachSeries(function(seriesModel) {
+    var stack = seriesModel.get("stack");
+    if (stack) {
+      var stackInfoList = stackInfoMap.get(stack) || stackInfoMap.set(stack, []);
+      var data = seriesModel.getData();
+      var stackInfo = {
+        // Used for calculate axis extent automatically.
+        // TODO: Type getCalculationInfo return more specific type?
+        stackResultDimension: data.getCalculationInfo("stackResultDimension"),
+        stackedOverDimension: data.getCalculationInfo("stackedOverDimension"),
+        stackedDimension: data.getCalculationInfo("stackedDimension"),
+        stackedByDimension: data.getCalculationInfo("stackedByDimension"),
+        isStackedByIndex: data.getCalculationInfo("isStackedByIndex"),
+        data,
+        seriesModel
+      };
+      if (!stackInfo.stackedDimension || !(stackInfo.isStackedByIndex || stackInfo.stackedByDimension)) {
+        return;
+      }
+      stackInfoList.length && data.setCalculationInfo("stackedOnSeries", stackInfoList[stackInfoList.length - 1].seriesModel);
+      stackInfoList.push(stackInfo);
+    }
+  });
+  stackInfoMap.each(calculateStack);
+}
+function calculateStack(stackInfoList) {
+  each(stackInfoList, function(targetStackInfo, idxInStack) {
+    var resultVal = [];
+    var resultNaN = [NaN, NaN];
+    var dims = [targetStackInfo.stackResultDimension, targetStackInfo.stackedOverDimension];
+    var targetData = targetStackInfo.data;
+    var isStackedByIndex = targetStackInfo.isStackedByIndex;
+    var stackStrategy = targetStackInfo.seriesModel.get("stackStrategy") || "samesign";
+    targetData.modify(dims, function(v0, v1, dataIndex) {
+      var sum = targetData.get(targetStackInfo.stackedDimension, dataIndex);
+      if (isNaN(sum)) {
+        return resultNaN;
+      }
+      var byValue;
+      var stackedDataRawIndex;
+      if (isStackedByIndex) {
+        stackedDataRawIndex = targetData.getRawIndex(dataIndex);
+      } else {
+        byValue = targetData.get(targetStackInfo.stackedByDimension, dataIndex);
+      }
+      var stackedOver = NaN;
+      for (var j = idxInStack - 1; j >= 0; j--) {
+        var stackInfo = stackInfoList[j];
+        if (!isStackedByIndex) {
+          stackedDataRawIndex = stackInfo.data.rawIndexOf(stackInfo.stackedByDimension, byValue);
+        }
+        if (stackedDataRawIndex >= 0) {
+          var val = stackInfo.data.getByRawIndex(stackInfo.stackResultDimension, stackedDataRawIndex);
+          if (stackStrategy === "all" || stackStrategy === "positive" && val > 0 || stackStrategy === "negative" && val < 0 || stackStrategy === "samesign" && sum >= 0 && val > 0 || stackStrategy === "samesign" && sum <= 0 && val < 0) {
+            sum = addSafe(sum, val);
+            stackedOver = val;
+            break;
+          }
+        }
+      }
+      resultVal[0] = sum;
+      resultVal[1] = stackedOver;
+      return resultVal;
+    });
+  });
+}
+export {
+  dataStack as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/processor/negativeDataFilter.mjs

@@ -0,0 +1,20 @@
+import { isNumber } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+function negativeDataFilter(seriesType) {
+  return {
+    seriesType,
+    reset: function(seriesModel, ecModel) {
+      var data = seriesModel.getData();
+      data.filterSelf(function(idx) {
+        var valueDim = data.mapDimension("value");
+        var curValue = data.get(valueDim, idx);
+        if (isNumber(curValue) && !isNaN(curValue) && curValue < 0) {
+          return false;
+        }
+        return true;
+      });
+    }
+  };
+}
+export {
+  negativeDataFilter as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/renderer/installCanvasRenderer.mjs

@@ -0,0 +1,7 @@
+import CanvasPainter from "../../../../../zrender@5.6.1/node_modules/zrender/lib/canvas/Painter.mjs";
+function install(registers) {
+  registers.registerPainter("canvas", CanvasPainter);
+}
+export {
+  install
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/scale/Interval.mjs

@@ -0,0 +1,191 @@
+import { __extends } from "../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import { round, getPrecision } from "../util/number.mjs";
+import { addCommas } from "../util/format.mjs";
+import Scale from "./Scale.mjs";
+import { contain, normalize, scale, getIntervalPrecision, intervalScaleNiceTicks } from "./helper.mjs";
+var roundNumber = round;
+var IntervalScale = (
+  /** @class */
+  function(_super) {
+    __extends(IntervalScale2, _super);
+    function IntervalScale2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = "interval";
+      _this._interval = 0;
+      _this._intervalPrecision = 2;
+      return _this;
+    }
+    IntervalScale2.prototype.parse = function(val) {
+      return val;
+    };
+    IntervalScale2.prototype.contain = function(val) {
+      return contain(val, this._extent);
+    };
+    IntervalScale2.prototype.normalize = function(val) {
+      return normalize(val, this._extent);
+    };
+    IntervalScale2.prototype.scale = function(val) {
+      return scale(val, this._extent);
+    };
+    IntervalScale2.prototype.setExtent = function(start, end) {
+      var thisExtent = this._extent;
+      if (!isNaN(start)) {
+        thisExtent[0] = parseFloat(start);
+      }
+      if (!isNaN(end)) {
+        thisExtent[1] = parseFloat(end);
+      }
+    };
+    IntervalScale2.prototype.unionExtent = function(other) {
+      var extent = this._extent;
+      other[0] < extent[0] && (extent[0] = other[0]);
+      other[1] > extent[1] && (extent[1] = other[1]);
+      this.setExtent(extent[0], extent[1]);
+    };
+    IntervalScale2.prototype.getInterval = function() {
+      return this._interval;
+    };
+    IntervalScale2.prototype.setInterval = function(interval) {
+      this._interval = interval;
+      this._niceExtent = this._extent.slice();
+      this._intervalPrecision = getIntervalPrecision(interval);
+    };
+    IntervalScale2.prototype.getTicks = function(expandToNicedExtent) {
+      var interval = this._interval;
+      var extent = this._extent;
+      var niceTickExtent = this._niceExtent;
+      var intervalPrecision = this._intervalPrecision;
+      var ticks = [];
+      if (!interval) {
+        return ticks;
+      }
+      var safeLimit = 1e4;
+      if (extent[0] < niceTickExtent[0]) {
+        if (expandToNicedExtent) {
+          ticks.push({
+            value: roundNumber(niceTickExtent[0] - interval, intervalPrecision)
+          });
+        } else {
+          ticks.push({
+            value: extent[0]
+          });
+        }
+      }
+      var tick = niceTickExtent[0];
+      while (tick <= niceTickExtent[1]) {
+        ticks.push({
+          value: tick
+        });
+        tick = roundNumber(tick + interval, intervalPrecision);
+        if (tick === ticks[ticks.length - 1].value) {
+          break;
+        }
+        if (ticks.length > safeLimit) {
+          return [];
+        }
+      }
+      var lastNiceTick = ticks.length ? ticks[ticks.length - 1].value : niceTickExtent[1];
+      if (extent[1] > lastNiceTick) {
+        if (expandToNicedExtent) {
+          ticks.push({
+            value: roundNumber(lastNiceTick + interval, intervalPrecision)
+          });
+        } else {
+          ticks.push({
+            value: extent[1]
+          });
+        }
+      }
+      return ticks;
+    };
+    IntervalScale2.prototype.getMinorTicks = function(splitNumber) {
+      var ticks = this.getTicks(true);
+      var minorTicks = [];
+      var extent = this.getExtent();
+      for (var i = 1; i < ticks.length; i++) {
+        var nextTick = ticks[i];
+        var prevTick = ticks[i - 1];
+        var count = 0;
+        var minorTicksGroup = [];
+        var interval = nextTick.value - prevTick.value;
+        var minorInterval = interval / splitNumber;
+        while (count < splitNumber - 1) {
+          var minorTick = roundNumber(prevTick.value + (count + 1) * minorInterval);
+          if (minorTick > extent[0] && minorTick < extent[1]) {
+            minorTicksGroup.push(minorTick);
+          }
+          count++;
+        }
+        minorTicks.push(minorTicksGroup);
+      }
+      return minorTicks;
+    };
+    IntervalScale2.prototype.getLabel = function(data, opt) {
+      if (data == null) {
+        return "";
+      }
+      var precision = opt && opt.precision;
+      if (precision == null) {
+        precision = getPrecision(data.value) || 0;
+      } else if (precision === "auto") {
+        precision = this._intervalPrecision;
+      }
+      var dataNum = roundNumber(data.value, precision, true);
+      return addCommas(dataNum);
+    };
+    IntervalScale2.prototype.calcNiceTicks = function(splitNumber, minInterval, maxInterval) {
+      splitNumber = splitNumber || 5;
+      var extent = this._extent;
+      var span = extent[1] - extent[0];
+      if (!isFinite(span)) {
+        return;
+      }
+      if (span < 0) {
+        span = -span;
+        extent.reverse();
+      }
+      var result = intervalScaleNiceTicks(extent, splitNumber, minInterval, maxInterval);
+      this._intervalPrecision = result.intervalPrecision;
+      this._interval = result.interval;
+      this._niceExtent = result.niceTickExtent;
+    };
+    IntervalScale2.prototype.calcNiceExtent = function(opt) {
+      var extent = this._extent;
+      if (extent[0] === extent[1]) {
+        if (extent[0] !== 0) {
+          var expandSize = Math.abs(extent[0]);
+          if (!opt.fixMax) {
+            extent[1] += expandSize / 2;
+            extent[0] -= expandSize / 2;
+          } else {
+            extent[0] -= expandSize / 2;
+          }
+        } else {
+          extent[1] = 1;
+        }
+      }
+      var span = extent[1] - extent[0];
+      if (!isFinite(span)) {
+        extent[0] = 0;
+        extent[1] = 1;
+      }
+      this.calcNiceTicks(opt.splitNumber, opt.minInterval, opt.maxInterval);
+      var interval = this._interval;
+      if (!opt.fixMin) {
+        extent[0] = roundNumber(Math.floor(extent[0] / interval) * interval);
+      }
+      if (!opt.fixMax) {
+        extent[1] = roundNumber(Math.ceil(extent[1] / interval) * interval);
+      }
+    };
+    IntervalScale2.prototype.setNiceExtent = function(min, max) {
+      this._niceExtent = [min, max];
+    };
+    IntervalScale2.type = "interval";
+    return IntervalScale2;
+  }(Scale)
+);
+Scale.registerClass(IntervalScale);
+export {
+  IntervalScale as default
+};