@prokodo/ui 0.0.26 → 0.0.28

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

@@ -1,131 +1,189 @@
-function c() {
-  return typeof window < "u";
-}
-function s(n) {
-  return p(n) ? (n.nodeName || "").toLowerCase() : "#document";
-}
-function i(n) {
-  var t;
-  return (n == null || (t = n.ownerDocument) == null ? void 0 : t.defaultView) || window;
-}
-function E(n) {
-  var t;
-  return (t = (p(n) ? n.ownerDocument : n.document) || window.document) == null ? void 0 : t.documentElement;
-}
-function p(n) {
-  return c() ? n instanceof Node || n instanceof i(n).Node : !1;
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function hasWindow() {
+  return typeof window !== "undefined";
+}
+__name(hasWindow, "hasWindow");
+function getNodeName(node) {
+  if (isNode(node)) {
+    return (node.nodeName || "").toLowerCase();
+  }
+  return "#document";
+}
+__name(getNodeName, "getNodeName");
+function getWindow(node) {
+  var _node$ownerDocument;
+  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+}
+__name(getWindow, "getWindow");
+function getDocumentElement(node) {
+  var _ref;
+  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+}
+__name(getDocumentElement, "getDocumentElement");
+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;
+__name(isNode, "isNode");
+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;
+__name(isElement, "isElement");
+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;
+__name(isHTMLElement, "isHTMLElement");
+function isShadowRoot(value) {
+  if (!hasWindow() || typeof ShadowRoot === "undefined") {
+    return false;
+  }
+  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
 }
-function y(n) {
+__name(isShadowRoot, "isShadowRoot");
+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(s(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);
+}
+__name(isOverflowElement, "isOverflowElement");
+function isTableElement(element) {
+  return ["table", "td", "th"].includes(getNodeName(element));
+}
+__name(isTableElement, "isTableElement");
+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 = L(), e = m(n) ? b(n) : n;
-  return ["transform", "translate", "scale", "rotate", "perspective"].some((o) => e[o] ? e[o] !== "none" : !1) || (e.containerType ? e.containerType !== "normal" : !1) || !t && (e.backdropFilter ? e.backdropFilter !== "none" : !1) || !t && (e.filter ? e.filter !== "none" : !1) || ["transform", "translate", "scale", "rotate", "perspective", "filter"].some((o) => (e.willChange || "").includes(o)) || ["paint", "layout", "strict", "content"].some((o) => (e.contain || "").includes(o));
-}
-function k(n) {
-  let t = u(n);
-  for (; w(t) && !g(t); ) {
-    if (T(t))
-      return t;
-    if (N(t))
+__name(isTopLayer, "isTopLayer");
+function isContainingBlock(elementOrCss) {
+  const webkit = isWebKit();
+  const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;
+  return ["transform", "translate", "scale", "rotate", "perspective"].some((value) => css[value] ? css[value] !== "none" : false) || (css.containerType ? css.containerType !== "normal" : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== "none" : false) || !webkit && (css.filter ? css.filter !== "none" : false) || ["transform", "translate", "scale", "rotate", "perspective", "filter"].some((value) => (css.willChange || "").includes(value)) || ["paint", "layout", "strict", "content"].some((value) => (css.contain || "").includes(value));
+}
+__name(isContainingBlock, "isContainingBlock");
+function getContainingBlock(element) {
+  let currentNode = getParentNode(element);
+  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    if (isContainingBlock(currentNode)) {
+      return currentNode;
+    } else if (isTopLayer(currentNode)) {
       return null;
-    t = u(t);
+    }
+    currentNode = getParentNode(currentNode);
   }
   return null;
 }
-function L() {
-  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
-}
-function g(n) {
-  return ["html", "body", "#document"].includes(s(n));
-}
-function b(n) {
-  return i(n).getComputedStyle(n);
-}
-function C(n) {
-  return m(n) ? {
-    scrollLeft: n.scrollLeft,
-    scrollTop: n.scrollTop
-  } : {
-    scrollLeft: n.scrollX,
-    scrollTop: n.scrollY
+__name(getContainingBlock, "getContainingBlock");
+function isWebKit() {
+  if (typeof CSS === "undefined" || !CSS.supports) return false;
+  return CSS.supports("-webkit-backdrop-filter", "none");
+}
+__name(isWebKit, "isWebKit");
+function isLastTraversableNode(node) {
+  return ["html", "body", "#document"].includes(getNodeName(node));
+}
+__name(isLastTraversableNode, "isLastTraversableNode");
+function getComputedStyle(element) {
+  return getWindow(element).getComputedStyle(element);
+}
+__name(getComputedStyle, "getComputedStyle");
+function getNodeScroll(element) {
+  if (isElement(element)) {
+    return {
+      scrollLeft: element.scrollLeft,
+      scrollTop: element.scrollTop
+    };
+  }
+  return {
+    scrollLeft: element.scrollX,
+    scrollTop: element.scrollY
   };
 }
-function u(n) {
-  if (s(n) === "html")
-    return n;
-  const t = (
+__name(getNodeScroll, "getNodeScroll");
+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 = u(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), l = i(r);
-  if (S) {
-    const f = v(l);
-    return t.concat(l, l.visualViewport || [], y(r) ? r : [], f && e ? d(f) : []);
+  return isShadowRoot(result) ? result.host : result;
+}
+__name(getParentNode, "getParentNode");
+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);
+}
+__name(getNearestOverflowAncestor, "getNearestOverflowAncestor");
+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 v(n) {
-  return n.parent && Object.getPrototypeOf(n.parent) ? n.frameElement : null;
+__name(getOverflowAncestors, "getOverflowAncestors");
+function getFrameElement(win) {
+  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
 }
+__name(getFrameElement, "getFrameElement");
 export {
-  b as getComputedStyle,
-  k as getContainingBlock,
-  E as getDocumentElement,
-  v as getFrameElement,
-  h as getNearestOverflowAncestor,
-  s as getNodeName,
-  C as getNodeScroll,
-  d as getOverflowAncestors,
-  u 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,
-  L 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.9/node_modules/@floating-ui/utils/dist/floating-ui.utils.js

@@ -1,128 +1,170 @@
-const l = Math.min, a = Math.max, P = Math.round, M = Math.floor, O = (t) => ({
-  x: t,
-  y: t
-}), m = {
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const min = Math.min;
+const max = Math.max;
+const round = Math.round;
+const floor = Math.floor;
+const createCoords = /* @__PURE__ */ __name((v) => ({
+  x: v,
+  y: v
+}), "createCoords");
+const oppositeSideMap = {
   left: "right",
   right: "left",
   bottom: "top",
   top: "bottom"
-}, p = {
+};
+const oppositeAlignmentMap = {
   start: "end",
   end: "start"
 };
-function S(t, n, e) {
-  return a(t, l(n, e));
-}
-function w(t, n) {
-  return typeof t == "function" ? t(n) : t;
-}
-function f(t) {
-  return t.split("-")[0];
-}
-function g(t) {
-  return t.split("-")[1];
+function clamp(start, value, end) {
+  return max(start, min(value, end));
 }
-function h(t) {
-  return t === "x" ? "y" : "x";
+__name(clamp, "clamp");
+function evaluate(value, param) {
+  return typeof value === "function" ? value(param) : value;
 }
-function x(t) {
-  return t === "y" ? "height" : "width";
+__name(evaluate, "evaluate");
+function getSide(placement) {
+  return placement.split("-")[0];
 }
-function b(t) {
-  return ["top", "bottom"].includes(f(t)) ? "y" : "x";
+__name(getSide, "getSide");
+function getAlignment(placement) {
+  return placement.split("-")[1];
 }
-function d(t) {
-  return h(b(t));
+__name(getAlignment, "getAlignment");
+function getOppositeAxis(axis) {
+  return axis === "x" ? "y" : "x";
 }
-function j(t, n, e) {
-  e === void 0 && (e = !1);
-  const r = g(t), o = d(t), i = x(o);
-  let c = o === "x" ? r === (e ? "end" : "start") ? "right" : "left" : r === "start" ? "bottom" : "top";
-  return n.reference[i] > n.floating[i] && (c = u(c)), [c, u(c)];
+__name(getOppositeAxis, "getOppositeAxis");
+function getAxisLength(axis) {
+  return axis === "y" ? "height" : "width";
 }
-function C(t) {
-  const n = u(t);
-  return [s(t), n, s(n)];
+__name(getAxisLength, "getAxisLength");
+function getSideAxis(placement) {
+  return ["top", "bottom"].includes(getSide(placement)) ? "y" : "x";
 }
-function s(t) {
-  return t.replace(/start|end/g, (n) => p[n]);
+__name(getSideAxis, "getSideAxis");
+function getAlignmentAxis(placement) {
+  return getOppositeAxis(getSideAxis(placement));
 }
-function A(t, n, e) {
-  const r = ["left", "right"], o = ["right", "left"], i = ["top", "bottom"], c = ["bottom", "top"];
-  switch (t) {
+__name(getAlignmentAxis, "getAlignmentAxis");
+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)];
+}
+__name(getAlignmentSides, "getAlignmentSides");
+function getExpandedPlacements(placement) {
+  const oppositePlacement = getOppositePlacement(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+}
+__name(getExpandedPlacements, "getExpandedPlacements");
+function getOppositeAlignmentPlacement(placement) {
+  return placement.replace(/start|end/g, (alignment) => oppositeAlignmentMap[alignment]);
+}
+__name(getOppositeAlignmentPlacement, "getOppositeAlignmentPlacement");
+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 L(t, n, e, r) {
-  const o = g(t);
-  let i = A(f(t), e === "start", r);
-  return o && (i = i.map((c) => c + "-" + o), n && (i = i.concat(i.map(s)))), i;
+__name(getSideList, "getSideList");
+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 u(t) {
-  return t.replace(/left|right|bottom|top/g, (n) => m[n]);
+__name(getOppositeAxisPlacements, "getOppositeAxisPlacements");
+function getOppositePlacement(placement) {
+  return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap[side]);
 }
-function y(t) {
+__name(getOppositePlacement, "getOppositePlacement");
+function expandPaddingObject(padding) {
   return {
     top: 0,
     right: 0,
     bottom: 0,
     left: 0,
-    ...t
+    ...padding
   };
 }
-function E(t) {
-  return typeof t != "number" ? y(t) : {
-    top: t,
-    right: t,
-    bottom: t,
-    left: t
+__name(expandPaddingObject, "expandPaddingObject");
+function getPaddingObject(padding) {
+  return typeof padding !== "number" ? expandPaddingObject(padding) : {
+    top: padding,
+    right: padding,
+    bottom: padding,
+    left: padding
   };
 }
-function R(t) {
+__name(getPaddingObject, "getPaddingObject");
+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
   };
 }
+__name(rectToClientRect, "rectToClientRect");
 export {
-  S as clamp,
-  O as createCoords,
-  w as evaluate,
-  y as expandPaddingObject,
-  M as floor,
-  g as getAlignment,
-  d as getAlignmentAxis,
-  j as getAlignmentSides,
-  x as getAxisLength,
-  C as getExpandedPlacements,
-  s as getOppositeAlignmentPlacement,
-  h as getOppositeAxis,
-  L as getOppositeAxisPlacements,
-  u as getOppositePlacement,
-  E as getPaddingObject,
-  f as getSide,
-  b as getSideAxis,
-  a as max,
-  l as min,
-  R as rectToClientRect,
-  P as round
+  clamp,
+  createCoords,
+  evaluate,
+  expandPaddingObject,
+  floor,
+  getAlignment,
+  getAlignmentAxis,
+  getAlignmentSides,
+  getAxisLength,
+  getExpandedPlacements,
+  getOppositeAlignmentPlacement,
+  getOppositeAxis,
+  getOppositeAxisPlacements,
+  getOppositePlacement,
+  getPaddingObject,
+  getSide,
+  getSideAxis,
+  max,
+  min,
+  rectToClientRect,
+  round
 };