web-core-tcm 0.0.59 → 0.0.61

package/dist/node_modules/echarts/lib/processor/dataStack.js

@@ -0,0 +1,50 @@
+import { createHashMap as y, each as B } from "../../../zrender/lib/core/util.js";
+import { addSafe as f } from "../util/number.js";
+function C(o) {
+  var e = y();
+  o.eachSeries(function(c) {
+    var s = c.get("stack");
+    if (s) {
+      var n = e.get(s) || e.set(s, []), a = c.getData(), i = {
+        // Used for calculate axis extent automatically.
+        // TODO: Type getCalculationInfo return more specific type?
+        stackResultDimension: a.getCalculationInfo("stackResultDimension"),
+        stackedOverDimension: a.getCalculationInfo("stackedOverDimension"),
+        stackedDimension: a.getCalculationInfo("stackedDimension"),
+        stackedByDimension: a.getCalculationInfo("stackedByDimension"),
+        isStackedByIndex: a.getCalculationInfo("isStackedByIndex"),
+        data: a,
+        seriesModel: c
+      };
+      if (!i.stackedDimension || !(i.isStackedByIndex || i.stackedByDimension))
+        return;
+      n.length && a.setCalculationInfo("stackedOnSeries", n[n.length - 1].seriesModel), n.push(i);
+    }
+  }), e.each(N);
+}
+function N(o) {
+  B(o, function(e, c) {
+    var s = [], n = [NaN, NaN], a = [e.stackResultDimension, e.stackedOverDimension], i = e.data, D = e.isStackedByIndex, d = e.seriesModel.get("stackStrategy") || "samesign";
+    i.modify(a, function(x, h, l) {
+      var t = i.get(e.stackedDimension, l);
+      if (isNaN(t))
+        return n;
+      var g, m;
+      D ? m = i.getRawIndex(l) : g = i.get(e.stackedByDimension, l);
+      for (var k = NaN, v = c - 1; v >= 0; v--) {
+        var u = o[v];
+        if (D || (m = u.data.rawIndexOf(u.stackedByDimension, g)), m >= 0) {
+          var r = u.data.getByRawIndex(u.stackResultDimension, m);
+          if (d === "all" || d === "positive" && r > 0 || d === "negative" && r < 0 || d === "samesign" && t >= 0 && r > 0 || d === "samesign" && t <= 0 && r < 0) {
+            t = f(t, r), k = r;
+            break;
+          }
+        }
+      }
+      return s[0] = t, s[1] = k, s;
+    });
+  });
+}
+export {
+  C as default
+};

package/dist/node_modules/echarts/lib/processor/negativeDataFilter.js

@@ -0,0 +1,16 @@
+import { isNumber as n } from "../../../zrender/lib/core/util.js";
+function o(t) {
+  return {
+    seriesType: t,
+    reset: function(a, f) {
+      var e = a.getData();
+      e.filterSelf(function(i) {
+        var u = e.mapDimension("value"), r = e.get(u, i);
+        return !(n(r) && !isNaN(r) && r < 0);
+      });
+    }
+  };
+}
+export {
+  o as default
+};

package/dist/node_modules/echarts/lib/renderer/installCanvasRenderer.js

@@ -0,0 +1,7 @@
+import n from "../../../zrender/lib/canvas/Painter.js";
+function t(a) {
+  a.registerPainter("canvas", n);
+}
+export {
+  t as install
+};

package/dist/node_modules/echarts/lib/renderer/installSVGRenderer.js

@@ -0,0 +1,7 @@
+import t from "../../../zrender/lib/svg/Painter.js";
+function e(r) {
+  r.registerPainter("svg", t);
+}
+export {
+  e as install
+};

package/dist/node_modules/echarts/lib/scale/Interval.js

@@ -0,0 +1,97 @@
+import { __extends as _ } from "../../../tslib/tslib.es6.js";
+import { round as y, getPrecision as m } from "../util/number.js";
+import { addCommas as g } from "../util/format.js";
+import h from "./Scale.js";
+import { contain as E, normalize as k, scale as N, getIntervalPrecision as P, intervalScaleNiceTicks as I } from "./helper.js";
+var v = y, M = (
+  /** @class */
+  (function(u) {
+    _(a, u);
+    function a() {
+      var t = u !== null && u.apply(this, arguments) || this;
+      return t.type = "interval", t._interval = 0, t._intervalPrecision = 2, t;
+    }
+    return a.prototype.parse = function(t) {
+      return t;
+    }, a.prototype.contain = function(t) {
+      return E(t, this._extent);
+    }, a.prototype.normalize = function(t) {
+      return k(t, this._extent);
+    }, a.prototype.scale = function(t) {
+      return N(t, this._extent);
+    }, a.prototype.setExtent = function(t, e) {
+      var i = this._extent;
+      isNaN(t) || (i[0] = parseFloat(t)), isNaN(e) || (i[1] = parseFloat(e));
+    }, a.prototype.unionExtent = function(t) {
+      var e = this._extent;
+      t[0] < e[0] && (e[0] = t[0]), t[1] > e[1] && (e[1] = t[1]), this.setExtent(e[0], e[1]);
+    }, a.prototype.getInterval = function() {
+      return this._interval;
+    }, a.prototype.setInterval = function(t) {
+      this._interval = t, this._niceExtent = this._extent.slice(), this._intervalPrecision = P(t);
+    }, a.prototype.getTicks = function(t) {
+      var e = this._interval, i = this._extent, s = this._niceExtent, r = this._intervalPrecision, n = [];
+      if (!e)
+        return n;
+      var c = 1e4;
+      i[0] < s[0] && (t ? n.push({
+        value: v(s[0] - e, r)
+      }) : n.push({
+        value: i[0]
+      }));
+      for (var l = s[0]; l <= s[1] && (n.push({
+        value: l
+      }), l = v(l + e, r), l !== n[n.length - 1].value); )
+        if (n.length > c)
+          return [];
+      var o = n.length ? n[n.length - 1].value : s[1];
+      return i[1] > o && (t ? n.push({
+        value: v(o + e, r)
+      }) : n.push({
+        value: i[1]
+      })), n;
+    }, a.prototype.getMinorTicks = function(t) {
+      for (var e = this.getTicks(!0), i = [], s = this.getExtent(), r = 1; r < e.length; r++) {
+        for (var n = e[r], c = e[r - 1], l = 0, o = [], p = n.value - c.value, x = p / t; l < t - 1; ) {
+          var f = v(c.value + (l + 1) * x);
+          f > s[0] && f < s[1] && o.push(f), l++;
+        }
+        i.push(o);
+      }
+      return i;
+    }, a.prototype.getLabel = function(t, e) {
+      if (t == null)
+        return "";
+      var i = e && e.precision;
+      i == null ? i = m(t.value) || 0 : i === "auto" && (i = this._intervalPrecision);
+      var s = v(t.value, i, !0);
+      return g(s);
+    }, a.prototype.calcNiceTicks = function(t, e, i) {
+      t = t || 5;
+      var s = this._extent, r = s[1] - s[0];
+      if (isFinite(r)) {
+        r < 0 && (r = -r, s.reverse());
+        var n = I(s, t, e, i);
+        this._intervalPrecision = n.intervalPrecision, this._interval = n.interval, this._niceExtent = n.niceTickExtent;
+      }
+    }, a.prototype.calcNiceExtent = function(t) {
+      var e = this._extent;
+      if (e[0] === e[1])
+        if (e[0] !== 0) {
+          var i = Math.abs(e[0]);
+          t.fixMax || (e[1] += i / 2), e[0] -= i / 2;
+        } else
+          e[1] = 1;
+      var s = e[1] - e[0];
+      isFinite(s) || (e[0] = 0, e[1] = 1), this.calcNiceTicks(t.splitNumber, t.minInterval, t.maxInterval);
+      var r = this._interval;
+      t.fixMin || (e[0] = v(Math.floor(e[0] / r) * r)), t.fixMax || (e[1] = v(Math.ceil(e[1] / r) * r));
+    }, a.prototype.setNiceExtent = function(t, e) {
+      this._niceExtent = [t, e];
+    }, a.type = "interval", a;
+  })(h)
+);
+h.registerClass(M);
+export {
+  M as default
+};

package/dist/node_modules/echarts/lib/scale/Log.js

@@ -0,0 +1,68 @@
+import { __extends as _ } from "../../../tslib/tslib.es6.js";
+import { map as M } from "../../../zrender/lib/core/util.js";
+import g from "./Scale.js";
+import { round as p, quantity as b, getPrecision as S } from "../util/number.js";
+import { contain as w, normalize as L, scale as k } from "./helper.js";
+import m from "./Interval.js";
+var v = g.prototype, l = m.prototype, P = p, d = Math.floor, F = Math.ceil, c = Math.pow, a = Math.log, E = (
+  /** @class */
+  (function(s) {
+    _(n, s);
+    function n() {
+      var t = s !== null && s.apply(this, arguments) || this;
+      return t.type = "log", t.base = 10, t._originalScale = new m(), t._interval = 0, t;
+    }
+    return n.prototype.getTicks = function(t) {
+      var i = this._originalScale, r = this._extent, e = i.getExtent(), x = l.getTicks.call(this, t);
+      return M(x, function(u) {
+        var f = u.value, o = p(c(this.base, f));
+        return o = f === r[0] && this._fixMin ? h(o, e[0]) : o, o = f === r[1] && this._fixMax ? h(o, e[1]) : o, {
+          value: o
+        };
+      }, this);
+    }, n.prototype.setExtent = function(t, i) {
+      var r = a(this.base);
+      t = a(Math.max(0, t)) / r, i = a(Math.max(0, i)) / r, l.setExtent.call(this, t, i);
+    }, n.prototype.getExtent = function() {
+      var t = this.base, i = v.getExtent.call(this);
+      i[0] = c(t, i[0]), i[1] = c(t, i[1]);
+      var r = this._originalScale, e = r.getExtent();
+      return this._fixMin && (i[0] = h(i[0], e[0])), this._fixMax && (i[1] = h(i[1], e[1])), i;
+    }, n.prototype.unionExtent = function(t) {
+      this._originalScale.unionExtent(t);
+      var i = this.base;
+      t[0] = a(t[0]) / a(i), t[1] = a(t[1]) / a(i), v.unionExtent.call(this, t);
+    }, n.prototype.unionExtentFromData = function(t, i) {
+      this.unionExtent(t.getApproximateExtent(i));
+    }, n.prototype.calcNiceTicks = function(t) {
+      t = t || 10;
+      var i = this._extent, r = i[1] - i[0];
+      if (!(r === 1 / 0 || r <= 0)) {
+        var e = b(r), x = t / r * e;
+        for (x <= 0.5 && (e *= 10); !isNaN(e) && Math.abs(e) < 1 && Math.abs(e) > 0; )
+          e *= 10;
+        var u = [p(F(i[0] / e) * e), p(d(i[1] / e) * e)];
+        this._interval = e, this._niceExtent = u;
+      }
+    }, n.prototype.calcNiceExtent = function(t) {
+      l.calcNiceExtent.call(this, t), this._fixMin = t.fixMin, this._fixMax = t.fixMax;
+    }, n.prototype.parse = function(t) {
+      return t;
+    }, n.prototype.contain = function(t) {
+      return t = a(t) / a(this.base), w(t, this._extent);
+    }, n.prototype.normalize = function(t) {
+      return t = a(t) / a(this.base), L(t, this._extent);
+    }, n.prototype.scale = function(t) {
+      return t = k(t, this._extent), c(this.base, t);
+    }, n.type = "log", n;
+  })(g)
+), y = E.prototype;
+y.getMinorTicks = l.getMinorTicks;
+y.getLabel = l.getLabel;
+function h(s, n) {
+  return P(s, S(n));
+}
+g.registerClass(E);
+export {
+  E as default
+};

package/dist/node_modules/echarts/lib/scale/Ordinal.js

@@ -0,0 +1,76 @@
+import { __extends as f } from "../../../tslib/tslib.es6.js";
+import p from "./Scale.js";
+import c from "../data/OrdinalMeta.js";
+import { contain as d, normalize as g, scale as y } from "./helper.js";
+import { isArray as m, map as _, isObject as x, isString as N } from "../../../zrender/lib/core/util.js";
+var O = (
+  /** @class */
+  (function(s) {
+    f(r, s);
+    function r(t) {
+      var e = s.call(this, t) || this;
+      e.type = "ordinal";
+      var n = e.getSetting("ordinalMeta");
+      return n || (n = new c({})), m(n) && (n = new c({
+        categories: _(n, function(o) {
+          return x(o) ? o.value : o;
+        })
+      })), e._ordinalMeta = n, e._extent = e.getSetting("extent") || [0, n.categories.length - 1], e;
+    }
+    return r.prototype.parse = function(t) {
+      return t == null ? NaN : N(t) ? this._ordinalMeta.getOrdinal(t) : Math.round(t);
+    }, r.prototype.contain = function(t) {
+      return t = this.parse(t), d(t, this._extent) && this._ordinalMeta.categories[t] != null;
+    }, r.prototype.normalize = function(t) {
+      return t = this._getTickNumber(this.parse(t)), g(t, this._extent);
+    }, r.prototype.scale = function(t) {
+      return t = Math.round(y(t, this._extent)), this.getRawOrdinalNumber(t);
+    }, r.prototype.getTicks = function() {
+      for (var t = [], e = this._extent, n = e[0]; n <= e[1]; )
+        t.push({
+          value: n
+        }), n++;
+      return t;
+    }, r.prototype.getMinorTicks = function(t) {
+    }, r.prototype.setSortInfo = function(t) {
+      if (t == null) {
+        this._ordinalNumbersByTick = this._ticksByOrdinalNumber = null;
+        return;
+      }
+      for (var e = t.ordinalNumbers, n = this._ordinalNumbersByTick = [], o = this._ticksByOrdinalNumber = [], i = 0, u = this._ordinalMeta.categories.length, h = Math.min(u, e.length); i < h; ++i) {
+        var l = e[i];
+        n[i] = l, o[l] = i;
+      }
+      for (var a = 0; i < u; ++i) {
+        for (; o[a] != null; )
+          a++;
+        n.push(a), o[a] = i;
+      }
+    }, r.prototype._getTickNumber = function(t) {
+      var e = this._ticksByOrdinalNumber;
+      return e && t >= 0 && t < e.length ? e[t] : t;
+    }, r.prototype.getRawOrdinalNumber = function(t) {
+      var e = this._ordinalNumbersByTick;
+      return e && t >= 0 && t < e.length ? e[t] : t;
+    }, r.prototype.getLabel = function(t) {
+      if (!this.isBlank()) {
+        var e = this.getRawOrdinalNumber(t.value), n = this._ordinalMeta.categories[e];
+        return n == null ? "" : n + "";
+      }
+    }, r.prototype.count = function() {
+      return this._extent[1] - this._extent[0] + 1;
+    }, r.prototype.unionExtentFromData = function(t, e) {
+      this.unionExtent(t.getApproximateExtent(e));
+    }, r.prototype.isInExtentRange = function(t) {
+      return t = this._getTickNumber(t), this._extent[0] <= t && this._extent[1] >= t;
+    }, r.prototype.getOrdinalMeta = function() {
+      return this._ordinalMeta;
+    }, r.prototype.calcNiceTicks = function() {
+    }, r.prototype.calcNiceExtent = function() {
+    }, r.type = "ordinal", r;
+  })(p)
+);
+p.registerClass(O);
+export {
+  O as default
+};

package/dist/node_modules/echarts/lib/scale/Scale.js

@@ -0,0 +1,32 @@
+import { enableClassManagement as o } from "../util/clazz.js";
+var s = (
+  /** @class */
+  (function() {
+    function n(t) {
+      this._setting = t || {}, this._extent = [1 / 0, -1 / 0];
+    }
+    return n.prototype.getSetting = function(t) {
+      return this._setting[t];
+    }, n.prototype.unionExtent = function(t) {
+      var e = this._extent;
+      t[0] < e[0] && (e[0] = t[0]), t[1] > e[1] && (e[1] = t[1]);
+    }, n.prototype.unionExtentFromData = function(t, e) {
+      this.unionExtent(t.getApproximateExtent(e));
+    }, n.prototype.getExtent = function() {
+      return this._extent.slice();
+    }, n.prototype.setExtent = function(t, e) {
+      var i = this._extent;
+      isNaN(t) || (i[0] = t), isNaN(e) || (i[1] = e);
+    }, n.prototype.isInExtentRange = function(t) {
+      return this._extent[0] <= t && this._extent[1] >= t;
+    }, n.prototype.isBlank = function() {
+      return this._isBlank;
+    }, n.prototype.setBlank = function(t) {
+      this._isBlank = t;
+    }, n;
+  })()
+);
+o(s);
+export {
+  s as default
+};

package/dist/node_modules/echarts/lib/scale/Time.js

@@ -0,0 +1,257 @@
+import { __extends as re } from "../../../tslib/tslib.es6.js";
+import { parseDate as p, nice as ne } from "../util/number.js";
+import { format as ae, fullLeveledFormatter as j, getDefaultFormatPrecisionOfInterval as ue, getPrimaryTimeUnit as A, leveledFormat as ie, ONE_DAY as v, ONE_SECOND as W, ONE_MINUTE as Z, ONE_HOUR as F, ONE_YEAR as J, timeUnits as se, isPrimaryTimeUnit as oe, secondsSetterName as $, millisecondsSetterName as I, minutesSetterName as U, hoursSetterName as T, dateSetterName as C, monthSetterName as x, getUnitValue as K, millisecondsGetterName as ce, secondsGetterName as fe, minutesGetterName as le, hoursGetterName as he, dateGetterName as ve, monthGetterName as me, fullYearGetterName as de, fullYearSetterName as ge } from "../util/time.js";
+import { contain as ye, normalize as Se, scale as _e } from "./helper.js";
+import we from "./Interval.js";
+import be from "./Scale.js";
+import { isNumber as Me, filter as Q, map as De } from "../../../zrender/lib/core/util.js";
+var Oe = function(r, n, e, t) {
+  for (; e < t; ) {
+    var a = e + t >>> 1;
+    r[a][1] < n ? e = a + 1 : t = a;
+  }
+  return e;
+}, Ee = (
+  /** @class */
+  (function(r) {
+    re(n, r);
+    function n(e) {
+      var t = r.call(this, e) || this;
+      return t.type = "time", t;
+    }
+    return n.prototype.getLabel = function(e) {
+      var t = this.getSetting("useUTC");
+      return ae(e.value, j[ue(A(this._minLevelUnit))] || j.second, t, this.getSetting("locale"));
+    }, n.prototype.getFormattedLabel = function(e, t, a) {
+      var i = this.getSetting("useUTC"), o = this.getSetting("locale");
+      return ie(e, t, a, o, i);
+    }, n.prototype.getTicks = function() {
+      var e = this._interval, t = this._extent, a = [];
+      if (!e)
+        return a;
+      a.push({
+        value: t[0],
+        level: 0
+      });
+      var i = this.getSetting("useUTC"), o = Ye(this._minLevelUnit, this._approxInterval, i, t);
+      return a = a.concat(o), a.push({
+        value: t[1],
+        level: 0
+      }), a;
+    }, n.prototype.calcNiceExtent = function(e) {
+      var t = this._extent;
+      if (t[0] === t[1] && (t[0] -= v, t[1] += v), t[1] === -1 / 0 && t[0] === 1 / 0) {
+        var a = /* @__PURE__ */ new Date();
+        t[1] = +new Date(a.getFullYear(), a.getMonth(), a.getDate()), t[0] = t[1] - v;
+      }
+      this.calcNiceTicks(e.splitNumber, e.minInterval, e.maxInterval);
+    }, n.prototype.calcNiceTicks = function(e, t, a) {
+      e = e || 10;
+      var i = this._extent, o = i[1] - i[0];
+      this._approxInterval = o / e, t != null && this._approxInterval < t && (this._approxInterval = t), a != null && this._approxInterval > a && (this._approxInterval = a);
+      var g = k.length, y = Math.min(Oe(k, this._approxInterval, 0, g), g - 1);
+      this._interval = k[y][1], this._minLevelUnit = k[Math.max(y - 1, 0)][0];
+    }, n.prototype.parse = function(e) {
+      return Me(e) ? e : +p(e);
+    }, n.prototype.contain = function(e) {
+      return ye(this.parse(e), this._extent);
+    }, n.prototype.normalize = function(e) {
+      return Se(this.parse(e), this._extent);
+    }, n.prototype.scale = function(e) {
+      return _e(e, this._extent);
+    }, n.type = "time", n;
+  })(we)
+), k = [
+  // Format                           interval
+  ["second", W],
+  ["minute", Z],
+  ["hour", F],
+  ["quarter-day", F * 6],
+  ["half-day", F * 12],
+  ["day", v * 1.2],
+  ["half-week", v * 3.5],
+  ["week", v * 7],
+  ["month", v * 31],
+  ["quarter", v * 95],
+  ["half-year", J / 2],
+  ["year", J]
+  // 1Y
+];
+function Le(r, n, e, t) {
+  var a = p(n), i = p(e), o = function(N) {
+    return K(a, N, t) === K(i, N, t);
+  }, g = function() {
+    return o("year");
+  }, y = function() {
+    return g() && o("month");
+  }, S = function() {
+    return y() && o("day");
+  }, l = function() {
+    return S() && o("hour");
+  }, _ = function() {
+    return l() && o("minute");
+  }, E = function() {
+    return _() && o("second");
+  }, u = function() {
+    return E() && o("millisecond");
+  };
+  switch (r) {
+    case "year":
+      return g();
+    case "month":
+      return y();
+    case "day":
+      return S();
+    case "hour":
+      return l();
+    case "minute":
+      return _();
+    case "second":
+      return E();
+    case "millisecond":
+      return u();
+  }
+}
+function Ae(r, n) {
+  return r /= v, r > 16 ? 16 : r > 7.5 ? 7 : r > 3.5 ? 4 : r > 1.5 ? 2 : 1;
+}
+function Ne(r) {
+  var n = 30 * v;
+  return r /= n, r > 6 ? 6 : r > 3 ? 3 : r > 2 ? 2 : 1;
+}
+function ke(r) {
+  return r /= F, r > 12 ? 12 : r > 6 ? 6 : r > 3.5 ? 4 : r > 2 ? 2 : 1;
+}
+function V(r, n) {
+  return r /= n ? Z : W, r > 30 ? 30 : r > 20 ? 20 : r > 15 ? 15 : r > 10 ? 10 : r > 5 ? 5 : r > 2 ? 2 : 1;
+}
+function Fe(r) {
+  return ne(r);
+}
+function Ge(r, n, e) {
+  var t = new Date(r);
+  switch (A(n)) {
+    case "year":
+    case "month":
+      t[x(e)](0);
+    case "day":
+      t[C(e)](1);
+    case "hour":
+      t[T(e)](0);
+    case "minute":
+      t[U(e)](0);
+    case "second":
+      t[$(e)](0), t[I(e)](0);
+  }
+  return t.getTime();
+}
+function Ye(r, n, e, t) {
+  var a = 1e4, i = se, o = 0;
+  function g(f, s, M, D, H, m, L) {
+    for (var O = new Date(s), c = s, h = O[D](); c < M && c <= t[1]; )
+      L.push({
+        value: c
+      }), h += f, O[H](h), c = O.getTime();
+    L.push({
+      value: c,
+      notAdd: !0
+    });
+  }
+  function y(f, s, M) {
+    var D = [], H = !s.length;
+    if (!Le(A(f), t[0], t[1], e)) {
+      H && (s = [{
+        // TODO Optimize. Not include so may ticks.
+        value: Ge(new Date(t[0]), f, e)
+      }, {
+        value: t[1]
+      }]);
+      for (var m = 0; m < s.length - 1; m++) {
+        var L = s[m].value, O = s[m + 1].value;
+        if (L !== O) {
+          var c = void 0, h = void 0, d = void 0, X = !1;
+          switch (f) {
+            case "year":
+              c = Math.max(1, Math.round(n / v / 365)), h = de(e), d = ge(e);
+              break;
+            case "half-year":
+            case "quarter":
+            case "month":
+              c = Ne(n), h = me(e), d = x(e);
+              break;
+            case "week":
+            // PENDING If week is added. Ignore day.
+            case "half-week":
+            case "day":
+              c = Ae(n), h = ve(e), d = C(e), X = !0;
+              break;
+            case "half-day":
+            case "quarter-day":
+            case "hour":
+              c = ke(n), h = he(e), d = T(e);
+              break;
+            case "minute":
+              c = V(n, !0), h = le(e), d = U(e);
+              break;
+            case "second":
+              c = V(n, !1), h = fe(e), d = $(e);
+              break;
+            case "millisecond":
+              c = Fe(n), h = ce(e), d = I(e);
+              break;
+          }
+          g(c, L, O, h, d, X, D), f === "year" && M.length > 1 && m === 0 && M.unshift({
+            value: M[0].value - c
+          });
+        }
+      }
+      for (var m = 0; m < D.length; m++)
+        M.push(D[m]);
+      return D;
+    }
+  }
+  for (var S = [], l = [], _ = 0, E = 0, u = 0; u < i.length && o++ < a; ++u) {
+    var N = A(i[u]);
+    if (oe(i[u])) {
+      y(i[u], S[S.length - 1] || [], l);
+      var ee = i[u + 1] ? A(i[u + 1]) : null;
+      if (N !== ee) {
+        if (l.length) {
+          E = _, l.sort(function(f, s) {
+            return f.value - s.value;
+          });
+          for (var z = [], w = 0; w < l.length; ++w) {
+            var G = l[w].value;
+            (w === 0 || l[w - 1].value !== G) && (z.push(l[w]), G >= t[0] && G <= t[1] && _++);
+          }
+          var Y = (t[1] - t[0]) / n;
+          if (_ > Y * 1.5 && E > Y / 1.5 || (S.push(z), _ > Y || r === i[u]))
+            break;
+        }
+        l = [];
+      }
+    }
+  }
+  for (var P = Q(De(S, function(f) {
+    return Q(f, function(s) {
+      return s.value >= t[0] && s.value <= t[1] && !s.notAdd;
+    });
+  }), function(f) {
+    return f.length > 0;
+  }), b = [], te = P.length - 1, u = 0; u < P.length; ++u)
+    for (var R = P[u], q = 0; q < R.length; ++q)
+      b.push({
+        value: R[q].value,
+        level: te - u
+      });
+  b.sort(function(f, s) {
+    return f.value - s.value;
+  });
+  for (var B = [], u = 0; u < b.length; ++u)
+    (u === 0 || b[u].value !== b[u - 1].value) && B.push(b[u]);
+  return B;
+}
+be.registerClass(Ee);
+export {
+  Ee as default
+};

package/dist/node_modules/echarts/lib/scale/helper.js

@@ -0,0 +1,42 @@
+import { getPrecision as c, nice as h, round as l, quantityExponent as M } from "../util/number.js";
+function m(r) {
+  return r.type === "interval" || r.type === "log";
+}
+function F(r, i, o, f) {
+  var u = {}, v = r[1] - r[0], a = u.interval = h(v / i);
+  o != null && a < o && (a = u.interval = o), f != null && a > f && (a = u.interval = f);
+  var n = u.intervalPrecision = g(a), p = u.niceTickExtent = [l(Math.ceil(r[0] / a) * a, n), l(Math.floor(r[1] / a) * a, n)];
+  return y(p, r), u;
+}
+function S(r) {
+  var i = Math.pow(10, M(r)), o = r / i;
+  return o ? o === 2 ? o = 3 : o === 3 ? o = 5 : o *= 2 : o = 1, l(o * i);
+}
+function g(r) {
+  return c(r) + 2;
+}
+function s(r, i, o) {
+  r[i] = Math.max(Math.min(r[i], o[1]), o[0]);
+}
+function y(r, i) {
+  !isFinite(r[0]) && (r[0] = i[0]), !isFinite(r[1]) && (r[1] = i[1]), s(r, 0, i), s(r, 1, i), r[0] > r[1] && (r[0] = r[1]);
+}
+function q(r, i) {
+  return r >= i[0] && r <= i[1];
+}
+function w(r, i) {
+  return i[1] === i[0] ? 0.5 : (r - i[0]) / (i[1] - i[0]);
+}
+function z(r, i) {
+  return r * (i[1] - i[0]) + i[0];
+}
+export {
+  q as contain,
+  y as fixExtent,
+  g as getIntervalPrecision,
+  S as increaseInterval,
+  F as intervalScaleNiceTicks,
+  m as isIntervalOrLogScale,
+  w as normalize,
+  z as scale
+};