webpack 5.107.1 → 5.108.0

package/lib/runtime/AsyncModuleRuntimeModule.js

@@ -29,24 +29,26 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 		const { runtimeTemplate } = compilation;
 		const fn = RuntimeGlobals.asyncModule;
 		const defer = this._deferInterop;
+		const cst = runtimeTemplate.renderConst();
+		const lt = runtimeTemplate.renderLet();
 		return Template.asString([
-			'var hasSymbol = typeof Symbol === "function";',
-			'var webpackQueues = hasSymbol ? Symbol("webpack queues") : "__webpack_queues__";',
-			`var webpackExports = ${
+			`${cst} hasSymbol = typeof Symbol === "function";`,
+			`${cst} webpackQueues = hasSymbol ? Symbol("webpack queues") : "__webpack_queues__";`,
+			`${cst} webpackExports = ${
 				defer ? `${RuntimeGlobals.asyncModuleExportSymbol}= ` : ""
 			}hasSymbol ? Symbol("webpack exports") : "${RuntimeGlobals.exports}";`,
-			'var webpackError = hasSymbol ? Symbol("webpack error") : "__webpack_error__";',
+			`${cst} webpackError = hasSymbol ? Symbol("webpack error") : "__webpack_error__";`,
 			defer
 				? Template.asString([
-						`var webpackDone = ${RuntimeGlobals.asyncModuleDoneSymbol} = hasSymbol ? Symbol("webpack done") : "__webpack_done__";`,
-						`var webpackDefer = ${RuntimeGlobals.deferredModuleAsyncTransitiveDependenciesSymbol} = hasSymbol ? Symbol("webpack defer") : "__webpack_defer__";`,
+						`${cst} webpackDone = ${RuntimeGlobals.asyncModuleDoneSymbol} = hasSymbol ? Symbol("webpack done") : "__webpack_done__";`,
+						`${cst} webpackDefer = ${RuntimeGlobals.deferredModuleAsyncTransitiveDependenciesSymbol} = hasSymbol ? Symbol("webpack defer") : "__webpack_defer__";`,
 						`${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies} = ${runtimeTemplate.basicFunction(
 							"asyncDeps",
 							[
 								Template.indent([
-									"var hasUnresolvedAsyncSubgraph = asyncDeps.some((id) => {",
+									`${cst} hasUnresolvedAsyncSubgraph = asyncDeps.some((id) => {`,
 									Template.indent([
-										"var cache = __webpack_module_cache__[id];",
+										`${cst} cache = __webpack_module_cache__[id];`,
 										"return !cache || cache[webpackDone] === false;"
 									]),
 									"});",
@@ -60,8 +62,8 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 						)}`
 					])
 				: "",
-			`var resolveQueue = ${runtimeTemplate.basicFunction("queue", [
-				"if(queue && queue.d < 1) {",
+			`${cst} resolveQueue = ${runtimeTemplate.basicFunction("queue", [
+				`if(${runtimeTemplate.optionalChaining("queue", "d < 1")}) {`,
 				Template.indent([
 					"queue.d = 1;",
 					`queue.forEach(${runtimeTemplate.expressionFunction(
@@ -75,7 +77,7 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 				]),
 				"}"
 			])}`,
-			`var wrapDeps = ${runtimeTemplate.returningFunction(
+			`${cst} wrapDeps = ${runtimeTemplate.returningFunction(
 				`deps.map(${runtimeTemplate.basicFunction("dep", [
 					'if(dep !== null && typeof dep === "object") {',
 					Template.indent([
@@ -83,10 +85,10 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 							? Template.asString([
 									"if(!dep[webpackQueues] && dep[webpackDefer]) {",
 									Template.indent([
-										`var asyncDeps = ${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies}(dep[webpackDefer]);`,
+										`${cst} asyncDeps = ${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies}(dep[webpackDefer]);`,
 										"if (asyncDeps) {",
 										Template.indent([
-											"var d = dep;",
+											`${cst} d = dep;`,
 											"dep = {",
 											Template.indent([
 												"then(onFulfilled, onRejected) {",
@@ -107,7 +109,7 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 						"if(dep[webpackQueues]) return dep;",
 						"if(dep.then) {",
 						Template.indent([
-							"var queue = [];",
+							`${cst} queue = [];`,
 							"queue.d = 0;",
 							`dep.then(${runtimeTemplate.basicFunction("r", [
 								"obj[webpackExports] = r;",
@@ -116,7 +118,7 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 								"obj[webpackError] = e;",
 								"resolveQueue(queue);"
 							])});`,
-							"var obj = {};",
+							`${cst} obj = {};`,
 							defer ? "obj[webpackDefer] = false;" : "",
 							`obj[webpackQueues] = ${runtimeTemplate.expressionFunction(
 								"fn(queue)",
@@ -127,7 +129,7 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 						"}"
 					]),
 					"}",
-					"var ret = {};",
+					`${cst} ret = {};`,
 					`ret[webpackQueues] = ${runtimeTemplate.emptyFunction()};`,
 					"ret[webpackExports] = dep;",
 					"return ret;"
@@ -135,14 +137,14 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 				"deps"
 			)};`,
 			`${fn} = ${runtimeTemplate.basicFunction("module, body, hasAwait", [
-				"var queue;",
+				`${lt} queue;`,
 				"hasAwait && ((queue = []).d = -1);",
-				"var depQueues = new Set();",
-				"var exports = module.exports;",
-				"var currentDeps;",
-				"var outerResolve;",
-				"var reject;",
-				`var promise = new Promise(${runtimeTemplate.basicFunction(
+				`${cst} depQueues = new Set();`,
+				`${cst} exports = module.exports;`,
+				`${lt} currentDeps;`,
+				`${lt} outerResolve;`,
+				`${lt} reject;`,
+				`${cst} promise = new Promise(${runtimeTemplate.basicFunction(
 					"resolve, rej",
 					["reject = rej;", "outerResolve = resolve;"]
 				)});`,
@@ -152,17 +154,17 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 					"fn"
 				)};`,
 				"module.exports = promise;",
-				`var handle = ${runtimeTemplate.basicFunction("deps", [
+				`${cst} handle = ${runtimeTemplate.basicFunction("deps", [
 					"currentDeps = wrapDeps(deps);",
-					"var fn;",
-					`var getResult = ${runtimeTemplate.returningFunction(
+					`${lt} fn;`,
+					`${cst} getResult = ${runtimeTemplate.returningFunction(
 						`currentDeps.map(${runtimeTemplate.basicFunction("d", [
 							defer ? "if(d[webpackDefer]) return d;" : "",
 							"if(d[webpackError]) throw d[webpackError];",
 							"return d[webpackExports];"
 						])})`
 					)}`,
-					`var promise = new Promise(${runtimeTemplate.basicFunction(
+					`${cst} promise = new Promise(${runtimeTemplate.basicFunction(
 						"resolve",
 						[
 							`fn = ${runtimeTemplate.expressionFunction(
@@ -170,7 +172,7 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 								""
 							)};`,
 							"fn.r = 0;",
-							`var fnQueue = ${runtimeTemplate.expressionFunction(
+							`${cst} fnQueue = ${runtimeTemplate.expressionFunction(
 								"q !== queue && !depQueues.has(q) && (depQueues.add(q), q && !q.d && (fn.r++, q.push(fn)))",
 								"q"
 							)};`,
@@ -184,14 +186,14 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 					)});`,
 					"return fn.r ? promise : getResult();"
 				])}`,
-				`var done = ${runtimeTemplate.expressionFunction(
+				`${cst} done = ${runtimeTemplate.expressionFunction(
 					`(err ? reject(promise[webpackError] = err) : outerResolve(exports)), resolveQueue(queue)${
 						defer ? ", promise[webpackDone] = true" : ""
 					}`,
 					"err"
 				)}`,
 				"body(handle, done);",
-				"queue && queue.d < 0 && (queue.d = 0);"
+				`${runtimeTemplate.optionalChaining("queue", "d < 0")} && (queue.d = 0);`
 			])};`
 		]);
 	}

package/lib/runtime/AutoPublicPathRuntimeModule.js

@@ -47,26 +47,32 @@ class AutoPublicPathRuntimeModule extends RuntimeModule {
 			? "globalThis"
 			: RuntimeGlobals.global;
 
+		const runtimeTemplate = compilation.runtimeTemplate;
+		const cst = runtimeTemplate.renderConst();
+		const lt = runtimeTemplate.renderLet();
 		return Template.asString([
-			"var scriptUrl;",
+			`${lt} scriptUrl;`,
 			scriptType === "module"
 				? `if (typeof ${importMetaName}.url === "string") scriptUrl = ${importMetaName}.url`
 				: Template.asString([
 						`if (${global}.importScripts) scriptUrl = ${global}.location + "";`,
-						`var document = ${global}.document;`,
+						`${cst} document = ${global}.document;`,
 						"if (!scriptUrl && document) {",
 						Template.indent([
 							// Technically we could use `document.currentScript instanceof window.HTMLScriptElement`,
 							// but an attacker could try to inject `<script>HTMLScriptElement = HTMLImageElement</script>`
 							// and use `<img name="currentScript" src="https://attacker.controlled.server/"></img>`
-							"if (document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT')",
+							`if (${runtimeTemplate.optionalChaining(
+								"document.currentScript",
+								"tagName.toUpperCase() === 'SCRIPT'"
+							)})`,
 							Template.indent("scriptUrl = document.currentScript.src;"),
 							"if (!scriptUrl) {",
 							Template.indent([
-								'var scripts = document.getElementsByTagName("script");',
+								`${cst} scripts = document.getElementsByTagName("script");`,
 								"if(scripts.length) {",
 								Template.indent([
-									"var i = scripts.length - 1;",
+									`${lt} i = scripts.length - 1;`,
 									"while (i > -1 && (!scriptUrl || !/^http(s?):/.test(scriptUrl))) scriptUrl = scripts[i--].src;"
 								]),
 								"}"

package/lib/runtime/CompatGetDefaultExportRuntimeModule.js

@@ -26,7 +26,7 @@ class CompatGetDefaultExportRuntimeModule extends HelperRuntimeModule {
 		return Template.asString([
 			"// getDefaultExport function for compatibility with non-harmony modules",
 			`${fn} = ${runtimeTemplate.basicFunction("module", [
-				"var getter = module && module.__esModule ?",
+				`${runtimeTemplate.renderConst()} getter = module && module.__esModule ?`,
 				Template.indent([
 					`${runtimeTemplate.returningFunction("module['default']")} :`,
 					`${runtimeTemplate.returningFunction("module")};`

package/lib/runtime/CreateFakeNamespaceObjectRuntimeModule.js

@@ -23,12 +23,14 @@ class CreateFakeNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const { runtimeTemplate } = compilation;
 		const fn = RuntimeGlobals.createFakeNamespaceObject;
+		const cst = runtimeTemplate.renderConst();
+		const lt = runtimeTemplate.renderLet();
 		return Template.asString([
-			`var getProto = Object.getPrototypeOf ? ${runtimeTemplate.returningFunction(
+			`${cst} getProto = Object.getPrototypeOf ? ${runtimeTemplate.returningFunction(
 				"Object.getPrototypeOf(obj)",
 				"obj"
 			)} : ${runtimeTemplate.returningFunction("obj.__proto__", "obj")};`,
-			"var leafPrototypes;",
+			`${lt} leafPrototypes;`,
 			"// create a fake namespace object",
 			"// mode & 1: value is a module id, require it",
 			"// mode & 2: merge all properties of value into the ns",
@@ -46,9 +48,9 @@ class CreateFakeNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 					"if((mode & 16) && typeof value.then === 'function') return value;"
 				]),
 				"}",
-				"var ns = Object.create(null);",
+				`${cst} ns = Object.create(null);`,
 				`${RuntimeGlobals.makeNamespaceObject}(ns);`,
-				"var def = {};",
+				`${cst} def = {};`,
 				"leafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];",
 				"for(var current = mode & 2 && value; (typeof current == 'object' || typeof current == 'function') && !~leafPrototypes.indexOf(current); current = getProto(current)) {",
 				Template.indent([

package/lib/runtime/DefinePropertyGettersRuntimeModule.js

@@ -24,13 +24,42 @@ class DefinePropertyGettersRuntimeModule extends HelperRuntimeModule {
 		const { runtimeTemplate } = compilation;
 		const fn = RuntimeGlobals.definePropertyGetters;
 		return Template.asString([
-			"// define getter functions for harmony exports",
+			"// define getter/value functions for harmony exports",
 			`${fn} = ${runtimeTemplate.basicFunction("exports, definition", [
-				"for(var key in definition) {",
+				"if(Array.isArray(definition)) {",
 				Template.indent([
-					`if(${RuntimeGlobals.hasOwnProperty}(definition, key) && !${RuntimeGlobals.hasOwnProperty}(exports, key)) {`,
+					"var i = 0;",
+					"while(i < definition.length) {",
 					Template.indent([
-						"Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });"
+						"var key = definition[i++];",
+						"var binding = definition[i++];",
+						`if(!${RuntimeGlobals.hasOwnProperty}(exports, key)) {`,
+						Template.indent([
+							"if(binding === 0) {",
+							Template.indent([
+								"Object.defineProperty(exports, key, { enumerable: true, value: definition[i++] });"
+							]),
+							"} else {",
+							Template.indent([
+								"Object.defineProperty(exports, key, { enumerable: true, get: binding });"
+							]),
+							"}"
+						]),
+						"} else if(binding === 0) { i++; }"
+					]),
+					"}"
+				]),
+				// TODO webpack 6: remove object format support. Internal code (e.g. ConcatenatedModule)
+				// and third-party libraries may still call __webpack_require__.d() with an object.
+				"} else {",
+				Template.indent([
+					"for(var key in definition) {",
+					Template.indent([
+						`if(${RuntimeGlobals.hasOwnProperty}(definition, key) && !${RuntimeGlobals.hasOwnProperty}(exports, key)) {`,
+						Template.indent([
+							"Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });"
+						]),
+						"}"
 					]),
 					"}"
 				]),

package/lib/runtime/GetChunkFilenameRuntimeModule.js

@@ -7,6 +7,7 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
+const { reEncodeDigest } = require("../TemplatedPathPlugin");
 const { first } = require("../util/SetHelpers");
 
 /** @typedef {import("../Chunk")} Chunk */
@@ -14,6 +15,7 @@ const { first } = require("../util/SetHelpers");
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compilation").HashWithLengthFunction} HashWithLengthFunction */
+/** @typedef {import("../Compilation").HashWithDigestFunction} HashWithDigestFunction */
 /** @typedef {import("../Chunk").ChunkFilenameTemplate} ChunkFilenameTemplate */
 
 class GetChunkFilenameRuntimeModule extends RuntimeModule {
@@ -23,8 +25,16 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 	 * @param {string} global function name to be assigned
 	 * @param {(chunk: Chunk) => ChunkFilenameTemplate | false} getFilenameForChunk functor to get the filename or function
 	 * @param {boolean} allChunks when false, only async chunks are included
+	 * @param {boolean=} usesFullHashDigest the filename uses `[fullhash:<digest>]`/`[hash:<digest>]`, so the re-encoded full hash must be inlined (post-hash) instead of read from the runtime `getFullHash()` expression
 	 */
-	constructor(contentType, name, global, getFilenameForChunk, allChunks) {
+	constructor(
+		contentType,
+		name,
+		global,
+		getFilenameForChunk,
+		allChunks,
+		usesFullHashDigest
+	) {
 		super(`get ${name} chunk filename`);
 		/** @type {string} */
 		this.contentType = contentType;
@@ -34,8 +44,16 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 		this.getFilenameForChunk = getFilenameForChunk;
 		/** @type {boolean} */
 		this.allChunks = allChunks;
-		/** @type {boolean} */
-		this.dependentHash = true;
+		// An inline digest on `[fullhash]` needs the final hash inlined, so this
+		// module must re-render after hashing (`fullHash`); otherwise it only needs
+		// the referenced chunk hashes, available before the full hash (`dependentHash`).
+		if (usesFullHashDigest) {
+			/** @type {boolean} */
+			this.fullHash = true;
+		} else {
+			/** @type {boolean} */
+			this.dependentHash = true;
+		}
 	}
 
 	/**
@@ -48,6 +66,37 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
 		const chunk = /** @type {Chunk} */ (this.chunk);
 		const { runtimeTemplate } = compilation;
+		// Digest the stored hashes are encoded in, for re-encoding `[<hash>:<digest>]`.
+		const sourceDigest = compilation.outputOptions.hashDigest;
+
+		/**
+		 * Re-encodes a full hash digest into the requested digest, optionally truncated.
+		 * @param {string} value full hash digest
+		 * @param {string} digest requested digest
+		 * @param {number=} length requested length
+		 * @returns {string} re-encoded hash
+		 */
+		const reEncode = (value, digest, length) => {
+			const hash = reEncodeDigest(
+				value,
+				/** @type {string} */ (sourceDigest),
+				digest
+			);
+			return length ? hash.slice(0, length) : hash;
+		};
+
+		// `[fullhash:<digest>]`/`[hash:<digest>]` would resolve to a runtime
+		// `getFullHash()` expression that can't be re-encoded; instead this module is
+		// flagged `fullHash` and re-rendered after hashing, so we inline the
+		// re-encoded full hash here — byte-identical to the statically emitted file.
+		/** @type {HashWithDigestFunction} */
+		const fullHashWithDigest = (digest, length) => {
+			const fullHash = compilation.fullHash;
+			// Pre-hash pass (hash not computed yet): a placeholder, replaced on the
+			// post-hash re-render. Matches `GetFullHashRuntimeModule`'s `|| "XXXX"`.
+			if (!fullHash) return length ? "x".repeat(length) : "x";
+			return reEncode(fullHash, digest, length);
+		};
 
 		/** @type {Map<ChunkFilenameTemplate, Set<Chunk>>} */
 		const chunkFilenames = new Map();
@@ -162,12 +211,17 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
 				hashWithLength: (length) =>
 					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
+				hashWithDigest: fullHashWithDigest,
 				chunk: {
 					id: unquotedStringify(/** @type {ChunkId} */ (c.id)),
 					hash: unquotedStringify(/** @type {string} */ (c.renderedHash)),
 					hashWithLength: unquotedStringifyWithLength(
 						/** @type {string} */ (c.renderedHash)
 					),
+					hashWithDigest: (digest, length) =>
+						unquotedStringify(
+							reEncode(/** @type {string} */ (c.hash), digest, length)
+						),
 					name: unquotedStringify(c.name || /** @type {ChunkId} */ (c.id)),
 					contentHash: {
 						[contentType]: unquotedStringify(c.contentHash[contentType])
@@ -176,6 +230,16 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 						[contentType]: unquotedStringifyWithLength(
 							c.contentHash[contentType]
 						)
+					},
+					contentHashWithDigest: {
+						[contentType]: (digest, length) =>
+							unquotedStringify(
+								reEncode(
+									c.contentHashFull[contentType] || c.contentHash[contentType],
+									digest,
+									length
+								)
+							)
 					}
 				},
 				contentHashType: contentType
@@ -248,18 +312,33 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
 				hashWithLength: (length) =>
 					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
+				hashWithDigest: fullHashWithDigest,
 				chunk: {
 					id: '" + chunkId + "',
 					hash: mapExpr((c) => /** @type {string} */ (c.renderedHash)),
 					hashWithLength: mapExprWithLength(
 						(c) => /** @type {string} */ (c.renderedHash)
 					),
+					hashWithDigest: (digest, length) =>
+						mapExpr((c) =>
+							reEncode(/** @type {string} */ (c.hash), digest, length)
+						),
 					name: mapExpr((c) => c.name || /** @type {ChunkId} */ (c.id)),
 					contentHash: {
 						[contentType]: mapExpr((c) => c.contentHash[contentType])
 					},
 					contentHashWithLength: {
 						[contentType]: mapExprWithLength((c) => c.contentHash[contentType])
+					},
+					contentHashWithDigest: {
+						[contentType]: (digest, length) =>
+							mapExpr((c) =>
+								reEncode(
+									c.contentHashFull[contentType] || c.contentHash[contentType],
+									digest,
+									length
+								)
+							)
 					}
 				},
 				contentHashType: contentType

package/lib/runtime/GetTrustedTypesPolicyRuntimeModule.js

@@ -35,7 +35,7 @@ class GetTrustedTypesPolicyRuntimeModule extends HelperRuntimeModule {
 			: false;
 
 		return Template.asString([
-			"var policy;",
+			`${runtimeTemplate.renderLet()} policy;`,
 			`${fn} = ${runtimeTemplate.basicFunction("", [
 				"// Create Trusted Type policy if Trusted Types are available and the policy doesn't exist yet.",
 				"if (policy === undefined) {",

package/lib/runtime/HasOwnPropertyRuntimeModule.js

@@ -26,7 +26,7 @@ class HasOwnPropertyRuntimeModule extends RuntimeModule {
 
 		return Template.asString([
 			`${RuntimeGlobals.hasOwnProperty} = ${runtimeTemplate.returningFunction(
-				"Object.prototype.hasOwnProperty.call(obj, prop)",
+				runtimeTemplate.objectHasOwn("obj", "prop"),
 				"obj, prop"
 			)}`
 		]);

package/lib/runtime/LoadScriptRuntimeModule.js

@@ -111,10 +111,12 @@ class LoadScriptRuntimeModule extends HelperRuntimeModule {
 				: ""
 		]);
 
+		const cst = runtimeTemplate.renderConst();
+		const lt = runtimeTemplate.renderLet();
 		return Template.asString([
-			"var inProgress = {};",
+			`${cst} inProgress = {};`,
 			uniqueName
-				? `var dataWebpackPrefix = ${JSON.stringify(`${uniqueName}:`)};`
+				? `${cst} dataWebpackPrefix = ${JSON.stringify(`${uniqueName}:`)};`
 				: "// data-webpack is not used as build has no uniqueName",
 			"// loadScript function to load a script via script tag",
 			`${fn} = ${runtimeTemplate.basicFunction(
@@ -123,13 +125,13 @@ class LoadScriptRuntimeModule extends HelperRuntimeModule {
 				}`,
 				[
 					"if(inProgress[url]) { inProgress[url].push(done); return; }",
-					"var script, needAttach;",
+					`${lt} script, needAttach;`,
 					"if(key !== undefined) {",
 					Template.indent([
-						'var scripts = document.getElementsByTagName("script");',
+						`${cst} scripts = document.getElementsByTagName("script");`,
 						"for(var i = 0; i < scripts.length; i++) {",
 						Template.indent([
-							"var s = scripts[i];",
+							`${cst} s = scripts[i];`,
 							`if(s.getAttribute("src") == url${
 								uniqueName
 									? ' || s.getAttribute("data-webpack") == dataWebpackPrefix + key'
@@ -146,23 +148,26 @@ class LoadScriptRuntimeModule extends HelperRuntimeModule {
 					]),
 					"}",
 					"inProgress[url] = [done];",
-					`var onScriptComplete = ${runtimeTemplate.basicFunction(
+					`${cst} onScriptComplete = ${runtimeTemplate.basicFunction(
 						"prev, event",
 						Template.asString([
 							"// avoid mem leaks in IE.",
 							"script.onerror = script.onload = null;",
 							"clearTimeout(timeout);",
-							"var doneFns = inProgress[url];",
+							`${cst} doneFns = inProgress[url];`,
 							"delete inProgress[url];",
-							"script.parentNode && script.parentNode.removeChild(script);",
-							`doneFns && doneFns.forEach(${runtimeTemplate.returningFunction(
-								"fn(event)",
-								"fn"
-							)});`,
+							`${runtimeTemplate.optionalChaining(
+								"script.parentNode",
+								"removeChild(script)"
+							)};`,
+							`${runtimeTemplate.optionalChaining(
+								"doneFns",
+								`forEach(${runtimeTemplate.returningFunction("fn(event)", "fn")})`
+							)};`,
 							"if(prev) return prev(event);"
 						])
 					)}`,
-					`var timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), ${loadTimeout});`,
+					`${cst} timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), ${loadTimeout});`,
 					"script.onerror = onScriptComplete.bind(null, script.onerror);",
 					"script.onload = onScriptComplete.bind(null, script.onload);",
 					"needAttach && document.head.appendChild(script);"