@viasat/beam-shared 2.0.0

package/lib/components/floatingui.es.js

@@ -0,0 +1,608 @@
+const et = ["top", "right", "bottom", "left"], K = ["start", "end"], N = /* @__PURE__ */ et.reduce((t, e) => t.concat(e, e + "-" + K[0], e + "-" + K[1]), []), W = Math.min, lt = Math.max, at = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, ft = {
+  start: "end",
+  end: "start"
+};
+function Y(t, e, s) {
+  return lt(t, W(e, s));
+}
+function H(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+function C(t) {
+  return t.split("-")[0];
+}
+function M(t) {
+  return t.split("-")[1];
+}
+function q(t) {
+  return t === "x" ? "y" : "x";
+}
+function nt(t) {
+  return t === "y" ? "height" : "width";
+}
+function V(t) {
+  return ["top", "bottom"].includes(C(t)) ? "y" : "x";
+}
+function ot(t) {
+  return q(V(t));
+}
+function it(t, e, s) {
+  s === void 0 && (s = !1);
+  const r = M(t), i = ot(t), n = nt(i);
+  let o = i === "x" ? r === (s ? "end" : "start") ? "right" : "left" : r === "start" ? "bottom" : "top";
+  return e.reference[n] > e.floating[n] && (o = _(o)), [o, _(o)];
+}
+function ut(t) {
+  const e = _(t);
+  return [z(t), e, z(e)];
+}
+function z(t) {
+  return t.replace(/start|end/g, (e) => ft[e]);
+}
+function dt(t, e, s) {
+  const r = ["left", "right"], i = ["right", "left"], n = ["top", "bottom"], o = ["bottom", "top"];
+  switch (t) {
+    case "top":
+    case "bottom":
+      return s ? e ? i : r : e ? r : i;
+    case "left":
+    case "right":
+      return e ? n : o;
+    default:
+      return [];
+  }
+}
+function mt(t, e, s, r) {
+  const i = M(t);
+  let n = dt(C(t), s === "start", r);
+  return i && (n = n.map((o) => o + "-" + i), e && (n = n.concat(n.map(z)))), n;
+}
+function _(t) {
+  return t.replace(/left|right|bottom|top/g, (e) => at[e]);
+}
+function gt(t) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...t
+  };
+}
+function st(t) {
+  return typeof t != "number" ? gt(t) : {
+    top: t,
+    right: t,
+    bottom: t,
+    left: t
+  };
+}
+function Q(t) {
+  const {
+    x: e,
+    y: s,
+    width: r,
+    height: i
+  } = t;
+  return {
+    width: r,
+    height: i,
+    top: s,
+    left: e,
+    right: e + r,
+    bottom: s + i,
+    x: e,
+    y: s
+  };
+}
+async function I(t, e) {
+  var s;
+  e === void 0 && (e = {});
+  const {
+    x: r,
+    y: i,
+    platform: n,
+    rects: o,
+    elements: c,
+    strategy: u
+  } = t, {
+    boundary: w = "clippingAncestors",
+    rootBoundary: p = "viewport",
+    elementContext: l = "floating",
+    altBoundary: d = !1,
+    padding: a = 0
+  } = H(e, t), m = st(a), f = c[d ? l === "floating" ? "reference" : "floating" : l], g = Q(await n.getClippingRect({
+    element: (s = await (n.isElement == null ? void 0 : n.isElement(f))) == null || s ? f : f.contextElement || await (n.getDocumentElement == null ? void 0 : n.getDocumentElement(c.floating)),
+    boundary: w,
+    rootBoundary: p,
+    strategy: u
+  })), h = l === "floating" ? {
+    x: r,
+    y: i,
+    width: o.floating.width,
+    height: o.floating.height
+  } : o.reference, y = await (n.getOffsetParent == null ? void 0 : n.getOffsetParent(c.floating)), b = await (n.isElement == null ? void 0 : n.isElement(y)) ? await (n.getScale == null ? void 0 : n.getScale(y)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, A = Q(n.convertOffsetParentRelativeRectToViewportRelativeRect ? await n.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: c,
+    rect: h,
+    offsetParent: y,
+    strategy: u
+  }) : h);
+  return {
+    top: (g.top - A.top + m.top) / b.y,
+    bottom: (A.bottom - g.bottom + m.bottom) / b.y,
+    left: (g.left - A.left + m.left) / b.x,
+    right: (A.right - g.right + m.right) / b.x
+  };
+}
+function pt(t, e, s) {
+  return (t ? [...s.filter((i) => M(i) === t), ...s.filter((i) => M(i) !== t)] : s.filter((i) => C(i) === i)).filter((i) => t ? M(i) === t || (e ? z(i) !== i : !1) : !0);
+}
+const xt = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "autoPlacement",
+    options: t,
+    async fn(e) {
+      var s, r, i;
+      const {
+        rects: n,
+        middlewareData: o,
+        placement: c,
+        platform: u,
+        elements: w
+      } = e, {
+        crossAxis: p = !1,
+        alignment: l,
+        allowedPlacements: d = N,
+        autoAlignment: a = !0,
+        ...m
+      } = H(t, e), v = l !== void 0 || d === N ? pt(l || null, a, d) : d, f = await I(e, m), g = ((s = o.autoPlacement) == null ? void 0 : s.index) || 0, h = v[g];
+      if (h == null)
+        return {};
+      const y = it(h, n, await (u.isRTL == null ? void 0 : u.isRTL(w.floating)));
+      if (c !== h)
+        return {
+          reset: {
+            placement: v[0]
+          }
+        };
+      const b = [f[C(h)], f[y[0]], f[y[1]]], A = [...((r = o.autoPlacement) == null ? void 0 : r.overflows) || [], {
+        placement: h,
+        overflows: b
+      }], B = v[g + 1];
+      if (B)
+        return {
+          data: {
+            index: g + 1,
+            overflows: A
+          },
+          reset: {
+            placement: B
+          }
+        };
+      const F = A.map((x) => {
+        const P = M(x.placement);
+        return [x.placement, P && p ? (
+          // Check along the mainAxis and main crossAxis side.
+          x.overflows.slice(0, 2).reduce((j, T) => j + T, 0)
+        ) : (
+          // Check only the mainAxis.
+          x.overflows[0]
+        ), x.overflows];
+      }).sort((x, P) => x[1] - P[1]), D = ((i = F.filter((x) => x[2].slice(
+        0,
+        // Aligned placements should not check their opposite crossAxis
+        // side.
+        M(x[0]) ? 2 : 3
+      ).every((P) => P <= 0))[0]) == null ? void 0 : i[0]) || F[0][0];
+      return D !== c ? {
+        data: {
+          index: g + 1,
+          overflows: A
+        },
+        reset: {
+          placement: D
+        }
+      } : {};
+    }
+  };
+}, ht = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "flip",
+    options: t,
+    async fn(e) {
+      var s, r;
+      const {
+        placement: i,
+        middlewareData: n,
+        rects: o,
+        initialPlacement: c,
+        platform: u,
+        elements: w
+      } = e, {
+        mainAxis: p = !0,
+        crossAxis: l = !0,
+        fallbackPlacements: d,
+        fallbackStrategy: a = "bestFit",
+        fallbackAxisSideDirection: m = "none",
+        flipAlignment: v = !0,
+        ...f
+      } = H(t, e);
+      if ((s = n.arrow) != null && s.alignmentOffset)
+        return {};
+      const g = C(i), h = V(c), y = C(c) === c, b = await (u.isRTL == null ? void 0 : u.isRTL(w.floating)), A = d || (y || !v ? [_(c)] : ut(c)), B = m !== "none";
+      !d && B && A.push(...mt(c, v, m, b));
+      const F = [c, ...A], S = await I(e, f), D = [];
+      let x = ((r = n.flip) == null ? void 0 : r.overflows) || [];
+      if (p && D.push(S[g]), l) {
+        const R = it(i, o, b);
+        D.push(S[R[0]], S[R[1]]);
+      }
+      if (x = [...x, {
+        placement: i,
+        overflows: D
+      }], !D.every((R) => R <= 0)) {
+        var P, j;
+        const R = (((P = n.flip) == null ? void 0 : P.index) || 0) + 1, E = F[R];
+        if (E)
+          return {
+            data: {
+              index: R,
+              overflows: x
+            },
+            reset: {
+              placement: E
+            }
+          };
+        let L = (j = x.filter((k) => k.overflows[0] <= 0).sort((k, $) => k.overflows[1] - $.overflows[1])[0]) == null ? void 0 : j.placement;
+        if (!L)
+          switch (a) {
+            case "bestFit": {
+              var T;
+              const k = (T = x.filter(($) => {
+                if (B) {
+                  const O = V($.placement);
+                  return O === h || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  O === "y";
+                }
+                return !0;
+              }).map(($) => [$.placement, $.overflows.filter((O) => O > 0).reduce((O, U) => O + U, 0)]).sort(($, O) => $[1] - O[1])[0]) == null ? void 0 : T[0];
+              k && (L = k);
+              break;
+            }
+            case "initialPlacement":
+              L = c;
+              break;
+          }
+        if (i !== L)
+          return {
+            reset: {
+              placement: L
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+function Z(t, e) {
+  return {
+    top: t.top - e.height,
+    right: t.right - e.width,
+    bottom: t.bottom - e.height,
+    left: t.left - e.width
+  };
+}
+function tt(t) {
+  return et.some((e) => t[e] >= 0);
+}
+const wt = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "hide",
+    options: t,
+    async fn(e) {
+      const {
+        rects: s
+      } = e, {
+        strategy: r = "referenceHidden",
+        ...i
+      } = H(t, e);
+      switch (r) {
+        case "referenceHidden": {
+          const n = await I(e, {
+            ...i,
+            elementContext: "reference"
+          }), o = Z(n, s.reference);
+          return {
+            data: {
+              referenceHiddenOffsets: o,
+              referenceHidden: tt(o)
+            }
+          };
+        }
+        case "escaped": {
+          const n = await I(e, {
+            ...i,
+            altBoundary: !0
+          }), o = Z(n, s.floating);
+          return {
+            data: {
+              escapedOffsets: o,
+              escaped: tt(o)
+            }
+          };
+        }
+        default:
+          return {};
+      }
+    }
+  };
+};
+async function vt(t, e) {
+  const {
+    placement: s,
+    platform: r,
+    elements: i
+  } = t, n = await (r.isRTL == null ? void 0 : r.isRTL(i.floating)), o = C(s), c = M(s), u = V(s) === "y", w = ["left", "top"].includes(o) ? -1 : 1, p = n && u ? -1 : 1, l = H(e, t);
+  let {
+    mainAxis: d,
+    crossAxis: a,
+    alignmentAxis: m
+  } = typeof l == "number" ? {
+    mainAxis: l,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: l.mainAxis || 0,
+    crossAxis: l.crossAxis || 0,
+    alignmentAxis: l.alignmentAxis
+  };
+  return c && typeof m == "number" && (a = c === "end" ? m * -1 : m), u ? {
+    x: a * p,
+    y: d * w
+  } : {
+    x: d * w,
+    y: a * p
+  };
+}
+const yt = function(t) {
+  return t === void 0 && (t = 0), {
+    name: "offset",
+    options: t,
+    async fn(e) {
+      var s, r;
+      const {
+        x: i,
+        y: n,
+        placement: o,
+        middlewareData: c
+      } = e, u = await vt(e, t);
+      return o === ((s = c.offset) == null ? void 0 : s.placement) && (r = c.arrow) != null && r.alignmentOffset ? {} : {
+        x: i + u.x,
+        y: n + u.y,
+        data: {
+          ...u,
+          placement: o
+        }
+      };
+    }
+  };
+}, At = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "shift",
+    options: t,
+    async fn(e) {
+      const {
+        x: s,
+        y: r,
+        placement: i
+      } = e, {
+        mainAxis: n = !0,
+        crossAxis: o = !1,
+        limiter: c = {
+          fn: (f) => {
+            let {
+              x: g,
+              y: h
+            } = f;
+            return {
+              x: g,
+              y: h
+            };
+          }
+        },
+        ...u
+      } = H(t, e), w = {
+        x: s,
+        y: r
+      }, p = await I(e, u), l = V(C(i)), d = q(l);
+      let a = w[d], m = w[l];
+      if (n) {
+        const f = d === "y" ? "top" : "left", g = d === "y" ? "bottom" : "right", h = a + p[f], y = a - p[g];
+        a = Y(h, a, y);
+      }
+      if (o) {
+        const f = l === "y" ? "top" : "left", g = l === "y" ? "bottom" : "right", h = m + p[f], y = m - p[g];
+        m = Y(h, m, y);
+      }
+      const v = c.fn({
+        ...e,
+        [d]: a,
+        [l]: m
+      });
+      return {
+        ...v,
+        data: {
+          x: v.x - s,
+          y: v.y - r,
+          enabled: {
+            [d]: n,
+            [l]: o
+          }
+        }
+      };
+    }
+  };
+}, bt = yt, Pt = xt, Ot = At, St = ht, Rt = wt, Dt = (t) => {
+  var e;
+  return {
+    visibility: (e = t.hide) != null && e.referenceHidden ? "hidden" : "visible"
+  };
+}, $t = (t) => ({
+  name: "arrowStyles",
+  options: t,
+  async fn(e) {
+    var G, J;
+    const { x: s, y: r, placement: i, rects: n, platform: o, elements: c, middlewareData: u } = e, { element: w, padding: p = 0 } = H(t, e) || {};
+    if (w == null)
+      return {};
+    const l = st(p), d = { x: s, y: r }, a = ot(i), m = q(a), v = nt(a), f = await o.getDimensions(w), g = a === "y", h = g ? "top" : "left", y = g ? "bottom" : "right", b = g ? "clientHeight" : "clientWidth", A = n.reference[v] + n.reference[a] - d[a] - n.floating[v], B = d[a] - n.reference[a], F = await ((G = o.getOffsetParent) == null ? void 0 : G.call(o, w));
+    let S = F ? F[b] : 0;
+    (!S || !await ((J = o.isElement) == null ? void 0 : J.call(o, F))) && (S = c.floating[b] || n.floating[v]);
+    const D = A / 2 - B / 2, x = S / 2 - f.width / 2 - 1, P = W(l[h], x), j = W(l[y], x), T = P, R = S - f.width - j, E = S / 2 - f.width / 2 + D, L = Y(T, E, R), k = !u.arrow && M(i) != null && E !== L && n.reference[v] / 2 - (E < T ? P : j) - f.width / 2 < 0, $ = k ? E < T ? E - T : E - R : 0, O = C(i), U = ["top", "left"].includes(O) ? -1 : 1, rt = f.height * U, ct = Ct({
+      placement: O,
+      arrowHeight: f.height,
+      arrowWidth: f.width,
+      // pass arrow middleware
+      [a]: L
+      // for posterity, this is what the floating-ui arrow middleware returns
+      // centerOffset: center - offset - alignmentOffset,
+      // ...(shouldAddOffset && { alignmentOffset }),
+    });
+    return {
+      [a]: d[a] + $,
+      [m]: d[m] + rt,
+      data: ct,
+      reset: k
+    };
+  }
+}), X = (t, e, s, r) => {
+  if (r) {
+    const i = r === !0 ? s() : s(r);
+    t[e](i);
+  }
+}, Tt = ({
+  baseConfig: t,
+  middleware: e,
+  offset: s,
+  arrow: r,
+  placement: i = "top"
+}) => {
+  const n = { ...t, placement: i };
+  let o = [];
+  if (typeof e.overrides != "object") {
+    o.push(bt(s));
+    let c = e.flip ?? !0;
+    e.autoPlacement && (c = !1), X(
+      o,
+      "unshift",
+      Pt,
+      e.autoPlacement
+    ), X(o, "push", Ot, e.shift ?? !0), X(o, "unshift", St, c), X(o, "push", Rt, e.hide ?? !0);
+  } else
+    o.push(...e.overrides);
+  return r.hide || o.push($t(r.options)), typeof e.overrides == "function" && (o = e.overrides(o)), n.middleware = o, n;
+}, Ct = ({
+  placement: t,
+  arrowHeight: e,
+  arrowWidth: s,
+  x: r,
+  y: i
+}) => {
+  const n = C(t), o = s / 2 - e, c = {
+    /* since the default orientation is pointing down, we don't need to rotate the arrow
+    if the tooltip is on top of the reference element
+     */
+    top: "rotate(0deg)",
+    // since the default orientation is pointing down, we don't need to translate the arrow
+    bottom: "rotate(180deg)",
+    /* For an arrow with non-equal width and height, once we rotate the arrow 90 degrees
+        for left and right positions, the top-left corner of the arrow will not be the same
+        as the top-left corner of the original downward-pointing arrow. Thus, top:0 for
+        example will not place the arrow at the top of the tooltip.
+    
+        To fix this, we need to translate the arrow along the x-axis by the difference between
+        the arrow's width and height.
+    
+         * Example: note that the transformation origin is always bottom-center
+         *
+         * default, downward pointing position    rotated 90 degrees, offset from edge
+         * |________  =>                         |     |\  <- the top is slightly higher!
+         * |   ..                                |     | *
+         * |                                     |     |/
+    
+        We use translate X to move it along vertical axis as translations are applied before
+        rotation transformations. In both situations, the overall effect is sliding the
+        arrow downwards.
+         */
+    left: `rotate(-90deg) translateX(${-o}px)`,
+    right: `rotate(90deg) translateX(${o}px)`
+  }[n], u = -s / 2 - e, w = {
+    /*
+     * If the tooltip is at the top of the anchor, place the arrow at the bottom of
+     * the tooltip with bottom: 0. The bottom of the arrow will be flush with the bottom
+     * of the tooltip. Result:
+     * v   (arrow)
+     * --- (bottom of tooltip)
+     *
+     * Then, shift it down by its height so the flat, top side of the arrow is
+     * flush with the bottom of the tooltip.
+     *
+     * --- (bottom of tooltip)
+     * v   (arrow)
+     */
+    top: `${-e}px`,
+    /*
+     * Place the arrow at the top of the tooltip with top: 0. The arrow will be rotated
+     * to point downwards by default. When it's then rotated by 180 deg with
+     * transform-origin as bottom center, we need to shift the arrow up by its height
+     * so it's still flush with the top.
+     *
+     * Then, we need to shift the arrow up by its height again so its bottom edge is
+     * flush with the top of the tooltip.
+     *
+     * In summary the arrow is shifted up by 2 * arrowHeight, or top: -2 * arrowHeight
+     */
+    bottom: `${-e * 2}px`,
+    /*
+     * Place the arrow at the right of the tooltip with right: 0. When we rotate
+     * the arrow 90 degrees clockwise about the bottom center, there will now be
+     * space between the right edge of the tooltip and the arrow. To fix this, we
+     * need to shift the arrow left by the difference between half of the
+     * arrow's width and the arrow's height (the two lengths on the horizontal axis)
+     *
+     * Example: note that the transformation origin is always bottom-center
+     *
+     * default, downward pointing position       rotated 90 degrees, offset from edge
+     * |                                        |
+     * |--------  =>                            |     |\
+     * |   ..                                   |     | *
+     * |                                        |     |/
+     */
+    left: `${u}px`,
+    // similarly for the right side
+    right: `${u}px`
+  }[n], p = {
+    transform: c
+  };
+  p.left = r != null ? `${r}px` : "", p.top = i != null ? `${i}px` : "";
+  const l = _(n);
+  return p[l] = w, p;
+};
+export {
+  $t as arrowMiddleware,
+  Ct as arrowStyles,
+  Tt as buildFloatingUIConfig,
+  Dt as visibilityHandler
+};

package/lib/components/form.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("../../chunks/form.CIzlawbr.js");exports.getCheckBoxGroupMeta=e.getCheckBoxGroupMeta;exports.getMultiSelectMeta=e.getMultiSelectMeta;exports.isGroupBlurEvent=e.isGroupBlurEvent;exports.validateFormField=e.validateFormField;exports.validationModes=e.validationModes;exports.validators=e.validators;

package/lib/components/form.d.ts

@@ -0,0 +1,69 @@
+import { Optional } from '../utils/types';
+export type FormValue = string | boolean | number | Array<string | number> | FormData;
+export declare const validationModes: readonly ["onChange", "onBlur", "onSubmit"];
+export type ValidationMode = typeof validationModes[number];
+export type FieldType = HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement | NodeListOf<HTMLElement>;
+export interface ValidationResult {
+    error: boolean;
+    message?: string;
+}
+export interface FieldMeta<FT = FieldType> {
+    field: FT;
+    initializer: () => void;
+    validators: Array<FormValidator<FT>>;
+    errorSetter: (errors: Array<Optional<string>>) => void;
+}
+export interface FormValidator<FT = FieldType> {
+    name: keyof typeof validators;
+    validator: (element: FT) => ValidationResult | Promise<ValidationResult>;
+}
+export declare const validateFormField: <FT = FieldType>(field: FT, validators: Array<FormValidator<FT>>) => Promise<Array<Optional<string>>>;
+export declare const isGroupBlurEvent: (event: FocusEvent) => {
+    groupBlur: boolean;
+};
+export declare const getCheckBoxGroupMeta: (checkboxGroup: NodeListOf<HTMLInputElement>) => {
+    isCheckBoxGroup: boolean;
+    selectedBoxes: Array<HTMLInputElement>;
+};
+export declare const getMultiSelectMeta: (element: HTMLSelectElement) => {
+    isMultiSelect: boolean;
+    selectedOptions: Array<HTMLOptionElement>;
+};
+declare const min: (params: {
+    value: number;
+    message?: string;
+}) => FormValidator;
+declare const max: (params: {
+    value: number;
+    message?: string;
+}) => FormValidator;
+declare const email: (params?: {
+    message?: string;
+}) => FormValidator;
+declare const pattern: (params: {
+    pattern: string | RegExp;
+    message?: string;
+}) => FormValidator;
+declare const required: (params?: {
+    message?: string;
+}) => FormValidator;
+declare const minLength: (params: {
+    length: number;
+    message?: string;
+}) => FormValidator;
+declare const maxLength: (params: {
+    length: number;
+    message?: string;
+}) => FormValidator;
+declare const define: (callback: FormValidator["validator"]) => FormValidator;
+export declare const validators: {
+    min: typeof min;
+    max: typeof max;
+    email: typeof email;
+    define: typeof define;
+    pattern: typeof pattern;
+    required: typeof required;
+    minLength: typeof minLength;
+    maxLength: typeof maxLength;
+};
+export {};

package/lib/components/form.es.js

@@ -0,0 +1,9 @@
+import { g as t, b as o, i as s, a as i, v as l, c as r } from "../../chunks/form.BRWIo59c.js";
+export {
+  t as getCheckBoxGroupMeta,
+  o as getMultiSelectMeta,
+  s as isGroupBlurEvent,
+  i as validateFormField,
+  l as validationModes,
+  r as validators
+};

package/lib/components/helperText.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});require("../utils/constants.cjs.js");const e=require("../../chunks/helperText.C-apoW8Z.js");exports.sizes=e.sizes;exports.states=e.states;

package/lib/components/helperText.d.ts

@@ -0,0 +1,4 @@
+export declare const sizes: readonly ["sm", "md"];
+export declare const states: readonly ["info", "warning", "positive", "negative"];
+export type HelperTextSize = typeof sizes[number];
+export type HelperTextAppearance = typeof states[number];

package/lib/components/helperText.es.js

@@ -0,0 +1,6 @@
+import "../utils/constants.es.js";
+import { s as e, a as o } from "../../chunks/helperText.CS5sun4r.js";
+export {
+  e as sizes,
+  o as states
+};

package/lib/components/icon.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});require("../utils/constants.cjs.js");const o=require("../../chunks/icon.SiHuIfL8.js");exports.iconColors=o.iconColors;exports.iconSizes=o.iconSizes;exports.roles=o.roles;