qaema-ui 0.0.1

package/dist/node_modules/recharts/es6/polar/Pie.js

@@ -0,0 +1,464 @@
+import g, { PureComponent as oe } from "react";
+import se from "../../../react-smooth/es6/Animate.js";
+import le from "../../../../_virtual/get.js";
+import ce from "../../../../_virtual/isEqual.js";
+import D from "../../../../_virtual/isNil.js";
+import N from "../../../../_virtual/isFunction.js";
+import { clsx as U } from "../../../clsx/dist/clsx.js";
+import { Layer as B } from "../container/Layer.js";
+import { Curve as ue } from "../shape/Curve.js";
+import { Text as fe } from "../component/Text.js";
+import { Label as de } from "../component/Label.js";
+import { LabelList as me } from "../component/LabelList.js";
+import { Cell as pe } from "../component/Cell.js";
+import { filterProps as V, findAllByType as ve } from "../util/ReactUtils.js";
+import { Global as he } from "../util/Global.js";
+import { polarToCartesian as z, getMaxRadius as Ae } from "../util/PolarUtils.js";
+import { interpolateNumber as X, isNumber as T, uniqueId as ge, mathSign as q, getPercentValue as $ } from "../util/DataUtils.js";
+import { getValueByDataKey as j } from "../util/ChartUtils.js";
+import { warn as Y } from "../util/LogUtils.js";
+import { adaptEventsOfChild as be } from "../util/types.js";
+import { Shape as ye } from "../util/ActiveShapeUtils.js";
+var H;
+function L(r) {
+  "@babel/helpers - typeof";
+  return L = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(n) {
+    return typeof n;
+  } : function(n) {
+    return n && typeof Symbol == "function" && n.constructor === Symbol && n !== Symbol.prototype ? "symbol" : typeof n;
+  }, L(r);
+}
+function K() {
+  return K = Object.assign ? Object.assign.bind() : function(r) {
+    for (var n = 1; n < arguments.length; n++) {
+      var i = arguments[n];
+      for (var e in i)
+        Object.prototype.hasOwnProperty.call(i, e) && (r[e] = i[e]);
+    }
+    return r;
+  }, K.apply(this, arguments);
+}
+function ee(r, n) {
+  var i = Object.keys(r);
+  if (Object.getOwnPropertySymbols) {
+    var e = Object.getOwnPropertySymbols(r);
+    n && (e = e.filter(function(t) {
+      return Object.getOwnPropertyDescriptor(r, t).enumerable;
+    })), i.push.apply(i, e);
+  }
+  return i;
+}
+function c(r) {
+  for (var n = 1; n < arguments.length; n++) {
+    var i = arguments[n] != null ? arguments[n] : {};
+    n % 2 ? ee(Object(i), !0).forEach(function(e) {
+      y(r, e, i[e]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(r, Object.getOwnPropertyDescriptors(i)) : ee(Object(i)).forEach(function(e) {
+      Object.defineProperty(r, e, Object.getOwnPropertyDescriptor(i, e));
+    });
+  }
+  return r;
+}
+function Se(r, n) {
+  if (!(r instanceof n))
+    throw new TypeError("Cannot call a class as a function");
+}
+function te(r, n) {
+  for (var i = 0; i < n.length; i++) {
+    var e = n[i];
+    e.enumerable = e.enumerable || !1, e.configurable = !0, "value" in e && (e.writable = !0), Object.defineProperty(r, re(e.key), e);
+  }
+}
+function Re(r, n, i) {
+  return n && te(r.prototype, n), i && te(r, i), Object.defineProperty(r, "prototype", { writable: !1 }), r;
+}
+function Oe(r, n, i) {
+  return n = W(n), Pe(r, ne() ? Reflect.construct(n, i || [], W(r).constructor) : n.apply(r, i));
+}
+function Pe(r, n) {
+  if (n && (L(n) === "object" || typeof n == "function"))
+    return n;
+  if (n !== void 0)
+    throw new TypeError("Derived constructors may only return object or undefined");
+  return Ie(r);
+}
+function Ie(r) {
+  if (r === void 0)
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return r;
+}
+function ne() {
+  try {
+    var r = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+  } catch {
+  }
+  return (ne = function() {
+    return !!r;
+  })();
+}
+function W(r) {
+  return W = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(i) {
+    return i.__proto__ || Object.getPrototypeOf(i);
+  }, W(r);
+}
+function _e(r, n) {
+  if (typeof n != "function" && n !== null)
+    throw new TypeError("Super expression must either be null or a function");
+  r.prototype = Object.create(n && n.prototype, { constructor: { value: r, writable: !0, configurable: !0 } }), Object.defineProperty(r, "prototype", { writable: !1 }), n && G(r, n);
+}
+function G(r, n) {
+  return G = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(e, t) {
+    return e.__proto__ = t, e;
+  }, G(r, n);
+}
+function y(r, n, i) {
+  return n = re(n), n in r ? Object.defineProperty(r, n, { value: i, enumerable: !0, configurable: !0, writable: !0 }) : r[n] = i, r;
+}
+function re(r) {
+  var n = Ee(r, "string");
+  return L(n) == "symbol" ? n : n + "";
+}
+function Ee(r, n) {
+  if (L(r) != "object" || !r) return r;
+  var i = r[Symbol.toPrimitive];
+  if (i !== void 0) {
+    var e = i.call(r, n);
+    if (L(e) != "object") return e;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(r);
+}
+var w = /* @__PURE__ */ (function(r) {
+  function n(i) {
+    var e;
+    return Se(this, n), e = Oe(this, n, [i]), y(e, "pieRef", null), y(e, "sectorRefs", []), y(e, "id", ge("recharts-pie-")), y(e, "handleAnimationEnd", function() {
+      var t = e.props.onAnimationEnd;
+      e.setState({
+        isAnimationFinished: !0
+      }), N(t) && t();
+    }), y(e, "handleAnimationStart", function() {
+      var t = e.props.onAnimationStart;
+      e.setState({
+        isAnimationFinished: !1
+      }), N(t) && t();
+    }), e.state = {
+      isAnimationFinished: !i.isAnimationActive,
+      prevIsAnimationActive: i.isAnimationActive,
+      prevAnimationId: i.animationId,
+      sectorToFocus: 0
+    }, e;
+  }
+  return _e(n, r), Re(n, [{
+    key: "isActiveIndex",
+    value: function(e) {
+      var t = this.props.activeIndex;
+      return Array.isArray(t) ? t.indexOf(e) !== -1 : e === t;
+    }
+  }, {
+    key: "hasActiveIndex",
+    value: function() {
+      var e = this.props.activeIndex;
+      return Array.isArray(e) ? e.length !== 0 : e || e === 0;
+    }
+  }, {
+    key: "renderLabels",
+    value: function(e) {
+      var t = this.props.isAnimationActive;
+      if (t && !this.state.isAnimationFinished)
+        return null;
+      var a = this.props, o = a.label, u = a.labelLine, f = a.dataKey, s = a.valueKey, m = V(this.props, !1), p = V(o, !1), R = V(u, !1), O = o && o.offsetRadius || 20, v = e.map(function(l, d) {
+        var h = (l.startAngle + l.endAngle) / 2, A = z(l.cx, l.cy, l.outerRadius + O, h), S = c(c(c(c({}, m), l), {}, {
+          stroke: "none"
+        }, p), {}, {
+          index: d,
+          textAnchor: n.getTextAnchor(A.x, l.cx)
+        }, A), x = c(c(c(c({}, m), l), {}, {
+          fill: "none",
+          stroke: l.fill
+        }, R), {}, {
+          index: d,
+          points: [z(l.cx, l.cy, l.outerRadius, h), A]
+        }), P = f;
+        return D(f) && D(s) ? P = "value" : D(f) && (P = s), // eslint-disable-next-line react/no-array-index-key
+        /* @__PURE__ */ g.createElement(B, {
+          key: "label-".concat(l.startAngle, "-").concat(l.endAngle, "-").concat(l.midAngle, "-").concat(d)
+        }, u && n.renderLabelLineItem(u, x, "line"), n.renderLabelItem(o, S, j(l, P)));
+      });
+      return /* @__PURE__ */ g.createElement(B, {
+        className: "recharts-pie-labels"
+      }, v);
+    }
+  }, {
+    key: "renderSectorsStatically",
+    value: function(e) {
+      var t = this, a = this.props, o = a.activeShape, u = a.blendStroke, f = a.inactiveShape;
+      return e.map(function(s, m) {
+        if ((s == null ? void 0 : s.startAngle) === 0 && (s == null ? void 0 : s.endAngle) === 0 && e.length !== 1) return null;
+        var p = t.isActiveIndex(m), R = f && t.hasActiveIndex() ? f : null, O = p ? o : R, v = c(c({}, s), {}, {
+          stroke: u ? s.fill : s.stroke,
+          tabIndex: -1
+        });
+        return /* @__PURE__ */ g.createElement(B, K({
+          ref: function(d) {
+            d && !t.sectorRefs.includes(d) && t.sectorRefs.push(d);
+          },
+          tabIndex: -1,
+          className: "recharts-pie-sector"
+        }, be(t.props, s, m), {
+          // eslint-disable-next-line react/no-array-index-key
+          key: "sector-".concat(s == null ? void 0 : s.startAngle, "-").concat(s == null ? void 0 : s.endAngle, "-").concat(s.midAngle, "-").concat(m)
+        }), /* @__PURE__ */ g.createElement(ye, K({
+          option: O,
+          isActive: p,
+          shapeType: "sector"
+        }, v)));
+      });
+    }
+  }, {
+    key: "renderSectorsWithAnimation",
+    value: function() {
+      var e = this, t = this.props, a = t.sectors, o = t.isAnimationActive, u = t.animationBegin, f = t.animationDuration, s = t.animationEasing, m = t.animationId, p = this.state, R = p.prevSectors, O = p.prevIsAnimationActive;
+      return /* @__PURE__ */ g.createElement(se, {
+        begin: u,
+        duration: f,
+        isActive: o,
+        easing: s,
+        from: {
+          t: 0
+        },
+        to: {
+          t: 1
+        },
+        key: "pie-".concat(m, "-").concat(O),
+        onAnimationStart: this.handleAnimationStart,
+        onAnimationEnd: this.handleAnimationEnd
+      }, function(v) {
+        var l = v.t, d = [], h = a && a[0], A = h.startAngle;
+        return a.forEach(function(S, x) {
+          var P = R && R[x], E = x > 0 ? le(S, "paddingAngle", 0) : 0;
+          if (P) {
+            var F = X(P.endAngle - P.startAngle, S.endAngle - S.startAngle), b = c(c({}, S), {}, {
+              startAngle: A + E,
+              endAngle: A + F(l) + E
+            });
+            d.push(b), A = b.endAngle;
+          } else {
+            var k = S.endAngle, I = S.startAngle, C = X(0, k - I), M = C(l), _ = c(c({}, S), {}, {
+              startAngle: A + E,
+              endAngle: A + M + E
+            });
+            d.push(_), A = _.endAngle;
+          }
+        }), /* @__PURE__ */ g.createElement(B, null, e.renderSectorsStatically(d));
+      });
+    }
+  }, {
+    key: "attachKeyboardHandlers",
+    value: function(e) {
+      var t = this;
+      e.onkeydown = function(a) {
+        if (!a.altKey)
+          switch (a.key) {
+            case "ArrowLeft": {
+              var o = ++t.state.sectorToFocus % t.sectorRefs.length;
+              t.sectorRefs[o].focus(), t.setState({
+                sectorToFocus: o
+              });
+              break;
+            }
+            case "ArrowRight": {
+              var u = --t.state.sectorToFocus < 0 ? t.sectorRefs.length - 1 : t.state.sectorToFocus % t.sectorRefs.length;
+              t.sectorRefs[u].focus(), t.setState({
+                sectorToFocus: u
+              });
+              break;
+            }
+            case "Escape": {
+              t.sectorRefs[t.state.sectorToFocus].blur(), t.setState({
+                sectorToFocus: 0
+              });
+              break;
+            }
+          }
+      };
+    }
+  }, {
+    key: "renderSectors",
+    value: function() {
+      var e = this.props, t = e.sectors, a = e.isAnimationActive, o = this.state.prevSectors;
+      return a && t && t.length && (!o || !ce(o, t)) ? this.renderSectorsWithAnimation() : this.renderSectorsStatically(t);
+    }
+  }, {
+    key: "componentDidMount",
+    value: function() {
+      this.pieRef && this.attachKeyboardHandlers(this.pieRef);
+    }
+  }, {
+    key: "render",
+    value: function() {
+      var e = this, t = this.props, a = t.hide, o = t.sectors, u = t.className, f = t.label, s = t.cx, m = t.cy, p = t.innerRadius, R = t.outerRadius, O = t.isAnimationActive, v = this.state.isAnimationFinished;
+      if (a || !o || !o.length || !T(s) || !T(m) || !T(p) || !T(R))
+        return null;
+      var l = U("recharts-pie", u);
+      return /* @__PURE__ */ g.createElement(B, {
+        tabIndex: this.props.rootTabIndex,
+        className: l,
+        ref: function(h) {
+          e.pieRef = h;
+        }
+      }, this.renderSectors(), f && this.renderLabels(o), de.renderCallByParent(this.props, null, !1), (!O || v) && me.renderCallByParent(this.props, o, !1));
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function(e, t) {
+      return t.prevIsAnimationActive !== e.isAnimationActive ? {
+        prevIsAnimationActive: e.isAnimationActive,
+        prevAnimationId: e.animationId,
+        curSectors: e.sectors,
+        prevSectors: [],
+        isAnimationFinished: !0
+      } : e.isAnimationActive && e.animationId !== t.prevAnimationId ? {
+        prevAnimationId: e.animationId,
+        curSectors: e.sectors,
+        prevSectors: t.curSectors,
+        isAnimationFinished: !0
+      } : e.sectors !== t.curSectors ? {
+        curSectors: e.sectors,
+        isAnimationFinished: !0
+      } : null;
+    }
+  }, {
+    key: "getTextAnchor",
+    value: function(e, t) {
+      return e > t ? "start" : e < t ? "end" : "middle";
+    }
+  }, {
+    key: "renderLabelLineItem",
+    value: function(e, t, a) {
+      if (/* @__PURE__ */ g.isValidElement(e))
+        return /* @__PURE__ */ g.cloneElement(e, t);
+      if (N(e))
+        return e(t);
+      var o = U("recharts-pie-label-line", typeof e != "boolean" ? e.className : "");
+      return /* @__PURE__ */ g.createElement(ue, K({}, t, {
+        key: a,
+        type: "linear",
+        className: o
+      }));
+    }
+  }, {
+    key: "renderLabelItem",
+    value: function(e, t, a) {
+      if (/* @__PURE__ */ g.isValidElement(e))
+        return /* @__PURE__ */ g.cloneElement(e, t);
+      var o = a;
+      if (N(e) && (o = e(t), /* @__PURE__ */ g.isValidElement(o)))
+        return o;
+      var u = U("recharts-pie-label-text", typeof e != "boolean" && !N(e) ? e.className : "");
+      return /* @__PURE__ */ g.createElement(fe, K({}, t, {
+        alignmentBaseline: "middle",
+        className: u
+      }), o);
+    }
+  }]);
+})(oe);
+H = w;
+y(w, "displayName", "Pie");
+y(w, "defaultProps", {
+  stroke: "#fff",
+  fill: "#808080",
+  legendType: "rect",
+  cx: "50%",
+  cy: "50%",
+  startAngle: 0,
+  endAngle: 360,
+  innerRadius: 0,
+  outerRadius: "80%",
+  paddingAngle: 0,
+  labelLine: !0,
+  hide: !1,
+  minAngle: 0,
+  isAnimationActive: !he.isSsr,
+  animationBegin: 400,
+  animationDuration: 1500,
+  animationEasing: "ease",
+  nameKey: "name",
+  blendStroke: !1,
+  rootTabIndex: 0
+});
+y(w, "parseDeltaAngle", function(r, n) {
+  var i = q(n - r), e = Math.min(Math.abs(n - r), 360);
+  return i * e;
+});
+y(w, "getRealPieData", function(r) {
+  var n = r.data, i = r.children, e = V(r, !1), t = ve(i, pe);
+  return n && n.length ? n.map(function(a, o) {
+    return c(c(c({
+      payload: a
+    }, e), a), t && t[o] && t[o].props);
+  }) : t && t.length ? t.map(function(a) {
+    return c(c({}, e), a.props);
+  }) : [];
+});
+y(w, "parseCoordinateOfPie", function(r, n) {
+  var i = n.top, e = n.left, t = n.width, a = n.height, o = Ae(t, a), u = e + $(r.cx, t, t / 2), f = i + $(r.cy, a, a / 2), s = $(r.innerRadius, o, 0), m = $(r.outerRadius, o, o * 0.8), p = r.maxRadius || Math.sqrt(t * t + a * a) / 2;
+  return {
+    cx: u,
+    cy: f,
+    innerRadius: s,
+    outerRadius: m,
+    maxRadius: p
+  };
+});
+y(w, "getComposedData", function(r) {
+  var n = r.item, i = r.offset, e = n.type.defaultProps !== void 0 ? c(c({}, n.type.defaultProps), n.props) : n.props, t = H.getRealPieData(e);
+  if (!t || !t.length)
+    return null;
+  var a = e.cornerRadius, o = e.startAngle, u = e.endAngle, f = e.paddingAngle, s = e.dataKey, m = e.nameKey, p = e.valueKey, R = e.tooltipType, O = Math.abs(e.minAngle), v = H.parseCoordinateOfPie(e, i), l = H.parseDeltaAngle(o, u), d = Math.abs(l), h = s;
+  D(s) && D(p) ? (Y(!1, `Use "dataKey" to specify the value of pie,
+      the props "valueKey" will be deprecated in 1.1.0`), h = "value") : D(s) && (Y(!1, `Use "dataKey" to specify the value of pie,
+      the props "valueKey" will be deprecated in 1.1.0`), h = p);
+  var A = t.filter(function(b) {
+    return j(b, h, 0) !== 0;
+  }).length, S = (d >= 360 ? A : A - 1) * f, x = d - A * O - S, P = t.reduce(function(b, k) {
+    var I = j(k, h, 0);
+    return b + (T(I) ? I : 0);
+  }, 0), E;
+  if (P > 0) {
+    var F;
+    E = t.map(function(b, k) {
+      var I = j(b, h, 0), C = j(b, m, k), M = (T(I) ? I : 0) / P, _;
+      k ? _ = F.endAngle + q(l) * f * (I !== 0 ? 1 : 0) : _ = o;
+      var Z = _ + q(l) * ((I !== 0 ? O : 0) + M * x), J = (_ + Z) / 2, Q = (v.innerRadius + v.outerRadius) / 2, ie = [{
+        name: C,
+        value: I,
+        payload: b,
+        dataKey: h,
+        type: R
+      }], ae = z(v.cx, v.cy, Q, J);
+      return F = c(c(c({
+        percent: M,
+        cornerRadius: a,
+        name: C,
+        tooltipPayload: ie,
+        midAngle: J,
+        middleRadius: Q,
+        tooltipPosition: ae
+      }, b), v), {}, {
+        value: j(b, h),
+        startAngle: _,
+        endAngle: Z,
+        payload: b,
+        paddingAngle: q(l) * f
+      }), F;
+    });
+  }
+  return c(c({}, v), {}, {
+    sectors: E,
+    data: t
+  });
+});
+export {
+  w as Pie
+};

package/dist/node_modules/recharts/es6/polar/PolarAngleAxis.js

@@ -0,0 +1,242 @@
+import c, { PureComponent as z } from "react";
+import C from "../../../../_virtual/isFunction.js";
+import { clsx as w } from "../../../clsx/dist/clsx.js";
+import { Layer as P } from "../container/Layer.js";
+import { Dot as $ } from "../shape/Dot.js";
+import { Polygon as F } from "../shape/Polygon.js";
+import { Text as B } from "../component/Text.js";
+import { adaptEventsOfChild as K } from "../util/types.js";
+import { filterProps as d } from "../util/ReactUtils.js";
+import { polarToCartesian as _, getTickClassName as M } from "../util/PolarUtils.js";
+function b(t) {
+  "@babel/helpers - typeof";
+  return b = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(e) {
+    return typeof e;
+  } : function(e) {
+    return e && typeof Symbol == "function" && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e;
+  }, b(t);
+}
+function f() {
+  return f = Object.assign ? Object.assign.bind() : function(t) {
+    for (var e = 1; e < arguments.length; e++) {
+      var n = arguments[e];
+      for (var r in n)
+        Object.prototype.hasOwnProperty.call(n, r) && (t[r] = n[r]);
+    }
+    return t;
+  }, f.apply(this, arguments);
+}
+function A(t, e) {
+  var n = Object.keys(t);
+  if (Object.getOwnPropertySymbols) {
+    var r = Object.getOwnPropertySymbols(t);
+    e && (r = r.filter(function(i) {
+      return Object.getOwnPropertyDescriptor(t, i).enumerable;
+    })), n.push.apply(n, r);
+  }
+  return n;
+}
+function u(t) {
+  for (var e = 1; e < arguments.length; e++) {
+    var n = arguments[e] != null ? arguments[e] : {};
+    e % 2 ? A(Object(n), !0).forEach(function(r) {
+      x(t, r, n[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(t, Object.getOwnPropertyDescriptors(n)) : A(Object(n)).forEach(function(r) {
+      Object.defineProperty(t, r, Object.getOwnPropertyDescriptor(n, r));
+    });
+  }
+  return t;
+}
+function V(t, e) {
+  if (!(t instanceof e))
+    throw new TypeError("Cannot call a class as a function");
+}
+function L(t, e) {
+  for (var n = 0; n < e.length; n++) {
+    var r = e[n];
+    r.enumerable = r.enumerable || !1, r.configurable = !0, "value" in r && (r.writable = !0), Object.defineProperty(t, N(r.key), r);
+  }
+}
+function q(t, e, n) {
+  return e && L(t.prototype, e), n && L(t, n), Object.defineProperty(t, "prototype", { writable: !1 }), t;
+}
+function G(t, e, n) {
+  return e = g(e), H(t, S() ? Reflect.construct(e, n || [], g(t).constructor) : e.apply(t, n));
+}
+function H(t, e) {
+  if (e && (b(e) === "object" || typeof e == "function"))
+    return e;
+  if (e !== void 0)
+    throw new TypeError("Derived constructors may only return object or undefined");
+  return J(t);
+}
+function J(t) {
+  if (t === void 0)
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return t;
+}
+function S() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+  } catch {
+  }
+  return (S = function() {
+    return !!t;
+  })();
+}
+function g(t) {
+  return g = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(n) {
+    return n.__proto__ || Object.getPrototypeOf(n);
+  }, g(t);
+}
+function Q(t, e) {
+  if (typeof e != "function" && e !== null)
+    throw new TypeError("Super expression must either be null or a function");
+  t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && T(t, e);
+}
+function T(t, e) {
+  return T = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(r, i) {
+    return r.__proto__ = i, r;
+  }, T(t, e);
+}
+function x(t, e, n) {
+  return e = N(e), e in t ? Object.defineProperty(t, e, { value: n, enumerable: !0, configurable: !0, writable: !0 }) : t[e] = n, t;
+}
+function N(t) {
+  var e = U(t, "string");
+  return b(e) == "symbol" ? e : e + "";
+}
+function U(t, e) {
+  if (b(t) != "object" || !t) return t;
+  var n = t[Symbol.toPrimitive];
+  if (n !== void 0) {
+    var r = n.call(t, e);
+    if (b(r) != "object") return r;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (e === "string" ? String : Number)(t);
+}
+var W = Math.PI / 180, E = 1e-5, j = /* @__PURE__ */ (function(t) {
+  function e() {
+    return V(this, e), G(this, e, arguments);
+  }
+  return Q(e, t), q(e, [{
+    key: "getTickLineCoord",
+    value: (
+      /**
+       * Calculate the coordinate of line endpoint
+       * @param  {Object} data The Data if ticks
+       * @return {Object} (x0, y0): The start point of text,
+       *                  (x1, y1): The end point close to text,
+       *                  (x2, y2): The end point close to axis
+       */
+      function(r) {
+        var i = this.props, a = i.cx, o = i.cy, s = i.radius, p = i.orientation, y = i.tickSize, m = y || 8, v = _(a, o, s, r.coordinate), h = _(a, o, s + (p === "inner" ? -1 : 1) * m, r.coordinate);
+        return {
+          x1: v.x,
+          y1: v.y,
+          x2: h.x,
+          y2: h.y
+        };
+      }
+    )
+    /**
+     * Get the text-anchor of each tick
+     * @param  {Object} data Data of ticks
+     * @return {String} text-anchor
+     */
+  }, {
+    key: "getTickTextAnchor",
+    value: function(r) {
+      var i = this.props.orientation, a = Math.cos(-r.coordinate * W), o;
+      return a > E ? o = i === "outer" ? "start" : "end" : a < -E ? o = i === "outer" ? "end" : "start" : o = "middle", o;
+    }
+  }, {
+    key: "renderAxisLine",
+    value: function() {
+      var r = this.props, i = r.cx, a = r.cy, o = r.radius, s = r.axisLine, p = r.axisLineType, y = u(u({}, d(this.props, !1)), {}, {
+        fill: "none"
+      }, d(s, !1));
+      if (p === "circle")
+        return /* @__PURE__ */ c.createElement($, f({
+          className: "recharts-polar-angle-axis-line"
+        }, y, {
+          cx: i,
+          cy: a,
+          r: o
+        }));
+      var m = this.props.ticks, v = m.map(function(h) {
+        return _(i, a, o, h.coordinate);
+      });
+      return /* @__PURE__ */ c.createElement(F, f({
+        className: "recharts-polar-angle-axis-line"
+      }, y, {
+        points: v
+      }));
+    }
+  }, {
+    key: "renderTicks",
+    value: function() {
+      var r = this, i = this.props, a = i.ticks, o = i.tick, s = i.tickLine, p = i.tickFormatter, y = i.stroke, m = d(this.props, !1), v = d(o, !1), h = u(u({}, m), {}, {
+        fill: "none"
+      }, d(s, !1)), D = a.map(function(l, k) {
+        var O = r.getTickLineCoord(l), I = r.getTickTextAnchor(l), R = u(u(u({
+          textAnchor: I
+        }, m), {}, {
+          stroke: "none",
+          fill: y
+        }, v), {}, {
+          index: k,
+          payload: l,
+          x: O.x2,
+          y: O.y2
+        });
+        return /* @__PURE__ */ c.createElement(P, f({
+          className: w("recharts-polar-angle-axis-tick", M(o)),
+          key: "tick-".concat(l.coordinate)
+        }, K(r.props, l, k)), s && /* @__PURE__ */ c.createElement("line", f({
+          className: "recharts-polar-angle-axis-tick-line"
+        }, h, O)), o && e.renderTickItem(o, R, p ? p(l.value, k) : l.value));
+      });
+      return /* @__PURE__ */ c.createElement(P, {
+        className: "recharts-polar-angle-axis-ticks"
+      }, D);
+    }
+  }, {
+    key: "render",
+    value: function() {
+      var r = this.props, i = r.ticks, a = r.radius, o = r.axisLine;
+      return a <= 0 || !i || !i.length ? null : /* @__PURE__ */ c.createElement(P, {
+        className: w("recharts-polar-angle-axis", this.props.className)
+      }, o && this.renderAxisLine(), this.renderTicks());
+    }
+  }], [{
+    key: "renderTickItem",
+    value: function(r, i, a) {
+      var o;
+      return /* @__PURE__ */ c.isValidElement(r) ? o = /* @__PURE__ */ c.cloneElement(r, i) : C(r) ? o = r(i) : o = /* @__PURE__ */ c.createElement(B, f({}, i, {
+        className: "recharts-polar-angle-axis-tick-value"
+      }), a), o;
+    }
+  }]);
+})(z);
+x(j, "displayName", "PolarAngleAxis");
+x(j, "axisType", "angleAxis");
+x(j, "defaultProps", {
+  type: "category",
+  angleAxisId: 0,
+  scale: "auto",
+  cx: 0,
+  cy: 0,
+  orientation: "outer",
+  axisLine: !0,
+  tickLine: !0,
+  tickSize: 8,
+  tick: !0,
+  hide: !1,
+  allowDuplicatedCategory: !0
+});
+export {
+  j as PolarAngleAxis
+};