@cordisjs/fs 1.3.7 → 2.0.0-rc.0

package/README.md

@@ -1,5 +1 @@
 # @cordisjs/fs
-
-[![npm](https://img.shields.io/npm/v/@cordisjs/fs?style=flat-square)](https://www.npmjs.com/package/@cordisjs/fs)
-
-Node.js fs module ponyfill for browser.

package/lib/error.d.ts

@@ -0,0 +1,13 @@
+export declare class FsError extends Error {
+    code: FsError.Code;
+    url: URL;
+    name: string;
+    constructor(code: FsError.Code, url: URL, message: string);
+}
+export declare namespace FsError {
+    type Code = 
+    /** No provider is mounted for the location. */
+    'NoProvider'
+    /** The provider of the location does not implement the operation. */
+     | 'NotSupported';
+}

package/lib/index.d.ts

@@ -1,24 +1,64 @@
-import * as constants from './constants';
-import * as promises from './promises';
-import EventEmitter from 'events';
-import { Matcher } from 'anymatch';
-export { constants, promises };
-export declare class Dirent {
-    private handle;
-    name: string;
-    constructor(handle: FileSystemHandle);
-    isFile(): boolean;
-    isDirectory(): boolean;
+import { Context, Service } from 'cordis';
+import { Awaitable } from 'cosmokit';
+import { Watcher, WatchOptions } from './watcher.ts';
+export * from './error.ts';
+export * from './watcher.ts';
+declare module 'cordis' {
+    interface Context {
+        fs: Fs;
+    }
 }
-export interface WatchOptions {
-    ignored?: Matcher;
-    ignoreInitial?: boolean;
-    cwd?: string;
-    depth?: number;
-    interval?: number;
+/**
+ * The file system service, which forwards each operation to the provider
+ * mounted at its location.
+ */
+export declare class Fs extends Service {
+    private _mounts;
+    /** the connection that serves each watch, if any */
+    private _watchers;
+    constructor(ctx: Context);
+    /**
+     * Mount a provider at a scheme, such as `s3:`, or at a URL, such as
+     * `file:///`. A location goes to the provider of the longest prefix that
+     * contains it. The mount ends with the calling fiber.
+     *
+     * Every watch follows the routing: a change of the mounts moves it to the
+     * provider its location goes to, and a watch without a provider is resumed
+     * once one is mounted. Changes while a watch has no provider are not reported.
+     */
+    mount(prefix: string | URL, provider: FsProvider): import("cordis").Disposable<Promise<void>>;
+    /** Resolve a URL reference against `ctx.baseUrl`. */
+    resolve(path: string | URL): URL;
+    private _match;
+    private _route;
+    private _connect;
+    private _disconnect;
+    private _reroute;
+    /** Watch a file or a directory. The watch ends with the calling fiber. */
+    watch(path: string | URL, options?: WatchOptions): Watcher;
 }
-export declare class FSWatcher extends EventEmitter {
-    constructor(paths: string | readonly string[], options?: WatchOptions);
-    close(): void;
+export interface FsProvider {
+    /**
+     * Start serving `watcher`, and return a function that disposes it. The
+     * provider reports through `watcher.emit()`, with a `ready` once the initial
+     * scan is done, and reports nothing once the returned function is called.
+     */
+    watch?(watcher: Watcher): () => Awaitable<void>;
 }
-export declare function watch(paths: string | readonly string[], options?: WatchOptions): FSWatcher;
+export interface BaseFs extends FsProvider {
+}
+/** A provider that mounts itself, at `config.mount` or at its static `mount`. */
+export declare abstract class BaseFs {
+    ctx: Context;
+    static inject: string[];
+    /** The default mount point of the subclass. */
+    static mount?: string;
+    constructor(ctx: Context, config?: BaseFs.Config);
+}
+export declare namespace BaseFs {
+    interface Config {
+        /** a scheme such as `s3:`, or a URL such as `file:///` */
+        mount?: string;
+    }
+}
+export default Fs;

package/lib/index.js

@@ -1,81 +1,231 @@
-"use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+
+// src/index.ts
+import { Service } from "cordis";
+
+// src/error.ts
+var FsError = class extends Error {
+  constructor(code, url, message) {
+    super(message);
+    this.code = code;
+    this.url = url;
   }
-  return to;
+  code;
+  url;
+  static {
+    __name(this, "FsError");
+  }
+  name = "FsError";
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  Dirent: () => Dirent,
-  FSWatcher: () => FSWatcher,
-  constants: () => constants,
-  promises: () => promises,
-  watch: () => watch
-});
-module.exports = __toCommonJS(index_exports);
-var constants = __toESM(require("./constants"));
-var promises = __toESM(require("./promises"));
-var import_events = __toESM(require("events"));
-var Dirent = class {
-  constructor(handle) {
-    this.handle = handle;
-    this.name = handle.name;
+// src/watcher.ts
+var Watcher = class {
+  /** `connect` starts serving the watch, and returns a function that disposes it. */
+  constructor(ctx, url, options, connect) {
+    this.ctx = ctx;
+    this.url = url;
+    this.options = options;
+    this.dispose = ctx.effect(() => {
+      const disconnect = connect(this);
+      return () => {
+        this._closed = true;
+        return disconnect();
+      };
+    }, "ctx.fs.watch()");
   }
+  ctx;
+  url;
+  options;
   static {
-    __name(this, "Dirent");
+    __name(this, "Watcher");
   }
-  name;
-  isFile() {
-    return this.handle.kind === "file";
+  _hooks = { change: /* @__PURE__ */ new Set(), ready: /* @__PURE__ */ new Set(), error: /* @__PURE__ */ new Set() };
+  _ready = false;
+  _closed = false;
+  /** Ends the watch. */
+  dispose;
+  /** Adds a listener, and returns a function that removes it. */
+  on(name, listener) {
+    const hooks = this._hooks[name];
+    const hook = { listener };
+    hooks.add(hook);
+    if (name === "ready" && this._ready) {
+      queueMicrotask(() => {
+        if (!hook.removed) this._call(listener, []);
+      });
+    }
+    return () => {
+      hook.removed = true;
+      hooks.delete(hook);
+    };
   }
-  isDirectory() {
-    return this.handle.kind === "directory";
+  /**
+   * Reports an event, as the provider that serves the watch does. Only the
+   * first `ready` is dispatched, so a provider that takes over the watch does
+   * not report it again.
+   */
+  emit(name, ...args) {
+    if (this._closed) return;
+    if (name === "error") return this._error(args[0]);
+    if (name === "ready") {
+      if (this._ready) return;
+      this._ready = true;
+    }
+    this._dispatch(name, args);
+  }
+  // An event reaches the hooks taken when it is dispatched.
+  _dispatch(name, args) {
+    for (const hook of [...this._hooks[name]]) {
+      if (!hook.removed) this._call(hook.listener, args);
+    }
+  }
+  _call(listener, args) {
+    (async () => listener(...args))().catch((error) => this._error(error));
+  }
+  _error(error) {
+    if (this._closed) return;
+    const hooks = this._hooks.error;
+    if (!hooks.size) return this.ctx.logger.warn(error);
+    for (const hook of [...hooks]) {
+      if (hook.removed) continue;
+      (async () => hook.listener(error))().catch((error2) => this.ctx.logger.warn(error2));
+    }
   }
 };
-var FSWatcher = class extends import_events.default {
+
+// src/index.ts
+function normalizePrefix(prefix) {
+  if (typeof prefix === "string" && /^[a-zA-Z][a-zA-Z\d+.-]*:$/.test(prefix)) {
+    return prefix.toLowerCase();
+  }
+  const { href } = new URL(prefix);
+  return href.endsWith("/") ? href : href + "/";
+}
+__name(normalizePrefix, "normalizePrefix");
+var Fs = class extends Service {
   static {
-    __name(this, "FSWatcher");
+    __name(this, "Fs");
   }
-  constructor(paths, options) {
-    super();
+  _mounts = /* @__PURE__ */ new Map();
+  /** the connection that serves each watch, if any */
+  _watchers = /* @__PURE__ */ new Map();
+  constructor(ctx) {
+    super(ctx, "fs");
   }
-  close() {
+  /**
+   * Mount a provider at a scheme, such as `s3:`, or at a URL, such as
+   * `file:///`. A location goes to the provider of the longest prefix that
+   * contains it. The mount ends with the calling fiber.
+   *
+   * Every watch follows the routing: a change of the mounts moves it to the
+   * provider its location goes to, and a watch without a provider is resumed
+   * once one is mounted. Changes while a watch has no provider are not reported.
+   */
+  mount(prefix, provider) {
+    const key = normalizePrefix(prefix);
+    return this.ctx.effect(() => {
+      if (this._mounts.has(key)) {
+        throw new Error(`a provider is already mounted at ${key}`);
+      }
+      this._mounts.set(key, { prefix: key, provider });
+      this._reroute();
+      return () => {
+        this._mounts.delete(key);
+        return this._reroute();
+      };
+    }, "ctx.fs.mount()");
+  }
+  /** Resolve a URL reference against `ctx.baseUrl`. */
+  resolve(path) {
+    if (path instanceof URL) return path;
+    const base = this.ctx.baseUrl;
+    if (!base && !URL.canParse(path)) {
+      throw new TypeError(`cannot resolve the relative reference ${JSON.stringify(path)} without ctx.baseUrl`);
+    }
+    return new URL(path, base);
+  }
+  _match(url) {
+    let result;
+    for (const mount of this._mounts.values()) {
+      const matches = mount.prefix.endsWith(":") ? url.protocol === mount.prefix : url.href.startsWith(mount.prefix) || url.href + "/" === mount.prefix;
+      if (matches && (!result || mount.prefix.length > result.prefix.length)) result = mount;
+    }
+    return result;
+  }
+  _route(url) {
+    const mount = this._match(url);
+    if (!mount) throw new FsError("NoProvider", url, `no provider is mounted for ${url.href}`);
+    return mount;
+  }
+  _connect(watcher, mount) {
+    const { provider, prefix } = mount;
+    if (!provider.watch) {
+      throw new FsError("NotSupported", watcher.url, `the provider mounted at ${prefix} does not support watch()`);
+    }
+    const dispose = provider.watch(watcher);
+    this._watchers.set(watcher, { mount, dispose });
+  }
+  // The provider watch is disposed at once, and reports no more events.
+  async _disconnect(watcher) {
+    const connection = this._watchers.get(watcher);
+    if (!connection) return;
+    this._watchers.set(watcher, void 0);
+    await connection.dispose();
+  }
+  _reroute() {
+    const stops = [];
+    for (const [watcher, connection] of this._watchers) {
+      const mount = this._match(watcher.url);
+      if (mount === connection?.mount) continue;
+      stops.push(this._disconnect(watcher).catch((error) => watcher.emit("error", error)));
+      if (!mount) {
+        this.ctx.logger.debug("watch of %s is suspended without a provider", watcher.url.href);
+        continue;
+      }
+      try {
+        this._connect(watcher, mount);
+      } catch (error) {
+        watcher.emit("error", error);
+      }
+    }
+    return Promise.all(stops).then(() => {
+    });
+  }
+  /** Watch a file or a directory. The watch ends with the calling fiber. */
+  watch(path, options = {}) {
+    const url = this.resolve(path);
+    const mount = this._route(url);
+    return new Watcher(this.ctx, url, options, (watcher) => {
+      this._connect(watcher, mount);
+      return async () => {
+        const connection = this._watchers.get(watcher);
+        this._watchers.delete(watcher);
+        await connection?.dispose();
+      };
+    });
   }
 };
-function watch(paths, options) {
-  return new FSWatcher(paths, options);
-}
-__name(watch, "watch");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Dirent,
-  FSWatcher,
-  constants,
-  promises,
-  watch
-});
+var BaseFs = class {
+  constructor(ctx, config = {}) {
+    this.ctx = ctx;
+    const mount = config.mount ?? new.target.mount;
+    if (!mount) throw new TypeError("expected a mount point in the config");
+    ctx.fs.mount(mount, this);
+  }
+  ctx;
+  static {
+    __name(this, "BaseFs");
+  }
+  static inject = ["fs"];
+  /** The default mount point of the subclass. */
+  static mount;
+};
+var index_default = Fs;
+export {
+  BaseFs,
+  Fs,
+  FsError,
+  Watcher,
+  index_default as default
+};

package/lib/watcher.d.ts

@@ -0,0 +1,45 @@
+import { Context } from 'cordis';
+import { Awaitable } from 'cosmokit';
+export type WatchFilter = string[] | ((path: string, isDirectory: boolean) => boolean);
+export interface WatchOptions {
+    /**
+     * Decides which entries below a watched directory are kept.
+     */
+    filter?: WatchFilter;
+}
+export interface WatchEvents {
+    /** A file at or below the watched location is modified. */
+    change(url: URL): Awaitable<void>;
+    /** The initial scan is done. A listener added afterwards is called at once. */
+    ready(): Awaitable<void>;
+    /** An error is logged as a warning without a listener. */
+    error(error: unknown): Awaitable<void>;
+}
+/**
+ * A watch on a location, which ends with the calling fiber. The provider that
+ * the location is routed to reports its events, and another provider takes
+ * over when the routing changes.
+ */
+export declare class Watcher {
+    private ctx;
+    url: URL;
+    options: WatchOptions;
+    private _hooks;
+    private _ready;
+    private _closed;
+    /** Ends the watch. */
+    dispose: () => Promise<void>;
+    /** `connect` starts serving the watch, and returns a function that disposes it. */
+    constructor(ctx: Context, url: URL, options: WatchOptions, connect: (watcher: Watcher) => () => Promise<void>);
+    /** Adds a listener, and returns a function that removes it. */
+    on<K extends keyof WatchEvents>(name: K, listener: WatchEvents[K]): () => void;
+    /**
+     * Reports an event, as the provider that serves the watch does. Only the
+     * first `ready` is dispatched, so a provider that takes over the watch does
+     * not report it again.
+     */
+    emit<K extends keyof WatchEvents>(name: K, ...args: Parameters<WatchEvents[K]>): void;
+    private _dispatch;
+    private _call;
+    private _error;
+}

package/package.json

@@ -1,38 +1,46 @@
 {
   "name": "@cordisjs/fs",
-  "version": "1.3.7",
-  "description": "Node.js fs module ponyfill for browser",
-  "type": "commonjs",
-  "exports": {
-    ".": "./lib/index.js",
-    "./constants": "./lib/constants.js",
-    "./promises": "./lib/promises.js",
-    "./src/*": "./src/*",
-    "./package.json": "./package.json"
-  },
+  "description": "File system service for Cordis",
+  "version": "2.0.0-rc.0",
+  "sideEffects": false,
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "files": [
     "lib"
   ],
+  "author": "Shigma <shigma10826@gmail.com>",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/cordiverse/ponyfills.git",
+    "url": "git+https://github.com/cordiverse/cordis.git",
     "directory": "packages/fs"
   },
   "bugs": {
-    "url": "https://github.com/cordiverse/ponyfills/issues"
+    "url": "https://github.com/cordiverse/cordis/issues"
   },
-  "homepage": "https://github.com/cordiverse/ponyfills",
-  "author": "Shigma <shigma10826@gmail.com>",
+  "homepage": "https://github.com/cordiverse/cordis",
   "keywords": [
+    "cordis",
+    "component",
     "fs",
-    "filesystem",
-    "browserify",
-    "ponyfill",
-    "polyfill",
-    "node"
+    "file",
+    "service"
   ],
+  "cordis": {
+    "service": {
+      "implements": [
+        "fs"
+      ]
+    }
+  },
+  "peerDependencies": {
+    "cordis": "^4.0.0-rc.13"
+  },
+  "devDependencies": {
+    "cordis": "^4.0.0-rc.13"
+  },
   "dependencies": {
-    "anymatch": "^3.1.3"
+    "cosmokit": "^1.8.1"
   }
-}
+}

package/lib/constants.d.ts

@@ -1,56 +0,0 @@
-export declare const UV_FS_SYMLINK_DIR = 1;
-export declare const UV_FS_SYMLINK_JUNCTION = 2;
-export declare const O_RDONLY = 0;
-export declare const O_WRONLY = 1;
-export declare const O_RDWR = 2;
-export declare const UV_DIRENT_UNKNOWN = 0;
-export declare const UV_DIRENT_FILE = 1;
-export declare const UV_DIRENT_DIR = 2;
-export declare const UV_DIRENT_LINK = 3;
-export declare const UV_DIRENT_FIFO = 4;
-export declare const UV_DIRENT_SOCKET = 5;
-export declare const UV_DIRENT_CHAR = 6;
-export declare const UV_DIRENT_BLOCK = 7;
-export declare const S_IFMT = 61440;
-export declare const S_IFREG = 32768;
-export declare const S_IFDIR = 16384;
-export declare const S_IFCHR = 8192;
-export declare const S_IFBLK = 24576;
-export declare const S_IFIFO = 4096;
-export declare const S_IFLNK = 40960;
-export declare const S_IFSOCK = 49152;
-export declare const O_CREAT = 512;
-export declare const O_EXCL = 2048;
-export declare const UV_FS_O_FILEMAP = 0;
-export declare const O_NOCTTY = 131072;
-export declare const O_TRUNC = 1024;
-export declare const O_APPEND = 8;
-export declare const O_DIRECTORY = 1048576;
-export declare const O_NOFOLLOW = 256;
-export declare const O_SYNC = 128;
-export declare const O_DSYNC = 4194304;
-export declare const O_SYMLINK = 2097152;
-export declare const O_NONBLOCK = 4;
-export declare const S_IRWXU = 448;
-export declare const S_IRUSR = 256;
-export declare const S_IWUSR = 128;
-export declare const S_IXUSR = 64;
-export declare const S_IRWXG = 56;
-export declare const S_IRGRP = 32;
-export declare const S_IWGRP = 16;
-export declare const S_IXGRP = 8;
-export declare const S_IRWXO = 7;
-export declare const S_IROTH = 4;
-export declare const S_IWOTH = 2;
-export declare const S_IXOTH = 1;
-export declare const F_OK = 0;
-export declare const R_OK = 4;
-export declare const W_OK = 2;
-export declare const X_OK = 1;
-export declare const UV_FS_COPYFILE_EXCL = 1;
-export declare const COPYFILE_EXCL = 1;
-export declare const UV_FS_COPYFILE_FICLONE = 2;
-export declare const COPYFILE_FICLONE = 2;
-export declare const UV_FS_COPYFILE_FICLONE_FORCE = 4;
-export declare const COPYFILE_FICLONE_FORCE = 4;
-export declare function parseFlags(flags: string | number): number;

package/lib/constants.js

@@ -1,219 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/constants.ts
-var constants_exports = {};
-__export(constants_exports, {
-  COPYFILE_EXCL: () => COPYFILE_EXCL,
-  COPYFILE_FICLONE: () => COPYFILE_FICLONE,
-  COPYFILE_FICLONE_FORCE: () => COPYFILE_FICLONE_FORCE,
-  F_OK: () => F_OK,
-  O_APPEND: () => O_APPEND,
-  O_CREAT: () => O_CREAT,
-  O_DIRECTORY: () => O_DIRECTORY,
-  O_DSYNC: () => O_DSYNC,
-  O_EXCL: () => O_EXCL,
-  O_NOCTTY: () => O_NOCTTY,
-  O_NOFOLLOW: () => O_NOFOLLOW,
-  O_NONBLOCK: () => O_NONBLOCK,
-  O_RDONLY: () => O_RDONLY,
-  O_RDWR: () => O_RDWR,
-  O_SYMLINK: () => O_SYMLINK,
-  O_SYNC: () => O_SYNC,
-  O_TRUNC: () => O_TRUNC,
-  O_WRONLY: () => O_WRONLY,
-  R_OK: () => R_OK,
-  S_IFBLK: () => S_IFBLK,
-  S_IFCHR: () => S_IFCHR,
-  S_IFDIR: () => S_IFDIR,
-  S_IFIFO: () => S_IFIFO,
-  S_IFLNK: () => S_IFLNK,
-  S_IFMT: () => S_IFMT,
-  S_IFREG: () => S_IFREG,
-  S_IFSOCK: () => S_IFSOCK,
-  S_IRGRP: () => S_IRGRP,
-  S_IROTH: () => S_IROTH,
-  S_IRUSR: () => S_IRUSR,
-  S_IRWXG: () => S_IRWXG,
-  S_IRWXO: () => S_IRWXO,
-  S_IRWXU: () => S_IRWXU,
-  S_IWGRP: () => S_IWGRP,
-  S_IWOTH: () => S_IWOTH,
-  S_IWUSR: () => S_IWUSR,
-  S_IXGRP: () => S_IXGRP,
-  S_IXOTH: () => S_IXOTH,
-  S_IXUSR: () => S_IXUSR,
-  UV_DIRENT_BLOCK: () => UV_DIRENT_BLOCK,
-  UV_DIRENT_CHAR: () => UV_DIRENT_CHAR,
-  UV_DIRENT_DIR: () => UV_DIRENT_DIR,
-  UV_DIRENT_FIFO: () => UV_DIRENT_FIFO,
-  UV_DIRENT_FILE: () => UV_DIRENT_FILE,
-  UV_DIRENT_LINK: () => UV_DIRENT_LINK,
-  UV_DIRENT_SOCKET: () => UV_DIRENT_SOCKET,
-  UV_DIRENT_UNKNOWN: () => UV_DIRENT_UNKNOWN,
-  UV_FS_COPYFILE_EXCL: () => UV_FS_COPYFILE_EXCL,
-  UV_FS_COPYFILE_FICLONE: () => UV_FS_COPYFILE_FICLONE,
-  UV_FS_COPYFILE_FICLONE_FORCE: () => UV_FS_COPYFILE_FICLONE_FORCE,
-  UV_FS_O_FILEMAP: () => UV_FS_O_FILEMAP,
-  UV_FS_SYMLINK_DIR: () => UV_FS_SYMLINK_DIR,
-  UV_FS_SYMLINK_JUNCTION: () => UV_FS_SYMLINK_JUNCTION,
-  W_OK: () => W_OK,
-  X_OK: () => X_OK,
-  parseFlags: () => parseFlags
-});
-module.exports = __toCommonJS(constants_exports);
-var UV_FS_SYMLINK_DIR = 1;
-var UV_FS_SYMLINK_JUNCTION = 2;
-var O_RDONLY = 0;
-var O_WRONLY = 1;
-var O_RDWR = 2;
-var UV_DIRENT_UNKNOWN = 0;
-var UV_DIRENT_FILE = 1;
-var UV_DIRENT_DIR = 2;
-var UV_DIRENT_LINK = 3;
-var UV_DIRENT_FIFO = 4;
-var UV_DIRENT_SOCKET = 5;
-var UV_DIRENT_CHAR = 6;
-var UV_DIRENT_BLOCK = 7;
-var S_IFMT = 61440;
-var S_IFREG = 32768;
-var S_IFDIR = 16384;
-var S_IFCHR = 8192;
-var S_IFBLK = 24576;
-var S_IFIFO = 4096;
-var S_IFLNK = 40960;
-var S_IFSOCK = 49152;
-var O_CREAT = 512;
-var O_EXCL = 2048;
-var UV_FS_O_FILEMAP = 0;
-var O_NOCTTY = 131072;
-var O_TRUNC = 1024;
-var O_APPEND = 8;
-var O_DIRECTORY = 1048576;
-var O_NOFOLLOW = 256;
-var O_SYNC = 128;
-var O_DSYNC = 4194304;
-var O_SYMLINK = 2097152;
-var O_NONBLOCK = 4;
-var S_IRWXU = 448;
-var S_IRUSR = 256;
-var S_IWUSR = 128;
-var S_IXUSR = 64;
-var S_IRWXG = 56;
-var S_IRGRP = 32;
-var S_IWGRP = 16;
-var S_IXGRP = 8;
-var S_IRWXO = 7;
-var S_IROTH = 4;
-var S_IWOTH = 2;
-var S_IXOTH = 1;
-var F_OK = 0;
-var R_OK = 4;
-var W_OK = 2;
-var X_OK = 1;
-var UV_FS_COPYFILE_EXCL = 1;
-var COPYFILE_EXCL = 1;
-var UV_FS_COPYFILE_FICLONE = 2;
-var COPYFILE_FICLONE = 2;
-var UV_FS_COPYFILE_FICLONE_FORCE = 4;
-var COPYFILE_FICLONE_FORCE = 4;
-function parseFlags(flags) {
-  if (typeof flags === "number") return flags;
-  let result = 0;
-  for (const flag of flags) {
-    switch (flag) {
-      case "r":
-        break;
-      case "w":
-        break;
-      case "a":
-        result |= O_APPEND;
-        break;
-      case "x":
-        result |= O_EXCL;
-        break;
-      case "+":
-        break;
-      default:
-        throw new Error(`invalid flags: ${flags}`);
-    }
-  }
-  return result;
-}
-__name(parseFlags, "parseFlags");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  COPYFILE_EXCL,
-  COPYFILE_FICLONE,
-  COPYFILE_FICLONE_FORCE,
-  F_OK,
-  O_APPEND,
-  O_CREAT,
-  O_DIRECTORY,
-  O_DSYNC,
-  O_EXCL,
-  O_NOCTTY,
-  O_NOFOLLOW,
-  O_NONBLOCK,
-  O_RDONLY,
-  O_RDWR,
-  O_SYMLINK,
-  O_SYNC,
-  O_TRUNC,
-  O_WRONLY,
-  R_OK,
-  S_IFBLK,
-  S_IFCHR,
-  S_IFDIR,
-  S_IFIFO,
-  S_IFLNK,
-  S_IFMT,
-  S_IFREG,
-  S_IFSOCK,
-  S_IRGRP,
-  S_IROTH,
-  S_IRUSR,
-  S_IRWXG,
-  S_IRWXO,
-  S_IRWXU,
-  S_IWGRP,
-  S_IWOTH,
-  S_IWUSR,
-  S_IXGRP,
-  S_IXOTH,
-  S_IXUSR,
-  UV_DIRENT_BLOCK,
-  UV_DIRENT_CHAR,
-  UV_DIRENT_DIR,
-  UV_DIRENT_FIFO,
-  UV_DIRENT_FILE,
-  UV_DIRENT_LINK,
-  UV_DIRENT_SOCKET,
-  UV_DIRENT_UNKNOWN,
-  UV_FS_COPYFILE_EXCL,
-  UV_FS_COPYFILE_FICLONE,
-  UV_FS_COPYFILE_FICLONE_FORCE,
-  UV_FS_O_FILEMAP,
-  UV_FS_SYMLINK_DIR,
-  UV_FS_SYMLINK_JUNCTION,
-  W_OK,
-  X_OK,
-  parseFlags
-});

package/lib/promises.d.ts

@@ -1,90 +0,0 @@
-import { Buffer } from 'buffer';
-import { Dirent } from '.';
-declare global {
-    interface FileSystemCreateWritableOptions {
-        keepExistingData?: boolean;
-    }
-    interface FileSystemWritableFileStream extends WritableStream {
-        seek(position: number): Promise<void>;
-        truncate(size: number): Promise<void>;
-        write(data: string | ArrayBuffer | ArrayBufferView | Blob | DataView): Promise<void>;
-    }
-    interface FileSystemReadWriteOptions {
-        at: number;
-    }
-    interface FileSystemSyncAccessHandle {
-        close(): Promise<void>;
-        flush(): Promise<void>;
-        getSize(): Promise<number>;
-        read(buffer: ArrayBuffer | ArrayBufferView, options?: FileSystemReadWriteOptions): Promise<number>;
-        truncate(newSize: number): Promise<void>;
-        write(buffer: ArrayBuffer | ArrayBufferView, options?: FileSystemReadWriteOptions): Promise<number>;
-    }
-    interface FileSystemFileHandle {
-        createWritable(options?: FileSystemCreateWritableOptions): Promise<FileSystemWritableFileStream>;
-        createSyncAccessHandle(): Promise<FileSystemSyncAccessHandle>;
-    }
-    interface FileSystemDirectoryHandle {
-        entries(): AsyncIterable<[string, FileSystemHandle]>;
-        keys(): AsyncIterable<string>;
-        values(): AsyncIterable<FileSystemHandle>;
-    }
-}
-export interface EncodingOptions {
-    encoding?: BufferEncoding;
-}
-export declare function writeFile(path: string, data: string | ArrayBuffer | ArrayBufferView | Blob | DataView): Promise<void>;
-export declare function appendFile(path: string, data: string | ArrayBuffer | ArrayBufferView | Blob | DataView): Promise<void>;
-export declare function readFile(path: string, options?: BufferEncoding): Promise<string | Buffer<ArrayBuffer>>;
-export interface ReadDirectoryOptions {
-    withFileTypes?: boolean;
-}
-export declare function readdir(path: string, options: ReadDirectoryOptions & {
-    withFileTypes: true;
-}): Promise<Dirent[]>;
-export declare function readdir(path: string, options?: ReadDirectoryOptions & {
-    withFileTypes?: false;
-}): Promise<string[]>;
-export interface MakeDirectoryOptions {
-    recursive?: boolean;
-}
-export declare function mkdir(path: string, options?: MakeDirectoryOptions): Promise<void>;
-export interface RemoveOptions {
-    force?: boolean;
-    recursive?: boolean;
-}
-export declare function rm(path: string, options?: RemoveOptions): Promise<void>;
-export { rm as unlink, rm as rmdir };
-export interface CopyOptions {
-    force?: boolean;
-    recursive?: boolean;
-}
-export declare function cp(src: string, dst: string, options?: CopyOptions): Promise<void>;
-export { cp as copyFile };
-export declare function rename(oldPath: string, newPath: string): Promise<void>;
-export declare function getHandle(path: string, kind: 'file'): Promise<FileSystemFileHandle>;
-export declare function getHandle(path: string, kind: 'directory'): Promise<FileSystemDirectoryHandle>;
-export declare function getHandle(path: string, kind?: FileSystemHandleKind): Promise<FileSystemHandle>;
-export interface StatOptions {
-}
-export declare function stat(path: string, options?: StatOptions): Promise<{
-    isFile: () => boolean;
-    isDirectory: () => boolean;
-}>;
-export declare function access(path: string, mode?: number): Promise<void>;
-interface FileHandleWriteResult<T> {
-    bytesWritten: number;
-    buffer: T;
-}
-declare class FileHandle {
-    private handle;
-    private flags;
-    private _streamTask?;
-    constructor(handle: FileSystemFileHandle, flags: number);
-    stream(): Promise<FileSystemWritableFileStream>;
-    readFile(encoding?: BufferEncoding): Promise<string | Buffer<ArrayBuffer>>;
-    write<T extends Uint8Array>(buffer: T, offset?: number, length?: number, position?: number): Promise<FileHandleWriteResult<T>>;
-    write(data: string, position?: number, encoding?: BufferEncoding): Promise<FileHandleWriteResult<string>>;
-    close(): Promise<void>;
-}
-export declare function open(path: string, flags: string | number, mode?: number): Promise<FileHandle>;

package/lib/promises.js

@@ -1,325 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/promises.ts
-var promises_exports = {};
-__export(promises_exports, {
-  access: () => access,
-  appendFile: () => appendFile,
-  copyFile: () => cp,
-  cp: () => cp,
-  getHandle: () => getHandle,
-  mkdir: () => mkdir,
-  open: () => open,
-  readFile: () => readFile,
-  readdir: () => readdir,
-  rename: () => rename,
-  rm: () => rm,
-  rmdir: () => rm,
-  stat: () => stat,
-  unlink: () => rm,
-  writeFile: () => writeFile
-});
-module.exports = __toCommonJS(promises_exports);
-var import_buffer = require("buffer");
-var import_constants = require("./constants");
-var import__ = require(".");
-var SystemError = class extends Error {
-  static {
-    __name(this, "SystemError");
-  }
-  constructor(message, options) {
-    super(`${options.code}: ${message}, ${options.syscall} '${options.path}'`);
-  }
-};
-var ENOENT = class extends SystemError {
-  static {
-    __name(this, "ENOENT");
-  }
-  constructor(syscall2, path) {
-    super("no such file or directory", {
-      errno: -2,
-      code: "EEXIST",
-      syscall: syscall2,
-      path
-    });
-  }
-};
-var EEXIST = class extends SystemError {
-  static {
-    __name(this, "EEXIST");
-  }
-  constructor(syscall2, path) {
-    super("file already exists", {
-      errno: -17,
-      code: "EEXIST",
-      syscall: syscall2,
-      path
-    });
-  }
-};
-var ENOTDIR = class extends SystemError {
-  static {
-    __name(this, "ENOTDIR");
-  }
-  constructor(syscall2, path) {
-    super("not a directory", {
-      errno: -20,
-      code: "ENOTDIR",
-      syscall: syscall2,
-      path
-    });
-  }
-};
-var EISDIR = class extends SystemError {
-  static {
-    __name(this, "EISDIR");
-  }
-  constructor(syscall2, path) {
-    super("illegal operation on a directory", {
-      errno: -21,
-      code: "EISDIR",
-      syscall: syscall2,
-      path
-    });
-  }
-};
-async function syscall(type, path, cb, dict) {
-  try {
-    return await cb();
-  } catch (e) {
-    if (!(e instanceof DOMException)) throw e;
-    const constructor = dict[e.code];
-    if (!constructor) throw e;
-    throw new constructor(type, path);
-  }
-}
-__name(syscall, "syscall");
-async function getDirectoryHandle(type, path, parts, create) {
-  let root = await navigator.storage.getDirectory();
-  for (const part of parts) {
-    await syscall(type, path, async () => {
-      root = await root.getDirectoryHandle(part, { create });
-    }, {
-      [DOMException.TYPE_MISMATCH_ERR]: ENOTDIR,
-      [DOMException.NOT_FOUND_ERR]: ENOENT
-    });
-  }
-  return root;
-}
-__name(getDirectoryHandle, "getDirectoryHandle");
-async function getParent(type, path, create = false) {
-  const parts = path.split("/").filter(Boolean);
-  const filename = parts.pop();
-  return [await getDirectoryHandle(type, path, parts, create), filename];
-}
-__name(getParent, "getParent");
-async function getFileHandle(type, path, create = false) {
-  const [root, filename] = await getParent(type, path);
-  return syscall(type, path, () => root.getFileHandle(filename, { create }), {
-    [DOMException.TYPE_MISMATCH_ERR]: EISDIR,
-    [DOMException.NOT_FOUND_ERR]: ENOENT
-  });
-}
-__name(getFileHandle, "getFileHandle");
-async function writeOrAppendFile(type, path, data, keepExistingData) {
-  const handle = await getFileHandle(type, path, true);
-  const stream = await handle.createWritable({ keepExistingData });
-  if (typeof data === "string") {
-    data = new TextEncoder().encode(data);
-  }
-  await stream.write(data);
-  await stream.close();
-}
-__name(writeOrAppendFile, "writeOrAppendFile");
-async function writeFile(path, data) {
-  await writeOrAppendFile("write", path, data, false);
-}
-__name(writeFile, "writeFile");
-async function appendFile(path, data) {
-  await writeOrAppendFile("append", path, data, true);
-}
-__name(appendFile, "appendFile");
-async function _readFile(handle, encoding) {
-  const file = await handle.getFile();
-  if (encoding === "utf8" || encoding === "utf-8") {
-    return await file.text();
-  } else {
-    return import_buffer.Buffer.from(await file.arrayBuffer());
-  }
-}
-__name(_readFile, "_readFile");
-async function readFile(path, options) {
-  const handle = await getFileHandle("read", path);
-  return await _readFile(handle, options);
-}
-__name(readFile, "readFile");
-async function readdir(path, options = {}) {
-  const parts = path.split("/").filter(Boolean);
-  const root = await getDirectoryHandle("readdir", path, parts, false);
-  const results = [];
-  for await (const [name, handle] of root.entries()) {
-    results.push(options.withFileTypes ? new import__.Dirent(handle) : name);
-  }
-  return results;
-}
-__name(readdir, "readdir");
-async function mkdir(path, options = {}) {
-  if (options.recursive) {
-    await getDirectoryHandle("mkdir", path, path.split("/").filter(Boolean), true);
-    return;
-  }
-  const [root, filename] = await getParent("mkdir", path);
-  try {
-    await root.getDirectoryHandle(filename);
-  } catch (e) {
-    if (!(e instanceof DOMException)) throw e;
-    if (e.code === DOMException.NOT_FOUND_ERR) {
-      await root.getDirectoryHandle(filename, { create: true });
-      return;
-    } else if (e.code === DOMException.TYPE_MISMATCH_ERR) {
-      throw new EEXIST("mkdir", path);
-    }
-    throw e;
-  }
-  throw new EEXIST("mkdir", path);
-}
-__name(mkdir, "mkdir");
-async function rm(path, options = {}) {
-  try {
-    const [root, filename] = await getParent("rm", path);
-    await root.removeEntry(filename, { recursive: options.recursive });
-  } catch (e) {
-    if (options.force && e instanceof ENOENT) return;
-    throw e;
-  }
-}
-__name(rm, "rm");
-async function cp(src, dst, options = {}) {
-  const oldHandle = await getHandle(src);
-  const newHandle = await getHandle(dst, oldHandle.kind);
-  if (oldHandle.kind === "file") {
-    const buffer = await oldHandle.getFile().then((file) => file.arrayBuffer());
-    const stream = await newHandle.createWritable();
-    await stream.write(buffer);
-    await stream.close();
-  } else {
-    for await (const name of oldHandle.keys()) {
-      await cp(src + "/" + name, dst + "/" + name);
-    }
-  }
-}
-__name(cp, "cp");
-async function rename(oldPath, newPath) {
-  await cp(oldPath, newPath, { recursive: true });
-  await rm(oldPath, { recursive: true });
-}
-__name(rename, "rename");
-async function getHandle(path, kind) {
-  const [root, filename] = await getParent("lstat", path, !!kind);
-  if (kind === "file") {
-    return await root.getFileHandle(filename, { create: true });
-  } else if (kind === "directory") {
-    return await root.getDirectoryHandle(filename, { create: true });
-  }
-  try {
-    return await root.getFileHandle(filename);
-  } catch {
-    return await root.getDirectoryHandle(filename);
-  }
-}
-__name(getHandle, "getHandle");
-async function stat(path, options) {
-  const handle = await getHandle(path);
-  return {
-    isFile: /* @__PURE__ */ __name(() => handle.kind === "file", "isFile"),
-    isDirectory: /* @__PURE__ */ __name(() => handle.kind === "directory", "isDirectory")
-  };
-}
-__name(stat, "stat");
-async function access(path, mode) {
-  await getHandle(path);
-}
-__name(access, "access");
-var FileHandle = class {
-  constructor(handle, flags) {
-    this.handle = handle;
-    this.flags = flags;
-  }
-  static {
-    __name(this, "FileHandle");
-  }
-  _streamTask;
-  stream() {
-    return this._streamTask ||= this.handle.createWritable({
-      keepExistingData: !!(this.flags & import_constants.O_APPEND)
-    });
-  }
-  async readFile(encoding) {
-    return _readFile(this.handle, encoding);
-  }
-  async write(data, ...args) {
-    if (typeof data === "string") {
-      const result = await this.write(new TextEncoder().encode(data), void 0, void 0, args[1]);
-      return { ...result, buffer: data };
-    }
-    const offset = args[0] ?? 0;
-    const length = args[1] ?? data.byteLength - offset;
-    data = data.slice(offset, offset + length);
-    const stream = await this.stream();
-    await stream.write(data);
-    return { bytesWritten: data.byteLength, buffer: data };
-  }
-  async close() {
-    const stream = await this.stream();
-    await stream.close();
-  }
-};
-async function open(path, flags, mode) {
-  flags = (0, import_constants.parseFlags)(flags);
-  if (flags & import_constants.O_EXCL) {
-    try {
-      await getHandle(path);
-    } catch {
-      return new FileHandle(await getHandle(path, "file"), flags);
-    }
-    throw new EEXIST("open", path);
-  }
-  return new FileHandle(await getHandle(path, "file"), flags);
-}
-__name(open, "open");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  access,
-  appendFile,
-  copyFile,
-  cp,
-  getHandle,
-  mkdir,
-  open,
-  readFile,
-  readdir,
-  rename,
-  rm,
-  rmdir,
-  stat,
-  unlink,
-  writeFile
-});