webpack 5.111.0 → 5.112.0

package/lib/util/dataURL.js

@@ -39,14 +39,14 @@ const decodeDataURI = (uri) => {
 
 /**
  * A `data:` URI split into the parts a caller has to put back together.
- * `payload` is the text after the comma, still in the form it was written.
- * @typedef {{ mediaType: string, base64: boolean, payload: string }} ParsedDataURI
+ * `parameters` is every `;…` after the media type (`;base64` included) and
+ * `payload` the text after the comma, both in the form they were written.
+ * @typedef {{ mediaType: string, parameters: string, base64: boolean, payload: string }} ParsedDataURI
  */
 
 // `URIRegEx`'s `.` stops at a newline, which a raw `<svg>` payload carries, and
-// its `base64` group is optional in a way that reads `;charset=utf8` as one.
-// This one is the strict split a rewriter needs; that one stays as the matcher
-// module requests are recognized by.
+// its optional `base64` group reads `;charset=utf8` as one. This is the strict
+// split a rewriter needs; that one stays as the matcher for module requests.
 const STRICT_URI_REGEXP = /^data:([^,;]*)((?:;[^,;]*)*),([\s\S]*)$/i;
 
 const JSON_TYPE = "json";
@@ -120,22 +120,56 @@ const parseDataURI = (uri) => {
 	if (match === null) return null;
 	return {
 		mediaType: match[1],
+		parameters: match[2],
 		base64: /;base64$/i.test(match[2]),
 		payload: match[3]
 	};
 };
 
+// A charset other than UTF-8 names bytes this cannot read back as text.
+const FOREIGN_CHARSET_REGEXP = /;charset=(?!(?:utf-?8|us-ascii)(?:;|$))/i;
+
 /**
- * The payload as text, or `null` when reading it would not round-trip. A
- * percent-escaped payload is declined rather than decoded: how much of it the
- * author escaped is not recorded anywhere in the URI, so re-escaping would
- * rewrite bytes nothing asked to change.
+ * Decode a payload's percent-escapes the way the URL parser does: a `%` and two
+ * hex digits is the byte they name, and any other `%` is itself.
+ * @param {string} payload the payload as written
+ * @returns {Buffer} the bytes it names
+ */
+const percentDecode = (payload) => {
+	const input = Buffer.from(payload, "utf8");
+	const output = Buffer.allocUnsafe(input.length);
+	let length = 0;
+	for (let i = 0; i < input.length; i++) {
+		const byte = input[i];
+		if (byte === 0x25 && i + 2 < input.length) {
+			const digits = String.fromCharCode(input[i + 1], input[i + 2]);
+			if (/^[0-9a-f]{2}$/i.test(digits)) {
+				output[length++] = Number.parseInt(digits, 16);
+				i += 2;
+				continue;
+			}
+		}
+		output[length++] = byte;
+	}
+	return output.subarray(0, length);
+};
+
+/**
+ * The payload as text, or `null` when reading it would not round-trip. A raw
+ * `#` is read as content, as webpack's own `data:` modules read it, so a
+ * rebuilt URI escapes it rather than cutting the payload short.
  * @param {ParsedDataURI} parsed the split URI
  * @returns {string | null} the payload as text
  */
 const decodeDataURIPayload = (parsed) => {
 	if (!parsed.base64) {
-		return parsed.payload.includes("%") ? null : parsed.payload;
+		const { payload } = parsed;
+		if (!payload.includes("%")) return payload;
+		if (FOREIGN_CHARSET_REGEXP.test(parsed.parameters)) return null;
+		const bytes = percentDecode(payload);
+		const text = bytes.toString("utf8");
+		// Bytes that are no UTF-8 text are not written back as the same bytes.
+		return Buffer.from(text, "utf8").equals(bytes) ? text : null;
 	}
 	// Decoding is lenient rather than throwing, so garbage decodes to something
 	// that does not round-trip, which is the same answer: leave it alone.
@@ -145,6 +179,51 @@ const decodeDataURIPayload = (parsed) => {
 		: null;
 };
 
+/**
+ * A `data:` URI's payload as text, for a caller that will render it, with the
+ * language its media type names. `null` when there is nothing to offer: not a
+ * `data:` URI, a media type naming no language, a payload that would not
+ * round-trip, or a raw `#`, where a browser reads the rest as a fragment.
+ * @param {string} uri the URI, unquoted and unescaped
+ * @returns {{ parsed: ParsedDataURI, type: string, payload: string } | null} what it holds, or null
+ */
+const readEmbeddedDataURI = (uri) => {
+	if (uri.includes("#")) return null;
+	const parsed = parseDataURI(uri);
+	if (parsed === null) return null;
+	const type = languageOfMediaType(parsed.mediaType);
+	if (type === undefined) return null;
+	const payload = decodeDataURIPayload(parsed);
+	if (payload === null || payload === "") return null;
+	return { parsed, type, payload };
+};
+
+/**
+ * Escape a payload for a `data:` URI written without `base64`, touching only
+ * what would change what the URI means. The host's own quoting is the caller's.
+ * @param {string} text the payload as text
+ * @returns {string} the escaped payload
+ */
+const encodeDataURIPayload = (text) => {
+	// WHY: `%` starts an escape and `#` a fragment. The URL parser drops every
+	// tab and newline and strips C0 controls and spaces off the end, so those
+	// are escaped too, or the payload read back is not the one written.
+	let trailing = text.length;
+	while (trailing > 0 && text.charCodeAt(trailing - 1) === 0x20) trailing--;
+	let out = "";
+	let start = 0;
+	for (let i = 0; i < text.length; i++) {
+		const c = text.charCodeAt(i);
+		if (c > 0x20 && c !== 0x7f && c !== 0x25 && c !== 0x23) continue;
+		if (c === 0x20 && i < trailing) continue;
+		out += `${text.slice(start, i)}%${c < 0x10 ? "0" : ""}${c
+			.toString(16)
+			.toUpperCase()}`;
+		start = i + 1;
+	}
+	return start === 0 ? text : out + text.slice(start);
+};
+
 /**
  * Rebuild a `data:` URI around a new payload, in the form it was written in.
  * @param {ParsedDataURI} parsed the split URI
@@ -152,14 +231,12 @@ const decodeDataURIPayload = (parsed) => {
  * @returns {string} the rebuilt URI
  */
 const buildDataURI = (parsed, text) => {
-	const head = `data:${parsed.mediaType}${parsed.base64 ? ";base64" : ""},`;
+	// A `;charset=` names how the payload decodes, so it is kept as written.
+	const head = `data:${parsed.mediaType}${parsed.parameters},`;
 	if (parsed.base64) {
 		return head + Buffer.from(text, "utf8").toString("base64");
 	}
-	// Only the two that would change what the URI means: `%` starts an escape and
-	// `#` starts a fragment. Everything else stays as the renderer wrote it, and
-	// the url token's own quoting is the caller's to apply.
-	return head + text.replace(/%/g, "%25").replace(/#/g, "%23");
+	return head + encodeDataURIPayload(text);
 };
 
 /**
@@ -209,8 +286,7 @@ const collectEmbeddedDiagnostics = (reported) => {
 
 /**
  * What a renderer made of one embedded body: the minified text, and anything it
- * has to report about it. A bare string is the text alone, `undefined` a
- * renderer that declined.
+ * has to report about it. A bare string is the text alone.
  * @typedef {{ code?: string, warnings?: (Error | string)[], errors?: (Error | string)[] }} EmbeddedSourceResult
  */
 
@@ -258,7 +334,9 @@ module.exports = {
 	decodeDataURI,
 	decodeDataURIPayload,
 	embeddedText,
+	encodeDataURIPayload,
 	languageOfFilename,
 	languageOfMediaType,
-	parseDataURI
+	parseDataURI,
+	readEmbeddedDataURI
 };

package/lib/util/deprecation.js

@@ -203,7 +203,7 @@ module.exports.arrayToSetDeprecation = (set, name) => {
  * Returns } SetDeprecatedArray.
  * @template T
  * @param {string} name name
- * @returns {{ new <T = EXPECTED_ANY>(values?: ReadonlyArray<T> | null): SetDeprecatedArray<T> }} SetDeprecatedArray
+ * @returns {{ new <T>(values?: ReadonlyArray<T> | null): SetDeprecatedArray<T> }} SetDeprecatedArray
  */
 module.exports.createArrayToSetDeprecationSet = (name) => {
 	let initialized = false;

package/lib/util/extractComments.js

@@ -0,0 +1,118 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author sheo13666q @sheo13666q
+*/
+
+"use strict";
+
+/**
+ * A condition in the minimizer plugin's `extractComments`. A function's arguments
+ * are each minimizer's own, so these minifiers hand it what `MinimizeExtractCommentsCondition` names.
+ * @typedef {boolean | string | RegExp | ((...args: never[]) => boolean)} PluginExtractCommentsCondition
+ */
+/**
+ * The minimizer plugin's `extractComments`, as far as these minifiers read it: a
+ * condition, or an object holding one.
+ * @typedef {PluginExtractCommentsCondition | { condition?: PluginExtractCommentsCondition }} PluginExtractComments
+ */
+/** @typedef {import("../../declarations/WebpackOptions").OptimizationMinimizeExtractComments} MinimizeExtractComments */
+/** @typedef {import("../../declarations/WebpackOptions").OptimizationMinimizeExtractCommentsCondition} MinimizeExtractCommentsCondition */
+/** @typedef {boolean | string | RegExp | ((comment: string) => boolean)} CommentsOption */
+/** @typedef {(comment: string, line: number, column: number) => boolean} CommentPredicate */
+
+/**
+ * How one language writes a comment, and which it keeps where nothing is extracted.
+ * @typedef {object} CommentSyntax
+ * @property {string} open what opens a comment, e.g. `/*`
+ * @property {string} close what closes it
+ * @property {(comment: string) => boolean} some what the `comments: "some"` level keeps
+ * @property {(comment: string) => boolean} unstated what is kept when `comments` is unset
+ */
+
+/**
+ * A `comments` value as the predicate over a comment's text it stands for.
+ * @param {CommentsOption} comments as configured
+ * @param {(comment: string) => boolean} some what `"some"` keeps
+ * @returns {(comment: string) => boolean} whether a comment is kept
+ */
+const keepCondition = (comments, some) => {
+	if (typeof comments === "function") return comments;
+	if (comments === true || comments === "all") return () => true;
+	if (comments === false) return () => false;
+	if (comments === "some") return some;
+	const pattern = comments instanceof RegExp ? comments : new RegExp(comments);
+	return (comment) => pattern.test(comment);
+};
+
+/**
+ * Which comments `extractComments` takes out, read as terser-webpack-plugin
+ * reads it: `true`, `"some"` or an object without a condition is terser's `some`
+ * bar IE's `@cc_on`, which marks conditional compilation rather than a license.
+ * @param {PluginExtractComments | MinimizeExtractComments | undefined} option as configured
+ * @returns {CommentPredicate | undefined} the condition, or undefined when nothing is extracted
+ */
+const extractCondition = (option) => {
+	if (option === undefined || option === false) return undefined;
+	/** @type {PluginExtractComments | MinimizeExtractComments} */
+	let condition = option;
+	if (typeof option === "object" && !(option instanceof RegExp)) {
+		// Extracting with a condition nothing meets still drops what is not kept.
+		condition = option.condition === undefined ? true : option.condition;
+		if (condition === false) return () => false;
+	}
+	if (condition === true || condition === "some") {
+		return (comment) => /@preserve|@lic|^\**!/i.test(comment);
+	}
+	if (typeof condition === "function") {
+		// No node to hand it, nor a second kind of comment: the predicate is asked
+		// about the comment alone, its text and place.
+		const predicate = /** @type {MinimizeExtractCommentsCondition} */ (
+			condition
+		);
+		return (comment, line, col) =>
+			predicate({ value: comment, line, col }) === true;
+	}
+	// an object option was unwrapped to its condition above
+	const keep = keepCondition(
+		/** @type {string | RegExp} */ (condition),
+		() => false
+	);
+	return (comment) => keep(comment);
+};
+
+/**
+ * The `comments` predicate a print takes to extract comments, and the list
+ * they are collected into, deduplicated and written with their delimiters.
+ * @param {PluginExtractComments | MinimizeExtractComments | undefined} option `extractComments` as configured
+ * @param {CommentsOption | undefined} comments the language's `comments` option
+ * @param {CommentSyntax} syntax how the language writes and keeps comments
+ * @returns {{ comments: CommentPredicate, extracted: string[] } | undefined} undefined when nothing is extracted
+ */
+const extractComments = (option, comments, syntax) => {
+	const extract = extractCondition(option);
+	if (extract === undefined) return undefined;
+	// As terser does: where the comments kept are not stated, extracting leaves
+	// only what the language must keep.
+	const keep =
+		comments === undefined
+			? syntax.unstated
+			: keepCondition(comments, syntax.some);
+	/** @type {string[]} */
+	const extracted = [];
+	const seen = new Set();
+	return {
+		comments: (comment, line, column) => {
+			if (!extract(comment, line, column)) return keep(comment);
+			const text = `${syntax.open}${comment}${syntax.close}`;
+			if (!seen.has(text)) {
+				seen.add(text);
+				extracted.push(text);
+			}
+			return false;
+		},
+		extracted
+	};
+};
+
+module.exports.extractComments = extractComments;
+module.exports.keepCondition = keepCondition;

package/lib/util/formatLocation.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-/** @import { DependencyLocation, SourcePosition } from "../Dependency" */
+/** @import { DependencyLocation, SourcePosition } from "../graph/Dependency" */
 
 /**
  * Returns formatted position.

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
@@ -22,6 +22,9 @@ const getGlobToRegExpSource = memoize(
 );
 
 /** @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 +521,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 +541,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 +558,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/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 +572,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 +626,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 +1136,11 @@ const globPatternBaseReachesDir = (patterns, dirPath) => {
 
 module.exports = {
 	commonGlobBaseDir,
+	compileGlobList,
+	compileRelativeGlobPaths,
 	createPathGlobMatcher,
+	createPathGlobPrefixRegExp,
+	createPathGlobRegExp,
 	escapeGlobPattern,
 	extractGlobBaseDir,
 	getGlobToRegExpSource,
@@ -976,6 +1155,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/hash/wasm-hash.js

@@ -7,10 +7,9 @@
 
 const Hash = require("../Hash");
 
-// 65536 is the size of a wasm memory page
-// 64 is the maximum chunk size for every possible wasm hash implementation
-// 4 is the maximum number of bytes per char for string encoding (max is utf-8)
-// ~3 makes sure that it's always a block of 4 chars, so avoid partially encoded bytes for base64
+// 65536 is a wasm memory page, 64 the largest chunk size any wasm hash
+// implementation takes, 4 the most bytes utf-8 spends on one char, and `& ~3`
+// keeps it a whole block of 4 chars so base64 never sees a partial encoding.
 const MAX_SHORT_STRING = Math.floor((65536 - 64) / 4) & ~3;
 
 /**