webpack 5.103.0 → 5.104.1

package/lib/css/walkCssTokens.js

@@ -10,16 +10,18 @@
  * @property {((input: string, start: number, end: number, innerStart: number, innerEnd: number) => number)=} url
  * @property {((input: string, start: number, end: number) => number)=} comment
  * @property {((input: string, start: number, end: number) => number)=} string
+ * @property {((input: string, start: number, end: number) => number)=} leftCurlyBracket
+ * @property {((input: string, start: number, end: number) => number)=} rightCurlyBracket
  * @property {((input: string, start: number, end: number) => number)=} leftParenthesis
  * @property {((input: string, start: number, end: number) => number)=} rightParenthesis
+ * @property {((input: string, start: number, end: number) => number)=} leftSquareBracket
+ * @property {((input: string, start: number, end: number) => number)=} rightSquareBracket
  * @property {((input: string, start: number, end: number) => number)=} function
  * @property {((input: string, start: number, end: number) => number)=} colon
  * @property {((input: string, start: number, end: number) => number)=} atKeyword
  * @property {((input: string, start: number, end: number) => number)=} delim
  * @property {((input: string, start: number, end: number) => number)=} identifier
  * @property {((input: string, start: number, end: number, isId: boolean) => number)=} hash
- * @property {((input: string, start: number, end: number) => number)=} leftCurlyBracket
- * @property {((input: string, start: number, end: number) => number)=} rightCurlyBracket
  * @property {((input: string, start: number, end: number) => number)=} semicolon
  * @property {((input: string, start: number, end: number) => number)=} comma
  * @property {(() => boolean)=} needTerminate
@@ -717,14 +719,22 @@ const consumeRightParenthesis = (input, pos, callbacks) => {
 };
 
 /** @type {CharHandler} */
-const consumeLeftSquareBracket = (input, pos, _callbacks) =>
+const consumeLeftSquareBracket = (input, pos, callbacks) => {
 	// Return a <]-token>.
-	pos;
+	if (callbacks.leftSquareBracket !== undefined) {
+		return callbacks.leftSquareBracket(input, pos - 1, pos);
+	}
+	return pos;
+};
 
 /** @type {CharHandler} */
-const consumeRightSquareBracket = (input, pos, _callbacks) =>
+const consumeRightSquareBracket = (input, pos, callbacks) => {
 	// Return a <]-token>.
-	pos;
+	if (callbacks.rightSquareBracket !== undefined) {
+		return callbacks.rightSquareBracket(input, pos - 1, pos);
+	}
+	return pos;
+};
 
 /** @type {CharHandler} */
 const consumeLeftCurlyBracket = (input, pos, callbacks) => {
@@ -1201,7 +1211,7 @@ module.exports = (input, pos = 0, callbacks = {}) => {
  * @param {string} input input css
  * @param {number} pos pos
  * @param {CssTokenCallbacks} callbacks callbacks
- * @param {CssTokenCallbacks} additional additional callbacks
+ * @param {CssTokenCallbacks=} additional additional callbacks
  * @param {{ onlyTopLevel?: boolean, declarationValue?: boolean, atRulePrelude?: boolean, functionValue?: boolean }=} options options
  * @returns {number} pos
  */
@@ -1221,7 +1231,7 @@ const consumeUntil = (input, pos, callbacks, additional, options = {}) => {
 				needHandle = false;
 			}
 
-			if (additional.function !== undefined) {
+			if (additional && additional.function !== undefined) {
 				return additional.function(input, start, end);
 			}
 
@@ -1265,6 +1275,10 @@ const consumeUntil = (input, pos, callbacks, additional, options = {}) => {
 			needTerminate = true;
 			return end;
 		};
+		servicedCallbacks.semicolon = (_input, _start, end) => {
+			needTerminate = true;
+			return end;
+		};
 	}
 
 	while (pos < input.length) {
@@ -1326,13 +1340,18 @@ const eatWhitespace = (input, pos) => {
 /**
  * @param {string} input input
  * @param {number} pos position
- * @returns {number} position after whitespace and comments
+ * @returns {[number, boolean]} position after whitespace and comments
  */
 const eatWhitespaceAndComments = (input, pos) => {
+	let foundWhitespace = false;
+
 	for (;;) {
 		const originalPos = pos;
 		pos = consumeComments(input, pos, {});
 		while (_isWhiteSpace(input.charCodeAt(pos))) {
+			if (!foundWhitespace) {
+				foundWhitespace = true;
+			}
 			pos++;
 		}
 		if (originalPos === pos) {
@@ -1340,7 +1359,7 @@ const eatWhitespaceAndComments = (input, pos) => {
 		}
 	}
 
-	return pos;
+	return [pos, foundWhitespace];
 };
 
 /**
@@ -1394,7 +1413,7 @@ const skipCommentsAndEatIdentSequence = (input, pos) => {
  * @returns {[number, number] | undefined} positions of ident sequence
  */
 const eatString = (input, pos) => {
-	pos = eatWhitespaceAndComments(input, pos);
+	pos = eatWhitespaceAndComments(input, pos)[0];
 
 	const start = pos;
 
@@ -1627,7 +1646,7 @@ const eatImportTokens = (input, pos, cbs) => {
  * @returns {[number, number] | undefined} positions of ident sequence
  */
 const eatIdentSequence = (input, pos) => {
-	pos = eatWhitespaceAndComments(input, pos);
+	pos = eatWhitespaceAndComments(input, pos)[0];
 
 	const start = pos;
 
@@ -1652,7 +1671,7 @@ const eatIdentSequence = (input, pos) => {
  * @returns {[number, number, boolean] | undefined} positions of ident sequence or string
  */
 const eatIdentSequenceOrString = (input, pos) => {
-	pos = eatWhitespaceAndComments(input, pos);
+	pos = eatWhitespaceAndComments(input, pos)[0];
 
 	const start = pos;
 
@@ -1716,5 +1735,6 @@ module.exports.eatWhiteLine = eatWhiteLine;
 module.exports.eatWhitespace = eatWhitespace;
 module.exports.eatWhitespaceAndComments = eatWhitespaceAndComments;
 module.exports.isIdentStartCodePoint = isIdentStartCodePoint;
+module.exports.isWhiteSpace = _isWhiteSpace;
 module.exports.skipCommentsAndEatIdentSequence =
 	skipCommentsAndEatIdentSequence;

package/lib/dependencies/CachedConstDependency.js

@@ -22,15 +22,22 @@ const NullDependency = require("./NullDependency");
 class CachedConstDependency extends NullDependency {
 	/**
 	 * @param {string} expression expression
-	 * @param {Range} range range
+	 * @param {Range | null} range range
 	 * @param {string} identifier identifier
+	 * @param {number=} place place where we inject the expression
 	 */
-	constructor(expression, range, identifier) {
+	constructor(
+		expression,
+		range,
+		identifier,
+		place = CachedConstDependency.PLACE_MODULE
+	) {
 		super();
 
 		this.expression = expression;
 		this.range = range;
 		this.identifier = identifier;
+		this.place = place;
 		this._hashUpdate = undefined;
 	}
 
@@ -38,7 +45,7 @@ class CachedConstDependency extends NullDependency {
 	 * @returns {string} hash update
 	 */
 	_createHashUpdate() {
-		return `${this.identifier}${this.range}${this.expression}`;
+		return `${this.place}${this.identifier}${this.range}${this.expression}`;
 	}
 
 	/**
@@ -63,6 +70,7 @@ class CachedConstDependency extends NullDependency {
 		write(this.expression);
 		write(this.range);
 		write(this.identifier);
+		write(this.place);
 
 		super.serialize(context);
 	}
@@ -76,11 +84,15 @@ class CachedConstDependency extends NullDependency {
 		this.expression = read();
 		this.range = read();
 		this.identifier = read();
+		this.place = read();
 
 		super.deserialize(context);
 	}
 }
 
+CachedConstDependency.PLACE_MODULE = 10;
+CachedConstDependency.PLACE_CHUNK = 20;
+
 makeSerializable(
 	CachedConstDependency,
 	"webpack/lib/dependencies/CachedConstDependency"
@@ -95,25 +107,27 @@ CachedConstDependency.Template = class CachedConstDependencyTemplate extends (
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(dependency, source, { initFragments }) {
+	apply(dependency, source, { initFragments, chunkInitFragments }) {
 		const dep = /** @type {CachedConstDependency} */ (dependency);
 
-		initFragments.push(
+		(dep.place === CachedConstDependency.PLACE_MODULE
+			? initFragments
+			: chunkInitFragments
+		).push(
 			new InitFragment(
 				`var ${dep.identifier} = ${dep.expression};\n`,
 				InitFragment.STAGE_CONSTANTS,
-				0,
+				// For a chunk we inject expression after imports
+				dep.place === CachedConstDependency.PLACE_MODULE ? 0 : 10,
 				`const ${dep.identifier}`
 			)
 		);
 
 		if (typeof dep.range === "number") {
 			source.insert(dep.range, dep.identifier);
-
-			return;
+		} else if (dep.range !== null) {
+			source.replace(dep.range[0], dep.range[1] - 1, dep.identifier);
 		}
-
-		source.replace(dep.range[0], dep.range[1] - 1, dep.identifier);
 	}
 };
 

package/lib/dependencies/CommonJsRequireContextDependency.js

@@ -19,7 +19,7 @@ class CommonJsRequireContextDependency extends ContextDependency {
 	 * @param {ContextDependencyOptions} options options for the context module
 	 * @param {Range} range location in source code
 	 * @param {Range | undefined} valueRange location of the require call
-	 * @param {boolean | string } inShorthand true or name
+	 * @param {boolean | string} inShorthand true or name
 	 * @param {string=} context context
 	 */
 	constructor(options, range, valueRange, inShorthand, context) {

package/lib/dependencies/ContextDependencyHelpers.js

@@ -42,14 +42,14 @@ const splitContextFromPrefix = (prefix) => {
 };
 
 /** @typedef {Partial<Omit<ContextDependencyOptions, "resource">>} PartialContextDependencyOptions */
-/** @typedef {{ new(options: ContextDependencyOptions, range: Range, valueRange: Range, ...args: any[]): ContextDependency }} ContextDependencyConstructor */
+/** @typedef {{ new(options: ContextDependencyOptions, range: Range, valueRange: Range, ...args: EXPECTED_ANY[]): ContextDependency }} ContextDependencyConstructor */
 
 /**
  * @param {ContextDependencyConstructor} Dep the Dependency class
  * @param {Range} range source range
  * @param {BasicEvaluatedExpression} param context param
  * @param {Expression} expr expr
- * @param {Pick<JavascriptParserOptions, `${"expr"|"wrapped"}Context${"Critical"|"Recursive"|"RegExp"}` | "exprContextRequest">} options options for context creation
+ * @param {Pick<JavascriptParserOptions, `${"expr" | "wrapped"}Context${"Critical" | "Recursive" | "RegExp"}` | "exprContextRequest">} options options for context creation
  * @param {PartialContextDependencyOptions} contextOptions options for the ContextModule
  * @param {JavascriptParser} parser the parser
  * @param {...EXPECTED_ANY} depArgs depArgs

package/lib/dependencies/ContextDependencyTemplateAsRequireCall.js

@@ -12,7 +12,9 @@ const ContextDependency = require("./ContextDependency");
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 
-class ContextDependencyTemplateAsRequireCall extends ContextDependency.Template {
+class ContextDependencyTemplateAsRequireCall
+	extends ContextDependency.Template
+{
 	/**
 	 * @param {Dependency} dependency the dependency for which the template should be applied
 	 * @param {ReplaceSource} source the current replace source which can be modified