@rspack/core 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/ChunkGroup.d.ts

@@ -6,6 +6,7 @@ export declare class ChunkGroup {
     protected constructor(inner: JsChunkGroup, compilation: JsCompilation);
     getFiles(): ReadonlyArray<string>;
     getParents(): ReadonlyArray<ChunkGroup>;
+    isInitial(): boolean;
     get chunks(): ReadonlyArray<Chunk>;
     get index(): Readonly<number | undefined>;
     get name(): Readonly<string | undefined>;

package/dist/ChunkGroup.js

@@ -40,6 +40,9 @@ class ChunkGroup {
             return ChunkGroup.__from_binding(cg, __classPrivateFieldGet(this, _ChunkGroup_innerCompilation, "f"));
         });
     }
+    isInitial() {
+        return __classPrivateFieldGet(this, _ChunkGroup_inner, "f").isInitial;
+    }
     get chunks() {
         return __classPrivateFieldGet(this, _ChunkGroup_inner, "f").chunks.map(c => Chunk_1.Chunk.__from_binding(c, __classPrivateFieldGet(this, _ChunkGroup_innerCompilation, "f")));
     }

package/dist/Compilation.d.ts

@@ -102,6 +102,24 @@ export interface KnownNormalizedStatsOptions {
     logging: false | "none" | "error" | "warn" | "info" | "log" | "verbose";
     loggingDebug: ((value: string) => boolean)[];
     loggingTrace: boolean;
+    chunkModules: boolean;
+    chunkRelations: boolean;
+    reasons: boolean;
+    moduleAssets: boolean;
+    nestedModules: boolean;
+    source: boolean;
+    usedExports: boolean;
+    providedExports: boolean;
+    optimizationBailout: boolean;
+    depth: boolean;
+    assets: boolean;
+    chunks: boolean;
+    errors: boolean;
+    errorsCount: boolean;
+    hash: boolean;
+    modules: boolean;
+    warnings: boolean;
+    warningsCount: boolean;
 }
 export type CreateStatsOptionsContext = KnownCreateStatsOptionsContext & Record<string, any>;
 export type NormalizedStatsOptions = KnownNormalizedStatsOptions & Omit<StatsOptions, keyof KnownNormalizedStatsOptions> & Record<string, any>;
@@ -149,6 +167,7 @@ export declare class Compilation {
             Set<string>
         ], void>;
         runtimeModule: RuntimeModule;
+        seal: liteTapable.SyncHook<[], void>;
         afterSeal: liteTapable.AsyncSeriesHook<[], void>;
     }>;
     name?: string;
@@ -192,6 +211,7 @@ export declare class Compilation {
      * Note: This is a proxy for webpack internal API, only method `get` and `keys` is supported now.
      */
     get namedChunks(): ReadonlyMap<string, Readonly<Chunk>>;
+    get entries(): Map<string, EntryData>;
     /**
      * Note: This is not a webpack public API, maybe removed in future.
      *
@@ -202,7 +222,7 @@ export declare class Compilation {
         buildMeta: Record<string, unknown>;
     };
     getCache(name: string): import("./lib/CacheFacade").CacheFacade;
-    createStatsOptions(optionsOrPreset: StatsValue | undefined, context?: CreateStatsOptionsContext): NormalizedStatsOptions;
+    createStatsOptions(statsValue: StatsValue | undefined, context?: CreateStatsOptionsContext): NormalizedStatsOptions;
     createStatsFactory(options: StatsOptions): StatsFactory;
     createStatsPrinter(options: StatsOptions): StatsPrinter;
     /**
@@ -355,3 +375,20 @@ export declare class Compilation {
     static PROCESS_ASSETS_STAGE_ANALYSE: number;
     static PROCESS_ASSETS_STAGE_REPORT: number;
 }
+export type EntryData = binding.JsEntryData;
+export declare class Entries implements Map<string, EntryData> {
+    #private;
+    constructor(data: binding.JsEntries);
+    clear(): void;
+    forEach(callback: (value: binding.JsEntryData, key: string, map: Map<string, binding.JsEntryData>) => void, thisArg?: any): void;
+    get size(): number;
+    entries(): IterableIterator<[string, binding.JsEntryData]>;
+    values(): IterableIterator<binding.JsEntryData>;
+    [Symbol.iterator](): IterableIterator<[string, binding.JsEntryData]>;
+    get [Symbol.toStringTag](): string;
+    has(key: string): boolean;
+    set(key: string, value: EntryData): this;
+    delete(key: string): boolean;
+    get(key: string): EntryData | undefined;
+    keys(): IterableIterator<string>;
+}

package/dist/Compilation.js

@@ -36,9 +36,9 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _Compilation_instances, _Compilation_inner, _Compilation_customModules, _Compilation_createCachedAssets, _Compilation_rebuildModuleCaller;
+var _Compilation_instances, _Compilation_inner, _Compilation_customModules, _Compilation_createCachedAssets, _Compilation_rebuildModuleCaller, _Entries_data;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Compilation = void 0;
+exports.Entries = exports.Compilation = void 0;
 const binding_1 = require("@rspack/binding");
 const liteTapable = __importStar(require("@rspack/lite-tapable"));
 const Chunk_1 = require("./Chunk");
@@ -98,12 +98,14 @@ class Compilation {
             const errorMessage = (reason) => `Can't automatically convert plugin using Compilation.hooks.${name} to Compilation.hooks.processAssets because ${reason}.
 BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a single Compilation.hooks.processAssets hook.`;
             const getOptions = (options) => {
-                if (typeof options === "string")
-                    options = { name: options };
-                if (options.stage) {
+                const isString = typeof options === "string";
+                if (!isString && options.stage) {
                     throw new Error(errorMessage("it's using the 'stage' option"));
                 }
-                return { ...options, stage: stage };
+                return {
+                    ...(isString ? { name: options } : options),
+                    stage: stage
+                };
             };
             return Object.freeze({
                 name,
@@ -157,6 +159,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
                 "runtimeRequirements"
             ]),
             runtimeModule: new liteTapable.SyncHook(["module", "chunk"]),
+            seal: new liteTapable.SyncHook([]),
             afterSeal: new liteTapable.AsyncSeriesHook([])
         };
         this.compiler = compiler;
@@ -237,6 +240,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
             }
         };
     }
+    get entries() {
+        return new Entries(__classPrivateFieldGet(this, _Compilation_inner, "f").entries);
+    }
     /**
      * Note: This is not a webpack public API, maybe removed in future.
      *
@@ -255,7 +261,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
     getCache(name) {
         return this.compiler.getCache(name);
     }
-    createStatsOptions(optionsOrPreset, context = {}) {
+    createStatsOptions(statsValue, context = {}) {
+        let optionsOrPreset = statsValue;
         if (typeof optionsOrPreset === "boolean" ||
             typeof optionsOrPreset === "string") {
             optionsOrPreset = { preset: optionsOrPreset };
@@ -448,12 +455,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
             {
                 method: "push",
                 handler(target, thisArg, warns) {
-                    warns = processWarningsHook.call(warns);
-                    for (let i = 0; i < warns.length; i++) {
-                        const warn = warns[i];
+                    return Reflect.apply(target, thisArg, processWarningsHook.call(warns).map(warn => {
                         inner.pushDiagnostic(RspackError_1.JsDiagnostic.__to_binding(warn, binding_1.JsRspackSeverity.Warn));
-                    }
-                    return Reflect.apply(target, thisArg, warns);
+                        return warn;
+                    }));
                 }
             },
             {
@@ -473,12 +478,11 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
             {
                 method: "unshift",
                 handler(target, thisArg, warns) {
-                    warns = processWarningsHook.call(warns);
-                    const warnList = warns.map(warn => {
+                    const warnings = processWarningsHook.call(warns);
+                    inner.spliceDiagnostic(0, 0, warnings.map(warn => {
                         return RspackError_1.JsDiagnostic.__to_binding(warn, binding_1.JsRspackSeverity.Warn);
-                    });
-                    inner.spliceDiagnostic(0, 0, warnList);
-                    return Reflect.apply(target, thisArg, warns);
+                    }));
+                    return Reflect.apply(target, thisArg, warnings);
                 }
             },
             {
@@ -521,11 +525,12 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
         if (!name) {
             throw new TypeError("Compilation.getLogger(name) called without a name");
         }
+        let logName = name;
         let logEntries;
         return new Logger_1.Logger((type, args) => {
-            if (typeof name === "function") {
-                name = name();
-                if (!name) {
+            if (typeof logName === "function") {
+                logName = logName();
+                if (!logName) {
                     throw new TypeError("Compilation.getLogger(name) called with a function not returning a name");
                 }
             }
@@ -545,67 +550,68 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
                 args,
                 trace
             };
-            if (this.hooks.log.call(name, logEntry) === undefined) {
+            if (this.hooks.log.call(logName, logEntry) === undefined) {
                 if (logEntry.type === Logger_1.LogType.profileEnd) {
                     if (typeof console.profileEnd === "function") {
-                        console.profileEnd(`[${name}] ${logEntry.args[0]}`);
+                        console.profileEnd(`[${logName}] ${logEntry.args[0]}`);
                     }
                 }
                 if (logEntries === undefined) {
-                    logEntries = this.logging.get(name);
+                    logEntries = this.logging.get(logName);
                     if (logEntries === undefined) {
                         logEntries = [];
-                        this.logging.set(name, logEntries);
+                        this.logging.set(logName, logEntries);
                     }
                 }
                 logEntries.push(logEntry);
                 if (logEntry.type === Logger_1.LogType.profile) {
                     if (typeof console.profile === "function") {
-                        console.profile(`[${name}] ${logEntry.args[0]}`);
+                        console.profile(`[${logName}] ${logEntry.args[0]}`);
                     }
                 }
             }
         }, (childName) => {
-            if (typeof name === "function") {
-                if (typeof childName === "function") {
+            let normalizedChildName = childName;
+            if (typeof logName === "function") {
+                if (typeof normalizedChildName === "function") {
                     return this.getLogger(() => {
-                        if (typeof name === "function") {
-                            name = name();
-                            if (!name) {
+                        if (typeof logName === "function") {
+                            logName = logName();
+                            if (!logName) {
                                 throw new TypeError("Compilation.getLogger(name) called with a function not returning a name");
                             }
                         }
-                        if (typeof childName === "function") {
-                            childName = childName();
-                            if (!childName) {
+                        if (typeof normalizedChildName === "function") {
+                            normalizedChildName = normalizedChildName();
+                            if (!normalizedChildName) {
                                 throw new TypeError("Logger.getChildLogger(name) called with a function not returning a name");
                             }
                         }
-                        return `${name}/${childName}`;
+                        return `${logName}/${normalizedChildName}`;
                     });
                 }
                 return this.getLogger(() => {
-                    if (typeof name === "function") {
-                        name = name();
-                        if (!name) {
+                    if (typeof logName === "function") {
+                        logName = logName();
+                        if (!logName) {
                             throw new TypeError("Compilation.getLogger(name) called with a function not returning a name");
                         }
                     }
-                    return `${name}/${childName}`;
+                    return `${logName}/${normalizedChildName}`;
                 });
             }
-            if (typeof childName === "function") {
+            if (typeof normalizedChildName === "function") {
                 return this.getLogger(() => {
-                    if (typeof childName === "function") {
-                        childName = childName();
-                        if (!childName) {
+                    if (typeof normalizedChildName === "function") {
+                        normalizedChildName = normalizedChildName();
+                        if (!normalizedChildName) {
                             throw new TypeError("Logger.getChildLogger(name) called with a function not returning a name");
                         }
                     }
-                    return `${name}/${childName}`;
+                    return `${logName}/${normalizedChildName}`;
                 });
             }
-            return this.getLogger(`${name}/${childName}`);
+            return this.getLogger(`${logName}/${normalizedChildName}`);
         });
     }
     getStats() {
@@ -759,3 +765,62 @@ Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER = 3000;
 Compilation.PROCESS_ASSETS_STAGE_ANALYSE = 4000;
 Compilation.PROCESS_ASSETS_STAGE_REPORT = 5000;
 exports.Compilation = Compilation;
+class Entries {
+    constructor(data) {
+        _Entries_data.set(this, void 0);
+        __classPrivateFieldSet(this, _Entries_data, data, "f");
+    }
+    clear() {
+        __classPrivateFieldGet(this, _Entries_data, "f").clear();
+    }
+    forEach(callback, thisArg) {
+        for (const [key, value] of this) {
+            callback.call(thisArg, value, key, this);
+        }
+    }
+    get size() {
+        return __classPrivateFieldGet(this, _Entries_data, "f").size;
+    }
+    entries() {
+        const self = this;
+        const keys = this.keys();
+        return {
+            [Symbol.iterator]() {
+                return this;
+            },
+            next() {
+                const { done, value } = keys.next();
+                return {
+                    done,
+                    value: done ? undefined : [value, self.get(value)]
+                };
+            }
+        };
+    }
+    values() {
+        return __classPrivateFieldGet(this, _Entries_data, "f").values()[Symbol.iterator]();
+    }
+    [(_Entries_data = new WeakMap(), Symbol.iterator)]() {
+        return this.entries();
+    }
+    get [Symbol.toStringTag]() {
+        return "Map";
+    }
+    has(key) {
+        return __classPrivateFieldGet(this, _Entries_data, "f").has(key);
+    }
+    set(key, value) {
+        __classPrivateFieldGet(this, _Entries_data, "f").set(key, value);
+        return this;
+    }
+    delete(key) {
+        return __classPrivateFieldGet(this, _Entries_data, "f").delete(key);
+    }
+    get(key) {
+        return __classPrivateFieldGet(this, _Entries_data, "f").get(key);
+    }
+    keys() {
+        return __classPrivateFieldGet(this, _Entries_data, "f").keys()[Symbol.iterator]();
+    }
+}
+exports.Entries = Entries;

package/dist/Compiler.d.ts

@@ -69,6 +69,7 @@ declare class Compiler {
         entryOption: liteTapable.SyncBailHook<[string, EntryNormalized], any>;
     };
     webpack: typeof rspack;
+    rspack: typeof rspack;
     name?: string;
     parentCompilation?: Compilation;
     root: Compiler;

package/dist/Compiler.js

@@ -137,6 +137,7 @@ class Compiler {
             entryOption: new liteTapable.SyncBailHook(["context", "entry"])
         };
         this.webpack = index_1.rspack;
+        this.rspack = index_1.rspack;
         this.root = this;
         this.outputPath = "";
         this.inputFileSystem = null;
@@ -199,62 +200,65 @@ class Compiler {
         if (!name) {
             throw new TypeError("Compiler.getInfrastructureLogger(name) called without a name");
         }
+        let normalizedName = name;
         return new Logger_1.Logger((type, args) => {
-            if (typeof name === "function") {
-                name = name();
-                if (!name) {
+            if (typeof normalizedName === "function") {
+                normalizedName = normalizedName();
+                if (!normalizedName) {
                     throw new TypeError("Compiler.getInfrastructureLogger(name) called with a function not returning a name");
                 }
             }
             else {
-                if (this.hooks.infrastructureLog.call(name, type, args) === undefined) {
+                if (this.hooks.infrastructureLog.call(normalizedName, type, args) ===
+                    undefined) {
                     if (this.infrastructureLogger !== undefined) {
-                        this.infrastructureLogger(name, type, args);
+                        this.infrastructureLogger(normalizedName, type, args);
                     }
                 }
             }
         }, (childName) => {
-            if (typeof name === "function") {
-                if (typeof childName === "function") {
+            let normalizedChildName = childName;
+            if (typeof normalizedName === "function") {
+                if (typeof normalizedChildName === "function") {
                     // @ts-expect-error
                     return this.getInfrastructureLogger(_ => {
-                        if (typeof name === "function") {
-                            name = name();
-                            if (!name) {
+                        if (typeof normalizedName === "function") {
+                            normalizedName = normalizedName();
+                            if (!normalizedName) {
                                 throw new TypeError("Compiler.getInfrastructureLogger(name) called with a function not returning a name");
                             }
                         }
-                        if (typeof childName === "function") {
-                            childName = childName();
-                            if (!childName) {
+                        if (typeof normalizedChildName === "function") {
+                            normalizedChildName = normalizedChildName();
+                            if (!normalizedChildName) {
                                 throw new TypeError("Logger.getChildLogger(name) called with a function not returning a name");
                             }
                         }
-                        return `${name}/${childName}`;
+                        return `${normalizedName}/${normalizedChildName}`;
                     });
                 }
                 return this.getInfrastructureLogger(() => {
-                    if (typeof name === "function") {
-                        name = name();
-                        if (!name) {
+                    if (typeof normalizedName === "function") {
+                        normalizedName = normalizedName();
+                        if (!normalizedName) {
                             throw new TypeError("Compiler.getInfrastructureLogger(name) called with a function not returning a name");
                         }
                     }
-                    return `${name}/${childName}`;
+                    return `${normalizedName}/${normalizedChildName}`;
                 });
             }
-            if (typeof childName === "function") {
+            if (typeof normalizedChildName === "function") {
                 return this.getInfrastructureLogger(() => {
-                    if (typeof childName === "function") {
-                        childName = childName();
-                        if (!childName) {
+                    if (typeof normalizedChildName === "function") {
+                        normalizedChildName = normalizedChildName();
+                        if (!normalizedChildName) {
                             throw new TypeError("Logger.getChildLogger(name) called with a function not returning a name");
                         }
                     }
-                    return `${name}/${childName}`;
+                    return `${normalizedName}/${normalizedChildName}`;
                 });
             }
-            return this.getInfrastructureLogger(`${name}/${childName}`);
+            return this.getInfrastructureLogger(`${normalizedName}/${normalizedChildName}`);
         });
     }
     /**
@@ -368,7 +372,7 @@ class Compiler {
         });
     }
     purgeInputFileSystem() {
-        if (this.inputFileSystem && this.inputFileSystem.purge) {
+        if (this.inputFileSystem?.purge) {
             this.inputFileSystem.purge();
         }
     }
@@ -614,7 +618,7 @@ _Compiler_instance = new WeakMap(), _Compiler_initial = new WeakMap(), _Compiler
                         throw cached.error;
                     return cached.exports;
                 }
-                var execOptions = {
+                const execOptions = {
                     id,
                     module: {
                         id,
@@ -665,6 +669,7 @@ _Compiler_instance = new WeakMap(), _Compiler_initial = new WeakMap(), _Compiler
         registerCompilationChunkAssetTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationChunkAsset, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.chunkAsset, queried => ({ chunk, filename }) => queried.call(Chunk_1.Chunk.__from_binding(chunk, __classPrivateFieldGet(this, _Compiler_compilation, "f")), filename)),
         registerCompilationProcessAssetsTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationProcessAssets, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.processAssets, queried => async () => await queried.promise(__classPrivateFieldGet(this, _Compiler_compilation, "f").assets)),
         registerCompilationAfterProcessAssetsTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationAfterProcessAssets, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.afterProcessAssets, queried => () => queried.call(__classPrivateFieldGet(this, _Compiler_compilation, "f").assets)),
+        registerCompilationSealTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationSeal, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.seal, queried => () => queried.call()),
         registerCompilationAfterSealTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationAfterSeal, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.afterSeal, queried => async () => await queried.promise()),
         registerNormalModuleFactoryBeforeResolveTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.NormalModuleFactoryBeforeResolve, () => __classPrivateFieldGet(this, _Compiler_compilationParams, "f").normalModuleFactory.hooks.beforeResolve, queried => async (resolveData) => {
             const normalizedResolveData = {

package/dist/ExecuteModulePlugin.d.ts

@@ -1,5 +1,4 @@
 import type { Compiler } from "./Compiler";
 export default class ExecuteModulePlugin {
-    constructor();
     apply(compiler: Compiler): void;
 }

package/dist/ExecuteModulePlugin.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const node_vm_1 = __importDefault(require("node:vm"));
 const _1 = require(".");
 class ExecuteModulePlugin {
-    constructor() { }
     apply(compiler) {
         compiler.hooks.compilation.tap("executeModule", compilation => {
             compilation.hooks.executeModule.tap("executeModule", (options, context) => {

package/dist/Module.d.ts

@@ -1,4 +1,4 @@
-import type { JsCodegenerationResult, JsCodegenerationResults, JsCreateData, JsFactoryMeta, JsModule } from "@rspack/binding";
+import type { JsCodegenerationResult, JsCreateData, JsFactoryMeta, JsModule } from "@rspack/binding";
 import type { Source } from "../compiled/webpack-sources";
 import type { Compilation } from "./Compilation";
 export type ResourceData = {
@@ -68,5 +68,4 @@ export declare class CodeGenerationResult {
     get(sourceType: string): string;
 }
 export declare class CodeGenerationResults {
-    constructor(_result: JsCodegenerationResults);
 }

package/dist/Module.js

@@ -67,6 +67,5 @@ class CodeGenerationResult {
 exports.CodeGenerationResult = CodeGenerationResult;
 _CodeGenerationResult_inner = new WeakMap();
 class CodeGenerationResults {
-    constructor(_result) { }
 }
 exports.CodeGenerationResults = CodeGenerationResults;

package/dist/MultiCompiler.js

@@ -51,21 +51,25 @@ const ArrayQueue_1 = __importDefault(require("./util/ArrayQueue"));
 class MultiCompiler {
     constructor(compilers, options) {
         _MultiCompiler_instances.add(this);
+        let normalizedCompilers;
         if (!Array.isArray(compilers)) {
-            compilers = Object.entries(compilers).map(([name, compiler]) => {
+            normalizedCompilers = Object.entries(compilers).map(([name, compiler]) => {
                 compiler.name = name;
                 return compiler;
             });
         }
+        else {
+            normalizedCompilers = compilers;
+        }
         this.hooks = {
             done: new liteTapable.SyncHook(["stats"]),
-            invalid: new liteTapable.MultiHook(compilers.map(c => c.hooks.invalid)),
-            run: new liteTapable.MultiHook(compilers.map(c => c.hooks.run)),
+            invalid: new liteTapable.MultiHook(normalizedCompilers.map(c => c.hooks.invalid)),
+            run: new liteTapable.MultiHook(normalizedCompilers.map(c => c.hooks.run)),
             watchClose: new liteTapable.SyncHook([]),
-            watchRun: new liteTapable.MultiHook(compilers.map(c => c.hooks.watchRun)),
-            infrastructureLog: new liteTapable.MultiHook(compilers.map(c => c.hooks.infrastructureLog))
+            watchRun: new liteTapable.MultiHook(normalizedCompilers.map(c => c.hooks.watchRun)),
+            infrastructureLog: new liteTapable.MultiHook(normalizedCompilers.map(c => c.hooks.infrastructureLog))
         };
-        this.compilers = compilers;
+        this.compilers = normalizedCompilers;
         this._options = {
             parallelism: options?.parallelism || Number.POSITIVE_INFINITY
         };
@@ -271,7 +275,7 @@ class MultiCompiler {
     }
     purgeInputFileSystem() {
         for (const compiler of this.compilers) {
-            if (compiler.inputFileSystem && compiler.inputFileSystem.purge) {
+            if (compiler.inputFileSystem?.purge) {
                 compiler.inputFileSystem.purge();
             }
         }

package/dist/MultiStats.d.ts

@@ -16,7 +16,7 @@ export default class MultiStats {
     get hash(): string;
     hasErrors(): boolean;
     hasWarnings(): boolean;
-    toJson(options?: any): StatsCompilation;
+    toJson(options: any): StatsCompilation;
     toString(options: any): string;
 }
 export { MultiStats };