webpack 5.64.2 → 5.66.0

package/lib/dependencies/CssExportDependency.js

@@ -0,0 +1,85 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"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("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+
+class CssExportDependency extends NullDependency {
+	/**
+	 * @param {string} name name
+	 * @param {string} value value
+	 */
+	constructor(name, value) {
+		super();
+		this.name = name;
+		this.value = value;
+	}
+
+	get type() {
+		return "css :export";
+	}
+
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		const name = this.name;
+		return {
+			exports: [
+				{
+					name,
+					canMangle: true
+				}
+			],
+			dependencies: undefined
+		};
+	}
+
+	serialize(context) {
+		const { write } = context;
+		write(this.name);
+		write(this.value);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+		this.name = read();
+		this.value = read();
+		super.deserialize(context);
+	}
+}
+
+CssExportDependency.Template = class CssExportDependencyTemplate 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, { cssExports }) {
+		const dep = /** @type {CssExportDependency} */ (dependency);
+		cssExports.set(dep.name, dep.value);
+	}
+};
+
+makeSerializable(
+	CssExportDependency,
+	"webpack/lib/dependencies/CssExportDependency"
+);
+
+module.exports = CssExportDependency;

package/lib/dependencies/CssImportDependency.js

@@ -0,0 +1,75 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class CssImportDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request
+	 * @param {[number, number]} range range of the argument
+	 * @param {string | undefined} supports list of supports conditions
+	 * @param {string | undefined} media list of media conditions
+	 */
+	constructor(request, range, supports, media) {
+		super(request);
+		this.range = range;
+		this.supports = supports;
+		this.media = media;
+	}
+
+	get type() {
+		return "css @import";
+	}
+
+	get category() {
+		return "css-import";
+	}
+
+	/**
+	 * @param {string} context context directory
+	 * @returns {Module} a module
+	 */
+	createIgnoredModule(context) {
+		return null;
+	}
+}
+
+CssImportDependency.Template = class CssImportDependencyTemplate 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 {CssImportDependency} */ (dependency);
+
+		source.replace(dep.range[0], dep.range[1] - 1, "");
+	}
+};
+
+makeSerializable(
+	CssImportDependency,
+	"webpack/lib/dependencies/CssImportDependency"
+);
+
+module.exports = CssImportDependency;

package/lib/dependencies/CssLocalIdentifierDependency.js

@@ -0,0 +1,119 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"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("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+
+class CssLocalIdentifierDependency extends NullDependency {
+	/**
+	 * @param {string} name name
+	 * @param {[number, number]} range range
+	 * @param {string=} prefix prefix
+	 */
+	constructor(name, range, prefix = "") {
+		super();
+		this.name = name;
+		this.range = range;
+		this.prefix = prefix;
+	}
+
+	get type() {
+		return "css local identifier";
+	}
+
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		const name = this.name;
+		return {
+			exports: [
+				{
+					name,
+					canMangle: true
+				}
+			],
+			dependencies: undefined
+		};
+	}
+
+	serialize(context) {
+		const { write } = context;
+		write(this.name);
+		write(this.range);
+		write(this.prefix);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+		this.name = read();
+		this.range = read();
+		this.prefix = read();
+		super.deserialize(context);
+	}
+}
+
+const escapeCssIdentifier = (str, omitUnderscore) => {
+	const escaped = `${str}`.replace(
+		// cspell:word uffff
+		/[^a-zA-Z0-9_\u0081-\uffff-]/g,
+		s => `\\${s}`
+	);
+	return !omitUnderscore && /^(?!--)[0-9-]/.test(escaped)
+		? `_${escaped}`
+		: escaped;
+};
+
+CssLocalIdentifierDependency.Template = class CssLocalIdentifierDependencyTemplate 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,
+		{ module, moduleGraph, chunkGraph, runtime, runtimeTemplate, cssExports }
+	) {
+		const dep = /** @type {CssLocalIdentifierDependency} */ (dependency);
+		const used = moduleGraph
+			.getExportInfo(module, dep.name)
+			.getUsedName(dep.name, runtime);
+		const moduleId = chunkGraph.getModuleId(module);
+		const identifier =
+			dep.prefix +
+			(runtimeTemplate.outputOptions.uniqueName
+				? runtimeTemplate.outputOptions.uniqueName + "-"
+				: "") +
+			(used ? moduleId + "-" + used : "-");
+		source.replace(
+			dep.range[0],
+			dep.range[1] - 1,
+			escapeCssIdentifier(identifier, dep.prefix)
+		);
+		if (used) cssExports.set(used, identifier);
+	}
+};
+
+makeSerializable(
+	CssLocalIdentifierDependency,
+	"webpack/lib/dependencies/CssLocalIdentifierDependency"
+);
+
+module.exports = CssLocalIdentifierDependency;

package/lib/dependencies/CssSelfLocalIdentifierDependency.js

@@ -0,0 +1,101 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const Dependency = require("../Dependency");
+const makeSerializable = require("../util/makeSerializable");
+const CssLocalIdentifierDependency = require("./CssLocalIdentifierDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class CssSelfLocalIdentifierDependency extends CssLocalIdentifierDependency {
+	/**
+	 * @param {string} name name
+	 * @param {[number, number]} range range
+	 * @param {string=} prefix prefix
+	 * @param {Set<string>=} declaredSet set of declared names (will only be active when in declared set)
+	 */
+	constructor(name, range, prefix = "", declaredSet = undefined) {
+		super(name, range, prefix);
+		this.declaredSet = declaredSet;
+	}
+
+	get type() {
+		return "css self local identifier";
+	}
+
+	get category() {
+		return "self";
+	}
+
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		return `self`;
+	}
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		if (this.declaredSet && !this.declaredSet.has(this.name)) return;
+		return super.getExports(moduleGraph);
+	}
+
+	/**
+	 * 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) {
+		if (this.declaredSet && !this.declaredSet.has(this.name))
+			return Dependency.NO_EXPORTS_REFERENCED;
+		return [[this.name]];
+	}
+
+	serialize(context) {
+		const { write } = context;
+		write(this.declaredSet);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+		this.declaredSet = read();
+		super.deserialize(context);
+	}
+}
+
+CssSelfLocalIdentifierDependency.Template = class CssSelfLocalIdentifierDependencyTemplate extends (
+	CssLocalIdentifierDependency.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 {CssSelfLocalIdentifierDependency} */ (dependency);
+		if (dep.declaredSet && !dep.declaredSet.has(dep.name)) return;
+		super.apply(dependency, source, templateContext);
+	}
+};
+
+makeSerializable(
+	CssSelfLocalIdentifierDependency,
+	"webpack/lib/dependencies/CssSelfLocalIdentifierDependency"
+);
+
+module.exports = CssSelfLocalIdentifierDependency;

package/lib/dependencies/CssUrlDependency.js

@@ -0,0 +1,132 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const memoize = require("../util/memoize");
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+const getRawDataUrlModule = memoize(() => require("../asset/RawDataUrlModule"));
+
+class CssUrlDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request
+	 * @param {[number, number]} range range of the argument
+	 * @param {string} cssFunctionKind kind of css function, e. g. url(), image()
+	 */
+	constructor(request, range, cssFunctionKind) {
+		super(request);
+		this.range = range;
+		this.cssFunctionKind = cssFunctionKind;
+	}
+
+	get type() {
+		return "css url()";
+	}
+
+	get category() {
+		return "url";
+	}
+
+	/**
+	 * @param {string} context context directory
+	 * @returns {Module} a module
+	 */
+	createIgnoredModule(context) {
+		const RawDataUrlModule = getRawDataUrlModule();
+		return new RawDataUrlModule("data:,", `ignored-asset`, `(ignored asset)`);
+	}
+
+	serialize(context) {
+		const { write } = context;
+		write(this.cssFunctionKind);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+		this.cssFunctionKind = read();
+		super.deserialize(context);
+	}
+}
+
+const cssEscapeString = str => {
+	let countWhiteOrBracket = 0;
+	let countQuotation = 0;
+	let countApostrophe = 0;
+	for (let i = 0; i < str.length; i++) {
+		const cc = str.charCodeAt(i);
+		switch (cc) {
+			case 9: // tab
+			case 10: // nl
+			case 32: // space
+			case 40: // (
+			case 41: // )
+				countWhiteOrBracket++;
+				break;
+			case 34:
+				countQuotation++;
+				break;
+			case 39:
+				countApostrophe++;
+				break;
+		}
+	}
+	if (countWhiteOrBracket < 2) {
+		return str.replace(/[\n\t ()'"\\]/g, m => `\\${m}`);
+	} else if (countQuotation <= countApostrophe) {
+		return `"${str.replace(/[\n"\\]/g, m => `\\${m}`)}"`;
+	} else {
+		return `'${str.replace(/[\n'\\]/g, m => `\\${m}`)}'`;
+	}
+};
+
+CssUrlDependency.Template = class CssUrlDependencyTemplate 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,
+		{ runtime, moduleGraph, runtimeTemplate, codeGenerationResults }
+	) {
+		const dep = /** @type {CssUrlDependency} */ (dependency);
+
+		source.replace(
+			dep.range[0],
+			dep.range[1] - 1,
+			`${dep.cssFunctionKind}(${cssEscapeString(
+				runtimeTemplate.assetUrl({
+					publicPath: "",
+					runtime,
+					module: moduleGraph.getModule(dep),
+					codeGenerationResults
+				})
+			)})`
+		);
+	}
+};
+
+makeSerializable(CssUrlDependency, "webpack/lib/dependencies/CssUrlDependency");
+
+module.exports = CssUrlDependency;

package/lib/dependencies/URLDependency.js

@@ -25,7 +25,7 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-const getRawModule = memoize(() => require("../RawModule"));
+const getRawDataUrlModule = memoize(() => require("../asset/RawDataUrlModule"));
 
 class URLDependency extends ModuleDependency {
 	/**
@@ -68,13 +68,8 @@ class URLDependency extends ModuleDependency {
 	 * @returns {Module} a module
 	 */
 	createIgnoredModule(context) {
-		const RawModule = getRawModule();
-		return new RawModule(
-			'module.exports = "data:,";',
-			`ignored-asset`,
-			`(ignored asset)`,
-			new Set([RuntimeGlobals.module])
-		);
+		const RawDataUrlModule = getRawDataUrlModule();
+		return new RawDataUrlModule("data:,", `ignored-asset`, `(ignored asset)`);
 	}
 
 	serialize(context) {

package/lib/esm/ModuleChunkFormatPlugin.js

@@ -5,18 +5,16 @@
 
 "use strict";
 
-const { ConcatSource, RawSource } = require("webpack-sources");
+const { ConcatSource } = require("webpack-sources");
 const { RuntimeGlobals } = require("..");
 const HotUpdateChunk = require("../HotUpdateChunk");
 const Template = require("../Template");
+const { getAllChunks } = require("../javascript/ChunkHelpers");
 const {
 	getCompilationHooks,
 	getChunkFilenameTemplate
 } = require("../javascript/JavascriptModulesPlugin");
-const {
-	generateEntryStartup,
-	updateHashForEntryStartup
-} = require("../javascript/StartupHelpers");
+const { updateHashForEntryStartup } = require("../javascript/StartupHelpers");
 
 /** @typedef {import("../Compiler")} Compiler */
 
@@ -84,63 +82,90 @@ class ModuleChunkFormatPlugin {
 										}
 									)
 									.split("/");
-								const runtimeOutputName = compilation
-									.getPath(
-										getChunkFilenameTemplate(
-											runtimeChunk,
-											compilation.outputOptions
-										),
-										{
-											chunk: runtimeChunk,
-											contentHashType: "javascript"
-										}
-									)
-									.split("/");
 
 								// remove filename, we only need the directory
-								const outputFilename = currentOutputName.pop();
+								currentOutputName.pop();
 
-								// remove common parts
-								while (
-									currentOutputName.length > 0 &&
-									runtimeOutputName.length > 0 &&
-									currentOutputName[0] === runtimeOutputName[0]
-								) {
-									currentOutputName.shift();
-									runtimeOutputName.shift();
-								}
+								const getRelativePath = chunk => {
+									const baseOutputName = currentOutputName.slice();
+									const chunkOutputName = compilation
+										.getPath(
+											getChunkFilenameTemplate(
+												chunk,
+												compilation.outputOptions
+											),
+											{
+												chunk: chunk,
+												contentHashType: "javascript"
+											}
+										)
+										.split("/");
 
-								// create final path
-								const runtimePath =
-									(currentOutputName.length > 0
-										? "../".repeat(currentOutputName.length)
-										: "./") + runtimeOutputName.join("/");
+									// remove common parts
+									while (
+										baseOutputName.length > 0 &&
+										chunkOutputName.length > 0 &&
+										baseOutputName[0] === chunkOutputName[0]
+									) {
+										baseOutputName.shift();
+										chunkOutputName.shift();
+									}
+									// create final path
+									return (
+										(baseOutputName.length > 0
+											? "../".repeat(baseOutputName.length)
+											: "./") + chunkOutputName.join("/")
+									);
+								};
 
 								const entrySource = new ConcatSource();
 								entrySource.add(source);
 								entrySource.add(";\n\n// load runtime\n");
 								entrySource.add(
 									`import __webpack_require__ from ${JSON.stringify(
-										runtimePath
-									)};\n`
-								);
-								entrySource.add(
-									`import * as __webpack_self_exports__ from ${JSON.stringify(
-										"./" + outputFilename
+										getRelativePath(runtimeChunk)
 									)};\n`
 								);
-								entrySource.add(
-									`${RuntimeGlobals.externalInstallChunk}(__webpack_self_exports__);\n`
-								);
-								const startupSource = new RawSource(
-									generateEntryStartup(
-										chunkGraph,
-										runtimeTemplate,
-										entries,
-										chunk,
-										false
-									)
+
+								const startupSource = new ConcatSource();
+								startupSource.add(
+									`var __webpack_exec__ = ${runtimeTemplate.returningFunction(
+										`__webpack_require__(${RuntimeGlobals.entryModuleId} = moduleId)`,
+										"moduleId"
+									)}\n`
 								);
+
+								const loadedChunks = new Set();
+								let index = 0;
+								for (let i = 0; i < entries.length; i++) {
+									const [module, entrypoint] = entries[i];
+									const final = i + 1 === entries.length;
+									const moduleId = chunkGraph.getModuleId(module);
+									const chunks = getAllChunks(
+										entrypoint,
+										runtimeChunk,
+										undefined
+									);
+									for (const chunk of chunks) {
+										if (loadedChunks.has(chunk)) continue;
+										loadedChunks.add(chunk);
+										startupSource.add(
+											`import * as __webpack_chunk_${index}__ from ${JSON.stringify(
+												getRelativePath(chunk)
+											)};\n`
+										);
+										startupSource.add(
+											`${RuntimeGlobals.externalInstallChunk}(__webpack_chunk_${index}__);\n`
+										);
+										index++;
+									}
+									startupSource.add(
+										`${
+											final ? "var __webpack_exports__ = " : ""
+										}__webpack_exec__(${JSON.stringify(moduleId)});\n`
+									);
+								}
+
 								entrySource.add(
 									hooks.renderStartup.call(
 										startupSource,