@socketsecurity/lib 6.0.2 → 6.0.4

package/dist/paths/predicates.js

@@ -1,121 +1,199 @@
 "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__
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_string = require('../primordials/string.js');
+const require_constants_platform = require('../constants/platform.js');
+const require_paths__internal = require('./_internal.js');
+const require_primordials_regexp = require('../primordials/regexp.js');
+
+//#region src/paths/predicates.ts
+/**
+* @file Path predicates — `is*` checks for path shape and kind. Split out of
+*   `paths/normalize.ts` for file-size hygiene. Pure boolean predicates over
+*   paths and character codes.
+*
+*   - `isAbsolute`, `isRelative` — root-anchoring shape
+*   - `isPath` — file-path vs package-spec vs URL discriminator
+*   - `isNodeModules`, `isUnixPath` — content-pattern checks
+*   - `isPathSeparator`, `isWindowsDeviceRoot` — char-code primitives
+*/
+/**
+* Check if a path is absolute.
+*
+* Handles both POSIX (`/...`) and Windows (drive-letter, UNC, device) absolute
+* path shapes.
+*
+* @example
+*   ;```typescript
+*   isAbsolute('/home/user') // true
+*   isAbsolute('C:\\Windows') // true on Windows
+*   isAbsolute('../relative') // false
+*   ```
+*
+* @param {string | Buffer | URL} pathLike - The path to check.
+*
+* @returns {boolean} `true` if absolute, `false` otherwise
+*/
+/* @__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;
+	const filepath = /* @__PURE__ */ require_paths__internal.pathLikeToString(pathLike);
+	const { length } = filepath;
+	if (length === 0) return false;
+	const code = require_primordials_string.StringPrototypeCharCodeAt(filepath, 0);
+	if (code === 47) return true;
+	if (code === 92) return true;
+	/* c8 ignore start - Windows drive-letter detection. */
+	if (require_constants_platform.WIN32 && length > 2) {
+		if (/* @__PURE__ */ isWindowsDeviceRoot(code) && require_primordials_string.StringPrototypeCharCodeAt(filepath, 1) === 58 && /* @__PURE__ */ isPathSeparator(require_primordials_string.StringPrototypeCharCodeAt(filepath, 2))) return true;
+	}
+	/* c8 ignore stop */
+	return false;
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Check if a path contains a `node_modules` directory segment.
+*
+* Matches `node_modules` only as a complete path segment.
+*
+* @example
+*   ;```typescript
+*   isNodeModules('/project/node_modules/package') // true
+*   isNodeModules('/src/my_node_modules_backup') // false
+*   ```
+*
+* @param {string | Buffer | URL} pathLike - The path to check.
+*
+* @returns {boolean} `true` if the path contains `node_modules`
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function isNodeModules(pathLike) {
-  const filepath = (0, import_internal.pathLikeToString)(pathLike);
-  return (0, import_regexp.RegExpPrototypeTest)(import_internal.nodeModulesPathRegExp, filepath);
+	return require_primordials_regexp.RegExpPrototypeTest(require_paths__internal.nodeModulesPathRegExp, /* @__PURE__ */ require_paths__internal.pathLikeToString(pathLike));
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Check if a value is a valid file path (absolute or relative).
+*
+* Distinguishes between file paths and other string formats like package names,
+* URLs, or bare module specifiers.
+*
+* @example
+*   ;```typescript
+*   isPath('/absolute/path') // true
+*   isPath('./relative/path') // true
+*   isPath('@scope/name/subpath') // true
+*   isPath('lodash') // false
+*   isPath('http://example.com') // false
+*   ```
+*
+* @param {string | Buffer | URL} pathLike - The value to check.
+*
+* @returns {boolean} `true` if the value is a valid file path
+*/
+/* @__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;
+	const filepath = /* @__PURE__ */ require_paths__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 (require_primordials_string.StringPrototypeStartsWith(filepath, "@") && !require_primordials_string.StringPrototypeStartsWith(filepath, "@/")) {
+			const parts = filepath.split("/");
+			if (parts.length <= 2 && !parts[1]?.includes("\\")) return false;
+		}
+		return true;
+	}
+	return false;
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Check if a character code is a path separator (`/` or `\`).
+*
+* @example
+*   ;```typescript
+*   isPathSeparator(47) // true — '/'
+*   isPathSeparator(92) // true — '\'
+*   isPathSeparator(65) // false — 'A'
+*   ```
+*
+* @param {number} code - The character code to check.
+*
+* @returns {boolean} `true` if separator
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function isPathSeparator(code) {
-  return code === import_internal.CHAR_FORWARD_SLASH || code === import_internal.CHAR_BACKWARD_SLASH;
+	return code === 47 || code === 92;
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Check if a path is relative (i.e., not absolute).
+*
+* Empty strings are treated as relative.
+*
+* @example
+*   ;```typescript
+*   isRelative('./src/index.js') // true
+*   isRelative('src/file.js') // true
+*   isRelative('/home/user') // false
+*   ```
+*
+* @param {string | Buffer | URL} pathLike - The path to check.
+*
+* @returns {boolean} `true` if the path is relative
+*/
+/* @__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);
+	const filepath = /* @__PURE__ */ require_paths__internal.pathLikeToString(pathLike);
+	/* c8 ignore start */
+	if (typeof filepath !== "string") return false;
+	/* c8 ignore stop */
+	if (filepath.length === 0) return true;
+	return !/* @__PURE__ */ isAbsolute(filepath);
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Check if a path uses MSYS/Git Bash Unix-style drive letter notation.
+*
+* Detects paths in the format `/c/...` where a single letter after the leading
+* slash represents a Windows drive letter.
+*
+* @example
+*   ;```typescript
+*   isUnixPath('/c/tools/bin') // true
+*   isUnixPath('/tmp/build') // false
+*   isUnixPath('C:/Windows') // false
+*   ```
+*
+* @param {string | Buffer | URL} pathLike - The path to check.
+*
+* @returns {boolean} `true` if the path uses MSYS drive letter notation
+*/
+/* @__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);
+	const filepath = /* @__PURE__ */ require_paths__internal.pathLikeToString(pathLike);
+	return typeof filepath === "string" && require_primordials_regexp.RegExpPrototypeTest(require_paths__internal.msysDriveRegExp, filepath);
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Check if a character code is a Windows device root letter (A-Z / a-z).
+*
+* @example
+*   ;```typescript
+*   isWindowsDeviceRoot(67) // true  — 'C'
+*   isWindowsDeviceRoot(99) // true  — 'c'
+*   isWindowsDeviceRoot(58) // false — ':'
+*   ```
+*
+* @param {number} code - The character code to check.
+*
+* @returns {boolean} `true` if valid drive-letter code
+*/
+/* c8 ignore start - Only called from Windows-only branches. */
+/* @__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;
+	return code >= 65 && code <= 90 || code >= 97 && code <= 122;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  isAbsolute,
-  isNodeModules,
-  isPath,
-  isPathSeparator,
-  isRelative,
-  isUnixPath,
-  isWindowsDeviceRoot
-});
+/* c8 ignore stop */
+
+//#endregion
+exports.isAbsolute = isAbsolute;
+exports.isNodeModules = isNodeModules;
+exports.isPath = isPath;
+exports.isPathSeparator = isPathSeparator;
+exports.isRelative = isRelative;
+exports.isUnixPath = isUnixPath;
+exports.isWindowsDeviceRoot = isWindowsDeviceRoot;

package/dist/paths/resolve.js

@@ -1,135 +1,153 @@
 "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__
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_string = require('../primordials/string.js');
+const require_constants_platform = require('../constants/platform.js');
+const require_paths__internal = require('./_internal.js');
+const require_paths_predicates = require('./predicates.js');
+const require_paths_normalize = require('./normalize.js');
+
+//#region src/paths/resolve.ts
+/**
+* @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
+*/
+/* @__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);
+	if (from === to) return "";
+	const actualFrom = /* @__PURE__ */ resolve(from);
+	const actualTo = /* @__PURE__ */ resolve(to);
+	if (actualFrom === actualTo) return "";
+	/* c8 ignore start - Windows-only case-insensitive comparison. */
+	if (require_constants_platform.WIN32) {
+		if (actualFrom.toLowerCase() === actualTo.toLowerCase()) return "";
+	}
+	/* c8 ignore stop */
+	const fromStart = 1;
+	const fromEnd = actualFrom.length;
+	const fromLen = fromEnd - fromStart;
+	const toStart = 1;
+	const toLen = actualTo.length - toStart;
+	const length = fromLen < toLen ? fromLen : toLen;
+	let lastCommonSep = -1;
+	let i = 0;
+	for (; i < length; i += 1) {
+		let fromCode = require_primordials_string.StringPrototypeCharCodeAt(actualFrom, fromStart + i);
+		let toCode = require_primordials_string.StringPrototypeCharCodeAt(actualTo, toStart + i);
+		/* c8 ignore start - Windows-only case folding. */
+		if (require_constants_platform.WIN32) {
+			if (fromCode >= 65 && fromCode <= 90) fromCode += 32;
+			if (toCode >= 65 && toCode <= 90) toCode += 32;
+		}
+		/* c8 ignore stop */
+		if (fromCode !== toCode) break;
+		if (/* @__PURE__ */ require_paths_predicates.isPathSeparator(require_primordials_string.StringPrototypeCharCodeAt(actualFrom, fromStart + i))) lastCommonSep = i;
+	}
+	/* c8 ignore start */
+	if (i === length) {
+		if (toLen > length) {
+			if (/* @__PURE__ */ require_paths_predicates.isPathSeparator(require_primordials_string.StringPrototypeCharCodeAt(actualTo, toStart + i))) return actualTo.slice(toStart + i + 1);
+			if (i === 0) return actualTo.slice(toStart + i);
+		} else if (fromLen > length) {
+			if (/* @__PURE__ */ require_paths_predicates.isPathSeparator(require_primordials_string.StringPrototypeCharCodeAt(actualFrom, fromStart + i))) lastCommonSep = i;
+			else if (i === 0) lastCommonSep = 0;
+		}
+	}
+	/* c8 ignore stop */
+	let out = "";
+	for (i = fromStart + lastCommonSep + 1; i <= fromEnd; i += 1) {
+		const code = require_primordials_string.StringPrototypeCharCodeAt(actualFrom, i);
+		if (i === fromEnd || /* @__PURE__ */ require_paths_predicates.isPathSeparator(code)) out += out.length === 0 ? ".." : "/..";
+	}
+	return out + actualTo.slice(toStart + lastCommonSep);
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* 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
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function relativeResolve(from, to) {
-  const rel = /* @__PURE__ */ relative(from, to);
-  if (rel === "") {
-    return "";
-  }
-  return (0, import_normalize.normalizePath)(rel);
+	const rel = /* @__PURE__ */ relative(from, to);
+	if (rel === "") return "";
+	return /* @__PURE__ */ require_paths_normalize.normalizePath(rel);
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* 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
+*/
+/* @__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);
+	let resolvedPath = "";
+	let resolvedAbsolute = false;
+	for (let i = segments.length - 1; i >= 0 && !resolvedAbsolute; i -= 1) {
+		const segment = segments[i];
+		/* c8 ignore start */
+		if (typeof segment !== "string" || segment.length === 0) continue;
+		resolvedPath = segment + (resolvedPath.length === 0 ? "" : `/${resolvedPath}`);
+		resolvedAbsolute = /* @__PURE__ */ require_paths_predicates.isAbsolute(segment);
+	}
+	if (!resolvedAbsolute) resolvedPath = /* @__PURE__ */ require("node:process").cwd() + (resolvedPath.length === 0 ? "" : `/${resolvedPath}`);
+	/* c8 ignore stop */
+	return /* @__PURE__ */ require_paths_normalize.normalizePath(resolvedPath);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  relative,
-  relativeResolve,
-  resolve
-});
+
+//#endregion
+exports.relative = relative;
+exports.relativeResolve = relativeResolve;
+exports.resolve = resolve;