@cordisjs/fs 1.3.7

package/README.md

@@ -0,0 +1,5 @@
+# @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/constants.d.ts

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,219 @@
+"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/index.d.ts

@@ -0,0 +1,24 @@
+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;
+}
+export interface WatchOptions {
+    ignored?: Matcher;
+    ignoreInitial?: boolean;
+    cwd?: string;
+    depth?: number;
+    interval?: number;
+}
+export declare class FSWatcher extends EventEmitter {
+    constructor(paths: string | readonly string[], options?: WatchOptions);
+    close(): void;
+}
+export declare function watch(paths: string | readonly string[], options?: WatchOptions): FSWatcher;

package/lib/index.js

@@ -0,0 +1,81 @@
+"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 });
+  }
+  return to;
+};
+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;
+  }
+  static {
+    __name(this, "Dirent");
+  }
+  name;
+  isFile() {
+    return this.handle.kind === "file";
+  }
+  isDirectory() {
+    return this.handle.kind === "directory";
+  }
+};
+var FSWatcher = class extends import_events.default {
+  static {
+    __name(this, "FSWatcher");
+  }
+  constructor(paths, options) {
+    super();
+  }
+  close() {
+  }
+};
+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
+});

package/lib/promises.d.ts

@@ -0,0 +1,90 @@
+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

@@ -0,0 +1,325 @@
+"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
+});

package/package.json

@@ -0,0 +1,38 @@
+{
+  "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"
+  },
+  "files": [
+    "lib"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cordiverse/ponyfills.git",
+    "directory": "packages/fs"
+  },
+  "bugs": {
+    "url": "https://github.com/cordiverse/ponyfills/issues"
+  },
+  "homepage": "https://github.com/cordiverse/ponyfills",
+  "author": "Shigma <shigma10826@gmail.com>",
+  "keywords": [
+    "fs",
+    "filesystem",
+    "browserify",
+    "ponyfill",
+    "polyfill",
+    "node"
+  ],
+  "dependencies": {
+    "anymatch": "^3.1.3"
+  }
+}