@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/paths/conversion.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @file Path conversion utilities — MSYS↔native bridging and string-shape
+ *   helpers. Split out of `paths/normalize.ts` for size hygiene.
+ *
+ *   - `fromUnixPath` / `toUnixPath` — MSYS↔native conversion
+ *   - `splitPath` — segment-array view of a path
+ *   - `trimLeadingDotSlash` — strip a single `./` / `.\` prefix
+ */
+/**
+ * Convert Unix-style POSIX paths to native Windows paths.
+ *
+ * This is the inverse of {@link toUnixPath}. On Windows, MSYS-style paths use
+ * `/c/` notation for drive letters and forward slashes, which PowerShell and
+ * cmd.exe cannot resolve. This function converts them to native Windows format
+ * with backslashes and proper drive letters.
+ *
+ * @example
+ *   ;```typescript
+ *   fromUnixPath('/c/projects/app/file.txt') // 'C:\\projects\\app\\file.txt' on Windows
+ *   fromUnixPath('/tmp/build/output') // '/tmp/build/output'
+ *   ```
+ *
+ * @param {string | Buffer | URL} pathLike - The MSYS/Unix-style path to
+ *   convert.
+ *
+ * @returns {string} Native Windows path or normalized Unix path
+ */
+export declare function fromUnixPath(pathLike: string | Buffer | URL): string;
+/**
+ * Split a path into an array of segments.
+ *
+ * Divides a path into individual components by splitting on path separators
+ * (both forward slashes and backslashes).
+ *
+ * @example
+ *   ;```typescript
+ *   splitPath('/home/user/file.txt') // ['', 'home', 'user', 'file.txt']
+ *   splitPath('C:\\Users\\John') // ['C:', 'Users', 'John']
+ *   splitPath('') // []
+ *   ```
+ *
+ * @param {string | Buffer | URL} pathLike - The path to split.
+ *
+ * @returns {string[]} Array of path segments, or empty array for empty paths
+ */
+export declare function splitPath(pathLike: string | Buffer | URL): string[];
+/**
+ * Convert Windows paths to MSYS/Unix-style POSIX paths for Git Bash tools.
+ *
+ * Git for Windows and MSYS2 tools expect POSIX-style paths with forward slashes
+ * and Unix drive letter notation (`/c/` instead of `C:\`).
+ *
+ * This is the inverse of {@link fromUnixPath}.
+ *
+ * @example
+ *   ;```typescript
+ *   toUnixPath('C:\\path\\to\\file.txt') // '/c/path/to/file.txt' on Windows
+ *   toUnixPath('/home/user/file') // '/home/user/file'
+ *   ```
+ *
+ * @param {string | Buffer | URL} pathLike - The path to convert.
+ *
+ * @returns {string} Unix-style POSIX path
+ */
+export declare function toUnixPath(pathLike: string | Buffer | URL): string;
+/**
+ * Remove a leading `./` or `.\` prefix from a path.
+ *
+ * Only removes a single leading `./` or `.\`. Does not touch `../` prefixes.
+ *
+ * @example
+ *   ;```typescript
+ *   trimLeadingDotSlash('./src/index.js') // 'src/index.js'
+ *   trimLeadingDotSlash('../lib/util.js') // '../lib/util.js'
+ *   trimLeadingDotSlash('/absolute/path') // '/absolute/path'
+ *   ```
+ *
+ * @param {string | Buffer | URL} pathLike - The path to process.
+ *
+ * @returns {string} The path without leading `./` / `.\`, or unchanged
+ */
+export declare function trimLeadingDotSlash(pathLike: string | Buffer | URL): string;

package/dist/paths/conversion.js

@@ -0,0 +1,74 @@
+"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 conversion_exports = {};
+__export(conversion_exports, {
+  fromUnixPath: () => fromUnixPath,
+  splitPath: () => splitPath,
+  toUnixPath: () => toUnixPath,
+  trimLeadingDotSlash: () => trimLeadingDotSlash
+});
+module.exports = __toCommonJS(conversion_exports);
+var import_platform = require("../constants/platform");
+var import_string = require("../primordials/string");
+var import_internal = require("./_internal");
+var import_normalize = require("./normalize");
+// @__NO_SIDE_EFFECTS__
+function fromUnixPath(pathLike) {
+  const normalized = (0, import_normalize.normalizePath)(pathLike);
+  if (import_platform.WIN32) {
+    return normalized.replace(/\//g, "\\");
+  }
+  return normalized;
+}
+// @__NO_SIDE_EFFECTS__
+function splitPath(pathLike) {
+  const filepath = (0, import_internal.pathLikeToString)(pathLike);
+  if (filepath === "") {
+    return [];
+  }
+  return filepath.split(import_internal.slashRegExp);
+}
+// @__NO_SIDE_EFFECTS__
+function toUnixPath(pathLike) {
+  const normalized = (0, import_normalize.normalizePath)(pathLike);
+  if (import_platform.WIN32) {
+    return normalized.replace(
+      /^([A-Z]):/i,
+      (_, letter) => `/${letter.toLowerCase()}`
+    );
+  }
+  return normalized;
+}
+// @__NO_SIDE_EFFECTS__
+function trimLeadingDotSlash(pathLike) {
+  const filepath = (0, import_internal.pathLikeToString)(pathLike);
+  if ((0, import_string.StringPrototypeStartsWith)(filepath, "./") || (0, import_string.StringPrototypeStartsWith)(filepath, ".\\")) {
+    return filepath.slice(2);
+  }
+  return filepath;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fromUnixPath,
+  splitPath,
+  toUnixPath,
+  trimLeadingDotSlash
+});

package/dist/paths/dirnames.d.ts

@@ -1,5 +1,5 @@
 /**
- * @fileoverview Directory name and path pattern constants.
+ * @file Directory name and path pattern constants.
  */
 export declare const NODE_MODULES = "node_modules";
 export declare const DOT_GIT_DIR = ".git";

package/dist/paths/exts.d.ts

@@ -1,5 +1,5 @@
 /**
- * @fileoverview File extension constants.
+ * @file File extension constants.
  */
 export declare const EXT_CJS = ".cjs";
 export declare const EXT_CMD = ".cmd";

package/dist/paths/filenames.d.ts

@@ -1,5 +1,5 @@
 /**
- * @fileoverview File name constants.
+ * @file File name constants.
  */
 export declare const PACKAGE_JSON = "package.json";
 export declare const TSCONFIG_JSON = "tsconfig.json";

package/dist/paths/globs.d.ts

@@ -1,5 +1,5 @@
 /**
- * @fileoverview Glob pattern constants.
+ * @file Glob pattern constants.
  */
 export declare const LICENSE_GLOB = "LICEN[CS]E{[.-]*,}";
 export declare const LICENSE_GLOB_RECURSIVE = "**/LICEN[CS]E{[.-]*,}";

package/dist/paths/normalize.d.ts

@@ -1,458 +1,48 @@
 /**
- * @fileoverview Path manipulation utilities with cross-platform support.
- * Provides path normalization, validation, and file extension handling.
- */
-/**
- * Convert Unix-style POSIX paths to native Windows paths.
- *
- * This is the inverse of {@link toUnixPath}. On Windows, MSYS-style paths use
- * `/c/` notation for drive letters and forward slashes, which PowerShell and
- * cmd.exe cannot resolve. This function converts them to native Windows format
- * with backslashes and proper drive letters.
- *
- * Conversion rules:
- * - On Windows: Converts drive notation and separators to native format
- *   - `/c/path/to/file` becomes `C:\path\to\file`
- *   - `/d/projects/app` becomes `D:\projects\app`
- *   - Forward slashes become backslashes
- *   - Drive letters are always uppercase in the output
- * - On Unix: Returns the normalized path unchanged (forward slashes preserved)
- *
- * @param {string | Buffer | URL} pathLike - The MSYS/Unix-style path to convert
- * @returns {string} Native Windows path (e.g., `C:\path\to\file`) or normalized Unix path
- *
- * @example
- * ```typescript
- * // MSYS drive letter paths (Windows)
- * fromUnixPath('/c/projects/app/file.txt')    // 'C:\\projects\\app\\file.txt'
- * fromUnixPath('/d/projects/foo/bar')         // 'D:\\projects\\foo\\bar'
- * fromUnixPath('/c')                          // 'C:\\'
- *
- * // Forward-slash paths (Windows)
- * fromUnixPath('C:/Windows/System32')         // 'C:\\Windows\\System32'
- *
- * // Unix (unchanged, forward slashes preserved)
- * fromUnixPath('/tmp/build/output')           // '/tmp/build/output'
- * ```
- */
-export declare function fromUnixPath(pathLike: string | Buffer | URL): string;
-/**
- * Check if a path is absolute.
- *
- * An absolute path is one that specifies a location from the root of the file system.
- * This function handles both POSIX and Windows path formats.
- *
- * POSIX absolute paths:
- * - Start with forward slash '/'
- * - Examples: '/home/user', '/usr/bin/node'
- *
- * Windows absolute paths (3 types):
- * 1. Drive-letter paths: Start with drive letter + colon + separator
- *    - Format: [A-Za-z]:[\\/]
- *    - Examples: 'C:\Windows', 'D:/data', 'c:\Program Files'
- *    - Reference: https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#file-and-directory-names
- *
- * 2. UNC paths: Start with double backslash (handled by backslash check)
- *    - Format: \\server\share
- *    - Examples: '\\server\share\file', '\\?\C:\path'
- *    - Reference: https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#unc-names
- *
- * 3. Device paths: Start with backslash
- *    - Examples: '\Windows', '\\.\device'
- *    - Note: Single backslash paths are relative to current drive
- *
- * @param {string | Buffer | URL} pathLike - The path to check
- * @returns {boolean} `true` if the path is absolute, `false` otherwise
- *
- * @example
- * ```typescript
- * // POSIX paths
- * isAbsolute('/home/user')           // true
- * isAbsolute('/usr/bin/node')        // true
- *
- * // Windows paths
- * isAbsolute('C:\\Windows')          // true
- * isAbsolute('D:/data')              // true
- * isAbsolute('\\\\server\\share')    // true
- *
- * // Relative paths
- * isAbsolute('../relative')          // false
- * isAbsolute('relative/path')        // false
- * isAbsolute('.')                    // false
- * ```
- */
-export declare function isAbsolute(pathLike: string | Buffer | URL): boolean;
-/**
- * Check if a path contains node_modules directory.
- *
- * Detects whether a given path includes a `node_modules` directory segment.
- * This is useful for identifying npm package dependencies and filtering
- * dependency-related paths.
- *
- * The check matches `node_modules` appearing as a complete path segment,
- * ensuring it is either at the start, end, or surrounded by path separators.
- *
- * @param {string | Buffer | URL} pathLike - The path to check
- * @returns {boolean} `true` if the path contains `node_modules`, `false` otherwise
- *
- * @example
- * ```typescript
- * isNodeModules('/project/node_modules/package')    // true
- * isNodeModules('node_modules/package/index.js')    // true
- * isNodeModules('/src/my_node_modules_backup')      // false
- * isNodeModules('/project/src/index.js')            // false
- * ```
- */
-export declare function isNodeModules(pathLike: string | Buffer | URL): boolean;
-/**
- * Check if a value is a valid file path (absolute or relative).
- *
- * Determines whether a given value represents a valid file system path.
- * This function distinguishes between file paths and other string formats
- * like package names, URLs, or bare module specifiers.
- *
- * Valid paths include:
- * - Absolute paths (e.g., `/usr/bin`, `C:\Windows`)
- * - Relative paths with separators (e.g., `./src`, `../lib`)
- * - Special relative paths (`.`, `..`)
- * - Paths starting with `@` that have subpaths (e.g., `@scope/name/file`)
- *
- * Not considered paths:
- * - URLs with protocols (e.g., `http://`, `file://`, `git:`)
- * - Bare package names (e.g., `lodash`, `react`)
- * - Scoped package names without subpaths (e.g., `@scope/name`)
- *
- * @param {string | Buffer | URL} pathLike - The value to check
- * @returns {boolean} `true` if the value is a valid file path, `false` otherwise
- *
- * @example
- * ```typescript
- * // Valid paths
- * isPath('/absolute/path')           // true
- * isPath('./relative/path')          // true
- * isPath('../parent/dir')            // true
- * isPath('.')                        // true
- * isPath('..')                       // true
- * isPath('@scope/name/subpath')      // true
- * isPath('C:\\Windows')              // true (Windows)
- *
- * // Not paths
- * isPath('lodash')                   // false - bare package name
- * isPath('@scope/package')           // false - scoped package name
- * isPath('http://example.com')       // false - URL
- * isPath('file://path')              // false - file URL
- * isPath('')                         // false - empty string
- * ```
- */
-export declare function isPath(pathLike: string | Buffer | URL): boolean;
-/**
- * Check if a path is relative.
- *
- * Determines whether a given path is relative (i.e., not absolute). A path
- * is considered relative if it does not specify a location from the root of
- * the file system.
- *
- * Relative paths include:
- * - Paths starting with `.` or `..` (e.g., `./src`, `../lib`)
- * - Paths without leading separators (e.g., `src/file.js`)
- * - Empty strings (treated as relative)
- *
- * @param {string | Buffer | URL} pathLike - The path to check
- * @returns {boolean} `true` if the path is relative, `false` if absolute
- *
- * @example
- * ```typescript
- * // Relative paths
- * isRelative('./src/index.js')       // true
- * isRelative('../lib/util.js')       // true
- * isRelative('src/file.js')          // true
- * isRelative('')                     // true
+ * @file Path normalization — the core `normalizePath` and its MSYS drive-letter
+ *   helper. The rest of the path module's surface (predicates, conversion,
+ *   resolution) lives in sibling leaves and is re-exported here so existing
+ *   `paths/normalize` importers keep working.
  *
- * // Absolute paths
- * isRelative('/home/user')           // false
- * isRelative('C:\\Windows')          // false (Windows)
- * isRelative('\\\\server\\share')    // false (Windows UNC)
- * ```
+ *   - `normalizePath` — backslash → forward-slash, segment collapse, UNC +
+ *     namespace preservation
+ *   - `msysDriveToNative` — `/c/path` → `C:/path` on Windows
  */
-export declare function isRelative(pathLike: string | Buffer | URL): boolean;
+export declare function msysDriveToNative(normalized: string): string;
 /**
- * Check if a path uses MSYS/Git Bash Unix-style drive letter notation.
+ * Normalize a path by converting backslashes to forward slashes and collapsing
+ * segments.
  *
- * Detects paths in the format `/c/...` where a single letter after the leading
- * slash represents a Windows drive letter. These paths are produced by MSYS2,
- * Git Bash, and `command -v` on Windows.
- *
- * Detection rules:
- * - Must start with `/` followed by a single ASCII letter (a-z, A-Z)
- * - The letter must be followed by `/` or be at the end of the string
- * - Examples: `/c/tools/bin`, `/d/projects`, `/c`
- * - Non-matches: `/tmp`, `/usr/local`, `C:/Windows`
- *
- * @param {string | Buffer | URL} pathLike - The path to check
- * @returns {boolean} `true` if the path uses MSYS drive letter notation
- *
- * @example
- * ```typescript
- * // MSYS drive letter paths
- * isUnixPath('/c/tools/bin')         // true
- * isUnixPath('/d/projects/app')       // true
- * isUnixPath('/c')                    // true
- * isUnixPath('/C/Windows')            // true
- *
- * // Not MSYS drive paths
- * isUnixPath('/tmp/build')            // false
- * isUnixPath('/usr/local/bin')        // false
- * isUnixPath('C:/Windows')            // false
- * isUnixPath('./relative')            // false
- * isUnixPath('')                      // false
- * ```
- */
-export declare function isUnixPath(pathLike: string | Buffer | URL): boolean;
-/**
- * Normalize a path by converting backslashes to forward slashes and collapsing segments.
- *
- * This function performs several normalization operations:
  * - Converts all backslashes (`\`) to forward slashes (`/`)
- * - Collapses repeated slashes into single slashes
- * - Resolves `.` (current directory) segments
- * - Resolves `..` (parent directory) segments
+ * - Collapses repeated slashes
+ * - Resolves `.` and `..` segments
  * - Preserves UNC path prefixes (`//server/share`)
  * - Preserves Windows namespace prefixes (`//./`, `//?/`)
  * - Returns `.` for empty or collapsed paths
+ * - On Windows: MSYS drive letters `/c/path` become `C:/path`
+ *
+ * @example
+ *   ;```typescript
+ *   normalizePath('foo/bar//baz') // 'foo/bar/baz'
+ *   normalizePath('foo/./bar') // 'foo/bar'
+ *   normalizePath('foo/bar/../baz') // 'foo/baz'
+ *   normalizePath('C:\\Users\\u\\file.txt') // 'C:/Users/u/file.txt'
+ *   normalizePath('\\\\server\\share\\file') // '//server/share/file'
+ *   normalizePath('') // '.'
+ *   ```
  *
- * Special handling:
- * - MSYS drive letters (Windows only): `/c/path` becomes `C:/path`
- * - UNC paths: Maintains double leading slashes for `//server/share` format
- * - Windows namespaces: Preserves `//./` and `//?/` prefixes
- * - Leading `..` segments: Preserved in relative paths without prefix
- * - Trailing components: Properly handled when resolving `..`
+ * @param {string | Buffer | URL} pathLike - The path to normalize.
  *
- * @param {string | Buffer | URL} pathLike - The path to normalize
- * @returns {string} The normalized path with forward slashes and collapsed segments
+ * @returns {string} The normalized path
  *
  * @security
  * **WARNING**: This function resolves `..` patterns as part of normalization, which means
  * paths like `/../etc/passwd` become `/etc/passwd`. When processing untrusted user input
  * (HTTP requests, file uploads, URL parameters), you MUST validate for path traversal
- * attacks BEFORE calling this function. Check for patterns like `..`, `%2e%2e`, `\..`,
- * and other traversal encodings first.
- *
- * @example
- * ```typescript
- * // Basic normalization
- * normalizePath('foo/bar//baz')              // 'foo/bar/baz'
- * normalizePath('foo/./bar')                 // 'foo/bar'
- * normalizePath('foo/bar/../baz')            // 'foo/baz'
- *
- * // Windows paths
- * normalizePath('C:\\Users\\username\\file.txt') // 'C:/Users/username/file.txt'
- * normalizePath('foo\\bar\\baz')                 // 'foo/bar/baz'
- *
- * // MSYS drive letters (Windows only)
- * normalizePath('/c/projects/app')              // 'C:/projects/app' (on Windows)
- * normalizePath('/d/tools/bin')                 // 'D:/tools/bin' (on Windows)
- *
- * // UNC paths
- * normalizePath('\\\\server\\share\\file')   // '//server/share/file'
- *
- * // Edge cases
- * normalizePath('')                          // '.'
- * normalizePath('.')                         // '.'
- * normalizePath('..')                        // '..'
- * normalizePath('///foo///bar///')           // '/foo/bar'
- * normalizePath('foo/../..')                 // '..'
- *
- * // Security: Path traversal is resolved (intended behavior for trusted paths)
- * normalizePath('/../etc/passwd')            // '/etc/passwd' ⚠️
- * normalizePath('/safe/../../unsafe')        // '/unsafe' ⚠️
- * ```
+ * attacks BEFORE calling this function.
  */
 export declare function normalizePath(pathLike: string | Buffer | URL): string;
-/**
- * Convert a path-like value to a string.
- *
- * Converts various path-like types (string, Buffer, URL) into a normalized
- * string representation. This function handles different input formats and
- * provides consistent string output for path operations.
- *
- * Supported input types:
- * - `string`: Returned as-is
- * - `Buffer`: Decoded as UTF-8 string
- * - `URL`: Converted using `fileURLToPath()`, with fallback for malformed URLs
- * - `null` / `undefined`: Returns empty string
- *
- * URL handling:
- * - Valid file URLs are converted via `url.fileURLToPath()`
- * - Malformed URLs fall back to pathname extraction with decoding
- * - Windows drive letters in URLs are handled specially
- * - Percent-encoded characters are decoded (e.g., `%20` becomes space)
- *
- * @param {string | Buffer | URL | null | undefined} pathLike - The path-like value to convert
- * @returns {string} The string representation of the path, or empty string for null/undefined
- *
- * @example
- * ```typescript
- * // String input
- * pathLikeToString('/home/user')                        // '/home/user'
- *
- * // Buffer input
- * pathLikeToString(Buffer.from('/tmp/file'))            // '/tmp/file'
- *
- * // URL input
- * pathLikeToString(new URL('file:///home/user'))        // '/home/user'
- * pathLikeToString(new URL('file:///C:/Windows'))       // 'C:/Windows' (Windows)
- *
- * // Null/undefined input
- * pathLikeToString(null)                                // ''
- * pathLikeToString(undefined)                           // ''
- *
- * // Percent-encoded URLs
- * pathLikeToString(new URL('file:///path%20with%20spaces'))  // '/path with spaces'
- * ```
- */
-export declare function pathLikeToString(pathLike: string | Buffer | URL | null | undefined): string;
-/**
- * Get the relative path from one path to another.
- *
- * Computes the relative path from `from` to `to` and normalizes the result.
- * This is a convenience wrapper around the `relative()` function that adds
- * path normalization (converting separators and collapsing segments).
- *
- * The function:
- * 1. Calculates the relative path using `relative()`
- * 2. Normalizes the result using `normalizePath()`
- * 3. Preserves empty strings (same path) without converting to `.`
- *
- * @param {string} from - The source path (starting point)
- * @param {string} to - The destination path (target)
- * @returns {string} The normalized relative path from `from` to `to`, or empty string if paths are identical
- *
- * @example
- * ```typescript
- * // Basic usage
- * relativeResolve('/foo/bar', '/foo/baz')         // '../baz'
- * relativeResolve('/foo/bar/baz', '/foo')         // '../..'
- * relativeResolve('/foo', '/foo/bar')             // 'bar'
- *
- * // Same paths
- * relativeResolve('/foo/bar', '/foo/bar')         // ''
- *
- * // Windows paths (normalized)
- * relativeResolve('C:\\foo\\bar', 'C:\\foo\\baz') // '../baz'
- *
- * // With normalization
- * relativeResolve('/foo/./bar', '/foo/baz')       // '../baz'
- * relativeResolve('/foo/bar/../baz', '/foo/qux')  // '../qux'
- * ```
- */
-export declare function relativeResolve(from: string, to: string): string;
-/**
- * Split a path into an array of segments.
- *
- * Divides a path into individual components by splitting on path separators
- * (both forward slashes and backslashes). This is useful for path traversal,
- * analysis, and manipulation.
- *
- * The function handles:
- * - Forward slashes (`/`) on all platforms
- * - Backslashes (`\`) on Windows
- * - Mixed separators in a single path
- * - Empty paths (returns empty array)
- *
- * Note: The resulting array may contain empty strings if the path has leading,
- * trailing, or consecutive separators (e.g., `/foo//bar/` becomes `['', 'foo', '', 'bar', '']`).
- *
- * @param {string | Buffer | URL} pathLike - The path to split
- * @returns {string[]} Array of path segments, or empty array for empty paths
- *
- * @example
- * ```typescript
- * // POSIX paths
- * splitPath('/home/user/file.txt')      // ['', 'home', 'user', 'file.txt']
- * splitPath('src/lib/util.js')          // ['src', 'lib', 'util.js']
- *
- * // Windows paths
- * splitPath('C:\\Users\\John')          // ['C:', 'Users', 'John']
- * splitPath('folder\\file.txt')         // ['folder', 'file.txt']
- *
- * // Mixed separators
- * splitPath('path/to\\file')            // ['path', 'to', 'file']
- *
- * // Edge cases
- * splitPath('')                         // []
- * splitPath('/')                        // ['', '']
- * splitPath('/foo//bar/')               // ['', 'foo', '', 'bar', '']
- * ```
- */
-export declare function splitPath(pathLike: string | Buffer | URL): string[];
-/**
- * Convert Windows paths to MSYS/Unix-style POSIX paths for Git Bash tools.
- *
- * Git for Windows and MSYS2 tools (like tar, git, etc.) expect POSIX-style
- * paths with forward slashes and Unix drive letter notation (/c/ instead of C:\).
- * This function handles the conversion for cross-platform compatibility.
- *
- * This is the inverse of {@link fromUnixPath}.
- *
- * Conversion rules:
- * - On Windows: Normalizes separators and converts drive letters
- *   - `C:\path\to\file` becomes `/c/path/to/file`
- *   - `D:/projects/app` becomes `/d/projects/app`
- *   - Drive letters are always lowercase in the output
- * - On Unix: Returns the path unchanged (passes through normalization)
- *
- * This is particularly important for:
- * - MSYS2/Git Bash tools that interpret `D:\` as a remote hostname
- * - Cross-platform build scripts using tar, git archive, etc.
- * - CI/CD environments where Git for Windows is used
- *
- * @param {string | Buffer | URL} pathLike - The path to convert
- * @returns {string} Unix-style POSIX path (e.g., `/c/path/to/file`)
- *
- * @example
- * ```typescript
- * // Windows drive letter paths
- * toUnixPath('C:\\path\\to\\file.txt')     // '/c/path/to/file.txt'
- * toUnixPath('D:/projects/foo/bar')        // '/d/projects/foo/bar'
- *
- * // Already forward slashes (still converts drive letter)
- * toUnixPath('C:/Windows/System32')        // '/c/Windows/System32'
- *
- * // Unix paths (unchanged on Unix platforms)
- * toUnixPath('/home/user/file')            // '/home/user/file'
- * toUnixPath('/var/log/app.log')           // '/var/log/app.log'
- *
- * // UNC paths (Windows network shares)
- * toUnixPath('\\\\server\\share\\file')    // '//server/share/file'
- * ```
- */
-export declare function toUnixPath(pathLike: string | Buffer | URL): string;
-/**
- * Remove leading ./ or ../ from a path.
- *
- * Strips the `./` or `.\` prefix from relative paths. This is useful for
- * normalizing paths when the current directory reference is implicit or
- * unwanted.
- *
- * Note: This function only removes a single leading `./` or `.\`. It does
- * not remove `../` prefixes or process the rest of the path.
- *
- * @param {string | Buffer | URL} pathLike - The path to process
- * @returns {string} The path without leading `./` or `.\`, or unchanged if no such prefix
- *
- * @example
- * ```typescript
- * // Remove ./ prefix
- * trimLeadingDotSlash('./src/index.js')     // 'src/index.js'
- * trimLeadingDotSlash('.\\src\\file.txt')   // 'src\\file.txt'
- *
- * // Preserve ../ prefix
- * trimLeadingDotSlash('../lib/util.js')     // '../lib/util.js'
- *
- * // No change for other paths
- * trimLeadingDotSlash('/absolute/path')     // '/absolute/path'
- * trimLeadingDotSlash('relative/path')      // 'relative/path'
- * trimLeadingDotSlash('.')                  // '.'
- * ```
- */
-export declare function trimLeadingDotSlash(pathLike: string | Buffer | URL): string;
+export { getUrl, pathLikeToString } from './_internal';
+export { fromUnixPath, splitPath, toUnixPath, trimLeadingDotSlash, } from './conversion';
+export { isAbsolute, isNodeModules, isPath, isPathSeparator, isRelative, isUnixPath, isWindowsDeviceRoot, } from './predicates';
+export { relative, relativeResolve, resolve } from './resolve';