nice-path 0.1.1 → 3.0.0

package/dist/index.js

@@ -1,477 +1,393 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __spreadArrays = (this && this.__spreadArrays) || function () {
-    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
-    for (var r = Array(s), k = 0, i = 0; i < il; i++)
-        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
-            r[k] = a[j];
-    return r;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var fs_1 = __importDefault(require("fs"));
-var path_1 = __importDefault(require("path"));
-var util_1 = __importDefault(require("util"));
-var readdirP = util_1.default.promisify(fs_1.default.readdir);
-function aOrAn(nextWord) {
-    return /^[aeiou]/i.test(nextWord) ? "an" : "a";
-}
-function pathKindErrorMessage(expected, actual) {
-    return "Expected to receive " + aOrAn(expected) + " " + expected + " path, but received " + aOrAn(actual) + " " + actual + " path instead";
+exports.Path = void 0;
+const WIN32_DRIVE_LETTER_REGEXP = /^[A-Za-z]:$/;
+function isWin32DriveLetter(pathString) {
+    return WIN32_DRIVE_LETTER_REGEXP.test(pathString);
 }
-function comparisonRootKindMismatchErrorMessage(firstPath, secondPath) {
-    var firstRootKind = detectRootKind(firstPath);
-    var secondRootKind = detectRootKind(secondPath);
-    return ("The two paths being compared are not in the same namespace; " +
-        ("the first path (" + JSON.stringify(firstPath) + ") has root kind " + JSON.stringify(firstRootKind) + " ") +
-        ("but the second path (" + JSON.stringify(secondPath) + ") has root kind ") +
-        ("'" + JSON.stringify(secondRootKind) + "'."));
+function validateSegments(segments, separator) {
+    return segments.filter((part, index) => {
+        // first part can be "" to represent left side of root "/"
+        // second part can be "" to support windows UNC paths
+        if (part === "" && index === 0) {
+            return true;
+        }
+        else if (part === "" &&
+            index === 1 &&
+            separator === "\\" &&
+            segments[0] === "") {
+            return true;
+        }
+        return Boolean(part);
+    });
 }
-function getSeparator(pathString) {
-    var sep = "/";
-    if (!pathString.includes(sep)) {
-        sep = "\\";
-        if (!pathString.includes(sep)) {
-            sep = path_1.default.sep;
+/** An object that represents a filesystem path. */
+class Path {
+    /** Split one or more path strings into an array of path segments. */
+    static splitToSegments(inputParts) {
+        if (!Array.isArray(inputParts)) {
+            inputParts = [inputParts];
         }
+        const separator = Path.detectSeparator(inputParts, "/");
+        return validateSegments(inputParts.map((part) => part.split(/(?:\/|\\)/g)).flat(1), separator);
     }
-    return sep;
-}
-function getSegments(pathString) {
-    var sep = getSeparator(pathString);
-    var segments = pathString.split(sep).filter(Boolean);
-    return segments;
-}
-// Normal path.join always uses path.sep and removes leading . or .. segments,
-// so this is a safer alternative.
-function safeJoin(pathsOrSegments, sep) {
-    var trimmedSegments = pathsOrSegments.map(function (pathOrSegment, pathOrSegmentIndex) {
-        return pathOrSegment
-            .split(sep)
-            .filter(function (segment) {
-            if (pathOrSegmentIndex === 0) {
-                return true;
+    /**
+     * Search the provided path string or strings for a path separator character
+     * (either forward slash or backslash), and return it. If none is found,
+     * return `fallback`.
+     */
+    static detectSeparator(input, fallback) {
+        let testStr = input;
+        if (Array.isArray(input)) {
+            testStr = input.join("|");
+        }
+        for (const char of testStr) {
+            if (char === "/") {
+                return "/";
             }
-            else {
-                return Boolean(segment);
+            else if (char === "\\") {
+                return "\\";
             }
-        })
-            .join(sep);
-    });
-    return trimmedSegments.join(sep);
-}
-function detectPathKind(pathString) {
-    var sep = getSeparator(pathString);
-    var segments = getSegments(pathString);
-    if (pathString.startsWith(sep) ||
-        pathString.startsWith("\\\\") ||
-        pathString.match(/^[A-Z]:/i)) {
-        return "absolute";
-    }
-    else if (segments[0] === "." || segments[0] === "..") {
-        return "relative";
+        }
+        return fallback;
     }
-    else {
-        return "unqualified";
+    /**
+     * Concatenates the input path(s) and then resolves all non-leading `.` and
+     * `..` segments.
+     */
+    static normalize(...inputs) {
+        return new Path(...inputs).normalize();
     }
-}
-function detectRootKind(pathString) {
-    var sep = getSeparator(pathString);
-    if (pathString.match(/^[A-Z]:/i)) {
-        return "letter-drive";
+    /**
+     * Return whether the provided path is absolute; that is, whether it
+     * starts with either `/`, `\`, or a drive letter (ie `C:`).
+     */
+    static isAbsolute(path) {
+        if (path instanceof Path) {
+            return path.isAbsolute();
+        }
+        else {
+            return new Path(path).isAbsolute();
+        }
     }
-    else if (pathString.startsWith("\\\\")) {
-        return "unc";
+    /** Create a new Path object using the provided input(s). */
+    constructor(...inputs) {
+        const parts = inputs
+            .flat(1)
+            .map((part) => (typeof part === "string" ? part : part.segments))
+            .flat(1);
+        this.segments = Path.splitToSegments(parts);
+        this.separator = Path.detectSeparator(parts, "/");
     }
-    else if (pathString.startsWith(sep)) {
-        return "leading-slash";
+    /**
+     * Create a new Path object using the provided segments and, optionally,
+     * separator.
+     *
+     * NOTE: this doesn't set the `segments` directly; it passes them through a
+     * filtering step first, to remove any double-slashes or etc. To set the
+     * `.segments` directly, use {@link fromRaw}.
+     */
+    static from(segments, separator) {
+        const separatorToUse = separator || Path.detectSeparator(segments, "/");
+        const path = new Path();
+        path.segments = validateSegments(segments, separatorToUse);
+        path.separator = separatorToUse;
+        return path;
     }
-    else {
-        throw new Error("Unable to detect root kind from path string: '" + pathString + "'. Is it an absolute path?");
+    /**
+     * Create a new Path object using the provided segments and separator.
+     *
+     * NOTE: this method doesn't do any sort of validation on `segments`; as such,
+     * it can be used to construct an invalid Path object. Consider using
+     * {@link from} instead.
+     */
+    static fromRaw(segments, separator) {
+        const path = new Path();
+        path.segments = segments;
+        path.separator = separator;
+        return path;
     }
-}
-function reconsistuteAbsolutePath(originalRaw, newSegments) {
-    var sep = getSeparator(originalRaw);
-    var rootKind = detectRootKind(originalRaw);
-    var suffix = safeJoin(newSegments, sep);
-    var prefix = "";
-    switch (rootKind) {
-        case "leading-slash": {
-            prefix = sep;
-            break;
-        }
-        case "unc": {
-            prefix = sep.repeat(2);
-            break;
+    /**
+     * Resolve all non-leading `.` and `..` segments in this path.
+     */
+    normalize() {
+        // we clone this cause we're gonna mutate it
+        const segments = [...this.segments];
+        const newSegments = [];
+        let currentSegment;
+        while (segments.length > 0) {
+            currentSegment = segments.shift();
+            switch (currentSegment) {
+                case ".": {
+                    if (newSegments.length === 0) {
+                        newSegments.push(currentSegment);
+                    }
+                    break;
+                }
+                case "..": {
+                    if (newSegments.length === 0) {
+                        newSegments.push(currentSegment);
+                    }
+                    else {
+                        newSegments.pop();
+                    }
+                    break;
+                }
+                default: {
+                    if (currentSegment != null) {
+                        newSegments.push(currentSegment);
+                    }
+                    break;
+                }
+            }
         }
+        return Path.fromRaw(newSegments, this.separator);
     }
-    return prefix + suffix;
-}
-var Path = /** @class */ (function () {
-    function Path(raw, kind) {
-        this.raw = raw;
-        this.kind = kind;
+    /**
+     * Create a new Path by appending additional path segments onto the end of
+     * this Path's segments.
+     *
+     * The returned path will use this path's separator.
+     */
+    concat(...others) {
+        const otherSegments = new Path(others.flat(1)).segments;
+        return Path.from(this.segments.concat(otherSegments), this.separator);
     }
-    Path.prototype.toString = function () {
-        return this.raw;
-    };
-    Path.fromAbsolutePathString = function (absolutePath) {
-        var kind = detectPathKind(absolutePath);
-        if (kind !== "absolute") {
-            throw new Error(pathKindErrorMessage("absolute", kind));
-        }
-        return new AbsolutePath(absolutePath);
-    };
-    Path.fromRelativePathString = function (relativePath) {
-        var kind = detectPathKind(relativePath);
-        if (kind !== "relative") {
-            throw new Error(pathKindErrorMessage("relative", kind));
+    /**
+     * Return whether this path is absolute; that is, whether it starts with
+     * either `/`, `\`, or a drive letter (ie `C:`).
+     */
+    isAbsolute() {
+        const firstPart = this.segments[0];
+        // empty first component indicates that path starts with leading slash.
+        // could be unix fs root, or windows unc path
+        if (firstPart === "")
+            return true;
+        // windows drive
+        if (/^[A-Za-z]:/.test(firstPart))
+            return true;
+        return false;
+    }
+    /**
+     * Make a second Path object containing the same segments and separator as
+     * this one.
+     */
+    clone() {
+        const theClone = this.constructor.fromRaw([...this.segments], this.separator);
+        return theClone;
+    }
+    /**
+     * Express this path relative to `dir`.
+     *
+     * @param dir - The directory to create a new path relative to.
+     * @param options - Options that affect the resulting path.
+     */
+    relativeTo(dir, options = {}) {
+        if (!(dir instanceof Path)) {
+            dir = new Path(dir);
         }
-        return new RelativePath(relativePath);
-    };
-    Path.fromUnqualifiedPathString = function (unqualifiedPath) {
-        var kind = detectPathKind(unqualifiedPath);
-        if (kind !== "unqualified") {
-            throw new Error(pathKindErrorMessage("unqualified", kind));
+        const ownSegments = [...this.segments];
+        const dirSegments = [...dir.segments];
+        while (ownSegments[0] === dirSegments[0]) {
+            ownSegments.shift();
+            dirSegments.shift();
         }
-        return new UnqualifiedPath(unqualifiedPath);
-    };
-    Path.from = function (raw) {
-        var kind = detectPathKind(raw);
-        switch (kind) {
-            case "absolute":
-                return new AbsolutePath(raw);
-            case "relative":
-                return new RelativePath(raw);
-            case "unqualified":
-                return new UnqualifiedPath(raw);
-            default: {
-                throw new Error("Unable to detect path type from input string");
+        if (dirSegments.length === 0) {
+            if (options.noLeadingDot) {
+                return Path.from(ownSegments, this.separator);
+            }
+            else {
+                return Path.from([".", ...ownSegments], this.separator);
             }
-        }
-    };
-    Path.prototype.isAbsolute = function () {
-        return this.kind === "absolute";
-    };
-    Path.prototype.isRelative = function () {
-        return this.kind === "relative";
-    };
-    Path.prototype.isUnqualified = function () {
-        return this.kind === "unqualified";
-    };
-    Path.prototype.hasTrailingSlash = function () {
-        var sep = getSeparator(this.raw);
-        return this.raw.endsWith(sep);
-    };
-    Path.prototype.removeTrailingSlash = function () {
-        if (!this.hasTrailingSlash()) {
-            return this;
         }
         else {
-            return new Path(this.raw.replace(/(?:[/\\])+$/, ""), this.kind);
+            const dotDots = dirSegments.map((_) => "..");
+            return Path.from([...dotDots, ...ownSegments], this.separator);
         }
-    };
-    Path.prototype.append = function () {
-        var segments = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            segments[_i] = arguments[_i];
+    }
+    /**
+     * Turn this path into a string by joining its segments using its separator.
+     */
+    toString() {
+        let result = this.segments.join(this.separator);
+        if (result == "") {
+            return "/";
         }
-        var sep = getSeparator(this.raw);
-        return new Path(safeJoin(__spreadArrays([this.raw], segments), sep), this.kind);
-    };
-    Path.prototype.resolve = function () {
-        var segments = getSegments(this.raw);
-        var nextSegments = [];
-        for (var i = 0; i < segments.length; i++) {
-            var currentSegment = segments[i];
-            if (currentSegment === "." && i !== 0) {
-                continue;
-            }
-            else if (currentSegment === ".." && nextSegments.length > 0) {
-                nextSegments.pop();
+        else {
+            if (isWin32DriveLetter(result)) {
+                return result + this.separator;
             }
             else {
-                nextSegments.push(currentSegment);
+                return result;
             }
         }
-        var nextRaw = reconsistuteAbsolutePath(this.raw, nextSegments);
-        return new Path(nextRaw, this.kind);
-    };
-    return Path;
-}());
-exports.Path = Path;
-var AbsolutePath = /** @class */ (function (_super) {
-    __extends(AbsolutePath, _super);
-    function AbsolutePath(raw) {
-        return _super.call(this, raw, "absolute") || this;
     }
-    AbsolutePath.prototype.relativeTo = function (relativeTo) {
-        if (typeof relativeTo === "string") {
-            var pathKind = detectPathKind(relativeTo);
-            if (pathKind !== "absolute") {
-                throw new Error(pathKindErrorMessage("absolute", pathKind));
-            }
-        }
-        var relativeToString = typeof relativeTo === "string" ? relativeTo : relativeTo.raw;
-        var thisRootKind = detectRootKind(this.raw);
-        var relativeToRootKind = detectRootKind(relativeToString);
-        if (thisRootKind !== relativeToRootKind) {
-            throw new Error(comparisonRootKindMismatchErrorMessage(this.raw, relativeToString));
+    /**
+     * Return the final path segment of this path. If this path has no path
+     * segments, the empty string is returned.
+     */
+    basename() {
+        const last = this.segments[this.segments.length - 1];
+        return last || "";
+    }
+    /**
+     * Return the trailing extension of this path. Set option `full` to `true` to
+     * get a compound extension like ".d.ts" instead of ".ts".
+     */
+    extname(options = {}) {
+        const filename = this.basename();
+        const parts = filename.split(".");
+        if (parts.length === 1) {
+            return "";
         }
-        if (thisRootKind === "letter-drive" &&
-            relativeToRootKind === "letter-drive" &&
-            this.raw.slice(0, 1).toUpperCase() !==
-                relativeToString.slice(0, 1).toUpperCase()) {
-            throw new Error("The two paths being compared are not on the same drive; comparing " +
-                JSON.stringify(this.raw) +
-                " and " +
-                JSON.stringify(relativeToString));
+        if (options.full) {
+            return "." + parts.slice(1).join(".");
         }
-        var thisSegments = getSegments(this.raw);
-        var relativeToSegments = getSegments(relativeToString);
-        if (thisRootKind === "unc" &&
-            relativeToRootKind === "unc" &&
-            thisSegments[0] !== relativeToSegments[0]) {
-            throw new Error("The two paths being compared are not on the same UNC host; comparing " +
-                JSON.stringify(this.raw) +
-                " and " +
-                JSON.stringify(relativeToString));
+        else {
+            return "." + parts[parts.length - 1];
         }
-        var longerLength = Math.max(thisSegments.length, relativeToSegments.length);
-        var lastSharedSegmentIndex = -1;
-        for (var i = 0; i < longerLength; i++) {
-            var thisSegment = thisSegments[i];
-            var relativeToSegment = relativeToSegments[i];
-            if (thisSegment === relativeToSegment) {
-                lastSharedSegmentIndex = i;
-            }
-            else {
-                break;
+    }
+    /**
+     * Return a new Path containing all of the path segments in this one except
+     * for the last one; ie. the path to the directory that contains this path.
+     */
+    dirname() {
+        return this.replaceLast([]);
+    }
+    /**
+     * Return whether this path starts with the provided value, by comparing one
+     * path segment at a time.
+     *
+     * The starting segments of this path must *exactly* match the segments in the
+     * provided value.
+     *
+     * This means that, given two Paths A and B:
+     *
+     * ```
+     *   A: Path { /home/user/.config }
+     *   B: Path { /home/user/.config2 }
+     * ```
+     *
+     * Path B does *not* start with Path A, because `".config" !== ".config2"`.
+     */
+    startsWith(value) {
+        value = new Path(value);
+        return value.segments.every((segment, index) => this.segments[index] === segment);
+    }
+    /**
+     * Return whether this path ends with the provided value, by comparing one
+     * path segment at a time.
+     *
+     * The ending segments of this path must *exactly* match the segments in the
+     * provided value.
+     *
+     * This means that, given two Paths A and B:
+     *
+     * ```
+     *   A: Path { /home/1user/.config }
+     *   B: Path { user/.config }
+     * ```
+     *
+     * Path A does *not* end with Path B, because `"1user" !== "user"`.
+     */
+    endsWith(value) {
+        value = new Path(value);
+        const valueSegmentsReversed = [...value.segments].reverse();
+        const ownSegmentsReversed = [...this.segments].reverse();
+        return valueSegmentsReversed.every((segment, index) => ownSegmentsReversed[index] === segment);
+    }
+    /**
+     * Return the path segment index at which `value` appears in this path, or
+     * `-1` if it doesn't appear in this path.
+     *
+     * @param value - The value to search for. If the value contains more than one path segment, the returned index will refer to the location of the value's first path segment.
+     * @param fromIndex - The index into this path's segments to begin searching at. Defaults to `0`.
+     */
+    indexOf(value, fromIndex = 0) {
+        value = new Path(value);
+        const ownSegmentsLength = this.segments.length;
+        for (let i = fromIndex; i < ownSegmentsLength; i++) {
+            if (value.segments.every((valueSegment, valueIndex) => {
+                return this.segments[i + valueIndex] === valueSegment;
+            })) {
+                return i;
             }
         }
-        var nextSegments = [];
-        if (lastSharedSegmentIndex === -1) {
-            // No shared commonality between the paths
-            nextSegments = relativeToSegments.map(function () { return ".."; });
-            nextSegments.push.apply(nextSegments, thisSegments);
+        return -1;
+    }
+    /**
+     * Return whether `value` appears in this path.
+     *
+     * @param value - The value to search for.
+     * @param fromIndex - The index into this path's segments to begin searching at. Defaults to `0`.
+     */
+    includes(value, fromIndex = 0) {
+        return this.indexOf(value, fromIndex) !== -1;
+    }
+    /**
+     * Return a new Path wherein the segments in `value` have been replaced with
+     * the segments in `replacement`. If the segments in `value` are not present
+     * in this path, a clone of this path is returned.
+     *
+     * Note that only the first match is replaced.
+     *
+     * @param value - What should be replaced
+     * @param replacement - What it should be replaced with
+     *
+     * NOTE: to remove segments, use an empty Array for `replacement`.
+     */
+    replace(value, replacement) {
+        value = new Path(value);
+        replacement = new Path(replacement);
+        const matchIndex = this.indexOf(value);
+        if (matchIndex === -1) {
+            return this.clone();
         }
         else {
-            var remainingThisSegments = [];
-            for (var i = 0; i < thisSegments.length; i++) {
-                if (i > lastSharedSegmentIndex) {
-                    remainingThisSegments.push(thisSegments[i]);
-                }
-            }
-            var remainingRelativeToSegments = [];
-            for (var i = 0; i < relativeToSegments.length; i++) {
-                if (i > lastSharedSegmentIndex) {
-                    remainingRelativeToSegments.push(thisSegments[i]);
-                }
-            }
-            nextSegments.push.apply(nextSegments, __spreadArrays(remainingRelativeToSegments.map(function () { return ".."; }), remainingThisSegments));
-        }
-        if (nextSegments[0] !== "..") {
-            nextSegments = __spreadArrays(["."], nextSegments);
+            const newSegments = [
+                ...this.segments.slice(0, matchIndex),
+                ...replacement.segments,
+                ...this.segments.slice(matchIndex + value.segments.length),
+            ];
+            return Path.from(newSegments, this.separator);
         }
-        var sep = getSeparator(this.raw);
-        var raw = safeJoin(nextSegments, sep);
-        return new RelativePath(raw);
-    };
-    AbsolutePath.prototype.append = function () {
-        var segments = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            segments[_i] = arguments[_i];
-        }
-        var normalPath = _super.prototype.append.apply(this, segments);
-        return new AbsolutePath(normalPath.raw);
-    };
-    AbsolutePath.prototype.removeTrailingSlash = function () {
-        var normalPath = _super.prototype.removeTrailingSlash.call(this);
-        return new AbsolutePath(normalPath.raw);
-    };
-    AbsolutePath.prototype.resolve = function () {
-        var normalPath = _super.prototype.resolve.call(this);
-        return new AbsolutePath(normalPath.raw);
-    };
-    AbsolutePath.prototype.readdir = function (options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var dirs;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, readdirP(this.raw, options)];
-                    case 1:
-                        dirs = _a.sent();
-                        // @ts-ignore
-                        return [2 /*return*/, dirs.map(function (dir) {
-                                return new AbsolutePath(path_1.default.join(_this.raw, dir.toString("utf-8")));
-                            })];
-                }
-            });
-        });
-    };
-    AbsolutePath.prototype.readdirSync = function (options) {
-        var _this = this;
-        var dirs = fs_1.default.readdirSync(this.raw, options);
-        // @ts-ignore
-        return dirs.map(function (dir) {
-            return new AbsolutePath(path_1.default.join(_this.raw, dir.toString("utf-8")));
-        });
-    };
-    AbsolutePath.prototype.parentDirectory = function () {
-        var segments = getSegments(this.raw);
-        var nextSegments = segments.slice(0, -1);
-        var nextRaw = reconsistuteAbsolutePath(this.raw, nextSegments);
-        return new AbsolutePath(nextRaw);
-    };
-    return AbsolutePath;
-}(Path));
-exports.AbsolutePath = AbsolutePath;
-var RelativePath = /** @class */ (function (_super) {
-    __extends(RelativePath, _super);
-    function RelativePath(raw) {
-        return _super.call(this, raw, "relative") || this;
     }
-    RelativePath.prototype.toAbsolute = function (contextDir) {
-        var contextDirPath = typeof contextDir === "string"
-            ? Path.fromAbsolutePathString(contextDir)
-            : contextDir;
-        var thisSegments = getSegments(this.raw);
-        var nextSegments = __spreadArrays([
-            contextDirPath.removeTrailingSlash().raw
-        ], thisSegments);
-        return new AbsolutePath(safeJoin(nextSegments, getSeparator(contextDirPath.raw))).resolve();
-    };
-    RelativePath.prototype.toUnqualified = function () {
-        var segments = getSegments(this.raw);
-        var sep = getSeparator(this.raw);
-        var firstNonRelativeSegmentIndex = 0;
-        for (var _i = 0, segments_1 = segments; _i < segments_1.length; _i++) {
-            var segment = segments_1[_i];
-            if (segment === "." || segment === "..") {
-                firstNonRelativeSegmentIndex++;
+    /**
+     * Return a new Path wherein all occurrences of the segments in `value` have
+     * been replaced with the segments in `replacement`. If the segments in
+     * `value` are not present in this path, a clone of this path is returned.
+     *
+     * @param value - What should be replaced
+     * @param replacement - What it should be replaced with
+     */
+    replaceAll(value, replacement) {
+        replacement = new Path(replacement);
+        let searchIndex = 0;
+        let currentPath = this;
+        const ownLength = this.segments.length;
+        while (searchIndex < ownLength) {
+            const matchingIndex = this.indexOf(value, searchIndex);
+            if (matchingIndex === -1) {
+                break;
             }
             else {
-                break;
+                currentPath = currentPath.replace(value, replacement);
+                searchIndex = matchingIndex + replacement.segments.length;
             }
         }
-        var unqualifiedSegments = segments.slice(firstNonRelativeSegmentIndex);
-        var newRaw = safeJoin(unqualifiedSegments, sep);
-        return new UnqualifiedPath(newRaw);
-    };
-    RelativePath.prototype.append = function () {
-        var segments = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            segments[_i] = arguments[_i];
-        }
-        var normalPath = _super.prototype.append.apply(this, segments);
-        return new RelativePath(normalPath.raw);
-    };
-    RelativePath.prototype.removeTrailingSlash = function () {
-        var normalPath = _super.prototype.removeTrailingSlash.call(this);
-        return new RelativePath(normalPath.raw);
-    };
-    RelativePath.prototype.resolve = function () {
-        var normalPath = _super.prototype.resolve.call(this);
-        return new RelativePath(normalPath.raw);
-    };
-    return RelativePath;
-}(Path));
-exports.RelativePath = RelativePath;
-var UnqualifiedPath = /** @class */ (function (_super) {
-    __extends(UnqualifiedPath, _super);
-    function UnqualifiedPath(raw) {
-        return _super.call(this, raw, "unqualified") || this;
+        return currentPath;
     }
-    UnqualifiedPath.prototype.toAbsolute = function (contextDir) {
-        var contextDirPath = typeof contextDir === "string"
-            ? Path.fromAbsolutePathString(contextDir)
-            : contextDir;
-        var thisSegments = getSegments(this.raw);
-        var nextSegments = __spreadArrays([
-            contextDirPath.removeTrailingSlash().raw
-        ], thisSegments);
-        return new AbsolutePath(safeJoin(nextSegments, getSeparator(contextDirPath.raw))).resolve();
-    };
-    UnqualifiedPath.prototype.append = function () {
-        var segments = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            segments[_i] = arguments[_i];
-        }
-        var normalPath = _super.prototype.append.apply(this, segments);
-        return new UnqualifiedPath(normalPath.raw);
-    };
-    UnqualifiedPath.prototype.prepend = function () {
-        var segments = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            segments[_i] = arguments[_i];
-        }
-        var sep = getSeparator(this.raw);
-        return new UnqualifiedPath(safeJoin(__spreadArrays(segments, [this.raw]), sep));
-    };
-    UnqualifiedPath.prototype.removeTrailingSlash = function () {
-        var normalPath = _super.prototype.removeTrailingSlash.call(this);
-        return new UnqualifiedPath(normalPath.raw);
-    };
-    UnqualifiedPath.prototype.resolve = function () {
-        var normalPath = _super.prototype.resolve.call(this);
-        return new UnqualifiedPath(normalPath.raw);
-    };
-    return UnqualifiedPath;
-}(Path));
-exports.UnqualifiedPath = UnqualifiedPath;
-module.exports = Path;
-module.exports.Path = Path;
-module.exports.AbsolutePath = AbsolutePath;
-module.exports.RelativePath = RelativePath;
-module.exports.UnqualifiedPath = UnqualifiedPath;
+    /**
+     * Return a copy of this path but with the final segment replaced with `replacement`
+     *
+     * @param replacement - The new final segment(s) for the returned Path
+     */
+    replaceLast(replacement) {
+        replacement = new Path(replacement);
+        const segments = [...this.segments];
+        segments.pop();
+        segments.push(...replacement.segments);
+        return Path.from(segments, this.separator);
+    }
+}
+exports.Path = Path;