added tailwind back, reenabled utilities which was causing the color issue
This commit is contained in:
+344
@@ -0,0 +1,344 @@
|
||||
/*
|
||||
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;
|
||||
Reference in New Issue
Block a user