webpack 5.106.1 → 5.107.0

package/lib/dependencies/HtmlInlineStyleDependency.js

@@ -0,0 +1,101 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const { CSS_TEXT_TYPE } = require("../ModuleSourceTypeConstants");
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+/**
+ * Represents an inline `<style>...</style>` block in an HTML module. The
+ * tag's content is fed into webpack's CSS pipeline as a virtual CSS module
+ * with `exportType: "text"` so `url()` and `\@import` references are
+ * resolved relative to the HTML file. At render time the original content
+ * range is replaced with the processed CSS text read from the CSS module's
+ * code generation data.
+ */
+class HtmlInlineStyleDependency extends ModuleDependency {
+	/**
+	 * Creates an instance of HtmlInlineStyleDependency.
+	 * @param {string} request virtual request resolving to the inline CSS (data URI)
+	 * @param {Range} range range of the inline CSS content (between `<style>` and `</style>`)
+	 */
+	constructor(request, range) {
+		super(request);
+		this.range = range;
+	}
+
+	get type() {
+		return "html inline style";
+	}
+
+	get category() {
+		return "html-style";
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		super.serialize(context);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		super.deserialize(context);
+	}
+}
+
+HtmlInlineStyleDependency.Template = class HtmlInlineStyleDependencyTemplate extends (
+	ModuleDependency.Template
+) {
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @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, { moduleGraph, runtime, codeGenerationResults }) {
+		const dep = /** @type {HtmlInlineStyleDependency} */ (dependency);
+		const module = /** @type {Module} */ (moduleGraph.getModule(dep));
+
+		/** @type {string} */
+		let cssText = "";
+
+		if (module) {
+			const codeGen =
+				/** @type {CodeGenerationResults} */
+				(codeGenerationResults).get(module, runtime);
+			const cssTextSource = codeGen.sources.get(CSS_TEXT_TYPE);
+			if (cssTextSource) {
+				cssText = /** @type {string} */ (cssTextSource.source());
+			}
+		}
+
+		source.replace(dep.range[0], dep.range[1] - 1, cssText);
+	}
+};
+
+makeSerializable(
+	HtmlInlineStyleDependency,
+	"webpack/lib/dependencies/HtmlInlineStyleDependency"
+);
+
+module.exports = HtmlInlineStyleDependency;

package/lib/dependencies/HtmlScriptSrcDependency.js

@@ -0,0 +1,318 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const CssUrlDependency = require("./CssUrlDependency");
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Entrypoint")} Entrypoint */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+/** @typedef {"script-classic" | "script-module" | "modulepreload" | "stylesheet"} HtmlScriptElementKind */
+
+class HtmlScriptSrcDependency extends ModuleDependency {
+	/**
+	 * Creates an instance of HtmlScriptSrcDependency.
+	 * @param {string} request request
+	 * @param {Range} range range of the attribute value in the source
+	 * @param {string} entryName name of the entry this script src is bundled into
+	 * @param {string=} category dependency category used for resolving and grouping
+	 * @param {HtmlScriptElementKind=} elementKind shape of the originating HTML element; used when expanding sibling tags for split/runtime chunks
+	 * @param {number=} tagStart position of the opening `<` of the originating tag in the source; sibling tags emitted for additional entry chunks are inserted right before this
+	 * @param {number=} tagOpenEnd position of the character immediately after the opening tag's `>` in the source; combined with `tagStart` this lets the template clone the original opening tag verbatim (preserving attributes like `nonce`, `crossorigin`, `referrerpolicy`, `defer`, `async`) when generating sibling tags
+	 */
+	constructor(
+		request,
+		range,
+		entryName,
+		category,
+		elementKind,
+		tagStart,
+		tagOpenEnd
+	) {
+		super(request);
+		this.range = range;
+		this.entryName = entryName;
+		/** @type {string} */
+		this._category = category || "commonjs";
+		/** @type {HtmlScriptElementKind} */
+		this.elementKind = elementKind || "script-classic";
+		/** @type {number} */
+		this.tagStart = tagStart === undefined ? -1 : tagStart;
+		/** @type {number} */
+		this.tagOpenEnd = tagOpenEnd === undefined ? -1 : tagOpenEnd;
+	}
+
+	get type() {
+		return "html script src";
+	}
+
+	get category() {
+		return this._category;
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.entryName);
+		write(this._category);
+		write(this.elementKind);
+		write(this.tagStart);
+		write(this.tagOpenEnd);
+		super.serialize(context);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.entryName = read();
+		this._category = read();
+		this.elementKind = read();
+		this.tagStart = read();
+		this.tagOpenEnd = read();
+		super.deserialize(context);
+	}
+}
+
+/**
+ * @param {Chunk} chunk a chunk
+ * @param {import("../Compilation")} compilation compilation
+ * @param {"javascript" | "css"} contentHashType which content hash to plug into the filename template
+ * @returns {string} chunk filename path (no public-path prefix)
+ */
+const getChunkFilename = (chunk, compilation, contentHashType) => {
+	const outputOptions = compilation.outputOptions;
+	let filenameTemplate;
+	if (contentHashType === "css") {
+		// For a CSS-typed chunk, use the same template the CSS pipeline
+		// will use when it actually emits the `.css` file, so the `<link
+		// rel="stylesheet" href>` URL we write into the HTML matches the
+		// asset on disk.
+		filenameTemplate =
+			require("../css/CssModulesPlugin").getChunkFilenameTemplate(
+				chunk,
+				outputOptions
+			);
+	} else {
+		filenameTemplate =
+			chunk.filenameTemplate ||
+			(chunk.canBeInitial()
+				? outputOptions.filename
+				: outputOptions.chunkFilename);
+	}
+
+	return compilation.getPath(filenameTemplate, {
+		chunk,
+		contentHashType
+	});
+};
+
+/**
+ * @param {Entrypoint} entrypoint entrypoint
+ * @returns {Chunk[]} every chunk this entrypoint needs in load order: the
+ * runtime chunk first (when `optimization.runtimeChunk` splits it off), then
+ * any intermediate chunks (e.g. from `optimization.splitChunks`), and finally
+ * the entry chunk itself. The entry chunk is always returned last so callers
+ * can identify it as the tag whose `src`/`href` attribute is being rewritten
+ * in place. Chunks that are already loaded by an ancestor (`dependOn`) entry's
+ * own script tag — i.e. the parent entrypoint's entry chunk *and* its runtime
+ * chunk — are skipped, otherwise they would be loaded twice when the same
+ * HTML contains tags for both the leader and the dependant entries.
+ */
+const getEntrypointChunksInLoadOrder = (entrypoint) => {
+	const entryChunk = /** @type {Chunk} */ (entrypoint.getEntrypointChunk());
+	const runtimeChunk = entrypoint.getRuntimeChunk();
+
+	/** @type {Set<Chunk>} */
+	const chunksLoadedByAncestorTags = new Set();
+	/** @type {Set<import("../ChunkGroup")>} */
+	const visitedGroups = new Set();
+	const walk = (/** @type {import("../ChunkGroup")} */ group) => {
+		if (visitedGroups.has(group)) return;
+		visitedGroups.add(group);
+		for (const parent of group.parentsIterable) {
+			if (
+				typeof (/** @type {Entrypoint} */ (parent).getEntrypointChunk) ===
+				"function"
+			) {
+				const parentEntry =
+					/** @type {Entrypoint} */
+					(parent).getEntrypointChunk();
+				if (parentEntry) chunksLoadedByAncestorTags.add(parentEntry);
+				const parentRuntime =
+					/** @type {Entrypoint} */
+					(parent).getRuntimeChunk();
+				if (parentRuntime) chunksLoadedByAncestorTags.add(parentRuntime);
+			}
+			walk(parent);
+		}
+	};
+	walk(entrypoint);
+
+	/** @type {Chunk[]} */
+	const ordered = [];
+	/** @type {Set<Chunk>} */
+	const seen = new Set();
+	const push = (/** @type {Chunk | null | undefined} */ chunk) => {
+		if (!chunk || seen.has(chunk) || chunk === entryChunk) return;
+		if (chunksLoadedByAncestorTags.has(chunk)) return;
+		seen.add(chunk);
+		ordered.push(chunk);
+	};
+	if (runtimeChunk !== entryChunk) {
+		push(runtimeChunk);
+	}
+	for (const chunk of entrypoint.chunks) {
+		push(chunk);
+	}
+	ordered.push(entryChunk);
+	return ordered;
+};
+
+/**
+ * Clone the original `<script>`/`<link>` opening tag with its `src`/`href`
+ * value swapped for a different chunk URL. Reusing the source text verbatim
+ * preserves attributes such as `nonce`, `crossorigin`, `referrerpolicy`,
+ * `defer`, and `async` so the sibling tags load with the same semantics as
+ * the entry tag that's already there. `integrity` is dropped because it's
+ * content-specific. When the original tag was upgraded to a module script
+ * (either by the author or by the `output.module` auto-upgrade in
+ * `HtmlParser`), the sibling is forced to `type="module"` regardless of what
+ * the source originally said.
+ * @param {string} originalTag the opening tag's source text including `>`
+ * @param {number} srcStartInTag offset of the src/href value start within `originalTag`
+ * @param {number} srcEndInTag offset of the src/href value end within `originalTag`
+ * @param {string} newUrl URL to put into the cloned tag's src/href slot
+ * @param {HtmlScriptElementKind} elementKind shape of the originating tag
+ * @returns {string} the sibling tag's HTML (including a closing `</script>` for script tags)
+ */
+const cloneTagWithUrl = (
+	originalTag,
+	srcStartInTag,
+	srcEndInTag,
+	newUrl,
+	elementKind
+) => {
+	let body =
+		originalTag.slice(0, srcStartInTag) +
+		newUrl +
+		originalTag.slice(srcEndInTag);
+
+	// Strip dangerous-to-copy attributes from the cloned tag — currently
+	// just `integrity`. The match handles all three quoting styles
+	// (`"…"`, `'…'`, unquoted) and the bare-attribute form.
+	body = body.replace(
+		/\s+integrity(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+))?(?=[\s/>])/gi,
+		""
+	);
+
+	if (elementKind === "script-module") {
+		if (/\stype\s*=/i.test(body)) {
+			body = body.replace(
+				/(\stype\s*=\s*)(?:"[^"]*"|'[^']*'|[^\s>]+)/i,
+				'$1"module"'
+			);
+		} else {
+			body = body.replace(/^<script\b/i, '<script type="module"');
+		}
+	}
+
+	// `<link>` is a void element — no closing tag. `<script>` needs `</script>`.
+	return elementKind === "modulepreload" || elementKind === "stylesheet"
+		? body
+		: `${body}</script>`;
+};
+
+HtmlScriptSrcDependency.Template = class HtmlScriptSrcDependencyTemplate extends (
+	ModuleDependency.Template
+) {
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @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 { runtimeTemplate } = templateContext;
+		const dep = /** @type {HtmlScriptSrcDependency} */ (dependency);
+		const compilation = runtimeTemplate.compilation;
+		const entrypoint = /** @type {Entrypoint | undefined} */ (
+			compilation.entrypoints.get(dep.entryName)
+		);
+
+		if (!entrypoint) {
+			source.replace(dep.range[0], dep.range[1] - 1, "data:,");
+			return;
+		}
+
+		const orderedChunks = getEntrypointChunksInLoadOrder(entrypoint);
+		const entryChunk = orderedChunks[orderedChunks.length - 1];
+		const contentHashType =
+			dep.elementKind === "stylesheet" ? "css" : "javascript";
+		const entryUrl = `${CssUrlDependency.PUBLIC_PATH_AUTO}${getChunkFilename(
+			entryChunk,
+			compilation,
+			contentHashType
+		)}`;
+		source.replace(dep.range[0], dep.range[1] - 1, entryUrl);
+
+		if (
+			orderedChunks.length <= 1 ||
+			dep.tagStart < 0 ||
+			dep.tagOpenEnd <= dep.tagStart
+		) {
+			return;
+		}
+
+		// The browser must load every chunk in dependency order, not just the
+		// entry chunk. Clone the original tag for each non-entry chunk so the
+		// preserved attributes (nonce, crossorigin, …) match the entry tag,
+		// and insert the clones before the original tag's `<`.
+		const originalContent = /** @type {string} */ (source.original().source());
+		const originalTag = originalContent.slice(dep.tagStart, dep.tagOpenEnd);
+		const srcStartInTag = dep.range[0] - dep.tagStart;
+		const srcEndInTag = dep.range[1] - dep.tagStart;
+
+		const siblings = [];
+		for (let i = 0; i < orderedChunks.length - 1; i++) {
+			const url = `${CssUrlDependency.PUBLIC_PATH_AUTO}${getChunkFilename(
+				orderedChunks[i],
+				compilation,
+				contentHashType
+			)}`;
+			siblings.push(
+				cloneTagWithUrl(
+					originalTag,
+					srcStartInTag,
+					srcEndInTag,
+					url,
+					dep.elementKind
+				)
+			);
+		}
+		source.insert(dep.tagStart, siblings.join(""));
+	}
+};
+
+makeSerializable(
+	HtmlScriptSrcDependency,
+	"webpack/lib/dependencies/HtmlScriptSrcDependency"
+);
+
+module.exports = HtmlScriptSrcDependency;

package/lib/dependencies/HtmlSourceDependency.js

@@ -0,0 +1,127 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const RawDataUrlModule = require("../asset/RawDataUrlModule");
+const makeSerializable = require("../util/makeSerializable");
+const memoize = require("../util/memoize");
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("../Module").CodeGenerationResultData} CodeGenerationResultData */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+const getIgnoredRawDataUrlModule = memoize(
+	() => new RawDataUrlModule("data:,", "ignored-asset", "(ignored asset)")
+);
+
+class HtmlSourceDependency extends ModuleDependency {
+	/**
+	 * Creates an instance of HtmlSourceDependency.
+	 * @param {string} request request
+	 * @param {Range} range range of the argument
+	 */
+	constructor(request, range) {
+		super(request);
+		this.range = range;
+	}
+
+	get type() {
+		return "html source()";
+	}
+
+	get category() {
+		return "url";
+	}
+
+	/**
+	 * Creates an ignored module.
+	 * @param {string} context context directory
+	 * @returns {Module} ignored module
+	 */
+	createIgnoredModule(context) {
+		return getIgnoredRawDataUrlModule();
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		super.serialize(context);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		super.deserialize(context);
+	}
+}
+
+HtmlSourceDependency.Template = class HtmlSourceDependencyTemplate extends (
+	ModuleDependency.Template
+) {
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @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,
+		{ moduleGraph, runtimeTemplate, codeGenerationResults }
+	) {
+		const dep = /** @type {HtmlSourceDependency} */ (dependency);
+		const module = /** @type {Module} */ (moduleGraph.getModule(dep));
+
+		/** @type {string | undefined} */
+		const newValue = this.assetUrl({
+			module,
+			codeGenerationResults
+		});
+
+		source.replace(dep.range[0], dep.range[1] - 1, newValue);
+	}
+
+	/**
+	 * Returns the url of the asset.
+	 * @param {object} options options object
+	 * @param {Module} options.module the module
+	 * @param {RuntimeSpec=} options.runtime runtime
+	 * @param {CodeGenerationResults} options.codeGenerationResults the code generation results
+	 * @returns {string} the url of the asset
+	 */
+	assetUrl({ runtime, module, codeGenerationResults }) {
+		if (!module) {
+			return "data:,";
+		}
+		const codeGen = codeGenerationResults.get(module, runtime);
+		const data = codeGen.data;
+		if (!data) return "data:,";
+		const url = data.get("url");
+		if (!url || !url["css-url"]) return "data:,";
+		return url["css-url"];
+	}
+};
+
+makeSerializable(
+	HtmlSourceDependency,
+	"webpack/lib/dependencies/HtmlSourceDependency"
+);
+
+module.exports = HtmlSourceDependency;

package/lib/dependencies/ImportContextDependency.js

@@ -16,6 +16,7 @@ const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTempl
 
 class ImportContextDependency extends ContextDependency {
 	/**
+	 * Creates an instance of ImportContextDependency.
 	 * @param {ContextDependencyOptions} options options
 	 * @param {Range} range range
 	 * @param {Range} valueRange value range
@@ -36,6 +37,7 @@ class ImportContextDependency extends ContextDependency {
 	}
 
 	/**
+	 * Returns an identifier to merge equal requests.
 	 * @returns {string | null} an identifier to merge equal requests
 	 */
 	getResourceIdentifier() {
@@ -49,6 +51,7 @@ class ImportContextDependency extends ContextDependency {
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
@@ -60,6 +63,7 @@ class ImportContextDependency extends ContextDependency {
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {

package/lib/dependencies/ImportDependency.js

@@ -27,6 +27,7 @@ const ModuleDependency = require("./ModuleDependency");
 
 class ImportDependency extends ModuleDependency {
 	/**
+	 * Creates an instance of ImportDependency.
 	 * @param {string} request the request
 	 * @param {Range} range expression range
 	 * @param {RawReferencedExports | null} referencedExports list of referenced exports
@@ -50,6 +51,7 @@ class ImportDependency extends ModuleDependency {
 	}
 
 	/**
+	 * Returns an identifier to merge equal requests.
 	 * @returns {string | null} an identifier to merge equal requests
 	 */
 	getResourceIdentifier() {
@@ -103,6 +105,7 @@ class ImportDependency extends ModuleDependency {
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
@@ -114,6 +117,7 @@ class ImportDependency extends ModuleDependency {
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
@@ -131,6 +135,7 @@ ImportDependency.Template = class ImportDependencyTemplate extends (
 	ModuleDependency.Template
 ) {
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @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

package/lib/dependencies/ImportEagerDependency.js

@@ -20,6 +20,7 @@ const ImportDependency = require("./ImportDependency");
 
 class ImportEagerDependency extends ImportDependency {
 	/**
+	 * Creates an instance of ImportEagerDependency.
 	 * @param {string} request the request
 	 * @param {Range} range expression range
 	 * @param {RawReferencedExports | null} referencedExports list of referenced exports
@@ -48,6 +49,7 @@ ImportEagerDependency.Template = class ImportEagerDependencyTemplate extends (
 	ImportDependency.Template
 ) {
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @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

package/lib/dependencies/ImportMetaContextDependency.js

@@ -14,6 +14,7 @@ const ModuleDependencyTemplateAsRequireId = require("./ModuleDependencyTemplateA
 
 class ImportMetaContextDependency extends ContextDependency {
 	/**
+	 * Creates an instance of ImportMetaContextDependency.
 	 * @param {ContextDependencyOptions} options options
 	 * @param {Range} range range
 	 */

package/lib/dependencies/ImportMetaContextDependencyParserPlugin.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const WebpackError = require("../WebpackError");
+const WebpackError = require("../errors/WebpackError");
 const {
 	evaluateToIdentifier
 } = require("../javascript/JavascriptParserHelpers");
@@ -28,6 +28,7 @@ const ImportMetaContextDependency = require("./ImportMetaContextDependency");
 /** @typedef {Pick<ContextModuleOptions, "mode" | "recursive" | "regExp" | "include" | "exclude" | "chunkName"> & { groupOptions: RawChunkGroupOptions, exports?: RawReferencedExports }} ImportMetaContextOptions */
 
 /**
+ * Creates a property parse error.
  * @param {Property} prop property
  * @param {string} expect except message
  * @returns {WebpackError} error
@@ -44,6 +45,7 @@ function createPropertyParseError(prop, expect) {
 }
 
 /**
+ * Creates an error from the provided msg.
  * @param {string} msg message
  * @param {DependencyLocation} loc location
  * @returns {WebpackError} error
@@ -59,6 +61,7 @@ const PLUGIN_NAME = "ImportMetaContextDependencyParserPlugin";
 
 module.exports = class ImportMetaContextDependencyParserPlugin {
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {JavascriptParser} parser the parser
 	 * @returns {void}
 	 */

package/lib/dependencies/ImportMetaContextPlugin.js

@@ -21,7 +21,7 @@ const PLUGIN_NAME = "ImportMetaContextPlugin";
 
 class ImportMetaContextPlugin {
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -43,6 +43,7 @@ class ImportMetaContextPlugin {
 				);
 
 				/**
+				 * Handles the hook callback for this code path.
 				 * @param {Parser} parser parser parser
 				 * @param {JavascriptParserOptions} parserOptions parserOptions
 				 * @returns {void}