@reliverse/pathkit 2.2.13 → 2.3.1

package/dist/mod.d.ts

@@ -1,10 +1,8 @@
 import type { posix } from "node:path";
 type PlatformPath = typeof posix;
 import { type GetFileImportsExportsOptions, getFileImportsExports, type ImportExportInfo, type ImportExportSpecifier } from "./utils/get-imports-exports.js";
-declare const normalizedAliasSymbol: unique symbol;
 export declare const IMPORT_EXPORT_REGEX: RegExp;
 interface NormalizedRecord extends Record<string, string> {
-    [normalizedAliasSymbol]?: true;
 }
 export interface ParsedPath {
     root: string;
@@ -211,7 +209,7 @@ declare const path: PlatformPath & typeof _pathBase & {
     posix: PlatformPath;
     win32: PlatformPath;
 };
-declare const win32: typeof posix;
+declare const win32: any;
 declare const delimiter: ";" | ":";
 export type { PlatformPath, PathExtFilter, ImportExtType, ImportExportInfo, ImportExportSpecifier, GetFileImportsExportsOptions, };
 export { _pathBase as posix, win32, basename, delimiter, dirname, extname, filename, format, isAbsolute, join, normalize, parse, relative, resolve, sep, toNamespacedPath, normalizeAliases, resolveAlias, reverseResolveAlias, normalizeWindowsPath, convertStringAliasRelative, convertImportsAliasToRelative, convertImportsExt, stripPathSegments, stripPathSegmentsInDirectory, attachPathSegments, attachPathSegmentsInDirectory, getFileImportsExports, };

package/dist/mod.js

@@ -32,7 +32,9 @@ const ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
 const PATH_ROOT_RE = /^[/\\]|^[a-zA-Z]:[/\\]/;
 export const IMPORT_EXPORT_REGEX = /(?:import\s+(?:type\s+)?[\s\S]*?\s+from\s+|import\s*\(\s*|export\s+(?:type\s+)?(?:\*\s+from\s+|(?:\w+(?:\s*,\s*|\s+))?\{[\s\S]*?\}(?:\s*,\s*\w+)?\s+from\s+|\w+\s+from\s+))\s*(['"])([^'"]+)\1/g;
 function normalizeWindowsPath(input = "") {
-  if (!input) return input;
+  if (!input) {
+    return input;
+  }
   return input.replace(/\\/g, SLASH).replace(DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
 }
 function compareAliases(a, b) {
@@ -61,7 +63,7 @@ function normalizeString(path2, allowAboveRoot) {
     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 || lastSegmentLength !== 2 || !res.endsWith(DOT) || res.at(-2) !== DOT) {
           if (res.length > 2) {
             const lastSlashIndex = res.lastIndexOf(SLASH);
             if (lastSlashIndex === -1) {
@@ -108,14 +110,18 @@ function normalizeString(path2, allowAboveRoot) {
 }
 const sep = SLASH;
 const normalize = (path2) => {
-  if (path2.length === 0) return DOT;
+  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;
+    if (isPathAbsolute) {
+      return SLASH;
+    }
     return trailingSeparator && originalPath.length > 0 && originalPath !== DOT ? "./" : DOT;
   }
   if (trailingSeparator && !path2.endsWith(SLASH)) {
@@ -139,7 +145,9 @@ const normalize = (path2) => {
   return path2;
 };
 const join = (...segments) => {
-  if (segments.length === 0) return DOT;
+  if (segments.length === 0) {
+    return DOT;
+  }
   let joined = EMPTY;
   for (const segment of segments) {
     if (typeof segment !== "string") {
@@ -153,7 +161,9 @@ const join = (...segments) => {
       }
     }
   }
-  if (joined.length === 0) return DOT;
+  if (joined.length === 0) {
+    return DOT;
+  }
   return normalize(joined);
 };
 const resolve = (...args) => {
@@ -164,7 +174,9 @@ const resolve = (...args) => {
     if (typeof path2 !== "string") {
       throw new TypeError("Arguments to path.resolve must be strings");
     }
-    if (path2.length === 0) continue;
+    if (path2.length === 0) {
+      continue;
+    }
     const normalizedSegment = normalizeWindowsPath(path2);
     resolvedPath = `${normalizedSegment}${SLASH}${resolvedPath}`;
     resolvedAbsolute = IS_ABSOLUTE_RE.test(normalizedSegment);
@@ -179,28 +191,42 @@ const resolve = (...args) => {
   return resolvedPath.length > 0 ? resolvedPath : DOT;
 };
 const isAbsolute = (p) => {
-  if (typeof p !== "string") return false;
+  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;
+  if (typeof p !== "string" || p.length === 0) {
+    return p;
+  }
   return normalize(p);
 };
 const extname = (p) => {
-  if (typeof p !== "string") return EMPTY;
+  if (typeof p !== "string") {
+    return EMPTY;
+  }
   const path2 = normalizeWindowsPath(p);
   let lastSlashIdx = path2.lastIndexOf(SLASH);
-  if (lastSlashIdx === -1) lastSlashIdx = 0;
+  if (lastSlashIdx === -1) {
+    lastSlashIdx = 0;
+  }
   const basePart = lastSlashIdx === 0 ? path2 : path2.substring(lastSlashIdx + 1);
-  if (basePart === DOT || basePart === DOUBLE_DOT) return EMPTY;
+  if (basePart === DOT || basePart === DOUBLE_DOT) {
+    return EMPTY;
+  }
   const lastDotIdx = basePart.lastIndexOf(DOT);
-  if (lastDotIdx <= 0) return EMPTY;
+  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;
+  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 && fromSegments[0] && toSegments[0] && DRIVE_LETTER_RE.test(fromSegments[0]) && DRIVE_LETTER_RE.test(toSegments[0]) && fromSegments[0].toUpperCase() !== toSegments[0].toUpperCase()) {
@@ -211,21 +237,23 @@ const relative = (from, to) => {
   while (commonSegments < maxCommon && fromSegments[commonSegments] === toSegments[commonSegments]) {
     commonSegments++;
   }
-  const upSegments = Array(fromSegments.length - commonSegments).fill(
-    DOUBLE_DOT
-  );
+  const upSegments = new 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;
+  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;
+  if (lastSlash === 0) {
+    return SLASH;
+  }
   const dir = normalizedPath.slice(0, lastSlash);
   if (DRIVE_LETTER_RE.test(dir) && dir.length === 2) {
     return dir + SLASH;
@@ -234,26 +262,33 @@ const dirname = (p) => {
 };
 const format = (p) => {
   if (typeof p !== "object" || p === null) {
-    throw new TypeError(
-      'Parameter "pathObject" must be an object, not null or other type.'
-    );
+    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}`;
+  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")
+  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;
+  if (end === 0) {
+    return EMPTY;
+  }
   let start = normalizedPath.lastIndexOf(SLASH, end - 1);
   start = start === -1 ? 0 : start + 1;
   let filename2 = normalizedPath.slice(start, end);
@@ -263,7 +298,9 @@ const basename = (p, ext) => {
   return filename2;
 };
 const parse = (p) => {
-  if (typeof p !== "string") throw new TypeError("Path must be a string.");
+  if (typeof p !== "string") {
+    throw new TypeError("Path must be a string.");
+  }
   const normalizedPath = normalizeWindowsPath(p);
   const B = basename(normalizedPath);
   const E = extname(B);
@@ -275,11 +312,9 @@ const parse = (p) => {
     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;
-      }
+    } else if (R === SLASH && D.startsWith("//") && 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;
@@ -293,7 +328,9 @@ const parse = (p) => {
 };
 function filename(pathString) {
   const base = basename(pathString);
-  if (!base) return void 0;
+  if (!base) {
+    return void 0;
+  }
   const separatorIndex = base.lastIndexOf(DOT);
   return separatorIndex <= 0 ? base : base.slice(0, separatorIndex);
 }
@@ -307,8 +344,9 @@ function normalizeAliases(aliases) {
   const sortedAliases = Object.fromEntries(sortedAliasesEntries);
   for (const key in sortedAliases) {
     for (const aliasPrefix in sortedAliases) {
-      if (aliasPrefix === key || key.startsWith(aliasPrefix + SLASH) || key === aliasPrefix)
+      if (aliasPrefix === key || key.startsWith(aliasPrefix + SLASH) || key === aliasPrefix) {
         continue;
+      }
       const value = sortedAliases[key];
       if (value?.startsWith(aliasPrefix)) {
         const nextChar = value[aliasPrefix.length];
@@ -480,7 +518,9 @@ async function processFile(filePath, aliasToReplace, targetDir, pathExtFilter, d
   for (const match of matches) {
     const originalQuote = match[1];
     const importPath = match[2];
-    if (!importPath) continue;
+    if (!importPath) {
+      continue;
+    }
     log(`  Processing import: ${importPath}`);
     if (!importPath.startsWith(baseAlias)) {
       if (DEBUG_MODE) {
@@ -497,7 +537,7 @@ async function processFile(filePath, aliasToReplace, targetDir, pathExtFilter, d
       log(`  - skipping: doesn't match pathExtFilter ${pathExtFilter}`);
       continue;
     }
-    log(`  - converting alias to relative path...`);
+    log("  - converting alias to relative path...");
     const relPath = await convertStringAliasRelative({
       importPath,
       importerFile: filePath,
@@ -514,16 +554,14 @@ async function processFile(filePath, aliasToReplace, targetDir, pathExtFilter, d
       updated = replaceAllInString(updated, searchString, replacementString);
       log(`  - applied change: ${importPath} \u2192 ${finalPath}`);
     } else {
-      log(`  - no change needed`);
+      log("  - no change needed");
     }
   }
   if (content !== updated) {
     await fs.writeFile(filePath, updated);
     log(`\u2713 processed: ${filePath}`);
-  } else {
-    if (DEBUG_MODE) {
-      log(`  - no changes made to file: ${filePath}`);
-    }
+  } else if (DEBUG_MODE) {
+    log(`  - no changes made to file: ${filePath}`);
   }
   return changes;
 }
@@ -542,7 +580,9 @@ async function processAllFiles({
       entries.map(async (entry) => {
         const fullPath = join(srcDir, entry.name);
         if (entry.isDirectory()) {
-          if (entry.name === "node_modules") return;
+          if (entry.name === "node_modules") {
+            return;
+          }
           const subdirResults = await processAllFiles({
             srcDir: fullPath,
             aliasToReplace,
@@ -619,21 +659,31 @@ async function convertImportsExt({
     "gm"
   );
   function shouldSkipPath(path2) {
-    if (path2.startsWith("node:") || path2.startsWith("bun:") || path2.startsWith("npm:") || path2.startsWith("jsr:") || path2.startsWith("node_modules"))
+    if (path2.startsWith("node:") || path2.startsWith("bun:") || path2.startsWith("npm:") || path2.startsWith("jsr:") || path2.startsWith("node_modules")) {
       return true;
+    }
     if (aliasPrefix && path2.startsWith(aliasPrefix)) {
       return false;
     }
     const segments = path2.split("/");
     const firstSegment = segments[0];
-    if (!firstSegment) return false;
+    if (!firstSegment) {
+      return false;
+    }
     if (path2.startsWith("@") || // scoped packages
     !firstSegment.includes(".") || // simple package names
-    firstSegment.includes("-") && !firstSegment.startsWith("."))
+    firstSegment.includes("-") && !firstSegment.startsWith(".")) {
       return true;
-    if (path2.startsWith("http://") || path2.startsWith("https://")) return true;
-    if (extTo !== "none" && path2.endsWith(`.${extTo}`)) return true;
-    if (extFrom === "none" && /\.[^/]+$/.test(path2)) return true;
+    }
+    if (path2.startsWith("http://") || path2.startsWith("https://")) {
+      return true;
+    }
+    if (extTo !== "none" && path2.endsWith(`.${extTo}`)) {
+      return true;
+    }
+    if (extFrom === "none" && /\.[^/]+$/.test(path2)) {
+      return true;
+    }
     return false;
   }
   try {
@@ -643,7 +693,9 @@ async function convertImportsExt({
       entries.map(async (entry) => {
         const fullPath = join(targetDir, entry.name);
         if (entry.isDirectory()) {
-          if (entry.name === "node_modules") return;
+          if (entry.name === "node_modules") {
+            return;
+          }
           const subdirResults = await convertImportsExt({
             targetDir: fullPath,
             extFrom,
@@ -660,7 +712,9 @@ async function convertImportsExt({
           while (match !== null) {
             const quote = match[1];
             const importPath = match[2];
-            if (!importPath) continue;
+            if (!importPath) {
+              continue;
+            }
             if (shouldSkipPath(importPath)) {
               match = importRegex.exec(updated);
               continue;
@@ -673,7 +727,9 @@ async function convertImportsExt({
             } else {
               replacementPath = importPath.slice(0, -fromExtStr.length) + toExtStr;
             }
-            if (importPath === replacementPath) continue;
+            if (importPath === replacementPath) {
+              continue;
+            }
             changes.push({ from: importPath, to: replacementPath });
             const searchStr = `${quote}${importPath}${quote}`;
             const replaceStr = `${quote}${replacementPath}${quote}`;
@@ -709,8 +765,12 @@ async function convertImportsExt({
   }
 }
 function stripPathSegments(path2, count = 1, alias = "") {
-  if (typeof path2 !== "string" || path2.length === 0) return path2;
-  if (count <= 0) return path2;
+  if (typeof path2 !== "string" || path2.length === 0) {
+    return path2;
+  }
+  if (count <= 0) {
+    return path2;
+  }
   const normalizedPath = normalizeWindowsPath(path2);
   const parsed = parse(normalizedPath);
   let pathSegments = [];
@@ -741,10 +801,7 @@ function stripPathSegments(path2, count = 1, alias = "") {
   const numToStrip = Math.min(count, pathSegments.length);
   const remainingBodySegments = pathSegments.slice(numToStrip);
   const pathRoot = parsed.root;
-  const effectiveSegments = [
-    ...leadingPreservedSegments,
-    ...remainingBodySegments
-  ];
+  const effectiveSegments = [...leadingPreservedSegments, ...remainingBodySegments];
   let result;
   if (effectiveSegments.length === 0) {
     result = normalize(pathRoot || DOT);
@@ -769,7 +826,9 @@ async function stripPathSegmentsInDirectory({
       entries.map(async (entry) => {
         const fullPath = join(targetDir, entry.name);
         if (entry.isDirectory()) {
-          if (entry.name === "node_modules") return;
+          if (entry.name === "node_modules") {
+            return;
+          }
           const subdirResults = await stripPathSegmentsInDirectory({
             targetDir: fullPath,
             segmentsToStrip,
@@ -785,18 +844,16 @@ async function stripPathSegmentsInDirectory({
           for (const match of matches) {
             const originalQuote = match[1];
             const importPath = match[2];
-            if (!importPath) continue;
+            if (!importPath) {
+              continue;
+            }
             if (!importPath.includes(SLASH)) {
               continue;
             }
             if (alias && !importPath.startsWith(alias.replace("/*", ""))) {
               continue;
             }
-            const strippedPath = stripPathSegments(
-              importPath,
-              segmentsToStrip,
-              alias
-            );
+            const strippedPath = stripPathSegments(importPath, segmentsToStrip, alias);
             if (importPath === strippedPath) {
               continue;
             }
@@ -836,7 +893,9 @@ async function stripPathSegmentsInDirectory({
   }
 }
 function attachPathSegments(path2, segments, options = {}) {
-  if (typeof path2 !== "string" || path2.length === 0) return path2;
+  if (typeof path2 !== "string" || path2.length === 0) {
+    return path2;
+  }
   const {
     position = "after",
     normalize: shouldNormalize = true,
@@ -846,14 +905,14 @@ function attachPathSegments(path2, segments, options = {}) {
   } = options;
   const segmentsArray = Array.isArray(segments) ? segments : [segments];
   const validSegments = segmentsArray.filter((s) => s.length > 0);
-  if (validSegments.length === 0) return path2;
+  if (validSegments.length === 0) {
+    return path2;
+  }
   const basePath = shouldNormalize ? normalizeWindowsPath(path2) : path2;
   let alias = "";
   let pathWithoutAlias = basePath;
   if (preserveAlias && position === "before") {
-    const aliasMatch = new RegExp(`^${preserveAlias.replace("*", ".*")}`).exec(
-      basePath
-    );
+    const aliasMatch = new RegExp(`^${preserveAlias.replace("*", ".*")}`).exec(basePath);
     if (aliasMatch) {
       alias = aliasMatch[0];
       pathWithoutAlias = basePath.slice(alias.length);
@@ -885,7 +944,9 @@ async function attachPathSegmentsInDirectory({
       entries.map(async (entry) => {
         const fullPath = join(targetDir, entry.name);
         if (entry.isDirectory()) {
-          if (entry.name === "node_modules") return;
+          if (entry.name === "node_modules") {
+            return;
+          }
           const subdirResults = await attachPathSegmentsInDirectory({
             targetDir: fullPath,
             segments,
@@ -901,14 +962,16 @@ async function attachPathSegmentsInDirectory({
           for (const match of matches) {
             const originalQuote = match[1];
             const importPath = match[2];
-            if (!importPath) continue;
-            if (!importPath.includes(SLASH)) continue;
-            const modifiedPath = attachPathSegments(
-              importPath,
-              segments,
-              options
-            );
-            if (importPath === modifiedPath) continue;
+            if (!importPath) {
+              continue;
+            }
+            if (!importPath.includes(SLASH)) {
+              continue;
+            }
+            const modifiedPath = attachPathSegments(importPath, segments, options);
+            if (importPath === modifiedPath) {
+              continue;
+            }
             changes.push({ from: importPath, to: modifiedPath });
             const searchStr = `${originalQuote}${importPath}${originalQuote}`;
             const replaceStr = `${originalQuote}${modifiedPath}${originalQuote}`;
@@ -925,9 +988,7 @@ async function attachPathSegmentsInDirectory({
       })
     );
     if (results.length > 0 && displayLogs) {
-      regularLogger(
-        () => "\n[attachPathSegmentsInDirectory] Summary of changes:"
-      );
+      regularLogger(() => "\n[attachPathSegmentsInDirectory] Summary of changes:");
       for (const { file, changes } of results) {
         const displayPath = relative(targetDir, file) || basename(file);
         regularLogger(() => `  in ${displayPath}:`);
@@ -966,11 +1027,15 @@ const _platforms = {
     sep: BACK_SLASH,
     delimiter: ";",
     isAbsolute: (p) => {
-      if (typeof p !== "string") return false;
+      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;
+      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)}`;
@@ -987,9 +1052,15 @@ const mix = (platformDefault = "currentSystem") => {
   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 === "delimiter") {
+        return actualDefault === "win32" ? ";" : ":";
+      }
+      if (prop === "posix") {
+        return _platforms.posix;
+      }
+      if (prop === "win32") {
+        return _platforms.win32;
+      }
       if (prop in target) {
         return target[prop];
       }

package/dist/utils/get-imports-exports.js

@@ -6,7 +6,9 @@ export function getFileImportsExports(content, options = {}) {
   } = options;
   const results = [];
   function getImportExtension(path) {
-    if (!path) return "";
+    if (!path) {
+      return "";
+    }
     const lastDotIndex = path.lastIndexOf(".");
     if (lastDotIndex <= 0 || lastDotIndex === path.length - 1) {
       return "";
@@ -25,7 +27,9 @@ export function getFileImportsExports(content, options = {}) {
       return getImportExtension(path);
     }
     const pathExt = getImportExtension(path);
-    if (!pathExt) return "";
+    if (!pathExt) {
+      return "";
+    }
     if (pathExt === ".js" || pathExt === ".jsx") {
       return pathExt === ".jsx" ? ".tsx" : ".ts";
     }
@@ -47,11 +51,18 @@ export function getFileImportsExports(content, options = {}) {
     namedExport: /export\s+(?:const|let|var|function|class|enum|interface|type)\s+(\w+)/g
   };
   function getPathType(path) {
-    if (path.startsWith(".")) return "relative";
-    if (path.startsWith("/")) return "absolute";
-    if (path.startsWith("@") || path.startsWith("~")) return "alias";
-    if (path.startsWith("http://") || path.startsWith("https://"))
+    if (path.startsWith(".")) {
+      return "relative";
+    }
+    if (path.startsWith("/")) {
+      return "absolute";
+    }
+    if (path.startsWith("@") || path.startsWith("~")) {
+      return "alias";
+    }
+    if (path.startsWith("http://") || path.startsWith("https://")) {
       return "module";
+    }
     return "bare";
   }
   function extractSpecifiers(statement) {
@@ -66,9 +77,7 @@ export function getFileImportsExports(content, options = {}) {
       });
       return specifiers;
     }
-    const defaultMatch = /import\s+(?:type\s+)?(\w+)(?:\s*,|\s+from)/.exec(
-      statement
-    );
+    const defaultMatch = /import\s+(?:type\s+)?(\w+)(?:\s*,|\s+from)/.exec(statement);
     if (defaultMatch?.[1] && !statement.includes("{")) {
       specifiers.push({
         type: "default",
@@ -82,11 +91,15 @@ export function getFileImportsExports(content, options = {}) {
       for (const item of items) {
         const typeMatch = /^type\s+(.+)/.exec(item);
         const actualItem = typeMatch ? typeMatch[1] : item;
-        if (!actualItem) continue;
+        if (!actualItem) {
+          continue;
+        }
         const isItemType = !!typeMatch || isTypeOnly;
         if (actualItem.includes(" as ")) {
           const [name, alias] = actualItem.split(" as ").map((p) => p.trim());
-          if (!name) continue;
+          if (!name) {
+            continue;
+          }
           specifiers.push({
             type: "named",
             name,
@@ -108,9 +121,13 @@ export function getFileImportsExports(content, options = {}) {
     const importMatches = [...content.matchAll(patterns.staticImport)];
     for (const match of importMatches) {
       const source = match[1] || match[3];
-      if (!source) continue;
+      if (!source) {
+        continue;
+      }
       const pathType = getPathType(source);
-      if (!pathType || !pathTypes.includes(pathType)) continue;
+      if (!(pathType && pathTypes.includes(pathType))) {
+        continue;
+      }
       const info = {
         statement: match[0],
         type: "static",
@@ -130,9 +147,13 @@ export function getFileImportsExports(content, options = {}) {
     const dynamicMatches = [...content.matchAll(patterns.dynamicImport)];
     for (const match of dynamicMatches) {
       const source = match[1];
-      if (!source) continue;
+      if (!source) {
+        continue;
+      }
       const pathType = getPathType(source);
-      if (!pathType || !pathTypes.includes(pathType)) continue;
+      if (!(pathType && pathTypes.includes(pathType))) {
+        continue;
+      }
       const info = {
         statement: match[0],
         type: "dynamic",
@@ -154,9 +175,13 @@ export function getFileImportsExports(content, options = {}) {
     const exportMatches = [...content.matchAll(patterns.staticExport)];
     for (const match of exportMatches) {
       const source = match[1];
-      if (!source) continue;
+      if (!source) {
+        continue;
+      }
       const pathType = getPathType(source);
-      if (!pathType || !pathTypes.includes(pathType)) continue;
+      if (!(pathType && pathTypes.includes(pathType))) {
+        continue;
+      }
       const info = {
         statement: match[0],
         type: "static",
@@ -194,7 +219,9 @@ export function getFileImportsExports(content, options = {}) {
     const namedMatches = [...content.matchAll(patterns.namedExport)];
     for (const match of namedMatches) {
       const name = match[1];
-      if (!name) continue;
+      if (!name) {
+        continue;
+      }
       const info = {
         statement: match[0],
         type: "static",
@@ -213,18 +240,15 @@ export function getFileImportsExports(content, options = {}) {
     }
   }
   if (limitPerType) {
-    const groupedByType = results.reduce(
-      (acc, curr) => {
-        const key = `${curr.kind}-${curr.pathType || "none"}`;
-        if (!acc[key]) acc[key] = [];
-        acc[key].push(curr);
-        return acc;
-      },
-      {}
-    );
-    return Object.values(groupedByType).flatMap(
-      (group) => group.slice(0, limitPerType)
-    );
+    const groupedByType = results.reduce((acc, curr) => {
+      const key = `${curr.kind}-${curr.pathType || "none"}`;
+      if (!acc[key]) {
+        acc[key] = [];
+      }
+      acc[key].push(curr);
+      return acc;
+    }, {});
+    return Object.values(groupedByType).flatMap((group) => group.slice(0, limitPerType));
   }
   return results;
 }

package/package.json

@@ -1,9 +1,14 @@
 {
   "name": "@reliverse/pathkit",
+  "version": "2.3.1",
+  "private": false,
   "description": "Path manipulation and resolution utilities for Reliverse ecosystem",
+  "license": "MIT",
   "author": "reliverse",
-  "version": "2.2.13",
-  "private": false,
+  "files": [
+    "dist",
+    "package.json"
+  ],
   "type": "module",
   "exports": {
     ".": {
@@ -13,10 +18,5 @@
   },
   "publishConfig": {
     "access": "public"
-  },
-  "files": [
-    "dist",
-    "package.json"
-  ],
-  "license": "MIT"
+  }
 }