webpack 5.59.0 → 5.94.0

package/lib/javascript/JavascriptModulesPlugin.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const eslintScope = require("eslint-scope");
 const { SyncWaterfallHook, SyncHook, SyncBailHook } = require("tapable");
 const vm = require("vm");
 const {
@@ -12,32 +13,48 @@ const {
 	OriginalSource,
 	PrefixSource,
 	RawSource,
-	CachedSource
+	CachedSource,
+	ReplaceSource
 } = require("webpack-sources");
 const Compilation = require("../Compilation");
 const { tryRunOrWebpackError } = require("../HookWebpackError");
 const HotUpdateChunk = require("../HotUpdateChunk");
 const InitFragment = require("../InitFragment");
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM,
+	WEBPACK_MODULE_TYPE_RUNTIME
+} = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const { last, someInIterable } = require("../util/IterableHelpers");
 const StringXor = require("../util/StringXor");
 const { compareModulesByIdentifier } = require("../util/comparators");
 const createHash = require("../util/createHash");
+const { getPathInAst, getAllReferences } = require("../util/mergeScope");
+const nonNumericOnlyHash = require("../util/nonNumericOnlyHash");
 const { intersectRuntime } = require("../util/runtime");
 const JavascriptGenerator = require("./JavascriptGenerator");
 const JavascriptParser = require("./JavascriptParser");
 
+/** @typedef {import("eslint-scope").Scope} Scope */
+/** @typedef {import("eslint-scope").Variable} Variable */
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").Output} OutputOptions */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
 /** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("../Entrypoint")} Entrypoint */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../util/Hash")} Hash */
 
 /**
@@ -48,35 +65,48 @@ const JavascriptParser = require("./JavascriptParser");
 const chunkHasJs = (chunk, chunkGraph) => {
 	if (chunkGraph.getNumberOfEntryModules(chunk) > 0) return true;
 
-	return chunkGraph.getChunkModulesIterableBySourceType(chunk, "javascript")
-		? true
-		: false;
+	return Boolean(
+		chunkGraph.getChunkModulesIterableBySourceType(chunk, "javascript")
+	);
 };
 
+/**
+ * @param {Module} module a module
+ * @param {string} code the code
+ * @returns {string} generated code for the stack
+ */
 const printGeneratedCodeForStack = (module, code) => {
 	const lines = code.split("\n");
 	const n = `${lines.length}`.length;
 	return `\n\nGenerated code for ${module.identifier()}\n${lines
-		.map((line, i, lines) => {
-			const iStr = `${i + 1}`;
-			return `${" ".repeat(n - iStr.length)}${iStr} | ${line}`;
-		})
+		.map(
+			/**
+			 * @param {string} line the line
+			 * @param {number} i the index
+			 * @param {string[]} lines the lines
+			 * @returns {string} the line with line number
+			 */
+			(line, i, lines) => {
+				const iStr = `${i + 1}`;
+				return `${" ".repeat(n - iStr.length)}${iStr} | ${line}`;
+			}
+		)
 		.join("\n")}`;
 };
 
 /**
- * @typedef {Object} RenderContext
+ * @typedef {object} RenderContext
  * @property {Chunk} chunk the chunk
  * @property {DependencyTemplates} dependencyTemplates the dependency templates
  * @property {RuntimeTemplate} runtimeTemplate the runtime template
  * @property {ModuleGraph} moduleGraph the module graph
  * @property {ChunkGraph} chunkGraph the chunk graph
  * @property {CodeGenerationResults} codeGenerationResults results of code generation
- * @property {boolean} strictMode rendering in strict context
+ * @property {boolean | undefined} strictMode rendering in strict context
  */
 
 /**
- * @typedef {Object} MainRenderContext
+ * @typedef {object} MainRenderContext
  * @property {Chunk} chunk the chunk
  * @property {DependencyTemplates} dependencyTemplates the dependency templates
  * @property {RuntimeTemplate} runtimeTemplate the runtime template
@@ -84,11 +114,11 @@ const printGeneratedCodeForStack = (module, code) => {
  * @property {ChunkGraph} chunkGraph the chunk graph
  * @property {CodeGenerationResults} codeGenerationResults results of code generation
  * @property {string} hash hash to be used for render call
- * @property {boolean} strictMode rendering in strict context
+ * @property {boolean | undefined} strictMode rendering in strict context
  */
 
 /**
- * @typedef {Object} ChunkRenderContext
+ * @typedef {object} ChunkRenderContext
  * @property {Chunk} chunk the chunk
  * @property {DependencyTemplates} dependencyTemplates the dependency templates
  * @property {RuntimeTemplate} runtimeTemplate the runtime template
@@ -96,12 +126,13 @@ const printGeneratedCodeForStack = (module, code) => {
  * @property {ChunkGraph} chunkGraph the chunk graph
  * @property {CodeGenerationResults} codeGenerationResults results of code generation
  * @property {InitFragment<ChunkRenderContext>[]} chunkInitFragments init fragments for the chunk
- * @property {boolean} strictMode rendering in strict context
+ * @property {boolean | undefined} strictMode rendering in strict context
  */
 
 /**
- * @typedef {Object} RenderBootstrapContext
+ * @typedef {object} RenderBootstrapContext
  * @property {Chunk} chunk the chunk
+ * @property {CodeGenerationResults} codeGenerationResults results of code generation
  * @property {RuntimeTemplate} runtimeTemplate the runtime template
  * @property {ModuleGraph} moduleGraph the module graph
  * @property {ChunkGraph} chunkGraph the chunk graph
@@ -111,7 +142,7 @@ const printGeneratedCodeForStack = (module, code) => {
 /** @typedef {RenderContext & { inlined: boolean }} StartupRenderContext */
 
 /**
- * @typedef {Object} CompilationHooks
+ * @typedef {object} CompilationHooks
  * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModuleContent
  * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModuleContainer
  * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModulePackage
@@ -122,8 +153,8 @@ const printGeneratedCodeForStack = (module, code) => {
  * @property {SyncWaterfallHook<[Source, Module, StartupRenderContext]>} renderStartup
  * @property {SyncWaterfallHook<[string, RenderBootstrapContext]>} renderRequire
  * @property {SyncBailHook<[Module, RenderBootstrapContext], string>} inlineInRuntimeBailout
- * @property {SyncBailHook<[Module, RenderContext], string>} embedInRuntimeBailout
- * @property {SyncBailHook<[RenderContext], string>} strictRuntimeBailout
+ * @property {SyncBailHook<[Module, RenderContext], string | void>} embedInRuntimeBailout
+ * @property {SyncBailHook<[RenderContext], string | void>} strictRuntimeBailout
  * @property {SyncHook<[Chunk, Hash, ChunkHashContext]>} chunkHash
  * @property {SyncBailHook<[Chunk, RenderContext], boolean>} useSourceMap
  */
@@ -131,6 +162,10 @@ const printGeneratedCodeForStack = (module, code) => {
 /** @type {WeakMap<Compilation, CompilationHooks>} */
 const compilationHooksMap = new WeakMap();
 
+const PLUGIN_NAME = "JavascriptModulesPlugin";
+
+/** @typedef {{ header: string[], beforeStartup: string[], startup: string[], afterStartup: string[], allowInlineStartup: boolean }} Bootstrap */
+
 class JavascriptModulesPlugin {
 	/**
 	 * @param {Compilation} compilation the compilation
@@ -194,155 +229,138 @@ class JavascriptModulesPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"JavascriptModulesPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
 				normalModuleFactory.hooks.createParser
-					.for("javascript/auto")
-					.tap("JavascriptModulesPlugin", options => {
-						return new JavascriptParser("auto");
-					});
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, options => new JavascriptParser("auto"));
 				normalModuleFactory.hooks.createParser
-					.for("javascript/dynamic")
-					.tap("JavascriptModulesPlugin", options => {
-						return new JavascriptParser("script");
-					});
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, options => new JavascriptParser("script"));
 				normalModuleFactory.hooks.createParser
-					.for("javascript/esm")
-					.tap("JavascriptModulesPlugin", options => {
-						return new JavascriptParser("module");
-					});
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, options => new JavascriptParser("module"));
 				normalModuleFactory.hooks.createGenerator
-					.for("javascript/auto")
-					.tap("JavascriptModulesPlugin", () => {
-						return new JavascriptGenerator();
-					});
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, () => new JavascriptGenerator());
 				normalModuleFactory.hooks.createGenerator
-					.for("javascript/dynamic")
-					.tap("JavascriptModulesPlugin", () => {
-						return new JavascriptGenerator();
-					});
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, () => new JavascriptGenerator());
 				normalModuleFactory.hooks.createGenerator
-					.for("javascript/esm")
-					.tap("JavascriptModulesPlugin", () => {
-						return new JavascriptGenerator();
-					});
-				compilation.hooks.renderManifest.tap(
-					"JavascriptModulesPlugin",
-					(result, options) => {
-						const {
-							hash,
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, () => new JavascriptGenerator());
+				compilation.hooks.renderManifest.tap(PLUGIN_NAME, (result, options) => {
+					const {
+						hash,
+						chunk,
+						chunkGraph,
+						moduleGraph,
+						runtimeTemplate,
+						dependencyTemplates,
+						outputOptions,
+						codeGenerationResults
+					} = options;
+
+					const hotUpdateChunk = chunk instanceof HotUpdateChunk ? chunk : null;
+
+					let render;
+					const filenameTemplate =
+						JavascriptModulesPlugin.getChunkFilenameTemplate(
 							chunk,
-							chunkGraph,
-							moduleGraph,
-							runtimeTemplate,
-							dependencyTemplates,
-							outputOptions,
-							codeGenerationResults
-						} = options;
-
-						const hotUpdateChunk =
-							chunk instanceof HotUpdateChunk ? chunk : null;
-
-						let render;
-						const filenameTemplate =
-							JavascriptModulesPlugin.getChunkFilenameTemplate(
-								chunk,
-								outputOptions
+							outputOptions
+						);
+					if (hotUpdateChunk) {
+						render = () =>
+							this.renderChunk(
+								{
+									chunk,
+									dependencyTemplates,
+									runtimeTemplate,
+									moduleGraph,
+									chunkGraph,
+									codeGenerationResults,
+									strictMode: runtimeTemplate.isModule()
+								},
+								hooks
 							);
-						if (hotUpdateChunk) {
-							render = () =>
-								this.renderChunk(
-									{
-										chunk,
-										dependencyTemplates,
-										runtimeTemplate,
-										moduleGraph,
-										chunkGraph,
-										codeGenerationResults,
-										strictMode: runtimeTemplate.isModule()
-									},
-									hooks
-								);
-						} else if (chunk.hasRuntime()) {
-							render = () =>
-								this.renderMain(
-									{
-										hash,
-										chunk,
-										dependencyTemplates,
-										runtimeTemplate,
-										moduleGraph,
-										chunkGraph,
-										codeGenerationResults,
-										strictMode: runtimeTemplate.isModule()
-									},
-									hooks,
-									compilation
-								);
-						} else {
-							if (!chunkHasJs(chunk, chunkGraph)) {
-								return result;
-							}
-
-							render = () =>
-								this.renderChunk(
-									{
-										chunk,
-										dependencyTemplates,
-										runtimeTemplate,
-										moduleGraph,
-										chunkGraph,
-										codeGenerationResults,
-										strictMode: runtimeTemplate.isModule()
-									},
-									hooks
-								);
+					} else if (chunk.hasRuntime()) {
+						render = () =>
+							this.renderMain(
+								{
+									hash,
+									chunk,
+									dependencyTemplates,
+									runtimeTemplate,
+									moduleGraph,
+									chunkGraph,
+									codeGenerationResults,
+									strictMode: runtimeTemplate.isModule()
+								},
+								hooks,
+								compilation
+							);
+					} else {
+						if (!chunkHasJs(chunk, chunkGraph)) {
+							return result;
 						}
 
-						result.push({
-							render,
-							filenameTemplate,
-							pathOptions: {
-								hash,
-								runtime: chunk.runtime,
-								chunk,
-								contentHashType: "javascript"
-							},
-							info: {
-								javascriptModule: compilation.runtimeTemplate.isModule()
-							},
-							identifier: hotUpdateChunk
-								? `hotupdatechunk${chunk.id}`
-								: `chunk${chunk.id}`,
-							hash: chunk.contentHash.javascript
-						});
-
-						return result;
-					}
-				);
-				compilation.hooks.chunkHash.tap(
-					"JavascriptModulesPlugin",
-					(chunk, hash, context) => {
-						hooks.chunkHash.call(chunk, hash, context);
-						if (chunk.hasRuntime()) {
-							this.updateHashWithBootstrap(
-								hash,
+						render = () =>
+							this.renderChunk(
 								{
-									hash: "0000",
 									chunk,
-									chunkGraph: context.chunkGraph,
-									moduleGraph: context.moduleGraph,
-									runtimeTemplate: context.runtimeTemplate
+									dependencyTemplates,
+									runtimeTemplate,
+									moduleGraph,
+									chunkGraph,
+									codeGenerationResults,
+									strictMode: runtimeTemplate.isModule()
 								},
 								hooks
 							);
-						}
 					}
-				);
-				compilation.hooks.contentHash.tap("JavascriptModulesPlugin", chunk => {
+
+					result.push({
+						render,
+						filenameTemplate,
+						pathOptions: {
+							hash,
+							runtime: chunk.runtime,
+							chunk,
+							contentHashType: "javascript"
+						},
+						info: {
+							javascriptModule: compilation.runtimeTemplate.isModule()
+						},
+						identifier: hotUpdateChunk
+							? `hotupdatechunk${chunk.id}`
+							: `chunk${chunk.id}`,
+						hash: chunk.contentHash.javascript
+					});
+
+					return result;
+				});
+				compilation.hooks.chunkHash.tap(PLUGIN_NAME, (chunk, hash, context) => {
+					hooks.chunkHash.call(chunk, hash, context);
+					if (chunk.hasRuntime()) {
+						this.updateHashWithBootstrap(
+							hash,
+							{
+								hash: "0000",
+								chunk,
+								codeGenerationResults: context.codeGenerationResults,
+								chunkGraph: context.chunkGraph,
+								moduleGraph: context.moduleGraph,
+								runtimeTemplate: context.runtimeTemplate
+							},
+							hooks
+						);
+					}
+				});
+				compilation.hooks.contentHash.tap(PLUGIN_NAME, chunk => {
 					const {
 						chunkGraph,
+						codeGenerationResults,
 						moduleGraph,
 						runtimeTemplate,
 						outputOptions: {
@@ -360,6 +378,7 @@ class JavascriptModulesPlugin {
 							{
 								hash: "0000",
 								chunk,
+								codeGenerationResults,
 								chunkGraph: compilation.chunkGraph,
 								moduleGraph: compilation.moduleGraph,
 								runtimeTemplate: compilation.runtimeTemplate
@@ -372,6 +391,7 @@ class JavascriptModulesPlugin {
 					}
 					hooks.chunkHash.call(chunk, hash, {
 						chunkGraph,
+						codeGenerationResults,
 						moduleGraph,
 						runtimeTemplate
 					});
@@ -388,7 +408,7 @@ class JavascriptModulesPlugin {
 					}
 					const runtimeModules = chunkGraph.getChunkModulesIterableBySourceType(
 						chunk,
-						"runtime"
+						WEBPACK_MODULE_TYPE_RUNTIME
 					);
 					if (runtimeModules) {
 						const xor = new StringXor();
@@ -398,86 +418,93 @@ class JavascriptModulesPlugin {
 						xor.updateHash(hash);
 					}
 					const digest = /** @type {string} */ (hash.digest(hashDigest));
-					chunk.contentHash.javascript = digest.substr(0, hashDigestLength);
+					chunk.contentHash.javascript = nonNumericOnlyHash(
+						digest,
+						hashDigestLength
+					);
 				});
 				compilation.hooks.additionalTreeRuntimeRequirements.tap(
-					"JavascriptModulesPlugin",
+					PLUGIN_NAME,
 					(chunk, set, { chunkGraph }) => {
 						if (
 							!set.has(RuntimeGlobals.startupNoDefault) &&
 							chunkGraph.hasChunkEntryDependentChunks(chunk)
 						) {
 							set.add(RuntimeGlobals.onChunksLoaded);
+							set.add(RuntimeGlobals.exports);
 							set.add(RuntimeGlobals.require);
 						}
 					}
 				);
-				compilation.hooks.executeModule.tap(
-					"JavascriptModulesPlugin",
-					(options, context) => {
-						const source =
-							options.codeGenerationResult.sources.get("javascript");
-						if (source === undefined) return;
-						const { module, moduleObject } = options;
-						const code = source.source();
-
-						const fn = vm.runInThisContext(
-							`(function(${module.moduleArgument}, ${module.exportsArgument}, __webpack_require__) {\n${code}\n/**/})`,
-							{
-								filename: module.identifier(),
-								lineOffset: -1
-							}
-						);
-						try {
-							fn.call(
-								moduleObject.exports,
-								moduleObject,
-								moduleObject.exports,
-								context.__webpack_require__
-							);
-						} catch (e) {
-							e.stack += printGeneratedCodeForStack(options.module, code);
-							throw e;
+				compilation.hooks.executeModule.tap(PLUGIN_NAME, (options, context) => {
+					const source = options.codeGenerationResult.sources.get("javascript");
+					if (source === undefined) return;
+					const { module, moduleObject } = options;
+					const code = source.source();
+
+					const fn = vm.runInThisContext(
+						`(function(${module.moduleArgument}, ${module.exportsArgument}, ${RuntimeGlobals.require}) {\n${code}\n/**/})`,
+						{
+							filename: module.identifier(),
+							lineOffset: -1
 						}
-					}
-				);
-				compilation.hooks.executeModule.tap(
-					"JavascriptModulesPlugin",
-					(options, context) => {
-						const source = options.codeGenerationResult.sources.get("runtime");
-						if (source === undefined) return;
-						let code = source.source();
-						if (typeof code !== "string") code = code.toString();
-
-						const fn = vm.runInThisContext(
-							`(function(__webpack_require__) {\n${code}\n/**/})`,
-							{
-								filename: options.module.identifier(),
-								lineOffset: -1
-							}
+					);
+					try {
+						fn.call(
+							moduleObject.exports,
+							moduleObject,
+							moduleObject.exports,
+							context.__webpack_require__
 						);
-						try {
-							fn.call(null, context.__webpack_require__);
-						} catch (e) {
-							e.stack += printGeneratedCodeForStack(options.module, code);
-							throw e;
+					} catch (err) {
+						/** @type {Error} */
+						(err).stack += printGeneratedCodeForStack(
+							options.module,
+							/** @type {string} */ (code)
+						);
+						throw err;
+					}
+				});
+				compilation.hooks.executeModule.tap(PLUGIN_NAME, (options, context) => {
+					const source = options.codeGenerationResult.sources.get("runtime");
+					if (source === undefined) return;
+					let code = source.source();
+					if (typeof code !== "string") code = code.toString();
+
+					const fn = vm.runInThisContext(
+						`(function(${RuntimeGlobals.require}) {\n${code}\n/**/})`,
+						{
+							filename: options.module.identifier(),
+							lineOffset: -1
 						}
+					);
+					try {
+						// eslint-disable-next-line no-useless-call
+						fn.call(null, context.__webpack_require__);
+					} catch (err) {
+						/** @type {Error} */
+						(err).stack += printGeneratedCodeForStack(options.module, code);
+						throw err;
 					}
-				);
+				});
 			}
 		);
 	}
 
+	/**
+	 * @param {Chunk} chunk chunk
+	 * @param {OutputOptions} outputOptions output options
+	 * @returns {TemplatePath} used filename template
+	 */
 	static getChunkFilenameTemplate(chunk, outputOptions) {
 		if (chunk.filenameTemplate) {
 			return chunk.filenameTemplate;
 		} else if (chunk instanceof HotUpdateChunk) {
-			return outputOptions.hotUpdateChunkFilename;
+			return /** @type {TemplatePath} */ (outputOptions.hotUpdateChunkFilename);
 		} else if (chunk.canBeInitial()) {
-			return outputOptions.filename;
-		} else {
-			return outputOptions.chunkFilename;
+			return /** @type {TemplatePath} */ (outputOptions.filename);
 		}
+		return /** @type {TemplatePath} */ (outputOptions.chunkFilename);
 	}
 
 	/**
@@ -485,7 +512,7 @@ class JavascriptModulesPlugin {
 	 * @param {ChunkRenderContext} renderContext options object
 	 * @param {CompilationHooks} hooks hooks
 	 * @param {boolean} factory true: renders as factory method, false: pure module content
-	 * @returns {Source} the newly generated source from rendering
+	 * @returns {Source | null} the newly generated source from rendering
 	 */
 	renderModule(module, renderContext, hooks, factory) {
 		const {
@@ -525,7 +552,9 @@ class JavascriptModulesPlugin {
 				const needThisAsExports = runtimeRequirements.has(
 					RuntimeGlobals.thisAsExports
 				);
-				const needStrict = module.buildInfo.strict && !strictMode;
+				const needStrict =
+					/** @type {BuildInfo} */
+					(module.buildInfo).strict && !strictMode;
 				const cacheEntry = this._moduleFactoryCache.get(
 					moduleSourcePostContent
 				);
@@ -546,19 +575,19 @@ class JavascriptModulesPlugin {
 						args.push(
 							needModule
 								? module.moduleArgument
-								: "__unused_webpack_" + module.moduleArgument
+								: `__unused_webpack_${module.moduleArgument}`
 						);
 					if (needExports || needRequire)
 						args.push(
 							needExports
 								? module.exportsArgument
-								: "__unused_webpack_" + module.exportsArgument
+								: `__unused_webpack_${module.exportsArgument}`
 						);
-					if (needRequire) args.push("__webpack_require__");
+					if (needRequire) args.push(RuntimeGlobals.require);
 					if (!needThisAsExports && runtimeTemplate.supportsArrowFunction()) {
-						factorySource.add("/***/ ((" + args.join(", ") + ") => {\n\n");
+						factorySource.add(`/***/ ((${args.join(", ")}) => {\n\n`);
 					} else {
-						factorySource.add("/***/ (function(" + args.join(", ") + ") {\n\n");
+						factorySource.add(`/***/ (function(${args.join(", ")}) {\n\n`);
 					}
 					if (needStrict) {
 						factorySource.add('"use strict";\n');
@@ -591,9 +620,9 @@ class JavascriptModulesPlugin {
 					),
 				"JavascriptModulesPlugin.getCompilationHooks().renderModulePackage"
 			);
-		} catch (e) {
-			e.module = module;
-			throw e;
+		} catch (err) {
+			err.module = module;
+			throw err;
 		}
 	}
 
@@ -612,7 +641,10 @@ class JavascriptModulesPlugin {
 		const allModules = modules ? Array.from(modules) : [];
 		let strictHeader;
 		let allStrict = renderContext.strictMode;
-		if (!allStrict && allModules.every(m => m.buildInfo.strict)) {
+		if (
+			!allStrict &&
+			allModules.every(m => /** @type {BuildInfo} */ (m.buildInfo).strict)
+		) {
 			const strictBailout = hooks.strictRuntimeBailout.call(renderContext);
 			strictHeader = strictBailout
 				? `// runtime can't be in strict mode because ${strictBailout}.\n`
@@ -660,8 +692,8 @@ class JavascriptModulesPlugin {
 		return strictHeader
 			? new ConcatSource(strictHeader, source, ";")
 			: renderContext.runtimeTemplate.isModule()
-			? source
-			: new ConcatSource(source, ";");
+				? source
+				: new ConcatSource(source, ";");
 	}
 
 	/**
@@ -688,12 +720,13 @@ class JavascriptModulesPlugin {
 		);
 
 		const hasEntryModules = chunkGraph.getNumberOfEntryModules(chunk) > 0;
+		/** @type {Set<Module> | undefined} */
 		let inlinedModules;
 		if (bootstrap.allowInlineStartup && hasEntryModules) {
 			inlinedModules = new Set(chunkGraph.getChunkEntryModulesIterable(chunk));
 		}
 
-		let source = new ConcatSource();
+		const source = new ConcatSource();
 		let prefix;
 		if (iife) {
 			if (runtimeTemplate.supportsArrowFunction()) {
@@ -706,16 +739,20 @@ class JavascriptModulesPlugin {
 			prefix = "/******/ ";
 		}
 		let allStrict = renderContext.strictMode;
-		if (!allStrict && allModules.every(m => m.buildInfo.strict)) {
+		if (
+			!allStrict &&
+			allModules.every(m => /** @type {BuildInfo} */ (m.buildInfo).strict)
+		) {
 			const strictBailout = hooks.strictRuntimeBailout.call(renderContext);
 			if (strictBailout) {
 				source.add(
-					prefix +
-						`// runtime can't be in strict mode because ${strictBailout}.\n`
+					`${
+						prefix
+					}// runtime can't be in strict mode because ${strictBailout}.\n`
 				);
 			} else {
 				allStrict = true;
-				source.add(prefix + '"use strict";\n');
+				source.add(`${prefix}"use strict";\n`);
 			}
 		}
 
@@ -729,7 +766,9 @@ class JavascriptModulesPlugin {
 		const chunkModules = Template.renderChunkModules(
 			chunkRenderContext,
 			inlinedModules
-				? allModules.filter(m => !inlinedModules.has(m))
+				? allModules.filter(
+						m => !(/** @type {Set<Module>} */ (inlinedModules).has(m))
+					)
 				: allModules,
 			module => this.renderModule(module, chunkRenderContext, hooks, true),
 			prefix
@@ -740,7 +779,7 @@ class JavascriptModulesPlugin {
 			runtimeRequirements.has(RuntimeGlobals.moduleFactoriesAddOnly) ||
 			runtimeRequirements.has(RuntimeGlobals.require)
 		) {
-			source.add(prefix + "var __webpack_modules__ = (");
+			source.add(`${prefix}var __webpack_modules__ = (`);
 			source.add(chunkModules || "{}");
 			source.add(");\n");
 			source.add(
@@ -749,7 +788,7 @@ class JavascriptModulesPlugin {
 		}
 
 		if (bootstrap.header.length > 0) {
-			const header = Template.asString(bootstrap.header) + "\n";
+			const header = `${Template.asString(bootstrap.header)}\n`;
 			source.add(
 				new PrefixSource(
 					prefix,
@@ -783,7 +822,7 @@ class JavascriptModulesPlugin {
 		}
 		if (inlinedModules) {
 			if (bootstrap.beforeStartup.length > 0) {
-				const beforeStartup = Template.asString(bootstrap.beforeStartup) + "\n";
+				const beforeStartup = `${Template.asString(bootstrap.beforeStartup)}\n`;
 				source.add(
 					new PrefixSource(
 						prefix,
@@ -793,36 +832,45 @@ class JavascriptModulesPlugin {
 					)
 				);
 			}
-			const lastInlinedModule = last(inlinedModules);
+			const lastInlinedModule = /** @type {Module} */ (last(inlinedModules));
 			const startupSource = new ConcatSource();
-			startupSource.add(`var __webpack_exports__ = {};\n`);
+
+			if (runtimeRequirements.has(RuntimeGlobals.exports)) {
+				startupSource.add(`var ${RuntimeGlobals.exports} = {};\n`);
+			}
+
+			const renamedInlinedModule = this.renameInlineModule(
+				allModules,
+				renderContext,
+				inlinedModules,
+				chunkRenderContext,
+				hooks
+			);
+
 			for (const m of inlinedModules) {
-				const renderedModule = this.renderModule(
-					m,
-					chunkRenderContext,
-					hooks,
-					false
-				);
+				const renderedModule =
+					renamedInlinedModule.get(m) ||
+					this.renderModule(m, chunkRenderContext, hooks, false);
+
 				if (renderedModule) {
-					const innerStrict = !allStrict && m.buildInfo.strict;
+					const innerStrict =
+						!allStrict && /** @type {BuildInfo} */ (m.buildInfo).strict;
 					const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(
 						m,
 						chunk.runtime
 					);
 					const exports = runtimeRequirements.has(RuntimeGlobals.exports);
 					const webpackExports =
-						exports && m.exportsArgument === "__webpack_exports__";
-					let iife = innerStrict
+						exports && m.exportsArgument === RuntimeGlobals.exports;
+					const iife = innerStrict
 						? "it need to be in strict mode."
 						: inlinedModules.size > 1
-						? // TODO check globals and top-level declarations of other entries and chunk modules
-						  // to make a better decision
-						  "it need to be isolated against other entry modules."
-						: chunkModules
-						? "it need to be isolated against other modules in the chunk."
-						: exports && !webpackExports
-						? `it uses a non-standard name for the exports (${m.exportsArgument}).`
-						: hooks.embedInRuntimeBailout.call(m, renderContext);
+							? // TODO check globals and top-level declarations of other entries and chunk modules
+								// to make a better decision
+								"it need to be isolated against other entry modules."
+							: exports && !webpackExports
+								? `it uses a non-standard name for the exports (${m.exportsArgument}).`
+								: hooks.embedInRuntimeBailout.call(m, renderContext);
 					let footer;
 					if (iife !== undefined) {
 						startupSource.add(
@@ -843,9 +891,9 @@ class JavascriptModulesPlugin {
 					if (exports) {
 						if (m !== lastInlinedModule)
 							startupSource.add(`var ${m.exportsArgument} = {};\n`);
-						else if (m.exportsArgument !== "__webpack_exports__")
+						else if (m.exportsArgument !== RuntimeGlobals.exports)
 							startupSource.add(
-								`var ${m.exportsArgument} = __webpack_exports__;\n`
+								`var ${m.exportsArgument} = ${RuntimeGlobals.exports};\n`
 							);
 					}
 					startupSource.add(renderedModule);
@@ -854,7 +902,7 @@ class JavascriptModulesPlugin {
 			}
 			if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
 				startupSource.add(
-					`__webpack_exports__ = ${RuntimeGlobals.onChunksLoaded}(__webpack_exports__);\n`
+					`${RuntimeGlobals.exports} = ${RuntimeGlobals.onChunksLoaded}(${RuntimeGlobals.exports});\n`
 				);
 			}
 			source.add(
@@ -864,7 +912,7 @@ class JavascriptModulesPlugin {
 				})
 			);
 			if (bootstrap.afterStartup.length > 0) {
-				const afterStartup = Template.asString(bootstrap.afterStartup) + "\n";
+				const afterStartup = `${Template.asString(bootstrap.afterStartup)}\n`;
 				source.add(
 					new PrefixSource(
 						prefix,
@@ -875,9 +923,10 @@ class JavascriptModulesPlugin {
 				);
 			}
 		} else {
-			const lastEntryModule = last(
-				chunkGraph.getChunkEntryModulesIterable(chunk)
-			);
+			const lastEntryModule =
+				/** @type {Module} */
+				(last(chunkGraph.getChunkEntryModulesIterable(chunk)));
+			/** @type {function(string[], string): Source} */
 			const toSource = useSourceMap
 				? (content, name) =>
 						new OriginalSource(Template.asString(content), name)
@@ -906,7 +955,7 @@ class JavascriptModulesPlugin {
 			hasEntryModules &&
 			runtimeRequirements.has(RuntimeGlobals.returnExportsFromRuntime)
 		) {
-			source.add(`${prefix}return __webpack_exports__;\n`);
+			source.add(`${prefix}return ${RuntimeGlobals.exports};\n`);
 		}
 		if (iife) {
 			source.add("/******/ })()\n");
@@ -931,6 +980,7 @@ class JavascriptModulesPlugin {
 				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().renderContent plugins should return something"
 			);
 		}
+
 		finalSource = InitFragment.addToSource(
 			finalSource,
 			chunkRenderContext.chunkInitFragments,
@@ -956,7 +1006,8 @@ class JavascriptModulesPlugin {
 	 */
 	updateHashWithBootstrap(hash, renderContext, hooks) {
 		const bootstrap = this.renderBootstrap(renderContext, hooks);
-		for (const key of Object.keys(bootstrap)) {
+		for (const _k of Object.keys(bootstrap)) {
+			const key = /** @type {keyof Bootstrap} */ (_k);
 			hash.update(key);
 			if (Array.isArray(bootstrap[key])) {
 				for (const line of bootstrap[key]) {
@@ -971,10 +1022,16 @@ class JavascriptModulesPlugin {
 	/**
 	 * @param {RenderBootstrapContext} renderContext options object
 	 * @param {CompilationHooks} hooks hooks
-	 * @returns {{ header: string[], beforeStartup: string[], startup: string[], afterStartup: string[], allowInlineStartup: boolean }} the generated source of the bootstrap code
+	 * @returns {Bootstrap} the generated source of the bootstrap code
 	 */
 	renderBootstrap(renderContext, hooks) {
-		const { chunkGraph, moduleGraph, chunk, runtimeTemplate } = renderContext;
+		const {
+			chunkGraph,
+			codeGenerationResults,
+			moduleGraph,
+			chunk,
+			runtimeTemplate
+		} = renderContext;
 
 		const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
 
@@ -994,6 +1051,9 @@ class JavascriptModulesPlugin {
 		const useRequire =
 			requireFunction || interceptModuleExecution || moduleUsed;
 
+		/**
+		 * @type {{startup: string[], beforeStartup: string[], header: string[], afterStartup: string[], allowInlineStartup: boolean}}
+		 */
 		const result = {
 			header: [],
 			beforeStartup: [],
@@ -1002,7 +1062,7 @@ class JavascriptModulesPlugin {
 			allowInlineStartup: true
 		};
 
-		let { header: buf, startup, beforeStartup, afterStartup } = result;
+		const { header: buf, startup, beforeStartup, afterStartup } = result;
 
 		if (result.allowInlineStartup && moduleFactories) {
 			startup.push(
@@ -1029,13 +1089,13 @@ class JavascriptModulesPlugin {
 
 		if (useRequire) {
 			buf.push("// The require function");
-			buf.push(`function __webpack_require__(moduleId) {`);
+			buf.push(`function ${RuntimeGlobals.require}(moduleId) {`);
 			buf.push(Template.indent(this.renderRequire(renderContext, hooks)));
 			buf.push("}");
 			buf.push("");
 		} else if (runtimeRequirements.has(RuntimeGlobals.requireScope)) {
 			buf.push("// The require scope");
-			buf.push("var __webpack_require__ = {};");
+			buf.push(`var ${RuntimeGlobals.require} = {};`);
 			buf.push("");
 		}
 
@@ -1072,7 +1132,9 @@ class JavascriptModulesPlugin {
 					entryModule,
 					entrypoint
 				] of chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)) {
-					const chunks = entrypoint.chunks.filter(c => c !== chunk);
+					const chunks =
+						/** @type {Entrypoint} */
+						(entrypoint).chunks.filter(c => c !== chunk);
 					if (result.allowInlineStartup && chunks.length > 0) {
 						buf2.push(
 							"// This entry module depends on other loaded chunks and execution need to be delayed"
@@ -1098,8 +1160,18 @@ class JavascriptModulesPlugin {
 						);
 						result.allowInlineStartup = false;
 					}
+
+					let data;
+					if (codeGenerationResults.has(entryModule, chunk.runtime)) {
+						const result = codeGenerationResults.get(
+							entryModule,
+							chunk.runtime
+						);
+						data = result.data;
+					}
 					if (
 						result.allowInlineStartup &&
+						(!data || !data.get("topLevelDeclarations")) &&
 						(!entryModule.buildInfo ||
 							!entryModule.buildInfo.topLevelDeclarations)
 					) {
@@ -1139,32 +1211,32 @@ class JavascriptModulesPlugin {
 					}
 					if (chunks.length > 0) {
 						buf2.push(
-							`${i === 0 ? "var __webpack_exports__ = " : ""}${
+							`${i === 0 ? `var ${RuntimeGlobals.exports} = ` : ""}${
 								RuntimeGlobals.onChunksLoaded
 							}(undefined, ${JSON.stringify(
 								chunks.map(c => c.id)
 							)}, ${runtimeTemplate.returningFunction(
-								`__webpack_require__(${moduleIdExpr})`
+								`${RuntimeGlobals.require}(${moduleIdExpr})`
 							)})`
 						);
 					} else if (useRequire) {
 						buf2.push(
-							`${
-								i === 0 ? "var __webpack_exports__ = " : ""
-							}__webpack_require__(${moduleIdExpr});`
+							`${i === 0 ? `var ${RuntimeGlobals.exports} = ` : ""}${
+								RuntimeGlobals.require
+							}(${moduleIdExpr});`
 						);
 					} else {
-						if (i === 0) buf2.push("var __webpack_exports__ = {};");
+						if (i === 0) buf2.push(`var ${RuntimeGlobals.exports} = {};`);
 						if (requireScopeUsed) {
 							buf2.push(
 								`__webpack_modules__[${moduleIdExpr}](0, ${
-									i === 0 ? "__webpack_exports__" : "{}"
-								}, __webpack_require__);`
+									i === 0 ? RuntimeGlobals.exports : "{}"
+								}, ${RuntimeGlobals.require});`
 							);
 						} else if (entryRuntimeRequirements.has(RuntimeGlobals.exports)) {
 							buf2.push(
 								`__webpack_modules__[${moduleIdExpr}](0, ${
-									i === 0 ? "__webpack_exports__" : "{}"
+									i === 0 ? RuntimeGlobals.exports : "{}"
 								});`
 							);
 						} else {
@@ -1174,7 +1246,7 @@ class JavascriptModulesPlugin {
 				}
 				if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
 					buf2.push(
-						`__webpack_exports__ = ${RuntimeGlobals.onChunksLoaded}(__webpack_exports__);`
+						`${RuntimeGlobals.exports} = ${RuntimeGlobals.onChunksLoaded}(${RuntimeGlobals.exports});`
 					);
 				}
 				if (
@@ -1187,13 +1259,13 @@ class JavascriptModulesPlugin {
 					buf.push(
 						`${RuntimeGlobals.startup} = ${runtimeTemplate.basicFunction("", [
 							...buf2,
-							"return __webpack_exports__;"
+							`return ${RuntimeGlobals.exports};`
 						])};`
 					);
 					buf.push("");
 					startup.push("// run startup");
 					startup.push(
-						`var __webpack_exports__ = ${RuntimeGlobals.startup}();`
+						`var ${RuntimeGlobals.exports} = ${RuntimeGlobals.startup}();`
 					);
 				} else if (runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore)) {
 					buf.push("// the startup function");
@@ -1241,7 +1313,9 @@ class JavascriptModulesPlugin {
 				`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`
 			);
 			startup.push("// run startup");
-			startup.push(`var __webpack_exports__ = ${RuntimeGlobals.startup}();`);
+			startup.push(
+				`var ${RuntimeGlobals.exports} = ${RuntimeGlobals.startup}();`
+			);
 		}
 		return result;
 	}
@@ -1262,18 +1336,18 @@ class JavascriptModulesPlugin {
 			RuntimeGlobals.interceptModuleExecution
 		)
 			? Template.asString([
-					"var execOptions = { id: moduleId, module: module, factory: __webpack_modules__[moduleId], require: __webpack_require__ };",
+					`var execOptions = { id: moduleId, module: module, factory: __webpack_modules__[moduleId], require: ${RuntimeGlobals.require} };`,
 					`${RuntimeGlobals.interceptModuleExecution}.forEach(function(handler) { handler(execOptions); });`,
 					"module = execOptions.module;",
 					"execOptions.factory.call(module.exports, module, module.exports, execOptions.require);"
-			  ])
+				])
 			: runtimeRequirements.has(RuntimeGlobals.thisAsExports)
-			? Template.asString([
-					"__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);"
-			  ])
-			: Template.asString([
-					"__webpack_modules__[moduleId](module, module.exports, __webpack_require__);"
-			  ]);
+				? Template.asString([
+						`__webpack_modules__[moduleId].call(module.exports, module, module.exports, ${RuntimeGlobals.require});`
+					])
+				: Template.asString([
+						`__webpack_modules__[moduleId](module, module.exports, ${RuntimeGlobals.require});`
+					]);
 		const needModuleId = runtimeRequirements.has(RuntimeGlobals.moduleId);
 		const needModuleLoaded = runtimeRequirements.has(
 			RuntimeGlobals.moduleLoaded
@@ -1286,7 +1360,7 @@ class JavascriptModulesPlugin {
 				? Template.indent([
 						"if (cachedModule.error !== undefined) throw cachedModule.error;",
 						"return cachedModule.exports;"
-				  ])
+					])
 				: Template.indent("return cachedModule.exports;"),
 			"}",
 			"// Create a new module (and put it into the cache)",
@@ -1309,27 +1383,27 @@ class JavascriptModulesPlugin {
 							"if(threw) delete __webpack_module_cache__[moduleId];"
 						]),
 						"}"
-				  ])
+					])
 				: outputOptions.strictModuleErrorHandling
-				? Template.asString([
-						"// Execute the module function",
-						"try {",
-						Template.indent(moduleExecution),
-						"} catch(e) {",
-						Template.indent(["module.error = e;", "throw e;"]),
-						"}"
-				  ])
-				: Template.asString([
-						"// Execute the module function",
-						moduleExecution
-				  ]),
+					? Template.asString([
+							"// Execute the module function",
+							"try {",
+							Template.indent(moduleExecution),
+							"} catch(e) {",
+							Template.indent(["module.error = e;", "throw e;"]),
+							"}"
+						])
+					: Template.asString([
+							"// Execute the module function",
+							moduleExecution
+						]),
 			needModuleLoaded
 				? Template.asString([
 						"",
 						"// Flag the module as loaded",
-						"module.loaded = true;",
+						`${RuntimeGlobals.moduleLoaded} = true;`,
 						""
-				  ])
+					])
 				: "",
 			"// Return the exports of the module",
 			"return module.exports;"
@@ -1339,6 +1413,160 @@ class JavascriptModulesPlugin {
 			"JavascriptModulesPlugin.getCompilationHooks().renderRequire"
 		);
 	}
+
+	/**
+	 * @param {Module[]} allModules allModules
+	 * @param {MainRenderContext} renderContext renderContext
+	 * @param {Set<Module>} inlinedModules inlinedModules
+	 * @param {ChunkRenderContext} chunkRenderContext chunkRenderContext
+	 * @param {CompilationHooks} hooks hooks
+	 * @returns {Map<Module, Source>} renamed inlined modules
+	 */
+	renameInlineModule(
+		allModules,
+		renderContext,
+		inlinedModules,
+		chunkRenderContext,
+		hooks
+	) {
+		const { runtimeTemplate } = renderContext;
+
+		/** @typedef {{ source: Source, ast: any, variables: Set<Variable>, usedInNonInlined: Set<Variable>}} InlinedModulesInfo */
+
+		/** @type {Map<Module, InlinedModulesInfo>} */
+		const inlinedModulesToInfo = new Map();
+		/** @type {Set<string>} */
+		const nonInlinedModuleThroughIdentifiers = new Set();
+		/** @type {Map<Module, Source>} */
+		const renamedInlinedModules = new Map();
+
+		for (const m of allModules) {
+			const isInlinedModule = inlinedModules && inlinedModules.has(m);
+			const moduleSource = this.renderModule(
+				m,
+				chunkRenderContext,
+				hooks,
+				!isInlinedModule
+			);
+
+			if (!moduleSource) continue;
+			const code = /** @type {string} */ (moduleSource.source());
+			const ast = JavascriptParser._parse(code, {
+				sourceType: "auto"
+			});
+
+			const scopeManager = eslintScope.analyze(ast, {
+				ecmaVersion: 6,
+				sourceType: "module",
+				optimistic: true,
+				ignoreEval: true
+			});
+
+			const globalScope = /** @type {Scope} */ (scopeManager.acquire(ast));
+			if (inlinedModules && inlinedModules.has(m)) {
+				const moduleScope = globalScope.childScopes[0];
+				inlinedModulesToInfo.set(m, {
+					source: moduleSource,
+					ast,
+					variables: new Set(moduleScope.variables),
+					usedInNonInlined: new Set()
+				});
+			} else {
+				for (const ref of globalScope.through) {
+					nonInlinedModuleThroughIdentifiers.add(ref.identifier.name);
+				}
+			}
+		}
+
+		for (const [, { variables, usedInNonInlined }] of inlinedModulesToInfo) {
+			for (const variable of variables) {
+				if (nonInlinedModuleThroughIdentifiers.has(variable.name)) {
+					usedInNonInlined.add(variable);
+				}
+			}
+		}
+
+		for (const [m, moduleInfo] of inlinedModulesToInfo) {
+			const { ast, source: _source, usedInNonInlined } = moduleInfo;
+			const source = new ReplaceSource(_source);
+			if (usedInNonInlined.size === 0) {
+				renamedInlinedModules.set(m, source);
+				continue;
+			}
+
+			const usedNames = new Set(
+				Array.from(
+					/** @type {InlinedModulesInfo} */
+					(inlinedModulesToInfo.get(m)).variables
+				).map(v => v.name)
+			);
+
+			for (const variable of usedInNonInlined) {
+				const references = getAllReferences(variable);
+				const allIdentifiers = new Set(
+					references.map(r => r.identifier).concat(variable.identifiers)
+				);
+
+				const newName = this.findNewName(
+					variable.name,
+					usedNames,
+					m.readableIdentifier(runtimeTemplate.requestShortener)
+				);
+				usedNames.add(newName);
+				for (const identifier of allIdentifiers) {
+					const r = /** @type {Range} */ (identifier.range);
+					const path = getPathInAst(ast, identifier);
+					if (path && path.length > 1) {
+						const maybeProperty =
+							path[1].type === "AssignmentPattern" && path[1].left === path[0]
+								? path[2]
+								: path[1];
+						if (maybeProperty.type === "Property" && maybeProperty.shorthand) {
+							source.insert(r[1], `: ${newName}`);
+							continue;
+						}
+					}
+					source.replace(r[0], r[1] - 1, newName);
+				}
+			}
+
+			renamedInlinedModules.set(m, source);
+		}
+
+		return renamedInlinedModules;
+	}
+
+	/**
+	 * @param {string} oldName oldName
+	 * @param {Set<string>} usedName usedName
+	 * @param {string} extraInfo extraInfo
+	 * @returns {string} extraInfo
+	 */
+	findNewName(oldName, usedName, extraInfo) {
+		let name = oldName;
+
+		// Remove uncool stuff
+		extraInfo = extraInfo.replace(
+			/\.+\/|(\/index)?\.([a-zA-Z0-9]{1,4})($|\s|\?)|\s*\+\s*\d+\s*modules/g,
+			""
+		);
+		const splittedInfo = extraInfo.split("/");
+		while (splittedInfo.length) {
+			name = splittedInfo.pop() + (name ? `_${name}` : "");
+			const nameIdent = Template.toIdentifier(name);
+			if (!usedName.has(nameIdent)) {
+				return nameIdent;
+			}
+		}
+
+		let i = 0;
+		let nameWithNumber = Template.toIdentifier(`${name}_${i}`);
+		while (usedName.has(nameWithNumber)) {
+			i++;
+			nameWithNumber = Template.toIdentifier(`${name}_${i}`);
+		}
+		return nameWithNumber;
+	}
 }
 
 module.exports = JavascriptModulesPlugin;