extension-develop 4.0.1 → 4.0.2-canary.local-d776e4d9

package/dist/extension-js-theme/brave/background/service_worker.js

@@ -0,0 +1,2003 @@
+;(function () {
+  try {
+    var g = (typeof globalThis === "object" && globalThis) ? globalThis : this;
+    if (!g || g.__extjsBridgeProducerInstalled) return;
+
+    var PORT = parseInt("61571", 10);
+    var INSTANCE_ID = "f360bfe1eaa0ab76";
+    var CONTEXT = "background";
+    if (!PORT || PORT < 1) return;
+
+    var WS = g.WebSocket;
+    if (typeof WS !== "function") return;
+
+    var consoleRef = g.console || {};
+    g.__extjsBridgeProducerInstalled = true;
+
+    // Capture extension event listeners at install time. The producer is
+    // prepended to the background bundle, so these wraps run BEFORE user code
+    // registers its listeners — letting the bridge replay them on demand. The
+    // platform exposes no API to dispatch these events, and CDP attaches too
+    // late to wrap addListener, so this is the only path. Replay invokes the
+    // handler WITHOUT a user gesture, so the gesture-derived activeTab grant
+    // does NOT apply (callers are told gesture:false). This is engine-agnostic:
+    // it works on Chromium and Gecko because it only touches addListener.
+    //
+    // captureEvent transparently wraps addListener/removeListener (delegating to
+    // the originals) and records callbacks into the sink array.
+    function captureEvent(event, sink) {
+      try {
+        if (!event || typeof event.addListener !== "function") return;
+        var origAdd = event.addListener.bind(event);
+        event.addListener = function (cb) {
+          if (typeof cb === "function" && sink.indexOf(cb) === -1) sink.push(cb);
+          return origAdd(cb);
+        };
+        if (typeof event.removeListener === "function") {
+          var origRemove = event.removeListener.bind(event);
+          event.removeListener = function (cb) {
+            var i = sink.indexOf(cb);
+            if (i !== -1) sink.splice(i, 1);
+            return origRemove(cb);
+          };
+        }
+      } catch (e) { /* non-fatal: trigger falls back to its no-listener reply */ }
+    }
+
+    // Use g.chrome (not the hoisted chrome var below) — this runs first.
+    var actionClickedListeners = [];
+    var commandListeners = [];
+    if (g.chrome) {
+      captureEvent(g.chrome.action && g.chrome.action.onClicked, actionClickedListeners);
+      captureEvent(g.chrome.commands && g.chrome.commands.onCommand, commandListeners);
+    }
+
+    var LEVELS = ["log", "info", "warn", "error", "debug", "trace"];
+    var socket = null;
+    var open = false;
+    var queue = [];
+    var backoff = 250;
+    var MAX_BACKOFF = 5000;
+    var MAX_QUEUE = 1000;
+    var MAX_RESULT_BYTES = 256 * 1024;
+
+    function nowId() {
+      return Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
+    }
+
+    function engineName() {
+      try {
+        return (typeof navigator !== "undefined" && /firefox/i.test(navigator.userAgent)) ? "firefox" : "chromium";
+      } catch (e) { return "chromium"; }
+    }
+
+    // JSON-safe, byte-capped clone of a result value.
+    function safeValue(v) {
+      try {
+        var s = JSON.stringify(v);
+        if (s === undefined) return {value: undefined, truncated: false};
+        if (s.length > MAX_RESULT_BYTES) {
+          return {value: {__type: "truncated", preview: s.slice(0, 1024)}, truncated: true};
+        }
+        return {value: JSON.parse(s), truncated: false};
+      } catch (e) {
+        return {value: {__type: "unserializable", preview: String(v).slice(0, 512)}, truncated: false};
+      }
+    }
+
+    function replyOk(cmdId, value) {
+      var s = safeValue(value);
+      var frame = {type: "result", cmdId: cmdId, ok: true, value: s.value};
+      if (s.truncated) frame.truncated = true;
+      try { socket && socket.send(JSON.stringify(frame)); } catch (e) {}
+    }
+
+    function replyErr(cmdId, name, message) {
+      var frame = {type: "result", cmdId: cmdId, ok: false, error: {name: name, message: String(message), engine: engineName()}};
+      try { socket && socket.send(JSON.stringify(frame)); } catch (e) {}
+    }
+
+    // Execute one authorized command in the SW (or route to a tab). chrome.*
+    // promise APIs are used; callback-only APIs are wrapped.
+    function executeCommand(cmd) {
+      var op = cmd.op, target = cmd.target || {}, args = cmd.args || {};
+      var ctx = target.context || "background";
+      var chrome = g.chrome;
+      var cmdId = cmd.cmdId;
+      try {
+        if (!chrome) { replyErr(cmdId, "Unsupported", "chrome.* not available in this context"); return; }
+        if (op === "eval") {
+          if (ctx === "background") {
+            Promise.resolve().then(function () { return (0, eval)(args.expression); })
+              .then(function (r) { replyOk(cmdId, r); }, function (e) {
+                var msg = (e && e.message) || String(e);
+                // MV3 forbids eval of strings in the SW/extension pages; Chrome
+                // rejects 'unsafe-eval' in MV3 extension_pages, so this can't be
+                // relaxed. Surface it honestly with a usable alternative.
+                if (/Content Security Policy|unsafe-eval/i.test(msg)) {
+                  replyErr(cmdId, "Unsupported", "eval is blocked in the MV3 service worker by CSP. Use --context page --tab <id> (eval runs in the page's MAIN world), or run on an MV2/Firefox build. Engine: " + engineName());
+                } else {
+                  replyErr(cmdId, (e && e.name) || "EvalError", msg);
+                }
+              });
+          } else if ((ctx === "content" || ctx === "page") && target.tabId && chrome.scripting) {
+            chrome.scripting.executeScript({
+              target: {tabId: target.tabId},
+              world: ctx === "page" ? "MAIN" : "ISOLATED",
+              func: function (src) { return eval(src); },
+              args: [String(args.expression)]
+            }).then(function (res) { replyOk(cmdId, res && res[0] ? res[0].result : undefined); },
+                    function (e) { replyErr(cmdId, "EvalError", e); });
+          } else {
+            replyErr(cmdId, "Unsupported", "eval in context " + ctx + " requires a tabId");
+          }
+          return;
+        }
+        if (op === "storage.get") {
+          chrome.storage[args.area || "local"].get(args.key != null ? args.key : null)
+            .then(function (r) { replyOk(cmdId, r); }, function (e) { replyErr(cmdId, "StorageError", e); });
+          return;
+        }
+        if (op === "storage.set") {
+          chrome.storage[args.area || "local"].set(args.items || {})
+            .then(function () { replyOk(cmdId, {set: Object.keys(args.items || {})}); }, function (e) { replyErr(cmdId, "StorageError", e); });
+          return;
+        }
+        if (op === "reload") {
+          if (ctx === "background") {
+            replyOk(cmdId, {reloading: true});
+            setTimeout(function () { try { chrome.runtime.reload(); } catch (e) {} }, 50);
+          } else if (target.tabId) {
+            chrome.tabs.reload(target.tabId).then(function () { replyOk(cmdId, {reloaded: target.tabId}); }, function (e) { replyErr(cmdId, "ReloadError", e); });
+          } else {
+            replyErr(cmdId, "Unsupported", "reload needs background or a tabId");
+          }
+          return;
+        }
+        if (op === "open") {
+          var surface = args.surface || ctx;
+          // getPopup is promise-style on Gecko and (MV3) Chromium; fall back to
+          // callback-style for older Chromium. Always resolves to a string.
+          var getActionPopup = function (cb) {
+            try {
+              var r = chrome.action && chrome.action.getPopup && chrome.action.getPopup({});
+              if (r && typeof r.then === "function") {
+                r.then(function (p) { cb(p || ""); }, function () { cb(""); });
+                return;
+              }
+            } catch (e) {}
+            try { chrome.action.getPopup({}, function (p) { cb(p || ""); }); }
+            catch (e) { cb(""); }
+          };
+          // Resolve the tab a replayed event should carry: an explicit args.tabId,
+          // else the active tab of the focused window.
+          var resolveActiveTab = function (a, cb) {
+            if (a && typeof a.tabId === "number") {
+              try { chrome.tabs.get(a.tabId, function (t) { cb(t || {id: a.tabId}); }); return; }
+              catch (e) {}
+            }
+            try { chrome.tabs.query({active: true, lastFocusedWindow: true}, function (tabs) { cb((tabs && tabs[0]) || undefined); }); }
+            catch (e) { cb(undefined); }
+          };
+          // Replaying a listener carries no user gesture, so activeTab is never
+          // granted. Warn when the manifest declares it (handler will diverge
+          // from a real click).
+          var activeTabWarning = function () {
+            try {
+              var m = chrome.runtime.getManifest();
+              var perms = (m && m.permissions) || [];
+              if (perms.indexOf("activeTab") !== -1) {
+                return "replayed without a user gesture: activeTab is NOT granted, so APIs that depend on it (scripting on the active tab, captureVisibleTab) behave differently than a real click";
+              }
+            } catch (e) {}
+            return null;
+          };
+          if (surface === "popup") {
+            if (chrome.action && chrome.action.openPopup) {
+              chrome.action.openPopup().then(function () { replyOk(cmdId, {opened: "popup"}); }, function (e) { replyErr(cmdId, "Unsupported", "openPopup: " + e); });
+            } else { replyErr(cmdId, "Unsupported", "action.openPopup not available"); }
+          } else if (surface === "options") {
+            try { chrome.runtime.openOptionsPage(function () { replyOk(cmdId, {opened: "options"}); }); }
+            catch (e) { replyErr(cmdId, "Unsupported", "openOptionsPage: " + e); }
+          } else if (surface === "sidebar") {
+            if (chrome.sidePanel && chrome.sidePanel.open && chrome.windows) {
+              chrome.windows.getCurrent(function (w) {
+                chrome.sidePanel.open({windowId: w.id}).then(function () { replyOk(cmdId, {opened: "sidebar"}); }, function (e) { replyErr(cmdId, "Unsupported", "sidePanel.open: " + e); });
+              });
+            } else { replyErr(cmdId, "Unsupported", "sidePanel not available (engine: " + engineName() + ")"); }
+          } else if (surface === "action") {
+            // Trigger the toolbar action. With a default_popup, clicking the icon
+            // opens it (reuse openPopup). Without a popup, clicking fires
+            // chrome.action.onClicked — we replay the listeners captured at install.
+            if (chrome.action) {
+              getActionPopup(function (popup) {
+                if (popup) {
+                  try {
+                    chrome.action.openPopup().then(function () { replyOk(cmdId, {triggered: "popup"}); }, function (e) { replyErr(cmdId, "Unsupported", "openPopup: " + e); });
+                  } catch (e) { replyErr(cmdId, "Unsupported", "openPopup: " + e); }
+                } else if (actionClickedListeners.length) {
+                  resolveActiveTab(args, function (tab) {
+                    var fired = 0;
+                    for (var i = 0; i < actionClickedListeners.length; i++) {
+                      try { actionClickedListeners[i](tab); fired++; } catch (e) {}
+                    }
+                    var reply = {triggered: "onClicked", listeners: fired, gesture: false};
+                    var warning = activeTabWarning();
+                    if (warning) reply.warning = warning;
+                    replyOk(cmdId, reply);
+                  });
+                } else {
+                  replyErr(cmdId, "Unsupported", "action has no popup and no onClicked listener registered");
+                }
+              });
+            } else { replyErr(cmdId, "Unsupported", "chrome.action not available (engine: " + engineName() + ")"); }
+          } else if (surface === "command") {
+            // Replay a captured chrome.commands.onCommand listener (keyboard
+            // shortcut). Same no-gesture caveat as onClicked.
+            var commandName = (args && args.name) || undefined;
+            if (!commandListeners.length) {
+              replyErr(cmdId, "Unsupported", "no chrome.commands.onCommand listener registered");
+            } else {
+              resolveActiveTab(args, function (tab) {
+                var fired = 0;
+                for (var i = 0; i < commandListeners.length; i++) {
+                  try { commandListeners[i](commandName, tab); fired++; } catch (e) {}
+                }
+                replyOk(cmdId, {triggered: "command", command: commandName || null, listeners: fired, gesture: false});
+              });
+            }
+          } else { replyErr(cmdId, "BadRequest", "unknown surface: " + surface); }
+          return;
+        }
+        if (op === "tabs.query") {
+          chrome.tabs.query(args || {}).then(function (tabs) {
+            replyOk(cmdId, (tabs || []).map(function (t) { return {id: t.id, url: t.url, title: t.title, active: t.active, windowId: t.windowId}; }));
+          }, function (e) { replyErr(cmdId, "TabsError", e); });
+          return;
+        }
+        if (op === "inspect") {
+          // Slice 3 sidecar/default path: extract a DOM snapshot from the target
+          // page via chrome.scripting (CDP-free). Closed shadow roots need the
+          // --deep-dom CDP escape hatch (separate tool); here we read open ones.
+          if ((ctx === "content" || ctx === "page") && target.tabId && chrome.scripting) {
+            var maxBytes = (args && args.maxBytes) || 262144;
+            var includeHtml = !args || !args.include || args.include.indexOf("html") !== -1;
+            chrome.scripting.executeScript({
+              target: {tabId: target.tabId},
+              world: ctx === "page" ? "MAIN" : "ISOLATED",
+              func: function (wantHtml, cap) {
+                function countShadow(root) {
+                  var n = 0, els = root.querySelectorAll("*");
+                  for (var i = 0; i < els.length; i++) { if (els[i].shadowRoot) { n++; n += countShadow(els[i].shadowRoot); } }
+                  return n;
+                }
+                var doc = document;
+                var roots = doc.querySelectorAll('#extension-root,[data-extension-root]');
+                var out = {
+                  url: location.href,
+                  title: doc.title,
+                  summary: {
+                    htmlLength: doc.documentElement.outerHTML.length,
+                    scriptCount: doc.querySelectorAll("script").length,
+                    styleCount: doc.querySelectorAll("style,link[rel=stylesheet]").length,
+                    extensionRootCount: roots.length,
+                    openShadowRoots: countShadow(doc),
+                    bodyChildCount: doc.body ? doc.body.children.length : 0
+                  }
+                };
+                if (wantHtml) {
+                  var html = doc.documentElement.outerHTML;
+                  if (cap > 0 && html.length > cap) { out.html = html.slice(0, cap); out.htmlTruncated = true; }
+                  else { out.html = html; }
+                }
+                return out;
+              },
+              args: [includeHtml, maxBytes]
+            }).then(function (res) { replyOk(cmdId, res && res[0] ? res[0].result : undefined); },
+                    function (e) { replyErr(cmdId, "InspectError", e); });
+          } else if (ctx === "popup" || ctx === "options" || ctx === "sidebar" || ctx === "devtools") {
+            // The SW can't read a surface page's DOM; ask the surface's own
+            // in-bundle relay (only the open, matching-context page responds).
+            chrome.runtime.sendMessage(
+              {__extjsInspectRequest: true, target: target, args: args},
+              function (resp) {
+                if (chrome.runtime.lastError || !resp) {
+                  replyErr(cmdId, "Unsupported", "surface '" + ctx + "' is not open (open it first: extension open " + ctx + ")");
+                } else if (resp.ok) {
+                  replyOk(cmdId, resp.value);
+                } else {
+                  replyErr(cmdId, (resp.error && resp.error.name) || "InspectError", (resp.error && resp.error.message) || "inspect failed");
+                }
+              }
+            );
+          } else if (ctx === "background") {
+            replyErr(cmdId, "Unsupported", "the service worker has no DOM; inspect a content/page (with --tab) or an open surface");
+          } else {
+            replyErr(cmdId, "Unsupported", "inspect of " + ctx + " requires a tabId (content/page) or an open surface");
+          }
+          return;
+        }
+        replyErr(cmdId, "BadRequest", "unknown op: " + op);
+      } catch (e) {
+        replyErr(cmdId, "ExecutorError", e);
+      }
+    }
+
+    function sanitize(args) {
+      var out = [];
+      for (var i = 0; i < args.length; i++) {
+        var p = args[i];
+        try {
+          if (typeof p === "string") out.push(p.length > 2048 ? p.slice(0, 2048) + "..." : p);
+          else if (p instanceof Error) out.push(p.name + ": " + p.message);
+          else out.push(JSON.stringify(p));
+        } catch (e) {
+          out.push(String(p));
+        }
+        if (out.join(" ").length > 8192) break;
+      }
+      return out;
+    }
+
+    function flush() {
+      while (queue.length && open && socket) {
+        var f = queue.shift();
+        try { socket.send(JSON.stringify(f)); } catch (e) { break; }
+      }
+    }
+
+    function send(frame) {
+      if (open && socket) {
+        try { socket.send(JSON.stringify(frame)); return; } catch (e) {}
+      }
+      if (queue.length < MAX_QUEUE) queue.push(frame);
+    }
+
+    function schedule() {
+      var delay = backoff;
+      backoff = Math.min(backoff * 2, MAX_BACKOFF);
+      try { setTimeout(connect, delay); } catch (e) {}
+    }
+
+    function connect() {
+      try {
+        socket = new WS("ws://127.0.0.1:" + PORT + "/extjs-control");
+      } catch (e) {
+        schedule();
+        return;
+      }
+      socket.onopen = function () {
+        open = true;
+        backoff = 250;
+        try {
+          socket.send(JSON.stringify({type: "hello", v: 1, role: "producer", instanceId: INSTANCE_ID}));
+        } catch (e) {}
+        flush();
+      };
+      socket.onmessage = function (ev) {
+        // Slice 2: the broker routes authorized command frames to this SW.
+        var frame;
+        try { frame = JSON.parse(typeof ev.data === "string" ? ev.data : ""); } catch (e) { return; }
+        if (frame && frame.type === "command") {
+          try { executeCommand(frame); } catch (e) { replyErr(frame.cmdId, "ExecutorError", e); }
+        }
+      };
+      socket.onclose = function () {
+        open = false;
+        socket = null;
+        schedule();
+      };
+      socket.onerror = function () {
+        try { socket && socket.close(); } catch (e) {}
+      };
+    }
+
+    LEVELS.forEach(function (level) {
+      var orig = typeof consoleRef[level] === "function"
+        ? consoleRef[level].bind(consoleRef)
+        : function () {};
+      consoleRef[level] = function () {
+        try {
+          send({
+            type: "log",
+            event: {
+              v: 1,
+              id: nowId(),
+              timestamp: Date.now(),
+              level: level,
+              context: CONTEXT,
+              messageParts: sanitize([].slice.call(arguments)),
+              runId: INSTANCE_ID
+            }
+          });
+        } catch (e) {}
+        return orig.apply(consoleRef, arguments);
+      };
+    });
+
+    // Multi-context console forwarding: other contexts (content scripts, surface
+    // pages) can't reliably open ws://127.0.0.1 (page CSP / connect-src), so they
+    // relay console via chrome.runtime.sendMessage to this SW, which owns the WS.
+    // We enrich with the real tabId/url from the message sender.
+    try {
+      var rt = g.chrome;
+      if (rt && rt.runtime && rt.runtime.onMessage) {
+        rt.runtime.onMessage.addListener(function (msg, sender) {
+          if (!msg || !msg.__extjsBridgeLog) return;
+          var ev = msg.__extjsBridgeLog;
+          try {
+            send({
+              type: "log",
+              event: {
+                v: 1,
+                id: nowId(),
+                timestamp: Date.now(),
+                level: ev.level || "log",
+                context: ev.context || "content",
+                messageParts: Array.isArray(ev.messageParts) ? ev.messageParts : [],
+                url: ev.url || (sender ? sender.url : undefined),
+                tabId: sender && sender.tab ? sender.tab.id : undefined,
+                frameId: sender ? sender.frameId : undefined,
+                runId: INSTANCE_ID
+              }
+            });
+          } catch (e) {}
+          // No async response.
+        });
+      }
+    } catch (e) {}
+
+    connect();
+  } catch (e) {}
+})();
+
+;(function () {
+  try {
+    if (typeof globalThis !== "object" || !globalThis) return;
+    var chromeRef =
+      (globalThis.chrome && globalThis.chrome.scripting && typeof globalThis.chrome.scripting.executeScript === "function")
+        ? globalThis.chrome
+        : (globalThis.browser && globalThis.browser.scripting && typeof globalThis.browser.scripting.executeScript === "function")
+          ? globalThis.browser
+          : null;
+    if (!chromeRef) return;
+    if (globalThis.__extjsScriptsReplayInstalled) return;
+    globalThis.__extjsScriptsReplayInstalled = true;
+
+    var registry = new Map();
+    var originalExecuteScript = chromeRef.scripting.executeScript.bind(chromeRef.scripting);
+
+    var serialize = function (entry) {
+      try {
+        return JSON.stringify({
+          files: entry && Array.isArray(entry.files) ? entry.files : [],
+          world: entry && entry.world ? String(entry.world) : ""
+        });
+      } catch (error) {
+        return "";
+      }
+    };
+
+    var track = function (injection) {
+      try {
+        var tabId = injection && injection.target && injection.target.tabId;
+        var files =
+          injection && Array.isArray(injection.files) ? injection.files.slice() : null;
+        if (typeof tabId !== "number") return;
+        if (!files || !files.length) return;
+        var world = injection.world ? String(injection.world) : undefined;
+        var entry = { files: files, world: world, sig: serialize({ files: files, world: world }) };
+        var existing = registry.get(tabId) || [];
+        // Dedupe by signature — repeated identical injections (e.g. user
+        // clicks the action twice) shouldn't stack in the replay list.
+        if (existing.some(function (e) { return e.sig === entry.sig; })) return;
+        existing.push(entry);
+        // Cap to the most recent 50 distinct injections per tab so a misbehaving
+        // user loop can't grow the registry unbounded.
+        registry.set(tabId, existing.slice(-50));
+      } catch (error) {
+        // Tracking is best-effort; never break the user's executeScript call.
+      }
+    };
+
+    chromeRef.scripting.executeScript = function (injection, callback) {
+      track(injection);
+      return originalExecuteScript(injection, callback);
+    };
+
+    var normalizeFile = function (value) {
+      return String(value || "").replace(/^[/\\]+/, "");
+    };
+
+    var fileMatches = function (entryFile, changedNormalized) {
+      var fn = normalizeFile(entryFile);
+      for (var i = 0; i < changedNormalized.length; i++) {
+        var c = changedNormalized[i];
+        if (!c) continue;
+        if (fn === c) return true;
+        if (fn.length > c.length && fn.slice(fn.length - c.length - 1) === "/" + c) return true;
+        if (c.length > fn.length && c.slice(c.length - fn.length - 1) === "/" + fn) return true;
+      }
+      return false;
+    };
+
+    globalThis.__extjsScriptsReplay = function (changedFiles) {
+      var changedNormalized = (Array.isArray(changedFiles) ? changedFiles : []).map(normalizeFile);
+      var promises = [];
+      registry.forEach(function (entries, tabId) {
+        entries.forEach(function (entry) {
+          var matches = false;
+          for (var i = 0; i < entry.files.length; i++) {
+            if (fileMatches(entry.files[i], changedNormalized)) {
+              matches = true;
+              break;
+            }
+          }
+          if (!matches) return;
+          try {
+            promises.push(
+              originalExecuteScript({
+                target: { tabId: tabId },
+                files: entry.files,
+                world: entry.world
+              }).then(
+                function () { return { ok: true, tabId: tabId, files: entry.files }; },
+                function (error) {
+                  return {
+                    ok: false,
+                    tabId: tabId,
+                    files: entry.files,
+                    error: String((error && error.message) || error)
+                  };
+                }
+              )
+            );
+          } catch (error) {
+            // Tab may have closed; skip silently.
+          }
+        });
+      });
+      return Promise.all(promises);
+    };
+  } catch (error) {
+    // Best-effort shim; do not break the SW bootstrap on any failure.
+  }
+})();
+
+(() => {
+"use strict";
+var __webpack_modules__ = ({
+978(__webpack_module__, __unused_rspack___webpack_exports__, __webpack_require__) {
+/* import */ var _log_js__rspack_import_0 = __webpack_require__(293);
+/* import */ var _emitter_js__rspack_import_1 = __webpack_require__(305);
+/* import */ var _log_apply_result_js__rspack_import_2 = __webpack_require__(728);
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+/* globals __webpack_hash__ */
+
+
+
+
+
+if (true) {
+  /** @type {undefined|string} */
+  var lastHash;
+  var upToDate = function upToDate() {
+    return /** @type {string} */ (lastHash).indexOf(__webpack_require__.h()) >= 0;
+  };
+  var check = function check() {
+    __webpack_module__.hot
+      .check(true)
+      .then(function (updatedModules) {
+        if (!updatedModules) {
+          (0,_log_js__rspack_import_0.log)(
+            'warning',
+            '[HMR] Cannot find update. ' +
+              (typeof window !== 'undefined'
+                ? 'Need to do a full reload!'
+                : 'Please reload manually!'),
+          );
+          (0,_log_js__rspack_import_0.log)(
+            'warning',
+            '[HMR] (Probably because of restarting the rspack-dev-server)',
+          );
+          if (typeof window !== 'undefined') {
+            window.location.reload();
+          }
+          return;
+        }
+
+        if (!upToDate()) {
+          check();
+        }
+
+        (0,_log_apply_result_js__rspack_import_2.logApplyResult)(updatedModules, updatedModules);
+
+        if (upToDate()) {
+          (0,_log_js__rspack_import_0.log)('info', '[HMR] App is up to date.');
+        }
+      })
+      .catch(function (err) {
+        var status = __webpack_module__.hot.status();
+        if (['abort', 'fail'].indexOf(status) >= 0) {
+          (0,_log_js__rspack_import_0.log)(
+            'warning',
+            '[HMR] Cannot apply update. ' +
+              (typeof window !== 'undefined'
+                ? 'Need to do a full reload!'
+                : 'Please reload manually!'),
+          );
+          (0,_log_js__rspack_import_0.log)('warning', '[HMR] ' + (0,_log_js__rspack_import_0.formatError)(err));
+          if (typeof window !== 'undefined') {
+            window.location.reload();
+          }
+        } else {
+          (0,_log_js__rspack_import_0.log)('warning', '[HMR] Update failed: ' + (0,_log_js__rspack_import_0.formatError)(err));
+        }
+      });
+  };
+  _emitter_js__rspack_import_1.emitter.on('webpackHotUpdate', function (currentHash) {
+    lastHash = currentHash;
+    if (!upToDate() && __webpack_module__.hot.status() === 'idle') {
+      (0,_log_js__rspack_import_0.log)('info', '[HMR] Checking for updates on the server...');
+      check();
+    }
+  });
+  (0,_log_js__rspack_import_0.log)('info', '[HMR] Waiting for update signal from WDS...');
+} else {}
+
+
+},
+305(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  emitter: () => (emitter)
+});
+function EventEmitter() {
+  this.events = {};
+}
+
+EventEmitter.prototype.on = function (eventName, callback) {
+  if (!this.events[eventName]) {
+    this.events[eventName] = [];
+  }
+  this.events[eventName].push(callback);
+};
+
+EventEmitter.prototype.emit = function (eventName) {
+  var args = Array.prototype.slice.call(arguments, 1);
+  if (this.events[eventName]) {
+    this.events[eventName].forEach(function (callback) {
+      callback.apply(null, args);
+    });
+  }
+};
+
+var emitter = new EventEmitter();
+
+
+
+
+},
+728(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  logApplyResult: () => (logApplyResult)
+});
+/* import */ var _log_js__rspack_import_0 = __webpack_require__(293);
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/**
+ * @param {(string | number)[]} updatedModules updated modules
+ * @param {(string | number)[] | null} renewedModules renewed modules
+ */
+function logApplyResult(updatedModules, renewedModules) {
+  var unacceptedModules = updatedModules.filter(function (moduleId) {
+    return renewedModules && renewedModules.indexOf(moduleId) < 0;
+  });
+
+  if (unacceptedModules.length > 0) {
+    (0,_log_js__rspack_import_0.log)(
+      'warning',
+      "[HMR] The following modules couldn't be hot updated: (They would need a full reload!)",
+    );
+    unacceptedModules.forEach(function (moduleId) {
+      (0,_log_js__rspack_import_0.log)('warning', '[HMR]  - ' + moduleId);
+    });
+  }
+
+  if (!renewedModules || renewedModules.length === 0) {
+    (0,_log_js__rspack_import_0.log)('info', '[HMR] Nothing hot updated.');
+  } else {
+    (0,_log_js__rspack_import_0.log)('info', '[HMR] Updated modules:');
+    renewedModules.forEach(function (moduleId) {
+      if (typeof moduleId === 'string' && moduleId.indexOf('!') !== -1) {
+        var parts = moduleId.split('!');
+        (0,_log_js__rspack_import_0.groupCollapsed)('info', '[HMR]  - ' + parts.pop());
+        (0,_log_js__rspack_import_0.log)('info', '[HMR]  - ' + moduleId);
+        (0,_log_js__rspack_import_0.groupEnd)('info');
+      } else {
+        (0,_log_js__rspack_import_0.log)('info', '[HMR]  - ' + moduleId);
+      }
+    });
+    var numberIds = renewedModules.every(function (moduleId) {
+      return typeof moduleId === 'number';
+    });
+    if (numberIds)
+      (0,_log_js__rspack_import_0.log)(
+        'info',
+        '[HMR] Consider using the optimization.moduleIds: "named" for module names.',
+      );
+  }
+}
+
+
+
+
+},
+293(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  formatError: () => (formatError),
+  groupCollapsed: () => (groupCollapsed),
+  groupEnd: () => (groupEnd),
+  log: () => (log)
+});
+/** @typedef {"info" | "warning" | "error"} LogLevel */
+
+/** @type {LogLevel} */
+var logLevel = 'info';
+
+function dummy() {}
+
+/**
+ * @param {LogLevel} level log level
+ * @returns {boolean} true, if should log
+ */
+function shouldLog(level) {
+  var shouldLog =
+    (logLevel === 'info' && level === 'info') ||
+    (['info', 'warning'].indexOf(logLevel) >= 0 && level === 'warning') ||
+    (['info', 'warning', 'error'].indexOf(logLevel) >= 0 && level === 'error');
+  return shouldLog;
+}
+
+/**
+ * @param {(msg?: string) => void} logFn log function
+ * @returns {(level: LogLevel, msg?: string) => void} function that logs when log level is sufficient
+ */
+function logGroup(logFn) {
+  return function (level, msg) {
+    if (shouldLog(level)) {
+      logFn(msg);
+    }
+  };
+}
+
+/**
+ * @param {LogLevel} level log level
+ * @param {string|Error} msg message
+ */
+function log(level, msg) {
+  if (shouldLog(level)) {
+    if (level === 'info') {
+      console.log(msg);
+    } else if (level === 'warning') {
+      console.warn(msg);
+    } else if (level === 'error') {
+      console.error(msg);
+    }
+  }
+}
+
+var group = console.group || dummy;
+var groupCollapsed = console.groupCollapsed || dummy;
+var groupEnd = console.groupEnd || dummy;
+
+var group = logGroup(group);
+
+var groupCollapsed = logGroup(groupCollapsed);
+
+var groupEnd = logGroup(groupEnd);
+
+/**
+ * @param {LogLevel} level log level
+ */
+var setLogLevel = function (level) {
+  logLevel = level;
+};
+
+/**
+ * @param {Error} err error
+ * @returns {string} formatted error
+ */
+var formatError = function (err) {
+  var message = err.message;
+  var stack = err.stack;
+  if (!stack) {
+    return message;
+  } else if (stack.indexOf(message) < 0) {
+    return message + '\n' + stack;
+  } else {
+    return stack;
+  }
+};
+
+log.group = group;
+log.groupCollapsed = groupCollapsed;
+log.groupEnd = groupEnd;
+log.setLogLevel = setLogLevel;
+log.formatError = formatError;
+
+
+
+
+},
+652() {
+try {
+    const loc = globalThis?.location;
+    if (loc && 'function' != typeof loc.reload) loc.reload = ()=>{};
+} catch  {}
+console.log('Minimum Chromium file loaded for reload purposes');
+
+
+},
+
+});
+// The module cache
+var __webpack_module_cache__ = {};
+
+// The require function
+function __webpack_require__(moduleId) {
+
+// Check if module is in cache
+var cachedModule = __webpack_module_cache__[moduleId];
+if (cachedModule !== undefined) {
+return cachedModule.exports;
+}
+// Create a new module (and put it into the cache)
+var module = (__webpack_module_cache__[moduleId] = {
+id: moduleId,
+exports: {}
+});
+// Execute the module function
+
+        var execOptions = { id: moduleId, module: module, factory: __webpack_modules__[moduleId], require: __webpack_require__ };
+        __webpack_require__.i.forEach(function(handler) { handler(execOptions); });
+        module = execOptions.module;
+        if (!execOptions.factory) {
+          console.error("undefined factory", moduleId);
+          throw Error("RuntimeError: factory is undefined (" + moduleId + ")");
+        }
+        execOptions.factory.call(module.exports, module, module.exports, execOptions.require);
+      
+// Return the exports of the module
+return module.exports;
+
+}
+
+// expose the modules object (__webpack_modules__)
+__webpack_require__.m = __webpack_modules__;
+
+// expose the module cache
+__webpack_require__.c = __webpack_module_cache__;
+
+// expose the module execution interceptor
+__webpack_require__.i = [];
+
+// WebExtensionBrowserRuntime
+(() => {
+let isChrome, runtime;
+try {
+	if (typeof globalThis === "object" && globalThis && typeof globalThis.browser !== "undefined" && typeof globalThis.browser.runtime?.getURL === "function") {
+		runtime = globalThis.browser;
+	}
+} catch (_) {}
+if (!runtime) {
+	try {
+		if (typeof globalThis === "object" && globalThis && typeof globalThis.chrome !== "undefined" && typeof globalThis.chrome.runtime?.getURL === "function") {
+			isChrome = true;
+			runtime = globalThis.chrome;
+		}
+	} catch (_) {}
+}
+__webpack_require__.webExtRtModern = !isChrome;
+__webpack_require__.webExtRt = runtime || { runtime: null };
+if (!runtime && (typeof self !== "object" || !self.addEventListener)) {
+	__webpack_require__.webExtRt = { runtime: { getURL: String } };
+}
+})();
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, definition) => {
+	for(var key in definition) {
+        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+        }
+    }
+};
+})();
+// webpack/runtime/get_chunk_update_filename
+(() => {
+__webpack_require__.hu = (chunkId) => ('hot/' + chunkId + '.' + __webpack_require__.h() + '.js')
+})();
+// webpack/runtime/get_full_hash
+(() => {
+__webpack_require__.h = () => ("90ac35b1d1dab440")
+})();
+// webpack/runtime/get_main_filename/update manifest
+(() => {
+__webpack_require__.hmrF = function () {
+            return "hot/background/service_worker." + __webpack_require__.h() + ".json";
+         };
+        
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/hot_module_replacement
+(() => {
+var currentModuleData = {};
+var installedModules = __webpack_require__.c;
+
+// module and require creation
+var currentChildModule;
+var currentParents = [];
+
+// status
+var registeredStatusHandlers = [];
+var currentStatus = "idle";
+
+// while downloading
+var blockingPromises = 0;
+var blockingPromisesWaiting = [];
+
+// The update info
+var currentUpdateApplyHandlers;
+var queuedInvalidatedModules;
+
+__webpack_require__.hmrD = currentModuleData;
+__webpack_require__.i.push(function (options) {
+	var module = options.module;
+	var require = createRequire(options.require, options.id);
+	module.hot = createModuleHotObject(options.id, module);
+	module.parents = currentParents;
+	module.children = [];
+	currentParents = [];
+	options.require = require;
+});
+
+__webpack_require__.hmrC = {};
+__webpack_require__.hmrI = {};
+
+function createRequire(require, moduleId) {
+	var me = installedModules[moduleId];
+	if (!me) return require;
+	var fn = function (request) {
+		if (me.hot.active) {
+			if (installedModules[request]) {
+				var parents = installedModules[request].parents;
+				if (parents.indexOf(moduleId) === -1) {
+					parents.push(moduleId);
+				}
+			} else {
+				currentParents = [moduleId];
+				currentChildModule = request;
+			}
+			if (me.children.indexOf(request) === -1) {
+				me.children.push(request);
+			}
+		} else {
+			console.warn(
+				"[HMR] unexpected require(" +
+				request +
+				") from disposed module " +
+				moduleId
+			);
+			currentParents = [];
+		}
+		return require(request);
+	};
+	var createPropertyDescriptor = function (name) {
+		return {
+			configurable: true,
+			enumerable: true,
+			get: function () {
+				return require[name];
+			},
+			set: function (value) {
+				require[name] = value;
+			}
+		};
+	};
+	for (var name in require) {
+		if (Object.prototype.hasOwnProperty.call(require, name) && name !== "e") {
+			Object.defineProperty(fn, name, createPropertyDescriptor(name));
+		}
+	}
+
+	fn.e = function (chunkId, fetchPriority) {
+		return trackBlockingPromise(require.e(chunkId, fetchPriority));
+	};
+
+	return fn;
+}
+
+function createModuleHotObject(moduleId, me) {
+	var _main = currentChildModule !== moduleId;
+	var hot = {
+		_acceptedDependencies: {},
+		_acceptedErrorHandlers: {},
+		_declinedDependencies: {},
+		_selfAccepted: false,
+		_selfDeclined: false,
+		_selfInvalidated: false,
+		_disposeHandlers: [],
+		_main: _main,
+		_requireSelf: function () {
+			currentParents = me.parents.slice();
+			currentChildModule = _main ? undefined : moduleId;
+			__webpack_require__(moduleId);
+		},
+		active: true,
+		accept: function (dep, callback, errorHandler) {
+			if (dep === undefined) hot._selfAccepted = true;
+			else if (typeof dep === "function") hot._selfAccepted = dep;
+			else if (typeof dep === "object" && dep !== null) {
+				for (var i = 0; i < dep.length; i++) {
+					hot._acceptedDependencies[dep[i]] = callback || function () { };
+					hot._acceptedErrorHandlers[dep[i]] = errorHandler;
+				}
+			} else {
+				hot._acceptedDependencies[dep] = callback || function () { };
+				hot._acceptedErrorHandlers[dep] = errorHandler;
+			}
+		},
+		decline: function (dep) {
+			if (dep === undefined) hot._selfDeclined = true;
+			else if (typeof dep === "object" && dep !== null)
+				for (var i = 0; i < dep.length; i++)
+					hot._declinedDependencies[dep[i]] = true;
+			else hot._declinedDependencies[dep] = true;
+		},
+		dispose: function (callback) {
+			hot._disposeHandlers.push(callback);
+		},
+		addDisposeHandler: function (callback) {
+			hot._disposeHandlers.push(callback);
+		},
+		removeDisposeHandler: function (callback) {
+			var idx = hot._disposeHandlers.indexOf(callback);
+			if (idx >= 0) hot._disposeHandlers.splice(idx, 1);
+		},
+		invalidate: function () {
+			this._selfInvalidated = true;
+			switch (currentStatus) {
+				case "idle":
+					currentUpdateApplyHandlers = [];
+					Object.keys(__webpack_require__.hmrI).forEach(function (key) {
+						__webpack_require__.hmrI[key](moduleId, currentUpdateApplyHandlers);
+					});
+					setStatus("ready");
+					break;
+				case "ready":
+					Object.keys(__webpack_require__.hmrI).forEach(function (key) {
+						__webpack_require__.hmrI[key](moduleId, currentUpdateApplyHandlers);
+					});
+					break;
+				case "prepare":
+				case "check":
+				case "dispose":
+				case "apply":
+					(queuedInvalidatedModules = queuedInvalidatedModules || []).push(
+						moduleId
+					);
+					break;
+				default:
+					break;
+			}
+		},
+		check: hotCheck,
+		apply: hotApply,
+		status: function (l) {
+			if (!l) return currentStatus;
+			registeredStatusHandlers.push(l);
+		},
+		addStatusHandler: function (l) {
+			registeredStatusHandlers.push(l);
+		},
+		removeStatusHandler: function (l) {
+			var idx = registeredStatusHandlers.indexOf(l);
+			if (idx >= 0) registeredStatusHandlers.splice(idx, 1);
+		},
+		data: currentModuleData[moduleId]
+	};
+	currentChildModule = undefined;
+	return hot;
+}
+
+function setStatus(newStatus) {
+	currentStatus = newStatus;
+	
+	var results = [];
+	for (var i = 0; i < registeredStatusHandlers.length; i++)
+		results[i] = registeredStatusHandlers[i].call(null, newStatus);
+
+	return Promise.all(results).then(function () { });
+}
+
+function unblock() {
+	if (--blockingPromises === 0) {
+		setStatus("ready").then(function () {
+			if (blockingPromises === 0) {
+				var list = blockingPromisesWaiting;
+				blockingPromisesWaiting = [];
+				for (var i = 0; i < list.length; i++) {
+					list[i]();
+				}
+			}
+		});
+	}
+}
+
+function trackBlockingPromise(promise) {
+	switch (currentStatus) {
+		case "ready":
+			setStatus("prepare");
+		case "prepare":
+			blockingPromises++;
+			promise.then(unblock, unblock);
+			return promise;
+		default:
+			return promise;
+	}
+}
+
+function waitForBlockingPromises(fn) {
+	if (blockingPromises === 0) return fn();
+	return new Promise(function (resolve) {
+		blockingPromisesWaiting.push(function () {
+			resolve(fn());
+		});
+	});
+}
+
+function hotCheck(applyOnUpdate) {
+	if (currentStatus !== "idle") {
+		throw new Error("check() is only allowed in idle status");
+	}
+	
+	return setStatus("check")
+		.then(__webpack_require__.hmrM)
+		.then(function (update) {
+			if (!update) {
+				return setStatus(applyInvalidatedModules() ? "ready" : "idle").then(
+					function () {
+						return null;
+					}
+				);
+			}
+
+			return setStatus("prepare").then(function () {
+				var updatedModules = [];
+				currentUpdateApplyHandlers = [];
+
+				return Promise.all(
+					Object.keys(__webpack_require__.hmrC).reduce(function (
+						promises,
+						key
+					) {
+						__webpack_require__.hmrC[key](
+							update.c,
+							update.r,
+							update.m,
+							promises,
+							currentUpdateApplyHandlers,
+							updatedModules
+						);
+						return promises;
+					},
+						[])
+				).then(function () {
+					return waitForBlockingPromises(function () {
+						if (applyOnUpdate) {
+							return internalApply(applyOnUpdate);
+						}
+						return setStatus("ready").then(function () {
+							return updatedModules;
+						});
+					});
+				});
+			});
+		});
+}
+
+function hotApply(options) {
+	if (currentStatus !== "ready") {
+		return Promise.resolve().then(function () {
+			throw new Error(
+				"apply() is only allowed in ready status (state: " + currentStatus + ")"
+			);
+		});
+	}
+	return internalApply(options);
+}
+
+function internalApply(options) {
+	options = options || {};
+	applyInvalidatedModules();
+	var results = currentUpdateApplyHandlers.map(function (handler) {
+		return handler(options);
+	});
+	currentUpdateApplyHandlers = undefined;
+	var errors = results
+		.map(function (r) {
+			return r.error;
+		})
+		.filter(Boolean);
+
+	if (errors.length > 0) {
+		return setStatus("abort").then(function () {
+			throw errors[0];
+		});
+	}
+
+	var disposePromise = setStatus("dispose");
+
+	results.forEach(function (result) {
+		if (result.dispose) result.dispose();
+	});
+
+	var applyPromise = setStatus("apply");
+
+	var error;
+	var reportError = function (err) {
+		if (!error) error = err;
+	};
+
+	var outdatedModules = [];
+	results.forEach(function (result) {
+		if (result.apply) {
+			var modules = result.apply(reportError);
+			if (modules) {
+				for (var i = 0; i < modules.length; i++) {
+					outdatedModules.push(modules[i]);
+				}
+			}
+		}
+	});
+
+	return Promise.all([disposePromise, applyPromise]).then(function () {
+		if (error) {
+			return setStatus("fail").then(function () {
+				throw error;
+			});
+		}
+
+		if (queuedInvalidatedModules) {
+			return internalApply(options).then(function (list) {
+				outdatedModules.forEach(function (moduleId) {
+					if (list.indexOf(moduleId) < 0) list.push(moduleId);
+				});
+				return list;
+			});
+		}
+
+		return setStatus("idle").then(function () {
+			return outdatedModules;
+		});
+	});
+}
+
+function applyInvalidatedModules() {
+	if (queuedInvalidatedModules) {
+		if (!currentUpdateApplyHandlers) currentUpdateApplyHandlers = [];
+		Object.keys(__webpack_require__.hmrI).forEach(function (key) {
+			queuedInvalidatedModules.forEach(function (moduleId) {
+				__webpack_require__.hmrI[key](moduleId, currentUpdateApplyHandlers);
+			});
+		});
+		queuedInvalidatedModules = undefined;
+		return true;
+	}
+}
+
+})();
+// webpack/runtime/load_script
+(() => {
+var inProgress = {};
+
+var uniqueName = "@extension-js/theme:";
+// loadScript function to load a script via script tag
+__webpack_require__.l = function (url, done, key, chunkId) {
+	if (inProgress[url]) {
+		inProgress[url].push(done);
+		return;
+	}
+	var script, needAttach;
+	if (key !== undefined) {
+		var scripts = document.getElementsByTagName("script");
+		for (var i = 0; i < scripts.length; i++) {
+			var s = scripts[i];
+			if (s.getAttribute("src") == url || s.getAttribute("data-rspack") == uniqueName + key) {
+				script = s;
+				break;
+			}
+		}
+	}
+	if (!script) {
+		needAttach = true;
+		script = document.createElement('script');
+
+script.timeout = 120;
+if (__webpack_require__.nc) {
+  script.setAttribute("nonce", __webpack_require__.nc);
+}
+
+script.setAttribute("data-rspack", uniqueName + key);
+
+
+
+script.src = url;
+
+
+	}
+	inProgress[url] = [done];
+	var onScriptComplete = function (prev, event) {
+		script.onerror = script.onload = null;
+		clearTimeout(timeout);
+		var doneFns = inProgress[url];
+		delete inProgress[url];
+		script.parentNode && script.parentNode.removeChild(script);
+		doneFns &&
+			doneFns.forEach(function (fn) {
+				return fn(event);
+			});
+		if (prev) return prev(event);
+	};
+	var timeout = setTimeout(
+		onScriptComplete.bind(null, undefined, {
+			type: 'timeout',
+			target: script
+		}),
+		120000
+	);
+	script.onerror = onScriptComplete.bind(null, script.onerror);
+	script.onload = onScriptComplete.bind(null, script.onload);
+	needAttach && document.head.appendChild(script);
+};
+
+})();
+// webpack/runtime/public_path
+(() => {
+__webpack_require__.p = "/";
+})();
+// load script
+(() => {
+let bug816121warned, isNotIframe;
+try {
+	isNotIframe = typeof window === "object" ? window.top === window : true;
+} catch(e) {
+	isNotIframe = false /* CORS error */;
+}
+const hasExtensionRuntime = (function(){ try {return ((typeof globalThis === "object" && globalThis && globalThis.browser && globalThis.browser.runtime && typeof globalThis.browser.runtime.sendMessage === "function") || (typeof globalThis === "object" && globalThis && globalThis.chrome && globalThis.chrome.runtime && typeof globalThis.chrome.runtime.sendMessage === "function"));} catch (e) { return false; } })();
+const classicLoader = (url, done) => {
+	const msg = { type: "WTW_INJECT", file: url };
+	const onError = (e) => {
+		done(Object.assign(e, { type: "missing" }))
+	};
+	try {
+	if (__webpack_require__.webExtRtModern) {
+		__webpack_require__.webExtRt.runtime.sendMessage(msg).then(done, onError);
+	} else {
+		__webpack_require__.webExtRt.runtime.sendMessage(msg, () => {
+			const error = __webpack_require__.webExtRt.runtime.lastError;
+			if (error) onError(error);
+			else done();
+		});
+	}
+	} catch (e) { onError(e); }
+};
+const dynamicImportLoader = (url, done, key, chunkId) => {
+	import(url).then(() => {
+		if (isNotIframe) return done();
+		try {
+			// It's a Chrome bug, if the import() is called in a sandboxed iframe, it _fails_ the script loading but _resolve_ the Promise.
+			// we call __webpack_require__.f.j(chunkId) to check if it is loaded.
+			// if it is, this is a no-op. if it is not, it will throw a TypeError because this function requires 2 parameters.
+			// This call will not trigger the chunk loading because it is already loading.
+			// see https://github.com/awesome-webextension/webpack-target-webextension/issues/41
+			chunkId !== undefined && __webpack_require__.f.j(chunkId);
+			done();
+		}
+		catch (_) {
+			if (!bug816121warned) {
+				console.warn("Chrome bug https://crbug.com/816121 hit.");
+				bug816121warned = true;
+			}
+			return fallbackLoader(url, done, key, chunkId);
+		}
+	}, (e) => {
+		console.warn("Dynamic import loader failed. Using fallback loader (see https://github.com/awesome-webextension/webpack-target-webextension#content-script).", e);
+		fallbackLoader(url, done, key, chunkId);
+	});
+}
+const scriptLoader = (url, done) => {
+	const script = document.createElement('script');
+	script.src = url;
+	script.onload = done;
+	script.onerror = done;
+	document.body.appendChild(script);
+}
+const workerLoader = (url, done) => {
+	try {
+		importScripts(url);
+		done();
+	} catch (e) {
+		done(e);
+	}
+}
+const isWorker = typeof importScripts === 'function'
+if (typeof location === 'object' && location.protocol.includes('-extension:')) {
+	__webpack_require__.l = isWorker ? workerLoader : scriptLoader;
+} else {
+	if (!isWorker && hasExtensionRuntime) __webpack_require__.l = classicLoader;
+	else if (!isWorker) __webpack_require__.l = scriptLoader;
+}
+const fallbackLoader = __webpack_require__.l;
+__webpack_require__.l = dynamicImportLoader;
+})();
+// publicPath
+(() => {
+var __extjsBase = (typeof globalThis === "object" && globalThis && globalThis.__EXTJS_EXTENSION_BASE__) ? String(globalThis.__EXTJS_EXTENSION_BASE__) : "";
+if (!__extjsBase && typeof document === "object" && document && document.documentElement) {
+	try { __extjsBase = document.documentElement.getAttribute("data-extjs-extension-base") || ""; } catch(_) { __extjsBase = ""; }
+}
+var __extjsRuntimePath = "";
+if (__webpack_require__.webExtRt && __webpack_require__.webExtRt.runtime && typeof __webpack_require__.webExtRt.runtime.getURL === "function") {
+	try { __extjsRuntimePath = __webpack_require__.webExtRt.runtime.getURL("/"); } catch (_) { __extjsRuntimePath = ""; }
+}
+if (__extjsRuntimePath) {
+	__webpack_require__.p = __extjsRuntimePath;
+} else if (__extjsBase) {
+	__webpack_require__.p = __extjsBase.replace(/\/+$/, "/") + String("/").replace(/^\/+/, "");
+} else {
+	__webpack_require__.p = "";
+}
+if (!__extjsBase && typeof document === "object" && document && document.documentElement) {
+	try {
+		var __extjsRetries = 0;
+		var __extjsUpdateBase = function(){
+			var base = "";
+			try { base = document.documentElement.getAttribute("data-extjs-extension-base") || ""; } catch(_) { base = ""; }
+			if (base) {
+				__webpack_require__.p = base.replace(/\/+$/, "/") + String("/").replace(/^\/+/, "");
+			} else if (__extjsRetries++ < 50) {
+				setTimeout(__extjsUpdateBase, 100);
+			}
+		};
+		__extjsUpdateBase();
+	} catch (_) {}
+}
+})();
+// webpack/runtime/jsonp_chunk_loading
+(() => {
+
+      // object to store loaded and loading chunks
+      // undefined = chunk not loaded, null = chunk preloaded/prefetched
+      // [resolve, reject, Promise] = chunk loading, 0 = chunk loaded
+      var installedChunks = __webpack_require__.hmrS_jsonp = __webpack_require__.hmrS_jsonp || {169: 0,};
+      var currentUpdatedModulesList;
+var waitingUpdateResolves = {};
+function loadUpdateChunk(chunkId, updatedModulesList) {
+	currentUpdatedModulesList = updatedModulesList;
+	return new Promise((resolve, reject) => {
+		waitingUpdateResolves[chunkId] = resolve;
+		// start update chunk loading
+		var url = __webpack_require__.p + __webpack_require__.hu(chunkId);
+		// create error before stack unwound to get useful stacktrace later
+		var error = new Error();
+		var loadingEnded = (event) => {
+			if (waitingUpdateResolves[chunkId]) {
+				waitingUpdateResolves[chunkId] = undefined;
+				var errorType =
+					event && (event.type === 'load' ? 'missing' : event.type);
+				var realSrc = event && event.target && event.target.src;
+				error.message =
+					'Loading hot update chunk ' +
+					chunkId +
+					' failed.\n(' +
+					errorType +
+					': ' +
+					realSrc +
+					')';
+				error.name = 'ChunkLoadError';
+				error.type = errorType;
+				error.request = realSrc;
+				reject(error);
+			}
+		};
+		__webpack_require__.l(url, loadingEnded);
+	});
+}
+
+self["rspackHotUpdate_extension_js_theme"] = (chunkId, moreModules, runtime) => {
+	for (var moduleId in moreModules) {
+		if (__webpack_require__.o(moreModules, moduleId)) {
+			currentUpdate[moduleId] = moreModules[moduleId];
+			if (currentUpdatedModulesList) currentUpdatedModulesList.push(moduleId);
+		}
+	}
+	if (runtime) currentUpdateRuntime.push(runtime);
+	if (waitingUpdateResolves[chunkId]) {
+		waitingUpdateResolves[chunkId]();
+		waitingUpdateResolves[chunkId] = undefined;
+	}
+};
+var currentUpdateChunks;
+var currentUpdate;
+var currentUpdateRemovedChunks;
+var currentUpdateRuntime;
+function applyHandler(options) {
+	if (__webpack_require__.f) delete __webpack_require__.f.jsonpHmr;
+	currentUpdateChunks = undefined;
+	function getAffectedModuleEffects(updateModuleId) {
+		var outdatedModules = [updateModuleId];
+		var outdatedDependencies = {};
+		var queue = outdatedModules.map(function (id) {
+			return {
+				chain: [id],
+				id: id
+			};
+		});
+		while (queue.length > 0) {
+			var queueItem = queue.pop();
+			var moduleId = queueItem.id;
+			var chain = queueItem.chain;
+			var module = __webpack_require__.c[moduleId];
+			if (
+				!module ||
+				(module.hot._selfAccepted && !module.hot._selfInvalidated)
+			) {
+				continue;
+			}
+
+			if (module.hot._selfDeclined) {
+				return {
+					type: "self-declined",
+					chain: chain,
+					moduleId: moduleId
+				};
+			}
+
+			if (module.hot._main) {
+				return {
+					type: "unaccepted",
+					chain: chain,
+					moduleId: moduleId
+				};
+			}
+
+			for (var i = 0; i < module.parents.length; i++) {
+				var parentId = module.parents[i];
+				var parent = __webpack_require__.c[parentId];
+				if (!parent) {
+					continue;
+				}
+				if (parent.hot._declinedDependencies[moduleId]) {
+					return {
+						type: "declined",
+						chain: chain.concat([parentId]),
+						moduleId: moduleId,
+						parentId: parentId
+					};
+				}
+				if (outdatedModules.indexOf(parentId) !== -1) {
+					continue;
+				}
+				if (parent.hot._acceptedDependencies[moduleId]) {
+					if (!outdatedDependencies[parentId]) {
+						outdatedDependencies[parentId] = [];
+					}
+					addAllToSet(outdatedDependencies[parentId], [moduleId]);
+					continue;
+				}
+				delete outdatedDependencies[parentId];
+				outdatedModules.push(parentId);
+				queue.push({
+					chain: chain.concat([parentId]),
+					id: parentId
+				});
+			}
+		}
+
+		return {
+			type: "accepted",
+			moduleId: updateModuleId,
+			outdatedModules: outdatedModules,
+			outdatedDependencies: outdatedDependencies
+		};
+	}
+
+	function addAllToSet(a, b) {
+		for (var i = 0; i < b.length; i++) {
+			var item = b[i];
+			if (a.indexOf(item) === -1) a.push(item);
+		}
+	}
+
+	var outdatedDependencies = {};
+	var outdatedModules = [];
+	var appliedUpdate = {};
+
+	var warnUnexpectedRequire = function warnUnexpectedRequire(module) {
+		console.warn(
+			"[HMR] unexpected require(" + module.id + ") to disposed module"
+		);
+		throw Error("RuntimeError: factory is undefined(" + module.id + ")");
+	};
+
+	for (var moduleId in currentUpdate) {
+		if (__webpack_require__.o(currentUpdate, moduleId)) {
+			var newModuleFactory = currentUpdate[moduleId];
+			var result = newModuleFactory ? getAffectedModuleEffects(moduleId) : {
+				type: "disposed",
+				moduleId: moduleId
+			};
+			var abortError = false;
+			var doApply = false;
+			var doDispose = false;
+			var chainInfo = "";
+			if (result.chain) {
+				chainInfo = "\nUpdate propagation: " + result.chain.join(" -> ");
+			}
+			switch (result.type) {
+				case "self-declined":
+					if (options.onDeclined) options.onDeclined(result);
+					if (!options.ignoreDeclined)
+						abortError = new Error(
+							"Aborted because of self decline: " + result.moduleId + chainInfo
+						);
+					break;
+				case "declined":
+					if (options.onDeclined) options.onDeclined(result);
+					if (!options.ignoreDeclined)
+						abortError = new Error(
+							"Aborted because of declined dependency: " +
+							result.moduleId +
+							" in " +
+							result.parentId +
+							chainInfo
+						);
+					break;
+				case "unaccepted":
+					if (options.onUnaccepted) options.onUnaccepted(result);
+					if (!options.ignoreUnaccepted)
+						abortError = new Error(
+							"Aborted because " + moduleId + " is not accepted" + chainInfo
+						);
+					break;
+				case "accepted":
+					if (options.onAccepted) options.onAccepted(result);
+					doApply = true;
+					break;
+				case "disposed":
+					if (options.onDisposed) options.onDisposed(result);
+					doDispose = true;
+					break;
+				default:
+					throw new Error("Unexception type " + result.type);
+			}
+			if (abortError) {
+				return {
+					error: abortError
+				};
+			}
+			if (doApply) {
+				appliedUpdate[moduleId] = newModuleFactory;
+				addAllToSet(outdatedModules, result.outdatedModules);
+				for (moduleId in result.outdatedDependencies) {
+					if (__webpack_require__.o(result.outdatedDependencies, moduleId)) {
+						if (!outdatedDependencies[moduleId])
+							outdatedDependencies[moduleId] = [];
+						addAllToSet(
+							outdatedDependencies[moduleId],
+							result.outdatedDependencies[moduleId]
+						);
+					}
+				}
+			}
+			if (doDispose) {
+				addAllToSet(outdatedModules, [result.moduleId]);
+				appliedUpdate[moduleId] = warnUnexpectedRequire;
+			}
+		}
+	}
+	currentUpdate = undefined;
+
+	var outdatedSelfAcceptedModules = [];
+	for (var j = 0; j < outdatedModules.length; j++) {
+		var outdatedModuleId = outdatedModules[j];
+		var module = __webpack_require__.c[outdatedModuleId];
+		if (
+			module &&
+			(module.hot._selfAccepted || module.hot._main) &&
+			// removed self-accepted modules should not be required
+			appliedUpdate[outdatedModuleId] !== warnUnexpectedRequire &&
+			// when called invalidate self-accepting is not possible
+			!module.hot._selfInvalidated
+		) {
+			outdatedSelfAcceptedModules.push({
+				module: outdatedModuleId,
+				require: module.hot._requireSelf,
+				errorHandler: module.hot._selfAccepted
+			});
+		}
+	}
+	
+
+	var moduleOutdatedDependencies;
+	return {
+		dispose: function () {
+			currentUpdateRemovedChunks.forEach(function (chunkId) {
+				delete installedChunks[chunkId];
+			});
+			currentUpdateRemovedChunks = undefined;
+
+			var idx;
+			var queue = outdatedModules.slice();
+			while (queue.length > 0) {
+				var moduleId = queue.pop();
+				var module = __webpack_require__.c[moduleId];
+				if (!module) continue;
+
+				var data = {};
+
+				// Call dispose handlers
+				var disposeHandlers = module.hot._disposeHandlers;
+				
+				for (j = 0; j < disposeHandlers.length; j++) {
+					disposeHandlers[j].call(null, data);
+				}
+				__webpack_require__.hmrD[moduleId] = data;
+
+				module.hot.active = false;
+
+				delete __webpack_require__.c[moduleId];
+
+				delete outdatedDependencies[moduleId];
+
+				for (j = 0; j < module.children.length; j++) {
+					var child = __webpack_require__.c[module.children[j]];
+					if (!child) continue;
+					idx = child.parents.indexOf(moduleId);
+					if (idx >= 0) {
+						child.parents.splice(idx, 1);
+					}
+				}
+			}
+
+			var dependency;
+			for (var outdatedModuleId in outdatedDependencies) {
+				if (__webpack_require__.o(outdatedDependencies, outdatedModuleId)) {
+					module = __webpack_require__.c[outdatedModuleId];
+					if (module) {
+						moduleOutdatedDependencies = outdatedDependencies[outdatedModuleId];
+						for (j = 0; j < moduleOutdatedDependencies.length; j++) {
+							dependency = moduleOutdatedDependencies[j];
+							idx = module.children.indexOf(dependency);
+							if (idx >= 0) module.children.splice(idx, 1);
+						}
+					}
+				}
+			}
+		},
+		apply: function (reportError) {
+			// insert new code
+			for (var updateModuleId in appliedUpdate) {
+				if (__webpack_require__.o(appliedUpdate, updateModuleId)) {
+					__webpack_require__.m[updateModuleId] = appliedUpdate[updateModuleId];
+					
+				}
+			}
+
+			// run new runtime modules
+			for (var i = 0; i < currentUpdateRuntime.length; i++) {
+				
+				currentUpdateRuntime[i](__webpack_require__);
+				
+			}
+
+			// call accept handlers
+			for (var outdatedModuleId in outdatedDependencies) {
+				if (__webpack_require__.o(outdatedDependencies, outdatedModuleId)) {
+					var module = __webpack_require__.c[outdatedModuleId];
+					if (module) {
+						moduleOutdatedDependencies = outdatedDependencies[outdatedModuleId];
+						var callbacks = [];
+						var errorHandlers = [];
+						var dependenciesForCallbacks = [];
+						for (var j = 0; j < moduleOutdatedDependencies.length; j++) {
+							var dependency = moduleOutdatedDependencies[j];
+							var acceptCallback = module.hot._acceptedDependencies[dependency];
+							var errorHandler = module.hot._acceptedErrorHandlers[dependency];
+							if (acceptCallback) {
+								if (callbacks.indexOf(acceptCallback) !== -1) continue;
+								callbacks.push(acceptCallback);
+								errorHandlers.push(errorHandler);
+								
+								dependenciesForCallbacks.push(dependency);
+							}
+						}
+						for (var k = 0; k < callbacks.length; k++) {
+							try {
+								callbacks[k].call(null, moduleOutdatedDependencies);
+							} catch (err) {
+								if (typeof errorHandlers[k] === "function") {
+									try {
+										errorHandlers[k](err, {
+											moduleId: outdatedModuleId,
+											dependencyId: dependenciesForCallbacks[k]
+										});
+									} catch (err2) {
+										if (options.onErrored) {
+											options.onErrored({
+												type: "accept-error-handler-errored",
+												moduleId: outdatedModuleId,
+												dependencyId: dependenciesForCallbacks[k],
+												error: err2,
+												originalError: err
+											});
+										}
+										if (!options.ignoreErrored) {
+											reportError(err2);
+											reportError(err);
+										}
+									}
+								} else {
+									if (options.onErrored) {
+										options.onErrored({
+											type: "accept-errored",
+											moduleId: outdatedModuleId,
+											dependencyId: dependenciesForCallbacks[k],
+											error: err
+										});
+									}
+									if (!options.ignoreErrored) {
+										reportError(err);
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+
+			// Load self accepted modules
+			for (var o = 0; o < outdatedSelfAcceptedModules.length; o++) {
+				var item = outdatedSelfAcceptedModules[o];
+				var moduleId = item.module;
+				try {
+					item.require(moduleId);
+				} catch (err) {
+					if (typeof item.errorHandler === "function") {
+						try {
+							item.errorHandler(err, {
+								moduleId: moduleId,
+								module: __webpack_require__.c[moduleId]
+							});
+						} catch (err1) {
+							if (options.onErrored) {
+								options.onErrored({
+									type: "self-accept-error-handler-errored",
+									moduleId: moduleId,
+									error: err1,
+									originalError: err
+								});
+							}
+							if (!options.ignoreErrored) {
+								reportError(err1);
+								reportError(err);
+							}
+						}
+					} else {
+						if (options.onErrored) {
+							options.onErrored({
+								type: "self-accept-errored",
+								moduleId: moduleId,
+								error: err
+							});
+						}
+						if (!options.ignoreErrored) {
+							reportError(err);
+						}
+					}
+				}
+			}
+
+			return outdatedModules;
+		}
+	};
+}
+
+__webpack_require__.hmrI.jsonp = function (moduleId, applyHandlers) {
+	if (!currentUpdate) {
+		currentUpdate = {};
+		currentUpdateRuntime = [];
+		currentUpdateRemovedChunks = [];
+		applyHandlers.push(applyHandler);
+	}
+	if (!__webpack_require__.o(currentUpdate, moduleId)) {
+		currentUpdate[moduleId] = __webpack_require__.m[moduleId];
+	}
+};
+
+__webpack_require__.hmrC.jsonp = function (
+	chunkIds,
+	removedChunks,
+	removedModules,
+	promises,
+	applyHandlers,
+	updatedModulesList
+) {
+	applyHandlers.push(applyHandler);
+	currentUpdateChunks = {};
+	currentUpdateRemovedChunks = removedChunks;
+	currentUpdate = removedModules.reduce(function (obj, key) {
+		obj[key] = false;
+		return obj;
+	}, {});
+	currentUpdateRuntime = [];
+	chunkIds.forEach(function (chunkId) {
+		if (
+			__webpack_require__.o(installedChunks, chunkId) &&
+			installedChunks[chunkId] !== undefined
+		) {
+			promises.push(loadUpdateChunk(chunkId, updatedModulesList));
+			currentUpdateChunks[chunkId] = true;
+		} else {
+			currentUpdateChunks[chunkId] = false;
+		}
+	});
+	if (__webpack_require__.f) {
+		__webpack_require__.f.jsonpHmr = function (chunkId, promises) {
+			if (
+				currentUpdateChunks &&
+				__webpack_require__.o(currentUpdateChunks, chunkId) &&
+				!currentUpdateChunks[chunkId]
+			) {
+				promises.push(loadUpdateChunk(chunkId));
+				currentUpdateChunks[chunkId] = true;
+			}
+		};
+	}
+};
+__webpack_require__.hmrM = () => {
+	if (typeof fetch === "undefined")
+		throw new Error("No browser support: need fetch API");
+	return fetch(__webpack_require__.p + __webpack_require__.hmrF()).then(
+		(response) => {
+			if (response.status === 404) return; // no update available
+			if (!response.ok)
+				throw new Error(
+					"Failed to fetch update manifest " + response.statusText
+				);
+			return response.json();
+		}
+	);
+};
+
+})();
+// module factories are used so entry inlining is disabled
+// startup
+// Load entry module and return exports
+__webpack_require__(978);
+var __webpack_exports__ = __webpack_require__(652);
+})()
+;
+//# sourceMappingURL=service_worker.js.map