@visulima/fs 4.0.3 → 4.0.5

package/dist/packem_shared/isFsCaseSensitive-D-ayleCy.js

@@ -0,0 +1,62 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const y = __cjs_getBuiltinModule("fs");
+const h = __cjs_getBuiltinModule("os");
+const u = __cjs_getBuiltinModule("path");
+
+var l = Object.defineProperty;
+var s = (i, t) => l(i, "name", { value: t, configurable: true });
+const a = s((i) => {
+  let t = "";
+  for (let e = 0; e < i.length; e += 1) {
+    const r = i[e], o = r.toUpperCase();
+    t += r === o ? r.toLowerCase() : o;
+  }
+  return t;
+}, "invertCase");
+const c = /* @__PURE__ */ new Map();
+const p = s((i, t) => {
+  const e = u.join(i, `.is-fs-case-sensitive-test-${process.pid}`);
+  try {
+    return t.writeFileSync(e, ""), !t.existsSync(a(e));
+  } finally {
+    try {
+      t.unlinkSync(e);
+    } catch {
+    }
+  }
+}, "checkDirectoryCaseWithWrite");
+const m = s((i, t, e) => {
+  try {
+    return p(i, e);
+  } catch (r) {
+    if (t === void 0) return p(h.tmpdir(), e);
+    throw r;
+  }
+}, "checkDirectoryCaseWithFallback");
+const S = s((i, t = y, e = true) => {
+  const r = i ?? process.cwd();
+  if (e && c.has(r)) return c.get(r);
+  let o;
+  const n = a(r);
+  return n !== r && t.existsSync(r) ? o = !t.existsSync(n) : o = m(r, i, t), e && c.set(r, o), o;
+}, "isFsCaseSensitive");
+
+export { S as isFsCaseSensitive };

package/dist/packem_shared/move-BD6JbYSu.js

@@ -0,0 +1,134 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  cwd
+} = __cjs_getProcess;
+import { toPath } from '@visulima/path/utils';
+const {
+  mkdir,
+  rename: rename$1,
+  copyFile,
+  unlink
+} = __cjs_getBuiltinModule("node:fs/promises");
+import { dirname, resolve } from '@visulima/path';
+import isAccessible from './isAccessible-iOp0Bou6.js';
+const {
+  mkdirSync,
+  renameSync: renameSync$1,
+  copyFileSync,
+  unlinkSync
+} = __cjs_getBuiltinModule("node:fs");
+import isAccessibleSync from './isAccessibleSync-38BmiIcx.js';
+
+class SameDirectoryError extends Error {
+  constructor(source, destination) {
+    super(`Source directory "${dirname(source)}" does not match destination directory "${dirname(destination)}"`);
+    this.name = "SameDirectoryError";
+  }
+}
+const validateSameDirectory = (source, destination) => {
+  if (!source || !destination) {
+    throw new Error("Source and destination paths must not be empty");
+  }
+  if (dirname(source) !== dirname(destination)) {
+    throw new SameDirectoryError(source, destination);
+  }
+};
+
+const internalMoveFile = async (sourcePath, destinationPath, { cwd, directoryMode, overwrite, validateDirectory }) => {
+  if (cwd) {
+    sourcePath = resolve(cwd, sourcePath);
+    destinationPath = resolve(cwd, destinationPath);
+  }
+  if (validateDirectory) {
+    validateSameDirectory(sourcePath, destinationPath);
+  }
+  if (!overwrite && await isAccessible(destinationPath)) {
+    throw new Error(`The destination file exists: ${destinationPath}`);
+  }
+  await mkdir(dirname(destinationPath), {
+    mode: directoryMode,
+    recursive: true
+  });
+  try {
+    await rename$1(sourcePath, destinationPath);
+  } catch (error) {
+    if (error.code === "EXDEV") {
+      await copyFile(sourcePath, destinationPath);
+      await unlink(sourcePath);
+    } else {
+      throw error;
+    }
+  }
+};
+
+const internalMoveFileSync = (sourcePath, destinationPath, { cwd, directoryMode, overwrite, validateDirectory }) => {
+  if (cwd) {
+    sourcePath = resolve(cwd, sourcePath);
+    destinationPath = resolve(cwd, destinationPath);
+  }
+  if (validateDirectory) {
+    validateSameDirectory(sourcePath, destinationPath);
+  }
+  if (!overwrite && isAccessibleSync(destinationPath)) {
+    throw new Error(`The destination file exists: ${destinationPath}`);
+  }
+  mkdirSync(dirname(destinationPath), {
+    mode: directoryMode,
+    recursive: true
+  });
+  try {
+    renameSync$1(sourcePath, destinationPath);
+  } catch (error) {
+    if (error.code === "EXDEV") {
+      copyFileSync(sourcePath, destinationPath);
+      unlinkSync(sourcePath);
+    } else {
+      throw error;
+    }
+  }
+};
+
+const move = async (sourcePath, destinationPath, options = {}) => {
+  const internalOptions = {
+    overwrite: true,
+    validateDirectory: false,
+    ...options,
+    cwd: options.cwd ? toPath(options.cwd) : cwd()
+  };
+  await internalMoveFile(sourcePath, destinationPath, internalOptions);
+};
+const moveSync = (sourcePath, destinationPath, options) => {
+  const internalOptions = { overwrite: true, validateDirectory: false, ...options };
+  internalOptions.cwd = internalOptions.cwd ? toPath(internalOptions.cwd) : cwd();
+  internalMoveFileSync(sourcePath, destinationPath, internalOptions);
+};
+const rename = async (source, destination, options) => {
+  const internalOptions = { overwrite: true, ...options, validateDirectory: true };
+  internalOptions.cwd = internalOptions.cwd ? toPath(internalOptions.cwd) : cwd();
+  await internalMoveFile(source, destination, internalOptions);
+};
+const renameSync = (source, destination, options) => {
+  const internalOptions = { overwrite: true, ...options, validateDirectory: true };
+  internalOptions.cwd = internalOptions.cwd ? toPath(internalOptions.cwd) : cwd();
+  internalMoveFileSync(source, destination, internalOptions);
+};
+
+export { move, moveSync, rename, renameSync };

package/dist/packem_shared/parseJson-CqUuRguZ.js

@@ -0,0 +1,231 @@
+import JSONError from './JSONError-BkHRnInH.js';
+
+const normalizeLF = (code) => code.replaceAll(/\r\n|\r(?!\n)|\n/gu, "\n");
+const _process = globalThis.process || /* @__PURE__ */ Object.create(null);
+const processShims = {
+  versions: {}
+};
+const process = new Proxy(_process, {
+  get(target, property) {
+    if (property in target) {
+      return target[property];
+    }
+    if (property in processShims) {
+      return processShims[property];
+    }
+    return void 0;
+  }
+});
+const getMarkerLines = (loc, source, linesAbove, linesBelow) => {
+  const startLoc = {
+    column: 0,
+    // @ts-expect-error Can be overwritten
+    line: -1,
+    ...loc.start
+  };
+  const endLoc = {
+    ...startLoc,
+    ...loc.end
+  };
+  const startLine = startLoc.line;
+  const startColumn = startLoc.column;
+  const endLine = endLoc.line;
+  const endColumn = endLoc.column;
+  let start = Math.max(startLine - (linesAbove + 1), 0);
+  let end = Math.min(source.length, endLine + linesBelow);
+  if (startLine === -1) {
+    start = 0;
+  }
+  if (endLine === -1) {
+    end = source.length;
+  }
+  const lineDiff = endLine - startLine;
+  const markerLines = {};
+  if (lineDiff) {
+    for (let index = 0; index <= lineDiff; index++) {
+      const lineNumber = index + startLine;
+      if (!startColumn) {
+        markerLines[lineNumber] = true;
+      } else if (index === 0) {
+        const sourceLength = source[lineNumber - 1]?.length;
+        markerLines[lineNumber] = [startColumn, (sourceLength ?? 0) - startColumn + 1];
+      } else if (index === lineDiff) {
+        markerLines[lineNumber] = [0, endColumn];
+      } else {
+        const sourceLength = source[lineNumber - index]?.length;
+        markerLines[lineNumber] = [0, sourceLength];
+      }
+    }
+  } else if (startColumn === endColumn) {
+    markerLines[startLine] = startColumn ? [startColumn, 0] : true;
+  } else {
+    markerLines[startLine] = [startColumn, (endColumn ?? 0) - (startColumn ?? 0)];
+  }
+  return { end, markerLines, start };
+};
+const CODE_FRAME_POINTER = process.platform === "win32" && !process.env?.WT_SESSION ? ">" : "❯";
+const codeFrame = (source, loc, options) => {
+  const config = {
+    // grab 2 lines before, and 3 lines after focused line
+    linesAbove: 2,
+    linesBelow: 3,
+    prefix: "",
+    showGutter: true,
+    tabWidth: 4,
+    ...options,
+    color: {
+      gutter: (value) => value,
+      marker: (value) => value,
+      message: (value) => value,
+      ...options?.color
+    }
+  };
+  const hasColumns = loc.start && typeof loc.start.column === "number";
+  let lines = normalizeLF(source).split("\n");
+  if (typeof config?.tabWidth === "number") {
+    lines = lines.map((ln) => ln.replaceAll("	", " ".repeat(config.tabWidth)));
+  }
+  const { end, markerLines, start } = getMarkerLines(loc, lines, config.linesAbove, config.linesBelow);
+  const numberMaxWidth = String(end).length;
+  const { gutter: colorizeGutter, marker: colorizeMarker, message: colorizeMessage } = config.color;
+  let frame = lines.slice(start, end).map((line, index) => {
+    const number = start + 1 + index;
+    const hasMarker = markerLines[number];
+    const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
+    const lastMarkerLine = !markerLines[number + 1];
+    const gutter = ` ${paddedNumber}${config.showGutter ? " |" : ""}`;
+    if (hasMarker) {
+      let markerLine = "";
+      if (Array.isArray(hasMarker)) {
+        const markerSpacing = line.replaceAll(/[^\t]/g, " ").slice(0, Math.max(hasMarker[0] - 1, 0));
+        const numberOfMarkers = hasMarker[1] || 1;
+        markerLine = [
+          "\n ",
+          config.prefix + colorizeGutter(gutter.replaceAll(/\d/g, " ")),
+          " ",
+          markerSpacing,
+          colorizeMarker("^").repeat(numberOfMarkers)
+        ].join("");
+        if (lastMarkerLine && config.message) {
+          markerLine += ` ${colorizeMessage(config.message)}`;
+        }
+      }
+      return [config.prefix + colorizeMarker(CODE_FRAME_POINTER), colorizeGutter(gutter), line.length > 0 ? ` ${line}` : "", markerLine].join("");
+    }
+    return `${config.prefix} ${colorizeGutter(gutter)}${line.length > 0 ? ` ${line}` : ""}`;
+  }).join("\n");
+  if (config.message && !hasColumns) {
+    frame = `${config.prefix + " ".repeat(numberMaxWidth + 1) + config.message}
+${frame}`;
+  }
+  return frame;
+};
+
+const binarySearch = (element, array) => {
+  let m = 0;
+  let n = array.length - 2;
+  while (m < n) {
+    const key = m + (n - m >> 1);
+    if (element < array[key]) {
+      n = key - 1;
+    } else if (element >= array[key + 1]) {
+      m = key + 1;
+    } else {
+      m = key;
+      break;
+    }
+  }
+  return m;
+};
+const getLineStartIndexes = (string_) => (
+  // eslint-disable-next-line unicorn/no-array-reduce
+  string_.split(/\n|\r(?!\n)/).reduce(
+    (accumulator, current) => {
+      accumulator.push(accumulator.at(-1) + current.length + 1);
+      return accumulator;
+    },
+    [0]
+  )
+);
+const indexToLineColumn = (input, index, options) => {
+  if ((!Array.isArray(input) && typeof input !== "string" || (typeof input === "string" || Array.isArray(input)) && input.length === 0)) {
+    return { column: 0, line: 0 };
+  }
+  if ((typeof index !== "number" || typeof input === "string" && index >= input.length || Array.isArray(input) && index + 1 >= input.at(-1))) {
+    return { column: 0, line: 0 };
+  }
+  if (typeof input === "string") {
+    const startIndexesOfEachLine = getLineStartIndexes(input);
+    const line2 = binarySearch(index, startIndexesOfEachLine);
+    return {
+      column: index - startIndexesOfEachLine[line2] + 1,
+      line: line2 + 1
+    };
+  }
+  const line = binarySearch(index, input);
+  return {
+    column: index - input[line] + 1,
+    line: line + 1
+  };
+};
+
+const getCodePoint = (character) => `\\u{${character.codePointAt(0).toString(16)}}`;
+const generateCodeFrame = (source, location, options) => codeFrame(
+  source,
+  { start: location },
+  {
+    tabWidth: false,
+    ...options
+  }
+);
+const getErrorLocation = (source, message) => {
+  const match = /in JSON at position (?<index>\d+)(?: \(line (?<line>\d+) column (?<column>\d+)\))?$/.exec(message);
+  if (!match) {
+    return void 0;
+  }
+  let { column, index, line } = match.groups;
+  if (line && column) {
+    return { column: Number(column), line: Number(line) };
+  }
+  index = Number(index);
+  if (index === source.length) {
+    index = source.length - 1;
+  }
+  return indexToLineColumn(source, index);
+};
+const addCodePointToUnexpectedToken = (message) => message.replace(
+  // TODO[engine:node@>=20]: The token always quoted after Node.js 20
+  // eslint-disable-next-line regexp/no-potentially-useless-backreference
+  /(?<=^Unexpected token )(?<quote>')?(.)\k<quote>/,
+  (_, _quote, token) => `"${token}"(${getCodePoint(token)})`
+);
+function parseJson(string, reviver, fileName, options) {
+  if (typeof reviver === "string") {
+    if (typeof fileName === "object") {
+      options = fileName;
+    }
+    fileName = reviver;
+    reviver = void 0;
+  }
+  let message;
+  try {
+    return JSON.parse(string, reviver);
+  } catch (error) {
+    message = error.message;
+  }
+  let location;
+  if (string) {
+    location = getErrorLocation(string, message);
+    message = addCodePointToUnexpectedToken(message);
+  } else {
+    message += " while parsing empty string";
+  }
+  const jsonError = new JSONError(message);
+  jsonError.fileName = fileName;
+  if (location) {
+    jsonError.codeFrame = generateCodeFrame(string, location, options);
+  }
+  throw jsonError;
+}
+
+export { parseJson as default };

package/dist/packem_shared/readFile-XVOjAw8r.js

@@ -0,0 +1,65 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  readFile: readFile$1
+} = __cjs_getBuiltinModule("node:fs/promises");
+const {
+  unzip,
+  brotliDecompress
+} = __cjs_getBuiltinModule("node:zlib");
+import { toPath } from '@visulima/path/utils';
+import { R_OK } from './F_OK-BalxCn9n.js';
+import PermissionError from './PermissionError-1qs0skfo.js';
+import isAccessible from './isAccessible-iOp0Bou6.js';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-8HANmVjk.js';
+
+const decompressionMethods = {
+  brotli: brotliDecompress,
+  gzip: unzip,
+  none: (buffer, callback) => {
+    callback(null, buffer);
+  }
+};
+const readFile = async (path, options) => {
+  assertValidFileOrDirectoryPath(path);
+  path = toPath(path);
+  if (!await isAccessible(path)) {
+    throw new PermissionError(`unable to read the non-accessible file: ${path}`);
+  }
+  if (!await isAccessible(path, R_OK)) {
+    throw new Error(`Unable to read the non-readable file: ${path}`);
+  }
+  const { buffer, compression, encoding, flag } = options ?? {};
+  return await readFile$1(path, flag ? { encoding, flag } : { encoding }).then(
+    async (content) => await new Promise((resolve, reject) => {
+      decompressionMethods[compression ?? "none"](content, (error, result) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve(buffer ? result : result.toString());
+        }
+      });
+    })
+  ).catch((error) => {
+    throw error;
+  });
+};
+
+export { readFile as default };

package/dist/packem_shared/readFileSync-B9Zg5PSF.js

@@ -0,0 +1,53 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  readFileSync: readFileSync$1
+} = __cjs_getBuiltinModule("node:fs");
+const {
+  unzipSync,
+  brotliDecompressSync
+} = __cjs_getBuiltinModule("node:zlib");
+import { toPath } from '@visulima/path/utils';
+import { R_OK } from './F_OK-BalxCn9n.js';
+import PermissionError from './PermissionError-1qs0skfo.js';
+import isAccessibleSync from './isAccessibleSync-38BmiIcx.js';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-8HANmVjk.js';
+
+const decompressionMethods = {
+  brotli: brotliDecompressSync,
+  gzip: unzipSync,
+  none: (buffer) => buffer
+};
+const readFileSync = (path, options) => {
+  assertValidFileOrDirectoryPath(path);
+  path = toPath(path);
+  if (!isAccessibleSync(path)) {
+    throw new PermissionError(`unable to read the non-accessible file: ${path}`);
+  }
+  if (!isAccessibleSync(path, R_OK)) {
+    throw new PermissionError(`invalid access to read file at: ${path}`);
+  }
+  const { buffer, compression, encoding, flag } = options ?? {};
+  const content = readFileSync$1(path, flag ? { encoding, flag } : { encoding });
+  const decompressed = decompressionMethods[compression ?? "none"](content);
+  return buffer ? decompressed : decompressed.toString();
+};
+
+export { readFileSync as default };

package/dist/packem_shared/readJson-Dra2m6s-.js

@@ -0,0 +1,22 @@
+import { toPath } from '@visulima/path/utils';
+import parseJson from './parseJson-CqUuRguZ.js';
+import readFile from './readFile-XVOjAw8r.js';
+
+async function readJson(path, reviver, options) {
+  if (typeof reviver === "object") {
+    options = reviver;
+    reviver = void 0;
+  }
+  const content = await readFile(path, {
+    buffer: true,
+    encoding: void 0
+  });
+  let data = new TextDecoder().decode(content);
+  const { beforeParse, color } = options ?? {};
+  if (typeof beforeParse === "function") {
+    data = beforeParse(data);
+  }
+  return parseJson(data, reviver, toPath(path), { color });
+}
+
+export { readJson as default };

package/dist/packem_shared/readJsonSync-B6Dl1I_6.js

@@ -0,0 +1,22 @@
+import { toPath } from '@visulima/path/utils';
+import parseJson from './parseJson-CqUuRguZ.js';
+import readFileSync from './readFileSync-B9Zg5PSF.js';
+
+function readJsonSync(path, reviver, options) {
+  if (typeof reviver === "object") {
+    options = reviver;
+    reviver = void 0;
+  }
+  const content = readFileSync(path, {
+    buffer: true,
+    encoding: void 0
+  });
+  let data = new TextDecoder().decode(content);
+  const { beforeParse, color } = options ?? {};
+  if (typeof beforeParse === "function") {
+    data = beforeParse(data);
+  }
+  return parseJson(data, reviver, toPath(path), { color });
+}
+
+export { readJsonSync as default };

package/dist/packem_shared/readYaml-Bu1nsexB.js

@@ -0,0 +1,10 @@
+import { parse } from 'yaml';
+import readFile from './readFile-XVOjAw8r.js';
+
+async function readYaml(path, reviver, options) {
+  const { buffer, compression, encoding = "utf8", flag, ...parseOptions } = options ?? {};
+  const content = await readFile(path, { buffer, compression, encoding, flag });
+  return typeof reviver === "function" ? parse(content, reviver, parseOptions) : parse(content, parseOptions);
+}
+
+export { readYaml as default };

package/dist/packem_shared/readYamlSync-Di88aMME.js

@@ -0,0 +1,10 @@
+import { parse } from 'yaml';
+import readFileSync from './readFileSync-B9Zg5PSF.js';
+
+function readYamlSync(path, reviver, options) {
+  const { buffer, compression, encoding = "utf8", flag, ...parseOptions } = options ?? {};
+  const content = readFileSync(path, { buffer, compression, encoding, flag });
+  return typeof reviver === "function" ? parse(content, reviver, parseOptions) : parse(content, parseOptions);
+}
+
+export { readYamlSync as default };

package/dist/packem_shared/remove-_oDY3uKo.js

@@ -0,0 +1,38 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  unlink,
+  rm
+} = __cjs_getBuiltinModule("node:fs/promises");
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-8HANmVjk.js';
+
+const remove = async (path, options = {}) => {
+  assertValidFileOrDirectoryPath(path);
+  try {
+    await unlink(path);
+  } catch {
+  }
+  try {
+    await rm(path, { force: true, maxRetries: options?.maxRetries, recursive: true, retryDelay: options?.retryDelay });
+  } catch {
+  }
+};
+
+export { remove as default };