@socketsecurity/lib 6.0.6 → 6.0.8

package/dist/external-tools/trufflehog/from-download.js

@@ -5,10 +5,10 @@ const require_runtime = require('../../_virtual/_rolldown/runtime.js');
 const require_paths_socket = require('../../paths/socket.js');
 const require_external_tools_from_download = require('../from-download.js');
 const require_external_tools_trufflehog_asset_names = require('./asset-names.js');
-let node_path = require("node:path");
-node_path = require_runtime.__toESM(node_path);
 let node_process = require("node:process");
 node_process = require_runtime.__toESM(node_process);
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
 
 //#region src/external-tools/trufflehog/from-download.ts
 /**
@@ -20,8 +20,11 @@ node_process = require_runtime.__toESM(node_process);
 *   check, no network. Trust-on-first-use: pass `integrity` from
 *   `external-tools.json` when available.
 */
-async function trufflehogFromDownload(opts) {
-	const { cacheDir, downloader, integrity, platformArch, version } = opts;
+async function trufflehogFromDownload(options) {
+	const { cacheDir, downloader, integrity, platformArch, version } = {
+		__proto__: null,
+		...options
+	};
 	const url = require_external_tools_trufflehog_asset_names.getTrufflehogDownloadUrl({
 		version,
 		platformArch

package/dist/external-tools/trufflehog/from-vfs.js

@@ -14,7 +14,7 @@ const require_smol_vfs = require('../../smol/vfs.js');
 */
 const TRUFFLEHOG_VFS_KEY = "trufflehog";
 async function trufflehogFromVfs() {
-	const vfs = /* @__PURE__ */ require_smol_vfs.getSmolVfs();
+	const vfs = require_smol_vfs.getSmolVfs();
 	if (!vfs) return;
 	/* c8 ignore start - smol Node binary only. */
 	if (!vfs.has("trufflehog")) return;

package/dist/external-tools/trufflehog/resolve.d.ts

@@ -24,7 +24,7 @@ export interface ResolveTrufflehogOptions {
         downloader?: BinaryDownloader | undefined;
     } | undefined;
 }
-export declare function cacheKey(opts: ResolveTrufflehogOptions | undefined): string;
-export declare function doResolveTrufflehog(opts?: ResolveTrufflehogOptions | undefined): Promise<ResolvedTrufflehog | undefined>;
+export declare function cacheKey(options: ResolveTrufflehogOptions | undefined): string;
+export declare function doResolveTrufflehog(options?: ResolveTrufflehogOptions | undefined): Promise<ResolvedTrufflehog | undefined>;
 export declare function resetTrufflehogResolution(): void;
-export declare function resolveTrufflehog(opts?: ResolveTrufflehogOptions | undefined): Promise<ResolvedTrufflehog | undefined>;
+export declare function resolveTrufflehog(options?: ResolveTrufflehogOptions | undefined): Promise<ResolvedTrufflehog | undefined>;

package/dist/external-tools/trufflehog/resolve.js

@@ -18,30 +18,38 @@ const require_external_tools_trufflehog_from_vfs = require('./from-vfs.js');
 *      per option-shape; same caching semantics as `resolveJre()`.
 */
 const resolutionCache = new require_primordials_map_set.MapCtor();
-function cacheKey(opts) {
-	if (!opts?.downloadIfMissing) return "local-only";
-	const { cacheDir, integrity, platformArch, version } = opts.downloadIfMissing;
+function cacheKey(options) {
+	options = {
+		__proto__: null,
+		...options
+	};
+	if (!options?.downloadIfMissing) return "local-only";
+	const { cacheDir, integrity, platformArch, version } = options.downloadIfMissing;
 	return `dl:${version}:${platformArch}:${typeof integrity === "string" ? integrity : integrity ? `${integrity.type}:${integrity.value}` : ""}:${cacheDir ?? ""}`;
 }
-async function doResolveTrufflehog(opts) {
+async function doResolveTrufflehog(options) {
+	options = {
+		__proto__: null,
+		...options
+	};
 	const fromVfs = await require_external_tools_trufflehog_from_vfs.trufflehogFromVfs();
 	/* c8 ignore start - smol Node binary only. */
 	if (fromVfs) return fromVfs;
 	/* c8 ignore stop */
 	const fromPath = await require_external_tools_trufflehog_from_path.trufflehogFromPath();
 	if (fromPath) return fromPath;
-	if (opts?.downloadIfMissing) return require_external_tools_trufflehog_from_download.trufflehogFromDownload(opts.downloadIfMissing);
+	if (options?.downloadIfMissing) return require_external_tools_trufflehog_from_download.trufflehogFromDownload(options.downloadIfMissing);
 }
 /* c8 ignore start - test-only escape hatch. */
 function resetTrufflehogResolution() {
 	resolutionCache.clear();
 }
 /* c8 ignore stop */
-function resolveTrufflehog(opts) {
-	const key = cacheKey(opts);
+function resolveTrufflehog(options) {
+	const key = cacheKey(options);
 	let cached = resolutionCache.get(key);
 	if (!cached) {
-		cached = doResolveTrufflehog(opts);
+		cached = doResolveTrufflehog(options);
 		resolutionCache.set(key, cached);
 	}
 	return cached;

package/dist/external-tools/trufflehog/types.d.ts

@@ -21,5 +21,5 @@ export interface ResolvedTrufflehog {
     /**
      * See {@link ResolvedToolIntegrity}.
      */
-    readonly integrity?: ResolvedToolIntegrity;
+    readonly integrity?: ResolvedToolIntegrity | undefined;
 }

package/dist/fs/_internal.d.ts

@@ -2,7 +2,7 @@
  * @file Private state shared between `fs/safe` and `fs/path-cache`. The `_`
  *   prefix keeps this module out of the generated package.json `exports` map
  *   (the `dist/**\/_*` ignore pattern in
- *   `scripts/fix/generate-package-exports.mts` filters it out), so it is not
+ *   `scripts/post-build/make-package-exports.mts` filters it out), so it is not
  *   part of the public surface — it exists only to give the two leaves above a
  *   common owner for the allowed-directory cache. The cache is invalidated by
  *   `invalidatePathCache()` in `fs/path-cache.ts` whenever paths are rewired in

package/dist/fs/_internal.js

@@ -9,36 +9,36 @@ const require_paths_socket = require('../paths/socket.js');
 * @file Private state shared between `fs/safe` and `fs/path-cache`. The `_`
 *   prefix keeps this module out of the generated package.json `exports` map
 *   (the `dist/**\/_*` ignore pattern in
-*   `scripts/fix/generate-package-exports.mts` filters it out), so it is not
+*   `scripts/post-build/make-package-exports.mts` filters it out), so it is not
 *   part of the public surface — it exists only to give the two leaves above a
 *   common owner for the allowed-directory cache. The cache is invalidated by
 *   `invalidatePathCache()` in `fs/path-cache.ts` whenever paths are rewired in
 *   tests (`paths/rewire.ts` registers `invalidatePathCache` as one of its
 *   cache callbacks); `getAllowedDirectories()` rehydrates on next call.
 */
-let _cachedAllowedDirs;
+let cachedAllowedDirs;
 /**
 * Clear the cached allowed-directories list. Used by `invalidatePathCache()`
 * when test path rewiring changes any of the underlying paths so the next read
 * picks up the new resolved values.
 */
 function clearAllowedDirectories() {
-	_cachedAllowedDirs = void 0;
+	cachedAllowedDirs = void 0;
 }
 /**
 * Get resolved allowed directories for safe deletion with lazy caching. These
 * directories are resolved once and cached for the process lifetime.
 */
 function getAllowedDirectories() {
-	if (_cachedAllowedDirs === void 0) {
-		const path = /* @__PURE__ */ require_node_path.getNodePath();
-		_cachedAllowedDirs = [
+	if (cachedAllowedDirs === void 0) {
+		const path = require_node_path.getNodePath();
+		cachedAllowedDirs = [
 			path.resolve(require_paths_socket.getOsTmpDir()),
 			path.resolve(require_paths_socket.getSocketCacacheDir()),
 			path.resolve(require_paths_socket.getSocketUserDir())
 		];
 	}
-	return _cachedAllowedDirs;
+	return cachedAllowedDirs;
 }
 
 //#endregion

package/dist/fs/access.js

@@ -23,13 +23,12 @@ const require_smol_path = require('../smol/path.js');
 *
 * @returns True if the access check succeeds.
 */
-/*@__NO_SIDE_EFFECTS__*/
 function canAccess(path, mode) {
 	/* c8 ignore start - native access arm only on socket-btm smol binaries; getSmolPath() is undefined on stock Node. */
-	const smolAccess = (/* @__PURE__ */ require_smol_path.getSmolPath())?.access;
+	const smolAccess = require_smol_path.getSmolPath()?.access;
 	if (smolAccess) return smolAccess(path, mode);
 	/* c8 ignore stop */
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const fs = require_node_fs.getNodeFs();
 	try {
 		fs.accessSync(path, mode);
 		return true;
@@ -40,23 +39,20 @@ function canAccess(path, mode) {
 /**
 * Can the process execute `path`? (`X_OK`)
 */
-/*@__NO_SIDE_EFFECTS__*/
 function canExecute(path) {
-	return /* @__PURE__ */ canAccess(path, (/* @__PURE__ */ require_node_fs.getNodeFs()).constants.X_OK);
+	return canAccess(path, require_node_fs.getNodeFs().constants.X_OK);
 }
 /**
 * Can the process read `path`? (`R_OK`)
 */
-/*@__NO_SIDE_EFFECTS__*/
 function canRead(path) {
-	return /* @__PURE__ */ canAccess(path, (/* @__PURE__ */ require_node_fs.getNodeFs()).constants.R_OK);
+	return canAccess(path, require_node_fs.getNodeFs().constants.R_OK);
 }
 /**
 * Can the process write `path`? (`W_OK`)
 */
-/*@__NO_SIDE_EFFECTS__*/
 function canWrite(path) {
-	return /* @__PURE__ */ canAccess(path, (/* @__PURE__ */ require_node_fs.getNodeFs()).constants.W_OK);
+	return canAccess(path, require_node_fs.getNodeFs().constants.W_OK);
 }
 
 //#endregion

package/dist/fs/allowed-dirs-cache.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @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. The
+ *   registration is deferred to a microtask (`registerInvalidationCallback`)
+ *   rather than run at top-level module load. This module sits in a require
+ *   cycle (`allowed-dirs-cache → _internal → paths/socket → …`); in the bundled
+ *   CJS the `registerCacheInvalidation` import binding from `paths/rewire` is
+ *   not yet initialized when this module first evaluates, so a synchronous
+ *   top-level call threw `registerCacheInvalidation is not defined` at require
+ *   time. Deferring to a microtask runs the call after the module graph has
+ *   settled, breaking the init-order hazard while keeping the load-time
+ *   registration contract (the callback is in place before any test hook
+ *   fires).
+ */
+/**
+ * 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
+ */
+export declare function invalidatePathCache(): void;
+/**
+ * Register `invalidatePathCache` with the rewire module after the current
+ * module-init turn, so the circular import is fully wired before the call.
+ * Guarded + self-rescheduling: in the require cycle (`allowed-dirs-cache →
+ * _internal → paths/socket → … → rewire`) the `registerCacheInvalidation` live
+ * binding can still be in its temporal dead zone when the first microtask fires
+ * under some import orders (vitest loads many modules concurrently), throwing
+ * `registerCacheInvalidation is not defined`. So check the binding is callable;
+ * if not, re-defer to the next microtask. The registration is a test-seam
+ * best-effort (it lets path-rewire flush this cache), so a bounded retry that
+ * lands on a later turn is correct — and a never-resolving binding (production,
+ * where rewire is unused) simply stops retrying without throwing.
+ *
+ * @internal
+ */
+export declare function registerInvalidationCallback(attempt?: number): void;

package/dist/fs/allowed-dirs-cache.js

@@ -0,0 +1,69 @@
+"use strict";
+/* 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/allowed-dirs-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. The
+*   registration is deferred to a microtask (`registerInvalidationCallback`)
+*   rather than run at top-level module load. This module sits in a require
+*   cycle (`allowed-dirs-cache → _internal → paths/socket → …`); in the bundled
+*   CJS the `registerCacheInvalidation` import binding from `paths/rewire` is
+*   not yet initialized when this module first evaluates, so a synchronous
+*   top-level call threw `registerCacheInvalidation is not defined` at require
+*   time. Deferring to a microtask runs the call after the module graph has
+*   settled, breaking the init-order hazard while keeping the load-time
+*   registration contract (the callback is in place before any test hook
+*   fires).
+*/
+/**
+* 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() {
+	require_fs__internal.clearAllowedDirectories();
+}
+/**
+* Register `invalidatePathCache` with the rewire module after the current
+* module-init turn, so the circular import is fully wired before the call.
+* Guarded + self-rescheduling: in the require cycle (`allowed-dirs-cache →
+* _internal → paths/socket → … → rewire`) the `registerCacheInvalidation` live
+* binding can still be in its temporal dead zone when the first microtask fires
+* under some import orders (vitest loads many modules concurrently), throwing
+* `registerCacheInvalidation is not defined`. So check the binding is callable;
+* if not, re-defer to the next microtask. The registration is a test-seam
+* best-effort (it lets path-rewire flush this cache), so a bounded retry that
+* lands on a later turn is correct — and a never-resolving binding (production,
+* where rewire is unused) simply stops retrying without throwing.
+*
+* @internal
+*/
+function registerInvalidationCallback(attempt = 0) {
+	try {
+		if (typeof require_paths_rewire.registerCacheInvalidation === "function") {
+			require_paths_rewire.registerCacheInvalidation(invalidatePathCache);
+			return;
+		}
+	} catch {}
+	if (attempt < 10) queueMicrotask(() => registerInvalidationCallback(attempt + 1));
+}
+queueMicrotask(() => registerInvalidationCallback());
+
+//#endregion
+exports.invalidatePathCache = invalidatePathCache;
+exports.registerInvalidationCallback = registerInvalidationCallback;

package/dist/fs/encoding.js

@@ -23,9 +23,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 *
 * @see https://github.com/nodejs/node/blob/ae62b36d442b7bf987e85ae6e0df0f02cc1bb17f/lib/internal/util.js#L247-L310
 */
-/*@__NO_SIDE_EFFECTS__*/
 function normalizeEncoding(enc) {
-	return enc == null || enc === "utf8" || enc === "utf-8" ? "utf8" : /* @__PURE__ */ normalizeEncodingSlow(enc);
+	return enc == null || enc === "utf8" || enc === "utf-8" ? "utf8" : normalizeEncodingSlow(enc);
 }
 /**
 * Move the "slow cases" to a separate function to make sure this function gets
@@ -46,11 +45,10 @@ function normalizeEncoding(enc) {
 *
 * @see https://github.com/nodejs/node/blob/ae62b36d442b7bf987e85ae6e0df0f02cc1bb17f/lib/internal/util.js#L247-L310
 */
-/*@__NO_SIDE_EFFECTS__*/
 function normalizeEncodingSlow(enc) {
 	const { length } = enc;
 	if (length === 4) {
-		if (enc === "ucs2" || enc === "UCS2") return "utf16le";
+		if (enc === "UCS2" || enc === "ucs2") return "utf16le";
 		if (enc.toLowerCase() === "ucs2") return "utf16le";
 	} else if (length === 3 && enc === "hex" || enc === "HEX" || enc.toLowerCase() === "hex") return "hex";
 	else if (length === 5) {
@@ -63,12 +61,12 @@ function normalizeEncodingSlow(enc) {
 		if (enc === "ucs-2") return "utf16le";
 	} else if (length === 6) {
 		if (enc === "base64") return "base64";
-		if (enc === "latin1" || enc === "binary") return "latin1";
+		if (enc === "binary" || enc === "latin1") return "latin1";
 		if (enc === "BASE64") return "base64";
-		if (enc === "LATIN1" || enc === "BINARY") return "latin1";
+		if (enc === "BINARY" || enc === "LATIN1") return "latin1";
 		enc = enc.toLowerCase();
 		if (enc === "base64") return "base64";
-		if (enc === "latin1" || enc === "binary") return "latin1";
+		if (enc === "binary" || enc === "latin1") return "latin1";
 	} else if (length === 7) {
 		if (enc === "utf16le" || enc === "UTF16LE" || enc.toLowerCase() === "utf16le") return "utf16le";
 	} else if (length === 8) {

package/dist/fs/{find-up.js → find.js}

@@ -2,17 +2,17 @@
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('../_virtual/_rolldown/runtime.js');
+const require_arrays_predicates = require('../arrays/predicates.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
+//#region src/fs/find.ts
 /**
 * @file Walk parent directories to locate a file or directory by name. The
 *   traversal includes the filesystem root (or the caller-supplied `stopAt`
@@ -43,7 +43,6 @@ const abortSignal = require_process_abort.getAbortSignal();
 *
 * @returns Normalized absolute path if found, undefined otherwise
 */
-/*@__NO_SIDE_EFFECTS__*/
 async function findUp(name, options) {
 	const { cwd = node_process.default.cwd(), signal = abortSignal } = {
 		__proto__: null,
@@ -55,16 +54,16 @@ async function findUp(name, options) {
 	};
 	if (onlyDirectories) onlyFiles = false;
 	if (onlyFiles) onlyDirectories = false;
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
-	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const fs = require_node_fs.getNodeFs();
+	const path = 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);
+			if (!onlyDirectories && stats.isFile()) return require_paths_normalize.normalizePath(thePath);
+			if (!onlyFiles && stats.isDirectory()) return require_paths_normalize.normalizePath(thePath);
 		} catch {}
 	}
 }
@@ -94,7 +93,6 @@ async function findUp(name, options) {
 *
 * @returns Normalized absolute path if found, undefined otherwise
 */
-/*@__NO_SIDE_EFFECTS__*/
 function findUpSync(name, options) {
 	const { cwd = node_process.default.cwd(), stopAt } = {
 		__proto__: null,
@@ -106,22 +104,22 @@ function findUpSync(name, options) {
 	};
 	if (onlyDirectories) onlyFiles = false;
 	if (onlyFiles) onlyDirectories = false;
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
-	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const fs = require_node_fs.getNodeFs();
+	const path = 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;
+	const smolFindUp = 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);
+		return found === void 0 ? void 0 : 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);
+			if (!onlyDirectories && stats.isFile()) return require_paths_normalize.normalizePath(thePath);
+			if (!onlyFiles && stats.isDirectory()) return require_paths_normalize.normalizePath(thePath);
 		} catch {}
 	}
 }

package/dist/fs/inspect.js

@@ -29,9 +29,8 @@ const require_globs_matcher = require('../globs/matcher.js');
 *
 * @returns `true` if path is a directory, `false` otherwise
 */
-/*@__NO_SIDE_EFFECTS__*/
 async function isDir(filepath) {
-	return !!(await /* @__PURE__ */ safeStat(filepath))?.isDirectory();
+	return !!(await safeStat(filepath))?.isDirectory();
 }
 /**
 * Check if a directory is empty synchronously. A directory is considered empty
@@ -52,18 +51,17 @@ async function isDir(filepath) {
 *
 * @returns `true` if directory is empty (or doesn't exist), `false` otherwise
 */
-/*@__NO_SIDE_EFFECTS__*/
 function isDirEmptySync(dirname, options) {
 	const { ignore = require_globs_defaults.defaultIgnore } = {
 		__proto__: null,
 		...options
 	};
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const fs = 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) });
+		const matcher = require_globs_matcher.getGlobMatcher(ignore, { cwd: require_paths__internal.pathLikeToString(dirname) });
 		let ignoredCount = 0;
 		for (let i = 0; i < length; i += 1) {
 			const file = files[i];
@@ -89,9 +87,8 @@ function isDirEmptySync(dirname, options) {
 *
 * @returns `true` if path is a directory, `false` otherwise
 */
-/*@__NO_SIDE_EFFECTS__*/
 function isDirSync(filepath) {
-	return !!(/* @__PURE__ */ safeStatSync(filepath))?.isDirectory();
+	return !!safeStatSync(filepath)?.isDirectory();
 }
 /**
 * Check if a path is a symbolic link synchronously. Uses `lstat` to check the
@@ -108,9 +105,8 @@ function isDirSync(filepath) {
 *
 * @returns `true` if path is a symbolic link, `false` otherwise
 */
-/*@__NO_SIDE_EFFECTS__*/
 function isSymlinkSync(filepath) {
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const fs = require_node_fs.getNodeFs();
 	try {
 		return fs.lstatSync(filepath).isSymbolicLink();
 	} catch {}
@@ -135,9 +131,8 @@ function isSymlinkSync(filepath) {
 *
 * @returns Promise resolving to Stats object, or undefined on error
 */
-/*@__NO_SIDE_EFFECTS__*/
 async function safeStat(filepath) {
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const fs = require_node_fs.getNodeFs();
 	try {
 		return await fs.promises.stat(filepath);
 	} catch {}
@@ -161,9 +156,8 @@ async function safeStat(filepath) {
 *
 * @returns Stats object, or undefined on error
 */
-/*@__NO_SIDE_EFFECTS__*/
 function safeStatSync(filepath) {
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const fs = require_node_fs.getNodeFs();
 	try {
 		return fs.statSync(filepath, {
 			__proto__: null,

package/dist/fs/read-dir.js

@@ -24,15 +24,14 @@ const require_fs_inspect = require('./inspect.js');
 *
 * @returns Array of directory names, optionally sorted
 */
-/*@__NO_SIDE_EFFECTS__*/
 function innerReadDirNames(dirents, dirname, options) {
 	const { ignore, includeEmpty = true, sort = true } = {
 		__proto__: null,
 		...options
 	};
-	const path = /* @__PURE__ */ require_node_path.getNodePath();
-	const names = dirents.filter((d) => d.isDirectory() && (includeEmpty || !/* @__PURE__ */ require_fs_inspect.isDirEmptySync(path.join(dirname || d.parentPath, d.name), { ignore }))).map((d) => d.name);
-	return sort ? names.sort(require_sorts_natural.naturalCompare) : names;
+	const path = require_node_path.getNodePath();
+	const names = dirents.filter((d) => d.isDirectory() && (includeEmpty || !require_fs_inspect.isDirEmptySync(path.join(dirname || d.parentPath, d.name), { ignore }))).map((d) => d.name);
+	return sort ? names.toSorted(require_sorts_natural.naturalCompare) : names;
 }
 /**
 * Read directory names asynchronously with filtering and sorting. Returns only
@@ -56,11 +55,10 @@ function innerReadDirNames(dirents, dirname, options) {
 *
 * @returns Array of directory names, empty array on error
 */
-/*@__NO_SIDE_EFFECTS__*/
 async function readDirNames(dirname, options) {
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const fs = require_node_fs.getNodeFs();
 	try {
-		return /* @__PURE__ */ innerReadDirNames(await fs.promises.readdir(dirname, {
+		return innerReadDirNames(await fs.promises.readdir(dirname, {
 			__proto__: null,
 			encoding: "utf8",
 			withFileTypes: true
@@ -90,11 +88,10 @@ async function readDirNames(dirname, options) {
 *
 * @returns Array of directory names, empty array on error
 */
-/*@__NO_SIDE_EFFECTS__*/
 function readDirNamesSync(dirname, options) {
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const fs = require_node_fs.getNodeFs();
 	try {
-		return /* @__PURE__ */ innerReadDirNames(fs.readdirSync(dirname, {
+		return innerReadDirNames(fs.readdirSync(dirname, {
 			__proto__: null,
 			encoding: "utf8",
 			withFileTypes: true

package/dist/fs/read-file.js

@@ -34,10 +34,9 @@ const abortSignal = require_process_abort.getAbortSignal();
 *
 * @returns Promise resolving to Buffer containing file contents
 */
-/*@__NO_SIDE_EFFECTS__*/
 async function readFileBinary(filepath, options) {
 	const opts = typeof options === "string" ? { encoding: options } : options;
-	return await (/* @__PURE__ */ require_node_fs.getNodeFs()).promises.readFile(filepath, {
+	return await require_node_fs.getNodeFs().promises.readFile(filepath, {
 		signal: abortSignal,
 		...opts,
 		encoding: void 0
@@ -61,10 +60,9 @@ async function readFileBinary(filepath, options) {
 *
 * @returns Buffer containing file contents
 */
-/*@__NO_SIDE_EFFECTS__*/
 function readFileBinarySync(filepath, options) {
 	const opts = typeof options === "string" ? { encoding: options } : options;
-	return (/* @__PURE__ */ require_node_fs.getNodeFs()).readFileSync(filepath, {
+	return require_node_fs.getNodeFs().readFileSync(filepath, {
 		...opts,
 		encoding: void 0
 	});
@@ -87,10 +85,9 @@ function readFileBinarySync(filepath, options) {
 *
 * @returns Promise resolving to string containing file contents
 */
-/*@__NO_SIDE_EFFECTS__*/
 async function readFileUtf8(filepath, options) {
 	const opts = typeof options === "string" ? { encoding: options } : options;
-	return await (/* @__PURE__ */ require_node_fs.getNodeFs()).promises.readFile(filepath, {
+	return await require_node_fs.getNodeFs().promises.readFile(filepath, {
 		signal: abortSignal,
 		...opts,
 		encoding: "utf8"
@@ -115,15 +112,13 @@ async function readFileUtf8(filepath, options) {
 *
 * @returns String containing file contents
 */
-/*@__NO_SIDE_EFFECTS__*/
 function readFileUtf8Sync(filepath, options) {
 	const opts = typeof options === "string" ? { encoding: options } : options;
-	return (/* @__PURE__ */ require_node_fs.getNodeFs()).readFileSync(filepath, {
+	return require_node_fs.getNodeFs().readFileSync(filepath, {
 		...opts,
 		encoding: "utf8"
 	});
 }
-/*@__NO_SIDE_EFFECTS__*/
 async function safeReadFile(filepath, options) {
 	const { defaultValue, ...rawReadOpts } = typeof options === "string" ? {
 		__proto__: null,
@@ -138,8 +133,8 @@ async function safeReadFile(filepath, options) {
 	};
 	const shouldReturnBuffer = readOpts.encoding === null;
 	/* c8 ignore next 3 */
-	const encoding = shouldReturnBuffer ? void 0 : /* @__PURE__ */ require_fs_encoding.normalizeEncoding(readOpts.encoding);
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const encoding = shouldReturnBuffer ? void 0 : require_fs_encoding.normalizeEncoding(readOpts.encoding);
+	const fs = require_node_fs.getNodeFs();
 	try {
 		return await fs.promises.readFile(filepath, {
 			__proto__: null,
@@ -152,7 +147,6 @@ async function safeReadFile(filepath, options) {
 	if (shouldReturnBuffer) return require_primordials_buffer.BufferIsBuffer(defaultValue) ? defaultValue : void 0;
 	return typeof defaultValue === "string" ? defaultValue : String(defaultValue);
 }
-/*@__NO_SIDE_EFFECTS__*/
 function safeReadFileSync(filepath, options) {
 	const { defaultValue, ...rawReadOpts } = typeof options === "string" ? {
 		__proto__: null,
@@ -167,8 +161,8 @@ function safeReadFileSync(filepath, options) {
 	};
 	const shouldReturnBuffer = readOpts.encoding === null;
 	/* c8 ignore next 3 */
-	const encoding = shouldReturnBuffer ? void 0 : /* @__PURE__ */ require_fs_encoding.normalizeEncoding(readOpts.encoding);
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const encoding = shouldReturnBuffer ? void 0 : require_fs_encoding.normalizeEncoding(readOpts.encoding);
+	const fs = require_node_fs.getNodeFs();
 	try {
 		return fs.readFileSync(filepath, {
 			__proto__: null,