@acronis-platform/shadcn-uikit 0.34.0 → 0.36.3

package/dist/node_modules/.pnpm/recharts@3.8.1_@types_react@19.2.15_react-dom@19.2.6_react@19.2.6__react-is@19.2.6_react@19.2.6_redux@5.0.1/node_modules/recharts/es6/state/selectors/axisSelectors.js

@@ -0,0 +1,908 @@
+import { createSelector as l } from "../../../../../../reselect@5.1.1/node_modules/reselect/dist/reselect.js";
+import ue from "../../../../../../../../_virtual/range.js";
+import { selectChartLayout as k } from "../../context/chartLayoutContext.js";
+import { getValueByDataKey as P, isCategoricalAxis as K, getDomainOfStackGroups as Te, getStackedData as Be } from "../../util/ChartUtils.js";
+import { selectChartDataWithIndexesIfNotInPanoramaPosition4 as $, selectChartDataWithIndexes as Se, selectChartDataSliceIfNotInPanorama as _e } from "./dataSelectors.js";
+import { parseNumericalUserDomain as Ge, isWellFormedNumberDomain as S, numericalDomainSpecifiedWithoutRequiringData as ze } from "../../util/isDomainSpecifiedByUser.js";
+import { hasDuplicate as oe, isNumOrStr as ce, isNotNil as C, isNan as Re, getPercentValue as je, mathSign as de } from "../../util/DataUtils.js";
+import { isWellBehavedNumber as y } from "../../util/isWellBehavedNumber.js";
+import { selectChartHeight as Ve, selectChartWidth as Xe } 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 Ye, selectStackOffsetType as pe, selectReverseStackOrder as We, selectChartName as Fe } from "./rootPropsSelectors.js";
+import { selectRadiusAxis as he, selectAngleAxis as Ae, selectRadiusAxisRange as $e, selectAngleAxisRange as qe } from "./polarAxisSelectors.js";
+import { pickAxisType as v } from "./pickAxisType.js";
+import { pickAxisId as R } from "./pickAxisId.js";
+import { combineAxisRangeWithReverse as He } from "./combiners/combineAxisRangeWithReverse.js";
+import { DEFAULT_Y_AXIS_WIDTH as q } from "../../util/Constants.js";
+import { getStackSeriesIdentifier as Ue } from "../../util/stacks/getStackSeriesIdentifier.js";
+import { combineDisplayedStackedData as Le } from "./combiners/combineDisplayedStackedData.js";
+import { isStacked as Ze } from "../types/StackedGraphicalItem.js";
+import { numberDomainEqualityCheck as H } from "./numberDomainEqualityCheck.js";
+import { emptyArraysAreEqualCheck as ge } from "./arrayEqualityCheck.js";
+import { selectTooltipAxisType as Je } from "./selectTooltipAxisType.js";
+import { selectTooltipAxisId as Qe } from "./selectTooltipAxisId.js";
+import { rechartsScaleFactory as ye } from "../../util/scale/RechartsScale.js";
+import { combineCheckedDomain as er } from "./combiners/combineCheckedDomain.js";
+import { combineConfiguredScale as be } from "./combiners/combineConfiguredScale.js";
+import { combineRealScaleType as rr } from "./combiners/combineRealScaleType.js";
+import { createCategoricalInverse as tr } from "../../util/scale/createCategoricalInverse.js";
+import { combineInverseScaleFunction as nr } from "./combiners/combineInverseScaleFunction.js";
+import { getNiceTickValues as ne, getTickValuesFixedDomain as ie } from "../../util/scale/getNiceTickValues.js";
+function ae(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    r && (n = n.filter(function(i) {
+      return Object.getOwnPropertyDescriptor(e, i).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 ? ae(Object(t), !0).forEach(function(n) {
+      ir(e, n, t[n]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ae(Object(t)).forEach(function(n) {
+      Object.defineProperty(e, n, Object.getOwnPropertyDescriptor(t, n));
+    });
+  }
+  return e;
+}
+function ir(e, r, t) {
+  return (r = ar(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e;
+}
+function ar(e) {
+  var r = lr(e, "string");
+  return typeof r == "symbol" ? r : r + "";
+}
+function lr(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);
+}
+var W = [0, "auto"], ur = {
+  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"
+}, or = (e, r) => e.cartesianAxis.xAxis[r], O = (e, r) => {
+  var t = or(e, r);
+  return t ?? ur;
+}, cr = {
+  allowDataOverflow: !1,
+  allowDecimals: !0,
+  allowDuplicatedCategory: !0,
+  angle: 0,
+  dataKey: void 0,
+  domain: W,
+  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
+}, dr = (e, r) => e.cartesianAxis.yAxis[r], I = (e, r) => {
+  var t = dr(e, r);
+  return t ?? cr;
+}, fr = {
+  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: ""
+}, U = (e, r) => {
+  var t = e.cartesianAxis.zAxis[r];
+  return t ?? fr;
+}, A = (e, r, t) => {
+  switch (r) {
+    case "xAxis":
+      return O(e, t);
+    case "yAxis":
+      return I(e, t);
+    case "zAxis":
+      return U(e, t);
+    case "angleAxis":
+      return Ae(e, t);
+    case "radiusAxis":
+      return he(e, t);
+    default:
+      throw new Error("Unexpected axis type: ".concat(r));
+  }
+}, sr = (e, r, t) => {
+  switch (r) {
+    case "xAxis":
+      return O(e, t);
+    case "yAxis":
+      return I(e, t);
+    default:
+      throw new Error("Unexpected axis type: ".concat(r));
+  }
+}, _ = (e, r, t) => {
+  switch (r) {
+    case "xAxis":
+      return O(e, t);
+    case "yAxis":
+      return I(e, t);
+    case "angleAxis":
+      return Ae(e, t);
+    case "radiusAxis":
+      return he(e, t);
+    default:
+      throw new Error("Unexpected axis type: ".concat(r));
+  }
+}, vr = (e) => e.graphicalItems.cartesianItems.some((r) => r.type === "bar") || e.graphicalItems.polarItems.some((r) => r.type === "radialBar");
+function mr(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 pr = (e) => e.graphicalItems.cartesianItems, hr = l([v, R], mr), Ar = (e, r, t) => e.filter(t).filter((n) => (r == null ? void 0 : r.includeHidden) === !0 ? !0 : !n.hide), M = l([pr, A, hr], Ar, {
+  memoizeOptions: {
+    resultEqualityCheck: ge
+  }
+}), De = l([M], (e) => e.filter((r) => r.type === "area" || r.type === "bar").filter(Ze)), gr = (e) => e.filter((r) => !("stackId" in r) || r.stackId === void 0), yr = l([M], gr), br = (e) => e.map((r) => r.data).filter(Boolean).flat(1), Dr = l([M], (e) => e.some((r) => !r.data)), ke = l([M], br, {
+  memoizeOptions: {
+    resultEqualityCheck: ge
+  }
+}), kr = (e, r) => {
+  var {
+    chartData: t = [],
+    dataStartIndex: n,
+    dataEndIndex: i
+  } = r;
+  return e.length > 0 ? e : t.slice(n, i + 1);
+}, L = l([ke, $], kr), xr = (e, r, t) => (r == null ? void 0 : r.dataKey) != null ? e.map((n) => ({
+  value: P(n, r.dataKey)
+})) : t.length > 0 ? t.map((n) => n.dataKey).flatMap((n) => e.map((i) => ({
+  value: P(i, n)
+}))) : e.map((n) => ({
+  value: n
+})), wr = (e, r, t, n, i, u) => {
+  var {
+    chartData: a = [],
+    dataStartIndex: o,
+    dataEndIndex: c
+  } = n, d = xr(e, r, t);
+  if (i && (r == null ? void 0 : r.dataKey) != null && u.length > 0) {
+    var f = a.slice(o, c + 1), p = f.map((s) => ({
+      value: P(s, r.dataKey)
+    })).filter((s) => s.value != null);
+    return [...p, ...d];
+  }
+  return d;
+}, G = l([L, A, M, $, Dr, ke], wr);
+function N(e) {
+  if (ce(e) || e instanceof Date) {
+    var r = Number(e);
+    if (y(r))
+      return r;
+  }
+}
+function le(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 D(e) {
+  return e.map(N).filter(C);
+}
+function Cr(e, r) {
+  var t = N(e), n = N(r);
+  return t == null && n == null ? 0 : t == null ? -1 : n == null ? 1 : t - n;
+}
+var Or = l([G], (e) => e == null ? void 0 : e.map((r) => r.value).sort(Cr));
+function xe(e, r) {
+  switch (e) {
+    case "xAxis":
+      return r.direction === "x";
+    case "yAxis":
+      return r.direction === "y";
+    default:
+      return !1;
+  }
+}
+function Ir(e, r, t) {
+  if (!t)
+    return [];
+  if (!t.length)
+    return [];
+  var n;
+  if (typeof r == "number" && !Re(r))
+    n = r;
+  else if (Array.isArray(r)) {
+    var i = D(r);
+    i.length > 0 && (n = Math.max(...i));
+  }
+  return n == null ? [] : D(t.flatMap((u) => {
+    var a = P(e, u.dataKey), o, c;
+    if (Array.isArray(a) ? [o, c] = a : o = c = a, !(!y(o) || !y(c)))
+      return [n - o, n + c];
+  }));
+}
+var we = (e) => {
+  var r = Je(e), t = Qe(e);
+  return _(e, r, t);
+}, dn = l([we], (e) => e == null ? void 0 : e.dataKey), Er = l([De, $, we], Le), Nr = (e, r, t, n) => {
+  var i = {}, u = r.reduce((a, o) => {
+    if (o.stackId == null)
+      return a;
+    var c = a[o.stackId];
+    return c == null && (c = []), c.push(o), a[o.stackId] = c, a;
+  }, i);
+  return Object.fromEntries(Object.entries(u).map((a) => {
+    var [o, c] = a, d = n ? [...c].reverse() : c, f = d.map(Ue);
+    return [o, {
+      // @ts-expect-error getStackedData requires that the input is array of objects, Recharts does not test for that
+      stackedData: Be(e, f, t),
+      graphicalItems: d
+    }];
+  }));
+}, Pr = l([Er, De, pe, We], Nr), Kr = (e, r, t, n) => {
+  var {
+    dataStartIndex: i,
+    dataEndIndex: u
+  } = r;
+  if (n == null && t !== "zAxis") {
+    var a = Te(e, i, u);
+    if (!(a != null && a[0] === 0 && a[1] === 0))
+      return a;
+  }
+}, Mr = l([A], (e) => e.allowDataOverflow), Ce = (e) => {
+  var r;
+  if (e == null || !("domain" in e))
+    return W;
+  if (e.domain != null)
+    return e.domain;
+  if ("ticks" in e && e.ticks != null) {
+    if (e.type === "number") {
+      var t = D(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 : W;
+}, Oe = l([A], Ce), Ie = l([Oe, Mr], ze), Tr = l([Pr, Se, v, Ie], Kr, {
+  memoizeOptions: {
+    resultEqualityCheck: H
+  }
+}), Ee = (e) => e.errorBars, Br = (e, r, t) => e.flatMap((n) => r[n.id]).filter(Boolean).filter((n) => xe(t, n)), F = function() {
+  for (var r = arguments.length, t = new Array(r), n = 0; n < r; n++)
+    t[n] = arguments[n];
+  var i = t.filter(Boolean);
+  if (i.length !== 0) {
+    var u = i.flat(), a = Math.min(...u), o = Math.max(...u);
+    return [a, o];
+  }
+}, Sr = function(r, t, n, i, u) {
+  var a = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : [], o, c;
+  if (n.length > 0 && n.forEach((d) => {
+    var f, p = d.data != null ? [...d.data] : a, s = (f = i[d.id]) === null || f === void 0 ? void 0 : f.filter((E) => xe(u, E));
+    p.forEach((E) => {
+      var h, B = P(E, (h = t.dataKey) !== null && h !== void 0 ? h : d.dataKey), m = Ir(E, B, s);
+      if (m.length >= 2) {
+        var b = Math.min(...m), g = Math.max(...m);
+        (o == null || b < o) && (o = b), (c == null || g > c) && (c = g);
+      }
+      var w = le(B);
+      w != null && (o = o == null ? w[0] : Math.min(o, w[0]), c = c == null ? w[1] : Math.max(c, w[1]));
+    });
+  }), (t == null ? void 0 : t.dataKey) != null && n.length === 0 && r.forEach((d) => {
+    var f = le(P(d, t.dataKey));
+    f != null && (o = o == null ? f[0] : Math.min(o, f[0]), c = c == null ? f[1] : Math.max(c, f[1]));
+  }), y(o) && y(c))
+    return [o, c];
+}, _r = l([L, A, yr, Ee, v, _e], Sr, {
+  memoizeOptions: {
+    resultEqualityCheck: H
+  }
+});
+function Gr(e) {
+  var {
+    value: r
+  } = e;
+  if (ce(r) || r instanceof Date)
+    return r;
+}
+var zr = (e, r, t) => {
+  var n = e.map(Gr).filter((i) => i != null);
+  return t && (r.dataKey == null || r.allowDuplicatedCategory && oe(n)) ? ue(0, e.length) : r.allowDuplicatedCategory ? n : Array.from(new Set(n));
+}, Rr = (e) => e.referenceElements.dots, Z = (e, r, t) => e.filter((n) => n.ifOverflow === "extendDomain").filter((n) => r === "xAxis" ? n.xAxisId === t : n.yAxisId === t), jr = l([Rr, v, R], Z), Vr = (e) => e.referenceElements.areas, Xr = l([Vr, v, R], Z), Yr = (e) => e.referenceElements.lines, Wr = l([Yr, v, R], Z), Fr = (e, r) => {
+  if (e != null) {
+    var t = D(e.map((n) => r === "xAxis" ? n.x : n.y));
+    if (t.length !== 0)
+      return [Math.min(...t), Math.max(...t)];
+  }
+}, $r = l(jr, v, Fr), qr = (e, r) => {
+  if (e != null) {
+    var t = D(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)];
+  }
+}, Hr = l([Xr, v], qr);
+function Ur(e) {
+  var r;
+  if (e.x != null)
+    return D([e.x]);
+  var t = (r = e.segment) === null || r === void 0 ? void 0 : r.map((n) => n.x);
+  return t == null || t.length === 0 ? [] : D(t);
+}
+function Lr(e) {
+  var r;
+  if (e.y != null)
+    return D([e.y]);
+  var t = (r = e.segment) === null || r === void 0 ? void 0 : r.map((n) => n.y);
+  return t == null || t.length === 0 ? [] : D(t);
+}
+var Zr = (e, r) => {
+  if (e != null) {
+    var t = e.flatMap((n) => r === "xAxis" ? Ur(n) : Lr(n));
+    if (t.length !== 0)
+      return [Math.min(...t), Math.max(...t)];
+  }
+}, Jr = l([Wr, v], Zr), Qr = l($r, Jr, Hr, (e, r, t) => F(e, t, r)), et = (e, r, t, n, i, u, a, o) => {
+  if (t != null)
+    return t;
+  var c = a === "vertical" && o === "xAxis" || a === "horizontal" && o === "yAxis", d = c ? F(n, u, i) : F(u, i);
+  return Ge(r, d, e.allowDataOverflow);
+}, rt = l([A, Oe, Ie, Tr, _r, Qr, k, v], et, {
+  memoizeOptions: {
+    resultEqualityCheck: H
+  }
+}), tt = [0, 1], nt = (e, r, t, n, i, u, a) => {
+  if (!((e == null || t == null || t.length === 0) && a === void 0)) {
+    var {
+      dataKey: o,
+      type: c
+    } = e, d = K(r, u);
+    if (d && o == null) {
+      var f;
+      return ue(0, (f = t == null ? void 0 : t.length) !== null && f !== void 0 ? f : 0);
+    }
+    return c === "category" ? zr(n, e, d) : i === "expand" && !d ? tt : a;
+  }
+}, J = l([A, k, L, G, pe, v, rt], nt), T = l([A, vr, Fe], rr), it = (e, r, t) => {
+  var {
+    niceTicks: n
+  } = r;
+  if (n !== "none") {
+    var i = Ce(r), u = Array.isArray(i) && (i[0] === "auto" || i[1] === "auto");
+    if ((n === "snap125" || n === "adaptive") && r != null && r.tickCount && S(e)) {
+      if (u)
+        return ne(e, r.tickCount, r.allowDecimals, n);
+      if (r.type === "number")
+        return ie(e, r.tickCount, r.allowDecimals, n);
+    }
+    if (n === "auto" && t === "linear" && r != null && r.tickCount) {
+      if (u && S(e))
+        return ne(e, r.tickCount, r.allowDecimals, "adaptive");
+      if (r.type === "number" && S(e))
+        return ie(e, r.tickCount, r.allowDecimals, "adaptive");
+    }
+  }
+}, Q = l([J, _, T], it), at = (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 i, u, a = r[0], o = (i = t[0]) !== null && i !== void 0 ? i : 0, c = r[1], d = (u = t[t.length - 1]) !== null && u !== void 0 ? u : 0;
+    return [Math.min(a, o), Math.max(c, d)];
+  }
+  return r;
+}, lt = l([A, J, Q, v], at), ut = l(G, A, (e, r) => {
+  if (!(!r || r.type !== "number")) {
+    var t = 1 / 0, n = Array.from(D(e.map((p) => p.value))).sort((p, s) => p - s), i = n[0], u = n[n.length - 1];
+    if (i == null || u == null)
+      return 1 / 0;
+    var a = u - i;
+    if (a === 0)
+      return 1 / 0;
+    for (var o = 0; o < n.length - 1; o++) {
+      var c = n[o], d = n[o + 1];
+      if (!(c == null || d == null)) {
+        var f = d - c;
+        t = Math.min(t, f);
+      }
+    }
+    return t / a;
+  }
+}), Ne = l(ut, k, Ye, x, (e, r, t, n, i) => i, (e, r, t, n, i) => {
+  if (!y(e))
+    return 0;
+  var u = r === "vertical" ? n.height : n.width;
+  if (i === "gap")
+    return e * u / 2;
+  if (i === "no-gap") {
+    var a = je(t, e * u), o = e * u / 2;
+    return o - a - (o - a) / u * a;
+  }
+  return 0;
+}), ot = (e, r, t) => {
+  var n = O(e, r);
+  return n == null || typeof n.padding != "string" ? 0 : Ne(e, "xAxis", r, t, n.padding);
+}, ct = (e, r, t) => {
+  var n = I(e, r);
+  return n == null || typeof n.padding != "string" ? 0 : Ne(e, "yAxis", r, t, n.padding);
+}, dt = l(O, ot, (e, r) => {
+  var t, n;
+  if (e == null)
+    return {
+      left: 0,
+      right: 0
+    };
+  var {
+    padding: i
+  } = e;
+  return typeof i == "string" ? {
+    left: r,
+    right: r
+  } : {
+    left: ((t = i.left) !== null && t !== void 0 ? t : 0) + r,
+    right: ((n = i.right) !== null && n !== void 0 ? n : 0) + r
+  };
+}), ft = l(I, ct, (e, r) => {
+  var t, n;
+  if (e == null)
+    return {
+      top: 0,
+      bottom: 0
+    };
+  var {
+    padding: i
+  } = e;
+  return typeof i == "string" ? {
+    top: r,
+    bottom: r
+  } : {
+    top: ((t = i.top) !== null && t !== void 0 ? t : 0) + r,
+    bottom: ((n = i.bottom) !== null && n !== void 0 ? n : 0) + r
+  };
+}), st = l([x, dt, ve, me, (e, r, t) => t], (e, r, t, n, i) => {
+  var {
+    padding: u
+  } = n;
+  return i ? [u.left, t.width - u.right] : [e.left + r.left, e.left + e.width - r.right];
+}), vt = l([x, k, ft, ve, me, (e, r, t) => t], (e, r, t, n, i, u) => {
+  var {
+    padding: a
+  } = i;
+  return u ? [n.height - a.bottom, a.top] : r === "horizontal" ? [e.top + e.height - t.bottom, e.top + t.top] : [e.top + t.top, e.top + e.height - t.bottom];
+}), j = (e, r, t, n) => {
+  var i;
+  switch (r) {
+    case "xAxis":
+      return st(e, t, n);
+    case "yAxis":
+      return vt(e, t, n);
+    case "zAxis":
+      return (i = U(e, t)) === null || i === void 0 ? void 0 : i.range;
+    case "angleAxis":
+      return qe(e);
+    case "radiusAxis":
+      return $e(e, t);
+    default:
+      return;
+  }
+}, Pe = l([A, j], He), mt = l([T, lt], er), ee = l([A, T, mt, Pe], be), pt = (e, r, t, n) => {
+  if (!(t == null || t.dataKey == null)) {
+    var {
+      type: i,
+      scale: u
+    } = t, a = K(e, n);
+    if (a && (i === "number" || u !== "auto"))
+      return r.map((o) => o.value);
+  }
+}, re = l([k, G, _, v], pt), V = l([ee], ye);
+l([ee], nr);
+l([ee, Or], tr);
+l([M, Ee, v], Br);
+function Ke(e, r) {
+  return e.id < r.id ? -1 : e.id > r.id ? 1 : 0;
+}
+var X = (e, r) => r, Y = (e, r, t) => t, ht = l(fe, X, Y, (e, r, t) => e.filter((n) => n.orientation === r).filter((n) => n.mirror === t).sort(Ke)), At = l(se, X, Y, (e, r, t) => e.filter((n) => n.orientation === r).filter((n) => n.mirror === t).sort(Ke)), Me = (e, r) => ({
+  width: e.width,
+  height: r.height
+}), gt = (e, r) => {
+  var t = typeof r.width == "number" ? r.width : q;
+  return {
+    width: t,
+    height: e.height
+  };
+};
+l(x, O, Me);
+var yt = (e, r, t) => {
+  switch (r) {
+    case "top":
+      return e.top;
+    case "bottom":
+      return t - e.bottom;
+    default:
+      return 0;
+  }
+}, bt = (e, r, t) => {
+  switch (r) {
+    case "left":
+      return e.left;
+    case "right":
+      return t - e.right;
+    default:
+      return 0;
+  }
+}, Dt = l(Ve, x, ht, X, Y, (e, r, t, n, i) => {
+  var u = {}, a;
+  return t.forEach((o) => {
+    var c = Me(r, o);
+    a == null && (a = yt(r, n, e));
+    var d = n === "top" && !i || n === "bottom" && i;
+    u[o.id] = a - Number(d) * c.height, a += (d ? -1 : 1) * c.height;
+  }), u;
+}), kt = l(Xe, x, At, X, Y, (e, r, t, n, i) => {
+  var u = {}, a;
+  return t.forEach((o) => {
+    var c = gt(r, o);
+    a == null && (a = bt(r, n, e));
+    var d = n === "left" && !i || n === "right" && i;
+    u[o.id] = a - Number(d) * c.width, a += (d ? -1 : 1) * c.width;
+  }), u;
+}), xt = (e, r) => {
+  var t = O(e, r);
+  if (t != null)
+    return Dt(e, t.orientation, t.mirror);
+};
+l([x, O, xt, (e, r) => r], (e, r, t, n) => {
+  if (r != null) {
+    var i = t == null ? void 0 : t[n];
+    return i == null ? {
+      x: e.left,
+      y: 0
+    } : {
+      x: e.left,
+      y: i
+    };
+  }
+});
+var wt = (e, r) => {
+  var t = I(e, r);
+  if (t != null)
+    return kt(e, t.orientation, t.mirror);
+};
+l([x, I, wt, (e, r) => r], (e, r, t, n) => {
+  if (r != null) {
+    var i = t == null ? void 0 : t[n];
+    return i == null ? {
+      x: 0,
+      y: e.top
+    } : {
+      x: i,
+      y: e.top
+    };
+  }
+});
+l(x, I, (e, r) => {
+  var t = typeof r.width == "number" ? r.width : q;
+  return {
+    width: t,
+    height: e.height
+  };
+});
+var Ct = (e, r, t, n) => {
+  if (t != null) {
+    var {
+      allowDuplicatedCategory: i,
+      type: u,
+      dataKey: a
+    } = t, o = K(e, n), c = r.map((f) => f.value), d = c.filter((f) => f != null);
+    if (a && o && u === "category" && i && oe(d))
+      return c;
+  }
+}, te = l([k, G, A, v], Ct);
+l([k, sr, T, V, te, re, j, Q, v], (e, r, t, n, i, u, a, o, c) => {
+  if (r != null) {
+    var d = K(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: u,
+      duplicateDomain: i,
+      isCategorical: d,
+      niceTicks: o,
+      range: a,
+      realScaleType: t,
+      scale: n
+    };
+  }
+});
+var Ot = (e, r, t, n, i, u, a, o, c) => {
+  if (!(r == null || n == null)) {
+    var d = K(e, c), {
+      type: f,
+      ticks: p,
+      tickCount: s
+    } = r, E = (
+      // @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
+    ), h = f === "category" && n.bandwidth ? n.bandwidth() / E : 0;
+    h = c === "angleAxis" && u != null && u.length >= 2 ? de(u[0] - u[1]) * 2 * h : h;
+    var B = p || i;
+    return B ? B.map((m, b) => {
+      var g = a ? a.indexOf(m) : m, w = n.map(g);
+      return y(w) ? {
+        index: b,
+        coordinate: w + h,
+        value: m,
+        offset: h
+      } : null;
+    }).filter(C) : d && o ? o.map((m, b) => {
+      var g = n.map(m);
+      return y(g) ? {
+        coordinate: g + h,
+        value: m,
+        index: b,
+        offset: h
+      } : null;
+    }).filter(C) : n.ticks ? n.ticks(s).map((m, b) => {
+      var g = n.map(m);
+      return y(g) ? {
+        coordinate: g + h,
+        value: m,
+        index: b,
+        offset: h
+      } : null;
+    }).filter(C) : n.domain().map((m, b) => {
+      var g = n.map(m);
+      return y(g) ? {
+        coordinate: g + h,
+        // @ts-expect-error can't use Date as index
+        value: a ? a[m] : m,
+        index: b,
+        offset: h
+      } : null;
+    }).filter(C);
+  }
+};
+l([k, _, T, V, Q, j, te, re, v], Ot);
+var It = (e, r, t, n, i, u, a) => {
+  if (!(r == null || t == null || n == null || n[0] === n[1])) {
+    var o = K(e, a), {
+      tickCount: c
+    } = r, d = 0;
+    return d = a === "angleAxis" && (n == null ? void 0 : n.length) >= 2 ? de(n[0] - n[1]) * 2 * d : d, o && u ? u.map((f, p) => {
+      var s = t.map(f);
+      return y(s) ? {
+        coordinate: s + d,
+        value: f,
+        index: p,
+        offset: d
+      } : null;
+    }).filter(C) : t.ticks ? t.ticks(c).map((f, p) => {
+      var s = t.map(f);
+      return y(s) ? {
+        coordinate: s + d,
+        value: f,
+        index: p,
+        offset: d
+      } : null;
+    }).filter(C) : t.domain().map((f, p) => {
+      var s = t.map(f);
+      return y(s) ? {
+        coordinate: s + d,
+        // @ts-expect-error can't use unknown as index
+        value: i ? i[f] : f,
+        index: p,
+        offset: d
+      } : null;
+    }).filter(C);
+  }
+};
+l([k, _, V, j, te, re, v], It);
+l(A, V, (e, r) => {
+  if (!(e == null || r == null))
+    return z(z({}, e), {}, {
+      scale: r
+    });
+});
+var Et = l([A, T, J, Pe], be), Nt = l([Et], ye);
+l((e, r, t) => U(e, t), Nt, (e, r) => {
+  if (!(e == null || r == null))
+    return z(z({}, e), {}, {
+      scale: r
+    });
+});
+l([k, 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;
+  }
+});
+var Pt = (e, r, t) => {
+  var n;
+  return (n = e.renderedTicks[r]) === null || n === void 0 ? void 0 : n[t];
+};
+l([Pt], (e) => {
+  if (!(!e || e.length === 0))
+    return (r) => {
+      var t, n = 1 / 0, i = e[0];
+      for (var u of e) {
+        var a = Math.abs(u.coordinate - r);
+        a < n && (n = a, i = u);
+      }
+      return (t = i) === null || t === void 0 ? void 0 : t.value;
+    };
+});
+export {
+  wr as combineAllAppliedValues,
+  xr as combineAppliedValues,
+  qr as combineAreasDomain,
+  nt as combineAxisDomain,
+  at as combineAxisDomainWithNiceTicks,
+  Ot as combineAxisTicks,
+  pt as combineCategoricalDomain,
+  kr as combineDisplayedData,
+  Sr as combineDomainOfAllAppliedNumericalValuesIncludingErrorValues,
+  Kr as combineDomainOfStackGroups,
+  Fr as combineDotsDomain,
+  Ct as combineDuplicateDomain,
+  It as combineGraphicalItemTicks,
+  br as combineGraphicalItemsData,
+  Ar as combineGraphicalItemsSettings,
+  Zr as combineLinesDomain,
+  it as combineNiceTicks,
+  et as combineNumericalDomain,
+  Nr as combineStackGroups,
+  W as defaultNumericDomain,
+  gr as filterGraphicalNotStackedItems,
+  Z as filterReferenceElements,
+  Ce as getDomainDefinition,
+  Ir as getErrorDomainByDataKey,
+  ur as implicitXAxis,
+  cr as implicitYAxis,
+  fr as implicitZAxis,
+  xe as isErrorBarRelevantForAxisType,
+  mr as itemAxisPredicate,
+  F as mergeDomains,
+  G as selectAllAppliedValues,
+  Ee as selectAllErrorBarSettings,
+  Dt as selectAllXAxesOffsetSteps,
+  kt as selectAllYAxesOffsetSteps,
+  Dr as selectAnyCartesianItemsUsesChartData,
+  J as selectAxisDomain,
+  lt as selectAxisDomainIncludingNiceTicks,
+  j as selectAxisRange,
+  Pe as selectAxisRangeWithReverse,
+  V as selectAxisScale,
+  A as selectBaseAxis,
+  ot as selectCalculatedXAxisPadding,
+  ct as selectCalculatedYAxisPadding,
+  ke as selectCartesianGraphicalItemsData,
+  M as selectCartesianItemsSettings,
+  re as selectCategoricalDomain,
+  mt as selectCheckedAxisDomain,
+  L as selectDisplayedData,
+  Er as selectDisplayedStackedData,
+  Oe as selectDomainDefinition,
+  Ie as selectDomainFromUserPreference,
+  Tr as selectDomainOfStackGroups,
+  te as selectDuplicateDomain,
+  vr as selectHasBar,
+  Q as selectNiceTicks,
+  rt as selectNumericalDomain,
+  T as selectRealScaleType,
+  Vr as selectReferenceAreas,
+  Xr as selectReferenceAreasByAxis,
+  Rr as selectReferenceDots,
+  jr as selectReferenceDotsByAxis,
+  Yr as selectReferenceLines,
+  Wr as selectReferenceLinesByAxis,
+  _ as selectRenderableAxisSettings,
+  Pt as selectRenderedTicksOfAxis,
+  ut as selectSmallestDistanceBetweenValues,
+  Or as selectSortedDataPoints,
+  Pr as selectStackGroups,
+  De as selectStackedCartesianItemsSettings,
+  we as selectTooltipAxis,
+  dn as selectTooltipAxisDataKey,
+  pr as selectUnfilteredCartesianItems,
+  st as selectXAxisRange,
+  O as selectXAxisSettings,
+  or as selectXAxisSettingsNoDefaults,
+  vt as selectYAxisRange,
+  I as selectYAxisSettings,
+  dr as selectYAxisSettingsNoDefaults,
+  U as selectZAxisSettings
+};
+//# sourceMappingURL=axisSelectors.js.map