source: frontend/node_modules/enhanced-resolve/lib/util/path.js

/*
        MIT License http://www.opensource.org/licenses/mit-license.php
        Author Tobias Koppers @sokra
*/

"use strict";

const path = require("path");

const CHAR_HASH = "#".charCodeAt(0);
const CHAR_SLASH = "/".charCodeAt(0);
const CHAR_BACKSLASH = "\\".charCodeAt(0);
const CHAR_A = "A".charCodeAt(0);
const CHAR_Z = "Z".charCodeAt(0);
const CHAR_LOWER_A = "a".charCodeAt(0);
const CHAR_LOWER_Z = "z".charCodeAt(0);
const CHAR_DOT = ".".charCodeAt(0);
const CHAR_COLON = ":".charCodeAt(0);
const CHAR_QUESTION = "?".charCodeAt(0);

const posixNormalize = path.posix.normalize;
const winNormalize = path.win32.normalize;

/**
 * @enum {number}
 */
const PathType = Object.freeze({
        Empty: 0,
        Normal: 1,
        Relative: 2,
        AbsoluteWin: 3,
        AbsolutePosix: 4,
        Internal: 5,
});

const deprecatedInvalidSegmentRegEx =
        /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))(\\|\/|$)/i;

const invalidSegmentRegEx =
        /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))?(\\|\/|$)/i;

/**
 * @param {string} maybePath a path known to start with `\\`
 * @returns {PathType} AbsoluteWin for `\\?\…` / `\\.\…`, otherwise Normal
 */
const getDosDeviceType = (maybePath) => {
        if (maybePath.length >= 4 && maybePath.charCodeAt(3) === CHAR_BACKSLASH) {
                const c2 = maybePath.charCodeAt(2);
                if (c2 === CHAR_QUESTION || c2 === CHAR_DOT) {
                        return PathType.AbsoluteWin;
                }
        }
        return PathType.Normal;
};

/**
 * @param {string} maybePath a path
 * @returns {PathType} type of path
 */
const getType = (maybePath) => {
        switch (maybePath.length) {
                case 0:
                        return PathType.Empty;
                case 1: {
                        const c0 = maybePath.charCodeAt(0);
                        switch (c0) {
                                case CHAR_DOT:
                                        return PathType.Relative;
                                case CHAR_SLASH:
                                        return PathType.AbsolutePosix;
                                case CHAR_HASH:
                                        return PathType.Internal;
                        }
                        return PathType.Normal;
                }
                case 2: {
                        const c0 = maybePath.charCodeAt(0);
                        switch (c0) {
                                case CHAR_DOT: {
                                        const c1 = maybePath.charCodeAt(1);
                                        switch (c1) {
                                                case CHAR_DOT:
                                                case CHAR_SLASH:
                                                        return PathType.Relative;
                                        }
                                        return PathType.Normal;
                                }
                                case CHAR_SLASH:
                                        return PathType.AbsolutePosix;
                                case CHAR_HASH:
                                        return PathType.Internal;
                        }
                        const c1 = maybePath.charCodeAt(1);
                        if (
                                c1 === CHAR_COLON &&
                                ((c0 >= CHAR_A && c0 <= CHAR_Z) ||
                                        (c0 >= CHAR_LOWER_A && c0 <= CHAR_LOWER_Z))
                        ) {
                                return PathType.AbsoluteWin;
                        }
                        return PathType.Normal;
                }
        }
        const c0 = maybePath.charCodeAt(0);
        switch (c0) {
                case CHAR_DOT: {
                        const c1 = maybePath.charCodeAt(1);
                        switch (c1) {
                                case CHAR_SLASH:
                                        return PathType.Relative;
                                case CHAR_DOT: {
                                        const c2 = maybePath.charCodeAt(2);
                                        if (c2 === CHAR_SLASH) return PathType.Relative;
                                        return PathType.Normal;
                                }
                        }
                        return PathType.Normal;
                }
                case CHAR_SLASH:
                        return PathType.AbsolutePosix;
                case CHAR_HASH:
                        return PathType.Internal;
        }
        const c1 = maybePath.charCodeAt(1);
        if (c1 === CHAR_COLON) {
                const c2 = maybePath.charCodeAt(2);
                if (
                        (c2 === CHAR_BACKSLASH || c2 === CHAR_SLASH) &&
                        ((c0 >= CHAR_A && c0 <= CHAR_Z) ||
                                (c0 >= CHAR_LOWER_A && c0 <= CHAR_LOWER_Z))
                ) {
                        return PathType.AbsoluteWin;
                }
        }
        // DOS device paths (`\\?\…`, `\\.\…`) are handled in a cold helper so
        // this function stays small — inlining the full check here regressed
        // `description-files-multi` under `--no-opt` interpretation. Here we
        // only pay the two-byte gate for non-DOS inputs.
        if (c0 === CHAR_BACKSLASH && c1 === CHAR_BACKSLASH) {
                return getDosDeviceType(maybePath);
        }
        return PathType.Normal;
};

/**
 * @param {string} maybePath a path
 * @returns {string} the normalized path
 */
const normalize = (maybePath) => {
        switch (getType(maybePath)) {
                case PathType.Empty:
                        return maybePath;
                case PathType.AbsoluteWin:
                        return winNormalize(maybePath);
                case PathType.Relative: {
                        const r = posixNormalize(maybePath);
                        return getType(r) === PathType.Relative ? r : `./${r}`;
                }
        }
        return posixNormalize(maybePath);
};

/**
 * @param {string} rootPath the root path
 * @param {string | undefined} request the request path
 * @returns {string} the joined path
 */
const join = (rootPath, request) => {
        if (!request) return normalize(rootPath);
        const requestType = getType(request);
        switch (requestType) {
                case PathType.AbsolutePosix:
                        return posixNormalize(request);
                case PathType.AbsoluteWin:
                        return winNormalize(request);
        }
        switch (getType(rootPath)) {
                case PathType.Normal:
                case PathType.Relative:
                case PathType.AbsolutePosix:
                        return posixNormalize(`${rootPath}/${request}`);
                case PathType.AbsoluteWin:
                        return winNormalize(`${rootPath}\\${request}`);
        }
        switch (requestType) {
                case PathType.Empty:
                        return rootPath;
                case PathType.Relative: {
                        const r = posixNormalize(rootPath);
                        return getType(r) === PathType.Relative ? r : `./${r}`;
                }
        }
        return posixNormalize(rootPath);
};

/**
 * @param {string} maybePath a path
 * @returns {string} the directory name
 */
const dirname = (maybePath) => {
        switch (getType(maybePath)) {
                case PathType.AbsoluteWin:
                        return path.win32.dirname(maybePath);
        }
        return path.posix.dirname(maybePath);
};

/** @typedef {{ fn: (rootPath: string, request: string) => string, cache: Map<string, Map<string, string | undefined>> }} CachedJoin */

/**
 * @returns {CachedJoin} cached join
 */
const createCachedJoin = () => {
        /** @type {CachedJoin["cache"]} */
        const cache = new Map();
        /** @type {CachedJoin["fn"]} */
        const fn = (rootPath, request) => {
                /** @type {string | undefined} */
                let cacheEntry;
                let inner = cache.get(rootPath);
                if (inner === undefined) {
                        cache.set(rootPath, (inner = new Map()));
                } else {
                        cacheEntry = inner.get(request);
                        if (cacheEntry !== undefined) return cacheEntry;
                }
                cacheEntry = join(rootPath, request);
                inner.set(request, cacheEntry);
                return cacheEntry;
        };
        return { fn, cache };
};

/** @typedef {{ fn: (maybePath: string) => string, cache: Map<string, string> }} CachedDirname */

/**
 * @returns {CachedDirname} cached dirname
 */
const createCachedDirname = () => {
        /** @type {CachedDirname["cache"]} */
        const cache = new Map();
        /** @type {CachedDirname["fn"]} */
        const fn = (maybePath) => {
                const cacheEntry = cache.get(maybePath);
                if (cacheEntry !== undefined) return cacheEntry;
                const result = dirname(maybePath);
                cache.set(maybePath, result);
                return result;
        };
        return { fn, cache };
};

/** @typedef {{ fn: (maybePath: string, suffix?: string) => string, cache: Map<string, Map<string | undefined, string | undefined>> }} CachedBasename */

/**
 * @returns {CachedBasename} cached basename
 */
const createCachedBasename = () => {
        /** @type {CachedBasename["cache"]} */
        const cache = new Map();
        /** @type {CachedBasename["fn"]} */
        const fn = (maybePath, suffix) => {
                /** @type {string | undefined} */
                let cacheEntry;
                let inner = cache.get(maybePath);
                if (inner === undefined) {
                        cache.set(maybePath, (inner = new Map()));
                } else {
                        cacheEntry = inner.get(suffix);
                        if (cacheEntry !== undefined) return cacheEntry;
                }
                cacheEntry = path.basename(maybePath, suffix);
                inner.set(suffix, cacheEntry);
                return cacheEntry;
        };
        return { fn, cache };
};

/**
 * Whether `request` is a relative request — i.e. matches `^\.\.?(?:\/|$)`.
 *
 * This is called on every `doResolve` via `UnsafeCachePlugin` and
 * `getInnerRequest`, so the char-code form is meaningfully faster than the
 * equivalent regex test: no regex state machine, no string object churn.
 * @param {string} request request string
 * @returns {boolean} true if request is relative
 */
const isRelativeRequest = (request) => {
        const len = request.length;
        if (len === 0 || request.charCodeAt(0) !== CHAR_DOT) return false;
        if (len === 1) return true; // "."
        const c1 = request.charCodeAt(1);
        if (c1 === CHAR_SLASH) return true; // "./..."
        if (c1 !== CHAR_DOT) return false; // ".x..."
        if (len === 2) return true; // ".."
        return request.charCodeAt(2) === CHAR_SLASH; // "../..."
};

/**
 * Check if childPath is a subdirectory of parentPath.
 *
 * Called from `TsconfigPathsPlugin._selectPathsDataForContext` inside a loop
 * over every tsconfig-paths context on every resolve, so it's worth keeping
 * cheap. Compared to the previous `startsWith(normalize(parent + "/"))`
 * version, this: checks the last char with `charCodeAt` instead of two
 * `endsWith` calls; and skips `normalize()` entirely in the common case
 * (parent has no trailing separator), since all we really need is the same
 * anchoring effect — a cheap `startsWith` plus a separator char check on the
 * byte immediately after `parentPath.length`.
 * @param {string} parentPath parent directory path
 * @param {string} childPath child path to check
 * @returns {boolean} true if childPath is under parentPath
 */
const isSubPath = (parentPath, childPath) => {
        const parentLen = parentPath.length;
        if (parentLen === 0) {
                // Match the old `normalize("" + "/") === "/"` fallback: an empty
                // parent only "contains" a child that starts with a forward slash.
                return childPath.length > 0 && childPath.charCodeAt(0) === CHAR_SLASH;
        }
        const lastChar = parentPath.charCodeAt(parentLen - 1);
        if (lastChar === CHAR_SLASH || lastChar === CHAR_BACKSLASH) {
                // Parent already ends with a separator — a plain prefix test is enough.
                return childPath.startsWith(parentPath);
        }
        if (childPath.length <= parentLen) return false;
        if (!childPath.startsWith(parentPath)) return false;
        // Must be followed by a separator so "/app" doesn't match "/app-other".
        const nextChar = childPath.charCodeAt(parentLen);
        return nextChar === CHAR_SLASH || nextChar === CHAR_BACKSLASH;
};

module.exports.PathType = PathType;
module.exports.createCachedBasename = createCachedBasename;
module.exports.createCachedDirname = createCachedDirname;
module.exports.createCachedJoin = createCachedJoin;
module.exports.deprecatedInvalidSegmentRegEx = deprecatedInvalidSegmentRegEx;
module.exports.dirname = dirname;
module.exports.getType = getType;
module.exports.invalidSegmentRegEx = invalidSegmentRegEx;
module.exports.isRelativeRequest = isRelativeRequest;
module.exports.isSubPath = isSubPath;
module.exports.join = join;
module.exports.normalize = normalize;