webpack 5.105.2 → 5.105.3

package/lib/dependencies/CommonJsImportsParserPlugin.js

@@ -5,13 +5,9 @@
 
 "use strict";
 
-const { fileURLToPath } = require("url");
 const CommentCompilationWarning = require("../CommentCompilationWarning");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
-const WebpackError = require("../WebpackError");
-const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
-const { VariableInfo } = require("../javascript/JavascriptParser");
 const {
 	evaluateToIdentifier,
 	evaluateToString,
@@ -36,6 +32,7 @@ const RequireResolveHeaderDependency = require("./RequireResolveHeaderDependency
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
 /** @typedef {import("../javascript/JavascriptParser").ImportSource} ImportSource */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../javascript/JavascriptParser").Members} Members */
@@ -48,11 +45,300 @@ const RequireResolveHeaderDependency = require("./RequireResolveHeaderDependency
  * @property {string} context
  */
 
-const createRequireSpecifierTag = Symbol("createRequire");
-const createdRequireIdentifierTag = Symbol("createRequire()");
-
 const PLUGIN_NAME = "CommonJsImportsParserPlugin";
 
+/**
+ * @param {JavascriptParser} parser parser
+ * @returns {(expr: Expression) => boolean} handler
+ */
+const createRequireCacheDependency = (parser) =>
+	toConstantDependency(parser, RuntimeGlobals.moduleCache, [
+		RuntimeGlobals.moduleCache,
+		RuntimeGlobals.moduleId,
+		RuntimeGlobals.moduleLoaded
+	]);
+
+/**
+ * @param {JavascriptParser} parser parser
+ * @param {JavascriptParserOptions} options options
+ * @param {() => undefined | string} getContext context accessor
+ * @returns {(expr: Expression) => boolean} handler
+ */
+const createRequireAsExpressionHandler =
+	(parser, options, getContext) => (expr) => {
+		const dep = new CommonJsRequireContextDependency(
+			{
+				request: /** @type {string} */ (options.unknownContextRequest),
+				recursive: /** @type {boolean} */ (options.unknownContextRecursive),
+				regExp: /** @type {RegExp} */ (options.unknownContextRegExp),
+				mode: "sync"
+			},
+			/** @type {Range} */ (expr.range),
+			undefined,
+			parser.scope.inShorthand,
+			getContext()
+		);
+		dep.critical =
+			options.unknownContextCritical &&
+			"require function is used in a way in which dependencies cannot be statically extracted";
+		dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+		dep.optional = Boolean(parser.scope.inTry);
+		parser.state.current.addDependency(dep);
+		return true;
+	};
+
+/**
+ * @param {JavascriptParser} parser parser
+ * @param {JavascriptParserOptions} options options
+ * @param {() => undefined | string} getContext context accessor
+ * @returns {(callNew: boolean) => (expr: CallExpression | NewExpression) => (boolean | void)} handler factory
+ */
+const createRequireCallHandler = (parser, options, getContext) => {
+	/**
+	 * @param {CallExpression | NewExpression} expr expression
+	 * @param {BasicEvaluatedExpression} param param
+	 * @returns {boolean | void} true when handled
+	 */
+	const processRequireItem = (expr, param) => {
+		if (param.isString()) {
+			const dep = new CommonJsRequireDependency(
+				/** @type {string} */ (param.string),
+				/** @type {Range} */ (param.range),
+				getContext()
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.optional = Boolean(parser.scope.inTry);
+			parser.state.current.addDependency(dep);
+			return true;
+		}
+	};
+	/**
+	 * @param {CallExpression | NewExpression} expr expression
+	 * @param {BasicEvaluatedExpression} param param
+	 * @returns {boolean | void} true when handled
+	 */
+	const processRequireContext = (expr, param) => {
+		const dep = ContextDependencyHelpers.create(
+			CommonJsRequireContextDependency,
+			/** @type {Range} */ (expr.range),
+			param,
+			expr,
+			options,
+			{
+				category: "commonjs"
+			},
+			parser,
+			undefined,
+			getContext()
+		);
+		if (!dep) return;
+		dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+		dep.optional = Boolean(parser.scope.inTry);
+		parser.state.current.addDependency(dep);
+		return true;
+	};
+
+	return (callNew) => (expr) => {
+		if (options.commonjsMagicComments) {
+			const { options: requireOptions, errors: commentErrors } =
+				parser.parseCommentOptions(/** @type {Range} */ (expr.range));
+
+			if (commentErrors) {
+				for (const e of commentErrors) {
+					const { comment } = e;
+					parser.state.module.addWarning(
+						new CommentCompilationWarning(
+							`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+							/** @type {DependencyLocation} */ (comment.loc)
+						)
+					);
+				}
+			}
+			if (requireOptions && requireOptions.webpackIgnore !== undefined) {
+				if (typeof requireOptions.webpackIgnore !== "boolean") {
+					parser.state.module.addWarning(
+						new UnsupportedFeatureWarning(
+							`\`webpackIgnore\` expected a boolean, but received: ${requireOptions.webpackIgnore}.`,
+							/** @type {DependencyLocation} */ (expr.loc)
+						)
+					);
+				} else if (requireOptions.webpackIgnore) {
+					// Do not instrument `require()` if `webpackIgnore` is `true`
+					return true;
+				}
+			}
+		}
+
+		if (expr.arguments.length !== 1) return;
+		/** @type {null | LocalModule} */
+		let localModule;
+		const param = parser.evaluateExpression(expr.arguments[0]);
+		if (param.isConditional()) {
+			let isExpression = false;
+			for (const p of /** @type {BasicEvaluatedExpression[]} */ (
+				param.options
+			)) {
+				const result = processRequireItem(expr, p);
+				if (result === undefined) {
+					isExpression = true;
+				}
+			}
+			if (!isExpression) {
+				const dep = new RequireHeaderDependency(
+					/** @type {Range} */ (expr.callee.range)
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.module.addPresentationalDependency(dep);
+				return true;
+			}
+		}
+		if (
+			param.isString() &&
+			(localModule = getLocalModule(
+				parser.state,
+				/** @type {string} */ (param.string)
+			))
+		) {
+			localModule.flagUsed();
+			const dep = new LocalModuleDependency(
+				localModule,
+				/** @type {Range} */ (expr.range),
+				callNew
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			parser.state.module.addPresentationalDependency(dep);
+		} else {
+			const result = processRequireItem(expr, param);
+			if (result === undefined) {
+				processRequireContext(expr, param);
+			} else {
+				const dep = new RequireHeaderDependency(
+					/** @type {Range} */ (expr.callee.range)
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.module.addPresentationalDependency(dep);
+			}
+		}
+		return true;
+	};
+};
+
+/**
+ * @param {JavascriptParser} parser parser
+ * @param {JavascriptParserOptions} options options
+ * @param {() => undefined | string} getContext context accessor
+ * @returns {(expr: CallExpression, weak: boolean) => (boolean | void)} resolver
+ */
+const createProcessResolveHandler = (parser, options, getContext) => {
+	/**
+	 * @param {CallExpression} expr call expression
+	 * @param {BasicEvaluatedExpression} param param
+	 * @param {boolean} weak weak
+	 * @returns {boolean | void} true when handled
+	 */
+	const processResolveItem = (expr, param, weak) => {
+		if (param.isString()) {
+			const dep = new RequireResolveDependency(
+				/** @type {string} */ (param.string),
+				/** @type {Range} */ (param.range),
+				getContext()
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.optional = Boolean(parser.scope.inTry);
+			dep.weak = weak;
+			parser.state.current.addDependency(dep);
+			return true;
+		}
+	};
+	/**
+	 * @param {CallExpression} expr call expression
+	 * @param {BasicEvaluatedExpression} param param
+	 * @param {boolean} weak weak
+	 * @returns {boolean | void} true when handled
+	 */
+	const processResolveContext = (expr, param, weak) => {
+		const dep = ContextDependencyHelpers.create(
+			RequireResolveContextDependency,
+			/** @type {Range} */ (param.range),
+			param,
+			expr,
+			options,
+			{
+				category: "commonjs",
+				mode: weak ? "weak" : "sync"
+			},
+			parser,
+			getContext()
+		);
+		if (!dep) return;
+		dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+		dep.optional = Boolean(parser.scope.inTry);
+		parser.state.current.addDependency(dep);
+		return true;
+	};
+
+	return (expr, weak) => {
+		if (!weak && options.commonjsMagicComments) {
+			const { options: requireOptions, errors: commentErrors } =
+				parser.parseCommentOptions(/** @type {Range} */ (expr.range));
+
+			if (commentErrors) {
+				for (const e of commentErrors) {
+					const { comment } = e;
+					parser.state.module.addWarning(
+						new CommentCompilationWarning(
+							`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+							/** @type {DependencyLocation} */ (comment.loc)
+						)
+					);
+				}
+			}
+			if (requireOptions && requireOptions.webpackIgnore !== undefined) {
+				if (typeof requireOptions.webpackIgnore !== "boolean") {
+					parser.state.module.addWarning(
+						new UnsupportedFeatureWarning(
+							`\`webpackIgnore\` expected a boolean, but received: ${requireOptions.webpackIgnore}.`,
+							/** @type {DependencyLocation} */ (expr.loc)
+						)
+					);
+				} else if (requireOptions.webpackIgnore) {
+					// Do not instrument `require()` if `webpackIgnore` is `true`
+					return true;
+				}
+			}
+		}
+
+		if (expr.arguments.length !== 1) return;
+		const param = parser.evaluateExpression(expr.arguments[0]);
+		if (param.isConditional()) {
+			for (const option of /** @type {BasicEvaluatedExpression[]} */ (
+				param.options
+			)) {
+				const result = processResolveItem(expr, option, weak);
+				if (result === undefined) {
+					processResolveContext(expr, option, weak);
+				}
+			}
+			const dep = new RequireResolveHeaderDependency(
+				/** @type {Range} */ (expr.callee.range)
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			parser.state.module.addPresentationalDependency(dep);
+			return true;
+		}
+		const result = processResolveItem(expr, param, weak);
+		if (result === undefined) {
+			processResolveContext(expr, param, weak);
+		}
+		const dep = new RequireResolveHeaderDependency(
+			/** @type {Range} */ (expr.callee.range)
+		);
+		dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+		parser.state.module.addPresentationalDependency(dep);
+		return true;
+	};
+};
+
 class CommonJsImportsParserPlugin {
 	/**
 	 * @param {JavascriptParserOptions} options parser options
@@ -98,20 +384,6 @@ class CommonJsImportsParserPlugin {
 					evaluateToIdentifier(expression, "require", getMembers, true)
 				);
 		};
-		/**
-		 * @param {string | symbol} tag tag
-		 */
-		const tapRequireExpressionTag = (tag) => {
-			parser.hooks.typeof
-				.for(tag)
-				.tap(
-					PLUGIN_NAME,
-					toConstantDependency(parser, JSON.stringify("function"))
-				);
-			parser.hooks.evaluateTypeof
-				.for(tag)
-				.tap(PLUGIN_NAME, evaluateToString("function"));
-		};
 		tapRequireExpression("require", () => []);
 		tapRequireExpression("require.resolve", () => ["resolve"]);
 		tapRequireExpression("require.resolveWeak", () => ["resolveWeak"]);
@@ -176,15 +448,7 @@ class CommonJsImportsParserPlugin {
 		// #endregion
 
 		// #region Inspection
-		const requireCache = toConstantDependency(
-			parser,
-			RuntimeGlobals.moduleCache,
-			[
-				RuntimeGlobals.moduleCache,
-				RuntimeGlobals.moduleId,
-				RuntimeGlobals.moduleLoaded
-			]
-		);
+		const requireCache = createRequireCacheDependency(parser);
 
 		parser.hooks.expression.for("require.cache").tap(PLUGIN_NAME, requireCache);
 		// #endregion
@@ -194,163 +458,26 @@ class CommonJsImportsParserPlugin {
 		 * @param {Expression} expr expression
 		 * @returns {boolean} true when handled
 		 */
-		const requireAsExpressionHandler = (expr) => {
-			const dep = new CommonJsRequireContextDependency(
-				{
-					request: /** @type {string} */ (options.unknownContextRequest),
-					recursive: /** @type {boolean} */ (options.unknownContextRecursive),
-					regExp: /** @type {RegExp} */ (options.unknownContextRegExp),
-					mode: "sync"
-				},
-				/** @type {Range} */ (expr.range),
-				undefined,
-				parser.scope.inShorthand,
-				getContext()
-			);
-			dep.critical =
-				options.unknownContextCritical &&
-				"require function is used in a way in which dependencies cannot be statically extracted";
-			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-			dep.optional = Boolean(parser.scope.inTry);
-			parser.state.current.addDependency(dep);
-			return true;
-		};
+		const requireAsExpressionHandler = createRequireAsExpressionHandler(
+			parser,
+			options,
+			getContext
+		);
 		parser.hooks.expression
 			.for("require")
 			.tap(PLUGIN_NAME, requireAsExpressionHandler);
 		// #endregion
 
 		// #region Require
-		/**
-		 * @param {CallExpression | NewExpression} expr expression
-		 * @param {BasicEvaluatedExpression} param param
-		 * @returns {boolean | void} true when handled
-		 */
-		const processRequireItem = (expr, param) => {
-			if (param.isString()) {
-				const dep = new CommonJsRequireDependency(
-					/** @type {string} */ (param.string),
-					/** @type {Range} */ (param.range),
-					getContext()
-				);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-				dep.optional = Boolean(parser.scope.inTry);
-				parser.state.current.addDependency(dep);
-				return true;
-			}
-		};
-		/**
-		 * @param {CallExpression | NewExpression} expr expression
-		 * @param {BasicEvaluatedExpression} param param
-		 * @returns {boolean | void} true when handled
-		 */
-		const processRequireContext = (expr, param) => {
-			const dep = ContextDependencyHelpers.create(
-				CommonJsRequireContextDependency,
-				/** @type {Range} */ (expr.range),
-				param,
-				expr,
-				options,
-				{
-					category: "commonjs"
-				},
-				parser,
-				undefined,
-				getContext()
-			);
-			if (!dep) return;
-			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-			dep.optional = Boolean(parser.scope.inTry);
-			parser.state.current.addDependency(dep);
-			return true;
-		};
 		/**
 		 * @param {boolean} callNew true, when require is called with new
 		 * @returns {(expr: CallExpression | NewExpression) => (boolean | void)} handler
 		 */
-		const createRequireHandler = (callNew) => (expr) => {
-			if (options.commonjsMagicComments) {
-				const { options: requireOptions, errors: commentErrors } =
-					parser.parseCommentOptions(/** @type {Range} */ (expr.range));
-
-				if (commentErrors) {
-					for (const e of commentErrors) {
-						const { comment } = e;
-						parser.state.module.addWarning(
-							new CommentCompilationWarning(
-								`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
-								/** @type {DependencyLocation} */ (comment.loc)
-							)
-						);
-					}
-				}
-				if (requireOptions && requireOptions.webpackIgnore !== undefined) {
-					if (typeof requireOptions.webpackIgnore !== "boolean") {
-						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
-								`\`webpackIgnore\` expected a boolean, but received: ${requireOptions.webpackIgnore}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
-							)
-						);
-					} else if (requireOptions.webpackIgnore) {
-						// Do not instrument `require()` if `webpackIgnore` is `true`
-						return true;
-					}
-				}
-			}
-
-			if (expr.arguments.length !== 1) return;
-			/** @type {null | LocalModule} */
-			let localModule;
-			const param = parser.evaluateExpression(expr.arguments[0]);
-			if (param.isConditional()) {
-				let isExpression = false;
-				for (const p of /** @type {BasicEvaluatedExpression[]} */ (
-					param.options
-				)) {
-					const result = processRequireItem(expr, p);
-					if (result === undefined) {
-						isExpression = true;
-					}
-				}
-				if (!isExpression) {
-					const dep = new RequireHeaderDependency(
-						/** @type {Range} */ (expr.callee.range)
-					);
-					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-					parser.state.module.addPresentationalDependency(dep);
-					return true;
-				}
-			}
-			if (
-				param.isString() &&
-				(localModule = getLocalModule(
-					parser.state,
-					/** @type {string} */ (param.string)
-				))
-			) {
-				localModule.flagUsed();
-				const dep = new LocalModuleDependency(
-					localModule,
-					/** @type {Range} */ (expr.range),
-					callNew
-				);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-				parser.state.module.addPresentationalDependency(dep);
-			} else {
-				const result = processRequireItem(expr, param);
-				if (result === undefined) {
-					processRequireContext(expr, param);
-				} else {
-					const dep = new RequireHeaderDependency(
-						/** @type {Range} */ (expr.callee.range)
-					);
-					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-					parser.state.module.addPresentationalDependency(dep);
-				}
-			}
-			return true;
-		};
+		const createRequireHandler = createRequireCallHandler(
+			parser,
+			options,
+			getContext
+		);
 		parser.hooks.call
 			.for("require")
 			.tap(PLUGIN_NAME, createRequireHandler(false));
@@ -460,112 +587,11 @@ class CommonJsImportsParserPlugin {
 		 * @param {boolean} weak weak
 		 * @returns {boolean | void} true when handled
 		 */
-		const processResolve = (expr, weak) => {
-			if (!weak && options.commonjsMagicComments) {
-				const { options: requireOptions, errors: commentErrors } =
-					parser.parseCommentOptions(/** @type {Range} */ (expr.range));
-
-				if (commentErrors) {
-					for (const e of commentErrors) {
-						const { comment } = e;
-						parser.state.module.addWarning(
-							new CommentCompilationWarning(
-								`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
-								/** @type {DependencyLocation} */ (comment.loc)
-							)
-						);
-					}
-				}
-				if (requireOptions && requireOptions.webpackIgnore !== undefined) {
-					if (typeof requireOptions.webpackIgnore !== "boolean") {
-						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
-								`\`webpackIgnore\` expected a boolean, but received: ${requireOptions.webpackIgnore}.`,
-								/** @type {DependencyLocation} */ (expr.loc)
-							)
-						);
-					} else if (requireOptions.webpackIgnore) {
-						// Do not instrument `require()` if `webpackIgnore` is `true`
-						return true;
-					}
-				}
-			}
-
-			if (expr.arguments.length !== 1) return;
-			const param = parser.evaluateExpression(expr.arguments[0]);
-			if (param.isConditional()) {
-				for (const option of /** @type {BasicEvaluatedExpression[]} */ (
-					param.options
-				)) {
-					const result = processResolveItem(expr, option, weak);
-					if (result === undefined) {
-						processResolveContext(expr, option, weak);
-					}
-				}
-				const dep = new RequireResolveHeaderDependency(
-					/** @type {Range} */ (expr.callee.range)
-				);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-				parser.state.module.addPresentationalDependency(dep);
-				return true;
-			}
-			const result = processResolveItem(expr, param, weak);
-			if (result === undefined) {
-				processResolveContext(expr, param, weak);
-			}
-			const dep = new RequireResolveHeaderDependency(
-				/** @type {Range} */ (expr.callee.range)
-			);
-			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-			parser.state.module.addPresentationalDependency(dep);
-			return true;
-		};
-		/**
-		 * @param {CallExpression} expr call expression
-		 * @param {BasicEvaluatedExpression} param param
-		 * @param {boolean} weak weak
-		 * @returns {boolean | void} true when handled
-		 */
-		const processResolveItem = (expr, param, weak) => {
-			if (param.isString()) {
-				const dep = new RequireResolveDependency(
-					/** @type {string} */ (param.string),
-					/** @type {Range} */ (param.range),
-					getContext()
-				);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-				dep.optional = Boolean(parser.scope.inTry);
-				dep.weak = weak;
-				parser.state.current.addDependency(dep);
-				return true;
-			}
-		};
-		/**
-		 * @param {CallExpression} expr call expression
-		 * @param {BasicEvaluatedExpression} param param
-		 * @param {boolean} weak weak
-		 * @returns {boolean | void} true when handled
-		 */
-		const processResolveContext = (expr, param, weak) => {
-			const dep = ContextDependencyHelpers.create(
-				RequireResolveContextDependency,
-				/** @type {Range} */ (param.range),
-				param,
-				expr,
-				options,
-				{
-					category: "commonjs",
-					mode: weak ? "weak" : "sync"
-				},
-				parser,
-				getContext()
-			);
-			if (!dep) return;
-			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-			dep.optional = Boolean(parser.scope.inTry);
-			parser.state.current.addDependency(dep);
-			return true;
-		};
+		const processResolve = createProcessResolveHandler(
+			parser,
+			options,
+			getContext
+		);
 
 		parser.hooks.call
 			.for("require.resolve")
@@ -574,232 +600,12 @@ class CommonJsImportsParserPlugin {
 			.for("require.resolveWeak")
 			.tap(PLUGIN_NAME, (expr) => processResolve(expr, true));
 		// #endregion
-
-		// #region Create require
-
-		if (!options.createRequire) return;
-
-		/** @type {ImportSource[]} */
-		let moduleName = [];
-		/** @type {string | undefined} */
-		let specifierName;
-
-		if (options.createRequire === true) {
-			moduleName = ["module", "node:module"];
-			specifierName = "createRequire";
-		} else {
-			/** @type {undefined | string} */
-			let moduleName;
-			const match = /^(.*) from (.*)$/.exec(options.createRequire);
-			if (match) {
-				[, specifierName, moduleName] = match;
-			}
-			if (!specifierName || !moduleName) {
-				const err = new WebpackError(
-					`Parsing javascript parser option "createRequire" failed, got ${JSON.stringify(
-						options.createRequire
-					)}`
-				);
-				err.details =
-					'Expected string in format "createRequire from module", where "createRequire" is specifier name and "module" name of the module';
-				throw err;
-			}
-		}
-
-		tapRequireExpressionTag(createdRequireIdentifierTag);
-		tapRequireExpressionTag(createRequireSpecifierTag);
-		parser.hooks.evaluateCallExpression
-			.for(createRequireSpecifierTag)
-			.tap(PLUGIN_NAME, (expr) => {
-				const context = parseCreateRequireArguments(expr);
-				if (context === undefined) return;
-				const ident = parser.evaluatedVariable({
-					tag: createdRequireIdentifierTag,
-					data: { context },
-					next: undefined
-				});
-
-				return new BasicEvaluatedExpression()
-					.setIdentifier(ident, ident, () => [])
-					.setSideEffects(false)
-					.setRange(/** @type {Range} */ (expr.range));
-			});
-		parser.hooks.unhandledExpressionMemberChain
-			.for(createdRequireIdentifierTag)
-			.tap(PLUGIN_NAME, (expr, members) =>
-				expressionIsUnsupported(
-					parser,
-					`createRequire().${members.join(".")} is not supported by webpack.`
-				)(expr)
-			);
-		parser.hooks.canRename
-			.for(createdRequireIdentifierTag)
-			.tap(PLUGIN_NAME, () => true);
-		parser.hooks.canRename
-			.for(createRequireSpecifierTag)
-			.tap(PLUGIN_NAME, () => true);
-		parser.hooks.rename
-			.for(createRequireSpecifierTag)
-			.tap(PLUGIN_NAME, defineUndefined);
-		parser.hooks.expression
-			.for(createdRequireIdentifierTag)
-			.tap(PLUGIN_NAME, requireAsExpressionHandler);
-		parser.hooks.call
-			.for(createdRequireIdentifierTag)
-			.tap(PLUGIN_NAME, createRequireHandler(false));
-		/**
-		 * @param {CallExpression} expr call expression
-		 * @returns {string | void} context
-		 */
-		const parseCreateRequireArguments = (expr) => {
-			const args = expr.arguments;
-			if (args.length !== 1) {
-				const err = new WebpackError(
-					"module.createRequire supports only one argument."
-				);
-				err.loc = /** @type {DependencyLocation} */ (expr.loc);
-				parser.state.module.addWarning(err);
-				return;
-			}
-			const arg = args[0];
-			const evaluated = parser.evaluateExpression(arg);
-			if (!evaluated.isString()) {
-				const err = new WebpackError(
-					"module.createRequire failed parsing argument."
-				);
-				err.loc = /** @type {DependencyLocation} */ (arg.loc);
-				parser.state.module.addWarning(err);
-				return;
-			}
-			const ctx = /** @type {string} */ (evaluated.string).startsWith("file://")
-				? fileURLToPath(/** @type {string} */ (evaluated.string))
-				: /** @type {string} */ (evaluated.string);
-			// argument always should be a filename
-			return ctx.slice(0, ctx.lastIndexOf(ctx.startsWith("/") ? "/" : "\\"));
-		};
-
-		parser.hooks.import.tap(
-			{
-				name: PLUGIN_NAME,
-				stage: -10
-			},
-			(statement, source) => {
-				if (
-					!moduleName.includes(source) ||
-					statement.specifiers.length !== 1 ||
-					statement.specifiers[0].type !== "ImportSpecifier" ||
-					statement.specifiers[0].imported.type !== "Identifier" ||
-					statement.specifiers[0].imported.name !== specifierName
-				) {
-					return;
-				}
-				// clear for 'import { createRequire as x } from "module"'
-				// if any other specifier was used import module
-				const clearDep = new ConstDependency(
-					parser.isAsiPosition(/** @type {Range} */ (statement.range)[0])
-						? ";"
-						: "",
-					/** @type {Range} */ (statement.range)
-				);
-				clearDep.loc = /** @type {DependencyLocation} */ (statement.loc);
-				parser.state.module.addPresentationalDependency(clearDep);
-				parser.unsetAsiPosition(/** @type {Range} */ (statement.range)[1]);
-				return true;
-			}
-		);
-		parser.hooks.importSpecifier.tap(
-			{
-				name: PLUGIN_NAME,
-				stage: -10
-			},
-			(statement, source, id, name) => {
-				if (!moduleName.includes(source) || id !== specifierName) return;
-				parser.tagVariable(name, createRequireSpecifierTag);
-				return true;
-			}
-		);
-		parser.hooks.preDeclarator.tap(PLUGIN_NAME, (declarator) => {
-			if (
-				declarator.id.type !== "Identifier" ||
-				!declarator.init ||
-				declarator.init.type !== "CallExpression" ||
-				declarator.init.callee.type !== "Identifier"
-			) {
-				return;
-			}
-			const variableInfo = parser.getVariableInfo(declarator.init.callee.name);
-			if (
-				variableInfo instanceof VariableInfo &&
-				variableInfo.tagInfo &&
-				variableInfo.tagInfo.tag === createRequireSpecifierTag
-			) {
-				const context = parseCreateRequireArguments(declarator.init);
-				if (context === undefined) return;
-				parser.tagVariable(declarator.id.name, createdRequireIdentifierTag, {
-					name: declarator.id.name,
-					context
-				});
-				return true;
-			}
-		});
-
-		parser.hooks.memberChainOfCallMemberChain
-			.for(createRequireSpecifierTag)
-			.tap(PLUGIN_NAME, (expr, calleeMembers, callExpr, members) => {
-				if (
-					calleeMembers.length !== 0 ||
-					members.length !== 1 ||
-					members[0] !== "cache"
-				) {
-					return;
-				}
-				// createRequire().cache
-				const context = parseCreateRequireArguments(callExpr);
-				if (context === undefined) return;
-				return requireCache(expr);
-			});
-		parser.hooks.callMemberChainOfCallMemberChain
-			.for(createRequireSpecifierTag)
-			.tap(PLUGIN_NAME, (expr, calleeMembers, innerCallExpression, members) => {
-				if (
-					calleeMembers.length !== 0 ||
-					members.length !== 1 ||
-					members[0] !== "resolve"
-				) {
-					return;
-				}
-				// createRequire().resolve()
-				return processResolve(expr, false);
-			});
-		parser.hooks.expressionMemberChain
-			.for(createdRequireIdentifierTag)
-			.tap(PLUGIN_NAME, (expr, members) => {
-				// require.cache
-				if (members.length === 1 && members[0] === "cache") {
-					return requireCache(expr);
-				}
-			});
-		parser.hooks.callMemberChain
-			.for(createdRequireIdentifierTag)
-			.tap(PLUGIN_NAME, (expr, members) => {
-				// require.resolve()
-				if (members.length === 1 && members[0] === "resolve") {
-					return processResolve(expr, false);
-				}
-			});
-		parser.hooks.call
-			.for(createRequireSpecifierTag)
-			.tap(PLUGIN_NAME, (expr) => {
-				const clearDep = new ConstDependency(
-					"/* createRequire() */ undefined",
-					/** @type {Range} */ (expr.range)
-				);
-				clearDep.loc = /** @type {DependencyLocation} */ (expr.loc);
-				parser.state.module.addPresentationalDependency(clearDep);
-				return true;
-			});
-		// #endregion
 	}
 }
 
 module.exports = CommonJsImportsParserPlugin;
+module.exports.createProcessResolveHandler = createProcessResolveHandler;
+module.exports.createRequireAsExpressionHandler =
+	createRequireAsExpressionHandler;
+module.exports.createRequireCacheDependency = createRequireCacheDependency;
+module.exports.createRequireHandler = createRequireCallHandler;