web-core-tcm 0.0.59 → 0.0.62

package/dist/node_modules/echarts/lib/coord/View.js

@@ -0,0 +1,91 @@
+import { __extends as T } from "../../../tslib/tslib.es6.js";
+import { applyTransform as c, copy as y } from "../../../zrender/lib/core/vector.js";
+import { copy as v, create as d, invert as g } from "../../../zrender/lib/core/matrix.js";
+import f from "../../../zrender/lib/core/BoundingRect.js";
+import i from "../../../zrender/lib/core/Transformable.js";
+import { parsePercent as p } from "../util/number.js";
+var u = c, M = (
+  /** @class */
+  (function(s) {
+    T(o, s);
+    function o(r) {
+      var t = s.call(this) || this;
+      return t.type = "view", t.dimensions = ["x", "y"], t._roamTransformable = new i(), t._rawTransformable = new i(), t.name = r, t;
+    }
+    return o.prototype.setBoundingRect = function(r, t, e, n) {
+      return this._rect = new f(r, t, e, n), this._rect;
+    }, o.prototype.getBoundingRect = function() {
+      return this._rect;
+    }, o.prototype.setViewRect = function(r, t, e, n) {
+      this._transformTo(r, t, e, n), this._viewRect = new f(r, t, e, n);
+    }, o.prototype._transformTo = function(r, t, e, n) {
+      var m = this.getBoundingRect(), a = this._rawTransformable;
+      a.transform = m.calculateTransform(new f(r, t, e, n));
+      var h = a.parent;
+      a.parent = null, a.decomposeTransform(), a.parent = h, this._updateTransform();
+    }, o.prototype.setCenter = function(r, t) {
+      r && (this._center = [p(r[0], t.getWidth()), p(r[1], t.getHeight())], this._updateCenterAndZoom());
+    }, o.prototype.setZoom = function(r) {
+      r = r || 1;
+      var t = this.zoomLimit;
+      t && (t.max != null && (r = Math.min(t.max, r)), t.min != null && (r = Math.max(t.min, r))), this._zoom = r, this._updateCenterAndZoom();
+    }, o.prototype.getDefaultCenter = function() {
+      var r = this.getBoundingRect(), t = r.x + r.width / 2, e = r.y + r.height / 2;
+      return [t, e];
+    }, o.prototype.getCenter = function() {
+      return this._center || this.getDefaultCenter();
+    }, o.prototype.getZoom = function() {
+      return this._zoom || 1;
+    }, o.prototype.getRoamTransform = function() {
+      return this._roamTransformable.getLocalTransform();
+    }, o.prototype._updateCenterAndZoom = function() {
+      var r = this._rawTransformable.getLocalTransform(), t = this._roamTransformable, e = this.getDefaultCenter(), n = this.getCenter(), m = this.getZoom();
+      n = c([], n, r), e = c([], e, r), t.originX = n[0], t.originY = n[1], t.x = e[0] - n[0], t.y = e[1] - n[1], t.scaleX = t.scaleY = m, this._updateTransform();
+    }, o.prototype._updateTransform = function() {
+      var r = this._roamTransformable, t = this._rawTransformable;
+      t.parent = r, r.updateTransform(), t.updateTransform(), v(this.transform || (this.transform = []), t.transform || d()), this._rawTransform = t.getLocalTransform(), this.invTransform = this.invTransform || [], g(this.invTransform, this.transform), this.decomposeTransform();
+    }, o.prototype.getTransformInfo = function() {
+      var r = this._rawTransformable, t = this._roamTransformable, e = new i();
+      return e.transform = t.transform, e.decomposeTransform(), {
+        roam: {
+          x: e.x,
+          y: e.y,
+          scaleX: e.scaleX,
+          scaleY: e.scaleY
+        },
+        raw: {
+          x: r.x,
+          y: r.y,
+          scaleX: r.scaleX,
+          scaleY: r.scaleY
+        }
+      };
+    }, o.prototype.getViewRect = function() {
+      return this._viewRect;
+    }, o.prototype.getViewRectAfterRoam = function() {
+      var r = this.getBoundingRect().clone();
+      return r.applyTransform(this.transform), r;
+    }, o.prototype.dataToPoint = function(r, t, e) {
+      var n = t ? this._rawTransform : this.transform;
+      return e = e || [], n ? u(e, r, n) : y(e, r);
+    }, o.prototype.pointToData = function(r) {
+      var t = this.invTransform;
+      return t ? u([], r, t) : [r[0], r[1]];
+    }, o.prototype.convertToPixel = function(r, t, e) {
+      var n = l(t);
+      return n === this ? n.dataToPoint(e) : null;
+    }, o.prototype.convertFromPixel = function(r, t, e) {
+      var n = l(t);
+      return n === this ? n.pointToData(e) : null;
+    }, o.prototype.containPoint = function(r) {
+      return this.getViewRectAfterRoam().contain(r[0], r[1]);
+    }, o.dimensions = ["x", "y"], o;
+  })(i)
+);
+function l(s) {
+  var o = s.seriesModel;
+  return o ? o.coordinateSystem : null;
+}
+export {
+  M as default
+};

package/dist/node_modules/echarts/lib/coord/axisAlignTicks.js

@@ -0,0 +1,39 @@
+import { round as s } from "../util/number.js";
+import N from "../scale/Interval.js";
+import { getScaleExtent as d } from "./axisHelper.js";
+import { increaseInterval as g } from "../scale/helper.js";
+var p = Math.log;
+function L(a, F, f) {
+  var n = N.prototype, o = n.getTicks.call(f), u = n.getTicks.call(f, !0), l = o.length - 1, E = n.getInterval.call(f), c = d(a, F), t = c.extent, v = c.fixMin, x = c.fixMax;
+  if (a.type === "log") {
+    var M = p(a.base);
+    t = [p(t[0]) / M, p(t[1]) / M];
+  }
+  a.setExtent(t[0], t[1]), a.calcNiceExtent({
+    splitNumber: l,
+    fixMin: v,
+    fixMax: x
+  });
+  var T = n.getExtent.call(a);
+  v && (t[0] = T[0]), x && (t[1] = T[1]);
+  var i = n.getInterval.call(a), r = t[0], e = t[1];
+  if (v && x)
+    i = (e - r) / l;
+  else if (v)
+    for (e = t[0] + i * l; e < t[1] && isFinite(e) && isFinite(t[1]); )
+      i = g(i), e = t[0] + i * l;
+  else if (x)
+    for (r = t[1] - i * l; r > t[0] && isFinite(r) && isFinite(t[0]); )
+      i = g(i), r = t[1] - i * l;
+  else {
+    var I = a.getTicks().length - 1;
+    I > l && (i = g(i));
+    var m = i * l;
+    e = Math.ceil(t[1] / i) * i, r = s(e - m), r < 0 && t[0] >= 0 ? (r = 0, e = s(m)) : e > 0 && t[1] <= 0 && (e = 0, r = -s(m));
+  }
+  var h = (o[0].value - u[0].value) / E, k = (o[l].value - u[l].value) / E;
+  n.setExtent.call(a, r + i * h, e + i * k), n.setInterval.call(a, i), (h || k) && n.setNiceExtent.call(a, r + i, e - i);
+}
+export {
+  L as alignScaleTicks
+};

package/dist/node_modules/echarts/lib/coord/axisCommonTypes.js

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

package/dist/node_modules/echarts/lib/coord/axisDefault.js

@@ -0,0 +1,160 @@
+import { defaults as i, merge as e } from "../../../zrender/lib/core/util.js";
+var a = {
+  show: !0,
+  // zlevel: 0,
+  z: 0,
+  // Inverse the axis.
+  inverse: !1,
+  // 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: !1,
+  // Default `false` to avoid legacy user event listener fail.
+  triggerEvent: !1,
+  tooltip: {
+    show: !1
+  },
+  axisPointer: {},
+  axisLine: {
+    show: !0,
+    onZero: !0,
+    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: !0,
+    // Whether axisTick is inside the grid or outside the grid.
+    inside: !1,
+    // The length of axisTick.
+    length: 5,
+    lineStyle: {
+      width: 1
+    }
+  },
+  axisLabel: {
+    show: !0,
+    // Whether axisLabel is inside the grid or outside the grid.
+    inside: !1,
+    rotate: 0,
+    // true | false | null/undefined (auto)
+    showMinLabel: null,
+    // true | false | null/undefined (auto)
+    showMaxLabel: null,
+    margin: 8,
+    // formatter: null,
+    fontSize: 12
+  },
+  splitLine: {
+    show: !0,
+    showMinLine: !0,
+    showMaxLine: !0,
+    lineStyle: {
+      color: ["#E0E6F1"],
+      width: 1,
+      type: "solid"
+    }
+  },
+  splitArea: {
+    show: !1,
+    areaStyle: {
+      color: ["rgba(250,250,250,0.2)", "rgba(210,219,238,0.2)"]
+    }
+  }
+}, s = e({
+  // The gap at both ends of the axis. For categoryAxis, boolean.
+  boundaryGap: !0,
+  // Set false to faster category collection.
+  deduplication: null,
+  // splitArea: {
+  // show: false
+  // },
+  splitLine: {
+    show: !1
+  },
+  axisTick: {
+    // If tick is align with label when boundaryGap is true
+    alignWithLabel: !1,
+    interval: "auto"
+  },
+  axisLabel: {
+    interval: "auto"
+  }
+}, a), l = e({
+  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: !1,
+    // 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: !1,
+    lineStyle: {
+      color: "#F4F7FD",
+      width: 1
+    }
+  }
+}, a), t = e({
+  splitNumber: 6,
+  axisLabel: {
+    // To eliminate labels that are not nice
+    showMinLabel: !1,
+    showMaxLabel: !1,
+    rich: {
+      primary: {
+        fontWeight: "bold"
+      }
+    }
+  },
+  splitLine: {
+    show: !1
+  }
+}, l), o = i({
+  logBase: 10
+}, l);
+const r = {
+  category: s,
+  value: l,
+  time: t,
+  log: o
+};
+export {
+  r as default
+};

package/dist/node_modules/echarts/lib/coord/axisHelper.js

@@ -0,0 +1,162 @@
+import { each as m, keys as b, isString as h, isFunction as p } from "../../../zrender/lib/core/util.js";
+import M from "../scale/Ordinal.js";
+import y from "../scale/Interval.js";
+import w from "../scale/Scale.js";
+import { prepareLayoutBarSeries as L, makeColumnLayout as d, retrieveColumnLayout as I } from "../layout/barGrid.js";
+import E from "../../../zrender/lib/core/BoundingRect.js";
+import S from "../scale/Time.js";
+import O from "../scale/Log.js";
+import { getStackedDimension as C } from "../data/helper/dataStackHelper.js";
+import { ensureScaleRawExtentInfo as F } from "./scaleRawExtentInfo.js";
+function k(e, t) {
+  var a = e.type, r = F(e, t, e.getExtent()).calculate();
+  e.setBlank(r.isBlank);
+  var n = r.min, i = r.max, u = t.ecModel;
+  if (u && a === "time") {
+    var o = L("bar", u), l = !1;
+    if (m(o, function(g) {
+      l = l || g.getBaseAxis() === t.axis;
+    }), l) {
+      var v = d(o), f = R(n, i, t, v);
+      n = f.min, i = f.max;
+    }
+  }
+  return {
+    extent: [n, i],
+    // "fix" means "fixed", the value should not be
+    // changed in the subsequent steps.
+    fixMin: r.minFixed,
+    fixMax: r.maxFixed
+  };
+}
+function R(e, t, a, r) {
+  var n = a.axis.getExtent(), i = Math.abs(n[1] - n[0]), u = I(r, a.axis);
+  if (u === void 0)
+    return {
+      min: e,
+      max: t
+    };
+  var o = 1 / 0;
+  m(u, function(c) {
+    o = Math.min(c.offset, o);
+  });
+  var l = -1 / 0;
+  m(u, function(c) {
+    l = Math.max(c.offset + c.width, l);
+  }), o = Math.abs(o), l = Math.abs(l);
+  var v = o + l, f = t - e, g = 1 - (o + l) / i, s = f / g - f;
+  return t += s * (l / v), e -= s * (o / v), {
+    min: e,
+    max: t
+  };
+}
+function J(e, t) {
+  var a = t, r = k(e, a), n = r.extent, i = a.get("splitNumber");
+  e instanceof O && (e.base = a.get("logBase"));
+  var u = e.type, o = a.get("interval"), l = u === "interval" || u === "time";
+  e.setExtent(n[0], n[1]), e.calcNiceExtent({
+    splitNumber: i,
+    fixMin: r.fixMin,
+    fixMax: r.fixMax,
+    minInterval: l ? a.get("minInterval") : null,
+    maxInterval: l ? a.get("maxInterval") : null
+  }), o != null && e.setInterval && e.setInterval(o);
+}
+function K(e, t) {
+  if (t = t || e.get("type"), t)
+    switch (t) {
+      // Buildin scale
+      case "category":
+        return new M({
+          ordinalMeta: e.getOrdinalMeta ? e.getOrdinalMeta() : e.getCategories(),
+          extent: [1 / 0, -1 / 0]
+        });
+      case "time":
+        return new S({
+          locale: e.ecModel.getLocaleModel(),
+          useUTC: e.ecModel.get("useUTC")
+        });
+      default:
+        return new (w.getClass(t) || y)();
+    }
+}
+function Q(e) {
+  var t = e.scale.getExtent(), a = t[0], r = t[1];
+  return !(a > 0 && r > 0 || a < 0 && r < 0);
+}
+function T(e) {
+  var t = e.getLabelModel().get("formatter"), a = e.type === "category" ? e.scale.getExtent()[0] : null;
+  return e.scale.type === "time" ? /* @__PURE__ */ (function(r) {
+    return function(n, i) {
+      return e.scale.getFormattedLabel(n, i, r);
+    };
+  })(t) : h(t) ? /* @__PURE__ */ (function(r) {
+    return function(n) {
+      var i = e.scale.getLabel(n), u = r.replace("{value}", i ?? "");
+      return u;
+    };
+  })(t) : p(t) ? /* @__PURE__ */ (function(r) {
+    return function(n, i) {
+      return a != null && (i = n.value - a), r(D(e, n), i, n.level != null ? {
+        level: n.level
+      } : null);
+    };
+  })(t) : function(r) {
+    return e.scale.getLabel(r);
+  };
+}
+function D(e, t) {
+  return e.type === "category" ? e.scale.getLabel(t) : t.value;
+}
+function X(e) {
+  var t = e.model, a = e.scale;
+  if (!(!t.get(["axisLabel", "show"]) || a.isBlank())) {
+    var r, n, i = a.getExtent();
+    a instanceof M ? n = a.count() : (r = a.getTicks(), n = r.length);
+    var u = e.getLabelModel(), o = T(e), l, v = 1;
+    n > 40 && (v = Math.ceil(n / 40));
+    for (var f = 0; f < n; f += v) {
+      var g = r ? r[f] : {
+        value: i[0] + f
+      }, s = o(g, f), c = u.getTextRect(s), x = N(c, u.get("rotate") || 0);
+      l ? l.union(x) : l = x;
+    }
+    return l;
+  }
+}
+function N(e, t) {
+  var a = t * Math.PI / 180, r = e.width, n = e.height, i = r * Math.abs(Math.cos(a)) + Math.abs(n * Math.sin(a)), u = r * Math.abs(Math.sin(a)) + Math.abs(n * Math.cos(a)), o = new E(e.x, e.y, i, u);
+  return o;
+}
+function A(e) {
+  var t = e.get("interval");
+  return t ?? "auto";
+}
+function Y(e) {
+  return e.type === "category" && A(e.getLabelModel()) === 0;
+}
+function B(e, t) {
+  var a = {};
+  return m(e.mapDimensionsAll(t), function(r) {
+    a[C(e, r)] = !0;
+  }), b(a);
+}
+function $(e, t, a) {
+  t && m(B(t, a), function(r) {
+    var n = t.getApproximateExtent(r);
+    n[0] < e[0] && (e[0] = n[0]), n[1] > e[1] && (e[1] = n[1]);
+  });
+}
+export {
+  K as createScaleByModel,
+  X as estimateLabelUnionRect,
+  D as getAxisRawValue,
+  B as getDataDimensionsOnAxis,
+  A as getOptionCategoryInterval,
+  k as getScaleExtent,
+  Q as ifAxisCrossZero,
+  T as makeLabelFormatter,
+  J as niceScaleExtent,
+  Y as shouldShowAllLabels,
+  $ as unionAxisExtentFromData
+};

package/dist/node_modules/echarts/lib/coord/axisModelCommonMixin.js

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

package/dist/node_modules/echarts/lib/coord/axisModelCreator.js

@@ -0,0 +1,40 @@
+import { __extends as h } from "../../../tslib/tslib.es6.js";
+import c from "./axisDefault.js";
+import { fetchLayoutMode as M, getLayoutParams as v, mergeLayoutParam as A } from "../util/layout.js";
+import _ from "../data/OrdinalMeta.js";
+import { AXIS_TYPES as x } from "./axisCommonTypes.js";
+import { each as O, merge as a } from "../../../zrender/lib/core/util.js";
+function B(r, n, l, s) {
+  O(x, function(P, o) {
+    var d = a(a({}, c[o], !0), s, !0), m = (
+      /** @class */
+      (function(u) {
+        h(e, u);
+        function e() {
+          var t = u !== null && u.apply(this, arguments) || this;
+          return t.type = n + "Axis." + o, t;
+        }
+        return e.prototype.mergeDefaultAndTheme = function(t, i) {
+          var f = M(this), y = f ? v(t) : {}, g = i.getTheme();
+          a(t, g.get(o + "Axis")), a(t, this.getDefaultOption()), t.type = p(t), f && A(t, y, f);
+        }, e.prototype.optionUpdated = function() {
+          var t = this.option;
+          t.type === "category" && (this.__ordinalMeta = _.createByAxisModel(this));
+        }, e.prototype.getCategories = function(t) {
+          var i = this.option;
+          if (i.type === "category")
+            return t ? i.data : this.__ordinalMeta.categories;
+        }, e.prototype.getOrdinalMeta = function() {
+          return this.__ordinalMeta;
+        }, e.type = n + "Axis." + o, e.defaultOption = d, e;
+      })(l)
+    );
+    r.registerComponentModel(m);
+  }), r.registerSubTypeDefaulter(n + "Axis", p);
+}
+function p(r) {
+  return r.type || (r.data ? "category" : "value");
+}
+export {
+  B as default
+};

package/dist/node_modules/echarts/lib/coord/axisTickLabelBuilder.js

@@ -0,0 +1,176 @@
+import { filter as E, map as d, isFunction as A, each as O } from "../../../zrender/lib/core/util.js";
+import { getBoundingRect as P } from "../../../zrender/lib/contain/text.js";
+import { makeInner as W } from "../util/model.js";
+import { makeLabelFormatter as C, getOptionCategoryInterval as V, shouldShowAllLabels as j } from "./axisHelper.js";
+var L = W();
+function F(t, a) {
+  var e = d(a, function(r) {
+    return t.scale.parse(r);
+  });
+  return t.type === "time" && e.length > 0 && (e.sort(), e.unshift(e[0]), e.push(e[e.length - 1])), e;
+}
+function Z(t) {
+  var a = t.getLabelModel().get("customValues");
+  if (a) {
+    var e = C(t), r = t.scale.getExtent(), o = F(t, a), l = E(o, function(n) {
+      return n >= r[0] && n <= r[1];
+    });
+    return {
+      labels: d(l, function(n) {
+        var v = {
+          value: n
+        };
+        return {
+          formattedLabel: e(v),
+          rawLabel: t.scale.getLabel(v),
+          tickValue: n
+        };
+      })
+    };
+  }
+  return t.type === "category" ? G(t) : D(t);
+}
+function $(t, a) {
+  var e = t.getTickModel().get("customValues");
+  if (e) {
+    var r = t.scale.getExtent(), o = F(t, e);
+    return {
+      ticks: E(o, function(l) {
+        return l >= r[0] && l <= r[1];
+      })
+    };
+  }
+  return t.type === "category" ? q(t, a) : {
+    ticks: d(t.scale.getTicks(), function(l) {
+      return l.value;
+    })
+  };
+}
+function G(t) {
+  var a = t.getLabelModel(), e = N(t, a);
+  return !a.get("show") || t.scale.isBlank() ? {
+    labels: [],
+    labelCategoryInterval: e.labelCategoryInterval
+  } : e;
+}
+function N(t, a) {
+  var e = R(t, "labels"), r = V(a), o = S(e, r);
+  if (o)
+    return o;
+  var l, n;
+  return A(r) ? l = z(t, r) : (n = r === "auto" ? J(t) : r, l = H(t, n)), B(e, r, {
+    labels: l,
+    labelCategoryInterval: n
+  });
+}
+function q(t, a) {
+  var e = R(t, "ticks"), r = V(a), o = S(e, r);
+  if (o)
+    return o;
+  var l, n;
+  if ((!a.get("show") || t.scale.isBlank()) && (l = []), A(r))
+    l = z(t, r, !0);
+  else if (r === "auto") {
+    var v = N(t, t.getLabelModel());
+    n = v.labelCategoryInterval, l = d(v.labels, function(u) {
+      return u.tickValue;
+    });
+  } else
+    n = r, l = H(t, n, !0);
+  return B(e, r, {
+    ticks: l,
+    tickCategoryInterval: n
+  });
+}
+function D(t) {
+  var a = t.scale.getTicks(), e = C(t);
+  return {
+    labels: d(a, function(r, o) {
+      return {
+        level: r.level,
+        formattedLabel: e(r, o),
+        rawLabel: t.scale.getLabel(r),
+        tickValue: r.value
+      };
+    })
+  };
+}
+function R(t, a) {
+  return L(t)[a] || (L(t)[a] = []);
+}
+function S(t, a) {
+  for (var e = 0; e < t.length; e++)
+    if (t[e].key === a)
+      return t[e].value;
+}
+function B(t, a, e) {
+  return t.push({
+    key: a,
+    value: e
+  }), e;
+}
+function J(t) {
+  var a = L(t).autoInterval;
+  return a ?? (L(t).autoInterval = t.calculateCategoryInterval());
+}
+function _(t) {
+  var a = K(t), e = C(t), r = (a.axisRotate - a.labelRotate) / 180 * Math.PI, o = t.scale, l = o.getExtent(), n = o.count();
+  if (l[1] - l[0] < 1)
+    return 0;
+  var v = 1;
+  n > 40 && (v = Math.max(1, Math.floor(n / 40)));
+  for (var u = l[0], c = t.dataToCoord(u + 1) - t.dataToCoord(u), p = Math.abs(c * Math.cos(r)), M = Math.abs(c * Math.sin(r)), m = 0, h = 0; u <= l[1]; u += v) {
+    var s = 0, f = 0, b = P(e({
+      value: u
+    }), a.font, "center", "top");
+    s = b.width * 1.3, f = b.height * 1.3, m = Math.max(m, s, 7), h = Math.max(h, f, 7);
+  }
+  var g = m / p, T = h / M;
+  isNaN(g) && (g = 1 / 0), isNaN(T) && (T = 1 / 0);
+  var k = Math.max(0, Math.floor(Math.min(g, T))), i = L(t.model), y = t.getExtent(), I = i.lastAutoInterval, w = i.lastTickCount;
+  return I != null && w != null && Math.abs(I - k) <= 1 && Math.abs(w - n) <= 1 && I > k && i.axisExtent0 === y[0] && i.axisExtent1 === y[1] ? k = I : (i.lastTickCount = n, i.lastAutoInterval = k, i.axisExtent0 = y[0], i.axisExtent1 = y[1]), k;
+}
+function K(t) {
+  var a = t.getLabelModel();
+  return {
+    axisRotate: t.getRotate ? t.getRotate() : t.isHorizontal && !t.isHorizontal() ? 90 : 0,
+    labelRotate: a.get("rotate") || 0,
+    font: a.getFont()
+  };
+}
+function H(t, a, e) {
+  var r = C(t), o = t.scale, l = o.getExtent(), n = t.getLabelModel(), v = [], u = Math.max((a || 0) + 1, 1), c = l[0], p = o.count();
+  c !== 0 && u > 1 && p / u > 2 && (c = Math.round(Math.ceil(c / u) * u));
+  var M = j(t), m = n.get("showMinLabel") || M, h = n.get("showMaxLabel") || M;
+  m && c !== l[0] && f(l[0]);
+  for (var s = c; s <= l[1]; s += u)
+    f(s);
+  h && s - u !== l[1] && f(l[1]);
+  function f(b) {
+    var g = {
+      value: b
+    };
+    v.push(e ? b : {
+      formattedLabel: r(g),
+      rawLabel: o.getLabel(g),
+      tickValue: b
+    });
+  }
+  return v;
+}
+function z(t, a, e) {
+  var r = t.scale, o = C(t), l = [];
+  return O(r.getTicks(), function(n) {
+    var v = r.getLabel(n), u = n.value;
+    a(n.value, v) && l.push(e ? u : {
+      formattedLabel: o(n),
+      rawLabel: v,
+      tickValue: u
+    });
+  }), l;
+}
+export {
+  _ as calculateCategoryInterval,
+  Z as createAxisLabels,
+  $ as createAxisTicks
+};