webpack 5.96.1 → 5.97.0

package/lib/css/walkCssTokens.js

@@ -22,6 +22,7 @@
  * @property {(function(string, number, number): number)=} rightCurlyBracket
  * @property {(function(string, number, number): number)=} semicolon
  * @property {(function(string, number, number): number)=} comma
+ * @property {(function(): boolean)=} needTerminate
  */
 
 /** @typedef {function(string, number, CssTokenCallbacks): number} CharHandler */
@@ -77,13 +78,6 @@ const CC_HYPHEN_MINUS = "-".charCodeAt(0);
 const CC_LESS_THAN_SIGN = "<".charCodeAt(0);
 const CC_GREATER_THAN_SIGN = ">".charCodeAt(0);
 
-/**
- * @param {number} cc char code
- * @returns {boolean} true, if cc is a newline
- */
-const _isNewLine = cc =>
-	cc === CC_LINE_FEED || cc === CC_CARRIAGE_RETURN || cc === CC_FORM_FEED;
-
 /** @type {CharHandler} */
 const consumeSpace = (input, pos, _callbacks) => {
 	// Consume as much whitespace as possible.
@@ -95,6 +89,11 @@ const consumeSpace = (input, pos, _callbacks) => {
 	return pos;
 };
 
+// U+000A LINE FEED. Note that U+000D CARRIAGE RETURN and U+000C FORM FEED are not included in this definition,
+// as they are converted to U+000A LINE FEED during preprocessing.
+//
+// Replace any U+000D CARRIAGE RETURN (CR) code points, U+000C FORM FEED (FF) code points, or pairs of U+000D CARRIAGE RETURN (CR) followed by U+000A LINE FEED (LF) in input by a single U+000A LINE FEED (LF) code point.
+
 /**
  * @param {number} cc char code
  * @returns {boolean} true, if cc is a newline
@@ -102,6 +101,20 @@ const consumeSpace = (input, pos, _callbacks) => {
 const _isNewline = cc =>
 	cc === CC_LINE_FEED || cc === CC_CARRIAGE_RETURN || cc === CC_FORM_FEED;
 
+/**
+ * @param {number} cc char code
+ * @param {string} input input
+ * @param {number} pos position
+ * @returns {number} position
+ */
+const consumeExtraNewline = (cc, input, pos) => {
+	if (cc === CC_CARRIAGE_RETURN && input.charCodeAt(pos) === CC_LINE_FEED) {
+		pos++;
+	}
+
+	return pos;
+};
+
 /**
  * @param {number} cc char code
  * @returns {boolean} true, if cc is a space (U+0009 CHARACTER TABULATION or U+0020 SPACE)
@@ -215,8 +228,11 @@ const _consumeAnEscapedCodePoint = (input, pos) => {
 			}
 		}
 
-		if (_isWhiteSpace(input.charCodeAt(pos))) {
+		const cc = input.charCodeAt(pos);
+
+		if (_isWhiteSpace(cc)) {
 			pos++;
+			pos = consumeExtraNewline(cc, input, pos);
 		}
 
 		return pos;
@@ -266,7 +282,7 @@ const consumeAStringToken = (input, pos, callbacks) => {
 		// newline
 		// This is a parse error.
 		// Reconsume the current input code point, create a <bad-string-token>, and return it.
-		else if (_isNewLine(cc)) {
+		else if (_isNewline(cc)) {
 			pos--;
 			// bad string
 			return pos;
@@ -278,8 +294,10 @@ const consumeAStringToken = (input, pos, callbacks) => {
 				return pos;
 			}
 			// Otherwise, if the next input code point is a newline, consume it.
-			else if (_isNewLine(input.charCodeAt(pos))) {
+			else if (_isNewline(input.charCodeAt(pos))) {
+				const cc = input.charCodeAt(pos);
 				pos++;
+				pos = consumeExtraNewline(cc, input, pos);
 			}
 			// Otherwise, (the stream starts with a valid escape) consume an escaped code point and append the returned code point to the <string-token>’s value.
 			else if (_ifTwoCodePointsAreValidEscape(input, pos)) {
@@ -350,7 +368,7 @@ const _ifTwoCodePointsAreValidEscape = (input, pos, f, s) => {
 	// If the first code point is not U+005C REVERSE SOLIDUS (\), return false.
 	if (first !== CC_REVERSE_SOLIDUS) return false;
 	// Otherwise, if the second code point is a newline, return false.
-	if (_isNewLine(second)) return false;
+	if (_isNewline(second)) return false;
 	// Otherwise, return true.
 	return true;
 };
@@ -1156,12 +1174,12 @@ const consumeAToken = (input, pos, callbacks) => {
 
 /**
  * @param {string} input input css
- * @param {CssTokenCallbacks} callbacks callbacks
- * @returns {void}
+ * @param {number=} pos pos
+ * @param {CssTokenCallbacks=} callbacks callbacks
+ * @returns {number} pos
  */
-module.exports = (input, callbacks) => {
+module.exports = (input, pos = 0, callbacks = {}) => {
 	// This section describes how to consume a token from a stream of code points. It will return a single token of any type.
-	let pos = 0;
 	while (pos < input.length) {
 		// Consume comments.
 		pos = consumeComments(input, pos, callbacks);
@@ -1169,7 +1187,13 @@ module.exports = (input, callbacks) => {
 		// Consume the next input code point.
 		pos++;
 		pos = consumeAToken(input, pos, callbacks);
+
+		if (callbacks.needTerminate && callbacks.needTerminate()) {
+			break;
+		}
 	}
+
+	return pos;
 };
 
 module.exports.isIdentStartCodePoint = isIdentStartCodePoint;
@@ -1253,10 +1277,8 @@ module.exports.eatWhiteLine = (input, pos) => {
 			pos++;
 			continue;
 		}
-		if (_isNewLine(cc)) pos++;
-		// For `\r\n`
-		if (cc === CC_CARRIAGE_RETURN && input.charCodeAt(pos + 1) === CC_LINE_FEED)
-			pos++;
+		if (_isNewline(cc)) pos++;
+		pos = consumeExtraNewline(cc, input, pos);
 		break;
 	}
 

package/lib/dependencies/CachedConstDependency.js

@@ -52,8 +52,9 @@ class CachedConstDependency extends NullDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		if (this._hashUpdate === undefined)
+		if (this._hashUpdate === undefined) {
 			this._hashUpdate = this._createHashUpdate();
+		}
 		hash.update(this._hashUpdate);
 	}
 

package/lib/dependencies/ContextDependencyTemplateAsId.js

@@ -24,15 +24,16 @@ class ContextDependencyTemplateAsId extends ContextDependency.Template {
 		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
 	) {
 		const dep = /** @type {ContextDependency} */ (dependency);
+		const module = moduleGraph.getModule(dep);
 		const moduleExports = runtimeTemplate.moduleExports({
-			module: moduleGraph.getModule(dep),
+			module,
 			chunkGraph,
 			request: dep.request,
 			weak: dep.weak,
 			runtimeRequirements
 		});
 
-		if (moduleGraph.getModule(dep)) {
+		if (module) {
 			if (dep.valueRange) {
 				if (Array.isArray(dep.replaces)) {
 					for (let i = 0; i < dep.replaces.length; i++) {

package/lib/dependencies/{CssExportDependency.js → CssIcssExportDependency.js}

@@ -17,13 +17,12 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../css/CssExportsGenerator")} CssExportsGenerator */
 /** @typedef {import("../css/CssGenerator")} CssGenerator */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 
-class CssExportDependency extends NullDependency {
+class CssIcssExportDependency extends NullDependency {
 	/**
 	 * @param {string} name name
 	 * @param {string} value value
@@ -32,6 +31,7 @@ class CssExportDependency extends NullDependency {
 		super();
 		this.name = name;
 		this.value = value;
+		this._hashUpdate = undefined;
 	}
 
 	get type() {
@@ -59,7 +59,7 @@ class CssExportDependency extends NullDependency {
 	getExports(moduleGraph) {
 		const module = /** @type {CssModule} */ (moduleGraph.getParentModule(this));
 		const convention =
-			/** @type {CssGenerator | CssExportsGenerator} */
+			/** @type {CssGenerator} */
 			(module.generator).convention;
 		const names = this.getExportsConventionNames(this.name, convention);
 		return {
@@ -78,18 +78,21 @@ class CssExportDependency extends NullDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, { chunkGraph }) {
-		const module = /** @type {CssModule} */ (
-			chunkGraph.moduleGraph.getParentModule(this)
-		);
-		const generator =
-			/** @type {CssGenerator | CssExportsGenerator} */
-			(module.generator);
-		const names = this.getExportsConventionNames(
-			this.name,
-			generator.convention
-		);
+		if (this._hashUpdate === undefined) {
+			const module =
+				/** @type {CssModule} */
+				(chunkGraph.moduleGraph.getParentModule(this));
+			const generator =
+				/** @type {CssGenerator} */
+				(module.generator);
+			const names = this.getExportsConventionNames(
+				this.name,
+				generator.convention
+			);
+			this._hashUpdate = JSON.stringify(names);
+		}
 		hash.update("exportsConvention");
-		hash.update(JSON.stringify(names));
+		hash.update(this._hashUpdate);
 	}
 
 	/**
@@ -113,7 +116,7 @@ class CssExportDependency extends NullDependency {
 	}
 }
 
-CssExportDependency.Template = class CssExportDependencyTemplate extends (
+CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate extends (
 	NullDependency.Template
 ) {
 	/**
@@ -122,35 +125,32 @@ CssExportDependency.Template = class CssExportDependencyTemplate extends (
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(
-		dependency,
-		source,
-		{ cssExportsData, module: m, runtime, moduleGraph }
-	) {
-		const dep = /** @type {CssExportDependency} */ (dependency);
+	apply(dependency, source, { cssData, module: m, runtime, moduleGraph }) {
+		const dep = /** @type {CssIcssExportDependency} */ (dependency);
 		const module = /** @type {CssModule} */ (m);
 		const convention =
-			/** @type {CssGenerator | CssExportsGenerator} */
+			/** @type {CssGenerator} */
 			(module.generator).convention;
 		const names = dep.getExportsConventionNames(dep.name, convention);
-		const usedNames = /** @type {string[]} */ (
-			names
-				.map(name =>
-					moduleGraph.getExportInfo(module, name).getUsedName(name, runtime)
-				)
-				.filter(Boolean)
-		);
-		if (usedNames.length === 0) return;
+		const usedNames =
+			/** @type {string[]} */
+			(
+				names
+					.map(name =>
+						moduleGraph.getExportInfo(module, name).getUsedName(name, runtime)
+					)
+					.filter(Boolean)
+			);
 
-		for (const used of usedNames) {
-			cssExportsData.exports.set(used, dep.value);
+		for (const used of usedNames.concat(names)) {
+			cssData.exports.set(used, dep.value);
 		}
 	}
 };
 
 makeSerializable(
-	CssExportDependency,
-	"webpack/lib/dependencies/CssExportDependency"
+	CssIcssExportDependency,
+	"webpack/lib/dependencies/CssIcssExportDependency"
 );
 
-module.exports = CssExportDependency;
+module.exports = CssIcssExportDependency;

package/lib/dependencies/CssIcssImportDependency.js

@@ -0,0 +1,118 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const CssIcssExportDependency = require("./CssIcssExportDependency");
+const CssLocalIdentifierDependency = require("./CssLocalIdentifierDependency");
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+class CssIcssImportDependency extends ModuleDependency {
+	/**
+	 * Example of dependency:
+	 *
+	 *:import('./style.css') { IMPORTED_NAME: v-primary }
+	 * @param {string} request request request path which needs resolving
+	 * @param {string} exportName export name
+	 * @param {[number, number]} range the range of dependency
+	 */
+	constructor(request, exportName, range) {
+		super(request);
+		this.range = range;
+		this.exportName = exportName;
+	}
+
+	get type() {
+		return "css :import";
+	}
+
+	get category() {
+		return "css-import";
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		write(this.exportName);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		this.exportName = read();
+		super.deserialize(context);
+	}
+}
+
+CssIcssImportDependency.Template = class CssIcssImportDependencyTemplate extends (
+	ModuleDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {
+		const dep = /** @type {CssIcssImportDependency} */ (dependency);
+		const { range } = dep;
+		const module = templateContext.moduleGraph.getModule(dep);
+		let value;
+
+		for (const item of module.dependencies) {
+			if (
+				item instanceof CssLocalIdentifierDependency &&
+				dep.exportName === item.name
+			) {
+				value = CssLocalIdentifierDependency.Template.getIdentifier(
+					item,
+					dep.exportName,
+					{
+						...templateContext,
+						module
+					}
+				);
+				break;
+			} else if (
+				item instanceof CssIcssExportDependency &&
+				dep.exportName === item.name
+			) {
+				value = item.value;
+				break;
+			}
+		}
+
+		if (!value) {
+			throw new Error(
+				`Imported '${dep.exportName}' name from '${dep.request}' not found`
+			);
+		}
+
+		source.replace(range[0], range[1], value);
+	}
+};
+
+makeSerializable(
+	CssIcssImportDependency,
+	"webpack/lib/dependencies/CssIcssImportDependency"
+);
+
+module.exports = CssIcssImportDependency;

package/lib/dependencies/CssIcssSymbolDependency.js

@@ -0,0 +1,132 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const NullDependency = require("./NullDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../css/CssParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class CssIcssSymbolDependency extends NullDependency {
+	/**
+	 * @param {string} name name
+	 * @param {string} value value
+	 * @param {Range} range range
+	 */
+	constructor(name, value, range) {
+		super();
+		this.name = name;
+		this.value = value;
+		this.range = range;
+		this._hashUpdate = undefined;
+	}
+
+	get type() {
+		return "css @value identifier";
+	}
+
+	get category() {
+		return "self";
+	}
+
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate = `${this.range}${this.name}${this.value}`;
+		}
+		hash.update(this._hashUpdate);
+	}
+
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		return {
+			exports: [
+				{
+					name: this.name,
+					canMangle: true
+				}
+			],
+			dependencies: undefined
+		};
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		return [[this.name]];
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.name);
+		write(this.value);
+		write(this.range);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.name = read();
+		this.value = read();
+		this.range = read();
+		super.deserialize(context);
+	}
+}
+
+CssIcssSymbolDependency.Template = class CssValueAtRuleDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, { cssData }) {
+		const dep = /** @type {CssIcssSymbolDependency} */ (dependency);
+
+		source.replace(dep.range[0], dep.range[1] - 1, dep.value);
+
+		cssData.exports.set(dep.name, dep.value);
+	}
+};
+
+makeSerializable(
+	CssIcssSymbolDependency,
+	"webpack/lib/dependencies/CssIcssSymbolDependency"
+);
+
+module.exports = CssIcssSymbolDependency;

package/lib/dependencies/CssImportDependency.js

@@ -70,14 +70,6 @@ class CssImportDependency extends ModuleDependency {
 		return str;
 	}
 
-	/**
-	 * @param {string} context context directory
-	 * @returns {Module | null} a module
-	 */
-	createIgnoredModule(context) {
-		return null;
-	}
-
 	/**
 	 * @param {ObjectSerializerContext} context context
 	 */