@fluidattacks/design 8.1.0 → 8.3.0

package/dist/node_modules/react-stately/dist/private/calendar/useCalendarState.js

@@ -0,0 +1,254 @@
+import { constrainValue as m, isEqualDuration as de, alignCenter as j, isInvalid as I, alignEnd as H, alignStart as O, constrainStart as J, previousAvailableDate as ne } from "./utils.js";
+import { useControlledState as K } from "../utils/useControlledState.js";
+import { GregorianCalendar as ue } from "../../../../@internationalized/date/dist/private/calendars/GregorianCalendar.js";
+import { toCalendar as h, toCalendarDate as P } from "../../../../@internationalized/date/dist/private/conversion.js";
+import { today as oe, isEqualCalendar as fe, getWeeksInMonth as ce, startOfWeek as Q, getDayOfWeek as $e, isSameDay as x, endOfWeek as be, endOfMonth as ye, startOfMonth as me } from "../../../../@internationalized/date/dist/private/queries.js";
+import { DateFormatter as ve } from "../../../../@internationalized/date/dist/private/DateFormatter.js";
+import { useMemo as y, useState as M } from "react";
+function we(s) {
+  let A = y(() => new ve(s.locale), [
+    s.locale
+  ]), g = y(() => A.resolvedOptions(), [
+    A
+  ]), { locale: f, createCalendar: E, visibleDuration: a = {
+    months: 1
+  }, minValue: l, maxValue: i, selectionAlignment: T, isDateUnavailable: V, pageBehavior: B = "visible", selectionMode: R = "single", firstDayOfWeek: W, weeksInMonth: X } = s, b = y(() => E(g.calendar), [
+    E,
+    g.calendar
+  ]), [n, S] = K(s.value, s.defaultValue ?? null, s.onChange), u = y(() => Array.isArray(n) ? n.map((e) => h(P(e), b)) : n ? h(P(n), b) : null, [
+    n,
+    b
+  ]), N = y(() => {
+    let e = Array.isArray(n) ? n[0] : n;
+    return e && "timeZone" in e ? e.timeZone : g.timeZone;
+  }, [
+    n,
+    g.timeZone
+  ]), Y = y(() => s.focusedValue ? m(h(P(s.focusedValue), b), l, i) : void 0, [
+    s.focusedValue,
+    b,
+    l,
+    i
+  ]), _ = y(() => s.defaultFocusedValue ? m(h(P(s.defaultFocusedValue), b), l, i) : u ? m(Array.isArray(u) ? u[0] : u, l, i) : m(h(oe(N), b), l, i), [
+    s.defaultFocusedValue,
+    u,
+    N,
+    b,
+    l,
+    i
+  ]), [t, F] = K(Y, _, s.onFocusChange), p = () => {
+    switch (T) {
+      case "start":
+        return O(t, a, f, l, i);
+      case "end":
+        return H(t, a, f, l, i);
+      default:
+        return j(t, a, f, l, i);
+    }
+  }, [$, k] = M(p), [q, ee] = M(s.autoFocus || !1), [ae, te] = M(a);
+  de(a, ae) || (te(a), k(p()));
+  let C = y(() => {
+    let e = {
+      ...a
+    };
+    return e.days ? e.days-- : e.days = -1, $.add(e);
+  }, [
+    $,
+    a
+  ]), [se, le] = M(b);
+  if (!fe(b, se)) {
+    let e = h(t, b);
+    k(j(e, a, f, l, i)), F(e), le(b);
+  }
+  I(t, l, i) ? F(m(t, l, i)) : t.compare($) < 0 ? k(H(t, a, f, l, i)) : t.compare(C) > 0 && k(O(t, a, f, l, i));
+  function r(e) {
+    e = m(e, l, i), F(e);
+  }
+  function U(e) {
+    let o = m(e, l, i), d = ne(o, $, V);
+    if (!d) return null;
+    let c = Array.isArray(n) ? n[0] : n, D = h(d, c?.calendar || new ue());
+    return c && "hour" in c ? c.set(D) : D;
+  }
+  function L(e) {
+    if (!s.isDisabled && !s.isReadOnly) {
+      if (e === null) {
+        S(R === "multiple" ? [] : null);
+        return;
+      }
+      if (Array.isArray(e)) S(e.map(U).filter(Boolean));
+      else {
+        let o = U(e);
+        o && S(o);
+      }
+    }
+  }
+  let ie = y(() => u ? Array.isArray(u) ? u.some((e) => V?.(e) || I(e, l, i)) : V?.(u) || I(u, l, i) : !1, [
+    u,
+    V,
+    l,
+    i
+  ]), z = s.isInvalid || s.validationState === "invalid" || ie, re = z ? "invalid" : null, v = y(() => B === "visible" ? a : Z(a), [
+    B,
+    a
+  ]);
+  return {
+    isDisabled: s.isDisabled ?? !1,
+    isReadOnly: s.isReadOnly ?? !1,
+    value: u,
+    setValue: L,
+    selectionMode: R,
+    visibleDuration: a,
+    visibleRange: {
+      start: $,
+      end: C
+    },
+    minValue: l,
+    maxValue: i,
+    focusedDate: t,
+    timeZone: N,
+    validationState: re,
+    isValueInvalid: z,
+    setFocusedDate(e) {
+      r(e);
+    },
+    focusNextDay() {
+      r(t.add({
+        days: 1
+      }));
+    },
+    focusPreviousDay() {
+      r(t.subtract({
+        days: 1
+      }));
+    },
+    focusNextRow() {
+      a.days ? this.focusNextPage() : (a.weeks || a.months || a.years) && r(t.add({
+        weeks: 1
+      }));
+    },
+    focusPreviousRow() {
+      a.days ? this.focusPreviousPage() : (a.weeks || a.months || a.years) && r(t.subtract({
+        weeks: 1
+      }));
+    },
+    focusNextPage() {
+      let e = $.add(v);
+      F(m(t.add(v), l, i)), k(O(J(t, e, v, f, l, i), v, f));
+    },
+    focusPreviousPage() {
+      let e = $.subtract(v);
+      F(m(t.subtract(v), l, i)), k(O(J(t, e, v, f, l, i), v, f));
+    },
+    focusSectionStart() {
+      a.days ? r($) : a.weeks ? r(Q(t, f)) : (a.months || a.years) && r(me(t));
+    },
+    focusSectionEnd() {
+      a.days ? r(C) : a.weeks ? r(be(t, f)) : (a.months || a.years) && r(ye(t));
+    },
+    focusNextSection(e) {
+      if (!e && !a.days) {
+        r(t.add(Z(a)));
+        return;
+      }
+      a.days ? this.focusNextPage() : a.weeks ? r(t.add({
+        months: 1
+      })) : (a.months || a.years) && r(t.add({
+        years: 1
+      }));
+    },
+    focusPreviousSection(e) {
+      if (!e && !a.days) {
+        r(t.subtract(Z(a)));
+        return;
+      }
+      a.days ? this.focusPreviousPage() : a.weeks ? r(t.subtract({
+        months: 1
+      })) : (a.months || a.years) && r(t.subtract({
+        years: 1
+      }));
+    },
+    selectFocusedDate() {
+      V && V(t) || this.selectDate(t);
+    },
+    selectDate(e) {
+      if (!(s.isDisabled || s.isReadOnly))
+        if (R === "multiple" && e != null) {
+          let o = U(e);
+          if (!o) return;
+          let d = [];
+          Array.isArray(n) ? d = n : n != null && (d = [
+            n
+          ]);
+          let c = d.findIndex((w) => x(w, o)), D = c >= 0 ? d.slice(0, c).concat(d.slice(c + 1)) : [
+            ...d,
+            o
+          ];
+          S(D);
+        } else L(e);
+    },
+    isFocused: q,
+    setFocused: ee,
+    isInvalid(e) {
+      return I(e, l, i);
+    },
+    isSelected(e) {
+      return !u || this.isCellDisabled(e) || this.isCellUnavailable(e) ? !1 : Array.isArray(u) ? u.some((o) => x(o, e)) : x(e, u);
+    },
+    isCellFocused(e) {
+      return q && t && x(e, t);
+    },
+    isCellDisabled(e) {
+      return s.isDisabled || e.compare($) < 0 || e.compare(C) > 0 || this.isInvalid(e);
+    },
+    isCellUnavailable(e) {
+      return s.isDateUnavailable ? s.isDateUnavailable(e) : !1;
+    },
+    isPreviousVisibleRangeInvalid() {
+      let e = $.subtract({
+        days: 1
+      });
+      return x(e, $) || this.isInvalid(e);
+    },
+    isNextVisibleRangeInvalid() {
+      let e = C.add({
+        days: 1
+      });
+      return x(e, C) || this.isInvalid(e);
+    },
+    getDatesInWeek(e, o = $) {
+      let d = o.add({
+        weeks: e
+      }), c = [], D = a.days && a.days < 7 ? a.days : 7;
+      if (D === 7) {
+        d = Q(d, f, W);
+        let w = $e(d, f, W);
+        for (let G = 0; G < w; G++) c.push(null);
+      }
+      for (; c.length < D; ) {
+        c.push(d);
+        let w = d.add({
+          days: 1
+        });
+        if (x(d, w)) break;
+        d = w;
+      }
+      for (; c.length < D; ) c.push(null);
+      return c;
+    },
+    getWeeksInMonth(e = $) {
+      let o = X || ce(e, f, W);
+      return (a.weeks || a.days) && (o = a.weeks ?? 0, a.days && (o += Math.ceil(a.days / 7))), o;
+    }
+  };
+}
+function Z(s) {
+  let A = {
+    ...s
+  };
+  for (let g in s) A[g] = 1;
+  return A;
+}
+export {
+  we as useCalendarState
+};

package/dist/node_modules/react-stately/dist/private/calendar/useRangeCalendarState.js

@@ -0,0 +1,140 @@
+import { alignCenter as O, isInvalid as h, constrainValue as j, previousAvailableDate as q } from "./utils.js";
+import { useCalendarState as z } from "./useCalendarState.js";
+import { useControlledState as H } from "../utils/useControlledState.js";
+import { GregorianCalendar as J } from "../../../../@internationalized/date/dist/private/calendars/GregorianCalendar.js";
+import { toCalendarDate as I, toCalendar as K } from "../../../../@internationalized/date/dist/private/conversion.js";
+import { maxDate as L, minDate as Q } from "../../../../@internationalized/date/dist/private/queries.js";
+import { useState as k, useMemo as m, useCallback as T } from "react";
+function le(e) {
+  let { value: l, defaultValue: g, onChange: f, createCalendar: d, locale: D, visibleDuration: c = {
+    months: 1
+  }, minValue: $, maxValue: v, ...B } = e, [t, p] = H(l, g || null, f), [n, x] = k(null), y = "center";
+  if (t && t.start && t.end) {
+    let s = O(I(t.start), c, D, $, v).add(c).subtract({
+      days: 1
+    });
+    t.end.compare(s) > 0 && (y = "start");
+  }
+  let r = m(() => {
+    let a = e.isDateUnavailable;
+    if (a)
+      return (s) => a(s, n);
+  }, [
+    e.isDateUnavailable,
+    n
+  ]), S = T((a) => {
+    if (a && r && !e.allowsNonContiguousRanges) {
+      const s = w(a, r, c, -1), o = w(a, r, c, 1);
+      return {
+        start: s,
+        end: o
+      };
+    } else return null;
+  }, [
+    r,
+    c,
+    e.allowsNonContiguousRanges
+  ]), b = m(() => S(n), [
+    S,
+    n
+  ]), V = m(() => L($, b?.start), [
+    $,
+    b
+  ]), U = m(() => Q(v, b?.end), [
+    v,
+    b
+  ]), i = z({
+    ...B,
+    value: t && t.start,
+    createCalendar: d,
+    locale: D,
+    visibleDuration: c,
+    minValue: V,
+    maxValue: U,
+    selectionAlignment: e.selectionAlignment || y,
+    isDateUnavailable: r
+  }), C = n ? A(n, i.focusedDate) : t && A(t.start, t.end), R = (a) => {
+    if (e.isReadOnly) return;
+    const s = j(a, V, U), o = q(s, i.visibleRange.start, r);
+    if (o)
+      if (!n) x(o);
+      else {
+        let u = A(n, o);
+        u && p({
+          start: P(u.start, t?.start),
+          end: P(u.end, t?.end)
+        }), x(null);
+      }
+  }, [E, G] = k(!1), M = m(() => !t || n ? !1 : r && (r(t.start) || r(t.end)) ? !0 : h(t.start, $, v) || h(t.end, $, v), [
+    r,
+    t,
+    n,
+    $,
+    v
+  ]), F = e.isInvalid || e.validationState === "invalid" || M;
+  return {
+    ...i,
+    value: t,
+    setValue: p,
+    anchorDate: n,
+    setAnchorDate: x,
+    highlightedRange: C,
+    validationState: F ? "invalid" : null,
+    isValueInvalid: F,
+    selectFocusedDate() {
+      i.isCellUnavailable(i.focusedDate) || R(i.focusedDate);
+    },
+    commitSelection() {
+      R(i.focusedDate);
+    },
+    selectDate: R,
+    highlightDate(a) {
+      n && i.setFocusedDate(a);
+    },
+    isSelected(a) {
+      return !!(C && a.compare(C.start) >= 0 && a.compare(C.end) <= 0 && !i.isCellDisabled(a) && !i.isCellUnavailable(a));
+    },
+    isInvalid(a) {
+      return i.isInvalid(a) || h(a, b?.start, b?.end);
+    },
+    isDragging: E,
+    setDragging: G,
+    clearSelection() {
+      x(null), p(null);
+    },
+    focusNearestAvailableDate(a) {
+      let s = S(a), o = (N) => this.isInvalid(N) || h(N, s?.start, s?.end), u = a.add({
+        days: 1
+      });
+      o(u) && (u = a.subtract({
+        days: 1
+      })), o(u) || (this.setFocusedDate(u), this.setFocused(!0));
+    }
+  };
+}
+function A(e, l) {
+  return !e || !l ? null : (l.compare(e) < 0 && ([e, l] = [
+    l,
+    e
+  ]), {
+    start: I(e),
+    end: I(l)
+  });
+}
+function P(e, l) {
+  return e = K(e, l?.calendar || new J()), l && "hour" in l ? l.set(e) : e;
+}
+function w(e, l, g, f) {
+  let d = e.add({
+    days: f
+  }), D = e.subtract(g), c = e.add(g);
+  for (; (f < 0 ? d.compare(D) >= 0 : d.compare(c) <= 0) && !l(d); ) d = d.add({
+    days: f
+  });
+  if (l(d)) return d.add({
+    days: -f
+  });
+}
+export {
+  le as useRangeCalendarState
+};

package/dist/node_modules/react-stately/dist/private/calendar/utils.js

@@ -0,0 +1,66 @@
+import { toCalendarDate as o } from "../../../../@internationalized/date/dist/private/conversion.js";
+import { startOfYear as b, startOfMonth as l, startOfWeek as y, maxDate as i, minDate as p } from "../../../../@internationalized/date/dist/private/queries.js";
+function h(e, r, t) {
+  return r != null && e.compare(r) < 0 || t != null && e.compare(t) > 0;
+}
+function D(e, r, t, s, $) {
+  let f = {};
+  for (let n in r)
+    f[n] = Math.floor(r[n] / 2), f[n] > 0 && r[n] % 2 === 0 && f[n]--;
+  let c = a(e, r, t).subtract(f);
+  return d(e, c, r, t, s, $);
+}
+function a(e, r, t, s, $) {
+  let f = e;
+  return r.years ? f = b(e) : r.months ? f = l(e) : (r.weeks || r.days && r.days > 7) && (f = y(e, t)), d(e, f, r, t, s, $);
+}
+function x(e, r, t, s, $) {
+  let f = {
+    ...r
+  };
+  f.days ? f.days-- : f.weeks ? f.weeks-- : f.months ? f.months-- : f.years && f.years--;
+  let c = a(e, r, t).subtract(f);
+  return d(e, c, r, t, s, $);
+}
+function d(e, r, t, s, $, f) {
+  if ($ && e.compare($) >= 0) {
+    let c = i(r, a(o($), t, s));
+    c && (r = c);
+  }
+  if (f && e.compare(f) <= 0) {
+    let c = p(r, x(o(f), t, s));
+    c && (r = c);
+  }
+  return r;
+}
+function m(e, r, t) {
+  if (r) {
+    let s = i(e, o(r));
+    s && (e = s);
+  }
+  if (t) {
+    let s = p(e, o(t));
+    s && (e = s);
+  }
+  return e;
+}
+function k(e, r, t) {
+  if (!t) return e;
+  for (; e.compare(r) >= 0 && t(e); ) e = e.subtract({
+    days: 1
+  });
+  return e.compare(r) >= 0 ? e : null;
+}
+function O(e, r) {
+  return e === r ? !0 : e.days === r.days && e.weeks === r.weeks && e.months === r.months && e.years === r.years;
+}
+export {
+  D as alignCenter,
+  x as alignEnd,
+  a as alignStart,
+  d as constrainStart,
+  m as constrainValue,
+  O as isEqualDuration,
+  h as isInvalid,
+  k as previousAvailableDate
+};

package/dist/node_modules/react-stately/dist/private/collections/CollectionBuilder.js

@@ -0,0 +1,160 @@
+import c from "react";
+class b {
+  build(e, l) {
+    return this.context = l, v(() => this.iterateCollection(e));
+  }
+  *iterateCollection(e) {
+    let { children: l, items: r } = e;
+    if (c.isValidElement(l) && l.type === c.Fragment) yield* this.iterateCollection({
+      children: l.props.children,
+      items: r
+    });
+    else if (typeof l == "function") {
+      if (!r) throw new Error("props.children was a function but props.items is missing");
+      let t = 0;
+      for (let n of r)
+        yield* this.getFullNode({
+          value: n,
+          index: t
+        }, {
+          renderer: l
+        }), t++;
+    } else {
+      let t = [];
+      c.Children.forEach(l, (d) => {
+        d && t.push(d);
+      });
+      let n = 0;
+      for (let d of t) {
+        let y = this.getFullNode({
+          element: d,
+          index: n
+        }, {});
+        for (let i of y)
+          n++, yield i;
+      }
+    }
+  }
+  getKey(e, l, r, t) {
+    if (e.key != null) return e.key;
+    if (l.type === "cell" && l.key != null) return `${t}${l.key}`;
+    let n = l.value;
+    if (n != null) {
+      let d = n.key ?? n.id;
+      if (d == null) throw new Error("No key found for item");
+      return d;
+    }
+    return t ? `${t}.${l.index}` : `$.${l.index}`;
+  }
+  getChildState(e, l) {
+    return {
+      renderer: l.renderer || e.renderer
+    };
+  }
+  *getFullNode(e, l, r, t) {
+    if (c.isValidElement(e.element) && e.element.type === c.Fragment) {
+      let i = [];
+      c.Children.forEach(e.element.props.children, (s) => {
+        i.push(s);
+      });
+      let f = e.index ?? 0;
+      for (const s of i) yield* this.getFullNode({
+        element: s,
+        index: f++
+      }, l, r, t);
+      return;
+    }
+    let n = e.element;
+    if (!n && e.value && l && l.renderer) {
+      let i = this.cache.get(e.value);
+      if (i && (!i.shouldInvalidate || !i.shouldInvalidate(this.context))) {
+        i.index = e.index, i.parentKey = t ? t.key : null, yield i;
+        return;
+      }
+      n = l.renderer(e.value);
+    }
+    if (c.isValidElement(n)) {
+      let i = n.type;
+      if (typeof i != "function" && typeof i.getCollectionNode != "function") {
+        let o = n.type;
+        throw new Error(`Unknown element <${o}> in collection.`);
+      }
+      let f = i.getCollectionNode(n.props, this.context), s = e.index ?? 0, m = f.next();
+      for (; !m.done && m.value; ) {
+        let o = m.value;
+        e.index = s;
+        let x = o.key ?? null;
+        x == null && (x = o.element ? null : this.getKey(n, e, l, r));
+        let k = [
+          ...this.getFullNode({
+            ...o,
+            key: x,
+            index: s,
+            wrapper: w(e.wrapper, o.wrapper)
+          }, this.getChildState(l, o), r ? `${r}${n.key}` : n.key, t)
+        ];
+        for (let h of k) {
+          if (h.value = o.value ?? e.value ?? null, h.value && this.cache.set(h.value, h), e.type && h.type !== e.type) throw new Error(`Unsupported type <${$(h.type)}> in <${$(t?.type ?? "unknown parent type")}>. Only <${$(e.type)}> is supported.`);
+          s++, yield h;
+        }
+        m = f.next(k);
+      }
+      return;
+    }
+    if (e.key == null || e.type == null) return;
+    let d = this, y = {
+      type: e.type,
+      props: e.props,
+      key: e.key,
+      parentKey: t ? t.key : null,
+      value: e.value ?? null,
+      level: (t?.level ?? 0) + (t?.type === "item" ? 1 : 0),
+      index: e.index,
+      rendered: e.rendered,
+      textValue: e.textValue ?? "",
+      "aria-label": e["aria-label"],
+      wrapper: e.wrapper,
+      shouldInvalidate: e.shouldInvalidate,
+      hasChildNodes: e.hasChildNodes || !1,
+      childNodes: v(function* () {
+        if (!e.hasChildNodes || !e.childNodes) return;
+        let i = 0;
+        for (let f of e.childNodes()) {
+          f.key != null && (f.key = `${y.key}${f.key}`);
+          let s = d.getFullNode({
+            ...f,
+            index: i
+          }, d.getChildState(l, f), y.key, y);
+          for (let m of s)
+            i++, yield m;
+        }
+      })
+    };
+    yield y;
+  }
+  constructor() {
+    this.cache = /* @__PURE__ */ new WeakMap();
+  }
+}
+function v(u) {
+  let e = [], l = null;
+  return {
+    *[Symbol.iterator]() {
+      for (let r of e) yield r;
+      l || (l = u());
+      for (let r of l)
+        e.push(r), yield r;
+    }
+  };
+}
+function w(u, e) {
+  if (u && e) return (l) => u(e(l));
+  if (u) return u;
+  if (e) return e;
+}
+function $(u) {
+  return u[0].toUpperCase() + u.slice(1);
+}
+export {
+  b as CollectionBuilder
+};

package/dist/node_modules/react-stately/dist/private/collections/Item.js

@@ -0,0 +1,37 @@
+import d from "react";
+function r(t) {
+  return null;
+}
+r.getCollectionNode = function* (e, u) {
+  let { childItems: a, title: c, children: f } = e, i = e.title || e.children, n = e.textValue || (typeof i == "string" ? i : "") || e["aria-label"] || "";
+  !n && !u?.suppressTextValueWarning && process.env.NODE_ENV !== "production" && console.warn("<Item> with non-plain text contents is unsupported by type to select for accessibility. Please add a `textValue` prop."), yield {
+    type: "item",
+    props: e,
+    rendered: i,
+    textValue: n,
+    "aria-label": e["aria-label"],
+    hasChildNodes: o(e),
+    *childNodes() {
+      if (a) for (let l of a) yield {
+        type: "item",
+        value: l
+      };
+      else if (c) {
+        let l = [];
+        d.Children.forEach(f, (h) => {
+          l.push({
+            type: "item",
+            element: h
+          });
+        }), yield* l;
+      }
+    }
+  };
+};
+function o(t) {
+  return t.hasChildItems != null ? t.hasChildItems : !!(t.childItems || t.title && d.Children.count(t.children) > 0);
+}
+let m = r;
+export {
+  m as Item
+};

package/dist/node_modules/react-stately/dist/private/collections/getChildNodes.js

@@ -0,0 +1,33 @@
+function u(n, e) {
+  return typeof e.getChildren == "function" ? e.getChildren(n.key) : n.childNodes;
+}
+function c(n) {
+  return s(n);
+}
+function s(n, e) {
+  for (let t of n)
+    return t;
+}
+function $(n, e, t) {
+  if (e.parentKey === t.parentKey) return e.index - t.index;
+  let r = [
+    ...a(n, e),
+    e
+  ], f = [
+    ...a(n, t),
+    t
+  ], i = r.slice(0, f.length).findIndex((d, o) => d !== f[o]);
+  return i !== -1 ? (e = r[i], t = f[i], e.index - t.index) : r.findIndex((d) => d === t) >= 0 ? 1 : (f.findIndex((d) => d === e) >= 0, -1);
+}
+function a(n, e) {
+  let t = [], r = e;
+  for (; r?.parentKey != null; )
+    r = n.getItem(r.parentKey), r && t.unshift(r);
+  return t;
+}
+export {
+  $ as compareNodeOrder,
+  u as getChildNodes,
+  c as getFirstItem,
+  s as getNthItem
+};

package/dist/node_modules/react-stately/dist/private/collections/getItemCount.js

@@ -0,0 +1,14 @@
+import { getChildNodes as $ } from "./getChildNodes.js";
+const n = /* @__PURE__ */ new WeakMap();
+function s(e) {
+  let r = n.get(e);
+  if (r != null) return r;
+  let t = 0, a = (o) => {
+    for (let f of o)
+      f.type === "section" ? a($(f, e)) : f.type === "item" && t++;
+  };
+  return a(e), n.set(e, t), t;
+}
+export {
+  s as getItemCount
+};