@worldcoin/mini-apps-ui-kit-react 1.0.0-canary.9 → 1.0.0

package/dist/node_modules/.pnpm/@floating-ui_utils@0.2.8/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.js

@@ -1,131 +1,166 @@
-function c() {
-  return typeof window < "u";
+function hasWindow() {
+  return typeof window !== "undefined";
 }
-function f(n) {
-  return p(n) ? (n.nodeName || "").toLowerCase() : "#document";
+function getNodeName(node) {
+  if (isNode(node)) {
+    return (node.nodeName || "").toLowerCase();
+  }
+  return "#document";
 }
-function i(n) {
-  var t;
-  return (n == null || (t = n.ownerDocument) == null ? void 0 : t.defaultView) || window;
+function getWindow(node) {
+  var _node$ownerDocument;
+  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
 }
-function E(n) {
-  var t;
-  return (t = (p(n) ? n.ownerDocument : n.document) || window.document) == null ? void 0 : t.documentElement;
+function getDocumentElement(node) {
+  var _ref;
+  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
 }
-function p(n) {
-  return c() ? n instanceof Node || n instanceof i(n).Node : !1;
+function isNode(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Node || value instanceof getWindow(value).Node;
 }
-function m(n) {
-  return c() ? n instanceof Element || n instanceof i(n).Element : !1;
+function isElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Element || value instanceof getWindow(value).Element;
 }
-function w(n) {
-  return c() ? n instanceof HTMLElement || n instanceof i(n).HTMLElement : !1;
+function isHTMLElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
 }
-function a(n) {
-  return !c() || typeof ShadowRoot > "u" ? !1 : n instanceof ShadowRoot || n instanceof i(n).ShadowRoot;
+function isShadowRoot(value) {
+  if (!hasWindow() || typeof ShadowRoot === "undefined") {
+    return false;
+  }
+  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
 }
-function y(n) {
+function isOverflowElement(element) {
   const {
-    overflow: t,
-    overflowX: e,
-    overflowY: o,
-    display: r
-  } = b(n);
-  return /auto|scroll|overlay|hidden|clip/.test(t + o + e) && !["inline", "contents"].includes(r);
-}
-function D(n) {
-  return ["table", "td", "th"].includes(f(n));
-}
-function N(n) {
-  return [":popover-open", ":modal"].some((t) => {
+    overflow,
+    overflowX,
+    overflowY,
+    display
+  } = getComputedStyle(element);
+  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !["inline", "contents"].includes(display);
+}
+function isTableElement(element) {
+  return ["table", "td", "th"].includes(getNodeName(element));
+}
+function isTopLayer(element) {
+  return [":popover-open", ":modal"].some((selector) => {
     try {
-      return n.matches(t);
-    } catch {
-      return !1;
+      return element.matches(selector);
+    } catch (e) {
+      return false;
     }
   });
 }
-function T(n) {
-  const t = v(), e = m(n) ? b(n) : n;
-  return e.transform !== "none" || e.perspective !== "none" || (e.containerType ? e.containerType !== "normal" : !1) || !t && (e.backdropFilter ? e.backdropFilter !== "none" : !1) || !t && (e.filter ? e.filter !== "none" : !1) || ["transform", "perspective", "filter"].some((o) => (e.willChange || "").includes(o)) || ["paint", "layout", "strict", "content"].some((o) => (e.contain || "").includes(o));
-}
-function k(n) {
-  let t = l(n);
-  for (; w(t) && !g(t); ) {
-    if (T(t))
-      return t;
-    if (N(t))
+function isContainingBlock(elementOrCss) {
+  const webkit = isWebKit();
+  const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;
+  return css.transform !== "none" || css.perspective !== "none" || (css.containerType ? css.containerType !== "normal" : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== "none" : false) || !webkit && (css.filter ? css.filter !== "none" : false) || ["transform", "perspective", "filter"].some((value) => (css.willChange || "").includes(value)) || ["paint", "layout", "strict", "content"].some((value) => (css.contain || "").includes(value));
+}
+function getContainingBlock(element) {
+  let currentNode = getParentNode(element);
+  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    if (isContainingBlock(currentNode)) {
+      return currentNode;
+    } else if (isTopLayer(currentNode)) {
       return null;
-    t = l(t);
+    }
+    currentNode = getParentNode(currentNode);
   }
   return null;
 }
-function v() {
-  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+function isWebKit() {
+  if (typeof CSS === "undefined" || !CSS.supports) return false;
+  return CSS.supports("-webkit-backdrop-filter", "none");
 }
-function g(n) {
-  return ["html", "body", "#document"].includes(f(n));
+function isLastTraversableNode(node) {
+  return ["html", "body", "#document"].includes(getNodeName(node));
 }
-function b(n) {
-  return i(n).getComputedStyle(n);
+function getComputedStyle(element) {
+  return getWindow(element).getComputedStyle(element);
 }
-function C(n) {
-  return m(n) ? {
-    scrollLeft: n.scrollLeft,
-    scrollTop: n.scrollTop
-  } : {
-    scrollLeft: n.scrollX,
-    scrollTop: n.scrollY
+function getNodeScroll(element) {
+  if (isElement(element)) {
+    return {
+      scrollLeft: element.scrollLeft,
+      scrollTop: element.scrollTop
+    };
+  }
+  return {
+    scrollLeft: element.scrollX,
+    scrollTop: element.scrollY
   };
 }
-function l(n) {
-  if (f(n) === "html")
-    return n;
-  const t = (
+function getParentNode(node) {
+  if (getNodeName(node) === "html") {
+    return node;
+  }
+  const result = (
     // Step into the shadow DOM of the parent of a slotted node.
-    n.assignedSlot || // DOM Element detected.
-    n.parentNode || // ShadowRoot detected.
-    a(n) && n.host || // Fallback.
-    E(n)
+    node.assignedSlot || // DOM Element detected.
+    node.parentNode || // ShadowRoot detected.
+    isShadowRoot(node) && node.host || // Fallback.
+    getDocumentElement(node)
   );
-  return a(t) ? t.host : t;
-}
-function h(n) {
-  const t = l(n);
-  return g(t) ? n.ownerDocument ? n.ownerDocument.body : n.body : w(t) && y(t) ? t : h(t);
-}
-function d(n, t, e) {
-  var o;
-  t === void 0 && (t = []), e === void 0 && (e = !0);
-  const r = h(n), S = r === ((o = n.ownerDocument) == null ? void 0 : o.body), u = i(r);
-  if (S) {
-    const s = L(u);
-    return t.concat(u, u.visualViewport || [], y(r) ? r : [], s && e ? d(s) : []);
+  return isShadowRoot(result) ? result.host : result;
+}
+function getNearestOverflowAncestor(node) {
+  const parentNode = getParentNode(node);
+  if (isLastTraversableNode(parentNode)) {
+    return node.ownerDocument ? node.ownerDocument.body : node.body;
+  }
+  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
+    return parentNode;
+  }
+  return getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(node, list, traverseIframes) {
+  var _node$ownerDocument2;
+  if (list === void 0) {
+    list = [];
+  }
+  if (traverseIframes === void 0) {
+    traverseIframes = true;
+  }
+  const scrollableAncestor = getNearestOverflowAncestor(node);
+  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+  const win = getWindow(scrollableAncestor);
+  if (isBody) {
+    const frameElement = getFrameElement(win);
+    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
   }
-  return t.concat(r, d(r, [], e));
+  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
 }
-function L(n) {
-  return n.parent && Object.getPrototypeOf(n.parent) ? n.frameElement : null;
+function getFrameElement(win) {
+  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
 }
 export {
-  b as getComputedStyle,
-  k as getContainingBlock,
-  E as getDocumentElement,
-  L as getFrameElement,
-  h as getNearestOverflowAncestor,
-  f as getNodeName,
-  C as getNodeScroll,
-  d as getOverflowAncestors,
-  l as getParentNode,
-  i as getWindow,
-  T as isContainingBlock,
-  m as isElement,
-  w as isHTMLElement,
-  g as isLastTraversableNode,
-  p as isNode,
-  y as isOverflowElement,
-  a as isShadowRoot,
-  D as isTableElement,
-  N as isTopLayer,
-  v as isWebKit
+  getComputedStyle,
+  getContainingBlock,
+  getDocumentElement,
+  getFrameElement,
+  getNearestOverflowAncestor,
+  getNodeName,
+  getNodeScroll,
+  getOverflowAncestors,
+  getParentNode,
+  getWindow,
+  isContainingBlock,
+  isElement,
+  isHTMLElement,
+  isLastTraversableNode,
+  isNode,
+  isOverflowElement,
+  isShadowRoot,
+  isTableElement,
+  isTopLayer,
+  isWebKit
 };

package/dist/node_modules/.pnpm/@floating-ui_utils@0.2.8/node_modules/@floating-ui/utils/dist/floating-ui.utils.js

@@ -1,129 +1,153 @@
-const P = ["top", "right", "bottom", "left"], l = Math.min, m = Math.max, M = Math.round, O = Math.floor, S = (t) => ({
-  x: t,
-  y: t
-}), p = {
+const sides = ["top", "right", "bottom", "left"];
+const min = Math.min;
+const max = Math.max;
+const round = Math.round;
+const floor = Math.floor;
+const createCoords = (v) => ({
+  x: v,
+  y: v
+});
+const oppositeSideMap = {
   left: "right",
   right: "left",
   bottom: "top",
   top: "bottom"
-}, a = {
+};
+const oppositeAlignmentMap = {
   start: "end",
   end: "start"
 };
-function w(t, n, e) {
-  return m(t, l(n, e));
+function clamp(start, value, end) {
+  return max(start, min(value, end));
 }
-function j(t, n) {
-  return typeof t == "function" ? t(n) : t;
+function evaluate(value, param) {
+  return typeof value === "function" ? value(param) : value;
 }
-function u(t) {
-  return t.split("-")[0];
+function getSide(placement) {
+  return placement.split("-")[0];
 }
-function g(t) {
-  return t.split("-")[1];
+function getAlignment(placement) {
+  return placement.split("-")[1];
 }
-function h(t) {
-  return t === "x" ? "y" : "x";
+function getOppositeAxis(axis) {
+  return axis === "x" ? "y" : "x";
 }
-function b(t) {
-  return t === "y" ? "height" : "width";
+function getAxisLength(axis) {
+  return axis === "y" ? "height" : "width";
 }
-function x(t) {
-  return ["top", "bottom"].includes(u(t)) ? "y" : "x";
+function getSideAxis(placement) {
+  return ["top", "bottom"].includes(getSide(placement)) ? "y" : "x";
 }
-function d(t) {
-  return h(x(t));
+function getAlignmentAxis(placement) {
+  return getOppositeAxis(getSideAxis(placement));
 }
-function C(t, n, e) {
-  e === void 0 && (e = !1);
-  const r = g(t), o = d(t), i = b(o);
-  let c = o === "x" ? r === (e ? "end" : "start") ? "right" : "left" : r === "start" ? "bottom" : "top";
-  return n.reference[i] > n.floating[i] && (c = f(c)), [c, f(c)];
+function getAlignmentSides(placement, rects, rtl) {
+  if (rtl === void 0) {
+    rtl = false;
+  }
+  const alignment = getAlignment(placement);
+  const alignmentAxis = getAlignmentAxis(placement);
+  const length = getAxisLength(alignmentAxis);
+  let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
+  if (rects.reference[length] > rects.floating[length]) {
+    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+  }
+  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
 }
-function L(t) {
-  const n = f(t);
-  return [s(t), n, s(n)];
+function getExpandedPlacements(placement) {
+  const oppositePlacement = getOppositePlacement(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
 }
-function s(t) {
-  return t.replace(/start|end/g, (n) => a[n]);
+function getOppositeAlignmentPlacement(placement) {
+  return placement.replace(/start|end/g, (alignment) => oppositeAlignmentMap[alignment]);
 }
-function A(t, n, e) {
-  const r = ["left", "right"], o = ["right", "left"], i = ["top", "bottom"], c = ["bottom", "top"];
-  switch (t) {
+function getSideList(side, isStart, rtl) {
+  const lr = ["left", "right"];
+  const rl = ["right", "left"];
+  const tb = ["top", "bottom"];
+  const bt = ["bottom", "top"];
+  switch (side) {
     case "top":
     case "bottom":
-      return e ? n ? o : r : n ? r : o;
+      if (rtl) return isStart ? rl : lr;
+      return isStart ? lr : rl;
     case "left":
     case "right":
-      return n ? i : c;
+      return isStart ? tb : bt;
     default:
       return [];
   }
 }
-function E(t, n, e, r) {
-  const o = g(t);
-  let i = A(u(t), e === "start", r);
-  return o && (i = i.map((c) => c + "-" + o), n && (i = i.concat(i.map(s)))), i;
+function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+  const alignment = getAlignment(placement);
+  let list = getSideList(getSide(placement), direction === "start", rtl);
+  if (alignment) {
+    list = list.map((side) => side + "-" + alignment);
+    if (flipAlignment) {
+      list = list.concat(list.map(getOppositeAlignmentPlacement));
+    }
+  }
+  return list;
 }
-function f(t) {
-  return t.replace(/left|right|bottom|top/g, (n) => p[n]);
+function getOppositePlacement(placement) {
+  return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap[side]);
 }
-function y(t) {
+function expandPaddingObject(padding) {
   return {
     top: 0,
     right: 0,
     bottom: 0,
     left: 0,
-    ...t
+    ...padding
   };
 }
-function R(t) {
-  return typeof t != "number" ? y(t) : {
-    top: t,
-    right: t,
-    bottom: t,
-    left: t
+function getPaddingObject(padding) {
+  return typeof padding !== "number" ? expandPaddingObject(padding) : {
+    top: padding,
+    right: padding,
+    bottom: padding,
+    left: padding
   };
 }
-function T(t) {
+function rectToClientRect(rect) {
   const {
-    x: n,
-    y: e,
-    width: r,
-    height: o
-  } = t;
+    x,
+    y,
+    width,
+    height
+  } = rect;
   return {
-    width: r,
-    height: o,
-    top: e,
-    left: n,
-    right: n + r,
-    bottom: e + o,
-    x: n,
-    y: e
+    width,
+    height,
+    top: y,
+    left: x,
+    right: x + width,
+    bottom: y + height,
+    x,
+    y
   };
 }
 export {
-  w as clamp,
-  S as createCoords,
-  j as evaluate,
-  y as expandPaddingObject,
-  O as floor,
-  g as getAlignment,
-  d as getAlignmentAxis,
-  C as getAlignmentSides,
-  b as getAxisLength,
-  L as getExpandedPlacements,
-  s as getOppositeAlignmentPlacement,
-  h as getOppositeAxis,
-  E as getOppositeAxisPlacements,
-  f as getOppositePlacement,
-  R as getPaddingObject,
-  u as getSide,
-  x as getSideAxis,
-  m as max,
-  l as min,
-  T as rectToClientRect,
-  M as round,
-  P as sides
+  clamp,
+  createCoords,
+  evaluate,
+  expandPaddingObject,
+  floor,
+  getAlignment,
+  getAlignmentAxis,
+  getAlignmentSides,
+  getAxisLength,
+  getExpandedPlacements,
+  getOppositeAlignmentPlacement,
+  getOppositeAxis,
+  getOppositeAxisPlacements,
+  getOppositePlacement,
+  getPaddingObject,
+  getSide,
+  getSideAxis,
+  max,
+  min,
+  rectToClientRect,
+  round,
+  sides
 };

package/dist/node_modules/.pnpm/@radix-ui_number@1.1.0/node_modules/@radix-ui/number/dist/index.js

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

package/dist/node_modules/.pnpm/@radix-ui_primitive@1.1.1/node_modules/@radix-ui/primitive/dist/index.js

@@ -1,9 +1,11 @@
-function h(f, c, { checkForDefaultPrevented: p = !0 } = {}) {
-  return function(s) {
-    if (f == null || f(s), p === !1 || !s.defaultPrevented)
-      return c == null ? void 0 : c(s);
+function composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {
+  return function handleEvent(event) {
+    originalEventHandler == null ? void 0 : originalEventHandler(event);
+    if (checkForDefaultPrevented === false || !event.defaultPrevented) {
+      return ourEventHandler == null ? void 0 : ourEventHandler(event);
+    }
   };
 }
 export {
-  h as composeEventHandlers
+  composeEventHandlers
 };

package/dist/node_modules/.pnpm/@radix-ui_react-arrow@1.1.1_@types_react-dom@18.3.5_@types_react@18.3.18__@types_react@18.3.1_wfj52omijboqejc6zhpwkjvyjq/node_modules/@radix-ui/react-arrow/dist/index.js

@@ -1,24 +1,25 @@
-import * as n from "react";
-import { Primitive as p } from "../../../../../@radix-ui_react-primitive@2.0.1_@types_react-dom@18.3.5_@types_react@18.3.18__@types_react@18_sspjpiczol7qxzbuuyfihuep4u/node_modules/@radix-ui/react-primitive/dist/index.js";
-import { jsx as o } from "react/jsx-runtime";
-var v = "Arrow", e = n.forwardRef((r, i) => {
-  const { children: t, width: a = 10, height: s = 5, ...m } = r;
-  return /* @__PURE__ */ o(
-    p.svg,
+import * as React from "react";
+import { Primitive } from "../../../../../@radix-ui_react-primitive@2.0.1_@types_react-dom@18.3.5_@types_react@18.3.18__@types_react@18_sspjpiczol7qxzbuuyfihuep4u/node_modules/@radix-ui/react-primitive/dist/index.js";
+import { jsx } from "react/jsx-runtime";
+var NAME = "Arrow";
+var Arrow = React.forwardRef((props, forwardedRef) => {
+  const { children, width = 10, height = 5, ...arrowProps } = props;
+  return /* @__PURE__ */ jsx(
+    Primitive.svg,
     {
-      ...m,
-      ref: i,
-      width: a,
-      height: s,
+      ...arrowProps,
+      ref: forwardedRef,
+      width,
+      height,
       viewBox: "0 0 30 10",
       preserveAspectRatio: "none",
-      children: r.asChild ? t : /* @__PURE__ */ o("polygon", { points: "0,0 30,0 15,10" })
+      children: props.asChild ? children : /* @__PURE__ */ jsx("polygon", { points: "0,0 30,0 15,10" })
     }
   );
 });
-e.displayName = v;
-var h = e;
+Arrow.displayName = NAME;
+var Root = Arrow;
 export {
-  e as Arrow,
-  h as Root
+  Arrow,
+  Root
 };