@lvce-editor/iframe-worker 5.36.0 → 6.1.0

package/dist/iframeWorkerMain.js

@@ -54,6 +54,55 @@ class VError extends Error {
   }
 }
 
+class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AssertionError';
+  }
+}
+const Object$1 = 1;
+const Number = 2;
+const Array$1 = 3;
+const String = 4;
+const Boolean = 5;
+const Function = 6;
+const Null = 7;
+const Unknown = 8;
+const getType = value => {
+  switch (typeof value) {
+    case 'number':
+      return Number;
+    case 'function':
+      return Function;
+    case 'string':
+      return String;
+    case 'object':
+      if (value === null) {
+        return Null;
+      }
+      if (Array.isArray(value)) {
+        return Array$1;
+      }
+      return Object$1;
+    case 'boolean':
+      return Boolean;
+    default:
+      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) {
+    throw new AssertionError('expected value to be of type number');
+  }
+};
+
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
 };
@@ -464,7 +513,7 @@ const IpcParentWithMessagePort$1 = {
 };
 
 const Two = '2.0';
-const create$4 = (method, params) => {
+const create$4$1 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -472,7 +521,7 @@ const create$4 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$3 = (id, fn) => {
+const set$4 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get$2 = id => {
@@ -491,7 +540,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$3(id, resolve);
+  set$4(id, resolve);
   return {
     id,
     promise
@@ -719,7 +768,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$5 = (message, result) => {
+const create$7 = (message, result) => {
   return {
     jsonrpc: Two,
     id: message.id,
@@ -728,7 +777,7 @@ const create$5 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$5(message, resultProperty);
+  return create$7(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
@@ -833,13 +882,13 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   return unwrapJsonRpcResult(responseMessage);
 };
 const send = (transport, method, ...params) => {
-  const message = create$4(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);
 };
 
@@ -875,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();
@@ -936,7 +985,54 @@ const MessagePortRpcParent = {
   __proto__: null,
   create: create$e
 };
+const create$5 = async ({
+  commandMap,
+  messagePort
+}) => {
+  // TODO create a commandMap per rpc instance
+  register$4(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    messagePort,
+    isMessagePortOpen: true
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  messagePort.start();
+  return rpc;
+};
+const create$4 = async ({
+  commandMap,
+  messagePort
+}) => {
+  return create$5({
+    commandMap,
+    messagePort
+  });
+};
+const PlainMessagePortRpcParent = {
+  __proto__: null,
+  create: create$4
+};
 const create$3 = async ({
+  commandMap,
+  send
+}) => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  await send(port1);
+  return create$5({
+    commandMap,
+    messagePort: port2
+  });
+};
+const TransferMessagePortRpcParent = {
+  __proto__: null,
+  create: create$3
+};
+const create$6 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -948,14 +1044,39 @@ const create$3 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$3
+  create: create$6
+};
+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 Script = 2;
+
 const DebugWorker = 55;
+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`);
+  }
   rpcs$1[id] = rpc;
 };
 const get$1 = id => {
@@ -964,6 +1085,10 @@ const get$1 = id => {
 
 const create$2 = rpcId => {
   return {
+    async dispose() {
+      const rpc = get$1(rpcId);
+      await rpc.dispose();
+    },
     // @ts-ignore
     invoke(method, ...params) {
       const rpc = get$1(rpcId);
@@ -977,275 +1102,336 @@ const create$2 = rpcId => {
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$2(rpcId, rpc);
-    },
-    async dispose() {
-      const rpc = get$1(rpcId);
-      await rpc.dispose();
+      set$3(rpcId, rpc);
     }
   };
 };
 
 const {
-  invoke: invoke$5,
-  invokeAndTransfer: invokeAndTransfer$4,
-  set: set$1,
-  dispose
+  invoke: invoke$4,
+  invokeAndTransfer: invokeAndTransfer$3,
+  set: set$2
+} = create$2(ExtensionHostWorker);
+
+const {
+  dispose,
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$2,
+  set: set$1
 } = create$2(RendererWorker$1);
 const searchFileHtml = async uri => {
-  return invoke$5('ExtensionHost.searchFileWithHtml', uri);
+  return invoke$3('ExtensionHost.searchFileWithHtml', uri);
 };
 const getFilePathElectron = async file => {
-  return invoke$5('FileSystemHandle.getFilePathElectron', file);
+  return invoke$3('FileSystemHandle.getFilePathElectron', file);
 };
+/**
+ * @deprecated
+ */
 const showContextMenu = async (x, y, id, ...args) => {
-  return invoke$5('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);
+  number(menuId);
+  number(x);
+  number(y);
+  // @ts-ignore
+  await invoke$3('ContextMenu.show2', uid, menuId, x, y, args);
 };
 const getElectronVersion = async () => {
-  return invoke$5('Process.getElectronVersion');
+  return invoke$3('Process.getElectronVersion');
 };
 const applyBulkReplacement = async bulkEdits => {
-  await invoke$5('BulkReplacement.applyBulkReplacement', bulkEdits);
+  await invoke$3('BulkReplacement.applyBulkReplacement', bulkEdits);
 };
 const setColorTheme = async id => {
   // @ts-ignore
-  return invoke$5(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
+  return invoke$3(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
 };
 const getNodeVersion = async () => {
-  return invoke$5('Process.getNodeVersion');
+  return invoke$3('Process.getNodeVersion');
 };
 const getChromeVersion = async () => {
-  return invoke$5('Process.getChromeVersion');
+  return invoke$3('Process.getChromeVersion');
 };
 const getV8Version = async () => {
-  return invoke$5('Process.getV8Version');
+  return invoke$3('Process.getV8Version');
 };
 const getFileHandles = async fileIds => {
-  const files = await invoke$5('FileSystemHandle.getFileHandles', fileIds);
+  const files = await invoke$3('FileSystemHandle.getFileHandles', fileIds);
   return files;
 };
 const setWorkspacePath = async path => {
-  await invoke$5('Workspace.setPath', path);
+  await invoke$3('Workspace.setPath', path);
 };
 const registerWebViewInterceptor = async (id, port) => {
-  await invokeAndTransfer$4('WebView.registerInterceptor', id, port);
+  await invokeAndTransfer$2('WebView.registerInterceptor', id, port);
 };
 const unregisterWebViewInterceptor = async id => {
-  await invoke$5('WebView.unregisterInterceptor', id);
+  await invoke$3('WebView.unregisterInterceptor', id);
 };
 const sendMessagePortToEditorWorker = async (port, rpcId) => {
   const command = 'HandleMessagePort.handleMessagePort';
   // @ts-ignore
-  await invokeAndTransfer$4('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$4('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$4('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$2('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
 };
 const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
   const command = 'FileSystem.handleMessagePort';
   // @ts-ignore
-  await invokeAndTransfer$4('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
+  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
 };
 const readFile$1 = async uri => {
-  return invoke$5('FileSystem.readFile', uri);
+  return invoke$3('FileSystem.readFile', uri);
 };
 const getWebViewSecret = async key => {
   // @ts-ignore
-  return invoke$5('WebView.getSecret', key);
+  return invoke$3('WebView.getSecret', key);
 };
 const setWebViewPort = async (uid, port, origin, portType) => {
-  return invokeAndTransfer$4('WebView.setPort', uid, port, origin, portType);
+  return invokeAndTransfer$2('WebView.setPort', uid, port, origin, portType);
 };
 const setFocus = key => {
-  return invoke$5('Focus.setFocus', key);
+  return invoke$3('Focus.setFocus', key);
 };
 const getFileIcon = async options => {
-  return invoke$5('IconTheme.getFileIcon', options);
+  return invoke$3('IconTheme.getFileIcon', options);
 };
 const getColorThemeNames = async () => {
-  return invoke$5('ColorTheme.getColorThemeNames');
+  return invoke$3('ColorTheme.getColorThemeNames');
 };
 const disableExtension = async id => {
   // @ts-ignore
-  return invoke$5('ExtensionManagement.disable', id);
+  return invoke$3('ExtensionManagement.disable', id);
 };
 const enableExtension = async id => {
   // @ts-ignore
-  return invoke$5('ExtensionManagement.enable', id);
+  return invoke$3('ExtensionManagement.enable', id);
 };
 const handleDebugChange = async params => {
   // @ts-ignore
-  return invoke$5('Run And Debug.handleChange', params);
+  return invoke$3('Run And Debug.handleChange', params);
 };
 const getFolderIcon = async options => {
-  return invoke$5('IconTheme.getFolderIcon', options);
+  return invoke$3('IconTheme.getFolderIcon', options);
+};
+const handleWorkspaceRefresh = async () => {
+  return invoke$3('Layout.handleWorkspaceRefresh');
 };
 const closeWidget = async widgetId => {
-  return invoke$5('Viewlet.closeWidget', widgetId);
+  return invoke$3('Viewlet.closeWidget', widgetId);
 };
 const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
   const command = 'HandleMessagePort.handleMessagePort2';
-  await invokeAndTransfer$4('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
 };
 const sendMessagePortToSearchProcess = async port => {
-  await invokeAndTransfer$4('SendMessagePortToElectron.sendMessagePortToElectron', port, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
+  await invokeAndTransfer$2('SendMessagePortToElectron.sendMessagePortToElectron', port, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
 };
 const confirm = async (message, options) => {
   // @ts-ignore
-  const result = await invoke$5('ConfirmPrompt.prompt', message, options);
+  const result = await invoke$3('ConfirmPrompt.prompt', message, options);
   return result;
 };
 const getRecentlyOpened = async () => {
-  return invoke$5(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
+  return invoke$3(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
 };
 const getKeyBindings = async () => {
-  return invoke$5('KeyBindingsInitial.getKeyBindings');
+  return invoke$3('KeyBindingsInitial.getKeyBindings');
 };
 const writeClipBoardText = async text => {
-  await invoke$5('ClipBoard.writeText', /* text */text);
+  await invoke$3('ClipBoard.writeText', /* text */text);
+};
+const readClipBoardText = async () => {
+  return invoke$3('ClipBoard.readText');
 };
 const writeClipBoardImage = async blob => {
   // @ts-ignore
-  await invoke$5('ClipBoard.writeImage', /* text */blob);
+  await invoke$3('ClipBoard.writeImage', /* text */blob);
 };
 const searchFileMemory = async uri => {
   // @ts-ignore
-  return invoke$5('ExtensionHost.searchFileWithMemory', uri);
+  return invoke$3('ExtensionHost.searchFileWithMemory', uri);
 };
 const searchFileFetch = async uri => {
-  return invoke$5('ExtensionHost.searchFileWithFetch', uri);
+  return invoke$3('ExtensionHost.searchFileWithFetch', uri);
 };
 const showMessageBox = async options => {
-  return invoke$5('ElectronDialog.showMessageBox', options);
+  return invoke$3('ElectronDialog.showMessageBox', options);
 };
 const handleDebugResumed = async params => {
-  await invoke$5('Run And Debug.handleResumed', params);
+  await invoke$3('Run And Debug.handleResumed', params);
 };
 const openWidget = async name => {
-  await invoke$5('Viewlet.openWidget', name);
+  await invoke$3('Viewlet.openWidget', name);
 };
 const getIcons = async requests => {
-  const icons = await invoke$5('IconTheme.getIcons', requests);
+  const icons = await invoke$3('IconTheme.getIcons', requests);
   return icons;
 };
 const activateByEvent = event => {
-  return invoke$5('ExtensionHostManagement.activateByEvent', event);
+  return invoke$3('ExtensionHostManagement.activateByEvent', event);
 };
 const setAdditionalFocus = focusKey => {
   // @ts-ignore
-  return invoke$5('Focus.setAdditionalFocus', focusKey);
+  return invoke$3('Focus.setAdditionalFocus', focusKey);
 };
 const getActiveEditorId = () => {
   // @ts-ignore
-  return invoke$5('GetActiveEditor.getActiveEditorId');
+  return invoke$3('GetActiveEditor.getActiveEditorId');
 };
 const getWorkspacePath = () => {
-  return invoke$5('Workspace.getPath');
+  return invoke$3('Workspace.getPath');
 };
 const sendMessagePortToRendererProcess = async port => {
   const command = 'HandleMessagePort.handleMessagePort';
   // @ts-ignore
-  await invokeAndTransfer$4('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$2('SendMessagePortToExtensionHostWorker.sendMessagePortToTextMeasurementWorker', port, command, 0);
+};
+const sendMessagePortToSourceControlWorker = async port => {
+  const command = 'SourceControl.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToSourceControlWorker', port, command, 0);
+};
+const sendMessagePortToSharedProcess = async port => {
+  const command = 'HandleElectronMessagePort.handleElectronMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, 0);
+};
+const sendMessagePortToFileSystemProcess = async (port, rpcId) => {
+  const command = 'HandleMessagePortForFileSystemProcess.handleMessagePortForFileSystemProcess';
+  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, rpcId);
+};
+const sendMessagePortToIframeWorker = async (port, rpcId) => {
+  const command = 'Iframes.handleMessagePort';
+  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToIframeWorker', port, command, rpcId);
+};
+const sendMessagePortToExtensionManagementWorker = async (port, rpcId) => {
+  const command = 'Extensions.handleMessagePort';
+  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionManagementWorker', port, command, rpcId);
 };
 const getPreference = async key => {
-  return await invoke$5('Preferences.get', key);
+  return await invoke$3('Preferences.get', key);
 };
 const getAllExtensions = async () => {
-  return invoke$5('ExtensionManagement.getAllExtensions');
+  return invoke$3('ExtensionManagement.getAllExtensions');
 };
 const rerenderEditor = async key => {
   // @ts-ignore
-  return invoke$5('Editor.rerender', key);
+  return invoke$3('Editor.rerender', key);
 };
 const handleDebugPaused = async params => {
-  await invoke$5('Run And Debug.handlePaused', params);
+  await invoke$3('Run And Debug.handlePaused', params);
 };
 const openUri = async (uri, focus, options) => {
-  await invoke$5('Main.openUri', uri, focus, options);
+  await invoke$3('Main.openUri', uri, focus, options);
 };
 const sendMessagePortToSyntaxHighlightingWorker = async port => {
-  await invokeAndTransfer$4(
+  await invokeAndTransfer$2(
   // @ts-ignore
   'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
 };
 const handleDebugScriptParsed = async script => {
-  await invoke$5('Run And Debug.handleScriptParsed', script);
+  await invoke$3('Run And Debug.handleScriptParsed', script);
 };
 const getWindowId = async () => {
-  return invoke$5('GetWindowId.getWindowId');
+  return invoke$3('GetWindowId.getWindowId');
 };
 const getBlob = async uri => {
   // @ts-ignore
-  return invoke$5('FileSystem.getBlob', uri);
+  return invoke$3('FileSystem.getBlob', uri);
 };
 const getExtensionCommands = async () => {
-  return invoke$5('ExtensionHost.getCommands');
+  return invoke$3('ExtensionHost.getCommands');
 };
 const showErrorDialog = async errorInfo => {
   // @ts-ignore
-  await invoke$5('ErrorHandling.showErrorDialog', errorInfo);
+  await invoke$3('ErrorHandling.showErrorDialog', errorInfo);
 };
 const getFolderSize = async uri => {
   // @ts-ignore
-  return await invoke$5('FileSystem.getFolderSize', uri);
+  return await invoke$3('FileSystem.getFolderSize', uri);
 };
 const getExtension = async id => {
   // @ts-ignore
-  return invoke$5('ExtensionManagement.getExtension', id);
+  return invoke$3('ExtensionManagement.getExtension', id);
 };
 const getMarkdownDom = async html => {
   // @ts-ignore
-  return invoke$5('Markdown.getVirtualDom', html);
+  return invoke$3('Markdown.getVirtualDom', html);
 };
 const renderMarkdown = async (markdown, options) => {
   // @ts-ignore
-  return invoke$5('Markdown.renderMarkdown', markdown, options);
+  return invoke$3('Markdown.renderMarkdown', markdown, options);
 };
 const openNativeFolder = async uri => {
   // @ts-ignore
-  await invoke$5('OpenNativeFolder.openNativeFolder', uri);
+  await invoke$3('OpenNativeFolder.openNativeFolder', uri);
 };
 const uninstallExtension = async id => {
-  return invoke$5('ExtensionManagement.uninstall', id);
+  return invoke$3('ExtensionManagement.uninstall', id);
 };
 const installExtension = async id => {
   // @ts-ignore
-  return invoke$5('ExtensionManagement.install', id);
+  return invoke$3('ExtensionManagement.install', id);
 };
 const openExtensionSearch = async () => {
   // @ts-ignore
-  return invoke$5('SideBar.openViewlet', 'Extensions');
+  return invoke$3('SideBar.openViewlet', 'Extensions');
 };
 const setExtensionsSearchValue = async searchValue => {
   // @ts-ignore
-  return invoke$5('Extensions.handleInput', searchValue);
+  return invoke$3('Extensions.handleInput', searchValue, Script);
 };
 const openExternal = async uri => {
   // @ts-ignore
-  await invoke$5('Open.openExternal', uri);
+  await invoke$3('Open.openExternal', uri);
 };
 const openUrl = async uri => {
   // @ts-ignore
-  await invoke$5('Open.openUrl', uri);
+  await invoke$3('Open.openUrl', uri);
 };
 const getAllPreferences = async () => {
   // @ts-ignore
-  return invoke$5('Preferences.getAll');
+  return invoke$3('Preferences.getAll');
 };
 const showSaveFilePicker = async () => {
   // @ts-ignore
-  return invoke$5('FilePicker.showSaveFilePicker');
+  return invoke$3('FilePicker.showSaveFilePicker');
 };
 const getLogsDir = async () => {
   // @ts-ignore
-  return invoke$5('PlatformPaths.getLogsDir');
+  return invoke$3('PlatformPaths.getLogsDir');
+};
+const measureTextBlockHeight = async (actualInput, fontFamily, fontSize, lineHeightPx, width) => {
+  return invoke$3(`MeasureTextHeight.measureTextBlockHeight`, actualInput, fontFamily, fontSize, lineHeightPx, width);
+};
+const registerMockRpc = commandMap => {
+  const mockRpc = createMockRpc({
+    commandMap
+  });
+  set$1(mockRpc);
+  return mockRpc;
 };
 
 const RendererWorker = {
@@ -1286,16 +1472,20 @@ const RendererWorker = {
   handleDebugPaused,
   handleDebugResumed,
   handleDebugScriptParsed,
+  handleWorkspaceRefresh,
   installExtension,
-  invoke: invoke$5,
-  invokeAndTransfer: invokeAndTransfer$4,
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$2,
+  measureTextBlockHeight,
   openExtensionSearch,
   openExternal,
   openNativeFolder,
   openUri,
   openUrl,
   openWidget,
+  readClipBoardText,
   readFile: readFile$1,
+  registerMockRpc,
   registerWebViewInterceptor,
   renderMarkdown,
   rerenderEditor,
@@ -1305,11 +1495,18 @@ const RendererWorker = {
   sendMessagePortToEditorWorker,
   sendMessagePortToErrorWorker,
   sendMessagePortToExtensionHostWorker,
+  sendMessagePortToExtensionManagementWorker,
+  sendMessagePortToFileSystemProcess,
   sendMessagePortToFileSystemWorker,
+  sendMessagePortToIconThemeWorker,
+  sendMessagePortToIframeWorker,
   sendMessagePortToMarkdownWorker,
   sendMessagePortToRendererProcess,
   sendMessagePortToSearchProcess,
+  sendMessagePortToSharedProcess,
+  sendMessagePortToSourceControlWorker,
   sendMessagePortToSyntaxHighlightingWorker,
+  sendMessagePortToTextMeasurementWorker,
   set: set$1,
   setAdditionalFocus,
   setColorTheme,
@@ -1318,6 +1515,7 @@ const RendererWorker = {
   setWebViewPort,
   setWorkspacePath,
   showContextMenu,
+  showContextMenu2,
   showErrorDialog,
   showMessageBox,
   showSaveFilePicker,
@@ -1327,20 +1525,6 @@ const RendererWorker = {
   writeClipBoardText
 };
 
-const {
-  invoke: invoke$4,
-  invokeAndTransfer: invokeAndTransfer$3
-} = RendererWorker;
-
-const invoke$3 = async (method, ...params) => {
-  // @ts-ignore
-  return invoke$4('WebView.compatExtensionHostWorkerInvoke', method, ...params);
-};
-const invokeAndTransfer$2 = async (method, ...params) => {
-  // @ts-ignore
-  return invokeAndTransfer$3('WebView.compatExtensionHostWorkerInvokeAndTransfer', method, ...params);
-};
-
 const getCredentialLess = locationHost => {
   if (locationHost.startsWith('localhost:')) {
     // disabled to improve performance and make testing easier
@@ -1547,9 +1731,12 @@ const getPortTuple = () => {
   };
 };
 
+const {
+  invoke: invoke$2} = RendererWorker;
+
 const getSavedState = async () => {
   // @ts-ignore
-  return invoke$4('WebView.getSavedState');
+  return invoke$2('WebView.getSavedState');
 };
 
 const getSavedWebViewState = async id => {
@@ -1619,7 +1806,7 @@ const getIframePermissionPolicy = webView => {
 
 const getWebViews = async () => {
   // @ts-ignore
-  return invoke$4('WebView.getWebViews');
+  return invoke$3('WebView.getWebViews');
 };
 
 const AllowScripts = 'allow-scripts';
@@ -1667,13 +1854,13 @@ const getPort = () => {
   return location.port;
 };
 
-const invoke$2 = async (method, ...params) => {
+const invoke$1 = async (method, ...params) => {
   // @ts-ignore
-  return invoke$4('WebView.compatRendererProcessInvoke', method, ...params);
+  return invoke$3('WebView.compatRendererProcessInvoke', method, ...params);
 };
 const invokeAndTransfer$1 = async (method, ...params) => {
   // @ts-ignore
-  return invokeAndTransfer$3('WebView.compatRendererProcessInvokeAndTransfer', method, ...params);
+  return invokeAndTransfer$2('WebView.compatRendererProcessInvokeAndTransfer', method, ...params);
 };
 
 const WebView = 'lvce-oss-webview';
@@ -1682,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$4('WebView.compatSharedProcessInvoke', method, ...params);
+  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) => {
@@ -1769,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();
@@ -1801,7 +1988,7 @@ const create2 = async ({
   const permissionPolicyString = permissionPolicy.join('; ');
   const iframeCsp = platform === Web ? csp : '';
   const credentialless = getCredentialLess(locationHost);
-  await invoke$4('ExtensionHostManagement.activateByEvent', `onWebView:${webViewId}`);
+  await invoke$2('ExtensionHostManagement.activateByEvent', `onWebView:${webViewId}`);
   const {
     port1,
     port2
@@ -1809,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$2('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$3('ExtensionHostWebView.load', webViewId, savedState);
+  await invoke$4('ExtensionHostWebView.load', webViewId, savedState);
   return {
     csp: iframeCsp,
     iframeSrc,
@@ -1831,26 +2018,22 @@ 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$4('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$3('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) => {
@@ -1888,7 +2071,7 @@ const getPortQuadruple = () => {
 };
 
 const readFile = uri => {
-  return invoke('FileSystem.readFile', uri);
+  return invoke$3('FileSystem.readFile', uri);
 };
 
 const RE_PROTOCOL = /^([a-z-]+):\/\//;
@@ -1919,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;
@@ -1964,22 +2149,16 @@ const commandMap$1 = {
 };
 
 const getWebViewWorkerRpc2 = async rpcInfo => {
-  const {
-    port1,
-    port2
-  } = getPortTuple();
-  const rpcPromise = MessagePortRpcParent.create({
+  const rpc = await TransferMessagePortRpcParent.create({
     commandMap: commandMap$1,
-    isMessagePortOpen: true,
-    messagePort: port2
+    async send(port) {
+      await invokeAndTransfer$3('WebView.createWebViewWorkerRpc2', rpcInfo, port);
+    }
   });
   // TODO
   // 1. ask extension host worker to ask renderer worker to ask renderer process to create a worker with given url
   // 2. send the port through renderer worker to renderer process to the worker for a direct connection
-  await invokeAndTransfer$2('WebView.createWebViewWorkerRpc2', rpcInfo, port1);
-  const rpc = await rpcPromise;
   // TODO rpc module should start the port
-  port2.start();
   return rpc;
 };
 
@@ -2090,7 +2269,7 @@ const getWebViewWorkerRpc = async rpcInfo => {
     isMessagePortOpen: true,
     messagePort: port2
   });
-  await invokeAndTransfer$2('WebView.createWebViewWorkerRpc', rpcInfo, port1);
+  await invokeAndTransfer$3('WebView.createWebViewWorkerRpc', rpcInfo, port1);
   const rpc = await rpcPromise;
   // TODO rpc module should start the port
   port2.start();
@@ -2131,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$3('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);
   }
@@ -2182,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);
@@ -2218,7 +2397,7 @@ const create3 = async ({
   const credentialless = getCredentialLess(locationHost);
 
   // TODO remove this
-  await invoke$4('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);
@@ -2232,11 +2411,11 @@ const create3 = async ({
     } = getPortTuple();
     const portType = '';
     await setPort(id, port1, origin, portType);
-    await invokeAndTransfer$2('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$3('ExtensionHostWebView.load', webViewId, savedState);
+    await invoke$4('ExtensionHostWebView.load', webViewId, savedState);
   }
   await createWebViewRpc(webView, savedState, uri, portId, id, origin);
   return {
@@ -2250,11 +2429,11 @@ const create3 = async ({
 
 const executeCommand = (method, ...params) => {
   // @ts-ignore
-  return invoke$4('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 => {
@@ -2270,6 +2449,28 @@ const getWebViewInfo = webViewId => {
   return undefined;
 };
 
+const handleMessagePort2 = async (port, rpcId) => {
+  object(port);
+  const rpc = await PlainMessagePortRpcParent.create({
+    commandMap: {},
+    messagePort: port
+  });
+  if (rpcId) {
+    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 = [];
@@ -2296,6 +2497,8 @@ const unregisterInterceptor = async id => {
 };
 
 const commandMap = {
+  'Iframes.handleMessagePort': 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": "5.36.0",
+  "version": "6.1.0",
   "description": "Web Worker to manage creation and lifecycle of iframes in Lvce Editor",
   "keywords": [
     "iframe"