issue-sticker 0.10.0 → 0.11.0

package/dist/{externalUserPayload-DNGAp9bP.js → externalUserPayload-BbOEmKZD.js}

@@ -1,7 +1,7 @@
-import { t as getCanvasSource, v as onCanvasSourceRegistered, C as CANVAS_INTERACTION_TAG, w as gzip_1, R as REPLAY_EVENT_TYPE, x as record, a as cn, p as useCallbackRef$1, i as useComposedRefs, f as Primitive, P as Presence, j as Portal$1, g as composeEventHandlers, k as createContextScope, l as createSlot, D as DismissableLayer, y as Content, z as createPopperScope, m as useControllableState, A as Root2$1, n as useId, B as Anchor, E as Arrow, d as usePortalContainer, e as OVERLAY_LAYER, s as stopEscapePropagation, o as useLayoutEffect2, V as VISUALLY_HIDDEN_STYLES, c as createLucideIcon, F as clsx, S as Slot$2, O as OVERLAY_LAYER_INDEX, M as MousePointer2 } from "./three-_bdgDAmI.js";
+import { t as getCanvasSource, v as onCanvasSourceRegistered, C as CANVAS_INTERACTION_TAG, w as gzip_1, R as REPLAY_EVENT_TYPE, x as record, a as cn, p as useCallbackRef$1, i as useComposedRefs, f as Primitive, P as Presence, j as Portal$1, g as composeEventHandlers, k as createContextScope, l as createSlot, D as DismissableLayer, y as Content, z as createPopperScope, A as Anchor, m as useControllableState, B as Root2$1, n as useId, E as Arrow, d as usePortalContainer, e as OVERLAY_LAYER, s as stopEscapePropagation, o as useLayoutEffect2, V as VISUALLY_HIDDEN_STYLES, c as createLucideIcon, F as clsx, S as Slot$2, O as OVERLAY_LAYER_INDEX, M as MousePointer2 } from "./three-DQdLNs7v.js";
 import { jsx, jsxs, Fragment } from "react/jsx-runtime";
 import * as React from "react";
-import React__default, { useState, createContext, useContext, useCallback, useRef, useLayoutEffect, useEffect, useMemo } from "react";
+import React__default, { useState, useRef, useEffect, useCallback, createContext, useContext, useLayoutEffect, useMemo } from "react";
 import * as ReactDOM from "react-dom";
 const DEFAULT_MAX_DURATION_MS = 12e4;
 const MIME_TYPE_CANDIDATES = ["video/webm;codecs=vp9", "video/webm"];
@@ -894,7 +894,7 @@ function settleFrame() {
 async function resolveNodeId(canvas) {
   var _a;
   try {
-    const { record: record2 } = await import("./three-_bdgDAmI.js").then((n) => n.I);
+    const { record: record2 } = await import("./three-DQdLNs7v.js").then((n) => n.I);
     const id = (_a = record2.mirror) == null ? void 0 : _a.getId(canvas);
     return typeof id === "number" && id > 0 ? id : null;
   } catch {
@@ -913,7 +913,7 @@ function startCanvasInteractionTracking(options = {}) {
   const lastSnapshot = /* @__PURE__ */ new WeakMap();
   let pending = null;
   const emit2 = options.emit ?? ((tag, payload) => {
-    void import("./three-_bdgDAmI.js").then((n) => n.I).then(({ addCustomEvent }) => addCustomEvent(tag, payload));
+    void import("./three-DQdLNs7v.js").then((n) => n.I).then(({ addCustomEvent }) => addCustomEvent(tag, payload));
   });
   const pointerOf = (started, rect) => [
     (started.x - rect.left) / rect.width * 2 - 1,
@@ -6169,14 +6169,844 @@ function composeIssueFilterGroups(integrations, customFields) {
   }
   return Array.from(groups.values()).sort((a2, b) => a2.label.localeCompare(b.label));
 }
-const STABLE_ATTR_KEYS = [
-  "data-testid",
-  "data-test",
-  "data-qa",
-  "data-cy",
-  "name",
-  "aria-label"
-];
+const IGNORED_NAME = /^(Primitive\.|Slot|Presence|Portal|Fragment|Suspense|StrictMode)|(Provider|Context|Consumer)$/;
+const MAX_DEPTH = 300;
+function fiberOf(element) {
+  for (const key of Object.keys(element)) {
+    if (key.startsWith("__reactFiber$") || key.startsWith("__reactInternalInstance$")) {
+      return element[key] ?? null;
+    }
+  }
+  return null;
+}
+function nameOf(type) {
+  if (typeof type === "function") {
+    const fn = type;
+    return fn.displayName ?? fn.name ?? null;
+  }
+  if (type && typeof type === "object") {
+    const wrapper = type;
+    return wrapper.displayName ?? nameOf(wrapper.render) ?? nameOf(wrapper.type);
+  }
+  return null;
+}
+const reactAdapter = {
+  framework: "react",
+  collect(element) {
+    let fiber = fiberOf(element);
+    if (!fiber) return null;
+    const names = [];
+    for (let depth = 0; fiber && depth < MAX_DEPTH; depth += 1) {
+      const name = nameOf(fiber.type);
+      if (typeof name === "string" && name && !IGNORED_NAME.test(name)) names.unshift(name);
+      fiber = fiber.return;
+    }
+    return names;
+  }
+};
+const ADAPTERS = [reactAdapter];
+const MIN_NAME_LENGTH = 3;
+const MAX_NAME_LENGTH = 60;
+function cleanPath(names) {
+  if (!names) return [];
+  const kept = names.filter((name) => typeof name === "string").map(
+    (name) => name.replace(/\s+/g, " ").trim().slice(0, MAX_NAME_LENGTH).replace(/[\uD800-\uDBFF]$/, "")
+  ).filter((name) => name.length >= MIN_NAME_LENGTH);
+  const deduped = kept.filter((name, index) => name !== kept[index - 1]);
+  return deduped.slice(-8);
+}
+function collectComponentPath(element, adapters = ADAPTERS) {
+  for (const adapter of adapters) {
+    let path = [];
+    try {
+      path = cleanPath(adapter.collect(element));
+    } catch {
+      path = [];
+    }
+    if (path.length) return { framework: adapter.framework, path };
+  }
+  return null;
+}
+var toStr = Object.prototype.toString;
+function isCallable(fn) {
+  return typeof fn === "function" || toStr.call(fn) === "[object Function]";
+}
+function toInteger(value) {
+  var number = Number(value);
+  if (isNaN(number)) {
+    return 0;
+  }
+  if (number === 0 || !isFinite(number)) {
+    return number;
+  }
+  return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number));
+}
+var maxSafeInteger = Math.pow(2, 53) - 1;
+function toLength(value) {
+  var len = toInteger(value);
+  return Math.min(Math.max(len, 0), maxSafeInteger);
+}
+function arrayFrom(arrayLike, mapFn) {
+  var C = Array;
+  var items = Object(arrayLike);
+  if (arrayLike == null) {
+    throw new TypeError("Array.from requires an array-like object - not null or undefined");
+  }
+  var len = toLength(items.length);
+  var A = isCallable(C) ? Object(new C(len)) : new Array(len);
+  var k = 0;
+  var kValue;
+  while (k < len) {
+    kValue = items[k];
+    {
+      A[k] = kValue;
+    }
+    k += 1;
+  }
+  A.length = len;
+  return A;
+}
+function _typeof(o2) {
+  "@babel/helpers - typeof";
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o3) {
+    return typeof o3;
+  } : function(o3) {
+    return o3 && "function" == typeof Symbol && o3.constructor === Symbol && o3 !== Symbol.prototype ? "symbol" : typeof o3;
+  }, _typeof(o2);
+}
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i2 = 0; i2 < props.length; i2++) {
+    var descriptor = props[i2];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  Object.defineProperty(Constructor, "prototype", { writable: false });
+  return Constructor;
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _toPropertyKey(t2) {
+  var i2 = _toPrimitive(t2, "string");
+  return "symbol" == _typeof(i2) ? i2 : i2 + "";
+}
+function _toPrimitive(t2, r2) {
+  if ("object" != _typeof(t2) || !t2) return t2;
+  var e2 = t2[Symbol.toPrimitive];
+  if (void 0 !== e2) {
+    var i2 = e2.call(t2, r2);
+    if ("object" != _typeof(i2)) return i2;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(t2);
+}
+var SetLike = /* @__PURE__ */ (function() {
+  function SetLike2() {
+    var items = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+    _classCallCheck(this, SetLike2);
+    _defineProperty(this, "items", void 0);
+    this.items = items;
+  }
+  return _createClass(SetLike2, [{
+    key: "add",
+    value: function add(value) {
+      if (this.has(value) === false) {
+        this.items.push(value);
+      }
+      return this;
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.items = [];
+    }
+  }, {
+    key: "delete",
+    value: function _delete(value) {
+      var previousLength = this.items.length;
+      this.items = this.items.filter(function(item) {
+        return item !== value;
+      });
+      return previousLength !== this.items.length;
+    }
+  }, {
+    key: "forEach",
+    value: function forEach(callbackfn) {
+      var _this = this;
+      this.items.forEach(function(item) {
+        callbackfn(item, item, _this);
+      });
+    }
+  }, {
+    key: "has",
+    value: function has(value) {
+      return this.items.indexOf(value) !== -1;
+    }
+  }, {
+    key: "size",
+    get: function get() {
+      return this.items.length;
+    }
+  }]);
+})();
+const SetLike$1 = typeof Set === "undefined" ? Set : SetLike;
+function getLocalName(element) {
+  var _element$localName;
+  return (
+    // eslint-disable-next-line no-restricted-properties -- actual guard for environments without localName
+    (_element$localName = element.localName) !== null && _element$localName !== void 0 ? _element$localName : (
+      // eslint-disable-next-line no-restricted-properties -- required for the fallback
+      element.tagName.toLowerCase()
+    )
+  );
+}
+var localNameToRoleMappings = {
+  article: "article",
+  aside: "complementary",
+  button: "button",
+  datalist: "listbox",
+  dd: "definition",
+  details: "group",
+  dialog: "dialog",
+  dt: "term",
+  fieldset: "group",
+  figure: "figure",
+  // WARNING: Only with an accessible name
+  form: "form",
+  footer: "contentinfo",
+  h1: "heading",
+  h2: "heading",
+  h3: "heading",
+  h4: "heading",
+  h5: "heading",
+  h6: "heading",
+  header: "banner",
+  hr: "separator",
+  html: "document",
+  legend: "legend",
+  li: "listitem",
+  math: "math",
+  main: "main",
+  menu: "list",
+  nav: "navigation",
+  ol: "list",
+  optgroup: "group",
+  // WARNING: Only in certain context
+  option: "option",
+  output: "status",
+  progress: "progressbar",
+  // WARNING: Only with an accessible name
+  section: "region",
+  summary: "button",
+  table: "table",
+  tbody: "rowgroup",
+  textarea: "textbox",
+  tfoot: "rowgroup",
+  // WARNING: Only in certain context
+  td: "cell",
+  th: "columnheader",
+  thead: "rowgroup",
+  tr: "row",
+  ul: "list"
+};
+var prohibitedAttributes = {
+  caption: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  code: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  deletion: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  emphasis: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  generic: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby", "aria-roledescription"]),
+  insertion: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  none: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  paragraph: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  presentation: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  strong: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  subscript: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  superscript: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"])
+};
+function hasGlobalAriaAttributes(element, role) {
+  return [
+    "aria-atomic",
+    "aria-busy",
+    "aria-controls",
+    "aria-current",
+    "aria-description",
+    "aria-describedby",
+    "aria-details",
+    // "disabled",
+    "aria-dropeffect",
+    // "errormessage",
+    "aria-flowto",
+    "aria-grabbed",
+    // "haspopup",
+    "aria-hidden",
+    // "invalid",
+    "aria-keyshortcuts",
+    "aria-label",
+    "aria-labelledby",
+    "aria-live",
+    "aria-owns",
+    "aria-relevant",
+    "aria-roledescription"
+  ].some(function(attributeName) {
+    var _prohibitedAttributes;
+    return element.hasAttribute(attributeName) && !((_prohibitedAttributes = prohibitedAttributes[role]) !== null && _prohibitedAttributes !== void 0 && _prohibitedAttributes.has(attributeName));
+  });
+}
+function ignorePresentationalRole(element, implicitRole) {
+  return hasGlobalAriaAttributes(element, implicitRole);
+}
+function getRole(element) {
+  var explicitRole = getExplicitRole(element);
+  if (explicitRole === null || presentationRoles.indexOf(explicitRole) !== -1) {
+    var implicitRole = getImplicitRole(element);
+    if (presentationRoles.indexOf(explicitRole || "") === -1 || ignorePresentationalRole(element, implicitRole || "")) {
+      return implicitRole;
+    }
+  }
+  return explicitRole;
+}
+function getImplicitRole(element) {
+  var mappedByTag = localNameToRoleMappings[getLocalName(element)];
+  if (mappedByTag !== void 0) {
+    return mappedByTag;
+  }
+  switch (getLocalName(element)) {
+    case "a":
+    case "area":
+    case "link":
+      if (element.hasAttribute("href")) {
+        return "link";
+      }
+      break;
+    case "img":
+      if (element.getAttribute("alt") === "" && !ignorePresentationalRole(element, "img")) {
+        return "presentation";
+      }
+      return "img";
+    case "input": {
+      var _ref = element, type = _ref.type;
+      switch (type) {
+        case "button":
+        case "image":
+        case "reset":
+        case "submit":
+          return "button";
+        case "checkbox":
+        case "radio":
+          return type;
+        case "range":
+          return "slider";
+        case "email":
+        case "tel":
+        case "text":
+        case "url":
+          if (element.hasAttribute("list")) {
+            return "combobox";
+          }
+          return "textbox";
+        case "search":
+          if (element.hasAttribute("list")) {
+            return "combobox";
+          }
+          return "searchbox";
+        case "number":
+          return "spinbutton";
+        default:
+          return null;
+      }
+    }
+    case "select":
+      if (element.hasAttribute("multiple") || element.size > 1) {
+        return "listbox";
+      }
+      return "combobox";
+  }
+  return null;
+}
+function getExplicitRole(element) {
+  var role = element.getAttribute("role");
+  if (role !== null) {
+    var explicitRole = role.trim().split(" ")[0];
+    if (explicitRole.length > 0) {
+      return explicitRole;
+    }
+  }
+  return null;
+}
+var presentationRoles = ["presentation", "none"];
+function isElement(node) {
+  return node !== null && node.nodeType === node.ELEMENT_NODE;
+}
+function isHTMLTableCaptionElement(node) {
+  return isElement(node) && getLocalName(node) === "caption";
+}
+function isHTMLInputElement(node) {
+  return isElement(node) && getLocalName(node) === "input";
+}
+function isHTMLOptGroupElement(node) {
+  return isElement(node) && getLocalName(node) === "optgroup";
+}
+function isHTMLSelectElement(node) {
+  return isElement(node) && getLocalName(node) === "select";
+}
+function isHTMLTableElement(node) {
+  return isElement(node) && getLocalName(node) === "table";
+}
+function isHTMLTextAreaElement(node) {
+  return isElement(node) && getLocalName(node) === "textarea";
+}
+function safeWindow(node) {
+  var _ref = node.ownerDocument === null ? node : node.ownerDocument, defaultView = _ref.defaultView;
+  if (defaultView === null) {
+    throw new TypeError("no window available");
+  }
+  return defaultView;
+}
+function isHTMLFieldSetElement(node) {
+  return isElement(node) && getLocalName(node) === "fieldset";
+}
+function isHTMLLegendElement(node) {
+  return isElement(node) && getLocalName(node) === "legend";
+}
+function isHTMLSlotElement(node) {
+  return isElement(node) && getLocalName(node) === "slot";
+}
+function isSVGElement(node) {
+  return isElement(node) && node.ownerSVGElement !== void 0;
+}
+function isSVGSVGElement(node) {
+  return isElement(node) && getLocalName(node) === "svg";
+}
+function isSVGTitleElement(node) {
+  return isSVGElement(node) && getLocalName(node) === "title";
+}
+function queryIdRefs(node, attributeName) {
+  if (isElement(node) && node.hasAttribute(attributeName)) {
+    var ids = node.getAttribute(attributeName).split(" ");
+    var root = node.getRootNode ? node.getRootNode() : node.ownerDocument;
+    return ids.map(function(id) {
+      return root.getElementById(id);
+    }).filter(
+      function(element) {
+        return element !== null;
+      }
+      // TODO: why does this not narrow?
+    );
+  }
+  return [];
+}
+function hasAnyConcreteRoles(node, roles) {
+  if (isElement(node)) {
+    return roles.indexOf(getRole(node)) !== -1;
+  }
+  return false;
+}
+function asFlatString(s2) {
+  return s2.trim().replace(/\s\s+/g, " ");
+}
+function isHidden$1(node, getComputedStyleImplementation) {
+  if (!isElement(node)) {
+    return false;
+  }
+  if (node.hasAttribute("hidden") || node.getAttribute("aria-hidden") === "true") {
+    return true;
+  }
+  var style = getComputedStyleImplementation(node);
+  return style.getPropertyValue("display") === "none" || style.getPropertyValue("visibility") === "hidden";
+}
+function isControl(node) {
+  return hasAnyConcreteRoles(node, ["button", "combobox", "listbox", "textbox"]) || hasAbstractRole(node, "range");
+}
+function hasAbstractRole(node, role) {
+  if (!isElement(node)) {
+    return false;
+  }
+  switch (role) {
+    case "range":
+      return hasAnyConcreteRoles(node, ["meter", "progressbar", "scrollbar", "slider", "spinbutton"]);
+    default:
+      throw new TypeError("No knowledge about abstract role '".concat(role, "'. This is likely a bug :("));
+  }
+}
+function querySelectorAllSubtree(element, selectors) {
+  var elements = arrayFrom(element.querySelectorAll(selectors));
+  queryIdRefs(element, "aria-owns").forEach(function(root) {
+    elements.push.apply(elements, arrayFrom(root.querySelectorAll(selectors)));
+  });
+  return elements;
+}
+function querySelectedOptions(listbox) {
+  if (isHTMLSelectElement(listbox)) {
+    return listbox.selectedOptions || querySelectorAllSubtree(listbox, "[selected]");
+  }
+  return querySelectorAllSubtree(listbox, '[aria-selected="true"]');
+}
+function isMarkedPresentational(node) {
+  return hasAnyConcreteRoles(node, presentationRoles);
+}
+function isNativeHostLanguageTextAlternativeElement(node) {
+  return isHTMLTableCaptionElement(node);
+}
+function allowsNameFromContent(node) {
+  return hasAnyConcreteRoles(node, ["button", "cell", "checkbox", "columnheader", "gridcell", "heading", "label", "legend", "link", "menuitem", "menuitemcheckbox", "menuitemradio", "option", "radio", "row", "rowheader", "switch", "tab", "tooltip", "treeitem"]);
+}
+function isDescendantOfNativeHostLanguageTextAlternativeElement(node) {
+  return false;
+}
+function getValueOfTextbox(element) {
+  if (isHTMLInputElement(element) || isHTMLTextAreaElement(element)) {
+    return element.value;
+  }
+  return element.textContent || "";
+}
+function getTextualContent(declaration) {
+  var content = declaration.getPropertyValue("content");
+  if (/^["'].*["']$/.test(content)) {
+    return content.slice(1, -1);
+  }
+  return "";
+}
+function isLabelableElement(element) {
+  var localName = getLocalName(element);
+  return localName === "button" || localName === "input" && element.getAttribute("type") !== "hidden" || localName === "meter" || localName === "output" || localName === "progress" || localName === "select" || localName === "textarea";
+}
+function findLabelableElement(element) {
+  if (isLabelableElement(element)) {
+    return element;
+  }
+  var labelableElement = null;
+  element.childNodes.forEach(function(childNode) {
+    if (labelableElement === null && isElement(childNode)) {
+      var descendantLabelableElement = findLabelableElement(childNode);
+      if (descendantLabelableElement !== null) {
+        labelableElement = descendantLabelableElement;
+      }
+    }
+  });
+  return labelableElement;
+}
+function getControlOfLabel(label) {
+  if (label.control !== void 0) {
+    return label.control;
+  }
+  var htmlFor = label.getAttribute("for");
+  if (htmlFor !== null) {
+    return label.ownerDocument.getElementById(htmlFor);
+  }
+  return findLabelableElement(label);
+}
+function getLabels$1(element) {
+  var labelsProperty = element.labels;
+  if (labelsProperty === null) {
+    return labelsProperty;
+  }
+  if (labelsProperty !== void 0) {
+    return arrayFrom(labelsProperty);
+  }
+  if (!isLabelableElement(element)) {
+    return null;
+  }
+  var document2 = element.ownerDocument;
+  return arrayFrom(document2.querySelectorAll("label")).filter(function(label) {
+    return getControlOfLabel(label) === element;
+  });
+}
+function getSlotContents(slot) {
+  var assignedNodes = slot.assignedNodes();
+  if (assignedNodes.length === 0) {
+    return arrayFrom(slot.childNodes);
+  }
+  return assignedNodes;
+}
+function computeTextAlternative(root) {
+  var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  var consultedNodes = new SetLike$1();
+  var computedStyles = typeof Map === "undefined" ? void 0 : /* @__PURE__ */ new Map();
+  var window2 = safeWindow(root);
+  var _options$compute = options.compute, compute = _options$compute === void 0 ? "name" : _options$compute, _options$computedStyl = options.computedStyleSupportsPseudoElements, computedStyleSupportsPseudoElements = _options$computedStyl === void 0 ? options.getComputedStyle !== void 0 : _options$computedStyl, _options$getComputedS = options.getComputedStyle, uncachedGetComputedStyle = _options$getComputedS === void 0 ? window2.getComputedStyle.bind(window2) : _options$getComputedS, _options$hidden = options.hidden, hidden = _options$hidden === void 0 ? false : _options$hidden;
+  var getComputedStyle2 = function getComputedStyle3(el, pseudoElement) {
+    if (pseudoElement !== void 0) {
+      throw new Error("use uncachedGetComputedStyle directly for pseudo elements");
+    }
+    if (computedStyles === void 0) {
+      return uncachedGetComputedStyle(el);
+    }
+    var cachedStyles = computedStyles.get(el);
+    if (cachedStyles) {
+      return cachedStyles;
+    }
+    var style = uncachedGetComputedStyle(el, pseudoElement);
+    computedStyles.set(el, style);
+    return style;
+  };
+  function computeMiscTextAlternative(node, context) {
+    var accumulatedText = "";
+    if (isElement(node) && computedStyleSupportsPseudoElements) {
+      var pseudoBefore = uncachedGetComputedStyle(node, "::before");
+      var beforeContent = getTextualContent(pseudoBefore);
+      accumulatedText = "".concat(beforeContent, " ").concat(accumulatedText);
+    }
+    var childNodes = isHTMLSlotElement(node) ? getSlotContents(node) : arrayFrom(node.childNodes).concat(queryIdRefs(node, "aria-owns"));
+    childNodes.forEach(function(child) {
+      var result = computeTextAlternative2(child, {
+        isEmbeddedInLabel: context.isEmbeddedInLabel,
+        isReferenced: false,
+        recursion: true
+      });
+      var display = isElement(child) ? getComputedStyle2(child).getPropertyValue("display") : "inline";
+      var separator = display !== "inline" ? " " : "";
+      accumulatedText += "".concat(separator).concat(result).concat(separator);
+    });
+    if (isElement(node) && computedStyleSupportsPseudoElements) {
+      var pseudoAfter = uncachedGetComputedStyle(node, "::after");
+      var afterContent = getTextualContent(pseudoAfter);
+      accumulatedText = "".concat(accumulatedText, " ").concat(afterContent);
+    }
+    return accumulatedText.trim();
+  }
+  function useAttribute(element, attributeName) {
+    var attribute = element.getAttributeNode(attributeName);
+    if (attribute !== null && !consultedNodes.has(attribute) && attribute.value.trim() !== "") {
+      consultedNodes.add(attribute);
+      return attribute.value;
+    }
+    return null;
+  }
+  function computeTooltipAttributeValue(node) {
+    if (!isElement(node)) {
+      return null;
+    }
+    return useAttribute(node, "title");
+  }
+  function computeElementTextAlternative(node) {
+    if (!isElement(node)) {
+      return null;
+    }
+    if (isHTMLFieldSetElement(node)) {
+      consultedNodes.add(node);
+      var children = arrayFrom(node.childNodes);
+      for (var i2 = 0; i2 < children.length; i2 += 1) {
+        var child = children[i2];
+        if (isHTMLLegendElement(child)) {
+          return computeTextAlternative2(child, {
+            isEmbeddedInLabel: false,
+            isReferenced: false,
+            recursion: false
+          });
+        }
+      }
+    } else if (isHTMLTableElement(node)) {
+      consultedNodes.add(node);
+      var _children = arrayFrom(node.childNodes);
+      for (var _i = 0; _i < _children.length; _i += 1) {
+        var _child = _children[_i];
+        if (isHTMLTableCaptionElement(_child)) {
+          return computeTextAlternative2(_child, {
+            isEmbeddedInLabel: false,
+            isReferenced: false,
+            recursion: false
+          });
+        }
+      }
+    } else if (isSVGSVGElement(node)) {
+      consultedNodes.add(node);
+      var _children2 = arrayFrom(node.childNodes);
+      for (var _i2 = 0; _i2 < _children2.length; _i2 += 1) {
+        var _child2 = _children2[_i2];
+        if (isSVGTitleElement(_child2)) {
+          return _child2.textContent;
+        }
+      }
+      return null;
+    } else if (getLocalName(node) === "img" || getLocalName(node) === "area") {
+      var nameFromAlt = useAttribute(node, "alt");
+      if (nameFromAlt !== null) {
+        return nameFromAlt;
+      }
+    } else if (isHTMLOptGroupElement(node)) {
+      var nameFromLabel = useAttribute(node, "label");
+      if (nameFromLabel !== null) {
+        return nameFromLabel;
+      }
+    }
+    if (isHTMLInputElement(node) && (node.type === "button" || node.type === "submit" || node.type === "reset")) {
+      var nameFromValue = useAttribute(node, "value");
+      if (nameFromValue !== null) {
+        return nameFromValue;
+      }
+      if (node.type === "submit") {
+        return "Submit";
+      }
+      if (node.type === "reset") {
+        return "Reset";
+      }
+    }
+    var labels = getLabels$1(node);
+    if (labels !== null && labels.length !== 0) {
+      consultedNodes.add(node);
+      return arrayFrom(labels).map(function(element) {
+        return computeTextAlternative2(element, {
+          isEmbeddedInLabel: true,
+          isReferenced: false,
+          recursion: true
+        });
+      }).filter(function(label) {
+        return label.length > 0;
+      }).join(" ");
+    }
+    if (isHTMLInputElement(node) && node.type === "image") {
+      var _nameFromAlt = useAttribute(node, "alt");
+      if (_nameFromAlt !== null) {
+        return _nameFromAlt;
+      }
+      var nameFromTitle = useAttribute(node, "title");
+      if (nameFromTitle !== null) {
+        return nameFromTitle;
+      }
+      return "Submit Query";
+    }
+    if (hasAnyConcreteRoles(node, ["button"])) {
+      var nameFromSubTree = computeMiscTextAlternative(node, {
+        isEmbeddedInLabel: false
+      });
+      if (nameFromSubTree !== "") {
+        return nameFromSubTree;
+      }
+    }
+    return null;
+  }
+  function computeTextAlternative2(current, context) {
+    if (consultedNodes.has(current)) {
+      return "";
+    }
+    if (!hidden && isHidden$1(current, getComputedStyle2) && !context.isReferenced) {
+      consultedNodes.add(current);
+      return "";
+    }
+    var labelAttributeNode = isElement(current) ? current.getAttributeNode("aria-labelledby") : null;
+    var labelElements = labelAttributeNode !== null && !consultedNodes.has(labelAttributeNode) ? queryIdRefs(current, "aria-labelledby") : [];
+    if (compute === "name" && !context.isReferenced && labelElements.length > 0) {
+      consultedNodes.add(labelAttributeNode);
+      return labelElements.map(function(element) {
+        return computeTextAlternative2(element, {
+          isEmbeddedInLabel: context.isEmbeddedInLabel,
+          isReferenced: true,
+          // this isn't recursion as specified, otherwise we would skip
+          // `aria-label` in
+          // <input id="myself" aria-label="foo" aria-labelledby="myself"
+          recursion: false
+        });
+      }).join(" ");
+    }
+    var skipToStep2E = context.recursion && isControl(current) && compute === "name";
+    if (!skipToStep2E) {
+      var ariaLabel = (isElement(current) && current.getAttribute("aria-label") || "").trim();
+      if (ariaLabel !== "" && compute === "name") {
+        consultedNodes.add(current);
+        return ariaLabel;
+      }
+      if (!isMarkedPresentational(current)) {
+        var elementTextAlternative = computeElementTextAlternative(current);
+        if (elementTextAlternative !== null) {
+          consultedNodes.add(current);
+          return elementTextAlternative;
+        }
+      }
+    }
+    if (hasAnyConcreteRoles(current, ["menu"])) {
+      consultedNodes.add(current);
+      return "";
+    }
+    if (skipToStep2E || context.isEmbeddedInLabel || context.isReferenced) {
+      if (hasAnyConcreteRoles(current, ["combobox", "listbox"])) {
+        consultedNodes.add(current);
+        var selectedOptions = querySelectedOptions(current);
+        if (selectedOptions.length === 0) {
+          return isHTMLInputElement(current) ? current.value : "";
+        }
+        return arrayFrom(selectedOptions).map(function(selectedOption) {
+          return computeTextAlternative2(selectedOption, {
+            isEmbeddedInLabel: context.isEmbeddedInLabel,
+            isReferenced: false,
+            recursion: true
+          });
+        }).join(" ");
+      }
+      if (hasAbstractRole(current, "range")) {
+        consultedNodes.add(current);
+        if (current.hasAttribute("aria-valuetext")) {
+          return current.getAttribute("aria-valuetext");
+        }
+        if (current.hasAttribute("aria-valuenow")) {
+          return current.getAttribute("aria-valuenow");
+        }
+        return current.getAttribute("value") || "";
+      }
+      if (hasAnyConcreteRoles(current, ["textbox"])) {
+        consultedNodes.add(current);
+        return getValueOfTextbox(current);
+      }
+    }
+    if (allowsNameFromContent(current) || isElement(current) && context.isReferenced || isNativeHostLanguageTextAlternativeElement(current) || isDescendantOfNativeHostLanguageTextAlternativeElement()) {
+      var accumulatedText2F = computeMiscTextAlternative(current, {
+        isEmbeddedInLabel: context.isEmbeddedInLabel
+      });
+      if (accumulatedText2F !== "") {
+        consultedNodes.add(current);
+        return accumulatedText2F;
+      }
+    }
+    if (current.nodeType === current.TEXT_NODE) {
+      consultedNodes.add(current);
+      return current.textContent || "";
+    }
+    if (context.recursion) {
+      consultedNodes.add(current);
+      return computeMiscTextAlternative(current, {
+        isEmbeddedInLabel: context.isEmbeddedInLabel
+      });
+    }
+    var tooltipAttributeValue = computeTooltipAttributeValue(current);
+    if (tooltipAttributeValue !== null) {
+      consultedNodes.add(current);
+      return tooltipAttributeValue;
+    }
+    consultedNodes.add(current);
+    return "";
+  }
+  return asFlatString(computeTextAlternative2(root, {
+    isEmbeddedInLabel: false,
+    // by spec computeAccessibleDescription starts with the referenced elements as roots
+    isReferenced: compute === "description",
+    recursion: false
+  }));
+}
+function prohibitsNaming(node) {
+  return hasAnyConcreteRoles(node, ["caption", "code", "deletion", "emphasis", "generic", "insertion", "none", "paragraph", "presentation", "strong", "subscript", "superscript"]);
+}
+function computeAccessibleName(root) {
+  var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  if (prohibitsNaming(root)) {
+    return "";
+  }
+  return computeTextAlternative(root, options);
+}
 const STATE_CLASS_RE = /^(is-|has-|js-)|^(active|open|selected|disabled|focus|hover|show|hidden|loading|dragging)$/i;
 function looksHashed(segment) {
   if (segment.includes("-")) return false;
@@ -6188,17 +7018,35 @@ function looksHashed(segment) {
   }
   return false;
 }
+const GENERATED_CLASS_PATTERNS = [
+  /^css-[a-z0-9]+(-|$)/i,
+  // emotion / MUI. 라벨이 붙으면 css-1e6y48t-MuiButtonBase-root
+  /^sc-[a-z0-9]+$/i,
+  // styled-components
+  /^makeStyles-.+-\d+$/,
+  // JSS makeStyles
+  /^jss\d+$/,
+  // JSS 기본 생성기
+  /^ng-tns-c\d+-\d+$/,
+  // Angular 애니메이션
+  /^_[\w-]+_[a-z0-9]{5}_\d+$/
+  // Vite CSS Modules 기본값: _로컬_해시(base36 5자)_줄번호
+];
+function hasCssModulesHash(token) {
+  const index = token.lastIndexOf("__");
+  if (index <= 0) return false;
+  const suffix = token.slice(index + 2);
+  return suffix.length === 5 && /^[\w-]+$/.test(suffix) && /[A-Z0-9_-]/.test(suffix);
+}
 function isUnstableToken(token) {
   if (!token) return true;
   if (token.includes(":") || token.includes("/")) return true;
   if (token.includes("--")) return true;
-  if (/^css-[a-z0-9]+$/i.test(token)) return true;
-  if (/^sc-[a-z0-9]+$/i.test(token)) return true;
   if (STATE_CLASS_RE.test(token)) return true;
-  const segments = token.split("__");
-  if (segments.length > 1 && looksHashed(segments[segments.length - 1] ?? "")) return true;
+  if (GENERATED_CLASS_PATTERNS.some((pattern) => pattern.test(token))) return true;
+  if (hasCssModulesHash(token)) return true;
   if (looksHashed(token)) return true;
-  return false;
+  return token.split(/[-_]+/).some(looksHashed);
 }
 function isStableClassName(cls) {
   return !isUnstableToken(cls);
@@ -6211,6 +7059,297 @@ function isUnstableId(id) {
   if (looksHashed(id)) return true;
   return false;
 }
+function intersection(firstArr, secondArr) {
+  const secondSet = new Set(secondArr);
+  return firstArr.filter((item) => secondSet.has(item));
+}
+function uniq(arr) {
+  return [...new Set(arr)];
+}
+function union(arr1, arr2) {
+  return uniq(arr1.concat(arr2));
+}
+const LOCATOR_TEXT_MAX = 80;
+const RAW_SLICE_FACTOR = 8;
+const LOCATOR_RAW_TEXT_MAX = LOCATOR_TEXT_MAX * RAW_SLICE_FACTOR;
+function dropTrailingLoneSurrogate(value) {
+  return /[\uD800-\uDBFF]$/.test(value) ? value.slice(0, -1) : value;
+}
+function cleanLocatorText(value, max2 = LOCATOR_TEXT_MAX) {
+  if (!value) return void 0;
+  const bounded = value.slice(0, max2 * RAW_SLICE_FACTOR);
+  const cleaned = dropTrailingLoneSurrogate(
+    redactSensitiveValues(bounded.replace(/\s+/g, " ").trim()).slice(0, max2)
+  ).trim();
+  return cleaned || void 0;
+}
+function normalizeForCompare(value) {
+  return value.toLowerCase().replace(/\d+/g, "#");
+}
+function jaccard(a2, b) {
+  const all = union(uniq(a2), uniq(b));
+  if (all.length === 0) return 0;
+  return intersection(uniq(a2), uniq(b)).length / all.length;
+}
+function textSimilarity(a2, b) {
+  const left = normalizeForCompare(a2);
+  const right = normalizeForCompare(b);
+  if (left === right) return 1;
+  const [shorter, longer] = left.length <= right.length ? [left, right] : [right, left];
+  const containment = shorter && longer.startsWith(shorter) ? shorter.length / longer.length : 0;
+  return Math.max(jaccard(left.split(" "), right.split(" ")), containment);
+}
+function labelSimilarity(stored, observed) {
+  const storedWords = new Set(normalizeForCompare(stored).split(" "));
+  const observedWords = new Set(normalizeForCompare(observed).split(" "));
+  const [smaller, larger] = storedWords.size <= observedWords.size ? [storedWords, observedWords] : [observedWords, storedWords];
+  const isStrictSubset = larger.size > smaller.size && [...smaller].every((w) => larger.has(w));
+  return isStrictSubset ? 0 : textSimilarity(stored, observed);
+}
+function digitGroups(value) {
+  return (value.match(/\d+/g) ?? []).join(" ");
+}
+function sameDigitGroups(a2, b) {
+  return digitGroups(a2) === digitGroups(b);
+}
+function labelSimilarityKeepingDigits(stored, observed) {
+  const left = stored.replace(/\s+/g, " ").trim();
+  const right = observed.replace(/\s+/g, " ").trim();
+  return sameDigitGroups(left, right) ? labelSimilarity(left, right) : 0;
+}
+const TEST_ATTR_KEYS = ["data-testid", "data-test", "data-qa", "data-cy"];
+const OTHER_ATTR_KEYS = ["name", "type", "placeholder", "alt", "title", "href", "src"];
+const URL_ATTR_KEYS = /* @__PURE__ */ new Set(["href", "src"]);
+const ATTR_VALUE_MAX = 120;
+const CLASS_LIMIT = 5;
+const LOCATOR_SIZE_MAX = 1024;
+const CONTAINER_ROLES = /* @__PURE__ */ new Set(["dialog", "alertdialog", "menu", "listbox", "tooltip"]);
+const CONTAINER_SELECTOR = 'dialog, [role="dialog"], [role="alertdialog"], [role="menu"], [role="listbox"], [role="tooltip"]';
+const LANDMARK_ROLES = /* @__PURE__ */ new Set([
+  "banner",
+  "navigation",
+  "main",
+  "complementary",
+  "contentinfo",
+  "region",
+  "form",
+  "search"
+]);
+const NAMED_ONLY_LANDMARKS = /* @__PURE__ */ new Set(["region", "form"]);
+const ROW_SELECTOR = 'li, tr, [role="row"], [role="listitem"], [role="option"]';
+const HEADING_SELECTOR = 'h1, h2, h3, h4, h5, h6, [role="heading"]';
+function safeRole(element) {
+  try {
+    return getRole(element) ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+function safeAccessibleName(element) {
+  try {
+    return cleanLocatorText(computeAccessibleName(element));
+  } catch {
+    return void 0;
+  }
+}
+function landmarkRole(node) {
+  const role = safeRole(node);
+  if (role === void 0 || !LANDMARK_ROLES.has(role)) return void 0;
+  if (NAMED_ONLY_LANDMARKS.has(role) && !safeAccessibleName(node)) return void 0;
+  return role;
+}
+function collectHeadings(doc) {
+  return Array.from(doc.querySelectorAll(HEADING_SELECTOR));
+}
+function matchesMask(element) {
+  try {
+    return element.matches(SESSION_REPLAY_FULL_MASK_SELECTOR);
+  } catch {
+    return true;
+  }
+}
+function hasMaskedDescendant(root) {
+  try {
+    return root.querySelector(SESSION_REPLAY_FULL_MASK_SELECTOR) !== null;
+  } catch {
+    return true;
+  }
+}
+function visibleText(root) {
+  if (!hasMaskedDescendant(root)) return root.textContent ?? "";
+  const walker = root.ownerDocument.createTreeWalker(
+    root,
+    NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT,
+    (node) => node.nodeType === Node.ELEMENT_NODE && matchesMask(node) ? NodeFilter.FILTER_REJECT : NodeFilter.FILTER_ACCEPT
+  );
+  let text = "";
+  for (let node = walker.nextNode(); node && text.length < LOCATOR_RAW_TEXT_MAX; ) {
+    if (node.nodeType === Node.TEXT_NODE) text += node.nodeValue ?? "";
+    node = walker.nextNode();
+  }
+  return text;
+}
+function closestAncestor(element, matches) {
+  let current = element.parentElement;
+  while (current) {
+    if (matches(current)) return current;
+    current = current.parentElement;
+  }
+  return null;
+}
+function nearestPrecedingHeading(element, headings) {
+  let found = null;
+  for (const heading of headings) {
+    if (heading === element || heading.contains(element)) continue;
+    if (heading.compareDocumentPosition(element) & Node.DOCUMENT_POSITION_FOLLOWING) {
+      found = heading;
+    } else {
+      break;
+    }
+  }
+  return found;
+}
+function rowTextOf(element) {
+  const row = element.closest(ROW_SELECTOR);
+  if (!row) return void 0;
+  const label = Array.from(row.children).find(
+    (cell) => !cell.contains(element) && visibleText(cell).trim()
+  );
+  const source = label ?? row;
+  if (isElementFullyMasked(source)) return void 0;
+  return cleanLocatorText(visibleText(source));
+}
+function urlPath(value, doc) {
+  try {
+    const url = new URL(value, doc.baseURI);
+    return url.protocol === "http:" || url.protocol === "https:" ? url.pathname : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function attrValue(element, key) {
+  const raw = element.getAttribute(key);
+  if (!raw) return void 0;
+  return cleanLocatorText(
+    URL_ATTR_KEYS.has(key) ? urlPath(raw, element.ownerDocument) : raw,
+    ATTR_VALUE_MAX
+  );
+}
+function sharesUrlPath(element, key, value) {
+  return Array.from(element.ownerDocument.getElementsByTagName(element.tagName)).some(
+    (other) => other !== element && attrValue(other, key) === value
+  );
+}
+function collectAttrs(element, masked, uniqueUrlAttrs) {
+  const attrs = {};
+  const keys = masked ? TEST_ATTR_KEYS : [...TEST_ATTR_KEYS, ...OTHER_ATTR_KEYS];
+  for (const key of keys) {
+    const value = attrValue(element, key);
+    if (!value) continue;
+    if (uniqueUrlAttrs && URL_ATTR_KEYS.has(key) && sharesUrlPath(element, key, value)) continue;
+    attrs[key] = value;
+  }
+  return Object.keys(attrs).length ? attrs : void 0;
+}
+function collectClasses(element) {
+  const classes = Array.from(element.classList).filter(isStableClassName).slice(0, CLASS_LIMIT);
+  return classes.length ? classes : void 0;
+}
+function tagIndex(element, scope) {
+  return Array.from(scope.getElementsByTagName(element.tagName)).indexOf(element);
+}
+function labelSources(element) {
+  var _a;
+  const doc = element.ownerDocument;
+  const ids = ((_a = element.getAttribute("aria-labelledby")) == null ? void 0 : _a.split(/\s+/).filter(Boolean)) ?? [];
+  const sources = ids.map((id) => doc.getElementById(id)).filter((node) => node !== null);
+  const labels = element.labels;
+  if (labels) sources.push(...Array.from(labels));
+  const wrapping = element.closest("label");
+  if (wrapping) sources.push(wrapping);
+  return sources;
+}
+function labelSourceMasked(element) {
+  return labelSources(element).some(
+    (node) => isElementFullyMasked(node) || hasMaskedDescendant(node)
+  );
+}
+function capSize(locator) {
+  const size = () => JSON.stringify(locator).length;
+  if (size() <= LOCATOR_SIZE_MAX) return locator;
+  delete locator.classes;
+  if (size() <= LOCATOR_SIZE_MAX) return locator;
+  if (locator.context) delete locator.context.heading;
+  if (size() <= LOCATOR_SIZE_MAX) return locator;
+  if (locator.attrs) {
+    for (const key of OTHER_ATTR_KEYS) delete locator.attrs[key];
+  }
+  if (size() <= LOCATOR_SIZE_MAX) return locator;
+  delete locator.context;
+  if (size() <= LOCATOR_SIZE_MAX) return locator;
+  delete locator.text;
+  return locator;
+}
+function buildElementLocator(element, options = {}) {
+  try {
+    return buildLocatorUnsafe(element, options);
+  } catch {
+    return { v: 1, tag: element.localName || element.tagName.toLowerCase() };
+  }
+}
+function buildLocatorUnsafe(element, options) {
+  const doc = element.ownerDocument;
+  const masked = isElementFullyMasked(element);
+  const locator = { v: 1, tag: element.tagName.toLowerCase() };
+  const role = safeRole(element);
+  if (role) locator.role = role;
+  if (!masked) {
+    const nameMasked = hasMaskedDescendant(element) || labelSourceMasked(element);
+    if (options.includeName !== false && !nameMasked) {
+      const name = safeAccessibleName(element);
+      if (name) locator.name = name;
+    }
+    const text = cleanLocatorText(visibleText(element));
+    if (text) locator.text = text;
+  }
+  const attrs = collectAttrs(element, masked, options.uniqueUrlAttrs !== false);
+  if (attrs) locator.attrs = attrs;
+  const classes = collectClasses(element);
+  if (classes) locator.classes = classes;
+  const container = closestAncestor(element, (node) => {
+    const nodeRole = safeRole(node);
+    return nodeRole !== void 0 && CONTAINER_ROLES.has(nodeRole);
+  });
+  const landmark = closestAncestor(element, (node) => landmarkRole(node) !== void 0);
+  const heading = nearestPrecedingHeading(element, options.headings ?? collectHeadings(doc));
+  const rowText = masked ? void 0 : rowTextOf(element);
+  const context = {};
+  if (container) {
+    const containerName = isElementFullyMasked(container) || hasMaskedDescendant(container) || labelSourceMasked(container) ? void 0 : safeAccessibleName(container);
+    context.container = {
+      role: safeRole(container),
+      ...containerName ? { name: containerName } : {}
+    };
+  }
+  if (landmark) context.landmark = landmarkRole(landmark);
+  const headingText = heading && !isElementFullyMasked(heading) ? cleanLocatorText(visibleText(heading)) : void 0;
+  if (headingText) context.heading = headingText;
+  if (rowText) context.rowText = rowText;
+  if (Object.keys(context).length) locator.context = context;
+  if (options.includeRoleIndex !== false) {
+    const index = tagIndex(element, container ?? doc);
+    if (index >= 0) locator.roleIndex = index;
+  }
+  return capSize(locator);
+}
+const STABLE_ATTR_KEYS = [
+  "data-testid",
+  "data-test",
+  "data-qa",
+  "data-cy",
+  "name",
+  "aria-label"
+];
 function cssAttrValue(value) {
   return value.replace(/(["\\])/g, "\\$1");
 }
@@ -6279,8 +7418,8 @@ function getElementSelector(element) {
   const segments = [];
   let current = element;
   let depth = 0;
-  const MAX_DEPTH = 5;
-  while (current && current.nodeType === Node.ELEMENT_NODE && depth < MAX_DEPTH) {
+  const MAX_DEPTH2 = 5;
+  while (current && current.nodeType === Node.ELEMENT_NODE && depth < MAX_DEPTH2) {
     segments.unshift(structuralSegment(current));
     const candidate = segments.join(" > ");
     if (matchesUniquely(candidate, element)) return candidate;
@@ -6320,9 +7459,15 @@ function getXPath(element) {
   }
   return parts.length ? `/html/body/${parts.join("/")}` : "/html/body";
 }
-function getElementPosition(element, event) {
+function getElementPosition(element, event, options = {}) {
   const rect = element.getBoundingClientRect();
   const scroll = getScrollPosition();
+  let component = null;
+  try {
+    component = (options.collectComponent ?? collectComponentPath)(element);
+  } catch {
+    component = null;
+  }
   return {
     x: event ? event.clientX + scroll.x : rect.left + scroll.x,
     y: event ? event.clientY + scroll.y : rect.top + scroll.y,
@@ -6334,7 +7479,9 @@ function getElementPosition(element, event) {
       top: rect.top + scroll.y,
       width: rect.width,
       height: rect.height
-    }
+    },
+    locator: buildElementLocator(element),
+    ...component ? { component } : {}
   };
 }
 function findElementByXPath(xpath) {
@@ -7964,15 +9111,68 @@ var Anchor2 = PopoverAnchor$1;
 var Trigger = PopoverTrigger$1;
 var Portal = PopoverPortal;
 var Content2 = PopoverContent$1;
-const Popover = Root2;
+const FLOATING_LAYER_SELECTOR = "[data-radix-popper-content-wrapper]";
+function isInsideLayer(path, content) {
+  return path.some((node) => {
+    if (!(node instanceof Element)) return false;
+    if (node === content) return true;
+    if (content.id && node.getAttribute("aria-controls") === content.id) return true;
+    return node.matches(FLOATING_LAYER_SELECTOR) && !node.contains(content);
+  });
+}
+function useShadowOutsideDismiss(onDismiss) {
+  const onDismissRef = useRef(onDismiss);
+  const detachRef = useRef(null);
+  useEffect(() => {
+    onDismissRef.current = onDismiss;
+  }, [onDismiss]);
+  useEffect(() => () => {
+    var _a;
+    return (_a = detachRef.current) == null ? void 0 : _a.call(detachRef);
+  }, []);
+  return useCallback((content) => {
+    var _a;
+    (_a = detachRef.current) == null ? void 0 : _a.call(detachRef);
+    detachRef.current = null;
+    if (!content) return;
+    const root = content.getRootNode();
+    if (!(root instanceof ShadowRoot)) return;
+    const handle = (event) => {
+      var _a2;
+      if (isInsideLayer(event.composedPath(), content)) return;
+      (_a2 = onDismissRef.current) == null ? void 0 : _a2.call(onDismissRef);
+    };
+    const types = ["pointerdown", "focusin"];
+    types.forEach((type) => root.addEventListener(type, handle));
+    detachRef.current = () => types.forEach((type) => root.removeEventListener(type, handle));
+  }, []);
+}
+const PopoverOpenChangeContext = React.createContext(
+  void 0
+);
+function Popover(props) {
+  return /* @__PURE__ */ jsx(PopoverOpenChangeContext.Provider, { value: props.onOpenChange, children: /* @__PURE__ */ jsx(Root2, { ...props }) });
+}
 const PopoverTrigger = Trigger;
 const PopoverAnchor = Anchor2;
 const PopoverContent = React.forwardRef(({ className, align = "center", sideOffset = 6, onEscapeKeyDown, ...props }, ref) => {
   const portalContainer = usePortalContainer();
+  const onOpenChange = React.useContext(PopoverOpenChangeContext);
+  const dismissRef = useShadowOutsideDismiss(
+    React.useCallback(() => onOpenChange == null ? void 0 : onOpenChange(false), [onOpenChange])
+  );
+  const contentRef = React.useCallback(
+    (node) => {
+      dismissRef(node);
+      if (typeof ref === "function") ref(node);
+      else if (ref) ref.current = node;
+    },
+    [dismissRef, ref]
+  );
   return /* @__PURE__ */ jsx(Portal, { container: portalContainer, children: /* @__PURE__ */ jsx(
     Content2,
     {
-      ref,
+      ref: contentRef,
       align,
       sideOffset,
       onEscapeKeyDown: stopEscapePropagation(onEscapeKeyDown),
@@ -13977,6 +15177,7 @@ function DatePicker({
   };
   const showClear = clearable && Boolean(value) && !disabled;
   const selectedDate = fromIso(value);
+  const dismissRef = useShadowOutsideDismiss(React.useCallback(() => setOpen(false), []));
   return /* @__PURE__ */ jsxs(Root2, { open, onOpenChange: setOpen, children: [
     /* @__PURE__ */ jsx(
       DatePickerTriggerField,
@@ -13994,6 +15195,7 @@ function DatePicker({
     /* @__PURE__ */ jsx(Portal, { container: portalContainer, children: /* @__PURE__ */ jsx(
       Content2,
       {
+        ref: dismissRef,
         align,
         side: "bottom",
         sideOffset: 6,
@@ -15355,6 +16557,15 @@ export {
   toast as a7,
   getSnapshot as a8,
   subscribe as a9,
+  sameDigitGroups as aA,
+  labelSimilarityKeepingDigits as aB,
+  landmarkRole as aC,
+  findElementBySelector as aD,
+  findElementByXPath as aE,
+  OnboardingProvider as aF,
+  useOnboardingTarget as aG,
+  useOnboardingFlow as aH,
+  PopoverAnchor as aI,
   getRegisteredUploadId as aa,
   ChevronRight as ab,
   ReactRemoveScroll as ac,
@@ -15372,12 +16583,15 @@ export {
   useDirection as ao,
   getPrimaryNotionMapping as ap,
   buttonVariants as aq,
-  findElementBySelector as ar,
-  findElementByXPath as as,
-  OnboardingProvider as at,
-  useOnboardingTarget as au,
-  useOnboardingFlow as av,
-  PopoverAnchor as aw,
+  TEST_ATTR_KEYS as ar,
+  jaccard as as,
+  textSimilarity as at,
+  collectHeadings as au,
+  buildElementLocator as av,
+  normalizeForCompare as aw,
+  CONTAINER_SELECTOR as ax,
+  safeRole as ay,
+  safeAccessibleName as az,
   buildJiraCreateFields as b,
   captureWithModernScreenshot as c,
   directUploadToSignedUrl as d,