webpack 5.93.0 → 5.94.0

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -50,7 +50,7 @@ const harmonySpecifierTag = Symbol("harmony import");
 
 /**
  * @param {ImportDeclaration | ExportNamedDeclaration | ExportAllDeclaration | (ImportExpression & { arguments?: ObjectExpression[] })} node node with assertions
- * @returns {ImportAttributes} import attributes
+ * @returns {ImportAttributes | undefined} import attributes
  */
 function getAttributes(node) {
 	if (
@@ -96,7 +96,7 @@ function getAttributes(node) {
 		? /** @type {{ assertions?: ImportAttributeNode[] }} */ (node).assertions
 		: /** @type {{ attributes?: ImportAttributeNode[] }} */ (node).attributes;
 	if (attributes === undefined) {
-		return undefined;
+		return;
 	}
 	const result = /** @type {ImportAttributes} */ ({});
 	for (const attribute of attributes) {
@@ -138,12 +138,22 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 	apply(parser) {
 		const { exportPresenceMode } = this;
 
+		/**
+		 * @param {string[]} members members
+		 * @param {boolean[]} membersOptionals members Optionals
+		 * @returns {string[]} a non optional part
+		 */
 		function getNonOptionalPart(members, membersOptionals) {
 			let i = 0;
 			while (i < members.length && membersOptionals[i] === false) i++;
 			return i !== members.length ? members.slice(0, i) : members;
 		}
 
+		/**
+		 * @param {TODO} node member expression
+		 * @param {number} count count
+		 * @returns {TODO} member expression
+		 */
 		function getNonOptionalMemberChain(node, count) {
 			while (count--) node = node.object;
 			return node;
@@ -221,7 +231,9 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 				)
 					return;
 				const settings = rootInfo.tagInfo.data;
-				const members = rightPart.getMembers();
+				const members =
+					/** @type {(() => string[])} */
+					(rightPart.getMembers)();
 				const dep = new HarmonyEvaluatedImportSpecifierDependency(
 					settings.source,
 					settings.sourceOrder,
@@ -280,6 +292,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 						members,
 						membersOptionals
 					);
+					/** @type {Range[]} */
 					const ranges = memberRanges.slice(
 						0,
 						memberRanges.length - (members.length - nonOptionalMembers.length)
@@ -326,6 +339,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 						members,
 						membersOptionals
 					);
+					/** @type {Range[]} */
 					const ranges = memberRanges.slice(
 						0,
 						memberRanges.length - (members.length - nonOptionalMembers.length)
@@ -355,7 +369,8 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 					);
 					// only in case when we strictly follow the spec we need a special case here
 					dep.namespaceObjectAsContext =
-						members.length > 0 && this.strictThisContextOnImports;
+						members.length > 0 &&
+						/** @type {boolean} */ (this.strictThisContextOnImports);
 					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 					parser.state.module.addDependency(dep);
 					if (args) parser.walkExpressions(args);

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -42,7 +42,7 @@ const { ExportPresenceModes } = HarmonyImportDependency;
 
 class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	/**
-	 * @param {TODO} request request
+	 * @param {string} request request
 	 * @param {number} sourceOrder source order
 	 * @param {string[]} ids ids
 	 * @param {string} name name
@@ -67,7 +67,6 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		this.range = range;
 		this.idRanges = idRanges;
 		this.exportPresenceMode = exportPresenceMode;
-		/** @type {boolean | undefined} */
 		this.namespaceObjectAsContext = false;
 		this.call = undefined;
 		this.directImport = undefined;
@@ -105,7 +104,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	getIds(moduleGraph) {
 		const meta = moduleGraph.getMetaIfExisting(this);
 		if (meta === undefined) return this.ids;
-		const ids = meta[idsSymbol];
+		const ids = meta[/** @type {keyof object} */ (idsSymbol)];
 		return ids !== undefined ? ids : this.ids;
 	}
 
@@ -149,7 +148,9 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		if (ids.length === 0) return this._getReferencedExportsInDestructuring();
 		let namespaceObjectAsContext = this.namespaceObjectAsContext;
 		if (ids[0] === "default") {
-			const selfModule = moduleGraph.getParentModule(this);
+			const selfModule =
+				/** @type {Module} */
+				(moduleGraph.getParentModule(this));
 			const importedModule =
 				/** @type {Module} */
 				(moduleGraph.getModule(this));
@@ -196,9 +197,8 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 				refs.push(ids ? ids.concat([id]) : [id]);
 			}
 			return refs;
-		} else {
-			return ids ? [ids] : Dependency.EXPORTS_OBJECT_REFERENCED;
 		}
+		return ids ? [ids] : Dependency.EXPORTS_OBJECT_REFERENCED;
 	}
 
 	/**
@@ -208,9 +208,12 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	_getEffectiveExportPresenceLevel(moduleGraph) {
 		if (this.exportPresenceMode !== ExportPresenceModes.AUTO)
 			return this.exportPresenceMode;
-		const buildMeta = /** @type {BuildMeta} */ (
-			moduleGraph.getParentModule(this).buildMeta
-		);
+		const buildMeta =
+			/** @type {BuildMeta} */
+			(
+				/** @type {Module} */
+				(moduleGraph.getParentModule(this)).buildMeta
+			);
 		return buildMeta.strictHarmonyModule
 			? ExportPresenceModes.ERROR
 			: ExportPresenceModes.WARN;
@@ -344,14 +347,34 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 		}
 
 		if (dep.referencedPropertiesInDestructuring) {
-			const prefixedIds = ids[0] === "default" ? ids.slice(1) : ids;
-			for (let {
+			let prefixedIds = ids;
+
+			if (ids[0] === "default") {
+				const selfModule = moduleGraph.getParentModule(dep);
+				const importedModule =
+					/** @type {Module} */
+					(moduleGraph.getModule(dep));
+				const exportsType = importedModule.getExportsType(
+					moduleGraph,
+					/** @type {BuildMeta} */
+					(selfModule.buildMeta).strictHarmonyModule
+				);
+				if (
+					(exportsType === "default-only" ||
+						exportsType === "default-with-named") &&
+					ids.length >= 1
+				) {
+					prefixedIds = ids.slice(1);
+				}
+			}
+
+			for (const {
 				id,
 				shorthand,
 				range
 			} of dep.referencedPropertiesInDestructuring) {
 				const concatedIds = prefixedIds.concat([id]);
-				const module = moduleGraph.getModule(dep);
+				const module = /** @type {Module} */ (moduleGraph.getModule(dep));
 				const used = moduleGraph
 					.getExportsInfo(module)
 					.getUsedName(concatedIds, runtime);
@@ -360,11 +383,13 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 				const name = concatedIds[concatedIds.length - 1];
 				if (newName === name) continue;
 
-				const comment = Template.toNormalComment(name) + " ";
+				const comment = `${Template.toNormalComment(name)} `;
 				const key = comment + JSON.stringify(newName);
 				source.replace(
-					range[0],
-					range[1] - 1,
+					/** @type {Range} */
+					(range)[0],
+					/** @type {Range} */
+					(range)[1] - 1,
 					shorthand ? `${key}: ${name}` : `${key}`
 				);
 			}

package/lib/dependencies/ImportDependency.js

@@ -124,7 +124,7 @@ ImportDependency.Template = class ImportDependencyTemplate extends (
 		);
 		const content = runtimeTemplate.moduleNamespacePromise({
 			chunkGraph,
-			block: block,
+			block,
 			module: /** @type {Module} */ (moduleGraph.getModule(dep)),
 			request: dep.request,
 			strict: /** @type {BuildMeta} */ (module.buildMeta).strictHarmonyModule,

package/lib/dependencies/ImportMetaContextDependencyParserPlugin.js

@@ -57,14 +57,14 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 	apply(parser) {
 		parser.hooks.evaluateIdentifier
 			.for("import.meta.webpackContext")
-			.tap("ImportMetaContextDependencyParserPlugin", expr => {
-				return evaluateToIdentifier(
+			.tap("ImportMetaContextDependencyParserPlugin", expr =>
+				evaluateToIdentifier(
 					"import.meta.webpackContext",
 					"import.meta",
 					() => ["webpackContext"],
 					true
-				)(expr);
-			});
+				)(expr)
+			);
 		parser.hooks.call
 			.for("import.meta.webpackContext")
 			.tap("ImportMetaContextDependencyParserPlugin", expr => {
@@ -293,7 +293,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 					/** @type {Range} */ (expr.range)
 				);
 				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-				dep.optional = !!parser.scope.inTry;
+				dep.optional = Boolean(parser.scope.inTry);
 				parser.state.current.addDependency(dep);
 				return true;
 			});

package/lib/dependencies/ImportMetaPlugin.js

@@ -49,9 +49,7 @@ class ImportMetaPlugin {
 				 * @param {NormalModule} module module
 				 * @returns {string} file url
 				 */
-				const getUrl = module => {
-					return pathToFileURL(module.resource).toString();
-				};
+				const getUrl = module => pathToFileURL(module.resource).toString();
 				/**
 				 * @param {Parser} parser parser parser
 				 * @param {JavascriptParserOptions} parserOptions parserOptions
@@ -76,8 +74,8 @@ class ImportMetaPlugin {
 						return;
 					}
 
-					/// import.meta direct ///
-					const webpackVersion = parseInt(
+					// import.meta direct
+					const webpackVersion = Number.parseInt(
 						require("../../package.json").version,
 						10
 					);
@@ -90,7 +88,7 @@ class ImportMetaPlugin {
 					 */
 					const importMetaUnknownProperty = members =>
 						`${Template.toNormalComment(
-							"unsupported import.meta." + members.join(".")
+							`unsupported import.meta.${members.join(".")}`
 						)} undefined${propertyAccess(members, 1)}`;
 					parser.hooks.typeof
 						.for("import.meta")
@@ -162,7 +160,7 @@ class ImportMetaPlugin {
 						evaluateToIdentifier("import.meta", "import.meta", () => [], true)
 					);
 
-					/// import.meta.url ///
+					// import.meta.url
 					parser.hooks.typeof
 						.for("import.meta.url")
 						.tap(
@@ -185,13 +183,13 @@ class ImportMetaPlugin {
 						.tap(PLUGIN_NAME, evaluateToString("string"));
 					parser.hooks.evaluateIdentifier
 						.for("import.meta.url")
-						.tap(PLUGIN_NAME, expr => {
-							return new BasicEvaluatedExpression()
+						.tap(PLUGIN_NAME, expr =>
+							new BasicEvaluatedExpression()
 								.setString(getUrl(parser.state.module))
-								.setRange(/** @type {Range} */ (expr.range));
-						});
+								.setRange(/** @type {Range} */ (expr.range))
+						);
 
-					/// import.meta.webpack ///
+					// import.meta.webpack
 					parser.hooks.typeof
 						.for("import.meta.webpack")
 						.tap(
@@ -211,7 +209,7 @@ class ImportMetaPlugin {
 						.for("import.meta.webpack")
 						.tap(PLUGIN_NAME, evaluateToNumber(webpackVersion));
 
-					/// Unknown properties ///
+					// Unknown properties
 					parser.hooks.unhandledExpressionMemberChain
 						.for("import.meta")
 						.tap(PLUGIN_NAME, (expr, members) => {

package/lib/dependencies/ImportParserPlugin.js

@@ -100,11 +100,9 @@ class ImportParserPlugin {
 								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
-					} else {
+					} else if (importOptions.webpackIgnore) {
 						// Do not instrument `import()` if `webpackIgnore` is `true`
-						if (importOptions.webpackIgnore) {
-							return false;
-						}
+						return false;
 					}
 				}
 				if (importOptions.webpackChunkName !== undefined) {
@@ -220,12 +218,10 @@ class ImportParserPlugin {
 								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
+					} else if (typeof importOptions.webpackExports === "string") {
+						exports = [[importOptions.webpackExports]];
 					} else {
-						if (typeof importOptions.webpackExports === "string") {
-							exports = [[importOptions.webpackExports]];
-						} else {
-							exports = exportsFromEnumerable(importOptions.webpackExports);
-						}
+						exports = exportsFromEnumerable(importOptions.webpackExports);
 					}
 				}
 			}
@@ -251,7 +247,7 @@ class ImportParserPlugin {
 				if (exports) {
 					parser.state.module.addWarning(
 						new UnsupportedFeatureWarning(
-							`\`webpackExports\` could not be used with destructuring assignment.`,
+							"`webpackExports` could not be used with destructuring assignment.",
 							/** @type {DependencyLocation} */ (expr.loc)
 						)
 					);
@@ -296,45 +292,44 @@ class ImportParserPlugin {
 						attributes
 					);
 					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-					dep.optional = !!parser.scope.inTry;
+					dep.optional = Boolean(parser.scope.inTry);
 					depBlock.addDependency(dep);
 					parser.state.current.addBlock(depBlock);
 				}
 				return true;
-			} else {
-				if (mode === "weak") {
-					mode = "async-weak";
-				}
-				const dep = ContextDependencyHelpers.create(
-					ImportContextDependency,
-					/** @type {Range} */ (expr.range),
-					param,
-					expr,
-					this.options,
-					{
-						chunkName,
-						groupOptions,
-						include,
-						exclude,
-						mode,
-						namespaceObject: /** @type {BuildMeta} */ (
-							parser.state.module.buildMeta
-						).strictHarmonyModule
-							? "strict"
-							: true,
-						typePrefix: "import()",
-						category: "esm",
-						referencedExports: exports,
-						attributes: getAttributes(expr)
-					},
-					parser
-				);
-				if (!dep) return;
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-				dep.optional = !!parser.scope.inTry;
-				parser.state.current.addDependency(dep);
-				return true;
 			}
+			if (mode === "weak") {
+				mode = "async-weak";
+			}
+			const dep = ContextDependencyHelpers.create(
+				ImportContextDependency,
+				/** @type {Range} */ (expr.range),
+				param,
+				expr,
+				this.options,
+				{
+					chunkName,
+					groupOptions,
+					include,
+					exclude,
+					mode,
+					namespaceObject: /** @type {BuildMeta} */ (
+						parser.state.module.buildMeta
+					).strictHarmonyModule
+						? "strict"
+						: true,
+					typePrefix: "import()",
+					category: "esm",
+					referencedExports: exports,
+					attributes: getAttributes(expr)
+				},
+				parser
+			);
+			if (!dep) return;
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.optional = Boolean(parser.scope.inTry);
+			parser.state.current.addDependency(dep);
+			return true;
 		});
 	}
 }

package/lib/dependencies/JsonExportsDependency.js

@@ -14,33 +14,35 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../json/JsonData")} JsonData */
+/** @typedef {import("../json/JsonData").RawJsonData} RawJsonData */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 
+/**
+ * @param {RawJsonData} data data
+ * @returns {TODO} value
+ */
 const getExportsFromData = data => {
 	if (data && typeof data === "object") {
 		if (Array.isArray(data)) {
 			return data.length < 100
-				? data.map((item, idx) => {
-						return {
-							name: `${idx}`,
-							canMangle: true,
-							exports: getExportsFromData(item)
-						};
-					})
+				? data.map((item, idx) => ({
+						name: `${idx}`,
+						canMangle: true,
+						exports: getExportsFromData(item)
+					}))
 				: undefined;
-		} else {
-			const exports = [];
-			for (const key of Object.keys(data)) {
-				exports.push({
-					name: key,
-					canMangle: true,
-					exports: getExportsFromData(data[key])
-				});
-			}
-			return exports;
 		}
+		const exports = [];
+		for (const key of Object.keys(data)) {
+			exports.push({
+				name: key,
+				canMangle: true,
+				exports: getExportsFromData(data[key])
+			});
+		}
+		return exports;
 	}
 	return undefined;
 };
@@ -65,7 +67,9 @@ class JsonExportsDependency extends NullDependency {
 	 */
 	getExports(moduleGraph) {
 		return {
-			exports: getExportsFromData(this.data && this.data.get()),
+			exports: getExportsFromData(
+				this.data && /** @type {RawJsonData} */ (this.data.get())
+			),
 			dependencies: undefined
 		};
 	}

package/lib/dependencies/LoaderPlugin.js

@@ -10,17 +10,12 @@ const LazySet = require("../util/LazySet");
 const LoaderDependency = require("./LoaderDependency");
 const LoaderImportDependency = require("./LoaderImportDependency");
 
+/** @typedef {import("../../declarations/LoaderContext").LoaderPluginLoaderContext} LoaderPluginLoaderContext */
 /** @typedef {import("../Compilation").DepConstructor} DepConstructor */
+/** @typedef {import("../Compilation").ExecuteModuleResult} ExecuteModuleResult */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
-
-/**
- * @callback LoadModuleCallback
- * @param {(Error | null)=} err error object
- * @param {string | Buffer=} source source code
- * @param {object=} map source map
- * @param {Module=} module loaded module if successful
- */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
 
 /**
  * @callback ImportModuleCallback
@@ -66,11 +61,6 @@ class LoaderPlugin {
 			NormalModule.getCompilationHooks(compilation).loader.tap(
 				"LoaderPlugin",
 				loaderContext => {
-					/**
-					 * @param {string} request the request string to load the module from
-					 * @param {LoadModuleCallback} callback callback returning the loaded module or error
-					 * @returns {void}
-					 */
 					loaderContext.loadModule = (request, callback) => {
 						const dep = new LoaderDependency(request);
 						dep.loc = {
@@ -91,7 +81,9 @@ class LoaderPlugin {
 							{
 								factory,
 								dependencies: [dep],
-								originModule: loaderContext._module,
+								originModule:
+									/** @type {NormalModule} */
+									(loaderContext._module),
 								context: loaderContext.context,
 								recursive: false
 							},
@@ -117,7 +109,8 @@ class LoaderPlugin {
 										)
 									);
 								}
-								let source, map;
+								let map;
+								let source;
 								if (moduleSource.sourceAndMap) {
 									const sourceAndMap = moduleSource.sourceAndMap();
 									map = sourceAndMap.map;
@@ -149,15 +142,20 @@ class LoaderPlugin {
 								for (const d of buildDependencies) {
 									loaderContext.addBuildDependency(d);
 								}
-								return callback(null, source, map, referencedModule);
+								return callback(
+									null,
+									source,
+									/** @type {object | null} */ (map),
+									referencedModule
+								);
 							}
 						);
 					};
 
 					/**
 					 * @param {string} request the request string to load the module from
-					 * @param {ImportModuleOptions=} options options
-					 * @param {ImportModuleCallback=} callback callback returning the exports
+					 * @param {ImportModuleOptions} options options
+					 * @param {ImportModuleCallback} callback callback returning the exports
 					 * @returns {void}
 					 */
 					const importModule = (request, options, callback) => {
@@ -180,7 +178,9 @@ class LoaderPlugin {
 							{
 								factory,
 								dependencies: [dep],
-								originModule: loaderContext._module,
+								originModule:
+									/** @type {NormalModule} */
+									(loaderContext._module),
 								contextInfo: {
 									issuerLayer: options.layer
 								},
@@ -207,42 +207,53 @@ class LoaderPlugin {
 									},
 									(err, result) => {
 										if (err) return callback(err);
-										for (const d of result.fileDependencies) {
+										const {
+											fileDependencies,
+											contextDependencies,
+											missingDependencies,
+											buildDependencies,
+											cacheable,
+											assets,
+											exports
+										} = /** @type {ExecuteModuleResult} */ (result);
+										for (const d of fileDependencies) {
 											loaderContext.addDependency(d);
 										}
-										for (const d of result.contextDependencies) {
+										for (const d of contextDependencies) {
 											loaderContext.addContextDependency(d);
 										}
-										for (const d of result.missingDependencies) {
+										for (const d of missingDependencies) {
 											loaderContext.addMissingDependency(d);
 										}
-										for (const d of result.buildDependencies) {
+										for (const d of buildDependencies) {
 											loaderContext.addBuildDependency(d);
 										}
-										if (result.cacheable === false)
-											loaderContext.cacheable(false);
-										for (const [name, { source, info }] of result.assets) {
-											const { buildInfo } = loaderContext._module;
+										if (cacheable === false) loaderContext.cacheable(false);
+										for (const [name, { source, info }] of assets) {
+											const buildInfo =
+												/** @type {BuildInfo} */
+												(
+													/** @type {NormalModule} */ (loaderContext._module)
+														.buildInfo
+												);
 											if (!buildInfo.assets) {
 												buildInfo.assets = Object.create(null);
 												buildInfo.assetsInfo = new Map();
 											}
-											buildInfo.assets[name] = source;
-											buildInfo.assetsInfo.set(name, info);
+											/** @type {NonNullable<BuildInfo["assets"]>} */
+											(buildInfo.assets)[name] = source;
+											/** @type {NonNullable<BuildInfo["assetsInfo"]>} */
+											(buildInfo.assetsInfo).set(name, info);
 										}
-										callback(null, result.exports);
+										callback(null, exports);
 									}
 								);
 							}
 						);
 					};
 
-					/**
-					 * @param {string} request the request string to load the module from
-					 * @param {ImportModuleOptions} options options
-					 * @param {ImportModuleCallback=} callback callback returning the exports
-					 * @returns {Promise<any> | void} exports
-					 */
+					// eslint-disable-next-line no-warning-comments
+					// @ts-ignore Overloading doesn't work
 					loaderContext.importModule = (request, options, callback) => {
 						if (!callback) {
 							return new Promise((resolve, reject) => {

package/lib/dependencies/LocalModule.js

@@ -29,7 +29,7 @@ class LocalModule {
 	 * @returns {string} variable name
 	 */
 	variableName() {
-		return "__WEBPACK_LOCAL_MODULE_" + this.idx + "__";
+		return `__WEBPACK_LOCAL_MODULE_${this.idx}__`;
 	}
 
 	/**

package/lib/dependencies/LocalModulesHelpers.js

@@ -17,8 +17,8 @@ const LocalModule = require("./LocalModule");
 const lookup = (parent, mod) => {
 	if (mod.charAt(0) !== ".") return mod;
 
-	var path = parent.split("/");
-	var segments = mod.split("/");
+	const path = parent.split("/");
+	const segments = mod.split("/");
 	path.pop();
 
 	for (let i = 0; i < segments.length; i++) {
@@ -38,7 +38,7 @@ const lookup = (parent, mod) => {
  * @param {string} name name
  * @returns {LocalModule} local module
  */
-exports.addLocalModule = (state, name) => {
+module.exports.addLocalModule = (state, name) => {
 	if (!state.localModules) {
 		state.localModules = [];
 	}
@@ -53,7 +53,7 @@ exports.addLocalModule = (state, name) => {
  * @param {string} [namedModule] named module
  * @returns {LocalModule | null} local module or null
  */
-exports.getLocalModule = (state, name, namedModule) => {
+module.exports.getLocalModule = (state, name, namedModule) => {
 	if (!state.localModules) return null;
 	if (namedModule) {
 		// resolve dependency name relative to the defining named module

package/lib/dependencies/ModuleDecoratorDependency.js

@@ -50,7 +50,7 @@ class ModuleDecoratorDependency extends NullDependency {
 	 * @returns {string | null} an identifier to merge equal requests
 	 */
 	getResourceIdentifier() {
-		return `self`;
+		return "self";
 	}
 
 	/**