@lvce-editor/server 0.15.21 → 0.15.22

package/static/{94c91f4 → 387e82c}/packages/renderer-process/dist/rendererProcessMain.js

@@ -209,11 +209,11 @@ var getCombinedMessage, mergeStacks, getErrorStack, VError;
 var init_VError = __esm({
   "src/parts/VError/VError.js"() {
     "use strict";
-    getCombinedMessage = (error, message) => {
+    getCombinedMessage = (error2, message) => {
       if (message) {
-        return `${message}: ${error}`;
+        return `${message}: ${error2}`;
       }
-      return `${error}`;
+      return `${error2}`;
     };
     mergeStacks = (parent, child) => {
       if (!child) {
@@ -229,34 +229,34 @@ var init_VError = __esm({
       }
       return child;
     };
-    getErrorStack = (error) => {
-      if (error && error.stack) {
-        return error.stack;
+    getErrorStack = (error2) => {
+      if (error2 && error2.stack) {
+        return error2.stack;
       }
-      if (error && error.lineNumber && error.columnNumber && error.fileName) {
+      if (error2 && error2.lineNumber && error2.columnNumber && error2.fileName) {
         const normalStackLooksLike = new Error().stack;
         if (/^[$\w]+@.*/.test(normalStackLooksLike)) {
-          return `${error}
-unknown@${error.fileName}:${error.lineNumber}:${error.columnNumber}`;
+          return `${error2}
+unknown@${error2.fileName}:${error2.lineNumber}:${error2.columnNumber}`;
         }
-        return `${error.message}
-  at ${error.fileName}:${error.lineNumber}:${error.columnNumber}`;
+        return `${error2.message}
+  at ${error2.fileName}:${error2.lineNumber}:${error2.columnNumber}`;
       }
       return "";
     };
     VError = class extends Error {
-      constructor(error, message) {
-        const combinedMessage = getCombinedMessage(error, message);
+      constructor(error2, message) {
+        const combinedMessage = getCombinedMessage(error2, message);
         super(combinedMessage);
         this.name = "VError";
-        if (error instanceof Error) {
-          const errorStack = getErrorStack(error);
+        if (error2 instanceof Error) {
+          const errorStack = getErrorStack(error2);
           this.stack = mergeStacks(this.stack, errorStack);
         }
-        if (error.codeFrame) {
-          this.codeFrame = error.codeFrame;
+        if (error2.codeFrame) {
+          this.codeFrame = error2.codeFrame;
         }
-        this.cause = error;
+        this.cause = error2;
       }
     };
   }
@@ -295,11 +295,11 @@ var init_Command = __esm({
       try {
         const module = await state.load(moduleId);
         initializeModule(module);
-      } catch (error) {
-        if (error && error instanceof SyntaxError && error.stack === `SyntaxError: ${error.message}`) {
-          Error.captureStackTrace(error, loadModule);
+      } catch (error2) {
+        if (error2 && error2 instanceof SyntaxError && error2.stack === `SyntaxError: ${error2.message}`) {
+          Error.captureStackTrace(error2, loadModule);
         }
-        throw new VError(error, `failed to load module ${moduleId}`);
+        throw new VError(error2, `failed to load module ${moduleId}`);
       }
     };
     getOrLoadModule = (moduleId) => {
@@ -318,8 +318,8 @@ var init_Command = __esm({
     executeCommandAsync = async (command, ...args) => {
       try {
         await loadCommand(command);
-      } catch (error) {
-        throw new VError(error, `Failed to load command ${command}`);
+      } catch (error2) {
+        throw new VError(error2, `Failed to load command ${command}`);
       }
       if (!(command in state.commands)) {
         if (hasThrown.has(command)) {
@@ -342,34 +342,6 @@ var init_Command = __esm({
   }
 });
 
-// src/parts/IsFirefoxWorkerError/IsFirefoxWorkerError.js
-var isFirefoxWorkerError;
-var init_IsFirefoxWorkerError = __esm({
-  "src/parts/IsFirefoxWorkerError/IsFirefoxWorkerError.js"() {
-    "use strict";
-    isFirefoxWorkerError = (message) => {
-      return [
-        "SyntaxError: import declarations may only appear at top level of a module",
-        "SyntaxError: export declarations may only appear at top level of a module"
-      ].includes(message);
-    };
-  }
-});
-
-// src/parts/Logger/Logger.js
-var warn, info;
-var init_Logger = __esm({
-  "src/parts/Logger/Logger.js"() {
-    "use strict";
-    warn = (...args) => {
-      console.warn(...args);
-    };
-    info = (...args) => {
-      console.info(...args);
-    };
-  }
-});
-
 // src/parts/Event/Event.js
 var preventDefault, stopPropagation;
 var init_Event = __esm({
@@ -395,8 +367,8 @@ var init_ContentSecurityPolicyErrorState = __esm({
        */
       errors: []
     };
-    addError = (error) => {
-      state2.errors.push(error);
+    addError = (error2) => {
+      state2.errors.push(error2);
     };
     hasRecentErrors = () => {
       return state2.errors.length > 0;
@@ -633,6 +605,23 @@ var init_Css_ipc = __esm({
   }
 });
 
+// src/parts/Logger/Logger.js
+var warn, error, info;
+var init_Logger = __esm({
+  "src/parts/Logger/Logger.js"() {
+    "use strict";
+    warn = (...args) => {
+      console.warn(...args);
+    };
+    error = (...args) => {
+      console.error(...args);
+    };
+    info = (...args) => {
+      console.info(...args);
+    };
+  }
+});
+
 // src/parts/Developer/Developer.js
 var modules, showState;
 var init_Developer = __esm({
@@ -1204,14 +1193,14 @@ var init_SerializeError = __esm({
   "src/parts/SerializeError/SerializeError.js"() {
     "use strict";
     init_EnsureError();
-    serializeError = (error) => {
-      error = ensureError(error);
+    serializeError = (error2) => {
+      error2 = ensureError(error2);
       return {
-        stack: error.stack,
-        message: error.message,
-        name: error.name,
-        type: error.constructor.name,
-        codeFrame: error.codeFrame
+        stack: error2.stack,
+        message: error2.message,
+        name: error2.name,
+        type: error2.constructor.name,
+        codeFrame: error2.codeFrame
       };
     };
   }
@@ -1224,8 +1213,8 @@ var init_GetErrorResponse = __esm({
     "use strict";
     init_JsonRpcVersion();
     init_SerializeError();
-    getErrorResponse = (message, error) => {
-      const serializedError = serializeError(error);
+    getErrorResponse = (message, error2) => {
+      const serializedError = serializeError(error2);
       return {
         jsonrpc: Two,
         id: message.id,
@@ -1268,8 +1257,8 @@ var init_GetResponse = __esm({
       try {
         const result = await execute2(message.method, ...message.params);
         return getSuccessResponse(message, result);
-      } catch (error) {
-        return getErrorResponse(message, error);
+      } catch (error2) {
+        return getErrorResponse(message, error2);
       }
     };
   }
@@ -1305,6 +1294,39 @@ var init_JsonRpcError = __esm({
   }
 });
 
+// src/parts/HandleJsonRpcMessage/HandleJsonRpcMessage.js
+var handleJsonRpcMessage;
+var init_HandleJsonRpcMessage = __esm({
+  "src/parts/HandleJsonRpcMessage/HandleJsonRpcMessage.js"() {
+    "use strict";
+    init_GetResponse();
+    init_HasTransferableResult();
+    init_JsonRpcError();
+    handleJsonRpcMessage = async (ipc, message, execute2, resolve2) => {
+      if (message && message.message) {
+        message = message.message;
+      }
+      if (message && message.data) {
+        message = message.data;
+      }
+      if ("id" in message) {
+        if ("method" in message) {
+          const response = await getResponse(message, execute2);
+          if (hasTransferrableResult(message.method) && "result" in response) {
+            ipc.sendAndTransfer(response, [response.result]);
+          } else {
+            ipc.send(response);
+          }
+          return;
+        }
+        resolve2(message.id, message);
+        return;
+      }
+      throw new JsonRpcError("unexpected message from renderer worker");
+    };
+  }
+});
+
 // src/parts/HandleIpc/HandleIpc.js
 var handleIpc;
 var init_HandleIpc = __esm({
@@ -1313,27 +1335,11 @@ var init_HandleIpc = __esm({
     init_Assert();
     init_Callback();
     init_Command();
-    init_GetResponse();
-    init_HasTransferableResult();
-    init_JsonRpcError();
+    init_HandleJsonRpcMessage();
     handleIpc = (ipc) => {
       object(ipc);
-      const handleMessage = async (event) => {
-        const message = event.data;
-        if ("id" in message) {
-          if ("method" in message) {
-            const response = await getResponse(message, execute);
-            if (hasTransferrableResult(message.method) && "result" in response) {
-              ipc.sendAndTransfer(response, [response.result]);
-            } else {
-              ipc.send(response);
-            }
-            return;
-          }
-          resolve(message.id, message);
-          return;
-        }
-        throw new JsonRpcError("unexpected message from renderer worker");
+      const handleMessage = (message) => {
+        return handleJsonRpcMessage(ipc, message, execute, resolve);
       };
       ipc.onmessage = handleMessage;
     };
@@ -1392,6 +1398,20 @@ var init_GetFirstWorkerEvent = __esm({
   }
 });
 
+// src/parts/IsFirefoxWorkerError/IsFirefoxWorkerError.js
+var isFirefoxWorkerError;
+var init_IsFirefoxWorkerError = __esm({
+  "src/parts/IsFirefoxWorkerError/IsFirefoxWorkerError.js"() {
+    "use strict";
+    isFirefoxWorkerError = (message) => {
+      return [
+        "SyntaxError: import declarations may only appear at top level of a module",
+        "SyntaxError: export declarations may only appear at top level of a module"
+      ].includes(message);
+    };
+  }
+});
+
 // src/parts/ModuleWorkersAreNotSupportedInFirefoxError/ModuleWorkersAreNotSupportedInFirefoxError.js
 var ModuleWorkersAreNotSupportedInFirefoxError;
 var init_ModuleWorkersAreNotSupportedInFirefoxError = __esm({
@@ -1454,12 +1474,12 @@ var init_BabelParseError = __esm({
       return message;
     };
     BabelParseError = class extends SyntaxError {
-      constructor(url, error) {
-        const message = getBabelErrorMessage(error.message);
+      constructor(url, error2) {
+        const message = getBabelErrorMessage(error2.message);
         super(message);
         this.name = "BabelParseError";
-        const line = error.loc.line;
-        const column = error.loc.column + 1;
+        const line = error2.loc.line;
+        const column = error2.loc.column + 1;
         this.stack = `${message}
   at ${url}:${line}:${column}`;
       }
@@ -4749,15 +4769,15 @@ var init_babel_parser = __esm({
             at
           } = raiseProperties, details = _objectWithoutPropertiesLoose(raiseProperties, _excluded);
           const loc = at instanceof Position ? at : at.loc.start;
-          const error = toParseError({
+          const error2 = toParseError({
             loc,
             details
           });
           if (!this.options.errorRecovery)
-            throw error;
+            throw error2;
           if (!this.isLookahead)
-            this.state.errors.push(error);
-          return error;
+            this.state.errors.push(error2);
+          return error2;
         }
         raiseOverwrite(toParseError, raiseProperties) {
           const {
@@ -4767,14 +4787,14 @@ var init_babel_parser = __esm({
           const pos = loc.index;
           const errors = this.state.errors;
           for (let i = errors.length - 1; i >= 0; i--) {
-            const error = errors[i];
-            if (error.loc.index === pos) {
+            const error2 = errors[i];
+            if (error2.loc.index === pos) {
               return errors[i] = toParseError({
                 loc,
                 details
               });
             }
-            if (error.loc.index < pos)
+            if (error2.loc.index < pos)
               break;
           }
           return this.raise(toParseError, raiseProperties);
@@ -4804,9 +4824,9 @@ var init_babel_parser = __esm({
             });
           }
         }
-        errorBuilder(error) {
+        errorBuilder(error2) {
           return (pos, lineStart, curLine) => {
-            this.raise(error, {
+            this.raise(error2, {
               at: buildPosition(pos, lineStart, curLine)
             });
           };
@@ -4958,7 +4978,7 @@ var init_babel_parser = __esm({
           }
           this.parser.raise(toParseError, origin);
         }
-        recordArrowParameterBindingError(error, {
+        recordArrowParameterBindingError(error2, {
           at: node
         }) {
           const {
@@ -4969,9 +4989,9 @@ var init_babel_parser = __esm({
             at: node.loc.start
           };
           if (scope.isCertainlyParameterDeclaration()) {
-            this.parser.raise(error, origin);
+            this.parser.raise(error2, origin);
           } else if (scope.canBeArrowParameterDeclaration()) {
-            scope.recordDeclarationError(error, origin);
+            scope.recordDeclarationError(error2, origin);
           } else {
             return;
           }
@@ -5152,19 +5172,19 @@ var init_babel_parser = __esm({
               aborted: false,
               failState: null
             };
-          } catch (error) {
+          } catch (error2) {
             const failState = this.state;
             this.state = oldState;
-            if (error instanceof SyntaxError) {
+            if (error2 instanceof SyntaxError) {
               return {
                 node: null,
-                error,
+                error: error2,
                 thrown: true,
                 aborted: false,
                 failState
               };
             }
-            if (error === abortSignal) {
+            if (error2 === abortSignal) {
               return {
                 node: abortSignal.node,
                 error: null,
@@ -5173,7 +5193,7 @@ var init_babel_parser = __esm({
                 failState
               };
             }
-            throw error;
+            throw error2;
           }
         }
         checkExpressionErrors(refExpressionErrors, andThrow) {
@@ -12063,9 +12083,9 @@ var init_babel_parser = __esm({
           throw new Error("The 'syntaxType' option of the 'recordAndTuple' plugin must be one of: " + RECORD_AND_TUPLE_SYNTAX_TYPES.map((p) => `'${p}'`).join(", "));
         }
         if (hasPlugin(plugins, "asyncDoExpressions") && !hasPlugin(plugins, "doExpressions")) {
-          const error = new Error("'asyncDoExpressions' requires 'doExpressions', please add 'doExpressions' to parser plugins.");
-          error.missingPlugins = "doExpressions";
-          throw error;
+          const error2 = new Error("'asyncDoExpressions' requires 'doExpressions', please add 'doExpressions' to parser plugins.");
+          error2.missingPlugins = "doExpressions";
+          throw error2;
         }
       }
       const mixinPlugins = {
@@ -16120,8 +16140,8 @@ var isSyntaxError;
 var init_IsSyntaxError = __esm({
   "src/parts/IsSyntaxError/IsSyntaxError.js"() {
     "use strict";
-    isSyntaxError = (error) => {
-      return error instanceof SyntaxError;
+    isSyntaxError = (error2) => {
+      return error2 instanceof SyntaxError;
     };
   }
 });
@@ -16133,8 +16153,8 @@ var init_IsBabelParseError = __esm({
     "use strict";
     init_ErrorCodes();
     init_IsSyntaxError();
-    isBabelError = (error) => {
-      return isSyntaxError(error) && error.code === BABEL_PARSER_SYNTAX_ERROR;
+    isBabelError = (error2) => {
+      return isSyntaxError(error2) && error2.code === BABEL_PARSER_SYNTAX_ERROR;
     };
   }
 });
@@ -16232,11 +16252,11 @@ var init_TryToGetActualErrorMessageWhenNetworkRequestSucceeds = __esm({
         }
       }
     };
-    tryToGetActualErrorMessage = async ({ error, url, response, workerName, seenUrls = [] }) => {
+    tryToGetActualErrorMessage = async ({ error: error2, url, response, workerName, seenUrls = [] }) => {
       let text2;
       try {
         text2 = await response.text();
-      } catch (error2) {
+      } catch (error3) {
         if (workerName) {
           return `Failed to start ${workerName}: Unknown Network Error (${response.status})`;
         }
@@ -16247,11 +16267,11 @@ var init_TryToGetActualErrorMessageWhenNetworkRequestSucceeds = __esm({
         ast = await parse2(text2, {
           sourceType: Module2
         });
-      } catch (error2) {
-        if (isBabelError(error2)) {
-          throw new BabelParseError(url, error2);
+      } catch (error3) {
+        if (isBabelError(error3)) {
+          throw new BabelParseError(url, error3);
         }
-        throw error2;
+        throw error3;
       }
       const dependencies = getBabelAstDependencies(text2, ast);
       await getErrorInDependencies({ url, dependencies, seenUrls, workerName });
@@ -16284,8 +16304,8 @@ var init_TryToGetActualWorkerErrorMessage = __esm({
       let response;
       try {
         response = await fetch(url);
-      } catch (error) {
-        return `Failed to start ${displayName}: ${error}`;
+      } catch (error2) {
+        return `Failed to start ${displayName}: ${error2}`;
       }
       if (response.ok) {
         return await tryToGetActualErrorMessage({
@@ -16403,12 +16423,12 @@ var init_IpcParentWithModuleWorker = __esm({
             break;
         }
         return worker;
-      } catch (error) {
-        if (error && error instanceof ModuleWorkersAreNotSupportedInFirefoxError) {
+      } catch (error2) {
+        if (error2 && error2 instanceof ModuleWorkersAreNotSupportedInFirefoxError) {
           const IpcParentWithMessagePort = await Promise.resolve().then(() => (init_IpcParentWithMessagePort(), IpcParentWithMessagePort_exports));
           return IpcParentWithMessagePort.create({ url });
         }
-        throw error;
+        throw error2;
       }
     };
     wrap = (worker) => {
@@ -16618,49 +16638,49 @@ var init_RestoreJsonRpcError = __esm({
         return new ErrorConstructor(message, name31);
       }
       if (ErrorConstructor === Error) {
-        const error = new Error(message);
+        const error2 = new Error(message);
         if (name31 && name31 !== "VError") {
-          error.name = name31;
+          error2.name = name31;
         }
-        return error;
+        return error2;
       }
       return new ErrorConstructor(message);
     };
-    restoreJsonRpcError = (error) => {
-      if (error && error instanceof Error) {
-        return error;
+    restoreJsonRpcError = (error2) => {
+      if (error2 && error2 instanceof Error) {
+        return error2;
       }
-      if (error && error.code && error.code === MethodNotFound) {
-        const restoredError = new JsonRpcError(error.message);
-        restoredError.stack = error.stack;
+      if (error2 && error2.code && error2.code === MethodNotFound) {
+        const restoredError = new JsonRpcError(error2.message);
+        restoredError.stack = error2.stack;
         return restoredError;
       }
-      if (error && error.message) {
-        const restoredError = constructError(error.message, error.type, error.name);
-        if (error.data) {
+      if (error2 && error2.message) {
+        const restoredError = constructError(error2.message, error2.type, error2.name);
+        if (error2.data) {
           const currentStack = joinLines(splitLines(new Error().stack).slice(1));
-          if (error.data.stack && error.data.type && error.message) {
-            restoredError.stack = error.data.type + ": " + error.message + NewLine + error.data.stack + NewLine + currentStack;
-          } else if (error.data.stack) {
-            restoredError.stack = error.data.stack;
+          if (error2.data.stack && error2.data.type && error2.message) {
+            restoredError.stack = error2.data.type + ": " + error2.message + NewLine + error2.data.stack + NewLine + currentStack;
+          } else if (error2.data.stack) {
+            restoredError.stack = error2.data.stack;
           }
-          if (error.data.codeFrame) {
-            restoredError.codeFrame = error.data.codeFrame;
+          if (error2.data.codeFrame) {
+            restoredError.codeFrame = error2.data.codeFrame;
           }
-          if (error.data.code) {
-            restoredError.code = error.data.code;
+          if (error2.data.code) {
+            restoredError.code = error2.data.code;
           }
-        } else if (error.stack) {
+        } else if (error2.stack) {
           const lowerStack = restoredError.stack;
           const indexNewLine = getNewLineIndex(lowerStack);
-          restoredError.stack = error.stack + lowerStack.slice(indexNewLine);
+          restoredError.stack = error2.stack + lowerStack.slice(indexNewLine);
         }
         return restoredError;
       }
-      if (typeof error === "string") {
-        return new Error(`JsonRpc Error: ${error}`);
+      if (typeof error2 === "string") {
+        return new Error(`JsonRpc Error: ${error2}`);
       }
-      return new Error(`JsonRpc Error: ${error}`);
+      return new Error(`JsonRpc Error: ${error2}`);
     };
   }
 });
@@ -16702,13 +16722,13 @@ var init_IpcParentWithElectron = __esm({
       resolve(data.id, data);
     };
     window.addEventListener("message", handleMessageFromWindow);
-    create9 = async ({ type: type3 }) => {
+    create9 = async ({ type: type3, name: name31 }) => {
       const { id, promise } = registerPromise();
       const message = {
         jsonrpc: Two,
         id,
         method: "CreateMessagePort.createMessagePort",
-        params: [type3]
+        params: [type3, name31]
       };
       if (typeof window.myApi === "undefined") {
         throw new Error("Electron api was requested but is not available");
@@ -16792,7 +16812,7 @@ var init_Platform = __esm({
     state8 = {
       getAssetDir() {
         if (true) {
-          return "/94c91f4";
+          return "/387e82c";
         }
         if (platform === "electron") {
           return "../../../../..";
@@ -19575,9 +19595,9 @@ var init_TestFrameWork = __esm({
         const disposables = [];
         await Promise.race([
           new Promise((resolve2) => {
-            const timeout = setTimeout(resolve2, maxDelay);
+            const timeout2 = setTimeout(resolve2, maxDelay);
             disposables.push(() => {
-              clearTimeout(timeout);
+              clearTimeout(timeout2);
             });
           }),
           new Promise((resolve2) => {
@@ -20241,8 +20261,8 @@ var init_ViewletAudioEvents = __esm({
     init_ComponentUid();
     handleAudioError2 = (event) => {
       const { target } = event;
-      const { error } = target;
-      const { code, message } = error;
+      const { error: error2 } = target;
+      const { code, message } = error2;
       const uid = fromEvent(event);
       handleAudioError(uid, code, message);
     };
@@ -20996,7 +21016,7 @@ __export(ViewletEditorCompletion_exports, {
   attachEvents: () => attachEvents4,
   create: () => create26,
   dispose: () => dispose6,
-  handleError: () => handleError2,
+  handleError: () => handleError,
   setBounds: () => setBounds2,
   setContentHeight: () => setContentHeight,
   setFocusedIndex: () => setFocusedIndex,
@@ -21006,7 +21026,7 @@ __export(ViewletEditorCompletion_exports, {
   setSize: () => setSize,
   showLoading: () => showLoading
 });
-var create$CompletionItem, render$CompletionItem, create26, attachEvents4, render$ExtensionsLess, render$ExtensionsEqual, render$ExtensionsMore, render$Items, setItems, dispose6, setFocusedIndex, showLoading, handleError2, setBounds2;
+var create$CompletionItem, render$CompletionItem, create26, attachEvents4, render$ExtensionsLess, render$ExtensionsEqual, render$ExtensionsMore, render$Items, setItems, dispose6, setFocusedIndex, showLoading, handleError, setBounds2;
 var init_ViewletEditorCompletion = __esm({
   "src/parts/ViewletEditorCompletion/ViewletEditorCompletion.js"() {
     "use strict";
@@ -21168,9 +21188,9 @@ var init_ViewletEditorCompletion = __esm({
       append($Viewlet);
       setAdditionalFocus("editorCompletions");
     };
-    handleError2 = (state15, error) => {
+    handleError = (state15, error2) => {
       const { $Viewlet } = state15;
-      $Viewlet.textContent = `${error}`;
+      $Viewlet.textContent = `${error2}`;
     };
     setBounds2 = (state15, x, y, width, height) => {
       number(x);
@@ -21209,7 +21229,7 @@ var init_ViewletEditorImageFunctions = __esm({
 });
 
 // src/parts/ViewletEditorImage/ViewletEditorImageEvents.js
-var handlePointerMove2, handlePointerUp2, handlePointerCaptureLost2, handlePointerDown2, handleWheel4, handleContextMenu5, handleError3, handleFocus3;
+var handlePointerMove2, handlePointerUp2, handlePointerCaptureLost2, handlePointerDown2, handleWheel4, handleContextMenu5, handleError2, handleFocus3;
 var init_ViewletEditorImageEvents = __esm({
   "src/parts/ViewletEditorImage/ViewletEditorImageEvents.js"() {
     "use strict";
@@ -21261,7 +21281,7 @@ var init_ViewletEditorImageEvents = __esm({
       const uid = fromEvent(event);
       handleContextMenu4(uid, button, clientX, clientY);
     };
-    handleError3 = (event) => {
+    handleError2 = (event) => {
       const uid = fromEvent(event);
       handleImageError2(uid);
     };
@@ -21308,7 +21328,7 @@ var init_ViewletEditorImage = __esm({
     };
     attachEvents5 = (state15) => {
       const { $Image, $ImageWrapper, $Viewlet } = state15;
-      $Image.onerror = handleError3;
+      $Image.onerror = handleError2;
       $ImageWrapper.onfocus = handleFocus3;
       $Viewlet.onpointerdown = handlePointerDown2;
       $Viewlet.onpointerup = handlePointerUp2;
@@ -22029,7 +22049,7 @@ var ViewletEditorText_exports = {};
 __export(ViewletEditorText_exports, {
   create: () => create30,
   focus: () => focus3,
-  handleError: () => handleError4,
+  handleError: () => handleError3,
   hideOverlayMessage: () => hideOverlayMessage,
   highlightAsLink: () => highlightAsLink,
   setFocused: () => setFocused2,
@@ -22039,7 +22059,7 @@ __export(ViewletEditorText_exports, {
   setText: () => setText3,
   showOverlayMessage: () => showOverlayMessage
 });
-var create30, setText3, setSelections3, handleError4, setScrollBar3, setScrollBarHorizontal3, highlightAsLink, showOverlayMessage, hideOverlayMessage, setFocused2, focus3;
+var create30, setText3, setSelections3, handleError3, setScrollBar3, setScrollBarHorizontal3, highlightAsLink, showOverlayMessage, hideOverlayMessage, setFocused2, focus3;
 var init_ViewletEditorText = __esm({
   "src/parts/ViewletEditorText/ViewletEditorText.js"() {
     "use strict";
@@ -22050,8 +22070,8 @@ var init_ViewletEditorText = __esm({
     create30 = create29;
     setText3 = setText2;
     setSelections3 = setSelections2;
-    handleError4 = (state15, error) => {
-      state15.$Viewlet.textContent = error;
+    handleError3 = (state15, error2) => {
+      state15.$Viewlet.textContent = error2;
     };
     setScrollBar3 = setScrollBar2;
     setScrollBarHorizontal3 = setScrollBarHorizontal2;
@@ -22232,8 +22252,8 @@ var init_IsFileSystemAccessNotSupportedOnFirefoxError = __esm({
   "src/parts/IsFileSystemAccessNotSupportedOnFireFoxError/IsFileSystemAccessNotSupportedOnFirefoxError.js"() {
     "use strict";
     init_Platform();
-    isFileSystemAccessNotSupportedOnFireFoxError = (error) => {
-      return error instanceof TypeError && error.message === "item.getAsFileSystemHandle is not a function" && getBrowser() === "firefox";
+    isFileSystemAccessNotSupportedOnFireFoxError = (error2) => {
+      return error2 instanceof TypeError && error2.message === "item.getAsFileSystemHandle is not a function" && getBrowser() === "firefox";
     };
   }
 });
@@ -22253,11 +22273,11 @@ var init_GetFileHandlesFromDataTransferItems = __esm({
         const itemsArray = [...items];
         const handles = await Promise.all(itemsArray.map(getHandle));
         return handles;
-      } catch (error) {
-        if (isFileSystemAccessNotSupportedOnFireFoxError(error)) {
+      } catch (error2) {
+        if (isFileSystemAccessNotSupportedOnFireFoxError(error2)) {
           throw new Error(`The File System Access Api is not supported on Firefox`);
         }
-        throw error;
+        throw error2;
       }
     };
   }
@@ -22410,7 +22430,7 @@ __export(ViewletExplorer_exports, {
   attachEvents: () => attachEvents6,
   create: () => create34,
   dispose: () => dispose10,
-  handleError: () => handleError5,
+  handleError: () => handleError4,
   hideEditBox: () => hideEditBox,
   hoverIndex: () => hoverIndex,
   insertEditBox: () => insertEditBox,
@@ -22420,7 +22440,7 @@ __export(ViewletExplorer_exports, {
   setFocusedIndex: () => setFocusedIndex2,
   updateDirents: () => updateDirents
 });
-var activeId, focusClassName, defaultIndent, create34, attachEvents6, create$Row2, render$Row, render$RowsLess, render$RowsEqual, render$RowsMore, render$Rows, handleError5, updateDirents, setFocusedIndex2, dispose10, hoverIndex, replaceWithEditBox, insertEditBox, hideEditBox, replaceEditBox, setDropTargets;
+var activeId, focusClassName, defaultIndent, create34, attachEvents6, create$Row2, render$Row, render$RowsLess, render$RowsEqual, render$RowsMore, render$Rows, handleError4, updateDirents, setFocusedIndex2, dispose10, hoverIndex, replaceWithEditBox, insertEditBox, hideEditBox, replaceEditBox, setDropTargets;
 var init_ViewletExplorer = __esm({
   "src/parts/ViewletExplorer/ViewletExplorer.js"() {
     "use strict";
@@ -22537,7 +22557,7 @@ var init_ViewletExplorer = __esm({
         render$RowsMore($Rows, rowInfos);
       }
     };
-    handleError5 = (state15, message) => {
+    handleError4 = (state15, message) => {
       object(state15);
       string(message);
       const { $Viewlet } = state15;
@@ -22954,7 +22974,7 @@ __export(ViewletExtensions_exports, {
   create: () => create36,
   dispose: () => dispose11,
   focus: () => focus6,
-  handleError: () => handleError6,
+  handleError: () => handleError5,
   openSuggest: () => openSuggest,
   setContentHeight: () => setContentHeight,
   setExtensionState: () => setExtensionState,
@@ -22966,7 +22986,7 @@ __export(ViewletExtensions_exports, {
   setSearchValue: () => setSearchValue,
   setSize: () => setSize
 });
-var activeId2, create$ExtensionSuggestions, create36, attachEvents8, setFocusedIndex3, focus6, setExtensionState, setMessage3, render$Extension, create$Extension, render$ExtensionsLess2, render$ExtensionsEqual2, render$ExtensionsMore2, render$Extensions, setExtensions, dispose11, openSuggest, closeSuggest, handleError6, setSearchValue;
+var activeId2, create$ExtensionSuggestions, create36, attachEvents8, setFocusedIndex3, focus6, setExtensionState, setMessage3, render$Extension, create$Extension, render$ExtensionsLess2, render$ExtensionsEqual2, render$ExtensionsMore2, render$Extensions, setExtensions, dispose11, openSuggest, closeSuggest, handleError5, setSearchValue;
 var init_ViewletExtensions = __esm({
   "src/parts/ViewletExtensions/ViewletExtensions.js"() {
     "use strict";
@@ -23204,7 +23224,7 @@ var init_ViewletExtensions = __esm({
     closeSuggest = (state15) => {
       state15.$ExtensionSuggestions.remove();
     };
-    handleError6 = (state15, message) => {
+    handleError5 = (state15, message) => {
       object(state15);
       string(message);
       const { $ListItems } = state15;
@@ -23406,7 +23426,7 @@ var init_ViewletLocationsEvents = __esm({
 });
 
 // src/parts/ViewletLocations/ViewletLocations.js
-var create38, attachEvents10, create$Location, render$Location, render$Locations, setLocations, setMessage4, setFocusedIndex4, handleError7, focus8;
+var create38, attachEvents10, create$Location, render$Location, render$Locations, setLocations, setMessage4, setFocusedIndex4, handleError6, focus8;
 var init_ViewletLocations = __esm({
   "src/parts/ViewletLocations/ViewletLocations.js"() {
     "use strict";
@@ -23498,7 +23518,7 @@ var init_ViewletLocations = __esm({
         $Locations.children[newFocusedIndex].classList.add("Focused");
       }
     };
-    handleError7 = (state15, message) => {
+    handleError6 = (state15, message) => {
       const { $Message } = state15;
       $Message.textContent = message;
     };
@@ -23517,7 +23537,7 @@ __export(ViewletImplementations_exports, {
   attachEvents: () => attachEvents10,
   create: () => create38,
   focus: () => focus8,
-  handleError: () => handleError7,
+  handleError: () => handleError6,
   setFocusedIndex: () => setFocusedIndex4,
   setLocations: () => setLocations,
   setMessage: () => setMessage4
@@ -23788,8 +23808,8 @@ var init_KeyBindingsState = __esm({
     setModifier = (modifier) => {
       state13.modifier = modifier;
     };
-    setModifierTimeout = (timeout) => {
-      state13.modifierTimeout = timeout;
+    setModifierTimeout = (timeout2) => {
+      state13.modifierTimeout = timeout2;
     };
     hasModifier = () => {
       return state13.modifier;
@@ -24403,11 +24423,11 @@ __export(ViewletOutput_exports, {
   dispose: () => dispose14,
   disposeFindWidget: () => disposeFindWidget,
   focus: () => focus10,
-  handleError: () => handleError8,
+  handleError: () => handleError7,
   openFindWidget: () => openFindWidget,
   setText: () => setText4
 });
-var create44, setText4, clear, handleError8, focus10, openFindWidget, disposeFindWidget, dispose14;
+var create44, setText4, clear, handleError7, focus10, openFindWidget, disposeFindWidget, dispose14;
 var init_ViewletOutput = __esm({
   "src/parts/ViewletOutput/ViewletOutput.js"() {
     "use strict";
@@ -24441,10 +24461,10 @@ var init_ViewletOutput = __esm({
       object(state15);
       state15.content.textContent = "";
     };
-    handleError8 = (state15, error) => {
+    handleError7 = (state15, error2) => {
       object(state15);
-      string(error);
-      state15.content.textContent = error;
+      string(error2);
+      state15.content.textContent = error2;
     };
     focus10 = (state15) => {
       object(state15);
@@ -25235,7 +25255,7 @@ __export(ViewletReferences_exports, {
   attachEvents: () => attachEvents10,
   create: () => create38,
   focus: () => focus8,
-  handleError: () => handleError7,
+  handleError: () => handleError6,
   setFocusedIndex: () => setFocusedIndex4,
   setLocations: () => setLocations,
   setMessage: () => setMessage4
@@ -26402,12 +26422,12 @@ var init_ViewletSourceControl = __esm({
       const { $ViewletTree } = state15;
       $ViewletTree.replaceChildren(...$$Entries);
     };
-    setError2 = (state15, error) => {
+    setError2 = (state15, error2) => {
       object(state15);
-      string(error);
+      string(error2);
       const $Error = document.createElement("div");
       $Error.className = "Error";
-      $Error.textContent = error;
+      $Error.textContent = error2;
       const { $ViewletTree } = state15;
       $ViewletTree.append($Error);
     };
@@ -26747,7 +26767,7 @@ var init_termterm = __esm({
       cursorRight,
       cursorLeft,
       backspace,
-      print,
+      print: print2,
       setGLevel,
       saveCursor,
       restoreCursor,
@@ -26967,24 +26987,24 @@ var init_termterm = __esm({
                     }
                     switch (element) {
                       case 27:
-                        print(array2, printStartIndex, i);
+                        print2(array2, printStartIndex, i);
                         state15 = State.Escaped;
                         i++;
                         break middle;
                       case 7:
-                        print(array2, printStartIndex, i);
+                        print2(array2, printStartIndex, i);
                         bell();
                         i++;
                         state15 = State.TopLevelContent;
                         break middle;
                       case 8:
-                        print(array2, printStartIndex, i);
+                        print2(array2, printStartIndex, i);
                         backspace();
                         i++;
                         state15 = State.TopLevelContent;
                         break middle;
                       case 13:
-                        print(array2, printStartIndex, i);
+                        print2(array2, printStartIndex, i);
                         carriageReturn();
                         i++;
                         state15 = State.TopLevelContent;
@@ -26994,7 +27014,7 @@ var init_termterm = __esm({
                         break;
                     }
                   }
-                  print(array2, printStartIndex, i);
+                  print2(array2, printStartIndex, i);
                   break;
                 default:
                   throw new Error("no");
@@ -28738,8 +28758,8 @@ var init_ViewletVideoEvents = __esm({
     init_ViewletVideoFunctions();
     handleVideoError2 = (event) => {
       const { target } = event;
-      const { error } = target;
-      const { code, message } = error;
+      const { error: error2 } = target;
+      const { code, message } = error2;
       handleVideoError(code, message);
     };
   }
@@ -28958,7 +28978,7 @@ var init_ViewletModule = __esm({
 });
 
 // src/parts/Viewlet/Viewlet.js
-var state14, create69, addKeyBindings3, removeKeyBindings3, loadModule2, invoke, focus20, refresh6, specialIds, isSpecial, createPlaceholder, sendMultiple, dispose23, handleError9, appendViewlet, ariaAnnounce, append2, appendToBody, getFn, executeCommands, show, setBounds3;
+var state14, create69, addKeyBindings3, removeKeyBindings3, loadModule2, invoke, focus20, refresh6, specialIds, isSpecial, createPlaceholder, sendMultiple, dispose23, handleError8, appendViewlet, ariaAnnounce, append2, appendToBody, getFn, executeCommands, show, setBounds3;
 var init_Viewlet = __esm({
   "src/parts/Viewlet/Viewlet.js"() {
     "use strict";
@@ -29003,8 +29023,8 @@ var init_Viewlet = __esm({
       try {
         const module = await load(id);
         state14.modules[id] = module;
-      } catch (error) {
-        throw new VError(error, `Failed to load ${id}`);
+      } catch (error2) {
+        throw new VError(error2, `Failed to load ${id}`);
       }
     };
     invoke = (viewletId, method, ...args) => {
@@ -29086,7 +29106,7 @@ var init_Viewlet = __esm({
             break;
           }
           case "Viewlet.handleError": {
-            handleError9(viewletId, method, ...args);
+            handleError8(viewletId, method, ...args);
             break;
           }
           case "Viewlet.focus": {
@@ -29132,7 +29152,7 @@ var init_Viewlet = __esm({
         throw new Error(`Failed to dispose ${id}`);
       }
     };
-    handleError9 = (id, parentId, message) => {
+    handleError8 = (id, parentId, message) => {
       info(`[viewlet-error] ${id}: ${message}`);
       const instance = state14.instances[id];
       if (instance && instance.state.$Viewlet.isConnected) {
@@ -29299,7 +29319,7 @@ var init_Viewlet_ipc = __esm({
       dispose: dispose23,
       executeCommands,
       focus: focus20,
-      handleError: handleError9,
+      handleError: handleError8,
       invoke,
       loadModule: loadModule2,
       refresh: refresh6,
@@ -29447,31 +29467,6 @@ var init_Window_ipc = __esm({
 
 // src/rendererProcessMain.js
 init_Command();
-
-// src/parts/IsChromeExtensionError/IsChromeExtensionError.js
-var isChromeExtensionError = (error) => {
-  return `${error}` === "Script error.";
-};
-
-// src/parts/ErrorHandling/ErrorHandling.js
-init_IsFirefoxWorkerError();
-init_Logger();
-var handleError = (error) => {
-  if (isChromeExtensionError(error)) {
-    return;
-  }
-  if (isFirefoxWorkerError(error)) {
-    return;
-  }
-  info(`[renderer-process] Unhandled Error: ${error}`);
-  alert(error);
-};
-var handleUnhandledRejection = (event) => {
-  info(`[renderer-process] Unhandled Rejection: ${event.reason}`);
-  alert(event.reason);
-};
-
-// src/rendererProcessMain.js
 init_Event();
 
 // src/parts/HandleContentSecurityPolicyViolation/HandleContentSecurityPolicyViolation.js
@@ -29559,11 +29554,1099 @@ var load2 = (moduleId) => {
 init_Platform();
 init_PlatformType();
 init_RendererWorker();
+
+// static/js/ky.js
+var HTTPError = class extends Error {
+  constructor(response, request, options) {
+    const code = response.status || response.status === 0 ? response.status : "";
+    const title = response.statusText || "";
+    const status = `${code} ${title}`.trim();
+    const reason = status ? `status code ${status}` : "an unknown error";
+    super(`Request failed with ${reason}`);
+    Object.defineProperty(this, "response", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "request", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "options", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.name = "HTTPError";
+    this.response = response;
+    this.request = request;
+    this.options = options;
+  }
+};
+var TimeoutError = class extends Error {
+  constructor(request) {
+    super("Request timed out");
+    Object.defineProperty(this, "request", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.name = "TimeoutError";
+    this.request = request;
+  }
+};
+var isObject = (value) => value !== null && typeof value === "object";
+var validateAndMerge = (...sources) => {
+  for (const source of sources) {
+    if ((!isObject(source) || Array.isArray(source)) && typeof source !== "undefined") {
+      throw new TypeError("The `options` argument must be an object");
+    }
+  }
+  return deepMerge({}, ...sources);
+};
+var mergeHeaders = (source1 = {}, source2 = {}) => {
+  const result = new globalThis.Headers(source1);
+  const isHeadersInstance = source2 instanceof globalThis.Headers;
+  const source = new globalThis.Headers(source2);
+  for (const [key, value] of source.entries()) {
+    if (isHeadersInstance && value === "undefined" || value === void 0) {
+      result.delete(key);
+    } else {
+      result.set(key, value);
+    }
+  }
+  return result;
+};
+var deepMerge = (...sources) => {
+  let returnValue = {};
+  let headers = {};
+  for (const source of sources) {
+    if (Array.isArray(source)) {
+      if (!Array.isArray(returnValue)) {
+        returnValue = [];
+      }
+      returnValue = [...returnValue, ...source];
+    } else if (isObject(source)) {
+      for (let [key, value] of Object.entries(source)) {
+        if (isObject(value) && key in returnValue) {
+          value = deepMerge(returnValue[key], value);
+        }
+        returnValue = { ...returnValue, [key]: value };
+      }
+      if (isObject(source.headers)) {
+        headers = mergeHeaders(headers, source.headers);
+        returnValue.headers = headers;
+      }
+    }
+  }
+  return returnValue;
+};
+var supportsRequestStreams = (() => {
+  let duplexAccessed = false;
+  let hasContentType = false;
+  const supportsReadableStream = typeof globalThis.ReadableStream === "function";
+  const supportsRequest = typeof globalThis.Request === "function";
+  if (supportsReadableStream && supportsRequest) {
+    hasContentType = new globalThis.Request("https://a.com", {
+      body: new globalThis.ReadableStream(),
+      method: "POST",
+      get duplex() {
+        duplexAccessed = true;
+        return "half";
+      }
+    }).headers.has("Content-Type");
+  }
+  return duplexAccessed && !hasContentType;
+})();
+var supportsAbortController = typeof globalThis.AbortController === "function";
+var supportsResponseStreams = typeof globalThis.ReadableStream === "function";
+var supportsFormData = typeof globalThis.FormData === "function";
+var requestMethods = ["get", "post", "put", "patch", "head", "delete"];
+var responseTypes = {
+  json: "application/json",
+  text: "text/*",
+  formData: "multipart/form-data",
+  arrayBuffer: "*/*",
+  blob: "*/*"
+};
+var maxSafeTimeout = 2147483647;
+var stop = Symbol("stop");
+var normalizeRequestMethod = (input) => requestMethods.includes(input) ? input.toUpperCase() : input;
+var retryMethods = ["get", "put", "head", "delete", "options", "trace"];
+var retryStatusCodes = [408, 413, 429, 500, 502, 503, 504];
+var retryAfterStatusCodes = [413, 429, 503];
+var defaultRetryOptions = {
+  limit: 2,
+  methods: retryMethods,
+  statusCodes: retryStatusCodes,
+  afterStatusCodes: retryAfterStatusCodes,
+  maxRetryAfter: Number.POSITIVE_INFINITY,
+  backoffLimit: Number.POSITIVE_INFINITY
+};
+var normalizeRetryOptions = (retry = {}) => {
+  if (typeof retry === "number") {
+    return {
+      ...defaultRetryOptions,
+      limit: retry
+    };
+  }
+  if (retry.methods && !Array.isArray(retry.methods)) {
+    throw new Error("retry.methods must be an array");
+  }
+  if (retry.statusCodes && !Array.isArray(retry.statusCodes)) {
+    throw new Error("retry.statusCodes must be an array");
+  }
+  return {
+    ...defaultRetryOptions,
+    ...retry,
+    afterStatusCodes: retryAfterStatusCodes
+  };
+};
+async function timeout(request, abortController, options) {
+  return new Promise((resolve2, reject) => {
+    const timeoutId = setTimeout(() => {
+      if (abortController) {
+        abortController.abort();
+      }
+      reject(new TimeoutError(request));
+    }, options.timeout);
+    void options.fetch(request).then(resolve2).catch(reject).then(() => {
+      clearTimeout(timeoutId);
+    });
+  });
+}
+var isDomExceptionSupported = Boolean(globalThis.DOMException);
+function composeAbortError(signal) {
+  var _a, _b;
+  if (isDomExceptionSupported) {
+    return new DOMException((_a = signal == null ? void 0 : signal.reason) != null ? _a : "The operation was aborted.", "AbortError");
+  }
+  const error2 = new Error((_b = signal == null ? void 0 : signal.reason) != null ? _b : "The operation was aborted.");
+  error2.name = "AbortError";
+  return error2;
+}
+async function delay(ms, { signal }) {
+  return new Promise((resolve2, reject) => {
+    if (signal) {
+      if (signal.aborted) {
+        reject(composeAbortError(signal));
+        return;
+      }
+      signal.addEventListener("abort", handleAbort, { once: true });
+    }
+    function handleAbort() {
+      reject(composeAbortError(signal));
+      clearTimeout(timeoutId);
+    }
+    const timeoutId = setTimeout(() => {
+      signal == null ? void 0 : signal.removeEventListener("abort", handleAbort);
+      resolve2();
+    }, ms);
+  });
+}
+var Ky = class {
+  static create(input, options) {
+    const ky2 = new Ky(input, options);
+    const fn = async () => {
+      if (ky2._options.timeout > maxSafeTimeout) {
+        throw new RangeError(`The \`timeout\` option cannot be greater than ${maxSafeTimeout}`);
+      }
+      await Promise.resolve();
+      let response = await ky2._fetch();
+      for (const hook of ky2._options.hooks.afterResponse) {
+        const modifiedResponse = await hook(ky2.request, ky2._options, ky2._decorateResponse(response.clone()));
+        if (modifiedResponse instanceof globalThis.Response) {
+          response = modifiedResponse;
+        }
+      }
+      ky2._decorateResponse(response);
+      if (!response.ok && ky2._options.throwHttpErrors) {
+        let error2 = new HTTPError(response, ky2.request, ky2._options);
+        for (const hook of ky2._options.hooks.beforeError) {
+          error2 = await hook(error2);
+        }
+        throw error2;
+      }
+      if (ky2._options.onDownloadProgress) {
+        if (typeof ky2._options.onDownloadProgress !== "function") {
+          throw new TypeError("The `onDownloadProgress` option must be a function");
+        }
+        if (!supportsResponseStreams) {
+          throw new Error("Streams are not supported in your environment. `ReadableStream` is missing.");
+        }
+        return ky2._stream(response.clone(), ky2._options.onDownloadProgress);
+      }
+      return response;
+    };
+    const isRetriableMethod = ky2._options.retry.methods.includes(ky2.request.method.toLowerCase());
+    const result = isRetriableMethod ? ky2._retry(fn) : fn();
+    for (const [type3, mimeType] of Object.entries(responseTypes)) {
+      result[type3] = async () => {
+        ky2.request.headers.set("accept", ky2.request.headers.get("accept") || mimeType);
+        const awaitedResult = await result;
+        const response = awaitedResult.clone();
+        if (type3 === "json") {
+          if (response.status === 204) {
+            return "";
+          }
+          const arrayBuffer = await response.clone().arrayBuffer();
+          const responseSize = arrayBuffer.byteLength;
+          if (responseSize === 0) {
+            return "";
+          }
+          if (options.parseJson) {
+            return options.parseJson(await response.text());
+          }
+        }
+        return response[type3]();
+      };
+    }
+    return result;
+  }
+  constructor(input, options = {}) {
+    var _a, _b, _c;
+    Object.defineProperty(this, "request", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "abortController", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_retryCount", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: 0
+    });
+    Object.defineProperty(this, "_input", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_options", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this._input = input;
+    this._options = {
+      credentials: this._input.credentials || "same-origin",
+      ...options,
+      headers: mergeHeaders(this._input.headers, options.headers),
+      hooks: deepMerge({
+        beforeRequest: [],
+        beforeRetry: [],
+        beforeError: [],
+        afterResponse: []
+      }, options.hooks),
+      method: normalizeRequestMethod((_a = options.method) != null ? _a : this._input.method),
+      prefixUrl: String(options.prefixUrl || ""),
+      retry: normalizeRetryOptions(options.retry),
+      throwHttpErrors: options.throwHttpErrors !== false,
+      timeout: typeof options.timeout === "undefined" ? 1e4 : options.timeout,
+      fetch: (_b = options.fetch) != null ? _b : globalThis.fetch.bind(globalThis)
+    };
+    if (typeof this._input !== "string" && !(this._input instanceof URL || this._input instanceof globalThis.Request)) {
+      throw new TypeError("`input` must be a string, URL, or Request");
+    }
+    if (this._options.prefixUrl && typeof this._input === "string") {
+      if (this._input.startsWith("/")) {
+        throw new Error("`input` must not begin with a slash when using `prefixUrl`");
+      }
+      if (!this._options.prefixUrl.endsWith("/")) {
+        this._options.prefixUrl += "/";
+      }
+      this._input = this._options.prefixUrl + this._input;
+    }
+    if (supportsAbortController) {
+      this.abortController = new globalThis.AbortController();
+      if (this._options.signal) {
+        const originalSignal = this._options.signal;
+        this._options.signal.addEventListener("abort", () => {
+          this.abortController.abort(originalSignal.reason);
+        });
+      }
+      this._options.signal = this.abortController.signal;
+    }
+    if (supportsRequestStreams) {
+      this._options.duplex = "half";
+    }
+    this.request = new globalThis.Request(this._input, this._options);
+    if (this._options.searchParams) {
+      const textSearchParams = typeof this._options.searchParams === "string" ? this._options.searchParams.replace(/^\?/, "") : new URLSearchParams(this._options.searchParams).toString();
+      const searchParams = "?" + textSearchParams;
+      const url = this.request.url.replace(/(?:\?.*?)?(?=#|$)/, searchParams);
+      if ((supportsFormData && this._options.body instanceof globalThis.FormData || this._options.body instanceof URLSearchParams) && !(this._options.headers && this._options.headers["content-type"])) {
+        this.request.headers.delete("content-type");
+      }
+      this.request = new globalThis.Request(new globalThis.Request(url, { ...this.request }), this._options);
+    }
+    if (this._options.json !== void 0) {
+      this._options.body = JSON.stringify(this._options.json);
+      this.request.headers.set("content-type", (_c = this._options.headers.get("content-type")) != null ? _c : "application/json");
+      this.request = new globalThis.Request(this.request, { body: this._options.body });
+    }
+  }
+  _calculateRetryDelay(error2) {
+    this._retryCount++;
+    if (this._retryCount < this._options.retry.limit && !(error2 instanceof TimeoutError)) {
+      if (error2 instanceof HTTPError) {
+        if (!this._options.retry.statusCodes.includes(error2.response.status)) {
+          return 0;
+        }
+        const retryAfter = error2.response.headers.get("Retry-After");
+        if (retryAfter && this._options.retry.afterStatusCodes.includes(error2.response.status)) {
+          let after = Number(retryAfter);
+          if (Number.isNaN(after)) {
+            after = Date.parse(retryAfter) - Date.now();
+          } else {
+            after *= 1e3;
+          }
+          if (typeof this._options.retry.maxRetryAfter !== "undefined" && after > this._options.retry.maxRetryAfter) {
+            return 0;
+          }
+          return after;
+        }
+        if (error2.response.status === 413) {
+          return 0;
+        }
+      }
+      const BACKOFF_FACTOR = 0.3;
+      return Math.min(this._options.retry.backoffLimit, BACKOFF_FACTOR * 2 ** (this._retryCount - 1) * 1e3);
+    }
+    return 0;
+  }
+  _decorateResponse(response) {
+    if (this._options.parseJson) {
+      response.json = async () => this._options.parseJson(await response.text());
+    }
+    return response;
+  }
+  async _retry(fn) {
+    try {
+      return await fn();
+    } catch (error2) {
+      const ms = Math.min(this._calculateRetryDelay(error2), maxSafeTimeout);
+      if (ms !== 0 && this._retryCount > 0) {
+        await delay(ms, { signal: this._options.signal });
+        for (const hook of this._options.hooks.beforeRetry) {
+          const hookResult = await hook({
+            request: this.request,
+            options: this._options,
+            error: error2,
+            retryCount: this._retryCount
+          });
+          if (hookResult === stop) {
+            return;
+          }
+        }
+        return this._retry(fn);
+      }
+      throw error2;
+    }
+  }
+  async _fetch() {
+    for (const hook of this._options.hooks.beforeRequest) {
+      const result = await hook(this.request, this._options);
+      if (result instanceof Request) {
+        this.request = result;
+        break;
+      }
+      if (result instanceof Response) {
+        return result;
+      }
+    }
+    if (this._options.timeout === false) {
+      return this._options.fetch(this.request.clone());
+    }
+    return timeout(this.request.clone(), this.abortController, this._options);
+  }
+  _stream(response, onDownloadProgress) {
+    const totalBytes = Number(response.headers.get("content-length")) || 0;
+    let transferredBytes = 0;
+    if (response.status === 204) {
+      if (onDownloadProgress) {
+        onDownloadProgress({ percent: 1, totalBytes, transferredBytes }, new Uint8Array());
+      }
+      return new globalThis.Response(null, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      });
+    }
+    return new globalThis.Response(new globalThis.ReadableStream({
+      async start(controller) {
+        const reader = response.body.getReader();
+        if (onDownloadProgress) {
+          onDownloadProgress({ percent: 0, transferredBytes: 0, totalBytes }, new Uint8Array());
+        }
+        async function read() {
+          const { done, value } = await reader.read();
+          if (done) {
+            controller.close();
+            return;
+          }
+          if (onDownloadProgress) {
+            transferredBytes += value.byteLength;
+            const percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
+            onDownloadProgress({ percent, transferredBytes, totalBytes }, value);
+          }
+          controller.enqueue(value);
+          await read();
+        }
+        await read();
+      }
+    }), {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  }
+};
+var createInstance = (defaults) => {
+  const ky2 = (input, options) => Ky.create(input, validateAndMerge(defaults, options));
+  for (const method of requestMethods) {
+    ky2[method] = (input, options) => Ky.create(input, validateAndMerge(defaults, options, { method }));
+  }
+  ky2.create = (newDefaults) => createInstance(validateAndMerge(newDefaults));
+  ky2.extend = (newDefaults) => createInstance(validateAndMerge(defaults, newDefaults));
+  ky2.stop = stop;
+  return ky2;
+};
+var ky = createInstance();
+var ky_default = ky;
+
+// src/parts/Ajax/Ajax.js
+init_VError();
+init_Assert();
+var getJson = async (url, options = {}) => {
+  try {
+    string(url);
+    const response = await ky_default(url, options);
+    return response.json();
+  } catch (error2) {
+    if (error2 && error2 instanceof TypeError && error2.message === "Failed to fetch") {
+      throw new VError(
+        `Failed to request json from "${url}". Make sure that the server is running and has CORS enabled`
+      );
+    }
+    if (error2 && error2 instanceof HTTPError) {
+      let json;
+      try {
+        json = await error2.response.json();
+      } catch {
+        throw error2;
+      }
+      if (json && json.message) {
+        throw new VError(
+          `Failed to request json from "${url}": ${json.message}`
+        );
+      }
+    }
+    error2.message = `Failed to request json from "${url}": ${error2.message}`;
+    throw error2;
+  }
+};
+var getText2 = async (url, options = {}) => {
+  try {
+    return await ky_default(url, options).text();
+  } catch (error2) {
+    if (error2 && error2 instanceof TypeError && error2.message === "Failed to fetch") {
+      throw new VError(
+        error2,
+        `Failed to request text from "${url}". Make sure that the server is running and has CORS enabled`
+      );
+    }
+    throw new VError(error2, `Failed to request text from "${url}"`);
+  }
+};
+
+// src/parts/PrettyError/PrettyError.js
+init_Assert();
+init_Character();
+
+// src/parts/CleanStack/CleanStack.js
+init_SplitLines();
+init_Assert();
+var RE_AT = /^\s+at/;
+var RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
+var RE_OBJECT_AS = /^\s*at Object\.\w+ \[as ([\w\.]+)\]/;
+var RE_OBJECT = /^\s*at Object\.(\w+)/;
+var RE_PATH_1 = /\((.*):(\d+):(\d+)\)$/;
+var RE_PATH_2 = /at (.*):(\d+):(\d+)$/;
+var RE_PATH_3 = /@(.*):(\d+):(\d+)$/;
+var RE_RESTORE_JSON_RPC_ERROR = /^\s*at restoreJsonRpcError/;
+var RE_UNWRAP_JSON_RPC_RESULT = /^\s*at unwrapJsonRpcResult/;
+var RE_JSON_RPC_INVOKE = /^\s*at invoke .*JsonRpc\.js/;
+var RE_ASSERT = /^\s*at .*\/Assert\.js/;
+var RE_CONSTRUCT_ERROR = /^\s*at constructError /;
+var isInternalLine = (line) => {
+  return RE_AT_PROMISE_INDEX.test(line);
+};
+var isRelevantLine = (line) => {
+  return !isInternalLine(line);
+};
+var isNormalStackLine = (line) => {
+  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line) || RE_PATH_2.test(line) || RE_PATH_3.test(line);
+};
+var isApplicationUsefulLine = (line, index) => {
+  if (index === 0) {
+    if (RE_ASSERT.test(line)) {
+      return false;
+    }
+    return true;
+  }
+  if (RE_RESTORE_JSON_RPC_ERROR.test(line) || RE_JSON_RPC_INVOKE.test(line) || RE_UNWRAP_JSON_RPC_RESULT.test(line) || RE_CONSTRUCT_ERROR.test(line)) {
+    return false;
+  }
+  return true;
+};
+var cleanLine = (line) => {
+  if (line.startsWith("    at async Module.")) {
+    return "    at async " + line.slice("    at async Module.".length);
+  }
+  if (line.startsWith("    at Module.")) {
+    return "    at " + line.slice("    at Module.".length);
+  }
+  const objectAsMatch = line.match(RE_OBJECT_AS);
+  if (objectAsMatch) {
+    return "    at " + objectAsMatch[1] + line.slice(objectAsMatch[0].length);
+  }
+  const objectMatch = line.match(RE_OBJECT);
+  if (objectMatch) {
+    return "    at " + objectMatch[1] + line.slice(objectMatch[0].length);
+  }
+  return line;
+};
+var getDetails = (lines) => {
+  const index = lines.findIndex(isNormalStackLine);
+  return {
+    custom: lines.slice(0, index),
+    actualStack: lines.slice(index).map(cleanLine)
+  };
+};
+var mergeCustom = (custom, relevantStack) => {
+  if (custom.length === 0) {
+    return relevantStack;
+  }
+  const firstLine = custom[0];
+  if (RE_PATH_1.test(firstLine)) {
+    return [`    at ${firstLine}`, ...relevantStack];
+  }
+  if (RE_PATH_2.test(firstLine)) {
+    return [`    at ${firstLine}`, ...relevantStack];
+  }
+  if (RE_PATH_3.test(firstLine)) {
+    return [firstLine, ...relevantStack];
+  }
+  return relevantStack;
+};
+var cleanStack = (stack) => {
+  string(stack);
+  const lines = splitLines(stack);
+  const { custom, actualStack } = getDetails(lines);
+  const relevantStack = actualStack.filter(isRelevantLine).filter(isApplicationUsefulLine);
+  const merged = mergeCustom(custom, relevantStack);
+  return merged;
+};
+
+// src/parts/CodeFrameColumns/CodeFrameColumns.js
+init_Character();
+var NEWLINE = /\n/;
+var getMarkerLines = (loc, source, opts) => {
+  const startLoc = {
+    column: 0,
+    line: -1,
+    ...loc.start
+  };
+  const endLoc = {
+    ...startLoc,
+    ...loc.end
+  };
+  const { linesAbove = 2, linesBelow = 3 } = opts || {};
+  const startLine = startLoc.line;
+  const startColumn = startLoc.column;
+  const endLine = endLoc.line;
+  const endColumn = endLoc.column;
+  let start = Math.max(startLine - (linesAbove + 1), 0);
+  let end = Math.min(source.length, endLine + linesBelow);
+  if (startLine === -1) {
+    start = 0;
+  }
+  if (endLine === -1) {
+    end = source.length;
+  }
+  const lineDiff = endLine - startLine;
+  const markerLines = {};
+  if (lineDiff) {
+    for (let i = 0; i <= lineDiff; i++) {
+      const lineNumber = i + startLine;
+      if (!startColumn) {
+        markerLines[lineNumber] = true;
+      } else if (i === 0) {
+        const sourceLength = source[lineNumber - 1].length;
+        markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
+      } else if (i === lineDiff) {
+        markerLines[lineNumber] = [0, endColumn];
+      } else {
+        const sourceLength = source[lineNumber - i].length;
+        markerLines[lineNumber] = [0, sourceLength];
+      }
+    }
+  } else {
+    if (startColumn === endColumn) {
+      if (startColumn) {
+        markerLines[startLine] = [startColumn, 0];
+      } else {
+        markerLines[startLine] = true;
+      }
+    } else {
+      markerLines[startLine] = [startColumn, endColumn - startColumn];
+    }
+  }
+  return { start, end, markerLines };
+};
+var create70 = (rawLines, loc, opts = {}) => {
+  const lines = rawLines.split(NEWLINE);
+  const { start, end, markerLines } = getMarkerLines(loc, lines, opts);
+  const hasColumns = loc.start && typeof loc.start.column === "number";
+  const numberMaxWidth = String(end).length;
+  let frame = rawLines.split(NEWLINE, end).slice(start, end).map((line, index) => {
+    const number2 = start + 1 + index;
+    const paddedNumber = ` ${number2}`.slice(-numberMaxWidth);
+    const gutter = ` ${paddedNumber} |`;
+    const hasMarker = markerLines[number2];
+    const lastMarkerLine = !markerLines[number2 + 1];
+    if (hasMarker) {
+      let markerLine = "";
+      if (Array.isArray(hasMarker)) {
+        const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " ");
+        const numberOfMarkers = hasMarker[1] || 1;
+        markerLine = ["\n ", gutter.replace(/\d/g, " "), " ", markerSpacing, "^".repeat(numberOfMarkers)].join("");
+        if (lastMarkerLine && opts.message) {
+          markerLine += " " + opts.message;
+        }
+      }
+      return [">", gutter, line.length > 0 ? ` ${line}` : "", markerLine].join("");
+    } else {
+      return ` ${gutter}${line.length > 0 ? ` ${line}` : ""}`;
+    }
+  }).join(NewLine);
+  if (opts.message && !hasColumns) {
+    frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}
+${frame}`;
+  }
+  return frame;
+};
+
+// src/parts/PrettyError/PrettyError.js
+init_GetNewLineIndex();
+
+// src/parts/IsActualSourceFile/IsActualSourceFile.js
+var isActualSourceFile = (path) => {
+  if (path === "<anonymous>" || path === "debugger eval code" || path.startsWith('"') || path.startsWith(`'`) || path.startsWith(")") || path.startsWith("file://")) {
+    return false;
+  }
+  return true;
+};
+
+// src/parts/PrettyError/PrettyError.js
+init_JoinLines();
+init_Logger();
+init_Platform();
+
+// src/parts/SourceMap/SourceMap.js
+init_Assert();
+
+// src/parts/IsEmptyString/IsEmptyString.js
+var isEmptyString = (string2) => {
+  return string2 === "";
+};
+
+// src/parts/SourceMap/SourceMap.js
+init_VError();
+
+// src/parts/Vlq/Vlq.js
+var char_to_integer = {};
+var integer_to_char = {};
+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".split("").forEach(function(char, i) {
+  char_to_integer[char] = i;
+  integer_to_char[i] = char;
+});
+var decode = (string2) => {
+  let result = [];
+  let shift = 0;
+  let value = 0;
+  for (let i = 0; i < string2.length; i += 1) {
+    let integer = char_to_integer[string2[i]];
+    if (integer === void 0) {
+      throw new Error("Invalid character (" + string2[i] + ")");
+    }
+    const has_continuation_bit = integer & 32;
+    integer &= 31;
+    value += integer << shift;
+    if (has_continuation_bit) {
+      shift += 5;
+    } else {
+      const should_negate = value & 1;
+      value >>>= 1;
+      if (should_negate) {
+        result.push(value === 0 ? -2147483648 : -value);
+      } else {
+        result.push(value);
+      }
+      value = shift = 0;
+    }
+  }
+  return result;
+};
+
+// src/parts/SourceMap/SourceMap.js
+var getColumnMapping = (mappings, line, column) => {
+  string(mappings);
+  number(line);
+  number(column);
+  let currentColumn = 0;
+  let currentLine = 1;
+  let originalSourceFileIndex = 0;
+  let originalLine = 0;
+  let originalColumn = 0;
+  let index = 0;
+  while (index !== -1) {
+    currentColumn = 0;
+    const newLineIndex = mappings.indexOf(";", index + 1);
+    currentLine++;
+    if (currentLine === line) {
+      const lineMapping = mappings.slice(index + 1, newLineIndex) + ",";
+      index = -1;
+      while (true) {
+        const newIndex = lineMapping.indexOf(",", index + 1);
+        if (newIndex === -1) {
+          throw new Error("no mapping found");
+        }
+        const chunk = lineMapping.slice(index + 1, newIndex);
+        const decodedChunk = decode(chunk);
+        currentColumn += decodedChunk[0];
+        originalSourceFileIndex += decodedChunk[1];
+        originalLine += decodedChunk[2];
+        originalColumn += decodedChunk[3];
+        index = newIndex;
+        if (currentColumn >= column) {
+          return {
+            originalSourceFileIndex,
+            originalLine: originalLine + 1,
+            originalColumn
+          };
+        }
+      }
+    } else {
+      const lineMappings = mappings.slice(index + 1, newLineIndex);
+      if (isEmptyString(lineMappings)) {
+        index = newLineIndex;
+        continue;
+      }
+      const chunks = lineMappings.split(",");
+      for (const chunk of chunks) {
+        const decodedChunk = decode(chunk);
+        currentColumn += decodedChunk[0];
+        originalSourceFileIndex += decodedChunk[1];
+        originalLine += decodedChunk[2];
+        originalColumn += decodedChunk[3];
+      }
+    }
+    index = newLineIndex;
+  }
+  throw new Error(`no mapping found`);
+};
+var getOriginalPosition = (sourceMap, line, column) => {
+  try {
+    object(sourceMap);
+    string(sourceMap.mappings);
+    array(sourceMap.sources);
+    array(sourceMap.names);
+    number(line);
+    number(column);
+    const { sources, mappings } = sourceMap;
+    if (!mappings) {
+      throw new Error(`no source for line ${line} found`);
+    }
+    const { originalLine, originalColumn, originalSourceFileIndex } = getColumnMapping(mappings, line, column);
+    const source = sources[originalSourceFileIndex];
+    return {
+      source,
+      originalLine,
+      originalColumn
+    };
+  } catch (error2) {
+    throw new VError(error2, `Failed to get original sourcemap position`);
+  }
+};
+
+// src/parts/PrettyError/PrettyError.js
+var getErrorMessage = (error2) => {
+  if (!error2) {
+    return `Error: ${error2}`;
+  }
+  let message = error2.message;
+  while (error2.cause) {
+    error2 = error2.cause;
+    message += `: ${error2}`;
+  }
+  return message;
+};
+var prepareErrorMessageWithCodeFrame = (error2) => {
+  if (!error2) {
+    return {
+      message: error2,
+      stack: void 0,
+      codeFrame: void 0,
+      type: "Error",
+      _error: error2
+    };
+  }
+  const message = getErrorMessage(error2);
+  const lines = cleanStack(error2.stack);
+  const relevantStack = joinLines(lines);
+  if (error2.codeFrame) {
+    return {
+      message,
+      stack: relevantStack,
+      codeFrame: error2.codeFrame,
+      type: error2.constructor.name,
+      _error: error2
+    };
+  }
+  return {
+    message,
+    stack: error2.originalStack,
+    codeFrame: error2.originalCodeFrame,
+    category: error2.category,
+    stderr: error2.stderr,
+    _error: error2
+  };
+};
+var RE_PATH_12 = /\((.*):(\d+):(\d+)\)$/;
+var RE_PATH_22 = /at (.*):(\d+):(\d+)$/;
+var RE_PATH_32 = /@(.*):(\d+):(\d+)$/;
+var RE_SOURCE_MAP = /^\/\/# sourceMappingURL=(.*)$/;
+var getFile = (lines) => {
+  for (const line of lines) {
+    if (line.match(RE_PATH_12) || line.match(RE_PATH_22) || line.match(RE_PATH_32)) {
+      return line;
+    }
+  }
+  return "";
+};
+var getSourceMapAbsolutePath = (file, relativePath) => {
+  const folder = file.slice(0, file.lastIndexOf("/"));
+  const absolutePath = folder + "/" + relativePath;
+  return absolutePath;
+};
+var toAbsoluteUrl = (file, relativePath) => {
+  const url = new URL(relativePath, file);
+  return url.href;
+};
+var getSourceMapMatch = (text2) => {
+  string(text2);
+  const index = text2.lastIndexOf(NewLine, text2.length - 2);
+  const lastLine = text2.slice(index + 1, -1);
+  const lastLineMatch = lastLine.match(RE_SOURCE_MAP);
+  if (lastLineMatch) {
+    return lastLineMatch;
+  }
+  const secondLastLineIndex = getNewLineIndex(text2, index - 1);
+  const secondLastLine = text2.slice(secondLastLineIndex, index);
+  const secondLastLineMatch = secondLastLine.match(RE_SOURCE_MAP);
+  return secondLastLineMatch;
+};
+var prepareErrorMessageWithoutCodeFrame = async (error2) => {
+  try {
+    const lines = cleanStack(error2.stack);
+    const file = getFile(lines);
+    let match = file.match(RE_PATH_12);
+    if (!match) {
+      match = file.match(RE_PATH_22);
+    }
+    if (!match) {
+      match = file.match(RE_PATH_32);
+    }
+    if (!match) {
+      return error2;
+    }
+    const [_, path, line, column] = match;
+    if (!isActualSourceFile(path)) {
+      return error2;
+    }
+    const text2 = await getText2(path);
+    const sourceMapMatch = getSourceMapMatch(text2);
+    const parsedLine = parseInt(line);
+    const parsedColumn = parseInt(column);
+    const message = getErrorMessage(error2);
+    const relevantStack = joinLines(lines);
+    if (sourceMapMatch) {
+      const sourceMapUrl = sourceMapMatch[1];
+      const sourceMapAbsolutePath = getSourceMapAbsolutePath(path, sourceMapUrl);
+      const sourceMap = await getJson(sourceMapAbsolutePath);
+      const { source, originalLine, originalColumn } = getOriginalPosition(sourceMap, parsedLine, parsedColumn);
+      const absoluteSourceUrl = toAbsoluteUrl(path, source);
+      const originalSourceContent = await getText2(absoluteSourceUrl);
+      const codeFrame2 = create70(originalSourceContent, {
+        start: {
+          line: originalLine,
+          column: originalColumn
+        },
+        end: {
+          line: originalLine,
+          column: originalColumn
+        }
+      });
+      return {
+        message,
+        codeFrame: codeFrame2,
+        stack: relevantStack,
+        type: error2.constructor.name,
+        _error: error2
+      };
+    }
+    const codeFrame = create70(text2, {
+      start: {
+        line: parsedLine,
+        column: parsedColumn
+      },
+      end: {
+        line: parsedLine,
+        column: parsedColumn
+      }
+    });
+    return {
+      message,
+      codeFrame,
+      stack: relevantStack,
+      type: error2.constructor.name,
+      _error: error2
+    };
+  } catch (otherError) {
+    warn(`ErrorHandling Error: ${otherError}`);
+    return error2;
+  }
+};
+var prepare = async (error2) => {
+  if (error2 && error2.message && error2.codeFrame) {
+    return prepareErrorMessageWithCodeFrame(error2);
+  }
+  if (error2 && error2.stack) {
+    return prepareErrorMessageWithoutCodeFrame(error2);
+  }
+  return error2;
+};
+var print = (error2, prefix = "") => {
+  if (void 0) {
+    if (error2 && error2._error) {
+      error(`${prefix}${error2._error}`);
+      return;
+    }
+    error(`${prefix}${error2}`);
+    return;
+  }
+  if (error2 && error2.type && error2.message && error2.codeFrame) {
+    error(`${prefix}${error2.type}: ${error2.message}
+
+${error2.codeFrame}
+
+${error2.stack}`);
+    return;
+  }
+  if (error2 && error2.message && error2.codeFrame) {
+    error(`${prefix}${error2.message}
+
+${error2.codeFrame}
+
+${error2.stack}`);
+    return;
+  }
+  if (error2 && error2.type && error2.message) {
+    error(`${prefix}${error2.type}: ${error2.message}
+${error2.stack}`);
+    return;
+  }
+  if (error2 && error2.stack) {
+    error(`${prefix}${error2.stack}`);
+    return;
+  }
+  if (error2 === null) {
+    error(`${prefix}null`);
+    return;
+  }
+  error(`${prefix}${error2}`);
+};
+var getMessage = (error2) => {
+  if (error2 && error2.type && error2.message) {
+    return `${error2.type}: ${error2.message}`;
+  }
+  if (error2 && error2.message) {
+    return `${error2.constructor.name}: ${error2.message}`;
+  }
+  return `Error: ${error2}`;
+};
+
+// src/parts/ErrorHandling/ErrorHandling.js
+var logError = async (error2, prefix = "") => {
+  const prettyError = await prepare(error2);
+  print(prettyError, prefix);
+  return prettyError;
+};
+var handleError9 = async (error2, notify = true, prefix = "") => {
+  try {
+    const prettyError = await logError(error2, prefix);
+    if (notify) {
+      alert(getMessage(prettyError));
+    }
+  } catch (otherError) {
+    console.warn(`ErrorHandling error`);
+    console.warn(otherError);
+    console.error(error2);
+  }
+};
+
+// src/parts/IsChromeExtensionError/IsChromeExtensionError.js
+var isChromeExtensionError = (error2) => {
+  return `${error2}` === "Script error.";
+};
+
+// src/parts/UnhandledErrorHandling/UnhandledErrorHandling.js
+init_IsFirefoxWorkerError();
+var handleUnhandledRejection = (event) => {
+  event.preventDefault();
+  handleError9(event.reason, true, "[renderer process] Unhandled Rejection: ");
+};
+var handleUnhandledError = (message, filename, lineno, colno, error2) => {
+  if (isChromeExtensionError(message)) {
+    return;
+  }
+  if (isFirefoxWorkerError(message)) {
+    return;
+  }
+  handleError9(error2, true, "[renderer-process] Unhandled Error: ");
+};
+
+// src/rendererProcessMain.js
 var handleBeforeInstallPrompt = (event) => {
   preventDefault(event);
 };
 var main = async () => {
-  onerror = handleError;
+  onerror = handleUnhandledError;
   onunhandledrejection = handleUnhandledRejection;
   if ("SecurityPolicyViolationEvent" in self) {
     self.addEventListener("securitypolicyviolation", handleContentSecurityPolicyViolation);
@@ -29580,4 +30663,5 @@ export {
   send2 as send
 };
 /*! @license DOMPurify 3.0.1 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.0.1/LICENSE */
+/*! MIT License © Sindre Sorhus */
 //# sourceMappingURL=rendererProcessMain.js.map