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

package/dist/fileSystemWorkerMain.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$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 number = value => {
+  const type = getType(value);
+  if (type !== Number$1) {
+    throw new AssertionError('expected value to be of type number');
+  }
+};
+
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
 };
@@ -899,7 +948,7 @@ const send = (transport, method, ...params) => {
   const message = create$4$1(method, params);
   transport.send(message);
 };
-const invoke$4 = (ipc, method, ...params) => {
+const invoke$5 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
 const invokeAndTransfer$3 = (ipc, method, ...params) => {
@@ -938,7 +987,7 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$4(ipc, method, ...params);
+      return invoke$5(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
       return invokeAndTransfer$3(ipc, method, ...params);
@@ -1094,6 +1143,191 @@ const createMockRpc = ({
   return mockRpc;
 };
 
+// TODO: including these in blob-util.ts causes typedoc to generate docs for them,
+// even with --excludePrivate ¯\_(ツ)_/¯
+/** @private */
+
+/* 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 {
+    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;
+};
+
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+const binaryStringToBlob = async (string, type) => {
+  try {
+    return binaryStringToBlob$1(string, type);
+  } catch (error) {
+    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');
+  }
+};
+
 const readFile$5 = async uri => {
   const response = await fetch(uri);
   if (!response.ok) {
@@ -1126,7 +1360,10 @@ const readJson$4 = async uri => {
   return json;
 };
 
+const Script = 2;
+
 const DebugWorker = 55;
+const ExtensionHostWorker = 44;
 const FileSystemProcess$1 = 210;
 const FileSystemWorker = 209;
 const RendererWorker$1 = 1;
@@ -1164,63 +1401,63 @@ const create = rpcId => {
 };
 
 const {
-  invoke: invoke$3,
+  invoke: invoke$4,
   invokeAndTransfer: invokeAndTransfer$2,
   set: set$3,
   dispose: dispose$1
 } = create(FileSystemProcess$1);
 const remove$3 = async uri => {
-  return invoke$3('FileSystem.remove', uri);
+  return invoke$4('FileSystem.remove', uri);
 };
 const readFile$4 = async uri => {
-  return invoke$3('FileSystem.readFile', uri);
+  return invoke$4('FileSystem.readFile', uri);
 };
 const appendFile$2 = async (uri, text) => {
   // @ts-ignore
-  return invoke$3('FileSystem.appendFile', uri, text);
+  return invoke$4('FileSystem.appendFile', uri, text);
 };
 const readDirWithFileTypes$2 = async uri => {
-  return invoke$3('FileSystem.readDirWithFileTypes', uri);
+  return invoke$4('FileSystem.readDirWithFileTypes', uri);
 };
 const getPathSeparator$2 = async root => {
   // @ts-ignore
-  return invoke$3('FileSystem.getPathSeparator', root);
+  return invoke$4('FileSystem.getPathSeparator', root);
 };
 const readJson$3 = async root => {
   // @ts-ignore
-  return invoke$3('FileSystem.readJson', root);
+  return invoke$4('FileSystem.readJson', root);
 };
 const getRealPath$2 = async path => {
   // @ts-ignore
-  return invoke$3('FileSystem.getRealPath', path);
+  return invoke$4('FileSystem.getRealPath', path);
 };
 const stat$2 = async path => {
   // @ts-ignore
-  return invoke$3('FileSystem.stat', path);
+  return invoke$4('FileSystem.stat', path);
 };
 const writeFile$3 = async (path, content) => {
   // @ts-ignore
-  return invoke$3('FileSystem.writeFile', path, content);
+  return invoke$4('FileSystem.writeFile', path, content);
 };
 const mkdir$2 = async path => {
   // @ts-ignore
-  return invoke$3('FileSystem.mkdir', path);
+  return invoke$4('FileSystem.mkdir', path);
 };
 const rename$3 = async (oldUri, newUri) => {
   // @ts-ignore
-  return invoke$3('FileSystem.rename', oldUri, newUri);
+  return invoke$4('FileSystem.rename', oldUri, newUri);
 };
 const copy$2 = async (oldUri, newUri) => {
   // @ts-ignore
-  return invoke$3('FileSystem.copy', oldUri, newUri);
+  return invoke$4('FileSystem.copy', oldUri, newUri);
 };
 const getFolderSize$3 = async uri => {
   // @ts-ignore
-  return invoke$3('FileSystem.getFolderSize', uri);
+  return invoke$4('FileSystem.getFolderSize', uri);
 };
 const exists$2 = async uri => {
   // @ts-ignore
-  return invoke$3('FileSystem.exists', uri);
+  return invoke$4('FileSystem.exists', uri);
 };
 const registerMockRpc$1 = commandMap => {
   const mockRpc = createMockRpc({
@@ -1239,7 +1476,7 @@ const FileSystemProcess = {
   getFolderSize: getFolderSize$3,
   getPathSeparator: getPathSeparator$2,
   getRealPath: getRealPath$2,
-  invoke: invoke$3,
+  invoke: invoke$4,
   invokeAndTransfer: invokeAndTransfer$2,
   mkdir: mkdir$2,
   readDirWithFileTypes: readDirWithFileTypes$2,
@@ -1254,51 +1491,62 @@ const FileSystemProcess = {
 };
 
 const {
-  invoke: invoke$2,
+  invoke: invoke$3,
   invokeAndTransfer: invokeAndTransfer$1,
   set: set$2,
   dispose
 } = create(RendererWorker$1);
 const searchFileHtml = async uri => {
-  return invoke$2('ExtensionHost.searchFileWithHtml', uri);
+  return invoke$3('ExtensionHost.searchFileWithHtml', uri);
 };
 const getFilePathElectron = async file => {
-  return invoke$2('FileSystemHandle.getFilePathElectron', file);
+  return invoke$3('FileSystemHandle.getFilePathElectron', file);
 };
+/**
+ * @deprecated
+ */
 const showContextMenu = async (x, y, id, ...args) => {
-  return invoke$2('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$2('Process.getElectronVersion');
+  return invoke$3('Process.getElectronVersion');
 };
 const applyBulkReplacement = async bulkEdits => {
-  await invoke$2('BulkReplacement.applyBulkReplacement', bulkEdits);
+  await invoke$3('BulkReplacement.applyBulkReplacement', bulkEdits);
 };
 const setColorTheme = async id => {
   // @ts-ignore
-  return invoke$2(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
+  return invoke$3(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
 };
 const getNodeVersion = async () => {
-  return invoke$2('Process.getNodeVersion');
+  return invoke$3('Process.getNodeVersion');
 };
 const getChromeVersion = async () => {
-  return invoke$2('Process.getChromeVersion');
+  return invoke$3('Process.getChromeVersion');
 };
 const getV8Version = async () => {
-  return invoke$2('Process.getV8Version');
+  return invoke$3('Process.getV8Version');
 };
 const getFileHandles = async fileIds => {
-  const files = await invoke$2('FileSystemHandle.getFileHandles', fileIds);
+  const files = await invoke$3('FileSystemHandle.getFileHandles', fileIds);
   return files;
 };
 const setWorkspacePath = async path => {
-  await invoke$2('Workspace.setPath', path);
+  await invoke$3('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);
+  await invoke$3('WebView.unregisterInterceptor', id);
 };
 const sendMessagePortToEditorWorker = async (port, rpcId) => {
   const command = 'HandleMessagePort.handleMessagePort';
@@ -1326,41 +1574,44 @@ const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
   await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
 };
 const readFile$3 = async uri => {
-  return invoke$2('FileSystem.readFile', uri);
+  return invoke$3('FileSystem.readFile', uri);
 };
 const getWebViewSecret = async key => {
   // @ts-ignore
-  return invoke$2('WebView.getSecret', key);
+  return invoke$3('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);
+  return invoke$3('Focus.setFocus', key);
 };
 const getFileIcon = async options => {
-  return invoke$2('IconTheme.getFileIcon', options);
+  return invoke$3('IconTheme.getFileIcon', options);
 };
 const getColorThemeNames = async () => {
-  return invoke$2('ColorTheme.getColorThemeNames');
+  return invoke$3('ColorTheme.getColorThemeNames');
 };
 const disableExtension = async id => {
   // @ts-ignore
-  return invoke$2('ExtensionManagement.disable', id);
+  return invoke$3('ExtensionManagement.disable', id);
 };
 const enableExtension = async id => {
   // @ts-ignore
-  return invoke$2('ExtensionManagement.enable', id);
+  return invoke$3('ExtensionManagement.enable', id);
 };
 const handleDebugChange = async params => {
   // @ts-ignore
-  return invoke$2('Run And Debug.handleChange', params);
+  return invoke$3('Run And Debug.handleChange', params);
 };
 const getFolderIcon = async options => {
-  return invoke$2('IconTheme.getFolderIcon', options);
+  return invoke$3('IconTheme.getFolderIcon', options);
+};
+const handleWorkspaceRefresh = async () => {
+  return invoke$3('Layout.handleWorkspaceRefresh');
 };
 const closeWidget = async widgetId => {
-  return invoke$2('Viewlet.closeWidget', widgetId);
+  return invoke$3('Viewlet.closeWidget', widgetId);
 };
 const sendMessagePortToExtensionHostWorker$1 = async (port, rpcId = 0) => {
   const command = 'HandleMessagePort.handleMessagePort2';
@@ -1371,76 +1622,89 @@ const sendMessagePortToSearchProcess = async port => {
 };
 const confirm = async (message, options) => {
   // @ts-ignore
-  const result = await invoke$2('ConfirmPrompt.prompt', message, options);
+  const result = await invoke$3('ConfirmPrompt.prompt', message, options);
   return result;
 };
 const getRecentlyOpened = async () => {
-  return invoke$2(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
+  return invoke$3(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
 };
 const getKeyBindings = async () => {
-  return invoke$2('KeyBindingsInitial.getKeyBindings');
+  return invoke$3('KeyBindingsInitial.getKeyBindings');
 };
 const writeClipBoardText = async text => {
-  await invoke$2('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$2('ClipBoard.writeImage', /* text */blob);
+  await invoke$3('ClipBoard.writeImage', /* text */blob);
 };
 const searchFileMemory = async uri => {
   // @ts-ignore
-  return invoke$2('ExtensionHost.searchFileWithMemory', uri);
+  return invoke$3('ExtensionHost.searchFileWithMemory', uri);
 };
 const searchFileFetch = async uri => {
-  return invoke$2('ExtensionHost.searchFileWithFetch', uri);
+  return invoke$3('ExtensionHost.searchFileWithFetch', uri);
 };
 const showMessageBox = async options => {
-  return invoke$2('ElectronDialog.showMessageBox', options);
+  return invoke$3('ElectronDialog.showMessageBox', options);
 };
 const handleDebugResumed = async params => {
-  await invoke$2('Run And Debug.handleResumed', params);
+  await invoke$3('Run And Debug.handleResumed', params);
 };
 const openWidget = async name => {
-  await invoke$2('Viewlet.openWidget', name);
+  await invoke$3('Viewlet.openWidget', name);
 };
 const getIcons = async requests => {
-  const icons = await invoke$2('IconTheme.getIcons', requests);
+  const icons = await invoke$3('IconTheme.getIcons', requests);
   return icons;
 };
 const activateByEvent = event => {
-  return invoke$2('ExtensionHostManagement.activateByEvent', event);
+  return invoke$3('ExtensionHostManagement.activateByEvent', event);
 };
 const setAdditionalFocus = focusKey => {
   // @ts-ignore
-  return invoke$2('Focus.setAdditionalFocus', focusKey);
+  return invoke$3('Focus.setAdditionalFocus', focusKey);
 };
 const getActiveEditorId = () => {
   // @ts-ignore
-  return invoke$2('GetActiveEditor.getActiveEditorId');
+  return invoke$3('GetActiveEditor.getActiveEditorId');
 };
 const getWorkspacePath = () => {
-  return invoke$2('Workspace.getPath');
+  return invoke$3('Workspace.getPath');
 };
 const sendMessagePortToRendererProcess = async port => {
   const command = 'HandleMessagePort.handleMessagePort';
   // @ts-ignore
   await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
 };
+const sendMessagePortToTextMeasurementWorker = async port => {
+  const command = 'TextMeasurement.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToTextMeasurementWorker', port, command, 0);
+};
+const sendMessagePortToSourceControlWorker = async port => {
+  const command = 'SourceControl.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToSourceControlWorker', port, command, 0);
+};
 const getPreference = async key => {
-  return await invoke$2('Preferences.get', key);
+  return await invoke$3('Preferences.get', key);
 };
 const getAllExtensions = async () => {
-  return invoke$2('ExtensionManagement.getAllExtensions');
+  return invoke$3('ExtensionManagement.getAllExtensions');
 };
 const rerenderEditor = async key => {
   // @ts-ignore
-  return invoke$2('Editor.rerender', key);
+  return invoke$3('Editor.rerender', key);
 };
 const handleDebugPaused = async params => {
-  await invoke$2('Run And Debug.handlePaused', params);
+  await invoke$3('Run And Debug.handlePaused', params);
 };
 const openUri = async (uri, focus, options) => {
-  await invoke$2('Main.openUri', uri, focus, options);
+  await invoke$3('Main.openUri', uri, focus, options);
 };
 const sendMessagePortToSyntaxHighlightingWorker = async port => {
   await invokeAndTransfer$1(
@@ -1448,76 +1712,79 @@ const sendMessagePortToSyntaxHighlightingWorker = async port => {
   'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
 };
 const handleDebugScriptParsed = async script => {
-  await invoke$2('Run And Debug.handleScriptParsed', script);
+  await invoke$3('Run And Debug.handleScriptParsed', script);
 };
 const getWindowId = async () => {
-  return invoke$2('GetWindowId.getWindowId');
+  return invoke$3('GetWindowId.getWindowId');
 };
 const getBlob = async uri => {
   // @ts-ignore
-  return invoke$2('FileSystem.getBlob', uri);
+  return invoke$3('FileSystem.getBlob', uri);
 };
 const getExtensionCommands = async () => {
-  return invoke$2('ExtensionHost.getCommands');
+  return invoke$3('ExtensionHost.getCommands');
 };
 const showErrorDialog = async errorInfo => {
   // @ts-ignore
-  await invoke$2('ErrorHandling.showErrorDialog', errorInfo);
+  await invoke$3('ErrorHandling.showErrorDialog', errorInfo);
 };
 const getFolderSize$2 = async uri => {
   // @ts-ignore
-  return await invoke$2('FileSystem.getFolderSize', uri);
+  return await invoke$3('FileSystem.getFolderSize', uri);
 };
 const getExtension = async id => {
   // @ts-ignore
-  return invoke$2('ExtensionManagement.getExtension', id);
+  return invoke$3('ExtensionManagement.getExtension', id);
 };
 const getMarkdownDom = async html => {
   // @ts-ignore
-  return invoke$2('Markdown.getVirtualDom', html);
+  return invoke$3('Markdown.getVirtualDom', html);
 };
 const renderMarkdown = async (markdown, options) => {
   // @ts-ignore
-  return invoke$2('Markdown.renderMarkdown', markdown, options);
+  return invoke$3('Markdown.renderMarkdown', markdown, options);
 };
 const openNativeFolder = async uri => {
   // @ts-ignore
-  await invoke$2('OpenNativeFolder.openNativeFolder', uri);
+  await invoke$3('OpenNativeFolder.openNativeFolder', uri);
 };
 const uninstallExtension = async id => {
-  return invoke$2('ExtensionManagement.uninstall', id);
+  return invoke$3('ExtensionManagement.uninstall', id);
 };
 const installExtension = async id => {
   // @ts-ignore
-  return invoke$2('ExtensionManagement.install', id);
+  return invoke$3('ExtensionManagement.install', id);
 };
 const openExtensionSearch = async () => {
   // @ts-ignore
-  return invoke$2('SideBar.openViewlet', 'Extensions');
+  return invoke$3('SideBar.openViewlet', 'Extensions');
 };
 const setExtensionsSearchValue = async searchValue => {
   // @ts-ignore
-  return invoke$2('Extensions.handleInput', searchValue);
+  return invoke$3('Extensions.handleInput', searchValue, Script);
 };
 const openExternal = async uri => {
   // @ts-ignore
-  await invoke$2('Open.openExternal', uri);
+  await invoke$3('Open.openExternal', uri);
 };
 const openUrl = async uri => {
   // @ts-ignore
-  await invoke$2('Open.openUrl', uri);
+  await invoke$3('Open.openUrl', uri);
 };
 const getAllPreferences = async () => {
   // @ts-ignore
-  return invoke$2('Preferences.getAll');
+  return invoke$3('Preferences.getAll');
 };
 const showSaveFilePicker = async () => {
   // @ts-ignore
-  return invoke$2('FilePicker.showSaveFilePicker');
+  return invoke$3('FilePicker.showSaveFilePicker');
 };
 const getLogsDir = async () => {
   // @ts-ignore
-  return invoke$2('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({
@@ -1565,15 +1832,18 @@ const RendererWorker = {
   handleDebugPaused,
   handleDebugResumed,
   handleDebugScriptParsed,
+  handleWorkspaceRefresh,
   installExtension,
-  invoke: invoke$2,
+  invoke: invoke$3,
   invokeAndTransfer: invokeAndTransfer$1,
+  measureTextBlockHeight,
   openExtensionSearch,
   openExternal,
   openNativeFolder,
   openUri,
   openUrl,
   openWidget,
+  readClipBoardText,
   readFile: readFile$3,
   registerMockRpc,
   registerWebViewInterceptor,
@@ -1590,7 +1860,9 @@ const RendererWorker = {
   sendMessagePortToMarkdownWorker,
   sendMessagePortToRendererProcess,
   sendMessagePortToSearchProcess,
+  sendMessagePortToSourceControlWorker,
   sendMessagePortToSyntaxHighlightingWorker,
+  sendMessagePortToTextMeasurementWorker,
   set: set$2,
   setAdditionalFocus,
   setColorTheme,
@@ -1599,6 +1871,7 @@ const RendererWorker = {
   setWebViewPort,
   setWorkspacePath,
   showContextMenu,
+  showContextMenu2,
   showErrorDialog,
   showMessageBox,
   showSaveFilePicker,
@@ -1608,51 +1881,35 @@ const RendererWorker = {
   writeClipBoardText
 };
 
-const getPortTuple = () => {
-  const {
-    port1,
-    port2
-  } = new MessageChannel();
+const createLazyRpc = rpcId => {
+  let rpcPromise;
+  let factory;
+  const createRpc = async () => {
+    const rpc = await factory();
+    set$4(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;
-
-const createExtensionHostRpc = async () => {
-  try {
-    const {
-      port1,
-      port2
-    } = getPortTuple();
-    await sendMessagePortToExtensionHostWorker(port2);
-    const rpc = await PlainMessagePortRpcParent.create({
-      commandMap: {},
-      messagePort: port1
-    });
-    return rpc;
-  } catch (error) {
-    throw new VError(error, `Failed to create extension host rpc`);
-  }
-};
-
-let rpcPromise = undefined;
-const getOrCreate = () => {
-  if (!rpcPromise) {
-    rpcPromise = createExtensionHostRpc();
-  }
-  return rpcPromise;
-};
-const invoke$1 = async (method, ...params) => {
-  const rpc = await getOrCreate();
-  return rpc.invoke(method, ...params);
-};
+  invoke: invoke$2,
+  setFactory
+} = createLazyRpc(ExtensionHostWorker);
 
 const RE_PROTOCOL = /^([a-z-]+):\/\//;
 const assertUri = uri => {
@@ -1663,11 +1920,11 @@ const assertUri = uri => {
 };
 
 const {
-  set,
+  set: set$1,
   rename: rename$2,
   copy: copy$1,
   mkdir: mkdir$1,
-  invoke,
+  invoke: invoke$1,
   getFolderSize: getFolderSize$1,
   writeFile: writeFile$2,
   stat: stat$1,
@@ -1684,7 +1941,7 @@ const {
 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) => {
@@ -1723,9 +1980,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 +1997,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 +2008,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);
@@ -1871,7 +2128,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);
@@ -1899,6 +2156,23 @@ const handleMessagePort = async (port, rpcId) => {
   }
 };
 
+const getPortTuple = () => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  return {
+    port1,
+    port2
+  };
+};
+
+const {
+  invokeAndTransfer,
+  set,
+  sendMessagePortToExtensionHostWorker
+} = RendererWorker;
+
 const sendMessagePortToFileSystemProcess = async port => {
   const command = 'HandleMessagePortForFileSystemProcess.handleMessagePortForFileSystemProcess';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, FileSystemWorker);
@@ -1960,13 +2234,117 @@ const initializeFileSytemProcess = async platform => {
     return;
   }
   const rpc = await createFileSystemProcessRpc(platform);
-  set(rpc);
+  set$1(rpc);
 };
 
 const initialize = async platform => {
   await initializeFileSytemProcess(platform);
 };
 
+const Directory = 'directory';
+const File = 'file';
+
+let rpcPromise = undefined;
+const getOrCreate = () => {
+  if (!rpcPromise) {
+    rpcPromise = Promise.resolve(get(RendererWorker$1));
+  }
+  return rpcPromise;
+};
+const invoke = async (method, ...params) => {
+  const rpc = await getOrCreate();
+  return rpc.invoke(method, ...params);
+};
+
+/* 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 invoke('Blob.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 File:
+      return uploadFile(fileSystemHandle, pathSeparator, root);
+    case Directory:
+      return uploadDirectory(fileSystemHandle, pathSeparator, root, uploadHandles);
+    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 {
+      name,
+      kind
+    } = 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 = {
   'FileSystem.appendFile': appendFile,
   'FileSystem.copy': copy,
@@ -1989,15 +2367,37 @@ const commandMap = {
   'FileSystem.watchFile': watchFile,
   'FileSystem.writeFile': writeFile,
   'FileSystem.writeBlob': writeBlob,
+  'FileSystem.uploadFileSystemHandles': uploadFileSystemHandles,
+  'Blob.base64StringToBlob': base64StringToBlob,
+  'Blob.binaryStringToBlob': binaryStringToBlob,
+  'Blob.blobToBinaryString': blobToBinaryString,
   'Initialize.initialize': initialize
 };
 
+const createExtensionHostRpc = async () => {
+  try {
+    const {
+      port1,
+      port2
+    } = getPortTuple();
+    await sendMessagePortToExtensionHostWorker(port2);
+    const rpc = await PlainMessagePortRpcParent.create({
+      commandMap: {},
+      messagePort: port1
+    });
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create extension host rpc`);
+  }
+};
+
 const listen = async () => {
   Object.assign(commandMapRef, commandMap);
+  setFactory(createExtensionHostRpc);
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });
-  set$1(rpc);
+  set(rpc);
 };
 
 const main = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/file-system-worker",
-  "version": "3.1.0",
+  "version": "4.0.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"
+  }
 }