webpack 5.105.3 → 5.106.0

package/lib/schemes/VirtualUrlPlugin.js

@@ -5,37 +5,33 @@
 
 "use strict";
 
-const { NormalModule } = require("..");
+const { getContext } = require("loader-runner");
+
 const ModuleNotFoundError = require("../ModuleNotFoundError");
+const NormalModule = require("../NormalModule");
+const { isAbsolute, join } = require("../util/fs");
 const { parseResourceWithoutFragment } = require("../util/identifier");
 
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../NormalModule")} NormalModule */
+const DEFAULT_SCHEME = "virtual";
+
+const PLUGIN_NAME = "VirtualUrlPlugin";
 
 /**
- * @template T
- * @typedef {import("../../declarations/LoaderContext").LoaderContext<T>} LoaderContext
+ * @typedef {import("../Compiler")} Compiler
+ * @typedef {import("../../declarations/plugins/schemes/VirtualUrlPlugin").VirtualModule} VirtualModuleConfig
+ * @typedef {import("../../declarations/plugins/schemes/VirtualUrlPlugin").VirtualModuleContent} VirtualModuleInput
+ * @typedef {import("../../declarations/plugins/schemes/VirtualUrlPlugin").VirtualUrlOptions} VirtualUrlOptions
  */
 
-const PLUGIN_NAME = "VirtualUrlPlugin";
-const DEFAULT_SCHEME = "virtual";
-
 /** @typedef {(loaderContext: LoaderContext<EXPECTED_ANY>) => Promise<string | Buffer> | string | Buffer} SourceFn */
 /** @typedef {() => string} VersionFn */
+/** @typedef {{ [key: string]: VirtualModuleInput }} VirtualModules */
 
 /**
- * @typedef {object} VirtualModuleConfig
- * @property {string=} type the module type
- * @property {SourceFn} source the source function
- * @property {VersionFn | true | string=} version optional version function or value
- */
-
-/**
- * @typedef {string | SourceFn | VirtualModuleConfig} VirtualModuleInput
+ * @template T
+ * @typedef {import("../../declarations/LoaderContext").LoaderContext<T>} LoaderContext
  */
 
-/** @typedef {{ [key: string]: VirtualModuleInput }} VirtualModules */
-
 /**
  * Normalizes a virtual module definition into a standard format
  * @param {VirtualModuleInput} virtualConfig The virtual module to normalize
@@ -83,6 +79,16 @@ function toVid(id, scheme) {
 	return `${scheme}:${id}`;
 }
 
+/**
+ * Converts a virtual module id to a module id
+ * @param {string} vid The virtual module id
+ * @param {string} scheme The URL scheme
+ * @returns {string} The module id
+ */
+function fromVid(vid, scheme) {
+	return vid.replace(`${scheme}:`, "");
+}
+
 const VALUE_DEP_VERSION = `webpack/${PLUGIN_NAME}/version`;
 
 /**
@@ -95,22 +101,26 @@ function toCacheKey(id, scheme) {
 	return `${VALUE_DEP_VERSION}/${toVid(id, scheme)}`;
 }
 
-/**
- * @typedef {object} VirtualUrlPluginOptions
- * @property {VirtualModules} modules - The virtual modules
- * @property {string=} scheme - The URL scheme to use
- */
-
 class VirtualUrlPlugin {
 	/**
 	 * @param {VirtualModules} modules The virtual modules
-	 * @param {string=} scheme The URL scheme to use
+	 * @param {Omit<VirtualUrlOptions, "modules"> | string=} schemeOrOptions The URL scheme to use
 	 */
-	constructor(modules, scheme) {
+	constructor(modules, schemeOrOptions) {
+		/** @type {VirtualUrlOptions} */
+		this.options = {
+			modules,
+			...(typeof schemeOrOptions === "string"
+				? { scheme: schemeOrOptions }
+				: schemeOrOptions || {})
+		};
+
 		/** @type {string} */
-		this.scheme = scheme || DEFAULT_SCHEME;
+		this.scheme = this.options.scheme || DEFAULT_SCHEME;
+		/** @type {VirtualUrlOptions["context"]} */
+		this.context = this.options.context || "auto";
 		/** @type {NormalizedModules} */
-		this.modules = normalizeModules(modules, this.scheme);
+		this.modules = normalizeModules(this.options.modules, this.scheme);
 	}
 
 	/**
@@ -119,6 +129,21 @@ class VirtualUrlPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
+		compiler.hooks.validate.tap(PLUGIN_NAME, () => {
+			compiler.validate(
+				() => require("../../schemas/plugins/schemes/VirtualUrlPlugin.json"),
+				this.options,
+				{
+					name: "Virtual Url Plugin",
+					baseDataPath: "options"
+				},
+				(options) =>
+					require("../../schemas/plugins/schemes/VirtualUrlPlugin.check")(
+						options
+					)
+			);
+		});
+
 		const scheme = this.scheme;
 		const cachedParseResourceWithoutFragment =
 			parseResourceWithoutFragment.bindCache(compiler.root);
@@ -157,10 +182,32 @@ class VirtualUrlPlugin {
 							resourceData.resource
 						);
 						const path = url.path;
-						const type = virtualConfig.type;
+						const type = virtualConfig.type || "";
+						const context = virtualConfig.context || this.context;
+
 						resourceData.path = path + type;
 						resourceData.resource = path;
-						resourceData.context = compiler.context;
+
+						if (context === "auto") {
+							const context = getContext(path);
+							if (context === path) {
+								resourceData.context = compiler.context;
+							} else {
+								const resolvedContext = fromVid(context, scheme);
+								resourceData.context = isAbsolute(resolvedContext)
+									? resolvedContext
+									: join(
+											/** @type {import("..").InputFileSystem} */
+											(compiler.inputFileSystem),
+											compiler.context,
+											resolvedContext
+										);
+							}
+						} else if (context && typeof context === "string") {
+							resourceData.context = context;
+						} else {
+							resourceData.context = compiler.context;
+						}
 
 						if (virtualConfig.version) {
 							const cacheKey = toCacheKey(resourceData.resource, scheme);

package/lib/serialization/FileMiddleware.js

@@ -270,15 +270,15 @@ const deserialize = async (middleware, name, readFile) => {
 			nextContent();
 		}
 		while (contentItemLength - contentPosition < n) {
-			const remaining = contentItem.slice(contentPosition);
+			const remaining = contentItem.subarray(contentPosition);
 			let lengthFromNext = n - remaining.length;
 			/** @type {Buffer[]} */
 			const buffers = [remaining];
 			for (let i = contentsIndex + 1; i < contents.length; i++) {
 				const l = contents[i].length;
 				if (l > lengthFromNext) {
-					buffers.push(contents[i].slice(0, lengthFromNext));
-					contents[i] = contents[i].slice(lengthFromNext);
+					buffers.push(contents[i].subarray(0, lengthFromNext));
+					contents[i] = contents[i].subarray(lengthFromNext);
 					lengthFromNext = 0;
 					break;
 				} else {
@@ -326,7 +326,7 @@ const deserialize = async (middleware, name, readFile) => {
 			}
 			return result;
 		}
-		const result = contentItem.slice(contentPosition, contentPosition + l);
+		const result = contentItem.subarray(contentPosition, contentPosition + l);
 		contentPosition += l;
 		// we clone the buffer here to allow the original content to be garbage collected
 		return l * 2 < contentItem.buffer.byteLength ? Buffer.from(result) : result;
@@ -355,7 +355,7 @@ const deserialize = async (middleware, name, readFile) => {
 		if (length < 0) {
 			const slice = readSlice(-length);
 			const size = Number(readUInt64LE(slice, 0));
-			const nameBuffer = slice.slice(8);
+			const nameBuffer = slice.subarray(8);
 			const name = nameBuffer.toString();
 			const lazy =
 				/** @type {LazyFunction} */
@@ -510,7 +510,7 @@ class FileMiddleware extends SerializerMiddleware {
 									chunks.push(b);
 								} else {
 									for (let i = 0; i < b.length; i += WRITE_LIMIT_CHUNK) {
-										chunks.push(b.slice(i, i + WRITE_LIMIT_CHUNK));
+										chunks.push(b.subarray(i, i + WRITE_LIMIT_CHUNK));
 									}
 								}
 							}
@@ -701,7 +701,7 @@ class FileMiddleware extends SerializerMiddleware {
 								/** @type {number} */ (currentBufferUsed);
 							// values passed to fs.read must be valid int32 values
 							if (readOffset > 0x7fffffff) {
-								readBuffer = currentBuffer.slice(readOffset);
+								readBuffer = currentBuffer.subarray(readOffset);
 								readOffset = 0;
 							}
 							if (readLength > 0x7fffffff) {

package/lib/sharing/ConsumeSharedModule.js

@@ -8,7 +8,10 @@
 const { RawSource } = require("webpack-sources");
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const Module = require("../Module");
-const { CONSUME_SHARED_TYPES } = require("../ModuleSourceTypeConstants");
+const {
+	CONSUME_SHARED_TYPES,
+	JAVASCRIPT_TYPES
+} = require("../ModuleSourceTypeConstants");
 const {
 	WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE
 } = require("../ModuleTypeConstants");
@@ -41,6 +44,7 @@ const fallbackModuleCache = new WeakMap();
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("../util/semver").SemVerRange} SemVerRange */
+/** @typedef {import("../Module").BasicSourceTypes} BasicSourceTypes */
 
 /**
  * @typedef {object} ConsumeOptions
@@ -159,6 +163,19 @@ class ConsumeSharedModule extends Module {
 		return CONSUME_SHARED_TYPES;
 	}
 
+	/**
+	 * Basic source types are high-level categories like javascript, css, webassembly, etc.
+	 * We only have built-in knowledge about the javascript basic type here; other basic types may be
+	 * added or changed over time by generators and do not need to be handled or detected here.
+	 *
+	 * Some modules, e.g. RemoteModule, may return non-basic source types like "remote" and "share-init"
+	 * from getSourceTypes(), but their generated output is still JavaScript, i.e. their basic type is JS.
+	 * @returns {BasicSourceTypes} types available (do not mutate)
+	 */
+	getSourceBasicTypes() {
+		return JAVASCRIPT_TYPES;
+	}
+
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @returns {Module | null} fallback module

package/lib/sharing/ConsumeSharedPlugin.js

@@ -10,7 +10,6 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const WebpackError = require("../WebpackError");
 const { parseOptions } = require("../container/options");
 const LazySet = require("../util/LazySet");
-const createSchemaValidation = require("../util/create-schema-validation");
 const { parseRange } = require("../util/semver");
 const ConsumeSharedFallbackDependency = require("./ConsumeSharedFallbackDependency");
 const ConsumeSharedModule = require("./ConsumeSharedModule");
@@ -32,15 +31,6 @@ const {
 /** @typedef {import("./ConsumeSharedModule").ConsumeOptions} ConsumeOptions */
 /** @typedef {import("./utils").DescriptionFile} DescriptionFile */
 
-const validate = createSchemaValidation(
-	require("../../schemas/plugins/sharing/ConsumeSharedPlugin.check"),
-	() => require("../../schemas/plugins/sharing/ConsumeSharedPlugin.json"),
-	{
-		name: "Consume Shared Plugin",
-		baseDataPath: "options"
-	}
-);
-
 /** @type {ResolveOptionsWithDependencyType} */
 const RESOLVE_OPTIONS = { dependencyType: "esm" };
 const PLUGIN_NAME = "ConsumeSharedPlugin";
@@ -50,13 +40,37 @@ class ConsumeSharedPlugin {
 	 * @param {ConsumeSharedPluginOptions} options options
 	 */
 	constructor(options) {
-		if (typeof options !== "string") {
-			validate(options);
+		this.options = options;
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		// TODO webpack 6 remove string support
+		if (typeof this.options !== "string") {
+			compiler.hooks.validate.tap(PLUGIN_NAME, () => {
+				compiler.validate(
+					() =>
+						require("../../schemas/plugins/sharing/ConsumeSharedPlugin.json"),
+					this.options,
+					{
+						name: "Consume Shared Plugin",
+						baseDataPath: "options"
+					},
+					(options) =>
+						require("../../schemas/plugins/sharing/ConsumeSharedPlugin.check")(
+							options
+						)
+				);
+			});
 		}
 
 		/** @type {[string, ConsumeOptions][]} */
-		this._consumes = parseOptions(
-			options.consumes,
+		const consumes = parseOptions(
+			this.options.consumes,
 			(item, key) => {
 				if (Array.isArray(item)) throw new Error("Unexpected array in options");
 				/** @type {ConsumeOptions} */
@@ -65,7 +79,7 @@ class ConsumeSharedPlugin {
 						? // item is a request/key
 							{
 								import: key,
-								shareScope: options.shareScope || "default",
+								shareScope: this.options.shareScope || "default",
 								shareKey: key,
 								requiredVersion: undefined,
 								packageName: undefined,
@@ -77,7 +91,7 @@ class ConsumeSharedPlugin {
 							// item is a version
 							{
 								import: key,
-								shareScope: options.shareScope || "default",
+								shareScope: this.options.shareScope || "default",
 								shareKey: key,
 								requiredVersion: parseRange(item),
 								strictVersion: true,
@@ -89,7 +103,7 @@ class ConsumeSharedPlugin {
 			},
 			(item, key) => ({
 				import: item.import === false ? undefined : item.import || key,
-				shareScope: item.shareScope || options.shareScope || "default",
+				shareScope: item.shareScope || this.options.shareScope || "default",
 				shareKey: item.shareKey || key,
 				requiredVersion:
 					typeof item.requiredVersion === "string"
@@ -104,14 +118,7 @@ class ConsumeSharedPlugin {
 				eager: Boolean(item.eager)
 			})
 		);
-	}
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
 		compiler.hooks.thisCompilation.tap(
 			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
@@ -128,7 +135,7 @@ class ConsumeSharedPlugin {
 				let resolvedConsumes;
 				/** @type {Consumes} */
 				let prefixedConsumes;
-				const promise = resolveMatchedConfigs(compilation, this._consumes).then(
+				const promise = resolveMatchedConfigs(compilation, consumes).then(
 					({ resolved, unresolved, prefixed }) => {
 						resolvedConsumes = resolved;
 						unresolvedConsumes = unresolved;

package/lib/sharing/ProvideSharedPlugin.js

@@ -7,7 +7,6 @@
 
 const WebpackError = require("../WebpackError");
 const { parseOptions } = require("../container/options");
-const createSchemaValidation = require("../util/create-schema-validation");
 const ProvideForSharedDependency = require("./ProvideForSharedDependency");
 const ProvideSharedDependency = require("./ProvideSharedDependency");
 const ProvideSharedModuleFactory = require("./ProvideSharedModuleFactory");
@@ -17,15 +16,6 @@ const ProvideSharedModuleFactory = require("./ProvideSharedModuleFactory");
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../NormalModuleFactory").NormalModuleCreateData} NormalModuleCreateData */
 
-const validate = createSchemaValidation(
-	require("../../schemas/plugins/sharing/ProvideSharedPlugin.check"),
-	() => require("../../schemas/plugins/sharing/ProvideSharedPlugin.json"),
-	{
-		name: "Provide Shared Plugin",
-		baseDataPath: "options"
-	}
-);
-
 /**
  * @typedef {object} ProvideOptions
  * @property {string} shareKey
@@ -43,11 +33,33 @@ class ProvideSharedPlugin {
 	 * @param {ProvideSharedPluginOptions} options options
 	 */
 	constructor(options) {
-		validate(options);
+		this.options = options;
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.validate.tap(PLUGIN_NAME, () => {
+			compiler.validate(
+				() => require("../../schemas/plugins/sharing/ProvideSharedPlugin.json"),
+				this.options,
+				{
+					name: "Provide Shared Plugin",
+					baseDataPath: "options"
+				},
+				(options) =>
+					require("../../schemas/plugins/sharing/ProvideSharedPlugin.check")(
+						options
+					)
+			);
+		});
 
 		/** @type {[string, ProvideOptions][]} */
-		this._provides = parseOptions(
-			options.provides,
+		const provides = parseOptions(
+			this.options.provides,
 			(item) => {
 				if (Array.isArray(item)) {
 					throw new Error("Unexpected array of provides");
@@ -56,7 +68,7 @@ class ProvideSharedPlugin {
 				const result = {
 					shareKey: item,
 					version: undefined,
-					shareScope: options.shareScope || "default",
+					shareScope: this.options.shareScope || "default",
 					eager: false
 				};
 				return result;
@@ -64,23 +76,15 @@ class ProvideSharedPlugin {
 			(item) => ({
 				shareKey: /** @type {string} */ (item.shareKey),
 				version: item.version,
-				shareScope: item.shareScope || options.shareScope || "default",
+				shareScope: item.shareScope || this.options.shareScope || "default",
 				eager: Boolean(item.eager)
 			})
-		);
-		this._provides.sort(([a], [b]) => {
+		).sort(([a], [b]) => {
 			if (a < b) return -1;
 			if (b < a) return 1;
 			return 0;
 		});
-	}
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
 		/** @type {WeakMap<Compilation, ResolvedProvideMap>} */
 		const compilationData = new WeakMap();
 
@@ -93,7 +97,7 @@ class ProvideSharedPlugin {
 				const matchProvides = new Map();
 				/** @type {Map<string, ProvideOptions>} */
 				const prefixMatchProvides = new Map();
-				for (const [request, config] of this._provides) {
+				for (const [request, config] of provides) {
 					if (/^(?:\/|[A-Z]:\\|\\\\|\.\.?(?:\/|$))/i.test(request)) {
 						// relative request
 						resolvedProvideMap.set(request, {

package/lib/util/AppendOnlyStackedSet.js

@@ -43,7 +43,9 @@ class AppendOnlyStackedSet {
 
 	clear() {
 		this._sets = [];
-		if (this._current) this._current.clear();
+		if (this._current) {
+			this._current = undefined;
+		}
 	}
 
 	/**
@@ -52,6 +54,25 @@ class AppendOnlyStackedSet {
 	createChild() {
 		return new AppendOnlyStackedSet(this._sets.length ? [...this._sets] : []);
 	}
+
+	/**
+	 * @returns {Iterator<T>} iterable iterator
+	 */
+	[Symbol.iterator]() {
+		const iterators = this._sets.map((map) => map[Symbol.iterator]());
+		let current = iterators.pop();
+		return {
+			next() {
+				if (!current) return { done: true, value: undefined };
+				let result = current.next();
+				while (result.done && iterators.length > 0) {
+					current = /** @type {SetIterator<T>} */ (iterators.pop());
+					result = current.next();
+				}
+				return result;
+			}
+		};
+	}
 }
 
 module.exports = AppendOnlyStackedSet;

package/lib/util/{propertyName.js → property.js}

@@ -73,4 +73,29 @@ const propertyName = (prop) => {
 	return JSON.stringify(prop);
 };
 
-module.exports = { RESERVED_IDENTIFIER, SAFE_IDENTIFIER, propertyName };
+/**
+ * @param {ArrayLike<string>} properties properties
+ * @param {number} start start index
+ * @returns {string} chain of property accesses
+ */
+const propertyAccess = (properties, start = 0) => {
+	let str = "";
+	for (let i = start; i < properties.length; i++) {
+		const p = properties[i];
+		if (`${Number(p)}` === p) {
+			str += `[${p}]`;
+		} else if (SAFE_IDENTIFIER.test(p) && !RESERVED_IDENTIFIER.has(p)) {
+			str += `.${p}`;
+		} else {
+			str += `[${JSON.stringify(p)}]`;
+		}
+	}
+	return str;
+};
+
+module.exports = {
+	RESERVED_IDENTIFIER,
+	SAFE_IDENTIFIER,
+	propertyAccess,
+	propertyName
+};

package/lib/wasm-async/AsyncWasmCompileRuntimeModule.js

@@ -0,0 +1,148 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+const Template = require("../Template");
+
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation")} Compilation */
+
+/** @typedef {(wasmModuleSrcPath: string) => string} GenerateBeforeLoadBinaryCode */
+/** @typedef {(wasmModuleSrcPath: string) => string} GenerateLoadBinaryCode */
+/** @typedef {() => string} GenerateBeforeCompileStreaming */
+
+/**
+ * @typedef {object} AsyncWasmCompileRuntimeModuleOptions
+ * @property {GenerateLoadBinaryCode} generateLoadBinaryCode
+ * @property {GenerateBeforeLoadBinaryCode=} generateBeforeLoadBinaryCode
+ * @property {GenerateBeforeCompileStreaming=} generateBeforeCompileStreaming
+ * @property {boolean} supportsStreaming
+ */
+
+class AsyncWasmCompileRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {AsyncWasmCompileRuntimeModuleOptions} options options
+	 */
+	constructor({
+		generateLoadBinaryCode,
+		generateBeforeLoadBinaryCode,
+		generateBeforeCompileStreaming,
+		supportsStreaming
+	}) {
+		super("wasm compile", RuntimeModule.STAGE_NORMAL);
+		/** @type {GenerateLoadBinaryCode} */
+		this.generateLoadBinaryCode = generateLoadBinaryCode;
+		/** @type {GenerateBeforeLoadBinaryCode | undefined} */
+		this.generateBeforeLoadBinaryCode = generateBeforeLoadBinaryCode;
+		/** @type {GenerateBeforeCompileStreaming | undefined} */
+		this.generateBeforeCompileStreaming = generateBeforeCompileStreaming;
+		/** @type {boolean} */
+		this.supportsStreaming = supportsStreaming;
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const chunk = /** @type {Chunk} */ (this.chunk);
+		const { outputOptions, runtimeTemplate } = compilation;
+		const fn = RuntimeGlobals.compileWasm;
+		const wasmModuleSrcPath = compilation.getPath(
+			JSON.stringify(outputOptions.webassemblyModuleFilename),
+			{
+				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
+				hashWithLength: (length) =>
+					`" + ${RuntimeGlobals.getFullHash}}().slice(0, ${length}) + "`,
+				module: {
+					id: '" + wasmModuleId + "',
+					hash: '" + wasmModuleHash + "',
+					hashWithLength(length) {
+						return `" + wasmModuleHash.slice(0, ${length}) + "`;
+					}
+				},
+				runtime: chunk.runtime
+			}
+		);
+
+		const loader = this.generateLoadBinaryCode(wasmModuleSrcPath);
+
+		// Fallback path: fetch -> arrayBuffer -> WebAssembly.compile
+		const fallback = [
+			`.then(${runtimeTemplate.returningFunction("x.arrayBuffer()", "x")})`,
+			`.then(${runtimeTemplate.returningFunction(
+				"WebAssembly.compile(bytes)",
+				"bytes"
+			)})`
+		];
+
+		const getStreaming = () => {
+			/**
+			 * @param {string[]} text text
+			 * @returns {string} merged text
+			 */
+			const concat = (...text) => text.join("");
+			return [
+				this.generateBeforeLoadBinaryCode
+					? this.generateBeforeLoadBinaryCode(wasmModuleSrcPath)
+					: "",
+				`var req = ${loader};`,
+				`var fallback = ${runtimeTemplate.returningFunction(
+					Template.asString(["req", Template.indent(fallback)])
+				)};`,
+				concat(
+					"return req.then(",
+					runtimeTemplate.basicFunction("res", [
+						'if (typeof WebAssembly.compileStreaming === "function") {',
+						Template.indent(
+							this.generateBeforeCompileStreaming
+								? this.generateBeforeCompileStreaming()
+								: ""
+						),
+						Template.indent([
+							"return WebAssembly.compileStreaming(res)",
+							Template.indent([
+								".catch(",
+								Template.indent([
+									runtimeTemplate.basicFunction("e", [
+										'if(res.headers.get("Content-Type") !== "application/wasm") {',
+										Template.indent([
+											'console.warn("`WebAssembly.compileStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.compile` which is slower. Original error:\\n", e);',
+											"return fallback();"
+										]),
+										"}",
+										"throw e;"
+									])
+								]),
+								");"
+							])
+						]),
+						"}",
+						"return fallback();"
+					]),
+					");"
+				)
+			];
+		};
+
+		return `${fn} = ${runtimeTemplate.basicFunction(
+			"wasmModuleId, wasmModuleHash",
+			this.supportsStreaming
+				? getStreaming()
+				: [
+						this.generateBeforeLoadBinaryCode
+							? this.generateBeforeLoadBinaryCode(wasmModuleSrcPath)
+							: "",
+						`return ${loader}`,
+						`${Template.indent(fallback)};`
+					]
+		)};`;
+	}
+}
+
+module.exports = AsyncWasmCompileRuntimeModule;