webpack 5.65.0 → 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/ModuleChunkLoadingRuntimeModule.js

@@ -81,7 +81,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 		);
 		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
 		const hasJsMatcher = compileBooleanMatcher(conditionMap);
-		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph);
+		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
 
 		const outputName = this.compilation.getPath(
 			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),

package/lib/hmr/lazyCompilationBackend.js

@@ -68,7 +68,9 @@ module.exports = options => (compiler, callback) => {
 		req.socket.setNoDelay(true);
 		res.writeHead(200, {
 			"content-type": "text/event-stream",
-			"Access-Control-Allow-Origin": "*"
+			"Access-Control-Allow-Origin": "*",
+			"Access-Control-Allow-Methods": "*",
+			"Access-Control-Allow-Headers": "*"
 		});
 		res.write("\n");
 		let moduleActivated = false;

package/lib/javascript/JavascriptGenerator.js

@@ -199,6 +199,7 @@ class JavascriptGenerator extends Generator {
 			runtime: generateContext.runtime,
 			runtimeRequirements: generateContext.runtimeRequirements,
 			concatenationScope: generateContext.concatenationScope,
+			codeGenerationResults: generateContext.codeGenerationResults,
 			initFragments
 		};
 

package/lib/javascript/StartupHelpers.js

@@ -9,7 +9,6 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const { isSubset } = require("../util/SetHelpers");
 const { getAllChunks } = require("./ChunkHelpers");
-const { chunkHasJs } = require("./JavascriptModulesPlugin");
 
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../Chunk")} Chunk */
@@ -119,12 +118,13 @@ exports.updateHashForEntryStartup = (hash, chunkGraph, entries, chunk) => {
 /**
  * @param {Chunk} chunk the chunk
  * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {function(Chunk, ChunkGraph): boolean} filterFn filter function
  * @returns {Set<number | string>} initially fulfilled chunk ids
  */
-exports.getInitialChunkIds = (chunk, chunkGraph) => {
+exports.getInitialChunkIds = (chunk, chunkGraph, filterFn) => {
 	const initialChunkIds = new Set(chunk.ids);
 	for (const c of chunk.getAllInitialChunks()) {
-		if (c === chunk || chunkHasJs(c, chunkGraph)) continue;
+		if (c === chunk || filterFn(c, chunkGraph)) continue;
 		for (const id of c.ids) initialChunkIds.add(id);
 	}
 	return initialChunkIds;

package/lib/library/AssignLibraryPlugin.js

@@ -92,7 +92,7 @@ const accessWithInit = (accessor, existingLength, initLast = false) => {
  * @property {LibraryType} type
  * @property {string[] | "global"} prefix name prefix
  * @property {string | false} declare declare name as variable
- * @property {"error"|"copy"|"assign"} unnamed behavior for unnamed library name
+ * @property {"error"|"static"|"copy"|"assign"} unnamed behavior for unnamed library name
  * @property {"copy"|"assign"=} named behavior for named library name
  */
 
@@ -261,19 +261,42 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 	 * @param {LibraryContext<T>} libraryContext context
 	 * @returns {Source} source with library export
 	 */
-	renderStartup(source, module, { chunk }, { options, compilation }) {
+	renderStartup(
+		source,
+		module,
+		{ moduleGraph, chunk },
+		{ options, compilation }
+	) {
 		const fullNameResolved = this._getResolvedFullName(
 			options,
 			chunk,
 			compilation
 		);
+		const staticExports = this.unnamed === "static";
 		const exportAccess = options.export
 			? propertyAccess(
 					Array.isArray(options.export) ? options.export : [options.export]
 			  )
 			: "";
 		const result = new ConcatSource(source);
-		if (options.name ? this.named === "copy" : this.unnamed === "copy") {
+		if (staticExports) {
+			const exportsInfo = moduleGraph.getExportsInfo(module);
+			const exportTarget = accessWithInit(
+				fullNameResolved,
+				this._getPrefix(compilation).length,
+				true
+			);
+			for (const exportInfo of exportsInfo.orderedExports) {
+				if (!exportInfo.provided) continue;
+				const nameAccess = propertyAccess([exportInfo.name]);
+				result.add(
+					`${exportTarget}${nameAccess} = __webpack_exports__${exportAccess}${nameAccess};\n`
+				);
+			}
+			result.add(
+				`Object.defineProperty(${exportTarget}, "__esModule", { value: true });\n`
+			);
+		} else if (options.name ? this.named === "copy" : this.unnamed === "copy") {
 			result.add(
 				`var __webpack_export_target__ = ${accessWithInit(
 					fullNameResolved,

package/lib/library/EnableLibraryPlugin.js

@@ -167,6 +167,17 @@ class EnableLibraryPlugin {
 					}).apply(compiler);
 					break;
 				}
+				case "commonjs-static": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const AssignLibraryPlugin = require("./AssignLibraryPlugin");
+					new AssignLibraryPlugin({
+						type,
+						prefix: ["exports"],
+						declare: false,
+						unnamed: "static"
+					}).apply(compiler);
+					break;
+				}
 				case "commonjs2":
 				case "commonjs-module": {
 					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697

package/lib/node/ReadFileChunkLoadingRuntimeModule.js

@@ -46,7 +46,7 @@ class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 		);
 		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
 		const hasJsMatcher = compileBooleanMatcher(conditionMap);
-		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph);
+		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
 
 		const outputName = this.compilation.getPath(
 			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),

package/lib/node/RequireChunkLoadingRuntimeModule.js

@@ -46,7 +46,7 @@ class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 		);
 		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
 		const hasJsMatcher = compileBooleanMatcher(conditionMap);
-		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph);
+		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
 
 		const outputName = this.compilation.getPath(
 			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),