@depup/webpack 5.106.0-depup.0 → 5.109.0-depup.0

package/lib/javascript/JavascriptModulesPlugin.js

@@ -16,8 +16,7 @@ const {
 	RawSource,
 	ReplaceSource
 } = require("webpack-sources");
-const Compilation = require("../Compilation");
-const { tryRunOrWebpackError } = require("../HookWebpackError");
+/** @typedef {import("../Compilation")} Compilation */
 const HotUpdateChunk = require("../HotUpdateChunk");
 const InitFragment = require("../InitFragment");
 const { JAVASCRIPT_TYPE } = require("../ModuleSourceTypeConstants");
@@ -30,6 +29,7 @@ const {
 const NormalModule = require("../NormalModule");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
+const { tryRunOrWebpackError } = require("../errors/HookWebpackError");
 const { last, someInIterable } = require("../util/IterableHelpers");
 const StringXor = require("../util/StringXor");
 const { compareModulesByFullName } = require("../util/comparators");
@@ -42,16 +42,33 @@ const {
 	getUsedNamesInScopeInfo
 } = require("../util/concatenate");
 const createHash = require("../util/createHash");
-const nonNumericOnlyHash = require("../util/nonNumericOnlyHash");
+const createHooksRegistry = require("../util/createHooksRegistry");
+const { digestNonNumericOnlyWithFull } = require("../util/nonNumericOnlyHash");
 const removeBOM = require("../util/removeBOM");
 const { intersectRuntime } = require("../util/runtime");
+const { getAllChunks } = require("./ChunkHelpers");
 const JavascriptGenerator = require("./JavascriptGenerator");
+const JavascriptModule = require("./JavascriptModule");
 const JavascriptParser = require("./JavascriptParser");
 
-/** @typedef {import("eslint-scope").Reference} Reference */
-/** @typedef {import("eslint-scope").Scope} Scope */
-/** @typedef {import("eslint-scope").Variable} Variable */
 /** @typedef {import("estree").Program} Program */
+/** @typedef {import("estree").Node} Node */
+/** @typedef {import("estree").Identifier} Identifier */
+/** @typedef {import("estree").CatchClause} CatchClause */
+/** @typedef {import("estree").ClassDeclaration} ClassDeclaration */
+/** @typedef {import("estree").ClassExpression} ClassExpression */
+/** @typedef {import("estree").FunctionDeclaration} FunctionDeclaration */
+/** @typedef {import("estree").FunctionExpression} FunctionExpression */
+/** @typedef {import("estree").ArrowFunctionExpression} ArrowFunctionExpression */
+/** @typedef {import("estree").VariableDeclarator} VariableDeclarator */
+/** @typedef {import("estree").VariableDeclaration} VariableDeclaration */
+/** @typedef {import("estree").ImportDeclaration} ImportDeclaration */
+/** @typedef {import("estree").ImportSpecifier} ImportSpecifier */
+/** @typedef {import("estree").ImportDefaultSpecifier} ImportDefaultSpecifier */
+/** @typedef {import("estree").ImportNamespaceSpecifier} ImportNamespaceSpecifier */
+/** @typedef {import("estree").AssignmentExpression} AssignmentExpression */
+/** @typedef {import("estree").ForInStatement} ForInStatement */
+/** @typedef {import("estree").ForOfStatement} ForOfStatement */
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../config/defaults").OutputNormalizedWithDefaults} OutputOptions */
 /** @typedef {import("../Chunk")} Chunk */
@@ -69,17 +86,73 @@ const JavascriptParser = require("./JavascriptParser");
 /** @typedef {import("../Module").CodeGenerationResultData} CodeGenerationResultData */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
-/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../Chunk").ChunkFilenameTemplate} ChunkFilenameTemplate */
+/** @typedef {import("../errors/WebpackError")} WebpackError */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/concatenate").ScopeSet} ScopeSet */
 /** @typedef {import("../util/concatenate").UsedNamesInScopeInfo} UsedNamesInScopeInfo */
 
+// TODO remove these types when we will update `eslint-scope` to the latest version and import them from `eslint-scope`
+/**
+ * @typedef {object} Scope
+ * @property {"block" | "catch" | "class" | "class-field-initializer" | "class-static-block" | "for" | "function" | "function-expression-name" | "global" | "module" | "switch" | "with" | "TDZ"} type
+ * @property {boolean} isStrict
+ * @property {Scope | null} upper
+ * @property {Scope[]} childScopes
+ * @property {Scope} variableScope
+ * @property {Node} block
+ * @property {Variable[]} variables
+ * @property {Map<string, Variable>} set
+ * @property {Reference[]} references
+ * @property {Reference[]} through
+ * @property {boolean} functionExpressionScope
+ * @property {{ variables: Variable[], set: Map<string, Variable> }=} implicit
+ */
+
+/**
+ * @typedef {
+ * | { type: "CatchClause", node: CatchClause, parent: null }
+ * | { type: "ClassName", node: ClassDeclaration | ClassExpression, parent: null }
+ * | { type: "FunctionName", node: FunctionDeclaration | FunctionExpression, parent: null }
+ * | { type: "ImplicitGlobalVariable", node: AssignmentExpression | ForInStatement | ForOfStatement, parent: null }
+ * | { type: "ImportBinding", node: ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier, parent: ImportDeclaration }
+ * | { type: "Parameter", node: FunctionDeclaration | FunctionExpression | ArrowFunctionExpression, parent: null }
+ * | { type: "TDZ", node: any, parent: null }
+ * | { type: "Variable", node: VariableDeclarator, parent: VariableDeclaration }
+ * } DefinitionType
+ */
+
+/** @typedef {DefinitionType & { name: Identifier }} Definition */
+
+/**
+ * @typedef {object} Variable
+ * @property {string} name
+ * @property {Scope} scope
+ * @property {Identifier[]} identifiers
+ * @property {Reference[]} references
+ * @property {Definition[]} defs
+ */
+
+/**
+ * @typedef {object} Reference
+ * @property {Identifier} identifier
+ * @property {Scope} from
+ * @property {Variable | null} resolved
+ * @property {Node | null} writeExpr
+ * @property {boolean} init
+ * @property {() => boolean} isWrite
+ * @property {() => boolean} isRead
+ * @property {() => boolean} isWriteOnly
+ * @property {() => boolean} isReadOnly
+ * @property {() => boolean} isReadWrite
+ */
+
 /** @type {WeakMap<ChunkGraph, WeakMap<Chunk, boolean>>} */
 const chunkHasJsCache = new WeakMap();
 
 /**
+ * Returns true, when a JS file is needed for this chunk.
  * @param {Chunk} chunk a chunk
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @returns {boolean} true, when a JS file is needed for this chunk
@@ -99,6 +172,7 @@ const _chunkHasJs = (chunk, chunkGraph) => {
 };
 
 /**
+ * Returns true, when a JS file is needed for this chunk.
  * @param {Chunk} chunk a chunk
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @returns {boolean} true, when a JS file is needed for this chunk
@@ -121,6 +195,7 @@ const chunkHasJs = (chunk, chunkGraph) => {
 };
 
 /**
+ * Chunk has runtime or js.
  * @param {Chunk} chunk a chunk
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @returns {boolean} true, when a JS file is needed for this chunk
@@ -148,6 +223,7 @@ const chunkHasRuntimeOrJs = (chunk, chunkGraph) => {
 };
 
 /**
+ * Print generated code for stack.
  * @param {Module} module a module
  * @param {string} code the code
  * @returns {string} generated code for the stack
@@ -158,6 +234,7 @@ const printGeneratedCodeForStack = (module, code) => {
 	return `\n\nGenerated code for ${module.identifier()}\n${lines
 		.map(
 			/**
+			 * Handles the callback logic for this hook.
 			 * @param {string} line the line
 			 * @param {number} i the index
 			 * @param {string[]} _lines the lines
@@ -172,6 +249,7 @@ const printGeneratedCodeForStack = (module, code) => {
 };
 
 /**
+ * Defines the render context type used by this module.
  * @typedef {object} RenderContext
  * @property {Chunk} chunk the chunk
  * @property {DependencyTemplates} dependencyTemplates the dependency templates
@@ -183,6 +261,7 @@ const printGeneratedCodeForStack = (module, code) => {
  */
 
 /**
+ * Defines the main render context type used by this module.
  * @typedef {object} MainRenderContext
  * @property {Chunk} chunk the chunk
  * @property {DependencyTemplates} dependencyTemplates the dependency templates
@@ -195,6 +274,7 @@ const printGeneratedCodeForStack = (module, code) => {
  */
 
 /**
+ * Defines the chunk render context type used by this module.
  * @typedef {object} ChunkRenderContext
  * @property {Chunk} chunk the chunk
  * @property {DependencyTemplates} dependencyTemplates the dependency templates
@@ -204,9 +284,12 @@ const printGeneratedCodeForStack = (module, code) => {
  * @property {CodeGenerationResults} codeGenerationResults results of code generation
  * @property {InitFragment<ChunkRenderContext>[]} chunkInitFragments init fragments for the chunk
  * @property {boolean | undefined} strictMode rendering in strict context
+ * @property {Module=} inlinedEntryModule entry module inlined at the chunk top level instead of the registry
+ * @property {Source=} inlinedEntrySource rendered body of the inlined entry module
  */
 
 /**
+ * Defines the render bootstrap context type used by this module.
  * @typedef {object} RenderBootstrapContext
  * @property {Chunk} chunk the chunk
  * @property {CodeGenerationResults} codeGenerationResults results of code generation
@@ -217,6 +300,7 @@ const printGeneratedCodeForStack = (module, code) => {
  */
 
 /**
+ * Defines the startup render context type used by this module.
  * @typedef {object} StartupRenderContext
  * @property {Chunk} chunk the chunk
  * @property {DependencyTemplates} dependencyTemplates the dependency templates
@@ -231,6 +315,7 @@ const printGeneratedCodeForStack = (module, code) => {
  */
 
 /**
+ * Defines the module render context type used by this module.
  * @typedef {object} ModuleRenderContext
  * @property {Chunk} chunk the chunk
  * @property {DependencyTemplates} dependencyTemplates the dependency templates
@@ -246,6 +331,7 @@ const printGeneratedCodeForStack = (module, code) => {
  */
 
 /**
+ * Defines the compilation hooks type used by this module.
  * @typedef {object} CompilationHooks
  * @property {SyncWaterfallHook<[Source, Module, ModuleRenderContext]>} renderModuleContent
  * @property {SyncWaterfallHook<[Source, Module, ModuleRenderContext]>} renderModuleContainer
@@ -263,63 +349,80 @@ const printGeneratedCodeForStack = (module, code) => {
  * @property {SyncBailHook<[Chunk, RenderContext], boolean | void>} useSourceMap
  */
 
-/** @type {WeakMap<Compilation, CompilationHooks>} */
-const compilationHooksMap = new WeakMap();
+/**
+ * Renames an inlined module's top-level declaration (and all its references) when
+ * its name is already taken in the shared startup scope, recording the chosen name
+ * in `allUsedNames`. Lets inlined modules be emitted without a per-entry/per-chunk
+ * IIFE by resolving name collisions instead of isolating each module.
+ * @param {InstanceType<typeof import("webpack-sources").ReplaceSource>} source the module source to edit
+ * @param {Program} ast the parsed module AST
+ * @param {Variable} variable the top-level variable to check/rename
+ * @param {string} moduleIdentifier the module identifier (for scope caching)
+ * @param {string} readableIdentifier the readable module identifier (for new names)
+ * @param {Set<string>} allUsedNames names already used in the shared scope (mutated)
+ * @returns {void}
+ */
+const renameInlinedModuleVariable = (
+	source,
+	ast,
+	variable,
+	moduleIdentifier,
+	readableIdentifier,
+	allUsedNames
+) => {
+	/** @type {UsedNamesInScopeInfo} */
+	const usedNamesInScopeInfo = new Map();
+	/** @type {ScopeSet} */
+	const ignoredScopes = new Set();
+
+	const name = variable.name;
+	const { usedNames, alreadyCheckedScopes } = getUsedNamesInScopeInfo(
+		usedNamesInScopeInfo,
+		moduleIdentifier,
+		name
+	);
+
+	if (allUsedNames.has(name) || usedNames.has(name)) {
+		const references = getAllReferences(variable);
+		const allIdentifiers = new Set([
+			...references.map((r) => r.identifier),
+			...variable.identifiers
+		]);
+		for (const ref of references) {
+			addScopeSymbols(ref.from, usedNames, alreadyCheckedScopes, ignoredScopes);
+		}
+
+		const newName = findNewName(
+			name,
+			allUsedNames,
+			usedNames,
+			readableIdentifier
+		);
+		allUsedNames.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);
+		}
+	}
+	allUsedNames.add(name);
+};
 
 const PLUGIN_NAME = "JavascriptModulesPlugin";
 
 /** @typedef {{ header: string[], beforeStartup: string[], startup: string[], afterStartup: string[], allowInlineStartup: boolean }} Bootstrap */
 
 class JavascriptModulesPlugin {
-	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {CompilationHooks} the attached hooks
-	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
-		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				renderModuleContent: new SyncWaterfallHook([
-					"source",
-					"module",
-					"moduleRenderContext"
-				]),
-				renderModuleContainer: new SyncWaterfallHook([
-					"source",
-					"module",
-					"moduleRenderContext"
-				]),
-				renderModulePackage: new SyncWaterfallHook([
-					"source",
-					"module",
-					"moduleRenderContext"
-				]),
-				render: new SyncWaterfallHook(["source", "renderContext"]),
-				renderContent: new SyncWaterfallHook(["source", "renderContext"]),
-				renderStartup: new SyncWaterfallHook([
-					"source",
-					"module",
-					"startupRenderContext"
-				]),
-				renderChunk: new SyncWaterfallHook(["source", "renderContext"]),
-				renderMain: new SyncWaterfallHook(["source", "renderContext"]),
-				renderRequire: new SyncWaterfallHook(["code", "renderContext"]),
-				inlineInRuntimeBailout: new SyncBailHook(["module", "renderContext"]),
-				embedInRuntimeBailout: new SyncBailHook(["module", "renderContext"]),
-				strictRuntimeBailout: new SyncBailHook(["renderContext"]),
-				chunkHash: new SyncHook(["chunk", "hash", "context"]),
-				useSourceMap: new SyncBailHook(["chunk", "renderContext"])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
-	}
-
 	constructor(options = {}) {
 		this.options = options;
 		/** @type {WeakMap<Source, { source: Source, needModule: boolean, needExports: boolean, needRequire: boolean, needThisAsExports: boolean, needStrict: boolean | undefined, renderShorthand: boolean }>} */
@@ -327,7 +430,7 @@ class JavascriptModulesPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -342,21 +445,44 @@ class JavascriptModulesPlugin {
 					JAVASCRIPT_MODULE_TYPE_DYNAMIC,
 					JAVASCRIPT_MODULE_TYPE_ESM
 				]) {
+					normalModuleFactory.hooks.createModuleClass
+						.for(type)
+						.tap(
+							PLUGIN_NAME,
+							(createData, _resolveData) => new JavascriptModule(createData)
+						);
 					normalModuleFactory.hooks.createParser
 						.for(type)
 						.tap(PLUGIN_NAME, (options) => {
 							switch (type) {
 								case JAVASCRIPT_MODULE_TYPE_AUTO: {
-									return new JavascriptParser("auto", { parse: options.parse });
+									return new JavascriptParser("auto", {
+										parse: options.parse,
+										typescript: options.typescript,
+										importPhases: Boolean(
+											options.deferImport || options.sourceImport
+										),
+										strictModeViolations: options.strictModeViolations
+									});
 								}
 								case JAVASCRIPT_MODULE_TYPE_DYNAMIC: {
 									return new JavascriptParser("script", {
-										parse: options.parse
+										parse: options.parse,
+										typescript: options.typescript,
+										importPhases: Boolean(
+											options.deferImport || options.sourceImport
+										),
+										strictModeViolations: options.strictModeViolations
 									});
 								}
 								case JAVASCRIPT_MODULE_TYPE_ESM: {
 									return new JavascriptParser("module", {
-										parse: options.parse
+										parse: options.parse,
+										typescript: options.typescript,
+										importPhases: Boolean(
+											options.deferImport || options.sourceImport
+										),
+										strictModeViolations: options.strictModeViolations
 									});
 								}
 							}
@@ -554,11 +680,8 @@ class JavascriptModulesPlugin {
 						}
 						xor.updateHash(hash);
 					}
-					const digest = hash.digest(hashDigest);
-					chunk.contentHash.javascript = nonNumericOnlyHash(
-						digest,
-						hashDigestLength
-					);
+					[chunk.contentHash.javascript, chunk.contentHashFull.javascript] =
+						digestNonNumericOnlyWithFull(hash, hashDigest, hashDigestLength);
 				});
 				compilation.hooks.additionalTreeRuntimeRequirements.tap(
 					PLUGIN_NAME,
@@ -642,15 +765,22 @@ class JavascriptModulesPlugin {
 	}
 
 	/**
+	 * Gets chunk filename template.
 	 * @param {Chunk} chunk chunk
 	 * @param {OutputOptions} outputOptions output options
-	 * @returns {TemplatePath} used filename template
+	 * @returns {ChunkFilenameTemplate} used filename template
 	 */
 	static getChunkFilenameTemplate(chunk, outputOptions) {
 		if (chunk.filenameTemplate) {
 			return chunk.filenameTemplate;
 		} else if (chunk instanceof HotUpdateChunk) {
 			return outputOptions.hotUpdateChunkFilename;
+		}
+		const entryOptions = chunk.getEntryOptions();
+		// A worker entry (`new Worker` or `entry.worker`) uses workerChunkFilename;
+		// chunks it loads internally keep `chunkFilename`
+		if (entryOptions !== undefined && entryOptions.worker) {
+			return outputOptions.workerChunkFilename;
 		} else if (chunk.canBeInitial()) {
 			return outputOptions.filename;
 		}
@@ -658,6 +788,7 @@ class JavascriptModulesPlugin {
 	}
 
 	/**
+	 * Renders the newly generated source from rendering.
 	 * @param {Module} module the rendered module
 	 * @param {ModuleRenderContext} renderContext options object
 	 * @param {CompilationHooks} hooks hooks
@@ -797,6 +928,7 @@ class JavascriptModulesPlugin {
 	}
 
 	/**
+	 * Renders the rendered source.
 	 * @param {RenderContext} renderContext the render context
 	 * @param {CompilationHooks} hooks hooks
 	 * @returns {Source} the rendered source
@@ -828,10 +960,30 @@ class JavascriptModulesPlugin {
 			chunkInitFragments: [],
 			strictMode: allStrict
 		};
+		// ESM entry chunk whose runtime lives in a separate chunk: inline the
+		// single entry module at the top level (instead of the module registry)
+		// so its own top-level declarations stay live ESM bindings for consumers.
+		const inlinedEntryModule = this._getEsmEntryModuleToInline(
+			renderContext,
+			allModules
+		);
+		let registryModules = allModules;
+		if (inlinedEntryModule) {
+			const inlinedEntrySource = this.renderModule(
+				inlinedEntryModule,
+				{ ...chunkRenderContext, factory: false },
+				hooks
+			);
+			if (inlinedEntrySource) {
+				registryModules = allModules.filter((m) => m !== inlinedEntryModule);
+				chunkRenderContext.inlinedEntryModule = inlinedEntryModule;
+				chunkRenderContext.inlinedEntrySource = inlinedEntrySource;
+			}
+		}
 		const moduleSources =
 			Template.renderChunkModules(
 				chunkRenderContext,
-				allModules,
+				registryModules,
 				(module, renderInObject) =>
 					this.renderModule(
 						module,
@@ -875,6 +1027,93 @@ class JavascriptModulesPlugin {
 	}
 
 	/**
+	 * Returns the chunk's single entry module when it can be inlined at the top
+	 * level of an ESM output chunk (instead of the module registry), which keeps
+	 * its exports as live ESM bindings. Only a self-contained ESM entry whose
+	 * top-level declarations can be lifted into the chunk scope qualifies;
+	 * otherwise `undefined` is returned and the registry path is used.
+	 * @param {RenderContext} renderContext render context
+	 * @param {Module[]} allModules all javascript modules of the chunk
+	 * @returns {Module | undefined} the entry module to inline, if any
+	 */
+	_getEsmEntryModuleToInline(renderContext, allModules) {
+		const {
+			chunk,
+			chunkGraph,
+			moduleGraph,
+			runtimeTemplate,
+			codeGenerationResults
+		} = renderContext;
+
+		// Only a single ESM entry whose runtime lives in a separate chunk.
+		if (
+			!runtimeTemplate.isModule() ||
+			chunk.hasRuntime() ||
+			chunkGraph.getNumberOfEntryModules(chunk) !== 1
+		) {
+			return undefined;
+		}
+		const [entryEntry] =
+			chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk);
+		const [entryModule, entrypoint] = /** @type {[Module, Entrypoint]} */ (
+			entryEntry
+		);
+
+		// Module-local safety: the body is lifted verbatim, so it must use the
+		// standard exports binding (not `module`/`this`) and expose top-level
+		// declarations whose names can't collide with runtime/startup identifiers.
+		const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(
+			entryModule,
+			chunk.runtime
+		);
+		if (
+			entryModule.exportsArgument !== RuntimeGlobals.exports ||
+			runtimeRequirements.has(RuntimeGlobals.module) ||
+			runtimeRequirements.has(RuntimeGlobals.thisAsExports)
+		) {
+			return undefined;
+		}
+		const topLevelDeclarations =
+			codeGenerationResults.getData(
+				entryModule,
+				chunk.runtime,
+				"topLevelDeclarations"
+			) ||
+			(entryModule.buildInfo && entryModule.buildInfo.topLevelDeclarations);
+		if (!topLevelDeclarations || topLevelDeclarations.size === 0) {
+			return undefined;
+		}
+		for (const name of topLevelDeclarations) {
+			if (RESERVED_NAMES.has(name) || name.startsWith("__webpack_")) {
+				return undefined;
+			}
+		}
+
+		// Self-contained: the entry must not be imported by another module (which
+		// needs it in the registry), and must not require other chunks or
+		// `dependOn` parents to execute first.
+		if (
+			entrypoint.getParents().length > 0 ||
+			getAllChunks(entrypoint, chunk, entrypoint.getRuntimeChunk()).size > 0
+		) {
+			return undefined;
+		}
+		const referenced = someInIterable(
+			moduleGraph.getIncomingConnectionsByOriginModule(entryModule),
+			([originModule, connections]) =>
+				originModule &&
+				originModule !== entryModule &&
+				connections.some((c) => c.isTargetActive(chunk.runtime)) &&
+				someInIterable(
+					chunkGraph.getModuleRuntimes(originModule),
+					(runtime) => intersectRuntime(runtime, chunk.runtime) !== undefined
+				)
+		);
+		return referenced ? undefined : entryModule;
+	}
+
+	/**
+	 * Renders the newly generated source from rendering.
 	 * @param {MainRenderContext} renderContext options object
 	 * @param {CompilationHooks} hooks hooks
 	 * @param {Compilation} compilation the compilation
@@ -926,9 +1165,7 @@ class JavascriptModulesPlugin {
 			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;
@@ -1052,10 +1289,8 @@ class JavascriptModulesPlugin {
 
 				const iife = innerStrict
 					? "it needs 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 needs to be isolated against other entry modules."
+					: inlinedModules.size > 1 && !renamedInlinedModule
+						? "it needs to be isolated against other entry modules."
 						: chunkModules && !renamedInlinedModule
 							? "it needs to be isolated against other modules in the chunk."
 							: exports && !webpackExports
@@ -1099,10 +1334,14 @@ class JavascriptModulesPlugin {
 					}
 					if (exports) {
 						if (m !== lastInlinedModule) {
-							startupSource.add(`var ${m.exportsArgument} = {};\n`);
+							startupSource.add(
+								`${runtimeTemplate.renderLet()} ${m.exportsArgument} = {};\n`
+							);
 						} else if (m.exportsArgument !== RuntimeGlobals.exports) {
 							startupSource.add(
-								`var ${m.exportsArgument} = ${RuntimeGlobals.exports};\n`
+								`${runtimeTemplate.renderLet()} ${m.exportsArgument} = ${
+									RuntimeGlobals.exports
+								};\n`
 							);
 						}
 					}
@@ -1145,7 +1384,7 @@ class JavascriptModulesPlugin {
 			}
 			if (startupRenderContext.needExportsDeclaration) {
 				renderedStartup = new ConcatSource(
-					`var ${RuntimeGlobals.exports} = {};\n`,
+					`${runtimeTemplate.renderLet()} ${RuntimeGlobals.exports} = {};\n`,
 					renderedStartup
 				);
 			}
@@ -1240,6 +1479,7 @@ class JavascriptModulesPlugin {
 	}
 
 	/**
+	 * Updates hash with bootstrap.
 	 * @param {Hash} hash the hash to be updated
 	 * @param {RenderBootstrapContext} renderContext options object
 	 * @param {CompilationHooks} hooks hooks
@@ -1260,6 +1500,7 @@ class JavascriptModulesPlugin {
 	}
 
 	/**
+	 * Renders the generated source of the bootstrap code.
 	 * @param {RenderBootstrapContext} renderContext options object
 	 * @param {CompilationHooks} hooks hooks
 	 * @returns {Bootstrap} the generated source of the bootstrap code
@@ -1321,9 +1562,10 @@ class JavascriptModulesPlugin {
 			result.allowInlineStartup = false;
 		}
 
+		const bootstrapCst = runtimeTemplate.renderConst();
 		if (useRequire || moduleCache) {
 			buf.push("// The module cache");
-			buf.push("var __webpack_module_cache__ = {};");
+			buf.push(`${bootstrapCst} __webpack_module_cache__ = {};`);
 			buf.push("");
 		}
 
@@ -1333,7 +1575,16 @@ class JavascriptModulesPlugin {
 			// This requires all deferred imports to a module can get the module export object before the module
 			// is evaluated.
 			buf.push("// The deferred module cache");
-			buf.push("var __webpack_module_deferred_exports__ = {};");
+			buf.push(`${bootstrapCst} __webpack_module_deferred_exports__ = {};`);
+			// Per the TC39 import-defer spec, every defer-import call site for
+			// the same module must yield the same Deferred Module Namespace
+			// Exotic Object (and a distinct one from any eager namespace).
+			// Cache the deferred namespace proxy here so calls from different
+			// files share identity.
+			buf.push("// The deferred namespace cache");
+			buf.push(
+				`${bootstrapCst} __webpack_module_deferred_namespace_cache__ = {};`
+			);
 			buf.push("");
 		}
 
@@ -1345,7 +1596,7 @@ class JavascriptModulesPlugin {
 			buf.push("");
 		} else if (runtimeRequirements.has(RuntimeGlobals.requireScope)) {
 			buf.push("// The require scope");
-			buf.push(`var ${RuntimeGlobals.require} = {};`);
+			buf.push(`${bootstrapCst} ${RuntimeGlobals.require} = {};`);
 			buf.push("");
 		}
 
@@ -1481,9 +1732,17 @@ class JavascriptModulesPlugin {
 						result.allowInlineStartup = false;
 					}
 
+					// `__webpack_exports__` may be reassigned later — by the
+					// `onChunksLoaded` wrapper below, by an inlined entry
+					// module that uses top-level `await` (the emitted
+					// bridge reassigns `__webpack_exports__` to the awaited
+					// value), or by other downstream codegen. Always declare
+					// with `let` (or `var` if `let` is unsupported) so
+					// reassignment is allowed.
+					const exportsDecl = runtimeTemplate.renderLet();
 					if (chunks.length > 0) {
 						buf2.push(
-							`${i === 0 ? `var ${RuntimeGlobals.exports} = ` : ""}${
+							`${i === 0 ? `${exportsDecl} ${RuntimeGlobals.exports} = ` : ""}${
 								RuntimeGlobals.onChunksLoaded
 							}(undefined, ${JSON.stringify(
 								chunks.map((c) => c.id)
@@ -1493,12 +1752,14 @@ class JavascriptModulesPlugin {
 						);
 					} else if (useRequire) {
 						buf2.push(
-							`${i === 0 ? `var ${RuntimeGlobals.exports} = ` : ""}${
+							`${i === 0 ? `${exportsDecl} ${RuntimeGlobals.exports} = ` : ""}${
 								RuntimeGlobals.require
 							}(${moduleIdExpr});`
 						);
 					} else {
-						if (i === 0) buf2.push(`var ${RuntimeGlobals.exports} = {};`);
+						if (i === 0) {
+							buf2.push(`${exportsDecl} ${RuntimeGlobals.exports} = {};`);
+						}
 						const needThisAsExports = entryRuntimeRequirements.has(
 							RuntimeGlobals.thisAsExports
 						);
@@ -1520,9 +1781,13 @@ class JavascriptModulesPlugin {
 								(() => {
 									if (needThisAsExports) {
 										const comma = args.length ? "," : "";
-										return `__webpack_modules__[${moduleIdExpr}].call(${RuntimeGlobals.exports}${comma}${args.join(",")});`;
+										return `__webpack_modules__[${moduleIdExpr}].call(${
+											RuntimeGlobals.exports
+										}${comma}${args.join(",")});`;
 									}
-									return `__webpack_modules__[${moduleIdExpr}](${args.join(",")});`;
+									return `__webpack_modules__[${moduleIdExpr}](${args.join(
+										","
+									)});`;
 								})()
 							)
 						);
@@ -1605,29 +1870,30 @@ class JavascriptModulesPlugin {
 	}
 
 	/**
+	 * Renders the generated source of the require function.
 	 * @param {RenderBootstrapContext} renderContext options object
 	 * @param {CompilationHooks} hooks hooks
 	 * @returns {string} the generated source of the require function
 	 */
 	renderRequire(renderContext, hooks) {
-		const {
-			chunk,
-			chunkGraph,
-			runtimeTemplate: { outputOptions }
-		} = renderContext;
+		const { chunk, chunkGraph, runtimeTemplate } = renderContext;
+		const { outputOptions } = runtimeTemplate;
+		const cst = runtimeTemplate.renderConst();
+		const lt = runtimeTemplate.renderLet();
 		const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
 
 		/**
+		 * Renders missing module error.
 		 * @param {string} condition guard expression
 		 * @returns {string[]} source
 		 */
 		const renderMissingModuleError = (condition) =>
-			outputOptions.pathinfo
+			outputOptions.strictModuleResolution
 				? [
 						`if (${condition}) {`,
 						Template.indent([
 							"delete __webpack_module_cache__[moduleId];",
-							'var e = new Error("Cannot find module \'" + moduleId + "\'");',
+							`${cst} e = new Error("Cannot find module '" + moduleId + "'");`,
 							"e.code = 'MODULE_NOT_FOUND';",
 							"throw e;"
 						]),
@@ -1639,7 +1905,7 @@ class JavascriptModulesPlugin {
 			RuntimeGlobals.interceptModuleExecution
 		)
 			? Template.asString([
-					`var execOptions = { id: moduleId, module: module, factory: __webpack_modules__[moduleId], require: ${RuntimeGlobals.require} };`,
+					`${cst} execOptions = { id: moduleId, module: module, factory: __webpack_modules__[moduleId], require: ${RuntimeGlobals.require} };`,
 					`${RuntimeGlobals.interceptModuleExecution}.forEach(function(handler) { handler(execOptions); });`,
 					...renderMissingModuleError("!execOptions.factory"),
 					"module = execOptions.module;",
@@ -1661,11 +1927,29 @@ class JavascriptModulesPlugin {
 		const needModuleDefer = runtimeRequirements.has(
 			RuntimeGlobals.makeDeferredNamespaceObject
 		);
+		// Both deferred-namespace runtimes re-invoke `__webpack_require__` on
+		// access, so a module's evaluation error must be retained and re-thrown
+		// (a Cyclic Module Record's [[EvaluationError]]); the optimized variant
+		// does not use `__webpack_module_deferred_exports__`, so it is tracked
+		// separately from `needModuleDefer`.
+		const needModuleDeferAny =
+			needModuleDefer ||
+			runtimeRequirements.has(
+				RuntimeGlobals.makeOptimizedDeferredNamespaceObject
+			);
+		const needModuleErrorCaching =
+			outputOptions.strictModuleErrorHandling || needModuleDeferAny;
+		// `module` is reassigned by the interceptModuleExecution path; use `let`.
+		const moduleDecl = runtimeRequirements.has(
+			RuntimeGlobals.interceptModuleExecution
+		)
+			? lt
+			: cst;
 		const content = Template.asString([
 			"// Check if module is in cache",
-			"var cachedModule = __webpack_module_cache__[moduleId];",
+			`${cst} cachedModule = __webpack_module_cache__[moduleId];`,
 			"if (cachedModule !== undefined) {",
-			outputOptions.strictModuleErrorHandling
+			needModuleErrorCaching
 				? Template.indent([
 						"if (cachedModule.error !== undefined) throw cachedModule.error;",
 						"return cachedModule.exports;"
@@ -1673,7 +1957,7 @@ class JavascriptModulesPlugin {
 				: Template.indent("return cachedModule.exports;"),
 			"}",
 			"// Create a new module (and put it into the cache)",
-			"var module = __webpack_module_cache__[moduleId] = {",
+			`${moduleDecl} module = __webpack_module_cache__[moduleId] = {`,
 			Template.indent([
 				needModuleId ? "id: moduleId," : "// no module.id needed",
 				needModuleLoaded ? "loaded: false," : "// no module.loaded needed",
@@ -1683,10 +1967,10 @@ class JavascriptModulesPlugin {
 			]),
 			"};",
 			"",
-			outputOptions.strictModuleExceptionHandling
+			outputOptions.strictModuleExceptionHandling && !needModuleErrorCaching
 				? Template.asString([
 						"// Execute the module function",
-						"var threw = true;",
+						`${lt} threw = true;`,
 						"try {",
 						Template.indent([
 							moduleExecution,
@@ -1701,20 +1985,27 @@ class JavascriptModulesPlugin {
 						]),
 						"}"
 					])
-				: outputOptions.strictModuleErrorHandling
+				: needModuleErrorCaching
 					? Template.asString([
 							"// Execute the module function",
+							// Mark the module as evaluating so a deferred namespace that
+							// forces evaluation of an already-evaluating module can throw
+							// instead of exposing its partial exports.
+							...(needModuleDeferAny ? ["module.evaluating = true;"] : []),
 							"try {",
-							Template.indent(
-								needModuleDefer
-									? [
-											moduleExecution,
-											"delete __webpack_module_deferred_exports__[moduleId];"
-										]
-									: moduleExecution
-							),
+							Template.indent([
+								moduleExecution,
+								...(needModuleDefer
+									? ["delete __webpack_module_deferred_exports__[moduleId];"]
+									: []),
+								...(needModuleDeferAny ? ["module.evaluating = false;"] : [])
+							]),
 							"} catch(e) {",
-							Template.indent(["module.error = e;", "throw e;"]),
+							Template.indent([
+								...(needModuleDeferAny ? ["module.evaluating = false;"] : []),
+								"module.error = e;",
+								"throw e;"
+							]),
 							"}"
 						])
 					: Template.asString([
@@ -1742,6 +2033,7 @@ class JavascriptModulesPlugin {
 	}
 
 	/**
+	 * Get renamed inline module.
 	 * @param {Compilation} compilation compilation
 	 * @param {Module[]} allModules allModules
 	 * @param {MainRenderContext} renderContext renderContext
@@ -1767,11 +2059,11 @@ class JavascriptModulesPlugin {
 			allModules.every((m) => /** @type {BuildInfo} */ (m.buildInfo).strict);
 		const isMultipleEntries = inlinedModules.size > 1;
 		const singleEntryWithModules = inlinedModules.size === 1 && hasChunkModules;
-		// TODO:
-		// This step is before the IIFE reason calculation. Ideally, it should only be executed when this function can optimize the
-		// IIFE reason. Otherwise, it should directly return false. There are four reasons now, we have skipped two already, the left
-		// one is 'it uses a non-standard name for the exports'.
-		if (isMultipleEntries || innerStrict || !singleEntryWithModules) {
+		// This step is before the IIFE reason calculation; it only runs for the
+		// cases whose IIFE reason it can remove: multiple inlined entry modules, or a
+		// single inlined entry alongside other chunk modules. The remaining reason
+		// ('it uses a non-standard name for the exports') is not handled here.
+		if (innerStrict || (!isMultipleEntries && !singleEntryWithModules)) {
 			return false;
 		}
 
@@ -1784,6 +2076,8 @@ class JavascriptModulesPlugin {
 		const inlinedModulesToInfo = new Map();
 		/** @type {Set<string>} */
 		const nonInlinedModuleThroughIdentifiers = new Set();
+		/** @type {Map<Module, Source>} */
+		const inlinedModuleSources = new Map();
 
 		for (const m of allModules) {
 			const isInlinedModule = inlinedModules && inlinedModules.has(m);
@@ -1798,13 +2092,24 @@ class JavascriptModulesPlugin {
 			);
 
 			if (!moduleSource) continue;
+			if (isInlinedModule) {
+				// Parsing the inlined entry (often the whole concatenated app) is
+				// expensive; defer it until we know renaming is actually needed.
+				inlinedModuleSources.set(m, moduleSource);
+				continue;
+			}
 			const code = /** @type {string} */ (moduleSource.source());
 
+			const { experiments } = compilation.options;
 			const { ast } = JavascriptParser._parse(
 				code,
 				{
 					sourceType: "auto",
-					ranges: true
+					ranges: true,
+					// generated code contains phase imports when the experiments are on
+					importPhases: Boolean(
+						experiments.deferImport || experiments.sourceImport
+					)
 				},
 				JavascriptParser._getModuleParseFunction(compilation, m)
 			);
@@ -1817,22 +2122,93 @@ class JavascriptModulesPlugin {
 			});
 
 			const globalScope = /** @type {Scope} */ (scopeManager.acquire(ast));
-			if (inlinedModules && inlinedModules.has(m)) {
-				const moduleScope = globalScope.childScopes[0];
-				inlinedModulesToInfo.set(m, {
-					source: moduleSource,
-					ast,
-					module: m,
-					variables: new Set(moduleScope.variables),
-					through: new Set(moduleScope.through),
-					usedInNonInlined: new Set(),
-					moduleScope
-				});
-			} else {
-				for (const ref of globalScope.through) {
-					nonInlinedModuleThroughIdentifiers.add(ref.identifier.name);
+			for (const ref of globalScope.through) {
+				nonInlinedModuleThroughIdentifiers.add(ref.identifier.name);
+			}
+		}
+
+		// Fast path: codegen reports each inlined entry's rendered top-level
+		// declarations and free names (post-concatenation), so when no declaration
+		// collides with a free name of any other module, another entry's
+		// declarations, or a reserved name, no renaming is needed and the entries
+		// don't have to be parsed at all.
+		fastPath: {
+			const { codeGenerationResults, chunk } = renderContext;
+			/** @type {Set<string>} */
+			const usedNames = new Set(nonInlinedModuleThroughIdentifiers);
+			for (const name of RESERVED_NAMES) usedNames.add(name);
+			/** @type {Set<string>[]} */
+			const declarationsList = [];
+			for (const m of inlinedModuleSources.keys()) {
+				if (!codeGenerationResults.has(m, chunk.runtime)) break fastPath;
+				const result = codeGenerationResults.get(m, chunk.runtime);
+				const data = result.data;
+				if (!data) break fastPath;
+				const declarations = data.get("topLevelDeclarations");
+				if (!declarations) break fastPath;
+				declarationsList.push(declarations);
+				if (!isMultipleEntries) continue;
+				// Entries share the startup scope: an entry's free names and runtime
+				// globals must not be shadowed by another entry's declarations.
+				const freeNames = data.get("freeNames");
+				if (!freeNames) break fastPath;
+				for (const name of freeNames) usedNames.add(name);
+				if (result.runtimeRequirements) {
+					for (const req of result.runtimeRequirements) {
+						const dot = req.indexOf(".");
+						usedNames.add(dot === -1 ? req : req.slice(0, dot));
+					}
 				}
 			}
+			for (const declarations of declarationsList) {
+				for (const name of declarations) {
+					if (usedNames.has(name)) break fastPath;
+				}
+				// earlier entries' declarations join the used set so later entries
+				// are checked against them
+				for (const name of declarations) usedNames.add(name);
+			}
+			for (const [m, moduleSource] of inlinedModuleSources) {
+				renamedInlinedModules.set(m, moduleSource);
+			}
+			return renamedInlinedModules;
+		}
+
+		for (const [m, moduleSource] of inlinedModuleSources) {
+			const code = /** @type {string} */ (moduleSource.source());
+
+			const { experiments } = compilation.options;
+			const { ast } = JavascriptParser._parse(
+				code,
+				{
+					sourceType: "auto",
+					ranges: true,
+					// generated code contains phase imports when the experiments are on
+					importPhases: Boolean(
+						experiments.deferImport || experiments.sourceImport
+					)
+				},
+				JavascriptParser._getModuleParseFunction(compilation, m)
+			);
+
+			const scopeManager = eslintScope.analyze(ast, {
+				ecmaVersion: 6,
+				sourceType: "module",
+				optimistic: true,
+				ignoreEval: true
+			});
+
+			const globalScope = /** @type {Scope} */ (scopeManager.acquire(ast));
+			const moduleScope = globalScope.childScopes[0];
+			inlinedModulesToInfo.set(m, {
+				source: moduleSource,
+				ast,
+				module: m,
+				variables: new Set(moduleScope.variables),
+				through: new Set(moduleScope.through),
+				usedInNonInlined: new Set(),
+				moduleScope
+			});
 		}
 
 		for (const [, { variables, usedInNonInlined }] of inlinedModulesToInfo) {
@@ -1846,6 +2222,36 @@ class JavascriptModulesPlugin {
 			}
 		}
 
+		// Multiple inlined entry modules share the chunk's startup scope. Rename any
+		// top-level declaration that would collide with another inlined module's
+		// declaration, with any inlined or non-inlined module's free (global)
+		// reference, or with a reserved name, so the modules can be emitted without a
+		// per-entry IIFE.
+		if (isMultipleEntries) {
+			/** @type {Set<string>} */
+			const allUsedNames = new Set(nonInlinedModuleThroughIdentifiers);
+			for (const name of RESERVED_NAMES) allUsedNames.add(name);
+			for (const { through } of inlinedModulesToInfo.values()) {
+				for (const ref of through) allUsedNames.add(ref.identifier.name);
+			}
+			for (const [m, moduleInfo] of inlinedModulesToInfo) {
+				const { ast, source: _source } = moduleInfo;
+				const source = new ReplaceSource(_source);
+				for (const variable of moduleInfo.variables) {
+					renameInlinedModuleVariable(
+						source,
+						ast,
+						variable,
+						moduleInfo.module.identifier(),
+						m.readableIdentifier(runtimeTemplate.requestShortener),
+						allUsedNames
+					);
+				}
+				renamedInlinedModules.set(m, source);
+			}
+			return renamedInlinedModules;
+		}
+
 		for (const [m, moduleInfo] of inlinedModulesToInfo) {
 			const { ast, source: _source, usedInNonInlined } = moduleInfo;
 			const source = new ReplaceSource(_source);
@@ -1864,60 +2270,14 @@ class JavascriptModulesPlugin {
 			}
 
 			for (const variable of info.variables) {
-				/** @type {UsedNamesInScopeInfo} */
-				const usedNamesInScopeInfo = new Map();
-				/** @type {ScopeSet} */
-				const ignoredScopes = new Set();
-
-				const name = variable.name;
-				const { usedNames, alreadyCheckedScopes } = getUsedNamesInScopeInfo(
-					usedNamesInScopeInfo,
+				renameInlinedModuleVariable(
+					source,
+					ast,
+					variable,
 					info.module.identifier(),
-					name
+					m.readableIdentifier(runtimeTemplate.requestShortener),
+					allUsedNames
 				);
-
-				if (allUsedNames.has(name) || usedNames.has(name)) {
-					const references = getAllReferences(variable);
-					const allIdentifiers = new Set([
-						...references.map((r) => r.identifier),
-						...variable.identifiers
-					]);
-					for (const ref of references) {
-						addScopeSymbols(
-							ref.from,
-							usedNames,
-							alreadyCheckedScopes,
-							ignoredScopes
-						);
-					}
-
-					const newName = findNewName(
-						variable.name,
-						allUsedNames,
-						usedNames,
-						m.readableIdentifier(runtimeTemplate.requestShortener)
-					);
-					allUsedNames.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);
-					}
-				}
-				allUsedNames.add(name);
 			}
 
 			renamedInlinedModules.set(m, source);
@@ -1927,5 +2287,41 @@ class JavascriptModulesPlugin {
 	}
 }
 
+JavascriptModulesPlugin.getCompilationHooks = createHooksRegistry(
+	() =>
+		/** @type {CompilationHooks} */ ({
+			renderModuleContent: new SyncWaterfallHook([
+				"source",
+				"module",
+				"moduleRenderContext"
+			]),
+			renderModuleContainer: new SyncWaterfallHook([
+				"source",
+				"module",
+				"moduleRenderContext"
+			]),
+			renderModulePackage: new SyncWaterfallHook([
+				"source",
+				"module",
+				"moduleRenderContext"
+			]),
+			render: new SyncWaterfallHook(["source", "renderContext"]),
+			renderContent: new SyncWaterfallHook(["source", "renderContext"]),
+			renderStartup: new SyncWaterfallHook([
+				"source",
+				"module",
+				"startupRenderContext"
+			]),
+			renderChunk: new SyncWaterfallHook(["source", "renderContext"]),
+			renderMain: new SyncWaterfallHook(["source", "renderContext"]),
+			renderRequire: new SyncWaterfallHook(["code", "renderContext"]),
+			inlineInRuntimeBailout: new SyncBailHook(["module", "renderContext"]),
+			embedInRuntimeBailout: new SyncBailHook(["module", "renderContext"]),
+			strictRuntimeBailout: new SyncBailHook(["renderContext"]),
+			chunkHash: new SyncHook(["chunk", "hash", "context"]),
+			useSourceMap: new SyncBailHook(["chunk", "renderContext"])
+		})
+);
+
 module.exports = JavascriptModulesPlugin;
 module.exports.chunkHasJs = chunkHasJs;