@depup/webpack 5.105.4-depup.37

package/lib/dependencies/CommonJsPlugin.js

@@ -0,0 +1,316 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC
+} = require("../ModuleTypeConstants");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+const SelfModuleFactory = require("../SelfModuleFactory");
+const Template = require("../Template");
+const {
+	evaluateToIdentifier,
+	expressionIsUnsupported,
+	toConstantDependency
+} = require("../javascript/JavascriptParserHelpers");
+const CommonJsExportRequireDependency = require("./CommonJsExportRequireDependency");
+const CommonJsExportsDependency = require("./CommonJsExportsDependency");
+const CommonJsExportsParserPlugin = require("./CommonJsExportsParserPlugin");
+const CommonJsFullRequireDependency = require("./CommonJsFullRequireDependency");
+const CommonJsImportsParserPlugin = require("./CommonJsImportsParserPlugin");
+const CommonJsRequireContextDependency = require("./CommonJsRequireContextDependency");
+const CommonJsRequireDependency = require("./CommonJsRequireDependency");
+const CommonJsSelfReferenceDependency = require("./CommonJsSelfReferenceDependency");
+const ModuleDecoratorDependency = require("./ModuleDecoratorDependency");
+const RequireHeaderDependency = require("./RequireHeaderDependency");
+const RequireResolveContextDependency = require("./RequireResolveContextDependency");
+const RequireResolveDependency = require("./RequireResolveDependency");
+const RequireResolveHeaderDependency = require("./RequireResolveHeaderDependency");
+const RuntimeRequirementsDependency = require("./RuntimeRequirementsDependency");
+
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../javascript/JavascriptParser")} Parser */
+
+const PLUGIN_NAME = "CommonJsPlugin";
+
+class CommonJsPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			PLUGIN_NAME,
+			(compilation, { contextModuleFactory, normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					CommonJsRequireDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					CommonJsRequireDependency,
+					new CommonJsRequireDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					CommonJsFullRequireDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					CommonJsFullRequireDependency,
+					new CommonJsFullRequireDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					CommonJsRequireContextDependency,
+					contextModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					CommonJsRequireContextDependency,
+					new CommonJsRequireContextDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					RequireResolveDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					RequireResolveDependency,
+					new RequireResolveDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					RequireResolveContextDependency,
+					contextModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					RequireResolveContextDependency,
+					new RequireResolveContextDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					RequireResolveHeaderDependency,
+					new RequireResolveHeaderDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					RequireHeaderDependency,
+					new RequireHeaderDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					CommonJsExportsDependency,
+					new CommonJsExportsDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					CommonJsExportRequireDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					CommonJsExportRequireDependency,
+					new CommonJsExportRequireDependency.Template()
+				);
+
+				const selfFactory = new SelfModuleFactory(compilation.moduleGraph);
+
+				compilation.dependencyFactories.set(
+					CommonJsSelfReferenceDependency,
+					selfFactory
+				);
+				compilation.dependencyTemplates.set(
+					CommonJsSelfReferenceDependency,
+					new CommonJsSelfReferenceDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					ModuleDecoratorDependency,
+					selfFactory
+				);
+				compilation.dependencyTemplates.set(
+					ModuleDecoratorDependency,
+					new ModuleDecoratorDependency.Template()
+				);
+
+				compilation.hooks.runtimeRequirementInModule
+					.for(RuntimeGlobals.harmonyModuleDecorator)
+					.tap(PLUGIN_NAME, (module, set) => {
+						set.add(RuntimeGlobals.module);
+						set.add(RuntimeGlobals.requireScope);
+					});
+
+				compilation.hooks.runtimeRequirementInModule
+					.for(RuntimeGlobals.nodeModuleDecorator)
+					.tap(PLUGIN_NAME, (module, set) => {
+						set.add(RuntimeGlobals.module);
+						set.add(RuntimeGlobals.requireScope);
+					});
+
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.harmonyModuleDecorator)
+					.tap(PLUGIN_NAME, (chunk, _set) => {
+						compilation.addRuntimeModule(
+							chunk,
+							new HarmonyModuleDecoratorRuntimeModule()
+						);
+					});
+
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.nodeModuleDecorator)
+					.tap(PLUGIN_NAME, (chunk, _set) => {
+						compilation.addRuntimeModule(
+							chunk,
+							new NodeModuleDecoratorRuntimeModule()
+						);
+					});
+
+				/**
+				 * @param {Parser} parser parser parser
+				 * @param {JavascriptParserOptions} parserOptions parserOptions
+				 * @returns {void}
+				 */
+				const handler = (parser, parserOptions) => {
+					if (parserOptions.commonjs !== undefined && !parserOptions.commonjs) {
+						return;
+					}
+					parser.hooks.typeof
+						.for("module")
+						.tap(
+							PLUGIN_NAME,
+							toConstantDependency(parser, JSON.stringify("object"))
+						);
+
+					parser.hooks.expression
+						.for("require.main")
+						.tap(
+							PLUGIN_NAME,
+							toConstantDependency(
+								parser,
+								`${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}]`,
+								[RuntimeGlobals.moduleCache, RuntimeGlobals.entryModuleId]
+							)
+						);
+
+					parser.hooks.expression
+						.for("require.extensions")
+						.tap(
+							PLUGIN_NAME,
+							expressionIsUnsupported(
+								parser,
+								"require.extensions is not supported by webpack. Use a loader instead."
+							)
+						);
+
+					parser.hooks.expression
+						.for(RuntimeGlobals.moduleLoaded)
+						.tap(PLUGIN_NAME, (expr) => {
+							/** @type {BuildInfo} */
+							(parser.state.module.buildInfo).moduleConcatenationBailout =
+								RuntimeGlobals.moduleLoaded;
+							const dep = new RuntimeRequirementsDependency([
+								RuntimeGlobals.moduleLoaded
+							]);
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
+
+					parser.hooks.expression
+						.for(RuntimeGlobals.moduleId)
+						.tap(PLUGIN_NAME, (expr) => {
+							/** @type {BuildInfo} */
+							(parser.state.module.buildInfo).moduleConcatenationBailout =
+								RuntimeGlobals.moduleId;
+							const dep = new RuntimeRequirementsDependency([
+								RuntimeGlobals.moduleId
+							]);
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
+
+					parser.hooks.evaluateIdentifier.for("module.hot").tap(
+						PLUGIN_NAME,
+						evaluateToIdentifier("module.hot", "module", () => ["hot"], null)
+					);
+
+					new CommonJsImportsParserPlugin(parserOptions).apply(parser);
+					new CommonJsExportsParserPlugin(compilation.moduleGraph).apply(
+						parser
+					);
+				};
+
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
+				normalModuleFactory.hooks.parser
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, handler);
+			}
+		);
+	}
+}
+
+class HarmonyModuleDecoratorRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("harmony module decorator");
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const { runtimeTemplate } = /** @type {Compilation} */ (this.compilation);
+		return Template.asString([
+			`${
+				RuntimeGlobals.harmonyModuleDecorator
+			} = ${runtimeTemplate.basicFunction("module", [
+				"module = Object.create(module);",
+				"if (!module.children) module.children = [];",
+				"Object.defineProperty(module, 'exports', {",
+				Template.indent([
+					"enumerable: true,",
+					`set: ${runtimeTemplate.basicFunction("", [
+						"throw new Error('ES Modules may not assign module.exports or exports.*, Use ESM export syntax, instead: ' + module.id);"
+					])}`
+				]),
+				"});",
+				"return module;"
+			])};`
+		]);
+	}
+}
+
+class NodeModuleDecoratorRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("node module decorator");
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const { runtimeTemplate } = /** @type {Compilation} */ (this.compilation);
+		return Template.asString([
+			`${RuntimeGlobals.nodeModuleDecorator} = ${runtimeTemplate.basicFunction(
+				"module",
+				[
+					"module.paths = [];",
+					"if (!module.children) module.children = [];",
+					"return module;"
+				]
+			)};`
+		]);
+	}
+}
+
+module.exports = CommonJsPlugin;

package/lib/dependencies/CommonJsRequireContextDependency.js

@@ -0,0 +1,73 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+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("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
+
+class CommonJsRequireContextDependency extends ContextDependency {
+	/**
+	 * @param {ContextDependencyOptions} options options for the context module
+	 * @param {Range} range location in source code
+	 * @param {Range=} valueRange location of the require call
+	 * @param {boolean | string=} inShorthand true or name
+	 * @param {string=} context context
+	 */
+	constructor(options, range, valueRange, inShorthand, context) {
+		super(options, context);
+
+		this.range = range;
+		this.valueRange = valueRange;
+		// inShorthand must be serialized by subclasses that use it
+		this.inShorthand = inShorthand;
+	}
+
+	get type() {
+		return "cjs require context";
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+
+		write(this.range);
+		write(this.valueRange);
+		write(this.inShorthand);
+
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+
+		this.range = read();
+		this.valueRange = read();
+		this.inShorthand = read();
+
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	CommonJsRequireContextDependency,
+	"webpack/lib/dependencies/CommonJsRequireContextDependency"
+);
+
+CommonJsRequireContextDependency.Template =
+	ContextDependencyTemplateAsRequireCall;
+
+module.exports = CommonJsRequireContextDependency;

package/lib/dependencies/CommonJsRequireDependency.js

@@ -0,0 +1,42 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+const ModuleDependencyTemplateAsId = require("./ModuleDependencyTemplateAsId");
+
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+class CommonJsRequireDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request
+	 * @param {Range=} range location in source code
+	 * @param {string=} context request context
+	 */
+	constructor(request, range, context) {
+		super(request);
+		this.range = range;
+		this._context = context;
+	}
+
+	get type() {
+		return "cjs require";
+	}
+
+	get category() {
+		return "commonjs";
+	}
+}
+
+CommonJsRequireDependency.Template = ModuleDependencyTemplateAsId;
+
+makeSerializable(
+	CommonJsRequireDependency,
+	"webpack/lib/dependencies/CommonJsRequireDependency"
+);
+
+module.exports = CommonJsRequireDependency;

package/lib/dependencies/CommonJsSelfReferenceDependency.js

@@ -0,0 +1,156 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const { equals } = require("../util/ArrayHelpers");
+const makeSerializable = require("../util/makeSerializable");
+const propertyAccess = require("../util/propertyAccess");
+const NullDependency = require("./NullDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ExportsInfo").ExportInfoName} ExportInfoName */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./CommonJsDependencyHelpers").CommonJSDependencyBaseKeywords} CommonJSDependencyBaseKeywords */
+
+class CommonJsSelfReferenceDependency extends NullDependency {
+	/**
+	 * @param {Range} range range
+	 * @param {CommonJSDependencyBaseKeywords} base base
+	 * @param {ExportInfoName[]} names names
+	 * @param {boolean} call is a call
+	 */
+	constructor(range, base, names, call) {
+		super();
+		this.range = range;
+		this.base = base;
+		this.names = names;
+		this.call = call;
+	}
+
+	get type() {
+		return "cjs self exports reference";
+	}
+
+	get category() {
+		return "self";
+	}
+
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		return "self";
+	}
+
+	/**
+	 * 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.call ? this.names.slice(0, -1) : this.names];
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		write(this.base);
+		write(this.names);
+		write(this.call);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		this.base = read();
+		this.names = read();
+		this.call = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	CommonJsSelfReferenceDependency,
+	"webpack/lib/dependencies/CommonJsSelfReferenceDependency"
+);
+
+CommonJsSelfReferenceDependency.Template = class CommonJsSelfReferenceDependencyTemplate 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, runtime, runtimeRequirements }
+	) {
+		const dep = /** @type {CommonJsSelfReferenceDependency} */ (dependency);
+		const used =
+			dep.names.length === 0
+				? dep.names
+				: moduleGraph.getExportsInfo(module).getUsedName(dep.names, runtime);
+		if (!used) {
+			throw new Error(
+				"Self-reference dependency has unused export name: This should not happen"
+			);
+		}
+
+		/** @type {string} */
+		let base;
+		switch (dep.base) {
+			case "exports":
+				runtimeRequirements.add(RuntimeGlobals.exports);
+				base = module.exportsArgument;
+				break;
+			case "module.exports":
+				runtimeRequirements.add(RuntimeGlobals.module);
+				base = `${module.moduleArgument}.exports`;
+				break;
+			case "this":
+				runtimeRequirements.add(RuntimeGlobals.thisAsExports);
+				base = "this";
+				break;
+			default:
+				throw new Error(`Unsupported base ${dep.base}`);
+		}
+
+		if (base === dep.base && equals(used, dep.names)) {
+			// Nothing has to be changed
+			// We don't use a replacement for compat reasons
+			// for plugins that update `module._source` which they
+			// shouldn't do!
+			return;
+		}
+
+		source.replace(
+			dep.range[0],
+			dep.range[1] - 1,
+			`${base}${propertyAccess(used)}`
+		);
+	}
+};
+
+module.exports = CommonJsSelfReferenceDependency;

package/lib/dependencies/ConstDependency.js

@@ -0,0 +1,118 @@
+/*
+	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("./NullDependency").RawRuntimeRequirements} RawRuntimeRequirements */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
+
+class ConstDependency extends NullDependency {
+	/**
+	 * @param {string} expression the expression
+	 * @param {number | Range} range the source range
+	 * @param {RawRuntimeRequirements | null=} runtimeRequirements runtime requirements
+	 */
+	constructor(expression, range, runtimeRequirements) {
+		super();
+		this.expression = expression;
+		this.range = range;
+		this.runtimeRequirements = runtimeRequirements
+			? new Set(runtimeRequirements)
+			: null;
+		/** @type {undefined | string} */
+		this._hashUpdate = undefined;
+	}
+
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		if (this._hashUpdate === undefined) {
+			let hashUpdate = `${this.range}|${this.expression}`;
+			if (this.runtimeRequirements) {
+				for (const item of this.runtimeRequirements) {
+					hashUpdate += "|";
+					hashUpdate += item;
+				}
+			}
+			this._hashUpdate = hashUpdate;
+		}
+		hash.update(this._hashUpdate);
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 */
+	getModuleEvaluationSideEffectsState(moduleGraph) {
+		return false;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.expression);
+		write(this.range);
+		write(this.runtimeRequirements);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.expression = read();
+		this.range = read();
+		this.runtimeRequirements = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(ConstDependency, "webpack/lib/dependencies/ConstDependency");
+
+ConstDependency.Template = class ConstDependencyTemplate 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, templateContext) {
+		const dep = /** @type {ConstDependency} */ (dependency);
+		if (dep.runtimeRequirements) {
+			for (const req of dep.runtimeRequirements) {
+				templateContext.runtimeRequirements.add(req);
+			}
+		}
+		if (typeof dep.range === "number") {
+			source.insert(dep.range, dep.expression);
+			return;
+		}
+
+		source.replace(dep.range[0], dep.range[1] - 1, dep.expression);
+	}
+};
+
+module.exports = ConstDependency;