@lvce-editor/main-process 2.28.0 → 2.30.0

package/dist/mainProcessMain.js

@@ -11,8 +11,8 @@ import { dirname } from 'node:path';
 import require$$1 from 'tty';
 import require$$1$1 from 'util';
 import require$$0 from 'os';
-import { Console } from 'node:console';
 import { tmpdir, homedir } from 'node:os';
+import { Console } from 'node:console';
 
 function escapeStringRegexp(string) {
   if (typeof string !== 'string') {
@@ -3287,11 +3287,11 @@ const mark = key => {
 };
 const toUiEntry = performanceEntry => {
   return {
-    name: performanceEntry.name,
-    entryType: performanceEntry.entryType,
-    startTime: performanceEntry.startTime,
+    detail: performanceEntry.detail,
     duration: performanceEntry.duration,
-    detail: performanceEntry.detail
+    entryType: performanceEntry.entryType,
+    name: performanceEntry.name,
+    startTime: performanceEntry.startTime
   };
 };
 const getEntries = () => {
@@ -3367,8 +3367,8 @@ const handleChildDisconnect = () => {
   info('[main process] shared process disconnected');
 };
 const launchSharedProcess = async ({
-  method,
-  env = {}
+  env = {},
+  method
 }) => {
   mark(WillStartSharedProcess);
   const sharedProcessPath = getSharedProcessPath();
@@ -3378,12 +3378,12 @@ const launchSharedProcess = async ({
     ...env
   };
   const sharedProcessRpc = await ElectronUtilityProcessRpcParent.create({
-    env: fullEnv,
     argv: [],
+    commandMap: commandMapRef,
+    env: fullEnv,
     execArgv,
-    path: sharedProcessPath,
     name: 'shared-process',
-    commandMap: commandMapRef,
+    path: sharedProcessPath,
     // @ts-ignore
     requiresSocket: requiresSocket
   });
@@ -3408,8 +3408,8 @@ const launchSharedProcess = async ({
   await sharedProcessRpc.invokeAndTransfer('HandleElectronMessagePort.handleElectronMessagePort', port2, MainProcess);
   await ElectronMessagePortRpcClient.create({
     commandMap: commandMapRef,
-    requiresSocket: requiresSocket,
-    messagePort: port1
+    messagePort: port1,
+    requiresSocket: requiresSocket
   });
   mark(DidStartSharedProcess);
   return sharedProcessRpc;
@@ -3423,14 +3423,14 @@ const state$6 = {
 };
 
 const getOrCreate = async ({
-  method,
-  env = {}
+  env = {},
+  method
 }) => {
   if (!state$6.promise) {
     // @ts-ignore
     state$6.promise = launchSharedProcess({
-      method,
-      env
+      env,
+      method
     });
   }
   return state$6.promise;
@@ -4811,10 +4811,10 @@ const minimist = /*@__PURE__*/getDefaultExportFromCjs(minimistExports);
 
 const parseCliArgs = argv => {
   const CLI_OPTIONS = {
-    boolean: [Version, Help, Wait, BuiltinSelfTest, Web, SandBox],
     alias: {
       version: 'v'
     },
+    boolean: [Version, Help, Wait, BuiltinSelfTest, Web, SandBox],
     default: {
       sandbox: false
     }
@@ -4869,9 +4869,9 @@ const Allow = 'allow';
 const Deny = 'deny';
 
 const state$4 = {
-  views: Object.create(null),
+  canceled: Object.create(null),
   fallThroughKeyBindings: [],
-  canceled: Object.create(null)
+  views: Object.create(null)
 };
 const add$1 = (id, browserWindow, view) => {
   // state
@@ -4959,23 +4959,23 @@ const isProtocolHandleApiSupported = protocol => {
 const WebView = 'lvce-oss-webview';
 
 const privilegedSchems = [{
-  scheme: scheme,
   privileges: {
-    standard: true,
+    codeCache: true,
     secure: true,
-    supportFetchAPI: true,
+    standard: true,
     stream: true,
-    codeCache: true
-  }
+    supportFetchAPI: true
+  },
+  scheme: scheme
 }, {
-  scheme: WebView,
   privileges: {
-    standard: true,
+    codeCache: true,
     secure: true,
-    supportFetchAPI: true,
+    standard: true,
     stream: true,
-    codeCache: true
-  }
+    supportFetchAPI: true
+  },
+  scheme: WebView
 }];
 
 const handle = (protocol, name, handleRequest) => {
@@ -5001,8 +5001,9 @@ const requestSingleInstanceLock = argv => {
 const hydrate = async () => {
   setMenu(null); // performance
   unhandled({
-    showDialog: true,
-    logger() {} // already exists in mainProcessMain.js
+    logger() {},
+    // already exists in mainProcessMain.js
+    showDialog: true
   });
 
   // TODO electron error ERROR:sandbox_linux.cc(364)] InitializeSandbox() called with multiple threads in process gpu-process
@@ -5115,83 +5116,83 @@ const getPrefix = commandId => {
 const getModuleId = commandId => {
   const prefix = getPrefix(commandId);
   switch (prefix) {
-    case 'Crash':
-      return Crash;
-    case 'ElectronApp':
     case 'App':
+    case 'ElectronApp':
       return App;
-    case 'Beep':
-      return Beep;
-    case 'ElectronWindow':
-      return Window;
-    case 'ElectronDeveloper':
-      return Developer;
     case 'AppWindow':
       return AppWindow;
-    case 'ElectronWindowProcessExplorer':
-      return ElectronWindowProcessExplorer;
-    case 'ElectronDialog':
-      return Dialog;
+    case 'Beep':
+      return Beep;
+    case 'Crash':
+      return Crash;
+    case 'CreateMessagePort':
+      return CreateMessagePort;
+    case 'CreatePidMap':
+      return CreatePidMap;
+    case 'DesktopCapturer':
+      return DesktopCapturer;
+    case 'ElectronApplicationMenu':
+      return ElectronApplicationMenu;
     case 'ElectronBeep':
       return Beep;
-    case 'ElectronShell':
-      return ElectronShell;
-    case 'ElectronPowerSaveBlocker':
-      return ElectronPowerSaveBlocker;
-    case 'ElectronSafeStorage':
-      return ElectronSafeStorage;
-    case 'ElectronContentTracing':
-      return ElectronContentTracing;
-    case 'ElectronNetLog':
-      return ElectronNetLog;
     case 'ElectronBrowserView':
       return ElectronBrowserView;
     case 'ElectronBrowserViewQuickPick':
       return ElectronBrowserViewQuickPick;
-    case 'ElectronContextMenu':
-      return ElectronContextMenu;
+    case 'ElectronBrowserViewSuggestions':
+      return ElectronBrowserViewSuggestions;
     case 'ElectronClipBoard':
       return ElectronClipBoard;
-    case 'ElectronApplicationMenu':
-      return ElectronApplicationMenu;
-    case 'Process':
-      return Process;
+    case 'ElectronContentTracing':
+      return ElectronContentTracing;
+    case 'ElectronContextMenu':
+      return ElectronContextMenu;
+    case 'ElectronDeveloper':
+      return Developer;
+    case 'ElectronDialog':
+      return Dialog;
     case 'ElectronNet':
       return ElectronNet;
-    case 'ElectronBrowserViewSuggestions':
-      return ElectronBrowserViewSuggestions;
-    case 'CreatePidMap':
-      return CreatePidMap;
-    case 'OpenExternal':
-      return OpenExternal$1;
-    case 'Platform':
-      return Platform;
-    case 'GetWindowId':
-      return GetWindowId;
-    case 'DesktopCapturer':
-      return DesktopCapturer;
-    case 'Trash':
-      return Trash;
-    case 'IpcParent':
-      return IpcParent;
-    case 'Exit':
-      return Exit;
+    case 'ElectronNetLog':
+      return ElectronNetLog;
+    case 'ElectronPowerSaveBlocker':
+      return ElectronPowerSaveBlocker;
+    case 'ElectronSafeStorage':
+      return ElectronSafeStorage;
     case 'ElectronScreen':
       return ElectronScreen;
-    case 'TemporaryMessagePort':
-      return TemporaryMessagePort;
+    case 'ElectronSession':
+      return ElectronSession;
+    case 'ElectronShell':
+      return ElectronShell;
     case 'ElectronWebContents':
       return ElectronWebContents;
     case 'ElectronWebContentsView':
       return ElectronWebContentsView;
     case 'ElectronWebContentsViewFunctions':
       return ElectronWebContentsViewFunctions;
-    case 'CreateMessagePort':
-      return CreateMessagePort;
+    case 'ElectronWindow':
+      return Window;
+    case 'ElectronWindowProcessExplorer':
+      return ElectronWindowProcessExplorer;
+    case 'Exit':
+      return Exit;
+    case 'GetWindowId':
+      return GetWindowId;
     case 'HandleElectronMessagePort':
       return HandleElectronMessagePort;
-    case 'ElectronSession':
-      return ElectronSession;
+    case 'IpcParent':
+      return IpcParent;
+    case 'OpenExternal':
+      return OpenExternal$1;
+    case 'Platform':
+      return Platform;
+    case 'Process':
+      return Process;
+    case 'TemporaryMessagePort':
+      return TemporaryMessagePort;
+    case 'Trash':
+      return Trash;
     default:
       throw new CommandNotFoundError(commandId);
   }
@@ -5199,8 +5200,8 @@ const getModuleId = commandId => {
 
 const state$3 = {
   commands: Object.create(null),
-  pendingModules: Object.create(null),
-  async load(moduleId) {}
+  async load(moduleId) {},
+  pendingModules: Object.create(null)
 };
 const initializeModule = module => {
   if (module.Commands) {
@@ -5263,9 +5264,9 @@ const isAllowedPermission$1 = permission => {
     case ClipBoardRead:
     case ClipBoardSanitizedWrite:
     case FullScreen:
-    case WindowPlacement:
     case Media:
     case OpenExternal:
+    case WindowPlacement:
       return true;
     default:
       return false;
@@ -5311,8 +5312,8 @@ const serializeRequestHeaders = headers => {
  */
 const serializeRequest = request => {
   return {
-    url: request.url,
-    headers: serializeRequestHeaders(request.headers)
+    headers: serializeRequestHeaders(request.headers),
+    url: request.url
   };
 };
 
@@ -5461,8 +5462,8 @@ const createAppWindow = async (windowOptions, parsedArgs, workingDirectory, titl
   };
   window.on('close', handleWindowClose);
   await ElectronWebContentsRpcClient.create({
-    webContents: window.webContents,
-    commandMap: commandMapRef
+    commandMap: commandMapRef,
+    webContents: window.webContents
   });
   await loadUrl(window, url);
 };
@@ -5523,10 +5524,10 @@ const ElectronMessagePort = 4;
 
 const getModule$2 = method => {
   switch (method) {
-    case NodeWorker:
-      return connectIpc$1;
     case ElectronUtilityProcess:
       return connectIpc$2;
+    case NodeWorker:
+      return connectIpc$1;
     default:
       throw new Error('unexpected ipc type');
   }
@@ -5551,10 +5552,10 @@ const connectIpc = async (method, rpc, browserWindowPort, ipcId) => {
 const handlePort = async (browserWindowPort, ipcId) => {
   const method = ElectronUtilityProcess;
   const sharedProcess = await getOrCreate({
-    method,
     env: {
       FOLDER: ''
-    }
+    },
+    method
   });
   await connectIpc(method, sharedProcess, browserWindowPort, ipcId);
 };
@@ -5576,8 +5577,8 @@ const add = (pid, process, name) => {
   object(process);
   string(name);
   state$1.all[pid] = {
-    process,
-    name
+    name,
+    process
   };
 };
 const remove = pid => {
@@ -5794,14 +5795,14 @@ const showOpenDialog = async (title, properties) => {
  * @returns
  */
 const showMessageBox = async ({
-  message,
   buttons,
-  type = Error$1,
+  defaultId,
   detail,
-  title,
-  windowId = -1,
+  message,
   productName,
-  defaultId
+  title,
+  type = Error$1,
+  windowId = -1
 }) => {
   string(message);
   array(buttons);
@@ -5816,15 +5817,15 @@ const showMessageBox = async ({
     message = message.message;
   }
   const result = await Electron.dialog.showMessageBox(window, {
-    // @ts-ignore
-    type,
-    message,
-    title: title || productName,
     buttons,
     cancelId: 1,
+    defaultId,
     detail,
+    message,
     noLink: true,
-    defaultId
+    title: title || productName,
+    // @ts-ignore
+    type
   });
   const selectedButtonIndex = result.response;
   return selectedButtonIndex;
@@ -5899,8 +5900,8 @@ const getHeight = () => {
 const getBounds = () => {
   const primaryDisplay = screen.getPrimaryDisplay();
   return {
-    width: primaryDisplay.bounds.width,
-    height: primaryDisplay.bounds.height
+    height: primaryDisplay.bounds.height,
+    width: primaryDisplay.bounds.width
   };
 };
 
@@ -5929,8 +5930,8 @@ const getStats$1 = webContentsId => {
   return {
     canGoBack,
     canGoForward,
-    url,
-    title
+    title,
+    url
   };
 };
 const dispose$1 = webContentsId => {
@@ -6134,34 +6135,18 @@ const Plus = 132;
 
 const getKeyCode = key => {
   switch (key) {
+    case Backquote$1:
+      return Backquote;
+    case Backslash$1:
+      return Backslash;
     case Backspace$1:
       return Backspace;
-    case Tab$1:
-      return Tab;
-    case Escape$1:
-      return Escape;
-    case Enter$1:
-      return Enter;
-    case Space$2:
-      return Space$1;
-    case PageUp$1:
-      return PageUp;
-    case PageDown$1:
-      return PageDown;
-    case End$1:
-      return End;
-    case Home$1:
-      return Home;
-    case LeftArrow$1:
-      return LeftArrow;
-    case UpArrow$1:
-      return UpArrow;
-    case RightArrow$1:
-      return RightArrow;
-    case DownArrow$1:
-      return DownArrow;
-    case Insert$1:
-      return Insert;
+    case BracketLeft$1:
+      return BracketLeft;
+    case BracketRight$1:
+      return BracketRight;
+    case Comma$1:
+      return Comma;
     case Delete$1:
       return Delete;
     case Digit0$1:
@@ -6184,6 +6169,68 @@ const getKeyCode = key => {
       return Digit8;
     case Digit9$1:
       return Digit9;
+    case DownArrow$1:
+      return DownArrow;
+    case End$1:
+      return End;
+    case Enter$1:
+      return Enter;
+    case Equal$1:
+      return Equal;
+    case Escape$1:
+      return Escape;
+    case F1$1:
+      return F1;
+    case F10$1:
+      return F10;
+    case F11$1:
+      return F11;
+    case F12$1:
+      return F12;
+    case F13$1:
+      return F13;
+    case F14$1:
+      return F14;
+    case F15$1:
+      return F15;
+    case F16$1:
+      return F16;
+    case F17$1:
+      return F17;
+    case F18$1:
+      return F18;
+    case F19$1:
+      return F19;
+    case F2$1:
+      return F2;
+    case F20$1:
+      return F20;
+    case F21$1:
+      return F21;
+    case F22$1:
+      return F22;
+    case F23$1:
+      return F23;
+    case F24$1:
+      return F24;
+    case F3$1:
+      return F3;
+    case F4$1:
+      return F4;
+    case F5$1:
+      return F5;
+    case F6$1:
+      return F6;
+    case F7$1:
+      return F7;
+    case F8$1:
+      return F8;
+    case F9$1:
+      return F9;
+    case Home$1:
+      return Home;
+    case Insert$1:
+      return Insert;
     case KeyA$1:
       return KeyA;
     case KeyB$1:
@@ -6236,80 +6283,34 @@ const getKeyCode = key => {
       return KeyY;
     case KeyZ$1:
       return KeyZ;
-    case F1$1:
-      return F1;
-    case F2$1:
-      return F2;
-    case F3$1:
-      return F3;
-    case F4$1:
-      return F4;
-    case F5$1:
-      return F5;
-    case F6$1:
-      return F6;
-    case F7$1:
-      return F7;
-    case F8$1:
-      return F8;
-    case F9$1:
-      return F9;
-    case F10$1:
-      return F10;
-    case F11$1:
-      return F11;
-    case F12$1:
-      return F12;
-    case F13$1:
-      return F13;
-    case F14$1:
-      return F14;
-    case F15$1:
-      return F15;
-    case F16$1:
-      return F16;
-    case F17$1:
-      return F17;
-    case F18$1:
-      return F18;
-    case F19$1:
-      return F19;
-    case F20$1:
-      return F20;
-    case F21$1:
-      return F21;
-    case F22$1:
-      return F22;
-    case F23$1:
-      return F23;
-    case F24$1:
-      return F24;
-    case SemiColon$1:
-      return SemiColon;
-    case Equal$1:
-      return Equal;
-    case Comma$1:
-      return Comma;
+    case LeftArrow$1:
+      return LeftArrow;
     case Minus$1:
       return Minus;
+    case PageDown$1:
+      return PageDown;
+    case PageUp$1:
+      return PageUp;
     case Period$1:
       return Period;
-    case Slash$1:
-      return Slash;
-    case Backquote$1:
-      return Backquote;
-    case BracketLeft$1:
-      return BracketLeft;
-    case Backslash$1:
-      return Backslash;
-    case BracketRight$1:
-      return BracketRight;
+    case Plus$1:
+      return Plus;
     case Quote$1:
       return Quote;
+    case RightArrow$1:
+      return RightArrow;
+    case SemiColon$1:
+      return SemiColon;
+    case Slash$1:
+      return Slash;
+    case Space$2:
+      return Space$1;
     case Star$1:
       return Star;
-    case Plus$1:
-      return Plus;
+    case Tab$1:
+      return Tab;
+    case UpArrow$1:
+      return UpArrow;
     default:
       return Unknown;
   }
@@ -6328,10 +6329,10 @@ const normalizeKey = key => {
 
 const getKeyBindingIdentifier = input => {
   const {
-    control,
-    shift,
     alt,
-    key
+    control,
+    key,
+    shift
   } = input;
   const modifierControl = control ? CtrlCmd : 0;
   const modifierShift = shift ? Shift : 0;
@@ -6352,8 +6353,8 @@ const detach$6 = (webContents, listener) => {
 const handler$6 = (event, input) => {
   if (input.type !== KeyDown) {
     return {
-      result: undefined,
-      messages: []
+      messages: [],
+      result: undefined
     };
   }
   const falltroughKeyBindings = getFallthroughKeyBindings();
@@ -6363,13 +6364,13 @@ const handler$6 = (event, input) => {
   if (matches) {
     event.preventDefault();
     return {
-      result: undefined,
-      messages: [['handleKeyBinding', identifier]]
+      messages: [['handleKeyBinding', identifier]],
+      result: undefined
     };
   }
   return {
-    result: undefined,
-    messages: []
+    messages: [],
+    result: undefined
   };
 };
 
@@ -6390,8 +6391,8 @@ const detach$5 = (webContents, listener) => {
 };
 const handler$5 = (event, params) => {
   return {
-    result: undefined,
-    messages: [['handleContextMenu', params]]
+    messages: [['handleContextMenu', params]],
+    result: undefined
   };
 };
 
@@ -6412,8 +6413,8 @@ const detach$4 = (webContents, listener) => {
 };
 const handler$4 = () => {
   return {
-    result: undefined,
-    messages: [['handleBrowserViewDestroyed']]
+    messages: [['handleBrowserViewDestroyed']],
+    result: undefined
   };
 };
 
@@ -6434,8 +6435,8 @@ const detach$3 = (webContents, listener) => {
 };
 const handler$3 = (event, url) => {
   return {
-    result: undefined,
-    messages: [['handleDidNavigate', url]]
+    messages: [['handleDidNavigate', url]],
+    result: undefined
   };
 };
 
@@ -6456,8 +6457,8 @@ const detach$2 = (webContents, listener) => {
 };
 const handler$2 = (event, title) => {
   return {
-    result: undefined,
-    messages: [['handleTitleUpdated', title]]
+    messages: [['handleTitleUpdated', title]],
+    result: undefined
   };
 };
 
@@ -6478,8 +6479,8 @@ const detach$1 = (webContents, listener) => {
 };
 const handler$1 = (event, url) => {
   return {
-    result: undefined,
-    messages: [['handleWillNavigate', url]]
+    messages: [['handleWillNavigate', url]],
+    result: undefined
   };
 };
 
@@ -6502,43 +6503,43 @@ const detach = (webContents, listener) => {
   webContents.setWindowOpenHandler(null);
 };
 const handler = ({
-  url,
   disposition,
   features,
   frameName,
+  postBody,
   referrer,
-  postBody
+  url
 }) => {
   if (url === 'about:blank') {
     return {
+      messages: [],
       result: {
         action: Allow
-      },
-      messages: []
+      }
     };
   }
   if (disposition === BackgroundTab) {
     return {
+      messages: [['handleWindowOpen', url]],
       result: {
         action: Deny
-      },
-      messages: [['handleWindowOpen', url]]
+      }
     };
   }
   if (disposition === NewWindow) {
     return {
+      messages: [],
       result: {
         action: Allow
-      },
-      messages: []
+      }
     };
   }
   info(`[main-process] blocked popup for ${url}`);
   return {
+    messages: [],
     result: {
       action: Deny
-    },
-    messages: []
+    }
   };
 };
 
@@ -6603,14 +6604,14 @@ const getBeforeRequestResponseXhrHead = url => {
 };
 const getBeforeRequestResponseXhr = (method, url) => {
   switch (method) {
-    case Post:
-      return getBeforeRequestResponseXhrPost(url);
     case Get:
       return getBeforeRequestResponseXhrGet(url);
     case Head:
       return getBeforeRequestResponseXhrHead(url);
     case Options:
       return getBeforeRequestResponseXhrOptions(url);
+    case Post:
+      return getBeforeRequestResponseXhrPost(url);
     default:
       return {};
   }
@@ -6661,9 +6662,9 @@ const isAllowedPermission = permission => {
   switch (permission) {
     case ClipBoardRead:
     case ClipBoardSanitizedWrite:
-    case WindowPlacement:
     case FullScreen:
     case GeoLocation:
+    case WindowPlacement:
       return true;
     default:
       return false;
@@ -6728,8 +6729,8 @@ const attachEventListeners = webContentsId => {
     const wrappedListener = (...args) => {
       // @ts-ignore
       const {
-        result,
-        messages
+        messages,
+        result
       } = value.handler(...args);
       for (const message of messages) {
         const [key, ...rest] = message;
@@ -6749,8 +6750,8 @@ const disposeWebContentsView = browserViewId => {
     return;
   }
   const {
-    view,
-    browserWindow
+    browserWindow,
+    view
   } = instance;
   remove$1(browserViewId);
   browserWindow.contentView.removeChildView(view);
@@ -6781,10 +6782,10 @@ const resizeBrowserView = (view, x, y, width, height) => {
   number(width);
   number(height);
   view.setBounds({
-    x,
-    y,
+    height,
     width,
-    height
+    x,
+    y
   });
 };
 const setIframeSrcFallback = async (view, code, message) => {
@@ -6890,8 +6891,8 @@ const show = id => {
     return;
   }
   const {
-    view,
-    browserWindow
+    browserWindow,
+    view
   } = state;
   browserWindow.contentView.addChildView(view);
 };
@@ -6913,8 +6914,8 @@ const hide = id => {
     return;
   }
   const {
-    view,
-    browserWindow
+    browserWindow,
+    view
   } = state;
   browserWindow.contentView.removeChildView(view);
 };
@@ -6977,8 +6978,8 @@ const getStats = view => {
   return {
     canGoBack,
     canGoForward,
-    url,
-    title
+    title,
+    url
   };
 };
 
@@ -7013,14 +7014,14 @@ const unhandleIpc = ipc => {
 
 const getModule$1 = method => {
   switch (method) {
+    case ElectronMessagePort$1:
+      return IpcChildWithElectronMessagePort$1;
+    case ElectronUtilityProcess$1:
+      return IpcChildWithElectronUtilityProcess$1;
     case NodeForkedProcess$1:
       return IpcChildWithNodeForkedProcess$1;
     case NodeWorker$1:
       return IpcChildWithNodeWorker$1;
-    case ElectronUtilityProcess$1:
-      return IpcChildWithElectronUtilityProcess$1;
-    case ElectronMessagePort$1:
-      return IpcChildWithElectronMessagePort$1;
     case RendererProcess2:
       return IpcChildWithRendererProcess2$1;
     default:
@@ -7102,8 +7103,8 @@ const getWindowId = webContentsId => {
 const handleElectronMessagePort = async (messagePort, rpcId) => {
   object(messagePort);
   const rpc = await ElectronMessagePortRpcClient.create({
-    messagePort: messagePort,
     commandMap: commandMapRef,
+    messagePort: messagePort,
     requiresSocket: requiresSocket
   });
   if (rpcId) {
@@ -7113,14 +7114,14 @@ const handleElectronMessagePort = async (messagePort, rpcId) => {
 
 const getModule = method => {
   switch (method) {
-    case NodeWorker:
-      return IpcParentWithNodeWorker$1;
-    case NodeForkedProcess:
-      return IpcParentWithNodeForkedProcess$1;
-    case ElectronUtilityProcess:
-      return Promise.resolve().then(function () { return IpcParentWithElectronUtilityProcess; });
     case ElectronMessagePort:
       return IpcParentWithElectronMessagePort$1;
+    case ElectronUtilityProcess:
+      return Promise.resolve().then(function () { return IpcParentWithElectronUtilityProcess; });
+    case NodeForkedProcess:
+      return IpcParentWithNodeForkedProcess$1;
+    case NodeWorker:
+      return IpcParentWithNodeWorker$1;
     default:
       throw new Error(`unexpected ipc type ${method}`);
   }
@@ -7192,8 +7193,8 @@ const {
   wrap
 } = IpcParentWithElectronUtilityProcess$1$1;
 const effects = ({
-  rawIpc,
-  name
+  name,
+  rawIpc
 }) => {
   if (!rawIpc.pid) {
     return;
@@ -7320,17 +7321,17 @@ const commandMap = {
   'ElectronWebContentsView.createWebContentsView': createWebContentsView,
   'ElectronWebContentsView.disposeWebContentsView': disposeWebContentsView,
   'ElectronWebContentsViewFunctions.addToWindow': addToWindow,
-  'ElectronWebContentsViewFunctions.getDomTree': wrapBrowserViewCommand(getDomTree),
   'ElectronWebContentsViewFunctions.backward': wrapBrowserViewCommand(backward),
   'ElectronWebContentsViewFunctions.cancelNavigation': wrapBrowserViewCommand(cancelNavigation),
   'ElectronWebContentsViewFunctions.copyImageAt': wrapBrowserViewCommand(copyImageAt),
-  'ElectronWebContentsViewFunctions.focus': wrapBrowserViewCommand(focus),
-  'ElectronWebContentsViewFunctions.insertCss': wrapBrowserViewCommand(insertCss),
   'ElectronWebContentsViewFunctions.executeJavaScript': wrapBrowserViewCommand(executeJavaScript),
-  'ElectronWebContentsViewFunctions.insertJavaScript': wrapBrowserViewCommand(executeJavaScript),
+  'ElectronWebContentsViewFunctions.focus': wrapBrowserViewCommand(focus),
   'ElectronWebContentsViewFunctions.forward': wrapBrowserViewCommand(forward),
+  'ElectronWebContentsViewFunctions.getDomTree': wrapBrowserViewCommand(getDomTree),
   'ElectronWebContentsViewFunctions.getStats': wrapBrowserViewCommand(getStats),
   'ElectronWebContentsViewFunctions.hide': hide,
+  'ElectronWebContentsViewFunctions.insertCss': wrapBrowserViewCommand(insertCss),
+  'ElectronWebContentsViewFunctions.insertJavaScript': wrapBrowserViewCommand(executeJavaScript),
   'ElectronWebContentsViewFunctions.inspectElement': wrapBrowserViewCommand(inspectElement),
   'ElectronWebContentsViewFunctions.openDevtools': wrapBrowserViewCommand(openDevtools),
   'ElectronWebContentsViewFunctions.reload': wrapBrowserViewCommand(wrapBrowserViewCommand(reload)),
@@ -7388,6 +7389,10 @@ const load = async moduleId => {
       return Promise.resolve().then(function () { return CreatePidMap_ipc; });
     case DesktopCapturer:
       return Promise.resolve().then(function () { return DesktopCapturer_ipc; });
+    case Developer:
+      return Promise.resolve().then(function () { return ElectronDeveloper_ipc; });
+    case Dialog:
+      return Promise.resolve().then(function () { return ElectronDialog_ipc; });
     case ElectronApplicationMenu:
       return Promise.resolve().then(function () { return ElectronApplicationMenu_ipc; });
     case ElectronClipBoard:
@@ -7396,10 +7401,6 @@ const load = async moduleId => {
       return Promise.resolve().then(function () { return ElectronContentTracing_ipc; });
     case ElectronContextMenu:
       return Promise.resolve().then(function () { return ElectronContextMenu_ipc; });
-    case Developer:
-      return Promise.resolve().then(function () { return ElectronDeveloper_ipc; });
-    case Dialog:
-      return Promise.resolve().then(function () { return ElectronDialog_ipc; });
     case ElectronNet:
       return Promise.resolve().then(function () { return ElectronNet_ipc; });
     case ElectronNetLog:
@@ -7408,38 +7409,38 @@ const load = async moduleId => {
       return Promise.resolve().then(function () { return ElectronPowerSaveBlocker_ipc; });
     case ElectronSafeStorage:
       return Promise.resolve().then(function () { return ElectronSafeStorage_ipc; });
+    case ElectronScreen:
+      return Promise.resolve().then(function () { return ElectronScreen_ipc; });
+    case ElectronSession:
+      return Promise.resolve().then(function () { return ElectronSession_ipc; });
     case ElectronShell:
       return Promise.resolve().then(function () { return ElectronShell_ipc; });
-    case Window:
-      return Promise.resolve().then(function () { return ElectronWindow_ipc; });
+    case ElectronWebContents:
+      return Promise.resolve().then(function () { return ElectronWebContents_ipc; });
+    case ElectronWebContentsView:
+      return Promise.resolve().then(function () { return ElectronWebContentsView_ipc; });
+    case ElectronWebContentsViewFunctions:
+      return Promise.resolve().then(function () { return ElectronWebContentsViewFunctions_ipc; });
     case ElectronWindowProcessExplorer:
       return Promise.resolve().then(function () { return ElectronWindowProcessExplorer_ipc; });
+    case Exit:
+      return Promise.resolve().then(function () { return Exit_ipc; });
+    case GetWindowId:
+      return Promise.resolve().then(function () { return GetWindowId_ipc; });
+    case HandleElectronMessagePort:
+      return Promise.resolve().then(function () { return HandleElectronMessagePort_ipc; });
     case IpcParent:
       return Promise.resolve().then(function () { return IpcParent_ipc; });
     case OpenExternal$1:
       return Promise.resolve().then(function () { return OpenExternal_ipc; });
     case Process:
       return Promise.resolve().then(function () { return Process_ipc; });
-    case Exit:
-      return Promise.resolve().then(function () { return Exit_ipc; });
-    case ElectronScreen:
-      return Promise.resolve().then(function () { return ElectronScreen_ipc; });
     case TemporaryMessagePort:
       return Promise.resolve().then(function () { return TemporaryMessagePort_ipc; });
-    case ElectronWebContents:
-      return Promise.resolve().then(function () { return ElectronWebContents_ipc; });
-    case ElectronWebContentsView:
-      return Promise.resolve().then(function () { return ElectronWebContentsView_ipc; });
-    case ElectronWebContentsViewFunctions:
-      return Promise.resolve().then(function () { return ElectronWebContentsViewFunctions_ipc; });
-    case HandleElectronMessagePort:
-      return Promise.resolve().then(function () { return HandleElectronMessagePort_ipc; });
-    case GetWindowId:
-      return Promise.resolve().then(function () { return GetWindowId_ipc; });
-    case ElectronSession:
-      return Promise.resolve().then(function () { return ElectronSession_ipc; });
     case Trash:
       return Promise.resolve().then(function () { return Trash_ipc; });
+    case Window:
+      return Promise.resolve().then(function () { return ElectronWindow_ipc; });
     default:
       throw new ModuleNotFoundError(moduleId);
   }
@@ -7540,42 +7541,66 @@ const DesktopCapturer_ipc = {
 	name: name$q
 };
 
-const name$p = 'ElectronApplicationMenu';
+const name$p = 'ElectronDeveloper';
 const Commands$p = {
-  setItems: setItems
+  crashMainProcess: crashMainProcess,
+  getPerformanceEntries: getPerformanceEntries
 };
 
-const ElectronApplicationMenu_ipc = {
+const ElectronDeveloper_ipc = {
 	__proto__: null,
 	Commands: Commands$p,
 	name: name$p
 };
 
+const name$o = 'ElectronDialog';
+const Commands$o = {
+  showMessageBox: showMessageBox,
+  showOpenDialog: showOpenDialog
+};
+
+const ElectronDialog_ipc = {
+	__proto__: null,
+	Commands: Commands$o,
+	name: name$o
+};
+
+const name$n = 'ElectronApplicationMenu';
+const Commands$n = {
+  setItems: setItems
+};
+
+const ElectronApplicationMenu_ipc = {
+	__proto__: null,
+	Commands: Commands$n,
+	name: name$n
+};
+
 const writeText = text => {
   clipboard.writeText(text);
 };
 
-const name$o = 'ElectronClipBoard';
-const Commands$o = {
+const name$m = 'ElectronClipBoard';
+const Commands$m = {
   writeText: writeText
 };
 
 const ElectronClipBoard_ipc = {
 	__proto__: null,
-	Commands: Commands$o,
-	name: name$o
+	Commands: Commands$m,
+	name: name$m
 };
 
-const name$n = 'ElectronContentTracing';
-const Commands$n = {
+const name$l = 'ElectronContentTracing';
+const Commands$l = {
   startRecording: startRecording,
   stopRecording: stopRecording
 };
 
 const ElectronContentTracing_ipc = {
 	__proto__: null,
-	Commands: Commands$n,
-	name: name$n
+	Commands: Commands$l,
+	name: name$l
 };
 
 const withResolvers = () => {
@@ -7592,27 +7617,27 @@ const withResolvers = () => {
     _reject = reject;
   });
   return {
-    resolve: _resolve,
+    promise,
     reject: _reject,
-    promise
+    resolve: _resolve
   };
 };
 
 const getElectronCallbacks = () => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = withResolvers();
   const handleClick = menuItem => {
     resolve({
-      type: 'click',
-      data: menuItem
+      data: menuItem,
+      type: 'click'
     });
   };
   const handleClose = () => {
     resolve({
-      type: 'close',
-      data: undefined
+      data: undefined,
+      type: 'close'
     });
   };
   return {
@@ -7640,73 +7665,49 @@ const openContextMenu = async (menuItems, x, y) => {
   number(x);
   number(y);
   const {
-    promise,
     handleClick,
-    handleClose
+    handleClose,
+    promise
   } = getElectronCallbacks();
   const template = getElectronMenuItems(menuItems, handleClick);
   const menu = Menu.buildFromTemplate(template);
   const window = BrowserWindow.getFocusedWindow();
   if (!window) {
     return {
-      type: 'close',
-      data: undefined
+      data: undefined,
+      type: 'close'
     };
   }
   menu.popup({
+    callback: handleClose,
     window,
     x,
-    y,
-    callback: handleClose
+    y
   });
   const event = await promise;
   // @ts-ignore
   if (event.type === 'click') {
     return {
-      type: 'click',
       // @ts-ignore
-      data: event.data.label
+      data: event.data.label,
+      type: 'click'
     };
   }
   // @ts-ignore
   if (event.type === 'close') {
     return {
-      type: 'close',
-      data: undefined
+      data: undefined,
+      type: 'close'
     };
   }
 };
 
-const name$m = 'ElectronContextMenu';
-const Commands$m = {
+const name$k = 'ElectronContextMenu';
+const Commands$k = {
   openContextMenu: openContextMenu
 };
 
 const ElectronContextMenu_ipc = {
-	__proto__: null,
-	Commands: Commands$m,
-	name: name$m
-};
-
-const name$l = 'ElectronDeveloper';
-const Commands$l = {
-  crashMainProcess: crashMainProcess,
-  getPerformanceEntries: getPerformanceEntries
-};
-
-const ElectronDeveloper_ipc = {
-	__proto__: null,
-	Commands: Commands$l,
-	name: name$l
-};
-
-const name$k = 'ElectronDialog';
-const Commands$k = {
-  showMessageBox: showMessageBox,
-  showOpenDialog: showOpenDialog
-};
-
-const ElectronDialog_ipc = {
 	__proto__: null,
 	Commands: Commands$k,
 	name: name$k
@@ -7760,216 +7761,216 @@ const ElectronSafeStorage_ipc = {
 	name: name$g
 };
 
-const name$f = 'ElectronShell';
+const name$f = 'ElectronScreen';
 const Commands$f = {
-  beep: beep$1,
-  openExternal: openExternal,
-  openPath: showItemInFolder,
-  showItemInFolder: showItemInFolder
+  getBounds: getBounds,
+  getHeight: getHeight,
+  getWidth: getWidth
 };
 
-const ElectronShell_ipc = {
+const ElectronScreen_ipc = {
 	__proto__: null,
 	Commands: Commands$f,
 	name: name$f
 };
 
-const name$e = 'ElectronWindow';
+const name$e = 'ElectronSession';
 const Commands$e = {
-  executeWindowFunction: executeWindowFunction,
-  executeWebContentsFunction: executeWebContentsFunction,
-  getFocusedWindowId: getFocusedWindowId,
-  getZoom: getZoom
+  registerWebviewProtocol: registerWebviewProtocol
 };
 
-const ElectronWindow_ipc = {
+const ElectronSession_ipc = {
 	__proto__: null,
 	Commands: Commands$e,
 	name: name$e
 };
 
-const name$d = 'ElectronWindowProcessExplorer';
+const name$d = 'ElectronShell';
 const Commands$d = {
-  open2: open2
+  beep: beep$1,
+  openExternal: openExternal,
+  openPath: showItemInFolder,
+  showItemInFolder: showItemInFolder
 };
 
-const ElectronWindowProcessExplorer_ipc = {
+const ElectronShell_ipc = {
 	__proto__: null,
 	Commands: Commands$d,
 	name: name$d
 };
 
-const name$c = 'IpcParent';
+const name$c = 'ElectronWebContents';
 const Commands$c = {
-  create: create$1
+  callFunction: callFunction,
+  dispose: dispose$1,
+  getStats: getStats$1
 };
 
-const IpcParent_ipc = {
+const ElectronWebContents_ipc = {
 	__proto__: null,
 	Commands: Commands$c,
 	name: name$c
 };
 
-const name$b = 'OpenExternal';
+const name$b = 'ElectronWebContentsView';
 const Commands$b = {
-  openExternal: openExternal
+  attachEventListeners: attachEventListeners,
+  createWebContentsView: createWebContentsView,
+  disposeWebContentsView: disposeWebContentsView
 };
 
-const OpenExternal_ipc = {
+const ElectronWebContentsView_ipc = {
 	__proto__: null,
 	Commands: Commands$b,
 	name: name$b
 };
 
-const name$a = 'Process';
+const name$a = 'ElectronWebContentsViewFunctions';
 const Commands$a = {
-  getArgv: getArgv,
-  getChromeVersion: getChromeVersion,
-  getElectronVersion: getElectronVersion,
-  getNodeVersion: getNodeVersion,
-  getPid: getPid,
-  getV8Version: getV8Version
+  addToWindow: addToWindow,
+  backward: wrapBrowserViewCommand(backward),
+  cancelNavigation: wrapBrowserViewCommand(cancelNavigation),
+  copyImageAt: wrapBrowserViewCommand(copyImageAt),
+  executeJavaScript: wrapBrowserViewCommand(executeJavaScript),
+  focus: wrapBrowserViewCommand(focus),
+  forward: wrapBrowserViewCommand(forward),
+  getDomTree: wrapBrowserViewCommand(getDomTree),
+  getStats: wrapBrowserViewCommand(getStats),
+  hide: hide,
+  insertCss: wrapBrowserViewCommand(insertCss),
+  insertJavaScript: wrapBrowserViewCommand(executeJavaScript),
+  inspectElement: wrapBrowserViewCommand(inspectElement),
+  openDevtools: wrapBrowserViewCommand(openDevtools),
+  reload: wrapBrowserViewCommand(reload),
+  resizeBrowserView: wrapBrowserViewCommand(resizeBrowserView),
+  setBackgroundColor: wrapBrowserViewCommand(setBackgroundColor),
+  setFallthroughKeyBindings: setFallThroughKeyBindings,
+  setIframeSrc: wrapBrowserViewCommand(setIframeSrc),
+  setIframeSrcFallback: wrapBrowserViewCommand(setIframeSrcFallback),
+  show: show
 };
 
-const Process_ipc = {
+const ElectronWebContentsViewFunctions_ipc = {
 	__proto__: null,
 	Commands: Commands$a,
 	name: name$a
 };
 
-const name$9 = 'Exit';
+const name$9 = 'ElectronWindowProcessExplorer';
 const Commands$9 = {
-  exit: exit
+  open2: open2
 };
 
-const Exit_ipc = {
+const ElectronWindowProcessExplorer_ipc = {
 	__proto__: null,
 	Commands: Commands$9,
 	name: name$9
 };
 
-const name$8 = 'ElectronScreen';
+const name$8 = 'Exit';
 const Commands$8 = {
-  getBounds: getBounds,
-  getWidth: getWidth,
-  getHeight: getHeight
+  exit: exit
 };
 
-const ElectronScreen_ipc = {
+const Exit_ipc = {
 	__proto__: null,
 	Commands: Commands$8,
 	name: name$8
 };
 
-const name$7 = 'TemporaryMessagePort';
+const name$7 = 'GetWindowId';
 const Commands$7 = {
-  createPortTuple: createPortTuple,
-  dispose: dispose,
-  sendTo: sendTo
+  getWindowId: getWindowId
 };
 
-const TemporaryMessagePort_ipc = {
+const GetWindowId_ipc = {
 	__proto__: null,
 	Commands: Commands$7,
 	name: name$7
 };
 
-const name$6 = 'ElectronWebContents';
+const name$6 = 'HandleElectronMessagePort';
 const Commands$6 = {
-  dispose: dispose$1,
-  getStats: getStats$1,
-  callFunction: callFunction
+  handleElectronMessagePort: handleElectronMessagePort
 };
 
-const ElectronWebContents_ipc = {
+const HandleElectronMessagePort_ipc = {
 	__proto__: null,
 	Commands: Commands$6,
 	name: name$6
 };
 
-const name$5 = 'ElectronWebContentsView';
+const name$5 = 'IpcParent';
 const Commands$5 = {
-  createWebContentsView: createWebContentsView,
-  attachEventListeners: attachEventListeners,
-  disposeWebContentsView: disposeWebContentsView
+  create: create$1
 };
 
-const ElectronWebContentsView_ipc = {
+const IpcParent_ipc = {
 	__proto__: null,
 	Commands: Commands$5,
 	name: name$5
 };
 
-const name$4 = 'ElectronWebContentsViewFunctions';
+const name$4 = 'OpenExternal';
 const Commands$4 = {
-  addToWindow: addToWindow,
-  backward: wrapBrowserViewCommand(backward),
-  cancelNavigation: wrapBrowserViewCommand(cancelNavigation),
-  copyImageAt: wrapBrowserViewCommand(copyImageAt),
-  focus: wrapBrowserViewCommand(focus),
-  forward: wrapBrowserViewCommand(forward),
-  getStats: wrapBrowserViewCommand(getStats),
-  hide: hide,
-  inspectElement: wrapBrowserViewCommand(inspectElement),
-  openDevtools: wrapBrowserViewCommand(openDevtools),
-  reload: wrapBrowserViewCommand(reload),
-  resizeBrowserView: wrapBrowserViewCommand(resizeBrowserView),
-  setBackgroundColor: wrapBrowserViewCommand(setBackgroundColor),
-  setFallthroughKeyBindings: setFallThroughKeyBindings,
-  setIframeSrc: wrapBrowserViewCommand(setIframeSrc),
-  setIframeSrcFallback: wrapBrowserViewCommand(setIframeSrcFallback),
-  show: show,
-  getDomTree: wrapBrowserViewCommand(getDomTree),
-  insertCss: wrapBrowserViewCommand(insertCss),
-  executeJavaScript: wrapBrowserViewCommand(executeJavaScript),
-  insertJavaScript: wrapBrowserViewCommand(executeJavaScript)
+  openExternal: openExternal
 };
 
-const ElectronWebContentsViewFunctions_ipc = {
+const OpenExternal_ipc = {
 	__proto__: null,
 	Commands: Commands$4,
 	name: name$4
 };
 
-const name$3 = 'HandleElectronMessagePort';
+const name$3 = 'Process';
 const Commands$3 = {
-  handleElectronMessagePort: handleElectronMessagePort
+  getArgv: getArgv,
+  getChromeVersion: getChromeVersion,
+  getElectronVersion: getElectronVersion,
+  getNodeVersion: getNodeVersion,
+  getPid: getPid,
+  getV8Version: getV8Version
 };
 
-const HandleElectronMessagePort_ipc = {
+const Process_ipc = {
 	__proto__: null,
 	Commands: Commands$3,
 	name: name$3
 };
 
-const name$2 = 'GetWindowId';
+const name$2 = 'TemporaryMessagePort';
 const Commands$2 = {
-  getWindowId: getWindowId
+  createPortTuple: createPortTuple,
+  dispose: dispose,
+  sendTo: sendTo
 };
 
-const GetWindowId_ipc = {
+const TemporaryMessagePort_ipc = {
 	__proto__: null,
 	Commands: Commands$2,
 	name: name$2
 };
 
-const name$1 = 'ElectronSession';
+const name$1 = 'Trash';
 const Commands$1 = {
-  registerWebviewProtocol: registerWebviewProtocol
+  trash: trash
 };
 
-const ElectronSession_ipc = {
+const Trash_ipc = {
 	__proto__: null,
 	Commands: Commands$1,
 	name: name$1
 };
 
-const name = 'Trash';
+const name = 'ElectronWindow';
 const Commands = {
-  trash: trash
+  executeWebContentsFunction: executeWebContentsFunction,
+  executeWindowFunction: executeWindowFunction,
+  getFocusedWindowId: getFocusedWindowId,
+  getZoom: getZoom
 };
 
-const Trash_ipc = {
+const ElectronWindow_ipc = {
 	__proto__: null,
 	Commands,
 	name