@depup/webpack 5.106.1-depup.0 → 5.109.0-depup.0

package/lib/dependencies/HtmlInlineHtmlDependency.js

@@ -0,0 +1,107 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const { HTML_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").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../util/Hash")} Hash */
+
+// One pass over the source: each char is replaced once and replacements aren't
+// re-scanned, so this matches the `&`-first sequential escape chain exactly.
+const ATTR_ESCAPE_REGEXP = /[&"']/g;
+/** @type {Record<string, string>} */
+const ATTR_ESCAPES = { "&": "&amp;", '"': "&quot;", "'": "&#39;" };
+/**
+ * @param {string} c matched character
+ * @returns {string} the HTML-attribute-escaped entity
+ */
+const escapeAttrChar = (c) => ATTR_ESCAPES[c];
+
+/**
+ * Represents an `<iframe srcdoc="...">` attribute — an entity-encoded HTML
+ * document. The decoded document is fed back through webpack's HTML pipeline as
+ * a virtual `data:text/html` module so its asset URLs resolve relative to the
+ * host HTML file. At render time the attribute value is replaced with the
+ * processed HTML read from the nested module's `html` code-generation data,
+ * re-escaped so the surrounding attribute stays valid.
+ */
+class HtmlInlineHtmlDependency extends ModuleDependency {
+	/**
+	 * @param {string} request virtual request resolving to the inline HTML (data URI)
+	 * @param {Range} range range of the `srcdoc` attribute value
+	 */
+	constructor(request, range) {
+		super(request);
+		this.range = range;
+	}
+
+	get type() {
+		return "html inline html";
+	}
+
+	get category() {
+		return "html-srcdoc";
+	}
+
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		// Recurse so the inline HTML's transitive deps (assets) propagate up.
+		// The module is guaranteed — it is registered as a code-generation dependency.
+		const module = /** @type {Module} */ (
+			context.chunkGraph.moduleGraph.getModule(this)
+		);
+		module.updateHash(hash, context);
+	}
+}
+
+HtmlInlineHtmlDependency.Template = class HtmlInlineHtmlDependencyTemplate 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 {HtmlInlineHtmlDependency} */ (dependency);
+		// The module is guaranteed — it is registered as a code-generation dependency.
+		const module = /** @type {Module} */ (moduleGraph.getModule(dep));
+		const codeGen =
+			/** @type {CodeGenerationResults} */
+			(codeGenerationResults).get(module, runtime);
+		const htmlSource = codeGen.sources.get(HTML_TYPE);
+
+		// The attribute value was entity-decoded before parsing, so re-escape the
+		// processed HTML to keep the surrounding `srcdoc="..."` attribute valid.
+		const htmlText = (
+			htmlSource ? /** @type {string} */ (htmlSource.source()) : ""
+		).replace(ATTR_ESCAPE_REGEXP, escapeAttrChar);
+
+		source.replace(dep.range[0], dep.range[1] - 1, htmlText);
+	}
+};
+
+makeSerializable(
+	HtmlInlineHtmlDependency,
+	"webpack/lib/dependencies/HtmlInlineHtmlDependency"
+);
+
+module.exports = HtmlInlineHtmlDependency;

package/lib/dependencies/HtmlInlineScriptDependency.js

@@ -0,0 +1,126 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const HtmlGenerator = require("../html/HtmlGenerator");
+const makeSerializable = require("../util/makeSerializable");
+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<[number, Range, string, string]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[number, Range, string, string]>} ObjectSerializerContext */
+
+/**
+ * Represents an inline `<script>...</script>` block in an HTML module. The
+ * tag's body is bundled as its own entry chunk — the same pipeline that
+ * processes `<script src>` — and the inline body is replaced with a
+ * `src` attribute pointing at the emitted chunk URL.
+ */
+class HtmlInlineScriptDependency extends ModuleDependency {
+	/**
+	 * Creates an instance of HtmlInlineScriptDependency.
+	 * @param {string} request virtual request resolving to the inline JS (data URI)
+	 * @param {number} insertPos position right after `<script` where ` src="…"` is inserted
+	 * @param {Range} contentRange range of the inline JS body (between `<script>` and `</script>`)
+	 * @param {string} entryName name of the entry the inline JS is bundled into
+	 * @param {string=} category dependency category used for resolving and grouping
+	 */
+	constructor(request, insertPos, contentRange, entryName, category) {
+		super(request);
+		/** @type {number} */
+		this.insertPos = insertPos;
+		this.contentRange = contentRange;
+		this.range = contentRange;
+		/** @type {string} */
+		this.entryName = entryName;
+		/** @type {string} */
+		this._category = category || "commonjs";
+	}
+
+	get type() {
+		return "html inline script";
+	}
+
+	get category() {
+		return this._category;
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		context
+			.write(this.insertPos)
+			.write(this.contentRange)
+			.write(this.entryName)
+			.write(this._category);
+		super.serialize(context);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		this.insertPos = context.read();
+		const c1 = context.rest;
+		this.contentRange = c1.read();
+		this.range = this.contentRange;
+		const c2 = c1.rest;
+		this.entryName = c2.read();
+		const c3 = c2.rest;
+		this._category = c3.read();
+		super.deserialize(c3.rest);
+	}
+}
+
+HtmlInlineScriptDependency.Template = class HtmlInlineScriptDependencyTemplate 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 {HtmlInlineScriptDependency} */ (dependency);
+		const compilation = runtimeTemplate.compilation;
+		const entrypoint = /** @type {Entrypoint | undefined} */ (
+			compilation.entrypoints.get(dep.entryName)
+		);
+
+		/** @type {string} */
+		let url = "data:,";
+
+		if (entrypoint) {
+			const chunk = /** @type {Chunk} */ (entrypoint.getEntrypointChunk());
+			// Defer chunk-URL substitution to renderManifest — chunk hashes aren't ready yet.
+			url = HtmlGenerator.makeChunkUrlSentinel(chunk, "javascript");
+		}
+
+		// Insert ` src="…"` right after `<script` so the inline body is
+		// served from the emitted chunk instead. The browser ignores the
+		// remaining inline body once `src` is present, but we still clear
+		// it below so the unprocessed JS doesn't ride along.
+		source.insert(dep.insertPos, ` src="${url}"`);
+		source.replace(dep.contentRange[0], dep.contentRange[1] - 1, "");
+	}
+};
+
+makeSerializable(
+	HtmlInlineScriptDependency,
+	"webpack/lib/dependencies/HtmlInlineScriptDependency"
+);
+
+module.exports = HtmlInlineScriptDependency;

package/lib/dependencies/HtmlInlineStyleDependency.js

@@ -0,0 +1,152 @@
+/*
+	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").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<boolean[]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<boolean[]>} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+const TRAILING_WHITESPACE_REGEXP = /\s+$/;
+// One pass over the source: each char is replaced once and replacements aren't
+// re-scanned, so this matches the `&`-first sequential escape chain exactly
+// while avoiding two extra full-string scans + intermediate strings.
+const ATTR_ESCAPE_REGEXP = /[&"']/g;
+/** @type {Record<string, string>} */
+const ATTR_ESCAPES = { "&": "&amp;", '"': "&quot;", "'": "&#39;" };
+/**
+ * @param {string} c matched character
+ * @returns {string} the HTML-attribute-escaped entity
+ */
+const escapeAttrChar = (c) => ATTR_ESCAPES[c];
+
+/**
+ * Represents inline CSS in an HTML module — either a `<style>...</style>`
+ * block (a stylesheet) or an element's `style="..."` attribute (a CSS
+ * block's contents). The 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>`, or the `style` attribute value)
+	 * @param {boolean=} attribute true when the source is a `style="..."` attribute (a block's contents) rather than a `<style>` block (stylesheet)
+	 * @param {boolean=} inAttribute true when the range is an attribute value (decoded on parse, so the processed CSS must be re-escaped on write-back); defaults to `attribute` — differs only for attribute values parsed as full stylesheets
+	 */
+	constructor(request, range, attribute = false, inAttribute = attribute) {
+		super(request);
+		this.range = range;
+		/** @type {boolean} */
+		this.attribute = attribute;
+		/** @type {boolean} */
+		this.inAttribute = inAttribute;
+	}
+
+	get type() {
+		return "html inline style";
+	}
+
+	get category() {
+		return this.attribute ? "html-style-attribute" : "html-style";
+	}
+
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		// Recurse so the inline CSS's transitive deps (e.g. `url(asset)`) propagate up.
+		const { chunkGraph } = context;
+		const module = chunkGraph.moduleGraph.getModule(this);
+		if (!module) return;
+		module.updateHash(hash, context);
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		super.serialize(context);
+		context.write(this.attribute);
+		context.write(this.inAttribute);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		super.deserialize(context);
+		this.attribute = context.read();
+		this.inAttribute = context.read();
+	}
+}
+
+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());
+			}
+		}
+
+		// An attribute value was entity-decoded before parsing, so re-escape
+		// the processed CSS to keep the surrounding markup valid in any
+		// quoting context, and drop the trailing newline the CSS generator
+		// appends so the rewritten attribute stays on one line.
+		if (dep.inAttribute) {
+			cssText = cssText
+				.replace(TRAILING_WHITESPACE_REGEXP, "")
+				.replace(ATTR_ESCAPE_REGEXP, escapeAttrChar);
+		}
+
+		source.replace(dep.range[0], dep.range[1] - 1, cssText);
+	}
+};
+
+makeSerializable(
+	HtmlInlineStyleDependency,
+	"webpack/lib/dependencies/HtmlInlineStyleDependency"
+);
+
+module.exports = HtmlInlineStyleDependency;

package/lib/dependencies/HtmlSourceDependency.js

@@ -0,0 +1,172 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const { ASSET_URL_TYPE } = require("../ModuleSourceTypeConstants");
+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").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @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/Hash")} Hash */
+/** @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;
+		/** @type {true | undefined} */
+		this.prefetch = undefined;
+		/** @type {true | undefined} */
+		this.preload = undefined;
+		/** @type {"low" | "high" | "auto" | undefined} */
+		this.fetchPriority = undefined;
+		/** @type {string | undefined} */
+		this.asAttribute = undefined;
+		/** @type {string | undefined} */
+		this.typeAttribute = undefined;
+		/** @type {string | undefined} */
+		this.mediaAttribute = undefined;
+	}
+
+	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();
+	}
+
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		// Fold in the asset's hash so the HTML invalidates when the embedded URL changes.
+		const { chunkGraph } = context;
+		const module = chunkGraph.moduleGraph.getModule(this);
+		if (!module) return;
+		const { hash: buildHash } = /** @type {BuildInfo} */ (module.buildInfo);
+		if (buildHash) hash.update(buildHash);
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.prefetch);
+		write(this.preload);
+		write(this.fetchPriority);
+		write(this.asAttribute);
+		write(this.typeAttribute);
+		write(this.mediaAttribute);
+		super.serialize(context);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.prefetch = read();
+		this.preload = read();
+		this.fetchPriority = read();
+		this.asAttribute = read();
+		this.typeAttribute = read();
+		this.mediaAttribute = read();
+		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[ASSET_URL_TYPE]) return "data:,";
+		return url[ASSET_URL_TYPE];
+	}
+};
+
+makeSerializable(
+	HtmlSourceDependency,
+	"webpack/lib/dependencies/HtmlSourceDependency"
+);
+
+module.exports = HtmlSourceDependency;

package/lib/dependencies/ImportContextDependency.js

@@ -10,12 +10,13 @@ const ContextDependency = require("./ContextDependency");
 const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
 
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range]>} ObjectSerializerContext */
 /** @typedef {import("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
 
 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,25 +51,23 @@ class ImportContextDependency extends ContextDependency {
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-
-		write(this.valueRange);
+		context.write(this.valueRange);
 
 		super.serialize(context);
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-
-		this.valueRange = read();
+		this.valueRange = context.read();
 
-		super.deserialize(context);
+		super.deserialize(context.rest);
 	}
 }