@reliverse/relifso 1.2.5 → 1.2.7

package/bin/impl/mkdirs.d.ts

@@ -1,6 +1,7 @@
-export interface MakeDirectoryOptions {
+interface MakeDirectoryOptions {
     recursive?: boolean;
     mode?: number | string;
 }
 export declare function mkdirsSync(dir: string, options?: MakeDirectoryOptions): string | undefined;
 export declare function mkdirs(dir: string, options?: MakeDirectoryOptions): Promise<string | undefined>;
+export {};

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

@@ -3,7 +3,7 @@
  *
  * @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).
+ * @param options - Options for writing the JSON file (e.g., replacer, spaces).
  */
 export declare function outputJsonSync(file: string, data: unknown, options?: unknown): void;
 /**
@@ -11,6 +11,6 @@ export declare function outputJsonSync(file: string, data: unknown, options?: un
  *
  * @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).
+ * @param options - Options for writing the JSON file (e.g., replacer, spaces).
  */
 export declare function outputJson(file: string, data: unknown, options?: unknown): Promise<void>;

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

@@ -1,14 +1,14 @@
 import type { Mode, OpenMode } from "node:fs";
 export interface JsonStringifyOptions {
     replacer?: (key: string, value: unknown) => unknown | (number | string)[] | null;
-    space?: string | number;
+    spaces?: string | number;
 }
 export interface WriteJsonOptions {
     encoding?: BufferEncoding | null;
     mode?: Mode;
     flag?: OpenMode;
     replacer?: (key: string, value: unknown) => unknown | (number | string)[] | null;
-    space?: string | number;
+    spaces?: string | number;
 }
 /**
  * Synchronously writes an object to a JSON file.

package/bin/impl/write-json.js

@@ -2,21 +2,21 @@ import { writeFileSync } from "./write-file.js";
 import { writeFile } 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 spaces = options.spaces === void 0 ? 2 : options.spaces;
   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);
+  const str = JSON.stringify(object, replacer, spaces);
   writeFileSync(file, str, fileWriteOpts);
 }
 export async function writeJson(file, object, options = {}) {
   const replacer = options.replacer === void 0 ? null : options.replacer;
-  const space = options.space === void 0 ? 2 : options.space;
+  const spaces = options.spaces === void 0 ? 2 : options.spaces;
   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);
+  const str = JSON.stringify(object, replacer, spaces);
   await writeFile(file, str, fileWriteOpts);
 }

package/bin/mod.d.ts

@@ -1,6 +1,7 @@
 import type { Stats } from "node:fs";
-import { accessSync, constants, readdirSync, statSync, copyFileSync } from "node:fs";
-import { readdir as nodeReaddirInternal, stat as nodeStatInternal, readdir, stat, access, copyFile } from "node:fs/promises";
+import { renameSync as nodeRenameSync, unlinkSync as nodeUnlinkSync, accessSync, constants, readdirSync, statSync, copyFileSync, appendFileSync, chmodSync, chownSync, closeSync, createReadStream, createWriteStream, fchmodSync, fchownSync, fdatasyncSync, fstatSync, fsyncSync, ftruncateSync, futimesSync, lchmodSync, lchownSync, linkSync, lstatSync, lutimesSync, mkdtempSync, openSync, opendirSync, readSync, readlinkSync, realpathSync, rmSync, rmdirSync, statfsSync, symlinkSync, truncateSync, unwatchFile, utimesSync, watchFile, writeFileSync, writeSync, readvSync, writevSync } from "node:fs";
+import { readdir as nodeReaddirInternal, stat as nodeStatInternal, rename as nodeRename, unlink as nodeUnlink, access, appendFile, chmod, chown, copyFile, lchmod, lchown, link, lstat, lutimes, mkdtemp, open, opendir, readdir, readlink, realpath, rm, rmdir, stat, statfs, symlink, truncate, utimes, watch, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
 import type { DiveOptions } from "./impl/dive.js";
 import { copy, copySync } from "./impl/copy.js";
 import { createFile, createFileSync } from "./impl/create-file.js";
@@ -14,8 +15,14 @@ import { pathExists, pathExistsSync } from "./impl/path-exists.js";
 import { readFile, readFileSync } from "./impl/read-file.js";
 import { readJson, readJsonSync } from "./impl/read-json.js";
 import { remove, removeSync } from "./impl/remove.js";
-import { writeFile, writeFileSync } from "./impl/write-file.js";
 import { writeJson, writeJsonSync } from "./impl/write-json.js";
+/**
+ * Recursively dives into a directory and yields files and directories.
+ * @param directory - The directory to dive into.
+ * @param action - An optional callback function to execute for each file or directory.
+ * @param options - An optional object containing options for the dive.
+ * @returns A Promise that resolves to an array of file paths if no action is provided, or void if an action is provided.
+ */
 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: typeof mkdirs;
@@ -34,66 +41,173 @@ declare const unlink: typeof remove;
 declare const unlinkSync: typeof removeSync;
 declare const rename: typeof move;
 declare const renameSync: typeof moveSync;
+declare const readJSON: typeof readJson;
+declare const readJSONSync: typeof readJsonSync;
+declare const writeJSON: typeof writeJson;
+declare const writeJSONSync: typeof writeJsonSync;
+declare const outputJSON: typeof outputJson;
+declare const outputJSONSync: typeof outputJsonSync;
+declare const cp: typeof copy;
+declare const cpSync: typeof copySync;
+declare const exists: typeof pathExists;
+declare const existsSync: typeof pathExistsSync;
+declare function readText(filePath: string, options?: BufferEncoding | {
+    encoding?: BufferEncoding | null;
+    flag?: string;
+}): Promise<string>;
+declare function readTextSync(filePath: string, options?: BufferEncoding | {
+    encoding?: BufferEncoding | null;
+    flag?: string;
+}): string;
+declare function readLines(filePath: string, options?: BufferEncoding | {
+    encoding?: BufferEncoding | null;
+    flag?: string;
+}): Promise<any>;
+declare function readLinesSync(filePath: string, options?: BufferEncoding | {
+    encoding?: BufferEncoding | null;
+    flag?: string;
+}): any;
+declare function isDirectory(filePath: string): Promise<boolean>;
+declare function isDirectorySync(filePath: string): boolean;
+declare function isSymlink(filePath: string): Promise<boolean>;
+declare function isSymlinkSync(filePath: string): boolean;
 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";
-export { readJson, writeJson, createFile, writeFile, readFile, mkdirs, emptyDir, pathExists, copy, move, remove, readdir, stat, access, copyFile, readJsonSync, writeJsonSync, createFileSync, writeFileSync, readFileSync, mkdirsSync, emptyDirSync, pathExistsSync, copySync, moveSync, removeSync, readdirSync, statSync, accessSync, constants, copyFileSync, mkdirp, mkdirpSync, rimraf, rimrafSync, ncp, ncpSync, ensureDir, ensureDirSync, ensureFile, ensureFileSync, outputJson, outputJsonSync, outputFile, outputFileSync, diveSync, mkdir, mkdirSync, unlink, unlinkSync, rename, renameSync, };
+export { accessSync, appendFileSync, chmodSync, chownSync, closeSync, copyFileSync, createReadStream, createWriteStream, fchmodSync, fchownSync, fdatasyncSync, fstatSync, fsyncSync, ftruncateSync, futimesSync, lchmodSync, lchownSync, linkSync, lstatSync, lutimesSync, mkdtempSync, openSync, opendirSync, readFileSync, readlinkSync, readSync, readdirSync, realpathSync, nodeRenameSync, rmSync, rmdirSync, statSync, statfsSync, symlinkSync, truncateSync, nodeUnlinkSync, unwatchFile, utimesSync, watchFile, writeFileSync, writeSync, readvSync, writevSync, readJsonSync, writeJsonSync, createFileSync, mkdirsSync, emptyDirSync, pathExistsSync, copySync, moveSync, removeSync, outputJsonSync, outputFileSync, diveSync, cpSync, ensureDirSync, ensureFileSync, existsSync, mkdirpSync, mkdirSync, ncpSync, outputJSONSync, readJSONSync, renameSync, rimrafSync, unlinkSync, writeJSONSync, isDirectorySync, isSymlinkSync, readLinesSync, readTextSync, readJson, writeJson, createFile, mkdirs, emptyDir, pathExists, copy, move, remove, outputJson, outputFile, access, appendFile, chmod, chown, copyFile, lchmod, lchown, link, lstat, lutimes, mkdtemp, open, opendir, readFile, readdir, readlink, realpath, nodeRename, rm, rmdir, stat, statfs, symlink, truncate, nodeUnlink, utimes, watch, writeFile, constants, cp, ensureDir, ensureFile, exists, mkdir, mkdirp, ncp, outputJSON, readJSON, rename, resolve, rimraf, unlink, writeJSON, isDirectory, isSymlink, readLines, readText, };
 declare const fs: {
+    accessSync: typeof accessSync;
+    appendFileSync: typeof appendFileSync;
+    chmodSync: typeof chmodSync;
+    chownSync: typeof chownSync;
+    closeSync: typeof closeSync;
+    copyFileSync: typeof copyFileSync;
+    createReadStream: typeof createReadStream;
+    createWriteStream: typeof createWriteStream;
+    fchmodSync: typeof fchmodSync;
+    fchownSync: typeof fchownSync;
+    fdatasyncSync: typeof fdatasyncSync;
+    fstatSync: typeof fstatSync;
+    fsyncSync: typeof fsyncSync;
+    ftruncateSync: typeof ftruncateSync;
+    futimesSync: typeof futimesSync;
+    lchmodSync: typeof lchmodSync;
+    lchownSync: typeof lchownSync;
+    linkSync: typeof linkSync;
+    lstatSync: import("fs").StatSyncFn;
+    lutimesSync: typeof lutimesSync;
+    mkdtempSync: typeof mkdtempSync;
+    openSync: typeof openSync;
+    opendirSync: typeof opendirSync;
+    readFileSync: typeof readFileSync;
+    readlinkSync: typeof readlinkSync;
+    readSync: typeof readSync;
+    readdirSync: typeof readdirSync;
+    realpathSync: typeof realpathSync;
+    nodeRenameSync: typeof nodeRenameSync;
+    rmSync: typeof rmSync;
+    rmdirSync: typeof rmdirSync;
+    statSync: import("fs").StatSyncFn;
+    statfsSync: typeof statfsSync;
+    symlinkSync: typeof symlinkSync;
+    truncateSync: typeof truncateSync;
+    nodeUnlinkSync: typeof nodeUnlinkSync;
+    unwatchFile: typeof unwatchFile;
+    utimesSync: typeof utimesSync;
+    watchFile: typeof watchFile;
+    writeFileSync: typeof writeFileSync;
+    writeSync: typeof writeSync;
+    readvSync: typeof readvSync;
+    writevSync: typeof writevSync;
+    readJsonSync: typeof readJsonSync;
+    writeJsonSync: typeof writeJsonSync;
+    createFileSync: typeof createFileSync;
+    mkdirsSync: typeof mkdirsSync;
+    emptyDirSync: typeof emptyDirSync;
+    pathExistsSync: typeof pathExistsSync;
+    copySync: typeof copySync;
+    moveSync: typeof moveSync;
+    removeSync: typeof removeSync;
+    outputJsonSync: typeof outputJsonSync;
+    outputFileSync: typeof outputFileSync;
+    diveSync: typeof diveSync;
+    cpSync: typeof copySync;
+    ensureDirSync: typeof mkdirsSync;
+    ensureFileSync: typeof createFileSync;
+    existsSync: typeof pathExistsSync;
+    mkdirpSync: typeof mkdirsSync;
+    mkdirSync: typeof mkdirsSync;
+    ncpSync: typeof copySync;
+    outputJSONSync: typeof outputJsonSync;
+    readJSONSync: typeof readJsonSync;
+    renameSync: typeof moveSync;
+    rimrafSync: typeof removeSync;
+    unlinkSync: typeof removeSync;
+    writeJSONSync: typeof writeJsonSync;
+    isDirectorySync: typeof isDirectorySync;
+    isSymlinkSync: typeof isSymlinkSync;
+    readLinesSync: typeof readLinesSync;
+    readTextSync: typeof readTextSync;
     readJson: typeof readJson;
     writeJson: typeof writeJson;
     createFile: typeof createFile;
-    writeFile: typeof writeFile;
-    readFile: typeof readFile;
     mkdirs: typeof mkdirs;
     emptyDir: typeof emptyDir;
     pathExists: typeof pathExists;
     copy: typeof copy;
     move: typeof move;
     remove: typeof remove;
-    readdir: typeof nodeReaddirInternal;
-    stat: typeof nodeStatInternal;
+    outputJson: typeof outputJson;
+    outputFile: typeof outputFile;
     access: typeof access;
+    appendFile: typeof appendFile;
+    chmod: typeof chmod;
+    chown: typeof chown;
     copyFile: typeof copyFile;
-    readJsonSync: typeof readJsonSync;
-    writeJsonSync: typeof writeJsonSync;
-    createFileSync: typeof createFileSync;
-    writeFileSync: typeof writeFileSync;
-    readFileSync: typeof readFileSync;
-    mkdirsSync: typeof mkdirsSync;
-    emptyDirSync: typeof emptyDirSync;
-    pathExistsSync: typeof pathExistsSync;
-    copySync: typeof copySync;
-    moveSync: typeof moveSync;
-    removeSync: typeof removeSync;
-    readdirSync: typeof readdirSync;
-    statSync: import("fs").StatSyncFn;
-    accessSync: typeof accessSync;
+    lchmod: typeof lchmod;
+    lchown: typeof lchown;
+    link: typeof link;
+    lstat: typeof lstat;
+    lutimes: typeof lutimes;
+    mkdtemp: typeof mkdtemp;
+    open: typeof open;
+    opendir: typeof opendir;
+    readFile: typeof readFile;
+    readdir: typeof nodeReaddirInternal;
+    readlink: typeof readlink;
+    realpath: typeof realpath;
+    nodeRename: typeof nodeRename;
+    rm: typeof rm;
+    rmdir: typeof rmdir;
+    stat: typeof nodeStatInternal;
+    statfs: typeof statfs;
+    symlink: typeof symlink;
+    truncate: typeof truncate;
+    nodeUnlink: typeof nodeUnlink;
+    utimes: typeof utimes;
+    watch: typeof watch;
+    writeFile: typeof writeFile;
     constants: typeof constants;
-    copyFileSync: typeof copyFileSync;
-    mkdirp: typeof mkdirs;
-    mkdirpSync: typeof mkdirsSync;
-    rimraf: typeof remove;
-    rimrafSync: typeof removeSync;
-    ncp: typeof copy;
-    ncpSync: typeof copySync;
+    cp: typeof copy;
     ensureDir: typeof mkdirs;
-    ensureDirSync: typeof mkdirsSync;
     ensureFile: typeof createFile;
-    ensureFileSync: typeof createFileSync;
-    outputJson: typeof outputJson;
-    outputJsonSync: typeof outputJsonSync;
-    outputFile: typeof outputFile;
-    outputFileSync: typeof outputFileSync;
-    dive: typeof dive;
-    diveSync: typeof diveSync;
+    exists: typeof pathExists;
     mkdir: typeof mkdirs;
-    mkdirSync: typeof mkdirsSync;
-    unlink: typeof remove;
-    unlinkSync: typeof removeSync;
+    mkdirp: typeof mkdirs;
+    ncp: typeof copy;
+    outputJSON: typeof outputJson;
+    readJSON: typeof readJson;
     rename: typeof move;
-    renameSync: typeof moveSync;
+    resolve: (...paths: string[]) => string;
+    rimraf: typeof remove;
+    unlink: typeof remove;
+    writeJSON: typeof writeJson;
+    isDirectory: typeof isDirectory;
+    isSymlink: typeof isSymlink;
+    readLines: typeof readLines;
+    readText: typeof readText;
 };
 export default fs;

package/bin/mod.js

@@ -1,13 +1,80 @@
-import { accessSync, constants, readdirSync, statSync, copyFileSync } from "node:fs";
+import {
+  renameSync as nodeRenameSync,
+  unlinkSync as nodeUnlinkSync,
+  accessSync,
+  constants,
+  readdirSync,
+  statSync,
+  copyFileSync,
+  appendFileSync,
+  chmodSync,
+  chownSync,
+  closeSync,
+  createReadStream,
+  createWriteStream,
+  fchmodSync,
+  fchownSync,
+  fdatasyncSync,
+  fstatSync,
+  fsyncSync,
+  ftruncateSync,
+  futimesSync,
+  lchmodSync,
+  lchownSync,
+  linkSync,
+  lstatSync,
+  lutimesSync,
+  mkdtempSync,
+  openSync,
+  opendirSync,
+  readSync,
+  readlinkSync,
+  realpathSync,
+  rmSync,
+  rmdirSync,
+  statfsSync,
+  symlinkSync,
+  truncateSync,
+  unwatchFile,
+  utimesSync,
+  watchFile,
+  writeFileSync,
+  writeSync,
+  readvSync,
+  writevSync
+} from "node:fs";
 import {
   readdir as nodeReaddirInternal,
   stat as nodeStatInternal,
+  rename as nodeRename,
+  unlink as nodeUnlink,
+  access,
+  appendFile,
+  chmod,
+  chown,
+  copyFile,
+  lchmod,
+  lchown,
+  link,
+  lstat,
+  lutimes,
+  mkdtemp,
+  open,
+  opendir,
   readdir,
+  readlink,
+  realpath,
+  rm,
+  rmdir,
   stat,
-  access,
-  copyFile
+  statfs,
+  symlink,
+  truncate,
+  utimes,
+  watch,
+  writeFile
 } from "node:fs/promises";
-import { join as pathJoin } from "node:path";
+import { join as pathJoin, resolve } from "node:path";
 import { copy, copySync } from "./impl/copy.js";
 import { createFile, createFileSync } from "./impl/create-file.js";
 import { diveSync } from "./impl/dive.js";
@@ -20,7 +87,6 @@ import { pathExists, pathExistsSync } from "./impl/path-exists.js";
 import { readFile, readFileSync } from "./impl/read-file.js";
 import { readJson, readJsonSync } from "./impl/read-json.js";
 import { remove, removeSync } from "./impl/remove.js";
-import { writeFile, writeFileSync } from "./impl/write-file.js";
 import { writeJson, writeJsonSync } from "./impl/write-json.js";
 async function* _diveWorker(currentPath, options, currentDepth) {
   const maxDepth = options.depth ?? Number.POSITIVE_INFINITY;
@@ -115,116 +181,345 @@ const unlink = remove;
 const unlinkSync = removeSync;
 const rename = move;
 const renameSync = moveSync;
+const readJSON = readJson;
+const readJSONSync = readJsonSync;
+const writeJSON = writeJson;
+const writeJSONSync = writeJsonSync;
+const outputJSON = outputJson;
+const outputJSONSync = outputJsonSync;
+const cp = copy;
+const cpSync = copySync;
+const exists = pathExists;
+const existsSync = pathExistsSync;
+async function readText(filePath, options = "utf8") {
+  return readFile(filePath, options);
+}
+function readTextSync(filePath, options = "utf8") {
+  return readFileSync(filePath, options);
+}
+async function readLines(filePath, options = { encoding: "utf8" }) {
+  const effectiveOptions = typeof options === "string" ? { encoding: options } : options;
+  const contentBuffer = await readFile(filePath, { ...effectiveOptions, encoding: null });
+  return contentBuffer.split(/\r?\n/);
+}
+function readLinesSync(filePath, options = { encoding: "utf8" }) {
+  const effectiveOptions = typeof options === "string" ? { encoding: options } : options;
+  const contentBuffer = readFileSync(filePath, { ...effectiveOptions, encoding: null });
+  const content = contentBuffer;
+  return content.split(/\r?\n/);
+}
+async function isDirectory(filePath) {
+  try {
+    const stats = await stat(filePath);
+    return stats.isDirectory();
+  } catch (error) {
+    if (error.code === "ENOENT" || error.code === "ENOTDIR") {
+      return false;
+    }
+    throw error;
+  }
+}
+function isDirectorySync(filePath) {
+  try {
+    const stats = statSync(filePath);
+    return stats.isDirectory();
+  } catch (error) {
+    if (error.code === "ENOENT" || error.code === "ENOTDIR") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function isSymlink(filePath) {
+  try {
+    const stats = await lstat(filePath);
+    return stats.isSymbolicLink();
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+function isSymlinkSync(filePath) {
+  try {
+    const stats = lstatSync(filePath);
+    return stats.isSymbolicLink();
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
 export {
+  accessSync,
+  appendFileSync,
+  chmodSync,
+  chownSync,
+  closeSync,
+  copyFileSync,
+  createReadStream,
+  createWriteStream,
+  fchmodSync,
+  fchownSync,
+  fdatasyncSync,
+  fstatSync,
+  fsyncSync,
+  ftruncateSync,
+  futimesSync,
+  lchmodSync,
+  lchownSync,
+  linkSync,
+  lstatSync,
+  lutimesSync,
+  mkdtempSync,
+  openSync,
+  opendirSync,
+  readFileSync,
+  readlinkSync,
+  readSync,
+  readdirSync,
+  realpathSync,
+  nodeRenameSync,
+  rmSync,
+  rmdirSync,
+  statSync,
+  statfsSync,
+  symlinkSync,
+  truncateSync,
+  nodeUnlinkSync,
+  unwatchFile,
+  utimesSync,
+  watchFile,
+  writeFileSync,
+  writeSync,
+  readvSync,
+  writevSync,
+  readJsonSync,
+  writeJsonSync,
+  createFileSync,
+  mkdirsSync,
+  emptyDirSync,
+  pathExistsSync,
+  copySync,
+  moveSync,
+  removeSync,
+  outputJsonSync,
+  outputFileSync,
+  diveSync,
+  cpSync,
+  ensureDirSync,
+  ensureFileSync,
+  existsSync,
+  mkdirpSync,
+  mkdirSync,
+  ncpSync,
+  outputJSONSync,
+  readJSONSync,
+  renameSync,
+  rimrafSync,
+  unlinkSync,
+  writeJSONSync,
+  isDirectorySync,
+  isSymlinkSync,
+  readLinesSync,
+  readTextSync,
   readJson,
   writeJson,
   createFile,
-  writeFile,
-  readFile,
   mkdirs,
   emptyDir,
   pathExists,
   copy,
   move,
   remove,
-  readdir,
-  stat,
+  outputJson,
+  outputFile,
   access,
+  appendFile,
+  chmod,
+  chown,
   copyFile,
+  lchmod,
+  lchown,
+  link,
+  lstat,
+  lutimes,
+  mkdtemp,
+  open,
+  opendir,
+  readFile,
+  readdir,
+  readlink,
+  realpath,
+  nodeRename,
+  rm,
+  rmdir,
+  stat,
+  statfs,
+  symlink,
+  truncate,
+  nodeUnlink,
+  utimes,
+  watch,
+  writeFile,
+  constants,
+  cp,
+  ensureDir,
+  ensureFile,
+  exists,
+  mkdir,
+  mkdirp,
+  ncp,
+  outputJSON,
+  readJSON,
+  rename,
+  resolve,
+  rimraf,
+  unlink,
+  writeJSON,
+  isDirectory,
+  isSymlink,
+  readLines,
+  readText
+};
+const fs = {
+  // Sync direct exports (node:fs)
+  accessSync,
+  appendFileSync,
+  chmodSync,
+  chownSync,
+  closeSync,
+  copyFileSync,
+  createReadStream,
+  createWriteStream,
+  fchmodSync,
+  fchownSync,
+  fdatasyncSync,
+  fstatSync,
+  fsyncSync,
+  ftruncateSync,
+  futimesSync,
+  lchmodSync,
+  lchownSync,
+  linkSync,
+  lstatSync,
+  lutimesSync,
+  mkdtempSync,
+  openSync,
+  opendirSync,
+  readFileSync,
+  readlinkSync,
+  readSync,
+  readdirSync,
+  realpathSync,
+  nodeRenameSync,
+  rmSync,
+  rmdirSync,
+  statSync,
+  statfsSync,
+  symlinkSync,
+  truncateSync,
+  nodeUnlinkSync,
+  unwatchFile,
+  utimesSync,
+  watchFile,
+  writeFileSync,
+  writeSync,
+  readvSync,
+  writevSync,
   readJsonSync,
   writeJsonSync,
   createFileSync,
-  writeFileSync,
-  readFileSync,
   mkdirsSync,
   emptyDirSync,
   pathExistsSync,
   copySync,
   moveSync,
   removeSync,
-  readdirSync,
-  statSync,
-  accessSync,
-  constants,
-  copyFileSync,
-  mkdirp,
-  mkdirpSync,
-  rimraf,
-  rimrafSync,
-  ncp,
-  ncpSync,
-  ensureDir,
-  ensureDirSync,
-  ensureFile,
-  ensureFileSync,
-  outputJson,
   outputJsonSync,
-  outputFile,
   outputFileSync,
   diveSync,
-  mkdir,
+  // Sync aliases
+  cpSync,
+  ensureDirSync,
+  ensureFileSync,
+  existsSync,
+  mkdirpSync,
   mkdirSync,
-  unlink,
+  ncpSync,
+  outputJSONSync,
+  readJSONSync,
+  renameSync,
+  rimrafSync,
   unlinkSync,
-  rename,
-  renameSync
-};
-const fs = {
-  // async methods
+  writeJSONSync,
+  // Simple sync custom implementations
+  isDirectorySync,
+  isSymlinkSync,
+  readLinesSync,
+  readTextSync,
+  // Async direct exports (node:fs/promises)
   readJson,
   writeJson,
   createFile,
-  writeFile,
-  readFile,
   mkdirs,
   emptyDir,
   pathExists,
   copy,
   move,
   remove,
-  readdir,
-  stat,
+  outputJson,
+  outputFile,
   access,
+  appendFile,
+  chmod,
+  chown,
   copyFile,
-  // sync methods
-  readJsonSync,
-  writeJsonSync,
-  createFileSync,
-  writeFileSync,
-  readFileSync,
-  mkdirsSync,
-  emptyDirSync,
-  pathExistsSync,
-  copySync,
-  moveSync,
-  removeSync,
-  readdirSync,
-  statSync,
-  accessSync,
+  lchmod,
+  lchown,
+  link,
+  lstat,
+  lutimes,
+  mkdtemp,
+  open,
+  opendir,
+  readFile,
+  readdir,
+  readlink,
+  realpath,
+  nodeRename,
+  rm,
+  rmdir,
+  stat,
+  statfs,
+  symlink,
+  truncate,
+  nodeUnlink,
+  utimes,
+  watch,
+  writeFile,
+  // Async aliases
   constants,
-  copyFileSync,
-  // alias
-  mkdirp,
-  mkdirpSync,
-  rimraf,
-  rimrafSync,
-  ncp,
-  ncpSync,
+  cp,
   ensureDir,
-  ensureDirSync,
   ensureFile,
-  ensureFileSync,
-  outputJson,
-  outputJsonSync,
-  outputFile,
-  outputFileSync,
-  dive,
-  diveSync,
+  exists,
   mkdir,
-  mkdirSync,
-  unlink,
-  unlinkSync,
+  mkdirp,
+  ncp,
+  outputJSON,
+  readJSON,
   rename,
-  renameSync
+  resolve,
+  rimraf,
+  unlink,
+  writeJSON,
+  // Simple async custom implementations
+  isDirectory,
+  isSymlink,
+  readLines,
+  readText
 };
 export default fs;

package/package.json

@@ -5,7 +5,7 @@
   "license": "MIT",
   "name": "@reliverse/relifso",
   "type": "module",
-  "version": "1.2.5",
+  "version": "1.2.7",
   "keywords": [
     "fs",
     "file",
@@ -70,7 +70,7 @@
     "klaw-sync": "^7.0.0",
     "knip": "^5.56.0",
     "minimist": "^1.2.8",
-    "mocha": "^11.3.0",
+    "mocha": "^11.4.0",
     "nyc": "^17.1.0",
     "proxyquire": "^2.1.3",
     "read-dir-files": "^0.1.1",