webpack 5.84.1 → 5.85.0

package/schemas/WebpackOptions.json

@@ -744,10 +744,18 @@
           "description": "The environment supports an async import() function to import EcmaScript modules.",
           "type": "boolean"
         },
+        "dynamicImportInWorker": {
+          "description": "The environment supports an async import() is available when creating a worker.",
+          "type": "boolean"
+        },
         "forOf": {
           "description": "The environment supports 'for of' iteration ('for (const x of array) { ... }').",
           "type": "boolean"
         },
+        "globalThis": {
+          "description": "The environment supports 'globalThis'.",
+          "type": "boolean"
+        },
         "module": {
           "description": "The environment supports EcmaScript Module syntax to import EcmaScript modules (import ... from '...').",
           "type": "boolean"
@@ -1254,6 +1262,10 @@
           "description": "Track and log detailed timing information for individual cache items.",
           "type": "boolean"
         },
+        "readonly": {
+          "description": "Enable/disable readonly mode.",
+          "type": "boolean"
+        },
         "store": {
           "description": "When to store data to the filesystem. (pack: Store data when compiler is idle in a single file).",
           "enum": ["pack"]

package/types.d.ts

@@ -356,7 +356,7 @@ declare class AsyncDependenciesBlock extends DependenciesBlock {
 	};
 	loc?: SyntheticDependencyLocation | RealDependencyLocation;
 	request?: string;
-	chunkName: string;
+	chunkName?: string;
 	module: any;
 }
 declare abstract class AsyncQueue<T, K, R> {
@@ -383,18 +383,28 @@ declare abstract class AsyncQueue<T, K, R> {
 	clear(): void;
 }
 declare class AsyncWebAssemblyModulesPlugin {
-	constructor(options?: any);
-	options: any;
+	constructor(options: AsyncWebAssemblyModulesPluginOptions);
+	options: AsyncWebAssemblyModulesPluginOptions;
 
 	/**
 	 * Apply the plugin
 	 */
 	apply(compiler: Compiler): void;
-	renderModule(module?: any, renderContext?: any, hooks?: any): any;
+	renderModule(
+		module: Module,
+		renderContext: WebAssemblyRenderContext,
+		hooks: CompilationHooksAsyncWebAssemblyModulesPlugin
+	): Source;
 	static getCompilationHooks(
 		compilation: Compilation
 	): CompilationHooksAsyncWebAssemblyModulesPlugin;
 }
+declare interface AsyncWebAssemblyModulesPluginOptions {
+	/**
+	 * mangle imports
+	 */
+	mangleImports?: boolean;
+}
 declare class AutomaticPrefetchPlugin {
 	constructor();
 
@@ -497,6 +507,7 @@ declare abstract class BasicEvaluatedExpression {
 	rootInfo: string | VariableInfoInterface;
 	getMembers: () => string[];
 	getMembersOptionals: () => boolean[];
+	getMemberRangeStarts: () => number[];
 	expression: NodeEstreeIndex;
 	isUnknown(): boolean;
 	isNull(): boolean;
@@ -581,7 +592,8 @@ declare abstract class BasicEvaluatedExpression {
 		identifier: string | VariableInfoInterface,
 		rootInfo: string | VariableInfoInterface,
 		getMembers: () => string[],
-		getMembersOptionals?: () => boolean[]
+		getMembersOptionals?: () => boolean[],
+		getMemberRangeStarts?: () => number[]
 	): BasicEvaluatedExpression;
 
 	/**
@@ -776,6 +788,7 @@ declare interface CallExpressionInfo {
 	name: string;
 	getMembers: () => string[];
 	getMembersOptionals: () => boolean[];
+	getMemberRangeStarts: () => number[];
 }
 declare interface CallbackAsyncQueue<T> {
 	(err?: null | WebpackError, result?: T): any;
@@ -1106,9 +1119,9 @@ declare abstract class ChunkGroup {
 	removeParent(chunkGroup: ChunkGroup): boolean;
 	addAsyncEntrypoint(entrypoint: Entrypoint): boolean;
 	get asyncEntrypointsIterable(): SortableSet<ChunkGroup>;
-	getBlocks(): any[];
+	getBlocks(): AsyncDependenciesBlock[];
 	getNumberOfBlocks(): number;
-	hasBlock(block?: any): boolean;
+	hasBlock(block: AsyncDependenciesBlock): boolean;
 	get blocksIterable(): Iterable<AsyncDependenciesBlock>;
 	addBlock(block: AsyncDependenciesBlock): boolean;
 	addOrigin(module: Module, loc: DependencyLocation, request: string): void;
@@ -1177,14 +1190,35 @@ declare interface ChunkMaps {
 	name: Record<string | number, string>;
 }
 declare class ChunkModuleIdRangePlugin {
-	constructor(options?: any);
-	options: any;
+	constructor(options: ChunkModuleIdRangePluginOptions);
+	options: ChunkModuleIdRangePluginOptions;
 
 	/**
 	 * Apply the plugin
 	 */
 	apply(compiler: Compiler): void;
 }
+declare interface ChunkModuleIdRangePluginOptions {
+	/**
+	 * the chunk name
+	 */
+	name: string;
+
+	/**
+	 * order
+	 */
+	order?: "index" | "index2" | "preOrderIndex" | "postOrderIndex";
+
+	/**
+	 * start id
+	 */
+	start?: number;
+
+	/**
+	 * end id
+	 */
+	end?: number;
+}
 declare interface ChunkModuleMaps {
 	id: Record<string | number, (string | number)[]>;
 	hash: Record<string | number, string>;
@@ -1482,7 +1516,7 @@ declare class Compilation {
 			any
 		>;
 		afterOptimizeChunkModules: SyncHook<[Iterable<Chunk>, Iterable<Module>]>;
-		shouldRecord: SyncBailHook<[], boolean>;
+		shouldRecord: SyncBailHook<[], undefined | boolean>;
 		additionalChunkRuntimeRequirements: SyncHook<
 			[Chunk, Set<string>, RuntimeRequirementsContext]
 		>;
@@ -1990,8 +2024,8 @@ declare interface CompilationHooksJavascriptModulesPlugin {
 		[Module, RenderBootstrapContext],
 		string
 	>;
-	embedInRuntimeBailout: SyncBailHook<[Module, RenderContext], string>;
-	strictRuntimeBailout: SyncBailHook<[RenderContext], string>;
+	embedInRuntimeBailout: SyncBailHook<[Module, RenderContext], string | void>;
+	strictRuntimeBailout: SyncBailHook<[RenderContext], string | void>;
 	chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
 	useSourceMap: SyncBailHook<[Chunk, RenderContext], boolean>;
 }
@@ -2006,7 +2040,7 @@ declare class Compiler {
 	constructor(context: string, options?: WebpackOptionsNormalized);
 	hooks: Readonly<{
 		initialize: SyncHook<[]>;
-		shouldEmit: SyncBailHook<[Compilation], boolean>;
+		shouldEmit: SyncBailHook<[Compilation], undefined | boolean>;
 		done: AsyncSeriesHook<[Stats]>;
 		afterDone: SyncHook<[Stats]>;
 		additionalPass: AsyncSeriesHook<[]>;
@@ -2892,73 +2926,65 @@ declare abstract class DependencyTemplates {
 	clone(): DependencyTemplates;
 }
 declare class DeterministicChunkIdsPlugin {
-	constructor(options?: any);
-	options: any;
+	constructor(options?: DeterministicChunkIdsPluginOptions);
+	options: DeterministicChunkIdsPluginOptions;
 
 	/**
 	 * Apply the plugin
 	 */
 	apply(compiler: Compiler): void;
 }
+declare interface DeterministicChunkIdsPluginOptions {
+	/**
+	 * context for ids
+	 */
+	context?: string;
+
+	/**
+	 * maximum length of ids
+	 */
+	maxLength?: number;
+}
 declare class DeterministicModuleIdsPlugin {
-	constructor(options?: {
-		/**
-		 * context relative to which module identifiers are computed
-		 */
-		context?: string;
-		/**
-		 * selector function for modules
-		 */
-		test?: (arg0: Module) => boolean;
-		/**
-		 * maximum id length in digits (used as starting point)
-		 */
-		maxLength?: number;
-		/**
-		 * hash salt for ids
-		 */
-		salt?: number;
-		/**
-		 * do not increase the maxLength to find an optimal id space size
-		 */
-		fixedLength?: boolean;
-		/**
-		 * throw an error when id conflicts occur (instead of rehashing)
-		 */
-		failOnConflict?: boolean;
-	});
-	options: {
-		/**
-		 * context relative to which module identifiers are computed
-		 */
-		context?: string;
-		/**
-		 * selector function for modules
-		 */
-		test?: (arg0: Module) => boolean;
-		/**
-		 * maximum id length in digits (used as starting point)
-		 */
-		maxLength?: number;
-		/**
-		 * hash salt for ids
-		 */
-		salt?: number;
-		/**
-		 * do not increase the maxLength to find an optimal id space size
-		 */
-		fixedLength?: boolean;
-		/**
-		 * throw an error when id conflicts occur (instead of rehashing)
-		 */
-		failOnConflict?: boolean;
-	};
+	constructor(options?: DeterministicModuleIdsPluginOptions);
+	options: DeterministicModuleIdsPluginOptions;
 
 	/**
 	 * Apply the plugin
 	 */
 	apply(compiler: Compiler): void;
 }
+declare interface DeterministicModuleIdsPluginOptions {
+	/**
+	 * context relative to which module identifiers are computed
+	 */
+	context?: string;
+
+	/**
+	 * selector function for modules
+	 */
+	test?: (arg0: Module) => boolean;
+
+	/**
+	 * maximum id length in digits (used as starting point)
+	 */
+	maxLength?: number;
+
+	/**
+	 * hash salt for ids
+	 */
+	salt?: number;
+
+	/**
+	 * do not increase the maxLength to find an optimal id space size
+	 */
+	fixedLength?: boolean;
+
+	/**
+	 * throw an error when id conflicts occur (instead of rehashing)
+	 */
+	failOnConflict?: boolean;
+}
 
 /**
  * Options for the webpack-dev-server.
@@ -3491,11 +3517,21 @@ declare interface Environment {
 	 */
 	dynamicImport?: boolean;
 
+	/**
+	 * The environment supports an async import() is available when creating a worker.
+	 */
+	dynamicImportInWorker?: boolean;
+
 	/**
 	 * The environment supports 'for of' iteration ('for (const x of array) { ... }').
 	 */
 	forOf?: boolean;
 
+	/**
+	 * The environment supports 'globalThis'.
+	 */
+	globalThis?: boolean;
+
 	/**
 	 * The environment supports EcmaScript Module syntax to import EcmaScript modules (import ... from '...').
 	 */
@@ -3955,6 +3991,7 @@ declare interface ExpressionExpressionInfo {
 	name: string;
 	getMembers: () => string[];
 	getMembersOptionals: () => boolean[];
+	getMemberRangeStarts: () => number[];
 }
 declare interface ExtensionAliasOption {
 	alias: string | string[];
@@ -4168,14 +4205,20 @@ declare class FetchCompileAsyncWasmPlugin {
 	apply(compiler: Compiler): void;
 }
 declare class FetchCompileWasmPlugin {
-	constructor(options?: any);
-	options: any;
+	constructor(options?: FetchCompileWasmPluginOptions);
+	options: FetchCompileWasmPluginOptions;
 
 	/**
 	 * Apply the plugin
 	 */
 	apply(compiler: Compiler): void;
 }
+declare interface FetchCompileWasmPluginOptions {
+	/**
+	 * mangle imports
+	 */
+	mangleImports?: boolean;
+}
 
 /**
  * Options object for persistent file-based caching.
@@ -4261,6 +4304,11 @@ declare interface FileCacheOptions {
 	 */
 	profile?: boolean;
 
+	/**
+	 * Enable/disable readonly mode.
+	 */
+	readonly?: boolean;
+
 	/**
 	 * When to store data to the filesystem. (pack: Store data when compiler is idle in a single file).
 	 */
@@ -4679,7 +4727,11 @@ declare interface HashableObject {
 declare class HashedModuleIdsPlugin {
 	constructor(options?: HashedModuleIdsPluginOptions);
 	options: HashedModuleIdsPluginOptions;
-	apply(compiler?: any): void;
+
+	/**
+	 * Apply the plugin
+	 */
+	apply(compiler: Compiler): void;
 }
 declare interface HashedModuleIdsPluginOptions {
 	/**
@@ -5291,7 +5343,10 @@ declare class JavascriptParser extends Parser {
 		topLevelAwait: SyncBailHook<[Expression], boolean | void>;
 		call: HookMap<SyncBailHook<[BaseCallExpression], boolean | void>>;
 		callMemberChain: HookMap<
-			SyncBailHook<[CallExpression, string[], boolean[]], boolean | void>
+			SyncBailHook<
+				[CallExpression, string[], boolean[], number[]],
+				boolean | void
+			>
 		>;
 		memberChainOfCallMemberChain: HookMap<
 			SyncBailHook<
@@ -5310,7 +5365,7 @@ declare class JavascriptParser extends Parser {
 		binaryExpression: SyncBailHook<[BinaryExpression], boolean | void>;
 		expression: HookMap<SyncBailHook<[Expression], boolean | void>>;
 		expressionMemberChain: HookMap<
-			SyncBailHook<[Expression, string[], boolean[]], boolean | void>
+			SyncBailHook<[Expression, string[], boolean[], number[]], boolean | void>
 		>;
 		unhandledExpressionMemberChain: HookMap<
 			SyncBailHook<[Expression, string[]], boolean | void>
@@ -5899,6 +5954,7 @@ declare class JavascriptParser extends Parser {
 			| YieldExpression
 			| Super;
 		membersOptionals: boolean[];
+		memberRangeStarts: number[];
 	};
 	getFreeInfoFromVariable(varName: string): {
 		name: string;
@@ -7028,6 +7084,12 @@ declare interface LoaderRunnerLoaderContext<OptionsType> {
 	 * Example: "web"
 	 */
 	target: string;
+
+	/**
+	 * Tell what kind of ES-features may be used in the generated runtime-code.
+	 * Example: { arrowFunction: true }
+	 */
+	environment: Environment;
 }
 declare class LoaderTargetPlugin {
 	constructor(target: string);
@@ -7191,64 +7253,18 @@ declare interface MinChunkSizePluginOptions {
 	minChunkSize: number;
 }
 declare class Module extends DependenciesBlock {
-	constructor(
-		type:
-			| ""
-			| "runtime"
-			| "javascript/auto"
-			| "javascript/dynamic"
-			| "javascript/esm"
-			| "json"
-			| "webassembly/async"
-			| "webassembly/sync"
-			| "css"
-			| "css/global"
-			| "css/module"
-			| "asset"
-			| "asset/inline"
-			| "asset/resource"
-			| "asset/source"
-			| "asset/raw-data-url"
-			| "fallback-module"
-			| "remote-module"
-			| "provide-module"
-			| "consume-shared-module"
-			| "lazy-compilation-proxy",
-		context?: string,
-		layer?: string
-	);
-	type:
-		| ""
-		| "runtime"
-		| "javascript/auto"
-		| "javascript/dynamic"
-		| "javascript/esm"
-		| "json"
-		| "webassembly/async"
-		| "webassembly/sync"
-		| "css"
-		| "css/global"
-		| "css/module"
-		| "asset"
-		| "asset/inline"
-		| "asset/resource"
-		| "asset/source"
-		| "asset/raw-data-url"
-		| "fallback-module"
-		| "remote-module"
-		| "provide-module"
-		| "consume-shared-module"
-		| "lazy-compilation-proxy";
+	constructor(type: string, context?: null | string, layer?: null | string);
+	type: string;
 	context: null | string;
 	layer: null | string;
 	needId: boolean;
 	debugId: number;
-	resolveOptions: ResolveOptionsWebpackOptions;
+	resolveOptions?: ResolveOptionsWebpackOptions;
 	factoryMeta?: object;
 	useSourceMap: boolean;
 	useSimpleSourceMap: boolean;
-	buildMeta: BuildMeta;
-	buildInfo: Record<string, any>;
+	buildMeta?: BuildMeta;
+	buildInfo?: Record<string, any>;
 	presentationalDependencies?: Dependency[];
 	codeGenerationDependencies?: Dependency[];
 	id: string | number;
@@ -7265,9 +7281,9 @@ declare class Module extends DependenciesBlock {
 		| ((requestShortener: RequestShortener) => string)
 	)[];
 	get optional(): boolean;
-	addChunk(chunk?: any): boolean;
-	removeChunk(chunk?: any): void;
-	isInChunk(chunk?: any): boolean;
+	addChunk(chunk: Chunk): boolean;
+	removeChunk(chunk: Chunk): void;
+	isInChunk(chunk: Chunk): boolean;
 	isEntryModule(): boolean;
 	getChunks(): Chunk[];
 	getNumberOfChunks(): number;
@@ -7397,7 +7413,7 @@ declare class ModuleDependency extends Dependency {
 declare abstract class ModuleFactory {
 	create(
 		data: ModuleFactoryCreateData,
-		callback: (arg0?: Error, arg1?: ModuleFactoryResult) => void
+		callback: (arg0?: null | Error, arg1?: ModuleFactoryResult) => void
 	): void;
 }
 declare interface ModuleFactoryCreateData {
@@ -7960,24 +7976,41 @@ declare abstract class MultiWatching {
 	close(callback: CallbackFunction<void>): void;
 }
 declare class NamedChunkIdsPlugin {
-	constructor(options?: any);
-	delimiter: any;
-	context: any;
+	constructor(options?: NamedChunkIdsPluginOptions);
+	delimiter: string;
+	context?: string;
 
 	/**
 	 * Apply the plugin
 	 */
 	apply(compiler: Compiler): void;
 }
+declare interface NamedChunkIdsPluginOptions {
+	/**
+	 * context
+	 */
+	context?: string;
+
+	/**
+	 * delimiter
+	 */
+	delimiter?: string;
+}
 declare class NamedModuleIdsPlugin {
-	constructor(options?: any);
-	options: any;
+	constructor(options?: NamedModuleIdsPluginOptions);
+	options: NamedModuleIdsPluginOptions;
 
 	/**
 	 * Apply the plugin
 	 */
 	apply(compiler: Compiler): void;
 }
+declare interface NamedModuleIdsPluginOptions {
+	/**
+	 * context
+	 */
+	context?: string;
+}
 declare class NaturalModuleIdsPlugin {
 	constructor();
 
@@ -8130,13 +8163,19 @@ declare class NodeTargetPlugin {
 	apply(compiler: Compiler): void;
 }
 declare class NodeTemplatePlugin {
-	constructor(options?: any);
+	constructor(options?: NodeTemplatePluginOptions);
 
 	/**
 	 * Apply the plugin
 	 */
 	apply(compiler: Compiler): void;
 }
+declare interface NodeTemplatePluginOptions {
+	/**
+	 * enable async chunk loading
+	 */
+	asyncChunkLoading?: boolean;
+}
 type NodeWebpackOptions = false | NodeOptions;
 declare class NormalModule extends Module {
 	constructor(__0: NormalModuleCreateData);
@@ -9886,14 +9925,20 @@ declare interface RawSourceMap {
 	file: string;
 }
 declare class ReadFileCompileWasmPlugin {
-	constructor(options?: any);
-	options: any;
+	constructor(options?: ReadFileCompileWasmPluginOptions);
+	options: ReadFileCompileWasmPluginOptions;
 
 	/**
 	 * Apply the plugin
 	 */
 	apply(compiler: Compiler): void;
 }
+declare interface ReadFileCompileWasmPluginOptions {
+	/**
+	 * mangle imports
+	 */
+	mangleImports?: boolean;
+}
 declare interface ReaddirOptions {
 	encoding?:
 		| null
@@ -10883,9 +10928,9 @@ declare class RuntimeModule extends Module {
 	constructor(name: string, stage?: number);
 	name: string;
 	stage: number;
-	compilation: Compilation;
-	chunk: Chunk;
-	chunkGraph: ChunkGraph;
+	compilation?: Compilation;
+	chunk?: Chunk;
+	chunkGraph?: ChunkGraph;
 	fullHash: boolean;
 	dependentHash: boolean;
 	attach(compilation: Compilation, chunk: Chunk, chunkGraph?: ChunkGraph): void;
@@ -11254,7 +11299,7 @@ declare abstract class RuntimeTemplate {
 		/**
 		 * when false, call context will not be preserved
 		 */
-		callContext: boolean;
+		callContext: null | boolean;
 		/**
 		 * when true and accessing the default exports, interop code will be generated
 		 */
@@ -12460,7 +12505,7 @@ declare class Template {
 		modules: Module[],
 		renderModule: (arg0: Module) => Source,
 		prefix?: string
-	): Source;
+	): null | Source;
 	static renderRuntimeModules(
 		runtimeModules: RuntimeModule[],
 		renderContext: RenderContext & {
@@ -13514,7 +13559,7 @@ declare namespace exports {
 		export { ProfilingPlugin };
 	}
 	export namespace util {
-		export const createHash: (algorithm: string | typeof Hash) => Hash;
+		export const createHash: (algorithm?: string | typeof Hash) => Hash;
 		export namespace comparators {
 			export let compareChunksById: (a: Chunk, b: Chunk) => 0 | 1 | -1;
 			export let compareModulesByIdentifier: (