qaema-ui 0.0.1

package/dist/node_modules/recharts/es6/cartesian/CartesianAxis.js

@@ -0,0 +1,365 @@
+import x, { Component as q } from "react";
+import E from "../../../../_virtual/isFunction.js";
+import z from "../../../../_virtual/get.js";
+import { clsx as j } from "../../../clsx/dist/clsx.js";
+import { shallowEqual as L } from "../util/ShallowEqual.js";
+import { Layer as R } from "../container/Layer.js";
+import { Text as K } from "../component/Text.js";
+import { Label as W } from "../component/Label.js";
+import { isNumber as J } from "../util/DataUtils.js";
+import { adaptEventsOfChild as Q } from "../util/types.js";
+import { filterProps as T } from "../util/ReactUtils.js";
+import { getTicks as X } from "./getTicks.js";
+var Y = ["viewBox"], Z = ["viewBox"], H = ["ticks"];
+function P(r) {
+  "@babel/helpers - typeof";
+  return P = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t) {
+    return typeof t;
+  } : function(t) {
+    return t && typeof Symbol == "function" && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+  }, P(r);
+}
+function _() {
+  return _ = Object.assign ? Object.assign.bind() : function(r) {
+    for (var t = 1; t < arguments.length; t++) {
+      var i = arguments[t];
+      for (var e in i)
+        Object.prototype.hasOwnProperty.call(i, e) && (r[e] = i[e]);
+    }
+    return r;
+  }, _.apply(this, arguments);
+}
+function $(r, t) {
+  var i = Object.keys(r);
+  if (Object.getOwnPropertySymbols) {
+    var e = Object.getOwnPropertySymbols(r);
+    t && (e = e.filter(function(n) {
+      return Object.getOwnPropertyDescriptor(r, n).enumerable;
+    })), i.push.apply(i, e);
+  }
+  return i;
+}
+function l(r) {
+  for (var t = 1; t < arguments.length; t++) {
+    var i = arguments[t] != null ? arguments[t] : {};
+    t % 2 ? $(Object(i), !0).forEach(function(e) {
+      A(r, e, i[e]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(r, Object.getOwnPropertyDescriptors(i)) : $(Object(i)).forEach(function(e) {
+      Object.defineProperty(r, e, Object.getOwnPropertyDescriptor(i, e));
+    });
+  }
+  return r;
+}
+function C(r, t) {
+  if (r == null) return {};
+  var i = ee(r, t), e, n;
+  if (Object.getOwnPropertySymbols) {
+    var a = Object.getOwnPropertySymbols(r);
+    for (n = 0; n < a.length; n++)
+      e = a[n], !(t.indexOf(e) >= 0) && Object.prototype.propertyIsEnumerable.call(r, e) && (i[e] = r[e]);
+  }
+  return i;
+}
+function ee(r, t) {
+  if (r == null) return {};
+  var i = {};
+  for (var e in r)
+    if (Object.prototype.hasOwnProperty.call(r, e)) {
+      if (t.indexOf(e) >= 0) continue;
+      i[e] = r[e];
+    }
+  return i;
+}
+function te(r, t) {
+  if (!(r instanceof t))
+    throw new TypeError("Cannot call a class as a function");
+}
+function D(r, t) {
+  for (var i = 0; i < t.length; i++) {
+    var e = t[i];
+    e.enumerable = e.enumerable || !1, e.configurable = !0, "value" in e && (e.writable = !0), Object.defineProperty(r, M(e.key), e);
+  }
+}
+function re(r, t, i) {
+  return t && D(r.prototype, t), i && D(r, i), Object.defineProperty(r, "prototype", { writable: !1 }), r;
+}
+function ie(r, t, i) {
+  return t = S(t), ne(r, I() ? Reflect.construct(t, i || [], S(r).constructor) : t.apply(r, i));
+}
+function ne(r, t) {
+  if (t && (P(t) === "object" || typeof t == "function"))
+    return t;
+  if (t !== void 0)
+    throw new TypeError("Derived constructors may only return object or undefined");
+  return oe(r);
+}
+function oe(r) {
+  if (r === void 0)
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return r;
+}
+function I() {
+  try {
+    var r = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+  } catch {
+  }
+  return (I = function() {
+    return !!r;
+  })();
+}
+function S(r) {
+  return S = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(i) {
+    return i.__proto__ || Object.getPrototypeOf(i);
+  }, S(r);
+}
+function ae(r, t) {
+  if (typeof t != "function" && t !== null)
+    throw new TypeError("Super expression must either be null or a function");
+  r.prototype = Object.create(t && t.prototype, { constructor: { value: r, writable: !0, configurable: !0 } }), Object.defineProperty(r, "prototype", { writable: !1 }), t && N(r, t);
+}
+function N(r, t) {
+  return N = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(e, n) {
+    return e.__proto__ = n, e;
+  }, N(r, t);
+}
+function A(r, t, i) {
+  return t = M(t), t in r ? Object.defineProperty(r, t, { value: i, enumerable: !0, configurable: !0, writable: !0 }) : r[t] = i, r;
+}
+function M(r) {
+  var t = ce(r, "string");
+  return P(t) == "symbol" ? t : t + "";
+}
+function ce(r, t) {
+  if (P(r) != "object" || !r) return r;
+  var i = r[Symbol.toPrimitive];
+  if (i !== void 0) {
+    var e = i.call(r, t);
+    if (P(e) != "object") return e;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(r);
+}
+var F = /* @__PURE__ */ (function(r) {
+  function t(i) {
+    var e;
+    return te(this, t), e = ie(this, t, [i]), e.state = {
+      fontSize: "",
+      letterSpacing: ""
+    }, e;
+  }
+  return ae(t, r), re(t, [{
+    key: "shouldComponentUpdate",
+    value: function(e, n) {
+      var a = e.viewBox, o = C(e, Y), c = this.props, s = c.viewBox, v = C(c, Z);
+      return !L(a, s) || !L(o, v) || !L(n, this.state);
+    }
+  }, {
+    key: "componentDidMount",
+    value: function() {
+      var e = this.layerReference;
+      if (e) {
+        var n = e.getElementsByClassName("recharts-cartesian-axis-tick-value")[0];
+        n && this.setState({
+          fontSize: window.getComputedStyle(n).fontSize,
+          letterSpacing: window.getComputedStyle(n).letterSpacing
+        });
+      }
+    }
+    /**
+     * Calculate the coordinates of endpoints in ticks
+     * @param  {Object} data The data of a simple tick
+     * @return {Object} (x1, y1): The coordinate of endpoint close to tick text
+     *  (x2, y2): The coordinate of endpoint close to axis
+     */
+  }, {
+    key: "getTickLineCoord",
+    value: function(e) {
+      var n = this.props, a = n.x, o = n.y, c = n.width, s = n.height, v = n.orientation, k = n.tickSize, f = n.mirror, h = n.tickMargin, u, p, d, y, O, w, b = f ? -1 : 1, m = e.tickSize || k, g = J(e.tickCoord) ? e.tickCoord : e.coordinate;
+      switch (v) {
+        case "top":
+          u = p = e.coordinate, y = o + +!f * s, d = y - b * m, w = d - b * h, O = g;
+          break;
+        case "left":
+          d = y = e.coordinate, p = a + +!f * c, u = p - b * m, O = u - b * h, w = g;
+          break;
+        case "right":
+          d = y = e.coordinate, p = a + +f * c, u = p + b * m, O = u + b * h, w = g;
+          break;
+        default:
+          u = p = e.coordinate, y = o + +f * s, d = y + b * m, w = d + b * h, O = g;
+          break;
+      }
+      return {
+        line: {
+          x1: u,
+          y1: d,
+          x2: p,
+          y2: y
+        },
+        tick: {
+          x: O,
+          y: w
+        }
+      };
+    }
+  }, {
+    key: "getTickTextAnchor",
+    value: function() {
+      var e = this.props, n = e.orientation, a = e.mirror, o;
+      switch (n) {
+        case "left":
+          o = a ? "start" : "end";
+          break;
+        case "right":
+          o = a ? "end" : "start";
+          break;
+        default:
+          o = "middle";
+          break;
+      }
+      return o;
+    }
+  }, {
+    key: "getTickVerticalAnchor",
+    value: function() {
+      var e = this.props, n = e.orientation, a = e.mirror, o = "end";
+      switch (n) {
+        case "left":
+        case "right":
+          o = "middle";
+          break;
+        case "top":
+          o = a ? "start" : "end";
+          break;
+        default:
+          o = a ? "end" : "start";
+          break;
+      }
+      return o;
+    }
+  }, {
+    key: "renderAxisLine",
+    value: function() {
+      var e = this.props, n = e.x, a = e.y, o = e.width, c = e.height, s = e.orientation, v = e.mirror, k = e.axisLine, f = l(l(l({}, T(this.props, !1)), T(k, !1)), {}, {
+        fill: "none"
+      });
+      if (s === "top" || s === "bottom") {
+        var h = +(s === "top" && !v || s === "bottom" && v);
+        f = l(l({}, f), {}, {
+          x1: n,
+          y1: a + h * c,
+          x2: n + o,
+          y2: a + h * c
+        });
+      } else {
+        var u = +(s === "left" && !v || s === "right" && v);
+        f = l(l({}, f), {}, {
+          x1: n + u * o,
+          y1: a,
+          x2: n + u * o,
+          y2: a + c
+        });
+      }
+      return /* @__PURE__ */ x.createElement("line", _({}, f, {
+        className: j("recharts-cartesian-axis-line", z(k, "className"))
+      }));
+    }
+  }, {
+    key: "renderTicks",
+    value: (
+      /**
+       * render the ticks
+       * @param {Array} ticks The ticks to actually render (overrides what was passed in props)
+       * @param {string} fontSize Fontsize to consider for tick spacing
+       * @param {string} letterSpacing Letterspacing to consider for tick spacing
+       * @return {ReactComponent} renderedTicks
+       */
+      function(e, n, a) {
+        var o = this, c = this.props, s = c.tickLine, v = c.stroke, k = c.tick, f = c.tickFormatter, h = c.unit, u = X(l(l({}, this.props), {}, {
+          ticks: e
+        }), n, a), p = this.getTickTextAnchor(), d = this.getTickVerticalAnchor(), y = T(this.props, !1), O = T(k, !1), w = l(l({}, y), {}, {
+          fill: "none"
+        }, T(s, !1)), b = u.map(function(m, g) {
+          var B = o.getTickLineCoord(m), V = B.line, G = B.tick, U = l(l(l(l({
+            textAnchor: p,
+            verticalAnchor: d
+          }, y), {}, {
+            stroke: "none",
+            fill: v
+          }, O), G), {}, {
+            index: g,
+            payload: m,
+            visibleTicksCount: u.length,
+            tickFormatter: f
+          });
+          return /* @__PURE__ */ x.createElement(R, _({
+            className: "recharts-cartesian-axis-tick",
+            key: "tick-".concat(m.value, "-").concat(m.coordinate, "-").concat(m.tickCoord)
+          }, Q(o.props, m, g)), s && /* @__PURE__ */ x.createElement("line", _({}, w, V, {
+            className: j("recharts-cartesian-axis-tick-line", z(s, "className"))
+          })), k && t.renderTickItem(k, U, "".concat(E(f) ? f(m.value, g) : m.value).concat(h || "")));
+        });
+        return /* @__PURE__ */ x.createElement("g", {
+          className: "recharts-cartesian-axis-ticks"
+        }, b);
+      }
+    )
+  }, {
+    key: "render",
+    value: function() {
+      var e = this, n = this.props, a = n.axisLine, o = n.width, c = n.height, s = n.ticksGenerator, v = n.className, k = n.hide;
+      if (k)
+        return null;
+      var f = this.props, h = f.ticks, u = C(f, H), p = h;
+      return E(s) && (p = h && h.length > 0 ? s(this.props) : s(u)), o <= 0 || c <= 0 || !p || !p.length ? null : /* @__PURE__ */ x.createElement(R, {
+        className: j("recharts-cartesian-axis", v),
+        ref: function(y) {
+          e.layerReference = y;
+        }
+      }, a && this.renderAxisLine(), this.renderTicks(p, this.state.fontSize, this.state.letterSpacing), W.renderCallByParent(this.props));
+    }
+  }], [{
+    key: "renderTickItem",
+    value: function(e, n, a) {
+      var o, c = j(n.className, "recharts-cartesian-axis-tick-value");
+      return /* @__PURE__ */ x.isValidElement(e) ? o = /* @__PURE__ */ x.cloneElement(e, l(l({}, n), {}, {
+        className: c
+      })) : E(e) ? o = e(l(l({}, n), {}, {
+        className: c
+      })) : o = /* @__PURE__ */ x.createElement(K, _({}, n, {
+        className: "recharts-cartesian-axis-tick-value"
+      }), a), o;
+    }
+  }]);
+})(q);
+A(F, "displayName", "CartesianAxis");
+A(F, "defaultProps", {
+  x: 0,
+  y: 0,
+  width: 0,
+  height: 0,
+  viewBox: {
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  // The orientation of axis
+  orientation: "bottom",
+  // The ticks
+  ticks: [],
+  stroke: "#666",
+  tickLine: !0,
+  axisLine: !0,
+  tick: !0,
+  mirror: !1,
+  minTickGap: 5,
+  // The width or height of tick
+  tickSize: 6,
+  tickMargin: 2,
+  interval: "preserveEnd"
+});
+export {
+  F as CartesianAxis
+};

package/dist/node_modules/recharts/es6/cartesian/CartesianGrid.js

@@ -0,0 +1,323 @@
+import d from "react";
+import F from "../../../../_virtual/isFunction.js";
+import { warn as $ } from "../util/LogUtils.js";
+import { isNumber as m } from "../util/DataUtils.js";
+import { filterProps as L } from "../util/ReactUtils.js";
+import { getCoordinatesOfGrid as H, getTicksOfAxis as V } from "../util/ChartUtils.js";
+import { getTicks as D } from "./getTicks.js";
+import { CartesianAxis as T } from "./CartesianAxis.js";
+import { useChartWidth as M, useChartHeight as K, useOffset as X, useArbitraryXAxis as Y, useYAxisWithFiniteDomainOrRandom as q } from "../context/chartLayoutContext.js";
+var J = ["x1", "y1", "x2", "y2", "key"], Q = ["offset"];
+function O(t) {
+  "@babel/helpers - typeof";
+  return O = 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;
+  }, O(t);
+}
+function I(t, e) {
+  var r = Object.keys(t);
+  if (Object.getOwnPropertySymbols) {
+    var i = Object.getOwnPropertySymbols(t);
+    e && (i = i.filter(function(a) {
+      return Object.getOwnPropertyDescriptor(t, a).enumerable;
+    })), r.push.apply(r, i);
+  }
+  return r;
+}
+function v(t) {
+  for (var e = 1; e < arguments.length; e++) {
+    var r = arguments[e] != null ? arguments[e] : {};
+    e % 2 ? I(Object(r), !0).forEach(function(i) {
+      U(t, i, r[i]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(t, Object.getOwnPropertyDescriptors(r)) : I(Object(r)).forEach(function(i) {
+      Object.defineProperty(t, i, Object.getOwnPropertyDescriptor(r, i));
+    });
+  }
+  return t;
+}
+function U(t, e, r) {
+  return e = Z(e), e in t ? Object.defineProperty(t, e, { value: r, enumerable: !0, configurable: !0, writable: !0 }) : t[e] = r, t;
+}
+function Z(t) {
+  var e = R(t, "string");
+  return O(e) == "symbol" ? e : e + "";
+}
+function R(t, e) {
+  if (O(t) != "object" || !t) return t;
+  var r = t[Symbol.toPrimitive];
+  if (r !== void 0) {
+    var i = r.call(t, e);
+    if (O(i) != "object") return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (e === "string" ? String : Number)(t);
+}
+function b() {
+  return b = Object.assign ? Object.assign.bind() : function(t) {
+    for (var e = 1; e < arguments.length; e++) {
+      var r = arguments[e];
+      for (var i in r)
+        Object.prototype.hasOwnProperty.call(r, i) && (t[i] = r[i]);
+    }
+    return t;
+  }, b.apply(this, arguments);
+}
+function W(t, e) {
+  if (t == null) return {};
+  var r = tt(t, e), i, a;
+  if (Object.getOwnPropertySymbols) {
+    var l = Object.getOwnPropertySymbols(t);
+    for (a = 0; a < l.length; a++)
+      i = l[a], !(e.indexOf(i) >= 0) && Object.prototype.propertyIsEnumerable.call(t, i) && (r[i] = t[i]);
+  }
+  return r;
+}
+function tt(t, e) {
+  if (t == null) return {};
+  var r = {};
+  for (var i in t)
+    if (Object.prototype.hasOwnProperty.call(t, i)) {
+      if (e.indexOf(i) >= 0) continue;
+      r[i] = t[i];
+    }
+  return r;
+}
+var et = function(e) {
+  var r = e.fill;
+  if (!r || r === "none")
+    return null;
+  var i = e.fillOpacity, a = e.x, l = e.y, o = e.width, u = e.height, f = e.ry;
+  return /* @__PURE__ */ d.createElement("rect", {
+    x: a,
+    y: l,
+    ry: f,
+    width: o,
+    height: u,
+    stroke: "none",
+    fill: r,
+    fillOpacity: i,
+    className: "recharts-cartesian-grid-bg"
+  });
+};
+function B(t, e) {
+  var r;
+  if (/* @__PURE__ */ d.isValidElement(t))
+    r = /* @__PURE__ */ d.cloneElement(t, e);
+  else if (F(t))
+    r = t(e);
+  else {
+    var i = e.x1, a = e.y1, l = e.x2, o = e.y2, u = e.key, f = W(e, J), c = L(f, !1);
+    c.offset;
+    var n = W(c, Q);
+    r = /* @__PURE__ */ d.createElement("line", b({}, n, {
+      x1: i,
+      y1: a,
+      x2: l,
+      y2: o,
+      fill: "none",
+      key: u
+    }));
+  }
+  return r;
+}
+function it(t) {
+  var e = t.x, r = t.width, i = t.horizontal, a = i === void 0 ? !0 : i, l = t.horizontalPoints;
+  if (!a || !l || !l.length)
+    return null;
+  var o = l.map(function(u, f) {
+    var c = v(v({}, t), {}, {
+      x1: e,
+      y1: u,
+      x2: e + r,
+      y2: u,
+      key: "line-".concat(f),
+      index: f
+    });
+    return B(a, c);
+  });
+  return /* @__PURE__ */ d.createElement("g", {
+    className: "recharts-cartesian-grid-horizontal"
+  }, o);
+}
+function rt(t) {
+  var e = t.y, r = t.height, i = t.vertical, a = i === void 0 ? !0 : i, l = t.verticalPoints;
+  if (!a || !l || !l.length)
+    return null;
+  var o = l.map(function(u, f) {
+    var c = v(v({}, t), {}, {
+      x1: u,
+      y1: e,
+      x2: u,
+      y2: e + r,
+      key: "line-".concat(f),
+      index: f
+    });
+    return B(a, c);
+  });
+  return /* @__PURE__ */ d.createElement("g", {
+    className: "recharts-cartesian-grid-vertical"
+  }, o);
+}
+function nt(t) {
+  var e = t.horizontalFill, r = t.fillOpacity, i = t.x, a = t.y, l = t.width, o = t.height, u = t.horizontalPoints, f = t.horizontal, c = f === void 0 ? !0 : f;
+  if (!c || !e || !e.length)
+    return null;
+  var n = u.map(function(h) {
+    return Math.round(h + a - a);
+  }).sort(function(h, s) {
+    return h - s;
+  });
+  a !== n[0] && n.unshift(0);
+  var g = n.map(function(h, s) {
+    var w = !n[s + 1], y = w ? a + o - h : n[s + 1] - h;
+    if (y <= 0)
+      return null;
+    var x = s % e.length;
+    return /* @__PURE__ */ d.createElement("rect", {
+      key: "react-".concat(s),
+      y: h,
+      x: i,
+      height: y,
+      width: l,
+      stroke: "none",
+      fill: e[x],
+      fillOpacity: r,
+      className: "recharts-cartesian-grid-bg"
+    });
+  });
+  return /* @__PURE__ */ d.createElement("g", {
+    className: "recharts-cartesian-gridstripes-horizontal"
+  }, g);
+}
+function at(t) {
+  var e = t.vertical, r = e === void 0 ? !0 : e, i = t.verticalFill, a = t.fillOpacity, l = t.x, o = t.y, u = t.width, f = t.height, c = t.verticalPoints;
+  if (!r || !i || !i.length)
+    return null;
+  var n = c.map(function(h) {
+    return Math.round(h + l - l);
+  }).sort(function(h, s) {
+    return h - s;
+  });
+  l !== n[0] && n.unshift(0);
+  var g = n.map(function(h, s) {
+    var w = !n[s + 1], y = w ? l + u - h : n[s + 1] - h;
+    if (y <= 0)
+      return null;
+    var x = s % i.length;
+    return /* @__PURE__ */ d.createElement("rect", {
+      key: "react-".concat(s),
+      x: h,
+      y: o,
+      width: y,
+      height: f,
+      stroke: "none",
+      fill: i[x],
+      fillOpacity: a,
+      className: "recharts-cartesian-grid-bg"
+    });
+  });
+  return /* @__PURE__ */ d.createElement("g", {
+    className: "recharts-cartesian-gridstripes-vertical"
+  }, g);
+}
+var lt = function(e, r) {
+  var i = e.xAxis, a = e.width, l = e.height, o = e.offset;
+  return H(D(v(v(v({}, T.defaultProps), i), {}, {
+    ticks: V(i, !0),
+    viewBox: {
+      x: 0,
+      y: 0,
+      width: a,
+      height: l
+    }
+  })), o.left, o.left + o.width, r);
+}, ot = function(e, r) {
+  var i = e.yAxis, a = e.width, l = e.height, o = e.offset;
+  return H(D(v(v(v({}, T.defaultProps), i), {}, {
+    ticks: V(i, !0),
+    viewBox: {
+      x: 0,
+      y: 0,
+      width: a,
+      height: l
+    }
+  })), o.top, o.top + o.height, r);
+}, P = {
+  horizontal: !0,
+  vertical: !0,
+  stroke: "#ccc",
+  fill: "none",
+  // The fill of colors of grid lines
+  verticalFill: [],
+  horizontalFill: []
+};
+function ct(t) {
+  var e, r, i, a, l, o, u = M(), f = K(), c = X(), n = v(v({}, t), {}, {
+    stroke: (e = t.stroke) !== null && e !== void 0 ? e : P.stroke,
+    fill: (r = t.fill) !== null && r !== void 0 ? r : P.fill,
+    horizontal: (i = t.horizontal) !== null && i !== void 0 ? i : P.horizontal,
+    horizontalFill: (a = t.horizontalFill) !== null && a !== void 0 ? a : P.horizontalFill,
+    vertical: (l = t.vertical) !== null && l !== void 0 ? l : P.vertical,
+    verticalFill: (o = t.verticalFill) !== null && o !== void 0 ? o : P.verticalFill,
+    x: m(t.x) ? t.x : c.left,
+    y: m(t.y) ? t.y : c.top,
+    width: m(t.width) ? t.width : c.width,
+    height: m(t.height) ? t.height : c.height
+  }), g = n.x, h = n.y, s = n.width, w = n.height, y = n.syncWithTicks, x = n.horizontalValues, C = n.verticalValues, z = Y(), A = q();
+  if (!m(s) || s <= 0 || !m(w) || w <= 0 || !m(g) || g !== +g || !m(h) || h !== +h)
+    return null;
+  var G = n.verticalCoordinatesGenerator || lt, _ = n.horizontalCoordinatesGenerator || ot, j = n.horizontalPoints, k = n.verticalPoints;
+  if ((!j || !j.length) && F(_)) {
+    var N = x && x.length, E = _({
+      yAxis: A ? v(v({}, A), {}, {
+        ticks: N ? x : A.ticks
+      }) : void 0,
+      width: u,
+      height: f,
+      offset: c
+    }, N ? !0 : y);
+    $(Array.isArray(E), "horizontalCoordinatesGenerator should return Array but instead it returned [".concat(O(E), "]")), Array.isArray(E) && (j = E);
+  }
+  if ((!k || !k.length) && F(G)) {
+    var p = C && C.length, S = G({
+      xAxis: z ? v(v({}, z), {}, {
+        ticks: p ? C : z.ticks
+      }) : void 0,
+      width: u,
+      height: f,
+      offset: c
+    }, p ? !0 : y);
+    $(Array.isArray(S), "verticalCoordinatesGenerator should return Array but instead it returned [".concat(O(S), "]")), Array.isArray(S) && (k = S);
+  }
+  return /* @__PURE__ */ d.createElement("g", {
+    className: "recharts-cartesian-grid"
+  }, /* @__PURE__ */ d.createElement(et, {
+    fill: n.fill,
+    fillOpacity: n.fillOpacity,
+    x: n.x,
+    y: n.y,
+    width: n.width,
+    height: n.height,
+    ry: n.ry
+  }), /* @__PURE__ */ d.createElement(it, b({}, n, {
+    offset: c,
+    horizontalPoints: j,
+    xAxis: z,
+    yAxis: A
+  })), /* @__PURE__ */ d.createElement(rt, b({}, n, {
+    offset: c,
+    verticalPoints: k,
+    xAxis: z,
+    yAxis: A
+  })), /* @__PURE__ */ d.createElement(nt, b({}, n, {
+    horizontalPoints: j
+  })), /* @__PURE__ */ d.createElement(at, b({}, n, {
+    verticalPoints: k
+  })));
+}
+ct.displayName = "CartesianGrid";
+export {
+  ct as CartesianGrid
+};