@depup/webpack 5.105.4-depup.37

package/lib/dependencies/AMDRequireDependenciesBlockParserPlugin.js

@@ -0,0 +1,425 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
+const AMDRequireArrayDependency = require("./AMDRequireArrayDependency");
+const AMDRequireContextDependency = require("./AMDRequireContextDependency");
+const AMDRequireDependenciesBlock = require("./AMDRequireDependenciesBlock");
+const AMDRequireDependency = require("./AMDRequireDependency");
+const AMDRequireItemDependency = require("./AMDRequireItemDependency");
+const ConstDependency = require("./ConstDependency");
+const ContextDependencyHelpers = require("./ContextDependencyHelpers");
+const LocalModuleDependency = require("./LocalModuleDependency");
+const { getLocalModule } = require("./LocalModulesHelpers");
+const UnsupportedDependency = require("./UnsupportedDependency");
+const getFunctionExpression = require("./getFunctionExpression");
+
+/** @typedef {import("estree").CallExpression} CallExpression */
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").Identifier} Identifier */
+/** @typedef {import("estree").SourceLocation} SourceLocation */
+/** @typedef {import("estree").SpreadElement} SpreadElement */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("./LocalModule")} LocalModule */
+
+const PLUGIN_NAME = "AMDRequireDependenciesBlockParserPlugin";
+
+class AMDRequireDependenciesBlockParserPlugin {
+	/**
+	 * @param {JavascriptParserOptions} options parserOptions
+	 */
+	constructor(options) {
+		this.options = options;
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {Expression | SpreadElement} expression expression
+	 * @returns {boolean} need bind this
+	 */
+	processFunctionArgument(parser, expression) {
+		let bindThis = true;
+		const fnData = getFunctionExpression(expression);
+		if (fnData) {
+			parser.inScope(
+				fnData.fn.params.filter(
+					(i) =>
+						!["require", "module", "exports"].includes(
+							/** @type {Identifier} */ (i).name
+						)
+				),
+				() => {
+					if (fnData.fn.body.type === "BlockStatement") {
+						parser.walkStatement(fnData.fn.body);
+					} else {
+						parser.walkExpression(fnData.fn.body);
+					}
+				}
+			);
+			parser.walkExpressions(fnData.expressions);
+			if (fnData.needThis === false) {
+				bindThis = false;
+			}
+		} else {
+			parser.walkExpression(expression);
+		}
+		return bindThis;
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
+	apply(parser) {
+		parser.hooks.call
+			.for("require")
+			.tap(PLUGIN_NAME, this.processCallRequire.bind(this, parser));
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {CallExpression} expr call expression
+	 * @param {BasicEvaluatedExpression} param param
+	 * @returns {boolean | undefined} result
+	 */
+	processArray(parser, expr, param) {
+		if (param.isArray()) {
+			for (const p of /** @type {BasicEvaluatedExpression[]} */ (param.items)) {
+				const result = this.processItem(parser, expr, p);
+				if (result === undefined) {
+					this.processContext(parser, expr, p);
+				}
+			}
+			return true;
+		} else if (param.isConstArray()) {
+			/** @type {(string | LocalModuleDependency | AMDRequireItemDependency)[]} */
+			const deps = [];
+			for (const request of /** @type {string[]} */ (param.array)) {
+				/** @type {string | LocalModuleDependency | AMDRequireItemDependency} */
+				let dep;
+				/** @type {undefined | null | LocalModule} */
+				let localModule;
+				if (request === "require") {
+					dep = RuntimeGlobals.require;
+				} else if (["exports", "module"].includes(request)) {
+					dep = request;
+				} else if ((localModule = getLocalModule(parser.state, request))) {
+					localModule.flagUsed();
+					dep = new LocalModuleDependency(localModule, undefined, false);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					parser.state.module.addPresentationalDependency(dep);
+				} else {
+					dep = this.newRequireItemDependency(request);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					dep.optional = Boolean(parser.scope.inTry);
+					parser.state.current.addDependency(dep);
+				}
+				deps.push(dep);
+			}
+			const dep = this.newRequireArrayDependency(
+				deps,
+				/** @type {Range} */
+				(param.range)
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.optional = Boolean(parser.scope.inTry);
+			parser.state.module.addPresentationalDependency(dep);
+			return true;
+		}
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {CallExpression} expr call expression
+	 * @param {BasicEvaluatedExpression} param param
+	 * @returns {boolean | undefined} result
+	 */
+	processItem(parser, expr, param) {
+		if (param.isConditional()) {
+			for (const p of /** @type {BasicEvaluatedExpression[]} */ (
+				param.options
+			)) {
+				const result = this.processItem(parser, expr, p);
+				if (result === undefined) {
+					this.processContext(parser, expr, p);
+				}
+			}
+			return true;
+		} else if (param.isString()) {
+			/** @type {Dependency} */
+			let dep;
+			/** @type {LocalModule | null | undefined} */
+			let localModule;
+			if (param.string === "require") {
+				dep = new ConstDependency(
+					RuntimeGlobals.require,
+					/** @type {Range} */
+					(param.range),
+					[RuntimeGlobals.require]
+				);
+			} else if (param.string === "module") {
+				dep = new ConstDependency(
+					parser.state.module.moduleArgument,
+					/** @type {Range} */
+					(param.range),
+					[RuntimeGlobals.module]
+				);
+			} else if (param.string === "exports") {
+				dep = new ConstDependency(
+					parser.state.module.exportsArgument,
+					/** @type {Range} */
+					(param.range),
+					[RuntimeGlobals.exports]
+				);
+			} else if (
+				(localModule = getLocalModule(
+					parser.state,
+					/** @type {string} */
+					(param.string)
+				))
+			) {
+				localModule.flagUsed();
+				dep = new LocalModuleDependency(localModule, param.range, false);
+			} else {
+				dep = this.newRequireItemDependency(
+					/** @type {string} */
+					(param.string),
+					param.range
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.optional = Boolean(parser.scope.inTry);
+				parser.state.current.addDependency(dep);
+				return true;
+			}
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			parser.state.module.addPresentationalDependency(dep);
+			return true;
+		}
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {CallExpression} expr call expression
+	 * @param {BasicEvaluatedExpression} param param
+	 * @returns {boolean | undefined} result
+	 */
+	processContext(parser, expr, param) {
+		const dep = ContextDependencyHelpers.create(
+			AMDRequireContextDependency,
+			/** @type {Range} */
+			(param.range),
+			param,
+			expr,
+			this.options,
+			{
+				category: "amd"
+			},
+			parser
+		);
+		if (!dep) return;
+		dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+		dep.optional = Boolean(parser.scope.inTry);
+		parser.state.current.addDependency(dep);
+		return true;
+	}
+
+	/**
+	 * @param {BasicEvaluatedExpression} param param
+	 * @returns {string | undefined} result
+	 */
+	processArrayForRequestString(param) {
+		if (param.isArray()) {
+			const result =
+				/** @type {BasicEvaluatedExpression[]} */
+				(param.items).map((item) => this.processItemForRequestString(item));
+			if (result.every(Boolean)) return result.join(" ");
+		} else if (param.isConstArray()) {
+			return /** @type {string[]} */ (param.array).join(" ");
+		}
+	}
+
+	/**
+	 * @param {BasicEvaluatedExpression} param param
+	 * @returns {string | undefined} result
+	 */
+	processItemForRequestString(param) {
+		if (param.isConditional()) {
+			const result =
+				/** @type {BasicEvaluatedExpression[]} */
+				(param.options).map((item) => this.processItemForRequestString(item));
+			if (result.every(Boolean)) return result.join("|");
+		} else if (param.isString()) {
+			return param.string;
+		}
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {CallExpression} expr call expression
+	 * @returns {boolean | undefined} result
+	 */
+	processCallRequire(parser, expr) {
+		/** @type {BasicEvaluatedExpression | undefined} */
+		let param;
+		/** @type {AMDRequireDependenciesBlock | undefined | null} */
+		let depBlock;
+		/** @type {AMDRequireDependency | undefined} */
+		let dep;
+		/** @type {boolean | undefined} */
+		let result;
+
+		const old = parser.state.current;
+
+		if (expr.arguments.length >= 1) {
+			param = parser.evaluateExpression(
+				/** @type {Expression} */ (expr.arguments[0])
+			);
+			depBlock = this.newRequireDependenciesBlock(
+				/** @type {DependencyLocation} */ (expr.loc),
+				this.processArrayForRequestString(param)
+			);
+			dep = this.newRequireDependency(
+				/** @type {Range} */ (expr.range),
+				/** @type {Range} */ (param.range),
+				expr.arguments.length > 1
+					? /** @type {Range} */ (expr.arguments[1].range)
+					: null,
+				expr.arguments.length > 2
+					? /** @type {Range} */ (expr.arguments[2].range)
+					: null
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			depBlock.addDependency(dep);
+
+			parser.state.current = /** @type {EXPECTED_ANY} */ (depBlock);
+		}
+
+		if (expr.arguments.length === 1) {
+			parser.inScope([], () => {
+				result = this.processArray(
+					parser,
+					expr,
+					/** @type {BasicEvaluatedExpression} */
+					(param)
+				);
+			});
+			parser.state.current = old;
+			if (!result) return;
+			parser.state.current.addBlock(
+				/** @type {AMDRequireDependenciesBlock} */
+				(depBlock)
+			);
+			return true;
+		}
+
+		if (expr.arguments.length === 2 || expr.arguments.length === 3) {
+			try {
+				parser.inScope([], () => {
+					result = this.processArray(
+						parser,
+						expr,
+						/** @type {BasicEvaluatedExpression} */
+						(param)
+					);
+				});
+				if (!result) {
+					const dep = new UnsupportedDependency(
+						"unsupported",
+						/** @type {Range} */
+						(expr.range)
+					);
+					old.addPresentationalDependency(dep);
+					if (parser.state.module) {
+						parser.state.module.addError(
+							new UnsupportedFeatureWarning(
+								`Cannot statically analyse 'require(…, …)' in line ${
+									/** @type {SourceLocation} */ (expr.loc).start.line
+								}`,
+								/** @type {DependencyLocation} */
+								(expr.loc)
+							)
+						);
+					}
+					depBlock = null;
+					return true;
+				}
+				/** @type {AMDRequireDependency} */
+				(dep).functionBindThis = this.processFunctionArgument(
+					parser,
+					expr.arguments[1]
+				);
+				if (expr.arguments.length === 3) {
+					/** @type {AMDRequireDependency} */
+					(dep).errorCallbackBindThis = this.processFunctionArgument(
+						parser,
+						expr.arguments[2]
+					);
+				}
+			} finally {
+				parser.state.current = old;
+				if (depBlock) parser.state.current.addBlock(depBlock);
+			}
+			return true;
+		}
+	}
+
+	/**
+	 * @param {DependencyLocation} loc location
+	 * @param {string=} request request
+	 * @returns {AMDRequireDependenciesBlock} AMDRequireDependenciesBlock
+	 */
+	newRequireDependenciesBlock(loc, request) {
+		return new AMDRequireDependenciesBlock(loc, request);
+	}
+
+	/**
+	 * @param {Range} outerRange outer range
+	 * @param {Range} arrayRange array range
+	 * @param {Range | null} functionRange function range
+	 * @param {Range | null} errorCallbackRange error callback range
+	 * @returns {AMDRequireDependency} dependency
+	 */
+	newRequireDependency(
+		outerRange,
+		arrayRange,
+		functionRange,
+		errorCallbackRange
+	) {
+		return new AMDRequireDependency(
+			outerRange,
+			arrayRange,
+			functionRange,
+			errorCallbackRange
+		);
+	}
+
+	/**
+	 * @param {string} request request
+	 * @param {Range=} range range
+	 * @returns {AMDRequireItemDependency} AMDRequireItemDependency
+	 */
+	newRequireItemDependency(request, range) {
+		return new AMDRequireItemDependency(request, range);
+	}
+
+	/**
+	 * @param {(string | LocalModuleDependency | AMDRequireItemDependency)[]} depsArray deps array
+	 * @param {Range} range range
+	 * @returns {AMDRequireArrayDependency} AMDRequireArrayDependency
+	 */
+	newRequireArrayDependency(depsArray, range) {
+		return new AMDRequireArrayDependency(depsArray, range);
+	}
+}
+
+module.exports = AMDRequireDependenciesBlockParserPlugin;

package/lib/dependencies/AMDRequireDependency.js

@@ -0,0 +1,189 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const makeSerializable = require("../util/makeSerializable");
+const NullDependency = require("./NullDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @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 AMDRequireDependency extends NullDependency {
+	/**
+	 * @param {Range} outerRange outer range
+	 * @param {Range} arrayRange array range
+	 * @param {Range | null} functionRange function range
+	 * @param {Range | null} errorCallbackRange error callback range
+	 */
+	constructor(outerRange, arrayRange, functionRange, errorCallbackRange) {
+		super();
+
+		this.outerRange = outerRange;
+		this.arrayRange = arrayRange;
+		this.functionRange = functionRange;
+		this.errorCallbackRange = errorCallbackRange;
+		this.functionBindThis = false;
+		this.errorCallbackBindThis = false;
+	}
+
+	get category() {
+		return "amd";
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+
+		write(this.outerRange);
+		write(this.arrayRange);
+		write(this.functionRange);
+		write(this.errorCallbackRange);
+		write(this.functionBindThis);
+		write(this.errorCallbackBindThis);
+
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+
+		this.outerRange = read();
+		this.arrayRange = read();
+		this.functionRange = read();
+		this.errorCallbackRange = read();
+		this.functionBindThis = read();
+		this.errorCallbackBindThis = read();
+
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	AMDRequireDependency,
+	"webpack/lib/dependencies/AMDRequireDependency"
+);
+
+AMDRequireDependency.Template = class AMDRequireDependencyTemplate 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, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		const dep = /** @type {AMDRequireDependency} */ (dependency);
+		const depBlock = /** @type {AsyncDependenciesBlock} */ (
+			moduleGraph.getParentBlock(dep)
+		);
+		const promise = runtimeTemplate.blockPromise({
+			chunkGraph,
+			block: depBlock,
+			message: "AMD require",
+			runtimeRequirements
+		});
+
+		// has array range but no function range
+		if (dep.arrayRange && !dep.functionRange) {
+			const startBlock = `${promise}.then(function() {`;
+			const endBlock = `;})['catch'](${RuntimeGlobals.uncaughtErrorHandler})`;
+			runtimeRequirements.add(RuntimeGlobals.uncaughtErrorHandler);
+
+			source.replace(dep.outerRange[0], dep.arrayRange[0] - 1, startBlock);
+
+			source.replace(dep.arrayRange[1], dep.outerRange[1] - 1, endBlock);
+
+			return;
+		}
+
+		// has function range but no array range
+		if (dep.functionRange && !dep.arrayRange) {
+			const startBlock = `${promise}.then((`;
+			const endBlock = `).bind(exports, ${RuntimeGlobals.require}, exports, module))['catch'](${RuntimeGlobals.uncaughtErrorHandler})`;
+			runtimeRequirements.add(RuntimeGlobals.uncaughtErrorHandler);
+
+			source.replace(dep.outerRange[0], dep.functionRange[0] - 1, startBlock);
+
+			source.replace(dep.functionRange[1], dep.outerRange[1] - 1, endBlock);
+
+			return;
+		}
+
+		// has array range, function range, and errorCallbackRange
+		if (dep.arrayRange && dep.functionRange && dep.errorCallbackRange) {
+			const startBlock = `${promise}.then(function() { `;
+			const errorRangeBlock = `}${
+				dep.functionBindThis ? ".bind(this)" : ""
+			})['catch'](`;
+			const endBlock = `${dep.errorCallbackBindThis ? ".bind(this)" : ""})`;
+
+			source.replace(dep.outerRange[0], dep.arrayRange[0] - 1, startBlock);
+
+			source.insert(dep.arrayRange[0], "var __WEBPACK_AMD_REQUIRE_ARRAY__ = ");
+
+			source.replace(dep.arrayRange[1], dep.functionRange[0] - 1, "; (");
+
+			source.insert(
+				dep.functionRange[1],
+				").apply(null, __WEBPACK_AMD_REQUIRE_ARRAY__);"
+			);
+
+			source.replace(
+				dep.functionRange[1],
+				dep.errorCallbackRange[0] - 1,
+				errorRangeBlock
+			);
+
+			source.replace(
+				dep.errorCallbackRange[1],
+				dep.outerRange[1] - 1,
+				endBlock
+			);
+
+			return;
+		}
+
+		// has array range, function range, but no errorCallbackRange
+		if (dep.arrayRange && dep.functionRange) {
+			const startBlock = `${promise}.then(function() { `;
+			const endBlock = `}${
+				dep.functionBindThis ? ".bind(this)" : ""
+			})['catch'](${RuntimeGlobals.uncaughtErrorHandler})`;
+			runtimeRequirements.add(RuntimeGlobals.uncaughtErrorHandler);
+
+			source.replace(dep.outerRange[0], dep.arrayRange[0] - 1, startBlock);
+
+			source.insert(dep.arrayRange[0], "var __WEBPACK_AMD_REQUIRE_ARRAY__ = ");
+
+			source.replace(dep.arrayRange[1], dep.functionRange[0] - 1, "; (");
+
+			source.insert(
+				dep.functionRange[1],
+				").apply(null, __WEBPACK_AMD_REQUIRE_ARRAY__);"
+			);
+
+			source.replace(dep.functionRange[1], dep.outerRange[1] - 1, endBlock);
+		}
+	}
+};
+
+module.exports = AMDRequireDependency;

package/lib/dependencies/AMDRequireItemDependency.js

@@ -0,0 +1,41 @@
+/*
+	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 ModuleDependencyTemplateAsRequireId = require("./ModuleDependencyTemplateAsRequireId");
+
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+class AMDRequireItemDependency extends ModuleDependency {
+	/**
+	 * @param {string} request the request string
+	 * @param {Range=} range location in source code
+	 */
+	constructor(request, range) {
+		super(request);
+
+		this.range = range;
+	}
+
+	get type() {
+		return "amd require";
+	}
+
+	get category() {
+		return "amd";
+	}
+}
+
+makeSerializable(
+	AMDRequireItemDependency,
+	"webpack/lib/dependencies/AMDRequireItemDependency"
+);
+
+AMDRequireItemDependency.Template = ModuleDependencyTemplateAsRequireId;
+
+module.exports = AMDRequireItemDependency;

package/lib/dependencies/AMDRuntimeModules.js

@@ -0,0 +1,50 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+const Template = require("../Template");
+
+/** @typedef {import("./AMDPlugin").AmdOptions} AmdOptions */
+
+class AMDDefineRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("amd define");
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		return Template.asString([
+			`${RuntimeGlobals.amdDefine} = function () {`,
+			Template.indent("throw new Error('define cannot be used indirect');"),
+			"};"
+		]);
+	}
+}
+
+class AMDOptionsRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {AmdOptions} options the AMD options
+	 */
+	constructor(options) {
+		super("amd options");
+		this.options = options;
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		return Template.asString([
+			`${RuntimeGlobals.amdOptions} = ${JSON.stringify(this.options)};`
+		]);
+	}
+}
+
+module.exports.AMDDefineRuntimeModule = AMDDefineRuntimeModule;
+module.exports.AMDOptionsRuntimeModule = AMDOptionsRuntimeModule;