webpack 5.108.4 → 5.109.1

package/lib/ids/IdHelpers.js

@@ -18,6 +18,17 @@ const numberHash = require("../util/numberHash");
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../css/CssModule").CssModuleBuildMeta} CssModuleBuildMeta */
 
+// Numbers longer than this are written in exponential form ("...e+xx"), so a
+// longer string can't be a plain integer id.
+const MAX_NUMERIC_STRING_LENGTH = 21;
+// Char codes bounding the "looks like a plain number" fast check in `avoidNumber`.
+const CC_HYPHEN_MINUS = 45;
+const CC_DIGIT_ONE = 49;
+const CC_DIGIT_NINE = 57;
+// Long ids are truncated to this length and disambiguated with a short hash.
+const MAX_SHORTENED_STRING_LENGTH = 100;
+const SHORTENED_STRING_HASH_LENGTH = 6;
+
 /**
  * Returns hash.
  * @param {string} str string to hash
@@ -38,14 +49,12 @@ const getHash = (str, len, hashFunction) => {
  * @returns {string} string prefixed by an underscore if it is a number
  */
 const avoidNumber = (str) => {
-	// max length of a number is 21 chars, bigger numbers a written as "...e+xx"
-	if (str.length > 21) return str;
+	if (str.length > MAX_NUMERIC_STRING_LENGTH) return str;
 	const firstChar = str.charCodeAt(0);
-	// skip everything that doesn't look like a number
-	// charCodes: "-": 45, "1": 49, "9": 57
-	if (firstChar < 49) {
-		if (firstChar !== 45) return str;
-	} else if (firstChar > 57) {
+	// Skip everything that doesn't start like a number ("-" or a digit).
+	if (firstChar < CC_DIGIT_ONE) {
+		if (firstChar !== CC_HYPHEN_MINUS) return str;
+	} else if (firstChar > CC_DIGIT_NINE) {
 		return str;
 	}
 	if (str === String(Number(str))) {
@@ -70,11 +79,16 @@ const requestToId = (request) =>
  * @returns {string} string with limited max length to 100 chars
  */
 const shortenLongString = (string, delimiter, hashFunction) => {
-	if (string.length < 100) return string;
+	if (string.length < MAX_SHORTENED_STRING_LENGTH) return string;
 	return (
-		string.slice(0, 100 - 6 - delimiter.length) +
+		string.slice(
+			0,
+			MAX_SHORTENED_STRING_LENGTH -
+				SHORTENED_STRING_HASH_LENGTH -
+				delimiter.length
+		) +
 		delimiter +
-		getHash(string, 6, hashFunction)
+		getHash(string, SHORTENED_STRING_HASH_LENGTH, hashFunction)
 	);
 };
 
@@ -363,7 +377,7 @@ const assignNames = (
 			items.sort(comparator);
 			let i = 0;
 			for (const item of items) {
-				while (nameToItems2.has(name + i) && usedIds.has(name + i)) i++;
+				while (usedIds.has(name + i)) i++;
 				assignName(item, name + i);
 				usedIds.add(name + i);
 				i++;

package/lib/index.js

@@ -606,6 +606,12 @@ module.exports = mergeExports(fn, {
 		}
 	},
 
+	html: {
+		get HtmlModulesPlugin() {
+			return require("./html/HtmlModulesPlugin");
+		}
+	},
+
 	library: {
 		get AbstractLibraryPlugin() {
 			return require("./library/AbstractLibraryPlugin");

package/lib/javascript/ArrayPushCallbackChunkFormatPlugin.js

@@ -65,12 +65,11 @@ class ArrayPushCallbackChunkFormatPlugin {
 				} else {
 					const chunkLoadingGlobal =
 						runtimeTemplate.outputOptions.chunkLoadingGlobal;
+					const chunkLoadingGlobalExpr = `${globalObject}[${JSON.stringify(
+						chunkLoadingGlobal
+					)}]`;
 					source.add(
-						`(${globalObject}[${JSON.stringify(
-							chunkLoadingGlobal
-						)}] = ${globalObject}[${JSON.stringify(
-							chunkLoadingGlobal
-						)}] || []).push([`
+						`(${runtimeTemplate.assignOr(chunkLoadingGlobalExpr, "[]")}).push([`
 					);
 					source.add(`${JSON.stringify(chunk.ids)},`);
 					source.add(modules);

package/lib/javascript/BasicEvaluatedExpression.js

@@ -31,36 +31,46 @@ const TypeBigInt = 13;
 /** @typedef {() => MembersOptionals} GetMembersOptionals */
 /** @typedef {() => MemberRanges} GetMemberRanges */
 
+// _flags bit layout: bits 0-3 type, then the boolean facts
+const FLAG_TYPE_MASK = 0b1111;
+const FLAG_TRUTHY = 0b10000;
+const FLAG_FALSY = 0b100000;
+const FLAG_NULLISH_KNOWN = 0b1000000;
+const FLAG_NULLISH = 0b10000000;
+const FLAG_SIDE_EFFECTS = 0b100000000;
+
+/**
+ * An instance is allocated for a large share of walked expressions, so the
+ * boolean facts live in one packed flags slot and the scalar/identifier
+ * fields in five slots shared by type, with accessors keeping every public
+ * field readable. This shrinks instances from 224 to 144 bytes on V8.
+ */
 class BasicEvaluatedExpression {
 	constructor() {
-		/** @type {number} */
-		this.type = TypeUnknown;
+		this._flags = FLAG_SIDE_EFFECTS;
 		/** @type {Range | undefined} */
-		this.range = undefined;
-		/** @type {boolean} */
-		this.falsy = false;
-		/** @type {boolean} */
-		this.truthy = false;
-		/** @type {boolean | undefined} */
-		this.nullish = undefined;
-		/** @type {boolean} */
-		this.sideEffects = true;
-		/** @type {boolean | undefined} */
-		this.bool = undefined;
-		/** @type {number | undefined} */
-		this.number = undefined;
-		/** @type {bigint | undefined} */
-		this.bigint = undefined;
-		/** @type {RegExp | undefined} */
-		this.regExp = undefined;
-		/** @type {string | undefined} */
-		this.string = undefined;
+		this._range = undefined;
+		/** @type {Node | undefined} */
+		this.expression = undefined;
+		// _v1..._v5 hold the scalar type-specific fields, the accessors narrow
+		// them by type; expression-valued fields get typed slots below
+		/** @type {unknown} */
+		this._v1 = undefined;
+		/** @type {unknown} */
+		this._v2 = undefined;
+		/** @type {unknown} */
+		this._v3 = undefined;
+		/** @type {unknown} */
+		this._v4 = undefined;
+		/** @type {unknown} */
+		this._v5 = undefined;
+		// expression-valued fields stay plain data properties: a type that
+		// references the class inside one of its own accessors makes tsc fork
+		// the class into two unrelated identities
 		/** @type {BasicEvaluatedExpression[] | undefined} */
 		this.quasis = undefined;
 		/** @type {BasicEvaluatedExpression[] | undefined} */
 		this.parts = undefined;
-		/** @type {EXPECTED_ANY[] | undefined} */
-		this.array = undefined;
 		/** @type {BasicEvaluatedExpression[] | undefined} */
 		this.items = undefined;
 		/** @type {BasicEvaluatedExpression[] | undefined} */
@@ -71,18 +81,304 @@ class BasicEvaluatedExpression {
 		this.postfix = undefined;
 		/** @type {BasicEvaluatedExpression[] | undefined} */
 		this.wrappedInnerExpressions = undefined;
-		/** @type {string | VariableInfo | undefined} */
-		this.identifier = undefined;
-		/** @type {string | VariableInfo | undefined} */
-		this.rootInfo = undefined;
-		/** @type {GetMembers | undefined} */
-		this.getMembers = undefined;
-		/** @type {GetMembersOptionals | undefined} */
-		this.getMembersOptionals = undefined;
-		/** @type {GetMemberRanges | undefined} */
-		this.getMemberRanges = undefined;
-		/** @type {Node | undefined} */
-		this.expression = undefined;
+	}
+
+	/**
+	 * Served lazily from the attached expression when not set explicitly:
+	 * `evaluateExpression`'s plain results share the expression's range, and
+	 * most evaluations never read it, so the node's range array is only
+	 * materialized on demand.
+	 * @returns {Range | undefined} range of the evaluated expression
+	 */
+	get range() {
+		const range = this._range;
+		if (range !== undefined) return range;
+		const expression = this.expression;
+		return expression === undefined
+			? undefined
+			: /** @type {Range} */ (
+					/** @type {{ range?: Range }} */ (expression).range
+				);
+	}
+
+	/**
+	 * @param {Range | undefined} value range of the evaluated expression
+	 */
+	set range(value) {
+		this._range = value;
+	}
+
+	/**
+	 * @returns {number} expression type
+	 */
+	get type() {
+		return this._flags & FLAG_TYPE_MASK;
+	}
+
+	/**
+	 * @param {number} value expression type
+	 */
+	set type(value) {
+		this._flags = (this._flags & ~FLAG_TYPE_MASK) | value;
+	}
+
+	/**
+	 * @returns {boolean} true when the expression is known truthy
+	 */
+	get truthy() {
+		return (this._flags & FLAG_TRUTHY) !== 0;
+	}
+
+	/**
+	 * @param {boolean} value known truthy
+	 */
+	set truthy(value) {
+		this._flags = value
+			? this._flags | FLAG_TRUTHY
+			: this._flags & ~FLAG_TRUTHY;
+	}
+
+	/**
+	 * @returns {boolean} true when the expression is known falsy
+	 */
+	get falsy() {
+		return (this._flags & FLAG_FALSY) !== 0;
+	}
+
+	/**
+	 * @param {boolean} value known falsy
+	 */
+	set falsy(value) {
+		this._flags = value ? this._flags | FLAG_FALSY : this._flags & ~FLAG_FALSY;
+	}
+
+	/**
+	 * @returns {boolean | undefined} whether the value is nullish, when known
+	 */
+	get nullish() {
+		return (this._flags & FLAG_NULLISH_KNOWN) === 0
+			? undefined
+			: (this._flags & FLAG_NULLISH) !== 0;
+	}
+
+	/**
+	 * @param {boolean | undefined} value whether the value is nullish
+	 */
+	set nullish(value) {
+		this._flags =
+			value === undefined
+				? this._flags & ~(FLAG_NULLISH_KNOWN | FLAG_NULLISH)
+				: value
+					? this._flags | FLAG_NULLISH_KNOWN | FLAG_NULLISH
+					: (this._flags | FLAG_NULLISH_KNOWN) & ~FLAG_NULLISH;
+	}
+
+	/**
+	 * @returns {boolean} true when the expression could have side effects
+	 */
+	get sideEffects() {
+		return (this._flags & FLAG_SIDE_EFFECTS) !== 0;
+	}
+
+	/**
+	 * @param {boolean} value could have side effects
+	 */
+	set sideEffects(value) {
+		this._flags = value
+			? this._flags | FLAG_SIDE_EFFECTS
+			: this._flags & ~FLAG_SIDE_EFFECTS;
+	}
+
+	/**
+	 * @returns {boolean | undefined} boolean value when boolean-typed
+	 */
+	get bool() {
+		return this.type === TypeBoolean
+			? /** @type {boolean} */ (this._v1)
+			: undefined;
+	}
+
+	/**
+	 * @param {boolean | undefined} value boolean value
+	 */
+	set bool(value) {
+		this._v1 = value;
+	}
+
+	/**
+	 * @returns {number | undefined} number value when number-typed
+	 */
+	get number() {
+		return this.type === TypeNumber
+			? /** @type {number} */ (this._v1)
+			: undefined;
+	}
+
+	/**
+	 * @param {number | undefined} value number value
+	 */
+	set number(value) {
+		this._v1 = value;
+	}
+
+	/**
+	 * @returns {bigint | undefined} bigint value when bigint-typed
+	 */
+	get bigint() {
+		return this.type === TypeBigInt
+			? /** @type {bigint} */ (this._v1)
+			: undefined;
+	}
+
+	/**
+	 * @param {bigint | undefined} value bigint value
+	 */
+	set bigint(value) {
+		this._v1 = value;
+	}
+
+	/**
+	 * @returns {RegExp | undefined} regexp value when regexp-typed
+	 */
+	get regExp() {
+		return this.type === TypeRegExp
+			? /** @type {RegExp} */ (this._v1)
+			: undefined;
+	}
+
+	/**
+	 * @param {RegExp | undefined} value regexp value
+	 */
+	set regExp(value) {
+		this._v1 = value;
+	}
+
+	/**
+	 * @returns {string | undefined} string value when string-typed
+	 */
+	get string() {
+		return this.type === TypeString
+			? /** @type {string} */ (this._v1)
+			: undefined;
+	}
+
+	/**
+	 * @param {string | undefined} value string value
+	 */
+	set string(value) {
+		this._v1 = value;
+	}
+
+	/**
+	 * @returns {"cooked" | "raw" | undefined} template string kind
+	 */
+	get templateStringKind() {
+		return this.type === TypeTemplateString
+			? /** @type {"cooked" | "raw"} */ (this._v3)
+			: undefined;
+	}
+
+	/**
+	 * @param {"cooked" | "raw" | undefined} value template string kind
+	 */
+	set templateStringKind(value) {
+		this._v3 = value;
+	}
+
+	/**
+	 * @returns {EXPECTED_ANY[] | undefined} const array values
+	 */
+	get array() {
+		return this.type === TypeConstArray
+			? /** @type {unknown[]} */ (this._v1)
+			: undefined;
+	}
+
+	/**
+	 * @param {EXPECTED_ANY[] | undefined} value const array values
+	 */
+	set array(value) {
+		this._v1 = value;
+	}
+
+	/**
+	 * @returns {string | VariableInfo | undefined} identifier
+	 */
+	get identifier() {
+		return this.type === TypeIdentifier
+			? /** @type {string | VariableInfo} */ (this._v1)
+			: undefined;
+	}
+
+	/**
+	 * @param {string | VariableInfo | undefined} value identifier
+	 */
+	set identifier(value) {
+		this._v1 = value;
+	}
+
+	/**
+	 * @returns {string | VariableInfo | undefined} root info
+	 */
+	get rootInfo() {
+		return this.type === TypeIdentifier
+			? /** @type {string | VariableInfo} */ (this._v2)
+			: undefined;
+	}
+
+	/**
+	 * @param {string | VariableInfo | undefined} value root info
+	 */
+	set rootInfo(value) {
+		this._v2 = value;
+	}
+
+	/**
+	 * @returns {GetMembers | undefined} members getter
+	 */
+	get getMembers() {
+		return this.type === TypeIdentifier
+			? /** @type {GetMembers} */ (this._v3)
+			: undefined;
+	}
+
+	/**
+	 * @param {GetMembers | undefined} value members getter
+	 */
+	set getMembers(value) {
+		this._v3 = value;
+	}
+
+	/**
+	 * @returns {GetMembersOptionals | undefined} members optionals getter
+	 */
+	get getMembersOptionals() {
+		return this.type === TypeIdentifier
+			? /** @type {GetMembersOptionals} */ (this._v4)
+			: undefined;
+	}
+
+	/**
+	 * @param {GetMembersOptionals | undefined} value members optionals getter
+	 */
+	set getMembersOptionals(value) {
+		this._v4 = value;
+	}
+
+	/**
+	 * @returns {GetMemberRanges | undefined} member ranges getter
+	 */
+	get getMemberRanges() {
+		return this.type === TypeIdentifier
+			? /** @type {GetMemberRanges} */ (this._v5)
+			: undefined;
+	}
+
+	/**
+	 * @param {GetMemberRanges | undefined} value member ranges getter
+	 */
+	set getMemberRanges(value) {
+		this._v5 = value;
 	}
 
 	isUnknown() {
@@ -538,7 +834,7 @@ class BasicEvaluatedExpression {
 	 * @returns {this} this
 	 */
 	setRange(range) {
-		this.range = range;
+		this._range = range;
 		return this;
 	}
 
@@ -572,34 +868,56 @@ BasicEvaluatedExpression.isValidRegExpFlags = (flags) => {
 	const len = flags.length;
 
 	if (len === 0) return true;
-	if (len > 4) return false;
-
-	// cspell:word gimy
-	let remaining = 0b0000; // bit per RegExp flag: gimy
+	// 8 standard flags: d g i m s u v y
+	if (len > 8) return false;
+
+	const D = 1; // d hasIndices
+	const G = 2; // g global
+	const I = 4; // i ignoreCase
+	const M = 8; // m multiline
+	const S = 16; // s dotAll
+	const U = 32; // u unicode
+	const V = 64; // v unicodeSets
+	const Y = 128; // y sticky
+	let seen = 0;
 
 	for (let i = 0; i < len; i++) {
+		let bit;
 		switch (flags.charCodeAt(i)) {
+			case 100 /* d */:
+				bit = D;
+				break;
 			case 103 /* g */:
-				if (remaining & 0b1000) return false;
-				remaining |= 0b1000;
+				bit = G;
 				break;
 			case 105 /* i */:
-				if (remaining & 0b0100) return false;
-				remaining |= 0b0100;
+				bit = I;
 				break;
 			case 109 /* m */:
-				if (remaining & 0b0010) return false;
-				remaining |= 0b0010;
+				bit = M;
+				break;
+			case 115 /* s */:
+				bit = S;
+				break;
+			case 117 /* u */:
+				bit = U;
+				break;
+			case 118 /* v */:
+				bit = V;
 				break;
 			case 121 /* y */:
-				if (remaining & 0b0001) return false;
-				remaining |= 0b0001;
+				bit = Y;
 				break;
 			default:
 				return false;
 		}
+		if (seen & bit) return false; // duplicate flag
+		seen |= bit;
 	}
 
+	// `u` and `v` are mutually exclusive
+	if (seen & U && seen & V) return false;
+
 	return true;
 };