@sailfish-ai/recorder 1.0.0-beta-12 → 1.0.0-beta-2

package/dist/sailfish-recorder.es.js

@@ -1,31 +1,31 @@
-var byteToHex = [];
-for (var i = 0; i < 256; ++i) {
-  byteToHex.push((i + 256).toString(16).slice(1));
+var byteToHex$1 = [];
+for (var i$2 = 0; i$2 < 256; ++i$2) {
+  byteToHex$1.push((i$2 + 256).toString(16).slice(1));
 }
 function unsafeStringify(arr, offset = 0) {
-  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+  return (byteToHex$1[arr[offset + 0]] + byteToHex$1[arr[offset + 1]] + byteToHex$1[arr[offset + 2]] + byteToHex$1[arr[offset + 3]] + "-" + byteToHex$1[arr[offset + 4]] + byteToHex$1[arr[offset + 5]] + "-" + byteToHex$1[arr[offset + 6]] + byteToHex$1[arr[offset + 7]] + "-" + byteToHex$1[arr[offset + 8]] + byteToHex$1[arr[offset + 9]] + "-" + byteToHex$1[arr[offset + 10]] + byteToHex$1[arr[offset + 11]] + byteToHex$1[arr[offset + 12]] + byteToHex$1[arr[offset + 13]] + byteToHex$1[arr[offset + 14]] + byteToHex$1[arr[offset + 15]]).toLowerCase();
 }
-var getRandomValues;
-var rnds8 = new Uint8Array(16);
-function rng() {
-  if (!getRandomValues) {
-    getRandomValues = typeof crypto !== "undefined" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
-    if (!getRandomValues) {
+var getRandomValues$1;
+var rnds8$1 = new Uint8Array(16);
+function rng$1() {
+  if (!getRandomValues$1) {
+    getRandomValues$1 = typeof crypto !== "undefined" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
+    if (!getRandomValues$1) {
       throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
     }
   }
-  return getRandomValues(rnds8);
+  return getRandomValues$1(rnds8$1);
 }
 var randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
 const native = {
   randomUUID
 };
-function v4(options, buf, offset) {
+function v4$1(options, buf, offset) {
   if (native.randomUUID && !buf && !options) {
     return native.randomUUID();
   }
   options = options || {};
-  var rnds = options.random || (options.rng || rng)();
+  var rnds = options.random || (options.rng || rng$1)();
   rnds[6] = rnds[6] & 15 | 64;
   rnds[8] = rnds[8] & 63 | 128;
   return unsafeStringify(rnds);
@@ -4940,7 +4940,7 @@ function hookSetter$1(target, key, d, isRevoked, win = window) {
   );
   return () => hookSetter$1(target, key, original || {}, true);
 }
-function patch$1(source, name, replacement) {
+function patch$2(source, name, replacement) {
   try {
     if (!(name in source)) {
       return () => {
@@ -6782,7 +6782,7 @@ function initFontObserver({ fontCb, doc }) {
     });
     return fontFace;
   };
-  const restoreHandler = patch$1(
+  const restoreHandler = patch$2(
     doc.fonts,
     "add",
     function(original) {
@@ -6842,7 +6842,7 @@ function initCustomElementObserver({
   const win = doc.defaultView;
   if (!win || !win.customElements) return () => {
   };
-  const restoreHandler = patch$1(
+  const restoreHandler = patch$2(
     win.customElements,
     "define",
     function(original) {
@@ -7200,7 +7200,7 @@ function initCanvas2DMutationObserver(cb, win, blockClass, blockSelector) {
       if (typeof win.CanvasRenderingContext2D.prototype[prop] !== "function") {
         continue;
       }
-      const restoreHandler = patch$1(
+      const restoreHandler = patch$2(
         win.CanvasRenderingContext2D.prototype,
         prop,
         function(original) {
@@ -7248,7 +7248,7 @@ function getNormalizedContextName(contextType) {
 function initCanvasContextObserver(win, blockClass, blockSelector, setPreserveDrawingBufferToTrue) {
   const handlers = [];
   try {
-    const restoreHandler = patch$1(
+    const restoreHandler = patch$2(
       win.HTMLCanvasElement.prototype,
       "getContext",
       function(original) {
@@ -7300,7 +7300,7 @@ function patchGLPrototype(prototype, type, cb, blockClass, blockSelector, win) {
       if (typeof prototype[prop] !== "function") {
         continue;
       }
-      const restoreHandler = patch$1(
+      const restoreHandler = patch$2(
         prototype,
         prop,
         function(original) {
@@ -7669,7 +7669,7 @@ class ShadowDomManager {
   patchAttachShadow(element, doc) {
     const manager = this;
     this.restoreHandlers.push(
-      patch$1(
+      patch$2(
         element.prototype,
         "attachShadow",
         function(original) {
@@ -11708,7 +11708,7 @@ let Declaration22$1 = declaration$2;
 let LazyResult22$1 = lazyResult$2;
 let Container22$1 = container$2;
 let Processor22$1 = processor$2;
-let stringify$7 = stringify_1$2;
+let stringify$8 = stringify_1$2;
 let fromJSON$3 = fromJSON_1$2;
 let Document222$1 = document$1$1;
 let Warning22$1 = warning$2;
@@ -11758,7 +11758,7 @@ postcss$4.plugin = function plugin2(name, initializer) {
   };
   return creator;
 };
-postcss$4.stringify = stringify$7;
+postcss$4.stringify = stringify$8;
 postcss$4.parse = parse$6;
 postcss$4.fromJSON = fromJSON$3;
 postcss$4.list = list$4;
@@ -15531,7 +15531,7 @@ function hookSetter(target, key, d, isRevoked, win = window) {
   );
   return () => hookSetter(target, key, original || {}, true);
 }
-function patch(source, name, replacement) {
+function patch$1(source, name, replacement) {
   try {
     if (!(name in source)) {
       return () => {
@@ -15851,7 +15851,7 @@ const utils = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePropert
     return nowTimestamp;
   },
   on,
-  patch,
+  patch: patch$1,
   polyfill: polyfill$1,
   queueToResolveTrees,
   shadowHostInDom,
@@ -19657,7 +19657,7 @@ function isObjTooDeep(obj, limit) {
   }
   return false;
 }
-function stringify(obj, stringifyOptions) {
+function stringify$7(obj, stringifyOptions) {
   const options = {
     numOfKeysLimit: 50,
     depthOfLimit: 4
@@ -19781,7 +19781,7 @@ function initLogObserver(cb, win, options) {
       const trace = ErrorStackParser.parse(error).map(
         (stackFrame) => stackFrame.toString()
       );
-      const payload = [stringify(message, logOptions.stringifyOptions)];
+      const payload = [stringify$7(message, logOptions.stringifyOptions)];
       cb({
         level: "error",
         trace,
@@ -19798,7 +19798,7 @@ function initLogObserver(cb, win, options) {
       if (event.reason instanceof Error) {
         error = event.reason;
         payload = [
-          stringify(
+          stringify$7(
             `Uncaught (in promise) ${error.name}: ${error.message}`,
             logOptions.stringifyOptions
           )
@@ -19806,8 +19806,8 @@ function initLogObserver(cb, win, options) {
       } else {
         error = new Error();
         payload = [
-          stringify("Uncaught (in promise)", logOptions.stringifyOptions),
-          stringify(event.reason, logOptions.stringifyOptions)
+          stringify$7("Uncaught (in promise)", logOptions.stringifyOptions),
+          stringify$7(event.reason, logOptions.stringifyOptions)
         ];
       }
       const trace = ErrorStackParser.parse(error).map(
@@ -19852,7 +19852,7 @@ function initLogObserver(cb, win, options) {
             const trace = ErrorStackParser.parse(new Error()).map((stackFrame) => stackFrame.toString()).splice(1);
             const argsForPayload = level === "assert" ? args.slice(1) : args;
             const payload = argsForPayload.map(
-              (s) => stringify(s, logOptions.stringifyOptions)
+              (s) => stringify$7(s, logOptions.stringifyOptions)
             );
             logCount++;
             if (logCount < logOptions.lengthThreshold) {
@@ -19866,7 +19866,7 @@ function initLogObserver(cb, win, options) {
                 level: "warn",
                 trace: [],
                 payload: [
-                  stringify("The number of log records reached the threshold.")
+                  stringify$7("The number of log records reached the threshold.")
                 ]
               });
             }
@@ -19886,6 +19886,524 @@ const getRecordConsolePlugin = (options) => ({
   observer: initLogObserver,
   options
 });
+var getRandomValues;
+var rnds8 = new Uint8Array(16);
+function rng() {
+  if (!getRandomValues) {
+    getRandomValues = typeof crypto !== "undefined" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== "undefined" && typeof msCrypto.getRandomValues === "function" && msCrypto.getRandomValues.bind(msCrypto);
+    if (!getRandomValues) {
+      throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+    }
+  }
+  return getRandomValues(rnds8);
+}
+const REGEX = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
+function validate(uuid) {
+  return typeof uuid === "string" && REGEX.test(uuid);
+}
+var byteToHex = [];
+for (var i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).substr(1));
+}
+function stringify(arr) {
+  var offset = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
+  var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+  if (!validate(uuid)) {
+    throw TypeError("Stringified UUID is invalid");
+  }
+  return uuid;
+}
+function v4(options, buf, offset) {
+  options = options || {};
+  var rnds = options.random || (options.rng || rng)();
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  return stringify(rnds);
+}
+function findLast(array, predicate) {
+  const length = array.length;
+  for (let i = length - 1; i >= 0; i -= 1) {
+    if (predicate(array[i])) {
+      return array[i];
+    }
+  }
+}
+function patch(source, name, replacement) {
+  try {
+    if (!(name in source)) {
+      return () => {
+      };
+    }
+    const original = source[name];
+    const wrapped = replacement(original);
+    if (typeof wrapped === "function") {
+      wrapped.prototype = wrapped.prototype || {};
+      Object.defineProperties(wrapped, {
+        __rrweb_original__: {
+          enumerable: false,
+          value: original
+        }
+      });
+    }
+    source[name] = wrapped;
+    return () => {
+      source[name] = original;
+    };
+  } catch {
+    return () => {
+    };
+  }
+}
+const defaultNetworkOptions = {
+  initiatorTypes: [
+    "audio",
+    "beacon",
+    "body",
+    "css",
+    "early-hint",
+    "embed",
+    "fetch",
+    "frame",
+    "iframe",
+    "icon",
+    "image",
+    "img",
+    "input",
+    "link",
+    "navigation",
+    "object",
+    "ping",
+    "script",
+    "track",
+    "video",
+    "xmlhttprequest"
+  ],
+  ignoreRequestFn: () => false,
+  recordHeaders: false,
+  recordBody: false,
+  recordInitialRequests: false
+};
+const isNavigationTiming = (entry) => entry.entryType === "navigation";
+const isResourceTiming = (entry) => entry.entryType === "resource";
+let requestId = `sfui-${v4()}`;
+function updateRequestId(newId) {
+  requestId = newId;
+  console.error(`X-SF3-RID updated to ${newId}`);
+}
+function initPerformanceObserver(cb, win, options) {
+  if (options.recordInitialRequests) {
+    const initialPerformanceEntries = win.performance.getEntries().filter(
+      (entry) => isNavigationTiming(entry) || isResourceTiming(entry) && options.initiatorTypes.includes(
+        entry.initiatorType
+      )
+    );
+    cb({
+      requests: initialPerformanceEntries.map((entry) => ({
+        url: entry.name,
+        initiatorType: entry.initiatorType,
+        status: "responseStatus" in entry ? entry.responseStatus : void 0,
+        startTime: Math.round(entry.startTime),
+        endTime: Math.round(entry.responseEnd)
+      })),
+      isInitial: true
+    });
+  }
+  const observer = new win.PerformanceObserver((entries) => {
+    const performanceEntries = entries.getEntries().filter(
+      (entry) => isNavigationTiming(entry) || isResourceTiming(entry) && options.initiatorTypes.includes(
+        entry.initiatorType
+      ) && entry.initiatorType !== "xmlhttprequest" && entry.initiatorType !== "fetch"
+    );
+    cb({
+      requests: performanceEntries.map((entry) => ({
+        url: entry.name,
+        initiatorType: entry.initiatorType,
+        status: "responseStatus" in entry ? entry.responseStatus : void 0,
+        startTime: Math.round(entry.startTime),
+        endTime: Math.round(entry.responseEnd)
+      }))
+    });
+  });
+  observer.observe({ entryTypes: ["navigation", "resource"] });
+  return () => {
+    observer.disconnect();
+  };
+}
+function shouldRecordHeaders(type, recordHeaders, headers, ignoredHeaders) {
+  if (!recordHeaders) {
+    return false;
+  }
+  if (typeof recordHeaders === "boolean") {
+    if (!recordHeaders) return false;
+  } else if (!recordHeaders[type]) {
+    return false;
+  }
+  const typeSpecificIgnoredHeaders = ignoredHeaders ? ignoredHeaders[type] : [];
+  const effectiveHeaders = {};
+  Object.keys(headers).forEach((header) => {
+    if (typeSpecificIgnoredHeaders && typeSpecificIgnoredHeaders.includes(header.toLowerCase())) {
+      effectiveHeaders[header] = headers[header];
+    }
+  });
+  return Object.keys(effectiveHeaders).length > 0;
+}
+function filterHeaders(type, headers, ignoredHeaders) {
+  const filteredHeaders = {};
+  const toIgnore = ignoredHeaders ? ignoredHeaders[type] : [];
+  Object.keys(headers).forEach((header) => {
+    if (!toIgnore.includes(header.toLowerCase())) {
+      filteredHeaders[header] = headers[header];
+    }
+  });
+  return filteredHeaders;
+}
+function shouldRecordBody(type, recordBody, headers, ignoreBodyParts) {
+  function matchesContentType(contentTypes) {
+    const contentTypeHeader = Object.keys(headers).find(
+      (key) => key.toLowerCase() === "content-type"
+    );
+    const contentType = contentTypeHeader && headers[contentTypeHeader];
+    return contentTypes.some((ct) => contentType == null ? void 0 : contentType.includes(ct));
+  }
+  if (!recordBody) return false;
+  if (typeof recordBody === "boolean") return true;
+  if (Array.isArray(recordBody)) return matchesContentType(recordBody);
+  const recordBodyType = recordBody[type];
+  if (typeof recordBodyType === "boolean") return recordBodyType;
+  return matchesContentType(recordBodyType);
+}
+function getRecordedBody(body, type, ignoreBodyParts) {
+  if (!body || typeof body !== "string") {
+    return body;
+  }
+  try {
+    const data = JSON.parse(body);
+    const ignoredParts = ignoreBodyParts ? ignoreBodyParts[type] : [];
+    const removeNestedProperty = (obj, path) => {
+      const parts = path.split(".");
+      const last = parts.pop();
+      const lastObj = parts.reduce((o, key) => o[key] = o[key] || {}, obj);
+      if (last !== void 0) {
+        delete lastObj[last];
+      }
+    };
+    ignoredParts.forEach((path) => {
+      removeNestedProperty(data, path);
+    });
+    return JSON.stringify(data);
+  } catch (error) {
+    return body;
+  }
+}
+async function getRequestPerformanceEntry(win, initiatorType, url, after, before, attempt = 0) {
+  if (attempt > 10) {
+    throw new Error("Cannot find performance entry");
+  }
+  const urlPerformanceEntries = win.performance.getEntriesByName(
+    url
+  );
+  const performanceEntry = findLast(
+    urlPerformanceEntries,
+    (entry) => isResourceTiming(entry) && entry.initiatorType === initiatorType && (!after || entry.startTime >= after) && (!before || entry.startTime <= before)
+  );
+  if (!performanceEntry) {
+    await new Promise((resolve2) => setTimeout(resolve2, 50 * attempt));
+    return getRequestPerformanceEntry(
+      win,
+      initiatorType,
+      url,
+      after,
+      before,
+      attempt + 1
+    );
+  }
+  return performanceEntry;
+}
+function initXhrObserver(cb, win, options) {
+  if (!options.initiatorTypes.includes("xmlhttprequest")) {
+    return () => {
+    };
+  }
+  const restorePatch = patch(
+    win.XMLHttpRequest.prototype,
+    "open",
+    (originalOpen) => {
+      return function(method, url, async = true, username, password) {
+        const xhr = this;
+        const req = new Request(url);
+        const networkRequest = {};
+        let after;
+        let before;
+        const requestHeaders = {};
+        const originalSetRequestHeader = xhr.setRequestHeader.bind(xhr);
+        xhr.setRequestHeader = (header, value) => {
+          requestHeaders[header] = value;
+          return originalSetRequestHeader(header, value);
+        };
+        xhr.setRequestHeader("X-SF3-RID", requestId);
+        const recordRequestHeaders = shouldRecordHeaders(
+          "request",
+          options.recordHeaders,
+          requestHeaders,
+          options.ignoreHeaders
+        );
+        if (recordRequestHeaders) {
+          networkRequest.requestHeaders = filterHeaders(
+            "request",
+            requestHeaders,
+            options.ignoreHeaders
+          );
+        }
+        const originalSend = xhr.send.bind(xhr);
+        xhr.send = (body) => {
+          if (shouldRecordBody(
+            "request",
+            options.recordBody,
+            requestHeaders,
+            options.ignoreBodyParts
+          )) {
+            if (body === void 0 || body === null) {
+              networkRequest.requestBody = null;
+            } else {
+              networkRequest.requestBody = getRecordedBody(
+                body,
+                "request",
+                options.ignoreBodyParts
+              );
+            }
+          }
+          after = win.performance.now();
+          return originalSend(body);
+        };
+        xhr.addEventListener("readystatechange", () => {
+          if (xhr.readyState !== xhr.DONE) {
+            return;
+          }
+          before = win.performance.now();
+          const responseHeaders = {};
+          const rawHeaders = xhr.getAllResponseHeaders();
+          const headers = rawHeaders.trim().split(/[\r\n]+/);
+          headers.forEach((line) => {
+            const parts = line.split(": ");
+            const header = parts.shift();
+            const value = parts.join(": ");
+            if (header) {
+              responseHeaders[header] = value;
+            }
+            if (header === "X-SF3-RID" && value !== requestId) {
+              updateRequestId(value);
+            }
+          });
+          const recordResponseHeaders = shouldRecordHeaders(
+            "response",
+            options.recordHeaders,
+            responseHeaders,
+            options.ignoreHeaders
+          );
+          if (recordResponseHeaders) {
+            networkRequest.responseHeaders = filterHeaders(
+              "response",
+              responseHeaders,
+              options.ignoreHeaders
+            );
+          }
+          if (shouldRecordBody(
+            "response",
+            options.recordBody,
+            responseHeaders,
+            options.ignoreBodyParts
+          )) {
+            if (xhr.response === void 0 || xhr.response === null) {
+              networkRequest.responseBody = null;
+            } else {
+              networkRequest.responseBody = getRecordedBody(
+                xhr.response,
+                "response",
+                options.ignoreBodyParts
+              );
+            }
+          }
+          getRequestPerformanceEntry(
+            win,
+            "xmlhttprequest",
+            req.url,
+            after,
+            before
+          ).then((entry) => {
+            const request = {
+              url: entry.name,
+              method: req.method,
+              initiatorType: entry.initiatorType,
+              status: xhr.status,
+              startTime: Math.round(entry.startTime),
+              endTime: Math.round(entry.responseEnd),
+              requestHeaders: networkRequest.requestHeaders,
+              requestBody: networkRequest.requestBody,
+              responseHeaders: networkRequest.responseHeaders,
+              responseBody: networkRequest.responseBody
+            };
+            cb({ requests: [request] });
+          }).catch(() => {
+          });
+        });
+        originalOpen.call(xhr, method, url, async, username, password);
+      };
+    }
+  );
+  return () => {
+    restorePatch();
+  };
+}
+function initFetchObserver(cb, win, options) {
+  if (!options.initiatorTypes.includes("fetch")) {
+    return () => {
+    };
+  }
+  const restorePatch = patch(win, "fetch", (originalFetch) => {
+    return async function(url, init) {
+      const req = new Request(url, {
+        ...init,
+        headers: {
+          ...init == null ? void 0 : init.headers,
+          "X-SF3-RID": requestId
+        }
+      });
+      let res;
+      const networkRequest = {};
+      let after;
+      let before;
+      try {
+        const requestHeaders = {};
+        req.headers.forEach((value, header) => {
+          requestHeaders[header] = value;
+        });
+        const recordRequestHeaders = shouldRecordHeaders(
+          "request",
+          options.recordHeaders,
+          requestHeaders,
+          options.ignoreHeaders
+        );
+        if (recordRequestHeaders) {
+          networkRequest.requestHeaders = filterHeaders(
+            "request",
+            requestHeaders,
+            options.ignoreHeaders
+          );
+        }
+        if (shouldRecordBody(
+          "request",
+          options.recordBody,
+          requestHeaders,
+          options.ignoreBodyParts
+        )) {
+          if (req.body === void 0 || req.body === null) {
+            networkRequest.requestBody = null;
+          } else {
+            networkRequest.requestBody = getRecordedBody(
+              await req.clone().text(),
+              "request",
+              options.ignoreBodyParts
+            );
+          }
+        }
+        after = win.performance.now();
+        res = await originalFetch(req);
+        before = win.performance.now();
+        const responseHeaders = {};
+        res.headers.forEach((value, header) => {
+          responseHeaders[header] = value;
+          if (header === "X-SF3-RID" && value !== requestId) {
+            updateRequestId(value);
+          }
+        });
+        const recordResponseHeaders = shouldRecordHeaders(
+          "response",
+          options.recordHeaders,
+          responseHeaders,
+          options.ignoreHeaders
+        );
+        if (recordResponseHeaders) {
+          networkRequest.responseHeaders = filterHeaders(
+            "response",
+            responseHeaders,
+            options.ignoreHeaders
+          );
+        }
+        if (shouldRecordBody(
+          "response",
+          options.recordBody,
+          responseHeaders,
+          options.ignoreBodyParts
+        )) {
+          let body;
+          try {
+            body = await res.clone().text();
+          } catch {
+          }
+          if (res.body === void 0 || res.body === null) {
+            networkRequest.responseBody = null;
+          } else {
+            networkRequest.responseBody = getRecordedBody(
+              await res.clone().text(),
+              "response",
+              options.ignoreBodyParts
+            );
+          }
+        }
+        return res;
+      } finally {
+        getRequestPerformanceEntry(win, "fetch", req.url, after, before).then((entry) => {
+          const request = {
+            url: entry.name,
+            method: req.method,
+            initiatorType: entry.initiatorType,
+            status: res == null ? void 0 : res.status,
+            startTime: Math.round(entry.startTime),
+            endTime: Math.round(entry.responseEnd),
+            requestHeaders: networkRequest.requestHeaders,
+            requestBody: networkRequest.requestBody,
+            responseHeaders: networkRequest.responseHeaders,
+            responseBody: networkRequest.responseBody
+          };
+          cb({ requests: [request] });
+        }).catch(() => {
+        });
+      }
+    };
+  });
+  return () => {
+    restorePatch();
+  };
+}
+function initNetworkObserver(callback, win, options) {
+  if (!("performance" in win)) {
+    return () => {
+    };
+  }
+  const networkOptions = options ? Object.assign({}, defaultNetworkOptions, options) : defaultNetworkOptions;
+  const cb = (data) => {
+    const requests = data.requests.filter(
+      (request) => !networkOptions.ignoreRequestFn(request)
+    );
+    if (requests.length > 0 || data.isInitial) {
+      callback({ ...data, requests });
+    }
+  };
+  const performanceObserver = initPerformanceObserver(cb, win, networkOptions);
+  const xhrObserver = initXhrObserver(cb, win, networkOptions);
+  const fetchObserver = initFetchObserver(cb, win, networkOptions);
+  return () => {
+    performanceObserver();
+    xhrObserver();
+    fetchObserver();
+  };
+}
+const NETWORK_PLUGIN_NAME = "@sailfish-rrweb/rrweb/network@1";
+const getRecordNetworkPlugin = (options) => ({
+  name: NETWORK_PLUGIN_NAME,
+  observer: initNetworkObserver,
+  options
+});
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation. All rights reserved.
 Licensed under the Apache License, Version 2.0 (the "License"); you may not use
@@ -20453,13 +20971,13 @@ var ReconnectingWebSocket = (
     return ReconnectingWebSocket2;
   }()
 );
-const version = "1.0.0-beta-12";
+const version = "1.0.0-beta-2";
 function initializeWebSocket(backendApi, apiKey, sessionId) {
   const wsHost = getWebSocketHost(backendApi);
   const wsScheme = window.location.protocol === "https:" ? "wss" : "ws";
   const wsUrl = `${wsScheme}://${wsHost}/ws/notify/?apiKey=${apiKey}&sessionId=${sessionId}&sender=JS%2FTS&version=${version}`;
   const options = {
-    connectionTimeout: 1e4
+    connectionTimeout: 5e3
   };
   const webSocket = new ReconnectingWebSocket(wsUrl, [], options);
   return webSocket;
@@ -20480,8 +20998,8 @@ async function initializeRecording(captureSettings, consoleRecordSettings, netwo
         cacheEvents(event);
       },
       plugins: [
-        getRecordConsolePlugin(consoleRecordSettings)
-        // getRecordNetworkPlugin(networkRecordSettings),
+        getRecordConsolePlugin(consoleRecordSettings),
+        getRecordNetworkPlugin(networkRecordSettings)
       ],
       maskInputOptions: { text: true },
       // Fix the incorrect property name
@@ -20547,7 +21065,7 @@ async function startRecording({
   backendApi
 }) {
   var _a2, _b;
-  const sessionId = v4();
+  const sessionId = v4$1();
   try {
     const captureSettingsResponse = await fetchCaptureSettings(
       apiKey,