@depup/webpack 5.106.1-depup.0 → 5.109.2-depup.0

package/lib/javascript/BasicEvaluatedExpression.js

@@ -31,35 +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() {
-		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} */
@@ -70,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() {
@@ -185,7 +482,7 @@ class BasicEvaluatedExpression {
 	}
 
 	/**
-	 * Gets the compile-time value of the expression
+	 * As compile time value.
 	 * @returns {undefined | null | string | number | boolean | RegExp | EXPECTED_ANY[] | bigint} the javascript value
 	 */
 	asCompileTimeValue() {
@@ -322,6 +619,7 @@ class BasicEvaluatedExpression {
 	}
 
 	/**
+	 * Updates string using the provided string.
 	 * @param {string} string value
 	 * @returns {BasicEvaluatedExpression} basic evaluated expression
 	 */
@@ -447,7 +745,7 @@ class BasicEvaluatedExpression {
 	}
 
 	/**
-	 * Adds options to a conditional expression.
+	 * Adds the provided basic evaluated expression to the basic evaluated expression.
 	 * @param {BasicEvaluatedExpression[]} options optional (consequent/alternate) expressions to be added
 	 * @returns {this} this
 	 */
@@ -536,7 +834,7 @@ class BasicEvaluatedExpression {
 	 * @returns {this} this
 	 */
 	setRange(range) {
-		this.range = range;
+		this._range = range;
 		return this;
 	}
 
@@ -562,6 +860,7 @@ class BasicEvaluatedExpression {
 }
 
 /**
+ * Returns is valid flags.
  * @param {string} flags regexp flags
  * @returns {boolean} is valid flags
  */
@@ -569,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;
 };
 

package/lib/javascript/ChunkFormatHelpers.js

@@ -15,7 +15,7 @@ const { updateHashForEntryStartup } = require("./StartupHelpers");
 /** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
 
 /**
- * Gets information about a chunk including its entries and runtime chunk
+ * Returns } Object containing chunk entries and runtime chunk.
  * @param {Chunk} chunk The chunk to get information for
  * @param {ChunkGraph} chunkGraph The chunk graph containing the chunk
  * @returns {{ entries: [Module, Entrypoint | undefined][], runtimeChunk: Chunk | null }} Object containing chunk entries and runtime chunk
@@ -43,6 +43,7 @@ function getChunkInfo(chunk, chunkGraph) {
  */
 function createChunkHashHandler(name) {
 	/**
+	 * Processes the provided chunk.
 	 * @param {Chunk} chunk The chunk to get information for
 	 * @param {Hash} hash The hash to update
 	 * @param {ChunkHashContext} chunkHashContext The chunk hash context

package/lib/javascript/ChunkHelpers.js

@@ -10,6 +10,7 @@ const Entrypoint = require("../Entrypoint");
 /** @typedef {import("../Chunk")} Chunk */
 
 /**
+ * Returns chunks.
  * @param {Entrypoint} entrypoint a chunk group
  * @param {(Chunk | null)=} excludedChunk1 current chunk which is excluded
  * @param {(Chunk | null)=} excludedChunk2 runtime chunk which is excluded

package/lib/javascript/CommonJsChunkFormatPlugin.js

@@ -26,7 +26,7 @@ const PLUGIN_NAME = "CommonJsChunkFormatPlugin";
 
 class CommonJsChunkFormatPlugin {
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */

package/lib/javascript/EnableChunkLoadingPlugin.js

@@ -14,6 +14,7 @@
 const enabledTypes = new WeakMap();
 
 /**
+ * Returns enabled types.
  * @param {Compiler} compiler compiler
  * @returns {ChunkLoadingTypes} enabled types
  */
@@ -29,13 +30,16 @@ const getEnabledTypes = (compiler) => {
 
 class EnableChunkLoadingPlugin {
 	/**
+	 * Creates an instance of EnableChunkLoadingPlugin.
 	 * @param {ChunkLoadingType} type library type that should be available
 	 */
 	constructor(type) {
+		/** @type {string} */
 		this.type = type;
 	}
 
 	/**
+	 * Updates enabled using the provided compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @param {ChunkLoadingType} type type of library
 	 * @returns {void}
@@ -45,6 +49,7 @@ class EnableChunkLoadingPlugin {
 	}
 
 	/**
+	 * Checks enabled.
 	 * @param {Compiler} compiler the compiler instance
 	 * @param {ChunkLoadingType} type type of library
 	 * @returns {void}
@@ -62,7 +67,7 @@ class EnableChunkLoadingPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */