@acronis-platform/shadcn-uikit 0.5.0 → 0.6.0

package/dist/node_modules/.pnpm/recharts@3.6.0_@types_react@18.3.27_react-dom@18.3.1_react@18.3.1__react-is@19.2.3_react@18.3.1_redux@5.0.1/node_modules/recharts/es6/state/selectors/axisSelectors.js

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