webpack 5.85.1 → 5.87.0

package/README.md

@@ -232,6 +232,7 @@ or are automatically applied via regex from your webpack configuration.
 |   <a href="https://github.com/webpack-contrib/polymer-webpack-loader"><img width="48" height="48" src="https://worldvectorlogo.com/logos/polymer.svg"></a>   | ![polymer-npm] | ![polymer-size] | Process HTML & CSS with preprocessor of choice and `require()` Web Components like first-class modules |
 | <a href="https://github.com/TheLarkInn/angular2-template-loader"><img width="48" height="48" src="https://worldvectorlogo.com/logos/angular-icon-1.svg"></a> | ![angular-npm] | ![angular-size] | Loads and compiles Angular 2 Components                                                                |
 |              <a href="https://github.com/riot/webpack-loader"><img width="48" height="48" src="https://worldvectorlogo.com/logos/riot.svg"></a>              |  ![riot-npm]   |  ![riot-size]   | Riot official webpack loader                                                                           |
+|          <a href="https://github.com/sveltejs/svelte-loader"><img width="48" height="48" src="https://worldvectorlogo.com/logos/svelte-1.svg"></a>           | ![svelte-npm]  | ![svelte-size]  | Official Svelte loader                                                                                 |
 
 [vue-npm]: https://img.shields.io/npm/v/vue-loader.svg
 [vue-size]: https://packagephobia.com/badge?p=vue-loader
@@ -241,6 +242,8 @@ or are automatically applied via regex from your webpack configuration.
 [angular-size]: https://packagephobia.com/badge?p=angular2-template-loader
 [riot-npm]: https://img.shields.io/npm/v/riot-tag-loader.svg
 [riot-size]: https://packagephobia.com/badge?p=riot-tag-loader
+[svelte-npm]: https://img.shields.io/npm/v/svelte-loader.svg
+[svelte-size]: https://packagephobia.com/badge?p=svelte-loader
 
 ### Performance
 
@@ -714,5 +717,5 @@ src="https://static.monei.net/monei-logo.svg" height="30" alt="MONEI"></a>
 [builds2-url]: https://dev.azure.com/webpack/webpack/_build/latest?definitionId=3
 [licenses-url]: https://app.fossa.io/projects/git%2Bhttps%3A%2F%2Fgithub.com%2Fwebpack%2Fwebpack?ref=badge_shield
 [licenses]: https://app.fossa.io/api/projects/git%2Bhttps%3A%2F%2Fgithub.com%2Fwebpack%2Fwebpack.svg?type=shield
-[cover]: https://img.shields.io/coveralls/webpack/webpack.svg
-[cover-url]: https://coveralls.io/r/webpack/webpack/
+[cover]: https://codecov.io/gh/webpack/webpack/branch/master/graph/badge.svg?token=mDP3mQJNnn
+[cover-url]: https://codecov.io/gh/webpack/webpack

package/lib/APIPlugin.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const InitFragment = require("./InitFragment");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
@@ -14,6 +15,7 @@ const RuntimeGlobals = require("./RuntimeGlobals");
 const WebpackError = require("./WebpackError");
 const ConstDependency = require("./dependencies/ConstDependency");
 const BasicEvaluatedExpression = require("./javascript/BasicEvaluatedExpression");
+const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
 const {
 	toConstantDependency,
 	evaluateToString
@@ -24,103 +26,121 @@ const GetFullHashRuntimeModule = require("./runtime/GetFullHashRuntimeModule");
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
 
-/* eslint-disable camelcase */
-const REPLACEMENTS = {
-	__webpack_require__: {
-		expr: RuntimeGlobals.require,
-		req: [RuntimeGlobals.require],
-		type: "function",
-		assign: false
-	},
-	__webpack_public_path__: {
-		expr: RuntimeGlobals.publicPath,
-		req: [RuntimeGlobals.publicPath],
-		type: "string",
-		assign: true
-	},
-	__webpack_base_uri__: {
-		expr: RuntimeGlobals.baseURI,
-		req: [RuntimeGlobals.baseURI],
-		type: "string",
-		assign: true
-	},
-	__webpack_modules__: {
-		expr: RuntimeGlobals.moduleFactories,
-		req: [RuntimeGlobals.moduleFactories],
-		type: "object",
-		assign: false
-	},
-	__webpack_chunk_load__: {
-		expr: RuntimeGlobals.ensureChunk,
-		req: [RuntimeGlobals.ensureChunk],
-		type: "function",
-		assign: true
-	},
-	__non_webpack_require__: {
-		expr: "require",
-		req: null,
-		type: undefined, // type is not known, depends on environment
-		assign: true
-	},
-	__webpack_nonce__: {
-		expr: RuntimeGlobals.scriptNonce,
-		req: [RuntimeGlobals.scriptNonce],
-		type: "string",
-		assign: true
-	},
-	__webpack_hash__: {
-		expr: `${RuntimeGlobals.getFullHash}()`,
-		req: [RuntimeGlobals.getFullHash],
-		type: "string",
-		assign: false
-	},
-	__webpack_chunkname__: {
-		expr: RuntimeGlobals.chunkName,
-		req: [RuntimeGlobals.chunkName],
-		type: "string",
-		assign: false
-	},
-	__webpack_get_script_filename__: {
-		expr: RuntimeGlobals.getChunkScriptFilename,
-		req: [RuntimeGlobals.getChunkScriptFilename],
-		type: "function",
-		assign: true
-	},
-	__webpack_runtime_id__: {
-		expr: RuntimeGlobals.runtimeId,
-		req: [RuntimeGlobals.runtimeId],
-		assign: false
-	},
-	"require.onError": {
-		expr: RuntimeGlobals.uncaughtErrorHandler,
-		req: [RuntimeGlobals.uncaughtErrorHandler],
-		type: undefined, // type is not known, could be function or undefined
-		assign: true // is never a pattern
-	},
-	__system_context__: {
-		expr: RuntimeGlobals.systemContext,
-		req: [RuntimeGlobals.systemContext],
-		type: "object",
-		assign: false
-	},
-	__webpack_share_scopes__: {
-		expr: RuntimeGlobals.shareScopeMap,
-		req: [RuntimeGlobals.shareScopeMap],
-		type: "object",
-		assign: false
-	},
-	__webpack_init_sharing__: {
-		expr: RuntimeGlobals.initializeSharing,
-		req: [RuntimeGlobals.initializeSharing],
-		type: "function",
-		assign: true
-	}
-};
-/* eslint-enable camelcase */
+/**
+ * @param {boolean} module true if ES module
+ * @param {string} importMetaName `import.meta` name
+ * @returns {Record<string, {expr: string, req: string[], type?: string, assign: boolean}>} replacements
+ */
+function getReplacements(module, importMetaName) {
+	return {
+		__webpack_require__: {
+			expr: RuntimeGlobals.require,
+			req: [RuntimeGlobals.require],
+			type: "function",
+			assign: false
+		},
+		__webpack_public_path__: {
+			expr: RuntimeGlobals.publicPath,
+			req: [RuntimeGlobals.publicPath],
+			type: "string",
+			assign: true
+		},
+		__webpack_base_uri__: {
+			expr: RuntimeGlobals.baseURI,
+			req: [RuntimeGlobals.baseURI],
+			type: "string",
+			assign: true
+		},
+		__webpack_modules__: {
+			expr: RuntimeGlobals.moduleFactories,
+			req: [RuntimeGlobals.moduleFactories],
+			type: "object",
+			assign: false
+		},
+		__webpack_chunk_load__: {
+			expr: RuntimeGlobals.ensureChunk,
+			req: [RuntimeGlobals.ensureChunk],
+			type: "function",
+			assign: true
+		},
+		__non_webpack_require__: {
+			expr: module
+				? `__WEBPACK_EXTERNAL_createRequire(${importMetaName}.url)`
+				: "require",
+			req: null,
+			type: undefined, // type is not known, depends on environment
+			assign: true
+		},
+		__webpack_nonce__: {
+			expr: RuntimeGlobals.scriptNonce,
+			req: [RuntimeGlobals.scriptNonce],
+			type: "string",
+			assign: true
+		},
+		__webpack_hash__: {
+			expr: `${RuntimeGlobals.getFullHash}()`,
+			req: [RuntimeGlobals.getFullHash],
+			type: "string",
+			assign: false
+		},
+		__webpack_chunkname__: {
+			expr: RuntimeGlobals.chunkName,
+			req: [RuntimeGlobals.chunkName],
+			type: "string",
+			assign: false
+		},
+		__webpack_get_script_filename__: {
+			expr: RuntimeGlobals.getChunkScriptFilename,
+			req: [RuntimeGlobals.getChunkScriptFilename],
+			type: "function",
+			assign: true
+		},
+		__webpack_runtime_id__: {
+			expr: RuntimeGlobals.runtimeId,
+			req: [RuntimeGlobals.runtimeId],
+			assign: false
+		},
+		"require.onError": {
+			expr: RuntimeGlobals.uncaughtErrorHandler,
+			req: [RuntimeGlobals.uncaughtErrorHandler],
+			type: undefined, // type is not known, could be function or undefined
+			assign: true // is never a pattern
+		},
+		__system_context__: {
+			expr: RuntimeGlobals.systemContext,
+			req: [RuntimeGlobals.systemContext],
+			type: "object",
+			assign: false
+		},
+		__webpack_share_scopes__: {
+			expr: RuntimeGlobals.shareScopeMap,
+			req: [RuntimeGlobals.shareScopeMap],
+			type: "object",
+			assign: false
+		},
+		__webpack_init_sharing__: {
+			expr: RuntimeGlobals.initializeSharing,
+			req: [RuntimeGlobals.initializeSharing],
+			type: "function",
+			assign: true
+		}
+	};
+}
 
 const PLUGIN_NAME = "APIPlugin";
 
+/**
+ * @typedef {Object} APIPluginOptions
+ * @property {boolean} [module] the output filename
+ */
+
 class APIPlugin {
+	/**
+	 * @param {APIPluginOptions} [options] options
+	 */
+	constructor(options = {}) {
+		this.options = options;
+	}
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -130,6 +150,12 @@ class APIPlugin {
 		compiler.hooks.compilation.tap(
 			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
+				const { importMetaName } = compilation.outputOptions;
+				const REPLACEMENTS = getReplacements(
+					this.options.module,
+					importMetaName
+				);
+
 				compilation.dependencyTemplates.set(
 					ConstDependency,
 					new ConstDependency.Template()
@@ -152,18 +178,43 @@ class APIPlugin {
 						return true;
 					});
 
+				const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
+
+				hooks.renderModuleContent.tap(
+					PLUGIN_NAME,
+					(source, module, renderContext) => {
+						if (module.buildInfo.needCreateRequire) {
+							const chunkInitFragments = [
+								new InitFragment(
+									'import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "module";\n',
+									InitFragment.STAGE_HARMONY_IMPORTS,
+									0,
+									"external module node-commonjs"
+								)
+							];
+
+							renderContext.chunkInitFragments.push(...chunkInitFragments);
+						}
+
+						return source;
+					}
+				);
+
 				/**
 				 * @param {JavascriptParser} parser the parser
 				 */
 				const handler = parser => {
 					Object.keys(REPLACEMENTS).forEach(key => {
 						const info = REPLACEMENTS[key];
-						parser.hooks.expression
-							.for(key)
-							.tap(
-								PLUGIN_NAME,
-								toConstantDependency(parser, info.expr, info.req)
-							);
+						parser.hooks.expression.for(key).tap(PLUGIN_NAME, expression => {
+							const dep = toConstantDependency(parser, info.expr, info.req);
+
+							if (key === "__non_webpack_require__" && this.options.module) {
+								parser.state.module.buildInfo.needCreateRequire = true;
+							}
+
+							return dep(expression);
+						});
 						if (info.assign === false) {
 							parser.hooks.assign.for(key).tap(PLUGIN_NAME, expr => {
 								const err = new WebpackError(`${key} must not be assigned`);

package/lib/CaseSensitiveModulesWarning.js

@@ -42,7 +42,9 @@ const createModulesListMessage = (modules, moduleGraph) => {
 
 			if (validReasons.length > 0) {
 				message += `\n    Used by ${validReasons.length} module(s), i. e.`;
-				message += `\n    ${validReasons[0].identifier()}`;
+				message += `\n    ${
+					/** @type {Module[]} */ (validReasons)[0].identifier()
+				}`;
 			}
 			return message;
 		})

package/lib/Chunk.js

@@ -23,6 +23,7 @@ const { mergeRuntime } = require("./util/runtime");
 /** @typedef {import("./ChunkGraph").ChunkSizeOptions} ChunkSizeOptions */
 /** @typedef {import("./ChunkGraph").ModuleFilterPredicate} ModuleFilterPredicate */
 /** @typedef {import("./ChunkGroup")} ChunkGroup */
+/** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Compilation").AssetInfo} AssetInfo */
 /** @typedef {import("./Compilation").PathData} PathData */
@@ -32,6 +33,8 @@ const { mergeRuntime } = require("./util/runtime");
 /** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
+/** @typedef {number | string} ChunkId */
+
 const ChunkFilesSet = createArrayToSetDeprecationSet("chunk.files");
 
 /**
@@ -66,21 +69,21 @@ class Chunk {
 	 * @param {boolean} backCompat enable backward-compatibility
 	 */
 	constructor(name, backCompat = true) {
-		/** @type {number | string | null} */
+		/** @type {ChunkId | null} */
 		this.id = null;
-		/** @type {(number|string)[] | null} */
+		/** @type {ChunkId[] | null} */
 		this.ids = null;
 		/** @type {number} */
 		this.debugId = debugId++;
-		/** @type {string} */
+		/** @type {string | undefined} */
 		this.name = name;
 		/** @type {SortableSet<string>} */
 		this.idNameHints = new SortableSet();
 		/** @type {boolean} */
 		this.preventIntegration = false;
-		/** @type {(string | function(PathData, AssetInfo=): string)?} */
+		/** @type {(string | function(PathData, AssetInfo=): string) | undefined} */
 		this.filenameTemplate = undefined;
-		/** @type {(string | function(PathData, AssetInfo=): string)?} */
+		/** @type {(string | function(PathData, AssetInfo=): string) | undefined} */
 		this.cssFilenameTemplate = undefined;
 		/** @private @type {SortableSet<ChunkGroup>} */
 		this._groups = new SortableSet(undefined, compareChunkGroupsByIndex);
@@ -350,7 +353,7 @@ class Chunk {
 		const chunkModuleHashMap = Object.create(null);
 
 		for (const asyncChunk of this.getAllAsyncChunks()) {
-			/** @type {(string|number)[]} */
+			/** @type {ChunkId[] | undefined} */
 			let array;
 			for (const module of chunkGraph.getOrderedChunkModulesIterable(
 				asyncChunk,
@@ -359,7 +362,7 @@ class Chunk {
 				if (filterFn(module)) {
 					if (array === undefined) {
 						array = [];
-						chunkModuleIdMap[asyncChunk.id] = array;
+						chunkModuleIdMap[/** @type {ChunkId} */ (asyncChunk.id)] = array;
 					}
 					const moduleId = chunkGraph.getModuleId(module);
 					array.push(moduleId);
@@ -405,15 +408,18 @@ class Chunk {
 		const chunkNameMap = Object.create(null);
 
 		for (const chunk of this.getAllAsyncChunks()) {
-			chunkHashMap[chunk.id] = realHash ? chunk.hash : chunk.renderedHash;
+			const id = /** @type {ChunkId} */ (chunk.id);
+			chunkHashMap[id] =
+				/** @type {string} */
+				(realHash ? chunk.hash : chunk.renderedHash);
 			for (const key of Object.keys(chunk.contentHash)) {
 				if (!chunkContentHashMap[key]) {
 					chunkContentHashMap[key] = Object.create(null);
 				}
-				chunkContentHashMap[key][chunk.id] = chunk.contentHash[key];
+				chunkContentHashMap[key][id] = chunk.contentHash[key];
 			}
 			if (chunk.name) {
-				chunkNameMap[chunk.id] = chunk.name;
+				chunkNameMap[id] = chunk.name;
 			}
 		}
 
@@ -553,7 +559,11 @@ class Chunk {
 		const entryModules =
 			chunkGraph.getChunkEntryModulesWithChunkGroupIterable(this);
 		for (const [m, chunkGroup] of entryModules) {
-			hash.update(`entry${chunkGraph.getModuleId(m)}${chunkGroup.id}`);
+			hash.update(
+				`entry${chunkGraph.getModuleId(m)}${
+					/** @type {ChunkGroup} */ (chunkGroup).id
+				}`
+			);
 		}
 	}
 
@@ -697,7 +707,13 @@ class Chunk {
 								lists.set(name, list);
 							}
 							list.push({
-								order: childGroup.options[key],
+								order:
+									/** @type {number} */
+									(
+										childGroup.options[
+											/** @type {keyof ChunkGroupOptions} */ (key)
+										]
+									),
 								group: childGroup
 							});
 						}
@@ -718,7 +734,7 @@ class Chunk {
 			for (const item of list) {
 				for (const chunk of item.group.chunks) {
 					if (filterFn && !filterFn(chunk, chunkGraph)) continue;
-					chunkIdSet.add(chunk.id);
+					chunkIdSet.add(/** @type {ChunkId} */ (chunk.id));
 				}
 			}
 			if (chunkIdSet.size > 0) {
@@ -731,13 +747,14 @@ class Chunk {
 	/**
 	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @param {string} type option name
-	 * @returns {{ onChunks: Chunk[], chunks: Set<Chunk> }[]} referenced chunks for a specific type
+	 * @returns {{ onChunks: Chunk[], chunks: Set<Chunk> }[] | undefined} referenced chunks for a specific type
 	 */
 	getChildrenOfTypeInOrder(chunkGraph, type) {
 		const list = [];
 		for (const group of this.groupsIterable) {
 			for (const childGroup of group.childrenIterable) {
-				const order = childGroup.options[type];
+				const order =
+					childGroup.options[/** @type {keyof ChunkGroupOptions} */ (type)];
 				if (order === undefined) continue;
 				list.push({
 					order,
@@ -748,7 +765,8 @@ class Chunk {
 		}
 		if (list.length === 0) return undefined;
 		list.sort((a, b) => {
-			const cmp = b.order - a.order;
+			const cmp =
+				/** @type {number} */ (b.order) - /** @type {number} */ (a.order);
 			if (cmp !== 0) return cmp;
 			return a.group.compareTo(chunkGraph, b.group);
 		});
@@ -792,7 +810,7 @@ class Chunk {
 				if (chunkMap === undefined) {
 					chunkMaps[key] = chunkMap = Object.create(null);
 				}
-				chunkMap[chunk.id] = data[key];
+				chunkMap[/** @type {ChunkId} */ (chunk.id)] = data[key];
 			}
 		};
 

package/lib/ChunkGroup.js

@@ -28,6 +28,7 @@ const {
  * @typedef {Object} RawChunkGroupOptions
  * @property {number=} preloadOrder
  * @property {number=} prefetchOrder
+ * @property {("low" | "high" | "auto")=} fetchPriority
  */
 
 /** @typedef {RawChunkGroupOptions & { name?: string }} ChunkGroupOptions */
@@ -97,7 +98,7 @@ class ChunkGroup {
 		/** Indices in bottom-up order */
 		/** @private @type {Map<Module, number>} */
 		this._modulePostOrderIndices = new Map();
-		/** @type {number} */
+		/** @type {number | undefined} */
 		this.index = undefined;
 	}
 
@@ -124,7 +125,7 @@ class ChunkGroup {
 
 	/**
 	 * returns the name of current ChunkGroup
-	 * @returns {string|undefined} returns the ChunkGroup name
+	 * @returns {string | undefined} returns the ChunkGroup name
 	 */
 	get name() {
 		return this.options.name;
@@ -132,7 +133,7 @@ class ChunkGroup {
 
 	/**
 	 * sets a new name for current ChunkGroup
-	 * @param {string} value the new name for ChunkGroup
+	 * @param {string | undefined} value the new name for ChunkGroup
 	 * @returns {void}
 	 */
 	set name(value) {
@@ -496,7 +497,11 @@ class ChunkGroup {
 						lists.set(name, (list = []));
 					}
 					list.push({
-						order: childGroup.options[key],
+						order:
+							/** @type {number} */
+							(
+								childGroup.options[/** @type {keyof ChunkGroupOptions} */ (key)]
+							),
 						group: childGroup
 					});
 				}
@@ -528,7 +533,7 @@ class ChunkGroup {
 	/**
 	 * Gets the top-down index of a module in this ChunkGroup
 	 * @param {Module} module the module
-	 * @returns {number} index
+	 * @returns {number | undefined} index
 	 */
 	getModulePreOrderIndex(module) {
 		return this._modulePreOrderIndices.get(module);
@@ -547,7 +552,7 @@ class ChunkGroup {
 	/**
 	 * Gets the bottom-up index of a module in this ChunkGroup
 	 * @param {Module} module the module
-	 * @returns {number} index
+	 * @returns {number | undefined} index
 	 */
 	getModulePostOrderIndex(module) {
 		return this._modulePostOrderIndices.get(module);

package/lib/Compiler.js

@@ -1011,8 +1011,7 @@ ${other}`);
 				try {
 					this.records = parseJson(content.toString("utf-8"));
 				} catch (e) {
-					e.message = "Cannot parse records: " + e.message;
-					return callback(e);
+					return callback(new Error(`Cannot parse records: ${e.message}`));
 				}
 
 				return callback();
@@ -1074,7 +1073,9 @@ ${other}`);
 		childCompiler.root = this.root;
 		if (Array.isArray(plugins)) {
 			for (const plugin of plugins) {
-				plugin.apply(childCompiler);
+				if (plugin) {
+					plugin.apply(childCompiler);
+				}
 			}
 		}
 		for (const name in this.hooks) {

package/lib/ConcatenationScope.js

@@ -108,7 +108,7 @@ class ConcatenationScope {
 		module,
 		{ ids = undefined, call = false, directImport = false, asiSafe = false }
 	) {
-		const info = this._modulesMap.get(module);
+		const info = /** @type {ModuleInfo} */ (this._modulesMap.get(module));
 		const callFlag = call ? "_call" : "";
 		const directImportFlag = directImport ? "_directImport" : "";
 		const asiSafeFlag = asiSafe
@@ -133,7 +133,7 @@ class ConcatenationScope {
 
 	/**
 	 * @param {string} name the identifier
-	 * @returns {ModuleReferenceOptions & { index: number }} parsed options and index
+	 * @returns {ModuleReferenceOptions & { index: number } | null} parsed options and index
 	 */
 	static matchModuleReference(name) {
 		const match = MODULE_REFERENCE_REGEXP.exec(name);

package/lib/ConditionalInitFragment.js

@@ -14,6 +14,11 @@ const { mergeRuntime } = require("./util/runtime");
 /** @typedef {import("./Generator").GenerateContext} GenerateContext */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
+/**
+ * @param {string} condition condition
+ * @param {string | Source} source source
+ * @returns {string | Source} wrapped source
+ */
 const wrapInCondition = (condition, source) => {
 	if (typeof source === "string") {
 		return Template.asString([
@@ -33,13 +38,14 @@ const wrapInCondition = (condition, source) => {
 
 /**
  * @typedef {GenerateContext} Context
+ * @extends {InitFragment<Context>}
  */
 class ConditionalInitFragment extends InitFragment {
 	/**
 	 * @param {string|Source} content the source code that will be included as initialization code
 	 * @param {number} stage category of initialization code (contribute to order)
 	 * @param {number} position position in the category (contribute to order)
-	 * @param {string} key unique key to avoid emitting the same initialization code twice
+	 * @param {string | undefined} key unique key to avoid emitting the same initialization code twice
 	 * @param {RuntimeSpec | boolean} runtimeCondition in which runtime this fragment should be executed
 	 * @param {string|Source=} endContent the source code that will be included at the end of the module
 	 */
@@ -89,6 +95,10 @@ class ConditionalInitFragment extends InitFragment {
 		return wrapInCondition(expr, this.endContent);
 	}
 
+	/**
+	 * @param {ConditionalInitFragment} other fragment to merge with
+	 * @returns {ConditionalInitFragment} merged fragment
+	 */
 	merge(other) {
 		if (this.runtimeCondition === true) return this;
 		if (other.runtimeCondition === true) return other;