@lvce-editor/file-system-worker 5.20.4 → 5.21.1

package/dist/fileSystemWorkerMain.js

@@ -64,10 +64,10 @@ const Object$1 = 1;
 const Number$1 = 2;
 const Array$1 = 3;
 const String$1 = 4;
-const Boolean = 5;
+const Boolean$1 = 5;
 const Function = 6;
 const Null = 7;
-const Unknown = 8;
+const Unknown$1 = 8;
 const getType = value => {
   switch (typeof value) {
     case 'number':
@@ -85,9 +85,9 @@ const getType = value => {
       }
       return Object$1;
     case 'boolean':
-      return Boolean;
+      return Boolean$1;
     default:
-      return Unknown;
+      return Unknown$1;
   }
 };
 const object = value => {
@@ -534,7 +534,7 @@ const waitForWebSocketToBeOpen = webSocket => {
     open: Open
   });
 };
-const create$b = async ({
+const create$c = async ({
   webSocket
 }) => {
   const firstWebSocketEvent = await waitForWebSocketToBeOpen(webSocket);
@@ -571,7 +571,7 @@ const wrap = webSocket => {
 };
 const IpcParentWithWebSocket$1 = {
   __proto__: null,
-  create: create$b,
+  create: create$c,
   wrap
 };
 
@@ -601,7 +601,7 @@ const callbacks = Object.create(null);
 const get$1 = id => {
   return callbacks[id];
 };
-const remove$6 = id => {
+const remove$7 = id => {
   delete callbacks[id];
 };
 class JsonRpcError extends Error {
@@ -826,7 +826,7 @@ const resolve = (id, response) => {
     return;
   }
   fn(response);
-  remove$6(id);
+  remove$7(id);
 };
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getErrorType = prettyError => {
@@ -882,7 +882,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$a = (message, result) => {
+const create$b = (message, result) => {
   return {
     id: message.id,
     jsonrpc: Two$1,
@@ -891,7 +891,7 @@ const create$a = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$a(message, resultProperty);
+  return create$b(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
@@ -990,7 +990,7 @@ const handleJsonRpcMessage = async (...args) => {
 
 const Two = '2.0';
 
-const create$9 = (method, params) => {
+const create$a = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -998,7 +998,7 @@ const create$9 = (method, params) => {
   };
 };
 
-const create$8 = (id, method, params) => {
+const create$9 = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -1009,12 +1009,12 @@ const create$8 = (id, method, params) => {
 };
 
 let id = 0;
-const create$7 = () => {
+const create$8 = () => {
   return ++id;
 };
 
 const registerPromise = map => {
-  const id = create$7();
+  const id = create$8();
   const {
     promise,
     resolve
@@ -1031,7 +1031,7 @@ const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer)
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$8(id, method, params);
+  const message = create$9(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -1067,7 +1067,7 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$9(method, params);
+      const message = create$a(method, params);
       ipc.send(message);
     }
   };
@@ -1135,7 +1135,7 @@ const createSharedLazyRpc = factory => {
   };
 };
 
-const create$6 = async ({
+const create$7 = async ({
   commandMap,
   isMessagePortOpen = true,
   messagePort
@@ -1153,7 +1153,7 @@ const create$6 = async ({
   return rpc;
 };
 
-const create$5 = async ({
+const create$6 = async ({
   commandMap,
   isMessagePortOpen,
   send
@@ -1163,20 +1163,20 @@ const create$5 = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$6({
+  return create$7({
     commandMap,
     isMessagePortOpen,
     messagePort: port2
   });
 };
 
-const create$4 = async ({
+const create$5 = async ({
   commandMap,
   isMessagePortOpen,
   send
 }) => {
   return createSharedLazyRpc(() => {
-    return create$5({
+    return create$6({
       commandMap,
       isMessagePortOpen,
       send
@@ -1204,7 +1204,7 @@ const getProtocol = () => {
   return location.protocol;
 };
 
-const create$3 = async ({
+const create$4 = async ({
   commandMap,
   webSocket
 }) => {
@@ -1236,7 +1236,7 @@ const connect$1 = async ({
 }) => {
   const webSocket = new WebSocket(wsUrl);
   try {
-    const rpc = await create$3({
+    const rpc = await create$4({
       commandMap,
       webSocket
     });
@@ -1249,7 +1249,7 @@ const connect$1 = async ({
     throw error;
   }
 };
-const create$2 = async ({
+const create$3 = async ({
   commandMap,
   onClose,
   type
@@ -1278,7 +1278,7 @@ const create$2 = async ({
   return connection.rpc;
 };
 
-const create$1 = async ({
+const create$2 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1316,12 +1316,12 @@ const set$5 = (id, rpc) => {
 const get = id => {
   return rpcs[id];
 };
-const remove$5 = id => {
+const remove$6 = id => {
   delete rpcs[id];
 };
 
 /* eslint-disable  @typescript-eslint/explicit-function-return-type */
-const create = rpcId => {
+const create$1 = rpcId => {
   return {
     async dispose() {
       const rpc = get(rpcId);
@@ -1346,7 +1346,7 @@ const create = rpcId => {
       set$5(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
-        remove$5(rpcId);
+        remove$6(rpcId);
       };
       // @ts-ignore
       return mockRpc;
@@ -1359,6 +1359,7 @@ const create = rpcId => {
 
 const Directory$1 = 3;
 const File$3 = 7;
+const Unknown = 12;
 
 const DebugWorker = 55;
 const ExtensionHostWorker = 44;
@@ -1369,23 +1370,23 @@ const RendererWorker = 1;
 
 const {
   set: set$4
-} = create(ExtensionHostWorker);
+} = create$1(ExtensionHostWorker);
 
 const {
   invoke: invoke$3,
   set: set$3
-} = create(FileSystemProcess$1);
-const remove$4 = async uri => {
+} = create$1(FileSystemProcess$1);
+const remove$5 = async uri => {
   return invoke$3('FileSystem.remove', uri);
 };
-const readFile$4 = async uri => {
+const readFile$5 = async uri => {
   return invoke$3('FileSystem.readFile', uri);
 };
 const appendFile$2 = async (uri, text) => {
   // @ts-ignore
   return invoke$3('FileSystem.appendFile', uri, text);
 };
-const readDirWithFileTypes$4 = async uri => {
+const readDirWithFileTypes$5 = async uri => {
   return invoke$3('FileSystem.readDirWithFileTypes', uri);
 };
 const readJson$4 = async root => {
@@ -1400,11 +1401,11 @@ const stat$4 = async path => {
   // @ts-ignore
   return invoke$3('FileSystem.stat', path);
 };
-const writeFile$4 = async (path, content) => {
+const writeFile$5 = async (path, content) => {
   // @ts-ignore
   return invoke$3('FileSystem.writeFile', path, content);
 };
-const mkdir$4 = async path => {
+const mkdir$5 = async path => {
   // @ts-ignore
   return invoke$3('FileSystem.mkdir', path);
 };
@@ -1420,7 +1421,7 @@ const getFolderSize$4 = async uri => {
   // @ts-ignore
   return invoke$3('FileSystem.getFolderSize', uri);
 };
-const exists$4 = async uri => {
+const exists$5 = async uri => {
   // @ts-ignore
   return invoke$3('FileSystem.exists', uri);
 };
@@ -1429,19 +1430,19 @@ const FileSystemProcess = {
   __proto__: null,
   appendFile: appendFile$2,
   copy: copy$4,
-  exists: exists$4,
+  exists: exists$5,
   getFolderSize: getFolderSize$4,
   getRealPath: getRealPath$4,
   invoke: invoke$3,
-  mkdir: mkdir$4,
-  readDirWithFileTypes: readDirWithFileTypes$4,
-  readFile: readFile$4,
+  mkdir: mkdir$5,
+  readDirWithFileTypes: readDirWithFileTypes$5,
+  readFile: readFile$5,
   readJson: readJson$4,
-  remove: remove$4,
+  remove: remove$5,
   rename: rename$4,
   set: set$3,
   stat: stat$4,
-  writeFile: writeFile$4
+  writeFile: writeFile$5
 };
 
 const createLazyRpc = rpcId => {
@@ -1481,7 +1482,7 @@ const createLazyRpc = rpcId => {
     activeRpc = undefined;
     rpcPromise = undefined;
     if (rpc && get(rpcId) === rpc) {
-      remove$5(rpcId);
+      remove$6(rpcId);
     }
     if (notify) {
       for (const listener of resetListeners) {
@@ -1519,13 +1520,13 @@ const createLazyRpc = rpcId => {
 
 const {
   set: set$2
-} = create(RendererProcess);
+} = create$1(RendererProcess);
 
 const {
   invoke: invoke$2,
   invokeAndTransfer,
   set: set$1
-} = create(RendererWorker);
+} = create$1(RendererWorker);
 const sendMessagePortToRendererProcess = async (port, rpcId = DebugWorker) => {
   const command = 'HandleMessagePort.handleMessagePort';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, rpcId);
@@ -1556,19 +1557,19 @@ const getFileHashes$1 = async uris => {
 const {
   appendFile: appendFile$1,
   copy: copy$3,
-  exists: exists$3,
+  exists: exists$4,
   getFolderSize: getFolderSize$3,
   getRealPath: getRealPath$3,
   invoke: invoke$1,
-  mkdir: mkdir$3,
-  readDirWithFileTypes: readDirWithFileTypes$3,
-  readFile: readFile$3,
+  mkdir: mkdir$4,
+  readDirWithFileTypes: readDirWithFileTypes$4,
+  readFile: readFile$4,
   readJson: readJson$3,
-  remove: remove$3,
+  remove: remove$4,
   rename: rename$3,
   set,
   stat: stat$3,
-  writeFile: writeFile$3
+  writeFile: writeFile$4
 } = FileSystemProcess;
 
 const Http = 'http:';
@@ -1689,11 +1690,11 @@ const readFileAsBlob$2 = async uri => {
   if (entry.type !== file) throw new Error(`File is a directory: ${uri}`);
   return entry.content;
 };
-const readFile$2 = async uri => {
+const readFile$3 = async uri => {
   const blob = await readFileAsBlob$2(uri);
   return blob.text();
 };
-const writeFile$2 = async (uri, content) => {
+const writeFile$3 = async (uri, content) => {
   const path = getPath(uri);
   ensureParentDirs(path);
   files.set(path, {
@@ -1704,9 +1705,9 @@ const writeFile$2 = async (uri, content) => {
   });
   await triggerMemfsFileWatcher(uri);
 };
-const exists$2 = async uri => !!getEntry(uri);
-const createFile$2 = async uri => writeFile$2(uri, '');
-const mkdir$2 = async uri => {
+const exists$3 = async uri => !!getEntry(uri);
+const createFile$2 = async uri => writeFile$3(uri, '');
+const mkdir$3 = async uri => {
   const path = getPath(uri);
   ensureParentDirs(path);
   files.set(path, {
@@ -1715,14 +1716,14 @@ const mkdir$2 = async uri => {
   });
   await triggerMemfsFileWatcher(uri);
 };
-const remove$2 = async uri => {
+const remove$3 = async uri => {
   const path = getPath(uri);
   for (const key of files.keys()) {
     if (key === path || key.startsWith(`${path}/`)) files.delete(key);
   }
   await triggerMemfsFileWatcher(uri);
 };
-const readDirWithFileTypes$2 = async uri => {
+const readDirWithFileTypes$3 = async uri => {
   const path = `${getPath(uri)}/`;
   const entries = new Map();
   for (const [key, value] of files) {
@@ -1756,7 +1757,7 @@ const rename$2 = async (oldUri, newUri) => {
   await triggerMemfsFileWatcher(oldUri);
   await triggerMemfsFileWatcher(newUri);
 };
-const copy$2 = async (oldUri, newUri) => writeFile$2(newUri, await readFile$2(oldUri));
+const copy$2 = async (oldUri, newUri) => writeFile$3(newUri, await readFile$3(oldUri));
 const stat$2 = async uri => {
   const entry = getEntry(uri);
   return entry ? {
@@ -1768,7 +1769,7 @@ const stat$2 = async uri => {
     size: 0
   };
 };
-const readJson$2 = async uri => JSON.parse(await readFile$2(uri));
+const readJson$2 = async uri => JSON.parse(await readFile$3(uri));
 const getPathSeparator$1 = async _root => '/';
 const getRealPath$2 = async uri => uri;
 const getFolderSize$2 = async uri => {
@@ -1789,20 +1790,20 @@ const FileSystemMemory = {
   __proto__: null,
   copy: copy$2,
   createFile: createFile$2,
-  exists: exists$2,
+  exists: exists$3,
   getFiles,
   getFolderSize: getFolderSize$2,
   getPathSeparator: getPathSeparator$1,
   getRealPath: getRealPath$2,
-  mkdir: mkdir$2,
-  readDirWithFileTypes: readDirWithFileTypes$2,
-  readFile: readFile$2,
+  mkdir: mkdir$3,
+  readDirWithFileTypes: readDirWithFileTypes$3,
+  readFile: readFile$3,
   readFileAsBlob: readFileAsBlob$2,
   readJson: readJson$2,
-  remove: remove$2,
+  remove: remove$3,
   rename: rename$2,
   stat: stat$2,
-  writeFile: writeFile$2
+  writeFile: writeFile$3
 };
 
 const memoryRoot = id => `memfs:///applications/${encodeURIComponent(id)}`;
@@ -1826,22 +1827,22 @@ const execute = async (id, method, ...args) => {
   // This callback handles only non-memory URIs, never file contents storage.
   return invoke$2('Application.execute', id, `FileSystem.${method}`, ...args);
 };
-const dispose = async id => remove$2(memoryRoot(id));
+const dispose = async id => remove$3(memoryRoot(id));
 
 const connect = async port => {
   const {
     commandMap
   } = await Promise.resolve().then(function () { return CommandMap; });
-  await create$6({
+  await create$7({
     commandMap,
     messagePort: port
   });
 };
 
-const remove$1 = async dirent => {
+const remove$2 = async dirent => {
   throw new Error('not implemented');
 };
-const readFile$1 = async uri => {
+const readFile$2 = async uri => {
   const response = await fetch(uri);
   if (!response.ok) {
     throw new Error(response.statusText);
@@ -1857,11 +1858,11 @@ const readFileAsBlob$1 = async uri => {
   const result = await response.blob();
   return result;
 };
-const exists$1 = async uri => {
+const exists$2 = async uri => {
   const response = await fetch(uri);
   return response.ok;
 };
-const readDirWithFileTypes$1 = async uri => {
+const readDirWithFileTypes$2 = async uri => {
   throw new Error('not implemented');
 };
 const readJson$1 = async uri => {
@@ -1881,10 +1882,10 @@ const stat$1 = async dirent => {
 const createFile$1 = async uri => {
   throw new Error('not implemented');
 };
-const writeFile$1 = async (uri, content) => {
+const writeFile$2 = async (uri, content) => {
   throw new Error('not implemented');
 };
-const mkdir$1 = async uri => {
+const mkdir$2 = async uri => {
   throw new Error('not implemented');
 };
 const rename$1 = async (oldUri, newUri) => {
@@ -1901,18 +1902,464 @@ const FileSystemFetch = {
   __proto__: null,
   copy: copy$1,
   createFile: createFile$1,
-  exists: exists$1,
+  exists: exists$2,
   getFolderSize: getFolderSize$1,
   getRealPath: getRealPath$1,
-  mkdir: mkdir$1,
-  readDirWithFileTypes: readDirWithFileTypes$1,
-  readFile: readFile$1,
+  mkdir: mkdir$2,
+  readDirWithFileTypes: readDirWithFileTypes$2,
+  readFile: readFile$2,
   readFileAsBlob: readFileAsBlob$1,
   readJson: readJson$1,
-  remove: remove$1,
+  remove: remove$2,
   rename: rename$1,
   stat: stat$1,
-  writeFile: writeFile$1
+  writeFile: writeFile$2
+};
+
+const hasName = (error, name) => {
+  return typeof error === 'object' && error !== null && 'name' in error && error.name === name;
+};
+const isNotAllowedError = error => hasName(error, 'NotAllowedError');
+const isNotFoundError = error => hasName(error, 'NotFoundError');
+
+const Granted = 'granted';
+const Prompt = 'prompt';
+const Denied = 'denied';
+
+const Directory = 'directory';
+const File$1 = 'file';
+
+const getDirentType = fileHandleKind => {
+  switch (fileHandleKind) {
+    case Directory:
+      return Directory$1;
+    case File$1:
+      return File$3;
+    default:
+      return Unknown;
+  }
+};
+
+class FileNotFoundError extends Error {
+  code = 'ENOENT';
+  constructor(path) {
+    super(`File not found '${path}'`);
+    this.name = 'FileNotFoundError';
+  }
+}
+
+/**
+ * Do not use directly, use FileSystemHtml.getChildHandles
+ * instead which prompts for the required permission to
+ * retrieve the child handles
+ */
+const getChildHandles$1 = async handle => {
+  object(handle);
+  // @ts-ignore - values() exists on FileSystemDirectoryHandle but TypeScript types may not include it
+  const handles = await Array.fromAsync(handle.values());
+  return handles;
+};
+const getFileHandle$1 = (handle, name, options) => {
+  return handle.getFileHandle(name, options);
+};
+const getDirectoryHandle$1 = (handle, name) => {
+  return handle.getDirectoryHandle(name);
+};
+
+const getBinaryString$1 = async file => {
+  const bytes = new Uint8Array(await file.arrayBuffer());
+  const chunks = [];
+  const chunkSize = 32_768;
+  for (let i = 0; i < bytes.length; i += chunkSize) {
+    chunks.push(String.fromCodePoint(...bytes.subarray(i, i + chunkSize)));
+  }
+  return chunks.join('');
+};
+
+const getFile = async handle => {
+  if ('file' in handle) return handle.file;
+  return handle.getFile();
+};
+const getBinaryString = async handle => {
+  const file = await getFile(handle);
+  const text = await getBinaryString$1(file);
+  return text;
+};
+const write = async (handle, content) => {
+  if ('readonly' in handle && handle.readonly) {
+    throw new Error(`File ${handle.name} is read-only`);
+  }
+  const writable = await handle.createWritable();
+  await writable.write(content);
+  await writable.close();
+};
+
+const {
+  invoke} = createLazyRpc(RendererProcess);
+
+const requestPermission = async (handle, options) => {
+  // query permission, but from renderer process
+  // because handle.requestPermission is not implemented
+  // in a worker, see https://github.com/WICG/file-system-access/issues/289
+  const permissionTypeNow = await invoke('FileSystemHandle.requestPermission', handle, options);
+  return permissionTypeNow;
+};
+const queryPermission = async (handle, options) => {
+  // @ts-ignore - queryPermission exists on FileSystemHandle but TypeScript types may not include it
+  return handle.queryPermission(options);
+};
+
+const join = (pathSeparator, ...parts) => {
+  return parts.join(pathSeparator);
+};
+const dirname = (pathSeparator, path) => {
+  const index = path.lastIndexOf(pathSeparator);
+  return index === -1 ? path : path.slice(0, index);
+};
+const getBaseName = (pathSeparator, path) => {
+  return path.slice(path.lastIndexOf(pathSeparator) + 1);
+};
+
+// Native IDB events expose a generic result that may itself be mutable.
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+const requestToPromise = request => {
+  return new Promise((resolve, reject) => {
+    request.addEventListener('success', () => resolve(request.result), {
+      once: true
+    });
+    request.addEventListener('error', () => reject(request.error || new Error('IndexedDB request failed')), {
+      once: true
+    });
+  });
+};
+const state$1 = {};
+const getDatabase = () => {
+  state$1.databasePromise ||= (() => {
+    // Keep the renderer's database and store names so existing workspaces restore.
+    const request = indexedDB.open('handle', 1);
+    request.onupgradeneeded = () => {
+      const database = request.result;
+      if (!database.objectStoreNames.contains('file-handles-store')) {
+        database.createObjectStore('file-handles-store');
+      }
+    };
+    return requestToPromise(request);
+  })();
+  return state$1.databasePromise;
+};
+const addHandle$1 = async (uri, handle) => {
+  const database = await getDatabase();
+  await requestToPromise(database.transaction('file-handles-store', 'readwrite').objectStore('file-handles-store').put(handle, uri));
+};
+const getHandle$1 = async uri => {
+  const database = await getDatabase();
+  return requestToPromise(database.transaction('file-handles-store').objectStore('file-handles-store').get(uri));
+};
+
+const handles = Object.create(null);
+const getLegacyHtmlKeys = uri => {
+  if (!uri.startsWith('html://')) {
+    return [];
+  }
+  const strippedUri = uri.slice('html://'.length);
+  const legacyKeys = [];
+  if (strippedUri) {
+    legacyKeys.push(strippedUri);
+  }
+  if (strippedUri.startsWith('/')) {
+    legacyKeys.push(strippedUri.slice(1));
+  }
+  return legacyKeys.filter((value, index, array) => value && array.indexOf(value) === index);
+};
+const addHandle = async (uri, handle) => {
+  try {
+    handles[uri] = handle;
+    await addHandle$1(uri, handle);
+  } catch (error) {
+    throw new VError(error, 'Failed to add handle');
+  }
+};
+const addHandles = async (parentUri, childHandles) => {
+  const promises = [];
+  for (const childHandle of childHandles) {
+    const childUri = parentUri + '/' + childHandle.name;
+    if (childUri in handles) {
+      continue;
+    }
+    handles[childUri] = childHandle;
+    promises.push(addHandle(childUri, childHandle));
+  }
+  await Promise.all(promises);
+};
+const removeHandle = uri => {
+  delete handles[uri];
+  const prefix = `${uri}/`;
+  for (const key in handles) {
+    if (key.startsWith(prefix)) {
+      delete handles[key];
+    }
+  }
+};
+const getHandle = async uri => {
+  try {
+    if (uri in handles) {
+      return handles[uri];
+    }
+    let handle = await getHandle$1(uri);
+    if (!handle) {
+      const legacyKeys = getLegacyHtmlKeys(uri);
+      for (const legacyKey of legacyKeys) {
+        handle = await getHandle$1(legacyKey);
+        if (handle) {
+          await addHandle(uri, handle);
+          handles[legacyKey] = handle;
+          break;
+        }
+      }
+    }
+    if (handle) {
+      handles[uri] = handle;
+    }
+    return handle;
+  } catch (error) {
+    throw new VError(error, 'Failed to get handle');
+  }
+};
+
+const pathSeparator$2 = '/';
+const getDirectoryHandleWithDependencies = async (uri, dependencies) => {
+  const handle = await dependencies.getHandle(uri);
+  if (handle) {
+    return handle;
+  }
+  const dirname$1 = dirname(pathSeparator$2, uri);
+  if (uri === dirname$1) {
+    return undefined;
+  }
+  const parentHandle = await getDirectoryHandleWithDependencies(dirname$1, dependencies);
+  if (!parentHandle) {
+    return undefined;
+  }
+  const baseName = getBaseName(pathSeparator$2, uri);
+  try {
+    const directoryHandle = await dependencies.getDirectoryHandle(parentHandle, baseName);
+    await dependencies.addHandle(uri, directoryHandle);
+    return directoryHandle;
+  } catch (error) {
+    if (isNotFoundError(error)) return undefined;
+    throw error;
+  }
+};
+const getDirectoryHandle = async uri => {
+  return getDirectoryHandleWithDependencies(uri, {
+    addHandle: addHandle,
+    getDirectoryHandle: getDirectoryHandle$1,
+    getHandle: async path => {
+      const handle = await getHandle(path);
+      return handle;
+    }
+  });
+};
+
+const pathSeparator$1 = '/';
+const getFileHandle = async (uri, options) => {
+  const handle = await getHandle(uri);
+  if (handle) {
+    return handle;
+  }
+  const dirname$1 = dirname(pathSeparator$1, uri);
+  const parentHandle = await getDirectoryHandle(dirname$1);
+  if (!parentHandle) {
+    return undefined;
+  }
+  const baseName = getBaseName(pathSeparator$1, uri);
+  const fileHandle = await getFileHandle$1(parentHandle, baseName, options);
+  return fileHandle;
+};
+
+const pathSeparator = '/';
+const exists$1 = async uri => {
+  const handle = await getHandle(uri);
+  return Boolean(handle);
+};
+const getDirent = handle => {
+  const {
+    kind,
+    name
+  } = handle;
+  const type = getDirentType(kind);
+  return {
+    name,
+    type
+  };
+};
+const getDirents = handles => {
+  const dirents = handles.map(getDirent);
+  return dirents;
+};
+const getChildHandlesFallbackPrompt = async handle => {
+  // TODO cannot prompt without user activation, else error occurs
+  // maybe need to show
+  const permissionTypeNow = await requestPermission(handle, {
+    mode: 'readwrite'
+  });
+  switch (permissionTypeNow) {
+    case Denied:
+    case Prompt:
+      return [];
+    case Granted:
+      return getChildHandles$1(handle);
+    default:
+      return [];
+  }
+};
+const getChildHandlesFallback = async handle => {
+  const permissionType = await queryPermission(handle, {
+    mode: 'readwrite'
+  });
+  switch (permissionType) {
+    case Denied:
+      return [];
+    case Granted:
+      throw new VError('invalid state');
+    case Prompt:
+      return await getChildHandlesFallbackPrompt(handle);
+    default:
+      return [];
+  }
+};
+const getChildHandles = async handle => {
+  try {
+    return await getChildHandles$1(handle);
+  } catch (error) {
+    if (isNotAllowedError(error)) {
+      return getChildHandlesFallback(handle);
+    }
+    throw new VError(error, 'failed to get child handles');
+  }
+};
+const readDirWithFileTypes$1 = async uri => {
+  try {
+    const handle = await getHandle(uri);
+    if (!handle) {
+      throw new Error(`File system handle not found for ${uri}`);
+    }
+    const childHandles = await getChildHandles(handle);
+    await addHandles(uri, childHandles);
+    const dirents = getDirents(childHandles);
+    return dirents;
+  } catch (error) {
+    throw new VError(error, 'failed to read directory');
+  }
+};
+const readFile$1 = async uri => {
+  try {
+    const handle = await getFileHandle(uri);
+    if (!handle) {
+      throw new VError(`File not found ${uri}`);
+    }
+    const file = await getFile(handle);
+    const text = await file.text();
+    return text;
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      throw new FileNotFoundError(uri);
+    }
+    throw new VError(error, 'Failed to read file');
+  }
+};
+const writeFile$1 = async (uri, content) => {
+  try {
+    const handle = await getFileHandle(uri, {
+      create: true
+    });
+    if (!handle) {
+      throw new VError(`File not found ${uri}`);
+    }
+    await write(handle, content);
+  } catch (error) {
+    throw new VError(error, 'Failed to save file');
+  }
+};
+const writeBlob$1 = async (uri, blob) => {
+  try {
+    const handle = await getFileHandle(uri, {
+      create: true
+    });
+    if (!handle) {
+      throw new VError(`File not found ${uri}`);
+    }
+    await write(handle, blob);
+  } catch (error) {
+    throw new VError(error, 'Failed to save file');
+  }
+};
+const remove$1 = async uri => {
+  try {
+    const dirname$1 = dirname(pathSeparator, uri);
+    const parentHandle = await getDirectoryHandle(dirname$1);
+    if (!parentHandle) {
+      throw new FileNotFoundError(uri);
+    }
+    const existingHandle = await getHandle(uri);
+    const baseName = getBaseName(pathSeparator, uri);
+    if (existingHandle?.kind === 'directory') {
+      await parentHandle.removeEntry(baseName, {
+        recursive: true
+      });
+    } else {
+      await parentHandle.removeEntry(baseName);
+    }
+    removeHandle(uri);
+  } catch (error) {
+    if (error instanceof FileNotFoundError || isNotFoundError(error)) {
+      throw new FileNotFoundError(uri);
+    }
+    throw new VError(error, 'Failed to remove');
+  }
+};
+const ensureDirectoryHandle = async uri => {
+  const existingHandle = await getHandle(uri);
+  if (existingHandle) {
+    if (existingHandle.kind !== 'directory') {
+      throw new VError(`Expected directory at ${uri}`);
+    }
+    return existingHandle;
+  }
+  const dirname$1 = dirname(pathSeparator, uri);
+  if (uri === dirname$1) {
+    throw new VError(`Directory handle not found for ${uri}`);
+  }
+  let parentHandle = await getDirectoryHandle(dirname$1);
+  if (!parentHandle) {
+    parentHandle = await ensureDirectoryHandle(dirname$1);
+  }
+  const baseName = getBaseName(pathSeparator, uri);
+  const directoryHandle = await parentHandle.getDirectoryHandle(baseName, {
+    create: true
+  });
+  await addHandle(uri, directoryHandle);
+  return directoryHandle;
+};
+const mkdir$1 = async uri => {
+  try {
+    await ensureDirectoryHandle(uri);
+  } catch (error) {
+    throw new VError(error, 'Failed to create directory');
+  }
+};
+const isReadonly$1 = async uri => {
+  const handle = await getHandle(uri);
+  return Boolean(handle && 'readonly' in handle && handle.readonly);
+};
+const getBlob = async uri => {
+  const handle = await getFileHandle(uri);
+  if (!handle) {
+    throw new Error(`file not found`);
+  }
+  const file = await getFile(handle);
+  // TODO convert handle to blob mime type?
+  return file;
 };
 
 const isFetch = uri => {
@@ -1938,29 +2385,31 @@ const isProviderUri = uri => {
 };
 
 const remove = async dirent => {
+  if (isHtml(dirent)) return remove$1(dirent);
   if (isMemory(dirent)) {
-    return remove$2(dirent);
+    return remove$3(dirent);
   }
   if (isProviderUri(dirent)) {
     return invoke$2('FileSystem.remove', dirent);
   }
-  return remove$3(dirent);
+  return remove$4(dirent);
 };
 const readFile = async uri => {
+  if (isHtml(uri)) return readFile$1(uri);
   if (uri.startsWith('untitled:')) return '';
-  if (isFetch(uri) || isHtml(uri)) {
+  if (isFetch(uri)) {
     return invoke$2('FileSystem.readFile', uri);
   }
   if (isHttp(uri)) {
-    return readFile$1(uri);
+    return readFile$2(uri);
   }
   if (isMemory(uri)) {
-    return readFile$2(uri);
+    return readFile$3(uri);
   }
   if (isProviderUri(uri)) {
     return invoke$2('FileSystem.readFile', uri);
   }
-  return readFile$3(uri);
+  return readFile$4(uri);
 };
 const getFileHash = async uri => {
   return getFileHash$1(uri);
@@ -1972,21 +2421,24 @@ const appendFile = async (uri, text) => {
   return appendFile$1(uri, text);
 };
 const readDirWithFileTypes = async uri => {
-  if (isFetch(uri) || isHtml(uri)) {
+  if (isHtml(uri)) return readDirWithFileTypes$1(uri);
+  if (isFetch(uri)) {
     return invoke$2('FileSystem.readDirWithFileTypes', uri);
   }
   if (isMemory(uri)) {
-    return readDirWithFileTypes$2(uri);
+    return readDirWithFileTypes$3(uri);
   }
   if (isProviderUri(uri)) {
     return invoke$2('FileSystem.readDirWithFileTypes', uri);
   }
-  return readDirWithFileTypes$3(uri);
+  return readDirWithFileTypes$4(uri);
 };
 const isReadonly = async uri => {
+  if (isHtml(uri)) return isReadonly$1(uri);
   return invoke$1('FileSystem.isReadonly', uri);
 };
 const readJson = async uri => {
+  if (isHtml(uri)) return JSON.parse(await readFile$1(uri));
   if (isHttp(uri)) {
     return readJson$1(uri);
   }
@@ -2006,6 +2458,7 @@ const getFileSize = async uri => {
   return invoke$1('FileSystem.getFileSize', uri);
 };
 const readFileAsBlob = async uri => {
+  if (isHtml(uri)) return getBlob(uri);
   if (isHttp(uri)) {
     return readFileAsBlob$1(uri);
   }
@@ -2032,31 +2485,34 @@ const stat = async dirent => {
   return stat$3(dirent);
 };
 const exists = async uri => {
+  if (isHtml(uri)) return exists$1(uri);
   if (isMemory(uri)) {
-    return exists$2(uri);
+    return exists$3(uri);
   }
-  if (isFetch(uri) || isHtml(uri) || isProviderUri(uri)) {
+  if (isFetch(uri) || isProviderUri(uri)) {
     return invoke$2('FileSystem.exists', uri);
   }
   if (isHttp(uri)) {
-    return exists$1(uri);
+    return exists$2(uri);
   }
-  return exists$3(uri);
+  return exists$4(uri);
 };
 const createFile = async uri => {
   if (isMemory(uri)) {
     return createFile$2(uri);
   }
-  return writeFile$3(uri, '');
+  if (isHtml(uri)) return writeFile$1(uri, '');
+  return writeFile$4(uri, '');
 };
 const writeFile = async (uri, content) => {
+  if (isHtml(uri)) return writeFile$1(uri, content);
   if (isMemory(uri)) {
-    return writeFile$2(uri, content);
+    return writeFile$3(uri, content);
   }
   if (isProviderUri(uri)) {
     return invoke$2('FileSystem.writeFile', uri, content);
   }
-  return writeFile$3(uri, content);
+  return writeFile$4(uri, content);
 };
 const getBytes = async blob => {
   if (blob.bytes) {
@@ -2067,16 +2523,18 @@ const getBytes = async blob => {
   return bytes;
 };
 const writeBlob = async (uri, blob) => {
+  if (isHtml(uri)) return writeBlob$1(uri, blob);
   const bytes = await getBytes(blob);
   // @ts-ignore
   await invoke$1('FileSystem.writeBuffer', uri, bytes);
 };
 const mkdir = async uri => {
+  if (isHtml(uri)) return mkdir$1(uri);
   if (isMemory(uri)) {
-    await mkdir$2(uri);
+    await mkdir$3(uri);
     return;
   }
-  return mkdir$3(uri);
+  return mkdir$4(uri);
 };
 const rename = async (oldUri, newUri) => {
   if (isMemory(oldUri) || isMemory(newUri)) {
@@ -2365,8 +2823,195 @@ const glob = async (root, pattern) => {
   return globWithFileSystem(FileSystemDisk, root, pattern);
 };
 
+const escapeRegExp = character => /[|\\{}()[\]^$+?.]/.test(character) ? `\\${character}` : character;
+const globToken = (pattern, index) => {
+  const character = pattern[index];
+  switch (character) {
+    case '?':
+      return ['[^/]', 1];
+    case '[':
+      {
+        const end = pattern.indexOf(']', index + 1);
+        if (end === -1) return ['\\[', 1];
+        const range = pattern.slice(index + 1, end);
+        const normalizedRange = range.startsWith('!') ? `^${range.slice(1)}` : range;
+        return [`[${normalizedRange}]`, end - index + 1];
+      }
+    case '*':
+      if (pattern[index + 1] !== '*') return ['[^/]*', 1];
+      return pattern[index + 2] === '/' ? ['(?:.*/)?', 3] : ['.*', 2];
+    default:
+      return [escapeRegExp(character), 1];
+  }
+};
+const globToRegExp = pattern => {
+  let source = '^';
+  let index = 0;
+  while (index < pattern.length) {
+    const [token, length] = globToken(pattern, index);
+    source += token;
+    index += length;
+  }
+  return new RegExp(`${source}$`);
+};
+const parseRule = line => {
+  let pattern = line.trimEnd();
+  if (!pattern || pattern.startsWith('#')) {
+    return undefined;
+  }
+  let negated = false;
+  if (pattern.startsWith('!')) {
+    negated = true;
+    pattern = pattern.slice(1);
+  } else if (pattern.startsWith('\\!') || pattern.startsWith('\\#')) {
+    pattern = pattern.slice(1);
+  }
+  const rooted = pattern.startsWith('/');
+  pattern = pattern.replace(/^\//, '');
+  const directoryOnly = pattern.endsWith('/');
+  if (directoryOnly) {
+    pattern = pattern.slice(0, -1);
+  }
+  if (!pattern) {
+    return undefined;
+  }
+  const hasSlash = rooted || pattern.includes('/');
+  return {
+    directoryOnly,
+    negated,
+    pattern: globToRegExp(pattern),
+    segmentOnly: !hasSlash
+  };
+};
+const ruleMatches = (rule, path, isDirectory) => {
+  if (rule.directoryOnly && !isDirectory) {
+    return false;
+  }
+  if (rule.segmentOnly) {
+    const name = path.slice(path.lastIndexOf('/') + 1);
+    return rule.pattern.test(name);
+  }
+  return rule.pattern.test(path);
+};
+const create = (contents = '') => {
+  const rules = contents.split(/\r?\n/).map(parseRule).filter(rule => rule !== undefined);
+  return {
+    hasNegation: rules.some(rule => rule.negated),
+    isIgnored(path, isDirectory = false) {
+      const parts = path.split('/').filter(Boolean);
+      let ignored = false;
+      for (let index = 0; index < parts.length; index++) {
+        if (ignored) {
+          return true;
+        }
+        const relativePath = parts.slice(0, index + 1).join('/');
+        const currentIsDirectory = index < parts.length - 1 || isDirectory;
+        for (const rule of rules) {
+          if (ruleMatches(rule, relativePath, currentIsDirectory)) {
+            ignored = !rule.negated;
+          }
+        }
+      }
+      return ignored;
+    }
+  };
+};
+
+const FILE_RESULT = 1;
+const MATCH_RESULT = 2;
+const USE_REGULAR_EXPRESSION = 1 << 1;
+const MATCH_WHOLE_WORD = 1 << 3;
+const MATCH_CASE = 1 << 4;
+const getLineMatch = (line, lineNumber, query, flags) => {
+  if (flags & USE_REGULAR_EXPRESSION) {
+    const regex = new RegExp(query, flags & MATCH_CASE ? '' : 'i');
+    const match = line.match(regex);
+    return match && typeof match.index === 'number' ? [{
+      end: match.index + match[0].length,
+      lineNumber,
+      start: match.index,
+      text: line,
+      type: MATCH_RESULT
+    }] : [];
+  }
+  const source = flags & MATCH_CASE ? line : line.toLowerCase();
+  const needle = flags & MATCH_CASE ? query : query.toLowerCase();
+  const index = source.indexOf(needle);
+  if (index === -1) {
+    return [];
+  }
+  if (flags & MATCH_WHOLE_WORD) {
+    const before = line[index - 1];
+    const after = line[index + query.length];
+    if (before && /[\p{L}\p{N}_]/u.test(before) || after && /[\p{L}\p{N}_]/u.test(after)) {
+      return [];
+    }
+  }
+  return [{
+    end: index + query.length,
+    lineNumber,
+    start: index,
+    text: line,
+    type: MATCH_RESULT
+  }];
+};
+const searchText = (file, content, query, flags = 0) => {
+  const matches = content.split(/\r?\n/).flatMap((line, index) => getLineMatch(line, index, query, flags));
+  return matches.length === 0 ? [] : [{
+    end: 0,
+    lineNumber: 0,
+    start: 0,
+    text: file,
+    type: FILE_RESULT
+  }, ...matches];
+};
+const searchHtmlDirectory = async (uri, relativePath, query, flags) => {
+  const entries = await readDirWithFileTypes$1(uri);
+  const results = [];
+  for (const entry of entries) {
+    const childUri = `${uri}/${entry.name}`;
+    const childRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+    if (entry.type === Directory$1) {
+      results.push(...(await searchHtmlDirectory(childUri, childRelativePath, query, flags)));
+    } else {
+      const content = await readFile$1(childUri);
+      results.push(...searchText(childRelativePath, content, query, flags));
+    }
+  }
+  return results;
+};
+const textSearch = async (root, query, options = {}) => {
+  return searchHtmlDirectory(root, '', query, options.flags || 0);
+};
+const searchDirectory = async (uri, prefix, matcher) => {
+  const entries = await readDirWithFileTypes$1(uri);
+  const results = [];
+  for (const entry of entries) {
+    const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.type === Directory$1) {
+      if (matcher.hasNegation || !matcher.isIgnored(relativePath, true)) {
+        results.push(...(await searchDirectory(`${uri}/${entry.name}`, relativePath, matcher)));
+      }
+    } else if (!matcher.isIgnored(relativePath)) {
+      results.push(relativePath);
+    }
+  }
+  return results;
+};
+const fileSearch = async uri => {
+  let contents = '';
+  try {
+    contents = await readFile$1(`${uri}/.gitignore`);
+  } catch (error) {
+    if (!(error instanceof FileNotFoundError)) {
+      throw error;
+    }
+  }
+  return searchDirectory(uri, '', create(contents));
+};
+
 const handleMessagePort = async (port, rpcId) => {
-  const rpc = await create$6({
+  const rpc = await create$7({
     commandMap: {},
     messagePort: port
   });
@@ -2381,7 +3026,7 @@ const sendMessagePortToFileSystemProcess = async port => {
 
 const createFileSystemProcessRpcElectron = async () => {
   try {
-    const rpc = await create$5({
+    const rpc = await create$6({
       commandMap: {},
       send: sendMessagePortToFileSystemProcess
     });
@@ -2400,7 +3045,7 @@ const createFileSystemProcessRpcNode = async () => {
         protocols,
         url
       } = await invoke$2('WebSocketCapability.create', 'file-system-process');
-      return await create$3({
+      return await create$4({
         commandMap: commandMapRef,
         webSocket: new WebSocket(url, protocols)
       });
@@ -2409,7 +3054,7 @@ const createFileSystemProcessRpcNode = async () => {
         throw error;
       }
     }
-    const rpc = await create$2({
+    const rpc = await create$3({
       commandMap: commandMapRef,
       type: 'file-system-process'
     });
@@ -2468,54 +3113,13 @@ const initialize = async platform => {
   await initializeFileSystemProcess(platform);
 };
 
-const Directory = 'directory';
-const File$1 = 'file';
-
-const {
-  invoke} = createLazyRpc(RendererProcess);
-
-/**
- * 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 Array.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);
+  const childHandles = await getChildHandles$1(fileSystemHandle);
   await uploadHandles(childHandles, pathSeparator, folderPath);
 };
 
-const getBinaryString$1 = async file => {
-  const bytes = new Uint8Array(await file.arrayBuffer());
-  const chunks = [];
-  const chunkSize = 32_768;
-  for (let i = 0; i < bytes.length; i += chunkSize) {
-    chunks.push(String.fromCodePoint(...bytes.subarray(i, i + chunkSize)));
-  }
-  return chunks.join('');
-};
-
-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);
@@ -2549,7 +3153,7 @@ const uploadFileSystemHandles = async (root, pathSeparator, fileSystemHandles) =
       name
     } = file;
     if (kind === Directory) {
-      await invoke('PersistentFileHandle.addHandle', `/${name}`, file);
+      await addHandle(`html:///${name}`, file);
       await invoke('Workspace.setPath', `html:///${name}`);
       return true;
     }
@@ -2589,8 +3193,13 @@ const commandMap = {
   'FileSystem.watchFile': watchFile,
   'FileSystem.writeBlob': writeBlob,
   'FileSystem.writeFile': writeFile,
+  'FileSystemHtml.fileSearch': fileSearch,
+  'FileSystemHtml.textSearch': textSearch,
   'FileSystemMemory.getFiles': getFiles,
-  'Initialize.initialize': initialize
+  'Initialize.initialize': initialize,
+  'PersistentFileHandle.addHandle': addHandle,
+  'PersistentFileHandle.getHandle': getHandle,
+  'PersistentFileHandle.removeHandle': removeHandle
 };
 
 const CommandMap = {
@@ -2618,7 +3227,7 @@ const fileSystemModules = {
 
 const initializeExtensionHostWorker = async () => {
   try {
-    const rpc = await create$4({
+    const rpc = await create$5({
       commandMap: {},
       send: port => sendMessagePortToExtensionManagementWorker(port, 0)
     });
@@ -2630,7 +3239,7 @@ const initializeExtensionHostWorker = async () => {
 
 const initializeRendererProcess = async () => {
   try {
-    const rpc = await create$4({
+    const rpc = await create$5({
       commandMap: {},
       send: sendMessagePortToRendererProcess
     });
@@ -2641,7 +3250,7 @@ const initializeRendererProcess = async () => {
 };
 
 const initializeRendererWorker = async () => {
-  const rpc = await create$1({
+  const rpc = await create$2({
     commandMap: commandMap
   });
   set$1(rpc);