@socketsecurity/lib 0.0.0 → 1.0.0

package/dist/path.js

@@ -0,0 +1,442 @@
+/* Socket Lib - Built with esbuild */
+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_exports = {};
+__export(path_exports, {
+  isAbsolute: () => isAbsolute,
+  isNodeModules: () => isNodeModules,
+  isPath: () => isPath,
+  isRelative: () => isRelative,
+  normalizePath: () => normalizePath,
+  pathLikeToString: () => pathLikeToString,
+  relativeResolve: () => relativeResolve,
+  splitPath: () => splitPath,
+  trimLeadingDotSlash: () => trimLeadingDotSlash
+});
+module.exports = __toCommonJS(path_exports);
+var import_platform = require("#constants/platform");
+var import_strings = require("./strings");
+const CHAR_BACKWARD_SLASH = 92;
+const CHAR_COLON = 58;
+const CHAR_FORWARD_SLASH = 47;
+const CHAR_LOWERCASE_A = 97;
+const CHAR_LOWERCASE_Z = 122;
+const CHAR_UPPERCASE_A = 65;
+const CHAR_UPPERCASE_Z = 90;
+const slashRegExp = /[/\\]/;
+const nodeModulesPathRegExp = /(?:^|[/\\])node_modules(?:[/\\]|$)/;
+// @__NO_SIDE_EFFECTS__
+function isPathSeparator(code) {
+  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+}
+// @__NO_SIDE_EFFECTS__
+function isWindowsDeviceRoot(code) {
+  return code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z || code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z;
+}
+let _buffer;
+// @__NO_SIDE_EFFECTS__
+function getBuffer() {
+  if (_buffer === void 0) {
+    _buffer = require("node:buffer");
+  }
+  return _buffer;
+}
+let _url;
+// @__NO_SIDE_EFFECTS__
+function getUrl() {
+  if (_url === void 0) {
+    _url = require("node:url");
+  }
+  return _url;
+}
+// @__NO_SIDE_EFFECTS__
+function isNodeModules(pathLike) {
+  const filepath = /* @__PURE__ */ pathLikeToString(pathLike);
+  return nodeModulesPathRegExp.test(filepath);
+}
+// @__NO_SIDE_EFFECTS__
+function isAbsolute(pathLike) {
+  const filepath = /* @__PURE__ */ pathLikeToString(pathLike);
+  const { length } = filepath;
+  if (length === 0) {
+    return false;
+  }
+  const code = filepath.charCodeAt(0);
+  if (code === CHAR_FORWARD_SLASH) {
+    return true;
+  }
+  if (code === CHAR_BACKWARD_SLASH) {
+    return true;
+  }
+  if (import_platform.WIN32 && length > 2) {
+    if (/* @__PURE__ */ isWindowsDeviceRoot(code) && filepath.charCodeAt(1) === CHAR_COLON && /* @__PURE__ */ isPathSeparator(filepath.charCodeAt(2))) {
+      return true;
+    }
+  }
+  return false;
+}
+// @__NO_SIDE_EFFECTS__
+function isPath(pathLike) {
+  const filepath = /* @__PURE__ */ 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 (filepath.startsWith("@") && !filepath.startsWith("@/")) {
+      const parts = filepath.split("/");
+      if (parts.length <= 2 && !parts[1]?.includes("\\")) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+// @__NO_SIDE_EFFECTS__
+function isRelative(pathLike) {
+  const filepath = /* @__PURE__ */ pathLikeToString(pathLike);
+  if (typeof filepath !== "string") {
+    return false;
+  }
+  if (filepath.length === 0) {
+    return true;
+  }
+  return !/* @__PURE__ */ isAbsolute(filepath);
+}
+// @__NO_SIDE_EFFECTS__
+function normalizePath(pathLike) {
+  const filepath = /* @__PURE__ */ pathLikeToString(pathLike);
+  const { length } = filepath;
+  if (length === 0) {
+    return ".";
+  }
+  if (length < 2) {
+    return length === 1 && filepath.charCodeAt(0) === 92 ? "/" : filepath;
+  }
+  let code = 0;
+  let start = 0;
+  let prefix = "";
+  if (length > 4 && filepath.charCodeAt(3) === 92) {
+    const code2 = filepath.charCodeAt(2);
+    if ((code2 === 63 || code2 === 46) && filepath.charCodeAt(0) === 92 && filepath.charCodeAt(1) === 92) {
+      start = 2;
+      prefix = "//";
+    }
+  }
+  if (start === 0) {
+    if (length > 2 && (filepath.charCodeAt(0) === 92 && filepath.charCodeAt(1) === 92 && filepath.charCodeAt(2) !== 92 || filepath.charCodeAt(0) === 47 && filepath.charCodeAt(1) === 47 && filepath.charCodeAt(2) !== 47)) {
+      let firstSegmentEnd = -1;
+      let hasSecondSegment = false;
+      let i = 2;
+      while (i < length && (filepath.charCodeAt(i) === 47 || filepath.charCodeAt(i) === 92)) {
+        i++;
+      }
+      while (i < length) {
+        const char = filepath.charCodeAt(i);
+        if (char === 47 || char === 92) {
+          firstSegmentEnd = i;
+          break;
+        }
+        i++;
+      }
+      if (firstSegmentEnd > 2) {
+        i = firstSegmentEnd;
+        while (i < length && (filepath.charCodeAt(i) === 47 || filepath.charCodeAt(i) === 92)) {
+          i++;
+        }
+        if (i < length) {
+          hasSecondSegment = true;
+        }
+      }
+      if (firstSegmentEnd > 2 && hasSecondSegment) {
+        start = 2;
+        prefix = "//";
+      } else {
+        code = filepath.charCodeAt(start);
+        while (code === 47 || code === 92) {
+          start += 1;
+          code = filepath.charCodeAt(start);
+        }
+        if (start) {
+          prefix = "/";
+        }
+      }
+    } else {
+      code = filepath.charCodeAt(start);
+      while (code === 47 || code === 92) {
+        start += 1;
+        code = filepath.charCodeAt(start);
+      }
+      if (start) {
+        prefix = "/";
+      }
+    }
+  }
+  let nextIndex = (0, import_strings.search)(filepath, slashRegExp, { fromIndex: start });
+  if (nextIndex === -1) {
+    const segment = filepath.slice(start);
+    if (segment === "." || segment.length === 0) {
+      return prefix || ".";
+    }
+    if (segment === "..") {
+      return prefix ? prefix.slice(0, -1) || "/" : "..";
+    }
+    return prefix + segment;
+  }
+  let collapsed = "";
+  let segmentCount = 0;
+  let leadingDotDots = 0;
+  while (nextIndex !== -1) {
+    const segment = filepath.slice(start, nextIndex);
+    if (segment.length > 0 && segment !== ".") {
+      if (segment === "..") {
+        if (segmentCount > 0) {
+          const lastSeparatorIndex = collapsed.lastIndexOf("/");
+          if (lastSeparatorIndex === -1) {
+            collapsed = "";
+            segmentCount = 0;
+            if (leadingDotDots > 0 && !prefix) {
+              collapsed = "..";
+              leadingDotDots = 1;
+            }
+          } else {
+            const lastSegmentStart = lastSeparatorIndex + 1;
+            const lastSegmentValue = collapsed.slice(lastSegmentStart);
+            if (lastSegmentValue === "..") {
+              collapsed = `${collapsed}/${segment}`;
+              leadingDotDots += 1;
+            } else {
+              collapsed = collapsed.slice(0, lastSeparatorIndex);
+              segmentCount -= 1;
+            }
+          }
+        } else if (!prefix) {
+          collapsed = collapsed + (collapsed.length === 0 ? "" : "/") + segment;
+          leadingDotDots += 1;
+        }
+      } else {
+        collapsed = collapsed + (collapsed.length === 0 ? "" : "/") + segment;
+        segmentCount += 1;
+      }
+    }
+    start = nextIndex + 1;
+    code = filepath.charCodeAt(start);
+    while (code === 47 || code === 92) {
+      start += 1;
+      code = filepath.charCodeAt(start);
+    }
+    nextIndex = (0, import_strings.search)(filepath, slashRegExp, { fromIndex: start });
+  }
+  const lastSegment = filepath.slice(start);
+  if (lastSegment.length > 0 && lastSegment !== ".") {
+    if (lastSegment === "..") {
+      if (segmentCount > 0) {
+        const lastSeparatorIndex = collapsed.lastIndexOf("/");
+        if (lastSeparatorIndex === -1) {
+          collapsed = "";
+          segmentCount = 0;
+          if (leadingDotDots > 0 && !prefix) {
+            collapsed = "..";
+            leadingDotDots = 1;
+          }
+        } else {
+          const lastSegmentStart = lastSeparatorIndex + 1;
+          const lastSegmentValue = collapsed.slice(lastSegmentStart);
+          if (lastSegmentValue === "..") {
+            collapsed = `${collapsed}/${lastSegment}`;
+            leadingDotDots += 1;
+          } else {
+            collapsed = collapsed.slice(0, lastSeparatorIndex);
+            segmentCount -= 1;
+          }
+        }
+      } else if (!prefix) {
+        collapsed = collapsed + (collapsed.length === 0 ? "" : "/") + lastSegment;
+        leadingDotDots += 1;
+      }
+    } else {
+      collapsed = collapsed + (collapsed.length === 0 ? "" : "/") + lastSegment;
+      segmentCount += 1;
+    }
+  }
+  if (collapsed.length === 0) {
+    return prefix || ".";
+  }
+  return prefix + collapsed;
+}
+// @__NO_SIDE_EFFECTS__
+function pathLikeToString(pathLike) {
+  if (pathLike === null || pathLike === void 0) {
+    return "";
+  }
+  if (typeof pathLike === "string") {
+    return pathLike;
+  }
+  const { Buffer: Buffer2 } = /* @__PURE__ */ getBuffer();
+  if (Buffer2.isBuffer(pathLike)) {
+    return pathLike.toString("utf8");
+  }
+  const url = /* @__PURE__ */ getUrl();
+  if (pathLike instanceof URL) {
+    try {
+      return url.fileURLToPath(pathLike);
+    } catch {
+      const pathname = pathLike.pathname;
+      const decodedPathname = decodeURIComponent(pathname);
+      const WIN322 = require("../constants/platform").WIN32;
+      if (WIN322 && decodedPathname.startsWith("/")) {
+        const letter = decodedPathname.charCodeAt(1) | 32;
+        const hasValidDriveLetter = decodedPathname.length >= 3 && letter >= 97 && // 'a' to 'z'
+        letter <= 122 && decodedPathname.charAt(2) === ":";
+        if (!hasValidDriveLetter) {
+          return decodedPathname;
+        }
+      }
+      return decodedPathname;
+    }
+  }
+  return String(pathLike);
+}
+// @__NO_SIDE_EFFECTS__
+function splitPath(pathLike) {
+  const filepath = /* @__PURE__ */ pathLikeToString(pathLike);
+  if (filepath === "") {
+    return [];
+  }
+  return filepath.split(slashRegExp);
+}
+// @__NO_SIDE_EFFECTS__
+function trimLeadingDotSlash(pathLike) {
+  const filepath = /* @__PURE__ */ pathLikeToString(pathLike);
+  if (filepath.startsWith("./") || filepath.startsWith(".\\")) {
+    return filepath.slice(2);
+  }
+  return filepath;
+}
+// @__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 = /* @__PURE__ */ isAbsolute(segment);
+  }
+  if (!resolvedAbsolute) {
+    const cwd = /* @__PURE__ */ require("node:process").cwd();
+    resolvedPath = cwd + (resolvedPath.length === 0 ? "" : `/${resolvedPath}`);
+  }
+  return /* @__PURE__ */ normalizePath(resolvedPath);
+}
+// @__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 "";
+  }
+  const WIN322 = require("../constants/platform").WIN32;
+  if (WIN322) {
+    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) {
+    const fromCode = actualFrom.charCodeAt(fromStart + i);
+    const toCode = actualTo.charCodeAt(toStart + i);
+    if (fromCode !== toCode) {
+      break;
+    }
+    if (/* @__PURE__ */ isPathSeparator(fromCode)) {
+      lastCommonSep = i;
+    }
+  }
+  if (i === length) {
+    if (toLen > length) {
+      const toCode = actualTo.charCodeAt(toStart + i);
+      if (/* @__PURE__ */ isPathSeparator(toCode)) {
+        return actualTo.slice(toStart + i + 1);
+      }
+      if (i === 0) {
+        return actualTo.slice(toStart + i);
+      }
+    } else if (fromLen > length) {
+      const fromCode = actualFrom.charCodeAt(fromStart + i);
+      if (/* @__PURE__ */ isPathSeparator(fromCode)) {
+        lastCommonSep = i;
+      } else if (i === 0) {
+        lastCommonSep = 0;
+      }
+    }
+  }
+  let out = "";
+  for (i = fromStart + lastCommonSep + 1; i <= fromEnd; i += 1) {
+    const code = actualFrom.charCodeAt(i);
+    if (i === fromEnd || /* @__PURE__ */ 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 /* @__PURE__ */ normalizePath(rel);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isAbsolute,
+  isNodeModules,
+  isPath,
+  isRelative,
+  normalizePath,
+  pathLikeToString,
+  relativeResolve,
+  splitPath,
+  trimLeadingDotSlash
+});
+//# sourceMappingURL=path.js.map

package/dist/path.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/path.ts"],
+  "sourcesContent": ["/**\n * @fileoverview Path manipulation utilities with cross-platform support.\n * Provides path normalization, validation, and file extension handling.\n */\n\nimport { WIN32 } from '#constants/platform'\n\nimport { search } from './strings'\n\n// Character code constants.\n// '\\'\nconst CHAR_BACKWARD_SLASH = 92\n// ':'\nconst CHAR_COLON = 58\n// '/'\nconst CHAR_FORWARD_SLASH = 47\n// 'a'\nconst CHAR_LOWERCASE_A = 97\n// 'z'\nconst CHAR_LOWERCASE_Z = 122\n// 'A'\nconst CHAR_UPPERCASE_A = 65\n// 'Z'\nconst CHAR_UPPERCASE_Z = 90\n\n// Regular expressions.\nconst slashRegExp = /[/\\\\]/\nconst nodeModulesPathRegExp = /(?:^|[/\\\\])node_modules(?:[/\\\\]|$)/\n\n/**\n * Check if a character code represents a path separator.\n */\n/*@__NO_SIDE_EFFECTS__*/\nfunction isPathSeparator(code: number): boolean {\n  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH\n}\n\n/**\n * Check if a character code represents a Windows device root letter.\n */\n/*@__NO_SIDE_EFFECTS__*/\nfunction isWindowsDeviceRoot(code: number): boolean {\n  return (\n    (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z) ||\n    (code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z)\n  )\n}\n\nlet _buffer: typeof import('node:buffer') | undefined\n/**\n * Lazily load the buffer module.\n * @private\n */\n/*@__NO_SIDE_EFFECTS__*/\nfunction getBuffer() {\n  if (_buffer === undefined) {\n    // Use non-'node:' prefixed require to avoid Webpack errors.\n\n    _buffer = /*@__PURE__*/ require('node:buffer')\n  }\n  return _buffer as typeof import('node:buffer')\n}\n\nlet _url: typeof import('node:url') | undefined\n/**\n * Lazily load the url module.\n * @private\n */\n/*@__NO_SIDE_EFFECTS__*/\nfunction getUrl() {\n  if (_url === undefined) {\n    // Use non-'node:' prefixed require to avoid Webpack errors.\n\n    _url = /*@__PURE__*/ require('node:url')\n  }\n  return _url as typeof import('node:url')\n}\n\n/**\n * Check if a path contains node_modules directory.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function isNodeModules(pathLike: string | Buffer | URL): boolean {\n  const filepath = pathLikeToString(pathLike)\n  return nodeModulesPathRegExp.test(filepath)\n}\n\n/**\n * Check if a path is absolute.\n *\n * An absolute path is one that specifies a location from the root of the file system.\n * This function handles both POSIX and Windows path formats.\n *\n * POSIX absolute paths:\n * - Start with forward slash '/'\n * - Examples: '/home/user', '/usr/bin/node'\n *\n * Windows absolute paths (3 types):\n * 1. Drive-letter paths: Start with drive letter + colon + separator\n *    - Format: [A-Za-z]:[\\\\/]\n *    - Examples: 'C:\\Windows', 'D:/data', 'c:\\Program Files'\n *    - Reference: https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#file-and-directory-names\n *\n * 2. UNC paths: Start with double backslash (handled by backslash check)\n *    - Format: \\\\server\\share\n *    - Examples: '\\\\server\\share\\file', '\\\\?\\C:\\path'\n *    - Reference: https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#unc-names\n *\n * 3. Device paths: Start with backslash\n *    - Examples: '\\Windows', '\\\\.\\device'\n *    - Note: Single backslash paths are relative to current drive\n *\n * Examples:\n * - isAbsolute('/home/user') \u2192 true (POSIX)\n * - isAbsolute('C:\\\\Windows') \u2192 true (Windows drive letter)\n * - isAbsolute('\\\\server\\\\share') \u2192 true (Windows UNC)\n * - isAbsolute('../relative') \u2192 false\n * - isAbsolute('relative/path') \u2192 false\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function isAbsolute(pathLike: string | Buffer | URL): boolean {\n  const filepath = pathLikeToString(pathLike)\n  const { length } = filepath\n\n  // Empty paths are not absolute.\n  if (length === 0) {\n    return false\n  }\n\n  const code = filepath.charCodeAt(0)\n\n  // POSIX: absolute paths start with forward slash '/'.\n  // This is the simplest case and works for all UNIX-like systems.\n  if (code === CHAR_FORWARD_SLASH) {\n    return true\n  }\n\n  // Windows: absolute paths can start with backslash '\\'.\n  // This includes UNC paths (\\\\server\\share) and device paths (\\\\.\\ or \\\\?\\).\n  // Single backslash is technically relative to current drive, but treated as absolute.\n  if (code === CHAR_BACKWARD_SLASH) {\n    return true\n  }\n\n  // Windows: drive-letter absolute paths (e.g., C:\\, D:\\).\n  // Format: [A-Za-z]:[\\\\/]\n  // Requires at least 3 characters: drive letter + colon + separator.\n  // Only treat as absolute on Windows platforms.\n  if (WIN32 && length > 2) {\n    // Check if first character is a letter (A-Z or a-z).\n    // Check if second character is colon ':'.\n    // Check if third character is a path separator (forward or backslash).\n    // This matches patterns like 'C:\\', 'D:/', 'c:\\Users', etc.\n    if (\n      isWindowsDeviceRoot(code) &&\n      filepath.charCodeAt(1) === CHAR_COLON &&\n      isPathSeparator(filepath.charCodeAt(2))\n    ) {\n      return true\n    }\n  }\n\n  // Not an absolute path.\n  return false\n}\n\n/**\n * Check if a value is a valid file path (absolute or relative).\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function isPath(pathLike: string | Buffer | URL): boolean {\n  const filepath = pathLikeToString(pathLike)\n  if (typeof filepath !== 'string' || filepath.length === 0) {\n    return false\n  }\n\n  // Exclude URLs with protocols (file:, http:, https:, git:, etc.).\n  // These should be handled by package spec parsers, not treated as file paths.\n  // Require at least 2 characters before colon to exclude Windows drive letters (C:, D:).\n  if (/^[a-z][a-z0-9+.-]+:/i.test(filepath)) {\n    return false\n  }\n\n  // Special relative paths.\n  if (filepath === '.' || filepath === '..') {\n    return true\n  }\n\n  // Absolute paths are always valid paths.\n  if (isAbsolute(filepath)) {\n    return true\n  }\n\n  // Contains path separators, so it's a path.\n  if (filepath.includes('/') || filepath.includes('\\\\')) {\n    // Distinguish scoped package names from paths starting with '@'.\n    // Scoped packages: @scope/name (exactly 2 parts, no backslashes).\n    // Paths: @scope/name/subpath (3+ parts) or @scope\\name (Windows backslash).\n    // Special case: '@/' is a valid path (already handled by separator check).\n    if (filepath.startsWith('@') && !filepath.startsWith('@/')) {\n      const parts = filepath.split('/')\n      // If exactly @scope/name with no Windows separators, it's a package name.\n      if (parts.length <= 2 && !parts[1]?.includes('\\\\')) {\n        return false\n      }\n    }\n    return true\n  }\n\n  // Bare names without separators are package names, not paths.\n  return false\n}\n\n/**\n * Check if a path is relative.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function isRelative(pathLike: string | Buffer | URL): boolean {\n  const filepath = pathLikeToString(pathLike)\n  if (typeof filepath !== 'string') {\n    return false\n  }\n  // Empty string is considered relative.\n  if (filepath.length === 0) {\n    return true\n  }\n  // A path is relative if it's not absolute.\n  return !isAbsolute(filepath)\n}\n\n/**\n * Normalize a path by converting backslashes to forward slashes and collapsing segments.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function normalizePath(pathLike: string | Buffer | URL): string {\n  const filepath = pathLikeToString(pathLike)\n  const { length } = filepath\n  if (length === 0) {\n    return '.'\n  }\n  if (length < 2) {\n    return length === 1 && filepath.charCodeAt(0) === 92 /*'\\\\'*/\n      ? '/'\n      : filepath\n  }\n\n  let code = 0\n  let start = 0\n\n  // Ensure win32 namespaces have two leading slashes so they are handled properly\n  // by path.win32.parse() after being normalized.\n  // https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#namespaces\n  // UNC paths, paths starting with double slashes, e.g. \"\\\\\\\\wsl.localhost\\\\Ubuntu\\home\\\\\",\n  // are okay to convert to forward slashes.\n  // https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#naming-conventions\n  let prefix = ''\n  if (length > 4 && filepath.charCodeAt(3) === 92 /*'\\\\'*/) {\n    const code2 = filepath.charCodeAt(2)\n    // Look for \\\\?\\ or \\\\.\\\n    if (\n      (code2 === 63 /*'?'*/ || code2 === 46) /*'.'*/ &&\n      filepath.charCodeAt(0) === 92 /*'\\\\'*/ &&\n      filepath.charCodeAt(1) === 92 /*'\\\\'*/\n    ) {\n      start = 2\n      prefix = '//'\n    }\n  }\n  if (start === 0) {\n    // Check for UNC paths first (\\\\server\\share or //server/share)\n    // UNC paths must start with exactly two slashes, not more\n    if (\n      length > 2 &&\n      ((filepath.charCodeAt(0) === 92 /*'\\\\'*/ &&\n        filepath.charCodeAt(1) === 92 /*'\\\\'*/ &&\n        filepath.charCodeAt(2) !== 92) /*'\\\\'*/ ||\n        (filepath.charCodeAt(0) === 47 /*'/'*/ &&\n          filepath.charCodeAt(1) === 47 /*'/'*/ &&\n          filepath.charCodeAt(2) !== 47)) /*'/'*/\n    ) {\n      // Check if this is a valid UNC path: must have server/share format\n      // Find the first segment (server name) and second segment (share name)\n      let firstSegmentEnd = -1\n      let hasSecondSegment = false\n\n      // Skip leading slashes after the initial double slash\n      let i = 2\n      while (\n        i < length &&\n        (filepath.charCodeAt(i) === 47 /*'/'*/ ||\n          filepath.charCodeAt(i) === 92) /*'\\\\'*/\n      ) {\n        i++\n      }\n\n      // Find the end of first segment (server name)\n      while (i < length) {\n        const char = filepath.charCodeAt(i)\n        if (char === 47 /*'/'*/ || char === 92 /*'\\\\'*/) {\n          firstSegmentEnd = i\n          break\n        }\n        i++\n      }\n\n      if (firstSegmentEnd > 2) {\n        // Skip slashes after server name\n        i = firstSegmentEnd\n        while (\n          i < length &&\n          (filepath.charCodeAt(i) === 47 /*'/'*/ ||\n            filepath.charCodeAt(i) === 92) /*'\\\\'*/\n        ) {\n          i++\n        }\n        // Check if there's a share name (second segment)\n        if (i < length) {\n          hasSecondSegment = true\n        }\n      }\n\n      if (firstSegmentEnd > 2 && hasSecondSegment) {\n        // Valid UNC path - preserve double leading slashes\n        start = 2\n        prefix = '//'\n      } else {\n        // Just repeated slashes, treat as regular path\n        code = filepath.charCodeAt(start)\n        while (code === 47 /*'/'*/ || code === 92 /*'\\\\'*/) {\n          start += 1\n          code = filepath.charCodeAt(start)\n        }\n        if (start) {\n          prefix = '/'\n        }\n      }\n    } else {\n      // Trim leading slashes for regular paths\n      code = filepath.charCodeAt(start)\n      while (code === 47 /*'/'*/ || code === 92 /*'\\\\'*/) {\n        start += 1\n        code = filepath.charCodeAt(start)\n      }\n      if (start) {\n        prefix = '/'\n      }\n    }\n  }\n  let nextIndex = search(filepath, slashRegExp, { fromIndex: start })\n  if (nextIndex === -1) {\n    const segment = filepath.slice(start)\n    if (segment === '.' || segment.length === 0) {\n      return prefix || '.'\n    }\n    if (segment === '..') {\n      return prefix ? prefix.slice(0, -1) || '/' : '..'\n    }\n    return prefix + segment\n  }\n  // Process segments and handle '.', '..', and empty segments.\n  let collapsed = ''\n  let segmentCount = 0\n  let leadingDotDots = 0\n  while (nextIndex !== -1) {\n    const segment = filepath.slice(start, nextIndex)\n    if (segment.length > 0 && segment !== '.') {\n      if (segment === '..') {\n        // Handle '..' by removing the last segment if possible.\n        if (segmentCount > 0) {\n          // Find the last separator and remove the last segment.\n          const lastSeparatorIndex = collapsed.lastIndexOf('/')\n          if (lastSeparatorIndex === -1) {\n            // Only one segment, remove it entirely.\n            collapsed = ''\n            segmentCount = 0\n            // Check if this was a leading '..', restore it.\n            if (leadingDotDots > 0 && !prefix) {\n              collapsed = '..'\n              leadingDotDots = 1\n            }\n          } else {\n            const lastSegmentStart = lastSeparatorIndex + 1\n            const lastSegmentValue = collapsed.slice(lastSegmentStart)\n            // Don't collapse leading '..' segments.\n            if (lastSegmentValue === '..') {\n              // Preserve the '..' and add another one.\n              collapsed = `${collapsed}/${segment}`\n              leadingDotDots += 1\n            } else {\n              // Normal collapse: remove the last segment.\n              collapsed = collapsed.slice(0, lastSeparatorIndex)\n              segmentCount -= 1\n            }\n          }\n        } else if (!prefix) {\n          // Preserve '..' for relative paths.\n          collapsed = collapsed + (collapsed.length === 0 ? '' : '/') + segment\n          leadingDotDots += 1\n        }\n      } else {\n        collapsed = collapsed + (collapsed.length === 0 ? '' : '/') + segment\n        segmentCount += 1\n      }\n    }\n    start = nextIndex + 1\n    code = filepath.charCodeAt(start)\n    while (code === 47 /*'/'*/ || code === 92 /*'\\\\'*/) {\n      start += 1\n      code = filepath.charCodeAt(start)\n    }\n    nextIndex = search(filepath, slashRegExp, { fromIndex: start })\n  }\n  const lastSegment = filepath.slice(start)\n  if (lastSegment.length > 0 && lastSegment !== '.') {\n    if (lastSegment === '..') {\n      if (segmentCount > 0) {\n        const lastSeparatorIndex = collapsed.lastIndexOf('/')\n        if (lastSeparatorIndex === -1) {\n          collapsed = ''\n          segmentCount = 0\n          // Check if this was a leading '..', restore it.\n          if (leadingDotDots > 0 && !prefix) {\n            collapsed = '..'\n            leadingDotDots = 1\n          }\n        } else {\n          const lastSegmentStart = lastSeparatorIndex + 1\n          const lastSegmentValue = collapsed.slice(lastSegmentStart)\n          // Don't collapse leading '..' segments.\n          if (lastSegmentValue === '..') {\n            // Preserve the '..' and add another one.\n            collapsed = `${collapsed}/${lastSegment}`\n            leadingDotDots += 1\n          } else {\n            // Normal collapse: remove the last segment.\n            collapsed = collapsed.slice(0, lastSeparatorIndex)\n            segmentCount -= 1\n          }\n        }\n      } else if (!prefix) {\n        collapsed =\n          collapsed + (collapsed.length === 0 ? '' : '/') + lastSegment\n        leadingDotDots += 1\n      }\n    } else {\n      collapsed = collapsed + (collapsed.length === 0 ? '' : '/') + lastSegment\n      segmentCount += 1\n    }\n  }\n\n  if (collapsed.length === 0) {\n    return prefix || '.'\n  }\n  return prefix + collapsed\n}\n\n/**\n * Convert a path-like value to a string.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function pathLikeToString(\n  pathLike: string | Buffer | URL | null | undefined,\n): string {\n  if (pathLike === null || pathLike === undefined) {\n    return ''\n  }\n  if (typeof pathLike === 'string') {\n    return pathLike\n  }\n  const { Buffer } = getBuffer()\n  if (Buffer.isBuffer(pathLike)) {\n    return pathLike.toString('utf8')\n  }\n  const url = getUrl()\n  if (pathLike instanceof URL) {\n    try {\n      return url.fileURLToPath(pathLike)\n    } catch {\n      // On Windows, file URLs like `file:///C:/path` include drive letters.\n      // If a file URL is missing its drive letter (malformed), fileURLToPath() throws an error.\n      // This fallback extracts the pathname directly from the URL object.\n      //\n      // Example flows:\n      // - Unix: file:///home/user \u2192 pathname '/home/user' \u2192 keep as-is\n      // - Windows valid: file:///C:/path \u2192 handled by fileURLToPath()\n      // - Windows invalid: file:///path \u2192 pathname '/path' \u2192 strips to 'path'\n      const pathname = pathLike.pathname\n\n      // Decode percent-encoded characters (e.g., %20 \u2192 space).\n      // The pathname property keeps URL encoding, but file paths need decoded characters.\n      // This is not platform-specific; all URLs use percent-encoding regardless of OS.\n      const decodedPathname = decodeURIComponent(pathname)\n\n      // URL pathnames always start with `/`.\n      // On Windows, strip the leading slash only for malformed URLs that lack drive letters\n      // (e.g., `/path` should be `path`, but `/C:/path` should be `C:/path`).\n      // On Unix, keep the leading slash for absolute paths (e.g., `/home/user`).\n      const WIN32 = require('../constants/platform').WIN32\n      if (WIN32 && decodedPathname.startsWith('/')) {\n        // Check for drive letter pattern following Node.js source: /[a-zA-Z]:/\n        // Character at index 1 should be a letter, character at index 2 should be ':'\n        // Convert to lowercase\n        const letter = decodedPathname.charCodeAt(1) | 0x20\n        const hasValidDriveLetter =\n          decodedPathname.length >= 3 &&\n          letter >= 97 &&\n          // 'a' to 'z'\n          letter <= 122 &&\n          decodedPathname.charAt(2) === ':'\n\n        if (!hasValidDriveLetter) {\n          // On Windows, preserve Unix-style absolute paths that don't start with a drive letter.\n          // Only strip the leading slash for truly malformed Windows paths.\n          // Since fileURLToPath() failed, this is likely a valid Unix-style absolute path.\n          return decodedPathname\n        }\n      }\n      return decodedPathname\n    }\n  }\n  return String(pathLike)\n}\n\n/**\n * Split a path into an array of segments.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function splitPath(pathLike: string | Buffer | URL): string[] {\n  const filepath = pathLikeToString(pathLike)\n  if (filepath === '') {\n    return []\n  }\n  return filepath.split(slashRegExp)\n}\n\n/**\n * Remove leading ./ or ../ from a path.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function trimLeadingDotSlash(pathLike: string | Buffer | URL): string {\n  const filepath = pathLikeToString(pathLike)\n  // Only trim ./ not ../\n  if (filepath.startsWith('./') || filepath.startsWith('.\\\\')) {\n    return filepath.slice(2)\n  }\n  return filepath\n}\n\n/**\n * Resolve an absolute path from path segments.\n *\n * This function mimics Node.js path.resolve() behavior by:\n * 1. Processing segments from right to left\n * 2. Stopping when an absolute path is found\n * 3. Prepending current working directory if no absolute path found\n * 4. Normalizing the final path\n *\n * Examples:\n * - resolve('foo', 'bar', 'baz') \u2192 '/cwd/foo/bar/baz'\n * - resolve('/foo', 'bar', 'baz') \u2192 '/foo/bar/baz'\n * - resolve('foo', '/bar', 'baz') \u2192 '/bar/baz'\n * - resolve('C:\\\\foo', 'bar') \u2192 'C:/foo/bar' (Windows)\n */\n/*@__NO_SIDE_EFFECTS__*/\nfunction resolve(...segments: string[]): string {\n  let resolvedPath = ''\n  let resolvedAbsolute = false\n\n  // Process segments from right to left until we find an absolute path.\n  // This allows later segments to override earlier ones.\n  // Example: resolve('/foo', '/bar') returns '/bar', not '/foo/bar'.\n  for (let i = segments.length - 1; i >= 0 && !resolvedAbsolute; i -= 1) {\n    const segment = segments[i]\n\n    // Skip empty or non-string segments.\n    if (typeof segment !== 'string' || segment.length === 0) {\n      continue\n    }\n\n    // Prepend the segment to the resolved path.\n    // Use forward slashes as separators (normalized later).\n    resolvedPath =\n      segment + (resolvedPath.length === 0 ? '' : `/${resolvedPath}`)\n\n    // Check if this segment is absolute.\n    // Absolute paths stop the resolution process.\n    resolvedAbsolute = isAbsolute(segment)\n  }\n\n  // If no absolute path was found in segments, prepend current working directory.\n  // This ensures the final path is always absolute.\n  if (!resolvedAbsolute) {\n    const cwd = /*@__PURE__*/ require('node:process').cwd()\n    resolvedPath = cwd + (resolvedPath.length === 0 ? '' : `/${resolvedPath}`)\n  }\n\n  // Normalize the resolved path (collapse '..' and '.', convert separators).\n  return normalizePath(resolvedPath)\n}\n\n/**\n * Calculate the relative path from one path to another.\n *\n * This function computes how to get from `from` to `to` using relative path notation.\n * Both paths are first resolved to absolute paths, then compared to find the common\n * base path, and finally a relative path is constructed using '../' for parent\n * directory traversal.\n *\n * Algorithm:\n * 1. Resolve both paths to absolute\n * 2. Find the longest common path prefix (up to a separator)\n * 3. For each remaining directory in `from`, add '../' to go up\n * 4. Append the remaining path from `to`\n *\n * Windows-specific behavior:\n * - File system paths are case-insensitive on Windows (NTFS, FAT32)\n * - 'C:\\Foo' and 'c:\\foo' are considered the same path\n * - Reference: https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file\n * - Case is preserved but not significant for comparison\n *\n * Examples:\n * - relative('/foo/bar', '/foo/baz') \u2192 '../baz'\n * - relative('/foo/bar/baz', '/foo') \u2192 '../..'\n * - relative('/foo', '/foo/bar') \u2192 'bar'\n * - relative('C:\\\\foo\\\\bar', 'C:\\\\foo\\\\baz') \u2192 '../baz' (Windows)\n */\n/*@__NO_SIDE_EFFECTS__*/\nfunction relative(from: string, to: string): string {\n  // Quick return if paths are already identical.\n  if (from === to) {\n    return ''\n  }\n\n  // Resolve both paths to absolute.\n  // This handles relative paths, '.', '..', and ensures consistent format.\n  const actualFrom = resolve(from)\n  const actualTo = resolve(to)\n\n  // Check again after resolution (paths might have been equivalent).\n  if (actualFrom === actualTo) {\n    return ''\n  }\n\n  const WIN32 = require('../constants/platform').WIN32\n\n  // Windows: perform case-insensitive comparison.\n  // NTFS and FAT32 preserve case but are case-insensitive for lookups.\n  // This means 'C:\\Foo\\bar.txt' and 'c:\\foo\\BAR.TXT' refer to the same file.\n  // Reference: https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#case-sensitivity\n  if (WIN32) {\n    const fromLower = actualFrom.toLowerCase()\n    const toLower = actualTo.toLowerCase()\n    if (fromLower === toLower) {\n      return ''\n    }\n  }\n\n  // Skip the leading separator for comparison.\n  // We compare paths starting after the root separator to find common directories.\n  // Example: '/foo/bar' becomes 'foo/bar' for comparison (index 1).\n  const fromStart = 1\n  const fromEnd = actualFrom.length\n  const fromLen = fromEnd - fromStart\n  const toStart = 1\n  const toEnd = actualTo.length\n  const toLen = toEnd - toStart\n\n  // Compare paths character by character to find the longest common prefix.\n  // We only consider a common prefix valid if it ends at a directory separator.\n  const length = fromLen < toLen ? fromLen : toLen\n  // Index of last common directory separator.\n  let lastCommonSep = -1\n  let i = 0\n\n  for (; i < length; i += 1) {\n    const fromCode = actualFrom.charCodeAt(fromStart + i)\n    const toCode = actualTo.charCodeAt(toStart + i)\n\n    // Paths diverge at this character.\n    if (fromCode !== toCode) {\n      break\n    }\n\n    // Track directory separators (both forward and backslash for Windows compatibility).\n    // We need this to ensure we only split at directory boundaries.\n    if (isPathSeparator(fromCode)) {\n      lastCommonSep = i\n    }\n  }\n\n  // Handle edge cases where one path is a prefix of the other.\n  if (i === length) {\n    if (toLen > length) {\n      // Destination path is longer.\n      const toCode = actualTo.charCodeAt(toStart + i)\n      if (isPathSeparator(toCode)) {\n        // `from` is the exact base path for `to`.\n        // Example: from='/foo/bar'; to='/foo/bar/baz' \u2192 'baz'\n        // Skip the separator character (+1) to get just the relative portion.\n        return actualTo.slice(toStart + i + 1)\n      }\n      if (i === 0) {\n        // `from` is the root directory.\n        // Example: from='/'; to='/foo' \u2192 'foo'\n        return actualTo.slice(toStart + i)\n      }\n    } else if (fromLen > length) {\n      // Source path is longer.\n      const fromCode = actualFrom.charCodeAt(fromStart + i)\n      if (isPathSeparator(fromCode)) {\n        // `to` is the exact base path for `from`.\n        // Example: from='/foo/bar/baz'; to='/foo/bar' \u2192 '..'\n        // We need to go up from the extra directory.\n        lastCommonSep = i\n      } else if (i === 0) {\n        // `to` is the root directory.\n        // Example: from='/foo'; to='/' \u2192 '..'\n        lastCommonSep = 0\n      }\n    }\n  }\n\n  // Generate the relative path by constructing '../' segments.\n  let out = ''\n\n  // Count the number of directories in `from` after the common base.\n  // For each directory, we need to go up one level ('../').\n  // Example: from='/a/b/c', to='/a/x' \u2192 common='a', need '../..' (up from c, up from b)\n  for (i = fromStart + lastCommonSep + 1; i <= fromEnd; i += 1) {\n    const code = actualFrom.charCodeAt(i)\n\n    // At the end of the path or at a separator, add '../'.\n    if (i === fromEnd || isPathSeparator(code)) {\n      out += out.length === 0 ? '..' : '/..'\n    }\n  }\n\n  // Append the rest of the destination path after the common base.\n  // This gives us the path from the common ancestor to the destination.\n  return out + actualTo.slice(toStart + lastCommonSep)\n}\n\n/**\n * Get the relative path from one path to another.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function relativeResolve(from: string, to: string): string {\n  const rel = relative(from, to)\n  // Empty string means same path - don't normalize to '.'\n  if (rel === '') {\n    return ''\n  }\n  return normalizePath(rel)\n}\n"],
+  "mappings": "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",
+  "names": ["Buffer", "WIN32"]
+}

package/dist/paths.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Get the Socket home directory (~/.socket).
+ * Alias for getSocketUserDir() for consistency across Socket projects.
+ */
+export declare function getSocketHomePath(): string;
+/**
+ * Get the Socket user directory (~/.socket).
+ */
+export declare function getSocketUserDir(): string;
+/**
+ * Get a Socket app directory (~/.socket/_<appName>).
+ */
+export declare function getSocketAppDir(appName: string): string;
+/**
+ * Get the Socket cacache directory (~/.socket/_cacache).
+ * Can be overridden with SOCKET_CACACHE_DIR environment variable for testing.
+ */
+export declare function getSocketCacacheDir(): string;
+/**
+ * Get the Socket DLX directory (~/.socket/_dlx).
+ */
+export declare function getSocketDlxDir(): string;
+/**
+ * Get a Socket app cache directory (~/.socket/_<appName>/cache).
+ */
+export declare function getSocketAppCacheDir(appName: string): string;
+/**
+ * Get a Socket app TTL cache directory (~/.socket/_<appName>/cache/ttl).
+ */
+export declare function getSocketAppCacheTtlDir(appName: string): string;
+/**
+ * Get the Socket CLI directory (~/.socket/_socket).
+ */
+export declare function getSocketCliDir(): string;
+/**
+ * Get the Socket Registry directory (~/.socket/_registry).
+ */
+export declare function getSocketRegistryDir(): string;
+/**
+ * Get the Socket Registry GitHub cache directory (~/.socket/_registry/cache/ttl/github).
+ */
+export declare function getSocketRegistryGithubCacheDir(): string;