@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/paths/predicates.js

@@ -0,0 +1,121 @@
+"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 predicates_exports = {};
+__export(predicates_exports, {
+  isAbsolute: () => isAbsolute,
+  isNodeModules: () => isNodeModules,
+  isPath: () => isPath,
+  isPathSeparator: () => isPathSeparator,
+  isRelative: () => isRelative,
+  isUnixPath: () => isUnixPath,
+  isWindowsDeviceRoot: () => isWindowsDeviceRoot
+});
+module.exports = __toCommonJS(predicates_exports);
+var import_platform = require("../constants/platform");
+var import_regexp = require("../primordials/regexp");
+var import_string = require("../primordials/string");
+var import_internal = require("./_internal");
+// @__NO_SIDE_EFFECTS__
+function isAbsolute(pathLike) {
+  const filepath = (0, import_internal.pathLikeToString)(pathLike);
+  const { length } = filepath;
+  if (length === 0) {
+    return false;
+  }
+  const code = (0, import_string.StringPrototypeCharCodeAt)(filepath, 0);
+  if (code === import_internal.CHAR_FORWARD_SLASH) {
+    return true;
+  }
+  if (code === import_internal.CHAR_BACKWARD_SLASH) {
+    return true;
+  }
+  if (import_platform.WIN32 && length > 2) {
+    if (/* @__PURE__ */ isWindowsDeviceRoot(code) && (0, import_string.StringPrototypeCharCodeAt)(filepath, 1) === import_internal.CHAR_COLON && /* @__PURE__ */ isPathSeparator((0, import_string.StringPrototypeCharCodeAt)(filepath, 2))) {
+      return true;
+    }
+  }
+  return false;
+}
+// @__NO_SIDE_EFFECTS__
+function isNodeModules(pathLike) {
+  const filepath = (0, import_internal.pathLikeToString)(pathLike);
+  return (0, import_regexp.RegExpPrototypeTest)(import_internal.nodeModulesPathRegExp, filepath);
+}
+// @__NO_SIDE_EFFECTS__
+function isPath(pathLike) {
+  const filepath = (0, import_internal.pathLikeToString)(pathLike);
+  if (typeof filepath !== "string" || filepath.length === 0) {
+    return false;
+  }
+  if (/^[a-z][a-z0-9+.-]+:/i.test(filepath)) {
+    return false;
+  }
+  if (filepath === "." || filepath === "..") {
+    return true;
+  }
+  if (/* @__PURE__ */ isAbsolute(filepath)) {
+    return true;
+  }
+  if (filepath.includes("/") || filepath.includes("\\")) {
+    if ((0, import_string.StringPrototypeStartsWith)(filepath, "@") && !(0, import_string.StringPrototypeStartsWith)(filepath, "@/")) {
+      const parts = filepath.split("/");
+      if (parts.length <= 2 && !parts[1]?.includes("\\")) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+// @__NO_SIDE_EFFECTS__
+function isPathSeparator(code) {
+  return code === import_internal.CHAR_FORWARD_SLASH || code === import_internal.CHAR_BACKWARD_SLASH;
+}
+// @__NO_SIDE_EFFECTS__
+function isRelative(pathLike) {
+  const filepath = (0, import_internal.pathLikeToString)(pathLike);
+  if (typeof filepath !== "string") {
+    return false;
+  }
+  if (filepath.length === 0) {
+    return true;
+  }
+  return !/* @__PURE__ */ isAbsolute(filepath);
+}
+// @__NO_SIDE_EFFECTS__
+function isUnixPath(pathLike) {
+  const filepath = (0, import_internal.pathLikeToString)(pathLike);
+  return typeof filepath === "string" && (0, import_regexp.RegExpPrototypeTest)(import_internal.msysDriveRegExp, filepath);
+}
+// @__NO_SIDE_EFFECTS__
+function isWindowsDeviceRoot(code) {
+  return code >= import_internal.CHAR_UPPERCASE_A && code <= import_internal.CHAR_UPPERCASE_Z || code >= import_internal.CHAR_LOWERCASE_A && code <= import_internal.CHAR_LOWERCASE_Z;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isAbsolute,
+  isNodeModules,
+  isPath,
+  isPathSeparator,
+  isRelative,
+  isUnixPath,
+  isWindowsDeviceRoot
+});

package/dist/paths/resolve.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @file Path resolution utilities — `resolve`, `relative`, `relativeResolve`.
+ *   Split out of `paths/normalize.ts` for size hygiene.
+ *
+ *   - `resolve` — Node-style `path.resolve()` over absolute-path semantics
+ *   - `relative` — relative path from one absolute to another
+ *   - `relativeResolve` — `relative` + `normalizePath` convenience wrapper
+ */
+/**
+ * Calculate the relative path from one path to another.
+ *
+ * Both inputs are resolved to absolute paths first, then compared to find the
+ * longest common base, and finally a relative path is constructed using `../`
+ * for parent-directory traversal.
+ *
+ * Windows file systems are case-insensitive; the comparison reflects that.
+ *
+ * @example
+ *   ;```typescript
+ *   relative('/foo/bar', '/foo/baz') // '../baz'
+ *   relative('/foo/bar/baz', '/foo') // '../..'
+ *   relative('/foo', '/foo/bar') // 'bar'
+ *   relative('/foo/bar', '/foo/bar') // ''
+ *   ```
+ *
+ * @param {string} from - Source path.
+ * @param {string} to - Destination path.
+ *
+ * @returns {string} Relative path from `from` to `to`, or empty string if equal
+ */
+export declare function relative(from: string, to: string): string;
+/**
+ * Get the normalized relative path from one path to another.
+ *
+ * Computes the relative path using `relative()` then runs the result through
+ * `normalizePath()`. Empty strings (same path) are preserved verbatim rather
+ * than collapsed to `.`.
+ *
+ * @example
+ *   ;```typescript
+ *   relativeResolve('/foo/bar', '/foo/baz') // '../baz'
+ *   relativeResolve('/foo/bar', '/foo/bar') // ''
+ *   relativeResolve('/foo/./bar', '/foo/baz') // '../baz'
+ *   ```
+ *
+ * @param {string} from - Source path.
+ * @param {string} to - Destination path.
+ *
+ * @returns {string} Normalized relative path, or empty string if equal
+ */
+export declare function relativeResolve(from: string, to: string): string;
+/**
+ * Resolve an absolute path from path segments.
+ *
+ * Mimics Node.js `path.resolve()`: processes segments right-to-left, stops at
+ * the first absolute segment, and prepends the cwd if no absolute segment is
+ * found. The final path is normalized.
+ *
+ * @example
+ *   ;```typescript
+ *   resolve('foo', 'bar', 'baz') // '/cwd/foo/bar/baz'
+ *   resolve('/foo', 'bar', 'baz') // '/foo/bar/baz'
+ *   resolve('foo', '/bar', 'baz') // '/bar/baz'
+ *   resolve() // '/cwd'
+ *   ```
+ *
+ * @param {...string} segments - Path segments to resolve.
+ *
+ * @returns {string} The resolved absolute path
+ */
+export declare function resolve(...segments: string[]): string;

package/dist/paths/resolve.js

@@ -0,0 +1,135 @@
+"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 resolve_exports = {};
+__export(resolve_exports, {
+  relative: () => relative,
+  relativeResolve: () => relativeResolve,
+  resolve: () => resolve
+});
+module.exports = __toCommonJS(resolve_exports);
+var import_platform = require("../constants/platform");
+var import_string = require("../primordials/string");
+var import_internal = require("./_internal");
+var import_normalize = require("./normalize");
+var import_predicates = require("./predicates");
+// @__NO_SIDE_EFFECTS__
+function relative(from, to) {
+  if (from === to) {
+    return "";
+  }
+  const actualFrom = /* @__PURE__ */ resolve(from);
+  const actualTo = /* @__PURE__ */ resolve(to);
+  if (actualFrom === actualTo) {
+    return "";
+  }
+  if (import_platform.WIN32) {
+    const fromLower = actualFrom.toLowerCase();
+    const toLower = actualTo.toLowerCase();
+    if (fromLower === toLower) {
+      return "";
+    }
+  }
+  const fromStart = 1;
+  const fromEnd = actualFrom.length;
+  const fromLen = fromEnd - fromStart;
+  const toStart = 1;
+  const toEnd = actualTo.length;
+  const toLen = toEnd - toStart;
+  const length = fromLen < toLen ? fromLen : toLen;
+  let lastCommonSep = -1;
+  let i = 0;
+  for (; i < length; i += 1) {
+    let fromCode = (0, import_string.StringPrototypeCharCodeAt)(actualFrom, fromStart + i);
+    let toCode = (0, import_string.StringPrototypeCharCodeAt)(actualTo, toStart + i);
+    if (import_platform.WIN32) {
+      if (fromCode >= import_internal.CHAR_UPPERCASE_A && fromCode <= import_internal.CHAR_UPPERCASE_Z) {
+        fromCode += 32;
+      }
+      if (toCode >= import_internal.CHAR_UPPERCASE_A && toCode <= import_internal.CHAR_UPPERCASE_Z) {
+        toCode += 32;
+      }
+    }
+    if (fromCode !== toCode) {
+      break;
+    }
+    if ((0, import_predicates.isPathSeparator)((0, import_string.StringPrototypeCharCodeAt)(actualFrom, fromStart + i))) {
+      lastCommonSep = i;
+    }
+  }
+  if (i === length) {
+    if (toLen > length) {
+      const toCode = (0, import_string.StringPrototypeCharCodeAt)(actualTo, toStart + i);
+      if ((0, import_predicates.isPathSeparator)(toCode)) {
+        return actualTo.slice(toStart + i + 1);
+      }
+      if (i === 0) {
+        return actualTo.slice(toStart + i);
+      }
+    } else if (fromLen > length) {
+      const fromCode = (0, import_string.StringPrototypeCharCodeAt)(actualFrom, fromStart + i);
+      if ((0, import_predicates.isPathSeparator)(fromCode)) {
+        lastCommonSep = i;
+      } else if (i === 0) {
+        lastCommonSep = 0;
+      }
+    }
+  }
+  let out = "";
+  for (i = fromStart + lastCommonSep + 1; i <= fromEnd; i += 1) {
+    const code = (0, import_string.StringPrototypeCharCodeAt)(actualFrom, i);
+    if (i === fromEnd || (0, import_predicates.isPathSeparator)(code)) {
+      out += out.length === 0 ? ".." : "/..";
+    }
+  }
+  return out + actualTo.slice(toStart + lastCommonSep);
+}
+// @__NO_SIDE_EFFECTS__
+function relativeResolve(from, to) {
+  const rel = /* @__PURE__ */ relative(from, to);
+  if (rel === "") {
+    return "";
+  }
+  return (0, import_normalize.normalizePath)(rel);
+}
+// @__NO_SIDE_EFFECTS__
+function resolve(...segments) {
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let i = segments.length - 1; i >= 0 && !resolvedAbsolute; i -= 1) {
+    const segment = segments[i];
+    if (typeof segment !== "string" || segment.length === 0) {
+      continue;
+    }
+    resolvedPath = segment + (resolvedPath.length === 0 ? "" : `/${resolvedPath}`);
+    resolvedAbsolute = (0, import_predicates.isAbsolute)(segment);
+  }
+  if (!resolvedAbsolute) {
+    const cwd = /* @__PURE__ */ require("node:process").cwd();
+    resolvedPath = cwd + (resolvedPath.length === 0 ? "" : `/${resolvedPath}`);
+  }
+  return (0, import_normalize.normalizePath)(resolvedPath);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  relative,
+  relativeResolve,
+  resolve
+});

package/dist/paths/rewire.d.ts

@@ -1,11 +1,11 @@
 /**
- * @fileoverview Path rewiring utilities for testing.
- * Allows tests to override os.tmpdir() and os.homedir() without directly modifying them.
+ * @file Path rewiring utilities for testing. Allows tests to override
+ *   os.tmpdir() and os.homedir() without directly modifying them. Features:
  *
- * Features:
- * - Test-friendly setPath/clearPath/resetPaths that work in beforeEach/afterEach
- * - Automatic cache invalidation for path-dependent modules
- * - Thread-safe for concurrent test execution
+ *   - Test-friendly setPath/clearPath/resetPaths that work in
+ *     beforeEach/afterEach
+ *   - Automatic cache invalidation for path-dependent modules
+ *   - Thread-safe for concurrent test execution
  */
 /**
  * Clear a specific path override.
@@ -14,10 +14,9 @@ export declare function clearPath(key: string): void;
 /**
  * Get a path value, checking overrides first.
  *
- * Resolution order:
- * 1. Test overrides (set via setPath in beforeEach)
- * 2. Cached value (for performance)
- * 3. Original function call (cached for subsequent calls)
+ * Resolution order: 1. Test overrides (set via setPath in beforeEach) 2. Cached
+ * value (for performance) 3. Original function call (cached for subsequent
+ * calls)
  *
  * @internal Used by path getters to support test rewiring
  */
@@ -27,54 +26,54 @@ export declare function getPathValue(key: string, originalFn: () => string): str
  */
 export declare function hasOverride(key: string): boolean;
 /**
- * Invalidate all cached paths.
- * Called automatically when setPath/clearPath/resetPaths are used.
- * Can also be called manually for advanced testing scenarios.
+ * Invalidate all cached paths. Called automatically when
+ * setPath/clearPath/resetPaths are used. Can also be called manually for
+ * advanced testing scenarios.
  *
  * @internal Primarily for internal use, but exported for advanced testing
  */
 export declare function invalidateCaches(): void;
 /**
- * Register a cache invalidation callback.
- * Called by modules that need to clear their caches when paths change.
+ * Register a cache invalidation callback. Called by modules that need to clear
+ * their caches when paths change.
  *
  * @internal Used by paths.ts and fs.ts
  */
 export declare function registerCacheInvalidation(callback: () => void): void;
 /**
- * Clear all path overrides and reset caches.
- * Useful in afterEach hooks to ensure clean test state.
+ * Clear all path overrides and reset caches. Useful in afterEach hooks to
+ * ensure clean test state.
  *
  * @example
- * ```typescript
- * import { resetPaths } from '#paths/rewire'
+ *   ;```typescript
+ *   import { resetPaths } from '#paths/rewire'
  *
- * afterEach(() => {
- *   resetPaths()
- * })
- * ```
+ *   afterEach(() => {
+ *     resetPaths()
+ *   })
+ *   ```
  */
 export declare function resetPaths(): void;
 /**
- * Set a path override for testing.
- * This triggers cache invalidation for path-dependent modules.
+ * Set a path override for testing. This triggers cache invalidation for
+ * path-dependent modules.
  *
  * @example
- * ```typescript
- * import { setPath, resetPaths } from '#paths/rewire'
- * import { getOsTmpDir } from './'
+ *   ;```typescript
+ *   import { setPath, resetPaths } from '#paths/rewire'
+ *   import { getOsTmpDir } from './'
  *
- * beforeEach(() => {
- *   setPath('tmpdir', '/custom/tmp')
- * })
+ *   beforeEach(() => {
+ *     setPath('tmpdir', '/custom/tmp')
+ *   })
  *
- * afterEach(() => {
- *   resetPaths()
- * })
+ *   afterEach(() => {
+ *     resetPaths()
+ *   })
  *
- * it('should use custom temp directory', () => {
- *   expect(getOsTmpDir()).toBe('/custom/tmp')
- * })
- * ```
+ *   it('should use custom temp directory', () => {
+ *     expect(getOsTmpDir()).toBe('/custom/tmp')
+ *   })
+ *   ```
  */
 export declare function setPath(key: string, value: string | undefined): void;

package/dist/paths/rewire.js

@@ -29,13 +29,13 @@ __export(rewire_exports, {
   setPath: () => setPath
 });
 module.exports = __toCommonJS(rewire_exports);
-var import_primordials = require("../primordials");
+var import_map_set = require("../primordials/map-set");
 const stateSymbol = Symbol.for("@socketsecurity/lib/paths/rewire/state");
 const _globalThis = globalThis;
 if (!_globalThis[stateSymbol]) {
   _globalThis[stateSymbol] = {
-    testOverrides: new import_primordials.MapCtor(),
-    valueCache: new import_primordials.MapCtor(),
+    testOverrides: new import_map_set.MapCtor(),
+    valueCache: new import_map_set.MapCtor(),
     cacheInvalidationCallbacks: []
   };
 }