@fecp/mobile 1.0.79 → 1.1.1

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

@@ -0,0 +1,120 @@
+import { __extends } from "../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import { map } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import Scale from "./Scale.mjs";
+import { round, quantity, getPrecision } from "../util/number.mjs";
+import { contain, normalize, scale } from "./helper.mjs";
+import IntervalScale from "./Interval.mjs";
+var scaleProto = Scale.prototype;
+var intervalScaleProto = IntervalScale.prototype;
+var roundingErrorFix = round;
+var mathFloor = Math.floor;
+var mathCeil = Math.ceil;
+var mathPow = Math.pow;
+var mathLog = Math.log;
+var LogScale = (
+  /** @class */
+  function(_super) {
+    __extends(LogScale2, _super);
+    function LogScale2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = "log";
+      _this.base = 10;
+      _this._originalScale = new IntervalScale();
+      _this._interval = 0;
+      return _this;
+    }
+    LogScale2.prototype.getTicks = function(expandToNicedExtent) {
+      var originalScale = this._originalScale;
+      var extent = this._extent;
+      var originalExtent = originalScale.getExtent();
+      var ticks = intervalScaleProto.getTicks.call(this, expandToNicedExtent);
+      return map(ticks, function(tick) {
+        var val = tick.value;
+        var powVal = round(mathPow(this.base, val));
+        powVal = val === extent[0] && this._fixMin ? fixRoundingError(powVal, originalExtent[0]) : powVal;
+        powVal = val === extent[1] && this._fixMax ? fixRoundingError(powVal, originalExtent[1]) : powVal;
+        return {
+          value: powVal
+        };
+      }, this);
+    };
+    LogScale2.prototype.setExtent = function(start, end) {
+      var base = mathLog(this.base);
+      start = mathLog(Math.max(0, start)) / base;
+      end = mathLog(Math.max(0, end)) / base;
+      intervalScaleProto.setExtent.call(this, start, end);
+    };
+    LogScale2.prototype.getExtent = function() {
+      var base = this.base;
+      var extent = scaleProto.getExtent.call(this);
+      extent[0] = mathPow(base, extent[0]);
+      extent[1] = mathPow(base, extent[1]);
+      var originalScale = this._originalScale;
+      var originalExtent = originalScale.getExtent();
+      this._fixMin && (extent[0] = fixRoundingError(extent[0], originalExtent[0]));
+      this._fixMax && (extent[1] = fixRoundingError(extent[1], originalExtent[1]));
+      return extent;
+    };
+    LogScale2.prototype.unionExtent = function(extent) {
+      this._originalScale.unionExtent(extent);
+      var base = this.base;
+      extent[0] = mathLog(extent[0]) / mathLog(base);
+      extent[1] = mathLog(extent[1]) / mathLog(base);
+      scaleProto.unionExtent.call(this, extent);
+    };
+    LogScale2.prototype.unionExtentFromData = function(data, dim) {
+      this.unionExtent(data.getApproximateExtent(dim));
+    };
+    LogScale2.prototype.calcNiceTicks = function(approxTickNum) {
+      approxTickNum = approxTickNum || 10;
+      var extent = this._extent;
+      var span = extent[1] - extent[0];
+      if (span === Infinity || span <= 0) {
+        return;
+      }
+      var interval = quantity(span);
+      var err = approxTickNum / span * interval;
+      if (err <= 0.5) {
+        interval *= 10;
+      }
+      while (!isNaN(interval) && Math.abs(interval) < 1 && Math.abs(interval) > 0) {
+        interval *= 10;
+      }
+      var niceExtent = [round(mathCeil(extent[0] / interval) * interval), round(mathFloor(extent[1] / interval) * interval)];
+      this._interval = interval;
+      this._niceExtent = niceExtent;
+    };
+    LogScale2.prototype.calcNiceExtent = function(opt) {
+      intervalScaleProto.calcNiceExtent.call(this, opt);
+      this._fixMin = opt.fixMin;
+      this._fixMax = opt.fixMax;
+    };
+    LogScale2.prototype.parse = function(val) {
+      return val;
+    };
+    LogScale2.prototype.contain = function(val) {
+      val = mathLog(val) / mathLog(this.base);
+      return contain(val, this._extent);
+    };
+    LogScale2.prototype.normalize = function(val) {
+      val = mathLog(val) / mathLog(this.base);
+      return normalize(val, this._extent);
+    };
+    LogScale2.prototype.scale = function(val) {
+      val = scale(val, this._extent);
+      return mathPow(this.base, val);
+    };
+    LogScale2.type = "log";
+    return LogScale2;
+  }(Scale)
+);
+var proto = LogScale.prototype;
+proto.getMinorTicks = intervalScaleProto.getMinorTicks;
+proto.getLabel = intervalScaleProto.getLabel;
+function fixRoundingError(val, originalVal) {
+  return roundingErrorFix(val, getPrecision(originalVal));
+}
+Scale.registerClass(LogScale);
+export {
+  LogScale as default
+};

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

@@ -0,0 +1,124 @@
+import { __extends } from "../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import Scale from "./Scale.mjs";
+import OrdinalMeta from "../data/OrdinalMeta.mjs";
+import { contain, normalize, scale } from "./helper.mjs";
+import { isArray, map, isObject, isString } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+var OrdinalScale = (
+  /** @class */
+  function(_super) {
+    __extends(OrdinalScale2, _super);
+    function OrdinalScale2(setting) {
+      var _this = _super.call(this, setting) || this;
+      _this.type = "ordinal";
+      var ordinalMeta = _this.getSetting("ordinalMeta");
+      if (!ordinalMeta) {
+        ordinalMeta = new OrdinalMeta({});
+      }
+      if (isArray(ordinalMeta)) {
+        ordinalMeta = new OrdinalMeta({
+          categories: map(ordinalMeta, function(item) {
+            return isObject(item) ? item.value : item;
+          })
+        });
+      }
+      _this._ordinalMeta = ordinalMeta;
+      _this._extent = _this.getSetting("extent") || [0, ordinalMeta.categories.length - 1];
+      return _this;
+    }
+    OrdinalScale2.prototype.parse = function(val) {
+      if (val == null) {
+        return NaN;
+      }
+      return isString(val) ? this._ordinalMeta.getOrdinal(val) : Math.round(val);
+    };
+    OrdinalScale2.prototype.contain = function(rank) {
+      rank = this.parse(rank);
+      return contain(rank, this._extent) && this._ordinalMeta.categories[rank] != null;
+    };
+    OrdinalScale2.prototype.normalize = function(val) {
+      val = this._getTickNumber(this.parse(val));
+      return normalize(val, this._extent);
+    };
+    OrdinalScale2.prototype.scale = function(val) {
+      val = Math.round(scale(val, this._extent));
+      return this.getRawOrdinalNumber(val);
+    };
+    OrdinalScale2.prototype.getTicks = function() {
+      var ticks = [];
+      var extent = this._extent;
+      var rank = extent[0];
+      while (rank <= extent[1]) {
+        ticks.push({
+          value: rank
+        });
+        rank++;
+      }
+      return ticks;
+    };
+    OrdinalScale2.prototype.getMinorTicks = function(splitNumber) {
+      return;
+    };
+    OrdinalScale2.prototype.setSortInfo = function(info) {
+      if (info == null) {
+        this._ordinalNumbersByTick = this._ticksByOrdinalNumber = null;
+        return;
+      }
+      var infoOrdinalNumbers = info.ordinalNumbers;
+      var ordinalsByTick = this._ordinalNumbersByTick = [];
+      var ticksByOrdinal = this._ticksByOrdinalNumber = [];
+      var tickNum = 0;
+      var allCategoryLen = this._ordinalMeta.categories.length;
+      for (var len = Math.min(allCategoryLen, infoOrdinalNumbers.length); tickNum < len; ++tickNum) {
+        var ordinalNumber = infoOrdinalNumbers[tickNum];
+        ordinalsByTick[tickNum] = ordinalNumber;
+        ticksByOrdinal[ordinalNumber] = tickNum;
+      }
+      var unusedOrdinal = 0;
+      for (; tickNum < allCategoryLen; ++tickNum) {
+        while (ticksByOrdinal[unusedOrdinal] != null) {
+          unusedOrdinal++;
+        }
+        ordinalsByTick.push(unusedOrdinal);
+        ticksByOrdinal[unusedOrdinal] = tickNum;
+      }
+    };
+    OrdinalScale2.prototype._getTickNumber = function(ordinal) {
+      var ticksByOrdinalNumber = this._ticksByOrdinalNumber;
+      return ticksByOrdinalNumber && ordinal >= 0 && ordinal < ticksByOrdinalNumber.length ? ticksByOrdinalNumber[ordinal] : ordinal;
+    };
+    OrdinalScale2.prototype.getRawOrdinalNumber = function(tickNumber) {
+      var ordinalNumbersByTick = this._ordinalNumbersByTick;
+      return ordinalNumbersByTick && tickNumber >= 0 && tickNumber < ordinalNumbersByTick.length ? ordinalNumbersByTick[tickNumber] : tickNumber;
+    };
+    OrdinalScale2.prototype.getLabel = function(tick) {
+      if (!this.isBlank()) {
+        var ordinalNumber = this.getRawOrdinalNumber(tick.value);
+        var cateogry = this._ordinalMeta.categories[ordinalNumber];
+        return cateogry == null ? "" : cateogry + "";
+      }
+    };
+    OrdinalScale2.prototype.count = function() {
+      return this._extent[1] - this._extent[0] + 1;
+    };
+    OrdinalScale2.prototype.unionExtentFromData = function(data, dim) {
+      this.unionExtent(data.getApproximateExtent(dim));
+    };
+    OrdinalScale2.prototype.isInExtentRange = function(value) {
+      value = this._getTickNumber(value);
+      return this._extent[0] <= value && this._extent[1] >= value;
+    };
+    OrdinalScale2.prototype.getOrdinalMeta = function() {
+      return this._ordinalMeta;
+    };
+    OrdinalScale2.prototype.calcNiceTicks = function() {
+    };
+    OrdinalScale2.prototype.calcNiceExtent = function() {
+    };
+    OrdinalScale2.type = "ordinal";
+    return OrdinalScale2;
+  }(Scale)
+);
+Scale.registerClass(OrdinalScale);
+export {
+  OrdinalScale as default
+};

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

@@ -0,0 +1,47 @@
+import { enableClassManagement } from "../util/clazz.mjs";
+var Scale = (
+  /** @class */
+  function() {
+    function Scale2(setting) {
+      this._setting = setting || {};
+      this._extent = [Infinity, -Infinity];
+    }
+    Scale2.prototype.getSetting = function(name) {
+      return this._setting[name];
+    };
+    Scale2.prototype.unionExtent = function(other) {
+      var extent = this._extent;
+      other[0] < extent[0] && (extent[0] = other[0]);
+      other[1] > extent[1] && (extent[1] = other[1]);
+    };
+    Scale2.prototype.unionExtentFromData = function(data, dim) {
+      this.unionExtent(data.getApproximateExtent(dim));
+    };
+    Scale2.prototype.getExtent = function() {
+      return this._extent.slice();
+    };
+    Scale2.prototype.setExtent = function(start, end) {
+      var thisExtent = this._extent;
+      if (!isNaN(start)) {
+        thisExtent[0] = start;
+      }
+      if (!isNaN(end)) {
+        thisExtent[1] = end;
+      }
+    };
+    Scale2.prototype.isInExtentRange = function(value) {
+      return this._extent[0] <= value && this._extent[1] >= value;
+    };
+    Scale2.prototype.isBlank = function() {
+      return this._isBlank;
+    };
+    Scale2.prototype.setBlank = function(isBlank) {
+      this._isBlank = isBlank;
+    };
+    return Scale2;
+  }()
+);
+enableClassManagement(Scale);
+export {
+  Scale as default
+};

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

@@ -0,0 +1,373 @@
+import { __extends } from "../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import { parseDate, nice } from "../util/number.mjs";
+import { format, fullLeveledFormatter, getDefaultFormatPrecisionOfInterval, getPrimaryTimeUnit, leveledFormat, ONE_DAY, ONE_SECOND, ONE_MINUTE, ONE_HOUR, ONE_YEAR, timeUnits, isPrimaryTimeUnit, secondsSetterName, millisecondsSetterName, minutesSetterName, hoursSetterName, dateSetterName, monthSetterName, getUnitValue, millisecondsGetterName, secondsGetterName, minutesGetterName, hoursGetterName, dateGetterName, monthGetterName, fullYearGetterName, fullYearSetterName } from "../util/time.mjs";
+import { contain, normalize, scale } from "./helper.mjs";
+import IntervalScale from "./Interval.mjs";
+import Scale from "./Scale.mjs";
+import { isNumber, filter, map } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+var bisect = function(a, x, lo, hi) {
+  while (lo < hi) {
+    var mid = lo + hi >>> 1;
+    if (a[mid][1] < x) {
+      lo = mid + 1;
+    } else {
+      hi = mid;
+    }
+  }
+  return lo;
+};
+var TimeScale = (
+  /** @class */
+  function(_super) {
+    __extends(TimeScale2, _super);
+    function TimeScale2(settings) {
+      var _this = _super.call(this, settings) || this;
+      _this.type = "time";
+      return _this;
+    }
+    TimeScale2.prototype.getLabel = function(tick) {
+      var useUTC = this.getSetting("useUTC");
+      return format(tick.value, fullLeveledFormatter[getDefaultFormatPrecisionOfInterval(getPrimaryTimeUnit(this._minLevelUnit))] || fullLeveledFormatter.second, useUTC, this.getSetting("locale"));
+    };
+    TimeScale2.prototype.getFormattedLabel = function(tick, idx, labelFormatter) {
+      var isUTC = this.getSetting("useUTC");
+      var lang = this.getSetting("locale");
+      return leveledFormat(tick, idx, labelFormatter, lang, isUTC);
+    };
+    TimeScale2.prototype.getTicks = function() {
+      var interval = this._interval;
+      var extent = this._extent;
+      var ticks = [];
+      if (!interval) {
+        return ticks;
+      }
+      ticks.push({
+        value: extent[0],
+        level: 0
+      });
+      var useUTC = this.getSetting("useUTC");
+      var innerTicks = getIntervalTicks(this._minLevelUnit, this._approxInterval, useUTC, extent);
+      ticks = ticks.concat(innerTicks);
+      ticks.push({
+        value: extent[1],
+        level: 0
+      });
+      return ticks;
+    };
+    TimeScale2.prototype.calcNiceExtent = function(opt) {
+      var extent = this._extent;
+      if (extent[0] === extent[1]) {
+        extent[0] -= ONE_DAY;
+        extent[1] += ONE_DAY;
+      }
+      if (extent[1] === -Infinity && extent[0] === Infinity) {
+        var d = /* @__PURE__ */ new Date();
+        extent[1] = +new Date(d.getFullYear(), d.getMonth(), d.getDate());
+        extent[0] = extent[1] - ONE_DAY;
+      }
+      this.calcNiceTicks(opt.splitNumber, opt.minInterval, opt.maxInterval);
+    };
+    TimeScale2.prototype.calcNiceTicks = function(approxTickNum, minInterval, maxInterval) {
+      approxTickNum = approxTickNum || 10;
+      var extent = this._extent;
+      var span = extent[1] - extent[0];
+      this._approxInterval = span / approxTickNum;
+      if (minInterval != null && this._approxInterval < minInterval) {
+        this._approxInterval = minInterval;
+      }
+      if (maxInterval != null && this._approxInterval > maxInterval) {
+        this._approxInterval = maxInterval;
+      }
+      var scaleIntervalsLen = scaleIntervals.length;
+      var idx = Math.min(bisect(scaleIntervals, this._approxInterval, 0, scaleIntervalsLen), scaleIntervalsLen - 1);
+      this._interval = scaleIntervals[idx][1];
+      this._minLevelUnit = scaleIntervals[Math.max(idx - 1, 0)][0];
+    };
+    TimeScale2.prototype.parse = function(val) {
+      return isNumber(val) ? val : +parseDate(val);
+    };
+    TimeScale2.prototype.contain = function(val) {
+      return contain(this.parse(val), this._extent);
+    };
+    TimeScale2.prototype.normalize = function(val) {
+      return normalize(this.parse(val), this._extent);
+    };
+    TimeScale2.prototype.scale = function(val) {
+      return scale(val, this._extent);
+    };
+    TimeScale2.type = "time";
+    return TimeScale2;
+  }(IntervalScale)
+);
+var scaleIntervals = [
+  // Format                           interval
+  ["second", ONE_SECOND],
+  ["minute", ONE_MINUTE],
+  ["hour", ONE_HOUR],
+  ["quarter-day", ONE_HOUR * 6],
+  ["half-day", ONE_HOUR * 12],
+  ["day", ONE_DAY * 1.2],
+  ["half-week", ONE_DAY * 3.5],
+  ["week", ONE_DAY * 7],
+  ["month", ONE_DAY * 31],
+  ["quarter", ONE_DAY * 95],
+  ["half-year", ONE_YEAR / 2],
+  ["year", ONE_YEAR]
+  // 1Y
+];
+function isUnitValueSame(unit, valueA, valueB, isUTC) {
+  var dateA = parseDate(valueA);
+  var dateB = parseDate(valueB);
+  var isSame = function(unit2) {
+    return getUnitValue(dateA, unit2, isUTC) === getUnitValue(dateB, unit2, isUTC);
+  };
+  var isSameYear = function() {
+    return isSame("year");
+  };
+  var isSameMonth = function() {
+    return isSameYear() && isSame("month");
+  };
+  var isSameDay = function() {
+    return isSameMonth() && isSame("day");
+  };
+  var isSameHour = function() {
+    return isSameDay() && isSame("hour");
+  };
+  var isSameMinute = function() {
+    return isSameHour() && isSame("minute");
+  };
+  var isSameSecond = function() {
+    return isSameMinute() && isSame("second");
+  };
+  var isSameMilliSecond = function() {
+    return isSameSecond() && isSame("millisecond");
+  };
+  switch (unit) {
+    case "year":
+      return isSameYear();
+    case "month":
+      return isSameMonth();
+    case "day":
+      return isSameDay();
+    case "hour":
+      return isSameHour();
+    case "minute":
+      return isSameMinute();
+    case "second":
+      return isSameSecond();
+    case "millisecond":
+      return isSameMilliSecond();
+  }
+}
+function getDateInterval(approxInterval, daysInMonth) {
+  approxInterval /= ONE_DAY;
+  return approxInterval > 16 ? 16 : approxInterval > 7.5 ? 7 : approxInterval > 3.5 ? 4 : approxInterval > 1.5 ? 2 : 1;
+}
+function getMonthInterval(approxInterval) {
+  var APPROX_ONE_MONTH = 30 * ONE_DAY;
+  approxInterval /= APPROX_ONE_MONTH;
+  return approxInterval > 6 ? 6 : approxInterval > 3 ? 3 : approxInterval > 2 ? 2 : 1;
+}
+function getHourInterval(approxInterval) {
+  approxInterval /= ONE_HOUR;
+  return approxInterval > 12 ? 12 : approxInterval > 6 ? 6 : approxInterval > 3.5 ? 4 : approxInterval > 2 ? 2 : 1;
+}
+function getMinutesAndSecondsInterval(approxInterval, isMinutes) {
+  approxInterval /= isMinutes ? ONE_MINUTE : ONE_SECOND;
+  return approxInterval > 30 ? 30 : approxInterval > 20 ? 20 : approxInterval > 15 ? 15 : approxInterval > 10 ? 10 : approxInterval > 5 ? 5 : approxInterval > 2 ? 2 : 1;
+}
+function getMillisecondsInterval(approxInterval) {
+  return nice(approxInterval, true);
+}
+function getFirstTimestampOfUnit(date, unitName, isUTC) {
+  var outDate = new Date(date);
+  switch (getPrimaryTimeUnit(unitName)) {
+    case "year":
+    case "month":
+      outDate[monthSetterName(isUTC)](0);
+    case "day":
+      outDate[dateSetterName(isUTC)](1);
+    case "hour":
+      outDate[hoursSetterName(isUTC)](0);
+    case "minute":
+      outDate[minutesSetterName(isUTC)](0);
+    case "second":
+      outDate[secondsSetterName(isUTC)](0);
+      outDate[millisecondsSetterName(isUTC)](0);
+  }
+  return outDate.getTime();
+}
+function getIntervalTicks(bottomUnitName, approxInterval, isUTC, extent) {
+  var safeLimit = 1e4;
+  var unitNames = timeUnits;
+  var iter = 0;
+  function addTicksInSpan(interval, minTimestamp, maxTimestamp, getMethodName, setMethodName, isDate, out) {
+    var date = new Date(minTimestamp);
+    var dateTime = minTimestamp;
+    var d = date[getMethodName]();
+    while (dateTime < maxTimestamp && dateTime <= extent[1]) {
+      out.push({
+        value: dateTime
+      });
+      d += interval;
+      date[setMethodName](d);
+      dateTime = date.getTime();
+    }
+    out.push({
+      value: dateTime,
+      notAdd: true
+    });
+  }
+  function addLevelTicks(unitName, lastLevelTicks, levelTicks2) {
+    var newAddedTicks = [];
+    var isFirstLevel = !lastLevelTicks.length;
+    if (isUnitValueSame(getPrimaryTimeUnit(unitName), extent[0], extent[1], isUTC)) {
+      return;
+    }
+    if (isFirstLevel) {
+      lastLevelTicks = [{
+        // TODO Optimize. Not include so may ticks.
+        value: getFirstTimestampOfUnit(new Date(extent[0]), unitName, isUTC)
+      }, {
+        value: extent[1]
+      }];
+    }
+    for (var i2 = 0; i2 < lastLevelTicks.length - 1; i2++) {
+      var startTick = lastLevelTicks[i2].value;
+      var endTick = lastLevelTicks[i2 + 1].value;
+      if (startTick === endTick) {
+        continue;
+      }
+      var interval = void 0;
+      var getterName = void 0;
+      var setterName = void 0;
+      var isDate = false;
+      switch (unitName) {
+        case "year":
+          interval = Math.max(1, Math.round(approxInterval / ONE_DAY / 365));
+          getterName = fullYearGetterName(isUTC);
+          setterName = fullYearSetterName(isUTC);
+          break;
+        case "half-year":
+        case "quarter":
+        case "month":
+          interval = getMonthInterval(approxInterval);
+          getterName = monthGetterName(isUTC);
+          setterName = monthSetterName(isUTC);
+          break;
+        case "week":
+        // PENDING If week is added. Ignore day.
+        case "half-week":
+        case "day":
+          interval = getDateInterval(approxInterval);
+          getterName = dateGetterName(isUTC);
+          setterName = dateSetterName(isUTC);
+          isDate = true;
+          break;
+        case "half-day":
+        case "quarter-day":
+        case "hour":
+          interval = getHourInterval(approxInterval);
+          getterName = hoursGetterName(isUTC);
+          setterName = hoursSetterName(isUTC);
+          break;
+        case "minute":
+          interval = getMinutesAndSecondsInterval(approxInterval, true);
+          getterName = minutesGetterName(isUTC);
+          setterName = minutesSetterName(isUTC);
+          break;
+        case "second":
+          interval = getMinutesAndSecondsInterval(approxInterval, false);
+          getterName = secondsGetterName(isUTC);
+          setterName = secondsSetterName(isUTC);
+          break;
+        case "millisecond":
+          interval = getMillisecondsInterval(approxInterval);
+          getterName = millisecondsGetterName(isUTC);
+          setterName = millisecondsSetterName(isUTC);
+          break;
+      }
+      addTicksInSpan(interval, startTick, endTick, getterName, setterName, isDate, newAddedTicks);
+      if (unitName === "year" && levelTicks2.length > 1 && i2 === 0) {
+        levelTicks2.unshift({
+          value: levelTicks2[0].value - interval
+        });
+      }
+    }
+    for (var i2 = 0; i2 < newAddedTicks.length; i2++) {
+      levelTicks2.push(newAddedTicks[i2]);
+    }
+    return newAddedTicks;
+  }
+  var levelsTicks = [];
+  var currentLevelTicks = [];
+  var tickCount = 0;
+  var lastLevelTickCount = 0;
+  for (var i = 0; i < unitNames.length && iter++ < safeLimit; ++i) {
+    var primaryTimeUnit = getPrimaryTimeUnit(unitNames[i]);
+    if (!isPrimaryTimeUnit(unitNames[i])) {
+      continue;
+    }
+    addLevelTicks(unitNames[i], levelsTicks[levelsTicks.length - 1] || [], currentLevelTicks);
+    var nextPrimaryTimeUnit = unitNames[i + 1] ? getPrimaryTimeUnit(unitNames[i + 1]) : null;
+    if (primaryTimeUnit !== nextPrimaryTimeUnit) {
+      if (currentLevelTicks.length) {
+        lastLevelTickCount = tickCount;
+        currentLevelTicks.sort(function(a, b) {
+          return a.value - b.value;
+        });
+        var levelTicksRemoveDuplicated = [];
+        for (var i_1 = 0; i_1 < currentLevelTicks.length; ++i_1) {
+          var tickValue = currentLevelTicks[i_1].value;
+          if (i_1 === 0 || currentLevelTicks[i_1 - 1].value !== tickValue) {
+            levelTicksRemoveDuplicated.push(currentLevelTicks[i_1]);
+            if (tickValue >= extent[0] && tickValue <= extent[1]) {
+              tickCount++;
+            }
+          }
+        }
+        var targetTickNum = (extent[1] - extent[0]) / approxInterval;
+        if (tickCount > targetTickNum * 1.5 && lastLevelTickCount > targetTickNum / 1.5) {
+          break;
+        }
+        levelsTicks.push(levelTicksRemoveDuplicated);
+        if (tickCount > targetTickNum || bottomUnitName === unitNames[i]) {
+          break;
+        }
+      }
+      currentLevelTicks = [];
+    }
+  }
+  var levelsTicksInExtent = filter(map(levelsTicks, function(levelTicks2) {
+    return filter(levelTicks2, function(tick) {
+      return tick.value >= extent[0] && tick.value <= extent[1] && !tick.notAdd;
+    });
+  }), function(levelTicks2) {
+    return levelTicks2.length > 0;
+  });
+  var ticks = [];
+  var maxLevel = levelsTicksInExtent.length - 1;
+  for (var i = 0; i < levelsTicksInExtent.length; ++i) {
+    var levelTicks = levelsTicksInExtent[i];
+    for (var k = 0; k < levelTicks.length; ++k) {
+      ticks.push({
+        value: levelTicks[k].value,
+        level: maxLevel - i
+      });
+    }
+  }
+  ticks.sort(function(a, b) {
+    return a.value - b.value;
+  });
+  var result = [];
+  for (var i = 0; i < ticks.length; ++i) {
+    if (i === 0 || ticks[i].value !== ticks[i - 1].value) {
+      result.push(ticks[i]);
+    }
+  }
+  return result;
+}
+Scale.registerClass(TimeScale);
+export {
+  TimeScale as default
+};