@reliverse/relifso 1.1.2 → 1.2.0

package/bin/impl/lib/copy/copy-sync.d.ts

@@ -1,25 +0,0 @@
-export interface CopyOptions {
-    /** Overwrite destination if it exists (falls back to `clobber`) */
-    overwrite?: boolean;
-    /** Throw if destination exists and won’t be overwritten                */
-    errorOnExist?: boolean;
-    /** Preserve atime / mtime – ⚠︎ slow on >4 GiB files on 32‑bit Node      */
-    preserveTimestamps?: boolean;
-    /** Follow symlinks instead of copying the link itself                   */
-    dereference?: boolean;
-    /** Filter callback: return false to skip a file/directory               */
-    filter?: (src: string, dest: string) => boolean;
-    /** Explicit chmod bits for new files/dirs                               */
-    mode?: number;
-    /** *Deprecated* in fs‑extra – kept for BC; default `true`               */
-    clobber?: boolean;
-}
-/**
- * Synchronous, fully‑typed variant of `fs‑extra`’s `copySync`.
- *
- * ```ts
- * copySync('src', 'dest', { overwrite: false, filter: /\\.png$/i.test });
- * ```
- */
-export declare function copySync(src: string, dest: string, options?: CopyOptions | ((src: string, dest: string) => boolean)): void;
-export default copySync;

package/bin/impl/lib/copy/copy-sync.js

@@ -1,119 +0,0 @@
-import {
-  existsSync,
-  statSync as _statSync,
-  lstatSync,
-  unlinkSync,
-  copyFileSync,
-  chmodSync,
-  mkdirSync,
-  readdirSync,
-  readlinkSync,
-  symlinkSync
-} from "graceful-fs";
-import { dirname, join, resolve } from "node:path";
-import { mkdirsSync } from "../mkdirs/index.js";
-import {
-  checkParentPathsSync,
-  checkPathsSync,
-  isSrcSubdir
-} from "../util/stat.js";
-import { utimesMillisSync } from "../util/utimes.js";
-export function copySync(src, dest, options = {}) {
-  const opts = typeof options === "function" ? { filter: options } : { ...options };
-  const clobber = "clobber" in opts ? !!opts.clobber : true;
-  opts.overwrite = opts.overwrite ?? clobber;
-  if (opts.preserveTimestamps && process.arch === "ia32") {
-    process.emitWarning(
-      "Using preserveTimestamps on 32-bit Node is discouraged - it may overflow",
-      { code: "FS_EXTRA_WARN0002", type: "Warning" }
-    );
-  }
-  const { srcStat, destStat } = checkPathsSync(src, dest, "copy", opts);
-  checkParentPathsSync(src, srcStat, dest, "copy");
-  if (opts.filter && !opts.filter(src, dest)) return;
-  const destParent = dirname(dest);
-  if (!existsSync(destParent)) mkdirsSync(destParent, {});
-  processEntry(destStat, src, dest, opts);
-}
-export default copySync;
-const processEntry = (destStat, src, dest, opts) => {
-  const statSync = opts.dereference ? _statSync : lstatSync;
-  const srcStat = statSync(src);
-  if (srcStat.isDirectory()) onDir(srcStat, destStat, src, dest, opts);
-  else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice())
-    onFile(srcStat, destStat, src, dest, opts);
-  else if (srcStat.isSymbolicLink()) onLink(destStat, src, dest, opts);
-  else if (srcStat.isSocket())
-    throw new Error(`Cannot copy a socket file: ${src}`);
-  else if (srcStat.isFIFO())
-    throw new Error(`Cannot copy a FIFO pipe: ${src}`);
-  else throw new Error(`Unknown file type: ${src}`);
-};
-const onFile = (srcStat, destStat, src, dest, opts) => {
-  if (!destStat) return copyFile(srcStat.mode, src, dest, opts);
-  if (opts.overwrite) {
-    unlinkSync(dest);
-    return copyFile(srcStat.mode, src, dest, opts);
-  }
-  if (opts.errorOnExist) {
-    throw new Error(`'${String(dest)}' already exists`);
-  }
-};
-const copyFile = (srcMode, src, dest, opts) => {
-  copyFileSync(src, dest);
-  if (opts.preserveTimestamps) handleTimestamps(srcMode, src, dest);
-  chmodSync(dest, srcMode);
-};
-const handleTimestamps = (srcMode, src, dest) => {
-  if ((srcMode & 128) === 0) chmodSync(dest, srcMode | 128);
-  const { atime, mtime } = _statSync(src);
-  utimesMillisSync(dest, atime, mtime);
-};
-const onDir = (srcStat, destStat, src, dest, opts) => {
-  if (!destStat) {
-    mkdirSync(dest);
-    chmodSync(dest, srcStat.mode);
-  }
-  copyDir(src, dest, opts);
-};
-const copyDir = (src, dest, opts) => {
-  for (const item of readdirSync(src)) {
-    const srcItem = join(src, item);
-    const destItem = join(dest, item);
-    if (opts.filter && !opts.filter(srcItem, destItem)) continue;
-    const { destStat } = checkPathsSync(srcItem, destItem, "copy", opts);
-    processEntry(destStat, srcItem, destItem, opts);
-  }
-};
-const onLink = (destStat, src, dest, opts) => {
-  let resolvedSrc = readlinkSync(src);
-  if (opts.dereference) resolvedSrc = resolve(process.cwd(), resolvedSrc);
-  if (!destStat) {
-    symlinkSync(resolvedSrc, dest);
-    return;
-  }
-  let resolvedDest;
-  try {
-    resolvedDest = readlinkSync(dest);
-  } catch (err) {
-    const e = err;
-    if (e.code === "EINVAL" || e.code === "UNKNOWN") {
-      symlinkSync(resolvedSrc, dest);
-      return;
-    }
-    throw err;
-  }
-  if (opts.dereference) resolvedDest = resolve(process.cwd(), resolvedDest);
-  if (isSrcSubdir(resolvedSrc, resolvedDest)) {
-    throw new Error(
-      `Cannot copy '${resolvedSrc}' into its own subdirectory '${resolvedDest}'.`
-    );
-  }
-  if (isSrcSubdir(resolvedDest, resolvedSrc)) {
-    throw new Error(
-      `Cannot overwrite '${resolvedDest}' with its parent '${resolvedSrc}'.`
-    );
-  }
-  unlinkSync(dest);
-  symlinkSync(resolvedSrc, dest);
-};

package/bin/impl/lib/copy/copy.d.ts

@@ -1,7 +0,0 @@
-/**
- * @param {string} src
- * @param {string} dest
- * @param {import('fs-extra').CopyOptions & { clobber?: boolean, overwrite?: boolean }} [opts]
- */
-declare const _default: (...args: any[]) => Promise<any> | void;
-export default _default;

package/bin/impl/lib/copy/copy.js

@@ -1,144 +0,0 @@
-import { dirname, join, resolve } from "node:path";
-import { fromPromise } from "universalify";
-import { exists as pathExists } from "../../fs/exists.js";
-import {
-  stat as _stat,
-  lstat,
-  unlink,
-  copyFile as _copyFile,
-  chmod,
-  mkdir,
-  readdir,
-  readlink,
-  symlink
-} from "../../fs/index.js";
-import { mkdirs } from "../mkdirs/index.js";
-import {
-  checkPaths,
-  checkParentPaths,
-  isSrcSubdir
-} from "../util/stat.js";
-import { utimesMillis } from "../util/utimes.js";
-export default fromPromise(async function copy(src, dest, opts = {}) {
-  if (typeof opts === "function") {
-    opts = { filter: opts };
-  }
-  opts.clobber = "clobber" in opts ? !!opts.clobber : true;
-  opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
-  if (opts.preserveTimestamps && process.arch === "ia32") {
-    process.emitWarning(
-      "Using the preserveTimestamps option in 32-bit node is not recommended;\n\n	see https://github.com/jprichardson/node-fs-extra/issues/269",
-      "Warning",
-      "fs-extra-WARN0001"
-    );
-  }
-  const { srcStat, destStat } = await checkPaths(src, dest, "copy", opts);
-  await checkParentPaths(src, srcStat, dest, "copy");
-  const include = await runFilter(src, dest, opts);
-  if (!include) return;
-  const destParent = dirname(dest);
-  const dirExists = await pathExists(destParent);
-  if (!dirExists) {
-    await mkdirs(destParent);
-  }
-  await getStatsAndPerformCopy(destStat, src, dest, opts);
-});
-async function runFilter(src, dest, opts) {
-  if (!opts.filter) return true;
-  return opts.filter(src, dest);
-}
-async function getStatsAndPerformCopy(destStat, src, dest, opts) {
-  const statFn = opts.dereference ? _stat : lstat;
-  const srcStat = await statFn(src);
-  if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
-  if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice())
-    return onFile(srcStat, destStat, src, dest, opts);
-  if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts);
-  if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`);
-  if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`);
-  throw new Error(`Unknown file: ${src}`);
-}
-async function onFile(srcStat, destStat, src, dest, opts) {
-  if (!destStat) return copyFile(srcStat, src, dest, opts);
-  if (opts.overwrite) {
-    await unlink(dest);
-    return copyFile(srcStat, src, dest, opts);
-  }
-  if (opts.errorOnExist) {
-    throw new Error(`'${dest}' already exists`);
-  }
-}
-async function copyFile(srcStat, src, dest, opts) {
-  await _copyFile(src, dest);
-  if (opts.preserveTimestamps) {
-    if (fileIsNotWritable(srcStat.mode)) {
-      await makeFileWritable(dest, srcStat.mode);
-    }
-    const updatedSrcStat = await _stat(src);
-    await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
-  }
-  return chmod(dest, srcStat.mode);
-}
-function fileIsNotWritable(srcMode) {
-  return (srcMode & 128) === 0;
-}
-function makeFileWritable(dest, srcMode) {
-  return chmod(dest, srcMode | 128);
-}
-async function onDir(srcStat, destStat, src, dest, opts) {
-  if (!destStat) {
-    await mkdir(dest);
-  }
-  const items = await readdir(src);
-  await Promise.all(
-    items.map(async (item) => {
-      const srcItem = join(src, item);
-      const destItem = join(dest, item);
-      const include = await runFilter(srcItem, destItem, opts);
-      if (!include) return;
-      const { destStat: destStat2 } = await checkPaths(srcItem, destItem, "copy", opts);
-      return getStatsAndPerformCopy(destStat2, srcItem, destItem, opts);
-    })
-  );
-  if (!destStat) {
-    await chmod(dest, srcStat.mode);
-  }
-}
-async function onLink(destStat, src, dest, opts) {
-  let resolvedSrc = await readlink(src);
-  if (opts.dereference) {
-    resolvedSrc = resolve(process.cwd(), resolvedSrc);
-  }
-  if (!destStat) {
-    return symlink(resolvedSrc, dest);
-  }
-  let resolvedDest = null;
-  try {
-    resolvedDest = await readlink(dest);
-  } catch (e) {
-    if (
-      // @ts-expect-error TODO: fix ts
-      /** @type {NodeJS.ErrnoException} */
-      e.code === "EINVAL" || // @ts-expect-error TODO: fix ts
-      /** @type {NodeJS.ErrnoException} */
-      e.code === "UNKNOWN"
-    )
-      return symlink(resolvedSrc, dest);
-    throw e;
-  }
-  if (opts.dereference) {
-    resolvedDest = resolve(process.cwd(), resolvedDest);
-  }
-  if (isSrcSubdir(resolvedSrc, resolvedDest)) {
-    throw new Error(
-      `Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`
-    );
-  }
-  if (isSrcSubdir(resolvedDest, resolvedSrc)) {
-    throw new Error(
-      `Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`
-    );
-  }
-  await unlink(dest);
-  return symlink(resolvedSrc, dest);
-}

package/bin/impl/lib/copy/index.d.ts

@@ -1,5 +0,0 @@
-export { copy, copySync } from "fs-extra";
-
-interface CopyOptions {
-  clobber?: boolean;
-}

package/bin/impl/lib/copy/index.js

@@ -1,2 +0,0 @@
-export { default as copy } from "./copy.js";
-export { default as copySync } from "./copy-sync.js";

package/bin/impl/lib/empty/index.d.ts

@@ -1 +0,0 @@
-export { emptyDir, emptyDirSync } from "fs-extra";

package/bin/impl/lib/empty/index.js

@@ -1,29 +0,0 @@
-import { join } from "node:path";
-import { fromPromise as u } from "universalify";
-import { readdir, readdirSync } from "../../fs/index.js";
-import { mkdirs, mkdirsSync } from "../mkdirs/index.js";
-import {
-  remove as _remove,
-  removeSync
-} from "../remove/index.js";
-export const emptyDir = u(async function emptyDir2(dir) {
-  let items;
-  try {
-    items = await readdir(dir);
-  } catch {
-    return mkdirs(dir);
-  }
-  return Promise.all(items.map((item) => _remove(join(dir, item))));
-});
-export function emptyDirSync(dir) {
-  let items;
-  try {
-    items = readdirSync(dir);
-  } catch {
-    return mkdirsSync(dir);
-  }
-  for (let item of items) {
-    item = join(dir, item);
-    removeSync(item);
-  }
-}

package/bin/impl/lib/ensure/file.d.ts

@@ -1,2 +0,0 @@
-export declare const createFile: (...args: any[]) => Promise<any> | void;
-export declare function createFileSync(file: any): void;

package/bin/impl/lib/ensure/file.js

@@ -1,56 +0,0 @@
-import { dirname } from "node:path";
-import { fromPromise } from "universalify";
-import {
-  writeFile,
-  stat,
-  readdir,
-  statSync,
-  readdirSync,
-  writeFileSync
-} from "../../fs/index.js";
-import { mkdirs, mkdirsSync } from "../mkdirs/index.js";
-async function _createFile(file) {
-  let stats;
-  try {
-    stats = await stat(file);
-  } catch {
-  }
-  if (stats?.isFile()) return;
-  const dir = dirname(file);
-  let dirStats = null;
-  try {
-    dirStats = await stat(dir);
-  } catch (err) {
-    if (err.code === "ENOENT") {
-      await mkdirs(dir);
-      await writeFile(file, "");
-      return;
-    } else {
-      throw err;
-    }
-  }
-  if (dirStats.isDirectory()) {
-    await writeFile(file, "");
-  } else {
-    await readdir(dir);
-  }
-}
-export const createFile = fromPromise(_createFile);
-export function createFileSync(file) {
-  let stats;
-  try {
-    stats = statSync(file);
-  } catch {
-  }
-  if (stats?.isFile()) return;
-  const dir = dirname(file);
-  try {
-    if (!statSync(dir).isDirectory()) {
-      readdirSync(dir);
-    }
-  } catch (err) {
-    if (err && err.code === "ENOENT") mkdirsSync(dir);
-    else throw err;
-  }
-  writeFileSync(file, "");
-}

package/bin/impl/lib/ensure/index.d.ts

@@ -1,8 +0,0 @@
-export {
-  ensureFile,
-  ensureFileSync,
-  ensureLink,
-  ensureLinkSync,
-  ensureSymlink,
-  ensureSymlinkSync,
-} from "fs-extra";

package/bin/impl/lib/ensure/index.js

@@ -1,12 +0,0 @@
-export {
-  createFile as ensureFile,
-  createFileSync as ensureFileSync
-} from "./file.js";
-export {
-  createLink as ensureLink,
-  createLinkSync as ensureLinkSync
-} from "./link.js";
-export {
-  createSymlink as ensureSymlink,
-  createSymlinkSync as ensureSymlinkSync
-} from "./symlink.js";

package/bin/impl/lib/ensure/link.d.ts

@@ -1,2 +0,0 @@
-export declare const createLink: (...args: any[]) => Promise<any> | void;
-export declare function createLinkSync(srcpath: any, dstpath: any): any;

package/bin/impl/lib/ensure/link.js

@@ -1,53 +0,0 @@
-import { dirname } from "node:path";
-import { fromPromise } from "universalify";
-import { exists as pathExists } from "../../fs/exists.js";
-import {
-  link,
-  lstat,
-  lstatSync,
-  existsSync,
-  linkSync
-} from "../../fs/index.js";
-import { mkdirs, mkdirsSync } from "../mkdirs/index.js";
-import { areIdentical } from "../util/stat.js";
-async function _createLink(srcpath, dstpath) {
-  let dstStat;
-  try {
-    dstStat = await lstat(dstpath);
-  } catch {
-  }
-  let srcStat;
-  try {
-    srcStat = await lstat(srcpath);
-  } catch (err) {
-    err.message = err.message.replace("lstat", "ensureLink");
-    throw err;
-  }
-  if (dstStat && areIdentical(srcStat, dstStat)) return;
-  const dir = dirname(dstpath);
-  const dirExists = await pathExists(dir);
-  if (!dirExists) {
-    await mkdirs(dir);
-  }
-  await link(srcpath, dstpath);
-}
-export const createLink = fromPromise(_createLink);
-export function createLinkSync(srcpath, dstpath) {
-  let dstStat;
-  try {
-    dstStat = lstatSync(dstpath);
-  } catch {
-  }
-  try {
-    const srcStat = lstatSync(srcpath);
-    if (dstStat && areIdentical(srcStat, dstStat)) return;
-  } catch (err) {
-    err.message = err.message.replace("lstat", "ensureLink");
-    throw err;
-  }
-  const dir = dirname(dstpath);
-  const dirExists = existsSync(dir);
-  if (dirExists) return linkSync(srcpath, dstpath);
-  mkdirsSync(dir);
-  return linkSync(srcpath, dstpath);
-}

package/bin/impl/lib/ensure/symlink-paths.d.ts

@@ -1,5 +0,0 @@
-export declare const symlinkPaths: (...args: any[]) => Promise<any> | void;
-export declare function symlinkPathsSync(srcpath: any, dstpath: any): {
-    toCwd: any;
-    toDst: any;
-};

package/bin/impl/lib/ensure/symlink-paths.js

@@ -1,63 +0,0 @@
-import { isAbsolute, dirname, join, relative } from "node:path";
-import { fromPromise } from "universalify";
-import { exists as pathExists } from "../../fs/exists.js";
-import { lstat, existsSync } from "../../fs/index.js";
-async function _symlinkPaths(srcpath, dstpath) {
-  if (isAbsolute(srcpath)) {
-    try {
-      await lstat(srcpath);
-    } catch (err) {
-      err.message = err.message.replace("lstat", "ensureSymlink");
-      throw err;
-    }
-    return {
-      toCwd: srcpath,
-      toDst: srcpath
-    };
-  }
-  const dstdir = dirname(dstpath);
-  const relativeToDst = join(dstdir, srcpath);
-  const exists = await pathExists(relativeToDst);
-  if (exists) {
-    return {
-      toCwd: relativeToDst,
-      toDst: srcpath
-    };
-  }
-  try {
-    await lstat(srcpath);
-  } catch (err) {
-    err.message = err.message.replace("lstat", "ensureSymlink");
-    throw err;
-  }
-  return {
-    toCwd: srcpath,
-    toDst: relative(dstdir, srcpath)
-  };
-}
-export const symlinkPaths = fromPromise(_symlinkPaths);
-export function symlinkPathsSync(srcpath, dstpath) {
-  if (isAbsolute(srcpath)) {
-    const exists2 = existsSync(srcpath);
-    if (!exists2) throw new Error("absolute srcpath does not exist");
-    return {
-      toCwd: srcpath,
-      toDst: srcpath
-    };
-  }
-  const dstdir = dirname(dstpath);
-  const relativeToDst = join(dstdir, srcpath);
-  const exists = existsSync(relativeToDst);
-  if (exists) {
-    return {
-      toCwd: relativeToDst,
-      toDst: srcpath
-    };
-  }
-  const srcExists = existsSync(srcpath);
-  if (!srcExists) throw new Error("relative srcpath does not exist");
-  return {
-    toCwd: srcpath,
-    toDst: relative(dstdir, srcpath)
-  };
-}

package/bin/impl/lib/ensure/symlink-type.d.ts

@@ -1,2 +0,0 @@
-export declare const symlinkType: (...args: any[]) => Promise<any> | void;
-export declare function symlinkTypeSync(srcpath: any, type: any): any;

package/bin/impl/lib/ensure/symlink-type.js

@@ -1,23 +0,0 @@
-import { fromPromise } from "universalify";
-import { lstat, lstatSync } from "../../fs/index.js";
-async function _symlinkType(srcpath, type) {
-  if (type) return type;
-  let stats;
-  try {
-    stats = await lstat(srcpath);
-  } catch {
-    return "file";
-  }
-  return stats?.isDirectory() ? "dir" : "file";
-}
-export const symlinkType = fromPromise(_symlinkType);
-export function symlinkTypeSync(srcpath, type) {
-  if (type) return type;
-  let stats;
-  try {
-    stats = lstatSync(srcpath);
-  } catch {
-    return "file";
-  }
-  return stats?.isDirectory() ? "dir" : "file";
-}

package/bin/impl/lib/ensure/symlink.d.ts

@@ -1,2 +0,0 @@
-export declare const createSymlink: (...args: any[]) => Promise<any> | void;
-export declare function createSymlinkSync(srcpath: any, dstpath: any, type: any): any;

package/bin/impl/lib/ensure/symlink.js

@@ -1,59 +0,0 @@
-import { dirname } from "node:path";
-import { fromPromise } from "universalify";
-import { exists as pathExists } from "../../fs/exists.js";
-import {
-  lstat,
-  stat,
-  symlink,
-  lstatSync,
-  statSync,
-  existsSync,
-  symlinkSync
-} from "../../fs/index.js";
-import { mkdirs, mkdirsSync } from "../mkdirs/index.js";
-import { areIdentical } from "../util/stat.js";
-import { symlinkPaths, symlinkPathsSync } from "./symlink-paths.js";
-import { symlinkType, symlinkTypeSync } from "./symlink-type.js";
-async function _createSymlink(srcpath, dstpath, type) {
-  let stats;
-  try {
-    stats = await lstat(dstpath);
-  } catch {
-  }
-  if (stats?.isSymbolicLink()) {
-    const [srcStat, dstStat] = await Promise.all([
-      stat(srcpath),
-      stat(dstpath)
-    ]);
-    if (areIdentical(srcStat, dstStat)) return;
-  }
-  const relative = await symlinkPaths(srcpath, dstpath);
-  srcpath = relative.toDst;
-  const toType = await symlinkType(relative.toCwd, type);
-  const dir = dirname(dstpath);
-  if (!await pathExists(dir)) {
-    await mkdirs(dir);
-  }
-  return symlink(srcpath, dstpath, toType);
-}
-export const createSymlink = fromPromise(_createSymlink);
-export function createSymlinkSync(srcpath, dstpath, type) {
-  let stats;
-  try {
-    stats = lstatSync(dstpath);
-  } catch {
-  }
-  if (stats?.isSymbolicLink()) {
-    const srcStat = statSync(srcpath);
-    const dstStat = statSync(dstpath);
-    if (areIdentical(srcStat, dstStat)) return;
-  }
-  const relative = symlinkPathsSync(srcpath, dstpath);
-  srcpath = relative.toDst;
-  type = symlinkTypeSync(relative.toCwd, type);
-  const dir = dirname(dstpath);
-  const exists = existsSync(dir);
-  if (exists) return symlinkSync(srcpath, dstpath, type);
-  mkdirsSync(dir);
-  return symlinkSync(srcpath, dstpath, type);
-}

package/bin/impl/lib/fs/index.d.ts

@@ -1 +0,0 @@
-export * from "../../fs/index.js";

package/bin/impl/lib/fs/index.js

@@ -1 +0,0 @@
-export * from "../../fs/index.js";

package/bin/impl/lib/index.d.ts

@@ -1,15 +0,0 @@
-export * from "../fs/index.js";
-export * from "./copy/index.js";
-export * from "./empty/index.js";
-export * from "./ensure/index.js";
-export * from "../json.js";
-export * from "./mkdirs/index.js";
-export * from "./move/index.js";
-export * from "./output-file/index.js";
-export * from "./remove/index.js";
-export { exists } from "../fs/exists.js";
-export { existsSync as pathExistsSync } from "../fs/index.js";
-export { exists as pathExists } from "../fs/exists.js";
-export { readJson as readJSON, readJsonSync as readJSONSync, writeJson as writeJSON, writeJsonSync as writeJSONSync, outputJson as outputJSON, outputJsonSync as outputJSONSync, } from "../json.js";
-export { mkdirs as mkdirp, mkdirsSync as mkdirpSync, mkdirs as ensureDir, mkdirsSync as ensureDirSync, } from "./mkdirs/index.js";
-export { ensureFile as createFile, ensureFileSync as createFileSync, ensureLink as createLink, ensureLinkSync as createLinkSync, ensureSymlink as createSymlink, ensureSymlinkSync as createSymlinkSync, } from "./ensure/index.js";