@highlight-run/rrweb 2.0.0-lambda.7 → 2.0.0-lambda.9

package/dist/rrweb.js

@@ -1873,6 +1873,7 @@ function requireStringifier$1() {
   hasRequiredStringifier$1 = 1;
   const STYLE_TAG = /(<)(\/?style\b)/gi;
   const COMMENT_OPEN = /(<)(!--)/g;
+  const AT_NAME_END = /[\t\n\f\r "#'()/;[\\\]{}]/;
   function escapeHTMLInCSS(str) {
     if (typeof str !== "string") return str;
     if (!str.includes("<")) return str;
@@ -1898,12 +1899,13 @@ function requireStringifier$1() {
   function atruleStart(str, node2) {
     let name = "@" + node2.name;
     let params = node2.params ? str.rawValue(node2, "params") : "";
-    if (typeof node2.raws.afterName !== "undefined") {
-      name += node2.raws.afterName;
-    } else if (params) {
-      name += " ";
+    let afterName = node2.raws.afterName;
+    if (typeof afterName === "undefined") {
+      afterName = params ? " " : "";
+    } else if (afterName === "" && params && !AT_NAME_END.test(params[0])) {
+      afterName = " ";
     }
-    return name + params;
+    return name + afterName + params;
   }
   function pushBody(str, stack, node2) {
     let nodes = node2.nodes;
@@ -1915,10 +1917,15 @@ function requireStringifier$1() {
     let semicolon = str.raw(node2, "semicolon");
     let isDocument = node2.type === "document";
     for (let i2 = nodes.length - 1; i2 >= 0; i2--) {
+      let child = nodes[i2];
+      let childSemicolon = last !== i2 || semicolon;
+      if (!childSemicolon && i2 < nodes.length - 1 && (child.type === "atrule" && !child.nodes || child.type === "decl" && child.prop.startsWith("--"))) {
+        childSemicolon = true;
+      }
       stack.push({
         document: isDocument,
-        node: nodes[i2],
-        semicolon: last !== i2 || semicolon
+        node: child,
+        semicolon: childSemicolon
       });
     }
   }
@@ -2209,6 +2216,9 @@ function requireStringifier$1() {
       return value;
     }
     root(node2) {
+      if (node2.source && node2.source.input.hasBOM) {
+        this.builder("\uFEFF", node2, "start");
+      }
       this.body(node2);
       if (node2.raws.after) {
         let after = node2.raws.after;
@@ -3281,15 +3291,12 @@ function requirePreviousMap$1() {
     }
     loadFile(path, cssFile, trusted) {
       if (!trusted && !this.unsafeMap) {
-        if (!/\.map$/i.test(path)) {
+        if (!/\.map$/i.test(path)) return void 0;
+        if (!cssFile) return void 0;
+        let rel = relative(dirname(cssFile), path);
+        if (rel === ".." || rel.startsWith(".." + sep) || isAbsolute(rel)) {
           return void 0;
         }
-        if (cssFile) {
-          let relativePath = relative(dirname(cssFile), path);
-          if (relativePath === ".." || relativePath.startsWith(".." + sep) || isAbsolute(relativePath)) {
-            return void 0;
-          }
-        }
       }
       this.root = dirname(path);
       if (existsSync(path)) {
@@ -3661,6 +3668,7 @@ function requireList$1() {
       return list.split(string, spaces);
     },
     split(string, separators, last) {
+      if (!string) return [];
       let array = [];
       let current = "";
       let split = false;
@@ -4947,11 +4955,16 @@ var hasRequiredWarning$1;
 function requireWarning$1() {
   if (hasRequiredWarning$1) return warning$1;
   hasRequiredWarning$1 = 1;
+  let Container = requireContainer$1();
+  let { my } = requireSymbols$1();
   class Warning {
     constructor(text, opts = {}) {
       this.type = "warning";
       this.text = text;
       if (opts.node && opts.node.source) {
+        if (!opts.node[my]) {
+          Container.rebuild(opts.node);
+        }
         let range = opts.node.rangeBy(opts);
         this.line = range.start.line;
         this.column = range.start.column;
@@ -5461,14 +5474,19 @@ function requireLazyResult$1() {
       }
       if (visit2.iterator !== 0) {
         let iterator = visit2.iterator;
+        if (visit2.descending) {
+          visit2.descending = false;
+          node2.indexes[iterator] += 1;
+        }
         let child;
         while (child = node2.nodes[node2.indexes[iterator]]) {
-          node2.indexes[iterator] += 1;
           if (!child[isClean]) {
             child[isClean] = true;
+            visit2.descending = true;
             stack.push(toStack(child));
             return;
           }
+          node2.indexes[iterator] += 1;
         }
         visit2.iterator = 0;
         delete node2.indexes[iterator];
@@ -5498,12 +5516,16 @@ function requireLazyResult$1() {
         let visitNode = visit2.node;
         if (visit2.iterator !== 0) {
           let iterator = visit2.iterator;
+          if (visit2.descending) {
+            visit2.descending = false;
+            visitNode.indexes[iterator] += 1;
+          }
           let child;
           let descended = false;
           while (child = visitNode.nodes[visitNode.indexes[iterator]]) {
-            visitNode.indexes[iterator] += 1;
             if (!child[isClean]) {
               child[isClean] = true;
+              visit2.descending = true;
               stack.push({
                 eventIndex: 0,
                 events: getEvents(child),
@@ -5513,6 +5535,7 @@ function requireLazyResult$1() {
               descended = true;
               break;
             }
+            visitNode.indexes[iterator] += 1;
           }
           if (descended) continue;
           visit2.iterator = 0;
@@ -5675,7 +5698,7 @@ function requireProcessor$1() {
   let Root = requireRoot$1();
   class Processor {
     constructor(plugins = []) {
-      this.version = "8.5.19";
+      this.version = "8.5.25";
       this.plugins = this.normalize(plugins);
     }
     normalize(plugins) {
@@ -6542,6 +6565,7 @@ function requireStringifier() {
   hasRequiredStringifier = 1;
   const STYLE_TAG = /(<)(\/?style\b)/gi;
   const COMMENT_OPEN = /(<)(!--)/g;
+  const AT_NAME_END = /[\t\n\f\r "#'()/;[\\\]{}]/;
   function escapeHTMLInCSS(str) {
     if (typeof str !== "string") return str;
     if (!str.includes("<")) return str;
@@ -6567,12 +6591,13 @@ function requireStringifier() {
   function atruleStart(str, node2) {
     let name = "@" + node2.name;
     let params = node2.params ? str.rawValue(node2, "params") : "";
-    if (typeof node2.raws.afterName !== "undefined") {
-      name += node2.raws.afterName;
-    } else if (params) {
-      name += " ";
+    let afterName = node2.raws.afterName;
+    if (typeof afterName === "undefined") {
+      afterName = params ? " " : "";
+    } else if (afterName === "" && params && !AT_NAME_END.test(params[0])) {
+      afterName = " ";
     }
-    return name + params;
+    return name + afterName + params;
   }
   function pushBody(str, stack, node2) {
     let nodes = node2.nodes;
@@ -6584,10 +6609,15 @@ function requireStringifier() {
     let semicolon = str.raw(node2, "semicolon");
     let isDocument = node2.type === "document";
     for (let i2 = nodes.length - 1; i2 >= 0; i2--) {
+      let child = nodes[i2];
+      let childSemicolon = last !== i2 || semicolon;
+      if (!childSemicolon && i2 < nodes.length - 1 && (child.type === "atrule" && !child.nodes || child.type === "decl" && child.prop.startsWith("--"))) {
+        childSemicolon = true;
+      }
       stack.push({
         document: isDocument,
-        node: nodes[i2],
-        semicolon: last !== i2 || semicolon
+        node: child,
+        semicolon: childSemicolon
       });
     }
   }
@@ -6878,6 +6908,9 @@ function requireStringifier() {
       return value;
     }
     root(node2) {
+      if (node2.source && node2.source.input.hasBOM) {
+        this.builder("\uFEFF", node2, "start");
+      }
       this.body(node2);
       if (node2.raws.after) {
         let after = node2.raws.after;
@@ -7950,15 +7983,12 @@ function requirePreviousMap() {
     }
     loadFile(path, cssFile, trusted) {
       if (!trusted && !this.unsafeMap) {
-        if (!/\.map$/i.test(path)) {
+        if (!/\.map$/i.test(path)) return void 0;
+        if (!cssFile) return void 0;
+        let rel = relative(dirname(cssFile), path);
+        if (rel === ".." || rel.startsWith(".." + sep) || isAbsolute(rel)) {
           return void 0;
         }
-        if (cssFile) {
-          let relativePath = relative(dirname(cssFile), path);
-          if (relativePath === ".." || relativePath.startsWith(".." + sep) || isAbsolute(relativePath)) {
-            return void 0;
-          }
-        }
       }
       this.root = dirname(path);
       if (existsSync(path)) {
@@ -8330,6 +8360,7 @@ function requireList() {
       return list.split(string, spaces);
     },
     split(string, separators, last) {
+      if (!string) return [];
       let array = [];
       let current = "";
       let split = false;
@@ -9616,11 +9647,16 @@ var hasRequiredWarning;
 function requireWarning() {
   if (hasRequiredWarning) return warning;
   hasRequiredWarning = 1;
+  let Container = requireContainer();
+  let { my } = requireSymbols();
   class Warning {
     constructor(text, opts = {}) {
       this.type = "warning";
       this.text = text;
       if (opts.node && opts.node.source) {
+        if (!opts.node[my]) {
+          Container.rebuild(opts.node);
+        }
         let range = opts.node.rangeBy(opts);
         this.line = range.start.line;
         this.column = range.start.column;
@@ -10130,14 +10166,19 @@ function requireLazyResult() {
       }
       if (visit2.iterator !== 0) {
         let iterator = visit2.iterator;
+        if (visit2.descending) {
+          visit2.descending = false;
+          node2.indexes[iterator] += 1;
+        }
         let child;
         while (child = node2.nodes[node2.indexes[iterator]]) {
-          node2.indexes[iterator] += 1;
           if (!child[isClean]) {
             child[isClean] = true;
+            visit2.descending = true;
             stack.push(toStack(child));
             return;
           }
+          node2.indexes[iterator] += 1;
         }
         visit2.iterator = 0;
         delete node2.indexes[iterator];
@@ -10167,12 +10208,16 @@ function requireLazyResult() {
         let visitNode = visit2.node;
         if (visit2.iterator !== 0) {
           let iterator = visit2.iterator;
+          if (visit2.descending) {
+            visit2.descending = false;
+            visitNode.indexes[iterator] += 1;
+          }
           let child;
           let descended = false;
           while (child = visitNode.nodes[visitNode.indexes[iterator]]) {
-            visitNode.indexes[iterator] += 1;
             if (!child[isClean]) {
               child[isClean] = true;
+              visit2.descending = true;
               stack.push({
                 eventIndex: 0,
                 events: getEvents(child),
@@ -10182,6 +10227,7 @@ function requireLazyResult() {
               descended = true;
               break;
             }
+            visitNode.indexes[iterator] += 1;
           }
           if (descended) continue;
           visit2.iterator = 0;
@@ -10344,7 +10390,7 @@ function requireProcessor() {
   let Root = requireRoot();
   class Processor {
     constructor(plugins = []) {
-      this.version = "8.5.19";
+      this.version = "8.5.25";
       this.plugins = this.normalize(plugins);
     }
     normalize(plugins) {
@@ -13626,66 +13672,142 @@ function getIdAndStyleId(sheet, mirror2, styleMirror) {
     id
   };
 }
-function initStyleSheetObserver({ styleSheetRuleCb, mirror: mirror2, stylesheetManager }, { win }) {
+function restorePatchedMethod(target, key, ours, restoreTo) {
+  if (target[key] === ours) {
+    target[key] = restoreTo;
+  }
+}
+const MAX_CSSOM_REPATCH_ATTEMPTS = 5;
+function initStyleSheetObserver({
+  styleSheetRuleCb,
+  mirror: mirror2,
+  stylesheetManager,
+  doc,
+  styleSheetResyncInterval
+}, { win }) {
   if (!win.CSSStyleSheet || !win.CSSStyleSheet.prototype) {
     return () => {
     };
   }
-  const insertRule = win.CSSStyleSheet.prototype.insertRule;
-  win.CSSStyleSheet.prototype.insertRule = new Proxy(insertRule, {
+  const reportedRuleCounts = /* @__PURE__ */ new WeakMap();
+  const unreconcilableSheets = /* @__PURE__ */ new WeakSet();
+  let probing = false;
+  let probeInsertObserved = false;
+  let probeDeleteObserved = false;
+  let probeSheet;
+  let stopped = false;
+  let insideInsertRule = false;
+  let insideDeleteRule = false;
+  const noteReportedRules = (sheet, delta) => {
+    const state = reportedRuleCounts.get(sheet);
+    if (state) {
+      state.reported = Math.max(0, state.reported + delta);
+      state.everSeen = Math.max(state.everSeen, state.reported);
+    }
+  };
+  const patchInsertRule = (target) => new Proxy(target, {
     apply: callbackWrapper(
-      (target, thisArg, argumentsList) => {
+      (nativeFn, thisArg, argumentsList) => {
+        if (probing) {
+          probeInsertObserved = true;
+          return nativeFn.apply(thisArg, argumentsList);
+        }
+        if (stopped || insideInsertRule) {
+          return nativeFn.apply(thisArg, argumentsList);
+        }
         const [rule2, index2] = argumentsList;
         const { id, styleId } = getIdAndStyleId(
           thisArg,
           mirror2,
           stylesheetManager.styleMirror
         );
-        if (id && id !== -1 || styleId && styleId !== -1) {
+        const reported = id && id !== -1 || styleId && styleId !== -1;
+        if (reported) {
           styleSheetRuleCb({
             id,
             styleId,
             adds: [{ rule: rule2, index: index2 }]
           });
         }
-        return target.apply(thisArg, argumentsList);
+        insideInsertRule = true;
+        let result2;
+        try {
+          result2 = nativeFn.apply(thisArg, argumentsList);
+        } finally {
+          insideInsertRule = false;
+        }
+        if (reported) {
+          noteReportedRules(thisArg, 1);
+        }
+        return result2;
       }
     )
   });
-  win.CSSStyleSheet.prototype.addRule = function(selector, styleBlock, index2 = this.cssRules.length) {
-    const rule2 = `${selector} { ${styleBlock} }`;
-    return win.CSSStyleSheet.prototype.insertRule.apply(this, [rule2, index2]);
-  };
-  const deleteRule = win.CSSStyleSheet.prototype.deleteRule;
-  win.CSSStyleSheet.prototype.deleteRule = new Proxy(deleteRule, {
+  const patchDeleteRule = (target) => new Proxy(target, {
     apply: callbackWrapper(
-      (target, thisArg, argumentsList) => {
+      (nativeFn, thisArg, argumentsList) => {
+        if (probing) {
+          probeDeleteObserved = true;
+          return nativeFn.apply(thisArg, argumentsList);
+        }
+        if (stopped || insideDeleteRule) {
+          return nativeFn.apply(thisArg, argumentsList);
+        }
         const [index2] = argumentsList;
         const { id, styleId } = getIdAndStyleId(
           thisArg,
           mirror2,
           stylesheetManager.styleMirror
         );
-        if (id && id !== -1 || styleId && styleId !== -1) {
+        const reported = id && id !== -1 || styleId && styleId !== -1;
+        if (reported) {
           styleSheetRuleCb({
             id,
             styleId,
             removes: [{ index: index2 }]
           });
         }
-        return target.apply(thisArg, argumentsList);
+        insideDeleteRule = true;
+        let result2;
+        try {
+          result2 = nativeFn.apply(thisArg, argumentsList);
+        } finally {
+          insideDeleteRule = false;
+        }
+        if (reported) {
+          noteReportedRules(thisArg, -1);
+        }
+        return result2;
       }
     )
   });
-  win.CSSStyleSheet.prototype.removeRule = function(index2) {
+  const insertRule = win.CSSStyleSheet.prototype.insertRule;
+  let insertRuleProxy = patchInsertRule(insertRule);
+  let restoreInsertRuleTo = insertRule;
+  win.CSSStyleSheet.prototype.insertRule = insertRuleProxy;
+  const addRule = win.CSSStyleSheet.prototype.addRule;
+  const addRuleShim = function(selector, styleBlock, index2 = this.cssRules.length) {
+    const rule2 = `${selector} { ${styleBlock} }`;
+    return win.CSSStyleSheet.prototype.insertRule.apply(this, [rule2, index2]);
+  };
+  win.CSSStyleSheet.prototype.addRule = addRuleShim;
+  const deleteRule = win.CSSStyleSheet.prototype.deleteRule;
+  let deleteRuleProxy = patchDeleteRule(deleteRule);
+  let restoreDeleteRuleTo = deleteRule;
+  win.CSSStyleSheet.prototype.deleteRule = deleteRuleProxy;
+  const removeRule = win.CSSStyleSheet.prototype.removeRule;
+  const removeRuleShim = function(index2) {
     return win.CSSStyleSheet.prototype.deleteRule.apply(this, [index2]);
   };
+  win.CSSStyleSheet.prototype.removeRule = removeRuleShim;
   let replace;
+  let replaceProxy;
   if (win.CSSStyleSheet.prototype.replace) {
     replace = win.CSSStyleSheet.prototype.replace;
-    win.CSSStyleSheet.prototype.replace = new Proxy(replace, {
+    replaceProxy = new Proxy(replace, {
       apply: callbackWrapper(
         (target, thisArg, argumentsList) => {
+          if (stopped) return target.apply(thisArg, argumentsList);
           const [text] = argumentsList;
           const { id, styleId } = getIdAndStyleId(
             thisArg,
@@ -13703,13 +13825,16 @@ function initStyleSheetObserver({ styleSheetRuleCb, mirror: mirror2, stylesheetM
         }
       )
     });
+    win.CSSStyleSheet.prototype.replace = replaceProxy;
   }
   let replaceSync;
+  let replaceSyncProxy;
   if (win.CSSStyleSheet.prototype.replaceSync) {
     replaceSync = win.CSSStyleSheet.prototype.replaceSync;
-    win.CSSStyleSheet.prototype.replaceSync = new Proxy(replaceSync, {
+    replaceSyncProxy = new Proxy(replaceSync, {
       apply: callbackWrapper(
         (target, thisArg, argumentsList) => {
+          if (stopped) return target.apply(thisArg, argumentsList);
           const [text] = argumentsList;
           const { id, styleId } = getIdAndStyleId(
             thisArg,
@@ -13727,6 +13852,7 @@ function initStyleSheetObserver({ styleSheetRuleCb, mirror: mirror2, stylesheetM
         }
       )
     });
+    win.CSSStyleSheet.prototype.replaceSync = replaceSyncProxy;
   }
   const supportedNestedCSSRuleTypes = {};
   if (canMonkeyPatchNestedCSSRule("CSSGroupingRule")) {
@@ -13743,6 +13869,7 @@ function initStyleSheetObserver({ styleSheetRuleCb, mirror: mirror2, stylesheetM
     }
   }
   const unmodifiedFunctions = {};
+  const nestedProxies = {};
   Object.entries(supportedNestedCSSRuleTypes).forEach(([typeKey, type]) => {
     unmodifiedFunctions[typeKey] = {
       // eslint-disable-next-line @typescript-eslint/unbound-method
@@ -13750,11 +13877,13 @@ function initStyleSheetObserver({ styleSheetRuleCb, mirror: mirror2, stylesheetM
       // eslint-disable-next-line @typescript-eslint/unbound-method
       deleteRule: type.prototype.deleteRule
     };
-    type.prototype.insertRule = new Proxy(
+    nestedProxies[typeKey] = {};
+    nestedProxies[typeKey].insertRule = new Proxy(
       unmodifiedFunctions[typeKey].insertRule,
       {
         apply: callbackWrapper(
           (target, thisArg, argumentsList) => {
+            if (stopped) return target.apply(thisArg, argumentsList);
             const [rule2, index2] = argumentsList;
             const { id, styleId } = getIdAndStyleId(
               thisArg.parentStyleSheet,
@@ -13782,11 +13911,12 @@ function initStyleSheetObserver({ styleSheetRuleCb, mirror: mirror2, stylesheetM
         )
       }
     );
-    type.prototype.deleteRule = new Proxy(
+    nestedProxies[typeKey].deleteRule = new Proxy(
       unmodifiedFunctions[typeKey].deleteRule,
       {
         apply: callbackWrapper(
           (target, thisArg, argumentsList) => {
+            if (stopped) return target.apply(thisArg, argumentsList);
             const [index2] = argumentsList;
             const { id, styleId } = getIdAndStyleId(
               thisArg.parentStyleSheet,
@@ -13807,15 +13937,148 @@ function initStyleSheetObserver({ styleSheetRuleCb, mirror: mirror2, stylesheetM
         )
       }
     );
+    type.prototype.insertRule = nestedProxies[typeKey].insertRule;
+    type.prototype.deleteRule = nestedProxies[typeKey].deleteRule;
   });
+  const captureIsHealthy = () => {
+    probing = true;
+    probeInsertObserved = false;
+    probeDeleteObserved = false;
+    try {
+      const probe = probeSheet ?? (probeSheet = new win.CSSStyleSheet());
+      probe.insertRule(":root {}", 0);
+      probe.deleteRule(0);
+    } catch (error) {
+      return {
+        insertRule: win.CSSStyleSheet.prototype.insertRule === insertRuleProxy,
+        deleteRule: win.CSSStyleSheet.prototype.deleteRule === deleteRuleProxy
+      };
+    } finally {
+      probing = false;
+    }
+    return {
+      insertRule: probeInsertObserved,
+      deleteRule: probeDeleteObserved
+    };
+  };
+  let repatchAttempts = 0;
+  const repatch = (health) => {
+    if (repatchAttempts >= MAX_CSSOM_REPATCH_ATTEMPTS) return;
+    repatchAttempts += 1;
+    if (!health.insertRule) {
+      restoreInsertRuleTo = win.CSSStyleSheet.prototype.insertRule;
+      insertRuleProxy = patchInsertRule(restoreInsertRuleTo);
+      win.CSSStyleSheet.prototype.insertRule = insertRuleProxy;
+    }
+    if (!health.deleteRule) {
+      restoreDeleteRuleTo = win.CSSStyleSheet.prototype.deleteRule;
+      deleteRuleProxy = patchDeleteRule(restoreDeleteRuleTo);
+      win.CSSStyleSheet.prototype.deleteRule = deleteRuleProxy;
+    }
+  };
+  const resyncCssomStyleSheets = (trusted) => {
+    for (let i2 = 0; i2 < doc.styleSheets.length; i2++) {
+      const sheet = doc.styleSheets[i2];
+      if (unreconcilableSheets.has(sheet)) continue;
+      const owner = sheet.ownerNode;
+      if (!owner || toLowerCase(owner.nodeName) !== "style") continue;
+      if ((owner.textContent || "").trim().length) continue;
+      const id = mirror2.getId(owner);
+      if (!id || id === -1) continue;
+      let rules2;
+      try {
+        rules2 = sheet.cssRules;
+      } catch (error) {
+        continue;
+      }
+      const live = rules2.length;
+      let state = reportedRuleCounts.get(sheet);
+      if (!state) {
+        if (Array.from(rules2).some((rule2) => isCSSImportRule(rule2))) {
+          unreconcilableSheets.add(sheet);
+          continue;
+        }
+        state = { reported: live, everSeen: live };
+        reportedRuleCounts.set(sheet, state);
+        if (trusted) continue;
+        replaceReplayerCopy(id, state, rules2);
+        continue;
+      }
+      state.everSeen = Math.max(state.everSeen, live);
+      if (live === state.reported) continue;
+      if (live > state.reported) {
+        const adds = [];
+        for (let index2 = state.reported; index2 < live; index2++) {
+          adds.push({ rule: rules2[index2].cssText, index: index2 });
+        }
+        styleSheetRuleCb({ id, adds });
+        state.reported = live;
+      } else {
+        replaceReplayerCopy(id, state, rules2);
+      }
+    }
+  };
+  function replaceReplayerCopy(id, state, rules2) {
+    const removes = [];
+    for (let index2 = state.everSeen - 1; index2 >= 0; index2--) {
+      removes.push({ index: index2 });
+    }
+    if (removes.length) styleSheetRuleCb({ id, removes });
+    styleSheetRuleCb({
+      id,
+      adds: Array.from(rules2, (rule2, index2) => ({
+        rule: rule2.cssText,
+        index: index2
+      }))
+    });
+    state.reported = rules2.length;
+    state.everSeen = rules2.length;
+  }
+  let resyncTimer;
+  if (styleSheetResyncInterval > 0) {
+    resyncTimer = win.setInterval(
+      callbackWrapper(() => {
+        const health = captureIsHealthy();
+        const healthy = health.insertRule && health.deleteRule;
+        if (!healthy) repatch(health);
+        resyncCssomStyleSheets(healthy);
+      }),
+      styleSheetResyncInterval
+    );
+  }
   return callbackWrapper(() => {
-    win.CSSStyleSheet.prototype.insertRule = insertRule;
-    win.CSSStyleSheet.prototype.deleteRule = deleteRule;
-    replace && (win.CSSStyleSheet.prototype.replace = replace);
-    replaceSync && (win.CSSStyleSheet.prototype.replaceSync = replaceSync);
+    if (resyncTimer !== void 0) win.clearInterval(resyncTimer);
+    stopped = true;
+    const proto = win.CSSStyleSheet.prototype;
+    restorePatchedMethod(
+      proto,
+      "insertRule",
+      insertRuleProxy,
+      restoreInsertRuleTo
+    );
+    restorePatchedMethod(
+      proto,
+      "deleteRule",
+      deleteRuleProxy,
+      restoreDeleteRuleTo
+    );
+    restorePatchedMethod(proto, "addRule", addRuleShim, addRule);
+    restorePatchedMethod(proto, "removeRule", removeRuleShim, removeRule);
+    replaceProxy && restorePatchedMethod(proto, "replace", replaceProxy, replace);
+    replaceSyncProxy && restorePatchedMethod(proto, "replaceSync", replaceSyncProxy, replaceSync);
     Object.entries(supportedNestedCSSRuleTypes).forEach(([typeKey, type]) => {
-      type.prototype.insertRule = unmodifiedFunctions[typeKey].insertRule;
-      type.prototype.deleteRule = unmodifiedFunctions[typeKey].deleteRule;
+      restorePatchedMethod(
+        type.prototype,
+        "insertRule",
+        nestedProxies[typeKey].insertRule,
+        unmodifiedFunctions[typeKey].insertRule
+      );
+      restorePatchedMethod(
+        type.prototype,
+        "deleteRule",
+        nestedProxies[typeKey].deleteRule,
+        unmodifiedFunctions[typeKey].deleteRule
+      );
     });
   });
 }
@@ -15583,6 +15846,7 @@ function record(options = {}) {
     keepIframeSrcFn = () => false,
     privacySetting = "default",
     ignoreCSSAttributes = /* @__PURE__ */ new Set([]),
+    styleSheetResyncInterval = 2e3,
     errorHandler: errorHandler2,
     logger
   } = options;
@@ -15961,6 +16225,7 @@ function record(options = {}) {
           processedNodeManager,
           canvasManager,
           ignoreCSSAttributes,
+          styleSheetResyncInterval,
           privacySetting,
           plugins: ((_a3 = plugins == null ? void 0 : plugins.filter((p) => p.observer)) == null ? void 0 : _a3.map((p) => ({
             observer: p.observer,
@@ -16847,12 +17112,36 @@ function variableListFor(ctx, ctor) {
   }
   return contextMap.get(ctor);
 }
-function deserializeArg(imageMap, ctx, preload) {
+const canvasArgConstructors = /* @__PURE__ */ new Set([
+  "Int8Array",
+  "Int16Array",
+  "Int32Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Uint16Array",
+  "Uint32Array",
+  "Float32Array",
+  "Float64Array",
+  "DataView",
+  "ImageData",
+  // normally serialized as base64, but reachable in `args` form through
+  // recordings made by older clients and through nested `DataView` args.
+  "ArrayBuffer",
+  // wraps nested args in recordings made by older clients — see the
+  // `preloadAllImages` tests for the shape.
+  "Array"
+]);
+function deserializeArg(imageMap, ctx, preload, enforceCanvasArgAllowlist = false) {
   return async (arg) => {
     if (arg && typeof arg === "object" && "rr_type" in arg) {
       if (preload) preload.isUnchanged = false;
       if (arg.rr_type === "ImageBitmap" && "args" in arg) {
-        const args = await deserializeArg(imageMap, ctx, preload)(arg.args);
+        const args = await deserializeArg(
+          imageMap,
+          ctx,
+          preload,
+          enforceCanvasArgAllowlist
+        )(arg.args);
         return await createImageBitmap.apply(null, args);
       } else if ("index" in arg) {
         if (preload || ctx === null) return arg;
@@ -16860,10 +17149,18 @@ function deserializeArg(imageMap, ctx, preload) {
         return variableListFor(ctx, name)[index2];
       } else if ("args" in arg) {
         const { rr_type: name, args } = arg;
+        if (enforceCanvasArgAllowlist && !canvasArgConstructors.has(name)) {
+          console.warn(
+            `[replayer] refusing to construct canvas arg of unknown type: ${name}`
+          );
+          return null;
+        }
         const ctor = window[name];
         return new ctor(
           ...await Promise.all(
-            args.map(deserializeArg(imageMap, ctx, preload))
+            args.map(
+              deserializeArg(imageMap, ctx, preload, enforceCanvasArgAllowlist)
+            )
           )
         );
       } else if ("base64" in arg) {
@@ -16880,7 +17177,9 @@ function deserializeArg(imageMap, ctx, preload) {
         }
       } else if ("data" in arg && arg.rr_type === "Blob") {
         const blobContents = await Promise.all(
-          arg.data.map(deserializeArg(imageMap, ctx, preload))
+          arg.data.map(
+            deserializeArg(imageMap, ctx, preload, enforceCanvasArgAllowlist)
+          )
         );
         const blob2 = new Blob(blobContents, {
           type: arg.type
@@ -16889,7 +17188,9 @@ function deserializeArg(imageMap, ctx, preload) {
       }
     } else if (Array.isArray(arg)) {
       const result2 = await Promise.all(
-        arg.map(deserializeArg(imageMap, ctx, preload))
+        arg.map(
+          deserializeArg(imageMap, ctx, preload, enforceCanvasArgAllowlist)
+        )
       );
       return result2;
     }
@@ -16930,7 +17231,8 @@ async function webglMutation({
   target,
   type,
   imageMap,
-  errorHandler: errorHandler2
+  errorHandler: errorHandler2,
+  enforceCanvasArgAllowlist
 }) {
   try {
     const ctx = getContext(target, type);
@@ -16941,7 +17243,9 @@ async function webglMutation({
     }
     const original = ctx[mutation.property];
     const args = await Promise.all(
-      mutation.args.map(deserializeArg(imageMap, ctx))
+      mutation.args.map(
+        deserializeArg(imageMap, ctx, void 0, enforceCanvasArgAllowlist)
+      )
     );
     const result2 = original.apply(ctx, args);
     saveToWebGLVarMap(ctx, result2);
@@ -16956,7 +17260,8 @@ async function canvasMutation$1({
   mutations,
   target,
   imageMap,
-  errorHandler: errorHandler2
+  errorHandler: errorHandler2,
+  enforceCanvasArgAllowlist
 }) {
   const ctx = target.getContext("2d");
   if (!ctx) {
@@ -16966,7 +17271,11 @@ async function canvasMutation$1({
   wrapCanvasContextDrawImage(ctx);
   const mutationArgsPromises = mutations.map(
     async (mutation) => {
-      return Promise.all(mutation.args.map(deserializeArg(imageMap, ctx)));
+      return Promise.all(
+        mutation.args.map(
+          deserializeArg(imageMap, ctx, void 0, enforceCanvasArgAllowlist)
+        )
+      );
     }
   );
   const args = await Promise.all(mutationArgsPromises);
@@ -16996,7 +17305,8 @@ async function canvasMutation({
   target,
   imageMap,
   canvasEventMap,
-  errorHandler: errorHandler2
+  errorHandler: errorHandler2,
+  enforceCanvasArgAllowlist
 }) {
   try {
     const precomputedMutation = canvasEventMap.get(event) || mutation;
@@ -17009,7 +17319,8 @@ async function canvasMutation({
           type: mutation.type,
           target,
           imageMap,
-          errorHandler: errorHandler2
+          errorHandler: errorHandler2,
+          enforceCanvasArgAllowlist
         });
       }
       return;
@@ -17019,7 +17330,8 @@ async function canvasMutation({
       mutations: commands,
       target,
       imageMap,
-      errorHandler: errorHandler2
+      errorHandler: errorHandler2,
+      enforceCanvasArgAllowlist
     });
   } catch (error) {
     errorHandler2(mutation, error);
@@ -17462,6 +17774,7 @@ class Replayer {
       insertStyleRules: [],
       triggerFocus: true,
       UNSAFE_replayCanvas: false,
+      enforceCanvasArgAllowlist: false,
       pauseAnimation: true,
       mouseTail: defaultMouseTailConfig,
       useVirtualDom: true,
@@ -17490,7 +17803,8 @@ class Replayer {
               target,
               imageMap: this.imageMap,
               canvasEventMap: this.canvasEventMap,
-              errorHandler: this.warnCanvasMutationFailed.bind(this)
+              errorHandler: this.warnCanvasMutationFailed.bind(this),
+              enforceCanvasArgAllowlist: this.config.enforceCanvasArgAllowlist
             });
           },
           applyInput: this.applyInput.bind(this),
@@ -18202,7 +18516,14 @@ class Replayer {
         const commands = await Promise.all(
           data.commands.map(async (c2) => {
             const args = await Promise.all(
-              c2.args.map(deserializeArg(this.imageMap, null, status))
+              c2.args.map(
+                deserializeArg(
+                  this.imageMap,
+                  null,
+                  status,
+                  this.config.enforceCanvasArgAllowlist
+                )
+              )
             );
             return { ...c2, args };
           })
@@ -18211,7 +18532,14 @@ class Replayer {
           this.canvasEventMap.set(event, { ...data, commands });
       } else {
         const args = await Promise.all(
-          data.args.map(deserializeArg(this.imageMap, null, status))
+          data.args.map(
+            deserializeArg(
+              this.imageMap,
+              null,
+              status,
+              this.config.enforceCanvasArgAllowlist
+            )
+          )
         );
         if (status.isUnchanged === false)
           this.canvasEventMap.set(event, { ...data, args });
@@ -18424,7 +18752,8 @@ class Replayer {
             target,
             imageMap: this.imageMap,
             canvasEventMap: this.canvasEventMap,
-            errorHandler: this.warnCanvasMutationFailed.bind(this)
+            errorHandler: this.warnCanvasMutationFailed.bind(this),
+            enforceCanvasArgAllowlist: this.config.enforceCanvasArgAllowlist
           });
         }
         break;
@@ -19147,20 +19476,531 @@ class Replayer {
     this.config.logger.log(REPLAY_CONSOLE_PREFIX, ...args);
   }
 }
+const RRWEB_EMBEDDED_CHANNEL = "rrweb-embedded";
+const RRWEB_EMBEDDED_PROTOCOL_VERSION = 1;
+const SERIALIZABLE_CONFIG_KEYS = [
+  "speed",
+  "maxSpeed",
+  "loadTimeout",
+  "skipInactive",
+  "inactivePeriodThreshold",
+  "showWarning",
+  "showDebug",
+  "blockClass",
+  "liveMode",
+  "insertStyleRules",
+  "triggerFocus",
+  "UNSAFE_replayCanvas",
+  "enforceCanvasArgAllowlist",
+  "cspContent",
+  "pauseAnimation",
+  "mouseTail",
+  "useVirtualDom",
+  "inactiveThreshold",
+  "inactiveSkipTime"
+];
+function pickSerializableConfig(config) {
+  const out = {};
+  if (config && typeof config === "object") {
+    for (const key of SERIALIZABLE_CONFIG_KEYS) {
+      const value = config[key];
+      if (value !== void 0 && typeof value !== "function") {
+        out[key] = value;
+      }
+    }
+  }
+  return out;
+}
+function wrap(message) {
+  return {
+    channel: RRWEB_EMBEDDED_CHANNEL,
+    version: RRWEB_EMBEDDED_PROTOCOL_VERSION,
+    message
+  };
+}
+function isEnvelope(data) {
+  if (!data || typeof data !== "object") return false;
+  const e2 = data;
+  return e2.channel === RRWEB_EMBEDDED_CHANNEL && e2.version === RRWEB_EMBEDDED_PROTOCOL_VERSION && !!e2.message && typeof e2.message === "object" && typeof e2.message.type === "string";
+}
+const PAYLOAD_EVENTS = /* @__PURE__ */ new Set([
+  ReplayerEvents.Resize,
+  ReplayerEvents.EventCast,
+  ReplayerEvents.CustomEvent
+]);
+class EmbeddedReplayerHost {
+  constructor(options = {}) {
+    __publicField(this, "root");
+    __publicField(this, "parentWindow");
+    __publicField(this, "timeUpdateIntervalMs");
+    __publicField(this, "expectedParentOrigin");
+    __publicField(this, "replayer", null);
+    __publicField(this, "playing", false);
+    __publicField(this, "timer", null);
+    __publicField(this, "started", false);
+    /**
+     * Last layout the parent asked for. Retained because each `Replayer` builds
+     * its own wrapper element, so a re-init would otherwise drop the scaling and
+     * render the replay at 1:1 in the corner.
+     */
+    __publicField(this, "layout", null);
+    __publicField(this, "onMessage", (event) => {
+      if (event.source !== this.parentWindow) return;
+      if (this.expectedParentOrigin === null) return;
+      if (event.origin !== this.expectedParentOrigin) return;
+      if (!isEnvelope(event.data)) return;
+      try {
+        this.handle(event.data.message);
+      } catch (err) {
+        this.post({
+          type: "error",
+          message: err instanceof Error ? err.message : String(err)
+        });
+      }
+    });
+    this.root = options.root ?? document.body;
+    this.parentWindow = options.parentWindow ?? window.parent;
+    this.timeUpdateIntervalMs = options.timeUpdateIntervalMs ?? 50;
+    this.expectedParentOrigin = options.expectedParentOrigin ?? new URLSearchParams(location.search).get("parentOrigin") ?? null;
+  }
+  /** Install the message listener and announce readiness to the parent. */
+  start() {
+    if (this.started) return;
+    this.started = true;
+    if (this.expectedParentOrigin === null) {
+      console.warn(
+        "[rrweb-embedded] no parentOrigin configured; all incoming messages will be ignored"
+      );
+    }
+    window.addEventListener("message", this.onMessage);
+    this.post({ type: "ready" });
+  }
+  /** Tear everything down (also invoked on a `destroy` command). */
+  stop() {
+    var _a2;
+    window.removeEventListener("message", this.onMessage);
+    this.setPlaying(false);
+    (_a2 = this.replayer) == null ? void 0 : _a2.destroy();
+    this.replayer = null;
+    this.started = false;
+  }
+  handle(command) {
+    var _a2, _b, _c, _d, _e, _f, _g;
+    switch (command.type) {
+      case "ping":
+        this.post({ type: "ready" });
+        return;
+      case "init":
+        this.init(command.events, command.config, command.autoplay);
+        return;
+      case "play":
+        (_a2 = this.replayer) == null ? void 0 : _a2.play(command.timeOffset ?? 0);
+        this.setPlaying(true);
+        return;
+      case "pause":
+        (_b = this.replayer) == null ? void 0 : _b.pause(command.timeOffset);
+        this.setPlaying(false);
+        this.postTime();
+        return;
+      case "resume":
+        (_c = this.replayer) == null ? void 0 : _c.resume(command.timeOffset ?? 0);
+        this.setPlaying(true);
+        return;
+      case "setLayout":
+        this.layout = {
+          scale: command.scale,
+          anchor: command.anchor ?? "center"
+        };
+        this.applyLayout();
+        this.postDimensions();
+        return;
+      case "setConfig":
+        (_d = this.replayer) == null ? void 0 : _d.setConfig(pickSerializableConfig(command.config));
+        return;
+      case "replaceEvents":
+        if (this.replayer) {
+          this.replayer.replaceEvents(command.events);
+          this.postInitialized();
+        }
+        return;
+      case "addEvent":
+        (_e = this.replayer) == null ? void 0 : _e.addEvent(command.event);
+        return;
+      case "enableInteract":
+        (_f = this.replayer) == null ? void 0 : _f.enableInteract();
+        return;
+      case "disableInteract":
+        (_g = this.replayer) == null ? void 0 : _g.disableInteract();
+        return;
+      case "destroy":
+        this.stop();
+        return;
+    }
+  }
+  init(events, config, autoplay) {
+    if (this.replayer) {
+      this.setPlaying(false);
+      this.replayer.destroy();
+    }
+    const replayerConfig = {
+      ...pickSerializableConfig(config),
+      root: this.root
+    };
+    this.replayer = new Replayer(events, replayerConfig);
+    this.wireEvents(this.replayer);
+    this.applyLayout();
+    this.postInitialized();
+    this.postDimensions();
+    if (autoplay) {
+      this.replayer.play(0);
+      this.setPlaying(true);
+    }
+  }
+  /**
+   * Translate the parent's layout intent into styles on the replay wrapper.
+   *
+   * Mirrors what an embedder would otherwise apply from its own stylesheet:
+   * `transform-origin: top left` with `left: 50%` to center horizontally, and
+   * either `top: 50%` + a -50% Y translate to center vertically, or `top: 0`
+   * with no Y translate to anchor at the top edge.
+   */
+  applyLayout() {
+    var _a2;
+    const wrapper = (_a2 = this.replayer) == null ? void 0 : _a2.wrapper;
+    if (!wrapper || !this.layout) return;
+    const { scale, anchor } = this.layout;
+    const top = anchor === "top";
+    wrapper.style.position = "absolute";
+    wrapper.style.transformOrigin = "top left";
+    wrapper.style.left = "50%";
+    wrapper.style.top = top ? "0" : "50%";
+    wrapper.style.transform = top ? `scale(${scale}) translate(-50%, 0)` : `scale(${scale}) translate(-50%, -50%)`;
+  }
+  /** Report the wrapper's rendered geometry; the parent cannot measure it. */
+  postDimensions() {
+    var _a2;
+    const wrapper = (_a2 = this.replayer) == null ? void 0 : _a2.wrapper;
+    if (!wrapper) return;
+    const rect = wrapper.getBoundingClientRect();
+    this.post({
+      type: "dimensions",
+      width: rect.width,
+      height: rect.height,
+      top: rect.top,
+      left: rect.left
+    });
+  }
+  /** Push the stable getters (metadata, activity intervals) to the parent. */
+  postInitialized() {
+    if (!this.replayer) return;
+    this.post({
+      type: "initialized",
+      metadata: this.replayer.getMetaData(),
+      activityIntervals: this.replayer.getActivityIntervals()
+    });
+  }
+  wireEvents(replayer) {
+    for (const name of Object.values(ReplayerEvents)) {
+      replayer.on(name, (payload) => {
+        if (name === ReplayerEvents.Finish) {
+          this.setPlaying(false);
+          this.postTime();
+        }
+        if (name === ReplayerEvents.Resize) {
+          this.postDimensions();
+        }
+        this.post(
+          PAYLOAD_EVENTS.has(name) && payload !== void 0 ? { type: "replayer-event", event: name, payload } : { type: "replayer-event", event: name }
+        );
+      });
+    }
+  }
+  /* --- current-time telemetry ------------------------------------------- */
+  setPlaying(playing) {
+    if (this.playing === playing) return;
+    this.playing = playing;
+    if (playing) this.startTimePump();
+    else this.stopTimePump();
+  }
+  startTimePump() {
+    if (this.timer !== null) return;
+    this.timer = setInterval(() => this.postTime(), this.timeUpdateIntervalMs);
+  }
+  /**
+   * Push the current playback position across the bridge.
+   *
+   * The parent cannot read the position synchronously — it lives in this realm
+   * behind an origin boundary — so the client's `getCurrentTime()` is only ever
+   * as fresh as the last push. While playing, the pump keeps it current. When
+   * playback stops the pump stops too, so the last pumped value would be up to
+   * one interval stale; callers that seek from it (`play(getCurrentTime())` to
+   * resume) would drift backwards. Pausing and finishing therefore push one
+   * final, settled value.
+   */
+  postTime() {
+    if (!this.replayer) return;
+    this.post({ type: "time", currentTime: this.replayer.getCurrentTime() });
+  }
+  stopTimePump() {
+    if (this.timer !== null) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  post(message) {
+    this.parentWindow.postMessage(
+      wrap(message),
+      this.expectedParentOrigin ?? "*"
+    );
+  }
+}
+function startEmbeddedReplayerHost(options) {
+  const host2 = new EmbeddedReplayerHost(options);
+  host2.start();
+  return host2;
+}
+class EmbeddedReplayerClient {
+  constructor(iframe, options = {}) {
+    __publicField(this, "iframe");
+    __publicField(this, "hostOrigin");
+    __publicField(this, "listeners", /* @__PURE__ */ new Map());
+    __publicField(this, "metadata", null);
+    __publicField(this, "activityIntervals", []);
+    __publicField(this, "dimensions", null);
+    __publicField(this, "lastCurrentTime", 0);
+    __publicField(this, "ready", false);
+    __publicField(this, "readyResolvers", []);
+    __publicField(this, "disposed", false);
+    /**
+     * Commands issued before the host handshakes. A command posted while the
+     * iframe is still on its initial `about:blank` (which carries the PARENT's
+     * origin) is rejected by the browser as an origin mismatch and lost — the
+     * viewer calls `setLayout` on mount, well before the host boots. Buffer until
+     * `ready`, then flush; by then the frame is on the host origin.
+     */
+    __publicField(this, "pending", []);
+    __publicField(this, "onMessage", (event) => {
+      if (event.source !== this.iframe.contentWindow) return;
+      if (!isEnvelope(event.data)) return;
+      this.handle(event.data.message);
+    });
+    this.iframe = iframe;
+    this.hostOrigin = options.hostOrigin ?? "*";
+    window.addEventListener("message", this.onMessage);
+    this.probe();
+  }
+  /** Resolves once the host iframe has loaded and announced readiness. */
+  whenReady() {
+    if (this.ready) return Promise.resolve();
+    return new Promise((resolve) => this.readyResolvers.push(resolve));
+  }
+  /* --- commands --------------------------------------------------------- */
+  init(events, config, autoplay = false) {
+    this.send({ type: "init", events, config, autoplay });
+  }
+  play(timeOffset) {
+    this.send({ type: "play", timeOffset });
+  }
+  pause(timeOffset) {
+    this.send({ type: "pause", timeOffset });
+  }
+  resume(timeOffset) {
+    this.send({ type: "resume", timeOffset });
+  }
+  setConfig(config) {
+    this.send({ type: "setConfig", config });
+  }
+  /**
+   * Scale and position the replay. Compute `scale` from your own container size
+   * and the recorded viewport, as you would when driving a local `Replayer`;
+   * the host applies it, since the wrapper element is not reachable from here.
+   * The layout is retained across re-inits.
+   */
+  setLayout(scale, anchor) {
+    this.send({ type: "setLayout", scale, anchor });
+  }
+  replaceEvents(events) {
+    this.send({ type: "replaceEvents", events });
+  }
+  addEvent(event) {
+    this.send({ type: "addEvent", event });
+  }
+  enableInteract() {
+    this.send({ type: "enableInteract" });
+  }
+  disableInteract() {
+    this.send({ type: "disableInteract" });
+  }
+  /** Tear down: destroys the host replayer and detaches the listener. */
+  destroy() {
+    if (this.disposed) return;
+    this.disposed = true;
+    try {
+      this.send({ type: "destroy" });
+    } finally {
+      window.removeEventListener("message", this.onMessage);
+      this.listeners.clear();
+    }
+  }
+  /* --- event surface ---------------------------------------------------- */
+  on(event, listener) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(listener);
+  }
+  off(event, listener) {
+    var _a2;
+    (_a2 = this.listeners.get(event)) == null ? void 0 : _a2.delete(listener);
+  }
+  /* --- getters ---------------------------------------------------------- */
+  // Cached getters mirroring the local Replayer's synchronous ones. Metadata
+  // and activity intervals arrive on `initialized` (re-sent on replaceEvents);
+  // current time is streamed by the host while playing.
+  /** Last-known current time (pushed by the host while playing). */
+  getCurrentTime() {
+    return this.lastCurrentTime;
+  }
+  getMetaData() {
+    return this.metadata;
+  }
+  getActivityIntervals() {
+    return this.activityIntervals;
+  }
+  /**
+   * Rendered geometry of the replay, in the host document's coordinate space —
+   * the cross-origin stand-in for `replayer.wrapper.getBoundingClientRect()`.
+   * Null until the host has reported it (listen for `'dimensions'`).
+   */
+  getDimensions() {
+    return this.dimensions;
+  }
+  /* --- internals -------------------------------------------------------- */
+  send(command) {
+    if (!this.ready) {
+      this.pending.push(command);
+      return;
+    }
+    this.postToHost(command);
+  }
+  postToHost(command) {
+    const target = this.iframe.contentWindow;
+    if (!target) return;
+    target.postMessage(wrap(command), this.hostOrigin);
+  }
+  flushPending() {
+    const queued = this.pending;
+    this.pending = [];
+    queued.forEach((command) => this.postToHost(command));
+  }
+  /** Data-free handshake probe; see the note in the constructor. */
+  probe() {
+    var _a2;
+    (_a2 = this.iframe.contentWindow) == null ? void 0 : _a2.postMessage(wrap({ type: "ping" }), "*");
+  }
+  handle(message) {
+    switch (message.type) {
+      case "ready":
+        this.ready = true;
+        this.flushPending();
+        this.readyResolvers.forEach((r2) => r2());
+        this.readyResolvers = [];
+        return;
+      case "initialized":
+        this.metadata = message.metadata;
+        this.activityIntervals = message.activityIntervals;
+        this.emit("initialized", message.metadata);
+        return;
+      case "replayer-event":
+        this.emit(message.event, message.payload);
+        return;
+      case "time":
+        this.lastCurrentTime = message.currentTime;
+        this.emit("time", message.currentTime);
+        return;
+      case "dimensions":
+        this.dimensions = {
+          width: message.width,
+          height: message.height,
+          top: message.top,
+          left: message.left
+        };
+        this.emit("dimensions", this.dimensions);
+        return;
+      case "error":
+        this.emit("error", message.message);
+        return;
+    }
+  }
+  emit(event, payload) {
+    var _a2;
+    (_a2 = this.listeners.get(event)) == null ? void 0 : _a2.forEach((listener) => listener(payload));
+  }
+}
+function originOf(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return "'self'";
+  }
+}
+function buildHostDocument(options) {
+  const scriptOrigin = originOf(options.scriptUrl);
+  const styleSources = [
+    "'unsafe-inline'",
+    scriptOrigin,
+    ...options.extraStyleSources ?? []
+  ].join(" ");
+  const csp = [
+    `default-src 'none'`,
+    `script-src ${scriptOrigin}`,
+    `style-src ${styleSources}`,
+    `img-src * data: blob:`,
+    `font-src * data:`,
+    `media-src * data: blob:`,
+    `frame-src *`,
+    `connect-src 'none'`,
+    `worker-src 'none'`
+  ].join("; ");
+  const styleTag = options.styleUrl ? `<link rel="stylesheet" href="${escapeAttr(options.styleUrl)}">` : "";
+  return `<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta http-equiv="Content-Security-Policy" content="${escapeAttr(csp)}">
+<style>html,body{margin:0;padding:0;height:100%;overflow:hidden;background:transparent}</style>
+${styleTag}
+<script type="module" src="${escapeAttr(options.scriptUrl)}"><\/script>
+</head>
+<body></body>
+</html>`;
+}
+function escapeAttr(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
 const { addCustomEvent } = record;
 const { freezePage } = record;
 const { takeFullSnapshot } = record;
 export {
+  EmbeddedReplayerClient,
+  EmbeddedReplayerHost,
   EventType,
   IncrementalSource,
   MouseInteractions,
+  RRWEB_EMBEDDED_CHANNEL,
+  RRWEB_EMBEDDED_PROTOCOL_VERSION,
   Replayer,
   ReplayerEvents,
   addCustomEvent,
+  buildHostDocument,
   canvasMutation,
   freezePage,
   _mirror as mirror,
+  pickSerializableConfig,
   record,
+  startEmbeddedReplayerHost,
   takeFullSnapshot,
   utils
 };