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

package/dist/sailfish-recorder.umd.js

@@ -2,34 +2,34 @@
   typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.SailfishRecorder = {}));
 })(this, function(exports2) {
   "use strict";
-  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);
@@ -4944,7 +4944,7 @@
     );
     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 () => {
@@ -6786,7 +6786,7 @@
       });
       return fontFace;
     };
-    const restoreHandler = patch$1(
+    const restoreHandler = patch$2(
       doc.fonts,
       "add",
       function(original) {
@@ -6846,7 +6846,7 @@
     const win = doc.defaultView;
     if (!win || !win.customElements) return () => {
     };
-    const restoreHandler = patch$1(
+    const restoreHandler = patch$2(
       win.customElements,
       "define",
       function(original) {
@@ -7204,7 +7204,7 @@
         if (typeof win.CanvasRenderingContext2D.prototype[prop] !== "function") {
           continue;
         }
-        const restoreHandler = patch$1(
+        const restoreHandler = patch$2(
           win.CanvasRenderingContext2D.prototype,
           prop,
           function(original) {
@@ -7252,7 +7252,7 @@
   function initCanvasContextObserver(win, blockClass, blockSelector, setPreserveDrawingBufferToTrue) {
     const handlers = [];
     try {
-      const restoreHandler = patch$1(
+      const restoreHandler = patch$2(
         win.HTMLCanvasElement.prototype,
         "getContext",
         function(original) {
@@ -7304,7 +7304,7 @@
         if (typeof prototype[prop] !== "function") {
           continue;
         }
-        const restoreHandler = patch$1(
+        const restoreHandler = patch$2(
           prototype,
           prop,
           function(original) {
@@ -7673,7 +7673,7 @@
     patchAttachShadow(element, doc) {
       const manager = this;
       this.restoreHandlers.push(
-        patch$1(
+        patch$2(
           element.prototype,
           "attachShadow",
           function(original) {
@@ -11712,7 +11712,7 @@
   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;
@@ -11762,7 +11762,7 @@
     };
     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;
@@ -15535,7 +15535,7 @@
     );
     return () => hookSetter(target, key, original || {}, true);
   }
-  function patch(source, name, replacement) {
+  function patch$1(source, name, replacement) {
     try {
       if (!(name in source)) {
         return () => {
@@ -15855,7 +15855,7 @@
       return nowTimestamp;
     },
     on,
-    patch,
+    patch: patch$1,
     polyfill: polyfill$1,
     queueToResolveTrees,
     shadowHostInDom,
@@ -19661,7 +19661,7 @@
     }
     return false;
   }
-  function stringify(obj, stringifyOptions) {
+  function stringify$7(obj, stringifyOptions) {
     const options = {
       numOfKeysLimit: 50,
       depthOfLimit: 4
@@ -19785,7 +19785,7 @@
         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,
@@ -19802,7 +19802,7 @@
         if (event.reason instanceof Error) {
           error = event.reason;
           payload = [
-            stringify(
+            stringify$7(
               `Uncaught (in promise) ${error.name}: ${error.message}`,
               logOptions.stringifyOptions
             )
@@ -19810,8 +19810,8 @@
         } 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(
@@ -19856,7 +19856,7 @@
               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) {
@@ -19870,7 +19870,7 @@
                   level: "warn",
                   trace: [],
                   payload: [
-                    stringify("The number of log records reached the threshold.")
+                    stringify$7("The number of log records reached the threshold.")
                   ]
                 });
               }
@@ -19890,6 +19890,524 @@
     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 i2 = length - 1; i2 >= 0; i2 -= 1) {
+      if (predicate(array[i2])) {
+        return array[i2];
+      }
+    }
+  }
+  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
@@ -20457,13 +20975,13 @@
       return ReconnectingWebSocket2;
     }()
   );
-  const version = "1.0.0-beta-14";
+  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;
@@ -20475,24 +20993,6 @@
   }
   const MASK_CLASS = "sailfishSanitize";
   function maskInputFn(text, node2) {
-    var _a2;
-    if (node2.type === "hidden") {
-      return "";
-    }
-    const patterns = {
-      creditCard: /\b(?:\d[ -]*?){13,16}\b/,
-      ssn: /\b\d{3}-\d{2}-\d{4}\b/
-    };
-    const MASK_CLASS2 = "mask";
-    if (node2.closest(`.${MASK_CLASS2}`)) {
-      return "*".repeat(text.length);
-    } else if (node2.hasAttribute("data-cc") || (((_a2 = node2.getAttribute("autocomplete")) == null ? void 0 : _a2.startsWith("cc-")) ?? false) || patterns.creditCard.test(text)) {
-      return "**** **** **** " + text.slice(-4);
-    } else if (node2.hasAttribute("data-ssn") || patterns.ssn.test(text)) {
-      return "***-**-" + text.slice(-4);
-    } else if (node2.hasAttribute("data-dob")) {
-      return "**/**/" + text.slice(-4);
-    }
     return text;
   }
   async function initializeRecording(captureSettings, consoleRecordSettings, networkRecordSettings, backendApi, apiKey, sessionId) {
@@ -20502,8 +21002,8 @@
           cacheEvents(event);
         },
         plugins: [
-          getRecordConsolePlugin(consoleRecordSettings)
-          // getRecordNetworkPlugin(networkRecordSettings),
+          getRecordConsolePlugin(consoleRecordSettings),
+          getRecordNetworkPlugin(networkRecordSettings)
         ],
         maskInputOptions: { text: true },
         // Fix the incorrect property name
@@ -20569,7 +21069,7 @@
     backendApi
   }) {
     var _a2, _b;
-    const sessionId = v4();
+    const sessionId = v4$1();
     try {
       const captureSettingsResponse = await fetchCaptureSettings(
         apiKey,