@boxcustodia/library 0.0.1 → 0.0.3

package/dist/index.es157.js

@@ -0,0 +1,220 @@
+import * as s from "react";
+import { useFloating as xe, offset as Pe, shift as ye, flip as Ae, size as ve, arrow as Ce, hide as be, limitShift as Se } from "./index.es245.js";
+import { Root as Oe } from "./index.es246.js";
+import { useComposedRefs as T } from "./index.es137.js";
+import { createContextScope as Re } from "./index.es146.js";
+import { Primitive as z } from "./index.es151.js";
+import { useCallbackRef as Ee } from "./index.es139.js";
+import { useLayoutEffect as B } from "./index.es155.js";
+import { useSize as Ne } from "./index.es247.js";
+import { j as f } from "./index.es82.js";
+import { autoUpdate as _e } from "./index.es248.js";
+var N = "Popper", [L, Ue] = Re(N), [$e, Z] = L(N), U = (e) => {
+  const { __scopePopper: i, children: n } = e, [t, a] = s.useState(null);
+  return /* @__PURE__ */ f.jsx($e, { scope: i, anchor: t, onAnchorChange: a, children: n });
+};
+U.displayName = N;
+var q = "PopperAnchor", G = s.forwardRef(
+  (e, i) => {
+    const { __scopePopper: n, virtualRef: t, ...a } = e, r = Z(q, n), o = s.useRef(null), w = T(i, o);
+    return s.useEffect(() => {
+      r.onAnchorChange((t == null ? void 0 : t.current) || o.current);
+    }), t ? null : /* @__PURE__ */ f.jsx(z.div, { ...a, ref: w });
+  }
+);
+G.displayName = q;
+var _ = "PopperContent", [je, He] = L(_), J = s.forwardRef(
+  (e, i) => {
+    var I, Y, M, X, D, F;
+    const {
+      __scopePopper: n,
+      side: t = "bottom",
+      sideOffset: a = 0,
+      align: r = "center",
+      alignOffset: o = 0,
+      arrowPadding: w = 0,
+      avoidCollisions: p = !0,
+      collisionBoundary: c = [],
+      collisionPadding: x = 0,
+      sticky: m = "partial",
+      hideWhenDetached: y = !1,
+      updatePositionStrategy: A = "optimized",
+      onPlaced: l,
+      ...d
+    } = e, v = Z(_, n), [h, C] = s.useState(null), ee = T(i, (P) => C(P)), [E, te] = s.useState(null), g = Ne(E), re = (g == null ? void 0 : g.width) ?? 0, $ = (g == null ? void 0 : g.height) ?? 0, oe = t + (r !== "center" ? "-" + r : ""), ne = typeof x == "number" ? x : { top: 0, right: 0, bottom: 0, left: 0, ...x }, j = Array.isArray(c) ? c : [c], ae = j.length > 0, b = {
+      padding: ne,
+      boundary: j.filter(Ie),
+      // with `strategy: 'fixed'`, this is the only way to get it to respect boundaries
+      altBoundary: ae
+    }, { refs: ie, floatingStyles: H, placement: se, isPositioned: S, middlewareData: u } = xe({
+      // default to `fixed` strategy so users don't have to pick and we also avoid focus scroll issues
+      strategy: "fixed",
+      placement: oe,
+      whileElementsMounted: (...P) => _e(...P, {
+        animationFrame: A === "always"
+      }),
+      elements: {
+        reference: v.anchor
+      },
+      middleware: [
+        Pe({ mainAxis: a + $, alignmentAxis: o }),
+        p && ye({
+          mainAxis: !0,
+          crossAxis: !1,
+          limiter: m === "partial" ? Se() : void 0,
+          ...b
+        }),
+        p && Ae({ ...b }),
+        ve({
+          ...b,
+          apply: ({ elements: P, rects: k, availableWidth: he, availableHeight: ge }) => {
+            const { width: ue, height: we } = k.reference, R = P.floating.style;
+            R.setProperty("--radix-popper-available-width", `${he}px`), R.setProperty("--radix-popper-available-height", `${ge}px`), R.setProperty("--radix-popper-anchor-width", `${ue}px`), R.setProperty("--radix-popper-anchor-height", `${we}px`);
+          }
+        }),
+        E && Ce({ element: E, padding: w }),
+        Ye({ arrowWidth: re, arrowHeight: $ }),
+        y && be({ strategy: "referenceHidden", ...b })
+      ]
+    }), [W, pe] = V(se), O = Ee(l);
+    B(() => {
+      S && (O == null || O());
+    }, [S, O]);
+    const ce = (I = u.arrow) == null ? void 0 : I.x, de = (Y = u.arrow) == null ? void 0 : Y.y, le = ((M = u.arrow) == null ? void 0 : M.centerOffset) !== 0, [fe, me] = s.useState();
+    return B(() => {
+      h && me(window.getComputedStyle(h).zIndex);
+    }, [h]), /* @__PURE__ */ f.jsx(
+      "div",
+      {
+        ref: ie.setFloating,
+        "data-radix-popper-content-wrapper": "",
+        style: {
+          ...H,
+          transform: S ? H.transform : "translate(0, -200%)",
+          // keep off the page when measuring
+          minWidth: "max-content",
+          zIndex: fe,
+          "--radix-popper-transform-origin": [
+            (X = u.transformOrigin) == null ? void 0 : X.x,
+            (D = u.transformOrigin) == null ? void 0 : D.y
+          ].join(" "),
+          // hide the content if using the hide middleware and should be hidden
+          // set visibility to hidden and disable pointer events so the UI behaves
+          // as if the PopperContent isn't there at all
+          ...((F = u.hide) == null ? void 0 : F.referenceHidden) && {
+            visibility: "hidden",
+            pointerEvents: "none"
+          }
+        },
+        dir: e.dir,
+        children: /* @__PURE__ */ f.jsx(
+          je,
+          {
+            scope: n,
+            placedSide: W,
+            onArrowChange: te,
+            arrowX: ce,
+            arrowY: de,
+            shouldHideArrow: le,
+            children: /* @__PURE__ */ f.jsx(
+              z.div,
+              {
+                "data-side": W,
+                "data-align": pe,
+                ...d,
+                ref: ee,
+                style: {
+                  ...d.style,
+                  // if the PopperContent hasn't been placed yet (not all measurements done)
+                  // we prevent animations so that users's animation don't kick in too early referring wrong sides
+                  animation: S ? void 0 : "none"
+                }
+              }
+            )
+          }
+        )
+      }
+    );
+  }
+);
+J.displayName = _;
+var K = "PopperArrow", We = {
+  top: "bottom",
+  right: "left",
+  bottom: "top",
+  left: "right"
+}, Q = s.forwardRef(function(i, n) {
+  const { __scopePopper: t, ...a } = i, r = He(K, t), o = We[r.placedSide];
+  return (
+    // we have to use an extra wrapper because `ResizeObserver` (used by `useSize`)
+    // doesn't report size as we'd expect on SVG elements.
+    // it reports their bounding box which is effectively the largest path inside the SVG.
+    /* @__PURE__ */ f.jsx(
+      "span",
+      {
+        ref: r.onArrowChange,
+        style: {
+          position: "absolute",
+          left: r.arrowX,
+          top: r.arrowY,
+          [o]: 0,
+          transformOrigin: {
+            top: "",
+            right: "0 0",
+            bottom: "center 0",
+            left: "100% 0"
+          }[r.placedSide],
+          transform: {
+            top: "translateY(100%)",
+            right: "translateY(50%) rotate(90deg) translateX(-50%)",
+            bottom: "rotate(180deg)",
+            left: "translateY(50%) rotate(-90deg) translateX(50%)"
+          }[r.placedSide],
+          visibility: r.shouldHideArrow ? "hidden" : void 0
+        },
+        children: /* @__PURE__ */ f.jsx(
+          Oe,
+          {
+            ...a,
+            ref: n,
+            style: {
+              ...a.style,
+              // ensures the element can be measured correctly (mostly for if SVG)
+              display: "block"
+            }
+          }
+        )
+      }
+    )
+  );
+});
+Q.displayName = K;
+function Ie(e) {
+  return e !== null;
+}
+var Ye = (e) => ({
+  name: "transformOrigin",
+  options: e,
+  fn(i) {
+    var v, h, C;
+    const { placement: n, rects: t, middlewareData: a } = i, o = ((v = a.arrow) == null ? void 0 : v.centerOffset) !== 0, w = o ? 0 : e.arrowWidth, p = o ? 0 : e.arrowHeight, [c, x] = V(n), m = { start: "0%", center: "50%", end: "100%" }[x], y = (((h = a.arrow) == null ? void 0 : h.x) ?? 0) + w / 2, A = (((C = a.arrow) == null ? void 0 : C.y) ?? 0) + p / 2;
+    let l = "", d = "";
+    return c === "bottom" ? (l = o ? m : `${y}px`, d = `${-p}px`) : c === "top" ? (l = o ? m : `${y}px`, d = `${t.floating.height + p}px`) : c === "right" ? (l = `${-p}px`, d = o ? m : `${A}px`) : c === "left" && (l = `${t.floating.width + p}px`, d = o ? m : `${A}px`), { data: { x: l, y: d } };
+  }
+});
+function V(e) {
+  const [i, n = "center"] = e.split("-");
+  return [i, n];
+}
+var qe = U, Ge = G, Je = J, Ke = Q;
+export {
+  Ge as Anchor,
+  Ke as Arrow,
+  Je as Content,
+  U as Popper,
+  G as PopperAnchor,
+  Q as PopperArrow,
+  J as PopperContent,
+  qe as Root,
+  Ue as createPopperScope
+};

package/dist/index.es158.js

@@ -0,0 +1,6 @@
+function m(t, [a, n]) {
+  return Math.min(n, Math.max(a, t));
+}
+export {
+  m as clamp
+};

package/dist/index.es159.js

@@ -0,0 +1,48 @@
+import n from "react";
+import { createContextScope as O } from "./index.es146.js";
+import { useComposedRefs as I } from "./index.es137.js";
+import { Slot as S } from "./index.es87.js";
+import { j as u } from "./index.es82.js";
+function L(s) {
+  const f = s + "CollectionProvider", [A, E] = O(f), [N, m] = A(
+    f,
+    { collectionRef: { current: null }, itemMap: /* @__PURE__ */ new Map() }
+  ), a = (c) => {
+    const { scope: e, children: l } = c, o = n.useRef(null), t = n.useRef(/* @__PURE__ */ new Map()).current;
+    return /* @__PURE__ */ u.jsx(N, { scope: e, itemMap: t, collectionRef: o, children: l });
+  };
+  a.displayName = f;
+  const d = s + "CollectionSlot", p = n.forwardRef(
+    (c, e) => {
+      const { scope: l, children: o } = c, t = m(d, l), r = I(e, t.collectionRef);
+      return /* @__PURE__ */ u.jsx(S, { ref: r, children: o });
+    }
+  );
+  p.displayName = d;
+  const C = s + "CollectionItemSlot", R = "data-radix-collection-item", x = n.forwardRef(
+    (c, e) => {
+      const { scope: l, children: o, ...t } = c, r = n.useRef(null), M = I(e, r), i = m(C, l);
+      return n.useEffect(() => (i.itemMap.set(r, { ref: r, ...t }), () => void i.itemMap.delete(r))), /* @__PURE__ */ u.jsx(S, { [R]: "", ref: M, children: o });
+    }
+  );
+  x.displayName = C;
+  function _(c) {
+    const e = m(s + "CollectionConsumer", c);
+    return n.useCallback(() => {
+      const o = e.collectionRef.current;
+      if (!o) return [];
+      const t = Array.from(o.querySelectorAll(`[${R}]`));
+      return Array.from(e.itemMap.values()).sort(
+        (i, T) => t.indexOf(i.ref.current) - t.indexOf(T.ref.current)
+      );
+    }, [e.collectionRef, e.itemMap]);
+  }
+  return [
+    { Provider: a, Slot: p, ItemSlot: x },
+    _,
+    E
+  ];
+}
+export {
+  L as createCollection
+};

package/dist/index.es16.js

@@ -0,0 +1,24 @@
+import { useState as u, useCallback as n, useEffect as s } from "react";
+function z({
+  fn: g,
+  dependencies: p = [],
+  onError: e,
+  onSuccess: a,
+  onFinish: l
+}) {
+  const [y, d] = u(!0), [b, c] = u(null), [k, m] = u(null), f = n(() => {
+    d(!0), c(null), m(null), g().then((t) => {
+      a == null || a(t), m(t);
+    }).catch((t) => {
+      e == null || e(t), c(t);
+    }).finally(() => {
+      l == null || l(), d(!1);
+    });
+  }, p);
+  return s(() => {
+    f();
+  }, [f]), { loading: y, error: b, data: k, refetch: f };
+}
+export {
+  z as default
+};

package/dist/index.es160.js

@@ -0,0 +1,10 @@
+import * as t from "react";
+import "./index.es82.js";
+var r = t.createContext(void 0);
+function n(o) {
+  const e = t.useContext(r);
+  return o || e || "ltr";
+}
+export {
+  n as useDirection
+};

package/dist/index.es161.js

@@ -0,0 +1,8 @@
+import * as u from "react";
+function t(r) {
+  const e = u.useRef({ value: r, previous: r });
+  return u.useMemo(() => (e.current.value !== r && (e.current.previous = e.current.value, e.current.value = r), e.current.previous), [r]);
+}
+export {
+  t as usePrevious
+};

package/dist/index.es162.js

@@ -0,0 +1,30 @@
+import * as e from "react";
+import { Primitive as a } from "./index.es151.js";
+import { j as o } from "./index.es82.js";
+var t = "VisuallyHidden", d = e.forwardRef(
+  (r, i) => /* @__PURE__ */ o.jsx(
+    a.span,
+    {
+      ...r,
+      ref: i,
+      style: {
+        // See: https://github.com/twbs/bootstrap/blob/master/scss/mixins/_screen-reader.scss
+        position: "absolute",
+        border: 0,
+        width: 1,
+        height: 1,
+        padding: 0,
+        margin: -1,
+        overflow: "hidden",
+        clip: "rect(0, 0, 0, 0)",
+        whiteSpace: "nowrap",
+        wordWrap: "normal",
+        ...r.style
+      }
+    }
+  )
+);
+d.displayName = t;
+export {
+  d as VisuallyHidden
+};

package/dist/index.es163.js

@@ -0,0 +1,46 @@
+import { validateFieldsNatively as v, toNestErrors as d } from "./index.es272.js";
+import { appendErrors as h } from "./index.es105.js";
+var m = function(t, u) {
+  for (var o = {}; t.length; ) {
+    var r = t[0], c = r.code, n = r.message, e = r.path.join(".");
+    if (!o[e]) if ("unionErrors" in r) {
+      var s = r.unionErrors[0].errors[0];
+      o[e] = { message: s.message, type: s.code };
+    } else o[e] = { message: n, type: c };
+    if ("unionErrors" in r && r.unionErrors.forEach(function(f) {
+      return f.errors.forEach(function(l) {
+        return t.push(l);
+      });
+    }), u) {
+      var i = o[e].types, a = i && i[r.code];
+      o[e] = h(e, u, o, c, a ? [].concat(a, r.message) : r.message);
+    }
+    t.shift();
+  }
+  return o;
+}, E = function(t, u, o) {
+  return o === void 0 && (o = {}), function(r, c, n) {
+    try {
+      return Promise.resolve(function(e, s) {
+        try {
+          var i = Promise.resolve(t[o.mode === "sync" ? "parse" : "parseAsync"](r, u)).then(function(a) {
+            return n.shouldUseNativeValidation && v({}, n), { errors: {}, values: o.raw ? r : a };
+          });
+        } catch (a) {
+          return s(a);
+        }
+        return i && i.then ? i.then(void 0, s) : i;
+      }(0, function(e) {
+        if (function(s) {
+          return Array.isArray(s == null ? void 0 : s.errors);
+        }(e)) return { values: {}, errors: d(m(e.errors, !n.shouldUseNativeValidation && n.criteriaMode === "all"), n) };
+        throw e;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+};
+export {
+  E as zodResolver
+};

package/dist/index.es164.js

@@ -0,0 +1,120 @@
+import m from "./index.es324.js";
+import f from "./index.es175.js";
+import v from "./index.es332.js";
+import x from "./index.es325.js";
+import d from "./index.es326.js";
+import s from "react";
+import c from "./index.es333.js";
+import { getInitialChildMapping as E, getNextChildMapping as y, getChildMapping as g } from "./index.es334.js";
+var M = Object.values || function(a) {
+  return Object.keys(a).map(function(r) {
+    return a[r];
+  });
+}, F = {
+  component: "div",
+  childFactory: function(r) {
+    return r;
+  }
+}, h = /* @__PURE__ */ function(a) {
+  x(r, a);
+  function r(p, t) {
+    var e;
+    e = a.call(this, p, t) || this;
+    var o = e.handleExited.bind(v(e));
+    return e.state = {
+      contextValue: {
+        isMounting: !0
+      },
+      handleExited: o,
+      firstRender: !0
+    }, e;
+  }
+  var l = r.prototype;
+  return l.componentDidMount = function() {
+    this.mounted = !0, this.setState({
+      contextValue: {
+        isMounting: !1
+      }
+    });
+  }, l.componentWillUnmount = function() {
+    this.mounted = !1;
+  }, r.getDerivedStateFromProps = function(t, e) {
+    var o = e.children, n = e.handleExited, i = e.firstRender;
+    return {
+      children: i ? E(t, n) : y(t, o, n),
+      firstRender: !1
+    };
+  }, l.handleExited = function(t, e) {
+    var o = g(this.props.children);
+    t.key in o || (t.props.onExited && t.props.onExited(e), this.mounted && this.setState(function(n) {
+      var i = f({}, n.children);
+      return delete i[t.key], {
+        children: i
+      };
+    }));
+  }, l.render = function() {
+    var t = this.props, e = t.component, o = t.childFactory, n = m(t, ["component", "childFactory"]), i = this.state.contextValue, u = M(this.state.children).map(o);
+    return delete n.appear, delete n.enter, delete n.exit, e === null ? /* @__PURE__ */ s.createElement(c.Provider, {
+      value: i
+    }, u) : /* @__PURE__ */ s.createElement(c.Provider, {
+      value: i
+    }, /* @__PURE__ */ s.createElement(e, n, u));
+  }, r;
+}(s.Component);
+h.propTypes = process.env.NODE_ENV !== "production" ? {
+  /**
+   * `<TransitionGroup>` renders a `<div>` by default. You can change this
+   * behavior by providing a `component` prop.
+   * If you use React v16+ and would like to avoid a wrapping `<div>` element
+   * you can pass in `component={null}`. This is useful if the wrapping div
+   * borks your css styles.
+   */
+  component: d.any,
+  /**
+   * A set of `<Transition>` components, that are toggled `in` and out as they
+   * leave. the `<TransitionGroup>` will inject specific transition props, so
+   * remember to spread them through if you are wrapping the `<Transition>` as
+   * with our `<Fade>` example.
+   *
+   * While this component is meant for multiple `Transition` or `CSSTransition`
+   * children, sometimes you may want to have a single transition child with
+   * content that you want to be transitioned out and in when you change it
+   * (e.g. routes, images etc.) In that case you can change the `key` prop of
+   * the transition child as you change its content, this will cause
+   * `TransitionGroup` to transition the child out and back in.
+   */
+  children: d.node,
+  /**
+   * A convenience prop that enables or disables appear animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  appear: d.bool,
+  /**
+   * A convenience prop that enables or disables enter animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  enter: d.bool,
+  /**
+   * A convenience prop that enables or disables exit animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  exit: d.bool,
+  /**
+   * You may need to apply reactive updates to a child as it is exiting.
+   * This is generally done by using `cloneElement` however in the case of an exiting
+   * child the element has already been removed and not accessible to the consumer.
+   *
+   * If you do need to update a child as it leaves you can provide a `childFactory`
+   * to wrap every child, even the ones that are leaving.
+   *
+   * @type Function(child: ReactElement) -> ReactElement
+   */
+  childFactory: d.func
+} : {};
+h.defaultProps = F;
+export {
+  h as default
+};

package/dist/index.es165.js

@@ -0,0 +1,35 @@
+import { createStore as a } from "./index.es273.js";
+import c from "react";
+import d from "./index.es274.js";
+const n = { BASE_URL: "/", DEV: !1, MODE: "production", PROD: !0, SSR: !1 }, { useDebugValue: l } = c, { useSyncExternalStoreWithSelector: f } = d;
+let s = !1;
+const p = (t) => t;
+function E(t, o = p, e) {
+  (n ? "production" : void 0) !== "production" && e && !s && (console.warn(
+    "[DEPRECATED] Use `createWithEqualityFn` instead of `create` or use `useStoreWithEqualityFn` instead of `useStore`. They can be imported from 'zustand/traditional'. https://github.com/pmndrs/zustand/discussions/1937"
+  ), s = !0);
+  const r = f(
+    t.subscribe,
+    t.getState,
+    t.getServerState || t.getInitialState,
+    o,
+    e
+  );
+  return l(r), r;
+}
+const i = (t) => {
+  (n ? "production" : void 0) !== "production" && typeof t != "function" && console.warn(
+    "[DEPRECATED] Passing a vanilla store will be unsupported in a future version. Instead use `import { useStore } from 'zustand'`."
+  );
+  const o = typeof t == "function" ? a(t) : t, e = (r, u) => E(o, r, u);
+  return Object.assign(e, o), e;
+}, m = (t) => t ? i(t) : i;
+var v = (t) => ((n ? "production" : void 0) !== "production" && console.warn(
+  "[DEPRECATED] Default export is deprecated. Instead use `import { create } from 'zustand'`."
+), m(t));
+export {
+  m as create,
+  a as createStore,
+  v as default,
+  E as useStore
+};

package/dist/index.es166.js

@@ -0,0 +1,4 @@
+var r = {};
+export {
+  r as __exports
+};

package/dist/index.es167.js

@@ -0,0 +1,4 @@
+var e = {};
+export {
+  e as __exports
+};

package/dist/index.es168.js

@@ -0,0 +1,23 @@
+import { forwardRef as s, createElement as c } from "react";
+import { mergeClasses as n, toKebabCase as f } from "./index.es169.js";
+import l from "./index.es170.js";
+/**
+ * @license lucide-react v0.379.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const u = (e, r) => {
+  const o = s(
+    ({ className: t, ...a }, m) => c(l, {
+      ref: m,
+      iconNode: r,
+      className: n(`lucide-${f(e)}`, t),
+      ...a
+    })
+  );
+  return o.displayName = `${e}`, o;
+};
+export {
+  u as default
+};

package/dist/index.es169.js

@@ -0,0 +1,11 @@
+/**
+ * @license lucide-react v0.379.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const n = (e) => e.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(), a = (...e) => e.filter((o, r, t) => !!o && t.indexOf(o) === r).join(" ");
+export {
+  a as mergeClasses,
+  n as toKebabCase
+};

package/dist/index.es17.js

@@ -0,0 +1,31 @@
+import { useState as i, useRef as v, useCallback as b, useEffect as l } from "react";
+function p({
+  onVisible: r,
+  root: s = null,
+  rootMargin: u = "0px",
+  threshold: c = 0
+} = {}) {
+  const [n, a] = i(!1), e = v(null), f = b(
+    ([t]) => {
+      const I = t.isIntersecting;
+      a(I);
+    },
+    [r]
+  );
+  return l(() => {
+    if (e.current == null) return;
+    const t = new IntersectionObserver(f, {
+      root: s,
+      rootMargin: u,
+      threshold: c
+    });
+    return t.observe(e.current), () => {
+      e.current != null && t.unobserve(e.current);
+    };
+  }, [e, s, u, c, f]), l(() => {
+    n && (r == null || r());
+  }, [n]), { ref: e, isVisible: n };
+}
+export {
+  p as default
+};

package/dist/index.es170.js

@@ -0,0 +1,40 @@
+import { forwardRef as i, createElement as o } from "react";
+import b from "./index.es171.js";
+import { mergeClasses as d } from "./index.es169.js";
+/**
+ * @license lucide-react v0.379.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const N = i(
+  ({
+    color: m = "currentColor",
+    size: r = 24,
+    strokeWidth: e = 2,
+    absoluteStrokeWidth: a,
+    className: s = "",
+    children: t,
+    iconNode: u,
+    ...f
+  }, l) => o(
+    "svg",
+    {
+      ref: l,
+      ...b,
+      width: r,
+      height: r,
+      stroke: m,
+      strokeWidth: a ? Number(e) * 24 / Number(r) : e,
+      className: d("lucide", s),
+      ...f
+    },
+    [
+      ...u.map(([p, c]) => o(p, c)),
+      ...Array.isArray(t) ? t : [t]
+    ]
+  )
+);
+export {
+  N as default
+};