@appsurify-testmap/rrweb 2.1.3-alpha.4 → 3.1.1-alpha.1

package/dist/rrweb.umd.cjs

@@ -352,6 +352,8 @@ function stringifyRule(rule2, sheetHref) {
     return importStringified;
   } else {
     let ruleStringified = rule2.cssText;
+    if (rule2.type === CSSRule.KEYFRAMES_RULE || rule2.type === CSSRule.KEYFRAME_RULE)
+      ;
     if (isCSSStyleRule(rule2) && rule2.selectorText.includes(":")) {
       ruleStringified = fixSafariColons(ruleStringified);
     }
@@ -580,19 +582,19 @@ function splitCssText(cssText, style, _testNoPxNorm = false) {
           _testNoPxNorm
         );
         const jLimit = 100;
-        let j = 3;
-        for (; j < textContentNorm.length; j++) {
+        let j2 = 3;
+        for (; j2 < textContentNorm.length; j2++) {
           if (
             // keep consuming css identifiers (to get a decent chunk more quickly)
-            textContentNorm[j].match(/[a-zA-Z0-9]/) || // substring needs to be unique to this section
-            textContentNorm.indexOf(textContentNorm.substring(0, j), 1) !== -1
+            textContentNorm[j2].match(/[a-zA-Z0-9]/) || // substring needs to be unique to this section
+            textContentNorm.indexOf(textContentNorm.substring(0, j2), 1) !== -1
           ) {
             continue;
           }
           break;
         }
-        for (; j < textContentNorm.length; j++) {
-          let startSubstring = textContentNorm.substring(0, j);
+        for (; j2 < textContentNorm.length; j2++) {
+          let startSubstring = textContentNorm.substring(0, j2);
           let cssNormSplits = cssTextNorm.split(startSubstring);
           let splitNorm = -1;
           if (cssNormSplits.length === 2) {
@@ -609,11 +611,11 @@ function splitCssText(cssText, style, _testNoPxNorm = false) {
               splits.push(cssText);
               return splits;
             }
-            j = jLimit + 1;
-          } else if (j === textContentNorm.length - 1) {
+            j2 = jLimit + 1;
+          } else if (j2 === textContentNorm.length - 1) {
             splitNorm = cssTextNorm.indexOf(startSubstring);
           }
-          if (cssNormSplits.length >= 2 && j > jLimit) {
+          if (cssNormSplits.length >= 2 && j2 > jLimit) {
             const prevTextContent = childNodes2[i2 - 1].textContent;
             if (prevTextContent && typeof prevTextContent === "string") {
               const prevMinLength = normalizeCssString(prevTextContent).length;
@@ -624,29 +626,29 @@ function splitCssText(cssText, style, _testNoPxNorm = false) {
             }
           }
           if (splitNorm !== -1) {
-            let k = Math.floor(splitNorm / normFactor);
-            for (; k > 0 && k < cssText.length; ) {
+            let k2 = Math.floor(splitNorm / normFactor);
+            for (; k2 > 0 && k2 < cssText.length; ) {
               iterCount += 1;
               if (iterCount > 50 * childNodes2.length) {
                 splits.push(cssText);
                 return splits;
               }
               const normPart = normalizeCssString(
-                cssText.substring(0, k),
+                cssText.substring(0, k2),
                 _testNoPxNorm
               );
               if (normPart.length === splitNorm) {
-                splits.push(cssText.substring(0, k));
-                cssText = cssText.substring(k);
+                splits.push(cssText.substring(0, k2));
+                cssText = cssText.substring(k2);
                 cssTextNorm = cssTextNorm.substring(splitNorm);
                 break;
               } else if (normPart.length < splitNorm) {
-                k += Math.max(
+                k2 += Math.max(
                   1,
                   Math.floor((splitNorm - normPart.length) / normFactor)
                 );
               } else {
-                k -= Math.max(
+                k2 -= Math.max(
                   1,
                   Math.floor((normPart.length - splitNorm) * normFactor)
                 );
@@ -664,102 +666,6 @@ function splitCssText(cssText, style, _testNoPxNorm = false) {
 function markCssSplits(cssText, style) {
   return splitCssText(cssText, style).join("/* rr_split */");
 }
-function isSelectorUnique(selector, target) {
-  try {
-    const matches = document.querySelectorAll(selector);
-    return matches.length === 1 && matches[0] === target;
-  } catch (e2) {
-    return false;
-  }
-}
-function buildSelector(node2) {
-  if (!(node2 instanceof Element))
-    return null;
-  if (node2.id) {
-    return `#${CSS.escape(node2.id)}`;
-  }
-  const parts = [];
-  const tag = node2.tagName.toLowerCase();
-  if (node2.classList.length) {
-    parts.push(...Array.from(node2.classList).map((cls) => `.${CSS.escape(cls)}`));
-  }
-  Array.from(node2.attributes).forEach((attr) => {
-    if (attr.name.startsWith("data-")) {
-      parts.push(`[${attr.name}="${CSS.escape(attr.value)}"]`);
-    }
-  });
-  const shortSelector = `${tag}${parts.join("")}`;
-  if (isSelectorUnique(shortSelector, node2)) {
-    return shortSelector;
-  }
-  const pathParts = [];
-  let current = node2;
-  while (current && current.nodeType === Node.ELEMENT_NODE) {
-    const parent = current.parentElement;
-    const tagName = current.tagName.toLowerCase();
-    let nth = "";
-    if (parent) {
-      const siblings = Array.from(parent.children).filter(
-        (el) => el.tagName.toLowerCase() === tagName
-      );
-      if (siblings.length > 1) {
-        nth = `:nth-of-type(${siblings.indexOf(current) + 1})`;
-      }
-    }
-    pathParts.unshift(`${tagName}${nth}`);
-    current = parent;
-  }
-  return pathParts.join(" > ") || null;
-}
-function buildXPath(node2) {
-  switch (node2.nodeType) {
-    case Node.DOCUMENT_NODE:
-      return "/";
-    case Node.DOCUMENT_TYPE_NODE:
-      return "/html/doctype";
-    case Node.ELEMENT_NODE: {
-      const element = node2;
-      if (element.id) {
-        return `//*[@id="${CSS.escape(element.id)}"]`;
-      }
-      if (element.tagName.toLowerCase() === "html")
-        return "/html";
-      if (element === document.head)
-        return "/html/head";
-      if (element === document.body)
-        return "/html/body";
-      const parent = element.parentNode;
-      if (!parent)
-        return "";
-      const tag = element.tagName.toLowerCase();
-      const siblings = Array.from(parent.children).filter(
-        (el) => el.tagName.toLowerCase() === tag
-      );
-      const index2 = siblings.length > 1 ? `[${siblings.indexOf(element) + 1}]` : "";
-      return `${buildXPath(parent)}/${tag}${index2}`;
-    }
-    case Node.TEXT_NODE:
-    case Node.CDATA_SECTION_NODE:
-    case Node.COMMENT_NODE: {
-      const parent = node2.parentNode;
-      if (!parent)
-        return "";
-      const typeMap = {
-        [Node.TEXT_NODE]: "text()",
-        [Node.CDATA_SECTION_NODE]: "text()",
-        // CDATA ≡ text() в XPath
-        [Node.COMMENT_NODE]: "comment()"
-      };
-      const sameTypeSiblings = Array.from(parent.childNodes).filter(
-        (sibling) => sibling.nodeType === node2.nodeType
-      );
-      const index2 = sameTypeSiblings.length > 1 ? `[${sameTypeSiblings.indexOf(node2)}]` : "";
-      return `${buildXPath(parent)}/${typeMap[node2.nodeType]}${index2}`;
-    }
-    default:
-      return "";
-  }
-}
 function isTextVisible(n2) {
   var _a2;
   const parent = index$1.parentNode(n2);
@@ -892,6 +798,1309 @@ try {
   }
 } catch (error) {
 }
+const L = {
+  ANCHOR: 0.4,
+  PATH: 0.3,
+  TARGET: 0.2,
+  UNIQUENESS: 0.1
+};
+const I = {
+  SEMANTIC_TAG: 0.5,
+  ROLE: 0.3,
+  ARIA_LABEL: 0.1,
+  STABLE_ID: 0.1,
+  TEST_MARKER: 0.05,
+  DEPTH_PENALTY_THRESHOLD: 5,
+  DEPTH_PENALTY_FACTOR: 0.05,
+  DEGRADED_SCORE: 0.3
+};
+const ct = {
+  MIN_CONFIDENCE_FOR_SKIP: 0.7
+};
+const X = [
+  "form",
+  "main",
+  "nav",
+  "section",
+  "article",
+  "footer",
+  "header"
+];
+const K = [
+  "form",
+  "navigation",
+  "main",
+  "region",
+  "contentinfo",
+  "complementary",
+  "banner",
+  "search"
+];
+const lt = [
+  // HTML5 Semantic
+  "article",
+  "aside",
+  "details",
+  "figcaption",
+  "figure",
+  "footer",
+  "header",
+  "main",
+  "mark",
+  "nav",
+  "section",
+  "summary",
+  "time",
+  // Form elements
+  "button",
+  "datalist",
+  "fieldset",
+  "form",
+  "input",
+  "label",
+  "legend",
+  "meter",
+  "optgroup",
+  "option",
+  "output",
+  "progress",
+  "select",
+  "textarea",
+  // Interactive
+  "a",
+  "audio",
+  "video",
+  "canvas",
+  "dialog",
+  "menu",
+  // Text content
+  "blockquote",
+  "dd",
+  "dl",
+  "dt",
+  "hr",
+  "li",
+  "ol",
+  "ul",
+  "p",
+  "pre",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  // Table
+  "caption",
+  "col",
+  "colgroup",
+  "table",
+  "tbody",
+  "td",
+  "tfoot",
+  "th",
+  "thead",
+  "tr",
+  // SVG
+  "svg",
+  "path",
+  "circle",
+  "rect",
+  "line",
+  "polyline",
+  "polygon",
+  "ellipse",
+  "g",
+  "text",
+  "use"
+];
+const w = {
+  // Test attributes (highest priority)
+  "data-testid": 100,
+  "data-qa": 99,
+  "data-cy": 98,
+  "data-test": 97,
+  "data-test-id": 96,
+  // ARIA (accessibility semantics)
+  "aria-label": 90,
+  "aria-labelledby": 85,
+  "aria-describedby": 80,
+  // Semantic HTML attributes
+  name: 75,
+  href: 70,
+  // for <a>
+  src: 70,
+  // for <img>, <script>, etc.
+  type: 65,
+  role: 60,
+  alt: 55,
+  title: 50,
+  for: 45,
+  placeholder: 40,
+  // Any data-* attribute (if not above)
+  "data-*": 30,
+  // Any aria-* attribute (if not above)
+  "aria-*": 25
+};
+const B = /* @__PURE__ */ new Set([
+  "id",
+  // handled separately
+  "class",
+  // handled separately
+  "style",
+  // unstable
+  "xmlns",
+  // service attribute for SVG
+  "tabindex",
+  // can change
+  "contenteditable"
+]);
+const ut = {
+  maxPathDepth: 10,
+  enableSvgFingerprint: true,
+  confidenceThreshold: 0.1,
+  fallbackToBody: true,
+  includeUtilityClasses: false,
+  source: "dom-dsl"
+};
+function D(n2) {
+  return !!(/^[a-z]+-\d+$/i.test(n2) || /^[a-z]+(-[a-z]+)+-\d+$/i.test(n2) || /^[a-z]+(_[a-z]+)*_\d+$/i.test(n2) || /^\d+$/.test(n2) || /^:[a-z0-9]+:$/i.test(n2) || /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i.test(n2) || /^[a-z]{1,3}[A-Za-z0-9]{8,}$/.test(n2) && (/\d/.test(n2) || /[A-Z]/.test(n2)) || /^radix-/.test(n2) || /^mui-\d+$/.test(n2));
+}
+const G = /* @__PURE__ */ new Set([
+  "aria-labelledby",
+  "aria-describedby",
+  "aria-controls",
+  "aria-owns",
+  "aria-activedescendant",
+  "for",
+  "form",
+  "list",
+  "headers",
+  "aria-details",
+  "aria-errormessage",
+  "aria-flowto"
+]);
+function V(n2) {
+  return n2.trim().split(/\s+/).some((e2) => D(e2));
+}
+class ft {
+  constructor(t2, e2) {
+    var _a2;
+    this.maxDepth = (_a2 = t2.maxPathDepth) != null ? _a2 : 10, this.cache = e2;
+  }
+  /**
+   * Finds the best anchor element for the target
+   * @param target - Target element to find anchor for
+   * @returns Anchor result or null if not found
+   */
+  findAnchor(t2) {
+    if (this.cache) {
+      const i2 = this.cache.getAnchor(t2);
+      if (i2 !== void 0)
+        return i2;
+    }
+    let e2 = t2.parentElement, s2 = 0, r2 = null;
+    for (; e2 && s2 < this.maxDepth; ) {
+      if (e2.tagName.toLowerCase() === "body")
+        return r2 || {
+          element: e2,
+          score: I.DEGRADED_SCORE,
+          tier: "C",
+          depth: s2
+        };
+      const i2 = this.scoreAnchor(e2);
+      if (i2 > 0) {
+        const o2 = this.applyDepthPenalty(i2, s2), l2 = this.getTier(e2), u2 = { element: e2, score: o2, tier: l2, depth: s2 };
+        if (l2 === "A")
+          return u2;
+        (!r2 || o2 > r2.score) && (r2 = u2);
+      }
+      e2 = e2.parentElement, s2++;
+    }
+    const a2 = r2;
+    return this.cache && this.cache.setAnchor(t2, a2), a2;
+  }
+  /**
+   * Scores an element as anchor candidate (without depth penalty)
+   * @param element - Element to score
+   * @returns Raw score from 0 to 1
+   */
+  scoreAnchor(t2) {
+    let e2 = 0;
+    const s2 = t2.tagName.toLowerCase();
+    X.includes(s2) && (e2 += I.SEMANTIC_TAG);
+    const r2 = t2.getAttribute("role");
+    r2 && K.includes(r2) && (e2 += I.ROLE), (t2.hasAttribute("aria-label") || t2.hasAttribute("aria-labelledby")) && (e2 += I.ARIA_LABEL);
+    const a2 = t2.id;
+    return a2 && !D(a2) && (e2 += I.STABLE_ID), (t2.hasAttribute("data-testid") || t2.hasAttribute("data-qa") || t2.hasAttribute("data-test")) && (e2 += I.TEST_MARKER), Math.min(e2, 1);
+  }
+  /**
+   * Applies depth penalty to score
+   * Following SPECIFICATION.md §7: depthPenalty = (depth - threshold) * factor
+   */
+  applyDepthPenalty(t2, e2) {
+    if (e2 <= I.DEPTH_PENALTY_THRESHOLD)
+      return t2;
+    const s2 = (e2 - I.DEPTH_PENALTY_THRESHOLD) * I.DEPTH_PENALTY_FACTOR;
+    return Math.max(0, t2 - s2);
+  }
+  /**
+   * Determines the tier of an anchor element
+   */
+  getTier(t2) {
+    const e2 = t2.tagName.toLowerCase();
+    if (X.includes(e2))
+      return "A";
+    const s2 = t2.getAttribute("role");
+    return s2 && K.includes(s2) ? "B" : "C";
+  }
+}
+const gt = [
+  // CSS-in-JS
+  /^css-[a-z0-9]+$/i,
+  /^sc-[a-z0-9]+-\d+$/i,
+  /^[a-z]{5,8}$/i,
+  // Short generated classes (abcdef)
+  // Material-UI / MUI
+  /^Mui[A-Z]\w+-\w+-\w+/,
+  /^makeStyles-\w+-\d+$/,
+  // JSS
+  /^jss\d+$/,
+  // Emotion / Linaria
+  /^(emotion|linaria)-[a-z0-9]+/i,
+  // Component libraries with hashes
+  /^(chakra|tw-|ant-)[a-z0-9]+-\w+/i,
+  // Hash-based (hashes in classes)
+  /-[a-f0-9]{6,}$/i,
+  /^_[a-z0-9]{5,}$/i,
+  /\d{5,}/
+  // 5+ digits in a row
+];
+const pt = [
+  // === FIX 4: Tailwind arbitrary values and variants (highest priority) ===
+  /^\[/,
+  // Any arbitrary value or variant starting with [ (e.g., [&_svg]:..., [mask-type:luminance])
+  // === FIX 4: Pseudo-class variants (must be before specific patterns) ===
+  /^(first|last|odd|even|only|first-of-type|last-of-type|only-of-type):/,
+  // first:, last:, etc.
+  /^(hover|focus|active|disabled|enabled|checked|indeterminate|default|required|valid|invalid|in-range|out-of-range|placeholder-shown|autofill|read-only):/,
+  // State pseudo-classes
+  /^(focus-within|focus-visible|visited|target|open):/,
+  // Advanced pseudo-classes
+  // === FIX 4: Responsive variants (must be before specific patterns) ===
+  /^(sm|md|lg|xl|2xl|3xl|4xl|5xl|6xl|7xl):/,
+  // === FIX 4: Dark mode and directional variants ===
+  /^dark:/,
+  /^(rtl|ltr):/,
+  // === FIX 4: Group and peer variants ===
+  /^(group|peer)(-hover|-focus|-active)?:/,
+  // === FIX 4: Tailwind utilities with fraction values ===
+  /\/([\d.]+|full|auto|screen)$/,
+  // /50, /100, /full, /auto, /screen
+  // === FIX 4: Positioning utilities ===
+  /^(inset|top|right|bottom|left)(-|$)/,
+  // inset-0, top-0, left-0
+  // === Layout & Display ===
+  /^(flex|inline-flex|grid|block|inline|inline-block|hidden|visible)$/,
+  /^(absolute|relative|fixed|sticky|static)$/,
+  // === Flexbox & Grid ===
+  /^(items|justify|content|self|place)-/,
+  /^flex-(row|col|wrap|nowrap|1|auto|initial|none)/,
+  /^grid-(cols|rows|flow)/,
+  // === Spacing (Tailwind) ===
+  /^(gap|space)-/,
+  /^[mp][trblxy]?-(\d+|auto|px)$/,
+  // === Negative Tailwind utilities (margins, positioning, transforms) ===
+  /^-[mp][trblxy]?-\d+$/,
+  // -m-4, -mt-2, -mx-4, -px-4, -py-2
+  /^-(top|right|bottom|left|inset)-\d+$/,
+  // -top-4, -bottom-6, -left-6, -inset-0
+  /^-z-\d+$/,
+  // -z-10, -z-20
+  /^-space-[xy]-\d+$/,
+  // -space-x-2, -space-y-4
+  /^-translate-[xy]-\d+$/,
+  // -translate-x-4, -translate-y-2
+  /^-rotate-\d+$/,
+  // -rotate-45, -rotate-90
+  /^-scale-\d+$/,
+  // -scale-50, -scale-75
+  /^-skew-[xy]-\d+$/,
+  // -skew-x-12, -skew-y-6
+  // === Sizing ===
+  /^(w|h|min-w|min-h|max-w|max-h|size)-/,
+  // === Colors & Styling ===
+  // Note: text-* can be semantic (text-muted, text-primary) or utility (text-center, text-lg)
+  // More specific patterns for utility text-* classes
+  /^text-(center|left|right|justify|start|end|xs|sm|base|lg|xl|2xl|3xl|4xl|5xl|6xl|7xl|8xl|9xl)$/,
+  /^text-(uppercase|lowercase|capitalize|normal-case|underline|line-through|no-underline)$/,
+  /^text-(truncate|ellipsis|clip)$/,
+  /^(bg|border|ring|shadow|outline)-/,
+  /^rounded(-|$)/,
+  // === Typography ===
+  /^(font|leading|tracking|whitespace|break|truncate)-/,
+  /^(uppercase|lowercase|capitalize|normal-case)$/,
+  // === Transform & Animation (IMPORTANT!) ===
+  /^(transform|transition|duration|delay|ease|animate)-/,
+  /^(scale|rotate|translate|skew)-/,
+  /^transform$/,
+  /^backdrop-blur-/,
+  /^motion-/,
+  // Framer Motion
+  /^(fade|slide|zoom|bounce|pulse|spin|ping)-/,
+  // animations
+  // === Overflow & Scrolling ===
+  /^(overflow|overscroll|scroll)-/,
+  /^object-(contain|cover|fill|none|scale-down)$/,
+  // === Interactivity ===
+  /^(cursor|pointer-events|select|resize)-/,
+  // === Visibility & Opacity ===
+  /^(opacity|z)-/,
+  /^(visible|invisible|collapse)$/,
+  // === Bootstrap utilities ===
+  /^d-(none|inline|inline-block|block|grid|table|flex)$/,
+  /^(float|clearfix|text)-(left|right|center|justify|start|end)$/,
+  /^(m|p)[trblxy]?-[0-5]$/,
+  /^(w|h)-(25|50|75|100|auto)$/,
+  // Note: btn-* classes are semantic (component classes), not utility
+  // /^btn-(primary|secondary|success|danger|warning|info|light|dark|link)$/,
+  /^btn-(sm|lg|block)$/,
+  // Only size modifiers are utility
+  /^text-(muted|primary|success|danger|warning|info|light|dark|white)$/,
+  /^bg-(primary|secondary|success|danger|warning|info|light|dark|white|transparent)$/,
+  /^border(-top|-bottom|-left|-right)?(-0)?$/,
+  /^rounded(-top|-bottom|-left|-right|-circle|-pill|-0)?$/,
+  /^shadow(-sm|-lg|-none)?$/,
+  /^(align|justify|order|flex)-(start|end|center|between|around|fill|grow|shrink)$/,
+  /^col(-sm|-md|-lg|-xl)?(-\d+|-auto)?$/,
+  /^row(-cols)?(-\d+)?$/,
+  /^g[xy]?-[0-5]$/,
+  /^(show|hide|invisible|visible)$/,
+  /^(position|top|bottom|start|end)-(static|relative|absolute|fixed|sticky|-\d+)$/,
+  // === Common utility patterns ===
+  /^(row|col)$/,
+  /^clearfix$/,
+  /^pull-(left|right)$/,
+  /^float-(left|right|none)$/
+];
+function _(n2) {
+  return gt.some((t2) => t2.test(n2));
+}
+function q(n2) {
+  return n2.length <= 2 || /^\d/.test(n2) ? true : pt.some((t2) => t2.test(n2));
+}
+function St(n2) {
+  return !_(n2) && !q(n2);
+}
+function N(n2) {
+  return n2.filter((t2) => St(t2));
+}
+function At(n2) {
+  const t2 = [], e2 = [];
+  for (const s2 of n2)
+    q(s2) || _(s2) ? e2.push(s2) : t2.push(s2);
+  return { semantic: t2, utility: e2 };
+}
+function J(n2) {
+  return q(n2) || _(n2);
+}
+const tt = (n2) => n2.replace(/([#:.[\]@])/g, "\\$1");
+class xt {
+  constructor(t2, e2) {
+    var _a2;
+    this.maxDepth = (_a2 = t2.maxPathDepth) != null ? _a2 : 10, this.cache = e2;
+  }
+  /**
+   * Builds path from anchor to target (excluding both)
+   * @param anchor - Anchor element (start)
+   * @param target - Target element (end)
+   * @param extractor - Semantic extractor instance
+   * @returns Path build result with nodes and degradation info
+   */
+  buildPath(t2, e2, s2) {
+    const r2 = [];
+    let a2 = e2.parentElement;
+    for (; a2 && a2 !== t2 && r2.length < this.maxDepth; )
+      r2.unshift(a2), a2 = a2.parentElement;
+    const i2 = r2.length >= this.maxDepth && a2 !== t2;
+    let o2 = this.filterNoise(r2);
+    return o2 = this.ensureUniqueness(r2, o2, t2, e2, s2), {
+      path: o2.map((u2) => {
+        const d = u2.parentElement;
+        let c2;
+        if (d) {
+          const g = Array.from(d.children).indexOf(u2);
+          g !== -1 && (c2 = g + 1);
+        }
+        return {
+          tag: u2.tagName.toLowerCase(),
+          semantics: s2.extract(u2),
+          score: s2.scoreElement(u2),
+          nthChild: c2
+        };
+      }),
+      degraded: i2,
+      degradationReason: i2 ? "path-depth-overflow" : void 0
+    };
+  }
+  /**
+   * Legacy method for backward compatibility
+   */
+  buildPathNodes(t2, e2, s2) {
+    return this.buildPath(t2, e2, s2).path;
+  }
+  /**
+   * Ensures path uniqueness by adding nodes if needed
+   * Following SPECIFICATION.md §8 Disambiguation Algorithm
+   */
+  ensureUniqueness(t2, e2, s2, r2, a2) {
+    const i2 = this.buildTestSelector(s2, e2, r2);
+    try {
+      const o2 = r2.ownerDocument;
+      if (!o2)
+        return e2;
+      let l2;
+      if (this.cache) {
+        const d = this.cache.getSelectorResults(i2);
+        d !== void 0 ? l2 = d : (l2 = Array.from(o2.querySelectorAll(i2)), this.cache.setSelectorResults(i2, l2));
+      } else
+        l2 = o2.querySelectorAll(i2);
+      if (l2.length <= 1)
+        return e2;
+      const u2 = t2.filter((d) => !e2.includes(d));
+      for (const d of u2) {
+        if (a2.scoreElement(d) < ct.MIN_CONFIDENCE_FOR_SKIP)
+          continue;
+        const h = this.insertNodeInOrder(e2, d, t2), g = this.buildTestSelector(s2, h, r2);
+        try {
+          let f2;
+          if (this.cache) {
+            const p = this.cache.getSelectorResults(g);
+            p !== void 0 ? f2 = p : (f2 = Array.from(o2.querySelectorAll(g)), this.cache.setSelectorResults(g, f2));
+          } else
+            f2 = o2.querySelectorAll(g);
+          if (f2.length === 1)
+            return h;
+          f2.length < l2.length && (e2 = h);
+        } catch (e3) {
+        }
+      }
+      return e2;
+    } catch (e3) {
+      return e2;
+    }
+  }
+  /**
+   * Inserts node into path maintaining original order
+   */
+  insertNodeInOrder(t2, e2, s2) {
+    const r2 = s2.indexOf(e2), a2 = [...t2];
+    let i2 = 0;
+    for (let o2 = 0; o2 < a2.length && !(s2.indexOf(a2[o2]) > r2); o2++)
+      i2 = o2 + 1;
+    return a2.splice(i2, 0, e2), a2;
+  }
+  /**
+   * Builds a test CSS selector from path
+   */
+  buildTestSelector(t2, e2, s2) {
+    const r2 = [];
+    r2.push(this.elementToSelector(t2));
+    for (const a2 of e2)
+      r2.push(this.elementToSelector(a2));
+    return r2.push(this.elementToSelector(s2)), r2.join(" ");
+  }
+  /**
+   * Converts element to basic CSS selector
+   */
+  elementToSelector(t2) {
+    let e2 = t2.tagName.toLowerCase();
+    t2.id && !D(t2.id) && (e2 += `#${tt(t2.id)}`);
+    for (const s2 of Array.from(t2.classList))
+      J(s2) || (e2 += `.${tt(s2)}`);
+    return e2;
+  }
+  /**
+   * Filters out noise/layout elements
+   */
+  filterNoise(t2) {
+    return t2.filter((e2) => this.shouldInclude(e2));
+  }
+  /**
+   * Determines if element should be included in path
+   */
+  shouldInclude(t2) {
+    const e2 = t2.tagName.toLowerCase();
+    return lt.includes(e2) ? true : e2 === "div" || e2 === "span" ? this.hasSemanticFeatures(t2) : false;
+  }
+  /**
+   * Checks if element has meaningful semantic features
+   */
+  hasSemanticFeatures(t2) {
+    if (t2.hasAttribute("role"))
+      return true;
+    for (const s2 of Array.from(t2.attributes))
+      if (s2.name.startsWith("aria-"))
+        return true;
+    if (t2.classList.length > 0) {
+      for (const s2 of Array.from(t2.classList))
+        if (!J(s2))
+          return true;
+    }
+    if (t2.hasAttribute("data-testid") || t2.hasAttribute("data-qa") || t2.hasAttribute("data-test"))
+      return true;
+    const e2 = t2.id;
+    return !!(e2 && !D(e2));
+  }
+}
+function Q(n2) {
+  return n2 ? n2.trim().replace(/[\n\t\r]/g, " ").replace(/\s+/g, " ") : "";
+}
+const Ct = {
+  preserveQueryForAbsolute: true,
+  removeDynamicHashes: true
+};
+function Tt(n2) {
+  return n2 ? [
+    /\d{5,}/,
+    // 5+ digits
+    /[a-f0-9]{8,}/i,
+    // hex hash 8+ characters
+    /(session|token|temp|random|timestamp|nonce|cache)/i,
+    // dynamic words
+    /^\d+$/,
+    // only digits
+    /^[a-f0-9-]{32,}$/i
+    // UUID-like
+  ].some((e2) => e2.test(n2)) : false;
+}
+function Et(n2, t2) {
+  if (!n2)
+    return n2;
+  const e2 = n2.startsWith("http://") || n2.startsWith("https://"), [s2, r2] = n2.split("#"), [a2, i2] = s2.split("?");
+  let o2 = a2;
+  return e2 && t2.preserveQueryForAbsolute && i2 && (o2 += `?${i2}`), r2 && (t2.removeDynamicHashes && Tt(r2) || (o2 += `#${r2}`)), o2;
+}
+function k(n2, t2, e2 = {}) {
+  if (!t2)
+    return t2;
+  const s2 = __spreadValues(__spreadValues({}, Ct), e2);
+  return n2 === "href" || n2 === "src" ? Et(t2, s2) : t2;
+}
+const wt = [
+  "role",
+  "aria-label",
+  "aria-labelledby",
+  "aria-describedby",
+  "aria-controls",
+  "aria-owns",
+  "aria-level",
+  "aria-posinset",
+  "aria-setsize",
+  "aria-haspopup"
+];
+const vt = [
+  "aria-selected",
+  "aria-checked",
+  "aria-pressed",
+  "aria-expanded",
+  "aria-hidden",
+  "aria-disabled",
+  "aria-current",
+  "aria-busy",
+  "aria-invalid",
+  "aria-grabbed",
+  "aria-live",
+  "aria-atomic"
+];
+const $t = [
+  "data-state",
+  "data-active",
+  "data-inactive",
+  "data-selected",
+  "data-open",
+  "data-closed",
+  "data-visible",
+  "data-hidden",
+  "data-disabled",
+  "data-enabled",
+  "data-loading",
+  "data-error",
+  "data-success",
+  "data-highlighted",
+  "data-focused",
+  "data-hover",
+  "data-orientation",
+  "data-theme"
+];
+const Mt = [
+  "data-radix-",
+  "data-headlessui-",
+  "data-reach-",
+  "data-mui-",
+  "data-chakra-",
+  "data-mantine-",
+  "data-tw-"
+];
+const It = [
+  "data-testid",
+  "data-test-id",
+  "data-test",
+  "data-cy",
+  "data-qa",
+  "data-automation-id",
+  "data-id",
+  "data-component",
+  "data-entity-id",
+  "data-product-id",
+  "data-user-id"
+];
+const Rt = [
+  "id",
+  "name",
+  "type",
+  "placeholder",
+  "title",
+  "for",
+  "alt",
+  "href"
+];
+const Nt = [
+  "disabled",
+  "checked",
+  "selected",
+  "hidden",
+  "readonly",
+  "required",
+  "value"
+];
+const Dt = [
+  /^radix-/,
+  /^headlessui-/,
+  /^mui-/,
+  /:\w+:/
+  // matches :ru:, :r1:, etc.
+];
+function Ht(n2, t2) {
+  return wt.includes(n2) ? true : vt.includes(n2) || $t.includes(n2) || Mt.some((e2) => n2.startsWith(e2)) ? false : It.includes(n2) || n2.startsWith("data-") && n2.endsWith("-id") ? true : n2 === "id" ? !Dt.some((e2) => e2.test(t2)) : Rt.includes(n2) ? true : Nt.includes(n2) ? false : !!n2.startsWith("data-");
+}
+class Pt {
+  constructor(t2, e2) {
+    var _a2;
+    this.includeUtilityClasses = (_a2 = t2.includeUtilityClasses) != null ? _a2 : false, this.cache = e2;
+  }
+  /**
+   * Extracts semantic features from element
+   * @param element - DOM element to extract from
+   * @returns Semantic features object
+   */
+  extract(t2) {
+    if (this.cache) {
+      const i2 = this.cache.getSemantics(t2);
+      if (i2 !== void 0)
+        return i2;
+    }
+    const e2 = {}, s2 = t2.id;
+    if (s2 && !D(s2) && (e2.id = s2), t2.classList.length > 0) {
+      const i2 = Array.from(t2.classList);
+      if (this.includeUtilityClasses)
+        e2.classes = i2;
+      else {
+        const { semantic: o2 } = At(i2);
+        o2.length > 0 && (e2.classes = o2);
+      }
+    }
+    const r2 = this.extractAttributes(t2);
+    Object.keys(r2).length > 0 && (e2.attributes = r2);
+    const a2 = t2.getAttribute("role");
+    if (a2 && (e2.role = a2), this.shouldExtractText(t2)) {
+      const i2 = this.extractText(t2);
+      i2 && (e2.text = i2);
+    }
+    return this.cache && this.cache.setSemantics(t2, e2), e2;
+  }
+  /**
+   * Scores element based on semantic richness
+   * @param element - Element to score
+   * @returns Score from 0 to 1
+   */
+  scoreElement(t2) {
+    let e2 = 0.5;
+    const s2 = this.extract(t2);
+    return s2.id && (e2 += 0.15), s2.classes && s2.classes.length > 0 && (e2 += 0.1), s2.attributes && Object.keys(s2.attributes).length > 0 && (e2 += 0.1), s2.role && (e2 += 0.1), s2.text && (e2 += 0.05), Math.min(e2, 1);
+  }
+  /**
+   * Checks if attribute should be ignored
+   * @param attrName - Attribute name
+   * @returns True if should be ignored
+   */
+  shouldIgnoreAttribute(t2) {
+    return !!(B.has(t2) || t2.startsWith("on") || t2.startsWith("ng-") || t2.startsWith("_ng") || t2.startsWith("data-reactid") || t2.startsWith("data-react") || t2.startsWith("data-v-"));
+  }
+  /**
+   * Gets attribute priority
+   * @param attrName - Attribute name
+   * @returns Priority number (higher = more priority)
+   */
+  getAttributePriority(t2) {
+    return w[t2] !== void 0 ? w[t2] : t2.startsWith("data-") ? w["data-*"] : t2.startsWith("aria-") ? w["aria-*"] : 0;
+  }
+  /**
+   * Checks if attribute value is dynamic (should be ignored)
+   * @param value - Attribute value
+   * @returns True if value is dynamic
+   */
+  isDynamicValue(t2) {
+    return [
+      /^[a-f0-9]{32,}$/i,
+      // Long hashes
+      /^\d{10,}$/,
+      // Timestamp
+      /^(undefined|null|\[object)/,
+      // JS artifacts
+      /^{{.*}}$/
+      // Template literals
+    ].some((s2) => s2.test(t2));
+  }
+  /**
+   * Extracts relevant semantic attributes from element
+   * Iterates through all attributes and filters by priority
+   */
+  extractAttributes(t2) {
+    const e2 = {};
+    for (const s2 of Array.from(t2.attributes)) {
+      const r2 = s2.name;
+      if (this.shouldIgnoreAttribute(r2) || !Ht(r2, s2.value) || G.has(r2) && V(s2.value) || this.getAttributePriority(r2) === 0)
+        continue;
+      const i2 = r2 === "href" || r2 === "src" ? k(r2, s2.value) : s2.value;
+      !i2 || i2.trim() === "" || this.isDynamicValue(i2) || (e2[r2] = i2);
+    }
+    return e2;
+  }
+  /**
+   * Extracts and normalizes text content
+   */
+  extractText(t2) {
+    const e2 = this.getDirectTextContent(t2);
+    if (!e2)
+      return null;
+    const s2 = Q(e2);
+    if (!s2)
+      return null;
+    const r2 = 100, a2 = e2.length > r2 ? e2.slice(0, r2) + "..." : e2, i2 = s2.length > r2 ? s2.slice(0, r2) + "..." : s2;
+    return {
+      raw: a2,
+      normalized: i2
+    };
+  }
+  /**
+   * Gets direct text content excluding child elements
+   */
+  getDirectTextContent(t2) {
+    var _a2;
+    const e2 = [];
+    for (const s2 of Array.from(t2.childNodes))
+      if (s2.nodeType === Node.TEXT_NODE && s2.textContent) {
+        const r2 = s2.textContent.trim();
+        r2 && e2.push(r2);
+      }
+    return e2.length > 0 ? e2.join(" ") : (_a2 = t2.textContent) != null ? _a2 : null;
+  }
+  /**
+   * Determines if text should be extracted for this element
+   */
+  shouldExtractText(t2) {
+    const e2 = t2.tagName.toLowerCase();
+    return [
+      "button",
+      "a",
+      "label",
+      "h1",
+      "h2",
+      "h3",
+      "h4",
+      "h5",
+      "h6",
+      "p",
+      "span",
+      "li",
+      "th",
+      "td",
+      "dt",
+      "dd",
+      "legend",
+      "figcaption",
+      "summary"
+    ].includes(e2);
+  }
+}
+class kt {
+  /**
+   * Generates fingerprint for SVG element
+   * @param element - SVG element to fingerprint
+   * @returns SVG fingerprint object
+   */
+  fingerprint(t2) {
+    const e2 = t2.tagName.toLowerCase(), s2 = this.getShape(e2), r2 = {
+      shape: s2,
+      hasAnimation: this.hasAnimation(t2)
+    };
+    if (s2 === "path") {
+      const o2 = t2.getAttribute("d");
+      o2 && (r2.dHash = this.computePathHash(o2));
+    } else
+      ["circle", "rect", "ellipse", "line"].includes(s2) && (r2.geomHash = this.computeGeomHash(t2, s2));
+    const a2 = t2.getAttribute("role");
+    a2 && (r2.role = a2);
+    const i2 = t2.querySelector("title");
+    return (i2 == null ? void 0 : i2.textContent) && (r2.titleText = i2.textContent.trim()), r2;
+  }
+  /**
+   * Computes hash from path data (first N commands)
+   * @param d - SVG path d attribute value
+   * @returns Hash string
+   */
+  computePathHash(t2) {
+    const e2 = this.normalizePathData(t2);
+    return this.simpleHash(e2);
+  }
+  /**
+   * Gets the shape type from tag name
+   */
+  getShape(t2) {
+    var _a2;
+    return (_a2 = [
+      "path",
+      "circle",
+      "rect",
+      "line",
+      "polyline",
+      "polygon",
+      "ellipse",
+      "g",
+      "text",
+      "use",
+      "svg"
+    ].find((s2) => s2 === t2)) != null ? _a2 : "path";
+  }
+  /**
+   * Normalizes path data for consistent hashing
+   */
+  normalizePathData(t2) {
+    var _a2;
+    return ((_a2 = t2.match(/[MLHVCSQTAZ][^MLHVCSQTAZ]*/gi)) != null ? _a2 : []).slice(0, 5).map((r2) => r2.trim().replace(/(-?\d+\.?\d*)/g, (a2) => parseFloat(a2).toFixed(1))).join(" ");
+  }
+  /**
+   * Computes geometry hash for non-path shapes
+   */
+  computeGeomHash(t2, e2) {
+    var _a2, _b, _c, _d, _e, _f, _g, _h, _i;
+    const s2 = [];
+    switch (e2) {
+      case "circle":
+        s2.push(`r=${(_a2 = t2.getAttribute("r")) != null ? _a2 : "0"}`);
+        break;
+      case "rect":
+        {
+          const r2 = parseFloat((_b = t2.getAttribute("width")) != null ? _b : "0"), a2 = parseFloat((_c = t2.getAttribute("height")) != null ? _c : "0");
+          r2 > 0 && a2 > 0 && s2.push(`ratio=${(r2 / a2).toFixed(2)}`);
+        }
+        break;
+      case "ellipse":
+        {
+          const r2 = parseFloat((_d = t2.getAttribute("rx")) != null ? _d : "0"), a2 = parseFloat((_e = t2.getAttribute("ry")) != null ? _e : "0");
+          r2 > 0 && a2 > 0 && s2.push(`ratio=${(r2 / a2).toFixed(2)}`);
+        }
+        break;
+      case "line":
+        {
+          const r2 = parseFloat((_f = t2.getAttribute("x1")) != null ? _f : "0"), a2 = parseFloat((_g = t2.getAttribute("y1")) != null ? _g : "0"), i2 = parseFloat((_h = t2.getAttribute("x2")) != null ? _h : "0"), o2 = parseFloat((_i = t2.getAttribute("y2")) != null ? _i : "0"), l2 = Math.atan2(o2 - a2, i2 - r2);
+          s2.push(`angle=${l2.toFixed(2)}`);
+        }
+        break;
+    }
+    return this.simpleHash(s2.join(";"));
+  }
+  /**
+   * Detects animations on SVG element
+   */
+  hasAnimation(t2) {
+    if (t2.querySelector("animate, animateTransform, animateMotion"))
+      return true;
+    const e2 = t2.ownerDocument;
+    if (e2 == null ? void 0 : e2.defaultView)
+      try {
+        const s2 = e2.defaultView.getComputedStyle(t2);
+        if (s2.animationName !== "none" || s2.transitionProperty !== "all" && s2.transitionProperty !== "none")
+          return true;
+      } catch (e3) {
+      }
+    return false;
+  }
+  /**
+   * Simple hash function for fingerprinting (not cryptographic)
+   */
+  simpleHash(t2) {
+    let e2 = 0;
+    for (let s2 = 0; s2 < t2.length; s2++) {
+      const r2 = t2.charCodeAt(s2);
+      e2 = (e2 << 5) - e2 + r2, e2 = e2 & e2;
+    }
+    return Math.abs(e2).toString(16).padStart(8, "0");
+  }
+}
+function _t(n2, t2 = 0) {
+  const e2 = n2.anchor.score, s2 = n2.path.length > 0 ? n2.path.reduce((o2, l2) => o2 + l2.score, 0) / n2.path.length : 0.5, r2 = n2.target.score, a2 = e2 * L.ANCHOR + s2 * L.PATH + r2 * L.TARGET + t2 * L.UNIQUENESS, i2 = n2.anchor.degraded ? 0.2 : 0;
+  return Math.max(0, Math.min(1, a2 - i2));
+}
+class qt {
+  constructor(t2) {
+    this.cache = /* @__PURE__ */ new Map(), this.maxSize = t2;
+  }
+  get(t2) {
+    const e2 = this.cache.get(t2);
+    if (e2 !== void 0)
+      return this.cache.delete(t2), this.cache.set(t2, e2), e2;
+  }
+  set(t2, e2) {
+    if (this.cache.has(t2))
+      this.cache.delete(t2);
+    else if (this.cache.size >= this.maxSize) {
+      const s2 = this.cache.keys().next().value;
+      s2 !== void 0 && this.cache.delete(s2);
+    }
+    this.cache.set(t2, e2);
+  }
+  has(t2) {
+    return this.cache.has(t2);
+  }
+  delete(t2) {
+    this.cache.delete(t2);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+}
+class Lt {
+  constructor(t2 = {}) {
+    var _a2, _b;
+    this.eidCache = /* @__PURE__ */ new WeakMap(), this.selectorResultCache = new qt(
+      (_a2 = t2.maxSelectorCacheSize) != null ? _a2 : 1e3
+    ), this.anchorCache = /* @__PURE__ */ new WeakMap(), this.semanticsCache = /* @__PURE__ */ new WeakMap(), this.stats = {
+      eidHits: 0,
+      eidMisses: 0,
+      selectorHits: 0,
+      selectorMisses: 0,
+      anchorHits: 0,
+      anchorMisses: 0,
+      semanticsHits: 0,
+      semanticsMisses: 0,
+      selectorCacheSize: 0,
+      maxSelectorCacheSize: (_b = t2.maxSelectorCacheSize) != null ? _b : 1e3
+    };
+  }
+  /**
+   * Get cached EID for element
+   */
+  getEID(t2) {
+    const e2 = this.eidCache.get(t2);
+    if (e2 !== void 0)
+      return this.stats.eidHits++, e2;
+    this.stats.eidMisses++;
+  }
+  /**
+   * Cache EID for element
+   */
+  setEID(t2, e2) {
+    this.eidCache.set(t2, e2);
+  }
+  /**
+   * Get cached selector results
+   */
+  getSelectorResults(t2) {
+    const e2 = this.selectorResultCache.get(t2);
+    if (e2 !== void 0)
+      return this.stats.selectorHits++, this.stats.selectorCacheSize = this.selectorResultCache.size, e2;
+    this.stats.selectorMisses++, this.stats.selectorCacheSize = this.selectorResultCache.size;
+  }
+  /**
+   * Cache selector results
+   */
+  setSelectorResults(t2, e2) {
+    this.selectorResultCache.set(t2, e2), this.stats.selectorCacheSize = this.selectorResultCache.size;
+  }
+  /**
+   * Get cached anchor result
+   */
+  getAnchor(t2) {
+    if (this.anchorCache.has(t2))
+      return this.stats.anchorHits++, this.anchorCache.get(t2);
+    this.stats.anchorMisses++;
+  }
+  /**
+   * Cache anchor result
+   */
+  setAnchor(t2, e2) {
+    this.anchorCache.set(t2, e2);
+  }
+  /**
+   * Get cached semantics
+   */
+  getSemantics(t2) {
+    const e2 = this.semanticsCache.get(t2);
+    if (e2 !== void 0)
+      return this.stats.semanticsHits++, e2;
+    this.stats.semanticsMisses++;
+  }
+  /**
+   * Cache semantics
+   */
+  setSemantics(t2, e2) {
+    this.semanticsCache.set(t2, e2);
+  }
+  /**
+   * Clear all caches
+   */
+  clear() {
+    this.selectorResultCache.clear(), this.stats.selectorCacheSize = 0, this.stats = {
+      eidHits: 0,
+      eidMisses: 0,
+      selectorHits: 0,
+      selectorMisses: 0,
+      anchorHits: 0,
+      anchorMisses: 0,
+      semanticsHits: 0,
+      semanticsMisses: 0,
+      selectorCacheSize: 0,
+      maxSelectorCacheSize: this.stats.maxSelectorCacheSize
+    };
+  }
+  /**
+   * Invalidate cache for a specific element
+   * Note: WeakMaps don't support deletion, but we can clear selector cache
+   * if needed. This method is mainly for future extensibility.
+   */
+  invalidateElement(t2) {
+  }
+  /**
+   * Invalidate a specific selector from cache
+   */
+  invalidateSelector(t2) {
+    this.selectorResultCache.delete(t2), this.stats.selectorCacheSize = this.selectorResultCache.size;
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    return __spreadProps(__spreadValues({}, this.stats), {
+      selectorCacheSize: this.selectorResultCache.size
+    });
+  }
+  /**
+   * Get cache hit rate for EID cache
+   */
+  getEIDHitRate() {
+    const t2 = this.stats.eidHits + this.stats.eidMisses;
+    return t2 > 0 ? this.stats.eidHits / t2 : 0;
+  }
+  /**
+   * Get cache hit rate for selector cache
+   */
+  getSelectorHitRate() {
+    const t2 = this.stats.selectorHits + this.stats.selectorMisses;
+    return t2 > 0 ? this.stats.selectorHits / t2 : 0;
+  }
+  /**
+   * Get cache hit rate for anchor cache
+   */
+  getAnchorHitRate() {
+    const t2 = this.stats.anchorHits + this.stats.anchorMisses;
+    return t2 > 0 ? this.stats.anchorHits / t2 : 0;
+  }
+  /**
+   * Get cache hit rate for semantics cache
+   */
+  getSemanticsHitRate() {
+    const t2 = this.stats.semanticsHits + this.stats.semanticsMisses;
+    return t2 > 0 ? this.stats.semanticsHits / t2 : 0;
+  }
+  /**
+   * Get overall cache hit rate
+   */
+  getOverallHitRate() {
+    const t2 = this.stats.eidHits + this.stats.selectorHits + this.stats.anchorHits + this.stats.semanticsHits, e2 = this.stats.eidMisses + this.stats.selectorMisses + this.stats.anchorMisses + this.stats.semanticsMisses, s2 = t2 + e2;
+    return s2 > 0 ? t2 / s2 : 0;
+  }
+}
+function Ot(n2) {
+  return new Lt(n2);
+}
+let O = null;
+function Z() {
+  return O || (O = Ot()), O;
+}
+function Y(n2, t2 = {}) {
+  var _a3, _b, _c, _d;
+  var _a2;
+  if (!n2 || !n2.ownerDocument || !n2.isConnected)
+    return null;
+  const e2 = __spreadValues(__spreadValues({}, ut), t2), s2 = (_a3 = e2.cache) != null ? _a3 : Z(), r2 = s2.getEID(n2);
+  if (r2 !== void 0)
+    return r2;
+  const a2 = new ft(e2, s2), i2 = new xt(e2, s2), o2 = new Pt(e2, s2), l2 = new kt(), u2 = a2.findAnchor(n2);
+  if (!u2 && !e2.fallbackToBody)
+    return null;
+  const d = (_c = (_b = u2 == null ? void 0 : u2.element) != null ? _b : (_a2 = n2.ownerDocument) == null ? void 0 : _a2.body) != null ? _c : null;
+  if (!d)
+    return null;
+  const c2 = !u2 || u2.tier === "C", h = d.tagName.toLowerCase(), g = d.parentElement;
+  let f2;
+  if (g && h !== "body" && h !== "html") {
+    const T = Array.from(g.children).indexOf(d);
+    T !== -1 && (f2 = T + 1);
+  }
+  const p = o2.extract(d), m = {
+    tag: d.tagName.toLowerCase(),
+    semantics: p,
+    score: (_d = u2 == null ? void 0 : u2.score) != null ? _d : I.DEGRADED_SCORE,
+    degraded: c2,
+    nthChild: f2
+  }, b = i2.buildPath(d, n2, o2), y = o2.extract(n2);
+  e2.enableSvgFingerprint && zt(n2) && (y.svg = l2.fingerprint(n2));
+  const v2 = n2.parentElement;
+  let A;
+  if (v2) {
+    const T = Array.from(v2.children).indexOf(n2);
+    T !== -1 && (A = T + 1);
+  }
+  const S = {
+    tag: n2.tagName.toLowerCase(),
+    semantics: y,
+    score: o2.scoreElement(n2),
+    nthChild: A
+  }, $ = [], M = {
+    onMultiple: "best-score",
+    onMissing: "anchor-only",
+    maxDepth: 3
+  }, H = m.degraded || b.degraded, E = Ut(m.degraded, b), x2 = {
+    version: "1.0",
+    anchor: m,
+    path: b.path,
+    target: S,
+    constraints: $,
+    fallback: M,
+    meta: {
+      confidence: 0,
+      // Calculated below
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      generator: "dom-eid@1.0",
+      source: e2.source,
+      degraded: H,
+      degradationReason: E
+    }
+  };
+  return x2.meta.confidence = _t(x2), x2.meta.confidence < e2.confidenceThreshold ? null : (s2.setEID(n2, x2), x2);
+}
+function zt(n2) {
+  return n2.namespaceURI === "http://www.w3.org/2000/svg" || n2.tagName.toLowerCase() === "svg" || n2 instanceof SVGElement;
+}
+function Ut(n2, t2) {
+  if (n2 && t2.degraded)
+    return "anchor-and-path-degraded";
+  if (n2)
+    return "no-semantic-anchor";
+  if (t2.degraded)
+    return t2.degradationReason;
+}
+const rt = {
+  maxClasses: 2,
+  maxAttributes: 5,
+  includeText: true,
+  maxTextLength: 50,
+  simplifyTarget: true,
+  includeConstraints: true
+};
+function et(n2) {
+  return n2 === "id" ? 101 : w[n2] !== void 0 ? w[n2] : n2.startsWith("data-") ? w["data-*"] : n2.startsWith("aria-") ? w["aria-*"] : 0;
+}
+function Vt(n2) {
+  return ["id", "data-testid", "data-qa", "data-cy", "href", "text", "role"].includes(n2);
+}
+function Qt(n2) {
+  return !!(/@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/.test(n2) || /(\+?\d{1,3}[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}/.test(n2) || /\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}/.test(n2));
+}
+function Zt(n2, t2) {
+  const e2 = __spreadValues(__spreadValues({}, rt), t2), s2 = `v${n2.version}`, r2 = U(n2.anchor, false, e2), a2 = n2.path.length > 0 ? n2.path.map((l2) => U(l2, false, e2)).join(" > ") + " > " : "", i2 = U(n2.target, true, e2), o2 = e2.includeConstraints ? Xt(n2) : "";
+  return `${s2}: ${r2} :: ${a2}${i2}${o2}`;
+}
+function U(n2, t2 = false, e2 = rt) {
+  const { tag: s2, semantics: r2 } = n2;
+  let a2 = s2;
+  const i2 = [], o2 = __spreadValues({}, r2.attributes);
+  r2.id && (o2.id = r2.id), r2.role && !o2.role && (o2.role = r2.role);
+  const l2 = Object.entries(o2).map(([c2, h]) => {
+    const g = et(c2), f2 = c2 === "href" || c2 === "src" ? k(c2, h) : h;
+    return { name: c2, value: f2, priority: g };
+  }).filter((c2) => c2.name !== "id" && c2.name !== "class" && B.has(c2.name) || G.has(c2.name) && V(c2.value) ? false : c2.priority > 0 || c2.name === "role" || c2.name === "id");
+  l2.sort((c2, h) => h.priority - c2.priority);
+  const u2 = l2.slice(0, e2.maxAttributes);
+  u2.sort((c2, h) => c2.name.localeCompare(h.name));
+  for (const { name: c2, value: h } of u2)
+    i2.push(`${c2}="${j(h)}"`);
+  if (e2.includeText && r2.text && !Qt(r2.text.normalized)) {
+    const c2 = r2.text.normalized;
+    c2.length > 0 && c2.length <= e2.maxTextLength && i2.push(`text="${j(c2)}"`);
+  }
+  let d = i2;
+  if (i2.length > 0 && (t2 && e2.simplifyTarget && r2.id && (d = i2.filter((c2) => {
+    const h = c2.split("=")[0];
+    return et(h) >= 60 || h === "text" || h === "id" || h === "role";
+  })), d.length > 0 && d.sort((c2, h) => c2.localeCompare(h))), r2.classes && r2.classes.length > 0) {
+    const c2 = N(r2.classes), h = !!r2.id || i2.some(
+      (f2) => f2.startsWith("href=") || f2.startsWith("data-testid=") || f2.startsWith("text=") || f2.startsWith("role=")
+    );
+    if (!(t2 && e2.simplifyTarget && h) && c2.length > 0) {
+      const f2 = c2.sort().slice(0, e2.maxClasses);
+      a2 += f2.map((p) => `.${p}`).join("");
+    }
+  }
+  if (d.length > 0 && (a2 += `[${d.join(",")}]`), "nthChild" in n2 && n2.nthChild) {
+    const c2 = !!r2.id || r2.attributes && Object.keys(r2.attributes).some(Vt);
+    t2 && e2.simplifyTarget && c2 || (a2 += `#${n2.nthChild}`);
+  }
+  return a2;
+}
+function Xt(n2) {
+  if (!n2.constraints || n2.constraints.length === 0)
+    return "";
+  const t2 = [];
+  for (const e2 of n2.constraints)
+    switch (e2.type) {
+      case "uniqueness":
+        t2.push("unique=true");
+        break;
+      case "position":
+        e2.params && e2.params.strategy && t2.push(`pos=${e2.params.strategy}`);
+        break;
+      case "text-proximity":
+        if (e2.params && e2.params.reference) {
+          const s2 = j(String(e2.params.reference));
+          t2.push(`text="${s2}"`);
+        }
+        break;
+    }
+  return t2.length === 0 ? "" : ` {${t2.join(",")}}`;
+}
+function j(n2) {
+  return n2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/>/g, "\\>").replace(/:/g, "\\:");
+}
+function le(n2, t2, e2) {
+  const s2 = Y(n2, t2);
+  return s2 ? Zt(s2, e2) : null;
+}
 let _id = 1;
 const tagNameRegex = new RegExp("[^a-z0-9-_:]");
 const IGNORED_NODE = -2;
@@ -1013,6 +2222,8 @@ function ignoreAttribute(tagName, name, _value) {
   return (tagName === "video" || tagName === "audio") && name === "autoplay";
 }
 function isExcludeAttribute(name, exclude) {
+  if (!exclude)
+    return false;
   return typeof exclude === "string" ? name.includes(exclude) : exclude.test(name);
 }
 function _isBlockedElement(element, blockClass, blockSelector) {
@@ -1523,7 +2734,8 @@ function serializeNodeWithId(n2, options) {
     stylesheetLoadTimeout = 5e3,
     keepIframeSrcFn = () => false,
     newlyAddedElement = false,
-    cssCaptured = false
+    cssCaptured = false,
+    selectorOptions
   } = options;
   let { needsMask } = options;
   let { preserveWhiteSpace = true } = options;
@@ -1568,11 +2780,20 @@ function serializeNodeWithId(n2, options) {
   }
   const serializedNode = Object.assign(_serializedNode, { id });
   if (isElement(n2) || n2.nodeType === Node.TEXT_NODE) {
-    serializedNode.xpath = buildXPath(n2);
-    if (isElement(n2)) {
-      const selector = buildSelector(n2);
-      if (selector) {
-        serializedNode.selector = selector;
+    if (isElement(n2) && selectorOptions !== null && selectorOptions !== void 0) {
+      try {
+        const seqlGeneratorOptions = {
+          maxPathDepth: selectorOptions.maxPathDepth,
+          enableSvgFingerprint: selectorOptions.enableSvgFingerprint,
+          confidenceThreshold: selectorOptions.confidenceThreshold,
+          fallbackToBody: selectorOptions.fallbackToBody
+        };
+        const selector = le(n2, seqlGeneratorOptions);
+        if (selector) {
+          serializedNode.selector = selector;
+        }
+      } catch (error) {
+        console.warn("Failed to generate SEQL selector:", error);
       }
     }
     if (n2.nodeType === Node.TEXT_NODE) {
@@ -1627,7 +2848,8 @@ function serializeNodeWithId(n2, options) {
       onStylesheetLoad,
       stylesheetLoadTimeout,
       keepIframeSrcFn,
-      cssCaptured: false
+      cssCaptured: false,
+      selectorOptions
     };
     if (serializedNode.type === NodeType$3.Element && serializedNode.tagName === "textarea" && serializedNode.attributes.value !== void 0)
       ;
@@ -1687,7 +2909,8 @@ function serializeNodeWithId(n2, options) {
             iframeLoadTimeout,
             onStylesheetLoad,
             stylesheetLoadTimeout,
-            keepIframeSrcFn
+            keepIframeSrcFn,
+            selectorOptions
           });
           if (serializedIframeNode) {
             onIframeLoad(
@@ -1729,7 +2952,8 @@ function serializeNodeWithId(n2, options) {
             iframeLoadTimeout,
             onStylesheetLoad,
             stylesheetLoadTimeout,
-            keepIframeSrcFn
+            keepIframeSrcFn,
+            selectorOptions
           });
           if (serializedLinkNode) {
             onStylesheetLoad(
@@ -1745,6 +2969,7 @@ function serializeNodeWithId(n2, options) {
   return serializedNode;
 }
 function snapshot(n2, options) {
+  var _a2, _b, _c, _d;
   const {
     mirror: mirror2 = new Mirror(),
     blockClass = "rr-block",
@@ -1766,7 +2991,8 @@ function snapshot(n2, options) {
     iframeLoadTimeout,
     onStylesheetLoad,
     stylesheetLoadTimeout,
-    keepIframeSrcFn = () => false
+    keepIframeSrcFn = () => false,
+    selector
   } = options || {};
   const maskInputOptions = maskAllInputs === true ? {
     color: true,
@@ -1804,6 +3030,22 @@ function snapshot(n2, options) {
       headMetaVerification: true
     }
   ) : slimDOM === false ? {} : slimDOM;
+  const selectorOptions = selector === false ? null : selector === true ? {
+    maxPathDepth: 10,
+    enableSvgFingerprint: true,
+    confidenceThreshold: 0.3,
+    fallbackToBody: true
+  } : selector === void 0 ? {
+    maxPathDepth: 10,
+    enableSvgFingerprint: true,
+    confidenceThreshold: 0.3,
+    fallbackToBody: true
+  } : {
+    maxPathDepth: (_a2 = selector.maxPathDepth) != null ? _a2 : 10,
+    enableSvgFingerprint: (_b = selector.enableSvgFingerprint) != null ? _b : true,
+    confidenceThreshold: (_c = selector.confidenceThreshold) != null ? _c : 0.3,
+    fallbackToBody: (_d = selector.fallbackToBody) != null ? _d : true
+  };
   return serializeNodeWithId(n2, {
     doc: n2,
     mirror: mirror2,
@@ -1828,7 +3070,8 @@ function snapshot(n2, options) {
     onStylesheetLoad,
     stylesheetLoadTimeout,
     keepIframeSrcFn,
-    newlyAddedElement: false
+    newlyAddedElement: false,
+    selectorOptions
   });
 }
 const MEDIA_SELECTOR = /(max|min)-device-(width|height)/;
@@ -1865,6 +3108,33 @@ const pseudoClassPlugin = {
     };
   }
 };
+const animationFillModePlugin = {
+  postcssPlugin: "postcss-animation-fill-mode",
+  prepare: function() {
+    return {
+      Rule: function(rule2) {
+        let hasAnimation = false;
+        let hasAnimationFillMode = false;
+        let animationDeclaration = null;
+        rule2.walkDecls((decl) => {
+          if (decl.prop === "animation") {
+            hasAnimation = true;
+            animationDeclaration = decl;
+          }
+          if (decl.prop === "animation-fill-mode") {
+            hasAnimationFillMode = true;
+          }
+        });
+        if (hasAnimation && !hasAnimationFillMode && animationDeclaration) {
+          rule2.insertAfter(animationDeclaration, {
+            prop: "animation-fill-mode",
+            value: "forwards"
+          });
+        }
+      }
+    };
+  }
+};
 function getDefaultExportFromCjs$1(x2) {
   return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
 }
@@ -1883,12 +3153,12 @@ function getAugmentedNamespace$1(n2) {
   } else
     a2 = {};
   Object.defineProperty(a2, "__esModule", { value: true });
-  Object.keys(n2).forEach(function(k) {
-    var d = Object.getOwnPropertyDescriptor(n2, k);
-    Object.defineProperty(a2, k, d.get ? d : {
+  Object.keys(n2).forEach(function(k2) {
+    var d = Object.getOwnPropertyDescriptor(n2, k2);
+    Object.defineProperty(a2, k2, d.get ? d : {
       enumerable: true,
       get: function() {
-        return n2[k];
+        return n2[k2];
       }
     });
   });
@@ -2335,7 +3605,7 @@ function cloneNode$1(obj, parent) {
     } else if (i2 === "source") {
       cloned[i2] = value;
     } else if (Array.isArray(value)) {
-      cloned[i2] = value.map((j) => cloneNode$1(j, cloned));
+      cloned[i2] = value.map((j2) => cloneNode$1(j2, cloned));
     } else {
       if (type === "object" && value !== null)
         value = cloneNode$1(value);
@@ -2576,7 +3846,7 @@ let Node$5$1 = class Node2 {
     }
     return result2;
   }
-  toJSON(_, inputs) {
+  toJSON(_2, inputs) {
     let fixed = {};
     let emitInputs = inputs == null;
     inputs = inputs || /* @__PURE__ */ new Map();
@@ -4292,8 +5562,8 @@ let Parser$1$1 = class Parser {
       return;
     let founded = 0;
     let token;
-    for (let j = colon - 1; j >= 0; j--) {
-      token = tokens[j];
+    for (let j2 = colon - 1; j2 >= 0; j2--) {
+      token = tokens[j2];
       if (token[0] !== "space") {
         founded += 1;
         if (founded === 2)
@@ -4415,8 +5685,8 @@ let Parser$1$1 = class Parser {
       } else if (token[1].toLowerCase() === "important") {
         let cache = tokens.slice(0);
         let str = "";
-        for (let j = i2; j > 0; j--) {
-          let type = cache[j][0];
+        for (let j2 = i2; j2 > 0; j2--) {
+          let type = cache[j2][0];
           if (str.trim().indexOf("!") === 0 && type !== "space") {
             break;
           }
@@ -5609,7 +6879,8 @@ function adaptCssForReplay(cssText, cache) {
   try {
     const ast = postcss$1$1([
       mediaSelectorPlugin,
-      pseudoClassPlugin
+      pseudoClassPlugin,
+      animationFillModePlugin
     ]).process(cssText);
     result2 = ast.css;
   } catch (error) {
@@ -6142,12 +7413,12 @@ function getAugmentedNamespace(n2) {
   } else
     a2 = {};
   Object.defineProperty(a2, "__esModule", { value: true });
-  Object.keys(n2).forEach(function(k) {
-    var d = Object.getOwnPropertyDescriptor(n2, k);
-    Object.defineProperty(a2, k, d.get ? d : {
+  Object.keys(n2).forEach(function(k2) {
+    var d = Object.getOwnPropertyDescriptor(n2, k2);
+    Object.defineProperty(a2, k2, d.get ? d : {
       enumerable: true,
       get: function() {
-        return n2[k];
+        return n2[k2];
       }
     });
   });
@@ -6594,7 +7865,7 @@ function cloneNode(obj, parent) {
     } else if (i2 === "source") {
       cloned[i2] = value;
     } else if (Array.isArray(value)) {
-      cloned[i2] = value.map((j) => cloneNode(j, cloned));
+      cloned[i2] = value.map((j2) => cloneNode(j2, cloned));
     } else {
       if (type === "object" && value !== null)
         value = cloneNode(value);
@@ -6835,7 +8106,7 @@ let Node$5 = class Node22 {
     }
     return result2;
   }
-  toJSON(_, inputs) {
+  toJSON(_2, inputs) {
     let fixed = {};
     let emitInputs = inputs == null;
     inputs = inputs || /* @__PURE__ */ new Map();
@@ -8551,8 +9822,8 @@ let Parser$1 = class Parser2 {
       return;
     let founded = 0;
     let token;
-    for (let j = colon - 1; j >= 0; j--) {
-      token = tokens[j];
+    for (let j2 = colon - 1; j2 >= 0; j2--) {
+      token = tokens[j2];
       if (token[0] !== "space") {
         founded += 1;
         if (founded === 2)
@@ -8674,8 +9945,8 @@ let Parser$1 = class Parser2 {
       } else if (token[1].toLowerCase() === "important") {
         let cache = tokens.slice(0);
         let str = "";
-        for (let j = i2; j > 0; j--) {
-          let type = cache[j][0];
+        for (let j2 = i2; j2 > 0; j2--) {
+          let type = cache[j2][0];
           if (str.trim().indexOf("!") === 0 && type !== "space") {
             break;
           }
@@ -9851,7 +11122,7 @@ const CUSTOM_PROPERTY_REGEX = /^--[a-zA-Z0-9-]+$/;
 const camelize = (str) => {
   if (CUSTOM_PROPERTY_REGEX.test(str))
     return str;
-  return str.replace(camelizeRE, (_, c2) => c2 ? c2.toUpperCase() : "");
+  return str.replace(camelizeRE, (_2, c2) => c2 ? c2.toUpperCase() : "");
 };
 const hyphenateRE = /\B([A-Z])/g;
 const hyphenate = (str) => {
@@ -14981,7 +16252,7 @@ class VisibilityManager {
     }
   }
 }
-const version$1 = "2.1.3-alpha.4";
+const version$1 = "3.1.1-alpha.1";
 let wrappedEmit;
 let takeFullSnapshot$1;
 let canvasManager;
@@ -15622,30 +16893,30 @@ const mittProxy = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePro
   __proto__: null,
   default: mitt$1
 }, Symbol.toStringTag, { value: "Module" }));
-function polyfill(w = window, d = document) {
-  if ("scrollBehavior" in d.documentElement.style && w.__forceSmoothScrollPolyfill__ !== true) {
+function polyfill(w2 = window, d = document) {
+  if ("scrollBehavior" in d.documentElement.style && w2.__forceSmoothScrollPolyfill__ !== true) {
     return;
   }
-  const Element2 = w.HTMLElement || w.Element;
+  const Element2 = w2.HTMLElement || w2.Element;
   const SCROLL_TIME = 468;
   const original = {
-    scroll: w.scroll || w.scrollTo,
-    scrollBy: w.scrollBy,
+    scroll: w2.scroll || w2.scrollTo,
+    scrollBy: w2.scrollBy,
     elementScroll: Element2.prototype.scroll || scrollElement,
     scrollIntoView: Element2.prototype.scrollIntoView
   };
-  const now = w.performance && w.performance.now ? w.performance.now.bind(w.performance) : Date.now;
+  const now = w2.performance && w2.performance.now ? w2.performance.now.bind(w2.performance) : Date.now;
   function isMicrosoftBrowser(userAgent) {
     const userAgentPatterns = ["MSIE ", "Trident/", "Edge/"];
     return new RegExp(userAgentPatterns.join("|")).test(userAgent);
   }
-  const ROUNDING_TOLERANCE = isMicrosoftBrowser(w.navigator.userAgent) ? 1 : 0;
+  const ROUNDING_TOLERANCE = isMicrosoftBrowser(w2.navigator.userAgent) ? 1 : 0;
   function scrollElement(x2, y) {
     this.scrollLeft = x2;
     this.scrollTop = y;
   }
-  function ease(k) {
-    return 0.5 * (1 - Math.cos(Math.PI * k));
+  function ease(k2) {
+    return 0.5 * (1 - Math.cos(Math.PI * k2));
   }
   function shouldBailOut(firstArg) {
     if (firstArg === null || typeof firstArg !== "object" || firstArg.behavior === void 0 || firstArg.behavior === "auto" || firstArg.behavior === "instant") {
@@ -15667,7 +16938,7 @@ function polyfill(w = window, d = document) {
     }
   }
   function canOverflow(el, axis) {
-    const overflowValue = w.getComputedStyle(el, null)["overflow" + axis];
+    const overflowValue = w2.getComputedStyle(el, null)["overflow" + axis];
     return overflowValue === "auto" || overflowValue === "scroll";
   }
   function isScrollable(el) {
@@ -15693,7 +16964,7 @@ function polyfill(w = window, d = document) {
     currentY = context.startY + (context.y - context.startY) * value;
     context.method.call(context.scrollable, currentX, currentY);
     if (currentX !== context.x || currentY !== context.y) {
-      w.requestAnimationFrame(step.bind(w, context));
+      w2.requestAnimationFrame(step.bind(w2, context));
     }
   }
   function smoothScroll(el, x2, y) {
@@ -15703,9 +16974,9 @@ function polyfill(w = window, d = document) {
     let method;
     const startTime = now();
     if (el === d.body) {
-      scrollable = w;
-      startX = w.scrollX || w.pageXOffset;
-      startY = w.scrollY || w.pageYOffset;
+      scrollable = w2;
+      startX = w2.scrollX || w2.pageXOffset;
+      startY = w2.scrollY || w2.pageYOffset;
       method = original.scroll;
     } else {
       scrollable = el;
@@ -15723,43 +16994,43 @@ function polyfill(w = window, d = document) {
       y
     });
   }
-  w.scroll = w.scrollTo = function() {
+  w2.scroll = w2.scrollTo = function() {
     if (arguments[0] === void 0) {
       return;
     }
     if (shouldBailOut(arguments[0]) === true) {
       original.scroll.call(
-        w,
-        arguments[0].left !== void 0 ? arguments[0].left : typeof arguments[0] !== "object" ? arguments[0] : w.scrollX || w.pageXOffset,
+        w2,
+        arguments[0].left !== void 0 ? arguments[0].left : typeof arguments[0] !== "object" ? arguments[0] : w2.scrollX || w2.pageXOffset,
         // use top prop, second argument if present or fallback to scrollY
-        arguments[0].top !== void 0 ? arguments[0].top : arguments[1] !== void 0 ? arguments[1] : w.scrollY || w.pageYOffset
+        arguments[0].top !== void 0 ? arguments[0].top : arguments[1] !== void 0 ? arguments[1] : w2.scrollY || w2.pageYOffset
       );
       return;
     }
     smoothScroll.call(
-      w,
+      w2,
       d.body,
-      arguments[0].left !== void 0 ? ~~arguments[0].left : w.scrollX || w.pageXOffset,
-      arguments[0].top !== void 0 ? ~~arguments[0].top : w.scrollY || w.pageYOffset
+      arguments[0].left !== void 0 ? ~~arguments[0].left : w2.scrollX || w2.pageXOffset,
+      arguments[0].top !== void 0 ? ~~arguments[0].top : w2.scrollY || w2.pageYOffset
     );
   };
-  w.scrollBy = function() {
+  w2.scrollBy = function() {
     if (arguments[0] === void 0) {
       return;
     }
     if (shouldBailOut(arguments[0])) {
       original.scrollBy.call(
-        w,
+        w2,
         arguments[0].left !== void 0 ? arguments[0].left : typeof arguments[0] !== "object" ? arguments[0] : 0,
         arguments[0].top !== void 0 ? arguments[0].top : arguments[1] !== void 0 ? arguments[1] : 0
       );
       return;
     }
     smoothScroll.call(
-      w,
+      w2,
       d.body,
-      ~~arguments[0].left + (w.scrollX || w.pageXOffset),
-      ~~arguments[0].top + (w.scrollY || w.pageYOffset)
+      ~~arguments[0].left + (w2.scrollX || w2.pageXOffset),
+      ~~arguments[0].top + (w2.scrollY || w2.pageYOffset)
     );
   };
   Element2.prototype.scroll = Element2.prototype.scrollTo = function() {
@@ -15824,15 +17095,15 @@ function polyfill(w = window, d = document) {
         scrollableParent.scrollLeft + clientRects.left - parentRects.left,
         scrollableParent.scrollTop + clientRects.top - parentRects.top
       );
-      if (w.getComputedStyle(scrollableParent).position !== "fixed") {
-        w.scrollBy({
+      if (w2.getComputedStyle(scrollableParent).position !== "fixed") {
+        w2.scrollBy({
           left: parentRects.left,
           top: parentRects.top,
           behavior: "smooth"
         });
       }
     } else {
-      w.scrollBy({
+      w2.scrollBy({
         left: clientRects.left,
         top: clientRects.top,
         behavior: "smooth"
@@ -16024,16 +17295,16 @@ function s(n2, o2) {
           var S = b.value;
           if (void 0 === S)
             return c(p, g);
-          var w = "string" == typeof S ? { target: S } : S, j = w.target, E = w.actions, R = void 0 === E ? [] : E, N = w.cond, O = void 0 === N ? function() {
+          var w2 = "string" == typeof S ? { target: S } : S, j2 = w2.target, E = w2.actions, R = void 0 === E ? [] : E, N2 = w2.cond, O2 = void 0 === N2 ? function() {
             return true;
-          } : N, _ = void 0 === j, k = null != j ? j : p, T = n2.states[k];
-          if (O(g, d)) {
-            var q = t(f((_ ? r(R) : [].concat(x2.exit, R, T.entry).filter(function(t2) {
+          } : N2, _2 = void 0 === j2, k2 = null != j2 ? j2 : p, T = n2.states[k2];
+          if (O2(g, d)) {
+            var q2 = t(f((_2 ? r(R) : [].concat(x2.exit, R, T.entry).filter(function(t2) {
               return t2;
             })).map(function(t2) {
               return i(t2, y._options.actions);
-            }), g, d), 3), z = q[0], A = q[1], B = q[2], C = null != j ? j : p;
-            return { value: C, context: A, actions: z, changed: j !== p || z.length > 0 || B, matches: a(C) };
+            }), g, d), 3), z = q2[0], A = q2[1], B2 = q2[2], C = null != j2 ? j2 : p;
+            return { value: C, context: A, actions: z, changed: j2 !== p || z.length > 0 || B2, matches: a(C) };
           }
         }
       } catch (t2) {
@@ -18518,7 +19789,7 @@ class Replayer {
     this.config.logger.log(REPLAY_CONSOLE_PREFIX, ...args);
   }
 }
-const version = "2.1.3-alpha.4";
+const version = "3.1.1-alpha.1";
 const { getVersion } = record;
 const { isRecording } = record;
 const { flushCustomEventQueue } = record;