@socketsecurity/lib 1.0.4 → 1.1.0

package/dist/path.d.ts

@@ -1,5 +1,23 @@
 /**
  * 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
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function isNodeModules(pathLike: string | Buffer | URL): boolean;
@@ -28,47 +46,293 @@ export declare function isNodeModules(pathLike: string | Buffer | URL): boolean;
  *    - Examples: '\Windows', '\\.\device'
  *    - Note: Single backslash paths are relative to current drive
  *
- * Examples:
- * - isAbsolute('/home/user') → true (POSIX)
- * - isAbsolute('C:\\Windows') → true (Windows drive letter)
- * - isAbsolute('\\server\\share') → true (Windows UNC)
- * - isAbsolute('../relative') → false
- * - isAbsolute('relative/path') → false
+ * @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
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function isAbsolute(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
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 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
+ *
+ * // Absolute paths
+ * isRelative('/home/user')           // false
+ * isRelative('C:\\Windows')          // false (Windows)
+ * isRelative('\\\\server\\share')    // false (Windows UNC)
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function isRelative(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
+ * - Preserves UNC path prefixes (`//server/share`)
+ * - Preserves Windows namespace prefixes (`//./`, `//?/`)
+ * - Returns `.` for empty or collapsed paths
+ *
+ * Special handling:
+ * - 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
+ * @returns {string} The normalized path with forward slashes and collapsed segments
+ *
+ * @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\\John\\file.txt') // 'C:/Users/John/file.txt'
+ * normalizePath('foo\\bar\\baz')             // 'foo/bar/baz'
+ *
+ * // UNC paths
+ * normalizePath('\\\\server\\share\\file')   // '//server/share/file'
+ *
+ * // Edge cases
+ * normalizePath('')                          // '.'
+ * normalizePath('.')                         // '.'
+ * normalizePath('..')                        // '..'
+ * normalizePath('///foo///bar///')           // '/foo/bar'
+ * normalizePath('foo/../..')                 // '..'
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 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'
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function pathLikeToString(pathLike: string | Buffer | URL | null | undefined): 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', '']
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function splitPath(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('.')                  // '.'
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function trimLeadingDotSlash(pathLike: string | Buffer | URL): 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'
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function relativeResolve(from: string, to: string): string;

package/dist/path.js.map

@@ -1,7 +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": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,sBAAsB;AAEtB,qBAAuB;AAIvB,MAAM,sBAAsB;AAE5B,MAAM,aAAa;AAEnB,MAAM,qBAAqB;AAE3B,MAAM,mBAAmB;AAEzB,MAAM,mBAAmB;AAEzB,MAAM,mBAAmB;AAEzB,MAAM,mBAAmB;AAGzB,MAAM,cAAc;AACpB,MAAM,wBAAwB;AAAA;AAM9B,SAAS,gBAAgB,MAAuB;AAC9C,SAAO,SAAS,sBAAsB,SAAS;AACjD;AAAA;AAMA,SAAS,oBAAoB,MAAuB;AAClD,SACG,QAAQ,oBAAoB,QAAQ,oBACpC,QAAQ,oBAAoB,QAAQ;AAEzC;AAEA,IAAI;AAAA;AAMJ,SAAS,YAAY;AACnB,MAAI,YAAY,QAAW;AAGzB,cAAwB,QAAQ,aAAa;AAAA,EAC/C;AACA,SAAO;AACT;AAEA,IAAI;AAAA;AAMJ,SAAS,SAAS;AAChB,MAAI,SAAS,QAAW;AAGtB,WAAqB,QAAQ,UAAU;AAAA,EACzC;AACA,SAAO;AACT;AAAA;AAMO,SAAS,cAAc,UAA0C;AACtE,QAAM,WAAW,iCAAiB,QAAQ;AAC1C,SAAO,sBAAsB,KAAK,QAAQ;AAC5C;AAAA;AAmCO,SAAS,WAAW,UAA0C;AACnE,QAAM,WAAW,iCAAiB,QAAQ;AAC1C,QAAM,EAAE,OAAO,IAAI;AAGnB,MAAI,WAAW,GAAG;AAChB,WAAO;AAAA,EACT;AAEA,QAAM,OAAO,SAAS,WAAW,CAAC;AAIlC,MAAI,SAAS,oBAAoB;AAC/B,WAAO;AAAA,EACT;AAKA,MAAI,SAAS,qBAAqB;AAChC,WAAO;AAAA,EACT;AAMA,MAAI,yBAAS,SAAS,GAAG;AAKvB,QACE,oCAAoB,IAAI,KACxB,SAAS,WAAW,CAAC,MAAM,cAC3B,gCAAgB,SAAS,WAAW,CAAC,CAAC,GACtC;AACA,aAAO;AAAA,IACT;AAAA,EACF;AAGA,SAAO;AACT;AAAA;AAMO,SAAS,OAAO,UAA0C;AAC/D,QAAM,WAAW,iCAAiB,QAAQ;AAC1C,MAAI,OAAO,aAAa,YAAY,SAAS,WAAW,GAAG;AACzD,WAAO;AAAA,EACT;AAKA,MAAI,uBAAuB,KAAK,QAAQ,GAAG;AACzC,WAAO;AAAA,EACT;AAGA,MAAI,aAAa,OAAO,aAAa,MAAM;AACzC,WAAO;AAAA,EACT;AAGA,MAAI,2BAAW,QAAQ,GAAG;AACxB,WAAO;AAAA,EACT;AAGA,MAAI,SAAS,SAAS,GAAG,KAAK,SAAS,SAAS,IAAI,GAAG;AAKrD,QAAI,SAAS,WAAW,GAAG,KAAK,CAAC,SAAS,WAAW,IAAI,GAAG;AAC1D,YAAM,QAAQ,SAAS,MAAM,GAAG;AAEhC,UAAI,MAAM,UAAU,KAAK,CAAC,MAAM,CAAC,GAAG,SAAS,IAAI,GAAG;AAClD,eAAO;AAAA,MACT;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAGA,SAAO;AACT;AAAA;AAMO,SAAS,WAAW,UAA0C;AACnE,QAAM,WAAW,iCAAiB,QAAQ;AAC1C,MAAI,OAAO,aAAa,UAAU;AAChC,WAAO;AAAA,EACT;AAEA,MAAI,SAAS,WAAW,GAAG;AACzB,WAAO;AAAA,EACT;AAEA,SAAO,CAAC,2BAAW,QAAQ;AAC7B;AAAA;AAMO,SAAS,cAAc,UAAyC;AACrE,QAAM,WAAW,iCAAiB,QAAQ;AAC1C,QAAM,EAAE,OAAO,IAAI;AACnB,MAAI,WAAW,GAAG;AAChB,WAAO;AAAA,EACT;AACA,MAAI,SAAS,GAAG;AACd,WAAO,WAAW,KAAK,SAAS,WAAW,CAAC,MAAM,KAC9C,MACA;AAAA,EACN;AAEA,MAAI,OAAO;AACX,MAAI,QAAQ;AAQZ,MAAI,SAAS;AACb,MAAI,SAAS,KAAK,SAAS,WAAW,CAAC,MAAM,IAAa;AACxD,UAAM,QAAQ,SAAS,WAAW,CAAC;AAEnC,SACG,UAAU,MAAc,UAAU,OACnC,SAAS,WAAW,CAAC,MAAM,MAC3B,SAAS,WAAW,CAAC,MAAM,IAC3B;AACA,cAAQ;AACR,eAAS;AAAA,IACX;AAAA,EACF;AACA,MAAI,UAAU,GAAG;AAGf,QACE,SAAS,MACP,SAAS,WAAW,CAAC,MAAM,MAC3B,SAAS,WAAW,CAAC,MAAM,MAC3B,SAAS,WAAW,CAAC,MAAM,MAC1B,SAAS,WAAW,CAAC,MAAM,MAC1B,SAAS,WAAW,CAAC,MAAM,MAC3B,SAAS,WAAW,CAAC,MAAM,KAC/B;AAGA,UAAI,kBAAkB;AACtB,UAAI,mBAAmB;AAGvB,UAAI,IAAI;AACR,aACE,IAAI,WACH,SAAS,WAAW,CAAC,MAAM,MAC1B,SAAS,WAAW,CAAC,MAAM,KAC7B;AACA;AAAA,MACF;AAGA,aAAO,IAAI,QAAQ;AACjB,cAAM,OAAO,SAAS,WAAW,CAAC;AAClC,YAAI,SAAS,MAAc,SAAS,IAAa;AAC/C,4BAAkB;AAClB;AAAA,QACF;AACA;AAAA,MACF;AAEA,UAAI,kBAAkB,GAAG;AAEvB,YAAI;AACJ,eACE,IAAI,WACH,SAAS,WAAW,CAAC,MAAM,MAC1B,SAAS,WAAW,CAAC,MAAM,KAC7B;AACA;AAAA,QACF;AAEA,YAAI,IAAI,QAAQ;AACd,6BAAmB;AAAA,QACrB;AAAA,MACF;AAEA,UAAI,kBAAkB,KAAK,kBAAkB;AAE3C,gBAAQ;AACR,iBAAS;AAAA,MACX,OAAO;AAEL,eAAO,SAAS,WAAW,KAAK;AAChC,eAAO,SAAS,MAAc,SAAS,IAAa;AAClD,mBAAS;AACT,iBAAO,SAAS,WAAW,KAAK;AAAA,QAClC;AACA,YAAI,OAAO;AACT,mBAAS;AAAA,QACX;AAAA,MACF;AAAA,IACF,OAAO;AAEL,aAAO,SAAS,WAAW,KAAK;AAChC,aAAO,SAAS,MAAc,SAAS,IAAa;AAClD,iBAAS;AACT,eAAO,SAAS,WAAW,KAAK;AAAA,MAClC;AACA,UAAI,OAAO;AACT,iBAAS;AAAA,MACX;AAAA,IACF;AAAA,EACF;AACA,MAAI,gBAAY,uBAAO,UAAU,aAAa,EAAE,WAAW,MAAM,CAAC;AAClE,MAAI,cAAc,IAAI;AACpB,UAAM,UAAU,SAAS,MAAM,KAAK;AACpC,QAAI,YAAY,OAAO,QAAQ,WAAW,GAAG;AAC3C,aAAO,UAAU;AAAA,IACnB;AACA,QAAI,YAAY,MAAM;AACpB,aAAO,SAAS,OAAO,MAAM,GAAG,EAAE,KAAK,MAAM;AAAA,IAC/C;AACA,WAAO,SAAS;AAAA,EAClB;AAEA,MAAI,YAAY;AAChB,MAAI,eAAe;AACnB,MAAI,iBAAiB;AACrB,SAAO,cAAc,IAAI;AACvB,UAAM,UAAU,SAAS,MAAM,OAAO,SAAS;AAC/C,QAAI,QAAQ,SAAS,KAAK,YAAY,KAAK;AACzC,UAAI,YAAY,MAAM;AAEpB,YAAI,eAAe,GAAG;AAEpB,gBAAM,qBAAqB,UAAU,YAAY,GAAG;AACpD,cAAI,uBAAuB,IAAI;AAE7B,wBAAY;AACZ,2BAAe;AAEf,gBAAI,iBAAiB,KAAK,CAAC,QAAQ;AACjC,0BAAY;AACZ,+BAAiB;AAAA,YACnB;AAAA,UACF,OAAO;AACL,kBAAM,mBAAmB,qBAAqB;AAC9C,kBAAM,mBAAmB,UAAU,MAAM,gBAAgB;AAEzD,gBAAI,qBAAqB,MAAM;AAE7B,0BAAY,GAAG,SAAS,IAAI,OAAO;AACnC,gCAAkB;AAAA,YACpB,OAAO;AAEL,0BAAY,UAAU,MAAM,GAAG,kBAAkB;AACjD,8BAAgB;AAAA,YAClB;AAAA,UACF;AAAA,QACF,WAAW,CAAC,QAAQ;AAElB,sBAAY,aAAa,UAAU,WAAW,IAAI,KAAK,OAAO;AAC9D,4BAAkB;AAAA,QACpB;AAAA,MACF,OAAO;AACL,oBAAY,aAAa,UAAU,WAAW,IAAI,KAAK,OAAO;AAC9D,wBAAgB;AAAA,MAClB;AAAA,IACF;AACA,YAAQ,YAAY;AACpB,WAAO,SAAS,WAAW,KAAK;AAChC,WAAO,SAAS,MAAc,SAAS,IAAa;AAClD,eAAS;AACT,aAAO,SAAS,WAAW,KAAK;AAAA,IAClC;AACA,oBAAY,uBAAO,UAAU,aAAa,EAAE,WAAW,MAAM,CAAC;AAAA,EAChE;AACA,QAAM,cAAc,SAAS,MAAM,KAAK;AACxC,MAAI,YAAY,SAAS,KAAK,gBAAgB,KAAK;AACjD,QAAI,gBAAgB,MAAM;AACxB,UAAI,eAAe,GAAG;AACpB,cAAM,qBAAqB,UAAU,YAAY,GAAG;AACpD,YAAI,uBAAuB,IAAI;AAC7B,sBAAY;AACZ,yBAAe;AAEf,cAAI,iBAAiB,KAAK,CAAC,QAAQ;AACjC,wBAAY;AACZ,6BAAiB;AAAA,UACnB;AAAA,QACF,OAAO;AACL,gBAAM,mBAAmB,qBAAqB;AAC9C,gBAAM,mBAAmB,UAAU,MAAM,gBAAgB;AAEzD,cAAI,qBAAqB,MAAM;AAE7B,wBAAY,GAAG,SAAS,IAAI,WAAW;AACvC,8BAAkB;AAAA,UACpB,OAAO;AAEL,wBAAY,UAAU,MAAM,GAAG,kBAAkB;AACjD,4BAAgB;AAAA,UAClB;AAAA,QACF;AAAA,MACF,WAAW,CAAC,QAAQ;AAClB,oBACE,aAAa,UAAU,WAAW,IAAI,KAAK,OAAO;AACpD,0BAAkB;AAAA,MACpB;AAAA,IACF,OAAO;AACL,kBAAY,aAAa,UAAU,WAAW,IAAI,KAAK,OAAO;AAC9D,sBAAgB;AAAA,IAClB;AAAA,EACF;AAEA,MAAI,UAAU,WAAW,GAAG;AAC1B,WAAO,UAAU;AAAA,EACnB;AACA,SAAO,SAAS;AAClB;AAAA;AAMO,SAAS,iBACd,UACQ;AACR,MAAI,aAAa,QAAQ,aAAa,QAAW;AAC/C,WAAO;AAAA,EACT;AACA,MAAI,OAAO,aAAa,UAAU;AAChC,WAAO;AAAA,EACT;AACA,QAAM,EAAE,QAAAA,QAAO,IAAI,0BAAU;AAC7B,MAAIA,QAAO,SAAS,QAAQ,GAAG;AAC7B,WAAO,SAAS,SAAS,MAAM;AAAA,EACjC;AACA,QAAM,MAAM,uBAAO;AACnB,MAAI,oBAAoB,KAAK;AAC3B,QAAI;AACF,aAAO,IAAI,cAAc,QAAQ;AAAA,IACnC,QAAQ;AASN,YAAM,WAAW,SAAS;AAK1B,YAAM,kBAAkB,mBAAmB,QAAQ;AAMnD,YAAMC,SAAQ,QAAQ,uBAAuB,EAAE;AAC/C,UAAIA,UAAS,gBAAgB,WAAW,GAAG,GAAG;AAI5C,cAAM,SAAS,gBAAgB,WAAW,CAAC,IAAI;AAC/C,cAAM,sBACJ,gBAAgB,UAAU,KAC1B,UAAU;AAAA,QAEV,UAAU,OACV,gBAAgB,OAAO,CAAC,MAAM;AAEhC,YAAI,CAAC,qBAAqB;AAIxB,iBAAO;AAAA,QACT;AAAA,MACF;AACA,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO,OAAO,QAAQ;AACxB;AAAA;AAMO,SAAS,UAAU,UAA2C;AACnE,QAAM,WAAW,iCAAiB,QAAQ;AAC1C,MAAI,aAAa,IAAI;AACnB,WAAO,CAAC;AAAA,EACV;AACA,SAAO,SAAS,MAAM,WAAW;AACnC;AAAA;AAMO,SAAS,oBAAoB,UAAyC;AAC3E,QAAM,WAAW,iCAAiB,QAAQ;AAE1C,MAAI,SAAS,WAAW,IAAI,KAAK,SAAS,WAAW,KAAK,GAAG;AAC3D,WAAO,SAAS,MAAM,CAAC;AAAA,EACzB;AACA,SAAO;AACT;AAAA;AAkBA,SAAS,WAAW,UAA4B;AAC9C,MAAI,eAAe;AACnB,MAAI,mBAAmB;AAKvB,WAAS,IAAI,SAAS,SAAS,GAAG,KAAK,KAAK,CAAC,kBAAkB,KAAK,GAAG;AACrE,UAAM,UAAU,SAAS,CAAC;AAG1B,QAAI,OAAO,YAAY,YAAY,QAAQ,WAAW,GAAG;AACvD;AAAA,IACF;AAIA,mBACE,WAAW,aAAa,WAAW,IAAI,KAAK,IAAI,YAAY;AAI9D,uBAAmB,2BAAW,OAAO;AAAA,EACvC;AAIA,MAAI,CAAC,kBAAkB;AACrB,UAAM,MAAoB,wBAAQ,cAAc,EAAE,IAAI;AACtD,mBAAe,OAAO,aAAa,WAAW,IAAI,KAAK,IAAI,YAAY;AAAA,EACzE;AAGA,SAAO,8BAAc,YAAY;AACnC;AAAA;AA6BA,SAAS,SAAS,MAAc,IAAoB;AAElD,MAAI,SAAS,IAAI;AACf,WAAO;AAAA,EACT;AAIA,QAAM,aAAa,wBAAQ,IAAI;AAC/B,QAAM,WAAW,wBAAQ,EAAE;AAG3B,MAAI,eAAe,UAAU;AAC3B,WAAO;AAAA,EACT;AAEA,QAAMA,SAAQ,QAAQ,uBAAuB,EAAE;AAM/C,MAAIA,QAAO;AACT,UAAM,YAAY,WAAW,YAAY;AACzC,UAAM,UAAU,SAAS,YAAY;AACrC,QAAI,cAAc,SAAS;AACzB,aAAO;AAAA,IACT;AAAA,EACF;AAKA,QAAM,YAAY;AAClB,QAAM,UAAU,WAAW;AAC3B,QAAM,UAAU,UAAU;AAC1B,QAAM,UAAU;AAChB,QAAM,QAAQ,SAAS;AACvB,QAAM,QAAQ,QAAQ;AAItB,QAAM,SAAS,UAAU,QAAQ,UAAU;AAE3C,MAAI,gBAAgB;AACpB,MAAI,IAAI;AAER,SAAO,IAAI,QAAQ,KAAK,GAAG;AACzB,UAAM,WAAW,WAAW,WAAW,YAAY,CAAC;AACpD,UAAM,SAAS,SAAS,WAAW,UAAU,CAAC;AAG9C,QAAI,aAAa,QAAQ;AACvB;AAAA,IACF;AAIA,QAAI,gCAAgB,QAAQ,GAAG;AAC7B,sBAAgB;AAAA,IAClB;AAAA,EACF;AAGA,MAAI,MAAM,QAAQ;AAChB,QAAI,QAAQ,QAAQ;AAElB,YAAM,SAAS,SAAS,WAAW,UAAU,CAAC;AAC9C,UAAI,gCAAgB,MAAM,GAAG;AAI3B,eAAO,SAAS,MAAM,UAAU,IAAI,CAAC;AAAA,MACvC;AACA,UAAI,MAAM,GAAG;AAGX,eAAO,SAAS,MAAM,UAAU,CAAC;AAAA,MACnC;AAAA,IACF,WAAW,UAAU,QAAQ;AAE3B,YAAM,WAAW,WAAW,WAAW,YAAY,CAAC;AACpD,UAAI,gCAAgB,QAAQ,GAAG;AAI7B,wBAAgB;AAAA,MAClB,WAAW,MAAM,GAAG;AAGlB,wBAAgB;AAAA,MAClB;AAAA,IACF;AAAA,EACF;AAGA,MAAI,MAAM;AAKV,OAAK,IAAI,YAAY,gBAAgB,GAAG,KAAK,SAAS,KAAK,GAAG;AAC5D,UAAM,OAAO,WAAW,WAAW,CAAC;AAGpC,QAAI,MAAM,WAAW,gCAAgB,IAAI,GAAG;AAC1C,aAAO,IAAI,WAAW,IAAI,OAAO;AAAA,IACnC;AAAA,EACF;AAIA,SAAO,MAAM,SAAS,MAAM,UAAU,aAAa;AACrD;AAAA;AAMO,SAAS,gBAAgB,MAAc,IAAoB;AAChE,QAAM,MAAM,yBAAS,MAAM,EAAE;AAE7B,MAAI,QAAQ,IAAI;AACd,WAAO;AAAA,EACT;AACA,SAAO,8BAAc,GAAG;AAC1B;",
+  "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 * Determines whether the given character code is either a forward slash (/) or\n * backslash (\\), which are used as path separators across different platforms.\n *\n * @param {number} code - The character code to check\n * @returns {boolean} `true` if the code represents a path separator, `false` otherwise\n *\n * @example\n * ```typescript\n * isPathSeparator(47)  // true - forward slash '/'\n * isPathSeparator(92)  // true - backslash '\\'\n * isPathSeparator(65)  // false - letter 'A'\n * ```\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 * Tests whether the given character code falls within the valid range for\n * Windows drive letters (A-Z or a-z). These letters are used at the start\n * of Windows absolute paths (e.g., `C:\\`, `D:\\`).\n *\n * @param {number} code - The character code to check\n * @returns {boolean} `true` if the code is a valid drive letter, `false` otherwise\n *\n * @example\n * ```typescript\n * isWindowsDeviceRoot(67)  // true - letter 'C'\n * isWindowsDeviceRoot(99)  // true - letter 'c'\n * isWindowsDeviceRoot(58)  // false - colon ':'\n * isWindowsDeviceRoot(47)  // false - forward slash '/'\n * ```\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 *\n * Performs on-demand loading of Node.js buffer module to avoid initialization\n * overhead and potential Webpack bundling errors.\n *\n * @private\n * @returns {typeof import('node:buffer')} The buffer module\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 *\n * Performs on-demand loading of Node.js url module to avoid initialization\n * overhead and potential Webpack bundling errors.\n *\n * @private\n * @returns {typeof import('node:url')} The url module\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 * Detects whether a given path includes a `node_modules` directory segment.\n * This is useful for identifying npm package dependencies and filtering\n * dependency-related paths.\n *\n * The check matches `node_modules` appearing as a complete path segment,\n * ensuring it is either at the start, end, or surrounded by path separators.\n *\n * @param {string | Buffer | URL} pathLike - The path to check\n * @returns {boolean} `true` if the path contains `node_modules`, `false` otherwise\n *\n * @example\n * ```typescript\n * isNodeModules('/project/node_modules/package')    // true\n * isNodeModules('node_modules/package/index.js')    // true\n * isNodeModules('/src/my_node_modules_backup')      // false\n * isNodeModules('/project/src/index.js')            // false\n * ```\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 * @param {string | Buffer | URL} pathLike - The path to check\n * @returns {boolean} `true` if the path is absolute, `false` otherwise\n *\n * @example\n * ```typescript\n * // POSIX paths\n * isAbsolute('/home/user')           // true\n * isAbsolute('/usr/bin/node')        // true\n *\n * // Windows paths\n * isAbsolute('C:\\\\Windows')          // true\n * isAbsolute('D:/data')              // true\n * isAbsolute('\\\\\\\\server\\\\share')    // true\n *\n * // Relative paths\n * isAbsolute('../relative')          // false\n * isAbsolute('relative/path')        // false\n * isAbsolute('.')                    // false\n * ```\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 * Determines whether a given value represents a valid file system path.\n * This function distinguishes between file paths and other string formats\n * like package names, URLs, or bare module specifiers.\n *\n * Valid paths include:\n * - Absolute paths (e.g., `/usr/bin`, `C:\\Windows`)\n * - Relative paths with separators (e.g., `./src`, `../lib`)\n * - Special relative paths (`.`, `..`)\n * - Paths starting with `@` that have subpaths (e.g., `@scope/name/file`)\n *\n * Not considered paths:\n * - URLs with protocols (e.g., `http://`, `file://`, `git:`)\n * - Bare package names (e.g., `lodash`, `react`)\n * - Scoped package names without subpaths (e.g., `@scope/name`)\n *\n * @param {string | Buffer | URL} pathLike - The value to check\n * @returns {boolean} `true` if the value is a valid file path, `false` otherwise\n *\n * @example\n * ```typescript\n * // Valid paths\n * isPath('/absolute/path')           // true\n * isPath('./relative/path')          // true\n * isPath('../parent/dir')            // true\n * isPath('.')                        // true\n * isPath('..')                       // true\n * isPath('@scope/name/subpath')      // true\n * isPath('C:\\\\Windows')              // true (Windows)\n *\n * // Not paths\n * isPath('lodash')                   // false - bare package name\n * isPath('@scope/package')           // false - scoped package name\n * isPath('http://example.com')       // false - URL\n * isPath('file://path')              // false - file URL\n * isPath('')                         // false - empty string\n * ```\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 * Determines whether a given path is relative (i.e., not absolute). A path\n * is considered relative if it does not specify a location from the root of\n * the file system.\n *\n * Relative paths include:\n * - Paths starting with `.` or `..` (e.g., `./src`, `../lib`)\n * - Paths without leading separators (e.g., `src/file.js`)\n * - Empty strings (treated as relative)\n *\n * @param {string | Buffer | URL} pathLike - The path to check\n * @returns {boolean} `true` if the path is relative, `false` if absolute\n *\n * @example\n * ```typescript\n * // Relative paths\n * isRelative('./src/index.js')       // true\n * isRelative('../lib/util.js')       // true\n * isRelative('src/file.js')          // true\n * isRelative('')                     // true\n *\n * // Absolute paths\n * isRelative('/home/user')           // false\n * isRelative('C:\\\\Windows')          // false (Windows)\n * isRelative('\\\\\\\\server\\\\share')    // false (Windows UNC)\n * ```\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 * This function performs several normalization operations:\n * - Converts all backslashes (`\\`) to forward slashes (`/`)\n * - Collapses repeated slashes into single slashes\n * - Resolves `.` (current directory) segments\n * - Resolves `..` (parent directory) segments\n * - Preserves UNC path prefixes (`//server/share`)\n * - Preserves Windows namespace prefixes (`//./`, `//?/`)\n * - Returns `.` for empty or collapsed paths\n *\n * Special handling:\n * - UNC paths: Maintains double leading slashes for `//server/share` format\n * - Windows namespaces: Preserves `//./` and `//?/` prefixes\n * - Leading `..` segments: Preserved in relative paths without prefix\n * - Trailing components: Properly handled when resolving `..`\n *\n * @param {string | Buffer | URL} pathLike - The path to normalize\n * @returns {string} The normalized path with forward slashes and collapsed segments\n *\n * @example\n * ```typescript\n * // Basic normalization\n * normalizePath('foo/bar//baz')              // 'foo/bar/baz'\n * normalizePath('foo/./bar')                 // 'foo/bar'\n * normalizePath('foo/bar/../baz')            // 'foo/baz'\n *\n * // Windows paths\n * normalizePath('C:\\\\Users\\\\John\\\\file.txt') // 'C:/Users/John/file.txt'\n * normalizePath('foo\\\\bar\\\\baz')             // 'foo/bar/baz'\n *\n * // UNC paths\n * normalizePath('\\\\\\\\server\\\\share\\\\file')   // '//server/share/file'\n *\n * // Edge cases\n * normalizePath('')                          // '.'\n * normalizePath('.')                         // '.'\n * normalizePath('..')                        // '..'\n * normalizePath('///foo///bar///')           // '/foo/bar'\n * normalizePath('foo/../..')                 // '..'\n * ```\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 * Converts various path-like types (string, Buffer, URL) into a normalized\n * string representation. This function handles different input formats and\n * provides consistent string output for path operations.\n *\n * Supported input types:\n * - `string`: Returned as-is\n * - `Buffer`: Decoded as UTF-8 string\n * - `URL`: Converted using `fileURLToPath()`, with fallback for malformed URLs\n * - `null` / `undefined`: Returns empty string\n *\n * URL handling:\n * - Valid file URLs are converted via `url.fileURLToPath()`\n * - Malformed URLs fall back to pathname extraction with decoding\n * - Windows drive letters in URLs are handled specially\n * - Percent-encoded characters are decoded (e.g., `%20` becomes space)\n *\n * @param {string | Buffer | URL | null | undefined} pathLike - The path-like value to convert\n * @returns {string} The string representation of the path, or empty string for null/undefined\n *\n * @example\n * ```typescript\n * // String input\n * pathLikeToString('/home/user')                        // '/home/user'\n *\n * // Buffer input\n * pathLikeToString(Buffer.from('/tmp/file'))            // '/tmp/file'\n *\n * // URL input\n * pathLikeToString(new URL('file:///home/user'))        // '/home/user'\n * pathLikeToString(new URL('file:///C:/Windows'))       // 'C:/Windows' (Windows)\n *\n * // Null/undefined input\n * pathLikeToString(null)                                // ''\n * pathLikeToString(undefined)                           // ''\n *\n * // Percent-encoded URLs\n * pathLikeToString(new URL('file:///path%20with%20spaces'))  // '/path with spaces'\n * ```\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 * Divides a path into individual components by splitting on path separators\n * (both forward slashes and backslashes). This is useful for path traversal,\n * analysis, and manipulation.\n *\n * The function handles:\n * - Forward slashes (`/`) on all platforms\n * - Backslashes (`\\`) on Windows\n * - Mixed separators in a single path\n * - Empty paths (returns empty array)\n *\n * Note: The resulting array may contain empty strings if the path has leading,\n * trailing, or consecutive separators (e.g., `/foo//bar/` becomes `['', 'foo', '', 'bar', '']`).\n *\n * @param {string | Buffer | URL} pathLike - The path to split\n * @returns {string[]} Array of path segments, or empty array for empty paths\n *\n * @example\n * ```typescript\n * // POSIX paths\n * splitPath('/home/user/file.txt')      // ['', 'home', 'user', 'file.txt']\n * splitPath('src/lib/util.js')          // ['src', 'lib', 'util.js']\n *\n * // Windows paths\n * splitPath('C:\\\\Users\\\\John')          // ['C:', 'Users', 'John']\n * splitPath('folder\\\\file.txt')         // ['folder', 'file.txt']\n *\n * // Mixed separators\n * splitPath('path/to\\\\file')            // ['path', 'to', 'file']\n *\n * // Edge cases\n * splitPath('')                         // []\n * splitPath('/')                        // ['', '']\n * splitPath('/foo//bar/')               // ['', 'foo', '', 'bar', '']\n * ```\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 * Strips the `./` or `.\\` prefix from relative paths. This is useful for\n * normalizing paths when the current directory reference is implicit or\n * unwanted.\n *\n * Note: This function only removes a single leading `./` or `.\\`. It does\n * not remove `../` prefixes or process the rest of the path.\n *\n * @param {string | Buffer | URL} pathLike - The path to process\n * @returns {string} The path without leading `./` or `.\\`, or unchanged if no such prefix\n *\n * @example\n * ```typescript\n * // Remove ./ prefix\n * trimLeadingDotSlash('./src/index.js')     // 'src/index.js'\n * trimLeadingDotSlash('.\\\\src\\\\file.txt')   // 'src\\\\file.txt'\n *\n * // Preserve ../ prefix\n * trimLeadingDotSlash('../lib/util.js')     // '../lib/util.js'\n *\n * // No change for other paths\n * trimLeadingDotSlash('/absolute/path')     // '/absolute/path'\n * trimLeadingDotSlash('relative/path')      // 'relative/path'\n * trimLeadingDotSlash('.')                  // '.'\n * ```\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 building an\n * absolute path from the given segments. It processes segments from right\n * to left, stopping when an absolute path is encountered. If no absolute\n * path is found, it prepends the current working directory.\n *\n * Algorithm:\n * 1. Process segments from right to left\n * 2. Stop when an absolute path is found\n * 3. Prepend current working directory if no absolute path found\n * 4. Normalize the final path\n *\n * Key behaviors:\n * - Later segments override earlier ones (e.g., `resolve('/foo', '/bar')` returns `/bar`)\n * - Empty or non-string segments are skipped\n * - Result is always an absolute path\n * - Path separators are normalized to forward slashes\n *\n * @param {...string} segments - Path segments to resolve\n * @returns {string} The resolved absolute path\n *\n * @example\n * ```typescript\n * // Basic resolution\n * resolve('foo', 'bar', 'baz')           // '/cwd/foo/bar/baz' (assuming cwd is '/cwd')\n * resolve('/foo', 'bar', 'baz')          // '/foo/bar/baz'\n * resolve('foo', '/bar', 'baz')          // '/bar/baz'\n *\n * // Windows paths\n * resolve('C:\\\\foo', 'bar')              // 'C:/foo/bar'\n *\n * // Empty segments\n * resolve('foo', '', 'bar')              // '/cwd/foo/bar'\n * resolve()                              // '/cwd' (current directory)\n * ```\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 the `from` path to the `to` path\n * using relative path notation. Both paths are first resolved to absolute\n * paths, then compared to find the common base path, and finally a relative\n * path is constructed using `../` for parent 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 * @param {string} from - The source path (starting point)\n * @param {string} to - The destination path (target)\n * @returns {string} The relative path from `from` to `to`, or empty string if paths are identical\n *\n * @example\n * ```typescript\n * // Basic relative paths\n * relative('/foo/bar', '/foo/baz')           // '../baz'\n * relative('/foo/bar/baz', '/foo')           // '../..'\n * relative('/foo', '/foo/bar')               // 'bar'\n *\n * // Same paths\n * relative('/foo/bar', '/foo/bar')           // ''\n *\n * // Windows case-insensitive\n * relative('C:\\\\Foo\\\\bar', 'C:\\\\foo\\\\baz')   // '../baz' (Windows)\n *\n * // Root paths\n * relative('/', '/foo/bar')                  // 'foo/bar'\n * relative('/foo/bar', '/')                  // '../..'\n * ```\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 * Computes the relative path from `from` to `to` and normalizes the result.\n * This is a convenience wrapper around the `relative()` function that adds\n * path normalization (converting separators and collapsing segments).\n *\n * The function:\n * 1. Calculates the relative path using `relative()`\n * 2. Normalizes the result using `normalizePath()`\n * 3. Preserves empty strings (same path) without converting to `.`\n *\n * @param {string} from - The source path (starting point)\n * @param {string} to - The destination path (target)\n * @returns {string} The normalized relative path from `from` to `to`, or empty string if paths are identical\n *\n * @example\n * ```typescript\n * // Basic usage\n * relativeResolve('/foo/bar', '/foo/baz')         // '../baz'\n * relativeResolve('/foo/bar/baz', '/foo')         // '../..'\n * relativeResolve('/foo', '/foo/bar')             // 'bar'\n *\n * // Same paths\n * relativeResolve('/foo/bar', '/foo/bar')         // ''\n *\n * // Windows paths (normalized)\n * relativeResolve('C:\\\\foo\\\\bar', 'C:\\\\foo\\\\baz') // '../baz'\n *\n * // With normalization\n * relativeResolve('/foo/./bar', '/foo/baz')       // '../baz'\n * relativeResolve('/foo/bar/../baz', '/foo/qux')  // '../qux'\n * ```\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"]
 }