@statewalker/webrun-files 0.3.1 → 0.5.0

package/dist/index.js

@@ -1,1033 +0,0 @@
-// @statewalker/webrun-files v0.3.1 https://github.com/statewalker/webrun-files Copyright 2024 Mikhail Kotelnikov
-function normalizePath(filePath) {
-  const segments = filePath.split("/").filter((s) => !!s && s !== ".");
-  if (segments.length === 0) {
-    segments.push("");
-  }
-  segments.unshift("");
-  return segments.join("/");
-}
-
-function notImplemented(){
-  throw new Error('Not implemented.');
-}
-
-/*
- * FileInfo
- * - `kind` - (`file`|`directory`) kind of the returned entity
- * - `name` - the local name of this file entry (the last segment of the path)
- * - `path` - path to the file from the root of the "file system"
- * - `type` - an optional mime type of the file content; it is not defined for directories
- * - `size` - size of the file (only for files)
- * - `lastModified` - modification time as a long integer
- */
-
-/**
- * This is a common interface providing access to methods dealing with files.
- */
-class FilesApi {
-  constructor(options) {
-    this.options = options || {};
-  }
-
-  /**
-   * Returns an async generator providing information about files (FileInfo[]).
-   * Paths corresponding to directories has the "/" trailing symbol.
-   * @param {Object|String} file path to the folder or an object returned by the `list` or `info` methods
-   * @param {Object} options optional parameters
-   * @param {Boolean} options.recursive this flag defines if the returned generator
-   * should give access to all child directories and files or just direct children
-   * @return {AsyncGenerator<FileInfo>} generator returning information about
-   * individual file entries
-   */
-  async *list(file, options = {}) {
-    yield notImplemented();
-  }
-
-  /**
-   * Returns information about an individual file.
-   * @param {Object|String} file path to the file or an object returned by
-   * the `list` or `info` methods
-   * @return {FileInfo} information about the file corresponding to the specified
-   * path or null if there is no such a file
-   */
-  async stats(file) {
-    return notImplemented();
-  }
-
-  /**
-   * Removes file or folder corresponding to the specified path.
-   * All children of this entry will be removed as well.
-   * @param {Object|String} file path to the file to remove or an object
-   * returned by the `list` or `info` methods
-   * @return {Boolean} return true if the file was removed
-   */
-  async remove(file) {
-    return notImplemented();
-  }
-
-  /**
-   * Creates and returns a write stream for the file with the specified path.
-   * @param {Object|String} file path to the file or an object returned by
-   * the `list` or `info` methods
-   * @param {AsyncGenerator|AsyncIterator} content async generator function providing the binary
-   * file content to store
-   * @return {any} result of the action execution
-   */
-  async write(file, content) {
-    return notImplemented();
-  }
-
-  /**
-   * Creates an returns an AsyncIterator returning byte blocks with the file content.
-   * @param {Object|String} file path to the file or an object returned by
-   * the `list` or `info` methods
-   * @param {object} options read parameters
-   * @param {number} options.start starting read position; default value is 0
-   * @param {number} options.bufferSize the optional size of returned chunks buffers
-   */
-  async *read(file, options) {
-    yield notImplemented();
-  }
-
-  /**
-   * Copies a file from one path to another.
-   * @param {String} fromPath path to the source file
-   * @param {String} toPath path to the target file
-   * @param {Object} options additional options
-   * @param {Store} options.recursive if this flag is true then subfolders are also copied
-   * @param {Store} options.target optional target store where data should be copied
-   * @return {Boolean} if the file was successfully copied
-   */
-  async copy(source, target, options = {}) {
-    const doCopy = async (sourcePath, targetPath, sourceFile) => {
-      const suffix = sourceFile.path.substring(sourcePath.length);
-      targetPath = `${targetPath}${suffix}`;
-      const content = this.read(sourceFile);
-      return await this.write(targetPath, content);
-    };
-    const recursive = options.recursive === undefined || !!options.recursive;
-    const sourceFile = await this.stats(source);
-    if (sourceFile.kind === "directory") {
-      for await (const file of this.list(source, { ...options, recursive })) {
-        if (file.kind === "directory") continue;
-        await doCopy(source, target, file);
-      }
-    } else {
-      await doCopy(source, target, sourceFile);
-    }
-    return true;
-  }
-
-  /**
-   * Moves files from the initial position to the target path.
-   * The default implementation creates a new file copy in the new location
-   * and removes the old file.
-   *
-   * @param {String} fromPath path to the source file
-   * @param {String} toPath path to the target file
-   * @param {Object} options additional options
-   * @param {Store} options.target optional target store where data should be moved
-   * @return {Boolean} if the file was successfully moved
-   */
-  async move(fromPath, toPath, options = {}) {
-    if (!await this.copy(fromPath, toPath, options)) return false;
-    await this.remove(fromPath);
-    return true;
-  }
-
-  normalizePath(file) {
-    let filePath = typeof file === "object" ? file.path : file + "";
-    return normalizePath(filePath);
-  }
-}
-
-// https://docs.w3cub.com/http/basics_of_http/mime_types/complete_list_of_mime_types
-const mimeTypes = [
-  { "extensions": ["aac"], "mime": "audio/aac", "description": "AAC audio" },
-  { "extensions": ["abw"], "mime": "application/x-abiword", "description": "AbiWord document" },
-  { "extensions": ["arc"], "mime": "application/x-freearc", "description": "Archive document (multiple files embedded)" },
-  { "extensions": ["avi"], "mime": "video/x-msvideo", "description": "AVI: Audio Video Interleave" },
-  { "extensions": ["azw"], "mime": "application/vnd.amazon.ebook", "description": "Amazon Kindle eBook format" },
-  { "extensions": ["bin"], "mime": "application/octet-stream", "description": "Any kind of binary data" },
-  { "extensions": ["bmp"], "mime": "image/bmp", "description": "Windows OS/2 Bitmap Graphics" },
-  { "extensions": ["bz"], "mime": "application/x-bzip", "description": "BZip archive" },
-  { "extensions": ["bz2"], "mime": "application/x-bzip2", "description": "BZip2 archive" },
-  { "extensions": ["csh"], "mime": "application/x-csh", "description": "C-Shell script" },
-  { "extensions": ["css"], "mime": "text/css", "description": "Cascading Style Sheets (CSS)" },
-  { "extensions": ["csv"], "mime": "text/csv", "description": "Comma-separated values (CSV)" },
-  { "extensions": ["doc"], "mime": "application/msword", "description": "Microsoft Word" },
-  { "extensions": ["docx"], "mime": "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "description": "Microsoft Word (OpenXML)" },
-  { "extensions": ["eot"], "mime": "application/vnd.ms-fontobject", "description": "MS Embedded OpenType fonts" },
-  { "extensions": ["epub"], "mime": "application/epub+zip", "description": "Electronic publication (EPUB)" },
-  { "extensions": ["gz"], "mime": "application/gzip", "description": "GZip Compressed Archive" },
-  { "extensions": ["gif"], "mime": "image/gif", "description": "Graphics Interchange Format (GIF)" },
-  { "extensions": ["htm", "html"], "mime": "text/html", "description": "HyperText Markup Language (HTML)" },
-  { "extensions": ["ico"], "mime": "image/vnd.microsoft.icon", "description": "Icon format" },
-  { "extensions": ["ics"], "mime": "text/calendar", "description": "iCalendar format" },
-  { "extensions": ["jar"], "mime": "application/java-archive", "description": "Java Archive (JAR)" },
-  { "extensions": ["jpg", "jpeg"], "mime": "image/jpeg", "description": "JPEG images" },
-  { "extensions": ["js"], "mime": "text/javascript", "description": "JavaScript per the following specifications: https://html.spec.whatwg.org/multipage/#scriptingLanguages, https://html.spec.whatwg.org/multipage/#dependencies:willful-violation, https://datatracker.ietf.org/doc/draft-ietf-dispatch-javascript-mjs/" },
-  { "extensions": ["json"], "mime": "application/json", "description": "JSON format" },
-  { "extensions": ["jsonld"], "mime": "application/ld+json", "description": "JSON-LD format" },
-  { "extensions": ["mid", "midi"], "mime": "application/ld+json", "description": "Musical Instrument Digital Interface (MIDI)	audio/midi audio/x-midi" },
-  { "extensions": ["mjs"], "mime": "text/javascript", "description": "JavaScript module" },
-  { "extensions": ["mp3"], "mime": "audio/mpeg", "description": "MP3 audio" },
-  { "extensions": ["md"], "mime": "text/markdown", "description": "Markdown" },
-  { "extensions": ["mpeg"], "mime": "video/mpeg", "description": "MPEG Video" },
-  { "extensions": ["mpkg"], "mime": "application/vnd.apple.installer+xml", "description": "Apple Installer Package" },
-  { "extensions": ["odp"], "mime": "application/vnd.oasis.opendocument.presentation", "description": "OpenDocument presentation document" },
-  { "extensions": ["ods"], "mime": "application/vnd.oasis.opendocument.spreadsheet", "description": "OpenDocument spreadsheet document" },
-  { "extensions": ["odt"], "mime": "application/vnd.oasis.opendocument.text", "description": "OpenDocument text document" },
-  { "extensions": ["oga"], "mime": "audio/ogg", "description": "OGG audio" },
-  { "extensions": ["ogv"], "mime": "video/ogg", "description": "OGG video" },
-  { "extensions": ["ogx"], "mime": "application/ogg", "description": "OGG" },
-  { "extensions": ["opus"], "mime": "audio/opus", "description": "Opus audio" },
-  { "extensions": ["otf"], "mime": "font/otf", "description": "OpenType font" },
-  { "extensions": ["png"], "mime": "image/png", "description": "Portable Network Graphics" },
-  { "extensions": ["pdf"], "mime": "application/pdf", "description": "Adobe Portable Document Format (PDF)" },
-  { "extensions": ["php"], "mime": "application/x-httpd-php", "description": "Hypertext Preprocessor (Personal Home Page)" },
-  { "extensions": ["ppt"], "mime": "application/vnd.ms-powerpoint", "description": "Microsoft PowerPoint" },
-  { "extensions": ["pptx"], "mime": "application/vnd.openxmlformats-officedocument.presentationml.presentation", "description": "Microsoft PowerPoint (OpenXML)" },
-  { "extensions": ["rar"], "mime": "application/vnd.rar", "description": "RAR archive" },
-  { "extensions": ["rtf"], "mime": "application/rtf", "description": "Rich Text Format (RTF)" },
-  { "extensions": ["sh"], "mime": "application/x-sh", "description": "Bourne shell script" },
-  { "extensions": ["svg"], "mime": "image/svg+xml", "description": "Scalable Vector Graphics (SVG)" },
-  { "extensions": ["swf"], "mime": "application/x-shockwave-flash", "description": "Small web format (SWF) or Adobe Flash document" },
-  { "extensions": ["tar"], "mime": "application/x-tar", "description": "Tape Archive (TAR)" },
-  { "extensions": ["tif", "tiff"], "mime": "image/tiff", "description": "Tagged Image File Format (TIFF)" },
-  // { "extensions": ["ts"], "mime": "video/mp2t", "description": "MPEG transport stream" },
-  { "extensions": ["ttf"], "mime": "font/ttf", "description": "TrueType Font" },
-  { "extensions": ["txt"], "mime": "text/plain", "description": "Text, (generally ASCII or ISO 8859-n)" },
-  { "extensions": ["vsd"], "mime": "application/vnd.visio", "description": "Microsoft Visio" },
-  { "extensions": ["wav"], "mime": "audio/wav", "description": "Waveform Audio Format" },
-  { "extensions": ["weba"], "mime": "audio/webm", "description": "WEBM audio" },
-  { "extensions": ["webm"], "mime": "video/webm", "description": "WEBM video" },
-  { "extensions": ["webp"], "mime": "image/webp", "description": "WEBP image" },
-  { "extensions": ["woff"], "mime": "font/woff", "description": "Web Open Font Format (WOFF)" },
-  { "extensions": ["woff2"], "mime": "font/woff2", "description": "Web Open Font Format (WOFF)" },
-  { "extensions": ["xhtml"], "mime": "application/xhtml+xml", "description": "XHTML" },
-  { "extensions": ["xls"], "mime": "application/vnd.ms-excel", "description": "Microsoft Excel" },
-  { "extensions": ["xlsx"], "mime": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "description": "Microsoft Excel (OpenXML)" },
-  { "extensions": ["xml"], "mime": "application/xml", "description": "XML; application/xml - if not readable from casual users (RFC 3023, section 3); text/xml - if readable from casual users (RFC 3023, section 3)" },
-  { "extensions": ["xul"], "mime": "application/vnd.mozilla.xul+xml", "description": "XUL" },
-  { "extensions": ["zip"], "mime": "application/zip", "description": "ZIP archive" },
-  { "extensions": ["3gp"], "mime": "video/3gpp", "description": "3GPP audio/video container" },
-  { "extensions": ["3g2"], "mime": "video/3gpp2", "description": "3GPP2 audio/video container; audio/3gpp if it doesn't contain video; audio/3gpp2 if it doesn't contain video" },
-  { "extensions": ["7z"], "mime": "application/x-7z-compressed", "description": "7-zip archive" },
-
-  { "extensions": ["jsx"], "mime": "text/jsx", "description": "JavaScript Syntax Extension / JavaScript XML format" },
-  { "extensions": ["ts"], "mime": "text/ts", "description": "TypeScript format" },
-  { "extensions": ["tsx"], "mime": "text/tsx", "description": "TypeScript Syntax Extension / TypeScript XML format" },
-
-];
-
-const mimeTypesDescriptions = mimeTypes.reduce((index, t) => {
-  index[t.mime] = t.description;
-  return index;
-}, {});
-
-const extensionToMimeType = mimeTypes.reduce((index, t) => {
-  for (const ext of t.extensions) {
-    index[ext] = t.mime;
-  }
-  return index;
-}, {});
-
-const mimeTypeToExtensions = mimeTypes.reduce((index, t) => {
-  index[t.mime] = t.extensions;
-  return index;
-}, {});
-
-// import mimeDb from 'mime-db';
-// import mimeTypes from 'mime-types';
-
-function getMimeType(url) {
-  url = url || '';
-  const originalUrl = url;
-  url = url.split('?').shift(); // Remove queries (if any)
-  url = url.split('/').pop(); // Keep only the last segment of the path  
-  const extension = url.split('.').pop(); // Get extension
-  let mimeType = extensionToMimeType[extension];
-  if (!mimeType) {
-    mimeType =
-      originalUrl.match(/api\.observablehq\.com/) || originalUrl.match(/\.ojs$/)
-        ? 'application/javascript-observable'
-        : 'application/binary';
-  }
-  return mimeType;
-}
-
-class MemFilesApi extends FilesApi {
-  constructor(options) {
-    super(options);
-    this.index = {
-      "/" : {
-        "kind": "directory",
-        "path": "/",
-        "name": ""
-      }
-    };
-  }
-
-  async *list(file, { recursive = false } = {}) {
-    await this._init();
-    const filePath = this.normalizePath(file);
-    const paths = this._getPaths();
-    for (const path of paths) {
-      if (path.indexOf(filePath) !== 0 || path === filePath) continue;
-      const suffix = path.substring(filePath.length + 1);
-      const segments = suffix.split("/");
-      if (recursive || segments.length === 1) {
-        yield this._getFileInfo(path);
-      }
-    }
-  }
-
-  async stats(file) {
-    await this._init();
-    const filePath = this.normalizePath(file);
-    return this._getFileInfo(filePath);
-  }
-
-  async remove(file) {
-    await this._init();
-    const fileInfo = await this.stats(file);
-    if (!fileInfo) return false;
-    for await (const { path } of this.list(fileInfo, { recursive: true })) {
-      if (path !== "/") delete this.index[path];
-    }
-    delete this.index[fileInfo.path];
-  }
-
-  async write(file, content) {
-    await this._init();
-    await this._doWrite(file, content);
-  }
-
-  async *read(file /* { start = 0, bufferSize = 1024 * 8 } = {} */) {
-    await this._init();
-    const filePath = this.normalizePath(file);
-    const fileInfo = this.index[filePath];
-    if (!fileInfo || fileInfo.kind !== "file") return ; // throw new Error("Not a file");
-    const content = fileInfo.content;
-    yield* content;
-  }
-
-  // TODO:
-  // async copy(fromPath, toPath, options = {}) { ... }
-
-  // TODO:
-  // async move(fromPath, toPath, options = {}) { ... }
-
-  async _init() {
-    return this._initPromise = this._initPromise ||
-      Promise.resolve().then(() => this._addEntries(this.options.files));
-  }
-
-  async _doWrite(file, content) {
-    const filePath = this.normalizePath(file);
-    const segments = filePath.split("/").filter((s) => !!s);
-    const pathSegments = [""];
-    let info;
-    for (let i = 0; i < segments.length; i++) {
-      const name = segments[i];
-      pathSegments.push(name);
-      const path = pathSegments.join("/");
-      info = this.index[path] = this.index[path] || {
-        path,
-        name,
-        kind: "directory",
-      };
-    }
-    info.kind = "file";
-    info.content = [];
-    info.type = getMimeType(info.path);
-    info.size = 0;
-    info.lastModified = Date.now();
-    if (typeof content === "function") content = content();
-    for await (let chunk of content) {
-      chunk = new Uint8Array(chunk);
-      info.content.push(chunk);
-      info.size += chunk.length;
-    }
-  }
-
-  async _addEntries(index = {}) {
-    for (let [path, content] of Object.entries(index)) {
-      if (typeof content === "string") {
-        content = [new TextEncoder().encode(content)];
-      } else if (content instanceof Uint8Array) {
-        content = [content];
-      }
-      await this._doWrite(path, content);
-    }
-  }
-
-  _getPaths() {
-    return this._getIndexPaths(this.index);
-  }
-
-  _getIndexPaths(index) {
-    return Object.keys(index).sort(compare);
-    function compare(a, b) {
-      return a > b ? 1 : a < b ? -1 : 0;
-    }
-  }
-
-  _getFileInfo(path) {
-    const fileInfo = this.index[path];
-    if (!fileInfo) return null;
-    const info = { ...fileInfo };
-    delete info.content;
-    return info;
-  }
-
-}
-
-class NodeFilesApi extends FilesApi {
-  constructor(options) {
-    super(options);
-    if (!this.fs) throw new Error("File System is not defined.");
-    if (!this.rootDir) throw new Error("Root directory is not defined.");
-  }
-
-  get rootDirSegments() {
-    if (!this._rootDirSegments) {
-      this._rootDirSegments = this._toPathSegments(
-        this.options.rootDir || "./",
-      );
-    }
-    return this._rootDirSegments;
-  }
-
-  get rootDir() {
-    if (!this._rootDir) {
-      this._rootDir = this.rootDirSegments.join("/");
-    }
-    return this._rootDir;
-  }
-
-  get fs() {
-    return this.options.fs;
-  }
-
-  async _init() {
-    return this._initialized = this._initialized ||
-      (async () => {
-        const dirPath = this.rootDir;
-        return await mkdir(this.fs, dirPath);
-      })();
-  }
-
-  async *list(file, { recursive = false } = {}) {
-    await this._init();
-    const filePath = this._expandPath(file);
-    const fileInfo = await this._stats(filePath);
-    if (!fileInfo || fileInfo.kind !== "directory") return;
-    for await (let f of list(this.fs, filePath, recursive)) {
-      yield this._getFileInfo(f.path, f.stat);
-    }
-  }
-
-  async stats(file) {
-    await this._init();
-    const filePath = this._expandPath(file);
-    return this._stats(filePath);
-  }
-
-  async remove(file) {
-    await this._init();
-    const filePath = this._expandPath(file);
-    return await remove(this.fs, filePath);
-  }
-
-  async write(file, content) {
-    await this._init();
-    const filePath = this._expandPath(file);
-    const dir = pathDirname(filePath);
-    await this.fs.mkdir(dir, { recursive: true });
-    let handle;
-    try {
-      handle = await this.fs.open(filePath, "w");
-      if (typeof content === "function") content = content();
-      await handle.writeFile(content);
-    } finally {
-      handle && await handle.close();
-    }
-  }
-
-  async *read(file, { start = 0, bufferSize = 1024 * 8 } = {}) {
-    await this._init();
-    const filePath = this._expandPath(file);
-    let handle;
-    try {
-      handle = await this.fs.open(filePath, "r");
-      const offset = 0;
-      for (let position = start, bytesRead = 0; true; position += bytesRead) {
-        const buffer = new Uint8ClampedArray(bufferSize);
-        const result = await handle.read(
-          buffer,
-          offset,
-          bufferSize,
-          position,
-        );
-        bytesRead = result.bytesRead;
-        if (bytesRead === 0) break;
-        yield bytesRead < bufferSize
-          ? result.buffer.slice(0, bytesRead)
-          : result.buffer;
-      }
-    } finally {
-      handle && await handle.close();
-    }
-  }
-
-  // TODO:
-  // async copy(fromPath, toPath, options = {}) { ... }
-
-  // TODO:
-  // async move(fromPath, toPath, options = {}) { ... }
-
-  async _stats(filePath) {
-    try {
-      const stat = await this.fs.stat(filePath);
-      return this._getFileInfo(filePath, stat);
-    } catch (err) {
-      if (err.code !== "ENOENT") throw err;
-      return null;
-    }
-  }
-
-  _getFileInfo(path, stat) {
-    const segments = this._toPathSegments(path).slice(
-      this.rootDirSegments.length,
-    );
-    segments.unshift("");
-    const name = segments[segments.length - 1];
-    path = segments.join("/");
-    // const name = path.split("/").filter((s) => !!s).pop() || "";
-    let info = {
-      path,
-      name,
-      kind: "",
-    };
-    if (!stat.isFile()) {
-      info.kind = "directory";
-    } else {
-      info.size = stat.size || 0;
-      info.type = getMimeType(path);
-      info.kind = "file";
-      info.lastModified = new Date(stat.mtime).getTime();
-    }
-    return info;
-  }
-
-  _toPathSegments(filePath) {
-    filePath = this.normalizePath(filePath);
-    const segments = filePath.split("/"); // .filter((s) => !!s);
-    // if (segments.length === 0) segments.push("");
-    // segments.unshift("");
-    return segments;
-  }
-
-  _expandPath(file) {
-    const filePath = typeof file === "object" ? file.path : file + "";
-    const segments = this._toPathSegments(filePath).filter((s) => !!s);
-    // segments.shift(); // The first segment is always empty
-    segments.unshift(...this.rootDirSegments);
-    return segments.join("/");
-  }
-}
-
-function pathDirname(path) {
-  const segments = path.split("/");
-  segments.pop();
-  return segments.join("/");
-}
-
-function pathJoin(...paths) {
-  let segments = paths
-    .map((path) => path.split("/"))
-    .reduce((result, segments) => (result.push(...segments), result), []);
-  const firstSegment = segments.shift();
-  segments = segments.filter((s) => !!s && s !== ".");
-  segments.unshift(firstSegment);
-  return segments.join("/");
-}
-
-async function mkdir(fs, dir) {
-  try {
-    const stat = await fs.stat(dir);
-    if (stat && stat.isDirectory()) return true;
-  } catch (error) {
-    // Just ignore
-  }
-  const parent = pathDirname(dir);
-  if (dir === parent) return false;
-  await mkdir(fs, parent);
-  await fs.mkdir(dir, { recursive: true });
-  return true;
-}
-
-async function remove(fs, path) {
-  try {
-    let stat = await fs.stat(path);
-    if (stat.isDirectory()) {
-      for await (let file of list(fs, path, false)) {
-        await remove(fs, file.path);
-      }
-      await fs.rmdir(path);
-    } else {
-      await fs.unlink(path);
-    }
-  } catch (err) {
-    if (err.code !== "ENOENT") throw err;
-  }
-}
-
-async function* list(fs, filePath, recursive) {
-  try {
-    const stat = await fs.stat(filePath);
-    if (stat.isDirectory()) {
-      const array = await fs.readdir(filePath);
-      for (const name of array.sort()) {
-        const f = pathJoin(filePath, name);
-        let stat = await fs.stat(f);
-        yield { path: f, stat };
-        if (recursive && stat.isDirectory()) {
-          yield* list(fs, f, true);
-        }
-      }
-    }
-  } catch (err) {
-    if (err.code !== "ENOENT") throw err;
-  }
-}
-
-/**
- * Stateless adapter for the "File and Directory Entries API".
- * See https://developer.mozilla.org/en-US/docs/Web/API/File_and_Directory_Entries_API
- *
- * ## File and Directory Entries API
- * The File and Directory Entries API simulates a local file system
- * this web apps can navigate within and access files in. You can
- * develop apps which read, write, and create files and/or directories
- * in a virtual, sandboxed file system.
- */
-class AdapterForFilesAndDirectoryEntriesApi {
-  static canApply(handle) {
-    return ((handle?.isDirectory || handle?.isFile) &&
-      (typeof handle?.name === "string"));
-  }
-
-  async *listDirectoryChildren(handle) {
-    let dirReader = handle.createReader();
-    while (true) {
-      const list = await new Promise((resolve, reject) =>
-        dirReader.readEntries(resolve, reject)
-      );
-      if (!list.length) break;
-      yield* list;
-    }
-  }
-
-  isDirectoryHandle(handle) {
-    return handle?.isDirectory;
-  }
-  isFileHandle(handle) {
-    return handle?.isFile;
-  }
-
-  async getSubdirectoryHandle(dirHandle, directoryName, create) {
-    return new Promise((resolve, reject) =>
-      dirHandle.getDirectory(
-        directoryName,
-        { create },
-        resolve,
-        reject,
-      )
-    );
-  }
-
-  async getFileHandle(dirHandle, fileName, create = true) {
-    return new Promise((resolve, reject) =>
-      dirHandle.getFile(
-        fileName,
-        { create },
-        resolve,
-        reject,
-      )
-    );
-  }
-
-  async removeDirectoryEntry(dirHandle, handle) {
-    return new Promise((resolve, reject) => handle.remove(resolve, reject));
-  }
-
-  async getFile(handle) {
-    const file = await new Promise((resolve, reject) =>
-      handle.file(resolve, reject)
-    );
-    return file;
-  }
-
-  async getFileWriteStream(handle) {
-    throw new Error("Not implemented");
-  }
-}
-
-/**
- * Stateless adapter for the "File System API" and "File System Access API".
- * See:
- * - https://developer.mozilla.org/en-US/docs/Web/API/File_System_API
- * - https://wicg.github.io/file-system-access/
- */
-class AdapterForFileSystemApi {
-  static canApply(handle) {
-    return (handle?.kind === "file" || handle?.kind === "directory");
-  }
-
-  async *listDirectoryChildren(handle) {
-    yield* handle.values();
-  }
-
-  isDirectoryHandle(handle) {
-    return handle?.kind === "directory";
-  }
-  isFileHandle(handle) {
-    return handle?.kind === "file";
-  }
-
-  async getSubdirectoryHandle(dirHandle, directoryName, create) {
-    return await dirHandle.getDirectoryHandle(directoryName, { create });
-  }
-
-  async getFileHandle(dirHandle, fileName, create = true) {
-    return await dirHandle.getFileHandle(fileName, { create });
-  }
-
-  async removeDirectoryEntry(dirHandle, handle) {
-    return await dirHandle.removeEntry(handle.name, { recursive: true });
-  }
-
-  async getFile(handle) {
-    return await handle.getFile();
-  }
-
-  async getFileWriteStream(handle) {
-    return await handle.createWritable(); // Write the contents of the file to the stream.
-  }
-}
-
-class BrowserFilesApi extends FilesApi {
-  constructor(options) {
-    super(options);
-    if (!this.rootHandle) {
-      throw new Error("Root directory handle is not defined");
-    }
-    if (!this.adapter) {
-      throw new Error(
-        "Can not define a browser adapter for the specified root handle",
-      );
-    }
-  }
-
-  get rootHandle() {
-    return this.options.rootHandle || this.options.rootHandler;
-  }
-
-  get adapter() {
-    if (!this._adapter) {
-      const handle = this.rootHandle;
-      let adapter = AdapterForFilesAndDirectoryEntriesApi.canApply(handle)
-        ? new AdapterForFilesAndDirectoryEntriesApi()
-        : AdapterForFileSystemApi.canApply(handle)
-        ? new AdapterForFileSystemApi()
-        : null;
-      this._adapter = adapter;
-    }
-    return this._adapter;
-  }
-
-  async *list(file, { recursive = false } = {}) {
-    const segments = this._getPathSegments(file);
-    const handle = await this._getHandle(segments);
-    if (!handle) return;
-    const that = this;
-    if (this.adapter.isDirectoryHandle(handle)) {
-      // yield await this._getFileInfo(segments, handle);
-      yield* listChildren(segments, handle, recursive);
-    }
-
-    async function* listChildren(segments, dirHandle, recursive) {
-      for await (const handle of that._listDirectoryContent(dirHandle)) {
-        yield await that._getFileInfo([...segments, handle.name], handle);
-        if (recursive && that.adapter.isDirectoryHandle(handle)) {
-          yield* listChildren(
-            [...segments, handle.name],
-            handle,
-            recursive,
-          );
-        }
-      }
-    }
-  }
-
-  async stats(file) {
-    const segments = this._getPathSegments(file);
-    const handle = await this._getHandle(segments);
-    return handle ? await this._getFileInfo(segments, handle) : null;
-  }
-
-  async remove(file) {
-    const doRemove = async (dirHandle, handle) => {
-      let result = true;
-      if (this.adapter.isDirectoryHandle(handle)) {
-        const children = [];
-        for await (let child of this.adapter.listDirectoryChildren(handle)) {
-          children.push(child);
-        }
-        for (let child of children) {
-          result = result && await doRemove(handle, child);
-        }
-      }
-      if (dirHandle) {
-        result &= await this.adapter.removeDirectoryEntry(dirHandle, handle);
-      }
-      return result;
-    };
-
-    const segments = this._getPathSegments(file);
-    const handle = await this._getHandle(segments);
-    segments.pop();
-    const dirHandle = await this._getHandle(segments);
-    return doRemove(dirHandle !== handle ? dirHandle : null, handle);
-  }
-
-  async write(file, content) {
-    const segments = this._getPathSegments(file);
-    const fileName = segments.pop();
-    const dirHandle = await this._getDirectoryHandle(segments, true);
-    const fileHandle = await this.adapter.getFileHandle(
-      dirHandle,
-      fileName,
-      true,
-    );
-    const writable = await this.adapter.getFileWriteStream(fileHandle);
-    try {
-      if (typeof content === "function") content = content();
-      for await (let block of content) {
-        await writable.write(block.buffer ? block.buffer : block); // Close the file and write the contents to disk.
-      }
-    } finally {
-      await writable.close();
-    }
-  }
-
-  async *read(file /* { start = 0, bufferSize = 1024 * 8 } = {} */) {
-    const segments = this._getPathSegments(file);
-
-    const fileName = segments.pop();
-    const dirHandle = await this._getDirectoryHandle(segments, false);
-    const fileHandle = await this.adapter.getFileHandle(
-      dirHandle,
-      fileName,
-      false,
-    );
-    if (!fileHandle) return;
-    const fileData = await this.adapter.getFile(fileHandle);
-    const stream = fileData.stream();
-    const reader = stream.getReader();
-    try {
-      let chunk;
-      while (chunk = await reader.read()) {
-        if (chunk.done) break;
-        yield await chunk.value;
-      }
-    } finally {
-      await reader.cancel && reader.cancel();
-      // stream.cancel && stream.cancel();
-    }
-  }
-
-  // TODO:
-  // async copy(fromPath, toPath, options = {}) { ... }
-
-  // TODO:
-  // async move(fromPath, toPath, options = {}) { ... }
-
-  // ---------------------------------------------------------
-  // Private methods
-
-  async _getFileInfo(segments, handle) {
-    segments = [...segments];
-    const name = segments[segments.length - 1];
-    segments.unshift("");
-    const path = segments.join("/");
-    const info = {
-      kind: "",
-      path,
-      name,
-    };
-    if (this.adapter.isDirectoryHandle(handle)) {
-      info.kind = "directory";
-    } else {
-      info.kind = "file";
-
-      const file = await this.adapter.getFile(handle);
-      info.size = file.size;
-      info.type = getMimeType(path);
-      info.lastModified = file.lastModified;
-    }
-    return info;
-  }
-
-  _getPathSegments(file) {
-    let filePath = typeof file === "object" ? file.path : file + "";
-    // filePath = this.normalizePath(filePath);
-    const segments = filePath.split("/").filter((s) => !!s);
-    return segments;
-  }
-
-  async _getHandle(segments) {
-    const parentDirSegments = [...segments];
-    const name = parentDirSegments.pop();
-    const create = false;
-    try {
-      const dirHandle = await this._getDirectoryHandle(
-        parentDirSegments,
-        create,
-      );
-      try {
-        if (!name) return dirHandle;
-        return await this.adapter.getSubdirectoryHandle(
-          dirHandle,
-          name,
-          create,
-        );
-      } catch (error) {
-        return await this.adapter.getFileHandle(dirHandle, name, create);
-      }
-    } catch (error) {
-      return undefined;
-    }
-  }
-
-  async _getDirectoryHandle(segments, create = true) {
-    segments = [...segments];
-    let dirHandle = this.rootHandle;
-    for (let directoryName of segments) {
-      dirHandle = await this.adapter.getSubdirectoryHandle(
-        dirHandle,
-        directoryName,
-        create,
-      );
-      if (!dirHandle) break;
-    }
-    return dirHandle;
-  }
-
-  async *_listDirectoryContent(handle) {
-    let entries = [];
-    for await (const entry of this.adapter.listDirectoryChildren(handle)) {
-      entries.push(entry);
-    }
-    entries = entries.sort((a, b) => b.name > a.name ? 1 : -1);
-    yield* entries;
-  }
-}
-
-function addFilesApiLogger({
-  filesApi,
-  log = console.log,
-  wrapper = {},
-}) {
-  return ["list", "stats", "remove", "write", "read", "copy", "move"].reduce(
-    (wrapper, methodName) => {
-      const method = filesApi[methodName].bind(filesApi);
-      wrapper[methodName] = (...args) => {
-        let message = { method: methodName, stage : "enter", args };
-        try {
-          log(message);
-          return message.result = method.call(filesApi, ...args);
-        } catch (e) {
-          message.error = e;
-        } finally {
-          message.stage = "exit";
-          log(message);
-        }
-      };
-      return wrapper;
-    },
-    wrapper,
-  );
-}
-
-async function openBrowserFilesApi({
-  handlerKey = "root-dir",
-  readwrite = true,
-  // Methods below could be replaced by persistent implementation
-  // using the "idb-keyval" package (methods "get", "set", "del").
-  index = {},
-  get = async (key) => index[key],
-  set = async (key, handler) => index[key] = handler,
-  del = async (key) => delete index[key],
-} = {}) {
-  let rootHandler = await get(handlerKey);
-  if (!rootHandler) {
-    rootHandler = await window.showDirectoryPicker();
-    await set(handlerKey, rootHandler);
-  }
-  if (!(await verifyPermission(rootHandler, readwrite))) {
-    throw new Error("Access was not granted");
-  }
-  if (!(await isHandlerAccessible(rootHandler))) {
-    // await set(handlerKey, null);
-    await del(handlerKey);
-    throw new Error("Can not access to the folder. Please try again.");
-  }
-  return new BrowserFilesApi({ rootHandler });
-}
-
-async function isHandlerAccessible(fileHandle) {
-  // We need to perform a real read operation with the handler
-  // to check if the file/directory still exists.
-  let exists = false;
-  try {
-    if (fileHandle.kind === "file") {
-      await fileHandle.getFile();
-    } else {
-      for await (let item of fileHandle.values()) {
-        break;
-      }
-    }
-    exists = true;
-  } catch (error) {
-    console.log(error, fileHandle);
-    exists = false;
-  }
-  return exists;
-}
-
-async function verifyPermission(fileHandle, readWrite) {
-  const options = {};
-  if (readWrite) {
-    options.mode = "readwrite";
-  }
-  let granted = false;
-  // Check if permission was already granted. If so, return true.
-  if ((await fileHandle.queryPermission(options)) === "granted") {
-    granted = true;
-  }
-  // Request permission. If the user grants permission, return true.
-  if (
-    !granted && (await fileHandle.requestPermission(options)) === "granted"
-  ) {
-    granted = true;
-  }
-  // The user didn't grant permission, so return false.
-  return granted;
-}
-
-export { BrowserFilesApi, FilesApi, MemFilesApi, NodeFilesApi, addFilesApiLogger, extensionToMimeType, getMimeType, isHandlerAccessible, mimeTypeToExtensions, mimeTypes, mimeTypesDescriptions, normalizePath, openBrowserFilesApi, verifyPermission };