@lvce-editor/file-system-worker 5.20.3 → 5.21.0

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 => {
@@ -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 => {
@@ -1316,7 +1316,7 @@ const set$5 = (id, rpc) => {
 const get = id => {
   return rpcs[id];
 };
-const remove$5 = id => {
+const remove$6 = id => {
   delete rpcs[id];
 };
 
@@ -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;
@@ -1375,17 +1376,17 @@ const {
   invoke: invoke$3,
   set: set$3
 } = create(FileSystemProcess$1);
-const remove$4 = async uri => {
+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) {
@@ -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,7 +1827,7 @@ 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 {
@@ -1838,10 +1839,10 @@ const connect = async 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 (isFetch(uri) || isHtml(uri) || isProviderUri(uri)) {
+  if (isHtml(uri)) return exists$1(uri);
+  if (isMemory(uri)) {
+    return exists$3(uri);
+  }
+  if (isFetch(uri) || isProviderUri(uri)) {
     return invoke$2('FileSystem.exists', uri);
   }
   if (isHttp(uri)) {
-    return exists$1(uri);
-  }
-  if (isMemory(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,6 +2823,87 @@ const glob = async (root, pattern) => {
   return globWithFileSystem(FileSystemDisk, root, pattern);
 };
 
+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 = '') => {
+  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) {
+      results.push(...(await searchDirectory(`${uri}/${entry.name}`, relativePath)));
+    } else {
+      results.push(relativePath);
+    }
+  }
+  return results;
+};
+const fileSearch = uri => searchDirectory(uri);
+
 const handleMessagePort = async (port, rpcId) => {
   const rpc = await create$6({
     commandMap: {},
@@ -2468,54 +3007,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 +3047,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 +3087,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 = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/file-system-worker",
-  "version": "5.20.3",
+  "version": "5.21.0",
   "description": "File System Worker",
   "keywords": [
     "Lvce Editor"