@lvce-editor/embeds-worker 3.0.0 → 4.1.0

package/README.md

@@ -1 +1,12 @@
-# embeds-worker
+# Embeds Worker
+
+Web Worker for the embeds functionality in LVCE Editor.
+
+## Contributing
+
+```sh
+git clone git@github.com:lvce-editor/embeds-worker.git &&
+cd embeds-worker &&
+npm ci &&
+npm test
+```

package/dist/embedsWorkerMain.js

@@ -472,7 +472,7 @@ const create$4 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$3 = (id, fn) => {
+const set$5 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get$1 = id => {
@@ -491,7 +491,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$3(id, resolve);
+  set$5(id, resolve);
   return {
     id,
     promise
@@ -564,6 +564,17 @@ const constructError = (message, type, name) => {
   }
   return new ErrorConstructor(message);
 };
+const joinLines = lines => {
+  return lines.join(NewLine);
+};
+const splitLines = lines => {
+  return lines.split(NewLine);
+};
+const getCurrentStack = () => {
+  const stackLinesToSkip = 3;
+  const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
+  return currentStack;
+};
 const getNewLineIndex = (string, startIndex = undefined) => {
   return string.indexOf(NewLine, startIndex);
 };
@@ -574,19 +585,16 @@ const getParentStack = error => {
   }
   return parentStack;
 };
-const joinLines = lines => {
-  return lines.join(NewLine);
-};
 const MethodNotFound = -32601;
 const Custom = -32001;
-const splitLines = lines => {
-  return lines.split(NewLine);
-};
 const restoreJsonRpcError = error => {
+  const currentStack = getCurrentStack();
   if (error && error instanceof Error) {
+    if (typeof error.stack === 'string') {
+      error.stack = error.stack + NewLine + currentStack;
+    }
     return error;
   }
-  const currentStack = joinLines(splitLines(new Error().stack || '').slice(1));
   if (error && error.code && error.code === MethodNotFound) {
     const restoredError = new JsonRpcError(error.message);
     const parentStack = getParentStack(error);
@@ -667,6 +675,17 @@ const getErrorType = prettyError => {
   }
   return undefined;
 };
+const isAlreadyStack = line => {
+  return line.trim().startsWith('at ');
+};
+const getStack = prettyError => {
+  const stackString = prettyError.stack || '';
+  const newLineIndex = stackString.indexOf('\n');
+  if (newLineIndex !== -1 && !isAlreadyStack(stackString.slice(0, newLineIndex))) {
+    return stackString.slice(newLineIndex + 1);
+  }
+  return stackString;
+};
 const getErrorProperty = (error, prettyError) => {
   if (error && error.code === E_COMMAND_NOT_FOUND) {
     return {
@@ -679,7 +698,7 @@ const getErrorProperty = (error, prettyError) => {
     code: Custom,
     message: prettyError.message,
     data: {
-      stack: prettyError.stack,
+      stack: getStack(prettyError),
       codeFrame: prettyError.codeFrame,
       type: getErrorType(prettyError),
       code: prettyError.code,
@@ -687,18 +706,18 @@ const getErrorProperty = (error, prettyError) => {
     }
   };
 };
-const create$1$1 = (message, error) => {
+const create$1$1 = (id, error) => {
   return {
     jsonrpc: Two,
-    id: message.id,
+    id,
     error
   };
 };
-const getErrorResponse = (message, error, preparePrettyError, logError) => {
+const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1$1(message, errorProperty);
+  return create$1$1(id, errorProperty);
 };
 const create$5 = (message, result) => {
   return {
@@ -711,12 +730,27 @@ const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
   return create$5(message, resultProperty);
 };
+const getErrorResponseSimple = (id, error) => {
+  return {
+    jsonrpc: Two,
+    id,
+    error: {
+      code: Custom,
+      // @ts-ignore
+      message: error.message,
+      data: error
+    }
+  };
+};
 const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
   try {
     const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
     return getSuccessResponse(message, result);
   } catch (error) {
-    return getErrorResponse(message, error, preparePrettyError, logError);
+    if (ipc.canUseSimpleErrorResponse) {
+      return getErrorResponseSimple(message.id, error);
+    }
+    return getErrorResponse(message.id, error, preparePrettyError, logError);
   }
 };
 const defaultPreparePrettyError = error => {
@@ -771,7 +805,7 @@ const handleJsonRpcMessage = async (...args) => {
       try {
         ipc.send(response);
       } catch (error) {
-        const errorResponse = getErrorResponse(message, error, preparePrettyError, logError);
+        const errorResponse = getErrorResponse(message.id, error, preparePrettyError, logError);
         ipc.send(errorResponse);
       }
       return;
@@ -802,13 +836,19 @@ const send = (transport, method, ...params) => {
   const message = create$4(method, params);
   transport.send(message);
 };
-const invoke$3 = (ipc, method, ...params) => {
+const invoke$4 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer$1 = (ipc, method, ...params) => {
+const invokeAndTransfer$3 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
+  }
+}
 const commands = Object.create(null);
 const register = commandMap => {
   Object.assign(commands, commandMap);
@@ -819,7 +859,7 @@ const getCommand = key => {
 const execute = (command, ...args) => {
   const fn = getCommand(command);
   if (!fn) {
-    throw new Error(`command not found ${command}`);
+    throw new CommandNotFoundError(command);
   }
   return fn(...args);
 };
@@ -835,10 +875,10 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$3(ipc, method, ...params);
+      return invoke$4(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$1(ipc, method, ...params);
+      return invokeAndTransfer$3(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -876,7 +916,7 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$9 = async ({
+const create$e = async ({
   commandMap,
   messagePort,
   isMessagePortOpen
@@ -894,7 +934,7 @@ const create$9 = async ({
 };
 const MessagePortRpcParent = {
   __proto__: null,
-  create: create$9
+  create: create$e
 };
 const create$1 = async ({
   commandMap
@@ -910,17 +950,38 @@ const WebWorkerRpcClient = {
   __proto__: null,
   create: create$1
 };
+const createMockRpc = ({
+  commandMap
+}) => {
+  const invocations = [];
+  const invoke = (method, ...params) => {
+    invocations.push([method, ...params]);
+    const command = commandMap[method];
+    if (!command) {
+      throw new Error(`command ${method} not found`);
+    }
+    return command(...params);
+  };
+  const mockRpc = {
+    invoke,
+    invokeAndTransfer: invoke,
+    invocations
+  };
+  return mockRpc;
+};
+
+const DebugWorker = 55;
+const EmbedsProcess$1 = 207;
+const RendererWorker$1 = 1;
 
 const rpcs = Object.create(null);
-const set$7 = (id, rpc) => {
+const set$4 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get = id => {
   return rpcs[id];
 };
 
-/* eslint-disable  @typescript-eslint/explicit-function-return-type */
-
 const create = rpcId => {
   return {
     // @ts-ignore
@@ -936,46 +997,399 @@ const create = rpcId => {
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$7(rpcId, rpc);
+      set$4(rpcId, rpc);
+    },
+    async dispose() {
+      const rpc = get(rpcId);
+      await rpc.dispose();
     }
   };
 };
-const MainProcess$1 = -5;
-const RendererWorker$1 = 1;
+
 const {
-  invoke: invoke$5,
-  set: set$5
-} = create(MainProcess$1);
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$2,
+  set: set$3,
+  dispose: dispose$1
+} = create(EmbedsProcess$1);
+
 const EmbedsProcess = {
   __proto__: null,
-  invoke: invoke$5,
-  set: set$5
+  dispose: dispose$1,
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$2,
+  set: set$3
 };
+
 const {
   invoke: invoke$2,
-  invokeAndTransfer: invokeAndTransfer$2,
-  set: set$2
+  invokeAndTransfer: invokeAndTransfer$1,
+  set: set$2,
+  dispose
 } = create(RendererWorker$1);
+const searchFileHtml = async uri => {
+  return invoke$2('ExtensionHost.searchFileWithHtml', uri);
+};
+const getFilePathElectron = async file => {
+  return invoke$2('FileSystemHandle.getFilePathElectron', file);
+};
+const showContextMenu = async (x, y, id, ...args) => {
+  return invoke$2('ContextMenu.show', x, y, id, ...args);
+};
+const getElectronVersion = async () => {
+  return invoke$2('Process.getElectronVersion');
+};
+const applyBulkReplacement = async bulkEdits => {
+  await invoke$2('BulkReplacement.applyBulkReplacement', bulkEdits);
+};
+const setColorTheme = async id => {
+  // @ts-ignore
+  return invoke$2(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
+};
+const getNodeVersion = async () => {
+  return invoke$2('Process.getNodeVersion');
+};
+const getChromeVersion = async () => {
+  return invoke$2('Process.getChromeVersion');
+};
+const getV8Version = async () => {
+  return invoke$2('Process.getV8Version');
+};
+const getFileHandles = async fileIds => {
+  const files = await invoke$2('FileSystemHandle.getFileHandles', fileIds);
+  return files;
+};
+const setWorkspacePath = async path => {
+  await invoke$2('Workspace.setPath', path);
+};
+const registerWebViewInterceptor = async (id, port) => {
+  await invokeAndTransfer$1('WebView.registerInterceptor', id, port);
+};
+const unregisterWebViewInterceptor = async id => {
+  await invoke$2('WebView.unregisterInterceptor', id);
+};
+const sendMessagePortToEditorWorker = async (port, rpcId) => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
+};
+const sendMessagePortToErrorWorker = async (port, rpcId) => {
+  const command = 'Errors.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
+};
+const sendMessagePortToMarkdownWorker = async (port, rpcId) => {
+  const command = 'Markdown.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToMarkdownWorker', port, command, rpcId);
+};
+const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
+  const command = 'IconTheme.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
+};
+const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
+  const command = 'FileSystem.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
+};
+const readFile = async uri => {
+  return invoke$2('FileSystem.readFile', uri);
+};
+const getWebViewSecret = async key => {
+  // @ts-ignore
+  return invoke$2('WebView.getSecret', key);
+};
+const setWebViewPort = async (uid, port, origin, portType) => {
+  return invokeAndTransfer$1('WebView.setPort', uid, port, origin, portType);
+};
+const setFocus = key => {
+  return invoke$2('Focus.setFocus', key);
+};
+const getFileIcon = async options => {
+  return invoke$2('IconTheme.getFileIcon', options);
+};
+const getColorThemeNames = async () => {
+  return invoke$2('ColorTheme.getColorThemeNames');
+};
+const disableExtension = async id => {
+  // @ts-ignore
+  return invoke$2('ExtensionManagement.disable', id);
+};
+const enableExtension = async id => {
+  // @ts-ignore
+  return invoke$2('ExtensionManagement.enable', id);
+};
+const handleDebugChange = async params => {
+  // @ts-ignore
+  return invoke$2('Run And Debug.handleChange', params);
+};
+const getFolderIcon = async options => {
+  return invoke$2('IconTheme.getFolderIcon', options);
+};
+const closeWidget = async widgetId => {
+  return invoke$2('Viewlet.closeWidget', widgetId);
+};
+const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
+  const command = 'HandleMessagePort.handleMessagePort2';
+  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+};
+const sendMessagePortToSearchProcess = async port => {
+  await invokeAndTransfer$1('SendMessagePortToElectron.sendMessagePortToElectron', port, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
+};
+const confirm = async (message, options) => {
+  // @ts-ignore
+  const result = await invoke$2('ConfirmPrompt.prompt', message, options);
+  return result;
+};
+const getRecentlyOpened = async () => {
+  return invoke$2(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
+};
+const getKeyBindings = async () => {
+  return invoke$2('KeyBindingsInitial.getKeyBindings');
+};
+const writeClipBoardText = async text => {
+  await invoke$2('ClipBoard.writeText', /* text */text);
+};
+const writeClipBoardImage = async blob => {
+  // @ts-ignore
+  await invoke$2('ClipBoard.writeImage', /* text */blob);
+};
+const searchFileMemory = async uri => {
+  // @ts-ignore
+  return invoke$2('ExtensionHost.searchFileWithMemory', uri);
+};
+const searchFileFetch = async uri => {
+  return invoke$2('ExtensionHost.searchFileWithFetch', uri);
+};
+const showMessageBox = async options => {
+  return invoke$2('ElectronDialog.showMessageBox', options);
+};
+const handleDebugResumed = async params => {
+  await invoke$2('Run And Debug.handleResumed', params);
+};
+const openWidget = async name => {
+  await invoke$2('Viewlet.openWidget', name);
+};
+const getIcons = async requests => {
+  const icons = await invoke$2('IconTheme.getIcons', requests);
+  return icons;
+};
+const activateByEvent = event => {
+  return invoke$2('ExtensionHostManagement.activateByEvent', event);
+};
+const setAdditionalFocus = focusKey => {
+  // @ts-ignore
+  return invoke$2('Focus.setAdditionalFocus', focusKey);
+};
+const getActiveEditorId = () => {
+  // @ts-ignore
+  return invoke$2('GetActiveEditor.getActiveEditorId');
+};
+const getWorkspacePath = () => {
+  return invoke$2('Workspace.getPath');
+};
+const sendMessagePortToRendererProcess = async port => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
+};
+const getPreference = async key => {
+  return await invoke$2('Preferences.get', key);
+};
+const getAllExtensions = async () => {
+  return invoke$2('ExtensionManagement.getAllExtensions');
+};
+const rerenderEditor = async key => {
+  // @ts-ignore
+  return invoke$2('Editor.rerender', key);
+};
+const handleDebugPaused = async params => {
+  await invoke$2('Run And Debug.handlePaused', params);
+};
+const openUri = async (uri, focus, options) => {
+  await invoke$2('Main.openUri', uri, focus, options);
+};
+const sendMessagePortToSyntaxHighlightingWorker = async port => {
+  await invokeAndTransfer$1(
+  // @ts-ignore
+  'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
+};
+const handleDebugScriptParsed = async script => {
+  await invoke$2('Run And Debug.handleScriptParsed', script);
+};
+const getWindowId = async () => {
+  return invoke$2('GetWindowId.getWindowId');
+};
+const getBlob = async uri => {
+  // @ts-ignore
+  return invoke$2('FileSystem.getBlob', uri);
+};
+const getExtensionCommands = async () => {
+  return invoke$2('ExtensionHost.getCommands');
+};
+const showErrorDialog = async errorInfo => {
+  // @ts-ignore
+  await invoke$2('ErrorHandling.showErrorDialog', errorInfo);
+};
+const getFolderSize = async uri => {
+  // @ts-ignore
+  return await invoke$2('FileSystem.getFolderSize', uri);
+};
+const getExtension = async id => {
+  // @ts-ignore
+  return invoke$2('ExtensionManagement.getExtension', id);
+};
+const getMarkdownDom = async html => {
+  // @ts-ignore
+  return invoke$2('Markdown.getVirtualDom', html);
+};
+const renderMarkdown = async (markdown, options) => {
+  // @ts-ignore
+  return invoke$2('Markdown.renderMarkdown', markdown, options);
+};
+const openNativeFolder = async uri => {
+  // @ts-ignore
+  await invoke$2('OpenNativeFolder.openNativeFolder', uri);
+};
+const uninstallExtension = async id => {
+  return invoke$2('ExtensionManagement.uninstall', id);
+};
+const installExtension = async id => {
+  // @ts-ignore
+  return invoke$2('ExtensionManagement.install', id);
+};
+const openExtensionSearch = async () => {
+  // @ts-ignore
+  return invoke$2('SideBar.openViewlet', 'Extensions');
+};
+const setExtensionsSearchValue = async searchValue => {
+  // @ts-ignore
+  return invoke$2('Extensions.handleInput', searchValue);
+};
+const openExternal = async uri => {
+  // @ts-ignore
+  await invoke$2('Open.openExternal', uri);
+};
+const openUrl = async uri => {
+  // @ts-ignore
+  await invoke$2('Open.openUrl', uri);
+};
+const getAllPreferences = async () => {
+  // @ts-ignore
+  return invoke$2('Preferences.getAll');
+};
+const showSaveFilePicker = async () => {
+  // @ts-ignore
+  return invoke$2('FilePicker.showSaveFilePicker');
+};
+const getLogsDir = async () => {
+  // @ts-ignore
+  return invoke$2('PlatformPaths.getLogsDir');
+};
+const registerMockRpc = commandMap => {
+  const mockRpc = createMockRpc({
+    commandMap
+  });
+  set$2(mockRpc);
+  return mockRpc;
+};
+
 const RendererWorker = {
   __proto__: null,
+  activateByEvent,
+  applyBulkReplacement,
+  closeWidget,
+  confirm,
+  disableExtension,
+  dispose,
+  enableExtension,
+  getActiveEditorId,
+  getAllExtensions,
+  getAllPreferences,
+  getBlob,
+  getChromeVersion,
+  getColorThemeNames,
+  getElectronVersion,
+  getExtension,
+  getExtensionCommands,
+  getFileHandles,
+  getFileIcon,
+  getFilePathElectron,
+  getFolderIcon,
+  getFolderSize,
+  getIcons,
+  getKeyBindings,
+  getLogsDir,
+  getMarkdownDom,
+  getNodeVersion,
+  getPreference,
+  getRecentlyOpened,
+  getV8Version,
+  getWebViewSecret,
+  getWindowId,
+  getWorkspacePath,
+  handleDebugChange,
+  handleDebugPaused,
+  handleDebugResumed,
+  handleDebugScriptParsed,
+  installExtension,
   invoke: invoke$2,
-  invokeAndTransfer: invokeAndTransfer$2,
-  set: set$2
+  invokeAndTransfer: invokeAndTransfer$1,
+  openExtensionSearch,
+  openExternal,
+  openNativeFolder,
+  openUri,
+  openUrl,
+  openWidget,
+  readFile,
+  registerMockRpc,
+  registerWebViewInterceptor,
+  renderMarkdown,
+  rerenderEditor,
+  searchFileFetch,
+  searchFileHtml,
+  searchFileMemory,
+  sendMessagePortToEditorWorker,
+  sendMessagePortToErrorWorker,
+  sendMessagePortToExtensionHostWorker,
+  sendMessagePortToFileSystemWorker,
+  sendMessagePortToIconThemeWorker,
+  sendMessagePortToMarkdownWorker,
+  sendMessagePortToRendererProcess,
+  sendMessagePortToSearchProcess,
+  sendMessagePortToSyntaxHighlightingWorker,
+  set: set$2,
+  setAdditionalFocus,
+  setColorTheme,
+  setExtensionsSearchValue,
+  setFocus,
+  setWebViewPort,
+  setWorkspacePath,
+  showContextMenu,
+  showErrorDialog,
+  showMessageBox,
+  showSaveFilePicker,
+  uninstallExtension,
+  unregisterWebViewInterceptor,
+  writeClipBoardImage,
+  writeClipBoardText
 };
 
 const {
-  set: set$1,
-  invoke: invoke$1} = EmbedsProcess;
+  invoke: invoke$1,
+  set: set$1
+} = EmbedsProcess;
+
+const ERR_ABORTED = 'ERR_ABORTED';
+const ERR_FAILED = 'ERR_FAILED';
 
 const {
   invoke,
-  set,
-  invokeAndTransfer
+  invokeAndTransfer,
+  set
 } = RendererWorker;
 
-const ERR_ABORTED = 'ERR_ABORTED';
-const ERR_FAILED = 'ERR_FAILED';
-
 const createWebContentsView = async (restoreId, fallThroughKeyBindings) => {
   // @ts-ignore
   const id = await invoke$1('ElectronWebContentsView.createWebContentsView', restoreId, fallThroughKeyBindings);
@@ -985,7 +1399,6 @@ const disposeWebContentsView = id => {
   return invoke$1('ElectronWebContentsView.disposeWebContentsView', id);
 };
 const resizeWebContentsView = (id, x, y, width, height) => {
-  // @ts-ignore
   return invoke$1('ElectronWebContentsView.resizeBrowserView', id, x, y, width, height);
 };
 const setIframeSrcFallback = async (id, error) => {
@@ -993,12 +1406,10 @@ const setIframeSrcFallback = async (id, error) => {
     code,
     message
   } = error;
-  // @ts-ignore
   await invoke$1('ElectronWebContentsView.setIframeSrcFallback', id, code, message);
 };
 const setIframeSrc = async (id, iframeSrc) => {
   try {
-    // @ts-ignore
     await invoke$1('ElectronWebContentsView.setIframeSrc', id, iframeSrc);
   } catch (error) {
     console.log({
@@ -1006,11 +1417,13 @@ const setIframeSrc = async (id, iframeSrc) => {
     });
     // TODO send error back to embeds worker,
     // embeds worker decides how to handle error
+
     // @ts-ignore
     if (error && error.code === ERR_ABORTED) {
       console.info(`[embeds worker] navigation to ${iframeSrc} aborted`);
       return;
     }
+
     // @ts-ignore
     if (error && error.code === ERR_FAILED) {
       console.info(`[embeds worker] navigation to ${iframeSrc} canceled`);
@@ -1025,63 +1438,49 @@ const setIframeSrc = async (id, iframeSrc) => {
   }
 };
 const focus = id => {
-  // @ts-ignore
   return invoke$1('ElectronWebContentsView.focus', id);
 };
 const openDevtools = id => {
-  // @ts-ignore
   return invoke$1('ElectronWebContentsView.openDevtools', id);
 };
 const reload = id => {
-  // @ts-ignore
   return invoke$1('ElectronWebContentsView.reload', id);
 };
 const show = id => {
-  // @ts-ignore
   return invoke$1('ElectronWebContentsView.show', id);
 };
 const hide = id => {
-  // @ts-ignore
   return invoke$1('ElectronWebContentsView.hide', id);
 };
 const forward = id => {
-  // @ts-ignore
   return invoke$1('ElectronWebContentsView.forward', id);
 };
 const backward = id => {
-  // @ts-ignore
   return invoke$1('ElectronWebContentsView.backward', id);
 };
 const getDomTree = id => {
-  // @ts-ignore
   return invoke$1('ElectronWebContentsView.getDomTree', id);
 };
 const insertCss = (id, css) => {
-  // @ts-ignore
   return invoke$1('ElectronWebContentsView.insertCss', id, css);
 };
 const insertJavaScript = (id, code) => {
-  // @ts-ignore
   return invoke$1('ElectronWebContentsView.insertJavaScript', id, code);
 };
 const cancelNavigation = id => {
-  // @ts-ignore
   return invoke$1('ElectronWebContentsView.cancelNavigation', id);
 };
 const inspectElement = (id, x, y) => {
-  // @ts-ignore
   return invoke$1('ElectronWebContentsView.inspectElement', id, x, y);
 };
 const copyImageAt = (id, x, y) => {
-  // @ts-ignore
   return invoke$1('ElectronWebContentsView.copyImageAt', id, x, y);
 };
-const setFallthroughKeyBindings = (id, fallthroughKeybindings) => {
+const setFallthroughKeyBindings = async (id, fallthroughKeybindings) => {
   // TODO
   // return EmbedsProcess.invoke('ElectronWebContentsView.setFallthroughKeyBindings', id, fallthroughKeybindings)
 };
 const getStats = (id, fallthroughKeybindings) => {
-  // @ts-ignore
   return invoke$1('ElectronWebContentsView.getStats', id, fallthroughKeybindings);
 };
 const forwardEvent = key => (id, ...args) => {
@@ -1093,7 +1492,7 @@ const handleWillNavigate = forwardEvent('ElectronBrowserView.handleWillNavigate'
 const handleContextMenu = forwardEvent('ElectronBrowserView.handleContextMenu');
 
 const exit = () => {
-  self.close();
+  globalThis.close();
 };
 
 const getPortTuple = () => {
@@ -1126,8 +1525,8 @@ const createEmbedsProcessRpc = async () => {
     port1.start();
     const rpc = await MessagePortRpcParent.create({
       commandMap: {},
-      messagePort: port1,
-      isMessagePortOpen: true
+      isMessagePortOpen: true,
+      messagePort: port1
     });
     // TODO createMessageportRpcParent should call port start
     return rpc;

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@lvce-editor/embeds-worker",
-  "version": "3.0.0",
-  "description": "",
-  "main": "dist/embedsWorkerMain.js",
+  "version": "4.1.0",
+  "description": "Web Worker to manage electron webcontent views in Lvce Editor",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:lvce-editor/embeds-worker.git"
+  },
+  "license": "MIT",
+  "author": "Lvce Editor",
   "type": "module",
-  "keywords": [],
-  "author": "",
-  "license": "MIT"
+  "main": "dist/embedsWorkerMain.js"
 }