@lunardinos/browser 0.2.0

package/dist/recorder-core.js

@@ -0,0 +1,4892 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// ../rrweb-types/src/index.ts
+var MouseInteractions;
+var init_src = __esm(() => {
+  ((MouseInteractions2) => {
+    MouseInteractions2[MouseInteractions2["MouseUp"] = 0] = "MouseUp";
+    MouseInteractions2[MouseInteractions2["MouseDown"] = 1] = "MouseDown";
+    MouseInteractions2[MouseInteractions2["Click"] = 2] = "Click";
+    MouseInteractions2[MouseInteractions2["ContextMenu"] = 3] = "ContextMenu";
+    MouseInteractions2[MouseInteractions2["DblClick"] = 4] = "DblClick";
+    MouseInteractions2[MouseInteractions2["Focus"] = 5] = "Focus";
+    MouseInteractions2[MouseInteractions2["Blur"] = 6] = "Blur";
+    MouseInteractions2[MouseInteractions2["TouchStart"] = 7] = "TouchStart";
+    MouseInteractions2[MouseInteractions2["TouchMove_Departed"] = 8] = "TouchMove_Departed";
+    MouseInteractions2[MouseInteractions2["TouchEnd"] = 9] = "TouchEnd";
+    MouseInteractions2[MouseInteractions2["TouchCancel"] = 10] = "TouchCancel";
+  })(MouseInteractions ||= {});
+});
+
+// ../rrweb-record/src/dom.ts
+function getUntaintedPrototype(key) {
+  if (untaintedBasePrototype[key])
+    return untaintedBasePrototype[key];
+  const defaultObj = globalThis[key];
+  const defaultPrototype = defaultObj.prototype;
+  const accessorNames = key in testableAccessors ? testableAccessors[key] : undefined;
+  const isUntaintedAccessors = Boolean(accessorNames?.every((accessor) => Boolean(Object.getOwnPropertyDescriptor(defaultPrototype, accessor)?.get?.toString().includes("[native code]"))));
+  const methodNames = key in testableMethods ? testableMethods[key] : undefined;
+  const isUntaintedMethods = Boolean(methodNames?.every((method) => typeof defaultPrototype[method] === "function" && defaultPrototype[method]?.toString().includes("[native code]")));
+  if (isUntaintedAccessors && isUntaintedMethods && !isAngularZonePresent()) {
+    untaintedBasePrototype[key] = defaultObj.prototype;
+    return defaultObj.prototype;
+  }
+  try {
+    const iframeEl = document.createElement("iframe");
+    document.body.appendChild(iframeEl);
+    const win = iframeEl.contentWindow;
+    if (!win)
+      return defaultObj.prototype;
+    const untaintedObject = win[key].prototype;
+    document.body.removeChild(iframeEl);
+    if (!untaintedObject)
+      return defaultPrototype;
+    return untaintedBasePrototype[key] = untaintedObject;
+  } catch {
+    return defaultPrototype;
+  }
+}
+function getUntaintedAccessor(key, instance, accessor) {
+  const cacheKey = `${key}.${String(accessor)}`;
+  if (untaintedAccessorCache[cacheKey])
+    return untaintedAccessorCache[cacheKey].call(instance);
+  const untaintedPrototype = getUntaintedPrototype(key);
+  const untaintedAccessor = Object.getOwnPropertyDescriptor(untaintedPrototype, accessor)?.get;
+  if (!untaintedAccessor)
+    return instance[accessor];
+  untaintedAccessorCache[cacheKey] = untaintedAccessor;
+  return untaintedAccessor.call(instance);
+}
+function getUntaintedMethod(key, instance, method) {
+  const cacheKey = `${key}.${String(method)}`;
+  if (untaintedMethodCache[cacheKey])
+    return untaintedMethodCache[cacheKey].bind(instance);
+  const untaintedPrototype = getUntaintedPrototype(key);
+  const untaintedMethod = untaintedPrototype[method];
+  if (typeof untaintedMethod !== "function")
+    return instance[method];
+  untaintedMethodCache[cacheKey] = untaintedMethod;
+  return untaintedMethod.bind(instance);
+}
+function childNodes(n) {
+  return getUntaintedAccessor("Node", n, "childNodes");
+}
+function parentNode(n) {
+  return getUntaintedAccessor("Node", n, "parentNode");
+}
+function parentElement(n) {
+  return getUntaintedAccessor("Node", n, "parentElement");
+}
+function textContent(n) {
+  return getUntaintedAccessor("Node", n, "textContent");
+}
+function contains(n, other) {
+  return getUntaintedMethod("Node", n, "contains")(other);
+}
+function getRootNode(n) {
+  return getUntaintedMethod("Node", n, "getRootNode")();
+}
+function host(n) {
+  if (!n || !("host" in n))
+    return null;
+  return getUntaintedAccessor("ShadowRoot", n, "host");
+}
+function styleSheets(n) {
+  return n.styleSheets;
+}
+function shadowRoot(n) {
+  if (!n || !("shadowRoot" in n))
+    return null;
+  return getUntaintedAccessor("Element", n, "shadowRoot");
+}
+function querySelector(n, selectors) {
+  return getUntaintedAccessor("Element", n, "querySelector")(selectors);
+}
+function querySelectorAll(n, selectors) {
+  return getUntaintedAccessor("Element", n, "querySelectorAll")(selectors);
+}
+function mutationObserverCtor() {
+  return getUntaintedPrototype("MutationObserver").constructor;
+}
+var testableAccessors, testableMethods, untaintedBasePrototype, isAngularZonePresent = () => {
+  return !!globalThis.Zone;
+}, untaintedAccessorCache, untaintedMethodCache, dom_default;
+var init_dom = __esm(() => {
+  testableAccessors = {
+    Node: ["childNodes", "parentNode", "parentElement", "textContent"],
+    ShadowRoot: ["host", "styleSheets"],
+    Element: ["shadowRoot", "querySelector", "querySelectorAll"],
+    MutationObserver: []
+  };
+  testableMethods = {
+    Node: ["contains", "getRootNode"],
+    ShadowRoot: ["getSelection"],
+    Element: [],
+    MutationObserver: ["constructor"]
+  };
+  untaintedBasePrototype = {};
+  untaintedAccessorCache = {};
+  untaintedMethodCache = {};
+  dom_default = {
+    childNodes,
+    parentNode,
+    parentElement,
+    textContent,
+    contains,
+    getRootNode,
+    host,
+    styleSheets,
+    shadowRoot,
+    querySelector,
+    querySelectorAll,
+    mutationObserver: mutationObserverCtor
+  };
+});
+
+// ../rrweb-record/src/redact-pii.ts
+function redactPII(text) {
+  let result = text;
+  for (const { re, tag } of PII_PATTERNS) {
+    re.lastIndex = 0;
+    result = result.replace(re, tag);
+  }
+  return result;
+}
+var EMAIL_RE, PHONE_RE, CC_RE, SSN_RE, IP_RE, PII_PATTERNS;
+var init_redact_pii = __esm(() => {
+  EMAIL_RE = /\b[\w.+-]+@[\w.-]+\.\w{2,}\b/g;
+  PHONE_RE = /(?:\+|(?<=\s|^))\(?\d{1,4}\)?[\s-]\(?\d{1,5}\)?[\s-]?\d{2,}(?:[\s-]\d+)*/g;
+  CC_RE = /\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b/g;
+  SSN_RE = /\b\d{3}-\d{2}-\d{4}\b/g;
+  IP_RE = /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g;
+  PII_PATTERNS = [
+    { re: CC_RE, tag: "[redacted cc]" },
+    { re: SSN_RE, tag: "[redacted ssn]" },
+    { re: EMAIL_RE, tag: "[redacted email]" },
+    { re: IP_RE, tag: "[redacted ip]" },
+    { re: PHONE_RE, tag: "[redacted phone]" }
+  ];
+});
+
+// ../rrweb-record/src/snapshot-utils.ts
+function isElement(n) {
+  return n.nodeType === n.ELEMENT_NODE;
+}
+function isShadowRoot(n) {
+  const hostEl = n && "host" in n && "mode" in n && dom_default.host(n) || null;
+  return Boolean(hostEl && "shadowRoot" in hostEl && dom_default.shadowRoot(hostEl) === n);
+}
+function isNativeShadowDom(shadowRoot2) {
+  return Object.prototype.toString.call(shadowRoot2) === "[object ShadowRoot]";
+}
+function fixBrowserCompatibilityIssuesInCSS(cssText) {
+  if (cssText.includes(" background-clip: text;") && !cssText.includes(" -webkit-background-clip: text;")) {
+    cssText = cssText.replace(/\sbackground-clip:\s*text;/g, " -webkit-background-clip: text; background-clip: text;");
+  }
+  return cssText;
+}
+function escapeImportStatement(rule) {
+  const { cssText } = rule;
+  if (cssText.split('"').length < 3)
+    return cssText;
+  const statement = ["@import", `url(${JSON.stringify(rule.href)})`];
+  if (rule.layerName === "") {
+    statement.push("layer");
+  } else if (rule.layerName) {
+    statement.push(`layer(${rule.layerName})`);
+  }
+  if (rule.supportsText) {
+    statement.push(`supports(${rule.supportsText})`);
+  }
+  if (rule.media.length) {
+    statement.push(rule.media.mediaText);
+  }
+  return `${statement.join(" ")};`;
+}
+function stringifyStylesheet(s) {
+  try {
+    const rules = s.rules || s.cssRules;
+    if (!rules) {
+      return null;
+    }
+    let sheetHref = s.href;
+    if (!sheetHref && s.ownerNode && s.ownerNode.ownerDocument) {
+      sheetHref = s.ownerNode.ownerDocument.location.href;
+    }
+    const stringifiedRules = Array.from(rules, (rule) => stringifyRule(rule, sheetHref)).join("");
+    return fixBrowserCompatibilityIssuesInCSS(stringifiedRules);
+  } catch (_error) {
+    return null;
+  }
+}
+function stringifyRule(rule, sheetHref) {
+  if (isCSSImportRule(rule)) {
+    let importStringified;
+    try {
+      importStringified = stringifyStylesheet(rule.styleSheet) || escapeImportStatement(rule);
+    } catch (_error) {
+      importStringified = rule.cssText;
+    }
+    if (rule.styleSheet.href) {
+      return absolutifyURLs(importStringified, rule.styleSheet.href);
+    }
+    return importStringified;
+  }
+  let ruleStringified = rule.cssText;
+  if (isCSSStyleRule(rule) && rule.selectorText.includes(":")) {
+    ruleStringified = fixSafariColons(ruleStringified);
+  }
+  if (sheetHref) {
+    return absolutifyURLs(ruleStringified, sheetHref);
+  }
+  return ruleStringified;
+}
+function fixSafariColons(cssStringified) {
+  const regex = /(\[(?:[\w-]+)[^\\])(:(?:[\w-]+)\])/gm;
+  return cssStringified.replace(regex, "$1\\$2");
+}
+function isCSSImportRule(rule) {
+  return "styleSheet" in rule;
+}
+function isCSSStyleRule(rule) {
+  return "selectorText" in rule;
+}
+
+class PathMirror {
+  nodePathMap = new WeakMap;
+  pathNodeMap = new Map;
+  nodeMetaMap = new WeakMap;
+  computePath(n) {
+    const parts = [];
+    let current = n;
+    let parent = dom_default.parentNode(current);
+    while (parent) {
+      const children = dom_default.childNodes(parent);
+      const idx = Array.prototype.indexOf.call(children, current);
+      if (idx === -1)
+        break;
+      parts.unshift(idx);
+      current = parent;
+      parent = dom_default.parentNode(current);
+    }
+    return parts.join(".");
+  }
+  getPath(n) {
+    if (!n)
+      return "";
+    const cached = this.nodePathMap.get(n);
+    if (cached !== undefined)
+      return cached;
+    return this.computePath(n);
+  }
+  getNode(path) {
+    return this.pathNodeMap.get(path) || null;
+  }
+  getPaths() {
+    return Array.from(this.pathNodeMap.keys());
+  }
+  has(path) {
+    return this.pathNodeMap.has(path);
+  }
+  add(n, meta) {
+    const path = meta.path;
+    if (path !== undefined) {
+      this.nodePathMap.set(n, path);
+      this.pathNodeMap.set(path, n);
+    }
+    this.nodeMetaMap.set(n, meta);
+  }
+  replace(path, n) {
+    const oldNode = this.pathNodeMap.get(path);
+    if (oldNode) {
+      const meta = this.nodeMetaMap.get(oldNode);
+      if (meta)
+        this.nodeMetaMap.set(n, meta);
+    }
+    this.pathNodeMap.set(path, n);
+    this.nodePathMap.set(n, path);
+  }
+  setPath(n, path) {
+    this.nodePathMap.set(n, path);
+    this.pathNodeMap.set(path, n);
+  }
+  setMeta(n, meta) {
+    this.nodeMetaMap.set(n, meta);
+  }
+  getMeta(n) {
+    return this.nodeMetaMap.get(n) || null;
+  }
+  hasNode(node) {
+    return this.nodePathMap.has(node);
+  }
+  isIgnored(n) {
+    return this.nodePathMap.get(n) === IGNORED_PATH;
+  }
+  isSerialized(n) {
+    const path = this.nodePathMap.get(n);
+    return path !== undefined && path !== IGNORED_PATH;
+  }
+  removeNodeFromMap(n) {
+    const path = this.nodePathMap.get(n);
+    if (path !== undefined) {
+      this.pathNodeMap.delete(path);
+    }
+    this.nodePathMap.delete(n);
+    if (n.childNodes) {
+      n.childNodes.forEach((childNode) => this.removeNodeFromMap(childNode));
+    }
+  }
+  reset() {
+    this.nodePathMap = new WeakMap;
+    this.pathNodeMap = new Map;
+    this.nodeMetaMap = new WeakMap;
+  }
+}
+function createMirror() {
+  return new PathMirror;
+}
+
+class Mirror {
+  pathNodeMap = new Map;
+  nodeMetaMap = new WeakMap;
+  nodePathMap = new WeakMap;
+  getPath(n) {
+    if (!n)
+      return "";
+    return this.nodePathMap.get(n) ?? "";
+  }
+  getNode(path) {
+    return this.pathNodeMap.get(path) || null;
+  }
+  getPaths() {
+    return Array.from(this.pathNodeMap.keys());
+  }
+  getMeta(n) {
+    return this.nodeMetaMap.get(n) || null;
+  }
+  has(path) {
+    return this.pathNodeMap.has(path);
+  }
+  hasNode(node) {
+    return this.nodeMetaMap.has(node);
+  }
+  add(n, meta) {
+    const path = meta.path;
+    if (path !== undefined) {
+      this.pathNodeMap.set(path, n);
+      this.nodePathMap.set(n, path);
+    }
+    this.nodeMetaMap.set(n, meta);
+  }
+  replace(path, n) {
+    const oldNode = this.pathNodeMap.get(path);
+    if (oldNode) {
+      const meta = this.nodeMetaMap.get(oldNode);
+      if (meta)
+        this.nodeMetaMap.set(n, meta);
+    }
+    this.pathNodeMap.set(path, n);
+    this.nodePathMap.set(n, path);
+  }
+  removeNodeFromMap(n) {
+    const path = this.nodePathMap.get(n);
+    if (path !== undefined) {
+      this.pathNodeMap.delete(path);
+    }
+    this.nodePathMap.delete(n);
+    if (n.childNodes) {
+      n.childNodes.forEach((childNode) => this.removeNodeFromMap(childNode));
+    }
+  }
+  reset() {
+    this.pathNodeMap = new Map;
+    this.nodeMetaMap = new WeakMap;
+    this.nodePathMap = new WeakMap;
+  }
+}
+function maskInputValue({
+  element,
+  maskInputOptions,
+  tagName,
+  type,
+  value,
+  maskInputFn
+}) {
+  let text = value || "";
+  const actualType = type && toLowerCase(type);
+  if (maskInputOptions[tagName.toLowerCase()] || actualType && maskInputOptions[actualType]) {
+    if (maskInputFn) {
+      text = maskInputFn(text, element);
+    } else {
+      text = "*".repeat(text.length);
+    }
+  } else {
+    text = redactPII(text);
+  }
+  return text;
+}
+function toLowerCase(str) {
+  return str.toLowerCase();
+}
+function is2DCanvasBlank(canvas) {
+  const ctx = canvas.getContext("2d");
+  if (!ctx)
+    return true;
+  const chunkSize = 50;
+  for (let x = 0;x < canvas.width; x += chunkSize) {
+    for (let y = 0;y < canvas.height; y += chunkSize) {
+      const getImageData = ctx.getImageData;
+      const originalGetImageData = ORIGINAL_ATTRIBUTE_NAME in getImageData ? getImageData[ORIGINAL_ATTRIBUTE_NAME] : getImageData;
+      const pixelBuffer = new Uint32Array(originalGetImageData.call(ctx, x, y, Math.min(chunkSize, canvas.width - x), Math.min(chunkSize, canvas.height - y)).data.buffer);
+      if (pixelBuffer.some((pixel) => pixel !== 0))
+        return false;
+    }
+  }
+  return true;
+}
+function getInputType(element) {
+  const type = element.type;
+  return element.hasAttribute("data-rr-is-password") ? "password" : type ? toLowerCase(type) : null;
+}
+function extractFileExtension(path, baseURL) {
+  let url;
+  try {
+    url = new URL(path, baseURL ?? window.location.href);
+  } catch (_err) {
+    return null;
+  }
+  const regex = /\.([0-9a-z]+)(?:$)/i;
+  const match = url.pathname.match(regex);
+  return match?.[1] ?? null;
+}
+function extractOrigin(url) {
+  let origin = "";
+  if (url.indexOf("//") > -1) {
+    origin = url.split("/").slice(0, 3).join("/");
+  } else {
+    origin = url.split("/")[0];
+  }
+  origin = origin.split("?")[0];
+  return origin;
+}
+function absolutifyURLs(cssText, href) {
+  return (cssText || "").replace(URL_IN_CSS_REF, (origin, quote1, path1, quote2, path2, path3) => {
+    const filePath = path1 || path2 || path3;
+    const maybeQuote = quote1 || quote2 || "";
+    if (!filePath) {
+      return origin;
+    }
+    if (URL_PROTOCOL_MATCH.test(filePath) || URL_WWW_MATCH.test(filePath)) {
+      return `url(${maybeQuote}${filePath}${maybeQuote})`;
+    }
+    if (DATA_URI.test(filePath)) {
+      return `url(${maybeQuote}${filePath}${maybeQuote})`;
+    }
+    if (filePath[0] === "/") {
+      return `url(${maybeQuote}${extractOrigin(href) + filePath}${maybeQuote})`;
+    }
+    const stack = href.split("/");
+    const parts = filePath.split("/");
+    stack.pop();
+    for (const part of parts) {
+      if (part === ".") {} else if (part === "..") {
+        stack.pop();
+      } else {
+        stack.push(part);
+      }
+    }
+    return `url(${maybeQuote}${stack.join("/")}${maybeQuote})`;
+  });
+}
+function normalizeCssString(cssText) {
+  return cssText.replace(/(\/\*[^*]*\*\/)|[\s;]/g, "");
+}
+function splitCssText(cssText, style) {
+  const childNodes2 = Array.from(style.childNodes);
+  const splits = [];
+  if (childNodes2.length > 1 && cssText && typeof cssText === "string") {
+    const cssTextNorm = normalizeCssString(cssText);
+    for (let i = 1;i < childNodes2.length; i++) {
+      const childNode = childNodes2[i];
+      if (childNode.textContent && typeof childNode.textContent === "string") {
+        const textContentNorm = normalizeCssString(childNode.textContent);
+        for (let j = 3;j < textContentNorm.length; j++) {
+          const bit = textContentNorm.substring(0, j);
+          if (cssTextNorm.split(bit).length === 2) {
+            const splitNorm = cssTextNorm.indexOf(bit);
+            for (let k = splitNorm;k < cssText.length; k++) {
+              if (normalizeCssString(cssText.substring(0, k)).length === splitNorm) {
+                splits.push(cssText.substring(0, k));
+                cssText = cssText.substring(k);
+                break;
+              }
+            }
+            break;
+          }
+        }
+      }
+    }
+  }
+  splits.push(cssText);
+  return splits;
+}
+function markCssSplits(cssText, style) {
+  return splitCssText(cssText, style).join("/* rr_split */");
+}
+var IGNORED_PATH = "__ignored__", ORIGINAL_ATTRIBUTE_NAME = "__rrweb_original__", URL_IN_CSS_REF, URL_PROTOCOL_MATCH, URL_WWW_MATCH, DATA_URI;
+var init_snapshot_utils = __esm(() => {
+  init_src();
+  init_dom();
+  init_redact_pii();
+  URL_IN_CSS_REF = /url\((?:(')([^']*)'|(")(.*?)"|([^)]*))\)/gm;
+  URL_PROTOCOL_MATCH = /^(?:[a-z+]+:)?\/\//i;
+  URL_WWW_MATCH = /^www\..*/i;
+  DATA_URI = /^(data:)([^,]*),(.*)/i;
+});
+
+// ../rrweb-record/src/snapshot.ts
+function getValidTagName(element) {
+  if (element instanceof HTMLFormElement) {
+    return "form";
+  }
+  const processedTagName = toLowerCase(element.tagName);
+  if (tagNameRegex.test(processedTagName)) {
+    return "div";
+  }
+  return processedTagName;
+}
+function getAbsoluteSrcsetString(doc, attributeValue) {
+  if (attributeValue.trim() === "") {
+    return attributeValue;
+  }
+  let pos = 0;
+  function collectCharacters(regEx) {
+    let chars;
+    const match = regEx.exec(attributeValue.substring(pos));
+    if (match) {
+      chars = match[0];
+      pos += chars.length;
+      return chars;
+    }
+    return "";
+  }
+  const output = [];
+  while (true) {
+    collectCharacters(SRCSET_COMMAS_OR_SPACES);
+    if (pos >= attributeValue.length) {
+      break;
+    }
+    let url = collectCharacters(SRCSET_NOT_SPACES);
+    if (url.slice(-1) === ",") {
+      url = absoluteToDoc(doc, url.substring(0, url.length - 1));
+      output.push(url);
+    } else {
+      let descriptorsStr = "";
+      url = absoluteToDoc(doc, url);
+      let inParens = false;
+      while (true) {
+        const c = attributeValue.charAt(pos);
+        if (c === "") {
+          output.push((url + descriptorsStr).trim());
+          break;
+        }
+        if (!inParens) {
+          if (c === ",") {
+            pos += 1;
+            output.push((url + descriptorsStr).trim());
+            break;
+          }
+          if (c === "(") {
+            inParens = true;
+          }
+        } else {
+          if (c === ")") {
+            inParens = false;
+          }
+        }
+        descriptorsStr += c;
+        pos += 1;
+      }
+    }
+  }
+  return output.join(", ");
+}
+function absoluteToDoc(doc, attributeValue) {
+  if (!attributeValue || attributeValue.trim() === "") {
+    return attributeValue;
+  }
+  return getHref(doc, attributeValue);
+}
+function isSVGElement(el) {
+  return Boolean(el.tagName === "svg" || el.ownerSVGElement);
+}
+function getHref(doc, customHref) {
+  let a = cachedDocument.get(doc);
+  if (!a) {
+    a = doc.createElement("a");
+    cachedDocument.set(doc, a);
+  }
+  if (!customHref) {
+    customHref = "";
+  } else if (customHref.startsWith("blob:") || customHref.startsWith("data:")) {
+    return customHref;
+  }
+  a.setAttribute("href", customHref);
+  return a.href;
+}
+function transformAttribute(doc, tagName, name, value) {
+  if (!value) {
+    return value;
+  }
+  if (name === "src" || name === "href" && !(tagName === "use" && value[0] === "#")) {
+    return absoluteToDoc(doc, value);
+  }
+  if (name === "xlink:href" && value[0] !== "#") {
+    return absoluteToDoc(doc, value);
+  }
+  if (name === "background" && (tagName === "table" || tagName === "td" || tagName === "th")) {
+    return absoluteToDoc(doc, value);
+  }
+  if (name === "srcset") {
+    return getAbsoluteSrcsetString(doc, value);
+  }
+  if (name === "style") {
+    return absolutifyURLs(value, getHref(doc));
+  }
+  if (tagName === "object" && name === "data") {
+    return absoluteToDoc(doc, value);
+  }
+  return value;
+}
+function ignoreAttribute(tagName, name, _value) {
+  return (tagName === "video" || tagName === "audio") && name === "autoplay";
+}
+function _isBlockedElement(element, blockClass, blockSelector) {
+  try {
+    if (typeof blockClass === "string") {
+      if (element.classList.contains(blockClass)) {
+        return true;
+      }
+    } else {
+      for (let eIndex = element.classList.length;eIndex--; ) {
+        const className = element.classList[eIndex];
+        if (blockClass.test(className)) {
+          return true;
+        }
+      }
+    }
+    if (blockSelector) {
+      return element.matches(blockSelector);
+    }
+  } catch (_e) {}
+  return false;
+}
+function classMatchesRegex(node, regex, checkAncestors) {
+  if (!node)
+    return false;
+  if (node.nodeType !== node.ELEMENT_NODE) {
+    if (!checkAncestors)
+      return false;
+    return classMatchesRegex(dom_default.parentNode(node), regex, checkAncestors);
+  }
+  for (let eIndex = node.classList.length;eIndex--; ) {
+    const className = node.classList[eIndex];
+    if (regex.test(className)) {
+      return true;
+    }
+  }
+  if (!checkAncestors)
+    return false;
+  return classMatchesRegex(dom_default.parentNode(node), regex, checkAncestors);
+}
+function needMaskingText(node, maskTextClass, maskTextSelector, checkAncestors) {
+  let el;
+  if (isElement(node)) {
+    el = node;
+    if (!dom_default.childNodes(el).length) {
+      return false;
+    }
+  } else if (dom_default.parentElement(node) === null) {
+    return false;
+  } else {
+    el = dom_default.parentElement(node);
+  }
+  try {
+    if (typeof maskTextClass === "string") {
+      if (checkAncestors) {
+        if (el.closest(`.${maskTextClass}`))
+          return true;
+      } else {
+        if (el.classList.contains(maskTextClass))
+          return true;
+      }
+    } else {
+      if (classMatchesRegex(el, maskTextClass, checkAncestors))
+        return true;
+    }
+    if (maskTextSelector) {
+      if (checkAncestors) {
+        if (el.closest(maskTextSelector))
+          return true;
+      } else {
+        if (el.matches(maskTextSelector))
+          return true;
+      }
+    }
+  } catch (_e) {}
+  return false;
+}
+function onceIframeLoaded(iframeEl, listener, iframeLoadTimeout) {
+  const win = iframeEl.contentWindow;
+  if (!win) {
+    return;
+  }
+  let fired = false;
+  let readyState;
+  try {
+    readyState = win.document.readyState;
+  } catch (_error) {
+    return;
+  }
+  if (readyState !== "complete") {
+    const timer = setTimeout(() => {
+      if (!fired) {
+        listener();
+        fired = true;
+      }
+    }, iframeLoadTimeout);
+    iframeEl.addEventListener("load", () => {
+      clearTimeout(timer);
+      fired = true;
+      listener();
+    });
+    return;
+  }
+  const blankUrl = "about:blank";
+  if (win.location.href !== blankUrl || iframeEl.src === blankUrl || iframeEl.src === "") {
+    setTimeout(listener, 0);
+    return iframeEl.addEventListener("load", listener);
+  }
+  iframeEl.addEventListener("load", listener);
+}
+function onceStylesheetLoaded(link, listener, styleSheetLoadTimeout) {
+  let fired = false;
+  let styleSheetLoaded;
+  try {
+    styleSheetLoaded = link.sheet;
+  } catch (_error) {
+    return;
+  }
+  if (styleSheetLoaded)
+    return;
+  const timer = setTimeout(() => {
+    if (!fired) {
+      listener();
+      fired = true;
+    }
+  }, styleSheetLoadTimeout);
+  link.addEventListener("load", () => {
+    clearTimeout(timer);
+    fired = true;
+    listener();
+  });
+}
+function serializeNode(n, options) {
+  const {
+    doc,
+    mirror,
+    blockClass,
+    blockSelector,
+    needsMask,
+    inlineStylesheet,
+    maskInputOptions = {},
+    maskTextFn,
+    maskInputFn,
+    dataURLOptions = {},
+    inlineImages,
+    recordCanvas,
+    keepIframeSrcFn,
+    newlyAddedElement = false,
+    cssCaptured = false
+  } = options;
+  const rootId = getRootId(doc, mirror);
+  switch (n.nodeType) {
+    case n.DOCUMENT_NODE:
+      if (n.compatMode !== "CSS1Compat") {
+        return {
+          type: 0 /* Document */,
+          childNodes: [],
+          compatMode: n.compatMode
+        };
+      }
+      return {
+        type: 0 /* Document */,
+        childNodes: []
+      };
+    case n.DOCUMENT_TYPE_NODE:
+      return {
+        type: 1 /* DocumentType */,
+        name: n.name,
+        publicId: n.publicId,
+        systemId: n.systemId,
+        rootId
+      };
+    case n.ELEMENT_NODE:
+      return serializeElementNode(n, {
+        doc,
+        blockClass,
+        blockSelector,
+        inlineStylesheet,
+        maskInputOptions,
+        maskInputFn,
+        dataURLOptions,
+        inlineImages,
+        recordCanvas,
+        keepIframeSrcFn,
+        newlyAddedElement,
+        rootId
+      });
+    case n.TEXT_NODE:
+      return serializeTextNode(n, {
+        doc,
+        needsMask,
+        maskTextFn,
+        rootId,
+        cssCaptured
+      });
+    case n.CDATA_SECTION_NODE:
+      return {
+        type: 4 /* CDATA */,
+        textContent: "",
+        rootId
+      };
+    case n.COMMENT_NODE:
+      return {
+        type: 5 /* Comment */,
+        textContent: dom_default.textContent(n) || "",
+        rootId
+      };
+    default:
+      return false;
+  }
+}
+function getRootId(doc, mirror) {
+  if (!mirror.hasNode(doc))
+    return;
+  const docPath = mirror.getPath(doc);
+  return docPath === "" ? undefined : docPath;
+}
+function serializeTextNode(n, options) {
+  const { needsMask, maskTextFn, rootId, cssCaptured } = options;
+  const parent = dom_default.parentNode(n);
+  const parentTagName = parent && parent.tagName;
+  let textContent2 = "";
+  const isStyle = parentTagName === "STYLE" ? true : undefined;
+  const isScript = parentTagName === "SCRIPT" ? true : undefined;
+  if (isScript) {
+    textContent2 = "";
+  } else if (!cssCaptured) {
+    textContent2 = dom_default.textContent(n);
+    if (isStyle && textContent2) {
+      textContent2 = absolutifyURLs(textContent2, getHref(options.doc));
+    }
+  }
+  if (!isStyle && !isScript && textContent2 && needsMask) {
+    textContent2 = maskTextFn ? maskTextFn(textContent2, dom_default.parentElement(n)) : textContent2.replace(/[\S]/g, "*");
+  }
+  if (!isStyle && !isScript && textContent2) {
+    textContent2 = redactPII(textContent2);
+  }
+  return {
+    type: 3 /* Text */,
+    textContent: textContent2 || "",
+    rootId
+  };
+}
+function serializeElementNode(n, options) {
+  const {
+    doc,
+    blockClass,
+    blockSelector,
+    inlineStylesheet,
+    maskInputOptions = {},
+    maskInputFn,
+    dataURLOptions = {},
+    inlineImages,
+    recordCanvas,
+    keepIframeSrcFn,
+    newlyAddedElement = false,
+    rootId
+  } = options;
+  const needBlock = _isBlockedElement(n, blockClass, blockSelector);
+  const tagName = getValidTagName(n);
+  let attributes = {};
+  const len = n.attributes.length;
+  for (let i = 0;i < len; i++) {
+    const attr = n.attributes[i];
+    if (!ignoreAttribute(tagName, attr.name, attr.value)) {
+      attributes[attr.name] = transformAttribute(doc, tagName, toLowerCase(attr.name), attr.value);
+    }
+  }
+  if (tagName === "link" && inlineStylesheet) {
+    const stylesheet = Array.from(doc.styleSheets).find((s) => {
+      return s.href === n.href;
+    });
+    let cssText = null;
+    if (stylesheet) {
+      cssText = stringifyStylesheet(stylesheet);
+    }
+    if (cssText) {
+      attributes.rel = undefined;
+      attributes.href = undefined;
+      attributes._cssText = cssText;
+    }
+  }
+  if (tagName === "style" && n.sheet) {
+    let cssText = stringifyStylesheet(n.sheet);
+    if (cssText) {
+      if (n.childNodes.length > 1) {
+        cssText = markCssSplits(cssText, n);
+      }
+      attributes._cssText = cssText;
+    }
+  }
+  if (tagName === "input" || tagName === "textarea" || tagName === "select") {
+    const value = n.value;
+    const checked = n.checked;
+    if (attributes.type !== "radio" && attributes.type !== "checkbox" && attributes.type !== "submit" && attributes.type !== "button" && value) {
+      attributes.value = maskInputValue({
+        element: n,
+        type: getInputType(n),
+        tagName,
+        value,
+        maskInputOptions,
+        maskInputFn
+      });
+    } else if (checked) {
+      attributes.checked = checked;
+    }
+  }
+  if (tagName === "option") {
+    if (n.selected && !maskInputOptions.select) {
+      attributes.selected = true;
+    } else {
+      attributes.selected = undefined;
+    }
+  }
+  if (tagName === "dialog" && n.open) {
+    attributes.rr_open_mode = n.matches("dialog:modal") ? "modal" : "non-modal";
+  }
+  if (tagName === "canvas" && recordCanvas) {
+    if (n.__context === "2d") {
+      if (!is2DCanvasBlank(n)) {
+        attributes.rr_dataURL = n.toDataURL(dataURLOptions.type, dataURLOptions.quality);
+      }
+    } else if (!("__context" in n)) {
+      const canvasDataURL = n.toDataURL(dataURLOptions.type, dataURLOptions.quality);
+      const blankCanvas = doc.createElement("canvas");
+      blankCanvas.width = n.width;
+      blankCanvas.height = n.height;
+      const blankCanvasDataURL = blankCanvas.toDataURL(dataURLOptions.type, dataURLOptions.quality);
+      if (canvasDataURL !== blankCanvasDataURL) {
+        attributes.rr_dataURL = canvasDataURL;
+      }
+    }
+  }
+  if (tagName === "img" && inlineImages) {
+    if (!canvasService) {
+      canvasService = doc.createElement("canvas");
+      canvasCtx = canvasService.getContext("2d");
+    }
+    const image = n;
+    const imageSrc = image.currentSrc || image.getAttribute("src") || "<unknown-src>";
+    const priorCrossOrigin = image.crossOrigin;
+    const recordInlineImage = () => {
+      image.removeEventListener("load", recordInlineImage);
+      try {
+        canvasService.width = image.naturalWidth;
+        canvasService.height = image.naturalHeight;
+        canvasCtx?.drawImage(image, 0, 0);
+        attributes.rr_dataURL = canvasService?.toDataURL(dataURLOptions.type, dataURLOptions.quality);
+      } catch (err) {
+        if (image.crossOrigin !== "anonymous") {
+          image.crossOrigin = "anonymous";
+          if (image.complete && image.naturalWidth !== 0)
+            recordInlineImage();
+          else
+            image.addEventListener("load", recordInlineImage);
+          return;
+        }
+        console.warn(`Cannot inline img src=${imageSrc}! Error: ${err}`);
+      }
+      if (image.crossOrigin === "anonymous") {
+        priorCrossOrigin ? attributes.crossOrigin = priorCrossOrigin : image.removeAttribute("crossorigin");
+      }
+    };
+    if (image.complete && image.naturalWidth !== 0)
+      recordInlineImage();
+    else
+      image.addEventListener("load", recordInlineImage);
+  }
+  if (tagName === "audio" || tagName === "video") {
+    const mediaAttributes = attributes;
+    mediaAttributes.rr_mediaState = n.paused ? "paused" : "played";
+    mediaAttributes.rr_mediaCurrentTime = n.currentTime;
+    mediaAttributes.rr_mediaPlaybackRate = n.playbackRate;
+    mediaAttributes.rr_mediaMuted = n.muted;
+    mediaAttributes.rr_mediaLoop = n.loop;
+    mediaAttributes.rr_mediaVolume = n.volume;
+  }
+  if (!newlyAddedElement) {
+    if (n.scrollLeft) {
+      attributes.rr_scrollLeft = n.scrollLeft;
+    }
+    if (n.scrollTop) {
+      attributes.rr_scrollTop = n.scrollTop;
+    }
+  }
+  if (needBlock) {
+    const { width, height } = n.getBoundingClientRect();
+    attributes = {
+      class: attributes.class ?? null,
+      rr_width: `${width}px`,
+      rr_height: `${height}px`
+    };
+  }
+  if (tagName === "iframe" && !keepIframeSrcFn(attributes.src)) {
+    if (!n.contentDocument) {
+      attributes.rr_src = attributes.src ?? null;
+    }
+    attributes.src = undefined;
+  }
+  let isCustomElement;
+  try {
+    if (customElements.get(tagName))
+      isCustomElement = true;
+  } catch (_e) {}
+  return {
+    type: 2 /* Element */,
+    tagName,
+    attributes,
+    childNodes: [],
+    isSVG: isSVGElement(n) || undefined,
+    needBlock,
+    rootId,
+    isCustom: isCustomElement
+  };
+}
+function lowerIfExists(maybeAttr) {
+  if (maybeAttr === undefined || maybeAttr === null) {
+    return "";
+  }
+  return maybeAttr.toLowerCase();
+}
+function slimDOMExcluded(sn, slimDOMOptions) {
+  if (slimDOMOptions.comment && sn.type === 5 /* Comment */) {
+    return true;
+  }
+  if (sn.type === 2 /* Element */) {
+    if (slimDOMOptions.script && (sn.tagName === "script" || sn.tagName === "link" && (sn.attributes.rel === "preload" || sn.attributes.rel === "modulepreload") && sn.attributes.as === "script" || sn.tagName === "link" && sn.attributes.rel === "prefetch" && typeof sn.attributes.href === "string" && extractFileExtension(sn.attributes.href) === "js")) {
+      return true;
+    }
+    if (slimDOMOptions.headFavicon && (sn.tagName === "link" && sn.attributes.rel === "shortcut icon" || sn.tagName === "meta" && (lowerIfExists(sn.attributes.name).match(/^msapplication-tile(image|color)$/) || lowerIfExists(sn.attributes.name) === "application-name" || lowerIfExists(sn.attributes.rel) === "icon" || lowerIfExists(sn.attributes.rel) === "apple-touch-icon" || lowerIfExists(sn.attributes.rel) === "shortcut icon"))) {
+      return true;
+    }
+    if (sn.tagName === "meta") {
+      if (slimDOMOptions.headMetaDescKeywords && lowerIfExists(sn.attributes.name).match(/^description|keywords$/)) {
+        return true;
+      }
+      if (slimDOMOptions.headMetaSocial && (lowerIfExists(sn.attributes.property).match(/^(og|twitter|fb):/) || lowerIfExists(sn.attributes.name).match(/^(og|twitter):/) || lowerIfExists(sn.attributes.name) === "pinterest")) {
+        return true;
+      }
+      if (slimDOMOptions.headMetaRobots && (lowerIfExists(sn.attributes.name) === "robots" || lowerIfExists(sn.attributes.name) === "googlebot" || lowerIfExists(sn.attributes.name) === "bingbot")) {
+        return true;
+      }
+      if (slimDOMOptions.headMetaHttpEquiv && sn.attributes["http-equiv"] !== undefined) {
+        return true;
+      }
+      if (slimDOMOptions.headMetaAuthorship && (lowerIfExists(sn.attributes.name) === "author" || lowerIfExists(sn.attributes.name) === "generator" || lowerIfExists(sn.attributes.name) === "framework" || lowerIfExists(sn.attributes.name) === "publisher" || lowerIfExists(sn.attributes.name) === "progid" || lowerIfExists(sn.attributes.property).match(/^article:/) || lowerIfExists(sn.attributes.property).match(/^product:/))) {
+        return true;
+      }
+      if (slimDOMOptions.headMetaVerification && (lowerIfExists(sn.attributes.name) === "google-site-verification" || lowerIfExists(sn.attributes.name) === "yandex-verification" || lowerIfExists(sn.attributes.name) === "csrf-token" || lowerIfExists(sn.attributes.name) === "p:domain_verify" || lowerIfExists(sn.attributes.name) === "verify-v1" || lowerIfExists(sn.attributes.name) === "verification" || lowerIfExists(sn.attributes.name) === "shopify-checkout-api-token")) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function serializeNodeWithId(n, options) {
+  const {
+    doc,
+    mirror,
+    blockClass,
+    blockSelector,
+    maskTextClass,
+    maskTextSelector,
+    skipChild = false,
+    inlineStylesheet = true,
+    maskInputOptions = {},
+    maskTextFn,
+    maskInputFn,
+    slimDOMOptions,
+    dataURLOptions = {},
+    inlineImages = false,
+    recordCanvas = false,
+    onSerialize,
+    onIframeLoad,
+    iframeLoadTimeout = 5000,
+    onStylesheetLoad,
+    stylesheetLoadTimeout = 5000,
+    keepIframeSrcFn = () => false,
+    newlyAddedElement = false,
+    cssCaptured = false,
+    _parentPath,
+    _childIndex
+  } = options;
+  let { needsMask } = options;
+  let { preserveWhiteSpace = true } = options;
+  if (!needsMask) {
+    const checkAncestors = needsMask === undefined;
+    needsMask = needMaskingText(n, maskTextClass, maskTextSelector, checkAncestors);
+  }
+  const _serializedNode = serializeNode(n, {
+    doc,
+    mirror,
+    blockClass,
+    blockSelector,
+    needsMask,
+    inlineStylesheet,
+    maskInputOptions,
+    maskTextFn,
+    maskInputFn,
+    dataURLOptions,
+    inlineImages,
+    recordCanvas,
+    keepIframeSrcFn,
+    newlyAddedElement,
+    cssCaptured
+  });
+  if (!_serializedNode) {
+    console.warn(n, "not serialized");
+    return null;
+  }
+  let path;
+  if (_parentPath !== undefined && _childIndex !== undefined) {
+    path = _parentPath === "" ? `${_childIndex}` : `${_parentPath}.${_childIndex}`;
+  } else if (mirror.hasNode(n)) {
+    path = mirror.getPath(n);
+  } else {
+    path = mirror.computePath(n);
+  }
+  if (!mirror.hasNode(n) && (slimDOMExcluded(_serializedNode, slimDOMOptions) || !preserveWhiteSpace && _serializedNode.type === 3 /* Text */ && !_serializedNode.textContent.replace(/^\s+|\s+$/gm, "").length)) {
+    mirror.setPath(n, IGNORED_PATH);
+    mirror.setMeta(n, { ..._serializedNode, path: IGNORED_PATH });
+    return null;
+  }
+  const serializedNode = Object.assign(_serializedNode, { path });
+  mirror.setPath(n, path);
+  mirror.setMeta(n, serializedNode);
+  if (onSerialize) {
+    onSerialize(n);
+  }
+  let recordChild = !skipChild;
+  if (serializedNode.type === 2 /* Element */) {
+    recordChild = recordChild && !serializedNode.needBlock;
+    serializedNode.needBlock = undefined;
+    const shadowRootEl = dom_default.shadowRoot(n);
+    if (shadowRootEl && isNativeShadowDom(shadowRootEl))
+      serializedNode.isShadowHost = true;
+  }
+  if ((serializedNode.type === 0 /* Document */ || serializedNode.type === 2 /* Element */) && recordChild) {
+    if (slimDOMOptions.headWhitespace && serializedNode.type === 2 /* Element */ && serializedNode.tagName === "head") {
+      preserveWhiteSpace = false;
+    }
+    const bypassOptions = {
+      doc,
+      mirror,
+      blockClass,
+      blockSelector,
+      needsMask,
+      maskTextClass,
+      maskTextSelector,
+      skipChild,
+      inlineStylesheet,
+      maskInputOptions,
+      maskTextFn,
+      maskInputFn,
+      slimDOMOptions,
+      dataURLOptions,
+      inlineImages,
+      recordCanvas,
+      preserveWhiteSpace,
+      onSerialize,
+      onIframeLoad,
+      iframeLoadTimeout,
+      onStylesheetLoad,
+      stylesheetLoadTimeout,
+      keepIframeSrcFn,
+      cssCaptured: false,
+      _parentPath: path,
+      _childIndex: 0
+    };
+    if (serializedNode.type === 2 /* Element */ && serializedNode.tagName === "textarea" && serializedNode.attributes?.value !== undefined) {} else {
+      if (serializedNode.type === 2 /* Element */ && serializedNode.attributes?._cssText !== undefined && typeof serializedNode.attributes._cssText === "string") {
+        bypassOptions.cssCaptured = true;
+      }
+      let childIndex = 0;
+      for (const childN of Array.from(dom_default.childNodes(n))) {
+        bypassOptions._childIndex = childIndex;
+        const serializedChildNode = serializeNodeWithId(childN, bypassOptions);
+        if (serializedChildNode) {
+          if (!serializedNode.childNodes)
+            serializedNode.childNodes = [];
+          serializedNode.childNodes.push(serializedChildNode);
+        }
+        childIndex++;
+      }
+    }
+    let shadowRootEl = null;
+    if (isElement(n) && (shadowRootEl = dom_default.shadowRoot(n))) {
+      let shadowChildIndex = dom_default.childNodes(n).length;
+      for (const childN of Array.from(dom_default.childNodes(shadowRootEl))) {
+        bypassOptions._childIndex = shadowChildIndex;
+        const serializedChildNode = serializeNodeWithId(childN, bypassOptions);
+        if (serializedChildNode) {
+          isNativeShadowDom(shadowRootEl) && (serializedChildNode.isShadow = true);
+          if (!serializedNode.childNodes)
+            serializedNode.childNodes = [];
+          serializedNode.childNodes.push(serializedChildNode);
+        }
+        shadowChildIndex++;
+      }
+    }
+  }
+  const parent = dom_default.parentNode(n);
+  if (parent && isShadowRoot(parent) && isNativeShadowDom(parent)) {
+    serializedNode.isShadow = true;
+  }
+  if (serializedNode.type === 2 /* Element */ && serializedNode.tagName === "iframe") {
+    onceIframeLoaded(n, () => {
+      const iframeDoc = n.contentDocument;
+      if (iframeDoc && onIframeLoad) {
+        const serializedIframeNode = serializeNodeWithId(iframeDoc, {
+          doc: iframeDoc,
+          mirror,
+          blockClass,
+          blockSelector,
+          needsMask,
+          maskTextClass,
+          maskTextSelector,
+          skipChild: false,
+          inlineStylesheet,
+          maskInputOptions,
+          maskTextFn,
+          maskInputFn,
+          slimDOMOptions,
+          dataURLOptions,
+          inlineImages,
+          recordCanvas,
+          preserveWhiteSpace,
+          onSerialize,
+          onIframeLoad,
+          iframeLoadTimeout,
+          onStylesheetLoad,
+          stylesheetLoadTimeout,
+          keepIframeSrcFn
+        });
+        if (serializedIframeNode) {
+          onIframeLoad(n, serializedIframeNode);
+        }
+      }
+    }, iframeLoadTimeout);
+  }
+  if (serializedNode.type === 2 /* Element */ && serializedNode.tagName === "link" && typeof serializedNode.attributes?.rel === "string" && (serializedNode.attributes.rel === "stylesheet" || serializedNode.attributes.rel === "preload" && typeof serializedNode.attributes.href === "string" && extractFileExtension(serializedNode.attributes.href) === "css")) {
+    onceStylesheetLoaded(n, () => {
+      if (onStylesheetLoad) {
+        const serializedLinkNode = serializeNodeWithId(n, {
+          doc,
+          mirror,
+          blockClass,
+          blockSelector,
+          needsMask,
+          maskTextClass,
+          maskTextSelector,
+          skipChild: false,
+          inlineStylesheet,
+          maskInputOptions,
+          maskTextFn,
+          maskInputFn,
+          slimDOMOptions,
+          dataURLOptions,
+          inlineImages,
+          recordCanvas,
+          preserveWhiteSpace,
+          onSerialize,
+          onIframeLoad,
+          iframeLoadTimeout,
+          onStylesheetLoad,
+          stylesheetLoadTimeout,
+          keepIframeSrcFn
+        });
+        if (serializedLinkNode) {
+          onStylesheetLoad(n, serializedLinkNode);
+        }
+      }
+    }, stylesheetLoadTimeout);
+  }
+  return serializedNode;
+}
+function snapshot(n, options) {
+  const {
+    mirror = new PathMirror,
+    blockClass = "rr-block",
+    blockSelector = null,
+    maskTextClass = "rr-mask",
+    maskTextSelector = null,
+    inlineStylesheet = true,
+    inlineImages = false,
+    recordCanvas = false,
+    maskAllInputs = true,
+    maskTextFn,
+    maskInputFn,
+    slimDOM = false,
+    dataURLOptions,
+    preserveWhiteSpace,
+    onSerialize,
+    onIframeLoad,
+    iframeLoadTimeout,
+    onStylesheetLoad,
+    stylesheetLoadTimeout,
+    keepIframeSrcFn = () => false
+  } = options || {};
+  const maskInputOptions = maskAllInputs === true ? {
+    color: true,
+    date: true,
+    "datetime-local": true,
+    email: true,
+    month: true,
+    number: true,
+    range: true,
+    search: true,
+    tel: true,
+    text: true,
+    time: true,
+    url: true,
+    week: true,
+    textarea: true,
+    select: true,
+    password: true
+  } : maskAllInputs === false ? {
+    password: true
+  } : maskAllInputs;
+  const slimDOMOptions = slimDOM === true || slimDOM === "all" ? {
+    script: true,
+    comment: true,
+    headFavicon: true,
+    headWhitespace: true,
+    headMetaDescKeywords: slimDOM === "all",
+    headMetaSocial: true,
+    headMetaRobots: true,
+    headMetaHttpEquiv: true,
+    headMetaAuthorship: true,
+    headMetaVerification: true
+  } : slimDOM === false ? {} : slimDOM;
+  return serializeNodeWithId(n, {
+    doc: n,
+    mirror,
+    blockClass,
+    blockSelector,
+    maskTextClass,
+    maskTextSelector,
+    skipChild: false,
+    inlineStylesheet,
+    maskInputOptions,
+    maskTextFn,
+    maskInputFn,
+    slimDOMOptions,
+    dataURLOptions,
+    inlineImages,
+    recordCanvas,
+    preserveWhiteSpace,
+    onSerialize,
+    onIframeLoad,
+    iframeLoadTimeout,
+    onStylesheetLoad,
+    stylesheetLoadTimeout,
+    keepIframeSrcFn,
+    newlyAddedElement: false
+  });
+}
+var tagNameRegex, canvasService, canvasCtx, SRCSET_NOT_SPACES, SRCSET_COMMAS_OR_SPACES, cachedDocument, snapshot_default;
+var init_snapshot = __esm(() => {
+  init_src();
+  init_dom();
+  init_redact_pii();
+  init_snapshot_utils();
+  tagNameRegex = /[^a-z0-9-_:]/;
+  SRCSET_NOT_SPACES = /^[^ \t\n\r\u000c]+/;
+  SRCSET_COMMAS_OR_SPACES = /^[, \t\n\r\u000c]+/;
+  cachedDocument = new WeakMap;
+  snapshot_default = snapshot;
+});
+
+// ../rrweb-record/src/utils.ts
+function on(type, fn, target = document) {
+  const options = { capture: true, passive: true };
+  target.addEventListener(type, fn, options);
+  return () => target.removeEventListener(type, fn, options);
+}
+function throttle(func, wait, options = {}) {
+  let timeout = null;
+  let previous = 0;
+  return (...args) => {
+    const now = Date.now();
+    if (!previous && options.leading === false) {
+      previous = now;
+    }
+    const remaining = wait - (now - previous);
+    if (remaining <= 0 || remaining > wait) {
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = null;
+      }
+      previous = now;
+      func(args[0]);
+    } else if (!timeout && options.trailing !== false) {
+      timeout = setTimeout(() => {
+        previous = options.leading === false ? 0 : Date.now();
+        timeout = null;
+        func(args[0]);
+      }, remaining);
+    }
+  };
+}
+function hookSetter(target, key, d, isRevoked, win = window) {
+  const original = win.Object.getOwnPropertyDescriptor(target, key);
+  win.Object.defineProperty(target, key, isRevoked ? d : {
+    set(value) {
+      setTimeout(() => {
+        d.set?.call(this, value);
+      }, 0);
+      if (original?.set) {
+        original.set.call(this, value);
+      }
+    }
+  });
+  return () => hookSetter(target, key, original || {}, true);
+}
+function patch(source, name, replacement) {
+  try {
+    if (!(name in source)) {
+      return () => {};
+    }
+    const original = source[name];
+    const wrapped = replacement(original);
+    if (typeof wrapped === "function") {
+      wrapped.prototype = wrapped.prototype || {};
+      Object.defineProperties(wrapped, {
+        __rrweb_original__: {
+          enumerable: false,
+          value: original
+        }
+      });
+    }
+    source[name] = wrapped;
+    return () => {
+      source[name] = original;
+    };
+  } catch {
+    return () => {};
+  }
+}
+function getWindowScroll(win) {
+  const doc = win.document;
+  return {
+    left: doc.scrollingElement ? doc.scrollingElement.scrollLeft : win.pageXOffset !== undefined ? win.pageXOffset : doc.documentElement.scrollLeft || doc?.body && dom_default.parentElement(doc.body)?.scrollLeft || doc?.body?.scrollLeft || 0,
+    top: doc.scrollingElement ? doc.scrollingElement.scrollTop : win.pageYOffset !== undefined ? win.pageYOffset : doc?.documentElement.scrollTop || doc?.body && dom_default.parentElement(doc.body)?.scrollTop || doc?.body?.scrollTop || 0
+  };
+}
+function getWindowHeight() {
+  return window.innerHeight || document.documentElement?.clientHeight || document.body?.clientHeight;
+}
+function getWindowWidth() {
+  return window.innerWidth || document.documentElement?.clientWidth || document.body?.clientWidth;
+}
+function closestElementOfNode(node) {
+  if (!node) {
+    return null;
+  }
+  const el = node.nodeType === node.ELEMENT_NODE ? node : dom_default.parentElement(node);
+  return el;
+}
+function isBlocked(node, blockClass, blockSelector, checkAncestors) {
+  if (!node) {
+    return false;
+  }
+  const el = closestElementOfNode(node);
+  if (!el) {
+    return false;
+  }
+  try {
+    if (typeof blockClass === "string") {
+      if (el.classList.contains(blockClass))
+        return true;
+      if (checkAncestors && el.closest(`.${blockClass}`) !== null)
+        return true;
+    } else {
+      if (classMatchesRegex(el, blockClass, checkAncestors))
+        return true;
+    }
+  } catch (_e) {}
+  if (blockSelector) {
+    if (el.matches(blockSelector))
+      return true;
+    if (checkAncestors && el.closest(blockSelector) !== null)
+      return true;
+  }
+  return false;
+}
+function isSerialized(n, mirror) {
+  return mirror.isSerialized(n);
+}
+function isIgnored(n, mirror, slimDOMOptions) {
+  if (n.tagName === "TITLE" && slimDOMOptions.headTitleMutations) {
+    return true;
+  }
+  return mirror.isIgnored(n);
+}
+function isAncestorRemoved(target, mirror) {
+  if (isShadowRoot(target)) {
+    return false;
+  }
+  if (!mirror.isSerialized(target)) {
+    return true;
+  }
+  const parent = dom_default.parentNode(target);
+  if (parent && parent.nodeType === target.DOCUMENT_NODE) {
+    return false;
+  }
+  if (!parent) {
+    return true;
+  }
+  return isAncestorRemoved(parent, mirror);
+}
+function legacy_isTouchEvent(event) {
+  return Boolean(event.changedTouches);
+}
+function isSerializedIframe(n, mirror) {
+  return Boolean(n.nodeName === "IFRAME" && mirror.getMeta(n));
+}
+function isSerializedStylesheet(n, mirror) {
+  return Boolean(n.nodeName === "LINK" && n.nodeType === n.ELEMENT_NODE && n.getAttribute && n.getAttribute("rel") === "stylesheet" && mirror.getMeta(n));
+}
+function hasShadowRoot(n) {
+  if (!n)
+    return false;
+  if (typeof n.RRNodeType === "number" && "shadowRoot" in n) {
+    return Boolean(n.shadowRoot);
+  }
+  return Boolean(dom_default.shadowRoot(n));
+}
+
+class StyleSheetMirror {
+  id = 1;
+  styleIDMap = new WeakMap;
+  idStyleMap = new Map;
+  getId(stylesheet) {
+    return this.styleIDMap.get(stylesheet) ?? -1;
+  }
+  has(stylesheet) {
+    return this.styleIDMap.has(stylesheet);
+  }
+  add(stylesheet, id) {
+    if (this.has(stylesheet))
+      return this.getId(stylesheet);
+    let newId;
+    if (id === undefined) {
+      newId = this.id++;
+    } else
+      newId = id;
+    this.styleIDMap.set(stylesheet, newId);
+    this.idStyleMap.set(newId, stylesheet);
+    return newId;
+  }
+  getStyle(id) {
+    return this.idStyleMap.get(id) || null;
+  }
+  reset() {
+    this.styleIDMap = new WeakMap;
+    this.idStyleMap = new Map;
+    this.id = 1;
+  }
+  generateId() {
+    return this.id++;
+  }
+}
+function getShadowHost(n) {
+  let shadowHost = null;
+  if ("getRootNode" in n && dom_default.getRootNode(n)?.nodeType === Node.DOCUMENT_FRAGMENT_NODE && dom_default.host(dom_default.getRootNode(n)))
+    shadowHost = dom_default.host(dom_default.getRootNode(n));
+  return shadowHost;
+}
+function getRootShadowHost(n) {
+  let rootShadowHost = n;
+  let shadowHost;
+  while (shadowHost = getShadowHost(rootShadowHost))
+    rootShadowHost = shadowHost;
+  return rootShadowHost;
+}
+function shadowHostInDom(n) {
+  const doc = n.ownerDocument;
+  if (!doc)
+    return false;
+  const shadowHost = getRootShadowHost(n);
+  return dom_default.contains(doc, shadowHost);
+}
+function inDom(n) {
+  const doc = n.ownerDocument;
+  if (!doc)
+    return false;
+  return dom_default.contains(doc, n) || shadowHostInDom(n);
+}
+var nowTimestamp;
+var init_utils = __esm(() => {
+  init_dom();
+  init_snapshot();
+  init_snapshot_utils();
+  nowTimestamp = Date.now;
+  if (!/* @__PURE__ */ /[1-9][0-9]{12}/.test(Date.now().toString())) {
+    nowTimestamp = () => Date.now();
+  }
+});
+
+// ../rrweb-record/src/record/error-handler.ts
+function registerErrorHandler(handler) {
+  errorHandler = handler;
+}
+function unregisterErrorHandler() {
+  errorHandler = undefined;
+}
+var errorHandler, callbackWrapper = (cb) => {
+  if (!errorHandler) {
+    return cb;
+  }
+  const rrwebWrapped = (...rest) => {
+    try {
+      return cb(...rest);
+    } catch (error) {
+      if (errorHandler && errorHandler(error) === true) {
+        return;
+      }
+      throw error;
+    }
+  };
+  return rrwebWrapped;
+};
+
+// ../rrweb-record/src/record/observers/font-observer.ts
+var exports_font_observer = {};
+__export(exports_font_observer, {
+  initFontObserver: () => initFontObserver
+});
+function initFontObserver({ fontCb, doc }) {
+  const win = doc.defaultView;
+  if (!win) {
+    return () => {};
+  }
+  const handlers = [];
+  const fontMap = new WeakMap;
+  const originalFontFace = win.FontFace;
+  win.FontFace = function FontFace(family, source, descriptors) {
+    const fontFace = new originalFontFace(family, source, descriptors);
+    fontMap.set(fontFace, {
+      family,
+      buffer: typeof source !== "string",
+      descriptors,
+      fontSource: typeof source === "string" ? source : JSON.stringify(Array.from(new Uint8Array(source instanceof ArrayBuffer ? source : source.buffer)))
+    });
+    return fontFace;
+  };
+  const restoreHandler = patch(doc.fonts, "add", (original) => function(fontFace) {
+    setTimeout(callbackWrapper(() => {
+      const p = fontMap.get(fontFace);
+      if (p) {
+        fontCb(p);
+        fontMap.delete(fontFace);
+      }
+    }), 0);
+    return original.apply(this, [fontFace]);
+  });
+  handlers.push(() => {
+    win.FontFace = originalFontFace;
+  });
+  handlers.push(restoreHandler);
+  return callbackWrapper(() => {
+    handlers.forEach((h) => h());
+  });
+}
+var init_font_observer = __esm(() => {
+  init_utils();
+});
+
+// ../../node_modules/.bun/base64-arraybuffer@1.0.2/node_modules/base64-arraybuffer/dist/base64-arraybuffer.es5.js
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", lookup, i, encode = function(arraybuffer) {
+  var bytes = new Uint8Array(arraybuffer), i2, len = bytes.length, base64 = "";
+  for (i2 = 0;i2 < len; i2 += 3) {
+    base64 += chars[bytes[i2] >> 2];
+    base64 += chars[(bytes[i2] & 3) << 4 | bytes[i2 + 1] >> 4];
+    base64 += chars[(bytes[i2 + 1] & 15) << 2 | bytes[i2 + 2] >> 6];
+    base64 += chars[bytes[i2 + 2] & 63];
+  }
+  if (len % 3 === 2) {
+    base64 = base64.substring(0, base64.length - 1) + "=";
+  } else if (len % 3 === 1) {
+    base64 = base64.substring(0, base64.length - 2) + "==";
+  }
+  return base64;
+};
+var init_base64_arraybuffer_es5 = __esm(() => {
+  lookup = typeof Uint8Array === "undefined" ? [] : new Uint8Array(256);
+  for (i = 0;i < chars.length; i++) {
+    lookup[chars.charCodeAt(i)] = i;
+  }
+});
+
+// ../rrweb-record/src/record/observers/canvas/serialize-args.ts
+function variableListFor(ctx, ctor) {
+  let contextMap = canvasVarMap.get(ctx);
+  if (!contextMap) {
+    contextMap = new Map;
+    canvasVarMap.set(ctx, contextMap);
+  }
+  if (!contextMap.has(ctor)) {
+    contextMap.set(ctor, []);
+  }
+  return contextMap.get(ctor);
+}
+function serializeArg(value, win, ctx) {
+  if (Array.isArray(value)) {
+    return value.map((arg) => serializeArg(arg, win, ctx));
+  }
+  if (value === null) {
+    return value;
+  }
+  if (value instanceof Float32Array || value instanceof Float64Array || value instanceof Int32Array || value instanceof Uint32Array || value instanceof Uint8Array || value instanceof Uint16Array || value instanceof Int16Array || value instanceof Int8Array || value instanceof Uint8ClampedArray) {
+    const name = value.constructor.name;
+    return {
+      rr_type: name,
+      args: [Object.values(value)]
+    };
+  }
+  if (value instanceof ArrayBuffer) {
+    const name = value.constructor.name;
+    const base64 = encode(value);
+    return {
+      rr_type: name,
+      base64
+    };
+  }
+  if (value instanceof DataView) {
+    const name = value.constructor.name;
+    return {
+      rr_type: name,
+      args: [serializeArg(value.buffer, win, ctx), value.byteOffset, value.byteLength]
+    };
+  }
+  if (value instanceof HTMLImageElement) {
+    const name = value.constructor.name;
+    const { src } = value;
+    return {
+      rr_type: name,
+      src
+    };
+  }
+  if (value instanceof HTMLCanvasElement) {
+    const name = "HTMLImageElement";
+    const src = value.toDataURL();
+    return {
+      rr_type: name,
+      src
+    };
+  }
+  if (value instanceof ImageData) {
+    const name = value.constructor.name;
+    return {
+      rr_type: name,
+      args: [serializeArg(value.data, win, ctx), value.width, value.height]
+    };
+  }
+  if (isInstanceOfWebGLObject(value, win) || typeof value === "object") {
+    const name = value.constructor.name;
+    const index = saveWebGLVar(value, win, ctx);
+    return {
+      rr_type: name,
+      index
+    };
+  }
+  return value;
+}
+var canvasVarMap, saveWebGLVar = (value, win, ctx) => {
+  if (!value || !(isInstanceOfWebGLObject(value, win) || typeof value === "object"))
+    return;
+  const name = value.constructor.name;
+  const list = variableListFor(ctx, name);
+  let index = list.indexOf(value);
+  if (index === -1) {
+    index = list.length;
+    list.push(value);
+  }
+  return index;
+}, serializeArgs = (args, win, ctx) => {
+  return args.map((arg) => serializeArg(arg, win, ctx));
+}, isInstanceOfWebGLObject = (value, win) => {
+  const webGLConstructorNames = [
+    "WebGLActiveInfo",
+    "WebGLBuffer",
+    "WebGLFramebuffer",
+    "WebGLProgram",
+    "WebGLRenderbuffer",
+    "WebGLShader",
+    "WebGLShaderPrecisionFormat",
+    "WebGLTexture",
+    "WebGLUniformLocation",
+    "WebGLVertexArrayObject",
+    "WebGLVertexArrayObjectOES"
+  ];
+  const supportedWebGLConstructorNames = webGLConstructorNames.filter((name) => typeof win[name] === "function");
+  return Boolean(supportedWebGLConstructorNames.find((name) => value instanceof win[name]));
+};
+var init_serialize_args = __esm(() => {
+  init_base64_arraybuffer_es5();
+  canvasVarMap = new Map;
+});
+
+// ../rrweb-record/src/record/observers/canvas/2d.ts
+function initCanvas2DMutationObserver(cb, win, blockClass, blockSelector) {
+  const handlers = [];
+  const props2D = Object.getOwnPropertyNames(win.CanvasRenderingContext2D.prototype);
+  for (const prop of props2D) {
+    try {
+      if (typeof win.CanvasRenderingContext2D.prototype[prop] !== "function") {
+        continue;
+      }
+      const restoreHandler = patch(win.CanvasRenderingContext2D.prototype, prop, (original) => function(...args) {
+        if (!isBlocked(this.canvas, blockClass, blockSelector, true)) {
+          setTimeout(() => {
+            const recordArgs = serializeArgs(args, win, this);
+            cb(this.canvas, {
+              type: 0 /* 2D */,
+              property: prop,
+              args: recordArgs
+            });
+          }, 0);
+        }
+        return original.apply(this, args);
+      });
+      handlers.push(restoreHandler);
+    } catch {
+      const hookHandler = hookSetter(win.CanvasRenderingContext2D.prototype, prop, {
+        set(v) {
+          cb(this.canvas, {
+            type: 0 /* 2D */,
+            property: prop,
+            args: [v],
+            setter: true
+          });
+        }
+      });
+      handlers.push(hookHandler);
+    }
+  }
+  return () => {
+    handlers.forEach((h) => h());
+  };
+}
+var init_2d = __esm(() => {
+  init_src();
+  init_utils();
+  init_serialize_args();
+});
+
+// ../rrweb-record/src/record/observers/canvas/canvas.ts
+function getNormalizedContextName(contextType) {
+  return contextType === "experimental-webgl" ? "webgl" : contextType;
+}
+function initCanvasContextObserver(win, blockClass, blockSelector, setPreserveDrawingBufferToTrue) {
+  const handlers = [];
+  try {
+    const restoreHandler = patch(win.HTMLCanvasElement.prototype, "getContext", (original) => function(contextType, ...args) {
+      if (!isBlocked(this, blockClass, blockSelector, true)) {
+        const ctxName = getNormalizedContextName(contextType);
+        if (!("__context" in this))
+          this.__context = ctxName;
+        if (setPreserveDrawingBufferToTrue && ["webgl", "webgl2"].includes(ctxName)) {
+          if (args[0] && typeof args[0] === "object") {
+            const contextAttributes = args[0];
+            if (!contextAttributes.preserveDrawingBuffer) {
+              contextAttributes.preserveDrawingBuffer = true;
+            }
+          } else {
+            args.splice(0, 1, {
+              preserveDrawingBuffer: true
+            });
+          }
+        }
+      }
+      return original.apply(this, [contextType, ...args]);
+    });
+    handlers.push(restoreHandler);
+  } catch {
+    console.error("failed to patch HTMLCanvasElement.prototype.getContext");
+  }
+  return () => {
+    handlers.forEach((h) => h());
+  };
+}
+var init_canvas = __esm(() => {
+  init_utils();
+});
+
+// ../rrweb-record/src/record/observers/canvas/webgl.ts
+function patchGLPrototype(prototype, type, cb, blockClass, blockSelector, win) {
+  const handlers = [];
+  const props = Object.getOwnPropertyNames(prototype);
+  for (const prop of props) {
+    if (["isContextLost", "canvas", "drawingBufferWidth", "drawingBufferHeight"].includes(prop)) {
+      continue;
+    }
+    try {
+      if (typeof prototype[prop] !== "function") {
+        continue;
+      }
+      const restoreHandler = patch(prototype, prop, (original) => function(...args) {
+        const result = original.apply(this, args);
+        saveWebGLVar(result, win, this);
+        if ("tagName" in this.canvas && !isBlocked(this.canvas, blockClass, blockSelector, true)) {
+          const recordArgs = serializeArgs(args, win, this);
+          const mutation = {
+            type,
+            property: prop,
+            args: recordArgs
+          };
+          cb(this.canvas, mutation);
+        }
+        return result;
+      });
+      handlers.push(restoreHandler);
+    } catch {
+      const hookHandler = hookSetter(prototype, prop, {
+        set(v) {
+          cb(this.canvas, {
+            type,
+            property: prop,
+            args: [v],
+            setter: true
+          });
+        }
+      });
+      handlers.push(hookHandler);
+    }
+  }
+  return handlers;
+}
+function initCanvasWebGLMutationObserver(cb, win, blockClass, blockSelector) {
+  const handlers = [];
+  handlers.push(...patchGLPrototype(win.WebGLRenderingContext.prototype, 1 /* WebGL */, cb, blockClass, blockSelector, win));
+  if (typeof win.WebGL2RenderingContext !== "undefined") {
+    handlers.push(...patchGLPrototype(win.WebGL2RenderingContext.prototype, 2 /* WebGL2 */, cb, blockClass, blockSelector, win));
+  }
+  return () => {
+    handlers.forEach((h) => h());
+  };
+}
+var init_webgl = __esm(() => {
+  init_src();
+  init_utils();
+  init_serialize_args();
+});
+
+// ../rrweb-record/src/record/observers/canvas/canvas-manager.ts
+var exports_canvas_manager = {};
+__export(exports_canvas_manager, {
+  CanvasManager: () => CanvasManager
+});
+
+class CanvasManager {
+  pendingCanvasMutations = new Map;
+  rafStamps = { latestId: 0, invokeId: null };
+  mirror;
+  mutationCb;
+  resetObservers;
+  frozen = false;
+  locked = false;
+  reset() {
+    this.pendingCanvasMutations.clear();
+    this.resetObservers?.();
+  }
+  freeze() {
+    this.frozen = true;
+  }
+  unfreeze() {
+    this.frozen = false;
+  }
+  lock() {
+    this.locked = true;
+  }
+  unlock() {
+    this.locked = false;
+  }
+  constructor(options) {
+    const {
+      sampling = "all",
+      win,
+      blockClass,
+      blockSelector,
+      recordCanvas,
+      dataURLOptions
+    } = options;
+    this.mutationCb = options.mutationCb;
+    this.mirror = options.mirror;
+    if (recordCanvas && sampling === "all")
+      this.initCanvasMutationObserver(win, blockClass, blockSelector);
+    if (recordCanvas && typeof sampling === "number")
+      this.initCanvasFPSObserver(sampling, win, blockClass, blockSelector, {
+        dataURLOptions
+      });
+  }
+  processMutation = (target, mutation) => {
+    const newFrame = this.rafStamps.invokeId && this.rafStamps.latestId !== this.rafStamps.invokeId;
+    if (newFrame || !this.rafStamps.invokeId)
+      this.rafStamps.invokeId = this.rafStamps.latestId;
+    if (!this.pendingCanvasMutations.has(target)) {
+      this.pendingCanvasMutations.set(target, []);
+    }
+    this.pendingCanvasMutations.get(target)?.push(mutation);
+  };
+  initCanvasFPSObserver(fps, win, blockClass, blockSelector, options) {
+    const canvasContextReset = initCanvasContextObserver(win, blockClass, blockSelector, true);
+    const snapshotInProgressMap = new Map;
+    let nextWorkerId = 1;
+    const workerIdToPath = new Map;
+    const worker = {
+      postMessage() {},
+      onmessage() {}
+    };
+    worker.onmessage = (e) => {
+      const workerPath = workerIdToPath.get(e.data.id) ?? "";
+      snapshotInProgressMap.set(workerPath, false);
+      if (!("base64" in e.data))
+        return;
+      const { base64, type, width, height } = e.data;
+      this.mutationCb({
+        path: workerPath,
+        type: 0 /* 2D */,
+        commands: [
+          {
+            property: "clearRect",
+            args: [0, 0, width, height]
+          },
+          {
+            property: "drawImage",
+            args: [
+              {
+                rr_type: "ImageBitmap",
+                args: [
+                  {
+                    rr_type: "Blob",
+                    data: [{ rr_type: "ArrayBuffer", base64 }],
+                    type
+                  }
+                ]
+              },
+              0,
+              0
+            ]
+          }
+        ]
+      });
+    };
+    const timeBetweenSnapshots = 1000 / fps;
+    let lastSnapshotTime = 0;
+    let rafId;
+    const getCanvas = () => {
+      const matchedCanvas = [];
+      win.document.querySelectorAll("canvas").forEach((canvas) => {
+        if (!isBlocked(canvas, blockClass, blockSelector, true)) {
+          matchedCanvas.push(canvas);
+        }
+      });
+      return matchedCanvas;
+    };
+    const takeCanvasSnapshots = (timestamp) => {
+      if (lastSnapshotTime && timestamp - lastSnapshotTime < timeBetweenSnapshots) {
+        rafId = requestAnimationFrame(takeCanvasSnapshots);
+        return;
+      }
+      lastSnapshotTime = timestamp;
+      getCanvas().forEach(async (canvas) => {
+        const canvasPath = this.mirror.getPath(canvas);
+        if (snapshotInProgressMap.get(canvasPath))
+          return;
+        if (canvas.width === 0 || canvas.height === 0)
+          return;
+        snapshotInProgressMap.set(canvasPath, true);
+        if (["webgl", "webgl2"].includes(canvas.__context)) {
+          const context = canvas.getContext(canvas.__context);
+          if (context?.getContextAttributes()?.preserveDrawingBuffer === false) {
+            context.clear(context.COLOR_BUFFER_BIT);
+          }
+        }
+        const bitmap = await createImageBitmap(canvas);
+        const workerId = nextWorkerId++;
+        workerIdToPath.set(workerId, canvasPath);
+        worker.postMessage({
+          id: workerId,
+          bitmap,
+          width: canvas.width,
+          height: canvas.height,
+          dataURLOptions: options.dataURLOptions
+        }, [bitmap]);
+      });
+      rafId = requestAnimationFrame(takeCanvasSnapshots);
+    };
+    rafId = requestAnimationFrame(takeCanvasSnapshots);
+    this.resetObservers = () => {
+      canvasContextReset();
+      cancelAnimationFrame(rafId);
+    };
+  }
+  initCanvasMutationObserver(win, blockClass, blockSelector) {
+    this.startRAFTimestamping();
+    this.startPendingCanvasMutationFlusher();
+    const canvasContextReset = initCanvasContextObserver(win, blockClass, blockSelector, false);
+    const canvas2DReset = initCanvas2DMutationObserver(this.processMutation.bind(this), win, blockClass, blockSelector);
+    const canvasWebGL1and2Reset = initCanvasWebGLMutationObserver(this.processMutation.bind(this), win, blockClass, blockSelector);
+    this.resetObservers = () => {
+      canvasContextReset();
+      canvas2DReset();
+      canvasWebGL1and2Reset();
+    };
+  }
+  startPendingCanvasMutationFlusher() {
+    requestAnimationFrame(() => this.flushPendingCanvasMutations());
+  }
+  startRAFTimestamping() {
+    const setLatestRAFTimestamp = (timestamp) => {
+      this.rafStamps.latestId = timestamp;
+      requestAnimationFrame(setLatestRAFTimestamp);
+    };
+    requestAnimationFrame(setLatestRAFTimestamp);
+  }
+  flushPendingCanvasMutations() {
+    this.pendingCanvasMutations.forEach((_values, canvas) => {
+      const canvasPath = this.mirror.getPath(canvas);
+      this.flushPendingCanvasMutationFor(canvas, canvasPath);
+    });
+    requestAnimationFrame(() => this.flushPendingCanvasMutations());
+  }
+  flushPendingCanvasMutationFor(canvas, path) {
+    if (this.frozen || this.locked) {
+      return;
+    }
+    const valuesWithType = this.pendingCanvasMutations.get(canvas);
+    if (!valuesWithType || !path)
+      return;
+    const values = valuesWithType.map((value) => {
+      const { type: type2, ...rest } = value;
+      return rest;
+    });
+    const { type } = valuesWithType[0];
+    this.mutationCb({ path, type, commands: values });
+    this.pendingCanvasMutations.delete(canvas);
+  }
+}
+var init_canvas_manager = __esm(() => {
+  init_src();
+  init_utils();
+  init_2d();
+  init_canvas();
+  init_webgl();
+});
+
+// ../rrweb-record/src/record/index.ts
+init_src();
+init_dom();
+init_snapshot();
+init_snapshot_utils();
+init_utils();
+
+// ../rrweb-record/src/record/iframe-manager.ts
+init_src();
+
+// ../rrweb-record/src/record/cross-origin-iframe-mirror.ts
+class CrossOriginIframeMirror {
+  generateIdFn;
+  iframeLocalToParentMap = new WeakMap;
+  iframeParentToLocalMap = new WeakMap;
+  constructor(generateIdFn) {
+    this.generateIdFn = generateIdFn;
+  }
+  getPath(iframe, remotePath, localToParentMap, parentToLocalMap) {
+    const l2p = localToParentMap || this.getLocalToParentMap(iframe);
+    const p2l = parentToLocalMap || this.getParentToLocalMap(iframe);
+    let parentPath = l2p.get(remotePath);
+    if (parentPath === undefined) {
+      parentPath = this.generateIdFn();
+      l2p.set(remotePath, parentPath);
+      p2l.set(parentPath, remotePath);
+    }
+    return parentPath;
+  }
+  getId = this.getPath;
+  getPaths(iframe, remotePaths) {
+    const l2p = this.getLocalToParentMap(iframe);
+    const p2l = this.getParentToLocalMap(iframe);
+    return remotePaths.map((p) => this.getPath(iframe, p, l2p, p2l));
+  }
+  getIds = this.getPaths;
+  getRemotePath(iframe, parentPath, map) {
+    const p2l = map || this.getParentToLocalMap(iframe);
+    if (typeof parentPath !== typeof this.generateIdFn())
+      return parentPath;
+    const remotePath = p2l.get(parentPath);
+    if (remotePath === undefined) {
+      return typeof parentPath === "string" ? "" : -1;
+    }
+    return remotePath;
+  }
+  getRemotePaths(iframe, parentPaths) {
+    const p2l = this.getParentToLocalMap(iframe);
+    return parentPaths.map((p) => this.getRemotePath(iframe, p, p2l));
+  }
+  getRemoteId = this.getRemotePath;
+  getRemoteIds = this.getRemotePaths;
+  reset(iframe) {
+    if (!iframe) {
+      this.iframeLocalToParentMap = new WeakMap;
+      this.iframeParentToLocalMap = new WeakMap;
+      return;
+    }
+    this.iframeLocalToParentMap.delete(iframe);
+    this.iframeParentToLocalMap.delete(iframe);
+  }
+  getLocalToParentMap(iframe) {
+    let map = this.iframeLocalToParentMap.get(iframe);
+    if (!map) {
+      map = new Map;
+      this.iframeLocalToParentMap.set(iframe, map);
+    }
+    return map;
+  }
+  getParentToLocalMap(iframe) {
+    let map = this.iframeParentToLocalMap.get(iframe);
+    if (!map) {
+      map = new Map;
+      this.iframeParentToLocalMap.set(iframe, map);
+    }
+    return map;
+  }
+}
+
+// ../rrweb-record/src/record/iframe-manager.ts
+var _crossOriginPathCounter = 1;
+function genCrossOriginPath() {
+  return `__xo_${_crossOriginPathCounter++}`;
+}
+
+class IframeManager {
+  iframes = new WeakMap;
+  crossOriginIframeMap = new WeakMap;
+  crossOriginIframeMirror = new CrossOriginIframeMirror(genCrossOriginPath);
+  crossOriginIframeStyleMirror;
+  crossOriginIframeRootIdMap = new WeakMap;
+  mirror;
+  mutationCb;
+  wrappedEmit;
+  loadListener;
+  stylesheetManager;
+  recordCrossOriginIframes;
+  constructor(options) {
+    this.mutationCb = options.mutationCb;
+    this.wrappedEmit = options.wrappedEmit;
+    this.stylesheetManager = options.stylesheetManager;
+    this.recordCrossOriginIframes = options.recordCrossOriginIframes;
+    this.crossOriginIframeStyleMirror = new CrossOriginIframeMirror(this.stylesheetManager.styleMirror.generateId.bind(this.stylesheetManager.styleMirror));
+    this.mirror = options.mirror;
+    if (this.recordCrossOriginIframes) {
+      window.addEventListener("message", this.handleMessage.bind(this));
+    }
+  }
+  addIframe(iframeEl) {
+    this.iframes.set(iframeEl, true);
+    if (iframeEl.contentWindow)
+      this.crossOriginIframeMap.set(iframeEl.contentWindow, iframeEl);
+  }
+  addLoadListener(cb) {
+    this.loadListener = cb;
+  }
+  attachIframe(iframeEl, childSn) {
+    this.mutationCb({
+      adds: [
+        {
+          parentPath: this.mirror.getPath(iframeEl),
+          nextPath: null,
+          node: childSn
+        }
+      ],
+      removes: [],
+      texts: [],
+      attributes: [],
+      isAttachIframe: true
+    });
+    if (this.recordCrossOriginIframes)
+      iframeEl.contentWindow?.addEventListener("message", this.handleMessage.bind(this));
+    this.loadListener?.(iframeEl);
+    if (iframeEl.contentDocument?.adoptedStyleSheets && iframeEl.contentDocument.adoptedStyleSheets.length > 0)
+      this.stylesheetManager.adoptStyleSheets(iframeEl.contentDocument.adoptedStyleSheets, this.mirror.getPath(iframeEl.contentDocument));
+  }
+  handleMessage(message) {
+    const crossOriginMessageEvent = message;
+    if (crossOriginMessageEvent.data.type !== "rrweb" || crossOriginMessageEvent.origin !== crossOriginMessageEvent.data.origin)
+      return;
+    const iframeSourceWindow = message.source;
+    if (!iframeSourceWindow)
+      return;
+    const iframeEl = this.crossOriginIframeMap.get(message.source);
+    if (!iframeEl)
+      return;
+    const transformedEvent = this.transformCrossOriginEvent(iframeEl, crossOriginMessageEvent.data.event);
+    if (transformedEvent)
+      this.wrappedEmit(transformedEvent, crossOriginMessageEvent.data.isCheckout);
+  }
+  transformCrossOriginEvent(iframeEl, e) {
+    switch (e.type) {
+      case 7 /* Pageview */: {
+        this.crossOriginIframeMirror.reset(iframeEl);
+        this.crossOriginIframeStyleMirror.reset(iframeEl);
+        this.replacePathOnNode(e.data.node, iframeEl);
+        const pvRootPath = e.data.node.path;
+        this.crossOriginIframeRootIdMap.set(iframeEl, pvRootPath);
+        this.patchRootIdOnNode(e.data.node, pvRootPath);
+        return {
+          timestamp: e.timestamp,
+          type: 3 /* IncrementalSnapshot */,
+          data: {
+            source: 0 /* Mutation */,
+            adds: [
+              {
+                parentPath: this.mirror.getPath(iframeEl),
+                nextPath: null,
+                node: e.data.node
+              }
+            ],
+            removes: [],
+            texts: [],
+            attributes: [],
+            isAttachIframe: true
+          }
+        };
+      }
+      case 2 /* FullSnapshot */: {
+        this.crossOriginIframeMirror.reset(iframeEl);
+        this.crossOriginIframeStyleMirror.reset(iframeEl);
+        this.replacePathOnNode(e.data.node, iframeEl);
+        const rootPath = e.data.node.path;
+        this.crossOriginIframeRootIdMap.set(iframeEl, rootPath);
+        this.patchRootIdOnNode(e.data.node, rootPath);
+        return {
+          timestamp: e.timestamp,
+          type: 3 /* IncrementalSnapshot */,
+          data: {
+            source: 0 /* Mutation */,
+            adds: [
+              {
+                parentPath: this.mirror.getPath(iframeEl),
+                nextPath: null,
+                node: e.data.node
+              }
+            ],
+            removes: [],
+            texts: [],
+            attributes: [],
+            isAttachIframe: true
+          }
+        };
+      }
+      case 4 /* Meta */:
+      case 1 /* Load */:
+      case 0 /* DomContentLoaded */: {
+        return false;
+      }
+      case 6 /* Plugin */: {
+        return e;
+      }
+      case 5 /* Custom */: {
+        this.replacePaths(e.data.payload, iframeEl, [
+          "path",
+          "parentPath",
+          "previousPath",
+          "nextPath"
+        ]);
+        return e;
+      }
+      case 3 /* IncrementalSnapshot */: {
+        switch (e.data.source) {
+          case 0 /* Mutation */: {
+            e.data.adds.forEach((n) => {
+              this.replacePaths(n, iframeEl, ["parentPath", "nextPath", "previousPath"]);
+              this.replacePathOnNode(n.node, iframeEl);
+              const rootPath = this.crossOriginIframeRootIdMap.get(iframeEl);
+              rootPath && this.patchRootIdOnNode(n.node, rootPath);
+            });
+            e.data.removes.forEach((n) => {
+              this.replacePaths(n, iframeEl, ["parentPath", "path"]);
+            });
+            e.data.attributes.forEach((n) => {
+              this.replacePaths(n, iframeEl, ["path"]);
+            });
+            e.data.texts.forEach((n) => {
+              this.replacePaths(n, iframeEl, ["path"]);
+            });
+            return e;
+          }
+          case 12 /* Drag */:
+          case 6 /* TouchMove */:
+          case 1 /* MouseMove */: {
+            e.data.positions.forEach((p) => {
+              this.replacePaths(p, iframeEl, ["path"]);
+            });
+            return e;
+          }
+          case 4 /* ViewportResize */: {
+            return false;
+          }
+          case 7 /* MediaInteraction */:
+          case 2 /* MouseInteraction */:
+          case 3 /* Scroll */:
+          case 9 /* CanvasMutation */:
+          case 5 /* Input */: {
+            this.replacePaths(e.data, iframeEl, ["path"]);
+            return e;
+          }
+          case 8 /* StyleSheetRule */:
+          case 13 /* StyleDeclaration */: {
+            this.replacePaths(e.data, iframeEl, ["path"]);
+            this.replaceStyleIds(e.data, iframeEl, ["styleId"]);
+            return e;
+          }
+          case 10 /* Font */: {
+            return e;
+          }
+          case 14 /* Selection */: {
+            e.data.ranges.forEach((range) => {
+              this.replacePaths(range, iframeEl, ["start", "end"]);
+            });
+            return e;
+          }
+          case 15 /* AdoptedStyleSheet */: {
+            this.replacePaths(e.data, iframeEl, ["path"]);
+            this.replaceStyleIds(e.data, iframeEl, ["styleIds"]);
+            e.data.styles?.forEach((style) => {
+              this.replaceStyleIds(style, iframeEl, ["styleId"]);
+            });
+            return e;
+          }
+        }
+      }
+    }
+    return false;
+  }
+  replace(iframeMirror, obj, iframeEl, keys) {
+    for (const key of keys) {
+      if (!Array.isArray(obj[key]) && typeof obj[key] !== "string" && typeof obj[key] !== "number")
+        continue;
+      if (Array.isArray(obj[key])) {
+        obj[key] = iframeMirror.getPaths(iframeEl, obj[key]);
+      } else {
+        obj[key] = iframeMirror.getPath(iframeEl, obj[key]);
+      }
+    }
+    return obj;
+  }
+  replacePaths(obj, iframeEl, keys) {
+    return this.replace(this.crossOriginIframeMirror, obj, iframeEl, keys);
+  }
+  replaceStyleIds(obj, iframeEl, keys) {
+    return this.replace(this.crossOriginIframeStyleMirror, obj, iframeEl, keys);
+  }
+  replacePathOnNode(node, iframeEl) {
+    this.replacePaths(node, iframeEl, ["path", "rootId"]);
+    if ("childNodes" in node) {
+      node.childNodes.forEach((child) => {
+        this.replacePathOnNode(child, iframeEl);
+      });
+    }
+  }
+  patchRootIdOnNode(node, rootPath) {
+    if (node.type !== 0 /* Document */ && !node.rootId)
+      node.rootId = rootPath;
+    if ("childNodes" in node) {
+      node.childNodes.forEach((child) => {
+        this.patchRootIdOnNode(child, rootPath);
+      });
+    }
+  }
+}
+
+// ../rrweb-record/src/record/observer.ts
+init_src();
+init_dom();
+init_snapshot_utils();
+init_utils();
+
+// ../rrweb-record/src/record/mutation.ts
+init_dom();
+init_redact_pii();
+init_snapshot();
+init_snapshot_utils();
+init_utils();
+function isNodeInLinkedList(n) {
+  return "__ln" in n;
+}
+
+class DoubleLinkedList {
+  length = 0;
+  head = null;
+  tail = null;
+  get(position) {
+    if (position >= this.length) {
+      throw new Error("Position outside of list range");
+    }
+    let current = this.head;
+    for (let index = 0;index < position; index++) {
+      current = current?.next || null;
+    }
+    return current;
+  }
+  addNode(n) {
+    const node = {
+      value: n,
+      previous: null,
+      next: null
+    };
+    n.__ln = node;
+    if (n.previousSibling && isNodeInLinkedList(n.previousSibling)) {
+      const current = n.previousSibling.__ln.next;
+      node.next = current;
+      node.previous = n.previousSibling.__ln;
+      n.previousSibling.__ln.next = node;
+      if (current) {
+        current.previous = node;
+      }
+    } else if (n.nextSibling && isNodeInLinkedList(n.nextSibling) && n.nextSibling.__ln.previous) {
+      const current = n.nextSibling.__ln.previous;
+      node.previous = current;
+      node.next = n.nextSibling.__ln;
+      n.nextSibling.__ln.previous = node;
+      if (current) {
+        current.next = node;
+      }
+    } else {
+      if (this.head) {
+        this.head.previous = node;
+      }
+      node.next = this.head;
+      this.head = node;
+    }
+    if (node.next === null) {
+      this.tail = node;
+    }
+    this.length++;
+  }
+  removeNode(n) {
+    const current = n.__ln;
+    if (!this.head) {
+      return;
+    }
+    if (!current.previous) {
+      this.head = current.next;
+      if (this.head) {
+        this.head.previous = null;
+      } else {
+        this.tail = null;
+      }
+    } else {
+      current.previous.next = current.next;
+      if (current.next) {
+        current.next.previous = current.previous;
+      } else {
+        this.tail = current.previous;
+      }
+    }
+    if (n.__ln) {
+      n.__ln = undefined;
+    }
+    this.length--;
+  }
+}
+var moveKey = (path, parentPath) => `${path}@${parentPath}`;
+
+class MutationBuffer {
+  frozen = false;
+  locked = false;
+  rafScheduled = false;
+  texts = [];
+  attributes = [];
+  attributeMap = new WeakMap;
+  removes = [];
+  mapRemoves = [];
+  movedMap = {};
+  addedSet = new Set;
+  movedSet = new Set;
+  droppedSet = new Set;
+  removesSubTreeCache = new Set;
+  mutationCb;
+  blockClass;
+  blockSelector;
+  maskTextClass;
+  maskTextSelector;
+  inlineStylesheet;
+  maskInputOptions;
+  maskTextFn;
+  maskInputFn;
+  keepIframeSrcFn;
+  recordCanvas;
+  inlineImages;
+  slimDOMOptions;
+  dataURLOptions;
+  doc;
+  mirror;
+  iframeManager;
+  stylesheetManager;
+  shadowDomManager;
+  canvasManager = null;
+  processedNodeManager;
+  unattachedDoc;
+  init(options) {
+    [
+      "mutationCb",
+      "blockClass",
+      "blockSelector",
+      "maskTextClass",
+      "maskTextSelector",
+      "inlineStylesheet",
+      "maskInputOptions",
+      "maskTextFn",
+      "maskInputFn",
+      "keepIframeSrcFn",
+      "recordCanvas",
+      "inlineImages",
+      "slimDOMOptions",
+      "dataURLOptions",
+      "doc",
+      "mirror",
+      "iframeManager",
+      "stylesheetManager",
+      "shadowDomManager",
+      "canvasManager",
+      "processedNodeManager"
+    ].forEach((key) => {
+      this[key] = options[key];
+    });
+  }
+  setCanvasManager(cm) {
+    this.canvasManager = cm;
+  }
+  freeze() {
+    this.frozen = true;
+    this.canvasManager?.freeze();
+  }
+  unfreeze() {
+    this.frozen = false;
+    this.canvasManager?.unfreeze();
+    this.emit();
+  }
+  isFrozen() {
+    return this.frozen;
+  }
+  lock() {
+    this.locked = true;
+    this.canvasManager?.lock();
+  }
+  unlock() {
+    this.locked = false;
+    this.canvasManager?.unlock();
+    this.emit();
+  }
+  unlockAndDrop() {
+    this.dropPending();
+    this.locked = false;
+    this.canvasManager.unlock();
+  }
+  reset() {
+    this.shadowDomManager.reset();
+    this.canvasManager?.reset();
+  }
+  dropPending() {
+    while (this.mapRemoves.length) {
+      this.mirror.removeNodeFromMap(this.mapRemoves.shift());
+    }
+    this.texts = [];
+    this.attributes = [];
+    this.attributeMap = new WeakMap;
+    this.removes = [];
+    this.addedSet = new Set;
+    this.movedSet = new Set;
+    this.droppedSet = new Set;
+    this.removesSubTreeCache = new Set;
+    this.movedMap = {};
+  }
+  processMutations = (mutations) => {
+    mutations.forEach(this.processMutation);
+    if (!this.rafScheduled && !this.frozen && !this.locked) {
+      this.rafScheduled = true;
+      requestAnimationFrame(() => {
+        this.rafScheduled = false;
+        this.emit();
+      });
+    }
+  };
+  emit = () => {
+    if (this.frozen || this.locked) {
+      return;
+    }
+    const adds = [];
+    const addedPaths = new Set;
+    const addList = new DoubleLinkedList;
+    const getNextPath = (n) => {
+      let ns = n;
+      while (ns = ns?.nextSibling ?? null) {
+        if (this.mirror.isSerialized(ns)) {
+          return this.mirror.getPath(ns);
+        }
+      }
+      return null;
+    };
+    const getPreviousPath = (n) => {
+      let ps = n;
+      while (ps = ps?.previousSibling ?? null) {
+        if (this.mirror.isSerialized(ps)) {
+          return this.mirror.getPath(ps);
+        }
+      }
+      return null;
+    };
+    const pushAdd = (n) => {
+      const parent = dom_default.parentNode(n);
+      if (!parent || !inDom(n)) {
+        return;
+      }
+      let cssCaptured = false;
+      if (n.nodeType === Node.TEXT_NODE) {
+        const parentTag = parent.tagName;
+        if (parentTag === "TEXTAREA") {
+          return;
+        }
+        if (parentTag === "STYLE" && this.addedSet.has(parent)) {
+          cssCaptured = true;
+        }
+      }
+      const parentPath = isShadowRoot(parent) ? this.mirror.getPath(getShadowHost(n)) : this.mirror.getPath(parent);
+      const afterPath = getNextPath(n);
+      const beforePath = getPreviousPath(n);
+      if (!parentPath && parentPath !== "" || afterPath === "") {}
+      if (!this.mirror.isSerialized(parent) && !isShadowRoot(parent)) {
+        return addList.addNode(n);
+      }
+      const sn = serializeNodeWithId(n, {
+        doc: this.doc,
+        mirror: this.mirror,
+        blockClass: this.blockClass,
+        blockSelector: this.blockSelector,
+        maskTextClass: this.maskTextClass,
+        maskTextSelector: this.maskTextSelector,
+        skipChild: true,
+        newlyAddedElement: true,
+        inlineStylesheet: this.inlineStylesheet,
+        maskInputOptions: this.maskInputOptions,
+        maskTextFn: this.maskTextFn,
+        maskInputFn: this.maskInputFn,
+        slimDOMOptions: this.slimDOMOptions,
+        dataURLOptions: this.dataURLOptions,
+        recordCanvas: this.recordCanvas,
+        inlineImages: this.inlineImages,
+        onSerialize: (currentN) => {
+          if (isSerializedIframe(currentN, this.mirror)) {
+            this.iframeManager.addIframe(currentN);
+          }
+          if (isSerializedStylesheet(currentN, this.mirror)) {
+            this.stylesheetManager.trackLinkElement(currentN);
+          }
+          if (hasShadowRoot(n)) {
+            this.shadowDomManager.addShadowRoot(dom_default.shadowRoot(n), this.doc);
+          }
+        },
+        onIframeLoad: (iframe, childSn) => {
+          this.iframeManager.attachIframe(iframe, childSn);
+          this.shadowDomManager.observeAttachShadow(iframe);
+        },
+        onStylesheetLoad: (link, childSn) => {
+          this.stylesheetManager.attachLinkElement(link, childSn);
+        },
+        cssCaptured
+      });
+      if (sn) {
+        adds.push({
+          parentPath,
+          previousPath: beforePath,
+          nextPath: afterPath,
+          node: sn
+        });
+        addedPaths.add(sn.path);
+      }
+    };
+    while (this.mapRemoves.length) {
+      this.mirror.removeNodeFromMap(this.mapRemoves.shift());
+    }
+    for (const n of this.movedSet) {
+      if (isParentRemoved(this.removesSubTreeCache, n, this.mirror) && !this.movedSet.has(dom_default.parentNode(n))) {
+        continue;
+      }
+      pushAdd(n);
+    }
+    for (const n of this.addedSet) {
+      if (!isAncestorInSet(this.droppedSet, n) && !isParentRemoved(this.removesSubTreeCache, n, this.mirror)) {
+        pushAdd(n);
+      } else if (isAncestorInSet(this.movedSet, n)) {
+        pushAdd(n);
+      } else {
+        this.droppedSet.add(n);
+      }
+    }
+    let candidate = null;
+    while (addList.length) {
+      let node = null;
+      if (candidate) {
+        const parentNode2 = dom_default.parentNode(candidate.value);
+        const parentSerialized = parentNode2 && this.mirror.isSerialized(parentNode2);
+        const afterPath = getNextPath(candidate.value);
+        if (parentSerialized && afterPath !== IGNORED_PATH) {
+          node = candidate;
+        }
+      }
+      if (!node) {
+        let tailNode = addList.tail;
+        while (tailNode) {
+          const _node = tailNode;
+          tailNode = tailNode.previous;
+          if (_node) {
+            const parentNode2 = dom_default.parentNode(_node.value);
+            const parentSerialized = parentNode2 && this.mirror.isSerialized(parentNode2);
+            const afterPath = getNextPath(_node.value);
+            if (afterPath === IGNORED_PATH)
+              continue;
+            if (parentSerialized) {
+              node = _node;
+              break;
+            }
+            const unhandledNode = _node.value;
+            const parent = dom_default.parentNode(unhandledNode);
+            if (parent && parent.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+              const shadowHost = dom_default.host(parent);
+              if (this.mirror.isSerialized(shadowHost)) {
+                node = _node;
+                break;
+              }
+            }
+          }
+        }
+      }
+      if (!node) {
+        while (addList.head) {
+          addList.removeNode(addList.head.value);
+        }
+        break;
+      }
+      candidate = node.previous;
+      addList.removeNode(node.value);
+      pushAdd(node.value);
+    }
+    const payload = {
+      texts: this.texts.map((text) => {
+        const n = text.node;
+        const parent = dom_default.parentNode(n);
+        if (parent && parent.tagName === "TEXTAREA") {
+          this.genTextAreaValueMutation(parent);
+        }
+        return {
+          path: this.mirror.getPath(n),
+          value: text.value
+        };
+      }).filter((text) => !addedPaths.has(text.path)).filter((text) => text.path !== "" && text.path !== IGNORED_PATH),
+      attributes: this.attributes.map((attribute) => {
+        const { attributes } = attribute;
+        if (typeof attributes.style === "string") {
+          const diffAsStr = JSON.stringify(attribute.styleDiff);
+          const unchangedAsStr = JSON.stringify(attribute._unchangedStyles);
+          if (diffAsStr.length < attributes.style.length) {
+            if ((diffAsStr + unchangedAsStr).split("var(").length === attributes.style.split("var(").length) {
+              attributes.style = attribute.styleDiff;
+            }
+          }
+        }
+        return {
+          path: this.mirror.getPath(attribute.node),
+          attributes
+        };
+      }).filter((attribute) => !addedPaths.has(attribute.path)).filter((attribute) => attribute.path !== "" && attribute.path !== IGNORED_PATH),
+      removes: this.removes,
+      adds
+    };
+    if (!payload.texts.length && !payload.attributes.length && !payload.removes.length && !payload.adds.length) {
+      return;
+    }
+    this.texts = [];
+    this.attributes = [];
+    this.attributeMap = new WeakMap;
+    this.removes = [];
+    this.addedSet = new Set;
+    this.movedSet = new Set;
+    this.droppedSet = new Set;
+    this.removesSubTreeCache = new Set;
+    this.movedMap = {};
+    this.mutationCb(payload);
+  };
+  genTextAreaValueMutation = (textarea) => {
+    let item = this.attributeMap.get(textarea);
+    if (!item) {
+      item = {
+        node: textarea,
+        attributes: {},
+        styleDiff: {},
+        _unchangedStyles: {}
+      };
+      this.attributes.push(item);
+      this.attributeMap.set(textarea, item);
+    }
+    item.attributes.value = Array.from(dom_default.childNodes(textarea), (cn) => dom_default.textContent(cn) || "").join("");
+  };
+  processMutation = (m) => {
+    if (isIgnored(m.target, this.mirror, this.slimDOMOptions)) {
+      return;
+    }
+    switch (m.type) {
+      case "characterData": {
+        const value = dom_default.textContent(m.target);
+        if (!isBlocked(m.target, this.blockClass, this.blockSelector, false) && value !== m.oldValue) {
+          const masked = needMaskingText(m.target, this.maskTextClass, this.maskTextSelector, true) && value ? this.maskTextFn ? this.maskTextFn(value, closestElementOfNode(m.target)) : value.replace(/[\S]/g, "*") : value;
+          this.texts.push({
+            value: masked ? redactPII(masked) : masked,
+            node: m.target
+          });
+        }
+        break;
+      }
+      case "attributes": {
+        const target = m.target;
+        let attributeName = m.attributeName;
+        let value = m.target.getAttribute(attributeName);
+        if (attributeName === "value") {
+          const type = getInputType(target);
+          value = maskInputValue({
+            element: target,
+            maskInputOptions: this.maskInputOptions,
+            tagName: target.tagName,
+            type,
+            value,
+            maskInputFn: this.maskInputFn
+          });
+        }
+        if (isBlocked(m.target, this.blockClass, this.blockSelector, false) || value === m.oldValue) {
+          return;
+        }
+        let item = this.attributeMap.get(m.target);
+        if (target.tagName === "IFRAME" && attributeName === "src" && !this.keepIframeSrcFn(value)) {
+          if (!target.contentDocument) {
+            attributeName = "rr_src";
+          } else {
+            return;
+          }
+        }
+        if (!item) {
+          item = {
+            node: m.target,
+            attributes: {},
+            styleDiff: {},
+            _unchangedStyles: {}
+          };
+          this.attributes.push(item);
+          this.attributeMap.set(m.target, item);
+        }
+        if (attributeName === "type" && target.tagName === "INPUT" && (m.oldValue || "").toLowerCase() === "password") {
+          target.setAttribute("data-rr-is-password", "true");
+        }
+        if (!ignoreAttribute(target.tagName, attributeName, value)) {
+          item.attributes[attributeName] = transformAttribute(this.doc, toLowerCase(target.tagName), toLowerCase(attributeName), value);
+          if (attributeName === "style") {
+            if (!this.unattachedDoc) {
+              try {
+                this.unattachedDoc = document.implementation.createHTMLDocument();
+              } catch (_e) {
+                this.unattachedDoc = this.doc;
+              }
+            }
+            const old = this.unattachedDoc.createElement("span");
+            if (m.oldValue) {
+              old.setAttribute("style", m.oldValue);
+            }
+            for (const pname of Array.from(target.style)) {
+              const newValue = target.style.getPropertyValue(pname);
+              const newPriority = target.style.getPropertyPriority(pname);
+              if (newValue !== old.style.getPropertyValue(pname) || newPriority !== old.style.getPropertyPriority(pname)) {
+                if (newPriority === "") {
+                  item.styleDiff[pname] = newValue;
+                } else {
+                  item.styleDiff[pname] = [newValue, newPriority];
+                }
+              } else {
+                item._unchangedStyles[pname] = [newValue, newPriority];
+              }
+            }
+            for (const pname of Array.from(old.style)) {
+              if (target.style.getPropertyValue(pname) === "") {
+                item.styleDiff[pname] = false;
+              }
+            }
+          } else if (attributeName === "open" && target.tagName === "DIALOG") {
+            if (target.matches("dialog:modal")) {
+              item.attributes.rr_open_mode = "modal";
+            } else {
+              item.attributes.rr_open_mode = "non-modal";
+            }
+          }
+        }
+        break;
+      }
+      case "childList": {
+        if (isBlocked(m.target, this.blockClass, this.blockSelector, true))
+          return;
+        if (m.target.tagName === "TEXTAREA") {
+          this.genTextAreaValueMutation(m.target);
+          return;
+        }
+        m.addedNodes.forEach((n) => this.genAdds(n, m.target));
+        m.removedNodes.forEach((n) => {
+          const nodePath = this.mirror.getPath(n);
+          const parentPath = isShadowRoot(m.target) ? this.mirror.getPath(dom_default.host(m.target)) : this.mirror.getPath(m.target);
+          if (isBlocked(m.target, this.blockClass, this.blockSelector, false) || isIgnored(n, this.mirror, this.slimDOMOptions) || !isSerialized(n, this.mirror)) {
+            return;
+          }
+          if (this.addedSet.has(n)) {
+            deepDelete(this.addedSet, n);
+            this.droppedSet.add(n);
+          } else if (this.addedSet.has(m.target) && !this.mirror.hasNode(n)) {} else if (isAncestorRemoved(m.target, this.mirror)) {} else if (this.movedSet.has(n) && this.movedMap[moveKey(nodePath, parentPath)]) {
+            deepDelete(this.movedSet, n);
+          } else {
+            this.removes.push({
+              parentPath,
+              path: nodePath,
+              isShadow: isShadowRoot(m.target) && isNativeShadowDom(m.target) ? true : undefined
+            });
+            processRemoves(n, this.removesSubTreeCache);
+          }
+          this.mapRemoves.push(n);
+        });
+        break;
+      }
+      default:
+        break;
+    }
+  };
+  genAdds = (n, target) => {
+    if (this.processedNodeManager.inOtherBuffer(n, this))
+      return;
+    if (this.addedSet.has(n) || this.movedSet.has(n))
+      return;
+    if (this.mirror.hasNode(n)) {
+      if (isIgnored(n, this.mirror, this.slimDOMOptions)) {
+        return;
+      }
+      this.movedSet.add(n);
+      if (target && this.mirror.hasNode(target)) {
+        const targetPath = this.mirror.getPath(target);
+        if (targetPath && targetPath !== IGNORED_PATH) {
+          this.movedMap[moveKey(this.mirror.getPath(n), targetPath)] = true;
+        }
+      }
+    } else {
+      this.addedSet.add(n);
+      this.droppedSet.delete(n);
+    }
+    if (!isBlocked(n, this.blockClass, this.blockSelector, false)) {
+      dom_default.childNodes(n).forEach((childN) => this.genAdds(childN));
+      if (hasShadowRoot(n)) {
+        dom_default.childNodes(dom_default.shadowRoot(n)).forEach((childN) => {
+          this.processedNodeManager.add(childN, this);
+          this.genAdds(childN, n);
+        });
+      }
+    }
+  };
+}
+function deepDelete(addsSet, n) {
+  addsSet.delete(n);
+  dom_default.childNodes(n).forEach((childN) => deepDelete(addsSet, childN));
+}
+function processRemoves(n, cache) {
+  const queue = [n];
+  while (queue.length) {
+    const next = queue.pop();
+    if (cache.has(next))
+      continue;
+    cache.add(next);
+    dom_default.childNodes(next).forEach((n2) => queue.push(n2));
+  }
+  return;
+}
+function isParentRemoved(removes, n, mirror) {
+  if (removes.size === 0)
+    return false;
+  return _isParentRemoved(removes, n, mirror);
+}
+function _isParentRemoved(removes, n, _mirror) {
+  const node = dom_default.parentNode(n);
+  if (!node)
+    return false;
+  return removes.has(node);
+}
+function isAncestorInSet(set, n) {
+  if (set.size === 0)
+    return false;
+  return _isAncestorInSet(set, n);
+}
+function _isAncestorInSet(set, n) {
+  const parent = dom_default.parentNode(n);
+  if (!parent) {
+    return false;
+  }
+  if (set.has(parent)) {
+    return true;
+  }
+  return _isAncestorInSet(set, parent);
+}
+
+// ../rrweb-record/src/record/observer.ts
+var mutationBuffers = [];
+var observerBufferPairs = [];
+function flushMutationObservers() {
+  for (const { observer, buffer } of observerBufferPairs) {
+    const records = observer.takeRecords();
+    if (records.length > 0) {
+      buffer.processMutations(records);
+    }
+  }
+}
+function getEventTarget(event) {
+  try {
+    if ("composedPath" in event) {
+      const path = event.composedPath();
+      if (path.length) {
+        return path[0];
+      }
+    } else if ("path" in event && event.path.length) {
+      return event.path[0];
+    }
+  } catch {}
+  return event?.target;
+}
+function initMutationObserver(options, rootEl) {
+  const mutationBuffer = new MutationBuffer;
+  mutationBuffers.push(mutationBuffer);
+  mutationBuffer.init(options);
+  const observer = new (mutationObserverCtor())(callbackWrapper(mutationBuffer.processMutations.bind(mutationBuffer)));
+  observer.observe(rootEl, {
+    attributes: true,
+    attributeOldValue: true,
+    characterData: true,
+    characterDataOldValue: true,
+    childList: true,
+    subtree: true
+  });
+  observerBufferPairs.push({ observer, buffer: mutationBuffer });
+  return observer;
+}
+function initMoveObserver({ mousemoveCb, sampling, doc, mirror }) {
+  if (sampling.mousemove === false) {
+    return () => {};
+  }
+  const threshold = typeof sampling.mousemove === "number" ? sampling.mousemove : 50;
+  const callbackThreshold = typeof sampling.mousemoveCallback === "number" ? sampling.mousemoveCallback : 500;
+  let positions = [];
+  let timeBaseline;
+  const wrappedCb = throttle(callbackWrapper((source) => {
+    const totalOffset = Date.now() - timeBaseline;
+    mousemoveCb(positions.map((p) => {
+      p.timeOffset -= totalOffset;
+      return p;
+    }), source);
+    positions = [];
+    timeBaseline = null;
+  }), callbackThreshold);
+  const updatePosition = callbackWrapper(throttle(callbackWrapper((evt) => {
+    const target = getEventTarget(evt);
+    const { clientX, clientY } = legacy_isTouchEvent(evt) ? evt.changedTouches[0] : evt;
+    if (!timeBaseline) {
+      timeBaseline = nowTimestamp();
+    }
+    positions.push({
+      x: clientX,
+      y: clientY,
+      path: mirror.getPath(target),
+      timeOffset: nowTimestamp() - timeBaseline
+    });
+    wrappedCb(typeof DragEvent !== "undefined" && evt instanceof DragEvent ? 12 /* Drag */ : evt instanceof MouseEvent ? 1 /* MouseMove */ : 6 /* TouchMove */);
+  }), threshold, {
+    trailing: false
+  }));
+  const handlers = [
+    on("mousemove", updatePosition, doc),
+    on("touchmove", updatePosition, doc),
+    on("drag", updatePosition, doc)
+  ];
+  return callbackWrapper(() => {
+    handlers.forEach((h) => h());
+  });
+}
+function initMouseInteractionObserver({
+  mouseInteractionCb,
+  doc,
+  mirror,
+  blockClass,
+  blockSelector,
+  sampling
+}) {
+  if (sampling.mouseInteraction === false) {
+    return () => {};
+  }
+  const disableMap = sampling.mouseInteraction === true || sampling.mouseInteraction === undefined ? {} : sampling.mouseInteraction;
+  const handlers = [];
+  let currentPointerType = null;
+  const getHandler = (eventKey) => {
+    return (event) => {
+      const target = getEventTarget(event);
+      if (isBlocked(target, blockClass, blockSelector, true)) {
+        return;
+      }
+      let pointerType = null;
+      let thisEventKey = eventKey;
+      if ("pointerType" in event) {
+        switch (event.pointerType) {
+          case "mouse":
+            pointerType = 0 /* Mouse */;
+            break;
+          case "touch":
+            pointerType = 2 /* Touch */;
+            break;
+          case "pen":
+            pointerType = 1 /* Pen */;
+            break;
+        }
+        if (pointerType === 2 /* Touch */) {
+          if (MouseInteractions[eventKey] === 1 /* MouseDown */) {
+            thisEventKey = "TouchStart";
+          } else if (MouseInteractions[eventKey] === 0 /* MouseUp */) {
+            thisEventKey = "TouchEnd";
+          }
+        } else if (pointerType === 1 /* Pen */) {}
+      } else if (legacy_isTouchEvent(event)) {
+        pointerType = 2 /* Touch */;
+      }
+      if (pointerType !== null) {
+        currentPointerType = pointerType;
+        if (thisEventKey.startsWith("Touch") && pointerType === 2 /* Touch */ || thisEventKey.startsWith("Mouse") && pointerType === 0 /* Mouse */) {
+          pointerType = null;
+        }
+      } else if (MouseInteractions[eventKey] === 2 /* Click */) {
+        pointerType = currentPointerType;
+        currentPointerType = null;
+      }
+      const e = legacy_isTouchEvent(event) ? event.changedTouches[0] : event;
+      if (!e) {
+        return;
+      }
+      const path = mirror.getPath(target);
+      const { clientX, clientY } = e;
+      callbackWrapper(mouseInteractionCb)({
+        type: MouseInteractions[thisEventKey],
+        path,
+        x: clientX,
+        y: clientY,
+        ...pointerType !== null && { pointerType }
+      });
+    };
+  };
+  Object.keys(MouseInteractions).filter((key) => Number.isNaN(Number(key)) && !key.endsWith("_Departed") && disableMap[key] !== false).forEach((eventKey) => {
+    let eventName = toLowerCase(eventKey);
+    const handler = getHandler(eventKey);
+    if (window.PointerEvent) {
+      switch (MouseInteractions[eventKey]) {
+        case 1 /* MouseDown */:
+        case 0 /* MouseUp */:
+          eventName = eventName.replace("mouse", "pointer");
+          break;
+        case 7 /* TouchStart */:
+        case 9 /* TouchEnd */:
+          return;
+      }
+    }
+    handlers.push(on(eventName, handler, doc));
+  });
+  return callbackWrapper(() => {
+    handlers.forEach((h) => h());
+  });
+}
+function initScrollObserver({
+  scrollCb,
+  doc,
+  mirror,
+  blockClass,
+  blockSelector,
+  sampling
+}) {
+  const updatePosition = callbackWrapper(throttle(callbackWrapper((evt) => {
+    const target = getEventTarget(evt);
+    if (!target || isBlocked(target, blockClass, blockSelector, true)) {
+      return;
+    }
+    const path = mirror.getPath(target);
+    if (target === doc && doc.defaultView) {
+      const scrollLeftTop = getWindowScroll(doc.defaultView);
+      scrollCb({
+        path,
+        x: scrollLeftTop.left,
+        y: scrollLeftTop.top
+      });
+    } else {
+      scrollCb({
+        path,
+        x: target.scrollLeft,
+        y: target.scrollTop
+      });
+    }
+  }), sampling.scroll || 100));
+  return on("scroll", updatePosition, doc);
+}
+function initViewportResizeObserver({ viewportResizeCb }, { win }) {
+  let lastH = -1;
+  let lastW = -1;
+  const updateDimension = callbackWrapper(throttle(callbackWrapper(() => {
+    const height = getWindowHeight();
+    const width = getWindowWidth();
+    if (lastH !== height || lastW !== width) {
+      viewportResizeCb({
+        width: Number(width),
+        height: Number(height)
+      });
+      lastH = height;
+      lastW = width;
+    }
+  }), 200));
+  return on("resize", updateDimension, win);
+}
+var INPUT_TAGS = ["INPUT", "TEXTAREA", "SELECT"];
+var lastInputValueMap = new WeakMap;
+function initInputObserver({
+  inputCb,
+  doc,
+  mirror,
+  blockClass,
+  blockSelector,
+  ignoreClass,
+  ignoreSelector,
+  maskInputOptions,
+  maskInputFn,
+  sampling
+}) {
+  function eventHandler(event) {
+    let target = getEventTarget(event);
+    const tagName = target?.tagName;
+    if (target && tagName === "OPTION") {
+      target = dom_default.parentElement(target);
+    }
+    if (!target || !tagName || INPUT_TAGS.indexOf(tagName) < 0 || isBlocked(target, blockClass, blockSelector, true)) {
+      return;
+    }
+    if (target.classList.contains(ignoreClass) || ignoreSelector && target.matches(ignoreSelector)) {
+      return;
+    }
+    let text = target.value;
+    let isChecked = false;
+    const type = getInputType(target) || "";
+    if (type === "radio" || type === "checkbox") {
+      isChecked = target.checked;
+    } else if (maskInputOptions[tagName.toLowerCase()] || maskInputOptions[type]) {
+      text = maskInputValue({
+        element: target,
+        maskInputOptions,
+        tagName,
+        type,
+        value: text,
+        maskInputFn
+      });
+    }
+    cbWithDedup(target, { text, isChecked });
+    const name = target.name;
+    if (type === "radio" && name && isChecked) {
+      doc.querySelectorAll(`input[type="radio"][name="${name}"]`).forEach((el) => {
+        if (el !== target) {
+          const text2 = el.value;
+          cbWithDedup(el, { text: text2, isChecked: !isChecked });
+        }
+      });
+    }
+  }
+  function cbWithDedup(target, v) {
+    const lastInputValue = lastInputValueMap.get(target);
+    if (!lastInputValue || lastInputValue.text !== v.text || lastInputValue.isChecked !== v.isChecked) {
+      lastInputValueMap.set(target, v);
+      const path = mirror.getPath(target);
+      callbackWrapper(inputCb)({
+        ...v,
+        path
+      });
+    }
+  }
+  const events = sampling.input === "last" ? ["change"] : ["input", "change"];
+  const handlers = events.map((eventName) => on(eventName, callbackWrapper(eventHandler), doc));
+  const currentWindow = doc.defaultView;
+  if (!currentWindow) {
+    return () => {
+      handlers.forEach((h) => h());
+    };
+  }
+  const propertyDescriptor = currentWindow.Object.getOwnPropertyDescriptor(currentWindow.HTMLInputElement.prototype, "value");
+  const hookProperties = [
+    [currentWindow.HTMLInputElement.prototype, "value"],
+    [currentWindow.HTMLInputElement.prototype, "checked"],
+    [currentWindow.HTMLSelectElement.prototype, "value"],
+    [currentWindow.HTMLTextAreaElement.prototype, "value"],
+    [currentWindow.HTMLSelectElement.prototype, "selectedIndex"],
+    [currentWindow.HTMLOptionElement.prototype, "selected"]
+  ];
+  if (propertyDescriptor?.set) {
+    handlers.push(...hookProperties.map((p) => hookSetter(p[0], p[1], {
+      set() {
+        callbackWrapper(eventHandler)({
+          target: this,
+          isTrusted: false
+        });
+      }
+    }, false, currentWindow)));
+  }
+  return callbackWrapper(() => {
+    handlers.forEach((h) => h());
+  });
+}
+function getNestedCSSRulePositions(rule) {
+  const positions = [];
+  function recurse(childRule, pos) {
+    if (hasNestedCSSRule("CSSGroupingRule") && childRule.parentRule instanceof CSSGroupingRule || hasNestedCSSRule("CSSMediaRule") && childRule.parentRule instanceof CSSMediaRule || hasNestedCSSRule("CSSSupportsRule") && childRule.parentRule instanceof CSSSupportsRule || hasNestedCSSRule("CSSConditionRule") && childRule.parentRule instanceof CSSConditionRule) {
+      const rules = Array.from(childRule.parentRule.cssRules);
+      const index = rules.indexOf(childRule);
+      pos.unshift(index);
+    } else if (childRule.parentStyleSheet) {
+      const rules = Array.from(childRule.parentStyleSheet.cssRules);
+      const index = rules.indexOf(childRule);
+      pos.unshift(index);
+    }
+    return pos;
+  }
+  return recurse(rule, positions);
+}
+function getPathAndStyleId(sheet, mirror, styleMirror) {
+  let path;
+  let styleId;
+  if (!sheet)
+    return {};
+  if (sheet.ownerNode)
+    path = mirror.getPath(sheet.ownerNode);
+  else
+    styleId = styleMirror.getId(sheet);
+  return {
+    styleId,
+    path
+  };
+}
+function initStyleSheetObserver({ styleSheetRuleCb, mirror, stylesheetManager }, { win }) {
+  if (!win.CSSStyleSheet || !win.CSSStyleSheet.prototype) {
+    return () => {};
+  }
+  const insertRule = win.CSSStyleSheet.prototype.insertRule;
+  win.CSSStyleSheet.prototype.insertRule = new Proxy(insertRule, {
+    apply: callbackWrapper((target, thisArg, argumentsList) => {
+      const [rule, index] = argumentsList;
+      const { path, styleId } = getPathAndStyleId(thisArg, mirror, stylesheetManager.styleMirror);
+      if (path || styleId && styleId !== -1) {
+        styleSheetRuleCb({
+          path,
+          styleId,
+          adds: [{ rule, index }]
+        });
+      }
+      return target.apply(thisArg, argumentsList);
+    })
+  });
+  const deleteRule = win.CSSStyleSheet.prototype.deleteRule;
+  win.CSSStyleSheet.prototype.deleteRule = new Proxy(deleteRule, {
+    apply: callbackWrapper((target, thisArg, argumentsList) => {
+      const [index] = argumentsList;
+      const { path, styleId } = getPathAndStyleId(thisArg, mirror, stylesheetManager.styleMirror);
+      if (path || styleId && styleId !== -1) {
+        styleSheetRuleCb({
+          path,
+          styleId,
+          removes: [{ index }]
+        });
+      }
+      return target.apply(thisArg, argumentsList);
+    })
+  });
+  let replace;
+  if (win.CSSStyleSheet.prototype.replace) {
+    replace = win.CSSStyleSheet.prototype.replace;
+    win.CSSStyleSheet.prototype.replace = new Proxy(replace, {
+      apply: callbackWrapper((target, thisArg, argumentsList) => {
+        const [text] = argumentsList;
+        const { path, styleId } = getPathAndStyleId(thisArg, mirror, stylesheetManager.styleMirror);
+        if (path || styleId && styleId !== -1) {
+          styleSheetRuleCb({
+            path,
+            styleId,
+            replace: text
+          });
+        }
+        return target.apply(thisArg, argumentsList);
+      })
+    });
+  }
+  let replaceSync;
+  if (win.CSSStyleSheet.prototype.replaceSync) {
+    replaceSync = win.CSSStyleSheet.prototype.replaceSync;
+    win.CSSStyleSheet.prototype.replaceSync = new Proxy(replaceSync, {
+      apply: callbackWrapper((target, thisArg, argumentsList) => {
+        const [text] = argumentsList;
+        const { path, styleId } = getPathAndStyleId(thisArg, mirror, stylesheetManager.styleMirror);
+        if (path || styleId && styleId !== -1) {
+          styleSheetRuleCb({
+            path,
+            styleId,
+            replaceSync: text
+          });
+        }
+        return target.apply(thisArg, argumentsList);
+      })
+    });
+  }
+  const supportedNestedCSSRuleTypes = {};
+  if (canMonkeyPatchNestedCSSRule("CSSGroupingRule")) {
+    supportedNestedCSSRuleTypes.CSSGroupingRule = win.CSSGroupingRule;
+  } else {
+    if (canMonkeyPatchNestedCSSRule("CSSMediaRule")) {
+      supportedNestedCSSRuleTypes.CSSMediaRule = win.CSSMediaRule;
+    }
+    if (canMonkeyPatchNestedCSSRule("CSSConditionRule")) {
+      supportedNestedCSSRuleTypes.CSSConditionRule = win.CSSConditionRule;
+    }
+    if (canMonkeyPatchNestedCSSRule("CSSSupportsRule")) {
+      supportedNestedCSSRuleTypes.CSSSupportsRule = win.CSSSupportsRule;
+    }
+  }
+  const unmodifiedFunctions = {};
+  Object.entries(supportedNestedCSSRuleTypes).forEach(([typeKey, type]) => {
+    unmodifiedFunctions[typeKey] = {
+      insertRule: type.prototype.insertRule,
+      deleteRule: type.prototype.deleteRule
+    };
+    type.prototype.insertRule = new Proxy(unmodifiedFunctions[typeKey].insertRule, {
+      apply: callbackWrapper((target, thisArg, argumentsList) => {
+        const [rule, index] = argumentsList;
+        const { path, styleId } = getPathAndStyleId(thisArg.parentStyleSheet, mirror, stylesheetManager.styleMirror);
+        if (path || styleId && styleId !== -1) {
+          styleSheetRuleCb({
+            path,
+            styleId,
+            adds: [
+              {
+                rule,
+                index: [
+                  ...getNestedCSSRulePositions(thisArg),
+                  index || 0
+                ]
+              }
+            ]
+          });
+        }
+        return target.apply(thisArg, argumentsList);
+      })
+    });
+    type.prototype.deleteRule = new Proxy(unmodifiedFunctions[typeKey].deleteRule, {
+      apply: callbackWrapper((target, thisArg, argumentsList) => {
+        const [index] = argumentsList;
+        const { path, styleId } = getPathAndStyleId(thisArg.parentStyleSheet, mirror, stylesheetManager.styleMirror);
+        if (path || styleId && styleId !== -1) {
+          styleSheetRuleCb({
+            path,
+            styleId,
+            removes: [{ index: [...getNestedCSSRulePositions(thisArg), index] }]
+          });
+        }
+        return target.apply(thisArg, argumentsList);
+      })
+    });
+  });
+  return callbackWrapper(() => {
+    win.CSSStyleSheet.prototype.insertRule = insertRule;
+    win.CSSStyleSheet.prototype.deleteRule = deleteRule;
+    replace && (win.CSSStyleSheet.prototype.replace = replace);
+    replaceSync && (win.CSSStyleSheet.prototype.replaceSync = replaceSync);
+    Object.entries(supportedNestedCSSRuleTypes).forEach(([typeKey, type]) => {
+      type.prototype.insertRule = unmodifiedFunctions[typeKey].insertRule;
+      type.prototype.deleteRule = unmodifiedFunctions[typeKey].deleteRule;
+    });
+  });
+}
+function initAdoptedStyleSheetObserver({ mirror, stylesheetManager }, host2) {
+  let hostPath = null;
+  if (host2.nodeName === "#document")
+    hostPath = mirror.getPath(host2);
+  else
+    hostPath = mirror.getPath(dom_default.host(host2));
+  const patchTarget = host2.nodeName === "#document" ? host2.defaultView?.Document : host2.ownerDocument?.defaultView?.ShadowRoot;
+  const originalPropertyDescriptor = patchTarget?.prototype ? Object.getOwnPropertyDescriptor(patchTarget?.prototype, "adoptedStyleSheets") : undefined;
+  if (hostPath === null || !patchTarget || !originalPropertyDescriptor)
+    return () => {};
+  Object.defineProperty(host2, "adoptedStyleSheets", {
+    configurable: originalPropertyDescriptor.configurable,
+    enumerable: originalPropertyDescriptor.enumerable,
+    get() {
+      return originalPropertyDescriptor.get?.call(this);
+    },
+    set(sheets) {
+      const result = originalPropertyDescriptor.set?.call(this, sheets);
+      if (hostPath !== null) {
+        try {
+          stylesheetManager.adoptStyleSheets(sheets, hostPath);
+        } catch (_e) {}
+      }
+      return result;
+    }
+  });
+  return callbackWrapper(() => {
+    Object.defineProperty(host2, "adoptedStyleSheets", {
+      configurable: originalPropertyDescriptor.configurable,
+      enumerable: originalPropertyDescriptor.enumerable,
+      get: originalPropertyDescriptor.get,
+      set: originalPropertyDescriptor.set
+    });
+  });
+}
+function initStyleDeclarationObserver({ styleDeclarationCb, mirror, ignoreCSSAttributes, stylesheetManager }, { win }) {
+  const setProperty = win.CSSStyleDeclaration.prototype.setProperty;
+  win.CSSStyleDeclaration.prototype.setProperty = new Proxy(setProperty, {
+    apply: callbackWrapper((target, thisArg, argumentsList) => {
+      const [property, value, priority] = argumentsList;
+      if (ignoreCSSAttributes.has(property)) {
+        return setProperty.apply(thisArg, [property, value, priority]);
+      }
+      const { path, styleId } = getPathAndStyleId(thisArg.parentRule?.parentStyleSheet, mirror, stylesheetManager.styleMirror);
+      if (path || styleId && styleId !== -1) {
+        styleDeclarationCb({
+          path,
+          styleId,
+          set: {
+            property,
+            value,
+            priority
+          },
+          index: getNestedCSSRulePositions(thisArg.parentRule)
+        });
+      }
+      return target.apply(thisArg, argumentsList);
+    })
+  });
+  const removeProperty = win.CSSStyleDeclaration.prototype.removeProperty;
+  win.CSSStyleDeclaration.prototype.removeProperty = new Proxy(removeProperty, {
+    apply: callbackWrapper((target, thisArg, argumentsList) => {
+      const [property] = argumentsList;
+      if (ignoreCSSAttributes.has(property)) {
+        return removeProperty.apply(thisArg, [property]);
+      }
+      const { path, styleId } = getPathAndStyleId(thisArg.parentRule?.parentStyleSheet, mirror, stylesheetManager.styleMirror);
+      if (path || styleId && styleId !== -1) {
+        styleDeclarationCb({
+          path,
+          styleId,
+          remove: {
+            property
+          },
+          index: getNestedCSSRulePositions(thisArg.parentRule)
+        });
+      }
+      return target.apply(thisArg, argumentsList);
+    })
+  });
+  return callbackWrapper(() => {
+    win.CSSStyleDeclaration.prototype.setProperty = setProperty;
+    win.CSSStyleDeclaration.prototype.removeProperty = removeProperty;
+  });
+}
+function initMediaInteractionObserver({
+  mediaInteractionCb,
+  blockClass,
+  blockSelector,
+  mirror,
+  sampling,
+  doc
+}) {
+  const handler = callbackWrapper((type) => throttle(callbackWrapper((event) => {
+    const target = getEventTarget(event);
+    if (!target || isBlocked(target, blockClass, blockSelector, true)) {
+      return;
+    }
+    const { currentTime, volume, muted, playbackRate, loop } = target;
+    mediaInteractionCb({
+      type,
+      path: mirror.getPath(target),
+      currentTime,
+      volume,
+      muted,
+      playbackRate,
+      loop
+    });
+  }), sampling.media || 500));
+  const handlers = [
+    on("play", handler(0 /* Play */), doc),
+    on("pause", handler(1 /* Pause */), doc),
+    on("seeked", handler(2 /* Seeked */), doc),
+    on("volumechange", handler(3 /* VolumeChange */), doc),
+    on("ratechange", handler(4 /* RateChange */), doc)
+  ];
+  return callbackWrapper(() => {
+    handlers.forEach((h) => h());
+  });
+}
+function initSelectionObserver(param) {
+  const { doc, mirror, blockClass, blockSelector, selectionCb } = param;
+  let collapsed = true;
+  const updateSelection = callbackWrapper(() => {
+    const selection = doc.getSelection();
+    if (!selection || collapsed && selection?.isCollapsed)
+      return;
+    collapsed = selection.isCollapsed || false;
+    const ranges = [];
+    const count = selection.rangeCount || 0;
+    for (let i = 0;i < count; i++) {
+      const range = selection.getRangeAt(i);
+      const { startContainer, startOffset, endContainer, endOffset } = range;
+      const blocked = isBlocked(startContainer, blockClass, blockSelector, true) || isBlocked(endContainer, blockClass, blockSelector, true);
+      if (blocked)
+        continue;
+      ranges.push({
+        start: mirror.getPath(startContainer),
+        startOffset,
+        end: mirror.getPath(endContainer),
+        endOffset
+      });
+    }
+    selectionCb({ ranges });
+  });
+  updateSelection();
+  return on("selectionchange", updateSelection);
+}
+function initCustomElementObserver({ doc, customElementCb }) {
+  const win = doc.defaultView;
+  if (!win || !win.customElements)
+    return () => {};
+  const restoreHandler = patch(win.customElements, "define", (original) => function(name, constructor, options) {
+    try {
+      customElementCb({
+        define: {
+          name
+        }
+      });
+    } catch (_e) {
+      console.warn(`Custom element callback failed for ${name}`);
+    }
+    return original.apply(this, [name, constructor, options]);
+  });
+  return restoreHandler;
+}
+function initObservers(o) {
+  const currentWindow = o.doc.defaultView;
+  if (!currentWindow) {
+    return () => {};
+  }
+  const mutationObserver = initMutationObserver(o, o.doc);
+  const mousemoveHandler = initMoveObserver(o);
+  const mouseInteractionHandler = initMouseInteractionObserver(o);
+  const scrollHandler = initScrollObserver(o);
+  const viewportResizeHandler = initViewportResizeObserver(o, {
+    win: currentWindow
+  });
+  const inputHandler = initInputObserver(o);
+  const mediaInteractionHandler = initMediaInteractionObserver(o);
+  const styleSheetObserver = initStyleSheetObserver(o, { win: currentWindow });
+  const adoptedStyleSheetObserver = initAdoptedStyleSheetObserver(o, o.doc);
+  const styleDeclarationObserver = initStyleDeclarationObserver(o, {
+    win: currentWindow
+  });
+  let fontObserver = () => {};
+  if (o.collectFonts) {
+    Promise.resolve().then(() => (init_font_observer(), exports_font_observer)).then(({ initFontObserver: initFontObserver2 }) => {
+      fontObserver = initFontObserver2(o);
+    });
+  }
+  const selectionObserver = initSelectionObserver(o);
+  const customElementObserver = initCustomElementObserver(o);
+  return callbackWrapper(() => {
+    mutationBuffers.forEach((b) => b.reset());
+    mutationObserver.disconnect();
+    mousemoveHandler();
+    mouseInteractionHandler();
+    scrollHandler();
+    viewportResizeHandler();
+    inputHandler();
+    mediaInteractionHandler();
+    styleSheetObserver();
+    adoptedStyleSheetObserver();
+    styleDeclarationObserver();
+    fontObserver();
+    selectionObserver();
+    customElementObserver();
+  });
+}
+function hasNestedCSSRule(prop) {
+  return typeof window[prop] !== "undefined";
+}
+function canMonkeyPatchNestedCSSRule(prop) {
+  return Boolean(typeof window[prop] !== "undefined" && window[prop].prototype && "insertRule" in window[prop].prototype && "deleteRule" in window[prop].prototype);
+}
+
+// ../rrweb-record/src/record/processed-node-manager.ts
+class ProcessedNodeManager {
+  nodeMap = new WeakMap;
+  active = false;
+  inOtherBuffer(node, thisBuffer) {
+    const buffers = this.nodeMap.get(node);
+    return buffers && Array.from(buffers).some((buffer) => buffer !== thisBuffer);
+  }
+  add(node, buffer) {
+    if (!this.active) {
+      this.active = true;
+      requestAnimationFrame(() => {
+        this.nodeMap = new WeakMap;
+        this.active = false;
+      });
+    }
+    this.nodeMap.set(node, (this.nodeMap.get(node) || new Set).add(buffer));
+  }
+  destroy() {}
+}
+
+// ../rrweb-record/src/record/shadow-dom-manager.ts
+init_dom();
+init_snapshot_utils();
+init_utils();
+class ShadowDomManager {
+  shadowDoms = new WeakSet;
+  mutationCb;
+  scrollCb;
+  bypassOptions;
+  mirror;
+  restoreHandlers = [];
+  constructor(options) {
+    this.mutationCb = options.mutationCb;
+    this.scrollCb = options.scrollCb;
+    this.bypassOptions = options.bypassOptions;
+    this.mirror = options.mirror;
+    this.init();
+  }
+  init() {
+    this.reset();
+    this.patchAttachShadow(Element, document);
+  }
+  addShadowRoot(shadowRoot2, doc) {
+    if (!isNativeShadowDom(shadowRoot2))
+      return;
+    if (this.shadowDoms.has(shadowRoot2))
+      return;
+    this.shadowDoms.add(shadowRoot2);
+    const observer = initMutationObserver({
+      ...this.bypassOptions,
+      doc,
+      mutationCb: this.mutationCb,
+      mirror: this.mirror,
+      shadowDomManager: this
+    }, shadowRoot2);
+    this.restoreHandlers.push(() => observer.disconnect());
+    this.restoreHandlers.push(initScrollObserver({
+      ...this.bypassOptions,
+      scrollCb: this.scrollCb,
+      doc: shadowRoot2,
+      mirror: this.mirror
+    }));
+    setTimeout(() => {
+      if (shadowRoot2.adoptedStyleSheets && shadowRoot2.adoptedStyleSheets.length > 0)
+        this.bypassOptions.stylesheetManager.adoptStyleSheets(shadowRoot2.adoptedStyleSheets, this.mirror.getPath(dom_default.host(shadowRoot2)));
+      this.restoreHandlers.push(initAdoptedStyleSheetObserver({
+        mirror: this.mirror,
+        stylesheetManager: this.bypassOptions.stylesheetManager
+      }, shadowRoot2));
+    }, 0);
+  }
+  observeAttachShadow(iframeElement) {
+    if (!iframeElement.contentWindow || !iframeElement.contentDocument)
+      return;
+    this.patchAttachShadow(iframeElement.contentWindow.Element, iframeElement.contentDocument);
+  }
+  patchAttachShadow(element, doc) {
+    const manager = this;
+    this.restoreHandlers.push(patch(element.prototype, "attachShadow", (original) => function(option) {
+      const sRoot = original.call(this, option);
+      const shadowRootEl = dom_default.shadowRoot(this);
+      if (shadowRootEl && inDom(this))
+        manager.addShadowRoot(shadowRootEl, doc);
+      return sRoot;
+    }));
+  }
+  reset() {
+    this.restoreHandlers.forEach((handler) => {
+      try {
+        handler();
+      } catch (_e) {}
+    });
+    this.restoreHandlers = [];
+    this.shadowDoms = new WeakSet;
+  }
+}
+
+// ../rrweb-record/src/record/stylesheet-manager.ts
+init_snapshot_utils();
+init_utils();
+
+class StylesheetManager {
+  trackedLinkElements = new WeakSet;
+  mutationCb;
+  adoptedStyleSheetCb;
+  styleMirror = new StyleSheetMirror;
+  constructor(options) {
+    this.mutationCb = options.mutationCb;
+    this.adoptedStyleSheetCb = options.adoptedStyleSheetCb;
+  }
+  attachLinkElement(linkEl, childSn) {
+    if ("_cssText" in childSn.attributes)
+      this.mutationCb({
+        adds: [],
+        removes: [],
+        texts: [],
+        attributes: [
+          {
+            path: childSn.path,
+            attributes: childSn.attributes
+          }
+        ]
+      });
+    this.trackLinkElement(linkEl);
+  }
+  trackLinkElement(linkEl) {
+    if (this.trackedLinkElements.has(linkEl))
+      return;
+    this.trackedLinkElements.add(linkEl);
+    this.trackStylesheetInLinkElement(linkEl);
+  }
+  adoptStyleSheets(sheets, hostPath) {
+    if (sheets.length === 0)
+      return;
+    const adoptedStyleSheetData = {
+      path: hostPath,
+      styleIds: []
+    };
+    const styles = [];
+    for (const sheet of sheets) {
+      let styleId;
+      if (!this.styleMirror.has(sheet)) {
+        styleId = this.styleMirror.add(sheet);
+        styles.push({
+          styleId,
+          rules: Array.from(sheet.cssRules || sheet.rules, (r, index) => ({
+            rule: stringifyRule(r, sheet.href),
+            index
+          }))
+        });
+      } else
+        styleId = this.styleMirror.getId(sheet);
+      adoptedStyleSheetData.styleIds.push(styleId);
+    }
+    if (styles.length > 0)
+      adoptedStyleSheetData.styles = styles;
+    this.adoptedStyleSheetCb(adoptedStyleSheetData);
+  }
+  reset() {
+    this.styleMirror.reset();
+    this.trackedLinkElements = new WeakSet;
+  }
+  trackStylesheetInLinkElement(_linkEl) {}
+}
+
+// ../rrweb-record/src/record/index.ts
+var wrappedEmit;
+var takeFullSnapshot;
+var recording = false;
+var mirror = createMirror();
+function record(options = {}) {
+  const {
+    emit,
+    initialPageMetadata,
+    blockClass = "rr-block",
+    blockSelector = null,
+    ignoreClass = "rr-ignore",
+    ignoreSelector = null,
+    maskTextClass = "rr-mask",
+    maskTextSelector = null,
+    inlineStylesheet = true,
+    maskAllInputs,
+    maskInputOptions: _maskInputOptions,
+    slimDOMOptions: _slimDOMOptions,
+    maskInputFn,
+    maskTextFn,
+    sampling = {},
+    dataURLOptions = {},
+    recordCanvas = false,
+    recordCrossOriginIframes = false,
+    collectFonts = false,
+    inlineImages = false,
+    keepIframeSrcFn = () => false,
+    ignoreCSSAttributes = new Set([]),
+    errorHandler: errorHandler2
+  } = options;
+  registerErrorHandler(errorHandler2);
+  const inEmittingFrame = recordCrossOriginIframes ? window.parent === window : true;
+  let passEmitsToParent = false;
+  if (!inEmittingFrame) {
+    try {
+      if (window.parent.document) {
+        passEmitsToParent = false;
+      }
+    } catch (_e) {
+      passEmitsToParent = true;
+    }
+  }
+  if (inEmittingFrame && !emit) {
+    throw new Error("emit function is required");
+  }
+  if (!inEmittingFrame && !passEmitsToParent) {
+    return () => {};
+  }
+  mirror.reset();
+  const maskInputOptions = maskAllInputs === false ? _maskInputOptions !== undefined ? _maskInputOptions : { password: true } : {
+    color: true,
+    date: true,
+    "datetime-local": true,
+    email: true,
+    month: true,
+    number: true,
+    range: true,
+    search: true,
+    tel: true,
+    text: true,
+    time: true,
+    url: true,
+    week: true,
+    textarea: true,
+    select: true,
+    password: true
+  };
+  const slimDOMOptions = _slimDOMOptions === true || _slimDOMOptions === "all" ? {
+    script: true,
+    comment: true,
+    headFavicon: true,
+    headWhitespace: true,
+    headMetaSocial: true,
+    headMetaRobots: true,
+    headMetaHttpEquiv: true,
+    headMetaVerification: true,
+    headMetaAuthorship: _slimDOMOptions === "all",
+    headMetaDescKeywords: _slimDOMOptions === "all",
+    headTitleMutations: _slimDOMOptions === "all"
+  } : _slimDOMOptions ? _slimDOMOptions : {};
+  wrappedEmit = (r, isCheckout) => {
+    const e = r;
+    e.timestamp = nowTimestamp();
+    if (mutationBuffers[0]?.isFrozen() && e.type !== 7 /* Pageview */ && !(e.type === 3 /* IncrementalSnapshot */ && e.data.source === 0 /* Mutation */)) {
+      mutationBuffers.forEach((buf) => buf.unfreeze());
+    }
+    if (inEmittingFrame) {
+      emit?.(e, isCheckout);
+    } else if (passEmitsToParent) {
+      const message = {
+        type: "rrweb",
+        event: e,
+        origin: window.location.origin,
+        isCheckout
+      };
+      window.parent.postMessage(message, "*");
+    }
+  };
+  const wrappedMutationEmit = (m) => {
+    wrappedEmit({
+      type: 3 /* IncrementalSnapshot */,
+      data: {
+        source: 0 /* Mutation */,
+        ...m
+      }
+    });
+  };
+  const wrappedScrollEmit = (p) => wrappedEmit({
+    type: 3 /* IncrementalSnapshot */,
+    data: {
+      source: 3 /* Scroll */,
+      ...p
+    }
+  });
+  const wrappedCanvasMutationEmit = (p) => wrappedEmit({
+    type: 3 /* IncrementalSnapshot */,
+    data: {
+      source: 9 /* CanvasMutation */,
+      ...p
+    }
+  });
+  const wrappedAdoptedStyleSheetEmit = (a) => wrappedEmit({
+    type: 3 /* IncrementalSnapshot */,
+    data: {
+      source: 15 /* AdoptedStyleSheet */,
+      ...a
+    }
+  });
+  const stylesheetManager = new StylesheetManager({
+    mutationCb: wrappedMutationEmit,
+    adoptedStyleSheetCb: wrappedAdoptedStyleSheetEmit
+  });
+  const iframeManager = new IframeManager({
+    mirror,
+    mutationCb: wrappedMutationEmit,
+    stylesheetManager,
+    recordCrossOriginIframes,
+    wrappedEmit
+  });
+  const processedNodeManager = new ProcessedNodeManager;
+  let canvasManager = null;
+  if (recordCanvas) {
+    Promise.resolve().then(() => (init_canvas_manager(), exports_canvas_manager)).then(({ CanvasManager: CanvasManager2 }) => {
+      canvasManager = new CanvasManager2({
+        recordCanvas,
+        mutationCb: wrappedCanvasMutationEmit,
+        win: window,
+        blockClass,
+        blockSelector,
+        mirror,
+        sampling: sampling.canvas,
+        dataURLOptions
+      });
+      for (const buf of mutationBuffers) {
+        buf.setCanvasManager(canvasManager);
+      }
+    });
+  }
+  const shadowDomManager = new ShadowDomManager({
+    mutationCb: wrappedMutationEmit,
+    scrollCb: wrappedScrollEmit,
+    bypassOptions: {
+      blockClass,
+      blockSelector,
+      maskTextClass,
+      maskTextSelector,
+      inlineStylesheet,
+      maskInputOptions,
+      dataURLOptions,
+      maskTextFn,
+      maskInputFn,
+      recordCanvas,
+      inlineImages,
+      sampling,
+      slimDOMOptions,
+      iframeManager,
+      stylesheetManager,
+      canvasManager,
+      keepIframeSrcFn,
+      processedNodeManager
+    },
+    mirror
+  });
+  takeFullSnapshot = (isCheckout = false, pageMetadata) => {
+    stylesheetManager.reset();
+    shadowDomManager.init();
+    mutationBuffers.forEach((buf) => buf.lock());
+    const node = snapshot_default(document, {
+      mirror,
+      blockClass,
+      blockSelector,
+      maskTextClass,
+      maskTextSelector,
+      inlineStylesheet,
+      maskAllInputs: maskInputOptions,
+      maskTextFn,
+      maskInputFn,
+      slimDOM: slimDOMOptions,
+      dataURLOptions,
+      recordCanvas,
+      inlineImages,
+      onSerialize: (n) => {
+        if (isSerializedIframe(n, mirror)) {
+          iframeManager.addIframe(n);
+        }
+        if (isSerializedStylesheet(n, mirror)) {
+          stylesheetManager.trackLinkElement(n);
+        }
+        if (hasShadowRoot(n)) {
+          shadowDomManager.addShadowRoot(dom_default.shadowRoot(n), document);
+        }
+      },
+      onIframeLoad: (iframe, childSn) => {
+        iframeManager.attachIframe(iframe, childSn);
+        shadowDomManager.observeAttachShadow(iframe);
+      },
+      onStylesheetLoad: (linkEl, childSn) => {
+        stylesheetManager.attachLinkElement(linkEl, childSn);
+      },
+      keepIframeSrcFn
+    });
+    if (!node) {
+      return console.warn("Failed to snapshot the document");
+    }
+    wrappedEmit({
+      type: 7 /* Pageview */,
+      data: {
+        href: window.location.href,
+        width: getWindowWidth(),
+        height: getWindowHeight(),
+        node,
+        initialOffset: getWindowScroll(window),
+        ...pageMetadata
+      }
+    }, isCheckout);
+    mutationBuffers.forEach((buf) => buf.unlock());
+    if (document.adoptedStyleSheets && document.adoptedStyleSheets.length > 0)
+      stylesheetManager.adoptStyleSheets(document.adoptedStyleSheets, mirror.getPath(document));
+  };
+  try {
+    const handlers = [];
+    const observe = (doc) => {
+      return callbackWrapper(initObservers)({
+        mutationCb: wrappedMutationEmit,
+        mousemoveCb: (positions, source) => wrappedEmit({
+          type: 3 /* IncrementalSnapshot */,
+          data: {
+            source,
+            positions
+          }
+        }),
+        mouseInteractionCb: (d) => wrappedEmit({
+          type: 3 /* IncrementalSnapshot */,
+          data: {
+            source: 2 /* MouseInteraction */,
+            ...d
+          }
+        }),
+        scrollCb: wrappedScrollEmit,
+        viewportResizeCb: (d) => wrappedEmit({
+          type: 3 /* IncrementalSnapshot */,
+          data: {
+            source: 4 /* ViewportResize */,
+            ...d
+          }
+        }),
+        inputCb: (v) => wrappedEmit({
+          type: 3 /* IncrementalSnapshot */,
+          data: {
+            source: 5 /* Input */,
+            ...v
+          }
+        }),
+        mediaInteractionCb: (p) => wrappedEmit({
+          type: 3 /* IncrementalSnapshot */,
+          data: {
+            source: 7 /* MediaInteraction */,
+            ...p
+          }
+        }),
+        styleSheetRuleCb: (r) => wrappedEmit({
+          type: 3 /* IncrementalSnapshot */,
+          data: {
+            source: 8 /* StyleSheetRule */,
+            ...r
+          }
+        }),
+        styleDeclarationCb: (r) => wrappedEmit({
+          type: 3 /* IncrementalSnapshot */,
+          data: {
+            source: 13 /* StyleDeclaration */,
+            ...r
+          }
+        }),
+        canvasMutationCb: wrappedCanvasMutationEmit,
+        fontCb: (p) => wrappedEmit({
+          type: 3 /* IncrementalSnapshot */,
+          data: {
+            source: 10 /* Font */,
+            ...p
+          }
+        }),
+        selectionCb: (p) => {
+          wrappedEmit({
+            type: 3 /* IncrementalSnapshot */,
+            data: {
+              source: 14 /* Selection */,
+              ...p
+            }
+          });
+        },
+        customElementCb: (c) => {
+          wrappedEmit({
+            type: 3 /* IncrementalSnapshot */,
+            data: {
+              source: 16 /* CustomElement */,
+              ...c
+            }
+          });
+        },
+        blockClass,
+        ignoreClass,
+        ignoreSelector,
+        maskTextClass,
+        maskTextSelector,
+        maskInputOptions,
+        inlineStylesheet,
+        sampling,
+        recordCanvas,
+        inlineImages,
+        collectFonts,
+        doc,
+        maskInputFn,
+        maskTextFn,
+        keepIframeSrcFn,
+        blockSelector,
+        slimDOMOptions,
+        dataURLOptions,
+        mirror,
+        iframeManager,
+        stylesheetManager,
+        shadowDomManager,
+        processedNodeManager,
+        canvasManager,
+        ignoreCSSAttributes
+      });
+    };
+    iframeManager.addLoadListener((iframeEl) => {
+      try {
+        handlers.push(observe(iframeEl.contentDocument));
+      } catch (error) {
+        console.warn(error);
+      }
+    });
+    const init = () => {
+      takeFullSnapshot(false, initialPageMetadata);
+      handlers.push(observe(document));
+      recording = true;
+    };
+    if (document.readyState === "interactive" || document.readyState === "complete") {
+      init();
+    } else {
+      handlers.push(on("DOMContentLoaded", () => {
+        wrappedEmit({
+          type: 0 /* DomContentLoaded */,
+          data: {}
+        });
+      }));
+      handlers.push(on("load", () => {
+        wrappedEmit({
+          type: 1 /* Load */,
+          data: {}
+        });
+        init();
+      }, window));
+    }
+    return () => {
+      handlers.forEach((h) => h());
+      processedNodeManager.destroy();
+      recording = false;
+      unregisterErrorHandler();
+    };
+  } catch (error) {
+    console.warn(error);
+  }
+}
+record.addCustomEvent = (tag, payload) => {
+  if (!recording) {
+    throw new Error("please add custom event after start recording");
+  }
+  wrappedEmit({
+    type: 5 /* Custom */,
+    data: {
+      tag,
+      payload
+    }
+  });
+};
+record.freezePage = () => {
+  mutationBuffers.forEach((buf) => buf.freeze());
+};
+record.takeFullSnapshot = (isCheckout) => {
+  if (!recording) {
+    throw new Error("please take full snapshot after start recording");
+  }
+  takeFullSnapshot(isCheckout);
+};
+record.takePageviewSnapshot = (metadata) => {
+  if (!recording) {
+    throw new Error("please take pageview snapshot after start recording");
+  }
+  flushMutationObservers();
+  mutationBuffers.forEach((buf) => buf.dropPending());
+  takeFullSnapshot(false, metadata);
+};
+record.mirror = mirror;
+var record_default = record;
+
+// ../rrweb-record/src/index.ts
+init_snapshot_utils();
+
+// src/persistence.ts
+var VISITOR_COOKIE = "__ld_vid";
+var SESSION_COOKIE = "__ld_sid";
+var VISITOR_MAX_AGE = 365 * 24 * 60 * 60;
+var SESSION_MAX_AGE = 30 * 60;
+function getCookie(name) {
+  const match = document.cookie.match(new RegExp(`(?:^|;\\s*)${name}=([^;]*)`));
+  return match?.[1] ? decodeURIComponent(match[1]) : null;
+}
+function setCookie(name, value, maxAge) {
+  document.cookie = `${name}=${encodeURIComponent(value)};path=/;max-age=${maxAge};SameSite=Lax`;
+}
+function deleteCookie(name) {
+  document.cookie = `${name}=;path=/;max-age=0;SameSite=Lax`;
+}
+function createCookiePersistence() {
+  return {
+    mode: "cookie",
+    getVisitorId() {
+      return getCookie(VISITOR_COOKIE);
+    },
+    getSessionId() {
+      return getCookie(SESSION_COOKIE);
+    },
+    setVisitorId(id) {
+      setCookie(VISITOR_COOKIE, id, VISITOR_MAX_AGE);
+    },
+    setSessionId(id) {
+      setCookie(SESSION_COOKIE, id, SESSION_MAX_AGE);
+    },
+    touchSession() {
+      const sid = getCookie(SESSION_COOKIE);
+      if (sid)
+        setCookie(SESSION_COOKIE, sid, SESSION_MAX_AGE);
+    },
+    clear() {
+      deleteCookie(VISITOR_COOKIE);
+      deleteCookie(SESSION_COOKIE);
+    }
+  };
+}
+function createCookielessPersistence() {
+  return {
+    mode: "cookieless",
+    getVisitorId: () => null,
+    getSessionId: () => null,
+    setVisitorId: () => {},
+    setSessionId: () => {},
+    touchSession: () => {},
+    clear: () => {}
+  };
+}
+function createPersistence(mode) {
+  return mode === "cookie" ? createCookiePersistence() : createCookielessPersistence();
+}
+
+// src/recorder-core.ts
+var DEFAULT_ENDPOINT = "https://ingest.lunardinos.com";
+async function gzipCompress(input) {
+  try {
+    if (typeof CompressionStream === "undefined")
+      return null;
+    const blob = new Blob([input]);
+    const stream = blob.stream().pipeThrough(new CompressionStream("gzip"));
+    return await new Response(stream).blob();
+  } catch {
+    return null;
+  }
+}
+var INTERACTIVE_TAGS = new Set(["a", "button", "input", "select", "textarea"]);
+function findInteractiveElement(target) {
+  let el = target;
+  while (el && el !== document.body) {
+    if (INTERACTIVE_TAGS.has(el.tagName.toLowerCase()) || el.getAttribute("role")) {
+      return el;
+    }
+    el = el.parentElement;
+  }
+  return target;
+}
+function getDirectText(el) {
+  const text = el.innerText?.trim().slice(0, 80);
+  return text || null;
+}
+function truncateText(text) {
+  if (!text)
+    return null;
+  return text.length > 40 ? `${text.slice(0, 37)}...` : text;
+}
+function extractUtmParams() {
+  const params = new URLSearchParams(window.location.search);
+  const utm = {};
+  for (const key of ["utm_source", "utm_medium", "utm_campaign", "utm_term", "utm_content"]) {
+    const val = params.get(key);
+    if (val)
+      utm[key] = val;
+  }
+  return utm;
+}
+function createLunarDinosRecorder(config) {
+  const { apiKey, endpoint = DEFAULT_ENDPOINT, rrwebOptions = {}, batchInterval = 2000 } = config;
+  const defaultRrwebOptions = {
+    inlineImages: true
+  };
+  const url = `${endpoint}/api/events`;
+  let persistence = createPersistence(config.defaultPersistence ?? "cookie");
+  function beaconUrl() {
+    const u = new URL(url);
+    u.searchParams.set("key", apiKey);
+    if (persistence.mode === "cookieless")
+      u.searchParams.set("cookieless", "1");
+    return u.toString();
+  }
+  function send(body, headers) {
+    const reqHeaders = {
+      ...headers,
+      Authorization: `Bearer ${apiKey}`
+    };
+    if (persistence.mode === "cookieless") {
+      reqHeaders["X-LD-Cookieless"] = "1";
+    }
+    fetch(url, {
+      method: "POST",
+      headers: reqHeaders,
+      body
+    }).catch(() => {});
+  }
+  function sendViaBeacon(json) {
+    try {
+      const blob = new Blob([json], { type: "text/plain" });
+      const sent = navigator.sendBeacon(beaconUrl(), blob);
+      if (sent)
+        return;
+    } catch {}
+    try {
+      fetch(beaconUrl(), {
+        method: "POST",
+        body: json,
+        headers: { "Content-Type": "application/json" },
+        keepalive: true
+      }).catch(() => {});
+    } catch {}
+  }
+  let events = [];
+  let sessionId = null;
+  let visitorId = null;
+  let stopFn = null;
+  let intervalId = null;
+  let recording2 = false;
+  let pendingClickContext = null;
+  let pendingInputContext = null;
+  function captureSubmit(e) {
+    if (!recording2)
+      return;
+    const form = e.target;
+    const formName = form.getAttribute("name") ?? form.getAttribute("id") ?? form.getAttribute("aria-label") ?? null;
+    const formAction = form.getAttribute("action") ?? null;
+    try {
+      record_default.addCustomEvent("submit", { formName, formAction });
+    } catch {}
+  }
+  function captureInputContext(e) {
+    const el = e.target;
+    const tag = el.tagName?.toLowerCase();
+    if (tag !== "input" && tag !== "select" && tag !== "textarea")
+      return;
+    const inputEl = el;
+    const inputName = inputEl.getAttribute("name") ?? inputEl.getAttribute("id") ?? inputEl.getAttribute("aria-label") ?? (tag !== "select" ? inputEl.getAttribute("placeholder") : null) ?? (() => {
+      const id = inputEl.id;
+      if (id) {
+        const label = document.querySelector(`label[for="${id}"]`);
+        if (label)
+          return truncateText(label.textContent?.trim() ?? null);
+      }
+      const parentLabel = inputEl.closest("label");
+      return truncateText(parentLabel?.textContent?.trim() ?? null);
+    })() ?? null;
+    pendingInputContext = { inputTag: tag, inputName };
+  }
+  function captureClickContext(e) {
+    const raw = e.target;
+    const clicked = findInteractiveElement(raw);
+    const tag = clicked.tagName?.toLowerCase() ?? "unknown";
+    const TAG_ROLES = {
+      button: "button",
+      a: "link",
+      input: "textbox",
+      select: "combobox",
+      textarea: "textbox"
+    };
+    const role = clicked.getAttribute("role") ?? TAG_ROLES[tag] ?? null;
+    const name = clicked.getAttribute("aria-label") ?? clicked.getAttribute("name") ?? clicked.getAttribute("title") ?? truncateText(getDirectText(clicked)) ?? clicked.querySelector("[aria-label]")?.getAttribute("aria-label") ?? null;
+    const href = tag === "a" ? clicked.getAttribute("href") : clicked.closest("a")?.getAttribute("href") ?? null;
+    pendingClickContext = { clickTag: tag, clickRole: role, clickName: name, clickHref: href };
+  }
+  function flush(options) {
+    if (events.length === 0 || !sessionId)
+      return;
+    const batch = events.splice(0);
+    const id = sessionId;
+    const vid = visitorId;
+    const payload = { sessionId: id, events: batch };
+    if (vid)
+      payload.visitorId = vid;
+    const json = JSON.stringify(payload);
+    persistence.touchSession();
+    if (options?.beacon) {
+      sendViaBeacon(json);
+      return;
+    }
+    gzipCompress(json).then((compressed) => {
+      if (compressed && compressed.size < json.length) {
+        send(compressed, {
+          "Content-Type": "application/json",
+          "Content-Encoding": "gzip"
+        });
+      } else {
+        send(json, { "Content-Type": "application/json" });
+      }
+    });
+  }
+  function identify(payload) {
+    if (!recording2)
+      return;
+    try {
+      record_default.addCustomEvent("identify", payload);
+    } catch {}
+    flush();
+  }
+  function emitPageEvent(payload) {
+    if (!recording2)
+      return;
+    try {
+      record_default.takePageviewSnapshot({
+        href: payload.href,
+        title: payload.title,
+        routePattern: payload.routePattern ?? undefined,
+        params: payload.params,
+        referrer: payload.referrer ?? externalReferrer()
+      });
+    } catch {}
+  }
+  function captureError(e) {
+    if (!recording2)
+      return;
+    try {
+      record_default.addCustomEvent("error", {
+        message: e.message ?? "Unknown error",
+        source: e.filename ?? null
+      });
+    } catch {}
+  }
+  function captureRejection(e) {
+    if (!recording2)
+      return;
+    try {
+      const message = e.reason instanceof Error ? e.reason.message : String(e.reason ?? "Unhandled rejection");
+      record_default.addCustomEvent("error", {
+        message,
+        source: null
+      });
+    } catch {}
+  }
+  function externalReferrer() {
+    const ref = document.referrer;
+    if (!ref)
+      return null;
+    try {
+      return new URL(ref).origin === window.location.origin ? null : ref;
+    } catch {
+      return ref;
+    }
+  }
+  function emitSessionMeta() {
+    try {
+      const utm = extractUtmParams();
+      record_default.addCustomEvent("session:meta", {
+        referrer: externalReferrer(),
+        landingPage: window.location.pathname,
+        ...utm
+      });
+    } catch {}
+  }
+  function start(optionsOrSessionId) {
+    if (recording2)
+      return sessionId;
+    const startOpts = typeof optionsOrSessionId === "string" ? { sessionId: optionsOrSessionId } : optionsOrSessionId ?? {};
+    const existingSessionId = startOpts.sessionId;
+    const SESSION_STORAGE_KEY = "__ld_sid";
+    let isNewSession = false;
+    if (persistence.mode === "cookie") {
+      const persistedSession = persistence.getSessionId();
+      const storedSession = typeof sessionStorage !== "undefined" ? sessionStorage.getItem(SESSION_STORAGE_KEY) : null;
+      isNewSession = !persistedSession && !storedSession;
+      sessionId = persistedSession || storedSession || existingSessionId || crypto.randomUUID();
+      persistence.setSessionId(sessionId);
+      if (typeof sessionStorage !== "undefined") {
+        sessionStorage.setItem(SESSION_STORAGE_KEY, sessionId);
+      }
+    } else {
+      sessionId = existingSessionId || crypto.randomUUID();
+    }
+    visitorId = persistence.getVisitorId();
+    if (!visitorId && persistence.mode === "cookie") {
+      visitorId = crypto.randomUUID();
+      persistence.setVisitorId(visitorId);
+    }
+    events = [];
+    recording2 = true;
+    document.addEventListener("click", captureClickContext, true);
+    document.addEventListener("input", captureInputContext, true);
+    document.addEventListener("change", captureInputContext, true);
+    document.addEventListener("submit", captureSubmit, true);
+    window.addEventListener("error", captureError);
+    window.addEventListener("unhandledrejection", captureRejection);
+    stopFn = record_default({
+      ...defaultRrwebOptions,
+      ...rrwebOptions,
+      initialPageMetadata: startOpts.pageMetadata ? {
+        href: startOpts.pageMetadata.href,
+        title: startOpts.pageMetadata.title,
+        routePattern: startOpts.pageMetadata.routePattern ?? undefined,
+        params: startOpts.pageMetadata.params,
+        referrer: startOpts.pageMetadata.referrer ?? undefined
+      } : undefined,
+      emit(event) {
+        const ev = event;
+        if (ev.type === 3 && ev.data?.source === 2 && ev.data?.type === 2 && pendingClickContext) {
+          const d = ev.data;
+          d.clickTag = pendingClickContext.clickTag;
+          d.clickRole = pendingClickContext.clickRole;
+          d.clickName = pendingClickContext.clickName;
+          d.clickHref = pendingClickContext.clickHref;
+          pendingClickContext = null;
+        }
+        if (ev.type === 3 && ev.data?.source === 5 && pendingInputContext) {
+          const d = ev.data;
+          d.inputTag = pendingInputContext.inputTag;
+          d.inputName = pendingInputContext.inputName;
+          pendingInputContext = null;
+        }
+        events.push(event);
+      }
+    });
+    if (persistence.mode === "cookieless" || isNewSession) {
+      emitSessionMeta();
+    }
+    flush();
+    intervalId = setInterval(flush, batchInterval);
+    return sessionId;
+  }
+  function stop() {
+    if (!recording2)
+      return;
+    document.removeEventListener("click", captureClickContext, true);
+    document.removeEventListener("input", captureInputContext, true);
+    document.removeEventListener("change", captureInputContext, true);
+    document.removeEventListener("submit", captureSubmit, true);
+    window.removeEventListener("error", captureError);
+    window.removeEventListener("unhandledrejection", captureRejection);
+    try {
+      record_default.addCustomEvent("session:end", {});
+    } catch {}
+    flush();
+    if (intervalId) {
+      clearInterval(intervalId);
+      intervalId = null;
+    }
+    stopFn?.();
+    stopFn = null;
+    recording2 = false;
+    sessionId = null;
+    visitorId = null;
+    events = [];
+    pendingClickContext = null;
+    pendingInputContext = null;
+  }
+  function setPersistence(mode) {
+    const oldMode = persistence.mode;
+    if (oldMode === mode)
+      return;
+    if (oldMode === "cookieless" && mode === "cookie") {
+      persistence.clear();
+      persistence = createPersistence("cookie");
+      const newVisitorId = crypto.randomUUID();
+      persistence.setVisitorId(newVisitorId);
+      if (sessionId)
+        persistence.setSessionId(sessionId);
+      const oldVisitorId = visitorId;
+      visitorId = newVisitorId;
+      if (recording2 && oldVisitorId !== newVisitorId) {
+        try {
+          record_default.addCustomEvent("visitor:link", {
+            previousVisitorId: oldVisitorId,
+            newVisitorId
+          });
+        } catch {}
+      }
+    } else if (oldMode === "cookie" && mode === "cookieless") {
+      persistence.clear();
+      persistence = createPersistence("cookieless");
+      visitorId = null;
+    }
+  }
+  return {
+    start,
+    stop,
+    flush,
+    getSessionId: () => sessionId,
+    getVisitorId: () => visitorId,
+    isRecording: () => recording2,
+    emitPageEvent,
+    identify,
+    setPersistence
+  };
+}
+export {
+  createLunarDinosRecorder
+};