webpack 5.102.1 → 5.104.0

package/lib/javascript/JavascriptModulesPlugin.js

@@ -20,6 +20,7 @@ const Compilation = require("../Compilation");
 const { tryRunOrWebpackError } = require("../HookWebpackError");
 const HotUpdateChunk = require("../HotUpdateChunk");
 const InitFragment = require("../InitFragment");
+const { JAVASCRIPT_TYPE } = require("../ModuleSourceTypeConstants");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
@@ -79,7 +80,7 @@ const chunkHasJs = (chunk, chunkGraph) => {
 	if (chunkGraph.getNumberOfEntryModules(chunk) > 0) return true;
 
 	return Boolean(
-		chunkGraph.getChunkModulesIterableBySourceType(chunk, "javascript")
+		chunkGraph.getChunkModulesIterableBySourceType(chunk, JAVASCRIPT_TYPE)
 	);
 };
 
@@ -99,7 +100,7 @@ const chunkHasRuntimeOrJs = (chunk, chunkGraph) => {
 	}
 
 	return Boolean(
-		chunkGraph.getChunkModulesIterableBySourceType(chunk, "javascript")
+		chunkGraph.getChunkModulesIterableBySourceType(chunk, JAVASCRIPT_TYPE)
 	);
 };
 
@@ -181,7 +182,7 @@ const printGeneratedCodeForStack = (module, code) => {
  * @property {ChunkGraph} chunkGraph the chunk graph
  * @property {CodeGenerationResults} codeGenerationResults results of code generation
  * @property {boolean | undefined} strictMode rendering in strict context
- * @property {boolean } inlined inlined
+ * @property {boolean} inlined inlined
  * @property {boolean=} inlinedInIIFE the inlined entry module is wrapped in an IIFE
  */
 
@@ -197,6 +198,7 @@ const printGeneratedCodeForStack = (module, code) => {
  * @property {boolean | undefined} strictMode rendering in strict context
  * @property {boolean} factory true: renders as factory method, false: pure module content
  * @property {boolean=} inlinedInIIFE the inlined entry module is wrapped in an IIFE, existing only when `factory` is set to false
+ * @property {boolean=} renderInObject render module in object container
  */
 
 /**
@@ -276,7 +278,7 @@ class JavascriptModulesPlugin {
 
 	constructor(options = {}) {
 		this.options = options;
-		/** @type {WeakMap<Source, { source: Source, needModule:boolean, needExports: boolean, needRequire: boolean, needThisAsExports: boolean, needStrict: boolean | undefined }>} */
+		/** @type {WeakMap<Source, { source: Source, needModule:boolean, needExports: boolean, needRequire: boolean, needThisAsExports: boolean, needStrict: boolean | undefined, renderShorthand: boolean }>} */
 		this._moduleFactoryCache = new WeakMap();
 	}
 
@@ -298,16 +300,20 @@ class JavascriptModulesPlugin {
 				]) {
 					normalModuleFactory.hooks.createParser
 						.for(type)
-						.tap(PLUGIN_NAME, (_options) => {
+						.tap(PLUGIN_NAME, (options) => {
 							switch (type) {
 								case JAVASCRIPT_MODULE_TYPE_AUTO: {
-									return new JavascriptParser("auto");
+									return new JavascriptParser("auto", { parse: options.parse });
 								}
 								case JAVASCRIPT_MODULE_TYPE_DYNAMIC: {
-									return new JavascriptParser("script");
+									return new JavascriptParser("script", {
+										parse: options.parse
+									});
 								}
 								case JAVASCRIPT_MODULE_TYPE_ESM: {
-									return new JavascriptParser("module");
+									return new JavascriptParser("module", {
+										parse: options.parse
+									});
 								}
 							}
 						});
@@ -483,7 +489,7 @@ class JavascriptModulesPlugin {
 					});
 					const modules = chunkGraph.getChunkModulesIterableBySourceType(
 						chunk,
-						"javascript"
+						JAVASCRIPT_TYPE
 					);
 					if (modules) {
 						const xor = new StringXor();
@@ -523,7 +529,8 @@ class JavascriptModulesPlugin {
 					}
 				);
 				compilation.hooks.executeModule.tap(PLUGIN_NAME, (options, context) => {
-					const source = options.codeGenerationResult.sources.get("javascript");
+					const source =
+						options.codeGenerationResult.sources.get(JAVASCRIPT_TYPE);
 					if (source === undefined) return;
 					const { module } = options;
 					const code = source.source();
@@ -611,11 +618,12 @@ class JavascriptModulesPlugin {
 			runtimeTemplate,
 			codeGenerationResults,
 			strictMode,
-			factory
+			factory,
+			renderInObject
 		} = renderContext;
 		try {
 			const codeGenResult = codeGenerationResults.get(module, chunk.runtime);
-			const moduleSource = codeGenResult.sources.get("javascript");
+			const moduleSource = codeGenResult.sources.get(JAVASCRIPT_TYPE);
 			if (!moduleSource) return null;
 			if (codeGenResult.data !== undefined) {
 				const chunkInitFragments = codeGenResult.data.get("chunkInitFragments");
@@ -650,6 +658,8 @@ class JavascriptModulesPlugin {
 				const cacheEntry = this._moduleFactoryCache.get(
 					moduleSourcePostContent
 				);
+				const renderShorthand =
+					renderInObject === true && runtimeTemplate.supportsMethodShorthand();
 				let source;
 				if (
 					cacheEntry &&
@@ -657,7 +667,8 @@ class JavascriptModulesPlugin {
 					cacheEntry.needExports === needExports &&
 					cacheEntry.needRequire === needRequire &&
 					cacheEntry.needThisAsExports === needThisAsExports &&
-					cacheEntry.needStrict === needStrict
+					cacheEntry.needStrict === needStrict &&
+					cacheEntry.renderShorthand === renderShorthand
 				) {
 					source = cacheEntry.source;
 				} else {
@@ -678,16 +689,24 @@ class JavascriptModulesPlugin {
 						);
 					}
 					if (needRequire) args.push(RuntimeGlobals.require);
-					if (!needThisAsExports && runtimeTemplate.supportsArrowFunction()) {
+
+					if (renderShorthand) {
+						// we can optimize function to methodShorthand if render module factory in object
+						factorySource.add(`(${args.join(", ")}) {\n\n`);
+					} else if (
+						!needThisAsExports &&
+						runtimeTemplate.supportsArrowFunction()
+					) {
 						factorySource.add(`/***/ ((${args.join(", ")}) => {\n\n`);
 					} else {
 						factorySource.add(`/***/ (function(${args.join(", ")}) {\n\n`);
 					}
+
 					if (needStrict) {
 						factorySource.add('"use strict";\n');
 					}
 					factorySource.add(moduleSourcePostContent);
-					factorySource.add("\n\n/***/ })");
+					factorySource.add(`\n\n/***/ }${renderShorthand ? "" : ")"}`);
 					source = new CachedSource(factorySource);
 					this._moduleFactoryCache.set(moduleSourcePostContent, {
 						source,
@@ -695,7 +714,8 @@ class JavascriptModulesPlugin {
 						needExports,
 						needRequire,
 						needThisAsExports,
-						needStrict
+						needStrict,
+						renderShorthand
 					});
 				}
 				moduleSourcePostContainer = tryRunOrWebpackError(
@@ -730,7 +750,7 @@ class JavascriptModulesPlugin {
 		const { chunk, chunkGraph } = renderContext;
 		const modules = chunkGraph.getOrderedChunkModulesIterableBySourceType(
 			chunk,
-			"javascript",
+			JAVASCRIPT_TYPE,
 			compareModulesByIdOrIdentifier(chunkGraph)
 		);
 		const allModules = modules ? [...modules] : [];
@@ -753,12 +773,15 @@ class JavascriptModulesPlugin {
 			strictMode: allStrict
 		};
 		const moduleSources =
-			Template.renderChunkModules(chunkRenderContext, allModules, (module) =>
-				this.renderModule(
-					module,
-					{ ...chunkRenderContext, factory: true },
-					hooks
-				)
+			Template.renderChunkModules(
+				chunkRenderContext,
+				allModules,
+				(module, renderInObject) =>
+					this.renderModule(
+						module,
+						{ ...chunkRenderContext, factory: true, renderInObject },
+						hooks
+					)
 			) || new RawSource("{}");
 		let source = tryRunOrWebpackError(
 			() => hooks.renderChunk.call(moduleSources, chunkRenderContext),
@@ -814,7 +837,7 @@ class JavascriptModulesPlugin {
 		const allModules = [
 			...(chunkGraph.getOrderedChunkModulesIterableBySourceType(
 				chunk,
-				"javascript",
+				JAVASCRIPT_TYPE,
 				compareModulesByIdOrIdentifier(chunkGraph)
 			) || [])
 		];
@@ -870,10 +893,10 @@ class JavascriptModulesPlugin {
 						(m) => !(/** @type {Set<Module>} */ (inlinedModules).has(m))
 					)
 				: allModules,
-			(module) =>
+			(module, renderInObject) =>
 				this.renderModule(
 					module,
-					{ ...chunkRenderContext, factory: true },
+					{ ...chunkRenderContext, factory: true, renderInObject },
 					hooks
 				),
 			prefix
@@ -950,7 +973,8 @@ class JavascriptModulesPlugin {
 			let inlinedInIIFE = false;
 
 			if (avoidEntryIife) {
-				renamedInlinedModule = this.getRenamedInlineModule(
+				renamedInlinedModule = this._getRenamedInlineModule(
+					compilation,
 					allModules,
 					renderContext,
 					inlinedModules,
@@ -1275,7 +1299,9 @@ class JavascriptModulesPlugin {
 					entryModule,
 					entrypoint
 				] of chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)) {
-					if (!chunkGraph.getModuleSourceTypes(entryModule).has("javascript")) {
+					if (
+						!chunkGraph.getModuleSourceTypes(entryModule).has(JAVASCRIPT_TYPE)
+					) {
 						i--;
 						continue;
 					}
@@ -1535,6 +1561,19 @@ class JavascriptModulesPlugin {
 					])
 				: Template.indent("return cachedModule.exports;"),
 			"}",
+			// Add helpful error message in development mode when module is not found
+			...(outputOptions.pathinfo
+				? [
+						"// Check if module exists (development only)",
+						"if (__webpack_modules__[moduleId] === undefined) {",
+						Template.indent([
+							'var e = new Error("Cannot find module \'" + moduleId + "\'");',
+							"e.code = 'MODULE_NOT_FOUND';",
+							"throw e;"
+						]),
+						"}"
+					]
+				: []),
 			"// Create a new module (and put it into the cache)",
 			"var module = __webpack_module_cache__[moduleId] = {",
 			Template.indent([
@@ -1584,10 +1623,7 @@ class JavascriptModulesPlugin {
 							"// Execute the module function",
 							moduleExecution,
 							...(needModuleDefer
-								? [
-										"// delete __webpack_module_deferred_exports__[module];",
-										"// skipped because strictModuleErrorHandling is not enabled."
-									]
+								? ["delete __webpack_module_deferred_exports__[moduleId];"]
 								: [])
 						]),
 			needModuleLoaded
@@ -1608,6 +1644,7 @@ class JavascriptModulesPlugin {
 	}
 
 	/**
+	 * @param {Compilation} compilation compilation
 	 * @param {Module[]} allModules allModules
 	 * @param {MainRenderContext} renderContext renderContext
 	 * @param {Set<Module>} inlinedModules inlinedModules
@@ -1617,7 +1654,8 @@ class JavascriptModulesPlugin {
 	 * @param {boolean} hasChunkModules hasChunkModules
 	 * @returns {Map<Module, Source> | false} renamed inlined modules
 	 */
-	getRenamedInlineModule(
+	_getRenamedInlineModule(
+		compilation,
 		allModules,
 		renderContext,
 		inlinedModules,
@@ -1648,7 +1686,6 @@ class JavascriptModulesPlugin {
 		const inlinedModulesToInfo = new Map();
 		/** @type {Set<string>} */
 		const nonInlinedModuleThroughIdentifiers = new Set();
-		/** @type {Map<Module, Source>} */
 
 		for (const m of allModules) {
 			const isInlinedModule = inlinedModules && inlinedModules.has(m);
@@ -1664,9 +1701,15 @@ class JavascriptModulesPlugin {
 
 			if (!moduleSource) continue;
 			const code = /** @type {string} */ (moduleSource.source());
-			const ast = JavascriptParser._parse(code, {
-				sourceType: "auto"
-			});
+
+			const { ast } = JavascriptParser._parse(
+				code,
+				{
+					sourceType: "auto",
+					ranges: true
+				},
+				JavascriptParser._getModuleParseFunction(compilation, m)
+			);
 
 			const scopeManager = eslintScope.analyze(ast, {
 				ecmaVersion: 6,

package/lib/javascript/JavascriptParser.js

@@ -8,6 +8,7 @@
 const vm = require("vm");
 const { Parser: AcornParser, tokTypes } = require("acorn");
 const { HookMap, SyncBailHook } = require("tapable");
+const NormalModule = require("../NormalModule");
 const Parser = require("../Parser");
 const StackedMap = require("../util/StackedMap");
 const binarySearchBounds = require("../util/binarySearchBounds");
@@ -19,6 +20,7 @@ const memoize = require("../util/memoize");
 const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 
 /** @typedef {import("acorn").Options} AcornOptions */
+/** @typedef {import("acorn").ecmaVersion} EcmaVersion */
 /** @typedef {import("estree").AssignmentExpression} AssignmentExpression */
 /** @typedef {import("estree").BinaryExpression} BinaryExpression */
 /** @typedef {import("estree").BlockStatement} BlockStatement */
@@ -29,7 +31,8 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("estree").ForStatement} ForStatement */
 /** @typedef {import("estree").SwitchStatement} SwitchStatement */
 /** @typedef {import("estree").ClassExpression} ClassExpression */
-/** @typedef {import("estree").Comment} Comment */
+/** @typedef {import("estree").SourceLocation} SourceLocation */
+/** @typedef {import("estree").Comment & { start: number, end: number, loc: SourceLocation }} Comment */
 /** @typedef {import("estree").ConditionalExpression} ConditionalExpression */
 /** @typedef {import("estree").Declaration} Declaration */
 /** @typedef {import("estree").PrivateIdentifier} PrivateIdentifier */
@@ -97,6 +100,22 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 
+/** @typedef {import("../dependencies/LocalModule")} LocalModule */
+/** @typedef {import("../dependencies/HarmonyExportImportedSpecifierDependency").HarmonyStarExportsList} HarmonyStarExportsList */
+
+/**
+ * @typedef {object} KnownJavascriptParserState
+ * @property {Set<string>=} harmonyNamedExports
+ * @property {HarmonyStarExportsList=} harmonyStarExports
+ * @property {number=} lastHarmonyImportOrder
+ * @property {LocalModule[]=} localModules
+ */
+
+/** @typedef {ParserState & KnownJavascriptParserState} JavascriptParserState */
+
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module")} Module */
+
 /** @typedef {{ name: string | VariableInfo, rootInfo: string | VariableInfo, getMembers: () => Members, getMembersOptionals: () => MembersOptionals, getMemberRanges: () => MemberRanges }} GetInfoResult */
 /** @typedef {Statement | ModuleDeclaration | Expression | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration} StatementPathItem */
 /** @typedef {(ident: string) => void} OnIdentString */
@@ -297,7 +316,33 @@ class VariableInfo {
 
 /** @typedef {string | ScopeInfo | VariableInfo} ExportedVariableInfo */
 /** @typedef {Literal | string | null | undefined} ImportSource */
-/** @typedef {Omit<AcornOptions, "sourceType" | "ecmaVersion"> & { sourceType: "module" | "script" | "auto", ecmaVersion?: AcornOptions["ecmaVersion"] }} ParseOptions */
+
+/**
+ * @typedef {Omit<ParseOptions, "sourceType"> & {sourceType: "module" | "script" | "auto"}} InternalParseOptions
+ */
+
+/**
+ * @typedef {object} ParseOptions
+ * @property {"module" | "script"} sourceType
+ * @property {EcmaVersion=} ecmaVersion
+ * @property {boolean=} locations
+ * @property {boolean=} comments
+ * @property {boolean=} ranges
+ * @property {boolean=} semicolons
+ * @property {boolean=} allowHashBang
+ * @property {boolean=} allowReturnOutsideFunction
+ */
+
+/**
+ * @typedef {object} ParseResult
+ * @property {Program} ast
+ * @property {Comment[]} comments
+ * @property {Set<number>} semicolons
+ */
+
+/**
+ * @typedef {(code: string, options: ParseOptions) => ParseResult} ParseFunction
+ */
 
 /** @typedef {symbol} Tag */
 
@@ -343,6 +388,7 @@ const SCOPE_INFO_TERMINATED_THROW = 2;
  * @typedef {object} DestructuringAssignmentProperty
  * @property {string} id
  * @property {Range} range
+ * @property {SourceLocation} loc
  * @property {Set<DestructuringAssignmentProperty> | undefined=} pattern
  * @property {boolean | string} shorthand
  */
@@ -412,15 +458,15 @@ const getRootName = (expression) => {
 	}
 };
 
-/** @type {AcornOptions} */
+/** @type {ParseOptions} */
 const defaultParserOptions = {
-	ranges: true,
-	locations: true,
-	ecmaVersion: "latest",
 	sourceType: "module",
+	ecmaVersion: "latest",
+	ranges: false,
+	locations: false,
+	comments: false,
 	// https://github.com/tc39/proposal-hashbang
-	allowHashBang: true,
-	onComment: undefined
+	allowHashBang: true
 };
 
 const EMPTY_COMMENT_OPTIONS = {
@@ -432,9 +478,10 @@ const CLASS_NAME = "JavascriptParser";
 
 class JavascriptParser extends Parser {
 	/**
-	 * @param {"module" | "script" | "auto"} sourceType default source type
+	 * @param {"module" | "script" | "auto"=} sourceType default source type
+	 * @param {{ parse?: ParseFunction }=} options parser options
 	 */
-	constructor(sourceType = "auto") {
+	constructor(sourceType = "auto", options = {}) {
 		super();
 		this.hooks = Object.freeze({
 			/** @type {HookMap<SyncBailHook<[UnaryExpression], BasicEvaluatedExpression | null | undefined>>} */
@@ -628,9 +675,11 @@ class JavascriptParser extends Parser {
 			unusedStatement: new SyncBailHook(["statement"])
 		});
 		this.sourceType = sourceType;
+		this.options = options;
+
 		/** @type {ScopeInfo} */
 		this.scope = /** @type {EXPECTED_ANY} */ (undefined);
-		/** @type {ParserState} */
+		/** @type {JavascriptParserState} */
 		this.state = /** @type {EXPECTED_ANY} */ (undefined);
 		/** @type {Comment[] | undefined} */
 		this.comments = undefined;
@@ -1862,7 +1911,7 @@ class JavascriptParser extends Parser {
 			const expr = /** @type {ChainExpression} */ (_expr);
 			/** @type {Expression[]} */
 			const optionalExpressionsStack = [];
-			/** @type {Expression|Super} */
+			/** @type {Expression | Super} */
 			let next = expr.expression;
 
 			while (
@@ -3003,6 +3052,7 @@ class JavascriptParser extends Parser {
 				props.add({
 					id: key.name,
 					range: /** @type {Range} */ (key.range),
+					loc: /** @type {SourceLocation} */ (key.loc),
 					pattern,
 					shorthand: this.scope.inShorthand
 				});
@@ -3019,6 +3069,7 @@ class JavascriptParser extends Parser {
 					props.add({
 						id: str,
 						range: /** @type {Range} */ (key.range),
+						loc: /** @type {SourceLocation} */ (key.loc),
 						pattern,
 						shorthand: this.scope.inShorthand
 					});
@@ -3054,6 +3105,7 @@ class JavascriptParser extends Parser {
 			props.add({
 				id: `${i}`,
 				range: /** @type {Range} */ (element.range),
+				loc: /** @type {SourceLocation} */ (element.loc),
 				pattern,
 				shorthand: false
 			});
@@ -4626,17 +4678,23 @@ class JavascriptParser extends Parser {
 	 * @returns {ParserState} the parser state
 	 */
 	parse(source, state) {
-		let ast;
-		/** @type {import("acorn").Comment[]} */
-		let comments;
-		const semicolons = new Set();
 		if (source === null) {
 			throw new Error("source must not be null");
 		}
+
 		if (Buffer.isBuffer(source)) {
 			source = source.toString("utf8");
 		}
+
+		let ast;
+		/** @type {Comment[]} */
+		let comments;
+		/** @type {Set<number>} */
+		let semicolons;
+
 		if (typeof source === "object") {
+			semicolons = new Set();
+
 			ast = /** @type {Program} */ (source);
 			comments = source.comments;
 			if (source.semicolons) {
@@ -4647,12 +4705,17 @@ class JavascriptParser extends Parser {
 				}
 			}
 		} else {
-			comments = [];
-			ast = JavascriptParser._parse(source, {
-				sourceType: this.sourceType,
-				onComment: comments,
-				onInsertedSemicolon: (pos) => semicolons.add(pos)
-			});
+			({ ast, comments, semicolons } = JavascriptParser._parse(
+				source,
+				{
+					sourceType: this.sourceType,
+					locations: true,
+					ranges: true,
+					comments: true,
+					semicolons: true
+				},
+				this.options.parse
+			));
 		}
 
 		const oldScope = this.scope;
@@ -4702,10 +4765,11 @@ class JavascriptParser extends Parser {
 	 * @returns {BasicEvaluatedExpression} evaluation result
 	 */
 	evaluate(source) {
-		const ast = JavascriptParser._parse(`(${source})`, {
-			sourceType: this.sourceType,
-			locations: false
-		});
+		const { ast } = JavascriptParser._parse(
+			`(${source})`,
+			{ sourceType: this.sourceType },
+			this.options.parse
+		);
 		if (ast.body.length !== 1 || ast.body[0].type !== "ExpressionStatement") {
 			throw new Error("evaluate: Source is not a expression");
 		}
@@ -5082,7 +5146,7 @@ class JavascriptParser extends Parser {
 		if (comments.length === 0) {
 			return EMPTY_COMMENT_OPTIONS;
 		}
-		/** @type {Record<string, EXPECTED_ANY> } */
+		/** @type {Record<string, EXPECTED_ANY>} */
 		const options = {};
 		/** @type {(Error & { comment: Comment })[]} */
 		const errors = [];
@@ -5184,8 +5248,8 @@ class JavascriptParser extends Parser {
 		return { info, name };
 	}
 
-	/** @typedef {{ type: "call", call: CallExpression, calleeName: string, rootInfo: string | VariableInfo, getCalleeMembers: () => CalleeMembers, name: string, getMembers: () => Members, getMembersOptionals: () => MembersOptionals, getMemberRanges: () => MemberRanges}} CallExpressionInfo */
-	/** @typedef {{ type: "expression", rootInfo: string | VariableInfo, name: string, getMembers: () => Members, getMembersOptionals: () => MembersOptionals, getMemberRanges: () => MemberRanges}} ExpressionExpressionInfo */
+	/** @typedef {{ type: "call", call: CallExpression, calleeName: string, rootInfo: string | VariableInfo, getCalleeMembers: () => CalleeMembers, name: string, getMembers: () => Members, getMembersOptionals: () => MembersOptionals, getMemberRanges: () => MemberRanges }} CallExpressionInfo */
+	/** @typedef {{ type: "expression", rootInfo: string | VariableInfo, name: string, getMembers: () => Members, getMembersOptionals: () => MembersOptionals, getMemberRanges: () => MemberRanges }} ExpressionExpressionInfo */
 
 	/**
 	 * @param {Expression | Super} expression a member expression
@@ -5246,7 +5310,7 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {Expression} expression an expression
-	 * @returns {{ name: string, rootInfo: ExportedVariableInfo, getMembers: () => Members} | undefined} name info
+	 * @returns {{ name: string, rootInfo: ExportedVariableInfo, getMembers: () => Members } | undefined} name info
 	 */
 	getNameForExpression(expression) {
 		return this.getMemberExpressionInfo(
@@ -5255,27 +5319,84 @@ class JavascriptParser extends Parser {
 		);
 	}
 
+	/**
+	 * @param {Compilation} compilation compilation
+	 * @param {Module} module module
+	 * @returns {ParseFunction | undefined} parser
+	 */
+	static _getModuleParseFunction(compilation, module) {
+		// Get from module if available
+		if (
+			module instanceof NormalModule &&
+			module.parser instanceof JavascriptParser
+		) {
+			return module.parser.options.parse;
+		}
+
+		// Fallback to the global javascript parse function
+		if (typeof compilation.options.module.parser.javascript !== "undefined") {
+			return compilation.options.module.parser.javascript.parse;
+		}
+	}
+
 	/**
 	 * @param {string} code source code
-	 * @param {ParseOptions} options parsing options
-	 * @returns {Program} parsed ast
+	 * @param {InternalParseOptions} options parsing options
+	 * @param {ParseFunction=} customParse custom function to parse
+	 * @returns {ParseResult} parse result
 	 */
-	static _parse(code, options) {
+	static _parse(code, options, customParse) {
 		const type = options ? options.sourceType : "module";
-		/** @type {AcornOptions} */
+		/** @type {ParseOptions} */
 		const parserOptions = {
 			...defaultParserOptions,
 			allowReturnOutsideFunction: type === "script",
 			...options,
 			sourceType: type === "auto" ? "module" : type
 		};
+		/**
+		 * @param {string} code source code
+		 * @param {ParseOptions} options parsing options
+		 * @returns {ParseResult} parse result
+		 */
+		const internalParse = (code, options) => {
+			if (typeof customParse === "function") {
+				return customParse(code, options);
+			}
+
+			/** @type {Comment[]} */
+			const comments = [];
+
+			if (options.comments) {
+				/** @type {AcornOptions} */
+				(options).onComment = comments;
+			}
+
+			/** @type {Set<number>} */
+			const semicolons = new Set();
+
+			if (options.semicolons) {
+				/** @type {AcornOptions} */
+				(options).onInsertedSemicolon = (pos) => semicolons.add(pos);
+			}
+
+			const ast =
+				/** @type {Program} */
+				(parser.parse(code, /** @type {AcornOptions} */ (options)));
+
+			return { ast, comments, semicolons };
+		};
 
-		/** @type {import("acorn").Program | undefined} */
+		/** @type {Program | undefined} */
 		let ast;
+		/** @type {Comment[] | undefined} */
+		let comments;
+		/** @type {Set<number> | undefined} */
+		let semicolons;
 		let error;
 		let threw = false;
 		try {
-			ast = parser.parse(code, parserOptions);
+			({ ast, comments, semicolons } = internalParse(code, parserOptions));
 		} catch (err) {
 			error = err;
 			threw = true;
@@ -5283,14 +5404,10 @@ class JavascriptParser extends Parser {
 
 		if (threw && type === "auto") {
 			parserOptions.sourceType = "script";
-			if (!("allowReturnOutsideFunction" in options)) {
-				parserOptions.allowReturnOutsideFunction = true;
-			}
-			if (Array.isArray(parserOptions.onComment)) {
-				parserOptions.onComment.length = 0;
-			}
+			parserOptions.allowReturnOutsideFunction = true;
+
 			try {
-				ast = parser.parse(code, parserOptions);
+				({ ast, comments, semicolons } = internalParse(code, parserOptions));
 				threw = false;
 			} catch (_err) {
 				// we use the error from first parse try
@@ -5302,7 +5419,7 @@ class JavascriptParser extends Parser {
 			throw error;
 		}
 
-		return /** @type {Program} */ (ast);
+		return /** @type {ParseResult} */ ({ ast, comments, semicolons });
 	}
 
 	/**