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

package/dist/rrweb-all.cjs

@@ -300,6 +300,7 @@ 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);
     }
@@ -522,19 +523,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) {
@@ -551,11 +552,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;
@@ -566,29 +567,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)
                 );
@@ -606,96 +607,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 {
-    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);
@@ -828,6 +739,1274 @@ try {
   }
 } catch (error) {
 }
+const L = {
+  ANCHOR: 0.4,
+  PATH: 0.3,
+  TARGET: 0.2,
+  UNIQUENESS: 0.1
+}, 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
+}, ct = {
+  MIN_CONFIDENCE_FOR_SKIP: 0.7
+}, X = [
+  "form",
+  "main",
+  "nav",
+  "section",
+  "article",
+  "footer",
+  "header"
+], K = [
+  "form",
+  "navigation",
+  "main",
+  "region",
+  "contentinfo",
+  "complementary",
+  "banner",
+  "search"
+], 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"
+], 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
+}, B = /* @__PURE__ */ new Set([
+  "id",
+  // handled separately
+  "class",
+  // handled separately
+  "style",
+  // unstable
+  "xmlns",
+  // service attribute for SVG
+  "tabindex",
+  // can change
+  "contenteditable"
+]), 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) {
+    this.maxDepth = t2.maxPathDepth ?? 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
+], 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) {
+    this.maxDepth = t2.maxPathDepth ?? 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 {
+        }
+      }
+      return e2;
+    } catch {
+      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 = { ...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"
+], 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"
+], $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"
+], Mt = [
+  "data-radix-",
+  "data-headlessui-",
+  "data-reach-",
+  "data-mui-",
+  "data-chakra-",
+  "data-mantine-",
+  "data-tw-"
+], 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"
+], Rt = [
+  "id",
+  "name",
+  "type",
+  "placeholder",
+  "title",
+  "for",
+  "alt",
+  "href"
+], Nt = [
+  "disabled",
+  "checked",
+  "selected",
+  "hidden",
+  "readonly",
+  "required",
+  "value"
+], 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) {
+    this.includeUtilityClasses = t2.includeUtilityClasses ?? 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) {
+    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(" ") : t2.textContent ?? 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) {
+    return [
+      "path",
+      "circle",
+      "rect",
+      "line",
+      "polyline",
+      "polygon",
+      "ellipse",
+      "g",
+      "text",
+      "use",
+      "svg"
+    ].find((s2) => s2 === t2) ?? "path";
+  }
+  /**
+   * Normalizes path data for consistent hashing
+   */
+  normalizePathData(t2) {
+    return (t2.match(/[MLHVCSQTAZ][^MLHVCSQTAZ]*/gi) ?? []).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) {
+    const s2 = [];
+    switch (e2) {
+      case "circle":
+        s2.push(`r=${t2.getAttribute("r") ?? "0"}`);
+        break;
+      case "rect":
+        {
+          const r2 = parseFloat(t2.getAttribute("width") ?? "0"), a2 = parseFloat(t2.getAttribute("height") ?? "0");
+          r2 > 0 && a2 > 0 && s2.push(`ratio=${(r2 / a2).toFixed(2)}`);
+        }
+        break;
+      case "ellipse":
+        {
+          const r2 = parseFloat(t2.getAttribute("rx") ?? "0"), a2 = parseFloat(t2.getAttribute("ry") ?? "0");
+          r2 > 0 && a2 > 0 && s2.push(`ratio=${(r2 / a2).toFixed(2)}`);
+        }
+        break;
+      case "line":
+        {
+          const r2 = parseFloat(t2.getAttribute("x1") ?? "0"), a2 = parseFloat(t2.getAttribute("y1") ?? "0"), i2 = parseFloat(t2.getAttribute("x2") ?? "0"), o2 = parseFloat(t2.getAttribute("y2") ?? "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 {
+      }
+    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 = {}) {
+    this.eidCache = /* @__PURE__ */ new WeakMap(), this.selectorResultCache = new qt(
+      t2.maxSelectorCacheSize ?? 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: t2.maxSelectorCacheSize ?? 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 {
+      ...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 _a2;
+  if (!n2 || !n2.ownerDocument || !n2.isConnected)
+    return null;
+  const e2 = { ...ut, ...t2 }, s2 = e2.cache ?? 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 = (u2 == null ? void 0 : u2.element) ?? ((_a2 = n2.ownerDocument) == null ? void 0 : _a2.body) ?? 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: (u2 == null ? void 0 : u2.score) ?? 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 = { ...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 = { ...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;
@@ -949,6 +2128,7 @@ 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) {
@@ -1445,7 +2625,8 @@ function serializeNodeWithId(n2, options) {
     stylesheetLoadTimeout = 5e3,
     keepIframeSrcFn = () => false,
     newlyAddedElement = false,
-    cssCaptured = false
+    cssCaptured = false,
+    selectorOptions
   } = options;
   let { needsMask } = options;
   let { preserveWhiteSpace = true } = options;
@@ -1490,11 +2671,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) {
@@ -1549,7 +2739,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) ;
     else {
@@ -1608,7 +2799,8 @@ function serializeNodeWithId(n2, options) {
             iframeLoadTimeout,
             onStylesheetLoad,
             stylesheetLoadTimeout,
-            keepIframeSrcFn
+            keepIframeSrcFn,
+            selectorOptions
           });
           if (serializedIframeNode) {
             onIframeLoad(
@@ -1650,7 +2842,8 @@ function serializeNodeWithId(n2, options) {
             iframeLoadTimeout,
             onStylesheetLoad,
             stylesheetLoadTimeout,
-            keepIframeSrcFn
+            keepIframeSrcFn,
+            selectorOptions
           });
           if (serializedLinkNode) {
             onStylesheetLoad(
@@ -1687,7 +2880,8 @@ function snapshot(n2, options) {
     iframeLoadTimeout,
     onStylesheetLoad,
     stylesheetLoadTimeout,
-    keepIframeSrcFn = () => false
+    keepIframeSrcFn = () => false,
+    selector
   } = options || {};
   const maskInputOptions = maskAllInputs === true ? {
     color: true,
@@ -1725,6 +2919,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: selector.maxPathDepth ?? 10,
+    enableSvgFingerprint: selector.enableSvgFingerprint ?? true,
+    confidenceThreshold: selector.confidenceThreshold ?? 0.3,
+    fallbackToBody: selector.fallbackToBody ?? true
+  };
   return serializeNodeWithId(n2, {
     doc: n2,
     mirror: mirror2,
@@ -1749,7 +2959,8 @@ function snapshot(n2, options) {
     onStylesheetLoad,
     stylesheetLoadTimeout,
     keepIframeSrcFn,
-    newlyAddedElement: false
+    newlyAddedElement: false,
+    selectorOptions
   });
 }
 const MEDIA_SELECTOR = /(max|min)-device-(width|height)/;
@@ -1786,6 +2997,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;
 }
@@ -1802,12 +3040,12 @@ function getAugmentedNamespace$1(n2) {
     a2.prototype = f2.prototype;
   } 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];
       }
     });
   });
@@ -2231,7 +3469,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);
       cloned[i2] = value;
@@ -2466,7 +3704,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();
@@ -4111,8 +5349,8 @@ let Parser$1$1 = class Parser {
     if (colon === false) 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) break;
@@ -4230,8 +5468,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;
           }
@@ -5389,7 +6627,8 @@ function adaptCssForReplay(cssText, cache) {
   try {
     const ast = postcss$1$1([
       mediaSelectorPlugin,
-      pseudoClassPlugin
+      pseudoClassPlugin,
+      animationFillModePlugin
     ]).process(cssText);
     result2 = ast.css;
   } catch (error) {
@@ -5914,12 +7153,12 @@ function getAugmentedNamespace(n2) {
     a2.prototype = f2.prototype;
   } 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];
       }
     });
   });
@@ -6343,7 +7582,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);
       cloned[i2] = value;
@@ -6578,7 +7817,7 @@ let Node$5 = class Node22 {
     }
     return result2;
   }
-  toJSON(_, inputs) {
+  toJSON(_2, inputs) {
     let fixed = {};
     let emitInputs = inputs == null;
     inputs = inputs || /* @__PURE__ */ new Map();
@@ -8223,8 +9462,8 @@ let Parser$1 = class Parser2 {
     if (colon === false) 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) break;
@@ -8342,8 +9581,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;
           }
@@ -9483,7 +10722,7 @@ const camelizeRE = /-([a-z])/g;
 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) => {
@@ -14516,7 +15755,7 @@ class VisibilityManager {
     }
   }
 }
-const version$1 = "2.1.3-alpha.3";
+const version$1 = "3.1.1-alpha.1";
 let wrappedEmit;
 let takeFullSnapshot$1;
 let canvasManager;
@@ -14678,13 +15917,27 @@ function record(options = {}) {
     }
     return e2;
   };
+  let lastMetaHref = null;
+  let navSnapshotInProgress = false;
   wrappedEmit = (r2, isCheckout) => {
-    var _a2;
+    var _a2, _b2;
     const e2 = r2;
     e2.timestamp = nowTimestamp();
+    let navTriggeredFS = false;
     if (((_a2 = mutationBuffers[0]) == null ? void 0 : _a2.isFrozen()) && e2.type !== EventType.FullSnapshot && !(e2.type === EventType.IncrementalSnapshot && e2.data.source === IncrementalSource.Mutation)) {
       mutationBuffers.forEach((buf) => buf.unfreeze());
     }
+    if (!navSnapshotInProgress && e2.type !== EventType.Meta && e2.type !== EventType.FullSnapshot && lastMetaHref && window.location.href !== lastMetaHref) {
+      navSnapshotInProgress = true;
+      try {
+        recentVisibilityChanges = 0;
+        incrementalSnapshotCount = 0;
+        navTriggeredFS = true;
+        takeFullSnapshot$1(true);
+      } finally {
+        navSnapshotInProgress = false;
+      }
+    }
     if (inEmittingFrame) {
       emit == null ? void 0 : emit(eventProcessor(e2), isCheckout);
     } else if (passEmitsToParent) {
@@ -14696,6 +15949,9 @@ function record(options = {}) {
       };
       window.parent.postMessage(message, "*");
     }
+    if (e2.type === EventType.Meta) {
+      lastMetaHref = ((_b2 = e2.data) == null ? void 0 : _b2.href) || window.location.href;
+    }
     if (e2.type === EventType.FullSnapshot) {
       lastFullSnapshotEvent = e2;
       incrementalSnapshotCount = 0;
@@ -14704,14 +15960,16 @@ function record(options = {}) {
         return;
       }
       incrementalSnapshotCount++;
-      const exceedCount = checkoutEveryNth && incrementalSnapshotCount >= checkoutEveryNth;
-      const exceedTime = checkoutEveryNms && e2.timestamp - lastFullSnapshotEvent.timestamp > checkoutEveryNms;
-      const exceedVisibility = checkoutEveryNvm && recentVisibilityChanges >= checkoutEveryNvm;
-      if (exceedCount || exceedTime || exceedVisibility) {
-        if (exceedVisibility) {
-          recentVisibilityChanges = 0;
+      if (!navTriggeredFS) {
+        const exceedCount = checkoutEveryNth && incrementalSnapshotCount >= checkoutEveryNth;
+        const exceedTime = checkoutEveryNms && e2.timestamp - lastFullSnapshotEvent.timestamp > checkoutEveryNms;
+        const exceedVisibility = checkoutEveryNvm && recentVisibilityChanges >= checkoutEveryNvm;
+        if (exceedCount || exceedTime || exceedVisibility) {
+          if (exceedVisibility) {
+            recentVisibilityChanges = 0;
+          }
+          takeFullSnapshot$1(true);
         }
-        takeFullSnapshot$1(true);
       }
     }
   };
@@ -15150,30 +16408,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") {
@@ -15195,7 +16453,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) {
@@ -15221,7 +16479,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) {
@@ -15231,9 +16489,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;
@@ -15251,43 +16509,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() {
@@ -15352,15 +16610,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"
@@ -15546,16 +16804,16 @@ function s(n2, o2) {
         }(m), b = h.next(); !b.done; b = h.next()) {
           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$2(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) {
@@ -18007,7 +19265,7 @@ class Replayer {
     this.config.logger.log(REPLAY_CONSOLE_PREFIX, ...args);
   }
 }
-const version = "2.1.3-alpha.3";
+const version = "3.1.1-alpha.1";
 const { getVersion } = record;
 const { isRecording } = record;
 const { flushCustomEventQueue } = record;
@@ -18094,8 +19352,8 @@ var freb = function(eb, start) {
   }
   var r2 = new u32(b[30]);
   for (var i = 1; i < 30; ++i) {
-    for (var j = b[i]; j < b[i + 1]; ++j) {
-      r2[j] = j - b[i] << 5 | i;
+    for (var j2 = b[i]; j2 < b[i + 1]; ++j2) {
+      r2[j2] = j2 - b[i] << 5 | i;
     }
   }
   return [b, r2];
@@ -18116,9 +19374,9 @@ var hMap = function(cd, mb, r2) {
   var l2 = new u16(mb);
   for (; i < s2; ++i)
     ++l2[cd[i] - 1];
-  var le = new u16(mb);
+  var le2 = new u16(mb);
   for (i = 0; i < mb; ++i) {
-    le[i] = le[i - 1] + l2[i - 1] << 1;
+    le2[i] = le2[i - 1] + l2[i - 1] << 1;
   }
   var co;
   if (r2) {
@@ -18128,7 +19386,7 @@ var hMap = function(cd, mb, r2) {
       if (cd[i]) {
         var sv = i << 4 | cd[i];
         var r_1 = mb - cd[i];
-        var v2 = le[cd[i] - 1]++ << r_1;
+        var v2 = le2[cd[i] - 1]++ << r_1;
         for (var m = v2 | (1 << r_1) - 1; v2 <= m; ++v2) {
           co[rev[v2] >>> rvb] = sv;
         }
@@ -18137,7 +19395,7 @@ var hMap = function(cd, mb, r2) {
   } else {
     co = new u16(s2);
     for (i = 0; i < s2; ++i)
-      co[i] = rev[le[cd[i] - 1]++] >>> 15 - cd[i];
+      co[i] = rev[le2[cd[i] - 1]++] >>> 15 - cd[i];
   }
   return co;
 };
@@ -18250,10 +19508,10 @@ var inflt = function(dat, buf, st) {
               ldt[i++] = c2;
           }
         }
-        var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
-        lbt = max(lt);
+        var lt2 = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+        lbt = max(lt2);
         dbt = max(dt);
-        lm = hMap(lt, lbt, 1);
+        lm = hMap(lt2, lbt, 1);
         dm = hMap(dt, dbt, 1);
       } else
         throw "invalid block type";
@@ -18400,7 +19658,7 @@ var lc = function(c2) {
     ;
   var cl = new u16(++s2);
   var cli = 0, cln = c2[0], cls = 1;
-  var w = function(v2) {
+  var w2 = function(v2) {
     cl[cli++] = v2;
   };
   for (var i = 1; i <= s2; ++i) {
@@ -18409,20 +19667,20 @@ var lc = function(c2) {
     else {
       if (!cln && cls > 2) {
         for (; cls > 138; cls -= 138)
-          w(32754);
+          w2(32754);
         if (cls > 2) {
-          w(cls > 10 ? cls - 11 << 5 | 28690 : cls - 3 << 5 | 12305);
+          w2(cls > 10 ? cls - 11 << 5 | 28690 : cls - 3 << 5 | 12305);
           cls = 0;
         }
       } else if (cls > 3) {
-        w(cln), --cls;
+        w2(cln), --cls;
         for (; cls > 6; cls -= 6)
-          w(8304);
+          w2(8304);
         if (cls > 2)
-          w(cls - 3 << 5 | 8208), cls = 0;
+          w2(cls - 3 << 5 | 8208), cls = 0;
       }
       while (cls--)
-        w(cln);
+        w2(cln);
       cls = 1;
       cln = c2[i];
     }
@@ -18513,16 +19771,16 @@ var deo = /* @__PURE__ */ new u32([65540, 131080, 131088, 131104, 262176, 104870
 var dflt = function(dat, lvl, plvl, pre, post, lst) {
   var s2 = dat.length;
   var o2 = new u8(pre + s2 + 5 * (1 + Math.floor(s2 / 7e3)) + post);
-  var w = o2.subarray(pre, o2.length - post);
+  var w2 = o2.subarray(pre, o2.length - post);
   var pos = 0;
   if (!lvl || s2 < 8) {
     for (var i = 0; i <= s2; i += 65535) {
       var e2 = i + 65535;
       if (e2 < s2) {
-        pos = wfblk(w, pos, dat.subarray(i, e2));
+        pos = wfblk(w2, pos, dat.subarray(i, e2));
       } else {
-        w[i] = lst;
-        pos = wfblk(w, pos, dat.subarray(i, s2));
+        w2[i] = lst;
+        pos = wfblk(w2, pos, dat.subarray(i, s2));
       }
     }
   } else {
@@ -18546,12 +19804,12 @@ var dflt = function(dat, lvl, plvl, pre, post, lst) {
       if (wi <= i) {
         var rem = s2 - i;
         if ((lc_1 > 7e3 || li > 24576) && rem > 423) {
-          pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos);
+          pos = wblk(dat, w2, 0, syms, lf, df, eb, li, bs, i - bs, pos);
           li = lc_1 = eb = 0, bs = i;
-          for (var j = 0; j < 286; ++j)
-            lf[j] = 0;
-          for (var j = 0; j < 30; ++j)
-            df[j] = 0;
+          for (var j2 = 0; j2 < 286; ++j2)
+            lf[j2] = 0;
+          for (var j2 = 0; j2 < 30; ++j2)
+            df[j2] = 0;
         }
         var l2 = 2, d = 0, ch_1 = c2, dif = imod - pimod & 32767;
         if (rem > 2 && hv == hsh(i - dif)) {
@@ -18569,8 +19827,8 @@ var dflt = function(dat, lvl, plvl, pre, post, lst) {
                   break;
                 var mmd = Math.min(dif, nl - 2);
                 var md = 0;
-                for (var j = 0; j < mmd; ++j) {
-                  var ti = i - dif + j + 32768 & 32767;
+                for (var j2 = 0; j2 < mmd; ++j2) {
+                  var ti = i - dif + j2 + 32768 & 32767;
                   var pti = prev[ti];
                   var cd = ti - pti + 32768 & 32767;
                   if (cd > md)
@@ -18596,7 +19854,7 @@ var dflt = function(dat, lvl, plvl, pre, post, lst) {
         }
       }
     }
-    pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos);
+    pos = wblk(dat, w2, lst, syms, lf, df, eb, li, bs, i - bs, pos);
   }
   return slc(o2, 0, pre + shft(pos) + post);
 };
@@ -18654,7 +19912,7 @@ function strToU8(str, latin1) {
     return new TextEncoder().encode(str);
   var ar = new u8(str.length + (str.length >>> 1));
   var ai = 0;
-  var w = function(v2) {
+  var w2 = function(v2) {
     ar[ai++] = v2;
   };
   for (var i = 0; i < l2; ++i) {
@@ -18665,13 +19923,13 @@ function strToU8(str, latin1) {
     }
     var c2 = str.charCodeAt(i);
     if (c2 < 128 || latin1)
-      w(c2);
+      w2(c2);
     else if (c2 < 2048)
-      w(192 | c2 >>> 6), w(128 | c2 & 63);
+      w2(192 | c2 >>> 6), w2(128 | c2 & 63);
     else if (c2 > 55295 && c2 < 57344)
-      c2 = 65536 + (c2 & 1023 << 10) | str.charCodeAt(++i) & 1023, w(240 | c2 >>> 18), w(128 | c2 >>> 12 & 63), w(128 | c2 >>> 6 & 63), w(128 | c2 & 63);
+      c2 = 65536 + (c2 & 1023 << 10) | str.charCodeAt(++i) & 1023, w2(240 | c2 >>> 18), w2(128 | c2 >>> 12 & 63), w2(128 | c2 >>> 6 & 63), w2(128 | c2 & 63);
     else
-      w(224 | c2 >>> 12), w(128 | c2 >>> 6 & 63), w(128 | c2 & 63);
+      w2(224 | c2 >>> 12), w2(128 | c2 >>> 6 & 63), w2(128 | c2 & 63);
   }
   return slc(ar, 0, ai);
 }