@lvce-editor/file-system-worker 3.1.0 → 4.1.0

package/dist/fileSystemWorkerMain.js

@@ -54,6 +54,49 @@ class VError extends Error {
   }
 }
 
+class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AssertionError';
+  }
+}
+const Object$1 = 1;
+const Number$1 = 2;
+const Array$1 = 3;
+const String$1 = 4;
+const Boolean = 5;
+const Function = 6;
+const Null = 7;
+const Unknown = 8;
+const getType = value => {
+  switch (typeof value) {
+    case 'number':
+      return Number$1;
+    case 'function':
+      return Function;
+    case 'string':
+      return String$1;
+    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 isMessagePort = value => {
   return value && value instanceof MessagePort;
 };
@@ -535,7 +578,7 @@ const create$4$1 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$5 = (id, fn) => {
+const set$4 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get$1 = id => {
@@ -554,7 +597,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$5(id, resolve);
+  set$4(id, resolve);
   return {
     id,
     promise
@@ -902,7 +945,7 @@ const send = (transport, method, ...params) => {
 const invoke$4 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer$3 = (ipc, method, ...params) => {
+const invokeAndTransfer$2 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
@@ -941,7 +984,7 @@ const createRpc = ipc => {
       return invoke$4(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$3(ipc, method, ...params);
+      return invokeAndTransfer$2(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -999,18 +1042,23 @@ const PlainMessagePortRpc = {
   __proto__: null,
   create: create$5
 };
-const create$4 = async ({
+const create$3 = async ({
   commandMap,
-  messagePort
+  send
 }) => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  await send(port1);
   return create$5({
     commandMap,
-    messagePort
+    messagePort: port2
   });
 };
-const PlainMessagePortRpcParent = {
+const TransferMessagePortRpcParent = {
   __proto__: null,
-  create: create$4
+  create: create$3
 };
 const create$2 = async ({
   commandMap,
@@ -1060,7 +1108,7 @@ const WebSocketRpcParent2 = {
   __proto__: null,
   create: create$1
 };
-const create$3 = async ({
+const create$4 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1072,7 +1120,7 @@ const create$3 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$3
+  create: create$4
 };
 const createMockRpc = ({
   commandMap
@@ -1094,45 +1142,15 @@ const createMockRpc = ({
   return mockRpc;
 };
 
-const readFile$5 = async uri => {
-  const response = await fetch(uri);
-  if (!response.ok) {
-    throw new Error(response.statusText);
-  }
-  const result = await response.text();
-  return result;
-};
-const readFileAsBlob$1 = async uri => {
-  const response = await fetch(uri);
-  if (!response.ok) {
-    throw new Error(response.statusText);
-  }
-  const result = await response.blob();
-  return result;
-};
-const exists$3 = async uri => {
-  const response = await fetch(uri);
-  if (response.ok) {
-    return true;
-  }
-  return false;
-};
-const readJson$4 = async uri => {
-  const response = await fetch(uri);
-  if (!response.ok) {
-    throw new Error(`${response.statusText}`);
-  }
-  const json = await response.json();
-  return json;
-};
-
 const DebugWorker = 55;
+const ExtensionHostWorker = 44;
 const FileSystemProcess$1 = 210;
 const FileSystemWorker = 209;
-const RendererWorker$1 = 1;
+const RendererProcess = 1670;
+const RendererWorker = 1;
 
 const rpcs = Object.create(null);
-const set$4 = (id, rpc) => {
+const set$3 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get = id => {
@@ -1154,7 +1172,7 @@ const create = rpcId => {
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$4(rpcId, rpc);
+      set$3(rpcId, rpc);
     },
     async dispose() {
       const rpc = get(rpcId);
@@ -1165,9 +1183,9 @@ const create = rpcId => {
 
 const {
   invoke: invoke$3,
-  invokeAndTransfer: invokeAndTransfer$2,
-  set: set$3,
-  dispose: dispose$1
+  invokeAndTransfer: invokeAndTransfer$1,
+  set: set$2,
+  dispose
 } = create(FileSystemProcess$1);
 const remove$3 = async uri => {
   return invoke$3('FileSystem.remove', uri);
@@ -1186,7 +1204,7 @@ const getPathSeparator$2 = async root => {
   // @ts-ignore
   return invoke$3('FileSystem.getPathSeparator', root);
 };
-const readJson$3 = async root => {
+const readJson$4 = async root => {
   // @ts-ignore
   return invoke$3('FileSystem.readJson', root);
 };
@@ -1214,19 +1232,19 @@ const copy$2 = async (oldUri, newUri) => {
   // @ts-ignore
   return invoke$3('FileSystem.copy', oldUri, newUri);
 };
-const getFolderSize$3 = async uri => {
+const getFolderSize$2 = async uri => {
   // @ts-ignore
   return invoke$3('FileSystem.getFolderSize', uri);
 };
-const exists$2 = async uri => {
+const exists$3 = async uri => {
   // @ts-ignore
   return invoke$3('FileSystem.exists', uri);
 };
-const registerMockRpc$1 = commandMap => {
+const registerMockRpc = commandMap => {
   const mockRpc = createMockRpc({
     commandMap
   });
-  set$3(mockRpc);
+  set$2(mockRpc);
   return mockRpc;
 };
 
@@ -1234,426 +1252,284 @@ const FileSystemProcess = {
   __proto__: null,
   appendFile: appendFile$2,
   copy: copy$2,
-  dispose: dispose$1,
-  exists: exists$2,
-  getFolderSize: getFolderSize$3,
+  dispose,
+  exists: exists$3,
+  getFolderSize: getFolderSize$2,
   getPathSeparator: getPathSeparator$2,
   getRealPath: getRealPath$2,
   invoke: invoke$3,
-  invokeAndTransfer: invokeAndTransfer$2,
+  invokeAndTransfer: invokeAndTransfer$1,
   mkdir: mkdir$2,
   readDirWithFileTypes: readDirWithFileTypes$2,
   readFile: readFile$4,
-  readJson: readJson$3,
-  registerMockRpc: registerMockRpc$1,
+  readJson: readJson$4,
+  registerMockRpc,
   remove: remove$3,
   rename: rename$3,
-  set: set$3,
+  set: set$2,
   stat: stat$2,
   writeFile: writeFile$3
 };
 
 const {
-  invoke: invoke$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$3 = 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$1 = async (port, rpcId = 0) => {
+  invokeAndTransfer,
+  set: set$1} = create(RendererWorker);
+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');
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
 };
 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$2 = 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;
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
 };
 
-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: getFolderSize$2,
-  getIcons,
-  getKeyBindings,
-  getLogsDir,
-  getMarkdownDom,
-  getNodeVersion,
-  getPreference,
-  getRecentlyOpened,
-  getV8Version,
-  getWebViewSecret,
-  getWindowId,
-  getWorkspacePath,
-  handleDebugChange,
-  handleDebugPaused,
-  handleDebugResumed,
-  handleDebugScriptParsed,
-  installExtension,
-  invoke: invoke$2,
-  invokeAndTransfer: invokeAndTransfer$1,
-  openExtensionSearch,
-  openExternal,
-  openNativeFolder,
-  openUri,
-  openUrl,
-  openWidget,
-  readFile: readFile$3,
-  registerMockRpc,
-  registerWebViewInterceptor,
-  renderMarkdown,
-  rerenderEditor,
-  searchFileFetch,
-  searchFileHtml,
-  searchFileMemory,
-  sendMessagePortToEditorWorker,
-  sendMessagePortToErrorWorker,
-  sendMessagePortToExtensionHostWorker: sendMessagePortToExtensionHostWorker$1,
-  sendMessagePortToFileSystemWorker,
-  sendMessagePortToIconThemeWorker,
-  sendMessagePortToMarkdownWorker,
-  sendMessagePortToRendererProcess,
-  sendMessagePortToSearchProcess,
-  sendMessagePortToSyntaxHighlightingWorker,
-  set: set$2,
-  setAdditionalFocus,
-  setColorTheme,
-  setExtensionsSearchValue,
-  setFocus,
-  setWebViewPort,
-  setWorkspacePath,
-  showContextMenu,
-  showErrorDialog,
-  showMessageBox,
-  showSaveFilePicker,
-  uninstallExtension,
-  unregisterWebViewInterceptor,
-  writeClipBoardImage,
-  writeClipBoardText
-};
-
-const getPortTuple = () => {
-  const {
-    port1,
-    port2
-  } = new MessageChannel();
+const createLazyRpc = rpcId => {
+  let rpcPromise;
+  let factory;
+  const createRpc = async () => {
+    const rpc = await factory();
+    set$3(rpcId, rpc);
+  };
+  const ensureRpc = async () => {
+    if (!rpcPromise) {
+      rpcPromise = createRpc();
+    }
+    await rpcPromise;
+  };
   return {
-    port1,
-    port2
+    setFactory(value) {
+      factory = value;
+    },
+    async invoke(method, ...params) {
+      await ensureRpc();
+      const rpc = get(rpcId);
+      return rpc.invoke(method, ...params);
+    }
   };
 };
 
-const {
-  invokeAndTransfer,
-  set: set$1,
-  sendMessagePortToExtensionHostWorker
-} = RendererWorker;
+// TODO: including these in blob-util.ts causes typedoc to generate docs for them,
+// even with --excludePrivate ¯\_(ツ)_/¯
+/** @private */
 
-const createExtensionHostRpc = async () => {
+/* global Promise, Image, Blob, FileReader, atob, btoa,
+   BlobBuilder, MSBlobBuilder, MozBlobBuilder, WebKitBlobBuilder, webkitURL */
+/**
+ * Shim for
+ * [`new Blob()`](https://developer.mozilla.org/en-US/docs/Web/API/Blob.Blob)
+ * to support
+ * [older browsers that use the deprecated `BlobBuilder` API](http://caniuse.com/blob).
+ *
+ * Example:
+ *
+ * ```js
+ * var myBlob = blobUtil.createBlob(['hello world'], {type: 'text/plain'});
+ * ```
+ *
+ * @param parts - content of the Blob
+ * @param properties - usually `{type: myContentType}`,
+ *                           you can also pass a string for the content type
+ * @returns Blob
+ */
+function createBlob(parts, properties) {
+  parts = parts || [];
+  properties = properties || {};
+  if (typeof properties === 'string') {
+    properties = {
+      type: properties
+    }; // infer content type
+  }
   try {
-    const {
-      port1,
-      port2
-    } = getPortTuple();
-    await sendMessagePortToExtensionHostWorker(port2);
-    const rpc = await PlainMessagePortRpcParent.create({
-      commandMap: {},
-      messagePort: port1
-    });
-    return rpc;
+    return new Blob(parts, properties);
+  } catch (e) {
+    if (e.name !== 'TypeError') {
+      throw e;
+    }
+    var Builder = typeof BlobBuilder !== 'undefined' ? BlobBuilder : typeof MSBlobBuilder !== 'undefined' ? MSBlobBuilder : typeof MozBlobBuilder !== 'undefined' ? MozBlobBuilder : WebKitBlobBuilder;
+    var builder = new Builder();
+    for (var i = 0; i < parts.length; i += 1) {
+      builder.append(parts[i]);
+    }
+    return builder.getBlob(properties.type);
+  }
+}
+/**
+ * Convert a `Blob` to a binary string.
+ *
+ * Example:
+ *
+ * ```js
+ * blobUtil.blobToBinaryString(blob).then(function (binaryString) {
+ *   // success
+ * }).catch(function (err) {
+ *   // error
+ * });
+ * ```
+ *
+ * @param blob
+ * @returns Promise that resolves with the binary string
+ */
+function blobToBinaryString$1(blob) {
+  return new Promise(function (resolve, reject) {
+    var reader = new FileReader();
+    var hasBinaryString = typeof reader.readAsBinaryString === 'function';
+    reader.onloadend = function () {
+      var result = reader.result || '';
+      if (hasBinaryString) {
+        return resolve(result);
+      }
+      resolve(arrayBufferToBinaryString(result));
+    };
+    reader.onerror = reject;
+    if (hasBinaryString) {
+      reader.readAsBinaryString(blob);
+    } else {
+      reader.readAsArrayBuffer(blob);
+    }
+  });
+}
+/**
+ * Convert a base64-encoded string to a `Blob`.
+ *
+ * Example:
+ *
+ * ```js
+ * var blob = blobUtil.base64StringToBlob(base64String);
+ * ```
+ * @param base64 - base64-encoded string
+ * @param type - the content type (optional)
+ * @returns Blob
+ */
+function base64StringToBlob(base64, type) {
+  var parts = [binaryStringToArrayBuffer(atob(base64))];
+  return type ? createBlob(parts, {
+    type: type
+  }) : createBlob(parts);
+}
+/**
+ * Convert a binary string to a `Blob`.
+ *
+ * Example:
+ *
+ * ```js
+ * var blob = blobUtil.binaryStringToBlob(binaryString);
+ * ```
+ *
+ * @param binary - binary string
+ * @param type - the content type (optional)
+ * @returns Blob
+ */
+function binaryStringToBlob$1(binary, type) {
+  return base64StringToBlob(btoa(binary), type);
+}
+/**
+ * Convert an `ArrayBuffer` to a binary string.
+ *
+ * Example:
+ *
+ * ```js
+ * var myString = blobUtil.arrayBufferToBinaryString(arrayBuff)
+ * ```
+ *
+ * @param buffer - array buffer
+ * @returns binary string
+ */
+function arrayBufferToBinaryString(buffer) {
+  var binary = '';
+  var bytes = new Uint8Array(buffer);
+  var length = bytes.byteLength;
+  var i = -1;
+  while (++i < length) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return binary;
+}
+/**
+ * Convert a binary string to an `ArrayBuffer`.
+ *
+ * ```js
+ * var myBuffer = blobUtil.binaryStringToArrayBuffer(binaryString)
+ * ```
+ *
+ * @param binary - binary string
+ * @returns array buffer
+ */
+function binaryStringToArrayBuffer(binary) {
+  var length = binary.length;
+  var buf = new ArrayBuffer(length);
+  var arr = new Uint8Array(buf);
+  var i = -1;
+  while (++i < length) {
+    arr[i] = binary.charCodeAt(i);
+  }
+  return buf;
+}
+
+const normalizeBlobError = error => {
+  if (error && error instanceof ProgressEvent && error.target &&
+  // @ts-expect-error - target.error may not be in the type definition
+  error.target.error) {
+    // @ts-expect-error - target.error may not be in the type definition
+    return error.target.error;
+  }
+  return error;
+};
+
+const binaryStringToBlob = async (string, type) => {
+  try {
+    return binaryStringToBlob$1(string, type);
   } catch (error) {
-    throw new VError(error, `Failed to create extension host rpc`);
+    const normalizedError = normalizeBlobError(error);
+    throw new VError(normalizedError, 'Failed to convert binary string to blob');
+  }
+};
+const blobToBinaryString = async blob => {
+  try {
+    return await blobToBinaryString$1(blob);
+  } catch (error) {
+    const normalizedError = normalizeBlobError(error);
+    throw new VError(normalizedError, 'Failed to convert blob to binary string');
   }
 };
 
-let rpcPromise = undefined;
-const getOrCreate = () => {
-  if (!rpcPromise) {
-    rpcPromise = createExtensionHostRpc();
+const readFile$3 = async uri => {
+  const response = await fetch(uri);
+  if (!response.ok) {
+    throw new Error(response.statusText);
   }
-  return rpcPromise;
+  const result = await response.text();
+  return result;
 };
-const invoke$1 = async (method, ...params) => {
-  const rpc = await getOrCreate();
-  return rpc.invoke(method, ...params);
+const readFileAsBlob$1 = async uri => {
+  const response = await fetch(uri);
+  if (!response.ok) {
+    throw new Error(response.statusText);
+  }
+  const result = await response.blob();
+  return result;
+};
+const exists$2 = async uri => {
+  const response = await fetch(uri);
+  if (response.ok) {
+    return true;
+  }
+  return false;
+};
+const readJson$3 = async uri => {
+  const response = await fetch(uri);
+  if (!response.ok) {
+    throw new Error(`${response.statusText}`);
+  }
+  const json = await response.json();
+  return json;
 };
 
+const {
+  invoke: invoke$2,
+  setFactory: setFactory$1
+} = createLazyRpc(ExtensionHostWorker);
+
 const RE_PROTOCOL = /^([a-z-]+):\/\//;
 const assertUri = uri => {
   const protocolMatch = uri.match(RE_PROTOCOL);
@@ -1663,34 +1539,34 @@ const assertUri = uri => {
 };
 
 const {
-  set,
-  rename: rename$2,
+  appendFile: appendFile$1,
   copy: copy$1,
-  mkdir: mkdir$1,
-  invoke,
+  exists: exists$1,
   getFolderSize: getFolderSize$1,
-  writeFile: writeFile$2,
-  stat: stat$1,
-  readJson: readJson$2,
   getPathSeparator: getPathSeparator$1,
   getRealPath: getRealPath$1,
+  invoke: invoke$1,
+  mkdir: mkdir$1,
   readDirWithFileTypes: readDirWithFileTypes$1,
   readFile: readFile$2,
+  readJson: readJson$2,
   remove: remove$2,
-  exists: exists$1,
-  appendFile: appendFile$1
+  rename: rename$2,
+  set,
+  stat: stat$1,
+  writeFile: writeFile$2
 } = FileSystemProcess;
 
 const Http = 'http:';
 const Memory = 'memfs:';
 const Https = 'https:';
-const File = 'file:';
+const File$1 = 'file:';
 
 const watchCallbacks = Object.create(null);
 const registerWatchCallback = (id, rpcId, commandId, uri) => {
   watchCallbacks[id] = {
-    rpcId,
     commandId,
+    rpcId,
     uri
   };
 };
@@ -1700,8 +1576,8 @@ const executeWatchCallBack = async id => {
     throw new Error(`watch callback ${id} not found`);
   }
   const {
-    rpcId,
-    commandId
+    commandId,
+    rpcId
   } = entry;
   const rpc = get(rpcId);
   await rpc.invoke(commandId, id);
@@ -1723,9 +1599,9 @@ const watchFile = async (id, uri, rpcId) => {
   assertUri(uri);
   const commandId = 'Output.executeWatchCallback';
   registerWatchCallback(id, rpcId, commandId, uri);
-  if (uri.startsWith(File)) {
+  if (uri.startsWith(File$1)) {
     // @ts-ignore
-    await invoke('FileSystem.watchFile', id, uri);
+    await invoke$1('FileSystem.watchFile', id, uri);
   }
   // memfs file watchers are handled in-memory, no need to register with FileSystemProcess
 };
@@ -1740,7 +1616,7 @@ const unwatchFile = async id => {
   unregisterWatchCallback(id);
   // TODO only if it is a file uri
   // @ts-ignore
-  await invoke('FileSystem.unwatchFile', id);
+  await invoke$1('FileSystem.unwatchFile', id);
 };
 const triggerMemfsFileWatcher = async uri => {
   // Find all registered watchers for this URI and trigger them
@@ -1751,28 +1627,28 @@ const triggerMemfsFileWatcher = async uri => {
 };
 
 const remove$1 = async dirent => {
-  await invoke$1('FileSystemMemory.remove', dirent);
+  await invoke$2('FileSystemMemory.remove', dirent);
   // Trigger file watchers for memfs files
   await triggerMemfsFileWatcher(dirent);
 };
 const readFile$1 = async uri => {
-  return invoke$1('FileSystemMemory.readFile', uri);
+  return invoke$2('FileSystemMemory.readFile', uri);
 };
 const readJson$1 = async uri => {
   throw new Error('not implemented');
 };
 const createFile$1 = async uri => {
-  await invoke$1('FileSystemMemory.createFile', uri);
+  await invoke$2('FileSystemMemory.createFile', uri);
   // Trigger file watchers for memfs files
   await triggerMemfsFileWatcher(uri);
 };
 const writeFile$1 = async (uri, content) => {
-  await invoke$1('FileSystemMemory.writeFile', uri, content);
+  await invoke$2('FileSystemMemory.writeFile', uri, content);
   // Trigger file watchers for memfs files
   await triggerMemfsFileWatcher(uri);
 };
 const rename$1 = async (oldUri, newUri) => {
-  await invoke$1('FileSystemMemory.rename', oldUri, newUri);
+  await invoke$2('FileSystemMemory.rename', oldUri, newUri);
   // Trigger file watchers for both old and new URIs
   await triggerMemfsFileWatcher(oldUri);
   await triggerMemfsFileWatcher(newUri);
@@ -1786,7 +1662,6 @@ const isMemory = uri => {
   return uri.startsWith(Memory);
 };
 
-/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 const remove = async dirent => {
   if (isMemory(dirent)) {
     return remove$1(dirent);
@@ -1795,7 +1670,7 @@ const remove = async dirent => {
 };
 const readFile = async uri => {
   if (isHttp(uri)) {
-    return readFile$5(uri);
+    return readFile$3(uri);
   }
   if (isMemory(uri)) {
     return readFile$1(uri);
@@ -1813,7 +1688,7 @@ const getPathSeparator = async root => {
 };
 const readJson = async uri => {
   if (isHttp(uri)) {
-    return readJson$4(uri);
+    return readJson$3(uri);
   }
   if (isMemory(uri)) {
     return readJson$1();
@@ -1844,7 +1719,7 @@ const stat = async dirent => {
 };
 const exists = async uri => {
   if (isHttp(uri)) {
-    return exists$3(uri);
+    return exists$2(uri);
   }
   return exists$1(uri);
 };
@@ -1871,7 +1746,7 @@ const getBytes = async blob => {
 const writeBlob = async (uri, blob) => {
   const bytes = await getBytes(blob);
   // @ts-ignore
-  await invoke('FileSystem.writeBuffer', uri, bytes);
+  await invoke$1('FileSystem.writeBuffer', uri, bytes);
 };
 const mkdir = async uri => {
   return mkdir$1(uri);
@@ -1895,7 +1770,7 @@ const handleMessagePort = async (port, rpcId) => {
     messagePort: port
   });
   if (rpcId) {
-    set$4(rpcId, rpc);
+    set$3(rpcId, rpc);
   }
 };
 
@@ -1906,14 +1781,9 @@ const sendMessagePortToFileSystemProcess = async port => {
 
 const createFileSystemProcessRpcElectron = async () => {
   try {
-    const {
-      port1,
-      port2
-    } = getPortTuple();
-    await sendMessagePortToFileSystemProcess(port2);
-    const rpc = await PlainMessagePortRpcParent.create({
+    const rpc = await TransferMessagePortRpcParent.create({
       commandMap: {},
-      messagePort: port1
+      send: sendMessagePortToFileSystemProcess
     });
     return rpc;
   } catch (error) {
@@ -1926,8 +1796,8 @@ const commandMapRef = {};
 const createFileSystemProcessRpcNode = async () => {
   try {
     const rpc = await WebSocketRpcParent2.create({
-      type: 'file-system-process',
-      commandMap: commandMapRef
+      commandMap: commandMapRef,
+      type: 'file-system-process'
     });
     return rpc;
   } catch (error) {
@@ -1967,7 +1837,107 @@ const initialize = async platform => {
   await initializeFileSytemProcess(platform);
 };
 
+const Directory = 'directory';
+const File = 'file';
+
+const {
+  invoke,
+  setFactory
+} = createLazyRpc(RendererProcess);
+
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+
+const fromAsync = async asyncIterable => {
+  const children = [];
+  for await (const value of asyncIterable) {
+    children.push(value);
+  }
+  return children;
+};
+
+/**
+ * Do not use directly, use FileSystemHtml.getChildHandles
+ * instead which prompts for the required permission to
+ * retrieve the child handles
+ */
+const getChildHandles = async handle => {
+  object(handle);
+
+  // @ts-ignore - values() exists on FileSystemDirectoryHandle but TypeScript types may not include it
+  const handles = await fromAsync(handle.values());
+  return handles;
+};
+
+const uploadDirectory = async (fileSystemHandle, pathSeparator, root, uploadHandles) => {
+  const folderPath = root + pathSeparator + fileSystemHandle.name;
+  await mkdir(folderPath);
+  const childHandles = await getChildHandles(fileSystemHandle);
+  await uploadHandles(childHandles, pathSeparator, folderPath);
+};
+
+const getBinaryString$1 = file => {
+  return blobToBinaryString(file);
+};
+
+const getFile = handle => {
+  return handle.getFile();
+};
+const getBinaryString = async handle => {
+  const file = await getFile(handle);
+  const text = await getBinaryString$1(file);
+  return text;
+};
+
+const join = (pathSeparator, ...parts) => {
+  return parts.join(pathSeparator);
+};
+
+const uploadFile = async (fileSystemHandle, pathSeparator, root) => {
+  const content = await getBinaryString(fileSystemHandle);
+  const to = join(pathSeparator, root, fileSystemHandle.name);
+  await writeFile(to, content);
+};
+
+const uploadHandle = async (fileSystemHandle, pathSeparator, root, uploadHandles) => {
+  const {
+    kind
+  } = fileSystemHandle;
+  switch (kind) {
+    case Directory:
+      return uploadDirectory(fileSystemHandle, pathSeparator, root, uploadHandles);
+    case File:
+      return uploadFile(fileSystemHandle, pathSeparator, root);
+    default:
+      throw new Error(`unsupported file system handle type ${kind}`);
+  }
+};
+
+const uploadHandles = async (fileSystemHandles, pathSeparator, root) => {
+  for (const fileSystemHandle of fileSystemHandles) {
+    await uploadHandle(fileSystemHandle, pathSeparator, root, uploadHandles);
+  }
+};
+const uploadFileSystemHandles = async (root, pathSeparator, fileSystemHandles) => {
+  if (fileSystemHandles.length === 1) {
+    const file = fileSystemHandles[0];
+    const {
+      kind,
+      name
+    } = file;
+    if (kind === Directory) {
+      await invoke('PersistentFileHandle.addHandle', `/${name}`, file);
+      await invoke('Workspace.setPath', `html:///${name}`);
+      return true;
+    }
+  }
+  await uploadHandles(fileSystemHandles, pathSeparator, root);
+  return false;
+};
+
 const commandMap = {
+  'Blob.base64StringToBlob': base64StringToBlob,
+  'Blob.binaryStringToBlob': binaryStringToBlob,
+  'Blob.blobToBinaryString': blobToBinaryString,
   'FileSystem.appendFile': appendFile,
   'FileSystem.copy': copy,
   'FileSystem.createFile': createFile,
@@ -1986,14 +1956,41 @@ const commandMap = {
   'FileSystem.rename': rename,
   'FileSystem.stat': stat,
   'FileSystem.unwatchFile': unwatchFile,
+  'FileSystem.uploadFileSystemHandles': uploadFileSystemHandles,
   'FileSystem.watchFile': watchFile,
-  'FileSystem.writeFile': writeFile,
   'FileSystem.writeBlob': writeBlob,
+  'FileSystem.writeFile': writeFile,
   'Initialize.initialize': initialize
 };
 
+const createExtensionHostRpc = async () => {
+  try {
+    const rpc = await TransferMessagePortRpcParent.create({
+      commandMap: {},
+      send: sendMessagePortToExtensionHostWorker
+    });
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create extension host rpc`);
+  }
+};
+
+const createRendererProcessRpc = async () => {
+  try {
+    const rpc = await TransferMessagePortRpcParent.create({
+      commandMap: {},
+      send: sendMessagePortToRendererProcess
+    });
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create renderer process rpc`);
+  }
+};
+
 const listen = async () => {
   Object.assign(commandMapRef, commandMap);
+  setFactory$1(createExtensionHostRpc);
+  setFactory(createRendererProcessRpc);
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/file-system-worker",
-  "version": "3.1.0",
+  "version": "4.1.0",
   "description": "File System Worker",
   "keywords": [
     "Lvce Editor"
@@ -12,5 +12,8 @@
   "license": "MIT",
   "author": "Lvce Editor",
   "type": "module",
-  "main": "dist/fileSystemWorkerMain.js"
+  "main": "dist/fileSystemWorkerMain.js",
+  "dependencies": {
+    "blob-util": "^2.0.2"
+  }
 }