@zokugun/fs-path 0.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2026-present Baptiste Augrain
+
+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,153 @@
+[@zokugun/fs-path](https://github.com/zokugun/node-fs-path)
+===========================================================
+
+[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
+[![NPM Version](https://img.shields.io/npm/v/@zokugun/fs-path.svg?colorB=green)](https://www.npmjs.com/package/@zokugun/fs-path)
+[![Donation](https://img.shields.io/badge/donate-ko--fi-green)](https://ko-fi.com/daiyam)
+[![Donation](https://img.shields.io/badge/donate-liberapay-green)](https://liberapay.com/daiyam/donate)
+[![Donation](https://img.shields.io/badge/donate-paypal-green)](https://paypal.me/daiyam99)
+
+> Compact set of path utilities that complement Node's builtin `path` module.
+
+Features
+--------
+
+- Tilde expansion: expand `~` to the current user's home directory with `untildify`.
+- Safe joining and resolving: helpers that avoid common pitfalls when composing paths.
+- Useful utilities: retrieve parent paths, absolute normalization, and platform-aware helpers.
+- Small package with ESM and CJS builds
+
+Installation
+------------
+
+```bash
+npm add @zokugun/fs-path
+```
+
+Quick Start
+-----------
+
+```ts
+import { isInDir, join, resolve } from '@zokugun/fs-path'
+
+const configDir = resolve('~/.config/myapp')
+const dataFile = join(configDir, 'data.json')
+
+console.log('Config dir:', configDir)
+console.log('Data file:', dataFile)
+
+console.log('Is data file inside config dir?', isInDir(dataFile, configDir))
+```
+
+This example expands the current user's home directory, joins paths safely, and prints the resolved absolute path for `configDir`.
+
+API reference
+-------------
+
+- `absolute(...paths: string[]): string`: Return an absolute path for the given segments. Uses the current platform resolution behavior.
+- `dir(path: string): string`: Return the directory portion of `path` (empty string when the result is `.`).
+- `extension(path: string): string`: Return the file extension (same as `path.extname`).
+- `isAbsolute(path: string): boolean`: Return `true` when `path` is absolute for the current platform.
+- `isInDir(path: string, parent: string): boolean`: Return `true` when `path` is equal to or contained within `parent`.
+- `isInDirs(path: string, parents: string[]): boolean`: Return `true` when `path` is equal to or contained within in one of the `parents`.
+- `isSafePath(path: string, options?): boolean`: Return `true` when `path` is considered safe for use (guards against suspicious segments such as `..` when appropriate for the platform).
+- `isSafeSegment(segment: string, target?: Target | 'auto'): boolean`: Return `true` when a single path segment is safe (doesn't contain path separators or traversal sequences).
+- `join(...paths: string[]): string`: Join path segments; returns empty string when the join result is `.`.
+- `leaf(path: string, suffix?: string): string`: Return the basename of `path` (alias of `path.basename`).
+- `matchesGlob?(path: string, pattern: string): boolean`: Optional platform-provided glob matcher when available.
+- `normalize(path: string): string`: Normalize the path (same as `path.normalize`).
+- `parent(path: string): string`: Return the parent directory of `file` (empty string when the result is `.`).
+- `relative(from: string, to: string): string`: Compute the relative path from `from` to `to`.
+- `resolve(...paths: string[]): string`: Resolve path segments to an absolute path. Supports tilde expansion:
+    - `~` expands to the current user's home directory.
+    - `~username/...` attempts to expand to that user's home directory when available.
+- `sanitize(path: string, options?): Result<string>`: Return a sanitized form of `path` with unsafe segments normalized.
+- `untildify(path: string): string`: Expand a leading `~` or `~username` to the home directory, or return `path` unchanged.
+- `delimiter`: Platform-specific character (`;`/`:`).
+- `separator`: Platform-specific character (`\`/`/`).
+
+```ts
+export type PlatformPath = {
+    readonly delimiter: ';' | ':';
+    readonly separator: '\\' | '/';
+    readonly posix: PlatformPath;
+    readonly win32: PlatformPath;
+    absolute: (...paths: string[]) => string;
+    dir: (path: string) => string;
+    extension: (path: string) => string;
+    isAbsolute: (path: string) => boolean;
+    isInDir(path: string, parent: string): boolean;
+    isInDirs(path: string, parents: string[]): boolean;
+    isSafePath: (path: string, options?: {
+		parent?: string | null;
+		parents?: string | string[] | null;
+		target?: Target | 'auto';
+	}) => boolean;
+    isSafeSegment: (segment: string, target?: Target | 'auto') => boolean;
+    join: (...paths: string[]) => string;
+    leaf: (path: string, suffix?: string) => string;
+    matchesGlob?: (path: string, pattern: string) => boolean;
+    normalize: (path: string) => string;
+    parent: (path: string) => string;
+    relative: (from: string, to: string) => string;
+    resolve: (...paths: string[]) => string;
+    sanitize(path: string, options?: {
+        parent?: string | null;
+        parents?: string | string[] | null;
+        replacement?: string | null;
+        target?: Target | 'auto'
+    }) => Result<string>
+    untildify: (path: string) => string;
+};
+```
+
+Comparison with Node's `path`
+-----------------------------
+
+This library intentionally mirrors many of Node's `path` APIs but provides small ergonomic differences and extra features where useful:
+
+- `absolute(...paths)`: resolves using the runtime platform and always returns a normalized absolute path.
+- `dir(path)`: returns `path.parse(path).dir` (similar to `path.dirname`, kept for API symmetry).
+- `extension(path)`: alias of `path.extname`.
+- `join(...paths)`: wraps `path.join`. Returns `''` instead of `.` when the joined result is the current directory.
+- `isAbsolute(path)`, `normalize(path)`, `relative(from, to)`: direct mappings to `path.isAbsolute`, `path.normalize`, and `path.relative` respectively.
+- `leaf(path, suffix?)`: alias of `path.basename`.
+- `parent(file)`: wraps `path.dirname`. Returns `''` instead of `.` for consistency with `join`.
+- `resolve(...paths)`: wraps `path.resolve` but adds tilde expansion (`~` and `~username`) before resolving.
+- `untildify(path)`: purely handles `~` expansion; no direct equivalent in Node core.
+- `delimiter`: same value as `path.delimiter` on the current platform.
+- `separator`: same value as `path.sep` on the current platform.
+
+Contributions
+-------------
+
+Contributions are most welcome. Please:
+- Open issues and feature requests under the repository discussions.
+- Follow the [`CONTRIBUTING.md`](./CONTRIBUTING.md).
+
+Donations
+---------
+
+Support this project by becoming a financial contributor.
+
+<table>
+    <tr>
+        <td><img src="https://raw.githubusercontent.com/daiyam/assets/master/icons/256/funding_kofi.png" alt="Ko-fi" width="80px" height="80px"></td>
+        <td><a href="https://ko-fi.com/daiyam" target="_blank">ko-fi.com/daiyam</a></td>
+    </tr>
+    <tr>
+        <td><img src="https://raw.githubusercontent.com/daiyam/assets/master/icons/256/funding_liberapay.png" alt="Liberapay" width="80px" height="80px"></td>
+        <td><a href="https://liberapay.com/daiyam/donate" target="_blank">liberapay.com/daiyam/donate</a></td>
+    </tr>
+    <tr>
+        <td><img src="https://raw.githubusercontent.com/daiyam/assets/master/icons/256/funding_paypal.png" alt="PayPal" width="80px" height="80px"></td>
+        <td><a href="https://paypal.me/daiyam99" target="_blank">paypal.me/daiyam99</a></td>
+    </tr>
+</table>
+
+License
+-------
+
+Copyright &copy; 2026-present Baptiste Augrain
+
+Licensed under the [MIT license](https://opensource.org/licenses/MIT).

package/lib/cjs/absolute.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.absolute = absolute;
+function absolute(nodePath, localPath) {
+    return (...paths) => nodePath.resolve(localPath.resolve(...paths));
+}

package/lib/cjs/absolute.d.cts

@@ -0,0 +1,3 @@
+import type path from 'node:path';
+import { type PlatformPath } from './types.cjs';
+export declare function absolute(nodePath: path.PlatformPath, localPath: PlatformPath): (...paths: string[]) => string;

package/lib/cjs/dir.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dir = dir;
+function dir(nodePath, _localPath) {
+    return (path) => nodePath.parse(path).dir;
+}

package/lib/cjs/dir.d.cts

@@ -0,0 +1,3 @@
+import type path from 'node:path';
+import { type PlatformPath } from './types.cjs';
+export declare function dir(nodePath: path.PlatformPath, _localPath: PlatformPath): (path: string) => string;

package/lib/cjs/index.cjs

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.win32 = exports.untildify = exports.separator = exports.sanitize = exports.resolve = exports.relative = exports.posix = exports.isSafeSegment = exports.isSafePath = exports.isInDirs = exports.isInDir = exports.parent = exports.normalize = exports.matchesGlob = exports.leaf = exports.join = exports.isAbsolute = exports.extension = exports.delimiter = exports.absolute = void 0;
+const platform_js_1 = require("./platform.cjs");
+const { absolute, delimiter, extension, isAbsolute, join, leaf, matchesGlob, normalize, parent, isInDir, isInDirs, isSafePath, isSafeSegment, posix, relative, resolve, sanitize, separator, untildify, win32, } = platform_js_1.DEFAULT_PLATFORM;
+exports.absolute = absolute;
+exports.delimiter = delimiter;
+exports.extension = extension;
+exports.isAbsolute = isAbsolute;
+exports.join = join;
+exports.leaf = leaf;
+exports.matchesGlob = matchesGlob;
+exports.normalize = normalize;
+exports.parent = parent;
+exports.isInDir = isInDir;
+exports.isInDirs = isInDirs;
+exports.isSafePath = isSafePath;
+exports.isSafeSegment = isSafeSegment;
+exports.posix = posix;
+exports.relative = relative;
+exports.resolve = resolve;
+exports.sanitize = sanitize;
+exports.separator = separator;
+exports.untildify = untildify;
+exports.win32 = win32;
+/* eslint-enable unicorn/prefer-export-from */
+// eslint-disable-next-line import/no-anonymous-default-export
+exports.default = {
+    PlatformPath: undefined,
+    absolute,
+    delimiter,
+    extension,
+    isAbsolute,
+    join,
+    leaf,
+    matchesGlob,
+    normalize,
+    parent,
+    isInDir,
+    isInDirs,
+    isSafePath,
+    isSafeSegment,
+    posix,
+    relative,
+    resolve,
+    sanitize,
+    separator,
+    untildify,
+    win32,
+};

package/lib/cjs/index.d.cts

@@ -0,0 +1,47 @@
+import { type PlatformPath } from './types.cjs';
+declare const absolute: (...paths: string[]) => string, delimiter: ";" | ":", extension: (path: string) => string, isAbsolute: (path: string) => boolean, join: (...paths: string[]) => string, leaf: (path: string, suffix?: string) => string, matchesGlob: ((path: string, pattern: string) => boolean) | undefined, normalize: (path: string) => string, parent: (file: string) => string, isInDir: (file: string, dir: string) => boolean, isInDirs: (file: string, directories: string[]) => boolean, isSafePath: (path: string, options?: {
+    parent?: string | null;
+    parents?: string | string[] | null;
+    target?: Target | "auto";
+}) => boolean, isSafeSegment: (segment: string, target?: Target | "auto") => boolean, posix: PlatformPath, relative: (from: string, to: string) => string, resolve: (...paths: string[]) => string, sanitize: (path: string, options?: {
+    parent?: string | null;
+    parents?: string | string[] | null;
+    replacement?: string | null;
+    target?: Target | "auto";
+}) => DResult<string>, separator: "\\" | "/", untildify: (path: string) => string, win32: PlatformPath;
+export { type PlatformPath, absolute, delimiter, extension, isAbsolute, join, leaf, matchesGlob, normalize, parent, isInDir, isInDirs, isSafePath, isSafeSegment, posix, relative, resolve, sanitize, separator, untildify, win32, };
+import { type Target } from "@zokugun/fs-path-sanitize";
+import { type DResult } from "@zokugun/xtry/result";
+declare const _default: {
+    PlatformPath: PlatformPath;
+    absolute: (...paths: string[]) => string;
+    delimiter: ";" | ":";
+    extension: (path: string) => string;
+    isAbsolute: (path: string) => boolean;
+    join: (...paths: string[]) => string;
+    leaf: (path: string, suffix?: string) => string;
+    matchesGlob: ((path: string, pattern: string) => boolean) | undefined;
+    normalize: (path: string) => string;
+    parent: (file: string) => string;
+    isInDir: (file: string, dir: string) => boolean;
+    isInDirs: (file: string, directories: string[]) => boolean;
+    isSafePath: (path: string, options?: {
+        parent?: string | null;
+        parents?: string | string[] | null;
+        target?: Target | "auto";
+    }) => boolean;
+    isSafeSegment: (segment: string, target?: Target | "auto") => boolean;
+    posix: PlatformPath;
+    relative: (from: string, to: string) => string;
+    resolve: (...paths: string[]) => string;
+    sanitize: (path: string, options?: {
+        parent?: string | null;
+        parents?: string | string[] | null;
+        replacement?: string | null;
+        target?: Target | "auto";
+    }) => DResult<string>;
+    separator: "\\" | "/";
+    untildify: (path: string) => string;
+    win32: PlatformPath;
+};
+export default _default;

package/lib/cjs/is-in-dir.cjs

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInDir = isInDir;
+function isInDir(_nodePath, localPath) {
+    return (path, parent) => {
+        let resolvedPath = localPath.resolve(path);
+        let resolvedParent = localPath.resolve(parent);
+        if (localPath.separator === '\\') {
+            resolvedPath = resolvedPath.toLowerCase();
+            resolvedParent = resolvedParent.toLowerCase();
+        }
+        if (resolvedPath === resolvedParent) {
+            return true;
+        }
+        const suffixedParent = resolvedParent.endsWith(localPath.separator) ? resolvedParent : resolvedParent + localPath.separator;
+        return resolvedPath.startsWith(suffixedParent);
+    };
+}

package/lib/cjs/is-in-dir.d.cts

@@ -0,0 +1,3 @@
+import type path from 'node:path';
+import { type PlatformPath } from './types.cjs';
+export declare function isInDir(_nodePath: path.PlatformPath, localPath: PlatformPath): (path: string, parent: string) => boolean;

package/lib/cjs/is-in-dirs.cjs

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInDirs = isInDirs;
+// eslint-disable-next-line unicorn/prevent-abbreviations
+function isInDirs(_nodePath, localPath) {
+    if (localPath.separator === '\\') {
+        return (path, parents) => {
+            const resolvedPath = localPath.resolve(path).toLowerCase();
+            for (const parent of parents) {
+                const resolvedParent = localPath.resolve(parent).toLowerCase();
+                if (resolvedPath === resolvedParent) {
+                    return true;
+                }
+                const suffixedParent = resolvedParent.endsWith(localPath.separator) ? resolvedParent : resolvedParent + localPath.separator;
+                if (resolvedPath.startsWith(suffixedParent)) {
+                    return true;
+                }
+            }
+            return false;
+        };
+    }
+    else {
+        return (path, parents) => {
+            const resolvedPath = localPath.resolve(path);
+            for (const parent of parents) {
+                const resolvedParent = localPath.resolve(parent);
+                if (resolvedPath === resolvedParent) {
+                    return true;
+                }
+                const suffixedParent = resolvedParent.endsWith(localPath.separator) ? resolvedParent : resolvedParent + localPath.separator;
+                if (resolvedPath.startsWith(suffixedParent)) {
+                    return true;
+                }
+            }
+            return false;
+        };
+    }
+}

package/lib/cjs/is-in-dirs.d.cts

@@ -0,0 +1,3 @@
+import type path from 'node:path';
+import { type PlatformPath } from './types.cjs';
+export declare function isInDirs(_nodePath: path.PlatformPath, localPath: PlatformPath): (path: string, parents: string[]) => boolean;

package/lib/cjs/is-safe-path.cjs

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSafePath = isSafePath;
+const node_os_1 = __importDefault(require("node:os"));
+const fs_path_sanitize_1 = require("@zokugun/fs-path-sanitize");
+const is_it_type_1 = require("@zokugun/is-it-type");
+function isSafePath(_nodePath, localPath) {
+    let target;
+    if (localPath.separator === '\\') {
+        target = 'windows.safe';
+    }
+    else {
+        const system = node_os_1.default.platform();
+        target = system === 'darwin' ? 'macos.safe' : 'linux.safe';
+    }
+    const sanitizer = fs_path_sanitize_1.Sanitizer.getInstance(target);
+    return (path, options = {}) => {
+        let parents;
+        if ((0, is_it_type_1.isString)(options.parent)) {
+            parents = [options.parent];
+        }
+        if ((0, is_it_type_1.isString)(options.parents)) {
+            parents = [options.parents];
+        }
+        else if ((0, is_it_type_1.isArray)(options.parents)) {
+            parents = options.parents;
+        }
+        const safe = !options.target || options.target === 'auto' ? sanitizer.isSafePath(path) : (0, fs_path_sanitize_1.isSafePath)(path, target);
+        if (!safe) {
+            return false;
+        }
+        else if (parents) {
+            return localPath.isInDirs(path, parents);
+        }
+        else {
+            return true;
+        }
+    };
+}

package/lib/cjs/is-safe-path.d.cts

@@ -0,0 +1,8 @@
+import type path from 'node:path';
+import { type Target } from '@zokugun/fs-path-sanitize';
+import { type PlatformPath } from './types.cjs';
+export declare function isSafePath(_nodePath: path.PlatformPath, localPath: PlatformPath): (path: string, options?: {
+    parent?: string | null;
+    parents?: string | string[] | null;
+    target?: Target | 'auto';
+}) => boolean;

package/lib/cjs/is-safe-segment.cjs

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSafeSegment = isSafeSegment;
+const node_os_1 = __importDefault(require("node:os"));
+const fs_path_sanitize_1 = require("@zokugun/fs-path-sanitize");
+function isSafeSegment(_nodePath, localPath) {
+    let target;
+    if (localPath.separator === '\\') {
+        target = 'windows.safe';
+    }
+    else {
+        const system = node_os_1.default.platform();
+        target = system === 'darwin' ? 'macos.safe' : 'linux.safe';
+    }
+    const sanitizer = fs_path_sanitize_1.Sanitizer.getInstance(target);
+    return (segment, target) => {
+        if (!target || target === 'auto') {
+            return sanitizer.isSafePath(segment);
+        }
+        else {
+            return (0, fs_path_sanitize_1.isSafeSegment)(segment, target);
+        }
+    };
+}

package/lib/cjs/is-safe-segment.d.cts

@@ -0,0 +1,4 @@
+import type path from 'node:path';
+import { type Target } from '@zokugun/fs-path-sanitize';
+import { type PlatformPath } from './types.cjs';
+export declare function isSafeSegment(_nodePath: path.PlatformPath, localPath: PlatformPath): (segment: string, target?: Target | 'auto') => boolean;

package/lib/cjs/join.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.join = join;
+function join(nodePath, _localPath) {
+    return (...paths) => {
+        const joined = nodePath.join(...paths);
+        if (joined === '.') {
+            return '';
+        }
+        else {
+            return joined;
+        }
+    };
+}

package/lib/cjs/join.d.cts

@@ -0,0 +1,3 @@
+import type path from 'path';
+import { type PlatformPath } from './types.cjs';
+export declare function join(nodePath: path.PlatformPath, _localPath: PlatformPath): (...paths: string[]) => string;

package/lib/cjs/parent.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parent = parent;
+function parent(nodePath, _localPath) {
+    return (file) => {
+        const parent = nodePath.dirname(file);
+        if (parent === '.') {
+            return '';
+        }
+        else {
+            return parent;
+        }
+    };
+}

package/lib/cjs/parent.d.cts

@@ -0,0 +1,3 @@
+import type path from 'node:path';
+import { type PlatformPath } from './types.cjs';
+export declare function parent(nodePath: path.PlatformPath, _localPath: PlatformPath): (file: string) => string;

package/lib/cjs/platform.cjs

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PLATFORM = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const absolute_js_1 = require("./absolute.cjs");
+const dir_js_1 = require("./dir.cjs");
+const is_in_dir_js_1 = require("./is-in-dir.cjs");
+// eslint-disable-next-line unicorn/prevent-abbreviations
+const is_in_dirs_js_1 = require("./is-in-dirs.cjs");
+const is_safe_path_js_1 = require("./is-safe-path.cjs");
+const is_safe_segment_js_1 = require("./is-safe-segment.cjs");
+const join_js_1 = require("./join.cjs");
+const parent_js_1 = require("./parent.cjs");
+const resolve_js_1 = require("./resolve.cjs");
+const sanitize_js_1 = require("./sanitize.cjs");
+const untildify_js_1 = require("./untildify.cjs");
+function buildPlatform(path) {
+    const { basename: leaf, delimiter, extname: extension, isAbsolute, normalize, relative, sep: separator, } = path;
+    const result = {
+        delimiter,
+        separator,
+        extension,
+        isAbsolute,
+        leaf,
+        matchesGlob: path.matchesGlob ?? undefined,
+        normalize,
+        relative,
+    };
+    result.absolute = (0, absolute_js_1.absolute)(path, result);
+    result.dir = (0, dir_js_1.dir)(path, result);
+    result.isInDir = (0, is_in_dir_js_1.isInDir)(path, result);
+    result.isInDirs = (0, is_in_dirs_js_1.isInDirs)(path, result);
+    result.isSafePath = (0, is_safe_path_js_1.isSafePath)(path, result);
+    result.isSafeSegment = (0, is_safe_segment_js_1.isSafeSegment)(path, result);
+    result.join = (0, join_js_1.join)(path, result);
+    result.parent = (0, parent_js_1.parent)(path, result);
+    result.resolve = (0, resolve_js_1.resolve)(path, result);
+    result.sanitize = (0, sanitize_js_1.sanitize)(path, result);
+    result.untildify = (0, untildify_js_1.untildify)(path, result);
+    return result;
+}
+const POSIX_PLATFORM = buildPlatform(node_path_1.default.posix);
+const WIN32_PLATFORM = buildPlatform(node_path_1.default.win32);
+Object.defineProperties(POSIX_PLATFORM, {
+    posix: {
+        value: POSIX_PLATFORM,
+        writable: false,
+    },
+    win32: {
+        value: WIN32_PLATFORM,
+        writable: false,
+    },
+});
+Object.defineProperties(WIN32_PLATFORM, {
+    posix: {
+        value: POSIX_PLATFORM,
+        writable: false,
+    },
+    win32: {
+        value: WIN32_PLATFORM,
+        writable: false,
+    },
+});
+exports.DEFAULT_PLATFORM = (node_path_1.default === node_path_1.default.posix ? POSIX_PLATFORM : WIN32_PLATFORM);

package/lib/cjs/platform.d.cts

@@ -0,0 +1,2 @@
+import { type PlatformPath } from './types.cjs';
+export declare const DEFAULT_PLATFORM: PlatformPath;

package/lib/cjs/resolve.cjs

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolve = resolve;
+const node_process_1 = __importDefault(require("node:process"));
+const is_it_type_1 = require("@zokugun/is-it-type");
+const get_home_js_1 = require("./utils/get-home.cjs");
+const get_user_home_js_1 = require("./utils/get-user-home.cjs");
+const TILDE_REGEX = /^~(?=$|\/|\\)/;
+const USER_REGEX = /^~([^/\\]+)(.*)$/;
+function resolve(nodePath, _localPath) {
+    return (...paths) => {
+        if (paths.length === 0) {
+            return node_process_1.default.cwd();
+        }
+        else if (nodePath.isAbsolute(paths[0])) {
+            return nodePath.normalize(nodePath.join(...paths));
+        }
+        else if (TILDE_REGEX.test(paths[0])) {
+            const homedir = (0, get_home_js_1.getHome)();
+            if ((0, is_it_type_1.isString)(homedir)) {
+                paths.shift();
+                return nodePath.normalize(nodePath.join(homedir, ...paths));
+            }
+        }
+        else {
+            const match = USER_REGEX.exec(paths[0]);
+            if (match) {
+                const [, username, rest] = match;
+                const userHome = (0, get_user_home_js_1.getUserHome)(username);
+                if ((0, is_it_type_1.isString)(userHome)) {
+                    paths.shift();
+                    return nodePath.normalize(nodePath.join(userHome + rest, ...paths));
+                }
+            }
+        }
+        paths.unshift();
+        return nodePath.normalize(nodePath.join(node_process_1.default.cwd(), ...paths));
+    };
+}

package/lib/cjs/resolve.d.cts

@@ -0,0 +1,3 @@
+import type path from 'node:path';
+import { type PlatformPath } from './types.cjs';
+export declare function resolve(nodePath: path.PlatformPath, _localPath: PlatformPath): (...paths: string[]) => string;