@inploi/plugin-job-alerts 5.0.0 → 5.1.0

package/dist/plugin-job-alerts.cjs

@@ -1173,163 +1173,87 @@ const compat_module = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defin
   useTransition: k,
   version: vn
 }, Symbol.toStringTag, { value: "Module" }));
-function hasWindow() {
+function hasWindow$1() {
   return typeof window !== "undefined";
 }
-function getNodeName(node) {
-  if (isNode(node)) {
+function getNodeName$1(node) {
+  if (isNode$1(node)) {
     return (node.nodeName || "").toLowerCase();
   }
   return "#document";
 }
-function getWindow(node) {
+function getWindow$1(node) {
   var _node$ownerDocument;
   return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
 }
-function getDocumentElement(node) {
+function getDocumentElement$1(node) {
   var _ref;
-  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+  return (_ref = (isNode$1(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
 }
-function isNode(value) {
-  if (!hasWindow()) {
+function isNode$1(value) {
+  if (!hasWindow$1()) {
     return false;
   }
-  return value instanceof Node || value instanceof getWindow(value).Node;
+  return value instanceof Node || value instanceof getWindow$1(value).Node;
 }
-function isElement(value) {
-  if (!hasWindow()) {
+function isElement$1(value) {
+  if (!hasWindow$1()) {
     return false;
   }
-  return value instanceof Element || value instanceof getWindow(value).Element;
+  return value instanceof Element || value instanceof getWindow$1(value).Element;
 }
-function isHTMLElement(value) {
-  if (!hasWindow()) {
+function isHTMLElement$1(value) {
+  if (!hasWindow$1()) {
     return false;
   }
-  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+  return value instanceof HTMLElement || value instanceof getWindow$1(value).HTMLElement;
 }
-function isShadowRoot(value) {
-  if (!hasWindow() || typeof ShadowRoot === "undefined") {
+function isShadowRoot$1(value) {
+  if (!hasWindow$1() || typeof ShadowRoot === "undefined") {
     return false;
   }
-  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+  return value instanceof ShadowRoot || value instanceof getWindow$1(value).ShadowRoot;
 }
 const invalidOverflowDisplayValues = /* @__PURE__ */ new Set(["inline", "contents"]);
-function isOverflowElement(element) {
+function isOverflowElement$1(element) {
   const {
     overflow,
     overflowX,
     overflowY,
     display
-  } = getComputedStyle$1(element);
+  } = getComputedStyle$2(element);
   return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !invalidOverflowDisplayValues.has(display);
 }
-const tableElements = /* @__PURE__ */ new Set(["table", "td", "th"]);
-function isTableElement(element) {
-  return tableElements.has(getNodeName(element));
-}
-const topLayerSelectors = [":popover-open", ":modal"];
-function isTopLayer(element) {
-  return topLayerSelectors.some((selector) => {
-    try {
-      return element.matches(selector);
-    } catch (_e) {
-      return false;
-    }
-  });
-}
-const transformProperties = ["transform", "translate", "scale", "rotate", "perspective"];
-const willChangeValues = ["transform", "translate", "scale", "rotate", "perspective", "filter"];
-const containValues = ["paint", "layout", "strict", "content"];
-function isContainingBlock(elementOrCss) {
-  const webkit = isWebKit$1();
-  const css = isElement(elementOrCss) ? getComputedStyle$1(elementOrCss) : elementOrCss;
-  return transformProperties.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) || willChangeValues.some((value) => (css.willChange || "").includes(value)) || containValues.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;
-    }
-    currentNode = getParentNode(currentNode);
-  }
-  return null;
-}
-function isWebKit$1() {
+function isWebKit$2() {
   if (typeof CSS === "undefined" || !CSS.supports)
     return false;
   return CSS.supports("-webkit-backdrop-filter", "none");
 }
 const lastTraversableNodeNames = /* @__PURE__ */ new Set(["html", "body", "#document"]);
-function isLastTraversableNode(node) {
-  return lastTraversableNodeNames.has(getNodeName(node));
+function isLastTraversableNode$1(node) {
+  return lastTraversableNodeNames.has(getNodeName$1(node));
 }
-function getComputedStyle$1(element) {
-  return getWindow(element).getComputedStyle(element);
+function getComputedStyle$2(element) {
+  return getWindow$1(element).getComputedStyle(element);
 }
-function getNodeScroll(element) {
-  if (isElement(element)) {
-    return {
-      scrollLeft: element.scrollLeft,
-      scrollTop: element.scrollTop
-    };
-  }
-  return {
-    scrollLeft: element.scrollX,
-    scrollTop: element.scrollY
-  };
-}
-function getParentNode(node) {
-  if (getNodeName(node) === "html") {
+function getParentNode$1(node) {
+  if (getNodeName$1(node) === "html") {
     return node;
   }
   const result = (
     // Step into the shadow DOM of the parent of a slotted node.
     node.assignedSlot || // DOM Element detected.
     node.parentNode || // ShadowRoot detected.
-    isShadowRoot(node) && node.host || // Fallback.
-    getDocumentElement(node)
+    isShadowRoot$1(node) && node.host || // Fallback.
+    getDocumentElement$1(node)
   );
-  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 list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
-}
-function getFrameElement(win) {
-  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
+  return isShadowRoot$1(result) ? result.host : result;
 }
 const hasNavigator = typeof navigator !== "undefined";
 const nav = getNavigatorData();
 const platform$1 = getPlatform();
 const userAgent = getUserAgent();
-const isWebKit = typeof CSS === "undefined" || !CSS.supports ? false : CSS.supports("-webkit-backdrop-filter:none");
+const isWebKit$1 = typeof CSS === "undefined" || !CSS.supports ? false : CSS.supports("-webkit-backdrop-filter:none");
 const isIOS = (
   // iPads can claim to be MacIntel
   nav.platform === "MacIntel" && nav.maxTouchPoints > 1 ? true : /iP(hone|ad|od)|iOS/.test(nav.platform)
@@ -1536,14 +1460,14 @@ function hasInsetScrollbars(referenceElement) {
     return false;
   }
   const doc = ownerDocument(referenceElement);
-  const win = getWindow(doc);
+  const win = getWindow$1(doc);
   return win.innerWidth - doc.documentElement.clientWidth > 0;
 }
 function preventScrollOverlayScrollbars(referenceElement) {
   const doc = ownerDocument(referenceElement);
   const html = doc.documentElement;
   const body = doc.body;
-  const elementToLock = isOverflowElement(html) ? html : body;
+  const elementToLock = isOverflowElement$1(html) ? html : body;
   const originalOverflow = elementToLock.style.overflow;
   elementToLock.style.overflow = "hidden";
   return () => {
@@ -1555,12 +1479,12 @@ function preventScrollInsetScrollbars(referenceElement) {
   const doc = ownerDocument(referenceElement);
   const html = doc.documentElement;
   const body = doc.body;
-  const win = getWindow(html);
+  const win = getWindow$1(html);
   let scrollTop = 0;
   let scrollLeft = 0;
   const resizeFrame = AnimationFrame.create();
   const supportsStableScrollbarGutter = typeof CSS !== "undefined" && ((_a = CSS.supports) == null ? void 0 : _a.call(CSS, "scrollbar-gutter", "stable"));
-  if (isWebKit && (((_b = win.visualViewport) == null ? void 0 : _b.scale) ?? 1) !== 1) {
+  if (isWebKit$1 && (((_b = win.visualViewport) == null ? void 0 : _b.scale) ?? 1) !== 1) {
     return () => {
     };
   }
@@ -1595,7 +1519,7 @@ function preventScrollInsetScrollbars(referenceElement) {
     const scrollbarHeight = Math.max(0, win.innerHeight - html.clientHeight);
     const marginY = parseFloat(bodyStyles.marginTop) + parseFloat(bodyStyles.marginBottom);
     const marginX = parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight);
-    const elementToLock = isOverflowElement(html) ? html : body;
+    const elementToLock = isOverflowElement$1(html) ? html : body;
     if (supportsStableScrollbarGutter) {
       html.style.scrollbarGutter = scrollbarGutterValue;
       elementToLock.style.overflowY = "hidden";
@@ -1683,7 +1607,7 @@ class ScrollLocker {
     }
     const doc = ownerDocument(referenceElement);
     const html = doc.documentElement;
-    const htmlOverflowY = getWindow(html).getComputedStyle(html).overflowY;
+    const htmlOverflowY = getWindow$1(html).getComputedStyle(html).overflowY;
     if (htmlOverflowY === "hidden" || htmlOverflowY === "clip") {
       this.restore = NOOP;
       return;
@@ -1769,7 +1693,7 @@ function contains(parent, child) {
   if (parent.contains(child)) {
     return true;
   }
-  if (rootNode && isShadowRoot(rootNode)) {
+  if (rootNode && isShadowRoot$1(rootNode)) {
     let next = child;
     while (next) {
       if (parent === next) {
@@ -1803,7 +1727,7 @@ function getDocument(node) {
   return (node == null ? void 0 : node.ownerDocument) || document;
 }
 function isTypeableElement(element) {
-  return isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);
+  return isHTMLElement$1(element) && element.matches(TYPEABLE_SELECTOR);
 }
 function isTypeableCombobox(element) {
   if (!element) {
@@ -1876,103 +1800,35 @@ function formatErrorMessage(code, ...args) {
   args.forEach((arg) => url.searchParams.append("args[]", arg));
   return `Base UI error #${code}; visit ${url} for the full message.`;
 }
-const sides = ["top", "right", "bottom", "left"];
-const min = Math.min;
-const max = Math.max;
-const round = Math.round;
-const floor = Math.floor;
-const createCoords = (v2) => ({
-  x: v2,
-  y: v2
-});
-const oppositeSideMap = {
-  left: "right",
-  right: "left",
-  bottom: "top",
-  top: "bottom"
-};
-const oppositeAlignmentMap = {
-  start: "end",
-  end: "start"
-};
-function clamp(start, value, end) {
-  return max(start, min(value, end));
+const min$1 = Math.min;
+const max$1 = Math.max;
+const round$1 = Math.round;
+function clamp$1(start, value, end) {
+  return max$1(start, min$1(value, end));
 }
-function evaluate(value, param) {
+function evaluate$1(value, param) {
   return typeof value === "function" ? value(param) : value;
 }
-function getSide(placement) {
+function getSide$1(placement) {
   return placement.split("-")[0];
 }
-function getAlignment(placement) {
+function getAlignment$1(placement) {
   return placement.split("-")[1];
 }
-function getOppositeAxis(axis) {
+function getOppositeAxis$1(axis) {
   return axis === "x" ? "y" : "x";
 }
-function getAxisLength(axis) {
+function getAxisLength$1(axis) {
   return axis === "y" ? "height" : "width";
 }
 const yAxisSides = /* @__PURE__ */ new Set(["top", "bottom"]);
-function getSideAxis(placement) {
-  return yAxisSides.has(getSide(placement)) ? "y" : "x";
-}
-function getAlignmentAxis(placement) {
-  return getOppositeAxis(getSideAxis(placement));
-}
-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 getExpandedPlacements(placement) {
-  const oppositePlacement = getOppositePlacement(placement);
-  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
-}
-function getOppositeAlignmentPlacement(placement) {
-  return placement.replace(/start|end/g, (alignment) => oppositeAlignmentMap[alignment]);
-}
-const lrPlacement = ["left", "right"];
-const rlPlacement = ["right", "left"];
-const tbPlacement = ["top", "bottom"];
-const btPlacement = ["bottom", "top"];
-function getSideList(side, isStart, rtl) {
-  switch (side) {
-    case "top":
-    case "bottom":
-      if (rtl)
-        return isStart ? rlPlacement : lrPlacement;
-      return isStart ? lrPlacement : rlPlacement;
-    case "left":
-    case "right":
-      return isStart ? tbPlacement : btPlacement;
-    default:
-      return [];
-  }
-}
-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 getSideAxis$1(placement) {
+  return yAxisSides.has(getSide$1(placement)) ? "y" : "x";
 }
-function getOppositePlacement(placement) {
-  return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap[side]);
+function getAlignmentAxis$1(placement) {
+  return getOppositeAxis$1(getSideAxis$1(placement));
 }
-function expandPaddingObject(padding) {
+function expandPaddingObject$1(padding) {
   return {
     top: 0,
     right: 0,
@@ -1981,32 +1837,14 @@ function expandPaddingObject(padding) {
     ...padding
   };
 }
-function getPaddingObject(padding) {
-  return typeof padding !== "number" ? expandPaddingObject(padding) : {
+function getPaddingObject$1(padding) {
+  return typeof padding !== "number" ? expandPaddingObject$1(padding) : {
     top: padding,
     right: padding,
     bottom: padding,
     left: padding
   };
 }
-function rectToClientRect(rect) {
-  const {
-    x: x2,
-    y: y2,
-    width,
-    height
-  } = rect;
-  return {
-    width,
-    height,
-    top: y2,
-    left: x2,
-    right: x2 + width,
-    bottom: y2 + height,
-    x: x2,
-    y: y2
-  };
-}
 /*!
 * tabbable 6.3.0
 * @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE
@@ -2800,7 +2638,7 @@ function applyAttributeToOthers(uncorrectedAvoidElements, body, ariaHidden, iner
       return;
     }
     [].forEach.call(parent.children, (node) => {
-      if (getNodeName(node) === "script") {
+      if (getNodeName$1(node) === "script") {
         return;
       }
       if (elementsToKeep.has(node)) {
@@ -3142,7 +2980,7 @@ function useFloatingPortalNode(props = {}) {
     if (uniqueId == null) {
       return;
     }
-    const resolvedContainer = (containerProp && (isNode(containerProp) ? containerProp : containerProp.current)) ?? parentPortalNode ?? document.body;
+    const resolvedContainer = (containerProp && (isNode$1(containerProp) ? containerProp : containerProp.current)) ?? parentPortalNode ?? document.body;
     if (resolvedContainer == null) {
       if (containerRef.current) {
         containerRef.current = null;
@@ -3277,7 +3115,7 @@ function resolveRef(maybeRef) {
   return "current" in maybeRef ? maybeRef.current : maybeRef;
 }
 function getEventType(event, lastInteractionType) {
-  const win = getWindow(event.target);
+  const win = getWindow$1(event.target);
   if (event instanceof win.KeyboardEvent) {
     return "keyboard";
   }
@@ -3302,7 +3140,7 @@ function clearDisconnectedPreviouslyFocusedElements() {
 }
 function addPreviouslyFocusedElement(element) {
   clearDisconnectedPreviouslyFocusedElements();
-  if (element && getNodeName(element) !== "body") {
+  if (element && getNodeName$1(element) !== "body") {
     previouslyFocusedElements.push(element);
     if (previouslyFocusedElements.length > LIST_LIMIT) {
       previouslyFocusedElements = previouslyFocusedElements.slice(-LIST_LIMIT);
@@ -3330,7 +3168,7 @@ function isFocusable(element) {
   if (typeof element.checkVisibility === "function") {
     return element.checkVisibility();
   }
-  return getComputedStyle$1(element).display !== "none";
+  return getComputedStyle$2(element).display !== "none";
 }
 function handleTabIndex(floatingFocusElement, orderRef) {
   var _a;
@@ -3511,7 +3349,7 @@ function FloatingFocusManager(props) {
           handleTabIndex(floatingFocusElement, orderRef);
         }
         if (restoreFocus && currentTarget !== domReference && !isFocusable(target) && activeElement(getDocument(floatingFocusElement)) === getDocument(floatingFocusElement).body) {
-          if (isHTMLElement(floatingFocusElement)) {
+          if (isHTMLElement$1(floatingFocusElement)) {
             floatingFocusElement.focus();
             if (restoreFocus === "popup") {
               restoreFocusFrame.request(() => {
@@ -3523,7 +3361,7 @@ function FloatingFocusManager(props) {
           const prevTabbableIndex = tabbableIndexRef.current;
           const tabbableContent = getTabbableContent();
           const nodeToFocus = tabbableContent[prevTabbableIndex] || tabbableContent[tabbableContent.length - 1] || floatingFocusElement;
-          if (isHTMLElement(nodeToFocus)) {
+          if (isHTMLElement$1(nodeToFocus)) {
             nodeToFocus.focus();
           }
         }
@@ -3553,7 +3391,7 @@ function FloatingFocusManager(props) {
         dataRef.current.insideReactTree = false;
       });
     }
-    const domReferenceElement = isHTMLElement(domReference) ? domReference : null;
+    const domReferenceElement = isHTMLElement$1(domReference) ? domReference : null;
     const cleanups = [];
     if (!floating && !domReferenceElement) {
       return void 0;
@@ -3606,7 +3444,7 @@ function FloatingFocusManager(props) {
     };
   }, [open, disabled, domReference, floating, modal, orderRef, portalContext, isUntrappedTypeableCombobox, tree, getNodeId, getInsideElements, nextFocusableElement, previousFocusableElement]);
   useIsoLayoutEffect(() => {
-    if (!open || disabled || !isHTMLElement(floatingFocusElement)) {
+    if (!open || disabled || !isHTMLElement$1(floatingFocusElement)) {
       return;
     }
     const doc = getDocument(floatingFocusElement);
@@ -3707,7 +3545,7 @@ function FloatingFocusManager(props) {
         const hasExplicitReturnFocus = typeof returnFocusRef.current !== "boolean";
         if (
           // eslint-disable-next-line react-hooks/exhaustive-deps
-          returnFocusRef.current && !preventReturnFocusRef.current && isHTMLElement(tabbableReturnElement) && // If the focus moved somewhere else after mount, avoid returning focus
+          returnFocusRef.current && !preventReturnFocusRef.current && isHTMLElement$1(tabbableReturnElement) && // If the focus moved somewhere else after mount, avoid returning focus
           // since it likely entered a different element which should be
           // respected: https://github.com/floating-ui/floating-ui/issues/2607
           (!hasExplicitReturnFocus && tabbableReturnElement !== activeEl && activeEl !== doc.body ? isFocusInsideFloatingTree : true)
@@ -3895,6 +3733,134 @@ function useClick(context, props = {}) {
     reference
   } : EMPTY_OBJECT, [enabled, reference]);
 }
+const sides = ["top", "right", "bottom", "left"];
+const min = Math.min;
+const max = Math.max;
+const round = Math.round;
+const floor = Math.floor;
+const createCoords = (v2) => ({
+  x: v2,
+  y: v2
+});
+const oppositeSideMap = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+};
+function clamp(start, value, end) {
+  return max(start, min(value, end));
+}
+function evaluate(value, param) {
+  return typeof value === "function" ? value(param) : value;
+}
+function getSide(placement) {
+  return placement.split("-")[0];
+}
+function getAlignment(placement) {
+  return placement.split("-")[1];
+}
+function getOppositeAxis(axis) {
+  return axis === "x" ? "y" : "x";
+}
+function getAxisLength(axis) {
+  return axis === "y" ? "height" : "width";
+}
+function getSideAxis(placement) {
+  const firstChar = placement[0];
+  return firstChar === "t" || firstChar === "b" ? "y" : "x";
+}
+function getAlignmentAxis(placement) {
+  return getOppositeAxis(getSideAxis(placement));
+}
+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 getExpandedPlacements(placement) {
+  const oppositePlacement = getOppositePlacement(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+}
+function getOppositeAlignmentPlacement(placement) {
+  return placement.includes("start") ? placement.replace("start", "end") : placement.replace("end", "start");
+}
+const lrPlacement = ["left", "right"];
+const rlPlacement = ["right", "left"];
+const tbPlacement = ["top", "bottom"];
+const btPlacement = ["bottom", "top"];
+function getSideList(side, isStart, rtl) {
+  switch (side) {
+    case "top":
+    case "bottom":
+      if (rtl)
+        return isStart ? rlPlacement : lrPlacement;
+      return isStart ? lrPlacement : rlPlacement;
+    case "left":
+    case "right":
+      return isStart ? tbPlacement : btPlacement;
+    default:
+      return [];
+  }
+}
+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 getOppositePlacement(placement) {
+  const side = getSide(placement);
+  return oppositeSideMap[side] + placement.slice(side.length);
+}
+function expandPaddingObject(padding) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...padding
+  };
+}
+function getPaddingObject(padding) {
+  return typeof padding !== "number" ? expandPaddingObject(padding) : {
+    top: padding,
+    right: padding,
+    bottom: padding,
+    left: padding
+  };
+}
+function rectToClientRect(rect) {
+  const {
+    x: x2,
+    y: y2,
+    width,
+    height
+  } = rect;
+  return {
+    width,
+    height,
+    top: y2,
+    left: x2,
+    right: x2 + width,
+    bottom: y2 + height,
+    x: x2,
+    y: y2
+  };
+}
 function computeCoordsFromPlacement(_ref, placement, rtl) {
   let {
     reference,
@@ -3950,6 +3916,63 @@ function computeCoordsFromPlacement(_ref, placement, rtl) {
   }
   return coords;
 }
+async function detectOverflow(state, options) {
+  var _await$platform$isEle;
+  if (options === void 0) {
+    options = {};
+  }
+  const {
+    x: x2,
+    y: y2,
+    platform: platform2,
+    rects,
+    elements,
+    strategy
+  } = state;
+  const {
+    boundary = "clippingAncestors",
+    rootBoundary = "viewport",
+    elementContext = "floating",
+    altBoundary = false,
+    padding = 0
+  } = evaluate(options, state);
+  const paddingObject = getPaddingObject(padding);
+  const altContext = elementContext === "floating" ? "reference" : "floating";
+  const element = elements[altBoundary ? altContext : elementContext];
+  const clippingClientRect = rectToClientRect(await platform2.getClippingRect({
+    element: ((_await$platform$isEle = await (platform2.isElement == null ? void 0 : platform2.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform2.getDocumentElement == null ? void 0 : platform2.getDocumentElement(elements.floating)),
+    boundary,
+    rootBoundary,
+    strategy
+  }));
+  const rect = elementContext === "floating" ? {
+    x: x2,
+    y: y2,
+    width: rects.floating.width,
+    height: rects.floating.height
+  } : rects.reference;
+  const offsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(elements.floating));
+  const offsetScale = await (platform2.isElement == null ? void 0 : platform2.isElement(offsetParent)) ? await (platform2.getScale == null ? void 0 : platform2.getScale(offsetParent)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  };
+  const elementClientRect = rectToClientRect(platform2.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform2.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements,
+    rect,
+    offsetParent,
+    strategy
+  }) : rect);
+  return {
+    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
+    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
+    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
+    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
+  };
+}
+const MAX_RESET_COUNT = 50;
 const computePosition$1 = async (reference, floating, config) => {
   const {
     placement = "bottom",
@@ -3957,7 +3980,10 @@ const computePosition$1 = async (reference, floating, config) => {
     middleware = [],
     platform: platform2
   } = config;
-  const validMiddleware = middleware.filter(Boolean);
+  const platformWithDetectOverflow = platform2.detectOverflow ? platform2 : {
+    ...platform2,
+    detectOverflow
+  };
   const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(floating));
   let rects = await platform2.getElementRects({
     reference,
@@ -3969,13 +3995,17 @@ const computePosition$1 = async (reference, floating, config) => {
     y: y2
   } = computeCoordsFromPlacement(rects, placement, rtl);
   let statefulPlacement = placement;
-  let middlewareData = {};
   let resetCount = 0;
-  for (let i2 = 0; i2 < validMiddleware.length; i2++) {
+  const middlewareData = {};
+  for (let i2 = 0; i2 < middleware.length; i2++) {
+    const currentMiddleware = middleware[i2];
+    if (!currentMiddleware) {
+      continue;
+    }
     const {
       name,
       fn: fn2
-    } = validMiddleware[i2];
+    } = currentMiddleware;
     const {
       x: nextX,
       y: nextY,
@@ -3989,7 +4019,7 @@ const computePosition$1 = async (reference, floating, config) => {
       strategy,
       middlewareData,
       rects,
-      platform: platform2,
+      platform: platformWithDetectOverflow,
       elements: {
         reference,
         floating
@@ -3997,14 +4027,11 @@ const computePosition$1 = async (reference, floating, config) => {
     });
     x2 = nextX != null ? nextX : x2;
     y2 = nextY != null ? nextY : y2;
-    middlewareData = {
-      ...middlewareData,
-      [name]: {
-        ...middlewareData[name],
-        ...data
-      }
+    middlewareData[name] = {
+      ...middlewareData[name],
+      ...data
     };
-    if (reset && resetCount <= 50) {
+    if (reset && resetCount < MAX_RESET_COUNT) {
       resetCount++;
       if (typeof reset === "object") {
         if (reset.placement) {
@@ -4033,62 +4060,6 @@ const computePosition$1 = async (reference, floating, config) => {
     middlewareData
   };
 };
-async function detectOverflow(state, options) {
-  var _await$platform$isEle;
-  if (options === void 0) {
-    options = {};
-  }
-  const {
-    x: x2,
-    y: y2,
-    platform: platform2,
-    rects,
-    elements,
-    strategy
-  } = state;
-  const {
-    boundary = "clippingAncestors",
-    rootBoundary = "viewport",
-    elementContext = "floating",
-    altBoundary = false,
-    padding = 0
-  } = evaluate(options, state);
-  const paddingObject = getPaddingObject(padding);
-  const altContext = elementContext === "floating" ? "reference" : "floating";
-  const element = elements[altBoundary ? altContext : elementContext];
-  const clippingClientRect = rectToClientRect(await platform2.getClippingRect({
-    element: ((_await$platform$isEle = await (platform2.isElement == null ? void 0 : platform2.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform2.getDocumentElement == null ? void 0 : platform2.getDocumentElement(elements.floating)),
-    boundary,
-    rootBoundary,
-    strategy
-  }));
-  const rect = elementContext === "floating" ? {
-    x: x2,
-    y: y2,
-    width: rects.floating.width,
-    height: rects.floating.height
-  } : rects.reference;
-  const offsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(elements.floating));
-  const offsetScale = await (platform2.isElement == null ? void 0 : platform2.isElement(offsetParent)) ? await (platform2.getScale == null ? void 0 : platform2.getScale(offsetParent)) || {
-    x: 1,
-    y: 1
-  } : {
-    x: 1,
-    y: 1
-  };
-  const elementClientRect = rectToClientRect(platform2.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform2.convertOffsetParentRelativeRectToViewportRelativeRect({
-    elements,
-    rect,
-    offsetParent,
-    strategy
-  }) : rect);
-  return {
-    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
-    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
-    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
-    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
-  };
-}
 const flip$2 = function(options) {
   if (options === void 0) {
     options = {};
@@ -4128,7 +4099,7 @@ const flip$2 = function(options) {
         fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
       }
       const placements = [initialPlacement, ...fallbackPlacements];
-      const overflow = await detectOverflow(state, detectOverflowOptions);
+      const overflow = await platform2.detectOverflow(state, detectOverflowOptions);
       const overflows = [];
       let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
       if (checkMainAxis) {
@@ -4218,7 +4189,8 @@ const hide$3 = function(options) {
     options,
     async fn(state) {
       const {
-        rects
+        rects,
+        platform: platform2
       } = state;
       const {
         strategy = "referenceHidden",
@@ -4226,7 +4198,7 @@ const hide$3 = function(options) {
       } = evaluate(options, state);
       switch (strategy) {
         case "referenceHidden": {
-          const overflow = await detectOverflow(state, {
+          const overflow = await platform2.detectOverflow(state, {
             ...detectOverflowOptions,
             elementContext: "reference"
           });
@@ -4239,7 +4211,7 @@ const hide$3 = function(options) {
           };
         }
         case "escaped": {
-          const overflow = await detectOverflow(state, {
+          const overflow = await platform2.detectOverflow(state, {
             ...detectOverflowOptions,
             altBoundary: true
           });
@@ -4337,7 +4309,8 @@ const shift$2 = function(options) {
       const {
         x: x2,
         y: y2,
-        placement
+        placement,
+        platform: platform2
       } = state;
       const {
         mainAxis: checkMainAxis = true,
@@ -4360,7 +4333,7 @@ const shift$2 = function(options) {
         x: x2,
         y: y2
       };
-      const overflow = await detectOverflow(state, detectOverflowOptions);
+      const overflow = await platform2.detectOverflow(state, detectOverflowOptions);
       const crossAxis = getSideAxis(getSide(placement));
       const mainAxis = getOppositeAxis(crossAxis);
       let mainAxisCoord = coords[mainAxis];
@@ -4483,7 +4456,7 @@ const size$2 = function(options) {
         },
         ...detectOverflowOptions
       } = evaluate(options, state);
-      const overflow = await detectOverflow(state, detectOverflowOptions);
+      const overflow = await platform2.detectOverflow(state, detectOverflowOptions);
       const side = getSide(placement);
       const alignment = getAlignment(placement);
       const isYAxis = getSideAxis(placement) === "y";
@@ -4541,6 +4514,160 @@ const size$2 = function(options) {
     }
   };
 };
+function hasWindow() {
+  return typeof window !== "undefined";
+}
+function getNodeName(node) {
+  if (isNode(node)) {
+    return (node.nodeName || "").toLowerCase();
+  }
+  return "#document";
+}
+function getWindow(node) {
+  var _node$ownerDocument;
+  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+}
+function getDocumentElement(node) {
+  var _ref;
+  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+}
+function isNode(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Node || value instanceof getWindow(value).Node;
+}
+function isElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Element || value instanceof getWindow(value).Element;
+}
+function isHTMLElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+}
+function isShadowRoot(value) {
+  if (!hasWindow() || typeof ShadowRoot === "undefined") {
+    return false;
+  }
+  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+}
+function isOverflowElement(element) {
+  const {
+    overflow,
+    overflowX,
+    overflowY,
+    display
+  } = getComputedStyle$1(element);
+  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && display !== "inline" && display !== "contents";
+}
+function isTableElement(element) {
+  return /^(table|td|th)$/.test(getNodeName(element));
+}
+function isTopLayer(element) {
+  try {
+    if (element.matches(":popover-open")) {
+      return true;
+    }
+  } catch (_e) {
+  }
+  try {
+    return element.matches(":modal");
+  } catch (_e) {
+    return false;
+  }
+}
+const willChangeRe = /transform|translate|scale|rotate|perspective|filter/;
+const containRe = /paint|layout|strict|content/;
+const isNotNone = (value) => !!value && value !== "none";
+let isWebKitValue;
+function isContainingBlock(elementOrCss) {
+  const css = isElement(elementOrCss) ? getComputedStyle$1(elementOrCss) : elementOrCss;
+  return isNotNone(css.transform) || isNotNone(css.translate) || isNotNone(css.scale) || isNotNone(css.rotate) || isNotNone(css.perspective) || !isWebKit() && (isNotNone(css.backdropFilter) || isNotNone(css.filter)) || willChangeRe.test(css.willChange || "") || containRe.test(css.contain || "");
+}
+function getContainingBlock(element) {
+  let currentNode = getParentNode(element);
+  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    if (isContainingBlock(currentNode)) {
+      return currentNode;
+    } else if (isTopLayer(currentNode)) {
+      return null;
+    }
+    currentNode = getParentNode(currentNode);
+  }
+  return null;
+}
+function isWebKit() {
+  if (isWebKitValue == null) {
+    isWebKitValue = typeof CSS !== "undefined" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none");
+  }
+  return isWebKitValue;
+}
+function isLastTraversableNode(node) {
+  return /^(html|body|#document)$/.test(getNodeName(node));
+}
+function getComputedStyle$1(element) {
+  return getWindow(element).getComputedStyle(element);
+}
+function getNodeScroll(element) {
+  if (isElement(element)) {
+    return {
+      scrollLeft: element.scrollLeft,
+      scrollTop: element.scrollTop
+    };
+  }
+  return {
+    scrollLeft: element.scrollX,
+    scrollTop: element.scrollY
+  };
+}
+function getParentNode(node) {
+  if (getNodeName(node) === "html") {
+    return node;
+  }
+  const result = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    node.assignedSlot || // DOM Element detected.
+    node.parentNode || // ShadowRoot detected.
+    isShadowRoot(node) && node.host || // Fallback.
+    getDocumentElement(node)
+  );
+  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) : []);
+  } else {
+    return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+  }
+}
+function getFrameElement(win) {
+  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
+}
 function getCssDimensions$1(element) {
   const css = getComputedStyle$1(element);
   let width = parseFloat(css.width) || 0;
@@ -4589,7 +4716,7 @@ function getScale(element) {
 const noOffsets = /* @__PURE__ */ createCoords(0);
 function getVisualOffsets(element) {
   const win = getWindow(element);
-  if (!isWebKit$1() || !win.visualViewport) {
+  if (!isWebKit() || !win.visualViewport) {
     return noOffsets;
   }
   return {
@@ -4698,7 +4825,7 @@ function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
     if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
       scroll = getNodeScroll(offsetParent);
     }
-    if (isHTMLElement(offsetParent)) {
+    if (isOffsetParentAnElement) {
       const offsetRect = getBoundingClientRect(offsetParent);
       scale = getScale(offsetParent);
       offsets.x = offsetRect.x + offsetParent.clientLeft;
@@ -4746,7 +4873,7 @@ function getViewportRect(element, strategy) {
   if (visualViewport) {
     width = visualViewport.width;
     height = visualViewport.height;
-    const visualViewportBased = isWebKit$1();
+    const visualViewportBased = isWebKit();
     if (!visualViewportBased || visualViewportBased && strategy === "fixed") {
       x2 = visualViewport.offsetLeft;
       y2 = visualViewport.offsetTop;
@@ -4772,7 +4899,6 @@ function getViewportRect(element, strategy) {
     y: y2
   };
 }
-const absoluteOrFixed = /* @__PURE__ */ new Set(["absolute", "fixed"]);
 function getInnerBoundingClientRect(element, strategy) {
   const clientRect = getBoundingClientRect(element, true, strategy === "fixed");
   const top = clientRect.top + element.clientTop;
@@ -4830,7 +4956,7 @@ function getClippingElementAncestors(element, cache) {
     if (!currentNodeIsContaining && computedStyle.position === "fixed") {
       currentContainingBlockComputedStyle = null;
     }
-    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && absoluteOrFixed.has(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
+    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && (currentContainingBlockComputedStyle.position === "absolute" || currentContainingBlockComputedStyle.position === "fixed") || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
     if (shouldDropCurrentNode) {
       result = result.filter((ancestor) => ancestor !== currentNode);
     } else {
@@ -4850,20 +4976,23 @@ function getClippingRect(_ref) {
   } = _ref;
   const elementClippingAncestors = boundary === "clippingAncestors" ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
   const clippingAncestors = [...elementClippingAncestors, rootBoundary];
-  const firstClippingAncestor = clippingAncestors[0];
-  const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
-    const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
-    accRect.top = max(rect.top, accRect.top);
-    accRect.right = min(rect.right, accRect.right);
-    accRect.bottom = min(rect.bottom, accRect.bottom);
-    accRect.left = max(rect.left, accRect.left);
-    return accRect;
-  }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
+  const firstRect = getClientRectFromClippingAncestor(element, clippingAncestors[0], strategy);
+  let top = firstRect.top;
+  let right = firstRect.right;
+  let bottom = firstRect.bottom;
+  let left = firstRect.left;
+  for (let i2 = 1; i2 < clippingAncestors.length; i2++) {
+    const rect = getClientRectFromClippingAncestor(element, clippingAncestors[i2], strategy);
+    top = max(rect.top, top);
+    right = min(rect.right, right);
+    bottom = min(rect.bottom, bottom);
+    left = max(rect.left, left);
+  }
   return {
-    width: clippingRect.right - clippingRect.left,
-    height: clippingRect.bottom - clippingRect.top,
-    x: clippingRect.left,
-    y: clippingRect.top
+    width: right - left,
+    height: bottom - top,
+    x: left,
+    y: top
   };
 }
 function getDimensions(element) {
@@ -5072,7 +5201,7 @@ function autoUpdate(reference, floating, update2, options) {
     animationFrame = false
   } = options;
   const referenceEl = unwrapElement(reference);
-  const ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...getOverflowAncestors(floating)] : [];
+  const ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...floating ? getOverflowAncestors(floating) : []] : [];
   ancestors.forEach((ancestor) => {
     ancestorScroll && ancestor.addEventListener("scroll", update2, {
       passive: true
@@ -5085,7 +5214,7 @@ function autoUpdate(reference, floating, update2, options) {
   if (elementResize) {
     resizeObserver = new ResizeObserver((_ref) => {
       let [firstEntry] = _ref;
-      if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
+      if (firstEntry && firstEntry.target === referenceEl && resizeObserver && floating) {
         resizeObserver.unobserve(floating);
         cancelAnimationFrame(reobserveFrame);
         reobserveFrame = requestAnimationFrame(() => {
@@ -5098,7 +5227,9 @@ function autoUpdate(reference, floating, update2, options) {
     if (referenceEl && !animationFrame) {
       resizeObserver.observe(referenceEl);
     }
-    resizeObserver.observe(floating);
+    if (floating) {
+      resizeObserver.observe(floating);
+    }
   }
   let frameId;
   let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
@@ -5518,23 +5649,23 @@ function useDismiss(context, props = {}) {
     if (target && (triggers.hasElement(target) || triggers.hasMatchingElement((trigger) => contains(trigger, target)))) {
       return;
     }
-    let targetRootAncestor = isElement(target) ? target : null;
-    while (targetRootAncestor && !isLastTraversableNode(targetRootAncestor)) {
-      const nextParent = getParentNode(targetRootAncestor);
-      if (isLastTraversableNode(nextParent) || !isElement(nextParent)) {
+    let targetRootAncestor = isElement$1(target) ? target : null;
+    while (targetRootAncestor && !isLastTraversableNode$1(targetRootAncestor)) {
+      const nextParent = getParentNode$1(targetRootAncestor);
+      if (isLastTraversableNode$1(nextParent) || !isElement$1(nextParent)) {
         break;
       }
       targetRootAncestor = nextParent;
     }
-    if (markers.length && isElement(target) && !isRootElement(target) && // Clicked on a direct ancestor (e.g. FloatingOverlay).
+    if (markers.length && isElement$1(target) && !isRootElement(target) && // Clicked on a direct ancestor (e.g. FloatingOverlay).
     !contains(target, store5.select("floatingElement")) && // If the target root element contains none of the markers, then the
     // element was injected after the floating element rendered.
     Array.from(markers).every((marker) => !contains(targetRootAncestor, marker))) {
       return;
     }
-    if (isHTMLElement(target) && !("touches" in event)) {
-      const lastTraversableNode = isLastTraversableNode(target);
-      const style = getComputedStyle$1(target);
+    if (isHTMLElement$1(target) && !("touches" in event)) {
+      const lastTraversableNode = isLastTraversableNode$1(target);
+      const style = getComputedStyle$2(target);
       const scrollRe = /auto|scroll/;
       const isScrollableX = lastTraversableNode || scrollRe.test(style.overflowX);
       const isScrollableY = lastTraversableNode || scrollRe.test(style.overflowY);
@@ -5688,7 +5819,7 @@ function useDismiss(context, props = {}) {
       compositionTimeout.start(
         // 0ms or 1ms don't work in Safari. 5ms appears to consistently work.
         // Only apply to WebKit for the test to remain 0ms.
-        isWebKit$1() ? 5 : 0,
+        isWebKit$2() ? 5 : 0,
         () => {
           isComposingRef.current = false;
         }
@@ -5711,13 +5842,13 @@ function useDismiss(context, props = {}) {
     }
     let ancestors = [];
     if (ancestorScroll) {
-      if (isElement(domReferenceElement)) {
+      if (isElement$1(domReferenceElement)) {
         ancestors = getOverflowAncestors(domReferenceElement);
       }
-      if (isElement(floatingElement)) {
+      if (isElement$1(floatingElement)) {
         ancestors = ancestors.concat(getOverflowAncestors(floatingElement));
       }
-      if (!isElement(referenceElement) && referenceElement && referenceElement.contextElement) {
+      if (!isElement$1(referenceElement) && referenceElement && referenceElement.contextElement) {
         ancestors = ancestors.concat(getOverflowAncestors(referenceElement.contextElement));
       }
     }
@@ -7335,7 +7466,7 @@ function useFloatingRootContext(options) {
   const nested = useFloatingParentNodeId() != null;
   if (process.env.NODE_ENV !== "production") {
     const optionDomReference = elements.reference;
-    if (optionDomReference && !isElement(optionDomReference)) {
+    if (optionDomReference && !isElement$1(optionDomReference)) {
       console.error("Cannot pass a virtual element to the `elements.reference` option,", "as it must be a real DOM element. Use `context.setPositionReference()`", "instead.");
     }
   }
@@ -7356,7 +7487,7 @@ function useFloatingRootContext(options) {
     };
     if (elements.reference !== void 0) {
       valuesToSync.referenceElement = elements.reference;
-      valuesToSync.domReferenceElement = isElement(elements.reference) ? elements.reference : null;
+      valuesToSync.domReferenceElement = isElement$1(elements.reference) ? elements.reference : null;
     }
     if (elements.floating !== void 0) {
       valuesToSync.floatingElement = elements.floating;
@@ -7398,7 +7529,7 @@ function useFloating(options = {}) {
     }
   });
   const setPositionReference = q$1((node) => {
-    const computedPositionReference = isElement(node) ? {
+    const computedPositionReference = isElement$1(node) ? {
       getBoundingClientRect: () => node.getBoundingClientRect(),
       getClientRects: () => node.getClientRects(),
       contextElement: node
@@ -7409,17 +7540,17 @@ function useFloating(options = {}) {
   const [localDomReference, setLocalDomReference] = d$2(null);
   const [localFloatingElement, setLocalFloatingElement] = d$2(null);
   rootContext.useSyncedValue("referenceElement", localDomReference);
-  rootContext.useSyncedValue("domReferenceElement", isElement(localDomReference) ? localDomReference : null);
+  rootContext.useSyncedValue("domReferenceElement", isElement$1(localDomReference) ? localDomReference : null);
   rootContext.useSyncedValue("floatingElement", localFloatingElement);
   const setReference = q$1((node) => {
-    if (isElement(node) || node === null) {
+    if (isElement$1(node) || node === null) {
       domReferenceRef.current = node;
       setLocalDomReference(node);
     }
-    if (isElement(position.refs.reference.current) || position.refs.reference.current === null || // Don't allow setting virtual elements using the old technique back to
+    if (isElement$1(position.refs.reference.current) || position.refs.reference.current === null || // Don't allow setting virtual elements using the old technique back to
     // `null` to support `positionReference` + an unstable `reference`
     // callback ref.
-    node !== null && !isElement(node)) {
+    node !== null && !isElement$1(node)) {
       position.refs.setReference(node);
     }
   }, [position.refs, setLocalDomReference]);
@@ -7497,7 +7628,7 @@ function useSyncedFloatingRootContext(options) {
       referenceElement,
       floatingElement
     };
-    if (isElement(referenceElement)) {
+    if (isElement$1(referenceElement)) {
       valuesToSync.domReferenceElement = referenceElement;
     }
     store5.update(valuesToSync);
@@ -7631,7 +7762,7 @@ function useHoverFloatingInteraction(context, parameters = {}) {
     if (!enabled) {
       return void 0;
     }
-    if (open && ((_a = handleCloseOptionsRef.current) == null ? void 0 : _a.blockPointerEvents) && isHoverOpen() && isElement(domReferenceElement) && floatingElement) {
+    if (open && ((_a = handleCloseOptionsRef.current) == null ? void 0 : _a.blockPointerEvents) && isHoverOpen() && isElement$1(domReferenceElement) && floatingElement) {
       performedPointerEventsMutationRef.current = true;
       const body = getDocument(floatingElement).body;
       body.setAttribute(safePolygonIdentifier, "");
@@ -7832,7 +7963,7 @@ function useHoverReferenceInteraction(context, props = {}) {
       return void 0;
     }
     const trigger = triggerElementRef.current ?? (isActiveTrigger ? store5.select("domReferenceElement") : null);
-    if (!isElement(trigger)) {
+    if (!isElement$1(trigger)) {
       return void 0;
     }
     function onMouseEnter(event) {
@@ -8257,7 +8388,7 @@ function safePolygon(options = {}) {
         hasLanded = true;
         return void 0;
       }
-      if (isLeave && isElement(event.relatedTarget) && contains(elements.floating, event.relatedTarget)) {
+      if (isLeave && isElement$1(event.relatedTarget) && contains(elements.floating, event.relatedTarget)) {
         return void 0;
       }
       if (tree && getNodeChildren(tree.nodesRef.current, nodeId).some(({
@@ -8813,7 +8944,7 @@ function useButton(parameters = {}) {
   };
 }
 function isButtonElement(elem) {
-  return isHTMLElement(elem) && elem.tagName === "BUTTON";
+  return isHTMLElement$1(elem) && elem.tagName === "BUTTON";
 }
 let TransitionStatusDataAttributes = /* @__PURE__ */ function(TransitionStatusDataAttributes2) {
   TransitionStatusDataAttributes2["startingStyle"] = "data-starting-style";
@@ -9104,17 +9235,17 @@ const baseArrow = (options) => ({
       element,
       padding = 0,
       offsetParent = "real"
-    } = evaluate(options, state) || {};
+    } = evaluate$1(options, state) || {};
     if (element == null) {
       return {};
     }
-    const paddingObject = getPaddingObject(padding);
+    const paddingObject = getPaddingObject$1(padding);
     const coords = {
       x: x2,
       y: y2
     };
-    const axis = getAlignmentAxis(placement);
-    const length = getAxisLength(axis);
+    const axis = getAlignmentAxis$1(placement);
+    const length = getAxisLength$1(axis);
     const arrowDimensions = await platform2.getDimensions(element);
     const isYAxis = axis === "y";
     const minProp = isYAxis ? "top" : "left";
@@ -9134,8 +9265,8 @@ const baseArrow = (options) => ({
     const min2 = minPadding;
     const max2 = clientSize - arrowDimensions[length] - maxPadding;
     const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
-    const offset2 = clamp(min2, center, max2);
-    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset2 && rects.reference[length] / 2 - (center < min2 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
+    const offset2 = clamp$1(min2, center, max2);
+    const shouldAddOffset = !middlewareData.arrow && getAlignment$1(placement) != null && center !== offset2 && rects.reference[length] / 2 - (center < min2 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
     const alignmentOffset = shouldAddOffset ? center < min2 ? center - min2 : center - max2 : 0;
     return {
       [axis]: coords[axis] + alignmentOffset,
@@ -9194,7 +9325,7 @@ const adaptiveOrigin = {
       strategy,
       placement
     } = state;
-    const win = getWindow(floating);
+    const win = getWindow$1(floating);
     const styles = win.getComputedStyle(floating);
     const hasTransition = styles.transitionDuration !== "0s" && styles.transitionDuration !== "";
     if (!hasTransition) {
@@ -9223,7 +9354,7 @@ const adaptiveOrigin = {
     } else if (await ((_b = platform2.isElement) == null ? void 0 : _b.call(platform2, offsetParent))) {
       offsetDimensions = await platform2.getDimensions(offsetParent);
     }
-    const currentSide = getSide(placement);
+    const currentSide = getSide$1(placement);
     let x2 = rawX;
     let y2 = rawY;
     if (currentSide === "left") {
@@ -9261,8 +9392,8 @@ function getOffsetData(state, sideParam, isRtl) {
     placement
   } = state;
   const data = {
-    side: getLogicalSide(sideParam, getSide(placement), isRtl),
-    align: getAlignment(placement) || "center",
+    side: getLogicalSide(sideParam, getSide$1(placement), isRtl),
+    align: getAlignment$1(placement) || "center",
     anchor: {
       width: rects.reference.width,
       height: rects.reference.height
@@ -9400,7 +9531,7 @@ function useAnchorPositioning(params) {
           width,
           height
         } = arrowRef.current.getBoundingClientRect();
-        const sideAxis = getSideAxis(getSide(limitData.placement));
+        const sideAxis = getSideAxis$1(getSide$1(limitData.placement));
         const arrowSize = sideAxis === "y" ? width : height;
         const offsetAmount = sideAxis === "y" ? collisionPadding.left + collisionPadding.right : collisionPadding.top + collisionPadding.bottom;
         return {
@@ -9452,8 +9583,8 @@ function useAnchorPositioning(params) {
         rects,
         y: y3
       } = state;
-      const currentRenderedSide = getSide(renderedPlacement2);
-      const currentRenderedAxis = getSideAxis(currentRenderedSide);
+      const currentRenderedSide = getSide$1(renderedPlacement2);
+      const currentRenderedAxis = getSideAxis$1(currentRenderedSide);
       const arrowEl = arrowRef.current;
       const arrowX = ((_a2 = middlewareData2.arrow) == null ? void 0 : _a2.x) || 0;
       const arrowY = ((_b2 = middlewareData2.arrow) == null ? void 0 : _b2.y) || 0;
@@ -9555,9 +9686,9 @@ function useAnchorPositioning(params) {
     }
     return void 0;
   }, [keepMounted, mounted, elements, update2, autoUpdateOptions]);
-  const renderedSide = getSide(renderedPlacement);
+  const renderedSide = getSide$1(renderedPlacement);
   const logicalRenderedSide = getLogicalSide(sideParam, renderedSide, isRtl);
-  const renderedAlign = getAlignment(renderedPlacement) || "center";
+  const renderedAlign = getAlignment$1(renderedPlacement) || "center";
   const anchorHidden = Boolean((_a = middlewareData.hide) == null ? void 0 : _a.referenceHidden);
   useIsoLayoutEffect(() => {
     if (lazyFlip && mounted && isPositioned) {
@@ -9752,13 +9883,13 @@ const PopoverPositioner = /* @__PURE__ */ D(function PopoverPositioner2(componen
 if (process.env.NODE_ENV !== "production")
   PopoverPositioner.displayName = "PopoverPositioner";
 function getCssDimensions(element) {
-  const css = getComputedStyle$1(element);
+  const css = getComputedStyle$2(element);
   let width = parseFloat(css.width) || 0;
   let height = parseFloat(css.height) || 0;
-  const hasOffset = isHTMLElement(element);
+  const hasOffset = isHTMLElement$1(element);
   const offsetWidth = hasOffset ? element.offsetWidth : width;
   const offsetHeight = hasOffset ? element.offsetHeight : height;
-  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
+  const shouldFallback = round$1(width) !== offsetWidth || round$1(height) !== offsetHeight;
   if (shouldFallback) {
     width = offsetWidth;
     height = offsetHeight;
@@ -10024,7 +10155,7 @@ const PopoverPopup = /* @__PURE__ */ D(function PopoverPopup2(componentProps, fo
     initialFocus: resolvedInitialFocus,
     returnFocus: finalFocus,
     restoreFocus: "popup",
-    previousFocusableElement: isHTMLElement(activeTriggerElement) ? activeTriggerElement : void 0,
+    previousFocusableElement: isHTMLElement$1(activeTriggerElement) ? activeTriggerElement : void 0,
     nextFocusableElement: store5.context.triggerFocusTargetRef,
     beforeContentFocusGuardRef: store5.context.beforeContentFocusGuardRef,
     children: element
@@ -10091,12 +10222,12 @@ var createTranslateFunction = ({
   return t2;
 };
 var TranslationContext = R$2(null);
-var createTranslation = (defaultTerms) => {
+var createTranslation = (defaultTerms2) => {
   return {
-    defaultTerms,
+    defaultTerms: defaultTerms2,
     TranslationProvider: ({ terms, children, locale }) => {
       const t2 = T$1(() => {
-        return createTranslateFunction({ locale, terms: defaultTerms, overrides: terms });
+        return createTranslateFunction({ locale, terms: defaultTerms2, overrides: terms });
       }, [terms, locale]);
       return /* @__PURE__ */ u$2(TranslationContext.Provider, { value: { t: t2, locale }, children });
     },
@@ -10109,10 +10240,10 @@ var createTranslation = (defaultTerms) => {
     createTFunction: ({
       overrides,
       locale
-    }) => createTranslateFunction({ terms: defaultTerms, overrides, locale })
+    }) => createTranslateFunction({ terms: defaultTerms2, overrides, locale })
   };
 };
-const { TranslationProvider, useTranslation, createTFunction } = createTranslation({
+const defaultTerms = {
   DAILY: "Daily",
   WEEKLY: "Weekly",
   MONTHLY: "Monthly",
@@ -10123,8 +10254,11 @@ const { TranslationProvider, useTranslation, createTFunction } = createTranslati
   save: "Save",
   save_alert: "Save Alert",
   frequency: "Frequency",
-  create_alert: "Create Alert"
-});
+  create_alert: "Create Alert",
+  create_alert_error: "Failed to create alert. Please try again later.",
+  privacy_policy_link: "How we use your personal data"
+};
+const { TranslationProvider, useTranslation, createTFunction } = createTranslation(defaultTerms);
 var i = Symbol.for("preact-signals");
 function t() {
   if (!(s$1 > 1)) {
@@ -11424,13 +11558,6 @@ const InputError = ({ error: error2 }) => {
   ] });
 };
 const inputClass = "rounded-field-input bg-neutral-1 text-accent-11 autofill:shadow-[inset_0_0_0_1000px_var(--i-color-a-2)] autofill:focus:shadow-[inset_0_0_0_1000px_var(--i-color-a-1)] autofill:[-webkit-text-fill-color:var(--i-color-a-11)] px-3 py-2 ring ring-[1px] transition-all ease-expo-out duration-snappy ring-neutral-4 fr inline-flex w-full items-center justify-center px-2.5 text-base shadow-[0_0_0_1px] outline-none focus:shadow-[0_0_0_2px]";
-const getErrorMessage = (error2) => {
-  if (typeof error2 === "string")
-    return error2;
-  if (typeof error2 === "object" && error2 !== null && "message" in error2 && typeof error2.message === "string")
-    return error2.message;
-  return "Failed to create alert. Please try again later.";
-};
 const JobAlertsButton = D(
   ({ class: className, ...props }, ref) => /* @__PURE__ */ u$2(
     "button",
@@ -11451,6 +11578,21 @@ const JobAlertsButton = D(
   )
 );
 const PopoverHeader = () => /* @__PURE__ */ u$2("p", { class: "text-neutral-11 px-2 pb-4 pt-1 text-sm", children: store$1.config$.value.headerText });
+const PrivacyPolicyLink = ({ label }) => {
+  const url = store$1.config$.value.privacyPolicyUrl;
+  if (!url)
+    return null;
+  return /* @__PURE__ */ u$2(
+    "a",
+    {
+      href: url,
+      target: "_blank",
+      rel: "noopener noreferrer",
+      class: "text-neutral-11 hover:text-accent-11 px-2 text-xs underline underline-offset-2",
+      children: label
+    }
+  );
+};
 function noop2() {
 }
 const JobAlerts = ({ theme, rpcClient, logger, analytics }) => {
@@ -11499,7 +11641,7 @@ const JobAlerts = ({ theme, rpcClient, logger, analytics }) => {
               setFormState("idle");
             }).catch((err) => {
               logger.error(err);
-              setError(getErrorMessage(err));
+              setError(t2("create_alert_error"));
               setFormState("idle");
             });
           },
@@ -11553,6 +11695,7 @@ const JobAlerts = ({ theme, rpcClient, logger, analytics }) => {
                 /* @__PURE__ */ u$2("div", { class: "text-neutral-10 absolute bottom-0 right-0 top-0 flex items-center p-1", "aria-hidden": true, children: /* @__PURE__ */ u$2(Icon, { name: "chevron-up-down" }) })
               ] })
             ] }),
+            /* @__PURE__ */ u$2(PrivacyPolicyLink, { label: t2("privacy_policy_link") }),
             /* @__PURE__ */ u$2(
               "button",
               {
@@ -12190,6 +12333,11 @@ const tailwind = `#ija {
 	line-height: 1.25rem;
 }
 
+	#ija .text-xs {
+	font-size: 0.75rem;
+	line-height: 1rem;
+}
+
 	#ija .font-medium {
 	font-weight: 500;
 }
@@ -12240,6 +12388,10 @@ const tailwind = `#ija {
 	text-decoration-line: underline;
 }
 
+	#ija .underline-offset-2 {
+	text-underline-offset: 2px;
+}
+
 	#ija .opacity-0 {
 	opacity: 0;
 }
@@ -12469,6 +12621,10 @@ const tailwind = `#ija {
 	transform: translate(var(--tw-translate-x), var(--tw-translate-y)) rotate(var(--tw-rotate)) skewX(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y));
 }
 
+	#ija .hover\\:text-accent-11:hover {
+	color: var(--i-color-a-11);
+}
+
 	#ija .focus\\:shadow-\\[0_0_0_2px\\]:focus {
 	--tw-shadow: 0 0 0 2px;
 	--tw-shadow-colored: 0 0 0 2px var(--tw-shadow-color);
@@ -12634,4 +12790,5 @@ const jobAlertsPlugin = () => sdk.createPlugin(({ rpcClient, logger, analytics }
   };
 });
 exports.createJobAlertsDomManager = createJobAlertsDomManager;
+exports.defaultTerms = defaultTerms;
 exports.jobAlertsPlugin = jobAlertsPlugin;