@lvce-editor/file-system-worker 4.2.0 → 5.1.0

package/dist/fileSystemWorkerMain.js

@@ -1,3 +1,170 @@
+// 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;
+};
+
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
     return line.slice('Error: '.length);
@@ -54,6 +221,94 @@ class VError extends Error {
   }
 }
 
+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$4 = 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 RendererProcess = 1670;
+const RendererWorker = 1;
+
+const rpcs = Object.create(null);
+const set$5 = (id, rpc) => {
+  rpcs[id] = rpc;
+};
+const get$1 = id => {
+  return rpcs[id];
+};
+
+const create$6 = rpcId => {
+  return {
+    async dispose() {
+      const rpc = get$1(rpcId);
+      await rpc.dispose();
+    },
+    // @ts-ignore
+    invoke(method, ...params) {
+      const rpc = get$1(rpcId);
+      // @ts-ignore
+      return rpc.invoke(method, ...params);
+    },
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get$1(rpcId);
+      // @ts-ignore
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    set(rpc) {
+      set$5(rpcId, rpc);
+    }
+  };
+};
+
 class AssertionError extends Error {
   constructor(message) {
     super(message);
@@ -225,8 +480,8 @@ const getModuleNotFoundError = stderr => {
   const messageIndex = lines.findIndex(isModuleNotFoundMessage);
   const message = lines[messageIndex];
   return {
-    message,
-    code: ERR_MODULE_NOT_FOUND
+    code: ERR_MODULE_NOT_FOUND,
+    message
   };
 };
 const isModuleNotFoundError = stderr => {
@@ -249,14 +504,14 @@ const isUnhelpfulNativeModuleError = stderr => {
 const getNativeModuleErrorMessage = stderr => {
   const message = getMessageCodeBlock(stderr);
   return {
-    message: `Incompatible native node module: ${message}`,
-    code: E_INCOMPATIBLE_NATIVE_MODULE
+    code: E_INCOMPATIBLE_NATIVE_MODULE,
+    message: `Incompatible native node module: ${message}`
   };
 };
 const getModuleSyntaxError = () => {
   return {
-    message: `ES Modules are not supported in electron`,
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
+    message: `ES Modules are not supported in electron`
   };
 };
 const getHelpfulChildProcessError = (stdout, stderr) => {
@@ -275,8 +530,8 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
     rest
   } = getDetails(lines);
   return {
-    message: actualMessage,
     code: '',
+    message: actualMessage,
     stack: rest
   };
 };
@@ -286,8 +541,8 @@ class IpcError extends VError {
     if (stdout || stderr) {
       // @ts-ignore
       const {
-        message,
         code,
+        message,
         stack
       } = getHelpfulChildProcessError(stdout, stderr);
       const cause = new Error(message);
@@ -348,8 +603,8 @@ const wrap$f = global => {
 };
 const waitForFirstMessage = async port => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   port.addEventListener('message', resolve, {
     once: true
@@ -369,8 +624,8 @@ const listen$6 = async () => {
   const type = firstMessage.params[0];
   if (type === 'message-port') {
     parentIpc.send({
-      jsonrpc: '2.0',
       id: firstMessage.id,
+      jsonrpc: '2.0',
       result: null
     });
     parentIpc.dispose();
@@ -430,8 +685,8 @@ const removeListener = (emitter, type, callback) => {
 };
 const getFirstEvent = (eventEmitter, eventMap) => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   const listenerMap = Object.create(null);
   const cleanup = value => {
@@ -443,8 +698,8 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   for (const [event, type] of Object.entries(eventMap)) {
     const listener = event => {
       cleanup({
-        type,
-        event
+        event,
+        type
       });
     };
     addListener(eventEmitter, event, listener);
@@ -453,9 +708,9 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   return promise;
 };
 const Message$1 = 3;
-const create$5$1 = async ({
-  messagePort,
-  isMessagePortOpen
+const create$5 = async ({
+  isMessagePortOpen,
+  messagePort
 }) => {
   if (!isMessagePort(messagePort)) {
     throw new IpcError('port must be of type MessagePort');
@@ -468,8 +723,8 @@ const create$5$1 = async ({
   });
   messagePort.start();
   const {
-    type,
-    event
+    event,
+    type
   } = await eventPromise;
   if (type !== Message$1) {
     throw new IpcError('Failed to wait for ipc message');
@@ -504,7 +759,7 @@ const wrap$5 = messagePort => {
 };
 const IpcParentWithMessagePort$1 = {
   __proto__: null,
-  create: create$5$1,
+  create: create$5,
   signal: signal$1,
   wrap: wrap$5
 };
@@ -523,12 +778,12 @@ const parse = content => {
 };
 const waitForWebSocketToBeOpen = webSocket => {
   return getFirstEvent(webSocket, {
-    open: Open,
     close: Close,
-    error: Error$3
+    error: Error$3,
+    open: Open
   });
 };
-const create$7 = async ({
+const create$3 = async ({
   webSocket
 }) => {
   const firstWebSocketEvent = await waitForWebSocketToBeOpen(webSocket);
@@ -565,60 +820,18 @@ const wrap = webSocket => {
 };
 const IpcParentWithWebSocket$1 = {
   __proto__: null,
-  create: create$7,
+  create: create$3,
   wrap
 };
 
-const Two = '2.0';
-const create$4$1 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
-};
+const Two$1 = '2.0';
 const callbacks = Object.create(null);
-const set$4 = (id, fn) => {
-  callbacks[id] = fn;
-};
-const get$1 = id => {
+const get = id => {
   return callbacks[id];
 };
 const remove$4 = id => {
   delete callbacks[id];
 };
-let id = 0;
-const create$3$1 = () => {
-  return ++id;
-};
-const registerPromise = () => {
-  const id = create$3$1();
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  set$4(id, resolve);
-  return {
-    id,
-    promise
-  };
-};
-const create$2$1 = (method, params) => {
-  const {
-    id,
-    promise
-  } = registerPromise();
-  const message = {
-    jsonrpc: Two,
-    method,
-    params,
-    id
-  };
-  return {
-    message,
-    promise
-  };
-};
 class JsonRpcError extends Error {
   constructor(message) {
     super(message);
@@ -762,7 +975,7 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get$1(id);
+  const fn = get(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
@@ -814,7 +1027,7 @@ const getErrorProperty = (error, prettyError) => {
 };
 const create$1$1 = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error
   };
@@ -825,20 +1038,20 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$6 = (message, result) => {
+const create = (message, result) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id: message.id,
     result: result ?? null
   };
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$6(message, resultProperty);
+  return create(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error: {
       code: Custom,
@@ -925,29 +1138,6 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
-const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
-  const {
-    message,
-    promise
-  } = create$2$1(method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
-    ipc.sendAndTransfer(message);
-  } else {
-    ipc.send(message);
-  }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
-};
-const send = (transport, method, ...params) => {
-  const message = create$4$1(method, params);
-  transport.send(message);
-};
-const invoke$4 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, false);
-};
-const invokeAndTransfer$2 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, true);
-};
 
 class CommandNotFoundError extends Error {
   constructor(command) {
@@ -970,24 +1160,87 @@ const execute = (command, ...args) => {
   return fn(...args);
 };
 
+const Two = '2.0';
+const create$s = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+const create$r = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
+};
+let id = 0;
+const create$q = () => {
+  return ++id;
+};
+
+/* eslint-disable n/no-unsupported-features/es-syntax */
+
+const registerPromise = map => {
+  const id = create$q();
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
+    promise
+  };
+};
+
+// @ts-ignore
+const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
+    promise
+  } = registerPromise(callbacks);
+  const message = create$r(id, method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
 const createRpc = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks[id];
+  };
   const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, true);
+    },
     // @ts-ignore
     ipc,
     /**
      * @deprecated
      */
     send(method, ...params) {
-      send(ipc, method, ...params);
-    },
-    invoke(method, ...params) {
-      return invoke$4(ipc, method, ...params);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$2(ipc, method, ...params);
-    },
-    async dispose() {
-      await ipc?.dispose();
+      const message = create$s(method, params);
+      ipc.send(message);
     }
   };
   return rpc;
@@ -1004,7 +1257,7 @@ const logError = () => {
 const handleMessage = event => {
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
   const actualExecute = event?.target?.execute || execute;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
@@ -1022,57 +1275,52 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$5 = async ({
-  commandMap,
-  messagePort
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(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 PlainMessagePortRpc = {
-  __proto__: null,
-  create: create$5
+
+/* eslint-disable @typescript-eslint/no-misused-promises */
+
+const createSharedLazyRpc = factory => {
+  let rpcPromise;
+  const getOrCreate = () => {
+    if (!rpcPromise) {
+      rpcPromise = factory();
+    }
+    return rpcPromise;
+  };
+  return {
+    async dispose() {
+      const rpc = await getOrCreate();
+      await rpc.dispose();
+    },
+    async invoke(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invoke(method, ...params);
+    },
+    async invokeAndTransfer(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    async send(method, ...params) {
+      const rpc = await getOrCreate();
+      rpc.send(method, ...params);
+    }
+  };
 };
-const create$3 = async ({
+const create$i = async ({
   commandMap,
+  isMessagePortOpen,
   send
 }) => {
-  const {
-    port1,
-    port2
-  } = new MessageChannel();
-  await send(port1);
-  return create$5({
-    commandMap,
-    messagePort: port2
+  return createSharedLazyRpc(() => {
+    return create$2({
+      commandMap,
+      isMessagePortOpen,
+      send
+    });
   });
 };
-const TransferMessagePortRpcParent = {
+const LazyTransferMessagePortRpcParent = {
   __proto__: null,
-  create: create$3
-};
-const create$2 = async ({
-  commandMap,
-  webSocket
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const rawIpc = await IpcParentWithWebSocket$1.create({
-    webSocket
-  });
-  const ipc = IpcParentWithWebSocket$1.wrap(rawIpc);
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  return rpc;
+  create: create$i
 };
 const Https$1 = 'https:';
 const Ws = 'ws:';
@@ -1090,7 +1338,21 @@ const getHost = () => {
 const getProtocol = () => {
   return location.protocol;
 };
-const create$1 = async ({
+const create$h = async ({
+  commandMap,
+  webSocket
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithWebSocket$1.create({
+    webSocket
+  });
+  const ipc = IpcParentWithWebSocket$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+const create$g = async ({
   commandMap,
   type
 }) => {
@@ -1098,17 +1360,58 @@ const create$1 = async ({
   const protocol = getProtocol();
   const wsUrl = getWebSocketUrl(type, host, protocol);
   const webSocket = new WebSocket(wsUrl);
-  const rpc = await create$2({
-    webSocket,
-    commandMap
+  const rpc = await create$h({
+    commandMap,
+    webSocket
   });
   return rpc;
 };
 const WebSocketRpcParent2 = {
   __proto__: null,
-  create: create$1
+  create: create$g
 };
 const create$4 = async ({
+  commandMap,
+  isMessagePortOpen = true,
+  messagePort
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    isMessagePortOpen,
+    messagePort
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  messagePort.start();
+  return rpc;
+};
+const PlainMessagePortRpc = {
+  __proto__: null,
+  create: create$4
+};
+const create$2 = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  await send(port1);
+  return create$4({
+    commandMap,
+    isMessagePortOpen,
+    messagePort: port2
+  });
+};
+const TransferMessagePortRpcParent = {
+  __proto__: null,
+  create: create$2
+};
+const create$1 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1120,7 +1423,7 @@ const create$4 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$4
+  create: create$1
 };
 const createMockRpc = ({
   commandMap
@@ -1132,148 +1435,119 @@ const createMockRpc = ({
     if (!command) {
       throw new Error(`command ${method} not found`);
     }
-    return command(...params);
-  };
-  const mockRpc = {
-    invoke,
-    invokeAndTransfer: invoke,
-    invocations
-  };
-  return mockRpc;
-};
-
-const DebugWorker = 55;
-const ExtensionHostWorker = 44;
-const FileSystemProcess$1 = 210;
-const FileSystemWorker = 209;
-const RendererProcess = 1670;
-const RendererWorker = 1;
-
-const rpcs = Object.create(null);
-const set$3 = (id, rpc) => {
-  rpcs[id] = rpc;
-};
-const get = id => {
-  return rpcs[id];
-};
-
-const create = rpcId => {
-  return {
-    // @ts-ignore
-    invoke(method, ...params) {
-      const rpc = get(rpcId);
-      // @ts-ignore
-      return rpc.invoke(method, ...params);
-    },
-    // @ts-ignore
-    invokeAndTransfer(method, ...params) {
-      const rpc = get(rpcId);
-      // @ts-ignore
-      return rpc.invokeAndTransfer(method, ...params);
-    },
-    set(rpc) {
-      set$3(rpcId, rpc);
-    },
-    async dispose() {
-      const rpc = get(rpcId);
-      await rpc.dispose();
-    }
+    return command(...params);
+  };
+  const mockRpc = {
+    invocations,
+    invoke,
+    invokeAndTransfer: invoke
   };
+  return mockRpc;
 };
 
 const {
   invoke: invoke$3,
+  set: set$4
+} = create$6(ExtensionHostWorker);
+
+const {
+  dispose,
+  invoke: invoke$2,
   invokeAndTransfer: invokeAndTransfer$1,
-  set: set$2,
-  dispose
-} = create(FileSystemProcess$1);
+  set: set$3
+} = create$6(FileSystemProcess$1);
 const remove$3 = async uri => {
-  return invoke$3('FileSystem.remove', uri);
+  return invoke$2('FileSystem.remove', uri);
 };
-const readFile$4 = async uri => {
-  return invoke$3('FileSystem.readFile', uri);
+const readFile$3 = async uri => {
+  return invoke$2('FileSystem.readFile', uri);
 };
 const appendFile$2 = async (uri, text) => {
   // @ts-ignore
-  return invoke$3('FileSystem.appendFile', uri, text);
+  return invoke$2('FileSystem.appendFile', uri, text);
 };
 const readDirWithFileTypes$2 = async uri => {
-  return invoke$3('FileSystem.readDirWithFileTypes', uri);
+  return invoke$2('FileSystem.readDirWithFileTypes', uri);
 };
 const getPathSeparator$2 = async root => {
   // @ts-ignore
-  return invoke$3('FileSystem.getPathSeparator', root);
+  return invoke$2('FileSystem.getPathSeparator', root);
 };
-const readJson$4 = async root => {
+const readJson$3 = async root => {
   // @ts-ignore
-  return invoke$3('FileSystem.readJson', root);
+  return invoke$2('FileSystem.readJson', root);
 };
 const getRealPath$2 = async path => {
   // @ts-ignore
-  return invoke$3('FileSystem.getRealPath', path);
+  return invoke$2('FileSystem.getRealPath', path);
 };
 const stat$2 = async path => {
   // @ts-ignore
-  return invoke$3('FileSystem.stat', path);
+  return invoke$2('FileSystem.stat', path);
 };
 const writeFile$3 = async (path, content) => {
   // @ts-ignore
-  return invoke$3('FileSystem.writeFile', path, content);
+  return invoke$2('FileSystem.writeFile', path, content);
 };
 const mkdir$2 = async path => {
   // @ts-ignore
-  return invoke$3('FileSystem.mkdir', path);
+  return invoke$2('FileSystem.mkdir', path);
 };
 const rename$3 = async (oldUri, newUri) => {
   // @ts-ignore
-  return invoke$3('FileSystem.rename', oldUri, newUri);
+  return invoke$2('FileSystem.rename', oldUri, newUri);
 };
 const copy$2 = async (oldUri, newUri) => {
   // @ts-ignore
-  return invoke$3('FileSystem.copy', oldUri, newUri);
+  return invoke$2('FileSystem.copy', oldUri, newUri);
 };
 const getFolderSize$2 = async uri => {
   // @ts-ignore
-  return invoke$3('FileSystem.getFolderSize', uri);
+  return invoke$2('FileSystem.getFolderSize', uri);
 };
-const exists$3 = async uri => {
+const exists$2 = async uri => {
   // @ts-ignore
-  return invoke$3('FileSystem.exists', uri);
+  return invoke$2('FileSystem.exists', uri);
 };
 const registerMockRpc = commandMap => {
   const mockRpc = createMockRpc({
     commandMap
   });
-  set$2(mockRpc);
+  set$3(mockRpc);
   return mockRpc;
 };
 
 const FileSystemProcess = {
-  __proto__: null,
-  appendFile: appendFile$2,
-  copy: copy$2,
-  dispose,
-  exists: exists$3,
-  getFolderSize: getFolderSize$2,
-  getPathSeparator: getPathSeparator$2,
-  getRealPath: getRealPath$2,
-  invoke: invoke$3,
-  invokeAndTransfer: invokeAndTransfer$1,
-  mkdir: mkdir$2,
-  readDirWithFileTypes: readDirWithFileTypes$2,
-  readFile: readFile$4,
-  readJson: readJson$4,
-  registerMockRpc,
-  remove: remove$3,
-  rename: rename$3,
-  set: set$2,
-  stat: stat$2,
-  writeFile: writeFile$3
+   __proto__: null,
+   appendFile: appendFile$2,
+   copy: copy$2,
+   dispose,
+   exists: exists$2,
+   getFolderSize: getFolderSize$2,
+   getPathSeparator: getPathSeparator$2,
+   getRealPath: getRealPath$2,
+   invoke: invoke$2,
+   invokeAndTransfer: invokeAndTransfer$1,
+   mkdir: mkdir$2,
+   readDirWithFileTypes: readDirWithFileTypes$2,
+   readFile: readFile$3,
+   readJson: readJson$3,
+   registerMockRpc,
+   remove: remove$3,
+   rename: rename$3,
+   set: set$3,
+   stat: stat$2,
+   writeFile: writeFile$3
 };
 
+const {
+  set: set$2
+} = create$6(RendererProcess);
+
 const {
   invokeAndTransfer,
-  set: set$1} = create(RendererWorker);
+  set: set$1
+} = create$6(RendererWorker);
 const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
   const command = 'HandleMessagePort.handleMessagePort2';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
@@ -1289,7 +1563,7 @@ const createLazyRpc = rpcId => {
   let factory;
   const createRpc = async () => {
     const rpc = await factory();
-    set$3(rpcId, rpc);
+    set$5(rpcId, rpc);
   };
   const ensureRpc = async () => {
     if (!rpcPromise) {
@@ -1298,238 +1572,22 @@ const createLazyRpc = rpcId => {
     await rpcPromise;
   };
   return {
-    setFactory(value) {
-      factory = value;
-    },
     async invoke(method, ...params) {
       await ensureRpc();
-      const rpc = get(rpcId);
+      const rpc = get$1(rpcId);
       return rpc.invoke(method, ...params);
+    },
+    async invokeAndTransfer(method, ...params) {
+      await ensureRpc();
+      const rpc = get$1(rpcId);
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    setFactory(value) {
+      factory = value;
     }
   };
 };
 
-// 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;
-};
-
-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$3 = 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$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);
@@ -1579,7 +1637,7 @@ const executeWatchCallBack = async id => {
     commandId,
     rpcId
   } = entry;
-  const rpc = get(rpcId);
+  const rpc = get$1(rpcId);
   await rpc.invoke(commandId, id);
 };
 const unregisterWatchCallback = id => {
@@ -1627,28 +1685,28 @@ const triggerMemfsFileWatcher = async uri => {
 };
 
 const remove$1 = async dirent => {
-  await invoke$2('FileSystemMemory.remove', dirent);
+  await invoke$3('FileSystemMemory.remove', dirent);
   // Trigger file watchers for memfs files
   await triggerMemfsFileWatcher(dirent);
 };
 const readFile$1 = async uri => {
-  return invoke$2('FileSystemMemory.readFile', uri);
+  return invoke$3('FileSystemMemory.readFile', uri);
 };
 const readJson$1 = async uri => {
   throw new Error('not implemented');
 };
 const createFile$1 = async uri => {
-  await invoke$2('FileSystemMemory.createFile', uri);
+  await invoke$3('FileSystemMemory.createFile', uri);
   // Trigger file watchers for memfs files
   await triggerMemfsFileWatcher(uri);
 };
 const writeFile$1 = async (uri, content) => {
-  await invoke$2('FileSystemMemory.writeFile', uri, content);
+  await invoke$3('FileSystemMemory.writeFile', uri, content);
   // Trigger file watchers for memfs files
   await triggerMemfsFileWatcher(uri);
 };
 const rename$1 = async (oldUri, newUri) => {
-  await invoke$2('FileSystemMemory.rename', oldUri, newUri);
+  await invoke$3('FileSystemMemory.rename', oldUri, newUri);
   // Trigger file watchers for both old and new URIs
   await triggerMemfsFileWatcher(oldUri);
   await triggerMemfsFileWatcher(newUri);
@@ -1670,7 +1728,7 @@ const remove = async dirent => {
 };
 const readFile = async uri => {
   if (isHttp(uri)) {
-    return readFile$3(uri);
+    return readFile$4(uri);
   }
   if (isMemory(uri)) {
     return readFile$1(uri);
@@ -1688,7 +1746,7 @@ const getPathSeparator = async root => {
 };
 const readJson = async uri => {
   if (isHttp(uri)) {
-    return readJson$3(uri);
+    return readJson$4(uri);
   }
   if (isMemory(uri)) {
     return readJson$1();
@@ -1719,7 +1777,7 @@ const stat = async dirent => {
 };
 const exists = async uri => {
   if (isHttp(uri)) {
-    return exists$2(uri);
+    return exists$3(uri);
   }
   return exists$1(uri);
 };
@@ -1770,7 +1828,7 @@ const handleMessagePort = async (port, rpcId) => {
     messagePort: port
   });
   if (rpcId) {
-    set$3(rpcId, rpc);
+    set$5(rpcId, rpc);
   }
 };
 
@@ -1841,9 +1899,7 @@ const Directory = 'directory';
 const File = 'file';
 
 const {
-  invoke,
-  setFactory
-} = createLazyRpc(RendererProcess);
+  invoke} = createLazyRpc(RendererProcess);
 
 /**
  * Do not use directly, use FileSystemHtml.getChildHandles
@@ -1952,40 +2008,42 @@ const commandMap = {
   'Initialize.initialize': initialize
 };
 
-const createExtensionHostRpc = async () => {
+const initializeExtensionHostWorker = async () => {
   try {
-    const rpc = await TransferMessagePortRpcParent.create({
+    const rpc = await LazyTransferMessagePortRpcParent.create({
       commandMap: {},
       send: sendMessagePortToExtensionHostWorker
     });
-    return rpc;
+    set$4(rpc);
   } catch (error) {
     throw new VError(error, `Failed to create extension host rpc`);
   }
 };
 
-const createRendererProcessRpc = async () => {
+const initializeRendererProcess = async () => {
   try {
-    const rpc = await TransferMessagePortRpcParent.create({
+    const rpc = await LazyTransferMessagePortRpcParent.create({
       commandMap: {},
       send: sendMessagePortToRendererProcess
     });
-    return rpc;
+    set$2(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 initializeRendererWorker = async () => {
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });
   set$1(rpc);
 };
 
+const listen = async () => {
+  Object.assign(commandMapRef, commandMap);
+  await Promise.all([initializeExtensionHostWorker(), initializeRendererProcess(), initializeRendererWorker()]);
+};
+
 const main = async () => {
   await listen();
 };