@reliverse/relifso 1.1.2 → 1.2.0

package/README.md

@@ -16,6 +16,12 @@
 - ✌️ **Soon**: Bun v1.2+ ready — ships with Bun-aware enhancements out of the box
 - 🔥 **Soon**: Bun-specific features are exposed via `fs.*` when running on Bun
 
+## Heads Up
+
+- **Most of the things** mentioned in this doc **aren’t implemented yet** — they’re part of the vision for ~`v1.3.0`.
+- Got thoughts? Ideas? Send your feedback in [Discord](https://discord.gg/Pb8uKbwpsJ) or use [GitHub Issues](https://github.com/reliverse/relifso/issues).
+- Your feedback means the world and helps shape where this project goes next. Thank you!
+
 ## Install
 
 ```bash
@@ -282,7 +288,6 @@ Relifso wouldn’t be so cool without these gems:
 - [node:fs](https://nodejs.org/api/fs.html)+[node:path](https://nodejs.org/api/path.html) — origins
 - [`fs-extra`](https://github.com/jprichardson/node-fs-extra) — classic, reliable
 - [`fsxt`](https://github.com/uwx-node-modules/fsxt) — full fs-extra overhaul
-- [`fs-lite`](https://github.com/baooab/node-fs-lite) — no-deps, fully-typed
 
 ## Show Some Love
 

package/bin/impl/async.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Converts a synchronous function into an asynchronous function that returns a Promise.
+ *
+ * @param fn - The synchronous function to convert.
+ * @returns An asynchronous function that wraps the original synchronous function.
+ */
+export declare function toAsync<T extends (...args: any[]) => any>(fn: T): (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;

package/bin/impl/async.js

@@ -0,0 +1,9 @@
+export function toAsync(fn) {
+  return (...args) => new Promise((resolve, reject) => {
+    try {
+      resolve(fn(...args));
+    } catch (error) {
+      reject(error);
+    }
+  });
+}

package/bin/impl/copy.d.ts

@@ -0,0 +1,20 @@
+export interface CopyOptions {
+    overwrite?: boolean;
+    /** @deprecated Use `overwrite`. */
+    clobber?: boolean;
+    preserveTimestamps?: boolean;
+    /** @deprecated Not used. */
+    errorOnExist?: boolean;
+    /** @deprecated Not used. */
+    dereference?: boolean;
+    /** @deprecated Not used. */
+    filter?: (src: string, dest: string) => boolean;
+}
+/**
+ * Copies a file or directory. The directory can have contents. Like `cp -r`.
+ *
+ * @param src - The source path.
+ * @param dest - The destination path.
+ * @param options - Options for the copy operation.
+ */
+export declare function copySync(src: string, dest: string, options?: CopyOptions): void;

package/bin/impl/copy.js

@@ -0,0 +1,28 @@
+import { copyFileSync, statSync, constants as fsConstants } from "node:fs";
+import { dirname, join as joinPath, basename as basenamePath } from "node:path";
+import { mkdirsSync } from "./mkdirs.js";
+export function copySync(src, dest, options = {}) {
+  const { overwrite = options.clobber || false, preserveTimestamps = false } = options;
+  const srcStat = statSync(src, { throwIfNoEntry: true });
+  if (!srcStat) {
+  }
+  let destFinal = dest;
+  const destStat = statSync(dest, { throwIfNoEntry: false });
+  if (destStat?.isDirectory()) {
+    destFinal = joinPath(dest, basenamePath(src));
+  }
+  const destExists = statSync(destFinal, { throwIfNoEntry: false });
+  if (destExists && !overwrite) {
+    throw new Error(`Destination ${destFinal} already exists and overwrite is false.`);
+  }
+  const destDir = dirname(destFinal);
+  mkdirsSync(destDir);
+  if (srcStat.isDirectory()) {
+    mkdirsSync(destFinal);
+  } else {
+    copyFileSync(src, destFinal, preserveTimestamps ? fsConstants.COPYFILE_FICLONE : 0);
+    if (preserveTimestamps) {
+      console.warn("preserveTimestamps: utimesSync is not implemented for the moment.");
+    }
+  }
+}

package/bin/impl/create-file.d.ts

@@ -0,0 +1 @@
+export declare function createFileSync(file: string, content?: string): void;

package/bin/impl/create-file.js

@@ -0,0 +1,8 @@
+import { existsSync } from "node:fs";
+import { writeFileSync } from "./write-file.js";
+export function createFileSync(file, content = "") {
+  if (existsSync(file)) {
+    return;
+  }
+  return writeFileSync(file, content);
+}

package/bin/impl/dive.d.ts

@@ -0,0 +1,17 @@
+import { statSync } from "node:fs";
+export interface DiveOptions {
+    all?: boolean;
+    recursive?: boolean;
+    directories?: boolean;
+    files?: boolean;
+    ignore?: string[] | RegExp;
+    depth?: number;
+}
+/**
+ * Synchronously walks a directory and yields each file and/or directory path.
+ *
+ * @param dir - The directory to walk.
+ * @param callbackOrOptions - A callback function to execute for each entry, or options object.
+ * @param options - Options for the dive operation if a callback is provided as the second argument.
+ */
+export declare function diveSync(dir: string, callbackOrOptions?: ((path: string, stat: ReturnType<typeof statSync>) => void) | DiveOptions, options?: DiveOptions): Generator<string, void, unknown>;

package/bin/impl/dive.js

@@ -0,0 +1,56 @@
+import { readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+export function* diveSync(dir, callbackOrOptions, options) {
+  const currentDepth = 0;
+  let actualOptions = {
+    recursive: true,
+    files: true,
+    directories: false
+    // fs-extra's dive by default only yields files
+  };
+  let callback;
+  if (typeof callbackOrOptions === "function") {
+    callback = callbackOrOptions;
+    if (options) {
+      actualOptions = { ...actualOptions, ...options };
+    }
+  } else if (typeof callbackOrOptions === "object") {
+    actualOptions = { ...actualOptions, ...callbackOrOptions };
+  }
+  function* walk(currentPath, depth) {
+    if (actualOptions.depth !== void 0 && depth > actualOptions.depth) {
+      return;
+    }
+    const entries = readdirSync(currentPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryPath = join(currentPath, entry.name);
+      if (!actualOptions.all && entry.name.startsWith(".")) {
+        continue;
+      }
+      if (actualOptions.ignore) {
+        if (Array.isArray(actualOptions.ignore) && actualOptions.ignore.includes(entry.name)) {
+          continue;
+        }
+        if (actualOptions.ignore instanceof RegExp && actualOptions.ignore.test(entryPath)) {
+          continue;
+        }
+      }
+      const stat = statSync(entryPath);
+      if (entry.isFile()) {
+        if (actualOptions.files) {
+          if (callback) callback(entryPath, stat);
+          yield entryPath;
+        }
+      } else if (entry.isDirectory()) {
+        if (actualOptions.directories) {
+          if (callback) callback(entryPath, stat);
+          yield entryPath;
+        }
+        if (actualOptions.recursive) {
+          yield* walk(entryPath, depth + 1);
+        }
+      }
+    }
+  }
+  yield* walk(dir, currentDepth);
+}

package/bin/impl/empty-dir.d.ts

@@ -0,0 +1 @@
+export declare function emptyDirSync(dir: string): void;

package/bin/impl/empty-dir.js

@@ -0,0 +1,10 @@
+import { existsSync, readdirSync, rmSync } from "node:fs";
+import path from "node:path";
+export function emptyDirSync(dir) {
+  if (!existsSync(dir)) {
+    return;
+  }
+  for (const file of readdirSync(dir)) {
+    rmSync(path.resolve(dir, file), { recursive: true, force: true });
+  }
+}

package/bin/impl/mkdirs.d.ts

@@ -0,0 +1 @@
+export declare function mkdirsSync(dir: string): string | undefined;

package/bin/impl/mkdirs.js

@@ -0,0 +1,7 @@
+import { mkdirSync, existsSync } from "node:fs";
+export function mkdirsSync(dir) {
+  if (existsSync(dir)) {
+    return;
+  }
+  return mkdirSync(dir, { recursive: true });
+}

package/bin/impl/move.d.ts

@@ -0,0 +1,14 @@
+export interface MoveOptions {
+    overwrite?: boolean;
+    /** @deprecated Use `overwrite`. */
+    clobber?: boolean;
+}
+/**
+ * Moves a file or directory. If the destination is a directory, the source is moved into it.
+ * If the destination exists and is a file, it will be overwritten if `overwrite` is true.
+ *
+ * @param src - The source path.
+ * @param dest - The destination path.
+ * @param options - Options for the move operation.
+ */
+export declare function moveSync(src: string, dest: string, options?: MoveOptions): void;

package/bin/impl/move.js

@@ -0,0 +1,42 @@
+import { renameSync, statSync, unlinkSync, copyFileSync } from "node:fs";
+import { dirname, basename, join as joinPath } from "node:path";
+import { mkdirsSync } from "./mkdirs.js";
+export function moveSync(src, dest, options = {}) {
+  let overwrite;
+  if (options.overwrite !== void 0) {
+    overwrite = options.overwrite;
+  } else if (options.clobber !== void 0) {
+    console.warn(
+      "Warning: The 'clobber' option in moveSync is deprecated and will be removed in a future version. Please use 'overwrite' instead."
+    );
+    overwrite = options.clobber;
+  } else {
+    overwrite = false;
+  }
+  const srcStat = statSync(src, { throwIfNoEntry: true });
+  if (!srcStat) {
+  }
+  let destFinal = dest;
+  const destStat = statSync(dest, { throwIfNoEntry: false });
+  if (destStat?.isDirectory()) {
+    destFinal = joinPath(dest, basename(src));
+  }
+  if (statSync(destFinal, { throwIfNoEntry: false }) && !overwrite) {
+    throw new Error(`Destination ${destFinal} already exists and overwrite is false.`);
+  }
+  const destDir = dirname(destFinal);
+  mkdirsSync(destDir);
+  try {
+    renameSync(src, destFinal);
+  } catch (err) {
+    if (err.code === "EXDEV") {
+      copyFileSync(src, destFinal);
+      unlinkSync(src);
+    } else if (err.code === "EISDIR" || err.code === "EPERM") {
+      copyFileSync(src, destFinal);
+      unlinkSync(src);
+    } else {
+      throw err;
+    }
+  }
+}

package/bin/impl/output-file.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Ensures that the directory for the file exists and then writes the data to the file.
+ *
+ * @param file - The path to the file.
+ * @param data - The data to write.
+ * @param options - Options for writing the file (e.g., encoding, mode, flag).
+ */
+export declare function outputFileSync(file: string, data: string | Uint8Array, options?: unknown): void;

package/bin/impl/output-file.js

@@ -0,0 +1,8 @@
+import { dirname } from "node:path";
+import { mkdirsSync } from "./mkdirs.js";
+import { writeFileSync } from "./write-file.js";
+export function outputFileSync(file, data, options) {
+  const dir = dirname(file);
+  mkdirsSync(dir);
+  writeFileSync(file, data, options);
+}

package/bin/impl/output-json.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Ensures that the directory for the JSON file exists and then writes the JSON data to the file.
+ *
+ * @param file - The path to the file.
+ * @param data - The JSON data to write.
+ * @param options - Options for writing the JSON file (e.g., replacer, space).
+ */
+export declare function outputJsonSync(file: string, data: unknown, options?: unknown): void;

package/bin/impl/output-json.js

@@ -0,0 +1,8 @@
+import { dirname } from "node:path";
+import { mkdirsSync } from "./mkdirs.js";
+import { writeJsonSync } from "./write-json.js";
+export function outputJsonSync(file, data, options) {
+  const dir = dirname(file);
+  mkdirsSync(dir);
+  writeJsonSync(file, data, options);
+}

package/bin/impl/path-exists.d.ts

@@ -0,0 +1 @@
+export declare function pathExistsSync(path: string): boolean;

package/bin/impl/path-exists.js

@@ -0,0 +1,4 @@
+import { existsSync } from "node:fs";
+export function pathExistsSync(path) {
+  return existsSync(path);
+}

package/bin/impl/read-file.d.ts

@@ -0,0 +1,12 @@
+export interface ReadFileOptions {
+    encoding?: BufferEncoding | null;
+    flag?: string;
+}
+/**
+ * Reads the entire contents of a file.
+ *
+ * @param path - The path to the file.
+ * @param options - Options for reading the file. Can be an encoding string or an object.
+ * @returns The file content as a string or Buffer.
+ */
+export declare function readFileSync(path: string, options?: BufferEncoding | ReadFileOptions): string | Buffer;

package/bin/impl/read-file.js

@@ -0,0 +1,12 @@
+import { readFileSync as nodeReadFileSync } from "node:fs";
+export function readFileSync(path, options) {
+  let encoding;
+  let flag;
+  if (typeof options === "string") {
+    encoding = options;
+  } else if (options) {
+    encoding = options.encoding ?? void 0;
+    flag = options.flag;
+  }
+  return nodeReadFileSync(path, { encoding, flag });
+}

package/bin/impl/read-json.d.ts

@@ -0,0 +1,14 @@
+export interface ReadJsonOptions {
+    encoding?: BufferEncoding | null;
+    flag?: string;
+    reviver?: (key: string, value: unknown) => unknown;
+    throws?: boolean;
+}
+/**
+ * Reads a JSON file and then parses it into an object.
+ *
+ * @param file - The path to the file.
+ * @param options - Options for reading the file or parsing JSON. Can be an encoding string or an object.
+ * @returns The parsed JSON object.
+ */
+export declare function readJsonSync<T = unknown>(file: string, options?: BufferEncoding | ReadJsonOptions): T;

package/bin/impl/read-json.js

@@ -0,0 +1,24 @@
+import { readFileSync } from "node:fs";
+export function readJsonSync(file, options) {
+  let encoding = "utf8";
+  let reviver;
+  let throws = true;
+  if (typeof options === "string") {
+    encoding = options;
+  } else if (options) {
+    encoding = options.encoding ?? encoding;
+    reviver = options.reviver;
+    if (options.throws !== void 0) {
+      throws = options.throws;
+    }
+  }
+  try {
+    const data = readFileSync(file, { encoding });
+    return JSON.parse(data, reviver);
+  } catch (err) {
+    if (throws) {
+      throw err;
+    }
+    return void 0;
+  }
+}

package/bin/impl/remove.d.ts

@@ -0,0 +1 @@
+export declare function removeSync(path: string): void;

package/bin/impl/remove.js

@@ -0,0 +1,4 @@
+import { rmSync } from "node:fs";
+export function removeSync(path) {
+  return rmSync(path, { recursive: true, force: true });
+}

package/bin/impl/write-file.d.ts

@@ -0,0 +1,11 @@
+import { type PathLike } from "node:fs";
+export type WriteFileOptions = import("node:fs").WriteFileOptions;
+/**
+ * Synchronously writes data to a file, replacing the file if it already exists.
+ * Ensures the directory exists before writing.
+ *
+ * @param file - Path to the file.
+ * @param data - The data to write. If something other than a Buffer or Uint8Array is provided, it is converted to a string.
+ * @param options - Options for writing the file. Can be an encoding string or an object.
+ */
+export declare function writeFileSync(file: PathLike | number, data: string | NodeJS.ArrayBufferView, options?: WriteFileOptions): void;

package/bin/impl/write-file.js

@@ -0,0 +1,9 @@
+import { existsSync, mkdirSync, writeFileSync as nodeWriteFileSync } from "node:fs";
+import path from "node:path";
+export function writeFileSync(file, data, options) {
+  const dir = path.dirname(file.toString());
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  nodeWriteFileSync(file, data, options);
+}

package/bin/impl/write-json.d.ts

@@ -0,0 +1,20 @@
+import type { Mode, OpenMode } from "node:fs";
+export interface JsonStringifyOptions {
+    replacer?: (key: string, value: unknown) => unknown | (number | string)[] | null;
+    space?: string | number;
+}
+export interface WriteJsonOptions {
+    encoding?: BufferEncoding | null;
+    mode?: Mode;
+    flag?: OpenMode;
+    replacer?: (key: string, value: unknown) => unknown | (number | string)[] | null;
+    space?: string | number;
+}
+/**
+ * Synchronously writes an object to a JSON file.
+ *
+ * @param file - The path to the file.
+ * @param object - The object to stringify and write.
+ * @param options - Options for stringifying JSON or writing the file.
+ */
+export declare function writeJsonSync(file: string, object: unknown, options?: WriteJsonOptions): void;

package/bin/impl/write-json.js

@@ -0,0 +1,11 @@
+import { writeFileSync } from "./write-file.js";
+export function writeJsonSync(file, object, options = {}) {
+  const replacer = options.replacer === void 0 ? null : options.replacer;
+  const space = options.space === void 0 ? 2 : options.space;
+  const fileWriteOpts = {};
+  if (options.encoding !== void 0) fileWriteOpts.encoding = options.encoding;
+  if (options.mode !== void 0) fileWriteOpts.mode = options.mode;
+  if (options.flag !== void 0) fileWriteOpts.flag = options.flag.toString();
+  const str = JSON.stringify(object, replacer, space);
+  writeFileSync(file, str, fileWriteOpts);
+}

package/bin/mod.d.ts

@@ -1,2 +1,50 @@
-export * from "./impl/subindex.js";
-export * as default from "./impl/subindex.js";
+import type { Stats } from "node:fs";
+import type { DiveOptions } from "./impl/dive.js";
+import { copySync } from "./impl/copy.js";
+import { createFileSync } from "./impl/create-file.js";
+import { diveSync } from "./impl/dive.js";
+import { emptyDirSync } from "./impl/empty-dir.js";
+import { mkdirsSync } from "./impl/mkdirs.js";
+import { moveSync } from "./impl/move.js";
+import { outputFileSync } from "./impl/output-file.js";
+import { outputJsonSync } from "./impl/output-json.js";
+import { pathExistsSync } from "./impl/path-exists.js";
+import { readFileSync } from "./impl/read-file.js";
+import { readJsonSync, type ReadJsonOptions } from "./impl/read-json.js";
+import { removeSync } from "./impl/remove.js";
+import { writeFileSync } from "./impl/write-file.js";
+import { writeJsonSync } from "./impl/write-json.js";
+declare const readJson: <T>(file: string, options?: BufferEncoding | ReadJsonOptions) => Promise<T>;
+declare const writeJson: (file: string, object: unknown, options?: import("./impl/write-json.js").WriteJsonOptions | undefined) => Promise<void>;
+declare const createFile: (file: string, content?: string | undefined) => Promise<void>;
+declare const writeFile: (file: number | import("fs").PathLike, data: string | NodeJS.ArrayBufferView<ArrayBufferLike>, options?: import("fs").WriteFileOptions | undefined) => Promise<void>;
+declare const readFile: (path: string, options?: BufferEncoding | import("./impl/read-file.js").ReadFileOptions | undefined) => Promise<string | Buffer<ArrayBufferLike>>;
+declare const mkdirs: (dir: string) => Promise<string | undefined>;
+declare const emptyDir: (dir: string) => Promise<void>;
+declare const pathExists: (path: string) => Promise<boolean>;
+declare const copy: (src: string, dest: string, options?: import("./impl/copy.js").CopyOptions | undefined) => Promise<void>;
+declare const move: (src: string, dest: string, options?: import("./impl/move.js").MoveOptions | undefined) => Promise<void>;
+declare const remove: (path: string) => Promise<void>;
+declare const outputJson: (file: string, data: unknown, options?: unknown) => Promise<void>;
+declare const outputFile: (file: string, data: string | Uint8Array<ArrayBufferLike>, options?: unknown) => Promise<void>;
+export declare function dive(directory: string, action: (file: string, stat: Stats) => void | Promise<void>, options?: DiveOptions): Promise<void>;
+export declare function dive(directory: string, options?: DiveOptions): Promise<string[]>;
+declare const mkdirp: (dir: string) => Promise<string | undefined>;
+declare const ensureDir: (dir: string) => Promise<string | undefined>;
+declare const ensureFile: (file: string, content?: string | undefined) => Promise<void>;
+declare const rimraf: (path: string) => Promise<void>;
+declare const ncp: (src: string, dest: string, options?: import("./impl/copy.js").CopyOptions | undefined) => Promise<void>;
+declare const mkdirpSync: typeof mkdirsSync;
+declare const ensureDirSync: typeof mkdirsSync;
+declare const ensureFileSync: typeof createFileSync;
+declare const rimrafSync: typeof removeSync;
+declare const ncpSync: typeof copySync;
+export * from "node:fs";
+export { default } from "node:fs";
+export { readJson, writeJson, createFile, writeFile, readFile, mkdirs, emptyDir, pathExists, copy, move, remove, readJsonSync, writeJsonSync, createFileSync, writeFileSync, readFileSync, mkdirsSync, emptyDirSync, pathExistsSync, copySync, moveSync, removeSync, mkdirp, mkdirpSync, rimraf, rimrafSync, ncp, ncpSync, ensureDir, ensureDirSync, ensureFile, ensureFileSync, outputJson, outputJsonSync, outputFile, outputFileSync, diveSync, };
+export type { CopyOptions } from "./impl/copy.js";
+export type { MoveOptions } from "./impl/move.js";
+export type { ReadFileOptions } from "./impl/read-file.js";
+export type { ReadJsonOptions } from "./impl/read-json.js";
+export type { JsonStringifyOptions } from "./impl/write-json.js";
+export type { WriteJsonOptions } from "./impl/write-json.js";

package/bin/mod.js

@@ -1,2 +1,158 @@
-export * from "./impl/subindex.js";
-export * as default from "./impl/subindex.js";
+import { readdir, stat } from "node:fs/promises";
+import { join as pathJoin } from "node:path";
+import { toAsync } from "./impl/async.js";
+import { copySync } from "./impl/copy.js";
+import { createFileSync } from "./impl/create-file.js";
+import { diveSync } from "./impl/dive.js";
+import { emptyDirSync } from "./impl/empty-dir.js";
+import { mkdirsSync } from "./impl/mkdirs.js";
+import { moveSync } from "./impl/move.js";
+import { outputFileSync } from "./impl/output-file.js";
+import { outputJsonSync } from "./impl/output-json.js";
+import { pathExistsSync } from "./impl/path-exists.js";
+import { readFileSync } from "./impl/read-file.js";
+import { readJsonSync } from "./impl/read-json.js";
+import { removeSync } from "./impl/remove.js";
+import { writeFileSync } from "./impl/write-file.js";
+import { writeJsonSync } from "./impl/write-json.js";
+const readJson = toAsync(readJsonSync);
+const writeJson = toAsync(writeJsonSync);
+const createFile = toAsync(createFileSync);
+const writeFile = toAsync(writeFileSync);
+const readFile = toAsync(readFileSync);
+const mkdirs = toAsync(mkdirsSync);
+const emptyDir = toAsync(emptyDirSync);
+const pathExists = toAsync(pathExistsSync);
+const copy = toAsync(copySync);
+const move = toAsync(moveSync);
+const remove = toAsync(removeSync);
+const outputJson = toAsync(outputJsonSync);
+const outputFile = toAsync(outputFileSync);
+async function* _diveWorker(currentPath, options, currentDepth) {
+  const maxDepth = options.depth ?? Number.POSITIVE_INFINITY;
+  if (currentDepth > maxDepth) {
+    return;
+  }
+  let entries;
+  try {
+    entries = await readdir(currentPath, { withFileTypes: true });
+  } catch (_err) {
+    return;
+  }
+  for (const entry of entries) {
+    const entryPath = pathJoin(currentPath, entry.name);
+    if (!(options.all ?? false) && entry.name.startsWith(".")) {
+      continue;
+    }
+    if (options.ignore) {
+      if (Array.isArray(options.ignore) && options.ignore.some((pattern) => entry.name.includes(pattern))) {
+        continue;
+      }
+      if (options.ignore instanceof RegExp && options.ignore.test(entryPath)) {
+        continue;
+      }
+    }
+    let entryStat;
+    try {
+      entryStat = await stat(entryPath);
+    } catch (_err) {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      if (options.directories ?? false) {
+        yield { file: entryPath, stat: entryStat };
+      }
+      if (options.recursive ?? true) {
+        if (currentDepth < maxDepth) {
+          yield* _diveWorker(entryPath, options, currentDepth + 1);
+        }
+      }
+    } else if (entry.isFile()) {
+      if (options.files ?? true) {
+        yield { file: entryPath, stat: entryStat };
+      }
+    }
+  }
+}
+export async function dive(directory, actionOrOptions, optionsOnly) {
+  let action;
+  let options;
+  if (typeof actionOrOptions === "function") {
+    action = actionOrOptions;
+    options = optionsOnly;
+  } else {
+    options = actionOrOptions;
+  }
+  const currentOptions = {
+    recursive: true,
+    files: true,
+    directories: false,
+    all: false,
+    depth: Number.POSITIVE_INFINITY,
+    ...options
+    // User options override defaults
+  };
+  if (action) {
+    for await (const { file, stat: entryStat } of _diveWorker(directory, currentOptions, 0)) {
+      await action(file, entryStat);
+    }
+    return;
+  } else {
+    const results = [];
+    for await (const { file } of _diveWorker(directory, currentOptions, 0)) {
+      results.push(file);
+    }
+    return results;
+  }
+}
+const mkdirp = mkdirs;
+const ensureDir = mkdirs;
+const ensureFile = createFile;
+const rimraf = remove;
+const ncp = copy;
+const mkdirpSync = mkdirsSync;
+const ensureDirSync = mkdirsSync;
+const ensureFileSync = createFileSync;
+const rimrafSync = removeSync;
+const ncpSync = copySync;
+export * from "node:fs";
+export { default } from "node:fs";
+export {
+  readJson,
+  writeJson,
+  createFile,
+  writeFile,
+  readFile,
+  mkdirs,
+  emptyDir,
+  pathExists,
+  copy,
+  move,
+  remove,
+  readJsonSync,
+  writeJsonSync,
+  createFileSync,
+  writeFileSync,
+  readFileSync,
+  mkdirsSync,
+  emptyDirSync,
+  pathExistsSync,
+  copySync,
+  moveSync,
+  removeSync,
+  mkdirp,
+  mkdirpSync,
+  rimraf,
+  rimrafSync,
+  ncp,
+  ncpSync,
+  ensureDir,
+  ensureDirSync,
+  ensureFile,
+  ensureFileSync,
+  outputJson,
+  outputJsonSync,
+  outputFile,
+  outputFileSync,
+  diveSync
+};