@lvce-editor/iframe-worker 6.0.0 → 6.1.0

package/dist/iframeWorkerMain.js

@@ -90,6 +90,12 @@ const getType = value => {
       return Unknown;
   }
 };
+const object = value => {
+  const type = getType(value);
+  if (type !== Object$1) {
+    throw new AssertionError('expected value to be of type object');
+  }
+};
 const number = value => {
   const type = getType(value);
   if (type !== Number) {
@@ -515,7 +521,7 @@ const create$4$1 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$3 = (id, fn) => {
+const set$4 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get$2 = id => {
@@ -534,7 +540,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$3(id, resolve);
+  set$4(id, resolve);
   return {
     id,
     promise
@@ -879,10 +885,10 @@ const send = (transport, method, ...params) => {
   const message = create$4$1(method, params);
   transport.send(message);
 };
-const invoke$6 = (ipc, method, ...params) => {
+const invoke$5 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer$5 = (ipc, method, ...params) => {
+const invokeAndTransfer$4 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
@@ -918,10 +924,10 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$6(ipc, method, ...params);
+      return invoke$5(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$5(ipc, method, ...params);
+      return invokeAndTransfer$4(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -1067,7 +1073,7 @@ const ExtensionHostWorker = 44;
 const RendererWorker$1 = 1;
 
 const rpcs$1 = Object.create(null);
-const set$2 = (id, rpc) => {
+const set$3 = (id, rpc) => {
   if (rpcs$1[id]) {
     throw new Error(`rpc with id ${id} is already registered`);
   }
@@ -1096,32 +1102,34 @@ const create$2 = rpcId => {
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$2(rpcId, rpc);
+      set$3(rpcId, rpc);
     }
   };
 };
 
 const {
-  invoke: invoke$5,
-  invokeAndTransfer: invokeAndTransfer$4} = create$2(ExtensionHostWorker);
+  invoke: invoke$4,
+  invokeAndTransfer: invokeAndTransfer$3,
+  set: set$2
+} = create$2(ExtensionHostWorker);
 
 const {
   dispose,
-  invoke: invoke$4,
-  invokeAndTransfer: invokeAndTransfer$3,
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$2,
   set: set$1
 } = create$2(RendererWorker$1);
 const searchFileHtml = async uri => {
-  return invoke$4('ExtensionHost.searchFileWithHtml', uri);
+  return invoke$3('ExtensionHost.searchFileWithHtml', uri);
 };
 const getFilePathElectron = async file => {
-  return invoke$4('FileSystemHandle.getFilePathElectron', file);
+  return invoke$3('FileSystemHandle.getFilePathElectron', file);
 };
 /**
  * @deprecated
  */
 const showContextMenu = async (x, y, id, ...args) => {
-  return invoke$4('ContextMenu.show', x, y, id, ...args);
+  return invoke$3('ContextMenu.show', x, y, id, ...args);
 };
 const showContextMenu2 = async (uid, menuId, x, y, args) => {
   number(uid);
@@ -1129,294 +1137,294 @@ const showContextMenu2 = async (uid, menuId, x, y, args) => {
   number(x);
   number(y);
   // @ts-ignore
-  await invoke$4('ContextMenu.show2', uid, menuId, x, y, args);
+  await invoke$3('ContextMenu.show2', uid, menuId, x, y, args);
 };
 const getElectronVersion = async () => {
-  return invoke$4('Process.getElectronVersion');
+  return invoke$3('Process.getElectronVersion');
 };
 const applyBulkReplacement = async bulkEdits => {
-  await invoke$4('BulkReplacement.applyBulkReplacement', bulkEdits);
+  await invoke$3('BulkReplacement.applyBulkReplacement', bulkEdits);
 };
 const setColorTheme = async id => {
   // @ts-ignore
-  return invoke$4(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
+  return invoke$3(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
 };
 const getNodeVersion = async () => {
-  return invoke$4('Process.getNodeVersion');
+  return invoke$3('Process.getNodeVersion');
 };
 const getChromeVersion = async () => {
-  return invoke$4('Process.getChromeVersion');
+  return invoke$3('Process.getChromeVersion');
 };
 const getV8Version = async () => {
-  return invoke$4('Process.getV8Version');
+  return invoke$3('Process.getV8Version');
 };
 const getFileHandles = async fileIds => {
-  const files = await invoke$4('FileSystemHandle.getFileHandles', fileIds);
+  const files = await invoke$3('FileSystemHandle.getFileHandles', fileIds);
   return files;
 };
 const setWorkspacePath = async path => {
-  await invoke$4('Workspace.setPath', path);
+  await invoke$3('Workspace.setPath', path);
 };
 const registerWebViewInterceptor = async (id, port) => {
-  await invokeAndTransfer$3('WebView.registerInterceptor', id, port);
+  await invokeAndTransfer$2('WebView.registerInterceptor', id, port);
 };
 const unregisterWebViewInterceptor = async id => {
-  await invoke$4('WebView.unregisterInterceptor', id);
+  await invoke$3('WebView.unregisterInterceptor', id);
 };
 const sendMessagePortToEditorWorker = async (port, rpcId) => {
   const command = 'HandleMessagePort.handleMessagePort';
   // @ts-ignore
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
+  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
 };
 const sendMessagePortToErrorWorker = async (port, rpcId) => {
   const command = 'Errors.handleMessagePort';
   // @ts-ignore
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
+  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
 };
 const sendMessagePortToMarkdownWorker = async (port, rpcId) => {
   const command = 'Markdown.handleMessagePort';
   // @ts-ignore
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToMarkdownWorker', port, command, rpcId);
+  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToMarkdownWorker', port, command, rpcId);
 };
 const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
   const command = 'IconTheme.handleMessagePort';
   // @ts-ignore
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
+  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
 };
 const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
   const command = 'FileSystem.handleMessagePort';
   // @ts-ignore
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
+  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
 };
 const readFile$1 = async uri => {
-  return invoke$4('FileSystem.readFile', uri);
+  return invoke$3('FileSystem.readFile', uri);
 };
 const getWebViewSecret = async key => {
   // @ts-ignore
-  return invoke$4('WebView.getSecret', key);
+  return invoke$3('WebView.getSecret', key);
 };
 const setWebViewPort = async (uid, port, origin, portType) => {
-  return invokeAndTransfer$3('WebView.setPort', uid, port, origin, portType);
+  return invokeAndTransfer$2('WebView.setPort', uid, port, origin, portType);
 };
 const setFocus = key => {
-  return invoke$4('Focus.setFocus', key);
+  return invoke$3('Focus.setFocus', key);
 };
 const getFileIcon = async options => {
-  return invoke$4('IconTheme.getFileIcon', options);
+  return invoke$3('IconTheme.getFileIcon', options);
 };
 const getColorThemeNames = async () => {
-  return invoke$4('ColorTheme.getColorThemeNames');
+  return invoke$3('ColorTheme.getColorThemeNames');
 };
 const disableExtension = async id => {
   // @ts-ignore
-  return invoke$4('ExtensionManagement.disable', id);
+  return invoke$3('ExtensionManagement.disable', id);
 };
 const enableExtension = async id => {
   // @ts-ignore
-  return invoke$4('ExtensionManagement.enable', id);
+  return invoke$3('ExtensionManagement.enable', id);
 };
 const handleDebugChange = async params => {
   // @ts-ignore
-  return invoke$4('Run And Debug.handleChange', params);
+  return invoke$3('Run And Debug.handleChange', params);
 };
 const getFolderIcon = async options => {
-  return invoke$4('IconTheme.getFolderIcon', options);
+  return invoke$3('IconTheme.getFolderIcon', options);
 };
 const handleWorkspaceRefresh = async () => {
-  return invoke$4('Layout.handleWorkspaceRefresh');
+  return invoke$3('Layout.handleWorkspaceRefresh');
 };
 const closeWidget = async widgetId => {
-  return invoke$4('Viewlet.closeWidget', widgetId);
+  return invoke$3('Viewlet.closeWidget', widgetId);
 };
 const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
   const command = 'HandleMessagePort.handleMessagePort2';
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
 };
 const sendMessagePortToSearchProcess = async port => {
-  await invokeAndTransfer$3('SendMessagePortToElectron.sendMessagePortToElectron', port, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
+  await invokeAndTransfer$2('SendMessagePortToElectron.sendMessagePortToElectron', port, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
 };
 const confirm = async (message, options) => {
   // @ts-ignore
-  const result = await invoke$4('ConfirmPrompt.prompt', message, options);
+  const result = await invoke$3('ConfirmPrompt.prompt', message, options);
   return result;
 };
 const getRecentlyOpened = async () => {
-  return invoke$4(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
+  return invoke$3(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
 };
 const getKeyBindings = async () => {
-  return invoke$4('KeyBindingsInitial.getKeyBindings');
+  return invoke$3('KeyBindingsInitial.getKeyBindings');
 };
 const writeClipBoardText = async text => {
-  await invoke$4('ClipBoard.writeText', /* text */text);
+  await invoke$3('ClipBoard.writeText', /* text */text);
 };
 const readClipBoardText = async () => {
-  return invoke$4('ClipBoard.readText');
+  return invoke$3('ClipBoard.readText');
 };
 const writeClipBoardImage = async blob => {
   // @ts-ignore
-  await invoke$4('ClipBoard.writeImage', /* text */blob);
+  await invoke$3('ClipBoard.writeImage', /* text */blob);
 };
 const searchFileMemory = async uri => {
   // @ts-ignore
-  return invoke$4('ExtensionHost.searchFileWithMemory', uri);
+  return invoke$3('ExtensionHost.searchFileWithMemory', uri);
 };
 const searchFileFetch = async uri => {
-  return invoke$4('ExtensionHost.searchFileWithFetch', uri);
+  return invoke$3('ExtensionHost.searchFileWithFetch', uri);
 };
 const showMessageBox = async options => {
-  return invoke$4('ElectronDialog.showMessageBox', options);
+  return invoke$3('ElectronDialog.showMessageBox', options);
 };
 const handleDebugResumed = async params => {
-  await invoke$4('Run And Debug.handleResumed', params);
+  await invoke$3('Run And Debug.handleResumed', params);
 };
 const openWidget = async name => {
-  await invoke$4('Viewlet.openWidget', name);
+  await invoke$3('Viewlet.openWidget', name);
 };
 const getIcons = async requests => {
-  const icons = await invoke$4('IconTheme.getIcons', requests);
+  const icons = await invoke$3('IconTheme.getIcons', requests);
   return icons;
 };
 const activateByEvent = event => {
-  return invoke$4('ExtensionHostManagement.activateByEvent', event);
+  return invoke$3('ExtensionHostManagement.activateByEvent', event);
 };
 const setAdditionalFocus = focusKey => {
   // @ts-ignore
-  return invoke$4('Focus.setAdditionalFocus', focusKey);
+  return invoke$3('Focus.setAdditionalFocus', focusKey);
 };
 const getActiveEditorId = () => {
   // @ts-ignore
-  return invoke$4('GetActiveEditor.getActiveEditorId');
+  return invoke$3('GetActiveEditor.getActiveEditorId');
 };
 const getWorkspacePath = () => {
-  return invoke$4('Workspace.getPath');
+  return invoke$3('Workspace.getPath');
 };
 const sendMessagePortToRendererProcess = async port => {
   const command = 'HandleMessagePort.handleMessagePort';
   // @ts-ignore
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
+  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
 };
 const sendMessagePortToTextMeasurementWorker = async port => {
   const command = 'TextMeasurement.handleMessagePort';
   // @ts-ignore
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToTextMeasurementWorker', port, command, 0);
+  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToTextMeasurementWorker', port, command, 0);
 };
 const sendMessagePortToSourceControlWorker = async port => {
   const command = 'SourceControl.handleMessagePort';
   // @ts-ignore
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToSourceControlWorker', port, command, 0);
+  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToSourceControlWorker', port, command, 0);
 };
 const sendMessagePortToSharedProcess = async port => {
   const command = 'HandleElectronMessagePort.handleElectronMessagePort';
   // @ts-ignore
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, 0);
+  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, 0);
 };
 const sendMessagePortToFileSystemProcess = async (port, rpcId) => {
   const command = 'HandleMessagePortForFileSystemProcess.handleMessagePortForFileSystemProcess';
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, rpcId);
+  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, rpcId);
 };
 const sendMessagePortToIframeWorker = async (port, rpcId) => {
   const command = 'Iframes.handleMessagePort';
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToIframeWorker', port, command, rpcId);
+  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToIframeWorker', port, command, rpcId);
 };
 const sendMessagePortToExtensionManagementWorker = async (port, rpcId) => {
   const command = 'Extensions.handleMessagePort';
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionManagementWorker', port, command, rpcId);
+  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionManagementWorker', port, command, rpcId);
 };
 const getPreference = async key => {
-  return await invoke$4('Preferences.get', key);
+  return await invoke$3('Preferences.get', key);
 };
 const getAllExtensions = async () => {
-  return invoke$4('ExtensionManagement.getAllExtensions');
+  return invoke$3('ExtensionManagement.getAllExtensions');
 };
 const rerenderEditor = async key => {
   // @ts-ignore
-  return invoke$4('Editor.rerender', key);
+  return invoke$3('Editor.rerender', key);
 };
 const handleDebugPaused = async params => {
-  await invoke$4('Run And Debug.handlePaused', params);
+  await invoke$3('Run And Debug.handlePaused', params);
 };
 const openUri = async (uri, focus, options) => {
-  await invoke$4('Main.openUri', uri, focus, options);
+  await invoke$3('Main.openUri', uri, focus, options);
 };
 const sendMessagePortToSyntaxHighlightingWorker = async port => {
-  await invokeAndTransfer$3(
+  await invokeAndTransfer$2(
   // @ts-ignore
   'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
 };
 const handleDebugScriptParsed = async script => {
-  await invoke$4('Run And Debug.handleScriptParsed', script);
+  await invoke$3('Run And Debug.handleScriptParsed', script);
 };
 const getWindowId = async () => {
-  return invoke$4('GetWindowId.getWindowId');
+  return invoke$3('GetWindowId.getWindowId');
 };
 const getBlob = async uri => {
   // @ts-ignore
-  return invoke$4('FileSystem.getBlob', uri);
+  return invoke$3('FileSystem.getBlob', uri);
 };
 const getExtensionCommands = async () => {
-  return invoke$4('ExtensionHost.getCommands');
+  return invoke$3('ExtensionHost.getCommands');
 };
 const showErrorDialog = async errorInfo => {
   // @ts-ignore
-  await invoke$4('ErrorHandling.showErrorDialog', errorInfo);
+  await invoke$3('ErrorHandling.showErrorDialog', errorInfo);
 };
 const getFolderSize = async uri => {
   // @ts-ignore
-  return await invoke$4('FileSystem.getFolderSize', uri);
+  return await invoke$3('FileSystem.getFolderSize', uri);
 };
 const getExtension = async id => {
   // @ts-ignore
-  return invoke$4('ExtensionManagement.getExtension', id);
+  return invoke$3('ExtensionManagement.getExtension', id);
 };
 const getMarkdownDom = async html => {
   // @ts-ignore
-  return invoke$4('Markdown.getVirtualDom', html);
+  return invoke$3('Markdown.getVirtualDom', html);
 };
 const renderMarkdown = async (markdown, options) => {
   // @ts-ignore
-  return invoke$4('Markdown.renderMarkdown', markdown, options);
+  return invoke$3('Markdown.renderMarkdown', markdown, options);
 };
 const openNativeFolder = async uri => {
   // @ts-ignore
-  await invoke$4('OpenNativeFolder.openNativeFolder', uri);
+  await invoke$3('OpenNativeFolder.openNativeFolder', uri);
 };
 const uninstallExtension = async id => {
-  return invoke$4('ExtensionManagement.uninstall', id);
+  return invoke$3('ExtensionManagement.uninstall', id);
 };
 const installExtension = async id => {
   // @ts-ignore
-  return invoke$4('ExtensionManagement.install', id);
+  return invoke$3('ExtensionManagement.install', id);
 };
 const openExtensionSearch = async () => {
   // @ts-ignore
-  return invoke$4('SideBar.openViewlet', 'Extensions');
+  return invoke$3('SideBar.openViewlet', 'Extensions');
 };
 const setExtensionsSearchValue = async searchValue => {
   // @ts-ignore
-  return invoke$4('Extensions.handleInput', searchValue, Script);
+  return invoke$3('Extensions.handleInput', searchValue, Script);
 };
 const openExternal = async uri => {
   // @ts-ignore
-  await invoke$4('Open.openExternal', uri);
+  await invoke$3('Open.openExternal', uri);
 };
 const openUrl = async uri => {
   // @ts-ignore
-  await invoke$4('Open.openUrl', uri);
+  await invoke$3('Open.openUrl', uri);
 };
 const getAllPreferences = async () => {
   // @ts-ignore
-  return invoke$4('Preferences.getAll');
+  return invoke$3('Preferences.getAll');
 };
 const showSaveFilePicker = async () => {
   // @ts-ignore
-  return invoke$4('FilePicker.showSaveFilePicker');
+  return invoke$3('FilePicker.showSaveFilePicker');
 };
 const getLogsDir = async () => {
   // @ts-ignore
-  return invoke$4('PlatformPaths.getLogsDir');
+  return invoke$3('PlatformPaths.getLogsDir');
 };
 const measureTextBlockHeight = async (actualInput, fontFamily, fontSize, lineHeightPx, width) => {
-  return invoke$4(`MeasureTextHeight.measureTextBlockHeight`, actualInput, fontFamily, fontSize, lineHeightPx, width);
+  return invoke$3(`MeasureTextHeight.measureTextBlockHeight`, actualInput, fontFamily, fontSize, lineHeightPx, width);
 };
 const registerMockRpc = commandMap => {
   const mockRpc = createMockRpc({
@@ -1466,8 +1474,8 @@ const RendererWorker = {
   handleDebugScriptParsed,
   handleWorkspaceRefresh,
   installExtension,
-  invoke: invoke$4,
-  invokeAndTransfer: invokeAndTransfer$3,
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$2,
   measureTextBlockHeight,
   openExtensionSearch,
   openExternal,
@@ -1724,13 +1732,11 @@ const getPortTuple = () => {
 };
 
 const {
-  invoke: invoke$3,
-  invokeAndTransfer: invokeAndTransfer$2
-} = RendererWorker;
+  invoke: invoke$2} = RendererWorker;
 
 const getSavedState = async () => {
   // @ts-ignore
-  return invoke$3('WebView.getSavedState');
+  return invoke$2('WebView.getSavedState');
 };
 
 const getSavedWebViewState = async id => {
@@ -1848,7 +1854,7 @@ const getPort = () => {
   return location.port;
 };
 
-const invoke$2 = async (method, ...params) => {
+const invoke$1 = async (method, ...params) => {
   // @ts-ignore
   return invoke$3('WebView.compatRendererProcessInvoke', method, ...params);
 };
@@ -1863,28 +1869,28 @@ const setPort = async (uid, port, origin, portType) => {
   await invokeAndTransfer$1('WebView.setPort', uid, port, origin, portType);
 };
 
-const invoke$1 = async (method, ...params) => {
+const invoke = async (method, ...params) => {
   // @ts-ignore
   return invoke$3('WebView.compatSharedProcessInvoke', method, ...params);
 };
 
 const registerProtocol = async () => {
-  await invoke$1('WebViewServer.registerProtocol');
+  await invoke('WebViewServer.registerProtocol');
 };
 const create = async (previewServerId, useNewWebViewHandler) => {
-  await invoke$1('WebViewServer.create', previewServerId, useNewWebViewHandler);
+  await invoke('WebViewServer.create', previewServerId, useNewWebViewHandler);
 };
 const start = async (previewServerId, webViewPort) => {
-  await invoke$1('WebViewServer.start', previewServerId, webViewPort);
+  await invoke('WebViewServer.start', previewServerId, webViewPort);
 };
 const setInfo2 = async info => {
-  await invoke$1('WebViewServer.setInfo2', info);
+  await invoke('WebViewServer.setInfo2', info);
 };
 const setInfo = async (previewServerId, webViewId, webViewRoot, contentSecurityPolicy, iframeContent) => {
-  await invoke$1('WebViewServer.setInfo', previewServerId, webViewId, webViewRoot, contentSecurityPolicy, iframeContent);
+  await invoke('WebViewServer.setInfo', previewServerId, webViewId, webViewRoot, contentSecurityPolicy, iframeContent);
 };
 const setHandler = async (previewServerId, frameAncestors, webViewRoot, contentSecurityPolicy, iframeContent, remotePathPrefix) => {
-  await invoke$1('WebViewServer.setHandler', previewServerId, frameAncestors, webViewRoot, contentSecurityPolicy, iframeContent);
+  await invoke('WebViewServer.setHandler', previewServerId, frameAncestors, webViewRoot, contentSecurityPolicy, iframeContent);
 };
 
 const register$3 = async (previewServerId, webViewPort, frameAncestors, webViewRoot, csp, iframeContent, webViewId, remotePathPrefix, useNewWebViewHandler) => {
@@ -1950,7 +1956,7 @@ const create2 = async ({
 }) => {
   let root = '';
   if (platform === Remote) {
-    root = await invoke$1('Platform.getRoot');
+    root = await invoke('Platform.getRoot');
   }
   const webViews = await getWebViews();
   const locationProtocol = getProtocol$1();
@@ -1982,7 +1988,7 @@ const create2 = async ({
   const permissionPolicyString = permissionPolicy.join('; ');
   const iframeCsp = platform === Web ? csp : '';
   const credentialless = getCredentialLess(locationHost);
-  await invoke$3('ExtensionHostManagement.activateByEvent', `onWebView:${webViewId}`);
+  await invoke$2('ExtensionHostManagement.activateByEvent', `onWebView:${webViewId}`);
   const {
     port1,
     port2
@@ -1990,18 +1996,18 @@ const create2 = async ({
   const portId = create$1();
   const remotePathPrefix = '/remote';
   await register(previewServerId, webViewPort, frameAncestors, webViewRoot, csp, iframeContent, platform, webViewId, remotePathPrefix);
-  await invoke$2('WebView.create', id, iframeSrc, sandbox, iframeCsp, credentialless, permissionPolicyString, frameTitle);
+  await invoke$1('WebView.create', id, iframeSrc, sandbox, iframeCsp, credentialless, permissionPolicyString, frameTitle);
 
   // TODO maybe iframe waitForLoad is not needed. since it cannot be used detect errors anyway
   // and causes flash of unstyled content, maybe a better way would be to just send the
   // port and wait for the first port message
-  await invoke$2('WebView.load', id);
+  await invoke$1('WebView.load', id);
   const origin = getWebViewOrigin(webViewPort, platform, webViewScheme, webViewId);
   const portType = '';
   await setPort(id, port1, origin, portType);
-  await invokeAndTransfer$4('ExtensionHostWebView.create', webViewId, port2, uri, id, origin, webView);
+  await invokeAndTransfer$3('ExtensionHostWebView.create', webViewId, port2, uri, id, origin, webView);
   const savedState = await getSavedWebViewState(webViewId);
-  await invoke$5('ExtensionHostWebView.load', webViewId, savedState);
+  await invoke$4('ExtensionHostWebView.load', webViewId, savedState);
   return {
     csp: iframeCsp,
     iframeSrc,
@@ -2012,36 +2018,38 @@ const create2 = async ({
 };
 
 const createAndLoadWebView = async (id, iframeSrc, sandbox, iframeCsp, credentialless, permissionPolicyString, frameTitle) => {
-  await invoke$2('WebView.create', id, iframeSrc, sandbox, iframeCsp, credentialless, permissionPolicyString, frameTitle);
+  await invoke$1('WebView.create', id, iframeSrc, sandbox, iframeCsp, credentialless, permissionPolicyString, frameTitle);
 
   // TODO maybe iframe waitForLoad is not needed. since it cannot be used detect errors anyway
   // and causes flash of unstyled content, maybe a better way would be to just send the
   // port and wait for the first port message
-  await invoke$2('WebView.load', id);
+  await invoke$1('WebView.load', id);
 };
 
-const invoke = async (method, ...params) => {
-  // @ts-ignore
-  return invoke$3('WebView.compatRendererWorkerInvoke', method, ...params);
+const createSecondaryWebViewConnection = async (uid, origin, port) => {
+  const portType = 'application';
+  await invokeAndTransfer$2('WebView.setPort', uid, port, origin, portType);
 };
+
 const invokeAndTransfer = async (method, ...params) => {
   // @ts-ignore
-  return invokeAndTransfer$2('WebView.compatRendererWorkerInvokeAndTransfer', method, ...params);
-};
-
-const createSecondaryWebViewConnection = async (uid, origin, port) => {
-  const portType = 'application';
-  await invokeAndTransfer('WebView.setPort', uid, port, origin, portType);
+  return invokeAndTransfer$2(method, ...params);
 };
 
 const createWebViewConnection = async (uid, origin) => {
-  const rpc = await TransferMessagePortRpcParent.create({
+  const {
+    port1,
+    port2
+  } = getPortTuple();
+  const rpcPromise = MessagePortRpcParent.create({
     commandMap: {},
-    async send(port) {
-      const portType = 'test';
-      await invokeAndTransfer('WebView.setPort', uid, port, origin, portType);
-    }
+    isMessagePortOpen: false,
+    messagePort: port2
   });
+  const portType = 'test';
+  await invokeAndTransfer('WebView.setPort', uid, port1, origin, portType);
+  // TODO dispose rpc to avoid memory leak
+  const rpc = await rpcPromise;
   return rpc;
 };
 
@@ -2063,7 +2071,7 @@ const getPortQuadruple = () => {
 };
 
 const readFile = uri => {
-  return invoke('FileSystem.readFile', uri);
+  return invoke$3('FileSystem.readFile', uri);
 };
 
 const RE_PROTOCOL = /^([a-z-]+):\/\//;
@@ -2094,9 +2102,11 @@ const getAll$1 = () => {
 // 5. provide objectUrl to extension
 
 const getRemoteUrlForWebView = async options => {
+  object(options);
   const webView = get(options.id);
+  object(webView);
   const rpcPromise = createWebViewConnection(webView.webViewUid, webView.origin);
-  const blobPromise = invoke('FileSystem.getBlob', options.uri);
+  const blobPromise = invoke$3('FileSystem.getBlob', options.uri);
   const [rpc, blob] = await Promise.all([rpcPromise, blobPromise]);
   const objectUrl = await rpc.invoke('createObjectUrl', blob);
   return objectUrl;
@@ -2142,7 +2152,7 @@ const getWebViewWorkerRpc2 = async rpcInfo => {
   const rpc = await TransferMessagePortRpcParent.create({
     commandMap: commandMap$1,
     async send(port) {
-      await invokeAndTransfer$4('WebView.createWebViewWorkerRpc2', rpcInfo, port);
+      await invokeAndTransfer$3('WebView.createWebViewWorkerRpc2', rpcInfo, port);
     }
   });
   // TODO
@@ -2259,7 +2269,7 @@ const getWebViewWorkerRpc = async rpcInfo => {
     isMessagePortOpen: true,
     messagePort: port2
   });
-  await invokeAndTransfer$4('WebView.createWebViewWorkerRpc', rpcInfo, port1);
+  await invokeAndTransfer$3('WebView.createWebViewWorkerRpc', rpcInfo, port1);
   const rpc = await rpcPromise;
   // TODO rpc module should start the port
   port2.start();
@@ -2300,7 +2310,7 @@ const createWebViewRpc = async (webView, savedState, uri, portId, webViewUid, or
   if (!webView || !webView.rpc || typeof webView.rpc !== 'string') {
     return;
   }
-  const rpcInfo = await invoke$5('WebView.getRpcInfo', webView.rpc);
+  const rpcInfo = await invoke$4('WebView.getRpcInfo', webView.rpc);
   if (rpcInfo && rpcInfo.type === 'web-worker-2') {
     return createWebWorkerRpc2(rpcInfo, webView, savedState, uri, portId, webViewUid, origin);
   }
@@ -2351,7 +2361,7 @@ const create3 = async ({
   setPlatform(platform);
   let root = '';
   if (platform === Remote) {
-    root = await invoke$1('Platform.getRoot');
+    root = await invoke('Platform.getRoot');
   }
   const webViews = await getWebViews();
   const webViewId = getWebViewId(webViews, uri);
@@ -2387,7 +2397,7 @@ const create3 = async ({
   const credentialless = getCredentialLess(locationHost);
 
   // TODO remove this
-  await invoke$3('ExtensionHostManagement.activateByEvent', `onWebView:${webViewId}`);
+  await invoke$2('ExtensionHostManagement.activateByEvent', `onWebView:${webViewId}`);
   const portId = create$1();
   const remotePathPrefix = '/remote';
   await register(previewServerId, webViewPort, frameAncestors, webViewRoot, csp, iframeContent, platform, webViewId, remotePathPrefix, useNewWebViewHandler);
@@ -2401,11 +2411,11 @@ const create3 = async ({
     } = getPortTuple();
     const portType = '';
     await setPort(id, port1, origin, portType);
-    await invokeAndTransfer$4('ExtensionHostWebView.create', webViewId, port2, uri, id, origin, webView);
+    await invokeAndTransfer$3('ExtensionHostWebView.create', webViewId, port2, uri, id, origin, webView);
   }
   const savedState = await getSavedWebViewState(webViewId);
   if (hasOldRpc) {
-    await invoke$5('ExtensionHostWebView.load', webViewId, savedState);
+    await invoke$4('ExtensionHostWebView.load', webViewId, savedState);
   }
   await createWebViewRpc(webView, savedState, uri, portId, id, origin);
   return {
@@ -2419,11 +2429,11 @@ const create3 = async ({
 
 const executeCommand = (method, ...params) => {
   // @ts-ignore
-  return invoke$3('ExecuteExternalCommand.executeExternalCommand', method, ...params);
+  return invoke$2('ExecuteExternalCommand.executeExternalCommand', method, ...params);
 };
 
 const getSecret = async key => {
-  return invoke('WebView.getSecret', key);
+  return invoke$3('WebView.getSecret', key);
 };
 
 const getWebViewInfo = webViewId => {
@@ -2440,15 +2450,27 @@ const getWebViewInfo = webViewId => {
 };
 
 const handleMessagePort2 = async (port, rpcId) => {
+  object(port);
   const rpc = await PlainMessagePortRpcParent.create({
     commandMap: {},
     messagePort: port
   });
   if (rpcId) {
-    set$2(rpcId, rpc);
+    set$3(rpcId, rpc);
   }
 };
 
+const initialize = async platform => {
+  setPlatform(platform);
+  const rpc = await TransferMessagePortRpcParent.create({
+    commandMap: {},
+    async send(port) {
+      await sendMessagePortToExtensionHostWorker(port, 0);
+    }
+  });
+  set$2(rpc);
+};
+
 const saveState = async () => {
   const all = getAll$1();
   const serialized = [];
@@ -2476,7 +2498,7 @@ const unregisterInterceptor = async id => {
 
 const commandMap = {
   'Iframes.handleMessagePort': handleMessagePort2,
-  'Iframes.initialize': handleMessagePort2,
+  'Iframes.initialize': initialize,
   'WebView.create2': create2,
   'WebView.create3': create3,
   'WebView.executeExternalCommand': executeCommand,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/iframe-worker",
-  "version": "6.0.0",
+  "version": "6.1.0",
   "description": "Web Worker to manage creation and lifecycle of iframes in Lvce Editor",
   "keywords": [
     "iframe"