Skip to main content
Deno 2 is finally here 🎉️
Learn more
Module

std/path/posix.ts

Deno standard library
Go to Latest
The Standard Library has been moved to JSR. See the blog post for details.
File
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.// Copyright the Browserify authors. MIT License.// Ported from https://github.com/browserify/path-browserify/// This module is browser compatible.
import type { FormatInputPathObject, ParsedPath } from "./_interface.ts";import { CHAR_DOT } from "./_constants.ts";
import { _format, assertPath, encodeWhitespace, isPosixPathSeparator, lastPathSegment, normalizeString, stripSuffix, stripTrailingSeparators,} from "./_util.ts";
export const sep = "/";export const delimiter = ":";
// path.resolve([from ...], to)/** * Resolves `pathSegments` into an absolute path. * @param pathSegments an array of path segments */export function resolve(...pathSegments: string[]): string { let resolvedPath = ""; let resolvedAbsolute = false;
for (let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--) { let path: string;
if (i >= 0) path = pathSegments[i]; else { // deno-lint-ignore no-explicit-any const { Deno } = globalThis as any; if (typeof Deno?.cwd !== "function") { throw new TypeError("Resolved a relative path without a CWD."); } path = Deno.cwd(); }
assertPath(path);
// Skip empty entries if (path.length === 0) { continue; }
resolvedPath = `${path}/${resolvedPath}`; resolvedAbsolute = isPosixPathSeparator(path.charCodeAt(0)); }
// At this point the path should be resolved to a full absolute path, but // handle relative paths to be safe (might happen when process.cwd() fails)
// Normalize the path resolvedPath = normalizeString( resolvedPath, !resolvedAbsolute, "/", isPosixPathSeparator, );
if (resolvedAbsolute) { if (resolvedPath.length > 0) return `/${resolvedPath}`; else return "/"; } else if (resolvedPath.length > 0) return resolvedPath; else return ".";}
/** * Normalize the `path`, resolving `'..'` and `'.'` segments. * Note that resolving these segments does not necessarily mean that all will be eliminated. * A `'..'` at the top-level will be preserved, and an empty path is canonically `'.'`. * @param path to be normalized */export function normalize(path: string): string { assertPath(path);
if (path.length === 0) return ".";
const isAbsolute = isPosixPathSeparator(path.charCodeAt(0)); const trailingSeparator = isPosixPathSeparator( path.charCodeAt(path.length - 1), );
// Normalize the path path = normalizeString(path, !isAbsolute, "/", isPosixPathSeparator);
if (path.length === 0 && !isAbsolute) path = "."; if (path.length > 0 && trailingSeparator) path += "/";
if (isAbsolute) return `/${path}`; return path;}
/** * Verifies whether provided path is absolute * @param path to be verified as absolute */export function isAbsolute(path: string): boolean { assertPath(path); return path.length > 0 && isPosixPathSeparator(path.charCodeAt(0));}
/** * Join all given a sequence of `paths`,then normalizes the resulting path. * @param paths to be joined and normalized */export function join(...paths: string[]): string { if (paths.length === 0) return "."; let joined: string | undefined; for (let i = 0, len = paths.length; i < len; ++i) { const path = paths[i]; assertPath(path); if (path.length > 0) { if (!joined) joined = path; else joined += `/${path}`; } } if (!joined) return "."; return normalize(joined);}
/** * Return the relative path from `from` to `to` based on current working directory. * @param from path in current working directory * @param to path in current working directory */export function relative(from: string, to: string): string { assertPath(from); assertPath(to);
if (from === to) return "";
from = resolve(from); to = resolve(to);
if (from === to) return "";
// Trim any leading backslashes let fromStart = 1; const fromEnd = from.length; for (; fromStart < fromEnd; ++fromStart) { if (!isPosixPathSeparator(from.charCodeAt(fromStart))) break; } const fromLen = fromEnd - fromStart;
// Trim any leading backslashes let toStart = 1; const toEnd = to.length; for (; toStart < toEnd; ++toStart) { if (!isPosixPathSeparator(to.charCodeAt(toStart))) break; } const toLen = toEnd - toStart;
// Compare paths to find the longest common path from root const length = fromLen < toLen ? fromLen : toLen; let lastCommonSep = -1; let i = 0; for (; i <= length; ++i) { if (i === length) { if (toLen > length) { if (isPosixPathSeparator(to.charCodeAt(toStart + i))) { // We get here if `from` is the exact base path for `to`. // For example: from='/foo/bar'; to='/foo/bar/baz' return to.slice(toStart + i + 1); } else if (i === 0) { // We get here if `from` is the root // For example: from='/'; to='/foo' return to.slice(toStart + i); } } else if (fromLen > length) { if (isPosixPathSeparator(from.charCodeAt(fromStart + i))) { // We get here if `to` is the exact base path for `from`. // For example: from='/foo/bar/baz'; to='/foo/bar' lastCommonSep = i; } else if (i === 0) { // We get here if `to` is the root. // For example: from='/foo'; to='/' lastCommonSep = 0; } } break; } const fromCode = from.charCodeAt(fromStart + i); const toCode = to.charCodeAt(toStart + i); if (fromCode !== toCode) break; else if (isPosixPathSeparator(fromCode)) lastCommonSep = i; }
let out = ""; // Generate the relative path based on the path difference between `to` // and `from` for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) { if (i === fromEnd || isPosixPathSeparator(from.charCodeAt(i))) { if (out.length === 0) out += ".."; else out += "/.."; } }
// Lastly, append the rest of the destination (`to`) path that comes after // the common path parts if (out.length > 0) return out + to.slice(toStart + lastCommonSep); else { toStart += lastCommonSep; if (isPosixPathSeparator(to.charCodeAt(toStart))) ++toStart; return to.slice(toStart); }}
/** * Resolves path to a namespace path * @param path to resolve to namespace */export function toNamespacedPath(path: string): string { // Non-op on posix systems return path;}
/** * Return the directory path of a `path`. * @param path - path to extract the directory from. */export function dirname(path: string): string { if (path.length === 0) return ".";
let end = -1; let matchedNonSeparator = false;
for (let i = path.length - 1; i >= 1; --i) { if (isPosixPathSeparator(path.charCodeAt(i))) { if (matchedNonSeparator) { end = i; break; } } else { matchedNonSeparator = true; } }
// No matches. Fallback based on provided path: // // - leading slashes paths // "/foo" => "/" // "///foo" => "/" // - no slash path // "foo" => "." if (end === -1) { return isPosixPathSeparator(path.charCodeAt(0)) ? "/" : "."; }
return stripTrailingSeparators( path.slice(0, end), isPosixPathSeparator, );}
/** * Return the last portion of a `path`. * Trailing directory separators are ignored, and optional suffix is removed. * * @param path - path to extract the name from. * @param [suffix] - suffix to remove from extracted name. */export function basename(path: string, suffix = ""): string { assertPath(path);
if (path.length === 0) return path;
if (typeof suffix !== "string") { throw new TypeError( `Suffix must be a string. Received ${JSON.stringify(suffix)}`, ); }
const lastSegment = lastPathSegment(path, isPosixPathSeparator); const strippedSegment = stripTrailingSeparators( lastSegment, isPosixPathSeparator, ); return suffix ? stripSuffix(strippedSegment, suffix) : strippedSegment;}
/** * Return the extension of the `path` with leading period. * @param path with extension * @returns extension (ex. for `file.ts` returns `.ts`) */export function extname(path: string): string { assertPath(path); let startDot = -1; let startPart = 0; let end = -1; let matchedSlash = true; // Track the state of characters (if any) we see before our first dot and // after any path separator we find let preDotState = 0; for (let i = path.length - 1; i >= 0; --i) { const code = path.charCodeAt(i); if (isPosixPathSeparator(code)) { // If we reached a path separator that was not part of a set of path // separators at the end of the string, stop now if (!matchedSlash) { startPart = i + 1; break; } continue; } if (end === -1) { // We saw the first non-path separator, mark this as the end of our // extension matchedSlash = false; end = i + 1; } if (code === CHAR_DOT) { // If this is our first dot, mark it as the start of our extension if (startDot === -1) startDot = i; else if (preDotState !== 1) preDotState = 1; } else if (startDot !== -1) { // We saw a non-dot and non-path separator before our dot, so we should // have a good chance at having a non-empty extension preDotState = -1; } }
if ( startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot preDotState === 0 || // The (right-most) trimmed path component is exactly '..' (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) ) { return ""; } return path.slice(startDot, end);}
/** * Generate a path from `FormatInputPathObject` object. * @param pathObject with path */export function format(pathObject: FormatInputPathObject): string { if (pathObject === null || typeof pathObject !== "object") { throw new TypeError( `The "pathObject" argument must be of type Object. Received type ${typeof pathObject}`, ); } return _format("/", pathObject);}
/** * Return a `ParsedPath` object of the `path`. * @param path to process */export function parse(path: string): ParsedPath { assertPath(path);
const ret: ParsedPath = { root: "", dir: "", base: "", ext: "", name: "" }; if (path.length === 0) return ret; const isAbsolute = isPosixPathSeparator(path.charCodeAt(0)); let start: number; if (isAbsolute) { ret.root = "/"; start = 1; } else { start = 0; } let startDot = -1; let startPart = 0; let end = -1; let matchedSlash = true; let i = path.length - 1;
// Track the state of characters (if any) we see before our first dot and // after any path separator we find let preDotState = 0;
// Get non-dir info for (; i >= start; --i) { const code = path.charCodeAt(i); if (isPosixPathSeparator(code)) { // If we reached a path separator that was not part of a set of path // separators at the end of the string, stop now if (!matchedSlash) { startPart = i + 1; break; } continue; } if (end === -1) { // We saw the first non-path separator, mark this as the end of our // extension matchedSlash = false; end = i + 1; } if (code === CHAR_DOT) { // If this is our first dot, mark it as the start of our extension if (startDot === -1) startDot = i; else if (preDotState !== 1) preDotState = 1; } else if (startDot !== -1) { // We saw a non-dot and non-path separator before our dot, so we should // have a good chance at having a non-empty extension preDotState = -1; } }
if ( startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot preDotState === 0 || // The (right-most) trimmed path component is exactly '..' (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) ) { if (end !== -1) { if (startPart === 0 && isAbsolute) { ret.base = ret.name = path.slice(1, end); } else { ret.base = ret.name = path.slice(startPart, end); } } // Fallback to '/' in case there is no basename ret.base = ret.base || "/"; } else { if (startPart === 0 && isAbsolute) { ret.name = path.slice(1, startDot); ret.base = path.slice(1, end); } else { ret.name = path.slice(startPart, startDot); ret.base = path.slice(startPart, end); } ret.ext = path.slice(startDot, end); }
if (startPart > 0) { ret.dir = stripTrailingSeparators( path.slice(0, startPart - 1), isPosixPathSeparator, ); } else if (isAbsolute) ret.dir = "/";
return ret;}
/** * Converts a file URL to a path string. * * ```ts * import { fromFileUrl } from "https://deno.land/std@$STD_VERSION/path/posix.ts"; * fromFileUrl("file:///home/foo"); // "/home/foo" * ``` * @param url of a file URL */export function fromFileUrl(url: string | URL): string { url = url instanceof URL ? url : new URL(url); if (url.protocol != "file:") { throw new TypeError("Must be a file URL."); } return decodeURIComponent( url.pathname.replace(/%(?![0-9A-Fa-f]{2})/g, "%25"), );}
/** * Converts a path string to a file URL. * * ```ts * import { toFileUrl } from "https://deno.land/std@$STD_VERSION/path/posix.ts"; * toFileUrl("/home/foo"); // new URL("file:///home/foo") * ``` * @param path to convert to file URL */export function toFileUrl(path: string): URL { if (!isAbsolute(path)) { throw new TypeError("Must be an absolute path."); } const url = new URL("file:///"); url.pathname = encodeWhitespace( path.replace(/%/g, "%25").replace(/\\/g, "%5C"), ); return url;}