webpack 5.111.0 → 5.112.0

package/lib/{RuntimeTemplate.js → template/RuntimeTemplate.js}

@@ -6,54 +6,57 @@
 "use strict";
 
 const { CachedSource, ReplaceSource } = require("webpack-sources");
-const APIPlugin = require("./APIPlugin");
 
-const InitFragment = require("./InitFragment");
-const { CSS_TYPE, JAVASCRIPT_TYPE } = require("./ModuleSourceTypeConstants");
-const { WEBASSEMBLY_MODULE_TYPE_ASYNC } = require("./ModuleTypeConstants");
-const RuntimeGlobals = require("./RuntimeGlobals");
-const Template = require("./Template");
 const {
 	getOutgoingAsyncModules
-} = require("./async-modules/AsyncModuleHelpers");
-const HarmonyImportDependency = require("./dependencies/HarmonyImportDependency");
-const ImportDependency = require("./dependencies/ImportDependency");
-const { ImportPhaseUtils } = require("./dependencies/ImportPhase");
-const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
-const { InlinedUsedName } = require("./optimize/InlineExports");
+} = require("../async-modules/AsyncModuleHelpers");
+const { ImportPhaseUtils } = require("../dependencies/core/ImportPhase");
+const isDependencyKind = require("../graph/isDependencyKind");
+const APIPlugin = require("../javascript/APIPlugin");
+const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin");
+const {
+	CSS_TYPE,
+	JAVASCRIPT_TYPE
+} = require("../module/ModuleSourceTypeConstants");
+const {
+	WEBASSEMBLY_MODULE_TYPE_ASYNC
+} = require("../module/ModuleTypeConstants");
+const { isInlinedUsedName } = require("../optimize/InlineExports");
 const {
 	getDeferredCycleModuleIds,
 	getDeferredCycleModules,
 	getKnownExportNames,
 	getMakeDeferredNamespaceModeFromExportsType,
 	getOptimizedDeferredModule
-} = require("./runtime/MakeDeferredNamespaceObjectRuntime");
+} = require("../runtime/MakeDeferredNamespaceObjectRuntime");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
 const {
 	isAbsoluteBaseUri,
 	isChunkRelativeBaseUri
-} = require("./runtime/baseUri");
-const { equals } = require("./util/ArrayHelpers");
-const { getScheme } = require("./util/URLAbsoluteSpecifier");
-const { compareIds } = require("./util/comparators");
-const compileBooleanMatcher = require("./util/compileBooleanMatcher");
+} = require("../runtime/baseUri");
+const { equals } = require("../util/ArrayHelpers");
+const { getScheme } = require("../util/URLAbsoluteSpecifier");
+const { compareIds } = require("../util/comparators");
+const compileBooleanMatcher = require("../util/compileBooleanMatcher");
 const {
 	RESOLVABLE_SPECIFIER_REGEXP,
 	getUndoPath,
 	toJsStringLiteral
-} = require("./util/identifier");
-const memoize = require("./util/memoize");
-const { propertyAccess, propertyName } = require("./util/property");
+} = require("../util/identifier");
+const memoize = require("../util/memoize");
+const { propertyAccess, propertyName } = require("../util/property");
 const {
 	forEachRuntime,
 	getRuntimeKey,
 	intersectRuntime,
 	subtractRuntime
-} = require("./util/runtime");
+} = require("../util/runtime");
+const InitFragment = require("./InitFragment");
+const Template = require("./Template");
 
-const getCssModulesPlugin = memoize(() => require("./css/CssModulesPlugin"));
+const getCssModulesPlugin = memoize(() => require("../css/CssModulesPlugin"));
 // `Compilation` requires this module, so its stage constants are read lazily.
-const getCompilation = memoize(() => require("./Compilation"));
-const getExternalModule = memoize(() => require("./ExternalModule"));
+const getCompilation = memoize(() => require("../Compilation"));
 
 /**
  * @typedef {object} ChunkAssetNaming
@@ -88,10 +91,8 @@ const CHUNK_ASSET_NAMING = new Map([
 ]);
 const getTemplatedPathPlugin = memoize(() => require("./TemplatedPathPlugin"));
 const getConcatenatedModule = memoize(() =>
-	require("./optimize/ConcatenatedModule")
+	require("../optimize/ConcatenatedModule")
 );
-const getNormalModule = memoize(() => require("./NormalModule"));
-
 /**
  * Whether a hot update can re-run the module a reference is emitted into: the HMR
  * plugin marks every normal module, and a concatenated one is read through its root.
@@ -100,9 +101,8 @@ const getNormalModule = memoize(() => require("./NormalModule"));
  */
 const isHotModule = (module) => {
 	if (module === undefined) return false;
-	const normal =
-		module instanceof getConcatenatedModule() ? module.rootModule : module;
-	return normal instanceof getNormalModule() && normal.hot;
+	const normal = module.getRootModule();
+	return normal.is("normal") && normal.hot;
 };
 
 // Any `[hash]`/`[fullhash]`/`[chunkhash]`/`[contenthash]` token, incl. a `:<length>`
@@ -220,16 +220,16 @@ const HOT_NAME_BAILOUT =
 /**
  * @import {
  * 	OutputNormalizedWithDefaults as OutputOptions
- * } from "./config/defaults"
+ * } from "../config/defaults"
  */
-/** @import { PublicPath, WasmLoading } from "../declarations/WebpackOptions" */
-/** @import ModuleDependency from "./dependencies/ModuleDependency" */
+/** @import { PublicPath, WasmLoading } from "../../declarations/WebpackOptions.d.ts" */
+/** @import ModuleDependency from "../dependencies/core/ModuleDependency" */
 /**
  * @import Module, {
  * 	ReadOnlyRuntimeRequirements,
  * 	BuildMeta,
  * 	RuntimeRequirements
- * } from "./Module"
+ * } from "../module/Module"
  */
 /** @typedef {"import" | "url" | "url-runtime" | "url-inline" | "wasm" | "wasm-relative"} AnalyzableForm */
 /**
@@ -304,18 +304,19 @@ const CHUNK_ASSET_NAMING_BY_STAND_IN = new Map(
 
 const PASS_NAME = "analyzableChunkNaming";
 
-/** @import AsyncDependenciesBlock from "./AsyncDependenciesBlock" */
+/** @import AsyncDependenciesBlock from "../graph/AsyncDependenciesBlock" */
 /** @import { Source } from "webpack-sources" */
-/** @import Compiler from "./Compiler" */
-/** @import Chunk, { ChunkFilenameTemplate, ChunkId } from "./Chunk" */
-/** @import ChunkGraph, { ModuleId } from "./ChunkGraph" */
-/** @import Compilation from "./Compilation" */
-/** @import Dependency from "./Dependency" */
-/** @import ModuleGraph from "./ModuleGraph" */
-/** @import RequestShortener from "./RequestShortener" */
-/** @import Hash from "./util/Hash" */
-/** @import CodeGenerationResults from "./CodeGenerationResults" */
-/** @import { RuntimeSpec } from "./util/runtime" */
+/** @import Compiler from "../Compiler" */
+/** @import Chunk, { ChunkFilenameTemplate, ChunkId } from "../graph/Chunk" */
+/** @import ChunkGraph, { ModuleId } from "../graph/ChunkGraph" */
+/** @import Compilation from "../Compilation" */
+/** @import Dependency from "../graph/Dependency" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
+/** @import RequestShortener from "../util/RequestShortener" */
+/** @import Hash from "../util/Hash" */
+/** @import CodeGenerationResults from "../module/CodeGenerationResults" */
+/** @import { RuntimeSpec } from "../util/runtime" */
+/** @import { JsonValue } from "../fs/fs" */
 
 /**
  * A stand-in whose every hash reads back as `hash`. Which content hashes a chunk
@@ -428,7 +429,7 @@ function getGlobalObject(definition) {
 // An async external is a promise, not a module record with an evaluating state.
 const isAsyncExternal = (/** @type {Module} */ module) =>
 	Boolean(/** @type {BuildMeta} */ (module.buildMeta).async) &&
-	module instanceof getExternalModule();
+	module.is("external");
 
 // `createFakeNamespaceObject`'s "merge all properties" bit, the only one that
 // changes which names the namespace it builds carries.
@@ -745,8 +746,7 @@ class RuntimeTemplate {
 				: undefined;
 		// A reassigned `__webpack_public_path__` cannot reach a baked literal, and `.p`
 		// belongs to a runtime, so only the runtimes it reaches keep the runtime form.
-		// `url-inline` is unaffected: that form falls back to `.p + <file>`, which reads
-		// the reassigned value at the call site rather than through the wrapper.
+		// `url-inline` is unaffected: it reads the value at the call site.
 		if (
 			form !== "url-inline" &&
 			APIPlugin.runtimeUsesPublicPathOverride(
@@ -774,12 +774,13 @@ class RuntimeTemplate {
 			return true;
 		}
 
-		// `url-inline` asks whether the file can be named at the call site at all, and
-		// its `.p + <file>` fallback spells that without `import.meta` — so the gate
-		// below does not rule it out, and the asset's javascript wrapper stays dropped.
+		// `url-inline` asks only whether the file can be named at the call site, and
+		// its `.p + <file>` fallback spells that without `import.meta`, so the gate
+		// below does not rule it out.
+
 		// `environment.module` is deliberately not consulted: ESM output writes
-		// `import.meta` regardless (the public path, the chunk loader), so the url forms
-		// only match what the rest of the bundle already assumes the target reads.
+		// `import.meta` regardless, so the url forms match what the rest of the
+		// bundle already assumes the target reads.
 		if (form === "url-inline") return true;
 		// `eval` devtool wraps each module in `eval(...)`, where `import.meta` is a
 		// syntax error. Runtime modules are emitted beside them, never wrapped.
@@ -830,6 +831,16 @@ class RuntimeTemplate {
 		return true;
 	}
 
+	/**
+	 * Reports an analyzable-ESM bailout from outside this class.
+	 * @param {Module | undefined} module the module the reference is emitted into
+	 * @param {string} reason why no literal could be baked
+	 * @returns {void}
+	 */
+	analyzableBailout(module, reason) {
+		this._analyzableBailout(module, reason, null);
+	}
+
 	/**
 	 * Records why a reference kept the runtime form, on the module that wrote it —
 	 * the channel `ModuleConcatenationPlugin` already reports through, so it reaches
@@ -1124,10 +1135,9 @@ class RuntimeTemplate {
 		const chunks = this._moduleChunks(module, chunkGraph);
 		const parts = this._resolvePublicPathPrefix(publicPath);
 		if (parts === null) return null;
-		// A protocol-relative base names a host but no scheme, and the runtime reads it
-		// against the chunk's own url to get one — the very url this literal is
-		// resolved against — so it may stay protocol-relative instead of being settled
-		// here. Nothing walks back to the output root first: the base replaces it.
+		// A protocol-relative base names a host but no scheme, and the runtime reads
+		// it against the very url this literal resolves against, so it may stay that
+		// way. Nothing walks back to the output root: the base replaces it.
 		if (base.startsWith("//")) {
 			return this._specifierOf(
 				[["literal", base], ...rootedParts(parts), ["literal", filename]],
@@ -1192,10 +1202,9 @@ class RuntimeTemplate {
 		let base;
 		let found = false;
 		for (const chunk of this.compilation.chunks) {
-			// What a literal has to agree with is the one value `BaseUriRuntimeModule`
-			// writes out, and it reads the entry options off the chunk it is emitted into
-			// — so only a chunk carrying a runtime has a say. Entries sharing one runtime
-			// chunk already share the base it sets, however their descriptors differ.
+			// A literal must agree with the one value `BaseUriRuntimeModule` writes, and
+			// that reads the entry options off the chunk it is emitted into, so only a
+			// chunk carrying a runtime has a say.
 			if (!chunk.hasRuntime()) continue;
 			const entryOptions = chunk.getEntryOptions();
 			// An entry this code cannot run under has no say in the base it resolves to.
@@ -1483,14 +1492,13 @@ class RuntimeTemplate {
 		}
 		if (!this.supportTemplateLiteral()) return this._es5Concatenation(args);
 
-		// cost comparison between template literal and concatenation:
-		// both need equal surroundings: `xxx` vs "xxx"
-		// template literal has constant cost of 3 chars for each expression
-		// es5 concatenation has cost of 3 + n chars for n expressions in row
-		// when a es5 concatenation ends with an expression it reduces cost by 3
-		// when a es5 concatenation starts with an single expression it reduces cost by 3
-		// e. g. `${a}${b}${c}` (3*3 = 9) is longer than ""+a+b+c ((3+3)-3 = 3)
-		// e. g. `x${a}x${b}x${c}x` (3*3 = 9) is shorter than "x"+a+"x"+b+"x"+c+"x" (4+4+4 = 12)
+		// WHY: cost comparison between a template literal and a concatenation, both
+		// needing equal surroundings (`xxx` against "xxx"). A template literal costs
+		// a constant 3 chars per expression; an es5 concatenation costs 3 + n chars
+		// for n expressions in a row, and reduces by 3 where it ends with an
+		// expression or starts with a single one. So `${a}${b}${c}` (3*3 = 9) is
+		// longer than ""+a+b+c ((3+3)-3 = 3), while `x${a}x${b}x${c}x` (3*3 = 9) is
+		// shorter than "x"+a+"x"+b+"x"+c+"x" (4+4+4 = 12).
 
 		let templateCost = 0;
 		let concatenationCost = 0;
@@ -1853,6 +1861,28 @@ class RuntimeTemplate {
 		return `${this.comment({ request })}${JSON.stringify(moduleId)}`;
 	}
 
+	/**
+	 * The side-effect annotation for output another build reads back, which is the
+	 * only output it can pay for — elsewhere it is bytes with no consumer.
+	 * @returns {string} the annotation, or an empty string
+	 */
+	sideEffectsAnnotation() {
+		return this.outputOptions.module ? "/*#__PURE__*/" : "";
+	}
+
+	/**
+	 * A module instantiation's side-effect annotation. Write it only where the
+	 * statement ends the call: a minifier reads `f(id)(x)` as one and drops it.
+	 * @param {Module} module the instantiated module
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {string} the annotation, or an empty string when it may have side effects
+	 */
+	moduleSideEffectsAnnotation(module, moduleGraph) {
+		return module.getSideEffectsConnectionState(moduleGraph) === false
+			? this.sideEffectsAnnotation()
+			: "";
+	}
+
 	/**
 	 * Returns the expression.
 	 * @param {object} options options object
@@ -2080,8 +2110,8 @@ class RuntimeTemplate {
 		const exportsType = module.getExportsType(chunkGraph.moduleGraph, strict);
 
 		const isModuleDeferred =
-			(dependency instanceof HarmonyImportDependency ||
-				dependency instanceof ImportDependency) &&
+			(isDependencyKind(dependency, "esm-import") ||
+				isDependencyKind(dependency, "dynamic-import")) &&
 			ImportPhaseUtils.isDefer(dependency.phase) &&
 			!(/** @type {BuildMeta} */ (module.buildMeta).async);
 
@@ -2353,10 +2383,9 @@ class RuntimeTemplate {
 			request,
 			weak
 		});
-		// Harmony imports may be wrapped in runtime-condition `if` blocks
-		// but referenced outside those blocks (e.g. by harmony reexport),
-		// so they must remain function-scoped (`var`) rather than
-		// block-scoped (`let`/`const`).
+		// A harmony import may sit inside a runtime-condition `if` block yet be
+		// referenced outside it, so it stays function-scoped with `var` rather than
+		// block-scoped.
 		const optDeclaration = update ? "" : "var ";
 
 		const exportsType = module.getExportsType(
@@ -2370,8 +2399,9 @@ class RuntimeTemplate {
 		let importContent;
 
 		const isModuleDeferred =
-			(dependency instanceof HarmonyImportDependency ||
-				dependency instanceof ImportDependency) &&
+			dependency !== undefined &&
+			(isDependencyKind(dependency, "esm-import") ||
+				isDependencyKind(dependency, "dynamic-import")) &&
 			ImportPhaseUtils.isDefer(dependency.phase) &&
 			!isAsyncExternal(module);
 
@@ -2382,7 +2412,7 @@ class RuntimeTemplate {
 			// would deadlock; forcing the namespace throws instead.
 			outgoingAsyncModules.delete(originModule);
 
-			importContent = `/* deferred harmony import */ ${optDeclaration}${importVar} = ${getOptimizedDeferredModule(
+			importContent = `/* deferred harmony import */ ${optDeclaration}${importVar} = ${this.sideEffectsAnnotation()}${getOptimizedDeferredModule(
 				moduleId,
 				exportsType,
 				Array.from(outgoingAsyncModules, (mod) => chunkGraph.getModuleId(mod)),
@@ -2395,7 +2425,10 @@ class RuntimeTemplate {
 
 			return [importContent, ""];
 		}
-		importContent = `/* harmony import */ ${optDeclaration}${importVar} = ${RuntimeGlobals.require}(${moduleId});\n`;
+		importContent = `/* harmony import */ ${optDeclaration}${importVar} = ${this.moduleSideEffectsAnnotation(
+			module,
+			moduleGraph
+		)}${RuntimeGlobals.require}(${moduleId});\n`;
 
 		if (exportsType === "dynamic") {
 			runtimeRequirements.add(RuntimeGlobals.compatGetDefaultExport);
@@ -2462,8 +2495,8 @@ class RuntimeTemplate {
 		);
 
 		const isModuleDeferred =
-			(dependency instanceof HarmonyImportDependency ||
-				dependency instanceof ImportDependency) &&
+			(isDependencyKind(dependency, "esm-import") ||
+				isDependencyKind(dependency, "dynamic-import")) &&
 			ImportPhaseUtils.isDefer(dependency.phase) &&
 			!isAsyncExternal(module);
 
@@ -2480,7 +2513,7 @@ class RuntimeTemplate {
 						);
 						return `${comment} undefined`;
 					}
-					if (used instanceof InlinedUsedName) {
+					if (isInlinedUsedName(used)) {
 						throw new Error(
 							"Can't inline the exports of defer imported module"
 						);
@@ -2495,10 +2528,8 @@ class RuntimeTemplate {
 				}
 				// accessing the .default property is same thing as `require()` the module.
 
-				// For example:
-				// import mod from "cjs";    mod.default.x;
-				// is translated to
-				// var mod = require("cjs"); mod.x;
+				// So `import mod from "cjs"; mod.default.x` translates to
+				// `var mod = require("cjs"); mod.x`.
 				switch (exportsType) {
 					case "dynamic":
 						if (isCall) {
@@ -2538,10 +2569,9 @@ class RuntimeTemplate {
 				exportsType === "default-only" ||
 				exportsType === "default-with-named"
 			) {
-				// now exportName.length is 0, which means the namespace object is used in an unknown way
-				// for example:
-				// import * as ns from "cjs"; console.log(ns);
-				// we will need to createFakeNamespaceObject that simulates ES Module namespace object
+				// `exportName.length` is 0, so the namespace object is used in an unknown
+				// way — `import * as ns from "cjs"; console.log(ns)` — and needs
+				// `createFakeNamespaceObject` to simulate an ES module namespace.
 				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
 				initFragments.push(
 					new InitFragment(
@@ -2592,7 +2622,7 @@ class RuntimeTemplate {
 				);
 				return `${comment} undefined`;
 			}
-			if (used instanceof InlinedUsedName) {
+			if (isInlinedUsedName(used)) {
 				return used.render(
 					Template.toNormalComment(
 						`inlined export ${propertyAccess(exportName)}`
@@ -2709,7 +2739,7 @@ class RuntimeTemplate {
 			if (exportInfo.provided === false) continue;
 			const used = exportsInfo.getUsedName([exportInfo.name], runtime);
 			if (!used) continue;
-			if (used instanceof InlinedUsedName) {
+			if (isInlinedUsedName(used)) {
 				// An inlined export isn't reachable by name on the raw exports object,
 				// so the decoupled object must expose the inlined value directly.
 				mangled = true;
@@ -3443,9 +3473,8 @@ class RuntimeTemplate {
 		// emitted and filled in once the hash exists.
 		const deferred = template === undefined || HASH_IN_FILENAME.test(template);
 		// An id names the chunk in the stand-in, and one nothing could resolve would
-		// reach the bundle verbatim. The whole name is re-resolved later rather than
-		// carrying a stand-in of its own, so any hash spelling is fine here.
-		// One of the two always names where the reference goes.
+		// reach the bundle verbatim. The whole name is re-resolved later, so any hash
+		// spelling is fine here; one of the two always names the destination.
 		const chunks =
 			consumingChunks ||
 			this._moduleChunks(/** @type {Module} */ (consumingModule), chunkGraph);
@@ -3658,7 +3687,7 @@ class RuntimeTemplate {
 	/**
 	 * A path built by a function, resolved to the value it will have — or `null` when
 	 * it moves with the compilation hash, which code generation does not know.
-	 * @param {import("./TemplatedPathPlugin").TemplatePathFn<EXPECTED_ANY>} fn the function
+	 * @param {import("./TemplatedPathPlugin").TemplatePathFn} fn the function
 	 * @param {string | undefined} value its answer to the first probe, or `undefined`
 	 * when it answered nothing
 	 * @returns {string | null} the settled value, or `null` when it is hash-dependent
@@ -4272,6 +4301,49 @@ class RuntimeTemplate {
 		return this.returningFunction(factory);
 	}
 
+	/**
+	 * @param {object} options options
+	 * @param {Module} options.module the module the body belongs to
+	 * @param {boolean} options.needModule whether the body reads `module`
+	 * @param {boolean} options.needExports whether the body reads `exports`
+	 * @param {boolean} options.needRequire whether the body reads `__webpack_require__`
+	 * @param {boolean} options.needThisAsExports whether the body reads `this` as exports
+	 * @param {boolean=} options.shorthand render as a method shorthand, without the `function` keyword
+	 * @returns {string} the header, ending with the opening brace
+	 */
+	moduleFactoryFnHeader({
+		module,
+		needModule,
+		needExports,
+		needRequire,
+		needThisAsExports,
+		shorthand = false
+	}) {
+		/** @type {string[]} */
+		const args = [];
+		if (needExports || needRequire || needModule) {
+			args.push(
+				needModule
+					? module.moduleArgument
+					: `__unused_webpack_${module.moduleArgument}`
+			);
+		}
+		if (needExports || needRequire) {
+			args.push(
+				needExports
+					? module.exportsArgument
+					: `__unused_webpack_${module.exportsArgument}`
+			);
+		}
+		if (needRequire) args.push(RuntimeGlobals.require);
+		const parameters = args.join(", ");
+		if (shorthand) return `(${parameters}) {`;
+		if (!needThisAsExports && this.supportsArrowFunction()) {
+			return `(${parameters}) => {`;
+		}
+		return `function(${parameters}) {`;
+	}
+
 	/**
 	 * Define es module flag statement.
 	 * @param {object} options options
@@ -4355,11 +4427,9 @@ class RuntimeTemplate {
 			compilation.hooks.processAssets.tapPromise(
 				{
 					name: PASS_NAME,
-					// Before source maps are written and before a minifier runs: both read
-					// the asset, and a stand-in is a different length than what replaces it.
-					// Every hash it reads is already settled — `createHash` runs ahead of
-					// every `processAssets` stage — and `RealContentHashPlugin` still repairs
-					// the names afterwards.
+					// Before source maps are written and before a minifier runs, since both
+					// read the asset and a stand-in differs in length from what replaces it.
+					// Every hash it reads is settled: `createHash` precedes every stage.
 					stage: getCompilation().PROCESS_ASSETS_STAGE_DERIVED
 				},
 				async () => {
@@ -4585,7 +4655,7 @@ class RuntimeTemplate {
 	 * @returns {SpecifierPart[] | null} what it resolves to, or `null` if unreadable
 	 */
 	static _readAnalyzableSpecifier(payload) {
-		/** @type {EXPECTED_ANY} */
+		/** @type {JsonValue} */
 		let decoded;
 		try {
 			decoded = JSON.parse(
@@ -4600,17 +4670,19 @@ class RuntimeTemplate {
 		if (!Array.isArray(decoded)) return null;
 		for (const part of decoded) {
 			if (!Array.isArray(part) || part.length !== 2) return null;
-			if (!SPECIFIER_PART_KINDS.has(part[0])) return null;
+			if (!SPECIFIER_PART_KINDS.has(/** @type {string} */ (part[0]))) {
+				return null;
+			}
 			// Only a chunk id may be a number; the rest are read as text.
 			if (
 				typeof part[1] !== "string" &&
-				(!CHUNK_SPECIFIER_PART_KINDS.has(part[0]) ||
+				(!CHUNK_SPECIFIER_PART_KINDS.has(/** @type {string} */ (part[0])) ||
 					typeof part[1] !== "number")
 			) {
 				return null;
 			}
 		}
-		return decoded;
+		return /** @type {SpecifierPart[]} */ (decoded);
 	}
 }
 

package/lib/{Template.js → template/Template.js}

@@ -6,30 +6,32 @@
 "use strict";
 
 const { ConcatSource, PrefixSource } = require("webpack-sources");
-const { WEBPACK_MODULE_TYPE_RUNTIME } = require("./ModuleTypeConstants");
-const RuntimeGlobals = require("./RuntimeGlobals");
+const {
+	WEBPACK_MODULE_TYPE_RUNTIME
+} = require("../module/ModuleTypeConstants");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
 
 /** @import { Source } from "webpack-sources" */
 /**
  * @import {
  * 	OutputNormalizedWithDefaults as OutputOptions
- * } from "./config/defaults"
+ * } from "../config/defaults"
  */
-/** @import Chunk from "./Chunk" */
-/** @import ChunkGraph, { ModuleId } from "./ChunkGraph" */
-/** @import CodeGenerationResults from "./CodeGenerationResults" */
-/** @import { AssetInfo, PathData } from "./Compilation" */
+/** @import Chunk from "../graph/Chunk" */
+/** @import ChunkGraph, { ModuleId } from "../graph/ChunkGraph" */
+/** @import CodeGenerationResults from "../module/CodeGenerationResults" */
+/** @import { AssetInfo, PathData } from "../Compilation" */
 /** @import DependencyTemplates from "./DependencyTemplates" */
-/** @import Module from "./Module" */
-/** @import ModuleGraph from "./ModuleGraph" */
+/** @import Module from "../module/Module" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
 /** @import ModuleTemplate from "./ModuleTemplate" */
-/** @import RuntimeModule from "./RuntimeModule" */
+/** @import RuntimeModule from "../runtime/RuntimeModule" */
 /** @import RuntimeTemplate from "./RuntimeTemplate" */
 /**
  * @import {
  * 	ChunkRenderContext,
  * 	RenderContext
- * } from "./javascript/JavascriptModulesPlugin"
+ * } from "../javascript/JavascriptModulesPlugin"
  */
 
 const START_LOWERCASE_ALPHABET_CODE = "a".charCodeAt(0);