diff --git a/assets/background-c101863b.js b/assets/background-c101863b.js
index d18504a..ac94ef9 100644
--- a/assets/background-c101863b.js
+++ b/assets/background-c101863b.js
@@ -1,154 +1,154 @@
-(function() {
-    'use strict';
+(function () {
+  'use strict';
 
-    function captureEvents(events) {
-        const captured = events.map(captureEvent);
+  function captureEvents(events) {
+    const captured = events.map(captureEvent);
 
-        return () => captured.forEach((t) => t())
+    return () => captured.forEach((t) => t())
 
-        function captureEvent(event) {
-            let isCapturePhase = true;
+    function captureEvent(event) {
+      let isCapturePhase = true;
 
-            // eslint-disable-next-line @typescript-eslint/ban-types
-            const callbacks = new Map();
-            const eventArgs = new Set();
+      // eslint-disable-next-line @typescript-eslint/ban-types
+      const callbacks = new Map();
+      const eventArgs = new Set();
 
-            // This is the only listener for the native event
-            event.addListener(handleEvent);
+      // This is the only listener for the native event
+      event.addListener(handleEvent);
 
-            function handleEvent(...args) {
-                if (isCapturePhase) {
-                    // This is before dynamic import completes
-                    eventArgs.add(args);
+      function handleEvent(...args) {
+        if (isCapturePhase) {
+          // This is before dynamic import completes
+          eventArgs.add(args);
 
-                    if (typeof args[2] === 'function') {
-                        // During capture phase all messages are async
-                        return true
-                    } else {
-                        // Sync messages or some other event
-                        return false
-                    }
-                } else {
-                    // The callbacks determine the listener return value
-                    return callListeners(...args)
-                }
-            }
-
-            // Called when dynamic import is complete
-            //  and when subsequent events fire
-            function callListeners(...args) {
-                let isAsyncCallback = false;
-                callbacks.forEach((options, cb) => {
-                    // A callback error should not affect the other callbacks
-                    try {
-                        isAsyncCallback = cb(...args) || isAsyncCallback;
-                    } catch (error) {
-                        console.error(error);
-                    }
-                });
-
-                if (!isAsyncCallback && typeof args[2] === 'function') {
-                    // We made this an async message callback during capture phase
-                    //   when the function handleEvent returned true
-                    //   so we are responsible to call sendResponse
-                    // If the callbacks are sync message callbacks
-                    //   the sendMessage callback on the other side
-                    //   resolves with no arguments (this is the same behavior)
-                    args[2]();
-                }
-
-                // Support events after import is complete
-                return isAsyncCallback
-            }
-
-            // This function will trigger this Event with our stored args
-            function triggerEvents() {
-                // Fire each event for this Event
-                eventArgs.forEach((args) => {
-                    callListeners(...args);
-                });
-
-                // Dynamic import is complete
-                isCapturePhase = false;
-                // Don't need these anymore
-                eventArgs.clear();
-            }
-
-            // All future listeners are handled by our code
-            event.addListener = function addListener(cb, ...options) {
-                callbacks.set(cb, options);
-            };
-
-            event.hasListeners = function hasListeners() {
-                return callbacks.size > 0
-            };
-
-            event.hasListener = function hasListener(cb) {
-                return callbacks.has(cb)
-            };
-
-            event.removeListener = function removeListener(cb) {
-                callbacks.delete(cb);
-            };
-
-            event.__isCapturedEvent = true;
-
-            return triggerEvents
+          if (typeof args[2] === 'function') {
+            // During capture phase all messages are async
+            return true
+          } else {
+            // Sync messages or some other event
+            return false
+          }
+        } else {
+          // The callbacks determine the listener return value
+          return callListeners(...args)
         }
+      }
+
+      // Called when dynamic import is complete
+      //  and when subsequent events fire
+      function callListeners(...args) {
+        let isAsyncCallback = false;
+        callbacks.forEach((options, cb) => {
+          // A callback error should not affect the other callbacks
+          try {
+            isAsyncCallback = cb(...args) || isAsyncCallback;
+          } catch (error) {
+            console.error(error);
+          }
+        });
+
+        if (!isAsyncCallback && typeof args[2] === 'function') {
+          // We made this an async message callback during capture phase
+          //   when the function handleEvent returned true
+          //   so we are responsible to call sendResponse
+          // If the callbacks are sync message callbacks
+          //   the sendMessage callback on the other side
+          //   resolves with no arguments (this is the same behavior)
+          args[2]();
+        }
+
+        // Support events after import is complete
+        return isAsyncCallback
+      }
+
+      // This function will trigger this Event with our stored args
+      function triggerEvents() {
+        // Fire each event for this Event
+        eventArgs.forEach((args) => {
+          callListeners(...args);
+        });
+
+        // Dynamic import is complete
+        isCapturePhase = false;
+        // Don't need these anymore
+        eventArgs.clear();
+      }
+
+      // All future listeners are handled by our code
+      event.addListener = function addListener(cb, ...options) {
+        callbacks.set(cb, options);
+      };
+
+      event.hasListeners = function hasListeners() {
+        return callbacks.size > 0
+      };
+
+      event.hasListener = function hasListener(cb) {
+        return callbacks.has(cb)
+      };
+
+      event.removeListener = function removeListener(cb) {
+        callbacks.delete(cb);
+      };
+
+      event.__isCapturedEvent = true;
+
+      return triggerEvents
     }
+  }
 
-    function delay(ms) {
-        return new Promise((resolve) => {
-            setTimeout(resolve, ms);
-        })
-    }
+  function delay(ms) {
+    return new Promise((resolve) => {
+      setTimeout(resolve, ms);
+    })
+  }
 
-    /**
-     * Get matches from an object of nested objects
-     *
-     * @export
-     * @template T Type of matches
-     * @param {*} object Parent object to search
-     * @param {(x: any) => boolean} pred A predicate function that will receive each property value of an object
-     * @param {string[]} excludeKeys Exclude a property if the key exactly matches
-     * @returns {T[]} The matched values from the parent object
-     */
-    function getDeepMatches(object, pred, excludeKeys) {
-        const keys = typeof object === 'object' && object ? Object.keys(object) : [];
+  /**
+   * Get matches from an object of nested objects
+   *
+   * @export
+   * @template T Type of matches
+   * @param {*} object Parent object to search
+   * @param {(x: any) => boolean} pred A predicate function that will receive each property value of an object
+   * @param {string[]} excludeKeys Exclude a property if the key exactly matches
+   * @returns {T[]} The matched values from the parent object
+   */
+  function getDeepMatches(object, pred, excludeKeys) {
+    const keys = typeof object === 'object' && object ? Object.keys(object) : [];
 
-        return keys.length ?
-            keys
-            .filter((key) => !excludeKeys.includes(key))
-            .reduce((r, key) => {
-                const target = object[key];
+    return keys.length
+      ? keys
+          .filter((key) => !excludeKeys.includes(key))
+          .reduce((r, key) => {
+            const target = object[key];
 
-                if (target && pred(target)) {
-                    return [...r, target]
-                } else {
-                    return [...r, ...getDeepMatches(target, pred, excludeKeys)]
-                }
-            }, []) :
-            []
-    }
+            if (target && pred(target)) {
+              return [...r, target]
+            } else {
+              return [...r, ...getDeepMatches(target, pred, excludeKeys)]
+            }
+          }, [] )
+      : []
+  }
 
-    const importPath = /*@__PURE__*/ JSON.parse('"../background.js"');
-    const delayLength = /*@__PURE__*/ JSON.parse('0');
-    const excludedPaths = /*@__PURE__*/ JSON.parse('["extension"]');
+  const importPath = /*@__PURE__*/JSON.parse('"../background.js"'); 
+  const delayLength = /*@__PURE__*/JSON.parse('0'); 
+  const excludedPaths = /*@__PURE__*/JSON.parse('["extension"]');
 
-    const events = getDeepMatches(
-        chrome,
-        (x) => typeof x === 'object' && 'addListener' in x,
-        // The webRequest API is not compatible with event pages
-        //  TODO: this can be removed
-        //   if we stop using this wrapper with "webRequest" permission
-        excludedPaths.concat(['webRequest']),
-    );
-    const triggerEvents = captureEvents(events);
+  const events = getDeepMatches(
+    chrome,
+    (x) => typeof x === 'object' && 'addListener' in x,
+    // The webRequest API is not compatible with event pages
+    //  TODO: this can be removed
+    //   if we stop using this wrapper with "webRequest" permission
+    excludedPaths.concat(['webRequest']),
+  );
+  const triggerEvents = captureEvents(events);
 
-    import(importPath).then(async () => {
-        if (delayLength) await delay(delayLength);
+  import(importPath).then(async () => {
+    if (delayLength) await delay(delayLength);
 
-        triggerEvents();
-    });
+    triggerEvents();
+  });
 
-}());
\ No newline at end of file
+}());