@depup/webpack 5.105.4-depup.37

package/lib/dependencies/URLPlugin.js

@@ -0,0 +1,67 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../ModuleTypeConstants");
+
+const URLContextDependency = require("../dependencies/URLContextDependency");
+const URLDependency = require("../dependencies/URLDependency");
+const URLParserPlugin = require("../url/URLParserPlugin");
+
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+
+const PLUGIN_NAME = "URLPlugin";
+
+class URLPlugin {
+	/**
+	 * @param {Compiler} compiler compiler
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			PLUGIN_NAME,
+			(compilation, { normalModuleFactory, contextModuleFactory }) => {
+				compilation.dependencyFactories.set(URLDependency, normalModuleFactory);
+				compilation.dependencyTemplates.set(
+					URLDependency,
+					new URLDependency.Template()
+				);
+				compilation.dependencyFactories.set(
+					URLContextDependency,
+					contextModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					URLContextDependency,
+					new URLContextDependency.Template()
+				);
+
+				/**
+				 * @param {JavascriptParser} parser parser parser
+				 * @param {JavascriptParserOptions} parserOptions parserOptions
+				 * @returns {void}
+				 */
+				const handler = (parser, parserOptions) => {
+					if (parserOptions.url === false) return;
+					new URLParserPlugin(parserOptions).apply(parser);
+				};
+
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
+
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, handler);
+			}
+		);
+	}
+}
+
+module.exports = URLPlugin;

package/lib/dependencies/UnsupportedDependency.js

@@ -0,0 +1,82 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const NullDependency = require("./NullDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+class UnsupportedDependency extends NullDependency {
+	/**
+	 * @param {string} request the request string
+	 * @param {Range} range location in source code
+	 */
+	constructor(request, range) {
+		super();
+
+		this.request = request;
+		this.range = range;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+
+		write(this.request);
+		write(this.range);
+
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+
+		this.request = read();
+		this.range = read();
+
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	UnsupportedDependency,
+	"webpack/lib/dependencies/UnsupportedDependency"
+);
+
+UnsupportedDependency.Template = class UnsupportedDependencyTemplate 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, { runtimeTemplate }) {
+		const dep = /** @type {UnsupportedDependency} */ (dependency);
+
+		source.replace(
+			dep.range[0],
+			dep.range[1],
+			runtimeTemplate.missingModule({
+				request: dep.request
+			})
+		);
+	}
+};
+
+module.exports = UnsupportedDependency;

package/lib/dependencies/WebAssemblyExportImportedDependency.js

@@ -0,0 +1,93 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const Dependency = require("../Dependency");
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
+/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class WebAssemblyExportImportedDependency extends ModuleDependency {
+	/**
+	 * @param {string} exportName export name
+	 * @param {string} request request
+	 * @param {string} name name
+	 * @param {string} valueType value type
+	 */
+	constructor(exportName, request, name, valueType) {
+		super(request);
+		/** @type {string} */
+		this.exportName = exportName;
+		/** @type {string} */
+		this.name = name;
+		/** @type {string} */
+		this.valueType = valueType;
+	}
+
+	/**
+	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 */
+	couldAffectReferencingModule() {
+		return Dependency.TRANSITIVE;
+	}
+
+	/**
+	 * 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 {ReferencedExports} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		return [[this.name]];
+	}
+
+	get type() {
+		return "wasm export import";
+	}
+
+	get category() {
+		return "wasm";
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+
+		write(this.exportName);
+		write(this.name);
+		write(this.valueType);
+
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+
+		this.exportName = read();
+		this.name = read();
+		this.valueType = read();
+
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	WebAssemblyExportImportedDependency,
+	"webpack/lib/dependencies/WebAssemblyExportImportedDependency"
+);
+
+module.exports = WebAssemblyExportImportedDependency;

package/lib/dependencies/WebAssemblyImportDependency.js

@@ -0,0 +1,108 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const UnsupportedWebAssemblyFeatureError = require("../wasm-sync/UnsupportedWebAssemblyFeatureError");
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("@webassemblyjs/ast").ModuleImportDescription} ModuleImportDescription */
+/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class WebAssemblyImportDependency extends ModuleDependency {
+	/**
+	 * @param {string} request the request
+	 * @param {string} name the imported name
+	 * @param {ModuleImportDescription} description the WASM ast node
+	 * @param {false | string} onlyDirectImport if only direct imports are allowed
+	 */
+	constructor(request, name, description, onlyDirectImport) {
+		super(request);
+		/** @type {string} */
+		this.name = name;
+		/** @type {ModuleImportDescription} */
+		this.description = description;
+		/** @type {false | string} */
+		this.onlyDirectImport = onlyDirectImport;
+	}
+
+	get type() {
+		return "wasm import";
+	}
+
+	get category() {
+		return "wasm";
+	}
+
+	/**
+	 * 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 {ReferencedExports} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		return [[this.name]];
+	}
+
+	/**
+	 * Returns errors
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[] | null | undefined} errors
+	 */
+	getErrors(moduleGraph) {
+		const module = moduleGraph.getModule(this);
+
+		if (
+			this.onlyDirectImport &&
+			module &&
+			!module.type.startsWith("webassembly")
+		) {
+			return [
+				new UnsupportedWebAssemblyFeatureError(
+					`Import "${this.name}" from "${this.request}" with ${this.onlyDirectImport} can only be used for direct wasm to wasm dependencies`
+				)
+			];
+		}
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+
+		write(this.name);
+		write(this.description);
+		write(this.onlyDirectImport);
+
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+
+		this.name = read();
+		this.description = read();
+		this.onlyDirectImport = read();
+
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	WebAssemblyImportDependency,
+	"webpack/lib/dependencies/WebAssemblyImportDependency"
+);
+
+module.exports = WebAssemblyImportDependency;

package/lib/dependencies/WebpackIsIncludedDependency.js

@@ -0,0 +1,84 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const Dependency = require("../Dependency");
+const Template = require("../Template");
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class WebpackIsIncludedDependency extends ModuleDependency {
+	/**
+	 * @param {string} request the request string
+	 * @param {Range} range location in source code
+	 */
+	constructor(request, range) {
+		super(request);
+
+		this.weak = true;
+		this.range = range;
+	}
+
+	/**
+	 * 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 {ReferencedExports} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		// This doesn't use any export
+		return Dependency.NO_EXPORTS_REFERENCED;
+	}
+
+	get type() {
+		return "__webpack_is_included__";
+	}
+}
+
+makeSerializable(
+	WebpackIsIncludedDependency,
+	"webpack/lib/dependencies/WebpackIsIncludedDependency"
+);
+
+WebpackIsIncludedDependency.Template = class WebpackIsIncludedDependencyTemplate 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, { runtimeTemplate, chunkGraph, moduleGraph }) {
+		const dep = /** @type {WebpackIsIncludedDependency} */ (dependency);
+		const connection = moduleGraph.getConnection(dep);
+		const included = connection
+			? chunkGraph.getNumberOfModuleChunks(connection.module) > 0
+			: false;
+		const comment = runtimeTemplate.outputOptions.pathinfo
+			? Template.toComment(
+					`__webpack_is_included__ ${runtimeTemplate.requestShortener.shorten(
+						dep.request
+					)}`
+				)
+			: "";
+
+		source.replace(
+			dep.range[0],
+			dep.range[1] - 1,
+			`${comment}${JSON.stringify(included)}`
+		);
+	}
+};
+
+module.exports = WebpackIsIncludedDependency;

package/lib/dependencies/WorkerDependency.js

@@ -0,0 +1,141 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const Dependency = require("../Dependency");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Entrypoint")} Entrypoint */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @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 */
+
+/**
+ * @typedef {object} WorkerDependencyOptions
+ * @property {string=} publicPath public path for the worker
+ * @property {boolean=} needNewUrl true when need generate `new URL(...)`, otherwise false
+ */
+
+class WorkerDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request
+	 * @param {Range} range range
+	 * @param {WorkerDependencyOptions} workerDependencyOptions options
+	 */
+	constructor(request, range, workerDependencyOptions) {
+		super(request);
+		this.range = range;
+		// If options are updated, don't forget to update the hash and serialization functions
+		/** @type {WorkerDependencyOptions} */
+		this.options = workerDependencyOptions;
+		/** Cache the hash */
+		/** @type {undefined | string} */
+		this._hashUpdate = 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 {ReferencedExports} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		return Dependency.NO_EXPORTS_REFERENCED;
+	}
+
+	get type() {
+		return "new Worker()";
+	}
+
+	get category() {
+		return "worker";
+	}
+
+	/**
+	 * 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 = JSON.stringify(this.options);
+		}
+		hash.update(this._hashUpdate);
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.options);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.options = read();
+		super.deserialize(context);
+	}
+}
+
+WorkerDependency.Template = class WorkerDependencyTemplate 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 { chunkGraph, moduleGraph, runtimeRequirements } = templateContext;
+		const dep = /** @type {WorkerDependency} */ (dependency);
+		const block = /** @type {AsyncDependenciesBlock} */ (
+			moduleGraph.getParentBlock(dependency)
+		);
+		const entrypoint = /** @type {Entrypoint} */ (
+			chunkGraph.getBlockChunkGroup(block)
+		);
+		const chunk = entrypoint.getEntrypointChunk();
+		// We use the workerPublicPath option if provided, else we fallback to the RuntimeGlobal publicPath
+		const workerImportBaseUrl = dep.options.publicPath
+			? `"${dep.options.publicPath}"`
+			: RuntimeGlobals.publicPath;
+
+		runtimeRequirements.add(RuntimeGlobals.publicPath);
+		runtimeRequirements.add(RuntimeGlobals.baseURI);
+		runtimeRequirements.add(RuntimeGlobals.getChunkScriptFilename);
+
+		const workerImportStr = `/* worker import */ ${workerImportBaseUrl} + ${
+			RuntimeGlobals.getChunkScriptFilename
+		}(${JSON.stringify(chunk.id)}), ${RuntimeGlobals.baseURI}`;
+
+		source.replace(
+			dep.range[0],
+			dep.range[1] - 1,
+			dep.options.needNewUrl ? `new URL(${workerImportStr})` : workerImportStr
+		);
+	}
+};
+
+makeSerializable(WorkerDependency, "webpack/lib/dependencies/WorkerDependency");
+
+module.exports = WorkerDependency;