@zokugun/fs-path 0.1.0

package/lib/cjs/sanitize.cjs

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitize = sanitize;
+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");
+const xtry_1 = require("@zokugun/xtry");
+function sanitize(_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 = {}) => {
+        const resolvedPath = localPath.resolve(path);
+        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;
+        }
+        let sanitizedPath;
+        if (!options.target || options.target === 'auto') {
+            sanitizedPath = sanitizer.sanitizePath(resolvedPath, {
+                absolute: true,
+                replacement: options.replacement,
+            });
+        }
+        else {
+            sanitizedPath = (0, fs_path_sanitize_1.sanitizePath)(resolvedPath, {
+                absolute: true,
+                replacement: options.replacement,
+                target: options.target,
+            });
+        }
+        if (sanitizedPath.fails) {
+            return sanitizedPath;
+        }
+        if (parents) {
+            if (localPath.isInDirs(sanitizedPath.value, parents)) {
+                return sanitizedPath;
+            }
+            else {
+                return (0, xtry_1.err)('Invalid path: not within allowed parents');
+            }
+        }
+        else {
+            return sanitizedPath;
+        }
+    };
+}

package/lib/cjs/sanitize.d.cts

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

package/lib/cjs/types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/types.d.cts

@@ -0,0 +1,34 @@
+import { type Target } from '@zokugun/fs-path-sanitize';
+import { type DResult } from '@zokugun/xtry';
+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: (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;
+    join: (...paths: string[]) => string;
+    leaf: (path: string, suffix?: string) => string;
+    matchesGlob?: (path: string, pattern: string) => boolean;
+    normalize: (path: string) => string;
+    parent: (file: 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';
+    }) => DResult<string>;
+    untildify: (path: string) => string;
+};

package/lib/cjs/untildify.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.untildify = untildify;
+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 untildify(_nodePath, _localPath) {
+    return (path) => {
+        const homedir = (0, get_home_js_1.getHome)();
+        if ((0, is_it_type_1.isString)(homedir) && TILDE_REGEX.test(path)) {
+            return homedir + path.slice(1);
+        }
+        const match = USER_REGEX.exec(path);
+        if (match) {
+            const [, username, rest] = match;
+            const userHome = (0, get_user_home_js_1.getUserHome)(username);
+            if ((0, is_it_type_1.isString)(userHome)) {
+                return userHome + rest;
+            }
+        }
+        return path;
+    };
+}

package/lib/cjs/untildify.d.cts

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

package/lib/cjs/utils/get-home.cjs

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHome = getHome;
+const node_os_1 = __importDefault(require("node:os"));
+let $home;
+function getHome() {
+    $home ??= node_os_1.default.homedir();
+    return $home;
+}

package/lib/cjs/utils/get-home.d.cts

@@ -0,0 +1 @@
+export declare function getHome(): string;

package/lib/cjs/utils/get-user-home.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserHome = getUserHome;
+const node_os_1 = __importDefault(require("node:os"));
+const get_home_js_1 = require("./get-home.cjs");
+let $username;
+function getUserHome(username) {
+    $username ??= node_os_1.default.userInfo().username;
+    if (username === $username) {
+        return (0, get_home_js_1.getHome)();
+    }
+    else {
+        return null;
+    }
+}

package/lib/cjs/utils/get-user-home.d.cts

@@ -0,0 +1 @@
+export declare function getUserHome(username: string): string | null;

package/lib/esm/absolute.d.mts

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

package/lib/esm/absolute.mjs

@@ -0,0 +1,3 @@
+export function absolute(nodePath, localPath) {
+    return (...paths) => nodePath.resolve(localPath.resolve(...paths));
+}

package/lib/esm/dir.d.mts

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

package/lib/esm/dir.mjs

@@ -0,0 +1,3 @@
+export function dir(nodePath, _localPath) {
+    return (path) => nodePath.parse(path).dir;
+}

package/lib/esm/index.d.mts

@@ -0,0 +1,47 @@
+import { type PlatformPath } from './types.mjs';
+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";
+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/esm/index.mjs

@@ -0,0 +1,29 @@
+import { DEFAULT_PLATFORM } from './platform.mjs';
+const { absolute, delimiter, extension, isAbsolute, join, leaf, matchesGlob, normalize, parent, isInDir, isInDirs, isSafePath, isSafeSegment, posix, relative, resolve, sanitize, separator, untildify, win32, } = DEFAULT_PLATFORM;
+/* eslint-disable unicorn/prefer-export-from */
+export { absolute, delimiter, extension, isAbsolute, join, leaf, matchesGlob, normalize, parent, isInDir, isInDirs, isSafePath, isSafeSegment, posix, relative, resolve, sanitize, separator, untildify, win32, };
+/* eslint-enable unicorn/prefer-export-from */
+// eslint-disable-next-line import/no-anonymous-default-export
+export 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/esm/is-in-dir.d.mts

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

package/lib/esm/is-in-dir.mjs

@@ -0,0 +1,15 @@
+export 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/esm/is-in-dirs.d.mts

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

package/lib/esm/is-in-dirs.mjs

@@ -0,0 +1,35 @@
+// eslint-disable-next-line unicorn/prevent-abbreviations
+export 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/esm/is-safe-path.d.mts

@@ -0,0 +1,8 @@
+import type path from 'node:path';
+import { type Target } from '@zokugun/fs-path-sanitize';
+import { type PlatformPath } from './types.mjs';
+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/esm/is-safe-path.mjs

@@ -0,0 +1,36 @@
+import os from 'node:os';
+import { isSafePath as isSafe, Sanitizer } from '@zokugun/fs-path-sanitize';
+import { isArray, isString } from '@zokugun/is-it-type';
+export function isSafePath(_nodePath, localPath) {
+    let target;
+    if (localPath.separator === '\\') {
+        target = 'windows.safe';
+    }
+    else {
+        const system = os.platform();
+        target = system === 'darwin' ? 'macos.safe' : 'linux.safe';
+    }
+    const sanitizer = Sanitizer.getInstance(target);
+    return (path, options = {}) => {
+        let parents;
+        if (isString(options.parent)) {
+            parents = [options.parent];
+        }
+        if (isString(options.parents)) {
+            parents = [options.parents];
+        }
+        else if (isArray(options.parents)) {
+            parents = options.parents;
+        }
+        const safe = !options.target || options.target === 'auto' ? sanitizer.isSafePath(path) : isSafe(path, target);
+        if (!safe) {
+            return false;
+        }
+        else if (parents) {
+            return localPath.isInDirs(path, parents);
+        }
+        else {
+            return true;
+        }
+    };
+}

package/lib/esm/is-safe-segment.d.mts

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

package/lib/esm/is-safe-segment.mjs

@@ -0,0 +1,21 @@
+import os from 'node:os';
+import { isSafeSegment as isSafe, Sanitizer } from '@zokugun/fs-path-sanitize';
+export function isSafeSegment(_nodePath, localPath) {
+    let target;
+    if (localPath.separator === '\\') {
+        target = 'windows.safe';
+    }
+    else {
+        const system = os.platform();
+        target = system === 'darwin' ? 'macos.safe' : 'linux.safe';
+    }
+    const sanitizer = Sanitizer.getInstance(target);
+    return (segment, target) => {
+        if (!target || target === 'auto') {
+            return sanitizer.isSafePath(segment);
+        }
+        else {
+            return isSafe(segment, target);
+        }
+    };
+}

package/lib/esm/join.d.mts

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

package/lib/esm/join.mjs

@@ -0,0 +1,11 @@
+export function join(nodePath, _localPath) {
+    return (...paths) => {
+        const joined = nodePath.join(...paths);
+        if (joined === '.') {
+            return '';
+        }
+        else {
+            return joined;
+        }
+    };
+}

package/lib/esm/parent.d.mts

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

package/lib/esm/parent.mjs

@@ -0,0 +1,11 @@
+export function parent(nodePath, _localPath) {
+    return (file) => {
+        const parent = nodePath.dirname(file);
+        if (parent === '.') {
+            return '';
+        }
+        else {
+            return parent;
+        }
+    };
+}

package/lib/esm/platform.d.mts

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

package/lib/esm/platform.mjs

@@ -0,0 +1,61 @@
+import path from 'node:path';
+import { absolute } from './absolute.mjs';
+import { dir } from './dir.mjs';
+import { isInDir } from './is-in-dir.mjs';
+// eslint-disable-next-line unicorn/prevent-abbreviations
+import { isInDirs } from './is-in-dirs.mjs';
+import { isSafePath } from './is-safe-path.mjs';
+import { isSafeSegment } from './is-safe-segment.mjs';
+import { join } from './join.mjs';
+import { parent } from './parent.mjs';
+import { resolve } from './resolve.mjs';
+import { sanitize } from './sanitize.mjs';
+import { untildify } from './untildify.mjs';
+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 = absolute(path, result);
+    result.dir = dir(path, result);
+    result.isInDir = isInDir(path, result);
+    result.isInDirs = isInDirs(path, result);
+    result.isSafePath = isSafePath(path, result);
+    result.isSafeSegment = isSafeSegment(path, result);
+    result.join = join(path, result);
+    result.parent = parent(path, result);
+    result.resolve = resolve(path, result);
+    result.sanitize = sanitize(path, result);
+    result.untildify = untildify(path, result);
+    return result;
+}
+const POSIX_PLATFORM = buildPlatform(path.posix);
+const WIN32_PLATFORM = buildPlatform(path.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,
+    },
+});
+export const DEFAULT_PLATFORM = (path === path.posix ? POSIX_PLATFORM : WIN32_PLATFORM);

package/lib/esm/resolve.d.mts

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

package/lib/esm/resolve.mjs

@@ -0,0 +1,36 @@
+import process from 'node:process';
+import { isString } from '@zokugun/is-it-type';
+import { getHome } from './utils/get-home.mjs';
+import { getUserHome } from './utils/get-user-home.mjs';
+const TILDE_REGEX = /^~(?=$|\/|\\)/;
+const USER_REGEX = /^~([^/\\]+)(.*)$/;
+export function resolve(nodePath, _localPath) {
+    return (...paths) => {
+        if (paths.length === 0) {
+            return process.cwd();
+        }
+        else if (nodePath.isAbsolute(paths[0])) {
+            return nodePath.normalize(nodePath.join(...paths));
+        }
+        else if (TILDE_REGEX.test(paths[0])) {
+            const homedir = getHome();
+            if (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 = getUserHome(username);
+                if (isString(userHome)) {
+                    paths.shift();
+                    return nodePath.normalize(nodePath.join(userHome + rest, ...paths));
+                }
+            }
+        }
+        paths.unshift();
+        return nodePath.normalize(nodePath.join(process.cwd(), ...paths));
+    };
+}

package/lib/esm/sanitize.d.mts

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

package/lib/esm/sanitize.mjs

@@ -0,0 +1,56 @@
+import os from 'node:os';
+import { sanitizePath, Sanitizer } from '@zokugun/fs-path-sanitize';
+import { isArray, isString } from '@zokugun/is-it-type';
+import { err } from '@zokugun/xtry';
+export function sanitize(_nodePath, localPath) {
+    let target;
+    if (localPath.separator === '\\') {
+        target = 'windows.safe';
+    }
+    else {
+        const system = os.platform();
+        target = system === 'darwin' ? 'macos.safe' : 'linux.safe';
+    }
+    const sanitizer = Sanitizer.getInstance(target);
+    return (path, options = {}) => {
+        const resolvedPath = localPath.resolve(path);
+        let parents;
+        if (isString(options.parent)) {
+            parents = [options.parent];
+        }
+        if (isString(options.parents)) {
+            parents = [options.parents];
+        }
+        else if (isArray(options.parents)) {
+            parents = options.parents;
+        }
+        let sanitizedPath;
+        if (!options.target || options.target === 'auto') {
+            sanitizedPath = sanitizer.sanitizePath(resolvedPath, {
+                absolute: true,
+                replacement: options.replacement,
+            });
+        }
+        else {
+            sanitizedPath = sanitizePath(resolvedPath, {
+                absolute: true,
+                replacement: options.replacement,
+                target: options.target,
+            });
+        }
+        if (sanitizedPath.fails) {
+            return sanitizedPath;
+        }
+        if (parents) {
+            if (localPath.isInDirs(sanitizedPath.value, parents)) {
+                return sanitizedPath;
+            }
+            else {
+                return err('Invalid path: not within allowed parents');
+            }
+        }
+        else {
+            return sanitizedPath;
+        }
+    };
+}