webpack 5.106.2 → 5.107.1

package/lib/NormalModule.js

@@ -20,18 +20,17 @@ const {
 	SourceMapSource
 } = require("webpack-sources");
 const Compilation = require("./Compilation");
-const HookWebpackError = require("./HookWebpackError");
 const Module = require("./Module");
-const ModuleBuildError = require("./ModuleBuildError");
-const ModuleError = require("./ModuleError");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
-const ModuleParseError = require("./ModuleParseError");
 const { JAVASCRIPT_MODULE_TYPE_AUTO } = require("./ModuleTypeConstants");
-const ModuleWarning = require("./ModuleWarning");
 const RuntimeGlobals = require("./RuntimeGlobals");
-const UnhandledSchemeError = require("./UnhandledSchemeError");
-const WebpackError = require("./WebpackError");
-const formatLocation = require("./formatLocation");
+const HookWebpackError = require("./errors/HookWebpackError");
+const ModuleBuildError = require("./errors/ModuleBuildError");
+const ModuleError = require("./errors/ModuleError");
+const ModuleParseError = require("./errors/ModuleParseError");
+const ModuleWarning = require("./errors/ModuleWarning");
+const NonErrorEmittedError = require("./errors/NonErrorEmittedError");
+const UnhandledSchemeError = require("./errors/UnhandledSchemeError");
 const LazySet = require("./util/LazySet");
 const { isSubset } = require("./util/SetHelpers");
 const { getScheme } = require("./util/URLAbsoluteSpecifier");
@@ -44,6 +43,7 @@ const {
 } = require("./util/comparators");
 const createHash = require("./util/createHash");
 const { createFakeHook } = require("./util/deprecation");
+const formatLocation = require("./util/formatLocation");
 const { join } = require("./util/fs");
 const {
 	absolutify,
@@ -61,6 +61,7 @@ const parseJson = require("./util/parseJson");
 /** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
 /** @typedef {import("../declarations/WebpackOptions").NoParse} NoParse */
 /** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
+/** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("./Generator")} Generator */
 /** @typedef {import("./Generator").GenerateErrorFn} GenerateErrorFn */
@@ -85,8 +86,13 @@ const parseJson = require("./util/parseJson");
 /** @typedef {import("./Module").UnsafeCacheData} UnsafeCacheData */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {Iterator<SideEffectsWalk, ConnectionState, ConnectionState>} SideEffectsWalk */
 /** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
 /** @typedef {import("./NormalModuleFactory").NormalModuleTypes} NormalModuleTypes */
+/** @typedef {import("./NormalModuleFactory").ParserByType} ParserByType */
+/** @typedef {import("./NormalModuleFactory").ParserOptionsByType} ParserOptionsByType */
+/** @typedef {import("./NormalModuleFactory").GeneratorByType} GeneratorByType */
+/** @typedef {import("./NormalModuleFactory").GeneratorOptionsByType} GeneratorOptionsByType */
 /** @typedef {import("./NormalModuleFactory").ResourceSchemeData} ResourceSchemeData */
 /** @typedef {import("./Parser")} Parser */
 /** @typedef {import("./Parser").PreparsedAst} PreparsedAst */
@@ -119,13 +125,94 @@ const parseJson = require("./util/parseJson");
 /** @typedef {(content: string) => boolean} NoParseFn */
 
 const getInvalidDependenciesModuleWarning = memoize(() =>
-	require("./InvalidDependenciesModuleWarning")
+	require("./errors/InvalidDependenciesModuleWarning")
 );
 
 const getExtractSourceMap = memoize(() => require("./util/extractSourceMap"));
 
 const getValidate = memoize(() => require("schema-utils").validate);
 
+const getHarmonyImportSideEffectDependency = memoize(() =>
+	require("./dependencies/HarmonyImportSideEffectDependency")
+);
+
+/**
+ * @param {NormalModule} mod the module
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {Dependency} dep the dep that triggered the bailout
+ */
+const recordSideEffectsBailout = (mod, moduleGraph, dep) => {
+	if (mod._addedSideEffectsBailout === undefined) {
+		mod._addedSideEffectsBailout = new WeakSet();
+	} else if (mod._addedSideEffectsBailout.has(moduleGraph)) {
+		return;
+	}
+	mod._addedSideEffectsBailout.add(moduleGraph);
+	moduleGraph
+		.getOptimizationBailout(mod)
+		.push(
+			() =>
+				`Dependency (${dep.type}) with side effects at ${formatLocation(dep.loc)}`
+		);
+};
+
+/**
+ * Generator form of `getSideEffectsConnectionState` — descends through
+ * `HarmonyImportSideEffectDependency` via `yield` so the trampoline in
+ * `getSideEffectsConnectionState` can drive the walk iteratively (#20986).
+ * @param {NormalModule} mod the module being evaluated
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @returns {SideEffectsWalk} the generator
+ */
+function* walkSideEffects(mod, moduleGraph) {
+	if (mod.factoryMeta !== undefined) {
+		if (mod.factoryMeta.sideEffectFree) return false;
+		if (mod.factoryMeta.sideEffectFree === false) return true;
+	}
+	if (!(mod.buildMeta !== undefined && mod.buildMeta.sideEffectFree)) {
+		return true;
+	}
+	if (mod._isEvaluatingSideEffects) {
+		return ModuleGraphConnection.CIRCULAR_CONNECTION;
+	}
+
+	const SideEffectDep = getHarmonyImportSideEffectDependency();
+	mod._isEvaluatingSideEffects = true;
+	/** @type {ConnectionState} */
+	let current = false;
+
+	for (const dep of mod.dependencies) {
+		/** @type {ConnectionState} */
+		let state;
+		if (dep instanceof SideEffectDep) {
+			const refModule = moduleGraph.getModule(dep);
+			if (!refModule) {
+				state = true;
+			} else if (refModule instanceof NormalModule) {
+				state = yield walkSideEffects(refModule, moduleGraph);
+			} else {
+				state = refModule.getSideEffectsConnectionState(moduleGraph);
+			}
+		} else {
+			state = dep.getModuleEvaluationSideEffectsState(moduleGraph);
+		}
+
+		if (state === true) {
+			recordSideEffectsBailout(mod, moduleGraph, dep);
+			mod._isEvaluatingSideEffects = false;
+			return true;
+		}
+		if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
+			current = ModuleGraphConnection.addConnectionStates(current, state);
+		}
+	}
+
+	mod._isEvaluatingSideEffects = false;
+	// When caching is implemented here, make sure to not cache when
+	// at least one circular connection was folded into `current`.
+	return current;
+}
+
 const ABSOLUTE_PATH_REGEX = /^(?:[a-z]:\\|\\\\|\/)/i;
 
 /**
@@ -207,24 +294,6 @@ const asBuffer = (input) => {
 	return input;
 };
 
-class NonErrorEmittedError extends WebpackError {
-	/**
-	 * @param {EXPECTED_ANY} error value which is not an instance of Error
-	 */
-	constructor(error) {
-		super();
-
-		this.name = "NonErrorEmittedError";
-		this.message = `(Emitted value instead of an instance of Error) ${error}`;
-	}
-}
-
-makeSerializable(
-	NonErrorEmittedError,
-	"webpack/lib/NormalModule",
-	"NonErrorEmittedError"
-);
-
 /** @typedef {[string | Buffer, string | RawSourceMap | undefined, PreparsedAst | undefined]}  Result */
 
 /** @typedef {LoaderContext<EXPECTED_ANY>} AnyLoaderContext */
@@ -247,9 +316,10 @@ makeSerializable(
  */
 
 /**
+ * @template {NormalModuleTypes | ""} [T=NormalModuleTypes | ""]
  * @typedef {object} NormalModuleCreateData
  * @property {string=} layer an optional layer in which the module is
- * @property {NormalModuleTypes | ""} type module type. When deserializing, this is set to an empty string "".
+ * @property {T} type module type. When deserializing, this is set to an empty string "".
  * @property {string} request request string
  * @property {string} userRequest request intended by user (without loaders from config)
  * @property {string} rawRequest request without resolving
@@ -258,10 +328,10 @@ makeSerializable(
  * @property {(ResourceSchemeData & Partial<ResolveRequest>)=} resourceResolveData resource resolve data
  * @property {string} context context directory for resolving
  * @property {string=} matchResource path + query of the matched resource (virtual)
- * @property {Parser} parser the parser used
- * @property {ParserOptions=} parserOptions the options of the parser used
- * @property {Generator} generator the generator used
- * @property {GeneratorOptions=} generatorOptions the options of the generator used
+ * @property {ParserByType[T]} parser the parser used
+ * @property {ParserOptionsByType[T]=} parserOptions the options of the parser used
+ * @property {GeneratorByType[T]} generator the generator used
+ * @property {GeneratorOptionsByType[T]=} generatorOptions the options of the generator used
  * @property {ResolveOptions=} resolveOptions options used for resolving requests from this module
  * @property {boolean} extractSourceMap enable/disable extracting source map
  */
@@ -394,7 +464,7 @@ class NormalModule extends Module {
 		this.extractSourceMap = extractSourceMap;
 
 		// Info from Build
-		/** @type {WebpackError | null} */
+		/** @type {Error | null} */
 		this.error = null;
 		/**
 		 * @private
@@ -423,12 +493,10 @@ class NormalModule extends Module {
 		 */
 		this._forceBuild = true;
 		/**
-		 * @private
 		 * @type {boolean}
 		 */
 		this._isEvaluatingSideEffects = false;
 		/**
-		 * @private
 		 * @type {WeakSet<ModuleGraph> | undefined}
 		 */
 		this._addedSideEffectsBailout = undefined;
@@ -1176,7 +1244,7 @@ class NormalModule extends Module {
 	}
 
 	/**
-	 * @param {WebpackError} error the error
+	 * @param {Error} error the error
 	 * @returns {void}
 	 */
 	markModuleAsErrored(error) {
@@ -1328,7 +1396,7 @@ class NormalModule extends Module {
 				try {
 					hooks.beforeSnapshot.call(this);
 				} catch (err) {
-					this.markModuleAsErrored(/** @type {WebpackError} */ (err));
+					this.markModuleAsErrored(/** @type {Error} */ (err));
 					return callback();
 				}
 
@@ -1420,7 +1488,7 @@ class NormalModule extends Module {
 			try {
 				hooks.beforeParse.call(this);
 			} catch (err) {
-				this.markModuleAsErrored(/** @type {WebpackError} */ (err));
+				this.markModuleAsErrored(/** @type {Error} */ (err));
 				this._initBuildHash(compilation);
 				return callback();
 			}
@@ -1471,47 +1539,21 @@ class NormalModule extends Module {
 	 * @returns {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only
 	 */
 	getSideEffectsConnectionState(moduleGraph) {
-		if (this.factoryMeta !== undefined) {
-			if (this.factoryMeta.sideEffectFree) return false;
-			if (this.factoryMeta.sideEffectFree === false) return true;
-		}
-		if (this.buildMeta !== undefined && this.buildMeta.sideEffectFree) {
-			if (this._isEvaluatingSideEffects) {
-				return ModuleGraphConnection.CIRCULAR_CONNECTION;
+		// Trampoline `walkSideEffects` so the descent doesn't consume the
+		// call stack (#20986).
+		const stack = [walkSideEffects(this, moduleGraph)];
+		/** @type {ConnectionState} */
+		let r = false;
+		while (stack.length > 0) {
+			const step = stack[stack.length - 1].next(r);
+			if (step.done) {
+				stack.pop();
+				r = step.value;
+			} else {
+				stack.push(step.value);
 			}
-			this._isEvaluatingSideEffects = true;
-			/** @type {ConnectionState} */
-			let current = false;
-			for (const dep of this.dependencies) {
-				const state = dep.getModuleEvaluationSideEffectsState(moduleGraph);
-				if (state === true) {
-					if (
-						this._addedSideEffectsBailout === undefined
-							? ((this._addedSideEffectsBailout = new WeakSet()), true)
-							: !this._addedSideEffectsBailout.has(moduleGraph)
-					) {
-						this._addedSideEffectsBailout.add(moduleGraph);
-						moduleGraph
-							.getOptimizationBailout(this)
-							.push(
-								() =>
-									`Dependency (${
-										dep.type
-									}) with side effects at ${formatLocation(dep.loc)}`
-							);
-					}
-					this._isEvaluatingSideEffects = false;
-					return true;
-				} else if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
-					current = ModuleGraphConnection.addConnectionStates(current, state);
-				}
-			}
-			this._isEvaluatingSideEffects = false;
-			// When caching is implemented here, make sure to not cache when
-			// at least one circular connection was in the loop above
-			return current;
 		}
-		return true;
+		return r;
 	}
 
 	/**

package/lib/NormalModuleFactory.js

@@ -31,6 +31,7 @@ const { getScheme } = require("./util/URLAbsoluteSpecifier");
 const { cachedCleverMerge, cachedSetProperty } = require("./util/cleverMerge");
 const { join } = require("./util/fs");
 const {
+	escapeHashInPathRequest,
 	parseResource,
 	parseResourceWithoutFragment
 } = require("./util/identifier");
@@ -68,7 +69,7 @@ const {
  */
 
 /** @typedef {Pick<RuleSetRule, "type" | "sideEffects" | "parser" | "generator" | "resolve" | "layer" | "extractSourceMap">} ModuleSettings */
-/** @typedef {Partial<NormalModuleCreateData & { settings: ModuleSettings }>} CreateData */
+/** @typedef {NormalModuleCreateData & { settings: ModuleSettings }} CreateData */
 
 /**
  * Defines the resolve data type used by this module.
@@ -81,7 +82,7 @@ const {
  * @property {ImportAttributes=} attributes
  * @property {ModuleDependency[]} dependencies
  * @property {string} dependencyType
- * @property {CreateData} createData
+ * @property {Partial<CreateData>} createData
  * @property {FileSystemDependencies} fileDependencies
  * @property {FileSystemDependencies} missingDependencies
  * @property {FileSystemDependencies} contextDependencies
@@ -132,8 +133,9 @@ const {
 /** @typedef {import("./ModuleTypeConstants").CSS_MODULE_TYPE_GLOBAL} CSS_MODULE_TYPE_GLOBAL */
 /** @typedef {import("./ModuleTypeConstants").CSS_MODULE_TYPE_MODULE} CSS_MODULE_TYPE_MODULE */
 /** @typedef {import("./ModuleTypeConstants").CSS_MODULE_TYPE_AUTO} CSS_MODULE_TYPE_AUTO */
+/** @typedef {import("./ModuleTypeConstants").HTML_MODULE_TYPE} HTML_MODULE_TYPE */
 
-/** @typedef {JAVASCRIPT_MODULE_TYPE_AUTO | JAVASCRIPT_MODULE_TYPE_DYNAMIC | JAVASCRIPT_MODULE_TYPE_ESM | JSON_MODULE_TYPE | ASSET_MODULE_TYPE | ASSET_MODULE_TYPE_INLINE | ASSET_MODULE_TYPE_RESOURCE | ASSET_MODULE_TYPE_SOURCE | WEBASSEMBLY_MODULE_TYPE_ASYNC | WEBASSEMBLY_MODULE_TYPE_SYNC | CSS_MODULE_TYPE | CSS_MODULE_TYPE_GLOBAL | CSS_MODULE_TYPE_MODULE | CSS_MODULE_TYPE_AUTO} KnownNormalModuleTypes */
+/** @typedef {JAVASCRIPT_MODULE_TYPE_AUTO | JAVASCRIPT_MODULE_TYPE_DYNAMIC | JAVASCRIPT_MODULE_TYPE_ESM | JSON_MODULE_TYPE | ASSET_MODULE_TYPE | ASSET_MODULE_TYPE_INLINE | ASSET_MODULE_TYPE_RESOURCE | ASSET_MODULE_TYPE_SOURCE | WEBASSEMBLY_MODULE_TYPE_ASYNC | WEBASSEMBLY_MODULE_TYPE_SYNC | CSS_MODULE_TYPE | CSS_MODULE_TYPE_GLOBAL | CSS_MODULE_TYPE_MODULE | CSS_MODULE_TYPE_AUTO | HTML_MODULE_TYPE} KnownNormalModuleTypes */
 /** @typedef {KnownNormalModuleTypes | string} NormalModuleTypes */
 
 const EMPTY_RESOLVE_OPTIONS = {};
@@ -319,6 +321,11 @@ const ruleSetCompiler = new RuleSetCompiler([
 /** @typedef {import("../declarations/WebpackOptions").CssGeneratorOptions} CssGeneratorOptions */
 /** @typedef {import("../declarations/WebpackOptions").CssModuleGeneratorOptions} CssModuleGeneratorOptions */
 
+/** @typedef {import("./html/HtmlParser")} HtmlParser */
+/** @typedef {import("../declarations/WebpackOptions").EmptyParserOptions} HtmlParserOptions */
+/** @typedef {import("./html/HtmlGenerator")} HtmlGenerator */
+/** @typedef {import("../declarations/WebpackOptions").HtmlGeneratorOptions} HtmlGeneratorOptions */
+
 /* eslint-disable jsdoc/type-formatting */
 /**
  * Defines the shared type used by this module.
@@ -332,12 +339,13 @@ const ruleSetCompiler = new RuleSetCompiler([
  * [ASSET_MODULE_TYPE_RESOURCE, AssetParser, EmptyParserOptions, AssetGenerator, AssetGeneratorOptions],
  * [ASSET_MODULE_TYPE_SOURCE, AssetSourceParser, EmptyParserOptions, AssetSourceGenerator, EmptyGeneratorOptions],
  * [ASSET_MODULE_TYPE_BYTES, AssetBytesParser, EmptyParserOptions, AssetBytesGenerator, EmptyGeneratorOptions],
- * [WEBASSEMBLY_MODULE_TYPE_ASYNC, AsyncWebAssemblyParser, EmptyParserOptions, Generator, EmptyParserOptions],
- * [WEBASSEMBLY_MODULE_TYPE_SYNC, WebAssemblyParser, EmptyParserOptions, Generator, EmptyParserOptions],
+ * [WEBASSEMBLY_MODULE_TYPE_ASYNC, AsyncWebAssemblyParser, EmptyParserOptions, Generator, EmptyGeneratorOptions],
+ * [WEBASSEMBLY_MODULE_TYPE_SYNC, WebAssemblyParser, EmptyParserOptions, Generator, EmptyGeneratorOptions],
  * [CSS_MODULE_TYPE, CssParser, CssParserOptions, CssGenerator, CssGeneratorOptions],
  * [CSS_MODULE_TYPE_AUTO, CssParser, CssModuleParserOptions, CssGenerator, CssModuleGeneratorOptions],
  * [CSS_MODULE_TYPE_MODULE, CssParser, CssModuleParserOptions, CssGenerator, CssModuleGeneratorOptions],
  * [CSS_MODULE_TYPE_GLOBAL, CssParser, CssModuleParserOptions, CssGenerator, CssModuleGeneratorOptions],
+ * [HTML_MODULE_TYPE, HtmlParser, HtmlParserOptions, HtmlGenerator, HtmlGeneratorOptions],
  * [string, Parser, ParserOptions, Generator, GeneratorOptions],
  * ]} ParsersAndGeneratorsByTypes
  */
@@ -358,6 +366,18 @@ const ruleSetCompiler = new RuleSetCompiler([
  * @typedef {T extends [infer Head extends [string, ...unknown[]], ...infer Tail extends [string, ...unknown[]][]] ? Record<Head[0], SyncBailHook<ExtractTupleElements<Head, A>, R extends number ? Head[R] : R>> & RecordFactoryFromTuple<Tail, A, R> : unknown } RecordFactoryFromTuple
  */
 
+/**
+ * Maps each tuple in `T` to a record from its `[0]` key to its `[I]` value.
+ * @template {unknown[]} T
+ * @template {number} I
+ * @typedef {T extends [infer Head extends [string, ...unknown[]], ...infer Tail extends [string, ...unknown[]][]] ? Record<Head[0], I extends keyof Head ? Head[I] : never> & TupleToTypeMap<Tail, I> : unknown } TupleToTypeMap
+ */
+
+/** @typedef {TupleToTypeMap<ParsersAndGeneratorsByTypes, 1>} ParserByType */
+/** @typedef {TupleToTypeMap<ParsersAndGeneratorsByTypes, 2>} ParserOptionsByType */
+/** @typedef {TupleToTypeMap<ParsersAndGeneratorsByTypes, 3>} GeneratorByType */
+/** @typedef {TupleToTypeMap<ParsersAndGeneratorsByTypes, 4>} GeneratorOptionsByType */
+
 class NormalModuleFactory extends ModuleFactory {
 	/**
 	 * Creates an instance of NormalModuleFactory.
@@ -485,7 +505,9 @@ class NormalModuleFactory extends ModuleFactory {
 						// Ignored
 						if (result === false) return callback();
 
-						const createData = resolveData.createData;
+						const createData =
+							/** @type {CreateData} */
+							(resolveData.createData);
 
 						this.hooks.createModule.callAsync(
 							createData,
@@ -498,18 +520,12 @@ class NormalModuleFactory extends ModuleFactory {
 
 									// TODO webpack 6 make it required and move javascript/wasm/asset properties to own module
 									createdModule = this.hooks.createModuleClass
-										.for(
-											/** @type {ModuleSettings} */
-											(createData.settings).type
-										)
+										.for(createData.settings.type)
 										.call(createData, resolveData);
 
 									if (!createdModule) {
 										createdModule = /** @type {Module} */ (
-											new NormalModule(
-												/** @type {NormalModuleCreateData} */
-												(createData)
-											)
+											new NormalModule(createData)
 										);
 									}
 								}
@@ -910,7 +926,7 @@ class NormalModuleFactory extends ModuleFactory {
 						this.resolveResource(
 							contextInfo,
 							context,
-							unresolvedResource,
+							escapeHashInPathRequest(unresolvedResource),
 							normalResolver,
 							resolveContext,
 							(err, _resolvedResource, resolvedResourceResolveData) => {
@@ -1397,9 +1413,10 @@ If changing the source code is not an option there is also a resolve options cal
 
 	/**
 	 * Returns parser.
-	 * @param {string} type type
+	 * @template {string} T
+	 * @param {T} type type
 	 * @param {ParserOptions} parserOptions parser options
-	 * @returns {Parser} parser
+	 * @returns {ParserByType[T]} parser
 	 */
 	getParser(type, parserOptions = EMPTY_PARSER_OPTIONS) {
 		let cache = this.parserCache.get(type);
@@ -1416,14 +1433,15 @@ If changing the source code is not an option there is also a resolve options cal
 			cache.set(parserOptions, parser);
 		}
 
-		return parser;
+		return /** @type {ParserByType[T]} */ (parser);
 	}
 
 	/**
 	 * Creates a parser from the provided type.
-	 * @param {string} type type
+	 * @template {string} T
+	 * @param {T} type type
 	 * @param {ParserOptions} parserOptions parser options
-	 * @returns {Parser} parser
+	 * @returns {ParserByType[T]} parser
 	 */
 	createParser(type, parserOptions = {}) {
 		parserOptions = mergeGlobalOptions(
@@ -1436,14 +1454,15 @@ If changing the source code is not an option there is also a resolve options cal
 			throw new Error(`No parser registered for ${type}`);
 		}
 		this.hooks.parser.for(type).call(parser, parserOptions);
-		return parser;
+		return /** @type {ParserByType[T]} */ (parser);
 	}
 
 	/**
 	 * Returns generator.
-	 * @param {string} type type of generator
+	 * @template {string} T
+	 * @param {T} type type of generator
 	 * @param {GeneratorOptions} generatorOptions generator options
-	 * @returns {Generator} generator
+	 * @returns {GeneratorByType[T]} generator
 	 */
 	getGenerator(type, generatorOptions = EMPTY_GENERATOR_OPTIONS) {
 		let cache = this.generatorCache.get(type);
@@ -1460,14 +1479,15 @@ If changing the source code is not an option there is also a resolve options cal
 			cache.set(generatorOptions, generator);
 		}
 
-		return generator;
+		return /** @type {GeneratorByType[T]} */ (generator);
 	}
 
 	/**
 	 * Creates a generator.
-	 * @param {string} type type of generator
+	 * @template {string} T
+	 * @param {T} type type of generator
 	 * @param {GeneratorOptions} generatorOptions generator options
-	 * @returns {Generator} generator
+	 * @returns {GeneratorByType[T]} generator
 	 */
 	createGenerator(type, generatorOptions = {}) {
 		generatorOptions = mergeGlobalOptions(
@@ -1482,7 +1502,7 @@ If changing the source code is not an option there is also a resolve options cal
 			throw new Error(`No generator registered for ${type}`);
 		}
 		this.hooks.generator.for(type).call(generator, generatorOptions);
-		return generator;
+		return /** @type {GeneratorByType[T]} */ (generator);
 	}
 
 	/**

package/lib/Parser.js

@@ -33,7 +33,7 @@ class Parser {
 	 * @returns {ParserState} the parser state
 	 */
 	parse(source, state) {
-		const AbstractMethodError = require("./AbstractMethodError");
+		const AbstractMethodError = require("./errors/AbstractMethodError");
 
 		throw new AbstractMethodError();
 	}