@reliverse/pathkit 1.0.5 → 1.1.0

package/bin/mod.js

@@ -1,50 +1,726 @@
-import { normalizeWindowsPath } from "./pathkit-impl/_internal.js";
-import {
+import fs from "node:fs/promises";
+const EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+const SLASH = "/";
+const BACK_SLASH = "\\";
+const DOT = ".";
+const DOUBLE_DOT = "..";
+const EMPTY = "";
+const normalizedAliasSymbol = Symbol.for("pathkit:normalizedAlias");
+const DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+const DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const UNC_REGEX = /^[/\\]{2}/;
+const IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
+const PATH_ROOT_RE = /^[/\\]|^[a-zA-Z]:[/\\]/;
+const IMPORT_REGEX = /(?:import\s+(?:[\s\S]*?)\s+from\s+|import\s*\(\s*)\s*(['"])((?:@)[^'"]+)\1/g;
+const log = (msg) => console.log(`\x1B[2m${msg}\x1B[0m`);
+async function cleanDirs(dirs) {
+  await Promise.all(
+    dirs.map(async (d) => {
+      try {
+        await fs.rm(d, { recursive: true, force: true });
+        log(`\u2713 cleaned: ${d}`);
+      } catch (error) {
+        log(
+          `\u2717 error cleaning ${d}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    })
+  );
+}
+async function copyDir(src, dest) {
+  log(`\u2713 copying: ${src} \u2192 ${dest}`);
+  try {
+    await fs.mkdir(dest, { recursive: true });
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    await Promise.all(
+      entries.map(async (entry) => {
+        const srcPath = join(src, entry.name);
+        const destPath = join(dest, entry.name);
+        if (entry.isDirectory()) {
+          return copyDir(srcPath, destPath);
+        }
+        await fs.copyFile(srcPath, destPath);
+        log(`  copied: ${srcPath} \u2192 ${destPath}`);
+      })
+    );
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    log(`\u2717 error copying directory ${src} to ${dest}: ${errorMsg}`);
+    throw error;
+  }
+}
+function normalizeWindowsPath(input = "") {
+  if (!input) return input;
+  return input.replace(/\\/g, SLASH).replace(DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+function compareAliases(a, b) {
+  return b.split(SLASH).length - a.split(SLASH).length;
+}
+function cwd() {
+  if (typeof process !== "undefined" && typeof process.cwd === "function") {
+    return process.cwd().replace(/\\/g, SLASH);
+  }
+  return SLASH;
+}
+function normalizeString(path2, allowAboveRoot) {
+  let res = EMPTY;
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path2.length; ++index) {
+    if (index < path2.length) {
+      char = path2[index];
+    } else if (char === SLASH) {
+      break;
+    } else {
+      char = SLASH;
+    }
+    if (char === SLASH) {
+      if (lastSlash === index - 1 || dots === 1) {
+      } else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || !res.endsWith(DOT) || res[res.length - 2] !== DOT) {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf(SLASH);
+            if (lastSlashIndex === -1) {
+              res = EMPTY;
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf(SLASH);
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+          if (res.length > 0) {
+            res = EMPTY;
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? `${SLASH}..` : DOUBLE_DOT;
+          lastSegmentLength = 2;
+        }
+      } else {
+        const segment = path2.slice(lastSlash + 1, index);
+        if (res.length > 0) {
+          res += `${SLASH}${segment}`;
+        } else {
+          res = segment;
+        }
+        lastSegmentLength = segment.length;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === DOT && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+const sep = SLASH;
+const normalize = (path2) => {
+  if (path2.length === 0) return DOT;
+  const originalPath = path2;
+  path2 = normalizeWindowsPath(path2);
+  const isPathAbsolute = IS_ABSOLUTE_RE.test(path2);
+  const trailingSeparator = path2.endsWith(SLASH);
+  path2 = normalizeString(path2, !isPathAbsolute);
+  if (path2.length === 0) {
+    if (isPathAbsolute) return SLASH;
+    return trailingSeparator && originalPath.length > 0 && originalPath !== DOT ? "./" : DOT;
+  }
+  if (trailingSeparator && !path2.endsWith(SLASH)) {
+    path2 += SLASH;
+  }
+  if (DRIVE_LETTER_RE.test(path2) && path2.length === 2) {
+    path2 += SLASH;
+  }
+  if (UNC_REGEX.test(originalPath.replace(/\\/g, SLASH))) {
+    const normOriginal = originalPath.replace(/\\/g, SLASH);
+    if (normOriginal.startsWith("//./")) {
+      return `//./${path2.startsWith(SLASH) ? path2.substring(1) : path2}`;
+    }
+    if (normOriginal.startsWith("//") && !normOriginal.startsWith("//./")) {
+      return `//${path2.startsWith(SLASH) ? path2.substring(1) : path2}`;
+    }
+  }
+  if (isPathAbsolute && !IS_ABSOLUTE_RE.test(path2) && path2 !== SLASH) {
+    return `${SLASH}${path2}`;
+  }
+  return path2;
+};
+const join = (...segments) => {
+  if (segments.length === 0) return DOT;
+  let joined = EMPTY;
+  for (const segment of segments) {
+    if (typeof segment !== "string") {
+      throw new TypeError("Arguments to path.join must be strings");
+    }
+    if (segment.length > 0) {
+      if (joined.length === 0) {
+        joined = segment;
+      } else {
+        joined += `${SLASH}${segment}`;
+      }
+    }
+  }
+  if (joined.length === 0) return DOT;
+  return normalize(joined);
+};
+const resolve = (...args) => {
+  let resolvedPath = EMPTY;
+  let resolvedAbsolute = false;
+  for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+    const path2 = i >= 0 ? args[i] : cwd();
+    if (typeof path2 !== "string") {
+      throw new TypeError("Arguments to path.resolve must be strings");
+    }
+    if (path2.length === 0) continue;
+    const normalizedSegment = normalizeWindowsPath(path2);
+    resolvedPath = `${normalizedSegment}${SLASH}${resolvedPath}`;
+    resolvedAbsolute = IS_ABSOLUTE_RE.test(normalizedSegment);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute) {
+    if (IS_ABSOLUTE_RE.test(resolvedPath)) {
+      return resolvedPath;
+    }
+    return `${SLASH}${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : DOT;
+};
+const isAbsolute = (p) => {
+  if (typeof p !== "string") return false;
+  return IS_ABSOLUTE_RE.test(normalizeWindowsPath(p));
+};
+const toNamespacedPath = (p) => {
+  if (typeof p !== "string" || p.length === 0) return p;
+  return normalize(p);
+};
+const extname = (p) => {
+  if (typeof p !== "string") return EMPTY;
+  const path2 = normalizeWindowsPath(p);
+  let lastSlashIdx = path2.lastIndexOf(SLASH);
+  if (lastSlashIdx === -1) lastSlashIdx = 0;
+  const basePart = lastSlashIdx === 0 ? path2 : path2.substring(lastSlashIdx + 1);
+  if (basePart === DOT || basePart === DOUBLE_DOT) return EMPTY;
+  const lastDotIdx = basePart.lastIndexOf(DOT);
+  if (lastDotIdx <= 0) return EMPTY;
+  return basePart.substring(lastDotIdx);
+};
+const relative = (from, to) => {
+  const resolvedFrom = resolve(from);
+  const resolvedTo = resolve(to);
+  if (resolvedFrom === resolvedTo) return EMPTY;
+  const fromSegments = resolvedFrom.replace(ROOT_FOLDER_RE, "$1").split(SLASH).filter(Boolean);
+  const toSegments = resolvedTo.replace(ROOT_FOLDER_RE, "$1").split(SLASH).filter(Boolean);
+  if (fromSegments.length > 0 && toSegments.length > 0 && DRIVE_LETTER_RE.test(fromSegments[0]) && DRIVE_LETTER_RE.test(toSegments[0]) && fromSegments[0].toUpperCase() !== toSegments[0].toUpperCase()) {
+    return resolvedTo;
+  }
+  let commonSegments = 0;
+  const maxCommon = Math.min(fromSegments.length, toSegments.length);
+  while (commonSegments < maxCommon && fromSegments[commonSegments] === toSegments[commonSegments]) {
+    commonSegments++;
+  }
+  const upSegments = Array(fromSegments.length - commonSegments).fill(
+    DOUBLE_DOT
+  );
+  const downSegments = toSegments.slice(commonSegments);
+  const result = [...upSegments, ...downSegments].join(SLASH);
+  return result.length > 0 ? result : DOT;
+};
+const dirname = (p) => {
+  if (typeof p !== "string" || p.length === 0) return DOT;
+  const normalizedPath = normalizeWindowsPath(p);
+  const lastSlash = normalizedPath.lastIndexOf(SLASH);
+  if (lastSlash === -1) {
+    return IS_ABSOLUTE_RE.test(normalizedPath) ? SLASH : DOT;
+  }
+  if (lastSlash === 0) return SLASH;
+  const dir = normalizedPath.slice(0, lastSlash);
+  if (DRIVE_LETTER_RE.test(dir) && dir.length === 2) {
+    return dir + SLASH;
+  }
+  return normalize(dir);
+};
+const format = (p) => {
+  if (typeof p !== "object" || p === null) {
+    throw new TypeError(
+      'Parameter "pathObject" must be an object, not null or other type.'
+    );
+  }
+  const dir = p.dir || p.root || "";
+  const base = p.base || `${p.name || ""}${p.ext || ""}`;
+  if (!dir) return base;
+  if (dir === p.root) return `${dir}${base}`;
+  return normalize(`${dir}${SLASH}${base}`);
+};
+const basename = (p, ext) => {
+  if (typeof p !== "string") throw new TypeError("Path must be a string.");
+  if (ext !== void 0 && typeof ext !== "string")
+    throw new TypeError("[basename] `ext` must be a string.");
+  const normalizedPath = normalizeWindowsPath(p);
+  let end = normalizedPath.length;
+  while (end > 0 && normalizedPath[end - 1] === SLASH) {
+    end--;
+  }
+  if (end === 0) return EMPTY;
+  let start = normalizedPath.lastIndexOf(SLASH, end - 1);
+  start = start === -1 ? 0 : start + 1;
+  let filename2 = normalizedPath.slice(start, end);
+  if (ext && filename2.endsWith(ext) && filename2 !== ext) {
+    filename2 = filename2.slice(0, filename2.length - ext.length);
+  }
+  return filename2;
+};
+const parse = (p) => {
+  if (typeof p !== "string") throw new TypeError("Path must be a string.");
+  const normalizedPath = normalizeWindowsPath(p);
+  const B = basename(normalizedPath);
+  const E = extname(B);
+  const N = B.slice(0, B.length - E.length);
+  const D = dirname(normalizedPath);
+  let R = EMPTY;
+  const rootMatch = PATH_ROOT_RE.exec(normalizedPath);
+  if (rootMatch) {
+    R = rootMatch[0];
+    if (DRIVE_LETTER_RE.test(R) && R.length === 2 && normalizedPath.length > 2 && normalizedPath[2] === SLASH) {
+      R += SLASH;
+    } else if (R === SLASH && D.startsWith("//")) {
+      if (UNC_REGEX.exec(D)) {
+        const uncParts = D.split(SLASH).slice(0, 3);
+        R = uncParts.join(SLASH) || R;
+      }
+    }
+  }
+  const resolvedDir = D === DOT && R !== EMPTY && R !== DOT ? R : D;
+  return {
+    root: R,
+    dir: resolvedDir,
+    base: B,
+    ext: E,
+    name: N
+  };
+};
+function filename(pathString) {
+  const base = basename(pathString);
+  if (!base) return void 0;
+  const separatorIndex = base.lastIndexOf(DOT);
+  return separatorIndex <= 0 ? base : base.slice(0, separatorIndex);
+}
+function normalizeAliases(aliases) {
+  if (aliases[normalizedAliasSymbol]) {
+    return aliases;
+  }
+  const sortedAliasesEntries = Object.entries(aliases).map(
+    ([key, value]) => [normalizeWindowsPath(key), normalizeWindowsPath(value)]
+  ).sort(([a], [b]) => compareAliases(a, b));
+  const sortedAliases = Object.fromEntries(sortedAliasesEntries);
+  for (const key in sortedAliases) {
+    for (const aliasPrefix in sortedAliases) {
+      if (aliasPrefix === key || key.startsWith(aliasPrefix + SLASH) || key === aliasPrefix)
+        continue;
+      const value = sortedAliases[key];
+      if (value?.startsWith(aliasPrefix)) {
+        const nextChar = value[aliasPrefix.length];
+        if (nextChar === void 0 || nextChar === SLASH) {
+          sortedAliases[key] = sortedAliases[aliasPrefix] + value.slice(aliasPrefix.length);
+        }
+      }
+    }
+  }
+  const finalNormalizedAliases = { ...sortedAliases };
+  Object.defineProperty(finalNormalizedAliases, normalizedAliasSymbol, {
+    value: true,
+    enumerable: false
+  });
+  return finalNormalizedAliases;
+}
+function resolveAlias(path2, aliases) {
+  const normalizedPath = normalizeWindowsPath(path2);
+  const normalizedAliases = normalizeAliases(aliases);
+  for (const [alias, to] of Object.entries(normalizedAliases)) {
+    const effectiveAlias = alias.endsWith(SLASH) ? alias : alias + SLASH;
+    const effectivePath = normalizedPath.endsWith(SLASH) ? normalizedPath : normalizedPath + SLASH;
+    if (effectivePath.startsWith(effectiveAlias)) {
+      return join(to, normalizedPath.slice(alias.length));
+    }
+    if (normalizedPath === alias) {
+      return to;
+    }
+  }
+  return normalizedPath;
+}
+function reverseResolveAlias(path2, aliases) {
+  const normalizedPath = normalizeWindowsPath(path2);
+  const normalizedAliases = normalizeAliases(aliases);
+  const matches = [];
+  for (const [alias, to] of Object.entries(normalizedAliases)) {
+    const effectiveTo = to.endsWith(SLASH) ? to : to + SLASH;
+    const effectivePath = normalizedPath.endsWith(SLASH) ? normalizedPath : normalizedPath + SLASH;
+    if (effectivePath.startsWith(effectiveTo)) {
+      matches.push(join(alias, normalizedPath.slice(to.length)));
+    }
+    if (normalizedPath === to) {
+      matches.push(alias);
+    }
+  }
+  return matches.sort((a, b) => b.length - a.length);
+}
+const findAliasMatch = (importPath, paths) => {
+  if (paths[importPath]?.[0]) {
+    return {
+      key: importPath,
+      root: importPath,
+      resolvedPath: paths[importPath][0],
+      suffix: ""
+    };
+  }
+  for (const aliasKey in paths) {
+    if (aliasKey.endsWith("/*")) {
+      const aliasRoot = aliasKey.slice(0, -2);
+      if (importPath === aliasRoot || importPath.startsWith(`${aliasRoot}/`)) {
+        const suffix = importPath === aliasRoot ? "" : importPath.slice(aliasRoot.length + 1);
+        const targetPaths = paths[aliasKey];
+        if (targetPaths?.[0]) {
+          const resolvedPathPattern = targetPaths[0].slice(0, -2);
+          return {
+            key: aliasKey,
+            root: aliasRoot,
+            resolvedPath: resolvedPathPattern,
+            suffix
+          };
+        }
+      }
+    }
+  }
+  return null;
+};
+const toRelativeImport = (absPath, fromDir) => {
+  const rel = normalizeWindowsPath(relative(fromDir, absPath));
+  return rel.startsWith(DOT) ? rel : `./${rel}`;
+};
+async function resolveFileWithExtensions(basePath, extensions = ["", ...EXTENSIONS, ".json"]) {
+  for (const ext of extensions) {
+    try {
+      const fullPath = basePath + ext;
+      const stat = await fs.stat(fullPath);
+      if (stat.isFile()) {
+        return fullPath;
+      }
+    } catch {
+    }
+  }
+  for (const ext of extensions) {
+    try {
+      const indexPath = join(basePath, `index${ext}`);
+      const stat = await fs.stat(indexPath);
+      if (stat.isFile()) {
+        return indexPath;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function getTargetExtension(relPath, originalExt) {
+  const foundExt = extname(relPath);
+  if (originalExt) {
+    return relPath;
+  }
+  if (foundExt) {
+    return relPath.slice(0, -foundExt.length);
+  }
+  return relPath;
+}
+async function convertStringAliasRelative({
+  importPath,
+  importerFile,
+  pathPattern,
+  targetDir
+}) {
+  const paths = { [pathPattern]: ["./*"] };
+  const importerDir = dirname(importerFile);
+  const match = findAliasMatch(importPath, paths);
+  if (!match) return importPath;
+  const absPath = resolve(targetDir, match.resolvedPath, match.suffix);
+  const resolvedFile = await resolveFileWithExtensions(absPath);
+  const relPath = toRelativeImport(resolvedFile || absPath, importerDir);
+  const originalExt = extname(importPath);
+  return getTargetExtension(relPath, originalExt);
+}
+function replaceAllInString(original, searchValue, replaceValue) {
+  let currentPosition = 0;
+  let result = "";
+  while (currentPosition < original.length) {
+    const foundIdx = original.indexOf(searchValue, currentPosition);
+    if (foundIdx === -1) {
+      result += original.substring(currentPosition);
+      break;
+    }
+    result += original.substring(currentPosition, foundIdx);
+    result += replaceValue;
+    currentPosition = foundIdx + searchValue.length;
+  }
+  return result;
+}
+async function processFile(filePath, aliasToReplace, targetDir, pathExtFilter) {
+  const content = await fs.readFile(filePath, "utf-8");
+  let updated = content;
+  const changes = [];
+  const matches = Array.from(content.matchAll(IMPORT_REGEX));
+  const normalizedAlias = aliasToReplace.endsWith("/*") ? aliasToReplace : `${aliasToReplace}/*`;
+  for (const match of matches) {
+    const originalQuote = match[1];
+    const importPath = match[2];
+    const importExt = extname(importPath);
+    const shouldProcess = pathExtFilter === "js" && importExt === ".js" || pathExtFilter === "ts" && importExt === ".ts" || pathExtFilter === "none" && importExt === "" || pathExtFilter === "js-ts-none";
+    if (!shouldProcess) continue;
+    const relPath = await convertStringAliasRelative({
+      importPath,
+      importerFile: filePath,
+      pathPattern: normalizedAlias,
+      targetDir
+    });
+    if (importPath !== relPath) {
+      changes.push({ from: importPath, to: relPath });
+      const searchString = `${originalQuote}${importPath}${originalQuote}`;
+      const replacementString = `${originalQuote}${relPath}${originalQuote}`;
+      updated = replaceAllInString(updated, searchString, replacementString);
+    }
+  }
+  if (content !== updated) {
+    await fs.writeFile(filePath, updated);
+    log(`\u2713 processed: ${filePath}`);
+  }
+  return changes;
+}
+async function processAllFiles({
+  srcDir,
+  aliasToReplace,
+  extensionsToProcess,
+  rootDir,
+  pathExtFilter
+}) {
+  try {
+    const entries = await fs.readdir(srcDir, { withFileTypes: true });
+    const results = [];
+    await Promise.all(
+      entries.map(async (entry) => {
+        const fullPath = join(srcDir, entry.name);
+        if (entry.isDirectory()) {
+          if (entry.name === "node_modules" || entry.name.startsWith("."))
+            return;
+          const subdirResults = await processAllFiles({
+            srcDir: fullPath,
+            aliasToReplace,
+            extensionsToProcess,
+            rootDir,
+            pathExtFilter
+          });
+          results.push(...subdirResults);
+        } else if (extensionsToProcess.includes(extname(entry.name))) {
+          const changes = await processFile(
+            fullPath,
+            aliasToReplace,
+            rootDir,
+            pathExtFilter
+          );
+          if (changes.length > 0) {
+            results.push({ file: fullPath, changes });
+          }
+        }
+      })
+    );
+    return results;
+  } catch (error) {
+    log(
+      `error processing directory ${srcDir}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return [];
+  }
+}
+async function convertImportsAliasToRelative({
+  targetDir,
+  aliasToReplace,
+  // e.g. @, ~, @/*, ~/*
+  pathExtFilter
+}) {
+  const normalizedAlias = aliasToReplace.endsWith("/*") ? aliasToReplace : `${aliasToReplace}/*`;
+  log(
+    `Converting aliased imports starting with '${aliasToReplace}' to relative paths in "${targetDir}"...`
+  );
+  log(`   (Assuming "${normalizedAlias}" resolves relative to "${targetDir}")`);
+  log(`   (Using extension mode: ${pathExtFilter})`);
+  const results = await processAllFiles({
+    srcDir: targetDir,
+    aliasToReplace: normalizedAlias,
+    extensionsToProcess: EXTENSIONS,
+    rootDir: targetDir,
+    pathExtFilter
+  });
+  if (results.length > 0) {
+    log("\n[convertImportsAliasToRelative] Summary of changes:");
+    for (const { file, changes } of results) {
+      const displayPath = relative(targetDir, file) || basename(file);
+      log(`  in ${displayPath}:`);
+      for (const { from, to } of changes) {
+        log(`    - ${from} \u2192 ${to}`);
+      }
+    }
+  } else {
+  }
+  log("Import path conversion process complete.");
+  return results;
+}
+async function convertImportsExt({
+  targetDir,
+  extFrom,
+  extTo
+}) {
+  const fromExtStr = extFrom === "none" ? "" : `.${extFrom}`;
+  const toExtStr = extTo === "none" ? "" : `.${extTo}`;
+  const importRegex = new RegExp(
+    `(?:import\\s+(?:[\\s\\S]*?)\\s+from\\s+|import\\s*\\(\\s*)\\s*(['"])([^'"]+${fromExtStr.replace(".", "\\.")})(\\1)`,
+    "g"
+  );
+  try {
+    const entries = await fs.readdir(targetDir, { withFileTypes: true });
+    const results = [];
+    await Promise.all(
+      entries.map(async (entry) => {
+        const fullPath = join(targetDir, entry.name);
+        if (entry.isDirectory()) {
+          if (entry.name === "node_modules" || entry.name.startsWith(".")) {
+            return;
+          }
+          const subdirResults = await convertImportsExt({
+            targetDir: fullPath,
+            extFrom,
+            extTo
+          });
+          results.push(...subdirResults);
+        } else if (EXTENSIONS.includes(extname(entry.name))) {
+          const content = await fs.readFile(fullPath, "utf-8");
+          let updated = content;
+          const changes = [];
+          const matches = Array.from(content.matchAll(importRegex));
+          for (const match of matches) {
+            const quote = match[1];
+            const importPath = match[2];
+            let replacementPath;
+            if (extFrom === "none") {
+              replacementPath = importPath + toExtStr;
+            } else if (extTo === "none") {
+              replacementPath = importPath.slice(0, -fromExtStr.length);
+            } else {
+              replacementPath = importPath.slice(0, -fromExtStr.length) + toExtStr;
+            }
+            if (importPath === replacementPath) continue;
+            changes.push({ from: importPath, to: replacementPath });
+            const searchStr = `${quote}${importPath}${quote}`;
+            const replaceStr = `${quote}${replacementPath}${quote}`;
+            updated = replaceAllInString(updated, searchStr, replaceStr);
+          }
+          if (content !== updated) {
+            await fs.writeFile(fullPath, updated);
+            log(`\u2713 processed: ${fullPath}`);
+            if (changes.length > 0) {
+              results.push({ file: fullPath, changes });
+            }
+          }
+        }
+      })
+    );
+    if (results.length > 0) {
+      log("\n[convertImportsExt] Summary of changes:");
+      for (const { file, changes } of results) {
+        const displayPath = relative(targetDir, file) || basename(file);
+        log(`  in ${displayPath}:`);
+        for (const { from, to } of changes) {
+          log(`    - ${from} \u2192 ${to}`);
+        }
+      }
+    } else {
+    }
+    return results;
+  } catch (error) {
+    log(
+      `error processing directory ${targetDir}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return [];
+  }
+}
+const _pathBase = {
   sep,
   normalize,
   join,
   resolve,
-  normalizeString,
   isAbsolute,
-  toNamespacedPath,
-  extname,
-  relative,
   dirname,
-  format,
-  basename,
-  parse
-} from "./pathkit-impl/_path.js";
-import { delimiter, posix, win32 } from "./pathkit-impl/args-impl.js";
-import {
-  normalizeAliases,
-  resolveAlias,
-  reverseResolveAlias,
-  filename
-} from "./pathkit-impl/args-utils.js";
-export {
   basename,
-  delimiter,
-  dirname,
   extname,
-  filename,
   format,
-  isAbsolute,
-  join,
-  normalize,
-  normalizeAliases,
-  normalizeString,
-  normalizeWindowsPath,
   parse,
-  posix,
-  relative,
-  resolve,
-  resolveAlias,
-  reverseResolveAlias,
-  sep,
   toNamespacedPath,
-  win32
+  relative,
+  filename
+};
+const _platforms = {
+  posix: { ..._pathBase },
+  win32: {
+    ..._pathBase,
+    sep: BACK_SLASH,
+    delimiter: ";",
+    isAbsolute: (p) => {
+      if (typeof p !== "string") return false;
+      return /^[a-zA-Z]:[/\\]/.test(p) || /^[/\\]{2}/.test(p);
+    },
+    toNamespacedPath: (p) => {
+      if (typeof p !== "string" || p.length === 0) return p;
+      const resolved = resolve(p);
+      if (/^[a-zA-Z]:/.test(resolved)) {
+        return `\\\\?\\${resolved.replace(/\//g, BACK_SLASH)}`;
+      }
+      if (/^[/\\]{2}/.test(resolved)) {
+        return `\\\\?\\UNC\\${resolved.substring(2).replace(/\//g, BACK_SLASH)}`;
+      }
+      return p.replace(/\//g, BACK_SLASH);
+    }
+  }
+};
+const mix = (platformDefault = "currentSystem") => {
+  const actualDefault = platformDefault === "currentSystem" ? globalThis.process?.platform === "win32" ? "win32" : "posix" : platformDefault;
+  const defaultPathObject = actualDefault === "win32" ? _platforms.win32 : _platforms.posix;
+  return new Proxy(defaultPathObject, {
+    get(target, prop) {
+      if (prop === "delimiter") return actualDefault === "win32" ? ";" : ":";
+      if (prop === "posix") return _platforms.posix;
+      if (prop === "win32") return _platforms.win32;
+      if (prop in target) {
+        return target[prop];
+      }
+      if (prop in _pathBase) {
+        return _pathBase[prop];
+      }
+      return void 0;
+    }
+  });
 };
-const pathObj = {
+const path = mix();
+const win32 = _platforms.win32;
+const delimiter = globalThis.process?.platform === "win32" ? ";" : ":";
+export {
+  _pathBase as posix,
+  win32,
   basename,
   delimiter,
   dirname,
@@ -54,17 +730,19 @@ const pathObj = {
   isAbsolute,
   join,
   normalize,
-  normalizeAliases,
-  normalizeString,
-  normalizeWindowsPath,
   parse,
-  posix,
   relative,
   resolve,
-  resolveAlias,
-  reverseResolveAlias,
   sep,
   toNamespacedPath,
-  win32
+  normalizeAliases,
+  resolveAlias,
+  reverseResolveAlias,
+  normalizeWindowsPath,
+  cleanDirs,
+  copyDir,
+  convertStringAliasRelative,
+  convertImportsAliasToRelative,
+  convertImportsExt
 };
-export default pathObj;
+export default path;