@reliverse/pathkit 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) Nazar Kornienko (blefnk), Reliverse
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,253 @@
+# pathkit • cross‑platform path manipulation
+
+> @reliverse/pathkit is a slash‑consistent, cross‑platform path manipulation—drop‑in for `node:path`, always POSIX "/".
+
+[sponsor](https://github.com/sponsors/blefnk) • [discord](https://discord.gg/Pb8uKbwpsJ) • [npm](https://npmjs.com/package/@reliverse/pathkit) • [repo](https://github.com/reliverse/pathkit)
+
+## Key Features
+
+- 🔹 **`node:path` on Steroids** – `@reliverse/pathkit`: drop in and replace `node:path` instantly.
+- ➕ **`unjs/pathe` on Steroids** – `@reliverse/pathkit-plus`: alias resolution, import parsing, and more.
+- 🌀 **Always `/`** – POSIX separators 100% of the time (buh‑bye `\\`).
+- ⚙️ **Node.js API compatible** – familiar methods, no learning curve.
+- 🚀 **Modern & Fast** – TypeScript, pure ESM, Bun & Node‑ready.
+- 🧠 **Predictable & Testable** – deterministic output across Windows / macOS / Linux.
+
+## Installation
+
+```bash
+# bun • pnpm • yarn • npm
+bun add @reliverse/pathkit
+bun add -D @reliverse/pathkit-plus
+```
+
+_In most cases_ you may need to install `@reliverse/pathkit` as **regular dependency**.
+_In most cases_ you may need to install `@reliverse/pathkit-plus` as **dev dependency**.
+
+**Migrate**:
+
+```bash
+bun rm pathe
+# soon:
+# bun add -D @reliverse/dler
+# bun dler pathkit path-to-pathkit
+# bun dler pathkit pathe-to-pathkit
+```
+
+### `pathkit` vs `pathkit-plus`
+
+| Package | What you get | When to use |
+|---------|--------------|-------------|
+| **`@reliverse/pathkit`** | Core path API (POSIX everywhere) | You only need a drop‑in for `node:path` |
+| **`@reliverse/pathkit-plus`** | Everything in `pathkit` **+** advanced utilities | You need alias resolution, import transforms, etc. |
+
+## Why Pathkit? — The Problem with Native Paths
+
+Native `node:path` flips behavior between operating systems, spurring subtle bugs and OS checks.
+
+```js
+// With node:path – the same call may yield different separators on each OS
+import path from "node:path";
+
+const project = "users/blefnk/project";
+const full = path.join("C:\\", project);
+console.log(full); // "C:\\users\\blefnk\\project" (Windows) vs ??? (others)
+```
+
+### ✅ The `pathkit` Fix
+
+```js
+import { join } from "@reliverse/pathkit";
+
+const full = join("C:", "users", "blefnk", "project");
+console.log(full); // "C:/users/blefnk/project" on **every** OS 🎉
+```
+
+| Pain Point                     | `@reliverse/pathkit` Solution |
+| :----------------------------- | :--------------------------- |
+| Inconsistent separators        | ✅ Always `/` |
+| OS‑specific work‑arounds       | ✅ One code path |
+| Needs TypeScript + ESM         | ✅ Built‑in |
+| Works in Bun / Deno / Node     | ✅ Out of the box |
+
+## Quick Start
+
+```ts
+import { resolve, join, normalize } from "@reliverse/pathkit";
+
+// Mixed slashes & dot‑segments? No problem.
+const messy = "src\\..\\./dist///file.js";
+console.log(resolve(messy));             // → "dist/file.js"
+
+// Join is predictable everywhere:
+console.log(join("users", "blefnk"));    // → "users/blefnk"
+```
+
+**Side‑by‑Side Demo**:
+
+| Code | Windows Output | macOS / Linux Output |
+|------|----------------|----------------------|
+| `join("a", "b")` | `a/b` | `a/b` |
+| `resolve("..", "x")` | `x` | `x` |
+
+Say goodbye to `process.platform` conditionals 👋.
+
+## pathkit-plus Features
+
+`@reliverse/pathkit-plus` extends the core functionality with powerful utilities for working with imports, aliases, and more.
+
+### Import/Export Analysis
+
+The `getFileImportsExports` function provides detailed analysis of ES module imports and exports:
+
+```ts
+import { getFileImportsExports } from "@reliverse/pathkit-plus";
+
+const code = `
+import { ref } from "vue";
+import utils from "@/utils";
+import type { Config } from "./types";
+export { default as MyComponent } from "./MyComponent";
+`;
+
+const analysis = getFileImportsExports(code, {
+  kind: "all",           // "import" | "export" | "all"
+  pathTypes: ["alias"],  // Filter by path types
+  limitPerType: 2        // Limit results per type
+});
+```
+
+The analysis provides rich information about each import/export:
+
+```ts
+interface ImportExportInfo {
+  statement: string;           // Full original statement
+  type: "static" | "dynamic"; // Import type
+  kind: "import" | "export";  // Statement kind
+  source?: string;            // Import/export source path
+  pathType?: "alias" | "relative" | "absolute" | "bare" | "module";
+  pathTypeSymbol?: string;    // Path prefix (e.g., "@/", "~/")
+  isTypeOnly?: boolean;       // Type-only import/export
+  specifiers?: {              // Imported/exported items
+    type: "named" | "default" | "namespace" | "all";
+    name: string;
+    alias?: string;
+    isType?: boolean;
+  }[];
+  start: number;              // Position in source
+  end: number;
+}
+```
+
+Features:
+
+- ✨ Handles all import/export syntax variants
+- 🔍 Type imports/exports support
+- 💬 Preserves comments
+- 🎯 Path type detection
+- 🔄 Multi-line statement support
+
+### Path Transformation
+
+Convert between different path formats:
+
+```ts
+import { convertImportPaths } from "@reliverse/pathkit-plus";
+
+await convertImportPaths({
+  baseDir: "./src",
+  fromType: "relative",    // "./components/Button"
+  toType: "alias",         // "@/components/Button"
+  aliasPrefix: "@/",
+  generateSourceMap: true
+});
+```
+
+### Extension Conversion
+
+```ts
+import { convertImportExtensionsJsToTs } from "@reliverse/pathkit-plus";
+
+await convertImportExtensionsJsToTs({
+  dirPath: "./src",
+  generateSourceMap: true
+});
+```
+
+### Alias Resolution
+
+```ts
+import { 
+  normalizeAliases,
+  resolveAlias,
+  reverseResolveAlias
+} from "@reliverse/pathkit-plus";
+
+const aliases = { "@/": "/src/", "~/": "/home/user/" };
+
+// Normalize alias config
+console.log(normalizeAliases(aliases));
+
+// Resolve alias to absolute path
+console.log(resolveAlias("@/components", aliases));  // "/src/components"
+
+// Convert absolute path back to alias
+console.log(reverseResolveAlias("/src/utils", aliases));  // "@/utils"
+```
+
+### Utility Functions
+
+```ts
+import {
+  filename,               // Strip extension
+  extractPackageName,     // Get package name from import
+  normalizeQuotes,        // Standardize quote style
+  matchesGlob            // Test glob patterns
+} from "@reliverse/pathkit-plus";
+
+console.log(filename("/path/component.vue"));     // "component"
+console.log(extractPackageName("@scope/pkg"));    // "@scope/pkg"
+console.log(normalizeQuotes("import 'pkg'"));     // 'import "pkg"'
+console.log(matchesGlob("file.ts", "**/*.ts"));  // true
+```
+
+## Use Cases / Ideal For
+
+- 🛠️ **CLI tools**
+- 🌍 **Cross‑platform dev environments**
+- 🔄 **Bundlers, linters, compilers**
+- 🏗️ **Framework & library authors**
+- 📜 **Scripts / test runners**
+- …anywhere file‑paths roam!
+
+## Examples & Contributing
+
+```bash
+git clone https://github.com/reliverse/pathkit.git
+cd pathkit
+bun install
+bun dev
+```
+
+Bug reports & PRs are warmly welcome—come on in!
+
+## Related
+
+- [`@reliverse/rempts`](https://npmjs.com/package/@reliverse/rempts) – Terminal Prompts Engine
+
+## Community
+
+- ⭐ **Star** the repo if this helped you.
+- 💖 **Sponsor** [@blefnk](https://github.com/sponsors/blefnk) to keep the lights on.
+- 💬 **Chat** with us on [Discord](https://discord.gg/Pb8uKbwpsJ).
+
+## License
+
+[MIT](LICENSE) © [Nazar Kornienko (blefnk)](https://github.com/blefnk), [Reliverse](https://github.com/reliverse)
+
+## Badges
+
+[![npm](https://img.shields.io/npm/v/@reliverse/pathkit?label=npm%20v)](https://npmjs.com/package/@reliverse/pathkit)
+[![downloads](https://img.shields.io/npm/dm/@reliverse/pathkit.svg?color=brightgreen)](https://npmjs.com/package/@reliverse/pathkit)
+[![typescript](https://img.shields.io/badge/typed-%E2%9C%85-blue)](https://github.com/reliverse/pathkit)
+[![license](https://img.shields.io/npm/l/@reliverse/pathkit.svg)](LICENSE)

package/bin/mod.d.ts

@@ -0,0 +1,4 @@
+export { delimiter, posix, win32 } from "./pathkit-impl/args-impl.js";
+export { normalizeAliases, resolveAlias, reverseResolveAlias, filename, } from "./pathkit-impl/args-utils.js";
+export { normalizeWindowsPath } from "./pathkit-impl/_internal.js";
+export { sep, normalize, join, resolve, normalizeString, isAbsolute, toNamespacedPath, extname, relative, dirname, format, basename, parse, } from "./pathkit-impl/_path.js";

package/bin/mod.js

@@ -0,0 +1,23 @@
+export { delimiter, posix, win32 } from "./pathkit-impl/args-impl.js";
+export {
+  normalizeAliases,
+  resolveAlias,
+  reverseResolveAlias,
+  filename
+} from "./pathkit-impl/args-utils.js";
+export { normalizeWindowsPath } from "./pathkit-impl/_internal.js";
+export {
+  sep,
+  normalize,
+  join,
+  resolve,
+  normalizeString,
+  isAbsolute,
+  toNamespacedPath,
+  extname,
+  relative,
+  dirname,
+  format,
+  basename,
+  parse
+} from "./pathkit-impl/_path.js";

package/bin/pathkit-impl/_internal.d.ts

@@ -0,0 +1 @@
+export declare function normalizeWindowsPath(input?: string): string;

package/bin/pathkit-impl/_internal.js

@@ -0,0 +1,7 @@
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+export function normalizeWindowsPath(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}

package/bin/pathkit-impl/_path.d.ts

@@ -0,0 +1,26 @@
+import type path from "node:path";
+/**
+ * Constant for path separator.
+ *
+ * Always equals to `"/"`.
+ */
+export declare const sep = "/";
+export declare const normalize: typeof path.normalize;
+export declare const join: typeof path.join;
+export declare const resolve: typeof path.resolve;
+/**
+ * Resolves a string path, resolving '.' and '.' segments and allowing paths above the root.
+ *
+ * @param path - The path to normalise.
+ * @param allowAboveRoot - Whether to allow the resulting path to be above the root directory.
+ * @returns the normalised path string.
+ */
+export declare function normalizeString(path: string, allowAboveRoot: boolean): string;
+export declare const isAbsolute: typeof path.isAbsolute;
+export declare const toNamespacedPath: typeof path.toNamespacedPath;
+export declare const extname: typeof path.extname;
+export declare const relative: typeof path.relative;
+export declare const dirname: typeof path.dirname;
+export declare const format: typeof path.format;
+export declare const basename: typeof path.basename;
+export declare const parse: typeof path.parse;

package/bin/pathkit-impl/_path.js

@@ -0,0 +1,206 @@
+import { normalizeWindowsPath } from "./_internal.js";
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
+const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
+const _PATH_ROOT_RE = /^[/\\]|^[a-zA-Z]:[/\\]/;
+export const sep = "/";
+export const normalize = (path) => {
+  if (path.length === 0) {
+    return ".";
+  }
+  path = normalizeWindowsPath(path);
+  const isUNCPath = _UNC_REGEX.exec(path);
+  const isPathAbsolute = isAbsolute(path);
+  const trailingSeparator = path.endsWith("/");
+  path = normalizeString(path, !isPathAbsolute);
+  if (path.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path += "/";
+  }
+  if (_DRIVE_LETTER_RE.test(path)) {
+    path += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path}`;
+    }
+    return `//${path}`;
+  }
+  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+export const join = (...segments) => {
+  let path = "";
+  for (const seg of segments) {
+    if (!seg) {
+      continue;
+    }
+    if (path.length > 0) {
+      const pathTrailing = path.endsWith("/");
+      const segLeading = seg.startsWith("/");
+      const both = pathTrailing && segLeading;
+      if (both) {
+        path += seg.slice(1);
+      } else {
+        path += pathTrailing || segLeading ? seg : `/${seg}`;
+      }
+    } else {
+      path += seg;
+    }
+  }
+  return normalize(path);
+};
+function cwd() {
+  if (typeof process !== "undefined" && typeof process.cwd === "function") {
+    return process.cwd().replace(/\\/g, "/");
+  }
+  return "/";
+}
+export const resolve = (...arguments_) => {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+    const path = index >= 0 ? arguments_[index] : cwd();
+    if (!path || path.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+export function normalizeString(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path.length; ++index) {
+    if (index < path.length) {
+      char = path[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) {
+      } else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || !res.endsWith(".") || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+          if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+export const isAbsolute = (p) => _IS_ABSOLUTE_RE.test(p);
+export const toNamespacedPath = (p) => normalizeWindowsPath(p);
+export const extname = (p) => {
+  if (p === "..") return "";
+  const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
+  return match?.[1] || "";
+};
+export const relative = (from, to) => {
+  const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
+  const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
+  if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) {
+    return _to.join("/");
+  }
+  const _fromCopy = [..._from];
+  for (const segment of _fromCopy) {
+    if (_to[0] !== segment) {
+      break;
+    }
+    _from.shift();
+    _to.shift();
+  }
+  return [..._from.map(() => ".."), ..._to].join("/");
+};
+export const dirname = (p) => {
+  const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+  if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) {
+    segments[0] += "/";
+  }
+  return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+export const format = (p) => {
+  const ext = p.ext ? p.ext.startsWith(".") ? p.ext : `.${p.ext}` : "";
+  const segments = [p.root, p.dir, p.base ?? (p.name ?? "") + ext].filter(
+    Boolean
+  );
+  return normalizeWindowsPath(
+    segments.length > 0 ? resolve(...segments) : segments.join("/")
+  );
+};
+export const basename = (p, extension) => {
+  const segments = normalizeWindowsPath(p).split("/");
+  let lastSegment = "";
+  for (let i = segments.length - 1; i >= 0; i--) {
+    const val = segments[i];
+    if (val) {
+      lastSegment = val;
+      break;
+    }
+  }
+  return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
+};
+export const parse = (p) => {
+  const root = _PATH_ROOT_RE.exec(p)?.[0]?.replace(/\\/g, "/") || "";
+  const base = basename(p);
+  const extension = extname(base);
+  return {
+    root,
+    dir: dirname(p),
+    base,
+    ext: extension,
+    name: base.slice(0, base.length - extension.length)
+  };
+};

package/bin/pathkit-impl/args-impl.d.ts

@@ -0,0 +1,9 @@
+export * from "./_path.js";
+/**
+ * The platform-specific file delimiter.
+ *
+ * Equals to `";"` in windows and `":"` in all other platforms.
+ */
+export declare const delimiter: ";" | ":";
+export declare const posix: import("path").PlatformPath;
+export declare const win32: import("path").PlatformPath;

package/bin/pathkit-impl/args-impl.js

@@ -0,0 +1,16 @@
+import * as _path from "./_path.js";
+export * from "./_path.js";
+export const delimiter = /* @__PURE__ */ (() => globalThis.process?.platform === "win32" ? ";" : ":")();
+const _platforms = { posix: void 0, win32: void 0 };
+const mix = (del = delimiter) => {
+  return new Proxy(_path, {
+    get(_, prop) {
+      if (prop === "delimiter") return del;
+      if (prop === "posix") return posix;
+      if (prop === "win32") return win32;
+      return _platforms[prop] || _path[prop];
+    }
+  });
+};
+export const posix = /* @__PURE__ */ mix(":");
+export const win32 = /* @__PURE__ */ mix(";");

package/bin/pathkit-impl/args-utils.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Normalises alias mappings, ensuring that more specific aliases are resolved before less specific ones.
+ * This function also ensures that aliases do not resolve to themselves cyclically.
+ *
+ * @param _aliases - A set of alias mappings where each key is an alias and its value is the actual path it points to.
+ * @returns a set of normalised alias mappings.
+ */
+export declare function normalizeAliases(_aliases: Record<string, string>): Record<string, string>;
+/**
+ * Resolves a path string to its alias if applicable, otherwise returns the original path.
+ * This function normalises the path, resolves the alias and then joins it to the alias target if necessary.
+ *
+ * @param path - The path string to resolve.
+ * @param aliases - A set of alias mappings to use for resolution.
+ * @returns the resolved path as a string.
+ */
+export declare function resolveAlias(path: string, aliases: Record<string, string>): any;
+/**
+ * Resolves a path string to its possible alias.
+ *
+ * Returns an array of possible alias resolutions (could be empty), sorted by specificity (longest first).
+ */
+export declare function reverseResolveAlias(path: string, aliases: Record<string, string>): string[];
+/**
+ * Extracts the filename from a given path, excluding any directory paths and the file extension.
+ *
+ * @param path - The full path of the file from which to extract the filename.
+ * @returns the filename without the extension, or `undefined` if the filename cannot be extracted.
+ */
+export declare function filename(path: string): string | undefined;

package/bin/pathkit-impl/args-utils.js

@@ -0,0 +1,75 @@
+import { normalizeWindowsPath } from "./_internal.js";
+import { join } from "./_path.js";
+const pathSeparators = /* @__PURE__ */ new Set(["/", "\\", void 0]);
+const normalizedAliasSymbol = Symbol.for("pathkit:normalizedAlias");
+const SLASH_RE = /[/\\]/;
+export function normalizeAliases(_aliases) {
+  if (_aliases[normalizedAliasSymbol]) {
+    return _aliases;
+  }
+  const aliases = Object.fromEntries(
+    Object.entries(_aliases).sort(([a], [b]) => _compareAliases(a, b))
+  );
+  for (const key in aliases) {
+    for (const alias in aliases) {
+      if (alias === key || key.startsWith(alias)) {
+        continue;
+      }
+      if (aliases[key]?.startsWith(alias) && pathSeparators.has(aliases[key][alias.length])) {
+        aliases[key] = aliases[alias] + aliases[key].slice(alias.length);
+      }
+    }
+  }
+  Object.defineProperty(aliases, normalizedAliasSymbol, {
+    value: true,
+    enumerable: false
+  });
+  return aliases;
+}
+export function resolveAlias(path, aliases) {
+  const _path = normalizeWindowsPath(path);
+  aliases = normalizeAliases(aliases);
+  for (const [alias, to] of Object.entries(aliases)) {
+    if (!_path.startsWith(alias)) {
+      continue;
+    }
+    const _alias = hasTrailingSlash(alias) ? alias.slice(0, -1) : alias;
+    if (hasTrailingSlash(_path[_alias.length])) {
+      return join(to, _path.slice(alias.length));
+    }
+  }
+  return _path;
+}
+export function reverseResolveAlias(path, aliases) {
+  const _path = normalizeWindowsPath(path);
+  aliases = normalizeAliases(aliases);
+  const matches = [];
+  for (const [to, alias] of Object.entries(aliases)) {
+    if (!_path.startsWith(alias)) {
+      continue;
+    }
+    const _alias = hasTrailingSlash(alias) ? alias.slice(0, -1) : alias;
+    if (hasTrailingSlash(_path[_alias.length])) {
+      matches.push(join(to, _path.slice(alias.length)));
+    }
+  }
+  return matches.sort((a, b) => b.length - a.length);
+}
+export function filename(path) {
+  const base = path.split(SLASH_RE).pop();
+  if (!base) {
+    return void 0;
+  }
+  const separatorIndex = base.lastIndexOf(".");
+  if (separatorIndex <= 0) {
+    return base;
+  }
+  return base.slice(0, separatorIndex);
+}
+function _compareAliases(a, b) {
+  return b.split("/").length - a.split("/").length;
+}
+function hasTrailingSlash(path = "/") {
+  const lastChar = path[path.length - 1];
+  return lastChar === "/" || lastChar === "\\";
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "description": "@reliverse/pathkit delivers slash-consistent, cross-platform path manipulation that just works. Ensures predictable POSIX (/) separators everywhere, simplifying your code and eliminating OS-specific pathing issues.",
+  "license": "MIT",
+  "name": "@reliverse/pathkit",
+  "type": "module",
+  "version": "1.0.0",
+  "dependencies": {},
+  "devDependencies": {},
+  "exports": {
+    ".": "./bin/mod.js"
+  },
+  "files": [
+    "bin",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "main": "./bin/mod.js",
+  "module": "./bin/mod.js",
+  "publishConfig": {
+    "access": "public"
+  }
+}