@posthog/rrweb-snapshot 0.0.40 → 0.0.42

package/dist/record-oACzRSl-.umd.cjs

@@ -0,0 +1,1569 @@
+(function (g, f) {if ("object" == typeof exports && "object" == typeof module) {module.exports = f();} else if ("function" == typeof define && define.amd) {define("rrwebSnapshotRecord", [], f);} else if ("object" == typeof exports) {exports["rrwebSnapshotRecord"] = f();} else {g["rrwebSnapshotRecord"] = f();}}(typeof self !== 'undefined' ? self : typeof globalThis !== 'undefined' ? globalThis : this, () => {var exports = {};var module = { exports };
+"use strict";
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// dist/types-B7TTv7Jc.cjs
+var require_types_B7TTv7Jc = __commonJS({
+  "dist/types-B7TTv7Jc.cjs"(exports2) {
+    "use strict";
+    var __defProp = Object.defineProperty;
+    var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+    var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+    var NodeType$1 = /* @__PURE__ */ ((NodeType2) => {
+      NodeType2[NodeType2["Document"] = 0] = "Document";
+      NodeType2[NodeType2["DocumentType"] = 1] = "DocumentType";
+      NodeType2[NodeType2["Element"] = 2] = "Element";
+      NodeType2[NodeType2["Text"] = 3] = "Text";
+      NodeType2[NodeType2["CDATA"] = 4] = "CDATA";
+      NodeType2[NodeType2["Comment"] = 5] = "Comment";
+      return NodeType2;
+    })(NodeType$1 || {});
+    var testableAccessors = {
+      Node: ["childNodes", "parentNode", "parentElement", "textContent"],
+      ShadowRoot: ["host", "styleSheets"],
+      Element: ["shadowRoot", "querySelector", "querySelectorAll"],
+      MutationObserver: []
+    };
+    var testableMethods = {
+      Node: ["contains", "getRootNode"],
+      ShadowRoot: ["getSelection"],
+      Element: [],
+      MutationObserver: ["constructor"]
+    };
+    var untaintedBasePrototype = {};
+    function angularZoneUnpatchedAlternative(key) {
+      var _a, _b;
+      const angularUnpatchedVersionSymbol = (_b = (_a = globalThis == null ? void 0 : globalThis.Zone) == null ? void 0 : _a.__symbol__) == null ? void 0 : _b.call(_a, key);
+      if (angularUnpatchedVersionSymbol && globalThis[angularUnpatchedVersionSymbol]) {
+        return globalThis[angularUnpatchedVersionSymbol];
+      } else {
+        return void 0;
+      }
+    }
+    function getUntaintedPrototype(key) {
+      if (untaintedBasePrototype[key])
+        return untaintedBasePrototype[key];
+      const candidate = angularZoneUnpatchedAlternative(key) || globalThis[key];
+      const defaultPrototype = candidate.prototype;
+      const accessorNames = key in testableAccessors ? testableAccessors[key] : void 0;
+      const isUntaintedAccessors = Boolean(
+        accessorNames && // @ts-expect-error 2345
+        accessorNames.every(
+          (accessor) => {
+            var _a, _b;
+            return Boolean(
+              (_b = (_a = Object.getOwnPropertyDescriptor(defaultPrototype, accessor)) == null ? void 0 : _a.get) == null ? void 0 : _b.toString().includes("[native code]")
+            );
+          }
+        )
+      );
+      const methodNames = key in testableMethods ? testableMethods[key] : void 0;
+      const isUntaintedMethods = Boolean(
+        methodNames && methodNames.every(
+          // @ts-expect-error 2345
+          (method) => {
+            var _a;
+            return typeof defaultPrototype[method] === "function" && ((_a = defaultPrototype[method]) == null ? void 0 : _a.toString().includes("[native code]"));
+          }
+        )
+      );
+      if (isUntaintedAccessors && isUntaintedMethods) {
+        untaintedBasePrototype[key] = candidate.prototype;
+        return candidate.prototype;
+      }
+      try {
+        const iframeEl = document.createElement("iframe");
+        document.body.appendChild(iframeEl);
+        const win = iframeEl.contentWindow;
+        if (!win) return candidate.prototype;
+        const untaintedObject = win[key].prototype;
+        document.body.removeChild(iframeEl);
+        if (!untaintedObject) return defaultPrototype;
+        return untaintedBasePrototype[key] = untaintedObject;
+      } catch (e) {
+        return defaultPrototype;
+      }
+    }
+    var untaintedAccessorCache = {};
+    function getUntaintedAccessor(key, instance, accessor) {
+      var _a;
+      const cacheKey = `${key}.${String(accessor)}`;
+      if (untaintedAccessorCache[cacheKey])
+        return untaintedAccessorCache[cacheKey].call(
+          instance
+        );
+      const untaintedPrototype = getUntaintedPrototype(key);
+      const untaintedAccessor = (_a = Object.getOwnPropertyDescriptor(
+        untaintedPrototype,
+        accessor
+      )) == null ? void 0 : _a.get;
+      if (!untaintedAccessor) return instance[accessor];
+      untaintedAccessorCache[cacheKey] = untaintedAccessor;
+      return untaintedAccessor.call(instance);
+    }
+    var untaintedMethodCache = {};
+    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;
+    }
+    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 (e) {
+        return () => {
+        };
+      }
+    }
+    var index = {
+      childNodes,
+      parentNode,
+      parentElement,
+      textContent,
+      contains,
+      getRootNode,
+      host,
+      styleSheets,
+      shadowRoot,
+      querySelector,
+      querySelectorAll,
+      mutationObserver: mutationObserverCtor,
+      patch
+    };
+    function isElement(n) {
+      return n.nodeType === n.ELEMENT_NODE;
+    }
+    function isShadowRoot(n) {
+      const hostEl = (
+        // anchor and textarea elements also have a `host` property
+        // but only shadow roots have a `mode` property
+        n && "host" in n && "mode" in n && index.host(n) || null
+      );
+      return Boolean(
+        hostEl && "shadowRoot" in hostEl && index.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) {
+          sheetHref = s.ownerNode.baseURI;
+        }
+        const stringifiedRules = Array.from(
+          rules,
+          (rule) => stringifyRule(rule, sheetHref)
+        ).join("");
+        return fixBrowserCompatibilityIssuesInCSS(stringifiedRules);
+      } catch (error) {
+        return null;
+      }
+    }
+    function stringifyRule(rule, sheetHref) {
+      var _a;
+      if (isCSSImportRule(rule)) {
+        let importStringified;
+        try {
+          importStringified = // for same-origin stylesheets,
+          // we can access the imported stylesheet rules directly
+          stringifyStylesheet(rule.styleSheet) || // work around browser issues with the raw string `@import url(...)` statement
+          escapeImportStatement(rule);
+        } catch (error) {
+          importStringified = rule.cssText;
+        }
+        try {
+          if (importStringified && ((_a = rule.styleSheet) == null ? void 0 : _a.href)) {
+            return absolutifyURLs(importStringified, rule.styleSheet.href);
+          }
+        } catch (e) {
+        }
+        return importStringified;
+      } else {
+        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;
+    }
+    var Mirror = class {
+      constructor() {
+        __publicField(this, "idNodeMap", /* @__PURE__ */ new Map());
+        __publicField(this, "nodeMetaMap", /* @__PURE__ */ new WeakMap());
+      }
+      getId(n) {
+        var _a;
+        if (!n) return -1;
+        const id = (_a = this.getMeta(n)) == null ? void 0 : _a.id;
+        return id != null ? id : -1;
+      }
+      getNode(id) {
+        return this.idNodeMap.get(id) || null;
+      }
+      getIds() {
+        return Array.from(this.idNodeMap.keys());
+      }
+      getMeta(n) {
+        return this.nodeMetaMap.get(n) || null;
+      }
+      // removes the node from idNodeMap
+      // doesn't remove the node from nodeMetaMap
+      removeNodeFromMap(n) {
+        const id = this.getId(n);
+        this.idNodeMap.delete(id);
+        if (n.childNodes) {
+          n.childNodes.forEach(
+            (childNode) => this.removeNodeFromMap(childNode)
+          );
+        }
+        if (isElement(n)) {
+          const shadowRootEl = index.shadowRoot(n);
+          if (shadowRootEl) {
+            this.removeNodeFromMap(shadowRootEl);
+          }
+          if (n.nodeName === "IFRAME" && n.contentDocument) {
+            this.removeNodeFromMap(
+              n.contentDocument
+            );
+          }
+        }
+      }
+      has(id) {
+        return this.idNodeMap.has(id);
+      }
+      hasNode(node) {
+        return this.nodeMetaMap.has(node);
+      }
+      add(n, meta) {
+        const id = meta.id;
+        this.idNodeMap.set(id, n);
+        this.nodeMetaMap.set(n, meta);
+      }
+      replace(id, n) {
+        const oldNode = this.getNode(id);
+        if (oldNode) {
+          const meta = this.nodeMetaMap.get(oldNode);
+          if (meta) this.nodeMetaMap.set(n, meta);
+        }
+        this.idNodeMap.set(id, n);
+      }
+      reset() {
+        this.idNodeMap = /* @__PURE__ */ new Map();
+        this.nodeMetaMap = /* @__PURE__ */ new WeakMap();
+      }
+    };
+    function createMirror() {
+      return new Mirror();
+    }
+    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);
+        }
+      }
+      return text;
+    }
+    function toLowerCase(str) {
+      return str.toLowerCase();
+    }
+    var ORIGINAL_ATTRIBUTE_NAME = "__rrweb_original__";
+    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(
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
+            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 isNodeMetaEqual(a, b) {
+      if (!a || !b || a.type !== b.type) return false;
+      if (a.type === NodeType$1.Document)
+        return a.compatMode === b.compatMode;
+      else if (a.type === NodeType$1.DocumentType)
+        return a.name === b.name && a.publicId === b.publicId && a.systemId === b.systemId;
+      else if (a.type === NodeType$1.Comment || a.type === NodeType$1.Text || a.type === NodeType$1.CDATA)
+        return a.textContent === b.textContent;
+      else if (a.type === NodeType$1.Element)
+        return a.tagName === b.tagName && JSON.stringify(a.attributes) === JSON.stringify(b.attributes) && a.isSVG === b.isSVG && a.needBlock === b.needBlock;
+      return false;
+    }
+    function getInputType(element) {
+      const type = element.type;
+      return element.hasAttribute("data-rr-is-password") ? "password" : type ? (
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+        toLowerCase(type)
+      ) : null;
+    }
+    function extractFileExtension(path, baseURL) {
+      var _a;
+      let url;
+      try {
+        url = new URL(path, baseURL != null ? baseURL : window.location.href);
+      } catch (err) {
+        return null;
+      }
+      const regex = /\.([0-9a-z]+)(?:$)/i;
+      const match = url.pathname.match(regex);
+      return (_a = match == null ? void 0 : match[1]) != null ? _a : 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;
+    }
+    var URL_IN_CSS_REF = /url\((?:(')([^']*)'|(")(.*?)"|([^)]*))\)/gm;
+    var URL_PROTOCOL_MATCH = /^(?:[a-z+]+:)?\/\//i;
+    var URL_WWW_MATCH = /^www\..*/i;
+    var DATA_URI = /^(data:)([^,]*),(.*)/i;
+    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 === ".") {
+              continue;
+            } else if (part === "..") {
+              stack.pop();
+            } else {
+              stack.push(part);
+            }
+          }
+          return `url(${maybeQuote}${stack.join("/")}${maybeQuote})`;
+        }
+      );
+    }
+    var STRIPED_PLACEHOLDER_SVG = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTAwJSIgaGVpZ2h0PSIxMDAlIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPgogIDxkZWZzPgogICAgPHBhdHRlcm4gaWQ9InN0cmlwZXMiIHBhdHRlcm5Vbml0cz0idXNlclNwYWNlT25Vc2UiIHdpZHRoPSIxNiIgaGVpZ2h0PSIxNiI+CiAgICAgIDxyZWN0IHdpZHRoPSIxNiIgaGVpZ2h0PSIxNiIgZmlsbD0iYmxhY2siLz4KICAgICAgPHBhdGggZD0iTTggMEgxNkwwIDE2VjhMOCAwWiIgZmlsbD0iIzJEMkQyRCIvPgogICAgICA8cGF0aCBkPSJNMTYgOFYxNkg4TDE2IDhaIiBmaWxsPSIjMkQyRDJEIi8+CiAgICA8L3BhdHRlcm4+CiAgPC9kZWZzPgogIDxyZWN0IHdpZHRoPSIxMDAlIiBoZWlnaHQ9IjEwMCUiIGZpbGw9InVybCgjc3RyaXBlcykiLz4KPC9zdmc+Cg==";
+    var MAX_IMAGE_DIMENSION_FOR_RECOMPRESSION = 4096;
+    function recompressBase64Image(img, dataURL, type, quality) {
+      if (!img.complete || img.naturalWidth === 0) {
+        return dataURL;
+      }
+      if (img.naturalWidth > MAX_IMAGE_DIMENSION_FOR_RECOMPRESSION || img.naturalHeight > MAX_IMAGE_DIMENSION_FOR_RECOMPRESSION) {
+        return dataURL;
+      }
+      try {
+        const canvas = document.createElement("canvas");
+        canvas.width = img.naturalWidth;
+        canvas.height = img.naturalHeight;
+        const ctx = canvas.getContext("2d");
+        if (!ctx) {
+          return dataURL;
+        }
+        ctx.drawImage(img, 0, 0);
+        const recompressed = canvas.toDataURL(type || "image/webp", quality != null ? quality : 0.4);
+        return recompressed;
+      } catch (err) {
+        return dataURL;
+      }
+    }
+    function checkDataURLSize(dataURL, maxLength) {
+      if (!maxLength || dataURL.length <= maxLength) {
+        return dataURL;
+      }
+      return STRIPED_PLACEHOLDER_SVG;
+    }
+    var NodeType = /* @__PURE__ */ ((NodeType2) => {
+      NodeType2[NodeType2["Document"] = 0] = "Document";
+      NodeType2[NodeType2["DocumentType"] = 1] = "DocumentType";
+      NodeType2[NodeType2["Element"] = 2] = "Element";
+      NodeType2[NodeType2["Text"] = 3] = "Text";
+      NodeType2[NodeType2["CDATA"] = 4] = "CDATA";
+      NodeType2[NodeType2["Comment"] = 5] = "Comment";
+      return NodeType2;
+    })(NodeType || {});
+    exports2.Mirror = Mirror;
+    exports2.NodeType = NodeType;
+    exports2.NodeType$1 = NodeType$1;
+    exports2.absolutifyURLs = absolutifyURLs;
+    exports2.checkDataURLSize = checkDataURLSize;
+    exports2.createMirror = createMirror;
+    exports2.escapeImportStatement = escapeImportStatement;
+    exports2.extractFileExtension = extractFileExtension;
+    exports2.fixSafariColons = fixSafariColons;
+    exports2.getInputType = getInputType;
+    exports2.index = index;
+    exports2.is2DCanvasBlank = is2DCanvasBlank;
+    exports2.isCSSImportRule = isCSSImportRule;
+    exports2.isCSSStyleRule = isCSSStyleRule;
+    exports2.isElement = isElement;
+    exports2.isNativeShadowDom = isNativeShadowDom;
+    exports2.isNodeMetaEqual = isNodeMetaEqual;
+    exports2.isShadowRoot = isShadowRoot;
+    exports2.maskInputValue = maskInputValue;
+    exports2.recompressBase64Image = recompressBase64Image;
+    exports2.stringifyRule = stringifyRule;
+    exports2.stringifyStylesheet = stringifyStylesheet;
+    exports2.toLowerCase = toLowerCase;
+  }
+});
+
+// dist/record-oACzRSl-.cjs
+var types = require_types_B7TTv7Jc();
+var _id = 1;
+var tagNameRegex = new RegExp("[^a-z0-9-_:]");
+var IGNORED_NODE = -2;
+function genId() {
+  return _id++;
+}
+function getValidTagName(element) {
+  if (element instanceof HTMLFormElement) {
+    return "form";
+  }
+  const processedTagName = types.toLowerCase(element.tagName);
+  if (tagNameRegex.test(processedTagName)) {
+    return "div";
+  }
+  return processedTagName;
+}
+var canvasService;
+var canvasCtx;
+var SRCSET_NOT_SPACES = /^[^ \t\n\r\u000c]+/;
+var SRCSET_COMMAS_OR_SPACES = /^[, \t\n\r\u000c]+/;
+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;
+        } else if (!inParens) {
+          if (c === ",") {
+            pos += 1;
+            output.push((url + descriptorsStr).trim());
+            break;
+          } else if (c === "(") {
+            inParens = true;
+          }
+        } else {
+          if (c === ")") {
+            inParens = false;
+          }
+        }
+        descriptorsStr += c;
+        pos += 1;
+      }
+    }
+  }
+  return output.join(", ");
+}
+var cachedDocument = /* @__PURE__ */ new WeakMap();
+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, element, dataURLOptions) {
+  if (!value) {
+    return value;
+  }
+  if (name === "src" || name === "href" && !(tagName === "use" && value[0] === "#")) {
+    const transformedValue = absoluteToDoc(doc, value);
+    if (tagName === "img" && transformedValue.startsWith("data:") && element) {
+      const img = element;
+      let processedDataURL = transformedValue;
+      if ((dataURLOptions == null ? void 0 : dataURLOptions.type) || (dataURLOptions == null ? void 0 : dataURLOptions.quality) !== void 0) {
+        processedDataURL = types.recompressBase64Image(
+          img,
+          transformedValue,
+          dataURLOptions.type,
+          dataURLOptions.quality
+        );
+      }
+      if (dataURLOptions == null ? void 0 : dataURLOptions.maxBase64ImageLength) {
+        processedDataURL = types.checkDataURLSize(
+          processedDataURL,
+          dataURLOptions.maxBase64ImageLength
+        );
+      }
+      return processedDataURL;
+    }
+    return transformedValue;
+  } else if (name === "xlink:href" && value[0] !== "#") {
+    return absoluteToDoc(doc, value);
+  } else if (name === "background" && (tagName === "table" || tagName === "td" || tagName === "th")) {
+    return absoluteToDoc(doc, value);
+  } else if (name === "srcset") {
+    return getAbsoluteSrcsetString(doc, value);
+  } else if (name === "style") {
+    return types.absolutifyURLs(value, getHref(doc));
+  } else 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(types.index.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(types.index.parentNode(node), regex, checkAncestors);
+}
+function needMaskingText(node, maskTextClass, maskTextSelector, checkAncestors) {
+  let el;
+  if (types.isElement(node)) {
+    el = node;
+    if (!types.index.childNodes(el).length) {
+      return false;
+    }
+  } else if (types.index.parentElement(node) === null) {
+    return false;
+  } else {
+    el = types.index.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
+  } = options;
+  const rootId = getRootId(doc, mirror);
+  switch (n.nodeType) {
+    case n.DOCUMENT_NODE:
+      if (n.compatMode !== "CSS1Compat") {
+        return {
+          type: types.NodeType$1.Document,
+          childNodes: [],
+          compatMode: n.compatMode
+          // probably "BackCompat"
+        };
+      } else {
+        return {
+          type: types.NodeType$1.Document,
+          childNodes: []
+        };
+      }
+    case n.DOCUMENT_TYPE_NODE:
+      return {
+        type: types.NodeType$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
+      });
+    case n.CDATA_SECTION_NODE:
+      return {
+        type: types.NodeType$1.CDATA,
+        textContent: "",
+        rootId
+      };
+    case n.COMMENT_NODE:
+      return {
+        type: types.NodeType$1.Comment,
+        textContent: types.index.textContent(n) || "",
+        rootId
+      };
+    default:
+      return false;
+  }
+}
+function getRootId(doc, mirror) {
+  if (!mirror.hasNode(doc)) return void 0;
+  const docId = mirror.getId(doc);
+  return docId === 1 ? void 0 : docId;
+}
+function serializeTextNode(n, options) {
+  var _a;
+  const { needsMask, maskTextFn, rootId } = options;
+  const parent = types.index.parentNode(n);
+  const parentTagName = parent && parent.tagName;
+  let text = types.index.textContent(n);
+  const isStyle = parentTagName === "STYLE" ? true : void 0;
+  const isScript = parentTagName === "SCRIPT" ? true : void 0;
+  if (isStyle && text) {
+    try {
+      if (n.nextSibling || n.previousSibling) {
+      } else if ((_a = parent.sheet) == null ? void 0 : _a.cssRules) {
+        text = types.stringifyStylesheet(parent.sheet);
+      }
+    } catch (err) {
+      console.warn(
+        `Cannot get CSS styles from text's parentNode. Error: ${err}`,
+        n
+      );
+    }
+    text = types.absolutifyURLs(text, getHref(options.doc));
+  }
+  if (isScript) {
+    text = "SCRIPT_PLACEHOLDER";
+  }
+  if (!isStyle && !isScript && text && needsMask) {
+    text = maskTextFn ? maskTextFn(text, types.index.parentElement(n)) : text.replace(/[\S]/g, "*");
+  }
+  return {
+    type: types.NodeType$1.Text,
+    textContent: text || "",
+    isStyle,
+    rootId
+  };
+}
+function findStylesheet(doc, href) {
+  return Array.from(doc.styleSheets).find((s) => s.href === href);
+}
+function hrefFrom(n) {
+  return n.href;
+}
+function serializeElementNode(n, options) {
+  var _a, _b;
+  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,
+        types.toLowerCase(attr.name),
+        attr.value,
+        n,
+        dataURLOptions
+      );
+    }
+  }
+  if (tagName === "link" && inlineStylesheet) {
+    const href = hrefFrom(n);
+    if (href) {
+      let stylesheet = findStylesheet(doc, href);
+      if (!stylesheet && href.includes(".css")) {
+        const rootDomain = window.location.origin;
+        const stylesheetPath = href.replace(window.location.href, "");
+        const potentialStylesheetHref = rootDomain + "/" + stylesheetPath;
+        stylesheet = findStylesheet(doc, potentialStylesheetHref);
+      }
+      let cssText = null;
+      if (stylesheet) {
+        cssText = types.stringifyStylesheet(stylesheet);
+      }
+      if (cssText) {
+        delete attributes.rel;
+        delete attributes.href;
+        attributes._cssText = cssText;
+      }
+    }
+  }
+  if (tagName === "style" && n.sheet && // TODO: Currently we only try to get dynamic stylesheet when it is an empty style element
+  !(n.innerText || types.index.textContent(n) || "").trim().length) {
+    const cssText = types.stringifyStylesheet(
+      n.sheet
+    );
+    if (cssText) {
+      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 = types.maskInputValue({
+        element: n,
+        type: types.getInputType(n),
+        tagName,
+        value,
+        maskInputOptions,
+        maskInputFn
+      });
+    } else if (checked) {
+      attributes.checked = checked;
+    }
+  }
+  if (tagName === "option") {
+    if (n.selected && !maskInputOptions["select"]) {
+      attributes.selected = true;
+    } else {
+      delete attributes.selected;
+    }
+  }
+  if (tagName === "dialog" && n.open) {
+    try {
+      attributes.rr_open_mode = n.matches("dialog:modal") ? "modal" : "non-modal";
+    } catch (e) {
+      attributes.rr_open_mode = "modal";
+      attributes.ph_rr_could_not_detect_modal = true;
+    }
+  }
+  if (tagName === "canvas" && recordCanvas) {
+    if (n.__context === "2d") {
+      if (!types.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;
+        } else {
+          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, left, top } = n.getBoundingClientRect();
+    attributes = {
+      class: attributes.class,
+      rr_width: `${width}px`,
+      rr_height: `${height}px`,
+      rr_left: `${Math.floor(left + (((_a = doc.defaultView) == null ? void 0 : _a.scrollX) || 0))}px`,
+      rr_top: `${Math.floor(top + (((_b = doc.defaultView) == null ? void 0 : _b.scrollY) || 0))}px`
+    };
+  }
+  if (tagName === "iframe" && !keepIframeSrcFn(attributes.src)) {
+    if (!n.contentDocument) {
+      attributes.rr_src = attributes.src;
+    }
+    delete attributes.src;
+  }
+  let isCustomElement;
+  try {
+    if (customElements.get(tagName)) isCustomElement = true;
+  } catch (e) {
+  }
+  return {
+    type: types.NodeType$1.Element,
+    tagName,
+    attributes,
+    childNodes: [],
+    isSVG: isSVGElement(n) || void 0,
+    needBlock,
+    rootId,
+    isCustom: isCustomElement
+  };
+}
+function lowerIfExists(maybeAttr) {
+  if (maybeAttr === void 0 || maybeAttr === null) {
+    return "";
+  } else {
+    return maybeAttr.toLowerCase();
+  }
+}
+function slimDOMExcluded(sn, slimDOMOptions) {
+  if (slimDOMOptions.comment && sn.type === types.NodeType$1.Comment) {
+    return true;
+  } else if (sn.type === types.NodeType$1.Element) {
+    if (slimDOMOptions.script && // script tag
+    (sn.tagName === "script" || // (module)preload link
+    sn.tagName === "link" && (sn.attributes.rel === "preload" && sn.attributes.as === "script" || sn.attributes.rel === "modulepreload") || // prefetch link
+    sn.tagName === "link" && sn.attributes.rel === "prefetch" && typeof sn.attributes.href === "string" && types.extractFileExtension(sn.attributes.href) === "js")) {
+      return true;
+    } else 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;
+    } else if (sn.tagName === "meta") {
+      if (slimDOMOptions.headMetaDescKeywords && lowerIfExists(sn.attributes.name).match(/^description|keywords$/)) {
+        return true;
+      } else if (slimDOMOptions.headMetaSocial && (lowerIfExists(sn.attributes.property).match(/^(og|twitter|fb):/) || // og = opengraph (facebook)
+      lowerIfExists(sn.attributes.name).match(/^(og|twitter):/) || lowerIfExists(sn.attributes.name) === "pinterest")) {
+        return true;
+      } else if (slimDOMOptions.headMetaRobots && (lowerIfExists(sn.attributes.name) === "robots" || lowerIfExists(sn.attributes.name) === "googlebot" || lowerIfExists(sn.attributes.name) === "bingbot")) {
+        return true;
+      } else if (slimDOMOptions.headMetaHttpEquiv && sn.attributes["http-equiv"] !== void 0) {
+        return true;
+      } else 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;
+      } else 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;
+}
+var DEFAULT_MAX_DEPTH = 50;
+var _maxDepthWarned = false;
+var _maxDepthReached = false;
+function wasMaxDepthReached() {
+  return _maxDepthReached;
+}
+function resetMaxDepthState() {
+  _maxDepthReached = false;
+  _maxDepthWarned = 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 = 5e3,
+    onStylesheetLoad,
+    stylesheetLoadTimeout = 5e3,
+    keepIframeSrcFn = () => false,
+    newlyAddedElement = false,
+    depth = 0,
+    maxDepth = DEFAULT_MAX_DEPTH
+  } = options;
+  let { needsMask } = options;
+  let { preserveWhiteSpace = true } = options;
+  if (depth >= maxDepth) {
+    _maxDepthReached = true;
+    if (!_maxDepthWarned) {
+      _maxDepthWarned = true;
+      console.warn(
+        `[rrweb-snapshot] DOM tree depth exceeded max depth of ${maxDepth}. Children beyond this depth will not be recorded. This may indicate deeply nested DOM structures.`
+      );
+    }
+    return null;
+  }
+  if (!needsMask) {
+    const checkAncestors = needsMask === void 0;
+    needsMask = needMaskingText(
+      n,
+      maskTextClass,
+      maskTextSelector,
+      checkAncestors
+    );
+  }
+  const _serializedNode = serializeNode(n, {
+    doc,
+    mirror,
+    blockClass,
+    blockSelector,
+    needsMask,
+    inlineStylesheet,
+    maskInputOptions,
+    maskTextFn,
+    maskInputFn,
+    dataURLOptions,
+    inlineImages,
+    recordCanvas,
+    keepIframeSrcFn,
+    newlyAddedElement
+  });
+  if (!_serializedNode) {
+    console.warn(n, "not serialized");
+    return null;
+  }
+  let id;
+  if (mirror.hasNode(n)) {
+    id = mirror.getId(n);
+  } else if (slimDOMExcluded(_serializedNode, slimDOMOptions) || !preserveWhiteSpace && _serializedNode.type === types.NodeType$1.Text && !_serializedNode.isStyle && !_serializedNode.textContent.replace(/^\s+|\s+$/gm, "").length) {
+    id = IGNORED_NODE;
+  } else {
+    id = genId();
+  }
+  const serializedNode = Object.assign(_serializedNode, { id });
+  mirror.add(n, serializedNode);
+  if (id === IGNORED_NODE) {
+    return null;
+  }
+  if (onSerialize) {
+    onSerialize(n);
+  }
+  let recordChild = !skipChild;
+  if (serializedNode.type === types.NodeType$1.Element) {
+    recordChild = recordChild && !serializedNode.needBlock;
+    delete serializedNode.needBlock;
+    const shadowRootEl = types.index.shadowRoot(n);
+    if (shadowRootEl && types.isNativeShadowDom(shadowRootEl))
+      serializedNode.isShadowHost = true;
+  }
+  if ((serializedNode.type === types.NodeType$1.Document || serializedNode.type === types.NodeType$1.Element) && recordChild) {
+    if (slimDOMOptions.headWhitespace && serializedNode.type === types.NodeType$1.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,
+      depth: depth + 1,
+      maxDepth
+    };
+    if (serializedNode.type === types.NodeType$1.Element && serializedNode.tagName === "textarea" && serializedNode.attributes.value !== void 0) ;
+    else {
+      for (const childN of Array.from(types.index.childNodes(n))) {
+        const serializedChildNode = serializeNodeWithId(childN, bypassOptions);
+        if (serializedChildNode) {
+          serializedNode.childNodes.push(serializedChildNode);
+        }
+      }
+    }
+    let shadowRootEl = null;
+    if (types.isElement(n) && (shadowRootEl = types.index.shadowRoot(n))) {
+      for (const childN of Array.from(types.index.childNodes(shadowRootEl))) {
+        const serializedChildNode = serializeNodeWithId(childN, bypassOptions);
+        if (serializedChildNode) {
+          types.isNativeShadowDom(shadowRootEl) && (serializedChildNode.isShadow = true);
+          serializedNode.childNodes.push(serializedChildNode);
+        }
+      }
+    }
+  }
+  const parent = types.index.parentNode(n);
+  if (parent && types.isShadowRoot(parent) && types.isNativeShadowDom(parent)) {
+    serializedNode.isShadow = true;
+  }
+  if (serializedNode.type === types.NodeType$1.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,
+            depth: depth + 1,
+            maxDepth
+          });
+          if (serializedIframeNode) {
+            onIframeLoad(
+              n,
+              serializedIframeNode
+            );
+          }
+        }
+      },
+      iframeLoadTimeout
+    );
+  }
+  if (serializedNode.type === types.NodeType$1.Element && serializedNode.tagName === "link" && typeof serializedNode.attributes.rel === "string" && (serializedNode.attributes.rel === "stylesheet" || serializedNode.attributes.rel === "preload" && typeof serializedNode.attributes.href === "string" && types.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,
+            depth,
+            maxDepth
+          });
+          if (serializedLinkNode) {
+            onStylesheetLoad(
+              n,
+              serializedLinkNode
+            );
+          }
+        }
+      },
+      stylesheetLoadTimeout
+    );
+  }
+  return serializedNode;
+}
+function snapshot(n, options) {
+  const {
+    mirror = new types.Mirror(),
+    blockClass = "rr-block",
+    blockSelector = null,
+    maskTextClass = "rr-mask",
+    maskTextSelector = null,
+    inlineStylesheet = true,
+    inlineImages = false,
+    recordCanvas = false,
+    maskAllInputs = false,
+    maskTextFn,
+    maskInputFn,
+    slimDOM = false,
+    dataURLOptions,
+    preserveWhiteSpace,
+    onSerialize,
+    onIframeLoad,
+    iframeLoadTimeout,
+    onStylesheetLoad,
+    stylesheetLoadTimeout,
+    keepIframeSrcFn = () => false,
+    maxDepth
+  } = 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" ? (
+    // if true: set of sensible options that should not throw away any information
+    {
+      script: true,
+      comment: true,
+      headFavicon: true,
+      headWhitespace: true,
+      headMetaDescKeywords: slimDOM === "all",
+      // destructive
+      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,
+    maxDepth
+  });
+}
+function visitSnapshot(node, onVisit) {
+  function walk(current) {
+    onVisit(current);
+    if (current.type === types.NodeType$1.Document || current.type === types.NodeType$1.Element) {
+      current.childNodes.forEach(walk);
+    }
+  }
+  walk(node);
+}
+function cleanupSnapshot() {
+  _id = 1;
+}
+exports.DEFAULT_MAX_DEPTH = DEFAULT_MAX_DEPTH;
+exports.IGNORED_NODE = IGNORED_NODE;
+exports.classMatchesRegex = classMatchesRegex;
+exports.cleanupSnapshot = cleanupSnapshot;
+exports.genId = genId;
+exports.ignoreAttribute = ignoreAttribute;
+exports.needMaskingText = needMaskingText;
+exports.resetMaxDepthState = resetMaxDepthState;
+exports.serializeNodeWithId = serializeNodeWithId;
+exports.snapshot = snapshot;
+exports.transformAttribute = transformAttribute;
+exports.visitSnapshot = visitSnapshot;
+exports.wasMaxDepthReached = wasMaxDepthReached;
+;if (typeof module.exports == "object" && typeof exports == "object") {
+  var __cp = (to, from, except, desc) => {
+    if ((from && typeof from === "object") || typeof from === "function") {
+      for (let key of Object.getOwnPropertyNames(from)) {
+        if (!Object.prototype.hasOwnProperty.call(to, key) && key !== except)
+        Object.defineProperty(to, key, {
+          get: () => from[key],
+          enumerable: !(desc = Object.getOwnPropertyDescriptor(from, key)) || desc.enumerable,
+        });
+      }
+    }
+    return to;
+  };
+  module.exports = __cp(module.exports, exports);
+}
+return module.exports;
+}))
+//# sourceMappingURL=record-oACzRSl-.umd.cjs.map