@visulima/fs 4.0.3 → 4.0.5

package/dist/packem_shared/ensureLink-BPnAG5-P.js

@@ -0,0 +1,54 @@
+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 {
+  lstat,
+  link
+} = __cjs_getBuiltinModule("node:fs/promises");
+import { toNamespacedPath, dirname } from '@visulima/path';
+import { toPath } from '@visulima/path/utils';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-8HANmVjk.js';
+import ensureDir from './ensureDir-C_kuQ5Ik.js';
+import { i as isStatsIdentical } from './is-stats-identical-D8FxpvQU.js';
+
+const ensureLink = async (source, destination) => {
+  assertValidFileOrDirectoryPath(source);
+  assertValidFileOrDirectoryPath(destination);
+  source = toNamespacedPath(toPath(source));
+  destination = toNamespacedPath(toPath(destination));
+  let destinationStat;
+  try {
+    destinationStat = await lstat(destination);
+  } catch {
+  }
+  let sourceStat;
+  try {
+    sourceStat = await lstat(source);
+  } catch (error) {
+    error.message = error.message.replace("lstat", "ensureLink");
+    throw error;
+  }
+  if (destinationStat && isStatsIdentical(sourceStat, destinationStat)) {
+    return;
+  }
+  await ensureDir(dirname(destination));
+  await link(source, destination);
+};
+
+export { ensureLink as default };

package/dist/packem_shared/ensureLinkSync-B-Z7X0ub.js

@@ -0,0 +1,54 @@
+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 {
+  lstatSync,
+  linkSync
+} = __cjs_getBuiltinModule("node:fs");
+import { toNamespacedPath, dirname } from '@visulima/path';
+import { toPath } from '@visulima/path/utils';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-8HANmVjk.js';
+import ensureDirSync from './ensureDirSync-CI5g-uBI.js';
+import { i as isStatsIdentical } from './is-stats-identical-D8FxpvQU.js';
+
+const ensureLinkSync = (source, destination) => {
+  assertValidFileOrDirectoryPath(source);
+  assertValidFileOrDirectoryPath(destination);
+  source = toNamespacedPath(toPath(source));
+  destination = toNamespacedPath(toPath(destination));
+  let destinationStat;
+  try {
+    destinationStat = lstatSync(destination);
+  } catch {
+  }
+  let sourceStat;
+  try {
+    sourceStat = lstatSync(source);
+  } catch (error) {
+    error.message = error.message.replace("lstat", "ensureLink");
+    throw error;
+  }
+  if (destinationStat && isStatsIdentical(sourceStat, destinationStat)) {
+    return;
+  }
+  ensureDirSync(dirname(destination));
+  linkSync(source, destination);
+};
+
+export { ensureLinkSync as default };

package/dist/packem_shared/ensureSymlink-BGz6W-Wa.js

@@ -0,0 +1,73 @@
+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 {
+  lstat,
+  stat,
+  symlink,
+  readlink
+} = __cjs_getBuiltinModule("node:fs/promises");
+import { toNamespacedPath, dirname, resolve } from '@visulima/path';
+import { toPath } from '@visulima/path/utils';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-8HANmVjk.js';
+import ensureDir from './ensureDir-C_kuQ5Ik.js';
+import { g as getFileInfoType } from './get-file-info-type-FD4-jsyg.js';
+import { i as isStatsIdentical } from './is-stats-identical-D8FxpvQU.js';
+import { r as resolveSymlinkTarget } from './resolve-symlink-target-Kh4GovFf.js';
+import AlreadyExistsError from './AlreadyExistsError-D5BGeeNR.js';
+
+const isWindows = process.platform === "win32" || /^(?:msys|cygwin)$/.test(process.env.OSTYPE);
+const ensureSymlink = async (target, linkName, type) => {
+  assertValidFileOrDirectoryPath(target);
+  assertValidFileOrDirectoryPath(linkName);
+  const targetRealPath = resolveSymlinkTarget(target, linkName);
+  linkName = toNamespacedPath(toPath(linkName));
+  try {
+    const linkStatInfo = await lstat(linkName);
+    if (linkStatInfo.isSymbolicLink() && isStatsIdentical(await stat(targetRealPath), await stat(linkName))) {
+      const [sourceStat, destinationStat] = await Promise.all([stat(targetRealPath), stat(linkName)]);
+      if (isStatsIdentical(sourceStat, destinationStat)) {
+        return;
+      }
+    }
+  } catch {
+  }
+  const sourceStatInfo = await lstat(targetRealPath);
+  const sourceFilePathType = getFileInfoType(sourceStatInfo);
+  await ensureDir(dirname(linkName));
+  const symlinkType = type ?? (isWindows ? "junction" : sourceFilePathType === "dir" ? "dir" : "file");
+  try {
+    await symlink(toNamespacedPath(toPath(targetRealPath)), linkName, symlinkType);
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+    const linkStatInfo = await lstat(linkName);
+    if (!linkStatInfo.isSymbolicLink()) {
+      throw new AlreadyExistsError(`A ${getFileInfoType(linkStatInfo)} already exists at the path: ${linkName}`);
+    }
+    const linkPath = await readlink(linkName);
+    const linkRealPath = toNamespacedPath(resolve(linkPath));
+    if (linkRealPath !== targetRealPath) {
+      throw new AlreadyExistsError(`A symlink targeting to an undesired path already exists: ${linkName} -> ${linkRealPath}`);
+    }
+  }
+};
+
+export { ensureSymlink as default };

package/dist/packem_shared/ensureSymlinkSync-C5Gk8QYi.js

@@ -0,0 +1,74 @@
+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 {
+  lstatSync,
+  statSync,
+  symlinkSync,
+  readlinkSync
+} = __cjs_getBuiltinModule("node:fs");
+import { toNamespacedPath, dirname, resolve } from '@visulima/path';
+import { toPath } from '@visulima/path/utils';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-8HANmVjk.js';
+import ensureDirSync from './ensureDirSync-CI5g-uBI.js';
+import { g as getFileInfoType } from './get-file-info-type-FD4-jsyg.js';
+import { i as isStatsIdentical } from './is-stats-identical-D8FxpvQU.js';
+import { r as resolveSymlinkTarget } from './resolve-symlink-target-Kh4GovFf.js';
+import AlreadyExistsError from './AlreadyExistsError-D5BGeeNR.js';
+
+const isWindows = process.platform === "win32" || /^(?:msys|cygwin)$/.test(process.env.OSTYPE);
+const ensureSymlinkSync = (target, linkName, type) => {
+  assertValidFileOrDirectoryPath(target);
+  assertValidFileOrDirectoryPath(linkName);
+  const targetRealPath = resolveSymlinkTarget(target, linkName);
+  linkName = toNamespacedPath(toPath(linkName));
+  try {
+    const linkStatInfo = lstatSync(linkName);
+    if (linkStatInfo.isSymbolicLink() && isStatsIdentical(statSync(targetRealPath), statSync(linkName))) {
+      const sourceStat = statSync(targetRealPath);
+      const destinationStat = statSync(linkName);
+      if (isStatsIdentical(sourceStat, destinationStat)) {
+        return;
+      }
+    }
+  } catch {
+  }
+  const sourceStatInfo = lstatSync(targetRealPath);
+  const sourceFilePathType = getFileInfoType(sourceStatInfo);
+  ensureDirSync(dirname(linkName));
+  const symlinkType = type ?? (isWindows ? "junction" : sourceFilePathType === "dir" ? "dir" : "file");
+  try {
+    symlinkSync(toNamespacedPath(toPath(targetRealPath)), linkName, symlinkType);
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+    const linkStatInfo = lstatSync(linkName);
+    if (!linkStatInfo.isSymbolicLink()) {
+      throw new AlreadyExistsError(`A ${getFileInfoType(linkStatInfo)} already exists at the path: ${linkName}`);
+    }
+    const linkPath = readlinkSync(linkName);
+    const linkRealPath = toNamespacedPath(resolve(linkPath));
+    if (linkRealPath !== targetRealPath) {
+      throw new AlreadyExistsError(`A symlink targeting to an undesired path already exists: ${linkName} -> ${linkRealPath}`);
+    }
+  }
+};
+
+export { ensureSymlinkSync as default };

package/dist/packem_shared/findUp-Lv9mZCIQ.js

@@ -0,0 +1,85 @@
+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 {
+  stat,
+  lstat
+} = __cjs_getBuiltinModule("node:fs/promises");
+const {
+  fileURLToPath
+} = __cjs_getBuiltinModule("node:url");
+import { resolve, parse, isAbsolute, dirname } from '@visulima/path';
+import { toPath } from '@visulima/path/utils';
+import { FIND_UP_STOP } from './F_OK-BalxCn9n.js';
+
+const findUp = async (name, options = {}) => {
+  if (typeof name !== "string" && !Array.isArray(name) && typeof name !== "function") {
+    throw new TypeError("The `name` argument must be of type `string` or `string[]`");
+  }
+  const cwd = options.cwd ? toPath(options.cwd) : process.cwd();
+  let directory = resolve(cwd);
+  const { root } = parse(directory);
+  const stopPath = toPath(options.stopAt ?? root);
+  const stopAt = resolve(directory, stopPath);
+  const type = options.type ?? "file";
+  const getMatchers = async function(currentDirectory) {
+    if (typeof name === "function") {
+      const match = await name(currentDirectory);
+      return [match];
+    }
+    if (typeof name === "string") {
+      return [name];
+    }
+    if (Array.isArray(name)) {
+      return name;
+    }
+    return [name];
+  };
+  if (options.allowSymlinks === void 0) {
+    options.allowSymlinks = true;
+  }
+  const statFunction = options.allowSymlinks ? stat : lstat;
+  while (directory && directory !== stopAt && directory !== root) {
+    for await (let fileName of await getMatchers(directory)) {
+      if (fileName === FIND_UP_STOP) {
+        return void 0;
+      }
+      if (fileName === void 0) {
+        continue;
+      }
+      if (Buffer.isBuffer(fileName)) {
+        fileName = fileName.toString();
+      } else if (fileName instanceof URL) {
+        fileName = fileURLToPath(fileName);
+      }
+      const filePath = isAbsolute(fileName) ? fileName : resolve(directory, fileName);
+      try {
+        const stats = await statFunction(filePath);
+        if (type === "file" && stats.isFile() || type === "directory" && stats.isDirectory()) {
+          return filePath;
+        }
+      } catch {
+      }
+    }
+    directory = dirname(directory);
+  }
+  return void 0;
+};
+
+export { findUp as default };

package/dist/packem_shared/findUpSync-BsK4Nrrq.js

@@ -0,0 +1,85 @@
+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 {
+  statSync,
+  lstatSync
+} = __cjs_getBuiltinModule("node:fs");
+const {
+  fileURLToPath
+} = __cjs_getBuiltinModule("node:url");
+import { resolve, parse, isAbsolute, dirname } from '@visulima/path';
+import { toPath } from '@visulima/path/utils';
+import { FIND_UP_STOP } from './F_OK-BalxCn9n.js';
+
+const findUpSync = (name, options = {}) => {
+  if (typeof name !== "string" && !Array.isArray(name) && typeof name !== "function") {
+    throw new TypeError("The `name` argument must be of type `string` or `string[]`");
+  }
+  const cwd = options.cwd ? toPath(options.cwd) : process.cwd();
+  let directory = resolve(cwd);
+  const { root } = parse(directory);
+  const stopPath = toPath(options.stopAt ?? root);
+  const stopAt = resolve(directory, stopPath);
+  const type = options.type ?? "file";
+  const getMatchers = function(currentDirectory) {
+    if (typeof name === "function") {
+      const match = name(currentDirectory);
+      return [match];
+    }
+    if (typeof name === "string") {
+      return [name];
+    }
+    if (Array.isArray(name)) {
+      return name;
+    }
+    return [name];
+  };
+  if (options.allowSymlinks === void 0) {
+    options.allowSymlinks = true;
+  }
+  const statFunction = options.allowSymlinks ? statSync : lstatSync;
+  while (directory && directory !== stopAt && directory !== root) {
+    for (let fileName of getMatchers(directory)) {
+      if (fileName === FIND_UP_STOP) {
+        return void 0;
+      }
+      if (fileName === void 0) {
+        continue;
+      }
+      if (Buffer.isBuffer(fileName)) {
+        fileName = fileName.toString();
+      } else if (fileName instanceof URL) {
+        fileName = fileURLToPath(fileName);
+      }
+      const filePath = isAbsolute(fileName) ? fileName : resolve(directory, fileName);
+      try {
+        const stats = statFunction(filePath);
+        if (type === "file" && stats.isFile() || type === "directory" && stats.isDirectory()) {
+          return filePath;
+        }
+      } catch {
+      }
+    }
+    directory = dirname(directory);
+  }
+  return void 0;
+};
+
+export { findUpSync as default };

package/dist/packem_shared/get-file-info-type-FD4-jsyg.js

@@ -0,0 +1,14 @@
+const getFileInfoType = (fileInfo) => {
+  if (fileInfo.isFile()) {
+    return "file";
+  }
+  if (fileInfo.isDirectory()) {
+    return "dir";
+  }
+  if (fileInfo.isSymbolicLink()) {
+    return "symlink";
+  }
+  return void 0;
+};
+
+export { getFileInfoType as g };

package/dist/packem_shared/index-CHM-in-V.js

@@ -0,0 +1,100 @@
+const INDENT_REGEX = /^(?:( )+|\t+)/;
+const INDENT_TYPE_SPACE = "space";
+const INDENT_TYPE_TAB = "tab";
+function shouldIgnoreSingleSpace(ignoreSingleSpaces, indentType, value) {
+  return ignoreSingleSpaces && indentType === INDENT_TYPE_SPACE && value === 1;
+}
+function makeIndentsMap(string, ignoreSingleSpaces) {
+  const indents = /* @__PURE__ */ new Map();
+  let previousSize = 0;
+  let previousIndentType;
+  let key;
+  for (const line of string.split(/\n/g)) {
+    if (!line) {
+      continue;
+    }
+    const matches = line.match(INDENT_REGEX);
+    if (matches === null) {
+      previousSize = 0;
+      previousIndentType = "";
+    } else {
+      const indent = matches[0].length;
+      const indentType = matches[1] ? INDENT_TYPE_SPACE : INDENT_TYPE_TAB;
+      if (shouldIgnoreSingleSpace(ignoreSingleSpaces, indentType, indent)) {
+        continue;
+      }
+      if (indentType !== previousIndentType) {
+        previousSize = 0;
+      }
+      previousIndentType = indentType;
+      let use = 1;
+      let weight = 0;
+      const indentDifference = indent - previousSize;
+      previousSize = indent;
+      if (indentDifference === 0) {
+        use = 0;
+        weight = 1;
+      } else {
+        const absoluteIndentDifference = Math.abs(indentDifference);
+        if (shouldIgnoreSingleSpace(ignoreSingleSpaces, indentType, absoluteIndentDifference)) {
+          continue;
+        }
+        key = encodeIndentsKey(indentType, absoluteIndentDifference);
+      }
+      const entry = indents.get(key);
+      indents.set(key, entry === void 0 ? [1, 0] : [entry[0] + use, entry[1] + weight]);
+    }
+  }
+  return indents;
+}
+function encodeIndentsKey(indentType, indentAmount) {
+  const typeCharacter = indentType === INDENT_TYPE_SPACE ? "s" : "t";
+  return typeCharacter + String(indentAmount);
+}
+function decodeIndentsKey(indentsKey) {
+  const keyHasTypeSpace = indentsKey[0] === "s";
+  const type = keyHasTypeSpace ? INDENT_TYPE_SPACE : INDENT_TYPE_TAB;
+  const amount = Number(indentsKey.slice(1));
+  return { type, amount };
+}
+function getMostUsedKey(indents) {
+  let result;
+  let maxUsed = 0;
+  let maxWeight = 0;
+  for (const [key, [usedCount, weight]] of indents) {
+    if (usedCount > maxUsed || usedCount === maxUsed && weight > maxWeight) {
+      maxUsed = usedCount;
+      maxWeight = weight;
+      result = key;
+    }
+  }
+  return result;
+}
+function makeIndentString(type, amount) {
+  const indentCharacter = type === INDENT_TYPE_SPACE ? " " : "	";
+  return indentCharacter.repeat(amount);
+}
+function detectIndent(string) {
+  if (typeof string !== "string") {
+    throw new TypeError("Expected a string");
+  }
+  let indents = makeIndentsMap(string, true);
+  if (indents.size === 0) {
+    indents = makeIndentsMap(string, false);
+  }
+  const keyOfMostUsedIndent = getMostUsedKey(indents);
+  let type;
+  let amount = 0;
+  let indent = "";
+  if (keyOfMostUsedIndent !== void 0) {
+    ({ type, amount } = decodeIndentsKey(keyOfMostUsedIndent));
+    indent = makeIndentString(type, amount);
+  }
+  return {
+    amount,
+    type,
+    indent
+  };
+}
+
+export { detectIndent as d };

package/dist/packem_shared/is-stats-identical-D8FxpvQU.js

@@ -0,0 +1,3 @@
+const isStatsIdentical = (sourceStat, destinationStat) => !!destinationStat.ino && !!destinationStat.dev && destinationStat.ino === sourceStat.ino && destinationStat.dev === sourceStat.dev;
+
+export { isStatsIdentical as i };

package/dist/packem_shared/isAccessible-iOp0Bou6.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 {
+  access
+} = __cjs_getBuiltinModule("node:fs/promises");
+import { toPath } from '@visulima/path/utils';
+import { F_OK } from './F_OK-BalxCn9n.js';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-8HANmVjk.js';
+
+async function isAccessible(path, mode = F_OK) {
+  assertValidFileOrDirectoryPath(path);
+  path = toPath(path);
+  try {
+    await access(path, mode);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export { isAccessible as default };

package/dist/packem_shared/isAccessibleSync-38BmiIcx.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 {
+  accessSync
+} = __cjs_getBuiltinModule("node:fs");
+import { toPath } from '@visulima/path/utils';
+import { F_OK } from './F_OK-BalxCn9n.js';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-8HANmVjk.js';
+
+function isAccessibleSync(path, mode = F_OK) {
+  assertValidFileOrDirectoryPath(path);
+  path = toPath(path);
+  try {
+    accessSync(path, mode);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export { isAccessibleSync as default };