@lvce-editor/server 0.15.21 → 0.15.22

package/static/387e82c/packages/renderer-process/src/parts/ErrorHandling/ErrorHandling.js

@@ -0,0 +1,27 @@
+import * as PrettyError from '../PrettyError/PrettyError.js'
+
+export const state = {
+  /**
+   * @type {string[]}
+   */
+  seenWarnings: [],
+}
+
+export const logError = async (error, prefix = '') => {
+  const prettyError = await PrettyError.prepare(error)
+  PrettyError.print(prettyError, prefix)
+  return prettyError
+}
+
+export const handleError = async (error, notify = true, prefix = '') => {
+  try {
+    const prettyError = await logError(error, prefix)
+    if (notify) {
+      alert(PrettyError.getMessage(prettyError))
+    }
+  } catch (otherError) {
+    console.warn(`ErrorHandling error`)
+    console.warn(otherError)
+    console.error(error)
+  }
+}

package/static/387e82c/packages/renderer-process/src/parts/HandleIpc/HandleIpc.js

@@ -0,0 +1,12 @@
+import * as Assert from '../Assert/Assert.js'
+import * as Callback from '../Callback/Callback.js'
+import * as Command from '../Command/Command.js'
+import * as HandleJsonRpcMessage from '../HandleJsonRpcMessage/HandleJsonRpcMessage.js'
+
+export const handleIpc = (ipc) => {
+  Assert.object(ipc)
+  const handleMessage = (message) => {
+    return HandleJsonRpcMessage.handleJsonRpcMessage(ipc, message, Command.execute, Callback.resolve)
+  }
+  ipc.onmessage = handleMessage
+}

package/static/387e82c/packages/renderer-process/src/parts/HandleJsonRpcMessage/HandleJsonRpcMessage.js

@@ -0,0 +1,27 @@
+import * as GetResponse from '../GetResponse/GetResponse.js'
+import * as HasTransferableResult from '../HasTransferableResult/HasTransferableResult.js'
+import { JsonRpcError } from '../JsonRpcError/JsonRpcError.js'
+
+export const handleJsonRpcMessage = async (ipc, message, execute, resolve) => {
+  // TODO adjust ipc implementation so that message is always a message
+  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.getResponse(message, execute)
+      if (HasTransferableResult.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')
+}

package/static/{94c91f4 → 387e82c}/packages/renderer-process/src/parts/IpcParentWithElectron/IpcParentWithElectron.js

@@ -10,13 +10,13 @@ const handleMessageFromWindow = (event) => {
 // @ts-ignore
 window.addEventListener('message', handleMessageFromWindow)
 
-export const create = async ({ type }) => {
+export const create = async ({ type, name }) => {
   const { id, promise } = Callback.registerPromise()
   const message = {
     jsonrpc: JsonRpcVersion.Two,
     id,
     method: 'CreateMessagePort.createMessagePort',
-    params: [type],
+    params: [type, name],
   }
   // @ts-ignore
   if (typeof window.myApi === 'undefined') {

package/static/{94c91f4 → 387e82c}/packages/renderer-process/src/parts/Platform/Platform.js

@@ -29,9 +29,9 @@ export const platform = getPlatform()
 export const state = {
   getAssetDir() {
     // @ts-ignore
-    if (typeof '/94c91f4' !== 'undefined') {
+    if (typeof '/387e82c' !== 'undefined') {
       // @ts-ignore
-      return '/94c91f4'
+      return '/387e82c'
     }
     if (platform === 'electron') {
       return '../../../../..'

package/static/387e82c/packages/renderer-process/src/parts/UnhandledErrorHandling/UnhandledErrorHandling.js

@@ -0,0 +1,20 @@
+import * as ErrorHandling from '../ErrorHandling/ErrorHandling.js'
+import * as IsChromeExtensionError from '../IsChromeExtensionError/IsChromeExtensionError.js'
+import * as IsFirefoxWorkerError from '../IsFirefoxWorkerError/IsFirefoxWorkerError.js'
+
+export const handleUnhandledRejection = (event) => {
+  event.preventDefault()
+  ErrorHandling.handleError(event.reason, true, '[renderer process] Unhandled Rejection: ')
+}
+
+export const handleUnhandledError = (message, filename, lineno, colno, error) => {
+  if (IsChromeExtensionError.isChromeExtensionError(message)) {
+    // ignore errors from chrome extensions
+    return
+  }
+  if (IsFirefoxWorkerError.isFirefoxWorkerError(message)) {
+    // ignore firefox worker errors
+    return
+  }
+  ErrorHandling.handleError(error, true, '[renderer-process] Unhandled Error: ')
+}

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

@@ -1,19 +1,19 @@
 import * as Command from './parts/Command/Command.js'
-import * as ErrorHandling from './parts/ErrorHandling/ErrorHandling.js'
 import * as Event from './parts/Event/Event.js'
 import * as HandleContentSecurityPolicyViolation from './parts/HandleContentSecurityPolicyViolation/HandleContentSecurityPolicyViolation.js'
 import * as Module from './parts/Module/Module.js'
 import * as Platform from './parts/Platform/Platform.js'
 import * as PlatformType from './parts/PlatformType/PlatformType.js'
 import * as RendererWorker from './parts/RendererWorker/RendererWorker.js'
+import * as UnhandledErrorHandling from './parts/UnhandledErrorHandling/UnhandledErrorHandling.js'
 
 const handleBeforeInstallPrompt = (event) => {
   Event.preventDefault(event)
 }
 
 const main = async () => {
-  onerror = ErrorHandling.handleError
-  onunhandledrejection = ErrorHandling.handleUnhandledRejection
+  onerror = UnhandledErrorHandling.handleUnhandledError
+  onunhandledrejection = UnhandledErrorHandling.handleUnhandledRejection
   if ('SecurityPolicyViolationEvent' in self) {
     self.addEventListener('securitypolicyviolation', HandleContentSecurityPolicyViolation.handleContentSecurityPolicyViolation)
   }

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

@@ -888,6 +888,44 @@ var init_JsonRpc = __esm({
   }
 });
 
+// src/parts/HandleJsonRpcMessage/HandleJsonRpcMessage.js
+var handleJsonRpcMessage;
+var init_HandleJsonRpcMessage = __esm({
+  "src/parts/HandleJsonRpcMessage/HandleJsonRpcMessage.js"() {
+    "use strict";
+    init_JsonRpcVersion();
+    handleJsonRpcMessage = async (ipc4, message, execute7, resolve2, source) => {
+      if (typeof message === "string") {
+        console.warn(`unexpected message from ${source}: ${message}`);
+        return;
+      }
+      if (message.id) {
+        if ("method" in message) {
+          try {
+            const result = await execute7(message.method, ...message.params);
+            ipc4.send({
+              jsonrpc: Two,
+              id: message.id,
+              result
+            });
+            return;
+          } catch (error2) {
+            ipc4.send({
+              jsonrpc: Two,
+              id: message.id,
+              error: error2
+            });
+            return;
+          }
+        }
+        resolve2(message.id, message);
+        return;
+      }
+      await execute7(message.method, ...message.params);
+    };
+  }
+});
+
 // src/parts/HandleIpc/HandleIpc.js
 var handleIpc;
 var init_HandleIpc = __esm({
@@ -895,36 +933,10 @@ var init_HandleIpc = __esm({
     "use strict";
     init_Callback();
     init_Command();
-    init_JsonRpcVersion();
+    init_HandleJsonRpcMessage();
     handleIpc = (ipc4, source = "process") => {
-      const handleMessageFromRendererProcess = async (message) => {
-        if (typeof message === "string") {
-          console.warn(`unexpected message from ${source}: ${message}`);
-          return;
-        }
-        if (message.id) {
-          if ("method" in message) {
-            try {
-              const result = await execute(message.method, ...message.params);
-              ipc4.send({
-                jsonrpc: Two,
-                id: message.id,
-                result
-              });
-              return;
-            } catch (error2) {
-              ipc4.send({
-                jsonrpc: Two,
-                id: message.id,
-                error: error2
-              });
-              return;
-            }
-          }
-          resolve(message.id, message);
-          return;
-        }
-        await execute(message.method, ...message.params);
+      const handleMessageFromRendererProcess = (message) => {
+        return handleJsonRpcMessage(ipc4, message, execute, resolve, source);
       };
       ipc4.onmessage = handleMessageFromRendererProcess;
     };
@@ -1167,17 +1179,20 @@ var init_IpcParentWithElectron = __esm({
     init_Assert();
     init_RendererProcess();
     init_RendererProcessIpcParentType();
-    getPort = async (type3) => {
+    getPort = async (type3, name122) => {
       const port = await invoke2("IpcParent.create", {
         method: Electron,
-        type: type3
+        type: type3,
+        name: name122
       });
       return port;
     };
     create2 = async (options2) => {
       const type3 = options2.type;
+      const name122 = options2.name || "electron ipc";
       string(type3);
-      const port = await getPort(type3);
+      string(name122);
+      const port = await getPort(type3, name122);
       return port;
     };
     wrap4 = (port) => {
@@ -2047,7 +2062,7 @@ var init_Platform = __esm({
     platform2 = "remote";
     getAssetDir = () => {
       if (true) {
-        return "/94c91f4";
+        return "/387e82c";
       }
       if (platform2 === Electron2) {
         return "../../../../..";
@@ -2774,7 +2789,7 @@ var init_Ajax = __esm({
 });
 
 // src/parts/CleanStack/CleanStack.js
-var RE_AT, RE_AT_PROMISE_INDEX, RE_OBJECT_AS, RE_OBJECT, RE_PATH_1, RE_PATH_2, RE_PATH_3, RE_RESTORE_JSON_RPC_ERROR, RE_UNWRAP_JSON_RPC_RESULT, RE_JSON_RPC_INVOKE, RE_ASSERT, RE_CONSTRUCT_ERROR, isInternalLine, isRelevantLine, isNormalStackLine, isApplicationUsefulLine, cleanLine, getDetails, mergeCustom, cleanStack;
+var RE_AT, RE_AT_PROMISE_INDEX, RE_OBJECT_AS, RE_OBJECT, RE_PATH_1, RE_PATH_2, RE_PATH_3, RE_RESTORE_JSON_RPC_ERROR, RE_UNWRAP_JSON_RPC_RESULT, RE_GET_RESPONSE, RE_JSON_RPC_INVOKE, RE_ASSERT, RE_CONSTRUCT_ERROR, isInternalLine, isRelevantLine, isNormalStackLine, isApplicationUsefulLine, cleanLine, getDetails, mergeCustom, cleanStack;
 var init_CleanStack = __esm({
   "src/parts/CleanStack/CleanStack.js"() {
     "use strict";
@@ -2789,6 +2804,7 @@ var init_CleanStack = __esm({
     RE_PATH_3 = /@(.*):(\d+):(\d+)$/;
     RE_RESTORE_JSON_RPC_ERROR = /^\s*at restoreJsonRpcError/;
     RE_UNWRAP_JSON_RPC_RESULT = /^\s*at unwrapJsonRpcResult/;
+    RE_GET_RESPONSE = /^\s*at getResponse/;
     RE_JSON_RPC_INVOKE = /^\s*at invoke .*JsonRpc\.js/;
     RE_ASSERT = /^\s*at .*\/Assert\.js/;
     RE_CONSTRUCT_ERROR = /^\s*at constructError /;
@@ -2808,7 +2824,7 @@ var init_CleanStack = __esm({
         }
         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)) {
+      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) || RE_GET_RESPONSE.test(line)) {
         return false;
       }
       return true;
@@ -3341,7 +3357,7 @@ ${error2.stack}`);
 });
 
 // src/parts/ErrorHandling/ErrorHandling.js
-var state8, logError, handleError, showErrorDialog, warn2, handleUnhandledRejection, handleUnhandledError;
+var state8, logError, handleError, showErrorDialog, warn2;
 var init_ErrorHandling = __esm({
   "src/parts/ErrorHandling/ErrorHandling.js"() {
     "use strict";
@@ -3397,14 +3413,6 @@ var init_ErrorHandling = __esm({
       state8.seenWarnings.push(stringified);
       console.warn(...args);
     };
-    handleUnhandledRejection = (event) => {
-      event.preventDefault();
-      handleError(event.reason, false, "[renderer-worker] Unhandled Rejection: ");
-    };
-    handleUnhandledError = (message, filename, lineno, colno, error2) => {
-      handleError(error2, false, "[renderer-worker] Unhandled Error: ");
-      return true;
-    };
   }
 });
 
@@ -4962,7 +4970,7 @@ var init_Workspace = __esm({
       return path.slice(path.lastIndexOf("/") + 1);
     };
     pathDirName = (path) => {
-      const pathSeparator2 = state15.pathSeparator;
+      const pathSeparator2 = state15.pathSeparator || "/";
       const index = path.lastIndexOf(pathSeparator2);
       if (index === -1) {
         return EmptyString;
@@ -5773,7 +5781,7 @@ var init_FileSystemAppShared = __esm({
             await writeFile4(path, defaultContent2);
             return defaultContent2;
           } catch (error3) {
-            throw new VError(error3, `Failed to read ${path} `);
+            throw new VError(error3, `Failed to write ${path} `);
           }
         }
         throw new VError(error2, `Failed to read ${path}`);
@@ -8314,6 +8322,7 @@ var init_ViewletManager = __esm({
     init_Css();
     init_CancelationError();
     init_GlobalEventBus();
+    init_Id();
     init_NameAnonymousFunction();
     init_Preferences();
     init_PrettyError();
@@ -8321,7 +8330,6 @@ var init_ViewletManager = __esm({
     init_SaveState();
     init_ViewletModuleId();
     init_ViewletStates();
-    init_Id();
     state29 = {
       pendingModules: /* @__PURE__ */ Object.create(null)
     };
@@ -22995,6 +23003,8 @@ var init_ExtensionManagement = __esm({
     init_ExtensionManifestStatus();
     init_InstallExtension();
     init_SharedProcess();
+    init_Platform();
+    init_PlatformType();
     install2 = (id) => {
       return install(id);
     };
@@ -23023,6 +23033,9 @@ var init_ExtensionManagement = __esm({
       );
     };
     getAllExtensions = async () => {
+      if (platform2 === Web) {
+        return [];
+      }
       return invoke3(
         /* ExtensionManagement.getAllExtensions */
         "ExtensionManagement.getAllExtensions"
@@ -36788,13 +36801,20 @@ var init_ViewletSideBar = __esm({
       const { titleAreaHeight } = state60;
       const childDimensions = getContentDimensions2(dimensions, titleAreaHeight);
       const currentViewletInstance = getInstance(state60.currentViewletId);
+      const newState = {
+        ...state60,
+        ...dimensions
+      };
+      if (!currentViewletInstance) {
+        return {
+          newState,
+          commands: []
+        };
+      }
       const currentViewletUid = currentViewletInstance.state.uid;
       const commands = resize7(currentViewletUid, childDimensions);
       return {
-        newState: {
-          ...state60,
-          ...dimensions
-        },
+        newState,
         commands
       };
     };
@@ -38964,12 +38984,7 @@ var init_ElectronContextMenu = __esm({
       const entries = await getMenuEntries25(id, ...args);
       state47.pendingMenus = entries;
       const electronMenuItems = convertMenuItems(entries);
-      return invoke4(
-        "ElectronContextMenu.openContextMenu",
-        electronMenuItems,
-        x2,
-        y2
-      );
+      return invoke4("ElectronContextMenu.openContextMenu", electronMenuItems, x2, y2);
     };
     handleMenuClose = () => {
       state47.pendingMenus = EMPTY_MENU;
@@ -53781,13 +53796,13 @@ var init_babel_parser = __esm({
           }
           return super.getExpression();
         }
-        parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly) {
-          if (!isString && isMaybeTypeOnly) {
+        parseExportSpecifier(node, isString2, isInTypeExport, isMaybeTypeOnly) {
+          if (!isString2 && isMaybeTypeOnly) {
             this.parseTypeOnlyImportExportSpecifier(node, false, isInTypeExport);
             return this.finishNode(node, "ExportSpecifier");
           }
           node.exportKind = "value";
-          return super.parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly);
+          return super.parseExportSpecifier(node, isString2, isInTypeExport, isMaybeTypeOnly);
         }
         parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
           if (!importedIsString && isMaybeTypeOnly) {
@@ -57675,17 +57690,17 @@ var init_babel_parser = __esm({
                 break;
             }
             const isMaybeTypeOnly = this.isContextual(128);
-            const isString = this.match(131);
+            const isString2 = this.match(131);
             const node = this.startNode();
             node.local = this.parseModuleExportName();
-            nodes.push(this.parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly));
+            nodes.push(this.parseExportSpecifier(node, isString2, isInTypeExport, isMaybeTypeOnly));
           }
           return nodes;
         }
-        parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly) {
+        parseExportSpecifier(node, isString2, isInTypeExport, isMaybeTypeOnly) {
           if (this.eatContextual(93)) {
             node.exported = this.parseModuleExportName();
-          } else if (isString) {
+          } else if (isString2) {
             node.exported = cloneStringLiteral(node.local);
           } else if (!node.exported) {
             node.exported = cloneIdentifier(node.local);
@@ -62914,20 +62929,32 @@ var init_Preferences_ipc = __esm({
   }
 });
 
-// src/parts/RecentlyOpened/RecentlyOpened.js
-var isValid2, getRecentlyOpened3, setRecentlyOpened, clearRecentlyOpened, getNewRecentlyOpened, addToRecentlyOpenedWeb, addToRecentlyOpenedRemote, addToRecentlyOpened, addWorkspacePathToRecentlyOpened, hydrate12;
-var init_RecentlyOpened = __esm({
-  "src/parts/RecentlyOpened/RecentlyOpened.js"() {
+// src/parts/IsString/IsString.js
+var isString;
+var init_IsString = __esm({
+  "src/parts/IsString/IsString.js"() {
+    "use strict";
+    isString = (value) => {
+      return typeof value === "string";
+    };
+  }
+});
+
+// src/parts/GetRecentlyOpened/GetRecentlyOpened.js
+var isValid2, getRecentlyOpened3;
+var init_GetRecentlyOpened = __esm({
+  "src/parts/GetRecentlyOpened/GetRecentlyOpened.js"() {
     "use strict";
     init_FileSystem();
-    init_GlobalEventBus();
+    init_IsString();
     init_Json();
-    init_Workspace();
-    init_Platform();
-    init_SharedProcess();
-    init_SharedProcessCommandType();
+    init_Logger();
+    init_VError();
     isValid2 = (recentlyOpened) => {
-      return recentlyOpened && Array.isArray(recentlyOpened);
+      if (!recentlyOpened || !Array.isArray(recentlyOpened)) {
+        return [];
+      }
+      return recentlyOpened && Array.isArray(recentlyOpened) && recentlyOpened.every(isString);
     };
     getRecentlyOpened3 = async () => {
       try {
@@ -62938,15 +62965,33 @@ var init_RecentlyOpened = __esm({
         }
         return parsed;
       } catch (error2) {
-        if (error2.message.includes("File not found")) {
-        } else if (error2.message.includes("failed to parse json")) {
+        if (error2 && error2 instanceof Error && error2.message.includes("File not found")) {
+        } else if (error2 && error2 instanceof Error && error2.message.includes("failed to parse json")) {
         } else {
-          error2.message = `Failed to read recently opened: ${error2.message}`;
-          console.warn(error2);
+          const vError = new VError(error2, `Failed to read recently opened`);
+          warn(vError);
         }
         return [];
       }
     };
+  }
+});
+
+// src/parts/RecentlyOpened/RecentlyOpened.js
+var getRecentlyOpened4, setRecentlyOpened, clearRecentlyOpened, getNewRecentlyOpened, addToRecentlyOpenedWeb, addToRecentlyOpenedRemote, addToRecentlyOpened, addWorkspacePathToRecentlyOpened, hydrate12;
+var init_RecentlyOpened = __esm({
+  "src/parts/RecentlyOpened/RecentlyOpened.js"() {
+    "use strict";
+    init_FileSystem();
+    init_GetRecentlyOpened();
+    init_GlobalEventBus();
+    init_Json();
+    init_Platform();
+    init_SharedProcess();
+    init_SharedProcessCommandType();
+    init_Workspace();
+    init_PlatformType();
+    getRecentlyOpened4 = getRecentlyOpened3;
     setRecentlyOpened = async (newRecentlyOpened) => {
       const stringified = stringify(newRecentlyOpened);
       await writeFile4("app://recently-opened.json", stringified);
@@ -62962,7 +63007,7 @@ var init_RecentlyOpened = __esm({
       return [path, ...recentlyOpened.slice(0, index), ...recentlyOpened.slice(index + 1)];
     };
     addToRecentlyOpenedWeb = async (path) => {
-      const recentlyOpened = await getRecentlyOpened3();
+      const recentlyOpened = await getRecentlyOpened4();
       const newRecentlyOpened = getNewRecentlyOpened(recentlyOpened, path);
       await setRecentlyOpened(newRecentlyOpened);
     };
@@ -62971,10 +63016,10 @@ var init_RecentlyOpened = __esm({
     };
     addToRecentlyOpened = async (path) => {
       switch (platform2) {
-        case "electron":
-        case "remote":
+        case Electron2:
+        case Remote:
           return addToRecentlyOpenedRemote(path);
-        case "web":
+        case Web:
           return addToRecentlyOpenedWeb(path);
         default:
           return;
@@ -63012,7 +63057,7 @@ var init_RecentlyOpened_ipc = __esm({
     Commands93 = {
       addToRecentlyOpened,
       clearRecentlyOpened,
-      getRecentlyOpened: getRecentlyOpened3,
+      getRecentlyOpened: getRecentlyOpened4,
       hydrate: hydrate12
     };
   }
@@ -63217,7 +63262,7 @@ var init_TestType = __esm({
 });
 
 // src/parts/ExecuteTest/ExecuteTest.js
-var printError, stringifyError2, executeTest;
+var printError, stringifyError2, formatDuration, executeTest;
 var init_ExecuteTest = __esm({
   "src/parts/ExecuteTest/ExecuteTest.js"() {
     "use strict";
@@ -63241,17 +63286,22 @@ var init_ExecuteTest = __esm({
       }
       return `${error2.message}`;
     };
+    formatDuration = (duration) => {
+      return duration.toFixed(2) + "ms";
+    };
     executeTest = async (name122, fn2, globals = {}) => {
       let _error;
       let _start;
       let _end;
       let _duration;
+      let _formattedDuration;
       try {
         _start = now();
         await fn2(globals);
         _end = now();
-        _duration = `${_end - _start}ms`;
-        console.info(`[test passed] ${name122} in ${_duration}`);
+        _duration = _end - _start;
+        _formattedDuration = formatDuration(_duration);
+        console.info(`PASS ${name122} in ${_formattedDuration}`);
       } catch (error2) {
         if (error2 && // @ts-ignore
         error2.message.startsWith(`Failed to load command TestFrameWork.`)) {
@@ -63271,7 +63321,7 @@ var init_ExecuteTest = __esm({
         text2 = `test failed: ${_error}`;
       } else {
         background = "green";
-        text2 = `test passed in ${_duration}`;
+        text2 = `test passed in ${_formattedDuration}`;
         state60 = Pass;
       }
       await invoke2("TestFrameWork.showOverlay", state60, background, text2);
@@ -64711,6 +64761,23 @@ var init_PerformanceMarkerType = __esm({
   }
 });
 
+// src/parts/UnhandledErrorHandling/UnhandledErrorHandling.js
+var handleUnhandledRejection, handleUnhandledError;
+var init_UnhandledErrorHandling = __esm({
+  "src/parts/UnhandledErrorHandling/UnhandledErrorHandling.js"() {
+    "use strict";
+    init_ErrorHandling();
+    handleUnhandledRejection = (event) => {
+      event.preventDefault();
+      handleError(event.reason, false, "[renderer-worker] Unhandled Rejection: ");
+    };
+    handleUnhandledError = (message, filename, lineno, colno, error2) => {
+      handleError(error2, false, "[renderer-worker] Unhandled Error: ");
+      return true;
+    };
+  }
+});
+
 // src/parts/Workbench/Workbench.js
 var startup;
 var init_Workbench = __esm({
@@ -64718,7 +64785,6 @@ var init_Workbench = __esm({
     "use strict";
     init_ColorTheme();
     init_Command();
-    init_ErrorHandling();
     init_IconTheme();
     init_Id();
     init_InitData();
@@ -64738,6 +64804,7 @@ var init_Workbench = __esm({
     init_ServiceWorker();
     init_SessionReplay();
     init_SharedProcess();
+    init_UnhandledErrorHandling();
     init_ViewletManager();
     init_ViewletModule();
     init_ViewletModuleId();