@socketsecurity/lib 6.0.2 → 6.0.4

package/dist/fs/find-up.js

@@ -1,152 +1,131 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var find_up_exports = {};
-__export(find_up_exports, {
-  findUp: () => findUp,
-  findUpSync: () => findUpSync
-});
-module.exports = __toCommonJS(find_up_exports);
-var import_node_process = __toESM(require("node:process"));
-var import_predicates = require("../arrays/predicates");
-var import_abort = require("../process/abort");
-var import_fs = require("../node/fs");
-var import_path = require("../node/path");
-var import_normalize = require("../paths/normalize");
-const abortSignal = (0, import_abort.getAbortSignal)();
-// @__NO_SIDE_EFFECTS__
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+const require_paths_normalize = require('../paths/normalize.js');
+const require_node_fs = require('../node/fs.js');
+const require_node_path = require('../node/path.js');
+const require_process_abort = require('../process/abort.js');
+const require_arrays_predicates = require('../arrays/predicates.js');
+const require_smol_path = require('../smol/path.js');
+const require_paths_walk = require('../paths/walk.js');
+let node_process = require("node:process");
+node_process = require_runtime.__toESM(node_process);
+
+//#region src/fs/find-up.ts
+/**
+* @file Walk parent directories to locate a file or directory by name. The
+*   traversal includes the filesystem root (or the caller-supplied `stopAt`
+*   boundary) — historically the loop exited at `dir === root` _before_
+*   visiting root itself, so a match at e.g. `/.foo` was never found. The
+*   current shape visits root, then breaks.
+*/
+const abortSignal = require_process_abort.getAbortSignal();
+/**
+* Find a file or directory by traversing up parent directories. Searches from
+* the starting directory upward to the filesystem root. Useful for finding
+* configuration files or project roots.
+*
+* @example
+*   ;```ts
+*   // Find package.json starting from current directory
+*   const pkgPath = await findUp('package.json')
+*
+*   // Find any of multiple config files
+*   const configPath = await findUp(['.config.js', '.config.json'])
+*
+*   // Find a directory instead of file
+*   const nodeModules = await findUp('node_modules', { onlyDirectories: true })
+*   ```
+*
+* @param name - Filename(s) to search for.
+* @param options - Search options including cwd and type filters.
+*
+* @returns Normalized absolute path if found, undefined otherwise
+*/
+/* @__NO_SIDE_EFFECTS__ */
 async function findUp(name, options) {
-  const { cwd = import_node_process.default.cwd(), signal = abortSignal } = {
-    __proto__: null,
-    ...options
-  };
-  let { onlyDirectories = false, onlyFiles = true } = {
-    __proto__: null,
-    ...options
-  };
-  if (onlyDirectories) {
-    onlyFiles = false;
-  }
-  if (onlyFiles) {
-    onlyDirectories = false;
-  }
-  const fs = (0, import_fs.getNodeFs)();
-  const path = (0, import_path.getNodePath)();
-  let dir = path.resolve(cwd);
-  const { root } = path.parse(dir);
-  const names = (0, import_predicates.isArray)(name) ? name : [name];
-  while (dir) {
-    for (const n of names) {
-      if (signal?.aborted) {
-        return void 0;
-      }
-      const thePath = path.join(dir, n);
-      try {
-        const stats = await fs.promises.stat(thePath);
-        if (!onlyDirectories && stats.isFile()) {
-          return (0, import_normalize.normalizePath)(thePath);
-        }
-        if (!onlyFiles && stats.isDirectory()) {
-          return (0, import_normalize.normalizePath)(thePath);
-        }
-      } catch {
-      }
-    }
-    if (dir === root) {
-      break;
-    }
-    dir = path.dirname(dir);
-  }
-  return void 0;
+	const { cwd = node_process.default.cwd(), signal = abortSignal } = {
+		__proto__: null,
+		...options
+	};
+	let { onlyDirectories = false, onlyFiles = true } = {
+		__proto__: null,
+		...options
+	};
+	if (onlyDirectories) onlyFiles = false;
+	if (onlyFiles) onlyDirectories = false;
+	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const names = require_arrays_predicates.isArray(name) ? name : [name];
+	for (const dir of require_paths_walk.walkUp(cwd)) for (const n of names) {
+		if (signal?.aborted) return;
+		const thePath = path.join(dir, n);
+		try {
+			const stats = await fs.promises.stat(thePath);
+			if (!onlyDirectories && stats.isFile()) return /* @__PURE__ */ require_paths_normalize.normalizePath(thePath);
+			if (!onlyFiles && stats.isDirectory()) return /* @__PURE__ */ require_paths_normalize.normalizePath(thePath);
+		} catch {}
+	}
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Synchronously find a file or directory by traversing up parent directories.
+* Searches from the starting directory upward to the filesystem root or
+* `stopAt` directory. Useful for finding configuration files or project roots
+* in synchronous contexts.
+*
+* @example
+*   ;```ts
+*   // Find package.json starting from current directory
+*   const pkgPath = findUpSync('package.json')
+*
+*   // Find .git directory but stop at home directory
+*   const gitPath = findUpSync('.git', {
+*     onlyDirectories: true,
+*     stopAt: process.env.HOME,
+*   })
+*
+*   // Find any of multiple config files
+*   const configPath = findUpSync(['.eslintrc.js', '.eslintrc.json'])
+*   ```
+*
+* @param name - Filename(s) to search for.
+* @param options - Search options including cwd, stopAt, and type filters.
+*
+* @returns Normalized absolute path if found, undefined otherwise
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function findUpSync(name, options) {
-  const { cwd = import_node_process.default.cwd(), stopAt } = {
-    __proto__: null,
-    ...options
-  };
-  let { onlyDirectories = false, onlyFiles = true } = {
-    __proto__: null,
-    ...options
-  };
-  if (onlyDirectories) {
-    onlyFiles = false;
-  }
-  if (onlyFiles) {
-    onlyDirectories = false;
-  }
-  const fs = (0, import_fs.getNodeFs)();
-  const path = (0, import_path.getNodePath)();
-  let dir = path.resolve(cwd);
-  const { root } = path.parse(dir);
-  const stopDir = stopAt ? path.resolve(stopAt) : void 0;
-  const names = (0, import_predicates.isArray)(name) ? name : [name];
-  while (dir) {
-    if (stopDir && dir === stopDir) {
-      for (const n of names) {
-        const thePath = path.join(dir, n);
-        try {
-          const stats = fs.statSync(thePath);
-          if (!onlyDirectories && stats.isFile()) {
-            return (0, import_normalize.normalizePath)(thePath);
-          }
-          if (!onlyFiles && stats.isDirectory()) {
-            return (0, import_normalize.normalizePath)(thePath);
-          }
-        } catch {
-        }
-      }
-      return void 0;
-    }
-    for (const n of names) {
-      const thePath = path.join(dir, n);
-      try {
-        const stats = fs.statSync(thePath);
-        if (!onlyDirectories && stats.isFile()) {
-          return (0, import_normalize.normalizePath)(thePath);
-        }
-        if (!onlyFiles && stats.isDirectory()) {
-          return (0, import_normalize.normalizePath)(thePath);
-        }
-      } catch {
-      }
-    }
-    if (dir === root) {
-      break;
-    }
-    dir = path.dirname(dir);
-  }
-  return void 0;
+	const { cwd = node_process.default.cwd(), stopAt } = {
+		__proto__: null,
+		...options
+	};
+	let { onlyDirectories = false, onlyFiles = true } = {
+		__proto__: null,
+		...options
+	};
+	if (onlyDirectories) onlyFiles = false;
+	if (onlyFiles) onlyDirectories = false;
+	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const names = require_arrays_predicates.isArray(name) ? name : [name];
+	/* c8 ignore start - native findUp arm only on socket-btm smol binaries; getSmolPath() is undefined on stock Node. */
+	const smolFindUp = (/* @__PURE__ */ require_smol_path.getSmolPath())?.findUp;
+	if (smolFindUp && stopAt === void 0) {
+		const found = smolFindUp(path.resolve(cwd), names, { onlyDirectories });
+		return found === void 0 ? void 0 : /* @__PURE__ */ require_paths_normalize.normalizePath(found);
+	}
+	/* c8 ignore stop */
+	for (const dir of require_paths_walk.walkUp(cwd, { stopAt })) for (const n of names) {
+		const thePath = path.join(dir, n);
+		try {
+			const stats = fs.statSync(thePath);
+			if (!onlyDirectories && stats.isFile()) return /* @__PURE__ */ require_paths_normalize.normalizePath(thePath);
+			if (!onlyFiles && stats.isDirectory()) return /* @__PURE__ */ require_paths_normalize.normalizePath(thePath);
+		} catch {}
+	}
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  findUp,
-  findUpSync
-});
+
+//#endregion
+exports.findUp = findUp;
+exports.findUpSync = findUpSync;

package/dist/fs/inspect.js

@@ -1,112 +1,181 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var inspect_exports = {};
-__export(inspect_exports, {
-  isDir: () => isDir,
-  isDirEmptySync: () => isDirEmptySync,
-  isDirSync: () => isDirSync,
-  isSymlinkSync: () => isSymlinkSync,
-  safeStat: () => safeStat,
-  safeStatSync: () => safeStatSync
-});
-module.exports = __toCommonJS(inspect_exports);
-var import_defaults = require("../globs/defaults");
-var import_matcher = require("../globs/matcher");
-var import_fs = require("../node/fs");
-var import_normalize = require("../paths/normalize");
-// @__NO_SIDE_EFFECTS__
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_paths__internal = require('../paths/_internal.js');
+const require_node_fs = require('../node/fs.js');
+const require_globs_defaults = require('../globs/defaults.js');
+const require_globs_matcher = require('../globs/matcher.js');
+
+//#region src/fs/inspect.ts
+/**
+* @file Filesystem inspection helpers — `stat` / `lstat` wrappers that return
+*   `undefined` instead of throwing, and the directory / symlink / emptiness
+*   predicates layered on top. Every entry point catches errors and reduces
+*   them to a falsy result; callers that need the underlying error code should
+*   use `node:fs` directly.
+*/
+/**
+* Check if a path is a directory asynchronously. Returns `true` for
+* directories, `false` for files or non-existent paths.
+*
+* @example
+*   ;```ts
+*   if (await isDir('./src')) {
+*     console.log('src is a directory')
+*   }
+*   ```
+*
+* @param filepath - Path to check.
+*
+* @returns `true` if path is a directory, `false` otherwise
+*/
+/* @__NO_SIDE_EFFECTS__ */
 async function isDir(filepath) {
-  return !!(await /* @__PURE__ */ safeStat(filepath))?.isDirectory();
+	return !!(await /* @__PURE__ */ safeStat(filepath))?.isDirectory();
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Check if a directory is empty synchronously. A directory is considered empty
+* if it contains no files after applying ignore patterns. Uses glob patterns to
+* filter ignored files.
+*
+* @example
+*   ;```ts
+*   // Check if directory is completely empty
+*   isDirEmptySync('./build')
+*
+*   // Check if directory is empty, ignoring .DS_Store files
+*   isDirEmptySync('./cache', { ignore: ['.DS_Store'] })
+*   ```
+*
+* @param dirname - Directory path to check.
+* @param options - Options including ignore patterns.
+*
+* @returns `true` if directory is empty (or doesn't exist), `false` otherwise
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function isDirEmptySync(dirname, options) {
-  const { ignore = import_defaults.defaultIgnore } = {
-    __proto__: null,
-    ...options
-  };
-  const fs = (0, import_fs.getNodeFs)();
-  try {
-    const files = fs.readdirSync(dirname);
-    const { length } = files;
-    if (length === 0) {
-      return true;
-    }
-    const matcher = (0, import_matcher.getGlobMatcher)(
-      ignore,
-      {
-        cwd: (0, import_normalize.pathLikeToString)(dirname)
-      }
-    );
-    let ignoredCount = 0;
-    for (let i = 0; i < length; i += 1) {
-      const file = files[i];
-      if (file && matcher(file)) {
-        ignoredCount += 1;
-      }
-    }
-    return ignoredCount === length;
-  } catch {
-    return false;
-  }
+	const { ignore = require_globs_defaults.defaultIgnore } = {
+		__proto__: null,
+		...options
+	};
+	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	try {
+		const files = fs.readdirSync(dirname);
+		const { length } = files;
+		if (length === 0) return true;
+		const matcher = /* @__PURE__ */ require_globs_matcher.getGlobMatcher(ignore, { cwd: /* @__PURE__ */ require_paths__internal.pathLikeToString(dirname) });
+		let ignoredCount = 0;
+		for (let i = 0; i < length; i += 1) {
+			const file = files[i];
+			if (file && matcher(file)) ignoredCount += 1;
+		}
+		return ignoredCount === length;
+	} catch {
+		return false;
+	}
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Check if a path is a directory synchronously. Returns `true` for directories,
+* `false` for files or non-existent paths.
+*
+* @example
+*   ;```ts
+*   if (isDirSync('./src')) {
+*     console.log('src is a directory')
+*   }
+*   ```
+*
+* @param filepath - Path to check.
+*
+* @returns `true` if path is a directory, `false` otherwise
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function isDirSync(filepath) {
-  return !!(/* @__PURE__ */ safeStatSync(filepath))?.isDirectory();
+	return !!(/* @__PURE__ */ safeStatSync(filepath))?.isDirectory();
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Check if a path is a symbolic link synchronously. Uses `lstat` to check the
+* link itself, not the target.
+*
+* @example
+*   ;```ts
+*   if (isSymlinkSync('./my-link')) {
+*     console.log('Path is a symbolic link')
+*   }
+*   ```
+*
+* @param filepath - Path to check.
+*
+* @returns `true` if path is a symbolic link, `false` otherwise
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function isSymlinkSync(filepath) {
-  const fs = (0, import_fs.getNodeFs)();
-  try {
-    return fs.lstatSync(filepath).isSymbolicLink();
-  } catch {
-  }
-  return false;
+	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	try {
+		return fs.lstatSync(filepath).isSymbolicLink();
+	} catch {}
+	return false;
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Safely get file stats asynchronously, returning undefined on error. Useful
+* for checking file existence and properties without error handling. Returns
+* undefined for any error (file not found, permission denied, etc.).
+*
+* @example
+*   ;```ts
+*   // Check if file exists and get its stats
+*   const stats = await safeStat('./file.txt')
+*   if (stats) {
+*     console.log('File size:', stats.size)
+*     console.log('Modified:', stats.mtime)
+*   }
+*   ```
+*
+* @param filepath - Path to check.
+*
+* @returns Promise resolving to Stats object, or undefined on error
+*/
+/* @__NO_SIDE_EFFECTS__ */
 async function safeStat(filepath) {
-  const fs = (0, import_fs.getNodeFs)();
-  try {
-    return await fs.promises.stat(filepath);
-  } catch {
-  }
-  return void 0;
+	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	try {
+		return await fs.promises.stat(filepath);
+	} catch {}
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Safely get file stats synchronously, returning undefined on error. Useful for
+* checking file existence and properties without error handling. Returns
+* undefined for any error (file not found, permission denied, etc.).
+*
+* @example
+*   ;```ts
+*   // Check if file exists and get its size
+*   const stats = safeStatSync('./file.txt')
+*   if (stats) {
+*     console.log('File size:', stats.size)
+*     console.log('Is directory:', stats.isDirectory())
+*   }
+*   ```
+*
+* @param filepath - Path to check.
+*
+* @returns Stats object, or undefined on error
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function safeStatSync(filepath) {
-  const fs = (0, import_fs.getNodeFs)();
-  try {
-    return fs.statSync(filepath, {
-      __proto__: null,
-      throwIfNoEntry: false
-    });
-  } catch {
-  }
-  return void 0;
+	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	try {
+		return fs.statSync(filepath, {
+			__proto__: null,
+			throwIfNoEntry: false
+		});
+	} catch {}
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  isDir,
-  isDirEmptySync,
-  isDirSync,
-  isSymlinkSync,
-  safeStat,
-  safeStatSync
-});
+
+//#endregion
+exports.isDir = isDir;
+exports.isDirEmptySync = isDirEmptySync;
+exports.isDirSync = isDirSync;
+exports.isSymlinkSync = isSymlinkSync;
+exports.safeStat = safeStat;
+exports.safeStatSync = safeStatSync;

package/dist/fs/path-cache.js

@@ -1,35 +1,34 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var path_cache_exports = {};
-__export(path_cache_exports, {
-  invalidatePathCache: () => invalidatePathCache
-});
-module.exports = __toCommonJS(path_cache_exports);
-var import_rewire = require("../paths/rewire");
-var import_internal = require("./_internal");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_paths_rewire = require('../paths/rewire.js');
+const require_fs__internal = require('./_internal.js');
+
+//#region src/fs/path-cache.ts
+/**
+* @file Cache-invalidation entry point for the allowed-directories list used by
+*   `safeDelete` / `safeDeleteSync`. Loading this module registers
+*   `invalidatePathCache` with `paths/rewire.ts` so test-time path overrides
+*   flush the cache; the registration is the module's only side effect, so
+*   callers that just need to flush the cache imperatively can call
+*   `invalidatePathCache()` directly without that side effect repeating.
+*/
+/**
+* Invalidate the cached allowed directories. Called automatically by the
+* paths/rewire module when paths are overridden in tests.
+*
+* @example
+*   ;```typescript
+*   invalidatePathCache()
+*   // Cached allowed directories are now cleared
+*   ```
+*
+* @internal Used for test rewiring
+*/
 function invalidatePathCache() {
-  (0, import_internal.clearAllowedDirectories)();
+	require_fs__internal.clearAllowedDirectories();
 }
-(0, import_rewire.registerCacheInvalidation)(invalidatePathCache);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  invalidatePathCache
-});
+require_paths_rewire.registerCacheInvalidation(invalidatePathCache);
+
+//#endregion
+exports.invalidatePathCache = invalidatePathCache;