@lvce-editor/main-process 3.0.0 → 4.0.0

package/dist/mainProcessMain.js

@@ -4,15 +4,15 @@ import process$1 from 'node:process';
 import { fileURLToPath } from 'node:url';
 import { inspect } from 'node:util';
 import { spawn } from 'node:child_process';
-import { MessageChannel } from 'node:worker_threads';
+import { Console } from 'node:console';
 import { createWriteStream, readFileSync } from 'node:fs';
+import { tmpdir, homedir } from 'node:os';
 import * as NodePath from 'node:path';
 import { dirname } from 'node:path';
 import require$$1 from 'tty';
 import require$$1$1 from 'util';
 import require$$0 from 'os';
-import { tmpdir, homedir } from 'node:os';
-import { Console } from 'node:console';
+import { MessageChannel } from 'node:worker_threads';
 
 function escapeStringRegexp(string) {
   if (typeof string !== 'string') {
@@ -779,7 +779,7 @@ const getNewLineIndex$2 = (string, startIndex = undefined) => {
 
 // TODO disable logging via environment variable, don't enable logging during tests
 
-const state$7 = {
+const state$6 = {
   console: undefined
 };
 const createConsole = () => {
@@ -789,8 +789,8 @@ const createConsole = () => {
   return logger;
 };
 const getOrCreateLogger = () => {
-  state$7.console ||= createConsole();
-  return state$7.console;
+  state$6.console ||= createConsole();
+  return state$6.console;
 };
 const info = (...args) => {
   const logger = getOrCreateLogger();
@@ -1163,39 +1163,39 @@ function requireLib () {
 	const NEWLINE$1 = /\r\n|[\n\r\u2028\u2029]/;
 	const BRACKET = /^[()[\]{}]$/;
 	let tokenize;
-	{
-	  const JSX_TAG = /^[a-z][\w-]*$/i;
-	  const getTokenType = function (token, offset, text) {
-	    if (token.type === "name") {
-	      if (helperValidatorIdentifier.isKeyword(token.value) || helperValidatorIdentifier.isStrictReservedWord(token.value, true) || sometimesKeywords.has(token.value)) {
-	        return "keyword";
-	      }
-	      if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.slice(offset - 2, offset) === "</")) {
-	        return "jsxIdentifier";
-	      }
-	      if (token.value[0] !== token.value[0].toLowerCase()) {
-	        return "capitalized";
-	      }
+	const JSX_TAG = /^[a-z][\w-]*$/i;
+	const getTokenType = function (token, offset, text) {
+	  if (token.type === "name") {
+	    const tokenValue = token.value;
+	    if (helperValidatorIdentifier.isKeyword(tokenValue) || helperValidatorIdentifier.isStrictReservedWord(tokenValue, true) || sometimesKeywords.has(tokenValue)) {
+	      return "keyword";
 	    }
-	    if (token.type === "punctuator" && BRACKET.test(token.value)) {
-	      return "bracket";
+	    if (JSX_TAG.test(tokenValue) && (text[offset - 1] === "<" || text.slice(offset - 2, offset) === "</")) {
+	      return "jsxIdentifier";
 	    }
-	    if (token.type === "invalid" && (token.value === "@" || token.value === "#")) {
-	      return "punctuator";
-	    }
-	    return token.type;
-	  };
-	  tokenize = function* (text) {
-	    let match;
-	    while (match = jsTokens.default.exec(text)) {
-	      const token = jsTokens.matchToToken(match);
-	      yield {
-	        type: getTokenType(token, match.index, text),
-	        value: token.value
-	      };
+	    const firstChar = String.fromCodePoint(tokenValue.codePointAt(0));
+	    if (firstChar !== firstChar.toLowerCase()) {
+	      return "capitalized";
 	    }
-	  };
-	}
+	  }
+	  if (token.type === "punctuator" && BRACKET.test(token.value)) {
+	    return "bracket";
+	  }
+	  if (token.type === "invalid" && (token.value === "@" || token.value === "#")) {
+	    return "punctuator";
+	  }
+	  return token.type;
+	};
+	tokenize = function* (text) {
+	  let match;
+	  while (match = jsTokens.default.exec(text)) {
+	    const token = jsTokens.matchToToken(match);
+	    yield {
+	      type: getTokenType(token, match.index, text),
+	      value: token.value
+	    };
+	  }
+	};
 	function highlight(text) {
 	  if (text === "") return "";
 	  const defs = getDefs(true);
@@ -1923,8 +1923,8 @@ const getModuleNotFoundError = stderr => {
   const messageIndex = lines.findIndex(isModuleNotFoundMessage);
   const message = lines[messageIndex];
   return {
-    message,
-    code: ERR_MODULE_NOT_FOUND
+    code: ERR_MODULE_NOT_FOUND,
+    message
   };
 };
 const isModuleNotFoundError = stderr => {
@@ -1947,14 +1947,14 @@ const isUnhelpfulNativeModuleError = stderr => {
 const getNativeModuleErrorMessage = stderr => {
   const message = getMessageCodeBlock(stderr);
   return {
-    message: `Incompatible native node module: ${message}`,
-    code: E_INCOMPATIBLE_NATIVE_MODULE
+    code: E_INCOMPATIBLE_NATIVE_MODULE,
+    message: `Incompatible native node module: ${message}`
   };
 };
 const getModuleSyntaxError = () => {
   return {
-    message: `ES Modules are not supported in electron`,
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
+    message: `ES Modules are not supported in electron`
   };
 };
 const getHelpfulChildProcessError = (stdout, stderr) => {
@@ -1973,8 +1973,8 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
     rest
   } = getDetails(lines);
   return {
-    message: actualMessage,
     code: '',
+    message: actualMessage,
     stack: rest
   };
 };
@@ -1984,8 +1984,8 @@ class IpcError extends VError {
     if (stdout || stderr) {
       // @ts-ignore
       const {
-        message,
         code,
+        message,
         stack
       } = getHelpfulChildProcessError(stdout, stderr);
       const cause = new Error(message);
@@ -2267,8 +2267,8 @@ const removeListener = (emitter, type, callback) => {
 };
 const getFirstEvent = (eventEmitter, eventMap) => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   const listenerMap = Object.create(null);
   const cleanup = value => {
@@ -2280,8 +2280,8 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   for (const [event, type] of Object.entries(eventMap)) {
     const listener = event => {
       cleanup({
-        type,
-        event
+        event,
+        type
       });
     };
     addListener(eventEmitter, event, listener);
@@ -2331,13 +2331,13 @@ const IpcParentWithElectronMessagePort$1 = {
   signal: signal$2,
   wrap: wrap$7
 };
-const Exit$1 = 1;
+const Exit = 1;
 const Error$2 = 2;
 const Message$1 = 3;
 const getFirstUtilityProcessEvent = async utilityProcess => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   let stdout = '';
   let stderr = '';
@@ -2358,18 +2358,18 @@ const getFirstUtilityProcessEvent = async utilityProcess => {
   };
   const handleMessage = event => {
     cleanup({
-      type: Message$1,
       event,
+      stderr,
       stdout,
-      stderr
+      type: Message$1
     });
   };
   const handleExit = event => {
     cleanup({
-      type: Exit$1,
       event,
+      stderr,
       stdout,
-      stderr
+      type: Exit
     });
   };
   // @ts-ignore
@@ -2379,22 +2379,22 @@ const getFirstUtilityProcessEvent = async utilityProcess => {
   utilityProcess.on('message', handleMessage);
   utilityProcess.on('exit', handleExit);
   const {
-    type,
-    event
+    event,
+    type
   } = await promise;
   return {
-    type,
     event,
+    stderr,
     stdout,
-    stderr
+    type
   };
 };
 const create$6 = async ({
-  path,
   argv = [],
+  env = process.env,
   execArgv = [],
   name,
-  env = process.env
+  path
 }) => {
   string(path);
   const actualArgv = ['--ipc-type=electron-utility-process', ...argv];
@@ -2402,10 +2402,10 @@ const create$6 = async ({
     utilityProcess
   } = await import('electron');
   const childProcess = utilityProcess.fork(path, actualArgv, {
+    env,
     execArgv,
-    stdio: 'pipe',
     serviceName: name,
-    env
+    stdio: 'pipe'
   });
   const handleExit = () => {
     // @ts-ignore
@@ -2417,11 +2417,11 @@ const create$6 = async ({
   // @ts-ignore
   childProcess.stdout.pipe(process.stdout);
   const {
-    type,
+    stderr,
     stdout,
-    stderr
+    type
   } = await getFirstUtilityProcessEvent(childProcess);
-  if (type === Exit$1) {
+  if (type === Exit) {
     throw new IpcError(`Utility process exited before ipc connection was established`, stdout, stderr);
   }
   // @ts-ignore
@@ -2465,8 +2465,8 @@ class ChildProcessError extends Error {
   constructor(stderr) {
     // @ts-ignore
     const {
-      message,
       code,
+      message,
       stack
     } = getHelpfulChildProcessError('', stderr);
     super(message || 'child process error');
@@ -2502,10 +2502,10 @@ const fixNodeChildProcessParameters = value => {
 };
 const getFirstNodeChildProcessEvent = async childProcess => {
   const {
-    type,
     event,
+    stderr,
     stdout,
-    stderr
+    type
   } = await new Promise((resolve, reject) => {
     let stderr = '';
     let stdout = '';
@@ -2527,26 +2527,26 @@ const getFirstNodeChildProcessEvent = async childProcess => {
     };
     const handleMessage = event => {
       cleanup({
-        type: Message$1,
         event,
+        stderr,
         stdout,
-        stderr
+        type: Message$1
       });
     };
     const handleExit = event => {
       cleanup({
-        type: Exit$1,
         event,
+        stderr,
         stdout,
-        stderr
+        type: Exit
       });
     };
     const handleError = event => {
       cleanup({
-        type: Error$2,
         event,
+        stderr,
         stdout,
-        stderr
+        type: Error$2
       });
     };
     if (childProcess.stdout && childProcess.stderr) {
@@ -2558,21 +2558,21 @@ const getFirstNodeChildProcessEvent = async childProcess => {
     childProcess.on('error', handleError);
   });
   return {
-    type,
     event,
+    stderr,
     stdout,
-    stderr
+    type
   };
 };
 
 // @ts-ignore
 const create$2$2 = async ({
-  path,
   argv = [],
   env,
   execArgv = [],
-  stdio = 'inherit',
-  name = 'child process'
+  name = 'child process',
+  path,
+  stdio = 'inherit'
 }) => {
   try {
     string(path);
@@ -2586,11 +2586,11 @@ const create$2$2 = async ({
       stdio: 'pipe'
     });
     const {
-      type,
       event,
-      stderr
+      stderr,
+      type
     } = await getFirstNodeChildProcessEvent(childProcess);
-    if (type === Exit$1) {
+    if (type === Exit) {
       throw new ChildProcessError(stderr);
     }
     if (type === Error$2) {
@@ -2653,18 +2653,18 @@ const fixNodeWorkerParameters = value => {
 };
 const getFirstNodeWorkerEvent = worker => {
   return getFirstEvent(worker, {
-    message: Message$1,
-    exit: Exit$1,
-    error: Error$2
+    error: Error$2,
+    exit: Exit,
+    message: Message$1
   });
 };
 const create$1$2 = async ({
-  path,
   argv = [],
   env = process.env,
   execArgv = [],
-  stdio,
-  name
+  name,
+  path,
+  stdio
 }) => {
   string(path);
   const actualArgv = ['--ipc-type=node-worker', ...argv];
@@ -2680,15 +2680,15 @@ const create$1$2 = async ({
     argv: actualArgv,
     env: actualEnv,
     execArgv,
-    stdout: ignoreStdio,
+    name,
     stderr: ignoreStdio,
-    name
+    stdout: ignoreStdio
   });
   const {
-    type,
-    event
+    event,
+    type
   } = await getFirstNodeWorkerEvent(worker);
-  if (type === Exit$1) {
+  if (type === Exit) {
     throw new IpcError(`Worker exited before ipc connection was established`);
   }
   if (type === Error$2) {
@@ -2732,14 +2732,7 @@ const IpcParentWithNodeWorker$1 = {
   wrap: wrap$1
 };
 
-const Two = '2.0';
-const create$4 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
-};
+const Two$1 = '2.0';
 const callbacks = Object.create(null);
 const set$2 = (id, fn) => {
   callbacks[id] = fn;
@@ -2750,11 +2743,11 @@ const get$4 = id => {
 const remove$2 = id => {
   delete callbacks[id];
 };
-let id = 0;
+let id$1 = 0;
 const create$3 = () => {
-  return ++id;
+  return ++id$1;
 };
-const registerPromise = () => {
+const registerPromise$1 = () => {
   const id = create$3();
   const {
     resolve,
@@ -2770,9 +2763,9 @@ const create$2$1 = (method, params) => {
   const {
     id,
     promise
-  } = registerPromise();
+  } = registerPromise$1();
   const message = {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     method,
     params,
     id
@@ -2934,7 +2927,7 @@ const resolve = (id, response) => {
   fn(response);
   remove$2(id);
 };
-const E_COMMAND_NOT_FOUND$1 = 'E_COMMAND_NOT_FOUND';
+const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getErrorType = prettyError => {
   if (prettyError && prettyError.type) {
     return prettyError.type;
@@ -2956,7 +2949,7 @@ const getStack = prettyError => {
   return stackString;
 };
 const getErrorProperty = (error, prettyError) => {
-  if (error && error.code === E_COMMAND_NOT_FOUND$1) {
+  if (error && error.code === E_COMMAND_NOT_FOUND) {
     return {
       code: MethodNotFound,
       message: error.message,
@@ -2977,7 +2970,7 @@ const getErrorProperty = (error, prettyError) => {
 };
 const create$1$1 = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error
   };
@@ -2988,20 +2981,20 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$5 = (message, result) => {
+const create$4 = (message, result) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id: message.id,
     result: result ?? null
   };
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$5(message, resultProperty);
+  return create$4(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error: {
       code: Custom,
@@ -3088,12 +3081,12 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
-const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
+const invokeHelper$1 = async (ipc, method, params, useSendAndTransfer) => {
   const {
     message,
     promise
   } = create$2$1(method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
+  if (ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
     ipc.send(message);
@@ -3101,25 +3094,18 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const responseMessage = await promise;
   return unwrapJsonRpcResult(responseMessage);
 };
-const send$2 = (transport, method, ...params) => {
-  const message = create$4(method, params);
-  transport.send(message);
-};
-const invoke$1 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, false);
-};
 const invokeAndTransfer$1 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, true);
+  return invokeHelper$1(ipc, method, params);
 };
 
-let CommandNotFoundError$1 = class CommandNotFoundError extends Error {
+class CommandNotFoundError extends Error {
   constructor(command) {
     super(`Command not found ${command}`);
     this.name = 'CommandNotFoundError';
   }
-};
+}
 const commands = Object.create(null);
-const register$1 = commandMap => {
+const register = commandMap => {
   Object.assign(commands, commandMap);
 };
 const getCommand = key => {
@@ -3128,29 +3114,92 @@ const getCommand = key => {
 const execute$1 = (command, ...args) => {
   const fn = getCommand(command);
   if (!fn) {
-    throw new CommandNotFoundError$1(command);
+    throw new CommandNotFoundError(command);
   }
   return fn(...args);
 };
 
+const Two = '2.0';
+const create$s = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+const create$r = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
+};
+let id = 0;
+const create$q = () => {
+  return ++id;
+};
+
+/* eslint-disable n/no-unsupported-features/es-syntax */
+
+const registerPromise = map => {
+  const id = create$q();
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
+    promise
+  };
+};
+
+// @ts-ignore
+const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
+    promise
+  } = registerPromise(callbacks);
+  const message = create$r(id, method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
 const createRpc = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks[id];
+  };
   const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, true);
+    },
     // @ts-ignore
     ipc,
     /**
      * @deprecated
      */
     send(method, ...params) {
-      send$2(ipc, method, ...params);
-    },
-    invoke(method, ...params) {
-      return invoke$1(ipc, method, ...params);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$1(ipc, method, ...params);
-    },
-    async dispose() {
-      await ipc?.dispose();
+      const message = create$s(method, params);
+      ipc.send(message);
     }
   };
   return rpc;
@@ -3167,7 +3216,7 @@ const logError$1 = () => {
 const handleMessage$1 = event => {
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket$1;
   const actualExecute = event?.target?.execute || execute$1;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError$1, actualRequiresSocket);
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError$1, actualRequiresSocket);
 };
 const handleIpc$1 = ipc => {
   if ('addEventListener' in ipc) {
@@ -3185,13 +3234,13 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$k = async ({
+const create$p = async ({
   commandMap,
   messagePort,
   requiresSocket
 }) => {
   // TODO create a commandMap per rpc instance
-  register$1(commandMap);
+  register(commandMap);
   const ipc = await listen$1(IpcChildWithElectronMessagePort$1, {
     messagePort
   });
@@ -3204,25 +3253,25 @@ const create$k = async ({
 };
 const ElectronMessagePortRpcClient = {
   __proto__: null,
-  create: create$k
+  create: create$p
 };
-const create$i = async ({
+const create$n = async ({
+  argv,
   commandMap,
   env,
-  argv,
   execArgv,
-  path,
   name,
+  path,
   requiresSocket
 }) => {
   // TODO create a commandMap per rpc instance
-  register$1(commandMap);
+  register(commandMap);
   const rawIpc = await IpcParentWithElectronUtilityProcess$1$1.create({
-    env,
     argv,
+    env,
     execArgv,
-    path,
-    name
+    name,
+    path
   });
   const ipc = IpcParentWithElectronUtilityProcess$1$1.wrap(rawIpc);
   if (requiresSocket) {
@@ -3235,15 +3284,15 @@ const create$i = async ({
 };
 const ElectronUtilityProcessRpcParent = {
   __proto__: null,
-  create: create$i
+  create: create$n
 };
-const create$h = async ({
+const create$m = async ({
   commandMap,
-  webContents,
-  requiresSocket
+  requiresSocket,
+  webContents
 }) => {
   // TODO create a commandMap per rpc instance
-  register$1(commandMap);
+  register(commandMap);
   const ipc = IpcChildWithRendererProcess2$1.wrap(webContents);
   if (requiresSocket) {
     // @ts-ignore
@@ -3255,7 +3304,7 @@ const create$h = async ({
 };
 const ElectronWebContentsRpcClient = {
   __proto__: null,
-  create: create$h
+  create: create$m
 };
 
 const commandMapRef = Object.create(null);
@@ -3411,7 +3460,7 @@ const launchSharedProcess = async ({
   return sharedProcessRpc;
 };
 
-const state$6 = {
+const state$5 = {
   /**
    * @type {any}
    */
@@ -3422,14 +3471,14 @@ const getOrCreate = async ({
   env = {},
   method
 }) => {
-  if (!state$6.promise) {
+  if (!state$5.promise) {
     // @ts-ignore
-    state$6.promise = launchSharedProcess({
+    state$5.promise = launchSharedProcess({
       env,
       method
     });
   }
-  return state$6.promise;
+  return state$5.promise;
 };
 const send$1 = async (method, ...params) => {
   const rpc = await getOrCreate({
@@ -4557,14 +4606,14 @@ const createTitleBar = items => {
 
 const PHASE_DEFAULT = 0;
 const PHASE_SHUTDOWN = -1;
-const state$5 = {
+const state$4 = {
   phase: PHASE_DEFAULT
 };
 const isShutDown = () => {
-  return state$5.phase === PHASE_SHUTDOWN;
+  return state$4.phase === PHASE_SHUTDOWN;
 };
 const setShutDown = () => {
-  state$5.phase = PHASE_SHUTDOWN;
+  state$4.phase = PHASE_SHUTDOWN;
 };
 
 // TODO move this function to shared process
@@ -4869,21 +4918,21 @@ const BeforeInputEvent = 'before-input-event';
 const Allow = 'allow';
 const Deny = 'deny';
 
-const state$4 = {
+const state$3 = {
   canceled: Object.create(null),
   fallThroughKeyBindings: [],
   views: Object.create(null)
 };
 const add$1 = (id, browserWindow, view) => {
   // state
-  state$4.views[id] = {
+  state$3.views[id] = {
     browserWindow,
     view
   };
 };
 const hasWebContents = id => {
   number(id);
-  return id in state$4.views;
+  return id in state$3.views;
 };
 /**
  *
@@ -4891,19 +4940,19 @@ const hasWebContents = id => {
  * @returns {{browserWindow: Electron.BrowserWindow, view: Electron.WebContentsView}}
  */
 const get$3 = id => {
-  return state$4.views[id];
+  return state$3.views[id];
 };
 const remove$1 = id => {
-  delete state$4.views[id];
+  delete state$3.views[id];
 };
 const setFallthroughKeyBindings = fallthroughKeyBindings => {
-  state$4.fallThroughKeyBindings = fallthroughKeyBindings;
+  state$3.fallThroughKeyBindings = fallthroughKeyBindings;
 };
 const getFallthroughKeyBindings = () => {
-  return state$4.fallThroughKeyBindings;
+  return state$3.fallThroughKeyBindings;
 };
 const setCanceled = id => {
-  state$4.canceled[id] = true;
+  state$3.canceled[id] = true;
 };
 
 const shouldAllowNavigation = webContentsId => {
@@ -5065,197 +5114,6 @@ const {
   argv
 } = process;
 
-const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
-const E_MODULE_NOT_FOUND = 'E_MODULE_NOT_FOUND';
-
-class CommandNotFoundError extends Error {
-  constructor(id) {
-    super(`command ${id} not found`);
-    this.name = 'CommandNotFoundError';
-    // @ts-ignore
-    this.code = E_COMMAND_NOT_FOUND;
-  }
-}
-
-const App = 1;
-const AppWindow = 2;
-const Beep = 3;
-const Developer = 4;
-const Dialog = 5;
-const ElectronWindowProcessExplorer = 6;
-const Window = 7;
-const ElectronShell = 8;
-const ElectronPowerSaveBlocker = 9;
-const ElectronSafeStorage = 10;
-const ElectronContentTracing = 11;
-const ElectronNetLog = 12;
-const ElectronBrowserView = 13;
-const ElectronBrowserViewQuickPick = 14;
-const ElectronContextMenu = 16;
-const ElectronClipBoard = 17;
-const ElectronApplicationMenu = 18;
-const Process = 19;
-const ElectronNet = 20;
-const ElectronBrowserViewSuggestions = 21;
-const CreatePidMap = 22;
-const OpenExternal$1 = 23;
-const Platform = 25;
-const GetWindowId = 26;
-const DesktopCapturer = 27;
-const Trash = 28;
-const IpcParent = 29;
-const Crash = 30;
-const Exit = 31;
-const ElectronScreen = 32;
-const TemporaryMessagePort = 34;
-const ElectronWebContents = 35;
-const ElectronWebContentsView = 36;
-const ElectronWebContentsViewFunctions = 37;
-const CreateMessagePort = 38;
-const HandleElectronMessagePort = 39;
-const ElectronSession = 40;
-
-const getPrefix = commandId => {
-  return commandId.slice(0, commandId.indexOf('.'));
-};
-const getModuleId = commandId => {
-  const prefix = getPrefix(commandId);
-  switch (prefix) {
-    case 'App':
-    case 'ElectronApp':
-      return App;
-    case 'AppWindow':
-      return AppWindow;
-    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 'ElectronBrowserView':
-      return ElectronBrowserView;
-    case 'ElectronBrowserViewQuickPick':
-      return ElectronBrowserViewQuickPick;
-    case 'ElectronBrowserViewSuggestions':
-      return ElectronBrowserViewSuggestions;
-    case 'ElectronClipBoard':
-      return ElectronClipBoard;
-    case 'ElectronContentTracing':
-      return ElectronContentTracing;
-    case 'ElectronContextMenu':
-      return ElectronContextMenu;
-    case 'ElectronDeveloper':
-      return Developer;
-    case 'ElectronDialog':
-      return Dialog;
-    case 'ElectronNet':
-      return ElectronNet;
-    case 'ElectronNetLog':
-      return ElectronNetLog;
-    case 'ElectronPowerSaveBlocker':
-      return ElectronPowerSaveBlocker;
-    case 'ElectronSafeStorage':
-      return ElectronSafeStorage;
-    case 'ElectronScreen':
-      return ElectronScreen;
-    case 'ElectronSession':
-      return ElectronSession;
-    case 'ElectronShell':
-      return ElectronShell;
-    case 'ElectronWebContents':
-      return ElectronWebContents;
-    case 'ElectronWebContentsView':
-      return ElectronWebContentsView;
-    case 'ElectronWebContentsViewFunctions':
-      return ElectronWebContentsViewFunctions;
-    case 'ElectronWindow':
-      return Window;
-    case 'ElectronWindowProcessExplorer':
-      return ElectronWindowProcessExplorer;
-    case 'Exit':
-      return Exit;
-    case 'GetWindowId':
-      return GetWindowId;
-    case 'HandleElectronMessagePort':
-      return HandleElectronMessagePort;
-    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);
-  }
-};
-
-const state$3 = {
-  commands: Object.create(null),
-  async load(moduleId) {},
-  pendingModules: Object.create(null)
-};
-const initializeModule = module => {
-  if (module.Commands) {
-    for (const [key, value] of Object.entries(module.Commands)) {
-      if (module.name) {
-        const actualKey = `${module.name}.${key}`;
-        register(actualKey, value);
-      } else {
-        register(key, value);
-      }
-    }
-    return;
-  }
-  throw new Error(`module ${module.name || '<unnamed module>'} is missing commands`);
-};
-const getOrLoadModule = moduleId => {
-  if (!state$3.pendingModules[moduleId]) {
-    const importPromise = state$3.load(moduleId);
-    state$3.pendingModules[moduleId] = importPromise.then(initializeModule);
-  }
-  return state$3.pendingModules[moduleId];
-};
-const loadCommand = command => getOrLoadModule(getModuleId(command));
-const register = (commandId, listener) => {
-  state$3.commands[commandId] = listener;
-};
-const hasThrown = new Set();
-const loadThenExecute = async (command, ...args) => {
-  await loadCommand(command);
-  // TODO can skip then block in prod (only to prevent endless loop in dev)
-  if (!(command in state$3.commands)) {
-    if (hasThrown.has(command)) {
-      return;
-    }
-    hasThrown.add(command);
-    throw new Error(`Command did not register "${command}"`);
-  }
-  return execute(command, ...args);
-};
-const execute = (command, ...args) => {
-  if (command in state$3.commands) {
-    return state$3.commands[command](...args);
-  }
-  return loadThenExecute(command, ...args);
-};
-const setLoad = load => {
-  state$3.load = load;
-};
-
 const ClipBoardRead = 'clipboard-read';
 const ClipBoardSanitizedWrite = 'clipboard-sanitized-write';
 const FullScreen = 'fullscreen';
@@ -5704,45 +5562,144 @@ const stopRecording = () => {
   return contentTracing.stopRecording();
 };
 
-const getPerformanceEntries = () => {
-  const entries = getEntries();
-  const {
-    timeOrigin
-  } = Performance;
+const withResolvers = () => {
+  /**
+   * @type {any}
+   */
+  let _resolve;
+  /**
+   * @type {any}
+   */
+  let _reject;
+  const promise = new Promise((resolve, reject) => {
+    _resolve = resolve;
+    _reject = reject;
+  });
   return {
-    entries,
-    timeOrigin
+    promise,
+    reject: _reject,
+    resolve: _resolve
   };
 };
-const crashMainProcess = () => {
-  throw new Error('oops');
-};
-
-const Error$1 = 'error';
 
-const getWindowById = windowId => {
-  number(windowId);
-  return Electron.BrowserWindow.fromId(windowId);
+const getElectronCallbacks = () => {
+  const {
+    promise,
+    resolve
+  } = withResolvers();
+  const handleClick = menuItem => {
+    resolve({
+      data: menuItem,
+      type: 'click'
+    });
+  };
+  const handleClose = () => {
+    resolve({
+      data: undefined,
+      type: 'close'
+    });
+  };
+  return {
+    handleClick,
+    handleClose,
+    promise
+  };
 };
 
-const executeWindowFunction = (browserWindowId, key) => {
-  const browserWindow = getWindowById(browserWindowId);
-  if (!browserWindow) {
-    info(`[main-process] browser window not found ${browserWindow}`);
-    return;
-  }
-  browserWindow[key]();
-};
-const executeWebContentsFunction = (browserWindowId, key, ...args) => {
-  const browserWindow = getWindowById(browserWindowId);
-  if (!browserWindow) {
-    info(`[main-process] browser window not found ${browserWindow}`);
-    return;
+const getElectronMenuItems = (menuItems, click) => {
+  const template = [];
+  for (const menuItem of menuItems) {
+    // @ts-ignore
+    template.push({
+      ...menuItem,
+      click
+    });
   }
-  browserWindow.webContents[key](...args);
-};
-const getFocusedWindow = () => {
-  return Electron.BrowserWindow.getFocusedWindow() || undefined;
+  return template;
+};
+
+const openContextMenu = async (menuItems, x, y) => {
+  array(menuItems);
+  number(x);
+  number(y);
+  const {
+    handleClick,
+    handleClose,
+    promise
+  } = getElectronCallbacks();
+  const template = getElectronMenuItems(menuItems, handleClick);
+  const menu = Menu.buildFromTemplate(template);
+  // TODO pass window id
+  const window = BrowserWindow.getFocusedWindow();
+  if (!window) {
+    return {
+      data: undefined,
+      type: 'close'
+    };
+  }
+  menu.popup({
+    callback: handleClose,
+    window,
+    x,
+    y
+  });
+  const event = await promise;
+  // @ts-ignore
+  if (event.type === 'click') {
+    return {
+      // @ts-ignore
+      data: event.data.label,
+      type: 'click'
+    };
+  }
+  // @ts-ignore
+  if (event.type === 'close') {
+    return {
+      data: undefined,
+      type: 'close'
+    };
+  }
+};
+
+const getPerformanceEntries = () => {
+  const entries = getEntries();
+  const {
+    timeOrigin
+  } = Performance;
+  return {
+    entries,
+    timeOrigin
+  };
+};
+const crashMainProcess = () => {
+  throw new Error('oops');
+};
+
+const Error$1 = 'error';
+
+const getWindowById = windowId => {
+  number(windowId);
+  return Electron.BrowserWindow.fromId(windowId);
+};
+
+const executeWindowFunction = (browserWindowId, key) => {
+  const browserWindow = getWindowById(browserWindowId);
+  if (!browserWindow) {
+    info(`[main-process] browser window not found ${browserWindow}`);
+    return;
+  }
+  browserWindow[key]();
+};
+const executeWebContentsFunction = (browserWindowId, key, ...args) => {
+  const browserWindow = getWindowById(browserWindowId);
+  if (!browserWindow) {
+    info(`[main-process] browser window not found ${browserWindow}`);
+    return;
+  }
+  browserWindow.webContents[key](...args);
+};
+const getFocusedWindow = () => {
+  return Electron.BrowserWindow.getFocusedWindow() || undefined;
 };
 const findById = windowId => {
   return getWindowById(windowId);
@@ -6992,6 +6949,13 @@ const printPrettyError = (prettyError, prefix = '') => {
   error(`${prefix}${prettyError.type}: ${prettyError.message}\n\n${prettyError.codeFrame}\n\n${prettyError.stack}\n`);
 };
 
+const execute = (method, ...params) => {
+  const fn = commandMapRef[method];
+  if (!fn) {
+    throw new Error(`command not found: ${method}`);
+  }
+  return fn(...params);
+};
 const logError = (error, prettyError) => {
   printPrettyError(prettyError, '[main-process] ');
 };
@@ -7169,6 +7133,7 @@ const shouldOpenExternal = url => {
 };
 
 const openExternal = async url => {
+  string(url);
   if (!shouldOpenExternal(url)) {
     throw new VError(`only http or https urls are allowed`);
   }
@@ -7299,6 +7264,7 @@ const commandMap = {
   'ElectronBeep.beep': beep,
   'ElectronContentTracing.startRecording': startRecording,
   'ElectronContentTracing.stopRecording': stopRecording,
+  'ElectronContextMenu.openContextMenu': openContextMenu,
   'ElectronDeveloper.crashMainProcess': crashMainProcess,
   'ElectronDeveloper.getPerformanceEntries': getPerformanceEntries,
   'ElectronDialog.showMessageBox': showMessageBox,
@@ -7369,88 +7335,6 @@ const commandMap = {
   'Trash.trash': trash
 };
 
-class ModuleNotFoundError extends Error {
-  constructor(id) {
-    super(`Module ${id} not found`);
-    this.name = 'ModuleNotFoundError';
-    // @ts-ignore
-    this.code = E_MODULE_NOT_FOUND;
-  }
-}
-
-const load = async moduleId => {
-  switch (moduleId) {
-    case App:
-      return Promise.resolve().then(function () { return App_ipc; });
-    case AppWindow:
-      return Promise.resolve().then(function () { return AppWindow_ipc; });
-    case Beep:
-      return Promise.resolve().then(function () { return Beep_ipc; });
-    case Crash:
-      return Promise.resolve().then(function () { return Crash_ipc; });
-    case CreateMessagePort:
-      return Promise.resolve().then(function () { return CreateMessagePort_ipc; });
-    case CreatePidMap:
-      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:
-      return Promise.resolve().then(function () { return ElectronClipBoard_ipc; });
-    case ElectronContentTracing:
-      return Promise.resolve().then(function () { return ElectronContentTracing_ipc; });
-    case ElectronContextMenu:
-      return Promise.resolve().then(function () { return ElectronContextMenu_ipc; });
-    case ElectronNet:
-      return Promise.resolve().then(function () { return ElectronNet_ipc; });
-    case ElectronNetLog:
-      return Promise.resolve().then(function () { return ElectronNetLog_ipc; });
-    case ElectronPowerSaveBlocker:
-      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 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 TemporaryMessagePort:
-      return Promise.resolve().then(function () { return TemporaryMessagePort_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);
-  }
-};
-
 const setStackTraceLimit = value => {
   if (Error.stackTraceLimit && Error.stackTraceLimit < value) {
     Error.stackTraceLimit = value;
@@ -7465,518 +7349,7 @@ const main = async () => {
   on$1('uncaughtExceptionMonitor', handleUncaughtExceptionMonitor);
   // workaround for https://github.com/electron/electron/issues/36526
   on$1('unhandledRejection', handleUnhandledRejection);
-  setLoad(load);
   await hydrate(isLinux, chromeUserDataPath, argv);
 };
 
 main();
-
-const name$w = 'App';
-const Commands$w = {};
-
-const App_ipc = {
-	__proto__: null,
-	Commands: Commands$w,
-	name: name$w
-};
-
-const name$v = 'AppWindow';
-const Commands$v = {
-  createAppWindow: createAppWindow
-};
-
-const AppWindow_ipc = {
-	__proto__: null,
-	Commands: Commands$v,
-	name: name$v
-};
-
-const name$u = 'Beep';
-const Commands$u = {
-  beep: beep$1
-};
-
-const Beep_ipc = {
-	__proto__: null,
-	Commands: Commands$u,
-	name: name$u
-};
-
-const name$t = 'Crash';
-const Commands$t = {
-  crashMainProcess: crashMainProcess$1
-};
-
-const Crash_ipc = {
-	__proto__: null,
-	Commands: Commands$t,
-	name: name$t
-};
-
-const name$s = 'CreateMessagePort';
-const Commands$s = {
-  createMessagePort: createMessagePort
-};
-
-const CreateMessagePort_ipc = {
-	__proto__: null,
-	Commands: Commands$s,
-	name: name$s
-};
-
-const name$r = 'CreatePidMap';
-const Commands$r = {
-  createPidMap: createPidMap
-};
-
-const CreatePidMap_ipc = {
-	__proto__: null,
-	Commands: Commands$r,
-	name: name$r
-};
-
-const name$q = 'DesktopCapturer';
-const Commands$q = {
-  getSources: getSources
-};
-
-const DesktopCapturer_ipc = {
-	__proto__: null,
-	Commands: Commands$q,
-	name: name$q
-};
-
-const name$p = 'ElectronDeveloper';
-const Commands$p = {
-  crashMainProcess: crashMainProcess,
-  getPerformanceEntries: getPerformanceEntries
-};
-
-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$m = 'ElectronClipBoard';
-const Commands$m = {
-  writeText: writeText
-};
-
-const ElectronClipBoard_ipc = {
-	__proto__: null,
-	Commands: Commands$m,
-	name: name$m
-};
-
-const name$l = 'ElectronContentTracing';
-const Commands$l = {
-  startRecording: startRecording,
-  stopRecording: stopRecording
-};
-
-const ElectronContentTracing_ipc = {
-	__proto__: null,
-	Commands: Commands$l,
-	name: name$l
-};
-
-const withResolvers = () => {
-  /**
-   * @type {any}
-   */
-  let _resolve;
-  /**
-   * @type {any}
-   */
-  let _reject;
-  const promise = new Promise((resolve, reject) => {
-    _resolve = resolve;
-    _reject = reject;
-  });
-  return {
-    promise,
-    reject: _reject,
-    resolve: _resolve
-  };
-};
-
-const getElectronCallbacks = () => {
-  const {
-    promise,
-    resolve
-  } = withResolvers();
-  const handleClick = menuItem => {
-    resolve({
-      data: menuItem,
-      type: 'click'
-    });
-  };
-  const handleClose = () => {
-    resolve({
-      data: undefined,
-      type: 'close'
-    });
-  };
-  return {
-    handleClick,
-    handleClose,
-    promise
-  };
-};
-
-const getElectronMenuItems = (menuItems, click) => {
-  const template = [];
-  for (const menuItem of menuItems) {
-    // @ts-ignore
-    template.push({
-      ...menuItem,
-      click
-    });
-  }
-  return template;
-};
-
-// @ts-ignore
-const openContextMenu = async (menuItems, x, y) => {
-  array(menuItems);
-  number(x);
-  number(y);
-  const {
-    handleClick,
-    handleClose,
-    promise
-  } = getElectronCallbacks();
-  const template = getElectronMenuItems(menuItems, handleClick);
-  const menu = Menu.buildFromTemplate(template);
-  const window = BrowserWindow.getFocusedWindow();
-  if (!window) {
-    return {
-      data: undefined,
-      type: 'close'
-    };
-  }
-  menu.popup({
-    callback: handleClose,
-    window,
-    x,
-    y
-  });
-  const event = await promise;
-  // @ts-ignore
-  if (event.type === 'click') {
-    return {
-      // @ts-ignore
-      data: event.data.label,
-      type: 'click'
-    };
-  }
-  // @ts-ignore
-  if (event.type === 'close') {
-    return {
-      data: undefined,
-      type: 'close'
-    };
-  }
-};
-
-const name$k = 'ElectronContextMenu';
-const Commands$k = {
-  openContextMenu: openContextMenu
-};
-
-const ElectronContextMenu_ipc = {
-	__proto__: null,
-	Commands: Commands$k,
-	name: name$k
-};
-
-const name$j = 'ElectronNet';
-const Commands$j = {
-  getJson: getJson
-};
-
-const ElectronNet_ipc = {
-	__proto__: null,
-	Commands: Commands$j,
-	name: name$j
-};
-
-const name$i = 'ElectronNetLog';
-const Commands$i = {
-  startLogging: startLogging,
-  stopLogging: stopLogging
-};
-
-const ElectronNetLog_ipc = {
-	__proto__: null,
-	Commands: Commands$i,
-	name: name$i
-};
-
-const name$h = 'ElectronPowerSaveBlocker';
-const Commands$h = {
-  start: start,
-  stop: stop
-};
-
-const ElectronPowerSaveBlocker_ipc = {
-	__proto__: null,
-	Commands: Commands$h,
-	name: name$h
-};
-
-const name$g = 'ElectronSafeStorage';
-const Commands$g = {
-  decrypt: decrypt,
-  encrypt: encrypt,
-  isEncryptionAvailable: isEncryptionAvailable
-};
-
-const ElectronSafeStorage_ipc = {
-	__proto__: null,
-	Commands: Commands$g,
-	name: name$g
-};
-
-const name$f = 'ElectronScreen';
-const Commands$f = {
-  getBounds: getBounds,
-  getHeight: getHeight,
-  getWidth: getWidth
-};
-
-const ElectronScreen_ipc = {
-	__proto__: null,
-	Commands: Commands$f,
-	name: name$f
-};
-
-const name$e = 'ElectronSession';
-const Commands$e = {
-  registerWebviewProtocol: registerWebviewProtocol
-};
-
-const ElectronSession_ipc = {
-	__proto__: null,
-	Commands: Commands$e,
-	name: name$e
-};
-
-const name$d = 'ElectronShell';
-const Commands$d = {
-  beep: beep$1,
-  openExternal: openExternal,
-  openPath: showItemInFolder,
-  showItemInFolder: showItemInFolder
-};
-
-const ElectronShell_ipc = {
-	__proto__: null,
-	Commands: Commands$d,
-	name: name$d
-};
-
-const name$c = 'ElectronWebContents';
-const Commands$c = {
-  callFunction: callFunction,
-  dispose: dispose$1,
-  getStats: getStats$1
-};
-
-const ElectronWebContents_ipc = {
-	__proto__: null,
-	Commands: Commands$c,
-	name: name$c
-};
-
-const name$b = 'ElectronWebContentsView';
-const Commands$b = {
-  attachEventListeners: attachEventListeners,
-  createWebContentsView: createWebContentsView,
-  disposeWebContentsView: disposeWebContentsView
-};
-
-const ElectronWebContentsView_ipc = {
-	__proto__: null,
-	Commands: Commands$b,
-	name: name$b
-};
-
-const name$a = 'ElectronWebContentsViewFunctions';
-const Commands$a = {
-  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 ElectronWebContentsViewFunctions_ipc = {
-	__proto__: null,
-	Commands: Commands$a,
-	name: name$a
-};
-
-const name$9 = 'ElectronWindowProcessExplorer';
-const Commands$9 = {
-  open2: open2
-};
-
-const ElectronWindowProcessExplorer_ipc = {
-	__proto__: null,
-	Commands: Commands$9,
-	name: name$9
-};
-
-const name$8 = 'Exit';
-const Commands$8 = {
-  exit: exit
-};
-
-const Exit_ipc = {
-	__proto__: null,
-	Commands: Commands$8,
-	name: name$8
-};
-
-const name$7 = 'GetWindowId';
-const Commands$7 = {
-  getWindowId: getWindowId
-};
-
-const GetWindowId_ipc = {
-	__proto__: null,
-	Commands: Commands$7,
-	name: name$7
-};
-
-const name$6 = 'HandleElectronMessagePort';
-const Commands$6 = {
-  handleElectronMessagePort: handleElectronMessagePort
-};
-
-const HandleElectronMessagePort_ipc = {
-	__proto__: null,
-	Commands: Commands$6,
-	name: name$6
-};
-
-const name$5 = 'IpcParent';
-const Commands$5 = {
-  create: create$1
-};
-
-const IpcParent_ipc = {
-	__proto__: null,
-	Commands: Commands$5,
-	name: name$5
-};
-
-const name$4 = 'OpenExternal';
-const Commands$4 = {
-  openExternal: openExternal
-};
-
-const OpenExternal_ipc = {
-	__proto__: null,
-	Commands: Commands$4,
-	name: name$4
-};
-
-const name$3 = 'Process';
-const Commands$3 = {
-  getArgv: getArgv,
-  getChromeVersion: getChromeVersion,
-  getElectronVersion: getElectronVersion,
-  getNodeVersion: getNodeVersion,
-  getPid: getPid,
-  getV8Version: getV8Version
-};
-
-const Process_ipc = {
-	__proto__: null,
-	Commands: Commands$3,
-	name: name$3
-};
-
-const name$2 = 'TemporaryMessagePort';
-const Commands$2 = {
-  createPortTuple: createPortTuple,
-  dispose: dispose,
-  sendTo: sendTo
-};
-
-const TemporaryMessagePort_ipc = {
-	__proto__: null,
-	Commands: Commands$2,
-	name: name$2
-};
-
-const name$1 = 'Trash';
-const Commands$1 = {
-  trash: trash
-};
-
-const Trash_ipc = {
-	__proto__: null,
-	Commands: Commands$1,
-	name: name$1
-};
-
-const name = 'ElectronWindow';
-const Commands = {
-  executeWebContentsFunction: executeWebContentsFunction,
-  executeWindowFunction: executeWindowFunction,
-  getFocusedWindowId: getFocusedWindowId,
-  getZoom: getZoom
-};
-
-const ElectronWindow_ipc = {
-	__proto__: null,
-	Commands,
-	name
-};