web-core-tcm 0.0.59 → 0.0.62

package/dist/node_modules/echarts/lib/coord/geo/geoCreator.js

@@ -0,0 +1,106 @@
+import { extend as L, each as y, map as j, mergeAll as V, retrieve as Z, createHashMap as k, merge as q } from "../../../../zrender/lib/core/util.js";
+import A, { geo2DDimensions as E } from "./Geo.js";
+import { getLayoutRect as K } from "../../util/layout.js";
+import { parsePercent as S } from "../../util/number.js";
+import Q from "./geoSourceManager.js";
+import { min as U, max as X } from "../../../../zrender/lib/core/vector.js";
+function O(v, u) {
+  var g = v.get("boundingCoords");
+  if (g != null) {
+    var r = g[0], n = g[1];
+    if (isFinite(r[0]) && isFinite(r[1]) && isFinite(n[0]) && isFinite(n[1])) {
+      var c = this.projection;
+      if (c) {
+        var e = r[0], i = r[1], a = n[0], t = n[1];
+        r = [1 / 0, 1 / 0], n = [-1 / 0, -1 / 0];
+        var o = function(F, I, D, W) {
+          for (var b = D - F, J = W - I, z = 0; z <= 100; z++) {
+            var P = z / 100, H = c.project([F + b * P, I + J * P]);
+            U(r, r, H), X(n, n, H);
+          }
+        };
+        o(e, i, a, i), o(a, i, a, t), o(a, t, e, t), o(e, t, a, i);
+      }
+      this.setBoundingRect(r[0], r[1], n[0] - r[0], n[1] - r[1]);
+    }
+  }
+  var h = this.getBoundingRect(), m = v.get("layoutCenter"), G = v.get("layoutSize"), w = u.getWidth(), C = u.getHeight(), d = h.width / h.height * this.aspectScale, N = !1, p, f;
+  m && G && (p = [S(m[0], w), S(m[1], C)], f = S(G, Math.min(w, C)), !isNaN(p[0]) && !isNaN(p[1]) && !isNaN(f) && (N = !0));
+  var s;
+  if (N)
+    s = {}, d > 1 ? (s.width = f, s.height = f / d) : (s.height = f, s.width = f * d), s.y = p[1] - s.height / 2, s.x = p[0] - s.width / 2;
+  else {
+    var R = v.getBoxLayoutParams();
+    R.aspect = d, s = K(R, {
+      width: w,
+      height: C
+    });
+  }
+  this.setViewRect(s.x, s.y, s.width, s.height), this.setCenter(v.get("center"), u), this.setZoom(v.get("zoom"));
+}
+function Y(v, u) {
+  y(u.get("geoCoord"), function(g, r) {
+    v.addGeoCoord(r, g);
+  });
+}
+var $ = (
+  /** @class */
+  (function() {
+    function v() {
+      this.dimensions = E;
+    }
+    return v.prototype.create = function(u, g) {
+      var r = [];
+      function n(e) {
+        return {
+          nameProperty: e.get("nameProperty"),
+          aspectScale: e.get("aspectScale"),
+          projection: e.get("projection")
+        };
+      }
+      u.eachComponent("geo", function(e, i) {
+        var a = e.get("map"), t = new A(a + i, a, L({
+          nameMap: e.get("nameMap")
+        }, n(e)));
+        t.zoomLimit = e.get("scaleLimit"), r.push(t), e.coordinateSystem = t, t.model = e, t.resize = O, t.resize(e, g);
+      }), u.eachSeries(function(e) {
+        var i = e.get("coordinateSystem");
+        if (i === "geo") {
+          var a = e.get("geoIndex") || 0;
+          e.coordinateSystem = r[a];
+        }
+      });
+      var c = {};
+      return u.eachSeriesByType("map", function(e) {
+        if (!e.getHostGeoModel()) {
+          var i = e.getMapType();
+          c[i] = c[i] || [], c[i].push(e);
+        }
+      }), y(c, function(e, i) {
+        var a = j(e, function(o) {
+          return o.get("nameMap");
+        }), t = new A(i, i, L({
+          nameMap: V(a)
+        }, n(e[0])));
+        t.zoomLimit = Z.apply(null, j(e, function(o) {
+          return o.get("scaleLimit");
+        })), r.push(t), t.resize = O, t.resize(e[0], g), y(e, function(o) {
+          o.coordinateSystem = t, Y(t, o);
+        });
+      }), r;
+    }, v.prototype.getFilledRegions = function(u, g, r, n) {
+      for (var c = (u || []).slice(), e = k(), i = 0; i < c.length; i++)
+        e.set(c[i].name, c[i]);
+      var a = Q.load(g, r, n);
+      return y(a.regions, function(t) {
+        var o = t.name, h = e.get(o), m = t.properties && t.properties.echartsStyle;
+        h || (h = {
+          name: o
+        }, c.push(h)), m && q(h, m);
+      }), c;
+    }, v;
+  })()
+), ee = new $();
+export {
+  ee as default
+};

package/dist/node_modules/echarts/lib/coord/geo/geoSourceManager.js

@@ -0,0 +1,66 @@
+import { createHashMap as u } from "../../../../zrender/lib/core/util.js";
+import { GeoSVGResource as c } from "./GeoSVGResource.js";
+import { GeoJSONResource as g } from "./GeoJSONResource.js";
+var t = u();
+const f = {
+  /**
+   * Compatible with previous `echarts.registerMap`.
+   *
+   * @usage
+   * ```js
+   *
+   * echarts.registerMap('USA', geoJson, specialAreas);
+   *
+   * echarts.registerMap('USA', {
+   *     geoJson: geoJson,
+   *     specialAreas: {...}
+   * });
+   * echarts.registerMap('USA', {
+   *     geoJSON: geoJson,
+   *     specialAreas: {...}
+   * });
+   *
+   * echarts.registerMap('airport', {
+   *     svg: svg
+   * }
+   * ```
+   *
+   * Note:
+   * Do not support that register multiple geoJSON or SVG
+   * one map name. Because different geoJSON and SVG have
+   * different unit. It's not easy to make sure how those
+   * units are mapping/normalize.
+   * If intending to use multiple geoJSON or SVG, we can
+   * use multiple geo coordinate system.
+   */
+  registerMap: function(r, e, s) {
+    if (e.svg) {
+      var o = new c(r, e.svg);
+      t.set(r, o);
+    } else {
+      var n = e.geoJson || e.geoJSON;
+      n && !e.features ? s = e.specialAreas : n = e;
+      var o = new g(r, n, s);
+      t.set(r, o);
+    }
+  },
+  getGeoResource: function(r) {
+    return t.get(r);
+  },
+  /**
+   * Only for exporting to users.
+   * **MUST NOT** used internally.
+   */
+  getMapForUser: function(r) {
+    var e = t.get(r);
+    return e && e.type === "geoJSON" && e.getMapForUser();
+  },
+  load: function(r, e, s) {
+    var o = t.get(r);
+    if (o)
+      return o.load(e, s);
+  }
+};
+export {
+  f as default
+};

package/dist/node_modules/echarts/lib/coord/geo/parseGeoJson.js

@@ -0,0 +1,67 @@
+import { map as d, each as p, filter as h } from "../../../../zrender/lib/core/util.js";
+import { GeoJSONLineStringGeometry as f, GeoJSONPolygonGeometry as g, GeoJSONRegion as m } from "./Region.js";
+function S(r) {
+  if (!r.UTF8Encoding)
+    return r;
+  var s = r, e = s.UTF8Scale;
+  e == null && (e = 1024);
+  var n = s.features;
+  return p(n, function(c) {
+    var t = c.geometry, a = t.encodeOffsets, o = t.coordinates;
+    if (a)
+      switch (t.type) {
+        case "LineString":
+          t.coordinates = l(o, a, e);
+          break;
+        case "Polygon":
+          u(o, a, e);
+          break;
+        case "MultiLineString":
+          u(o, a, e);
+          break;
+        case "MultiPolygon":
+          p(o, function(i, v) {
+            return u(i, a[v], e);
+          });
+      }
+  }), s.UTF8Encoding = !1, s;
+}
+function u(r, s, e) {
+  for (var n = 0; n < r.length; n++)
+    r[n] = l(r[n], s[n], e);
+}
+function l(r, s, e) {
+  for (var n = [], c = s[0], t = s[1], a = 0; a < r.length; a += 2) {
+    var o = r.charCodeAt(a) - 64, i = r.charCodeAt(a + 1) - 64;
+    o = o >> 1 ^ -(o & 1), i = i >> 1 ^ -(i & 1), o += c, i += t, c = o, t = i, n.push([o / e, i / e]);
+  }
+  return n;
+}
+function k(r, s) {
+  return r = S(r), d(h(r.features, function(e) {
+    return e.geometry && e.properties && e.geometry.coordinates.length > 0;
+  }), function(e) {
+    var n = e.properties, c = e.geometry, t = [];
+    switch (c.type) {
+      case "Polygon":
+        var a = c.coordinates;
+        t.push(new g(a[0], a.slice(1)));
+        break;
+      case "MultiPolygon":
+        p(c.coordinates, function(i) {
+          i[0] && t.push(new g(i[0], i.slice(1)));
+        });
+        break;
+      case "LineString":
+        t.push(new f([c.coordinates]));
+        break;
+      case "MultiLineString":
+        t.push(new f(c.coordinates));
+    }
+    var o = new m(n[s || "name"], t, n.cp);
+    return o.properties = n, o;
+  });
+}
+export {
+  k as default
+};

package/dist/node_modules/echarts/lib/coord/geo/prepareCustom.js

@@ -0,0 +1,29 @@
+import { bind as h, map as u } from "../../../../zrender/lib/core/util.js";
+function p(r, o) {
+  return o = o || [0, 0], u([0, 1], function(t) {
+    var a = o[t], i = r[t] / 2, n = [], e = [];
+    return n[t] = a - i, e[t] = a + i, n[1 - t] = e[1 - t] = o[1 - t], Math.abs(this.dataToPoint(n)[t] - this.dataToPoint(e)[t]);
+  }, this);
+}
+function g(r) {
+  var o = r.getBoundingRect();
+  return {
+    coordSys: {
+      type: "geo",
+      x: o.x,
+      y: o.y,
+      width: o.width,
+      height: o.height,
+      zoom: r.getZoom()
+    },
+    api: {
+      coord: function(t) {
+        return r.dataToPoint(t);
+      },
+      size: h(p, r)
+    }
+  };
+}
+export {
+  g as default
+};

package/dist/node_modules/echarts/lib/coord/parallel/AxisModel.js

@@ -0,0 +1,51 @@
+import { __extends as l } from "../../../../tslib/tslib.es6.js";
+import { clone as c, mixin as f } from "../../../../zrender/lib/core/util.js";
+import s from "../../model/Component.js";
+import p from "../../model/mixin/makeStyleMapper.js";
+import { asc as m } from "../../util/number.js";
+import { AxisModelCommonMixin as v } from "../axisModelCommonMixin.js";
+var h = (
+  /** @class */
+  (function(n) {
+    l(r, n);
+    function r() {
+      var t = n !== null && n.apply(this, arguments) || this;
+      return t.type = r.type, t.activeIntervals = [], t;
+    }
+    return r.prototype.getAreaSelectStyle = function() {
+      return p([
+        ["fill", "color"],
+        ["lineWidth", "borderWidth"],
+        ["stroke", "borderColor"],
+        ["width", "width"],
+        ["opacity", "opacity"]
+        // Option decal is in `DecalObject` but style.decal is in `PatternObject`.
+        // So do not transfer decal directly.
+      ])(this.getModel("areaSelectStyle"));
+    }, r.prototype.setActiveIntervals = function(t) {
+      var e = this.activeIntervals = c(t);
+      if (e)
+        for (var i = e.length - 1; i >= 0; i--)
+          m(e[i]);
+    }, r.prototype.getActiveState = function(t) {
+      var e = this.activeIntervals;
+      if (!e.length)
+        return "normal";
+      if (t == null || isNaN(+t))
+        return "inactive";
+      if (e.length === 1) {
+        var i = e[0];
+        if (i[0] <= t && t <= i[1])
+          return "active";
+      } else
+        for (var o = 0, a = e.length; o < a; o++)
+          if (e[o][0] <= t && t <= e[o][1])
+            return "active";
+      return "inactive";
+    }, r;
+  })(s)
+);
+f(h, v);
+export {
+  h as default
+};

package/dist/node_modules/echarts/lib/coord/parallel/Parallel.js

@@ -0,0 +1,180 @@
+import { createHashMap as M, each as E, clone as b } from "../../../../zrender/lib/core/util.js";
+import { rotate as C, create as P, translate as S } from "../../../../zrender/lib/core/matrix.js";
+import { getLayoutRect as I } from "../../util/layout.js";
+import { createScaleByModel as B, niceScaleExtent as D } from "../axisHelper.js";
+import T from "./ParallelAxis.js";
+import { applyTransform as k } from "../../util/graphic.js";
+import { round as N } from "../../util/number.js";
+import F from "../../component/helper/sliderMove.js";
+var f = E, _ = Math.min, A = Math.max, g = Math.floor, z = Math.ceil, W = N, H = Math.PI, X = (
+  /** @class */
+  (function() {
+    function l(a, t, p) {
+      this.type = "parallel", this._axesMap = M(), this._axesLayout = {}, this.dimensions = a.dimensions, this._model = a, this._init(a, t, p);
+    }
+    return l.prototype._init = function(a, t, p) {
+      var i = a.dimensions, e = a.parallelAxisIndex;
+      f(i, function(n, o) {
+        var r = e[o], h = t.getComponent("parallelAxis", r), s = this._axesMap.set(n, new T(n, B(h), [0, 0], h.get("type"), r)), d = s.type === "category";
+        s.onBand = d && h.get("boundaryGap"), s.inverse = h.get("inverse"), h.axis = s, s.model = h, s.coordinateSystem = h.coordinateSystem = this;
+      }, this);
+    }, l.prototype.update = function(a, t) {
+      this._updateAxesFromSeries(this._model, a);
+    }, l.prototype.containPoint = function(a) {
+      var t = this._makeLayoutInfo(), p = t.axisBase, i = t.layoutBase, e = t.pixelDimIndex, n = a[1 - e], o = a[e];
+      return n >= p && n <= p + t.axisLength && o >= i && o <= i + t.layoutLength;
+    }, l.prototype.getModel = function() {
+      return this._model;
+    }, l.prototype._updateAxesFromSeries = function(a, t) {
+      t.eachSeries(function(p) {
+        if (a.contains(p, t)) {
+          var i = p.getData();
+          f(this.dimensions, function(e) {
+            var n = this._axesMap.get(e);
+            n.scale.unionExtentFromData(i, i.mapDimension(e)), D(n.scale, n.model);
+          }, this);
+        }
+      }, this);
+    }, l.prototype.resize = function(a, t) {
+      this._rect = I(a.getBoxLayoutParams(), {
+        width: t.getWidth(),
+        height: t.getHeight()
+      }), this._layoutAxes();
+    }, l.prototype.getRect = function() {
+      return this._rect;
+    }, l.prototype._makeLayoutInfo = function() {
+      var a = this._model, t = this._rect, p = ["x", "y"], i = ["width", "height"], e = a.get("layout"), n = e === "horizontal" ? 0 : 1, o = t[i[n]], r = [0, o], h = this.dimensions.length, s = c(a.get("axisExpandWidth"), r), d = c(a.get("axisExpandCount") || 0, [0, h]), u = a.get("axisExpandable") && h > 3 && h > d && d > 1 && s > 0 && o > 0, x = a.get("axisExpandWindow"), v;
+      if (x)
+        v = c(x[1] - x[0], r), x[1] = x[0] + v;
+      else {
+        v = c(s * (d - 1), r);
+        var y = a.get("axisExpandCenter") || g(h / 2);
+        x = [s * y - v / 2], x[1] = x[0] + v;
+      }
+      var m = (o - v) / (h - d);
+      m < 3 && (m = 0);
+      var L = [g(W(x[0] / s, 1)) + 1, z(W(x[1] / s, 1)) - 1], w = m / s * x[0];
+      return {
+        layout: e,
+        pixelDimIndex: n,
+        layoutBase: t[p[n]],
+        layoutLength: o,
+        axisBase: t[p[1 - n]],
+        axisLength: t[i[1 - n]],
+        axisExpandable: u,
+        axisExpandWidth: s,
+        axisCollapseWidth: m,
+        axisExpandWindow: x,
+        axisCount: h,
+        winInnerIndices: L,
+        axisExpandWindow0Pos: w
+      };
+    }, l.prototype._layoutAxes = function() {
+      var a = this._rect, t = this._axesMap, p = this.dimensions, i = this._makeLayoutInfo(), e = i.layout;
+      t.each(function(n) {
+        var o = [0, i.axisLength], r = n.inverse ? 1 : 0;
+        n.setExtent(o[r], o[1 - r]);
+      }), f(p, function(n, o) {
+        var r = (i.axisExpandable ? $ : R)(o, i), h = {
+          horizontal: {
+            x: r.position,
+            y: i.axisLength
+          },
+          vertical: {
+            x: 0,
+            y: r.position
+          }
+        }, s = {
+          horizontal: H / 2,
+          vertical: 0
+        }, d = [h[e].x + a.x, h[e].y + a.y], u = s[e], x = P();
+        C(x, x, u), S(x, x, d), this._axesLayout[n] = {
+          position: d,
+          rotation: u,
+          transform: x,
+          axisNameAvailableWidth: r.axisNameAvailableWidth,
+          axisLabelShow: r.axisLabelShow,
+          nameTruncateMaxWidth: r.nameTruncateMaxWidth,
+          tickDirection: 1,
+          labelDirection: 1
+        };
+      }, this);
+    }, l.prototype.getAxis = function(a) {
+      return this._axesMap.get(a);
+    }, l.prototype.dataToPoint = function(a, t) {
+      return this.axisCoordToPoint(this._axesMap.get(t).dataToCoord(a), t);
+    }, l.prototype.eachActiveState = function(a, t, p, i) {
+      p == null && (p = 0), i == null && (i = a.count());
+      var e = this._axesMap, n = this.dimensions, o = [], r = [];
+      E(n, function(m) {
+        o.push(a.mapDimension(m)), r.push(e.get(m).model);
+      });
+      for (var h = this.hasAxisBrushed(), s = p; s < i; s++) {
+        var d = void 0;
+        if (!h)
+          d = "normal";
+        else {
+          d = "active";
+          for (var u = a.getValues(o, s), x = 0, v = n.length; x < v; x++) {
+            var y = r[x].getActiveState(u[x]);
+            if (y === "inactive") {
+              d = "inactive";
+              break;
+            }
+          }
+        }
+        t(d, s);
+      }
+    }, l.prototype.hasAxisBrushed = function() {
+      for (var a = this.dimensions, t = this._axesMap, p = !1, i = 0, e = a.length; i < e; i++)
+        t.get(a[i]).model.getActiveState() !== "normal" && (p = !0);
+      return p;
+    }, l.prototype.axisCoordToPoint = function(a, t) {
+      var p = this._axesLayout[t];
+      return k([a, 0], p.transform);
+    }, l.prototype.getAxisLayout = function(a) {
+      return b(this._axesLayout[a]);
+    }, l.prototype.getSlidedAxisExpandWindow = function(a) {
+      var t = this._makeLayoutInfo(), p = t.pixelDimIndex, i = t.axisExpandWindow.slice(), e = i[1] - i[0], n = [0, t.axisExpandWidth * (t.axisCount - 1)];
+      if (!this.containPoint(a))
+        return {
+          behavior: "none",
+          axisExpandWindow: i
+        };
+      var o = a[p] - t.layoutBase - t.axisExpandWindow0Pos, r, h = "slide", s = t.axisCollapseWidth, d = this._model.get("axisExpandSlideTriggerArea"), u = d[0] != null;
+      if (s)
+        u && s && o < e * d[0] ? (h = "jump", r = o - e * d[2]) : u && s && o > e * (1 - d[0]) ? (h = "jump", r = o - e * (1 - d[2])) : (r = o - e * d[1]) >= 0 && (r = o - e * (1 - d[1])) <= 0 && (r = 0), r *= t.axisExpandWidth / s, r ? F(r, i, n, "all") : h = "none";
+      else {
+        var x = i[1] - i[0], v = n[1] * o / x;
+        i = [A(0, v - x / 2)], i[1] = _(n[1], i[0] + x), i[0] = i[1] - x;
+      }
+      return {
+        axisExpandWindow: i,
+        behavior: h
+      };
+    }, l;
+  })()
+);
+function c(l, a) {
+  return _(A(l, a[0]), a[1]);
+}
+function R(l, a) {
+  var t = a.layoutLength / (a.axisCount - 1);
+  return {
+    position: t * l,
+    axisNameAvailableWidth: t,
+    axisLabelShow: !0
+  };
+}
+function $(l, a) {
+  var t = a.layoutLength, p = a.axisExpandWidth, i = a.axisCount, e = a.axisCollapseWidth, n = a.winInnerIndices, o, r = e, h = !1, s;
+  return l < n[0] ? (o = l * e, s = e) : l <= n[1] ? (o = a.axisExpandWindow0Pos + l * p - a.axisExpandWindow[0], r = p, h = !0) : (o = t - (i - 1 - l) * e, s = e), {
+    position: o,
+    axisNameAvailableWidth: r,
+    axisLabelShow: h,
+    nameTruncateMaxWidth: s
+  };
+}
+export {
+  X as default
+};

package/dist/node_modules/echarts/lib/coord/parallel/ParallelAxis.js

@@ -0,0 +1,18 @@
+import { __extends as s } from "../../../../tslib/tslib.es6.js";
+import u from "../Axis.js";
+var c = (
+  /** @class */
+  (function(r) {
+    s(t, r);
+    function t(e, i, a, l, n) {
+      var o = r.call(this, e, i, a) || this;
+      return o.type = l || "value", o.axisIndex = n, o;
+    }
+    return t.prototype.isHorizontal = function() {
+      return this.coordinateSystem.getModel().get("layout") !== "horizontal";
+    }, t;
+  })(u)
+);
+export {
+  c as default
+};

package/dist/node_modules/echarts/lib/coord/parallel/ParallelModel.js

@@ -0,0 +1,61 @@
+import { __extends as p } from "../../../../tslib/tslib.es6.js";
+import { merge as r, each as l, filter as s } from "../../../../zrender/lib/core/util.js";
+import x from "../../model/Component.js";
+var m = (
+  /** @class */
+  (function(i) {
+    p(t, i);
+    function t() {
+      var n = i !== null && i.apply(this, arguments) || this;
+      return n.type = t.type, n;
+    }
+    return t.prototype.init = function() {
+      i.prototype.init.apply(this, arguments), this.mergeOption({});
+    }, t.prototype.mergeOption = function(n) {
+      var e = this.option;
+      n && r(e, n, !0), this._initDimensions();
+    }, t.prototype.contains = function(n, e) {
+      var a = n.get("parallelIndex");
+      return a != null && e.getComponent("parallel", a) === this;
+    }, t.prototype.setAxisExpand = function(n) {
+      l(["axisExpandable", "axisExpandCenter", "axisExpandCount", "axisExpandWidth", "axisExpandWindow"], function(e) {
+        n.hasOwnProperty(e) && (this.option[e] = n[e]);
+      }, this);
+    }, t.prototype._initDimensions = function() {
+      var n = this.dimensions = [], e = this.parallelAxisIndex = [], a = s(this.ecModel.queryComponents({
+        mainType: "parallelAxis"
+      }), function(o) {
+        return (o.get("parallelIndex") || 0) === this.componentIndex;
+      }, this);
+      l(a, function(o) {
+        n.push("dim" + o.get("dim")), e.push(o.componentIndex);
+      });
+    }, t.type = "parallel", t.dependencies = ["parallelAxis"], t.layoutMode = "box", t.defaultOption = {
+      // zlevel: 0,
+      z: 0,
+      left: 80,
+      top: 60,
+      right: 80,
+      bottom: 60,
+      // width: {totalWidth} - left - right,
+      // height: {totalHeight} - top - bottom,
+      layout: "horizontal",
+      // FIXME
+      // naming?
+      axisExpandable: !1,
+      axisExpandCenter: null,
+      axisExpandCount: 0,
+      axisExpandWidth: 50,
+      axisExpandRate: 17,
+      axisExpandDebounce: 50,
+      // [out, in, jumpTarget]. In percentage. If use [null, 0.05], null means full.
+      // Do not doc to user until necessary.
+      axisExpandSlideTriggerArea: [-0.15, 0.05, 0.4],
+      axisExpandTriggerOn: "click",
+      parallelAxisDefault: null
+    }, t;
+  })(x)
+);
+export {
+  m as default
+};

package/dist/node_modules/echarts/lib/coord/parallel/parallelCreator.js

@@ -0,0 +1,20 @@
+import m from "./Parallel.js";
+import { SINGLE_REFERRING as c } from "../../util/model.js";
+function i(t, e) {
+  var n = [];
+  return t.eachComponent("parallel", function(r, a) {
+    var o = new m(r, t, e);
+    o.name = "parallel_" + a, o.resize(r, e), r.coordinateSystem = o, o.model = r, n.push(o);
+  }), t.eachSeries(function(r) {
+    if (r.get("coordinateSystem") === "parallel") {
+      var a = r.getReferringComponents("parallel", c).models[0];
+      r.coordinateSystem = a.coordinateSystem;
+    }
+  }), n;
+}
+var f = {
+  create: i
+};
+export {
+  f as default
+};

package/dist/node_modules/echarts/lib/coord/parallel/parallelPreprocessor.js

@@ -0,0 +1,25 @@
+import { each as i, isObject as n, merge as p } from "../../../../zrender/lib/core/util.js";
+import { normalizeToArray as f } from "../../util/model.js";
+function o(l) {
+  s(l), u(l);
+}
+function s(l) {
+  if (!l.parallel) {
+    var a = !1;
+    i(l.series, function(e) {
+      e && e.type === "parallel" && (a = !0);
+    }), a && (l.parallel = [{}]);
+  }
+}
+function u(l) {
+  var a = f(l.parallelAxis);
+  i(a, function(e) {
+    if (n(e)) {
+      var t = e.parallelIndex || 0, r = f(l.parallel)[t];
+      r && r.parallelAxisDefault && p(e, r.parallelAxisDefault, !1);
+    }
+  });
+}
+export {
+  o as default
+};

package/dist/node_modules/echarts/lib/coord/polar/AngleAxis.js

@@ -0,0 +1,29 @@
+import { __extends as T } from "../../../../tslib/tslib.es6.js";
+import { getBoundingRect as A } from "../../../../zrender/lib/contain/text.js";
+import s from "../Axis.js";
+import { makeInner as y } from "../../util/model.js";
+var C = y(), h = (
+  /** @class */
+  (function(v) {
+    T(r, v);
+    function r(t, a) {
+      return v.call(this, "angle", t, a || [0, 360]) || this;
+    }
+    return r.prototype.pointToData = function(t, a) {
+      return this.polar.pointToData(t, a)[this.dim === "radius" ? 0 : 1];
+    }, r.prototype.calculateCategoryInterval = function() {
+      var t = this, a = t.getLabelModel(), c = t.scale, i = c.getExtent(), p = c.count();
+      if (i[1] - i[0] < 1)
+        return 0;
+      var e = i[0], m = t.dataToCoord(e + 1) - t.dataToCoord(e), f = Math.abs(m), g = A(e == null ? "" : e + "", a.getFont(), "center", "top"), x = Math.max(g.height, 7), u = x / f;
+      isNaN(u) && (u = 1 / 0);
+      var o = Math.max(0, Math.floor(u)), n = C(t.model), l = n.lastAutoInterval, d = n.lastTickCount;
+      return l != null && d != null && Math.abs(l - o) <= 1 && Math.abs(d - p) <= 1 && l > o ? o = l : (n.lastTickCount = p, n.lastAutoInterval = o), o;
+    }, r;
+  })(s)
+);
+h.prototype.dataToAngle = s.prototype.dataToCoord;
+h.prototype.angleToData = s.prototype.coordToData;
+export {
+  h as default
+};