@depup/webpack 5.106.1-depup.0 → 5.109.2-depup.0

package/lib/runtime/CommonJsWrapRuntimeModule.js

@@ -0,0 +1,37 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const HelperRuntimeModule = require("./HelperRuntimeModule");
+
+/** @typedef {import("../Compilation")} Compilation */
+
+class CommonJsWrapRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("wrap commonjs module");
+	}
+
+	/**
+	 * Generates runtime code for this runtime module.
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
+		const fn = RuntimeGlobals.commonJsWrap;
+		return Template.asString([
+			"// execute a CommonJS module body with real module/exports objects, returning the final exports",
+			`${fn} = ${runtimeTemplate.basicFunction("body", [
+				`${runtimeTemplate.renderConst()} mod = { exports: {} };`,
+				"body.call(mod.exports, mod, mod.exports);",
+				"return mod.exports;"
+			])};`
+		]);
+	}
+}
+
+module.exports = CommonJsWrapRuntimeModule;

package/lib/runtime/CompatGetDefaultExportRuntimeModule.js

@@ -16,6 +16,7 @@ class CompatGetDefaultExportRuntimeModule extends HelperRuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {
@@ -25,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/CompatRuntimeModule.js

@@ -19,6 +19,7 @@ class CompatRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {
@@ -72,6 +73,7 @@ class CompatRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Returns true, if the runtime module should get it's own scope.
 	 * @returns {boolean} true, if the runtime module should get it's own scope
 	 */
 	shouldIsolate() {

package/lib/runtime/CreateFakeNamespaceObjectRuntimeModule.js

@@ -16,18 +16,21 @@ class CreateFakeNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {
 		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",
@@ -45,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/CreateScriptRuntimeModule.js

@@ -16,6 +16,7 @@ class CreateScriptRuntimeModule extends HelperRuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {

package/lib/runtime/CreateScriptUrlRuntimeModule.js

@@ -16,6 +16,7 @@ class CreateScriptUrlRuntimeModule extends HelperRuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {

package/lib/runtime/DefinePropertyGettersRuntimeModule.js

@@ -16,6 +16,7 @@ class DefinePropertyGettersRuntimeModule extends HelperRuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {
@@ -23,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/EnsureChunkRuntimeModule.js

@@ -22,6 +22,7 @@ class EnsureChunkRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {

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,31 +15,49 @@ const { first } = require("../util/SetHelpers");
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compilation").HashWithLengthFunction} HashWithLengthFunction */
-/** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
+/** @typedef {import("../Compilation").HashWithDigestFunction} HashWithDigestFunction */
+/** @typedef {import("../Chunk").ChunkFilenameTemplate} ChunkFilenameTemplate */
 
 class GetChunkFilenameRuntimeModule extends RuntimeModule {
 	/**
 	 * @param {string} contentType the contentType to use the content hash for
 	 * @param {string} name kind of filename
 	 * @param {string} global function name to be assigned
-	 * @param {(chunk: Chunk) => TemplatePath | false} getFilenameForChunk functor to get the filename or function
+	 * @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;
 		/** @type {string} */
 		this.global = global;
-		/** @type {(chunk: Chunk) => TemplatePath | false} */
+		/** @type {(chunk: Chunk) => ChunkFilenameTemplate | false} */
 		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;
+		}
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {
@@ -47,8 +66,39 @@ 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;
 
-		/** @type {Map<string | TemplatePath, Set<Chunk>>} */
+		/**
+		 * 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();
 		let maxChunks = 0;
 		/** @type {string | undefined} */
@@ -125,7 +175,7 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 
 		/**
 		 * @param {Chunk} c the chunk
-		 * @param {string | TemplatePath} chunkFilename the filename template for the chunk
+		 * @param {ChunkFilenameTemplate} chunkFilename the filename template for the chunk
 		 * @returns {void}
 		 */
 		const addStaticUrl = (c, chunkFilename) => {
@@ -161,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])
@@ -175,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
@@ -247,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/GetFullHashRuntimeModule.js

@@ -17,6 +17,7 @@ class GetFullHashRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {

package/lib/runtime/GetMainFilenameRuntimeModule.js

@@ -26,6 +26,7 @@ class GetMainFilenameRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {

package/lib/runtime/GetTrustedTypesPolicyRuntimeModule.js

@@ -22,6 +22,7 @@ class GetTrustedTypesPolicyRuntimeModule extends HelperRuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {
@@ -34,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/GetWorkletBootstrapRuntimeModule.js

@@ -0,0 +1,59 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author sheo13666q
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+const Template = require("../Template");
+
+/** @typedef {import("../Compilation")} Compilation */
+
+/**
+ * Provides a single object URL (one per base URI) for the worklet bootstrap
+ * script. A worklet global scope has no `self` and no `location`; this script
+ * sets them up before the emitted chunks — which assume a worker-like scope —
+ * are added via `addModule`. Deduping by base URI avoids leaking a new object
+ * URL per worklet.
+ */
+class GetWorkletBootstrapRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("get worklet bootstrap", RuntimeModule.STAGE_ATTACH);
+	}
+
+	/**
+	 * Generates runtime code for this runtime module.
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const { getWorkletBootstrap, baseURI } = RuntimeGlobals;
+		const { runtimeTemplate } = /** @type {Compilation} */ (this.compilation);
+		// The arrow inside the blob string is fine — it runs in the worklet (always
+		// a module scope); the surrounding functions must respect `output.environment`.
+		const getter = runtimeTemplate.basicFunction("", [
+			`var base = ${baseURI};`,
+			"if (!cache.has(base)) {",
+			Template.indent([
+				"var script = [",
+				Template.indent([
+					// worklet scopes have no `self`; chunks assume a worker-like scope
+					'"globalThis.self = globalThis.self || globalThis;",',
+					// some runtime modules read `location`; forward the document base
+					'"globalThis.location = " + JSON.stringify(base) + ";"'
+				]),
+				'].join("\\n");',
+				'cache.set(base, URL.createObjectURL(new Blob([script], { type: "text/javascript" })));'
+			]),
+			"}",
+			"return cache.get(base);"
+		]);
+		return `${getWorkletBootstrap} = (${runtimeTemplate.basicFunction("", [
+			"var cache = new Map();",
+			`return ${getter};`
+		])})();`;
+	}
+}
+
+module.exports = GetWorkletBootstrapRuntimeModule;

package/lib/runtime/GlobalRuntimeModule.js

@@ -14,6 +14,7 @@ class GlobalRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {

package/lib/runtime/HasOwnPropertyRuntimeModule.js

@@ -17,6 +17,7 @@ class HasOwnPropertyRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {
@@ -25,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/HelperRuntimeModule.js

@@ -6,8 +6,13 @@
 
 const RuntimeModule = require("../RuntimeModule");
 
+/**
+ * Base class for runtime modules that only emit helper functions and do not
+ * need special staging or attachment behavior beyond `RuntimeModule`.
+ */
 class HelperRuntimeModule extends RuntimeModule {
 	/**
+	 * Creates a helper runtime module with the provided readable name.
 	 * @param {string} name a readable name
 	 */
 	constructor(name) {

package/lib/runtime/LoadScriptRuntimeModule.js

@@ -5,9 +5,10 @@
 "use strict";
 
 const { SyncWaterfallHook } = require("tapable");
-const Compilation = require("../Compilation");
+/** @typedef {import("../Compilation")} Compilation */
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
+const createHooksRegistry = require("../util/createHooksRegistry");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
 
 /** @typedef {import("../Chunk")} Chunk */
@@ -17,30 +18,7 @@ const HelperRuntimeModule = require("./HelperRuntimeModule");
  * @property {SyncWaterfallHook<[string, Chunk]>} createScript
  */
 
-/** @type {WeakMap<Compilation, LoadScriptCompilationHooks>} */
-const compilationHooksMap = new WeakMap();
-
 class LoadScriptRuntimeModule extends HelperRuntimeModule {
-	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {LoadScriptCompilationHooks} 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 = {
-				createScript: new SyncWaterfallHook(["source", "chunk"])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
-	}
-
 	/**
 	 * @param {boolean=} withCreateScriptUrl use create script url for trusted types
 	 * @param {boolean=} withFetchPriority use `fetchPriority` attribute
@@ -54,6 +32,7 @@ class LoadScriptRuntimeModule extends HelperRuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {
@@ -110,10 +89,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(
@@ -122,13 +103,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'
@@ -145,23 +126,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);"
@@ -171,4 +155,11 @@ class LoadScriptRuntimeModule extends HelperRuntimeModule {
 	}
 }
 
+LoadScriptRuntimeModule.getCompilationHooks = createHooksRegistry(
+	() =>
+		/** @type {LoadScriptCompilationHooks} */ ({
+			createScript: new SyncWaterfallHook(["source", "chunk"])
+		})
+);
+
 module.exports = LoadScriptRuntimeModule;