@ucdjs/path-utils 0.1.1-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-PRESENT Lucas Nørgård
+
+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,24 @@
+# @ucdjs/path-utils
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![codecov][codecov-src]][codecov-href]
+
+A collection of path utility functions for the UCD project.
+
+## Installation
+
+```bash
+npm install @ucdjs/path-utils
+```
+
+## 📄 License
+
+Published under [MIT License](./LICENSE).
+
+[npm-version-src]: https://img.shields.io/npm/v/@ucdjs/path-utils?style=flat&colorA=18181B&colorB=4169E1
+[npm-version-href]: https://npmjs.com/package/@ucdjs/path-utils
+[npm-downloads-src]: https://img.shields.io/npm/dm/@ucdjs/path-utils?style=flat&colorA=18181B&colorB=4169E1
+[npm-downloads-href]: https://npmjs.com/package/@ucdjs/path-utils
+[codecov-src]: https://img.shields.io/codecov/c/gh/ucdjs/ucd?style=flat&colorA=18181B&colorB=4169E1
+[codecov-href]: https://codecov.io/gh/ucdjs/ucd

package/dist/index.d.mts

@@ -0,0 +1,97 @@
+//#region src/errors.d.ts
+declare abstract class PathUtilsBaseError extends Error {
+  constructor(message: string, options?: ErrorOptions);
+}
+declare class MaximumDecodingIterationsExceededError extends PathUtilsBaseError {
+  constructor();
+}
+declare class PathTraversalError extends PathUtilsBaseError {
+  readonly accessedPath: string;
+  readonly basePath: string;
+  constructor(basePath: string, accessedPath: string);
+}
+declare class WindowsDriveMismatchError extends PathUtilsBaseError {
+  readonly accessedDrive: string;
+  readonly baseDrive: string;
+  constructor(baseDrive: string, accessedDrive: string);
+}
+declare class FailedToDecodePathError extends PathUtilsBaseError {
+  constructor();
+}
+declare class IllegalCharacterInPathError extends PathUtilsBaseError {
+  constructor(character: string);
+}
+declare class WindowsPathBehaviorNotImplementedError extends PathUtilsBaseError {
+  constructor();
+}
+declare class UNCPathNotSupportedError extends PathUtilsBaseError {
+  readonly path: string;
+  constructor(path: string);
+}
+//#endregion
+//#region src/platform.d.ts
+/**
+ * Extracts the Windows drive letter from a given string, if present.
+ * @param {string} str - The input string to check for a Windows drive letter.
+ * @returns {string | null} The uppercase drive letter (e.g., "C") if found, otherwise null.
+ */
+declare function getWindowsDriveLetter(str: string): string | null;
+/**
+ * Checks if the given path is a Windows drive path (e.g., "C:", "D:\").
+ * @param {string} path - The path to check.
+ * @returns {boolean} True if the path is a Windows drive path, false otherwise.
+ */
+declare function isWindowsDrivePath(path: string): boolean;
+/**
+ * Removes the Windows drive letter from a path string.
+ * @param {string} path - The path to strip the drive letter from.
+ * @returns {string} The path without the Windows drive letter.
+ * @throws {TypeError} If the provided path is not a string.
+ */
+declare function stripDriveLetter(path: string): string;
+/**
+ * Checks if the given path is a UNC (Universal Naming Convention) path.
+ * @param {string} path - The path to check.
+ * @returns {boolean} True if the path is a UNC path, false otherwise.
+ */
+declare function isUNCPath(path: string): boolean;
+/**
+ * Asserts that the given path is not a UNC path. Throws UNCPathNotSupportedError if it is.
+ * @param {string} path - The path to check.
+ * @throws {UNCPathNotSupportedError} If the path is a UNC path.
+ */
+declare function assertNotUNCPath(path: string): void;
+/**
+ * Converts a path to Unix format by normalizing separators, stripping Windows drive letters, and ensuring a leading slash.
+ * @param {string} inputPath - The input path to convert.
+ * @returns {string} The path in Unix format.
+ */
+declare function toUnixFormat(inputPath: string): string;
+//#endregion
+//#region src/security.d.ts
+/**
+ * Checks if the resolved path is within the specified base path, considering case sensitivity.
+ * This function normalizes paths, applies leading slashes, and ensures the resolved path starts with the base path
+ * followed by a separator to prevent partial matches.
+ * @param {string} basePath - The base path to check against, must be a non-empty string.
+ * @param {string} resolvedPath - The path to check, must be a non-empty string.
+ * @returns {boolean} True if the resolved path is within the base path, false otherwise.
+ */
+declare function isWithinBase(basePath: string, resolvedPath: string): boolean;
+declare function decodePathSafely(encodedPath: string): string;
+declare function resolveSafePath(basePath: string, inputPath: string): string;
+//#endregion
+//#region src/utils.d.ts
+declare const isCaseSensitive: boolean;
+declare const osPlatform: NodeJS.Platform | null;
+//#endregion
+//#region src/index.d.ts
+declare const patheBasename: (path: string, suffix?: string) => string;
+declare const patheDirname: (path: string) => string;
+declare const patheExtname: (path: string) => string;
+declare const patheJoin: (...paths: string[]) => string;
+declare const patheNormalize: (path: string) => string;
+declare const patheRelative: (from: string, to: string) => string;
+declare const patheResolve: (...paths: string[]) => string;
+//#endregion
+export { FailedToDecodePathError, IllegalCharacterInPathError, MaximumDecodingIterationsExceededError, PathTraversalError, PathUtilsBaseError, UNCPathNotSupportedError, WindowsDriveMismatchError, WindowsPathBehaviorNotImplementedError, assertNotUNCPath, decodePathSafely, getWindowsDriveLetter, isCaseSensitive, isUNCPath, isWindowsDrivePath, isWithinBase, osPlatform, patheBasename, patheDirname, patheExtname, patheJoin, patheNormalize, patheRelative, patheResolve, resolveSafePath, stripDriveLetter, toUnixFormat };

package/dist/index.mjs

@@ -0,0 +1,431 @@
+import pathe, { basename, dirname, extname, join, normalize, relative, resolve } from "pathe";
+import { prependLeadingSlash, trimTrailingSlash } from "@luxass/utils";
+import { createDebugger } from "@ucdjs-internal/shared";
+
+//#region src/errors.ts
+var PathUtilsBaseError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "PathUtilsBaseError";
+	}
+};
+var MaximumDecodingIterationsExceededError = class extends PathUtilsBaseError {
+	constructor() {
+		super("Maximum decoding iterations exceeded - possible malicious input");
+		this.name = "MaximumDecodingIterationsExceededError";
+	}
+};
+var PathTraversalError = class extends PathUtilsBaseError {
+	accessedPath;
+	basePath;
+	constructor(basePath, accessedPath) {
+		super(`Path traversal detected: attempted to access '${accessedPath}' which is outside the allowed base path '${basePath}'`);
+		this.name = "PathTraversalError";
+		this.basePath = basePath;
+		this.accessedPath = accessedPath;
+	}
+};
+var WindowsDriveMismatchError = class extends PathUtilsBaseError {
+	accessedDrive;
+	baseDrive;
+	constructor(baseDrive, accessedDrive) {
+		super(`Drive letter mismatch detected: attempted to access '${accessedDrive}' which is on a different drive than the allowed base drive '${baseDrive}'`);
+		this.name = "WindowsDriveMismatchError";
+		this.baseDrive = baseDrive;
+		this.accessedDrive = accessedDrive;
+	}
+};
+var FailedToDecodePathError = class extends PathUtilsBaseError {
+	constructor() {
+		super("Failed to decode path");
+		this.name = "FailedToDecodePathError";
+	}
+};
+var IllegalCharacterInPathError = class extends PathUtilsBaseError {
+	constructor(character) {
+		super(`Illegal character detected in path: '${character}'`);
+		this.name = "IllegalCharacterInPathError";
+	}
+};
+var WindowsPathBehaviorNotImplementedError = class extends PathUtilsBaseError {
+	constructor() {
+		super("Windows path behavior not implemented");
+		this.name = "WindowsPathBehaviorNotImplementedError";
+	}
+};
+var UNCPathNotSupportedError = class extends PathUtilsBaseError {
+	path;
+	constructor(path) {
+		super(`UNC paths are not supported: '${path}'`);
+		this.name = "UNCPathNotSupportedError";
+		this.path = path;
+	}
+};
+
+//#endregion
+//#region src/constants.ts
+const MAX_DECODING_ITERATIONS = 10;
+const WINDOWS_DRIVE_LETTER_START_RE = /^[A-Z]:/i;
+const WINDOWS_DRIVE_LETTER_EVERYWHERE_RE = /[A-Z]:/i;
+const WINDOWS_DRIVE_RE = /^[A-Z]:[/\\]/i;
+const WINDOWS_UNC_ROOT_RE = /^\\\\(?![.?]\\)[^\\]+\\[^\\]+/;
+const CONTROL_CHARACTER_RE = /\p{Cc}/u;
+
+//#endregion
+//#region src/platform.ts
+const debug$1 = createDebugger("ucdjs:path-utils:platform");
+/**
+* Extracts the Windows drive letter from a given string, if present.
+* @param {string} str - The input string to check for a Windows drive letter.
+* @returns {string | null} The uppercase drive letter (e.g., "C") if found, otherwise null.
+*/
+function getWindowsDriveLetter(str) {
+	const match = str.match(WINDOWS_DRIVE_LETTER_START_RE);
+	if (match == null) return null;
+	return match[0]?.[0]?.toUpperCase() || null;
+}
+/**
+* Checks if the given path is a Windows drive path (e.g., "C:", "D:\").
+* @param {string} path - The path to check.
+* @returns {boolean} True if the path is a Windows drive path, false otherwise.
+*/
+function isWindowsDrivePath(path) {
+	return WINDOWS_DRIVE_RE.test(path);
+}
+/**
+* Removes the Windows drive letter from a path string.
+* @param {string} path - The path to strip the drive letter from.
+* @returns {string} The path without the Windows drive letter.
+* @throws {TypeError} If the provided path is not a string.
+*/
+function stripDriveLetter(path) {
+	if (typeof path !== "string") throw new TypeError("Path must be a string");
+	assertNotUNCPath(path);
+	return path.replace(WINDOWS_DRIVE_LETTER_START_RE, "");
+}
+/**
+* Checks if the given path is a UNC (Universal Naming Convention) path.
+* @param {string} path - The path to check.
+* @returns {boolean} True if the path is a UNC path, false otherwise.
+*/
+function isUNCPath(path) {
+	return WINDOWS_UNC_ROOT_RE.test(path);
+}
+/**
+* Asserts that the given path is not a UNC path. Throws UNCPathNotSupportedError if it is.
+* @param {string} path - The path to check.
+* @throws {UNCPathNotSupportedError} If the path is a UNC path.
+*/
+function assertNotUNCPath(path) {
+	if (isUNCPath(path)) {
+		debug$1?.("UNC path detected and rejected", { path });
+		throw new UNCPathNotSupportedError(path);
+	}
+}
+/**
+* Converts a path to Unix format by normalizing separators, stripping Windows drive letters, and ensuring a leading slash.
+* @param {string} inputPath - The input path to convert.
+* @returns {string} The path in Unix format.
+*/
+function toUnixFormat(inputPath) {
+	if (typeof inputPath !== "string") throw new TypeError("Input path must be a string");
+	if (inputPath.trim() === "") return "/";
+	assertNotUNCPath(inputPath);
+	let normalized = pathe.normalize(inputPath.trim());
+	normalized = normalized.replace(WINDOWS_DRIVE_LETTER_EVERYWHERE_RE, "");
+	normalized = prependLeadingSlash(normalized);
+	return trimTrailingSlash(pathe.normalize(normalized));
+}
+
+//#endregion
+//#region src/utils.ts
+const isCaseSensitive = "process" in globalThis && typeof globalThis.process === "object" && "platform" in globalThis.process && typeof globalThis.process.platform === "string" && globalThis.process.platform !== "win32" && globalThis.process.platform !== "darwin";
+const osPlatform = /* @__PURE__ */ (() => {
+	if ("process" in globalThis && typeof globalThis.process === "object" && "platform" in globalThis.process && typeof globalThis.process.platform === "string") return globalThis.process.platform;
+	return null;
+})();
+
+//#endregion
+//#region src/security.ts
+const debug = createDebugger("ucdjs:path-utils:security");
+/**
+* Checks if the resolved path is within the specified base path, considering case sensitivity.
+* This function normalizes paths, applies leading slashes, and ensures the resolved path starts with the base path
+* followed by a separator to prevent partial matches.
+* @param {string} basePath - The base path to check against, must be a non-empty string.
+* @param {string} resolvedPath - The path to check, must be a non-empty string.
+* @returns {boolean} True if the resolved path is within the base path, false otherwise.
+*/
+function isWithinBase(basePath, resolvedPath) {
+	if (typeof resolvedPath !== "string" || typeof basePath !== "string") {
+		debug?.("isWithinBase: invalid input types", {
+			resolvedPathType: typeof resolvedPath,
+			basePathType: typeof basePath
+		});
+		return false;
+	}
+	resolvedPath = resolvedPath.trim();
+	basePath = basePath.trim();
+	if (resolvedPath === "" || basePath === "") {
+		debug?.("isWithinBase: empty path(s)", {
+			resolvedPathEmpty: resolvedPath === "",
+			basePathEmpty: basePath === ""
+		});
+		return false;
+	}
+	assertNotUNCPath(resolvedPath);
+	assertNotUNCPath(basePath);
+	basePath = isWindowsDrivePath(basePath) ? basePath : prependLeadingSlash(basePath);
+	resolvedPath = isWindowsDrivePath(resolvedPath) ? resolvedPath : prependLeadingSlash(resolvedPath);
+	const normalizedResolved = pathe.normalize(resolvedPath);
+	const normalizedBase = pathe.normalize(basePath);
+	const resolved = isCaseSensitive ? normalizedResolved : normalizedResolved.toLowerCase();
+	const base = isCaseSensitive ? normalizedBase : normalizedBase.toLowerCase();
+	const baseWithSeparator = base.endsWith(pathe.sep) ? base : base + pathe.sep;
+	const isWithin = resolved === base || resolved.startsWith(baseWithSeparator);
+	debug?.("isWithinBase: check completed", {
+		normalizedBase,
+		normalizedResolved,
+		baseWithSeparator,
+		isCaseSensitive,
+		isWithin
+	});
+	return isWithin;
+}
+function decodePathSafely(encodedPath) {
+	if (typeof encodedPath !== "string") throw new TypeError("Encoded path must be a string");
+	debug?.("decodePathSafely: starting decode", { encodedPath });
+	let decodedPath = encodedPath;
+	let previousPath;
+	let iterations = 0;
+	do {
+		previousPath = decodedPath;
+		try {
+			decodedPath = decodeURIComponent(decodedPath);
+		} catch {}
+		decodedPath = decodedPath.replace(/%2e/gi, ".").replace(/%2f/gi, "/").replace(/%5c/gi, "\\");
+		iterations++;
+	} while (decodedPath !== previousPath && iterations < MAX_DECODING_ITERATIONS);
+	if (iterations >= MAX_DECODING_ITERATIONS) {
+		debug?.("decodePathSafely: max iterations exceeded", {
+			iterations,
+			originalPath: encodedPath,
+			finalPath: decodedPath
+		});
+		throw new MaximumDecodingIterationsExceededError();
+	}
+	debug?.("decodePathSafely: completed", {
+		iterations,
+		originalPath: encodedPath,
+		decodedPath,
+		wasEncoded: encodedPath !== decodedPath
+	});
+	return decodedPath;
+}
+function resolveSafePath(basePath, inputPath) {
+	if (typeof basePath !== "string") throw new TypeError("Base path must be a string");
+	basePath = basePath.trim();
+	inputPath = inputPath.trim();
+	debug?.("resolveSafePath: called", {
+		basePath,
+		inputPath
+	});
+	if (basePath === "") throw new Error("Base path cannot be empty");
+	assertNotUNCPath(basePath);
+	assertNotUNCPath(inputPath);
+	let decodedPath;
+	try {
+		decodedPath = decodePathSafely(inputPath);
+	} catch (err) {
+		debug?.("resolveSafePath: failed to decode input path", {
+			inputPath,
+			error: err
+		});
+		throw new FailedToDecodePathError();
+	}
+	assertNotUNCPath(decodedPath);
+	const originalBasePath = basePath;
+	const originalInputPath = inputPath;
+	basePath = isWindowsDrivePath(basePath) ? basePath : prependLeadingSlash(basePath);
+	inputPath = isWindowsDrivePath(inputPath) ? inputPath : prependLeadingSlash(inputPath);
+	debug?.("resolveSafePath: after leading slash normalization", {
+		basePath: {
+			original: originalBasePath,
+			normalized: basePath
+		},
+		inputPath: {
+			original: originalInputPath,
+			normalized: inputPath
+		},
+		decodedPath
+	});
+	const normalizedBasePath = pathe.normalize(basePath);
+	const illegalMatch = decodedPath.match(CONTROL_CHARACTER_RE);
+	if (decodedPath.includes("\0") || illegalMatch != null) {
+		const illegalChar = decodedPath.includes("\0") ? "\0" : illegalMatch?.[0] ?? "[unknown]";
+		debug?.("resolveSafePath: illegal character detected", {
+			decodedPath,
+			illegalChar,
+			charCode: illegalChar.charCodeAt(0)
+		});
+		throw new IllegalCharacterInPathError(illegalChar);
+	}
+	let resolvedPath;
+	const absoluteInputPath = pathe.normalize(decodedPath);
+	const isAbsoluteInput = WINDOWS_DRIVE_RE.test(decodedPath) || pathe.isAbsolute(toUnixFormat(decodedPath));
+	debug?.("resolveSafePath: path analysis", {
+		absoluteInputPath,
+		isAbsoluteInput,
+		normalizedBasePath
+	});
+	if (isAbsoluteInput && isWithinBase(normalizedBasePath, absoluteInputPath)) {
+		const normalizedBase = pathe.normalize(basePath);
+		const normalizedInput = pathe.normalize(absoluteInputPath);
+		if (normalizedInput.toLowerCase().startsWith(normalizedBase.toLowerCase())) {
+			const tailAfterBase = normalizedInput.slice(normalizedBase.length);
+			const result = pathe.normalize(normalizedBase + tailAfterBase);
+			debug?.("resolveSafePath: absolute path within base (preserving casing)", {
+				normalizedBase,
+				normalizedInput,
+				tailAfterBase,
+				result
+			});
+			return result;
+		}
+		debug?.("resolveSafePath: absolute path within base", { result: absoluteInputPath });
+		return pathe.normalize(absoluteInputPath);
+	}
+	const isWindows = osPlatform === "win32" || !isCaseSensitive && osPlatform !== "darwin";
+	if (isWindows && isWindowsDrivePath(decodedPath)) {
+		debug?.("resolveSafePath: delegating to Windows path resolution", {
+			isWindows,
+			decodedPath
+		});
+		return internal_resolveWindowsPath(basePath, decodedPath);
+	}
+	const unixPath = decodedPath.replace(/\\/g, "/");
+	if (pathe.isAbsolute(unixPath)) {
+		debug?.("resolveSafePath: handling absolute Unix path", {
+			unixPath,
+			normalizedBasePath
+		});
+		resolvedPath = internal_handleAbsolutePath(unixPath, normalizedBasePath);
+	} else {
+		debug?.("resolveSafePath: handling relative Unix path", {
+			unixPath,
+			normalizedBasePath
+		});
+		resolvedPath = internal_handleRelativePath(unixPath, normalizedBasePath);
+	}
+	if (!isWithinBase(normalizedBasePath, resolvedPath)) {
+		debug?.("resolveSafePath: path traversal detected", {
+			basePath: normalizedBasePath,
+			resolvedPath,
+			originalInput: inputPath
+		});
+		throw new PathTraversalError(normalizedBasePath, resolvedPath);
+	}
+	const normalized = pathe.normalize(resolvedPath);
+	debug?.("resolveSafePath: completed successfully", {
+		originalInput: originalInputPath,
+		basePath: normalizedBasePath,
+		result: normalized
+	});
+	return normalized;
+}
+/**
+* @internal
+*/
+function internal_resolveWindowsPath(basePath, decodedPath) {
+	debug?.("internal_resolveWindowsPath: called", {
+		basePath,
+		decodedPath
+	});
+	if (isWindowsDrivePath(decodedPath) && isWindowsDrivePath(basePath)) {
+		const normalizedBasePath = pathe.normalize(basePath);
+		const baseDriveLetter = getWindowsDriveLetter(basePath);
+		const inputDriveLetter = getWindowsDriveLetter(decodedPath);
+		debug?.("internal_resolveWindowsPath: drive letter comparison", {
+			baseDriveLetter,
+			inputDriveLetter,
+			match: baseDriveLetter === inputDriveLetter
+		});
+		if (baseDriveLetter != null && inputDriveLetter != null && baseDriveLetter !== inputDriveLetter) {
+			debug?.("internal_resolveWindowsPath: drive letter mismatch", {
+				baseDriveLetter,
+				inputDriveLetter
+			});
+			throw new WindowsDriveMismatchError(baseDriveLetter, inputDriveLetter);
+		}
+		const normalizedDecodedPath = pathe.normalize(decodedPath);
+		if (!isWithinBase(normalizedBasePath, normalizedDecodedPath)) {
+			debug?.("internal_resolveWindowsPath: path traversal detected", {
+				basePath: normalizedBasePath,
+				resolvedPath: normalizedDecodedPath
+			});
+			throw new PathTraversalError(normalizedBasePath, normalizedDecodedPath);
+		}
+		const result = pathe.normalize(normalizedDecodedPath);
+		debug?.("internal_resolveWindowsPath: completed successfully", {
+			basePath: normalizedBasePath,
+			result
+		});
+		return result;
+	}
+	debug?.("internal_resolveWindowsPath: unhandled path combination", {
+		basePath,
+		decodedPath,
+		isBaseWindowsDrive: isWindowsDrivePath(basePath),
+		isInputWindowsDrive: isWindowsDrivePath(decodedPath)
+	});
+	throw new WindowsPathBehaviorNotImplementedError();
+}
+/**
+* Handles absolute Unix-style paths by treating them as relative to the base path boundary.
+* @internal
+*/
+function internal_handleAbsolutePath(absoluteUnixPath, basePath) {
+	if (absoluteUnixPath === "/") {
+		debug?.("internal_handleAbsolutePath: root path mapped to base", { basePath });
+		return basePath;
+	}
+	const pathWithoutLeadingSlash = absoluteUnixPath.replace(/^\/+/, "");
+	const resolved = pathe.resolve(basePath, pathWithoutLeadingSlash);
+	debug?.("internal_handleAbsolutePath: resolved", {
+		absoluteUnixPath,
+		pathWithoutLeadingSlash,
+		basePath,
+		resolved
+	});
+	return resolved;
+}
+/**
+* Handles relative Unix-style paths by resolving them against the base path.
+* @internal
+*/
+function internal_handleRelativePath(relativeUnixPath, basePath) {
+	if (relativeUnixPath === "." || relativeUnixPath === "./") {
+		debug?.("internal_handleRelativePath: current directory mapped to base", { basePath });
+		return basePath;
+	}
+	const resolved = pathe.resolve(basePath, relativeUnixPath);
+	debug?.("internal_handleRelativePath: resolved", {
+		relativeUnixPath,
+		basePath,
+		resolved
+	});
+	return resolved;
+}
+
+//#endregion
+//#region src/index.ts
+const patheBasename = basename;
+const patheDirname = dirname;
+const patheExtname = extname;
+const patheJoin = join;
+const patheNormalize = normalize;
+const patheRelative = relative;
+const patheResolve = resolve;
+
+//#endregion
+export { FailedToDecodePathError, IllegalCharacterInPathError, MaximumDecodingIterationsExceededError, PathTraversalError, PathUtilsBaseError, UNCPathNotSupportedError, WindowsDriveMismatchError, WindowsPathBehaviorNotImplementedError, assertNotUNCPath, decodePathSafely, getWindowsDriveLetter, isCaseSensitive, isUNCPath, isWindowsDrivePath, isWithinBase, osPlatform, patheBasename, patheDirname, patheExtname, patheJoin, patheNormalize, patheRelative, patheResolve, resolveSafePath, stripDriveLetter, toUnixFormat };

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@ucdjs/path-utils",
+  "version": "0.1.1-beta.1",
+  "type": "module",
+  "author": {
+    "name": "Lucas Nørgård",
+    "email": "lucasnrgaard@gmail.com",
+    "url": "https://luxass.dev"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/ucdjs/ucd",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ucdjs/ucd.git",
+    "directory": "packages/path-utils"
+  },
+  "bugs": {
+    "url": "https://github.com/ucdjs/ucd/issues"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.18"
+  },
+  "dependencies": {
+    "@luxass/utils": "2.7.3",
+    "pathe": "2.0.3",
+    "@ucdjs-internal/shared": "0.1.1-beta.1"
+  },
+  "devDependencies": {
+    "@luxass/eslint-config": "7.2.0",
+    "eslint": "10.0.0",
+    "publint": "0.3.17",
+    "tsdown": "0.20.3",
+    "typescript": "5.9.3",
+    "vitest-testdirs": "4.4.2",
+    "@ucdjs-tooling/tsconfig": "1.0.0",
+    "@ucdjs-tooling/tsdown-config": "1.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown --tsconfig=./tsconfig.build.json",
+    "dev": "tsdown --watch",
+    "clean": "git clean -xdf dist node_modules",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit -p tsconfig.build.json"
+  }
+}