webpack 5.102.1 → 5.104.0

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) => {
@@ -1197,6 +1207,106 @@ module.exports = (input, pos = 0, callbacks = {}) => {
 	return pos;
 };
 
+/**
+ * @param {string} input input css
+ * @param {number} pos pos
+ * @param {CssTokenCallbacks} callbacks callbacks
+ * @param {CssTokenCallbacks=} additional additional callbacks
+ * @param {{ onlyTopLevel?: boolean, declarationValue?: boolean, atRulePrelude?: boolean, functionValue?: boolean }=} options options
+ * @returns {number} pos
+ */
+const consumeUntil = (input, pos, callbacks, additional, options = {}) => {
+	let needHandle = true;
+	let needTerminate = false;
+
+	/** @type {CssTokenCallbacks} */
+	const servicedCallbacks = {};
+
+	let balanced = 0;
+
+	if (options.onlyTopLevel) {
+		servicedCallbacks.function = (input, start, end) => {
+			balanced++;
+			if (!options.functionValue) {
+				needHandle = false;
+			}
+
+			if (additional && additional.function !== undefined) {
+				return additional.function(input, start, end);
+			}
+
+			return end;
+		};
+
+		servicedCallbacks.leftParenthesis = (_input, _start, end) => {
+			balanced++;
+			needHandle = false;
+			return end;
+		};
+		servicedCallbacks.rightParenthesis = (_input, _start, end) => {
+			balanced--;
+			if (balanced === 0) {
+				needHandle = true;
+			}
+			return end;
+		};
+	}
+
+	if (options.declarationValue) {
+		servicedCallbacks.semicolon = (_input, _start, end) => {
+			needTerminate = true;
+			return end;
+		};
+
+		servicedCallbacks.rightCurlyBracket = (_input, _start, end) => {
+			needTerminate = true;
+			return end;
+		};
+	} else if (options.functionValue) {
+		servicedCallbacks.rightParenthesis = (_input, _start, end) => {
+			balanced--;
+			if (balanced === 0) {
+				needTerminate = true;
+			}
+			return end;
+		};
+	} else if (options.atRulePrelude) {
+		servicedCallbacks.leftCurlyBracket = (_input, _start, end) => {
+			needTerminate = true;
+			return end;
+		};
+		servicedCallbacks.semicolon = (_input, _start, end) => {
+			needTerminate = true;
+			return end;
+		};
+	}
+
+	while (pos < input.length) {
+		// Consume comments.
+		pos = consumeComments(
+			input,
+			pos,
+			needHandle ? { ...servicedCallbacks, ...callbacks } : servicedCallbacks
+		);
+
+		const start = pos;
+
+		// Consume the next input code point.
+		pos++;
+		pos = consumeAToken(
+			input,
+			pos,
+			needHandle ? { ...servicedCallbacks, ...callbacks } : servicedCallbacks
+		);
+
+		if (needTerminate) {
+			return start;
+		}
+	}
+
+	return pos;
+};
+
 /**
  * @param {string} input input
  * @param {number} pos position
@@ -1230,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) {
@@ -1244,7 +1359,7 @@ const eatWhitespaceAndComments = (input, pos) => {
 		}
 	}
 
-	return pos;
+	return [pos, foundWhitespace];
 };
 
 /**
@@ -1298,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;
 
@@ -1531,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;
 
@@ -1556,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;
 
@@ -1608,6 +1723,7 @@ const eatUntil = (chars) => {
 	};
 };
 
+module.exports.consumeUntil = consumeUntil;
 module.exports.eatComments = eatComments;
 module.exports.eatIdentSequence = eatIdentSequence;
 module.exports.eatIdentSequenceOrString = eatIdentSequenceOrString;
@@ -1619,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/CommonJsImportsParserPlugin.js

@@ -126,15 +126,6 @@ class CommonJsImportsParserPlugin {
 		});
 
 		// #region Unsupported
-		parser.hooks.expression
-			.for("require.main")
-			.tap(
-				PLUGIN_NAME,
-				expressionIsUnsupported(
-					parser,
-					"require.main is not supported by webpack."
-				)
-			);
 		parser.hooks.call
 			.for("require.main.require")
 			.tap(

package/lib/dependencies/CommonJsPlugin.js

@@ -15,6 +15,7 @@ const SelfModuleFactory = require("../SelfModuleFactory");
 const Template = require("../Template");
 const {
 	evaluateToIdentifier,
+	expressionIsUnsupported,
 	toConstantDependency
 } = require("../javascript/JavascriptParserHelpers");
 const CommonJsExportRequireDependency = require("./CommonJsExportRequireDependency");
@@ -198,6 +199,17 @@ class CommonJsPlugin {
 								[RuntimeGlobals.moduleCache, RuntimeGlobals.entryModuleId]
 							)
 						);
+
+					parser.hooks.expression
+						.for("require.extensions")
+						.tap(
+							PLUGIN_NAME,
+							expressionIsUnsupported(
+								parser,
+								"require.extensions is not supported by webpack. Use a loader instead."
+							)
+						);
+
 					parser.hooks.expression
 						.for(RuntimeGlobals.moduleLoaded)
 						.tap(PLUGIN_NAME, (expr) => {

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