webpack 5.111.1 → 5.112.1

package/lib/util/globUtils.js

@@ -6,7 +6,7 @@
 "use strict";
 
 const path = require("path");
-const { join: joinPath } = require("./fs");
+const { join: joinPath } = require("../fs/fs");
 const {
 	ABSOLUTE_PATH_REGEXP,
 	WINDOWS_PATH_SEPARATOR_REGEXP
@@ -15,13 +15,13 @@ const memoize = require("./memoize");
 
 // watchpack's glob-to-regexp core, loaded only when a glob is translated
 const getGlobToRegExpSource = memoize(
-	() =>
-		/** @type {{ util: { globToRegExp: (glob: string) => string } }} */ (
-			/** @type {unknown} */ (require("watchpack"))
-		).util.globToRegExp
+	() => require("watchpack").util.globToRegExp
 );
 
 /** @typedef {{ caseSensitive?: boolean, requireLiteralLeadingDot?: boolean }} GlobMatchOptions */
+/** @typedef {(str: string) => boolean} GlobMatcher */
+/** @typedef {import("../../declarations/WebpackOptions").GlobCondition} GlobCondition */
+/** @import Module from "../module/Module" */
 
 /**
  * @param {string} s string
@@ -518,10 +518,12 @@ const segmentGlobToRegExpSource = (segment) => {
  * `path.matchesGlob` semantics: `*`, `?` and classes stay within a segment,
  * a whole-segment `**` spans segments, and neither crosses a dot segment.
  * @param {string} glob brace-free glob
+ * @param {boolean} lazy whether `**` spans as few segments as it can
  * @returns {string} regexp source without anchors
  */
-const braceFreeGlobToPathRegExpSource = (glob) => {
+const braceFreeGlobToPathRegExpSource = (glob, lazy) => {
 	const segments = optimizeGlobSegments(glob.split("/"));
+	const repeat = lazy ? "*?" : "*";
 	let source = "";
 	let needSeparator = false;
 	for (let i = 0; i < segments.length; i++) {
@@ -536,8 +538,8 @@ const braceFreeGlobToPathRegExpSource = (glob) => {
 			source += isLast
 				? `${needSeparator ? "/" : ""}(?:${NON_DOT_SEGMENT}(?:/${NON_DOT_SEGMENT})*)?`
 				: needSeparator
-					? `(?:/${NON_DOT_SEGMENT})*`
-					: `/?(?:${NON_DOT_SEGMENT}/)*`;
+					? `(?:/${NON_DOT_SEGMENT})${repeat}`
+					: `/?(?:${NON_DOT_SEGMENT}/)${repeat}`;
 			needSeparator = !isLast && needSeparator;
 			continue;
 		}
@@ -553,17 +555,10 @@ const braceFreeGlobToPathRegExpSource = (glob) => {
 };
 
 /**
- * Compiles a glob into a matcher over OS-independent paths: `\` is a path
- * separator in both the pattern and the tested path (never an escape, so a
- * pattern built with `path.resolve` works everywhere; use `[*]` to match a
- * literal `*`), and a relative pattern matches at any depth. Matching follows
- * `path.matchesGlob`, except where its minimatch shows through — see the
- * divergences listed above the corpus in `test/unitCases/globUtils.unittest.js`.
  * @param {string} pattern glob pattern
- * @param {GlobMatchOptions=} options options
- * @returns {((str: string) => boolean) | null} matcher, null for un-compilable patterns
+ * @returns {string} regexp source matching a normalized path, unanchored
  */
-const createPathGlobMatcher = (pattern, options = {}) => {
+const pathGlobToRegExpSource = (pattern) => {
 	let normalizedPattern = normalizePathSeparatorsForPath(pattern);
 	while (normalizedPattern.startsWith("./")) {
 		normalizedPattern = normalizedPattern.slice(2);
@@ -574,10 +569,40 @@ const createPathGlobMatcher = (pattern, options = {}) => {
 	) {
 		normalizedPattern = `**/${normalizedPattern}`;
 	}
-	const sources = expandGlobBraces(normalizedPattern).map(
-		braceFreeGlobToPathRegExpSource
+	const sources = expandGlobBraces(normalizedPattern).map((glob) =>
+		braceFreeGlobToPathRegExpSource(glob, false)
 	);
-	const source = sources.length === 1 ? sources[0] : `(?:${sources.join("|")})`;
+	return sources.length === 1 ? sources[0] : `(?:${sources.join("|")})`;
+};
+
+// a separator in a path regexp source, which a native path may spell `\`
+const PATH_SOURCE_SEPARATOR_REGEXP = /\\[\s\S]|\[\^\/|\//g;
+/** @type {Record<string, string>} */
+const PATH_SOURCE_SEPARATORS = { "/": "[\\\\/]", "[^/": "[^\\\\/" };
+
+/**
+ * @param {string} source regexp source over `/`-separated paths
+ * @returns {string} the same source, also accepting `\` as a separator
+ */
+const toNativePathSource = (source) =>
+	source.replace(
+		PATH_SOURCE_SEPARATOR_REGEXP,
+		(match) => PATH_SOURCE_SEPARATORS[match] || match
+	);
+
+/**
+ * Compiles a glob into a matcher over OS-independent paths: `\` is a path
+ * separator in both the pattern and the tested path (never an escape, so a
+ * pattern built with `path.resolve` works everywhere; use `[*]` to match a
+ * literal `*`), and a relative pattern matches at any depth. Matching follows
+ * `path.matchesGlob`, except where its minimatch shows through — see the
+ * divergences listed above the corpus in `test/unitCases/globUtils.unittest.js`.
+ * @param {string} pattern glob pattern
+ * @param {GlobMatchOptions=} options options
+ * @returns {((str: string) => boolean) | null} matcher, null for un-compilable patterns
+ */
+const createPathGlobMatcher = (pattern, options = {}) => {
+	const source = pathGlobToRegExpSource(pattern);
 	/** @type {RegExp} */
 	let regexp;
 	try {
@@ -598,6 +623,153 @@ const createPathGlobMatcher = (pattern, options = {}) => {
 	};
 };
 
+/**
+ * @param {GlobMatcher[]} positive patterns that select
+ * @param {GlobMatcher[]} negative patterns that subtract
+ * @returns {GlobMatcher} matcher
+ */
+const combineGlobMatchers = (positive, negative) => {
+	/** @type {GlobMatcher} */
+	const matchPositive =
+		positive.length === 0
+			? () => true
+			: positive.length === 1
+				? positive[0]
+				: (str) => positive.some((match) => match(str));
+	if (negative.length === 0) return matchPositive;
+	/** @type {GlobMatcher} */
+	const matchNegative =
+		negative.length === 1
+			? negative[0]
+			: (str) => negative.some((match) => match(str));
+	return (str) => matchPositive(str) && !matchNegative(str);
+};
+
+/**
+ * Compiles glob patterns into one matcher: patterns are OR-ed and a `!` prefix
+ * subtracts, as in `module.rules[].glob`.
+ * @param {string[]} globs glob patterns
+ * @param {(pattern: string, index: number) => never} onInvalid throws for an un-compilable pattern
+ * @returns {GlobMatcher} matcher
+ */
+const compileGlobList = (globs, onInvalid) => {
+	/** @type {GlobMatcher[]} */
+	const positive = [];
+	/** @type {GlobMatcher[]} */
+	const negative = [];
+	for (let i = 0; i < globs.length; i++) {
+		const pattern = globs[i];
+		const negated = pattern.startsWith("!");
+		const match = createPathGlobMatcher(negated ? pattern.slice(1) : pattern);
+		if (match === null) onInvalid(pattern, i);
+		(negated ? negative : positive).push(/** @type {GlobMatcher} */ (match));
+	}
+	return combineGlobMatchers(positive, negative);
+};
+
+/**
+ * @param {string} pattern glob pattern
+ * @returns {never} never returns
+ */
+const throwInvalidGlob = (pattern) => {
+	throw new Error(`Invalid glob pattern: ${pattern}`);
+};
+
+/** @type {WeakMap<GlobCondition, GlobMatcher>} */
+const globConditionMatchers = new WeakMap();
+
+/**
+ * Tests a path against `{ glob }`, compiled once per condition object.
+ * @param {GlobCondition} condition glob condition
+ * @param {string} str path
+ * @returns {boolean} true, when the path matches
+ */
+const matchGlobCondition = (condition, str) => {
+	let match = globConditionMatchers.get(condition);
+	if (match === undefined) {
+		match = compileGlobList(
+			Array.isArray(condition.glob) ? condition.glob : [condition.glob],
+			throwInvalidGlob
+		);
+		globConditionMatchers.set(condition, match);
+	}
+	return match(str);
+};
+
+/**
+ * Tests a module's `nameForCondition()` against `{ glob }`; a module without one never matches.
+ * @param {GlobCondition} condition glob condition
+ * @param {Module} module module
+ * @returns {boolean} true, when the module matches
+ */
+const matchModuleGlobCondition = (condition, module) => {
+	const name = module.nameForCondition();
+	return name ? matchGlobCondition(condition, name) : false;
+};
+
+/**
+ * Compiles each relative path of a path option as a glob, leaving absolute paths and RegExps as they are.
+ * @template T, R
+ * @param {(T | string)[]} paths option value
+ * @param {(pattern: string) => R} compile glob compiler
+ * @returns {(T | R | string)[]} paths with relative globs compiled
+ */
+const compileRelativeGlobPaths = (paths, compile) =>
+	paths.map((item) =>
+		typeof item === "string" && !ABSOLUTE_PATH_REGEXP.test(item)
+			? compile(item)
+			: item
+	);
+
+/**
+ * Compiles a glob into a RegExp matching what `createPathGlobMatcher` matches,
+ * for an option handed to code that only calls `.test()` on a native path.
+ * @param {string} pattern glob pattern
+ * @returns {RegExp} regexp
+ */
+const createPathGlobRegExp = (pattern) =>
+	new RegExp(`^${toNativePathSource(pathGlobToRegExpSource(pattern))}$`);
+
+/**
+ * Compiles a relative glob into a RegExp whose first group is the outermost
+ * directory it matches at the start of a path, trailing separator included — the
+ * shape `snapshot.managedPaths` and its siblings read. Like `module.rules[].glob`
+ * it matches at any depth, unless a leading `./` or `../` anchors it to `context`.
+ * @param {string} pattern relative glob pattern
+ * @param {string} context directory a `./` or `../` pattern is relative to
+ * @returns {RegExp} prefix regexp
+ */
+const createPathGlobPrefixRegExp = (pattern, context) => {
+	let glob = normalizePathSeparatorsForPath(pattern);
+	let baseSource = "";
+	if (glob.startsWith("./") || glob.startsWith("../")) {
+		let base = context;
+		for (;;) {
+			if (glob.startsWith("./")) {
+				glob = glob.slice(2);
+			} else if (glob.startsWith("../")) {
+				base = path.dirname(base);
+				glob = glob.slice(3);
+			} else {
+				break;
+			}
+		}
+		for (const c of path.join(base, "/")) {
+			baseSource += c === "/" || c === "\\" ? "[\\\\/]" : quoteRegExpChar(c);
+		}
+	} else if (!glob.startsWith("**/")) {
+		glob = `**/${glob}`;
+	}
+	if (!glob.endsWith("/")) glob += "/";
+	const sources = expandGlobBraces(glob).map((brace) =>
+		braceFreeGlobToPathRegExpSource(brace, true)
+	);
+	const source = toNativePathSource(
+		sources.length === 1 ? sources[0] : `(?:${sources.join("|")})`
+	);
+	return new RegExp(`^(${baseSource}${source})`);
+};
+
 /**
  * @param {string} path path
  * @param {string} baseDir base directory
@@ -961,7 +1133,11 @@ const globPatternBaseReachesDir = (patterns, dirPath) => {
 
 module.exports = {
 	commonGlobBaseDir,
+	compileGlobList,
+	compileRelativeGlobPaths,
 	createPathGlobMatcher,
+	createPathGlobPrefixRegExp,
+	createPathGlobRegExp,
 	escapeGlobPattern,
 	extractGlobBaseDir,
 	getGlobToRegExpSource,
@@ -976,6 +1152,8 @@ module.exports = {
 	isNonExhaustiveImportMetaGlobSkippedDir,
 	joinImportMetaGlobFsPath,
 	joinImportMetaGlobPath,
+	matchGlobCondition,
+	matchModuleGlobCondition,
 	normalizePathSeparators,
 	normalizePathSeparatorsForPath,
 	patternHasExplicitDotFor,

package/lib/util/haltVisitors.js

@@ -0,0 +1,51 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/**
+ * @template T
+ * @typedef {import("./SourceProcessor").VisitorFn<T>} VisitorFn
+ */
+/**
+ * @template T
+ * @typedef {import("./SourceProcessor").CompiledVisitorBucket<T>} CompiledVisitorBucket
+ */
+
+/**
+ * Empty every bucket of a compiled visitor map in place, so a dispatch loop
+ * running over one ends after the visitor that asked and none fires again.
+ * @template TPath
+ * @param {CompiledVisitorBucket<TPath>[]} map the map a walk dispatches from
+ * @returns {VisitorFn<TPath>[][]} each emptied list followed by its visitors, for {@link resumeVisitors}
+ */
+const haltVisitors = (map) => {
+	/** @type {VisitorFn<TPath>[][]} */
+	const halted = [];
+	for (let type = 0; type < map.length; type++) {
+		const bucket = map[type];
+		if (bucket === undefined) continue;
+		halted.push(bucket.enter, [...bucket.enter], bucket.exit, [...bucket.exit]);
+		bucket.enter.length = 0;
+		bucket.exit.length = 0;
+	}
+	return halted;
+};
+
+/**
+ * Put back what {@link haltVisitors} emptied, so the next walk fires them all.
+ * @template TPath
+ * @param {VisitorFn<TPath>[][]} halted what `haltVisitors` returned
+ */
+const resumeVisitors = (halted) => {
+	for (let i = 0; i < halted.length; i += 2) {
+		const list = halted[i];
+		const visitors = halted[i + 1];
+		for (let k = 0; k < visitors.length; k++) list.push(visitors[k]);
+	}
+};
+
+module.exports.haltVisitors = haltVisitors;
+module.exports.resumeVisitors = resumeVisitors;

package/lib/util/handlerKeys.js

@@ -4,7 +4,7 @@
 
 "use strict";
 
-/** @import RuntimeModule from "../RuntimeModule" */
+/** @import RuntimeModule from "../runtime/RuntimeModule" */
 
 /**
  * The one key a chunk's runtime modules install on a handler map, or `null` when
@@ -20,7 +20,7 @@ const getOnlyHandlerKey = (runtimeModule, handlers) => {
 	/** @type {string | null} */
 	let only = null;
 	for (const module of chunkGraph.getChunkRuntimeModulesIterable(chunk)) {
-		// TODO webpack 6: call it directly, every runtime module answers by then. A
+		// TODO in the next major release: call it directly, every runtime module answers by then. A
 		// module built against an older webpack extends a base class without it.
 		const installed =
 			typeof module.getInstalledChunkHandlers === "function"

package/lib/util/identifier.js

@@ -22,6 +22,8 @@ const FILE_URL_REGEXP = /^file:\//i;
 // What `import()` resolves as a place rather than as a package name: relative,
 // rooted, or carrying a scheme.
 const RESOLVABLE_SPECIFIER_REGEXP = /^(?:\.{0,2}\/|[a-zA-Z][\w+.-]*:)/;
+// The `./` and `../` segments a relative path opens with, either separator.
+const RELATIVE_PATH_PREFIX_REGEXP = /^(?:\.\.?[\\/])+/;
 
 /**
  * Converts a file URL to the path it names. Any other value is returned
@@ -570,6 +572,103 @@ const contextifySourceUrl = (context, source, associatedObjectForCache) => {
 	)}`;
 };
 
+const URL_SCHEME_REGEXP = /^[\w+.-]+:\/\//;
+const URL_PARTS_REGEXP =
+	/^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+const FILE_URL_PARTS_REGEXP =
+	/^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+const RELATIVE_URL_REGEXP = /^[.?#]/;
+
+/**
+ * Drops the `.` and empty segments of a slash-led path and folds each `..`
+ * into the segment before it, keeping the `..` left over only when relative.
+ * @param {string} urlPath a path starting with `/`
+ * @param {boolean} relative whether the path is relative, not a URL's
+ * @returns {string} the path, normalized
+ */
+const normalizeUrlPath = (urlPath, relative) => {
+	const pieces = urlPath.split("/");
+	let pointer = 1;
+	let directories = 0;
+	let addTrailingSlash = false;
+	for (let i = 1; i < pieces.length; i++) {
+		const piece = pieces[i];
+		if (!piece) {
+			addTrailingSlash = true;
+			continue;
+		}
+		addTrailingSlash = false;
+		if (piece === ".") continue;
+		if (piece === "..") {
+			if (directories) {
+				addTrailingSlash = true;
+				directories--;
+				pointer--;
+			} else if (relative) {
+				pieces[pointer++] = piece;
+			}
+			continue;
+		}
+		pieces[pointer++] = piece;
+		directories++;
+	}
+	let result = "";
+	for (let i = 1; i < pointer; i++) result += `/${pieces[i]}`;
+	if (!result || (addTrailingSlash && !result.endsWith("/.."))) result += "/";
+	return result;
+};
+
+/**
+ * A source map's source URL in the normal form source map readers resolve it
+ * to (`resolve-uri` with no base), so `./a/../b.js` reads `./b.js`.
+ * @param {string} url a source map's `sourceRoot` and source, joined
+ * @returns {string} the URL, normalized
+ */
+const normalizeSourceMapUrl = (url) => {
+	if (!url) return "";
+	if (url.startsWith("file:")) {
+		const match = /** @type {RegExpExecArray} */ (
+			FILE_URL_PARTS_REGEXP.exec(url)
+		);
+		const filePath = match[2];
+		return `file://${match[1] || ""}${normalizeUrlPath(
+			filePath.startsWith("/") ? filePath : `/${filePath}`,
+			false
+		)}${match[3] || ""}${match[4] || ""}`;
+	}
+	const schemeRelative = url.startsWith("//");
+	const absolutePath = !schemeRelative && url.startsWith("/");
+	const absolute =
+		!schemeRelative && !absolutePath && URL_SCHEME_REGEXP.test(url);
+	const match = /** @type {RegExpExecArray} */ (
+		URL_PARTS_REGEXP.exec(
+			schemeRelative
+				? `http:${url}`
+				: absolutePath
+					? `http://foo.com${url}`
+					: absolute
+						? url
+						: `http://foo.com/${url}`
+		)
+	);
+	const queryHash = (match[6] || "") + (match[7] || "");
+	if (url.startsWith("?") || url.startsWith("#")) return queryHash;
+	const relative = !schemeRelative && !absolutePath && !absolute;
+	const urlPath = normalizeUrlPath(match[5] || "/", relative);
+	if (absolutePath) return urlPath + queryHash;
+	if (relative) {
+		const relativePath = urlPath.slice(1);
+		if (!relativePath) return queryHash || ".";
+		return RELATIVE_URL_REGEXP.test(url) &&
+			!RELATIVE_URL_REGEXP.test(relativePath)
+			? `./${relativePath}${queryHash}`
+			: relativePath + queryHash;
+	}
+	return `${schemeRelative ? "" : match[1]}//${match[2] || ""}${match[3]}${
+		match[4] || ""
+	}${urlPath}${queryHash}`;
+};
+
 const LINE_SEPARATOR_REGEXP = /[\u2028\u2029]/g;
 
 /**
@@ -584,8 +683,23 @@ const toJsStringLiteral = (str) =>
 		c === "\u2029" ? "\\u2029" : "\\u2028"
 	);
 
+const parseResource = makeCacheable(_parseResource);
+
+/**
+ * The basename a request lends to what it is emitted as, so `./my-script.js`
+ * names `my-script`. A `data:` request carries no path and so no name.
+ * @param {string} request a request
+ * @returns {string | undefined} the basename without extension, when it has one
+ */
+const getRequestBaseName = (request) => {
+	if (request.startsWith("data:")) return undefined;
+	const { path: file } = parseResource(request);
+	return path.basename(file, path.extname(file)) || undefined;
+};
+
 module.exports.ABSOLUTE_PATH_REGEXP = ABSOLUTE_PATH_REGEXP;
 module.exports.NODE_MODULES_REGEXP = NODE_MODULES_REGEXP;
+module.exports.RELATIVE_PATH_PREFIX_REGEXP = RELATIVE_PATH_PREFIX_REGEXP;
 module.exports.RESOLVABLE_SPECIFIER_REGEXP = RESOLVABLE_SPECIFIER_REGEXP;
 module.exports.WINDOWS_ABS_PATH_REGEXP = WINDOWS_ABS_PATH_REGEXP;
 module.exports.WINDOWS_PATH_SEPARATOR_REGEXP = WINDOWS_PATH_SEPARATOR_REGEXP;
@@ -594,11 +708,13 @@ module.exports.contextify = contextify;
 module.exports.contextifySourceUrl = contextifySourceUrl;
 module.exports.escapeHashInPathRequest = escapeHashInPathRequest;
 module.exports.fileUrlToPath = fileUrlToPath;
+module.exports.getRequestBaseName = getRequestBaseName;
 module.exports.getUndoPath = getUndoPath;
 module.exports.makeCacheable = makeCacheable;
 module.exports.makePathsAbsolute = makeCacheableWithContext(_makePathsAbsolute);
 module.exports.makePathsRelative = makePathsRelative;
-module.exports.parseResource = makeCacheable(_parseResource);
+module.exports.normalizeSourceMapUrl = normalizeSourceMapUrl;
+module.exports.parseResource = parseResource;
 module.exports.parseResourceWithoutFragment = makeCacheable(
 	_parseResourceWithoutFragment
 );

package/lib/util/implicitTypeLoaderFallback.js

@@ -5,20 +5,22 @@
 
 "use strict";
 
-const { JAVASCRIPT_MODULE_TYPE_AUTO } = require("../ModuleTypeConstants");
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO
+} = require("../module/ModuleTypeConstants");
 const { parseResource } = require("./identifier");
 
-/** @import NormalModuleFactory from "../NormalModuleFactory" */
+/** @import NormalModuleFactory from "../module/NormalModuleFactory" */
 
 /**
  * When a built-in module type is only enabled implicitly (`experiments.css` /
- * `experiments.html` resolved from their `"auto"` default), modules that reach
+ * `experiments.html` / `experiments.asyncWebAssembly` resolved from their `"auto"` default), modules that reach
  * the factory with loaders applied — an inline request or loaders injected via
  * hooks (e.g. html-webpack-plugin's template loader) — keep the pre-existing
  * behavior: the loader result is parsed as JavaScript, not as the built-in type.
  * A `!=!` matchResource is an explicit re-type of the loader result and wins.
  *
- * TODO webpack 6: css/html are enabled unconditionally (`experiments.*: true`),
+ * TODO in the next major release: css/html/asyncWebAssembly are enabled unconditionally (`experiments.*: true`),
  * so this implicit-only workaround can be removed together with the `"auto"`
  * marker in `applyExperimentsDefaults`.
  * @param {NormalModuleFactory} normalModuleFactory the normal module factory