@pibit.ai/cure-design-system 0.6.42 → 0.6.43

package/dist/node_modules/recharts/es6/state/selectors/axisSelectors.js

@@ -0,0 +1,925 @@
+import { createSelector as o } from "../../../../reselect/dist/reselect.js";
+import { selectChartLayout as w } from "../../context/chartLayoutContext.js";
+import { getValueByDataKey as T, isCategoricalAxis as M, getDomainOfStackGroups as Se, getStackedData as Be } from "../../util/ChartUtils.js";
+import { selectChartDataWithIndexesIfNotInPanoramaPosition4 as H, selectChartDataWithIndexes as je, selectChartDataSliceIfNotInPanorama as ze } from "./dataSelectors.js";
+import { parseNumericalUserDomain as Ge, isWellFormedNumberDomain as S, numericalDomainSpecifiedWithoutRequiringData as Re } from "../../util/isDomainSpecifiedByUser.js";
+import { hasDuplicate as oe, isNumOrStr as ce, isNotNil as I, isNan as Xe, getPercentValue as Ve, mathSign as de } from "../../util/DataUtils.js";
+import { isWellBehavedNumber as g } from "../../util/isWellBehavedNumber.js";
+import { selectChartHeight as We, selectChartWidth as Ye } from "./containerSelectors.js";
+import { selectAllXAxes as fe, selectAllYAxes as se } from "./selectAllAxes.js";
+import { selectChartOffsetInternal as x } from "./selectChartOffsetInternal.js";
+import { selectBrushDimensions as ve, selectBrushSettings as me } from "./brushSelectors.js";
+import { selectBarCategoryGap as Fe, selectStackOffsetType as pe, selectReverseStackOrder as $e, selectChartName as He } from "./rootPropsSelectors.js";
+import { selectRadiusAxis as he, selectAngleAxis as Ae, selectRadiusAxisRange as qe, selectAngleAxisRange as Le } from "./polarAxisSelectors.js";
+import { pickAxisType as v } from "./pickAxisType.js";
+import { pickAxisId as G } from "./pickAxisId.js";
+import { combineAxisRangeWithReverse as Ue } from "./combiners/combineAxisRangeWithReverse.js";
+import { DEFAULT_Y_AXIS_WIDTH as q, DEFAULT_X_AXIS_HEIGHT as Ze } from "../../util/Constants.js";
+import { getStackSeriesIdentifier as Je } from "../../util/stacks/getStackSeriesIdentifier.js";
+import { combineDisplayedStackedData as Qe } from "./combiners/combineDisplayedStackedData.js";
+import { isStacked as er } from "../types/StackedGraphicalItem.js";
+import { numberDomainEqualityCheck as R } from "./numberDomainEqualityCheck.js";
+import { emptyArraysAreEqualCheck as ye } from "./arrayEqualityCheck.js";
+import { selectTooltipAxisType as rr } from "./selectTooltipAxisType.js";
+import { selectTooltipAxisId as tr } from "./selectTooltipAxisId.js";
+import { rechartsScaleFactory as ge } from "../../util/scale/RechartsScale.js";
+import { combineCheckedDomain as nr } from "./combiners/combineCheckedDomain.js";
+import { combineConfiguredScale as be } from "./combiners/combineConfiguredScale.js";
+import { combineRealScaleType as ar } from "./combiners/combineRealScaleType.js";
+import { createCategoricalInverse as ir } from "../../util/scale/createCategoricalInverse.js";
+import { combineInverseScaleFunction as lr } from "./combiners/combineInverseScaleFunction.js";
+import { range as De } from "../../../../es-toolkit/dist/compat/math/range.js";
+import { getNiceTickValues as ne, getTickValuesFixedDomain as ae } from "../../util/scale/getNiceTickValues.js";
+function ie(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    r && (n = n.filter(function(a) {
+      return Object.getOwnPropertyDescriptor(e, a).enumerable;
+    })), t.push.apply(t, n);
+  }
+  return t;
+}
+function z(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = arguments[r] != null ? arguments[r] : {};
+    r % 2 ? ie(Object(t), !0).forEach(function(n) {
+      ur(e, n, t[n]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ie(Object(t)).forEach(function(n) {
+      Object.defineProperty(e, n, Object.getOwnPropertyDescriptor(t, n));
+    });
+  }
+  return e;
+}
+function ur(e, r, t) {
+  return (r = or(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e;
+}
+function or(e) {
+  var r = cr(e, "string");
+  return typeof r == "symbol" ? r : r + "";
+}
+function cr(e, r) {
+  if (typeof e != "object" || !e) return e;
+  var t = e[Symbol.toPrimitive];
+  if (t !== void 0) {
+    var n = t.call(e, r);
+    if (typeof n != "object") return n;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (r === "string" ? String : Number)(e);
+}
+function ke(e, r) {
+  return vr(e) || sr(e, r) || fr(e, r) || dr();
+}
+function dr() {
+  throw new TypeError(`Invalid attempt to destructure non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function fr(e, r) {
+  if (e) {
+    if (typeof e == "string") return le(e, r);
+    var t = {}.toString.call(e).slice(8, -1);
+    return t === "Object" && e.constructor && (t = e.constructor.name), t === "Map" || t === "Set" ? Array.from(e) : t === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? le(e, r) : void 0;
+  }
+}
+function le(e, r) {
+  (r == null || r > e.length) && (r = e.length);
+  for (var t = 0, n = Array(r); t < r; t++) n[t] = e[t];
+  return n;
+}
+function sr(e, r) {
+  var t = e == null ? null : typeof Symbol < "u" && e[Symbol.iterator] || e["@@iterator"];
+  if (t != null) {
+    var n, a, l, i, u = [], c = !0, d = !1;
+    try {
+      if (l = (t = t.call(e)).next, r !== 0) for (; !(c = (n = l.call(t)).done) && (u.push(n.value), u.length !== r); c = !0) ;
+    } catch (f) {
+      d = !0, a = f;
+    } finally {
+      try {
+        if (!c && t.return != null && (i = t.return(), Object(i) !== i)) return;
+      } finally {
+        if (d) throw a;
+      }
+    }
+    return u;
+  }
+}
+function vr(e) {
+  if (Array.isArray(e)) return e;
+}
+var F = [0, "auto"], mr = {
+  allowDataOverflow: !1,
+  allowDecimals: !0,
+  allowDuplicatedCategory: !0,
+  angle: 0,
+  dataKey: void 0,
+  domain: void 0,
+  height: 30,
+  hide: !0,
+  id: 0,
+  includeHidden: !1,
+  interval: "preserveEnd",
+  minTickGap: 5,
+  mirror: !1,
+  name: void 0,
+  orientation: "bottom",
+  padding: {
+    left: 0,
+    right: 0
+  },
+  reversed: !1,
+  scale: "auto",
+  tick: !0,
+  tickCount: 5,
+  tickFormatter: void 0,
+  ticks: void 0,
+  type: "category",
+  unit: void 0,
+  niceTicks: "auto"
+}, pr = (e, r) => e.cartesianAxis.xAxis[r], O = (e, r) => {
+  var t = pr(e, r);
+  return t ?? mr;
+}, hr = {
+  allowDataOverflow: !1,
+  allowDecimals: !0,
+  allowDuplicatedCategory: !0,
+  angle: 0,
+  dataKey: void 0,
+  domain: F,
+  hide: !0,
+  id: 0,
+  includeHidden: !1,
+  interval: "preserveEnd",
+  minTickGap: 5,
+  mirror: !1,
+  name: void 0,
+  orientation: "left",
+  padding: {
+    top: 0,
+    bottom: 0
+  },
+  reversed: !1,
+  scale: "auto",
+  tick: !0,
+  tickCount: 5,
+  tickFormatter: void 0,
+  ticks: void 0,
+  type: "number",
+  unit: void 0,
+  niceTicks: "auto",
+  width: q
+}, Ar = (e, r) => e.cartesianAxis.yAxis[r], E = (e, r) => {
+  var t = Ar(e, r);
+  return t ?? hr;
+}, yr = {
+  domain: [0, "auto"],
+  includeHidden: !1,
+  reversed: !1,
+  allowDataOverflow: !1,
+  allowDuplicatedCategory: !1,
+  dataKey: void 0,
+  id: 0,
+  name: "",
+  range: [64, 64],
+  scale: "auto",
+  type: "number",
+  unit: ""
+}, L = (e, r) => {
+  var t = e.cartesianAxis.zAxis[r];
+  return t ?? yr;
+}, h = (e, r, t) => {
+  switch (r) {
+    case "xAxis":
+      return O(e, t);
+    case "yAxis":
+      return E(e, t);
+    case "zAxis":
+      return L(e, t);
+    case "angleAxis":
+      return Ae(e, t);
+    case "radiusAxis":
+      return he(e, t);
+    default:
+      throw new Error("Unexpected axis type: ".concat(r));
+  }
+}, gr = (e, r, t) => {
+  switch (r) {
+    case "xAxis":
+      return O(e, t);
+    case "yAxis":
+      return E(e, t);
+    default:
+      throw new Error("Unexpected axis type: ".concat(r));
+  }
+}, B = (e, r, t) => {
+  switch (r) {
+    case "xAxis":
+      return O(e, t);
+    case "yAxis":
+      return E(e, t);
+    case "angleAxis":
+      return Ae(e, t);
+    case "radiusAxis":
+      return he(e, t);
+    default:
+      throw new Error("Unexpected axis type: ".concat(r));
+  }
+}, br = (e) => e.graphicalItems.cartesianItems.some((r) => r.type === "bar") || e.graphicalItems.polarItems.some((r) => r.type === "radialBar");
+function Dr(e, r) {
+  return (t) => {
+    switch (e) {
+      case "xAxis":
+        return "xAxisId" in t && t.xAxisId === r;
+      case "yAxis":
+        return "yAxisId" in t && t.yAxisId === r;
+      case "zAxis":
+        return "zAxisId" in t && t.zAxisId === r;
+      case "angleAxis":
+        return "angleAxisId" in t && t.angleAxisId === r;
+      case "radiusAxis":
+        return "radiusAxisId" in t && t.radiusAxisId === r;
+      default:
+        return !1;
+    }
+  };
+}
+var kr = (e) => e.graphicalItems.cartesianItems, wr = o([v, G], Dr), xr = (e, r, t) => e.filter(t).filter((n) => (r == null ? void 0 : r.includeHidden) === !0 ? !0 : !n.hide), K = o([kr, h, wr], xr, {
+  memoizeOptions: {
+    resultEqualityCheck: ye
+  }
+}), we = o([K], (e) => e.filter((r) => r.type === "area" || r.type === "bar").filter(er)), Cr = (e) => e.filter((r) => !("stackId" in r) || r.stackId === void 0), Ir = o([K], Cr), Or = (e) => e.map((r) => r.data).filter(Boolean).flat(1), Er = o([K], (e) => e.some((r) => !r.data)), xe = o([K], Or, {
+  memoizeOptions: {
+    resultEqualityCheck: ye
+  }
+}), Nr = (e, r) => {
+  var t = r.chartData, n = t === void 0 ? [] : t, a = r.dataStartIndex, l = r.dataEndIndex;
+  return e.length > 0 ? e : n.slice(a, l + 1);
+}, U = o([xe, H], Nr), Tr = (e, r, t) => (r == null ? void 0 : r.dataKey) != null ? e.map((n) => ({
+  value: T(n, r.dataKey)
+})) : t.length > 0 ? t.map((n) => n.dataKey).flatMap((n) => e.map((a) => ({
+  value: T(a, n)
+}))) : e.map((n) => ({
+  value: n
+})), Mr = (e, r, t, n, a, l) => {
+  var i = n.chartData, u = i === void 0 ? [] : i, c = n.dataStartIndex, d = n.dataEndIndex, f = Tr(e, r, t);
+  if (a && (r == null ? void 0 : r.dataKey) != null && l.length > 0) {
+    var s = u.slice(c, d + 1), p = s.map((D) => ({
+      value: T(D, r.dataKey)
+    })).filter((D) => D.value != null);
+    return [...p, ...f];
+  }
+  return f;
+}, j = o([U, h, K, H, Er, xe], Mr);
+function N(e) {
+  if (ce(e) || e instanceof Date) {
+    var r = Number(e);
+    if (g(r))
+      return r;
+  }
+}
+function ue(e) {
+  if (Array.isArray(e)) {
+    var r = [N(e[0]), N(e[1])];
+    return S(r) ? r : void 0;
+  }
+  var t = N(e);
+  if (t != null)
+    return [t, t];
+}
+function b(e) {
+  return e.map(N).filter(I);
+}
+function Kr(e, r) {
+  var t = N(e), n = N(r);
+  return t == null && n == null ? 0 : t == null ? -1 : n == null ? 1 : t - n;
+}
+var _r = o([j], (e) => e == null ? void 0 : e.map((r) => r.value).sort(Kr));
+function Ce(e, r) {
+  switch (e) {
+    case "xAxis":
+      return r.direction === "x";
+    case "yAxis":
+      return r.direction === "y";
+    default:
+      return !1;
+  }
+}
+function Pr(e, r, t) {
+  if (!t)
+    return [];
+  if (!t.length)
+    return [];
+  var n;
+  if (typeof r == "number" && !Xe(r))
+    n = r;
+  else if (Array.isArray(r)) {
+    var a = b(r);
+    a.length > 0 && (n = Math.max(...a));
+  }
+  return n == null ? [] : b(t.flatMap((l) => {
+    var i = T(e, l.dataKey), u, c;
+    if (Array.isArray(i)) {
+      var d = ke(i, 2);
+      u = d[0], c = d[1];
+    } else
+      u = c = i;
+    if (!(!g(u) || !g(c)))
+      return [n - u, n + c];
+  }));
+}
+var Ie = (e) => {
+  var r = rr(e), t = tr(e);
+  return B(e, r, t);
+}, gn = o([Ie], (e) => e == null ? void 0 : e.dataKey), Sr = o([we, H, Ie], Qe), Br = (e, r, t, n) => {
+  var a = {}, l = r.reduce((i, u) => {
+    if (u.stackId == null)
+      return i;
+    var c = i[u.stackId];
+    return c == null && (c = []), c.push(u), i[u.stackId] = c, i;
+  }, a);
+  return Object.fromEntries(Object.entries(l).map((i) => {
+    var u = ke(i, 2), c = u[0], d = u[1], f = n ? [...d].reverse() : d, s = f.map(Je);
+    return [c, {
+      // @ts-expect-error getStackedData requires that the input is array of objects, Recharts does not test for that
+      stackedData: Be(e, s, t),
+      graphicalItems: f
+    }];
+  }));
+}, jr = o([Sr, we, pe, $e], Br), zr = (e, r, t, n) => {
+  var a = r.dataStartIndex, l = r.dataEndIndex;
+  if (n == null && t !== "zAxis")
+    return Se(e, a, l);
+}, Gr = o([h], (e) => e.allowDataOverflow), Oe = (e) => {
+  var r;
+  if (e == null || !("domain" in e))
+    return F;
+  if (e.domain != null)
+    return e.domain;
+  if ("ticks" in e && e.ticks != null) {
+    if (e.type === "number") {
+      var t = b(e.ticks);
+      return [Math.min(...t), Math.max(...t)];
+    }
+    if (e.type === "category")
+      return e.ticks.map(String);
+  }
+  return (r = e == null ? void 0 : e.domain) !== null && r !== void 0 ? r : F;
+}, Ee = o([h], Oe), Ne = o([Ee, Gr], Re), Rr = o([jr, je, v, Ne], zr, {
+  memoizeOptions: {
+    resultEqualityCheck: R
+  }
+}), Te = (e) => e.errorBars, Xr = (e, r, t) => e.flatMap((n) => r[n.id]).filter(Boolean).filter((n) => Ce(t, n)), $ = function() {
+  for (var r = arguments.length, t = new Array(r), n = 0; n < r; n++)
+    t[n] = arguments[n];
+  var a = t.filter(Boolean);
+  if (a.length !== 0) {
+    var l = a.flat(), i = Math.min(...l), u = Math.max(...l);
+    return [i, u];
+  }
+}, Vr = function(r, t, n, a, l) {
+  var i = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : [], u, c;
+  if (n.length > 0 && n.forEach((d) => {
+    var f, s = d.data != null ? [...d.data] : i, p = (f = a[d.id]) === null || f === void 0 ? void 0 : f.filter((D) => Ce(l, D));
+    s.forEach((D) => {
+      var A, P = T(D, (A = t.dataKey) !== null && A !== void 0 ? A : d.dataKey), m = Pr(D, P, p);
+      if (m.length >= 2) {
+        var k = Math.min(...m), y = Math.max(...m);
+        (u == null || k < u) && (u = k), (c == null || y > c) && (c = y);
+      }
+      var C = ue(P);
+      C != null && (u = u == null ? C[0] : Math.min(u, C[0]), c = c == null ? C[1] : Math.max(c, C[1]));
+    });
+  }), (t == null ? void 0 : t.dataKey) != null && n.length === 0 && r.forEach((d) => {
+    var f = ue(T(d, t.dataKey));
+    f != null && (u = u == null ? f[0] : Math.min(u, f[0]), c = c == null ? f[1] : Math.max(c, f[1]));
+  }), g(u) && g(c))
+    return [u, c];
+}, Wr = o([U, h, Ir, Te, v, ze], Vr, {
+  memoizeOptions: {
+    resultEqualityCheck: R
+  }
+});
+function Yr(e) {
+  var r = e.value;
+  if (ce(r) || r instanceof Date)
+    return r;
+}
+var Fr = (e, r, t) => {
+  var n = e.map(Yr).filter((a) => a != null);
+  return t && (r.dataKey == null || r.allowDuplicatedCategory && oe(n)) ? De(0, e.length) : r.allowDuplicatedCategory ? n : Array.from(new Set(n));
+}, $r = (e) => e.referenceElements.dots, Z = (e, r, t) => e.filter((n) => n.ifOverflow === "extendDomain").filter((n) => r === "xAxis" ? n.xAxisId === t : n.yAxisId === t), Hr = o([$r, v, G], Z), qr = (e) => e.referenceElements.areas, Lr = o([qr, v, G], Z), Ur = (e) => e.referenceElements.lines, Zr = o([Ur, v, G], Z), Jr = (e, r) => {
+  if (e != null) {
+    var t = b(e.map((n) => r === "xAxis" ? n.x : n.y));
+    if (t.length !== 0)
+      return [Math.min(...t), Math.max(...t)];
+  }
+}, Qr = o(Hr, v, Jr), et = (e, r) => {
+  if (e != null) {
+    var t = b(e.flatMap((n) => [r === "xAxis" ? n.x1 : n.y1, r === "xAxis" ? n.x2 : n.y2]));
+    if (t.length !== 0)
+      return [Math.min(...t), Math.max(...t)];
+  }
+}, rt = o([Lr, v], et);
+function tt(e) {
+  var r;
+  if (e.x != null)
+    return b([e.x]);
+  var t = (r = e.segment) === null || r === void 0 ? void 0 : r.map((n) => n.x);
+  return t == null || t.length === 0 ? [] : b(t);
+}
+function nt(e) {
+  var r;
+  if (e.y != null)
+    return b([e.y]);
+  var t = (r = e.segment) === null || r === void 0 ? void 0 : r.map((n) => n.y);
+  return t == null || t.length === 0 ? [] : b(t);
+}
+var at = (e, r) => {
+  if (e != null) {
+    var t = e.flatMap((n) => r === "xAxis" ? tt(n) : nt(n));
+    if (t.length !== 0)
+      return [Math.min(...t), Math.max(...t)];
+  }
+}, it = o([Zr, v], at), lt = o(Qr, it, rt, (e, r, t) => $(e, t, r)), ut = (e, r, t, n, a, l, i, u, c) => {
+  if (t != null)
+    return t;
+  var d = i === "vertical" && u === "xAxis" || i === "horizontal" && u === "yAxis", f = d ? $(n, l, a) : $(l, a), s = Ge(r, f, e.allowDataOverflow);
+  return s ?? (e.allowDataOverflow && f == null && c != null ? c : s);
+}, ot = (e) => {
+  if (!(e == null || e.type !== "number" || !("ticks" in e) || e.ticks == null)) {
+    var r = b(e.ticks);
+    if (r.length !== 0)
+      return [Math.min(...r), Math.max(...r)];
+  }
+}, ct = o([h], ot, {
+  memoizeOptions: {
+    resultEqualityCheck: R
+  }
+}), dt = o([h, Ee, Ne, Rr, Wr, lt, w, v, ct], ut, {
+  memoizeOptions: {
+    resultEqualityCheck: R
+  }
+}), ft = [0, 1], st = (e, r, t, n, a, l, i) => {
+  if (!((e == null || t == null || t.length === 0) && i === void 0)) {
+    var u = e.dataKey, c = e.type, d = M(r, l);
+    if (d && u == null) {
+      var f;
+      return De(0, (f = t == null ? void 0 : t.length) !== null && f !== void 0 ? f : 0);
+    }
+    return c === "category" ? Fr(n, e, d) : a === "expand" && !d ? ft : i;
+  }
+}, J = o([h, w, U, j, pe, v, dt], st), _ = o([h, br, He], ar), vt = (e, r, t) => {
+  var n = r.niceTicks;
+  if (n !== "none") {
+    var a = Oe(r), l = Array.isArray(a) && (a[0] === "auto" || a[1] === "auto");
+    if ((n === "snap125" || n === "adaptive") && r != null && r.tickCount && S(e)) {
+      if (l)
+        return ne(e, r.tickCount, r.allowDecimals, n);
+      if (r.type === "number")
+        return ae(e, r.tickCount, r.allowDecimals, n);
+    }
+    if (n === "auto" && t === "linear" && r != null && r.tickCount) {
+      if (l && S(e))
+        return ne(e, r.tickCount, r.allowDecimals, "adaptive");
+      if (r.type === "number" && S(e))
+        return ae(e, r.tickCount, r.allowDecimals, "adaptive");
+    }
+  }
+}, Q = o([J, B, _], vt), mt = (e, r, t, n) => {
+  if (
+    /*
+     * Angle axis for some reason uses nice ticks when rendering axis tick labels,
+     * but doesn't use nice ticks for extending domain like all the other axes do.
+     * Not really sure why? Is there a good reason,
+     * or is it just because someone added support for nice ticks to the other axes and forgot this one?
+     */
+    n !== "angleAxis" && (e == null ? void 0 : e.type) === "number" && S(r) && Array.isArray(t) && t.length > 0
+  ) {
+    var a, l, i = r[0], u = (a = t[0]) !== null && a !== void 0 ? a : 0, c = r[1], d = (l = t[t.length - 1]) !== null && l !== void 0 ? l : 0;
+    return [Math.min(i, u), Math.max(c, d)];
+  }
+  return r;
+}, pt = o([h, J, Q, v], mt), ht = o(j, h, (e, r) => {
+  if (!(!r || r.type !== "number")) {
+    var t = 1 / 0, n = Array.from(b(e.map((s) => s.value))).sort((s, p) => s - p), a = n[0], l = n[n.length - 1];
+    if (a == null || l == null)
+      return 1 / 0;
+    var i = l - a;
+    if (i === 0)
+      return 1 / 0;
+    for (var u = 0; u < n.length - 1; u++) {
+      var c = n[u], d = n[u + 1];
+      if (!(c == null || d == null)) {
+        var f = d - c;
+        t = Math.min(t, f);
+      }
+    }
+    return t / i;
+  }
+}), Me = o(ht, w, Fe, x, (e, r, t, n, a) => a, (e, r, t, n, a) => {
+  if (!g(e))
+    return 0;
+  var l = r === "vertical" ? n.height : n.width;
+  if (a === "gap")
+    return e * l / 2;
+  if (a === "no-gap") {
+    var i = Ve(t, e * l), u = e * l / 2;
+    return u - i - (u - i) / l * i;
+  }
+  return 0;
+}), At = (e, r, t) => {
+  var n = O(e, r);
+  return n == null || typeof n.padding != "string" ? 0 : Me(e, "xAxis", r, t, n.padding);
+}, yt = (e, r, t) => {
+  var n = E(e, r);
+  return n == null || typeof n.padding != "string" ? 0 : Me(e, "yAxis", r, t, n.padding);
+}, gt = o(O, At, (e, r) => {
+  var t, n;
+  if (e == null)
+    return {
+      left: 0,
+      right: 0
+    };
+  var a = e.padding;
+  return typeof a == "string" ? {
+    left: r,
+    right: r
+  } : {
+    left: ((t = a.left) !== null && t !== void 0 ? t : 0) + r,
+    right: ((n = a.right) !== null && n !== void 0 ? n : 0) + r
+  };
+}), bt = o(E, yt, (e, r) => {
+  var t, n;
+  if (e == null)
+    return {
+      top: 0,
+      bottom: 0
+    };
+  var a = e.padding;
+  return typeof a == "string" ? {
+    top: r,
+    bottom: r
+  } : {
+    top: ((t = a.top) !== null && t !== void 0 ? t : 0) + r,
+    bottom: ((n = a.bottom) !== null && n !== void 0 ? n : 0) + r
+  };
+}), Dt = o([x, gt, ve, me, (e, r, t) => t], (e, r, t, n, a) => {
+  var l = n.padding;
+  return a ? [l.left, t.width - l.right] : [e.left + r.left, e.left + e.width - r.right];
+}), kt = o([x, w, bt, ve, me, (e, r, t) => t], (e, r, t, n, a, l) => {
+  var i = a.padding;
+  return l ? [n.height - i.bottom, i.top] : r === "horizontal" ? [e.top + e.height - t.bottom, e.top + t.top] : [e.top + t.top, e.top + e.height - t.bottom];
+}), X = (e, r, t, n) => {
+  var a;
+  switch (r) {
+    case "xAxis":
+      return Dt(e, t, n);
+    case "yAxis":
+      return kt(e, t, n);
+    case "zAxis":
+      return (a = L(e, t)) === null || a === void 0 ? void 0 : a.range;
+    case "angleAxis":
+      return Le(e);
+    case "radiusAxis":
+      return qe(e, t);
+    default:
+      return;
+  }
+}, Ke = o([h, X], Ue), wt = o([_, pt], nr), ee = o([h, _, wt, Ke], be), xt = (e, r, t, n) => {
+  if (!(t == null || t.dataKey == null)) {
+    var a = t.type, l = t.scale, i = M(e, n);
+    if (i && (a === "number" || l !== "auto"))
+      return r.map((u) => u.value);
+  }
+}, re = o([w, j, B, v], xt), V = o([ee], ge);
+o([ee], lr);
+o([ee, _r], ir);
+o([K, Te, v], Xr);
+function _e(e, r) {
+  return e.id < r.id ? -1 : e.id > r.id ? 1 : 0;
+}
+var W = (e, r) => r, Y = (e, r, t) => t, Ct = o(fe, W, Y, (e, r, t) => e.filter((n) => n.orientation === r).filter((n) => n.mirror === t).sort(_e)), It = o(se, W, Y, (e, r, t) => e.filter((n) => n.orientation === r).filter((n) => n.mirror === t).sort(_e)), Pe = (e, r) => {
+  var t = typeof r.height == "number" ? r.height : Ze;
+  return {
+    width: e.width,
+    height: t
+  };
+}, Ot = (e, r) => {
+  var t = typeof r.width == "number" ? r.width : q;
+  return {
+    width: t,
+    height: e.height
+  };
+};
+o(x, O, Pe);
+var Et = (e, r, t) => {
+  switch (r) {
+    case "top":
+      return e.top;
+    case "bottom":
+      return t - e.bottom;
+    default:
+      return 0;
+  }
+}, Nt = (e, r, t) => {
+  switch (r) {
+    case "left":
+      return e.left;
+    case "right":
+      return t - e.right;
+    default:
+      return 0;
+  }
+}, Tt = o(We, x, Ct, W, Y, (e, r, t, n, a) => {
+  var l = {}, i;
+  return t.forEach((u) => {
+    var c = Pe(r, u);
+    i == null && (i = Et(r, n, e));
+    var d = n === "top" && !a || n === "bottom" && a;
+    l[u.id] = i - Number(d) * c.height, i += (d ? -1 : 1) * c.height;
+  }), l;
+}), Mt = o(Ye, x, It, W, Y, (e, r, t, n, a) => {
+  var l = {}, i;
+  return t.forEach((u) => {
+    var c = Ot(r, u);
+    i == null && (i = Nt(r, n, e));
+    var d = n === "left" && !a || n === "right" && a;
+    l[u.id] = i - Number(d) * c.width, i += (d ? -1 : 1) * c.width;
+  }), l;
+}), Kt = (e, r) => {
+  var t = O(e, r);
+  if (t != null)
+    return Tt(e, t.orientation, t.mirror);
+};
+o([x, O, Kt, (e, r) => r], (e, r, t, n) => {
+  if (r != null) {
+    var a = t == null ? void 0 : t[n];
+    return a == null ? {
+      x: e.left,
+      y: 0
+    } : {
+      x: e.left,
+      y: a
+    };
+  }
+});
+var _t = (e, r) => {
+  var t = E(e, r);
+  if (t != null)
+    return Mt(e, t.orientation, t.mirror);
+};
+o([x, E, _t, (e, r) => r], (e, r, t, n) => {
+  if (r != null) {
+    var a = t == null ? void 0 : t[n];
+    return a == null ? {
+      x: 0,
+      y: e.top
+    } : {
+      x: a,
+      y: e.top
+    };
+  }
+});
+o(x, E, (e, r) => {
+  var t = typeof r.width == "number" ? r.width : q;
+  return {
+    width: t,
+    height: e.height
+  };
+});
+var Pt = (e, r, t, n) => {
+  if (t != null) {
+    var a = t.allowDuplicatedCategory, l = t.type, i = t.dataKey, u = M(e, n), c = r.map((f) => f.value), d = c.filter((f) => f != null);
+    if (i && u && l === "category" && a && oe(d))
+      return c;
+  }
+}, te = o([w, j, h, v], Pt);
+o([w, gr, _, V, te, re, X, Q, v], (e, r, t, n, a, l, i, u, c) => {
+  if (r != null) {
+    var d = M(e, c);
+    return {
+      angle: r.angle,
+      interval: r.interval,
+      minTickGap: r.minTickGap,
+      orientation: r.orientation,
+      tick: r.tick,
+      tickCount: r.tickCount,
+      tickFormatter: r.tickFormatter,
+      ticks: r.ticks,
+      type: r.type,
+      unit: r.unit,
+      axisType: c,
+      categoricalDomain: l,
+      duplicateDomain: a,
+      isCategorical: d,
+      niceTicks: u,
+      range: i,
+      realScaleType: t,
+      scale: n
+    };
+  }
+});
+var St = (e, r, t, n, a, l, i, u, c) => {
+  if (!(r == null || n == null)) {
+    var d = M(e, c), f = r.type, s = r.ticks, p = r.tickCount, D = (
+      // @ts-expect-error This is testing for `scaleBand` but for band axis the type is reported as `band` so this looks like a dead code with a workaround elsewhere?
+      t === "scaleBand" && typeof n.bandwidth == "function" ? n.bandwidth() / 2 : 2
+    ), A = f === "category" && n.bandwidth ? n.bandwidth() / D : 0;
+    A = c === "angleAxis" && l != null && l.length >= 2 ? de(l[0] - l[1]) * 2 * A : A;
+    var P = s || a;
+    return P ? P.map((m, k) => {
+      var y = i ? i.indexOf(m) : m, C = n.map(y);
+      return g(C) ? {
+        index: k,
+        coordinate: C + A,
+        value: m,
+        offset: A
+      } : null;
+    }).filter(I) : d && u ? u.map((m, k) => {
+      var y = n.map(m);
+      return g(y) ? {
+        coordinate: y + A,
+        value: m,
+        index: k,
+        offset: A
+      } : null;
+    }).filter(I) : n.ticks ? n.ticks(p).map((m, k) => {
+      var y = n.map(m);
+      return g(y) ? {
+        coordinate: y + A,
+        value: m,
+        index: k,
+        offset: A
+      } : null;
+    }).filter(I) : n.domain().map((m, k) => {
+      var y = n.map(m);
+      return g(y) ? {
+        coordinate: y + A,
+        // @ts-expect-error can't use Date as index
+        value: i ? i[m] : m,
+        index: k,
+        offset: A
+      } : null;
+    }).filter(I);
+  }
+};
+o([w, B, _, V, Q, X, te, re, v], St);
+var Bt = (e, r, t, n, a, l, i) => {
+  if (!(r == null || t == null || n == null || n[0] === n[1])) {
+    var u = M(e, i), c = r.tickCount, d = 0;
+    return d = i === "angleAxis" && (n == null ? void 0 : n.length) >= 2 ? de(n[0] - n[1]) * 2 * d : d, u && l ? l.map((f, s) => {
+      var p = t.map(f);
+      return g(p) ? {
+        coordinate: p + d,
+        value: f,
+        index: s,
+        offset: d
+      } : null;
+    }).filter(I) : t.ticks ? t.ticks(c).map((f, s) => {
+      var p = t.map(f);
+      return g(p) ? {
+        coordinate: p + d,
+        value: f,
+        index: s,
+        offset: d
+      } : null;
+    }).filter(I) : t.domain().map((f, s) => {
+      var p = t.map(f);
+      return g(p) ? {
+        coordinate: p + d,
+        // @ts-expect-error can't use unknown as index
+        value: a ? a[f] : f,
+        index: s,
+        offset: d
+      } : null;
+    }).filter(I);
+  }
+};
+o([w, B, V, X, te, re, v], Bt);
+o(h, V, (e, r) => {
+  if (!(e == null || r == null))
+    return z(z({}, e), {}, {
+      scale: r
+    });
+});
+var jt = o([h, _, J, Ke], be), zt = o([jt], ge);
+o((e, r, t) => L(e, t), zt, (e, r) => {
+  if (!(e == null || r == null))
+    return z(z({}, e), {}, {
+      scale: r
+    });
+});
+var bn = o([w, fe, se], (e, r, t) => {
+  switch (e) {
+    case "horizontal":
+      return r.some((n) => n.reversed) ? "right-to-left" : "left-to-right";
+    case "vertical":
+      return t.some((n) => n.reversed) ? "bottom-to-top" : "top-to-bottom";
+    // TODO: make this better. For now, right arrow triggers "forward", left arrow "back"
+    // however, the tooltip moves an unintuitive direction because of how the indices are rendered
+    case "centric":
+    case "radial":
+      return "left-to-right";
+    default:
+      return;
+  }
+}), Gt = (e, r, t) => {
+  var n;
+  return (n = e.renderedTicks[r]) === null || n === void 0 ? void 0 : n[t];
+};
+o([Gt], (e) => {
+  if (!(!e || e.length === 0))
+    return (r) => {
+      var t, n = 1 / 0, a = e[0];
+      for (var l of e) {
+        var i = Math.abs(l.coordinate - r);
+        i < n && (n = i, a = l);
+      }
+      return (t = a) === null || t === void 0 ? void 0 : t.value;
+    };
+});
+export {
+  Mr as combineAllAppliedValues,
+  Tr as combineAppliedValues,
+  et as combineAreasDomain,
+  st as combineAxisDomain,
+  mt as combineAxisDomainWithNiceTicks,
+  St as combineAxisTicks,
+  xt as combineCategoricalDomain,
+  Nr as combineDisplayedData,
+  Vr as combineDomainOfAllAppliedNumericalValuesIncludingErrorValues,
+  zr as combineDomainOfStackGroups,
+  Jr as combineDotsDomain,
+  Pt as combineDuplicateDomain,
+  Bt as combineGraphicalItemTicks,
+  Or as combineGraphicalItemsData,
+  xr as combineGraphicalItemsSettings,
+  at as combineLinesDomain,
+  vt as combineNiceTicks,
+  ot as combineNumericTicksDomain,
+  ut as combineNumericalDomain,
+  Br as combineStackGroups,
+  F as defaultNumericDomain,
+  Cr as filterGraphicalNotStackedItems,
+  Z as filterReferenceElements,
+  Oe as getDomainDefinition,
+  Pr as getErrorDomainByDataKey,
+  mr as implicitXAxis,
+  hr as implicitYAxis,
+  yr as implicitZAxis,
+  Ce as isErrorBarRelevantForAxisType,
+  Dr as itemAxisPredicate,
+  $ as mergeDomains,
+  j as selectAllAppliedValues,
+  Te as selectAllErrorBarSettings,
+  Tt as selectAllXAxesOffsetSteps,
+  Mt as selectAllYAxesOffsetSteps,
+  Er as selectAnyCartesianItemsUsesChartData,
+  J as selectAxisDomain,
+  pt as selectAxisDomainIncludingNiceTicks,
+  X as selectAxisRange,
+  Ke as selectAxisRangeWithReverse,
+  V as selectAxisScale,
+  h as selectBaseAxis,
+  At as selectCalculatedXAxisPadding,
+  yt as selectCalculatedYAxisPadding,
+  xe as selectCartesianGraphicalItemsData,
+  K as selectCartesianItemsSettings,
+  re as selectCategoricalDomain,
+  bn as selectChartDirection,
+  wt as selectCheckedAxisDomain,
+  U as selectDisplayedData,
+  Sr as selectDisplayedStackedData,
+  Ee as selectDomainDefinition,
+  Ne as selectDomainFromUserPreference,
+  Rr as selectDomainOfStackGroups,
+  te as selectDuplicateDomain,
+  br as selectHasBar,
+  Q as selectNiceTicks,
+  ct as selectNumericTicksDomain,
+  dt as selectNumericalDomain,
+  _ as selectRealScaleType,
+  qr as selectReferenceAreas,
+  Lr as selectReferenceAreasByAxis,
+  $r as selectReferenceDots,
+  Hr as selectReferenceDotsByAxis,
+  Ur as selectReferenceLines,
+  Zr as selectReferenceLinesByAxis,
+  B as selectRenderableAxisSettings,
+  Gt as selectRenderedTicksOfAxis,
+  ht as selectSmallestDistanceBetweenValues,
+  _r as selectSortedDataPoints,
+  jr as selectStackGroups,
+  we as selectStackedCartesianItemsSettings,
+  Ie as selectTooltipAxis,
+  gn as selectTooltipAxisDataKey,
+  kr as selectUnfilteredCartesianItems,
+  Dt as selectXAxisRange,
+  O as selectXAxisSettings,
+  pr as selectXAxisSettingsNoDefaults,
+  kt as selectYAxisRange,
+  E as selectYAxisSettings,
+  Ar as selectYAxisSettingsNoDefaults,
+  L as selectZAxisSettings
+};