@rspack-debug/browser 0.0.0-alpha.0 → 1.6.4

package/dist/Compiler.d.ts

@@ -0,0 +1,223 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3bb53f36a5b8fc6bc1bd976ed7af161bd80/lib/Compiler.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type binding from "./binding";
+import * as liteTapable from "@rspack/lite-tapable";
+import type Watchpack from "watchpack";
+import type { Source } from "webpack-sources";
+import type { Chunk } from "./Chunk";
+import type { CompilationParams } from "./Compilation";
+import { Compilation } from "./Compilation";
+import { ContextModuleFactory } from "./ContextModuleFactory";
+import type { EntryNormalized, OutputNormalized, RspackOptionsNormalized, RspackPluginInstance } from "./config";
+import type { FileSystemInfoEntry } from "./FileSystemInfo";
+import { rspack } from "./index";
+import Cache from "./lib/Cache";
+import CacheFacade from "./lib/CacheFacade";
+import { Logger } from "./logging/Logger";
+import { NormalModuleFactory } from "./NormalModuleFactory";
+import { ResolverFactory } from "./ResolverFactory";
+import { RuleSetCompiler } from "./RuleSetCompiler";
+import { Stats } from "./Stats";
+import type { InputFileSystem, IntermediateFileSystem, OutputFileSystem, WatchFileSystem } from "./util/fs";
+import { Watching } from "./Watching";
+export interface AssetEmittedInfo {
+    content: Buffer;
+    source: Source;
+    outputPath: string;
+    targetPath: string;
+    compilation: Compilation;
+}
+export type CompilerHooks = {
+    done: liteTapable.AsyncSeriesHook<Stats>;
+    afterDone: liteTapable.SyncHook<Stats>;
+    thisCompilation: liteTapable.SyncHook<[Compilation, CompilationParams]>;
+    compilation: liteTapable.SyncHook<[Compilation, CompilationParams]>;
+    invalid: liteTapable.SyncHook<[string | null, number]>;
+    compile: liteTapable.SyncHook<[CompilationParams]>;
+    normalModuleFactory: liteTapable.SyncHook<NormalModuleFactory>;
+    contextModuleFactory: liteTapable.SyncHook<ContextModuleFactory>;
+    initialize: liteTapable.SyncHook<[]>;
+    shouldEmit: liteTapable.SyncBailHook<[Compilation], boolean>;
+    /**
+     * Called when infrastructure logging is triggered, allowing plugins to intercept, modify, or handle log messages.
+     * If the hook returns `true`, the default infrastructure logging will be prevented.
+     * If it returns `undefined`, the default logging will proceed.
+     * @param name - The name of the logger
+     * @param type - The log type (e.g., 'log', 'warn', 'error', ...)
+     * @param args - An array of arguments passed to the logging method
+     */
+    infrastructureLog: liteTapable.SyncBailHook<[
+        string,
+        string,
+        any[]
+    ], true | void>;
+    beforeRun: liteTapable.AsyncSeriesHook<[Compiler]>;
+    run: liteTapable.AsyncSeriesHook<[Compiler]>;
+    emit: liteTapable.AsyncSeriesHook<[Compilation]>;
+    assetEmitted: liteTapable.AsyncSeriesHook<[string, AssetEmittedInfo]>;
+    afterEmit: liteTapable.AsyncSeriesHook<[Compilation]>;
+    failed: liteTapable.SyncHook<[Error]>;
+    shutdown: liteTapable.AsyncSeriesHook<[]>;
+    watchRun: liteTapable.AsyncSeriesHook<[Compiler]>;
+    watchClose: liteTapable.SyncHook<[]>;
+    environment: liteTapable.SyncHook<[]>;
+    afterEnvironment: liteTapable.SyncHook<[]>;
+    afterPlugins: liteTapable.SyncHook<[Compiler]>;
+    afterResolvers: liteTapable.SyncHook<[Compiler]>;
+    make: liteTapable.AsyncParallelHook<[Compilation]>;
+    beforeCompile: liteTapable.AsyncSeriesHook<[CompilationParams]>;
+    afterCompile: liteTapable.AsyncSeriesHook<[Compilation]>;
+    finishMake: liteTapable.AsyncSeriesHook<[Compilation]>;
+    entryOption: liteTapable.SyncBailHook<[string, EntryNormalized], any>;
+    additionalPass: liteTapable.AsyncSeriesHook<[]>;
+};
+declare class Compiler {
+    #private;
+    hooks: CompilerHooks;
+    webpack: typeof rspack;
+    rspack: typeof rspack;
+    name?: string;
+    parentCompilation?: Compilation;
+    root: Compiler;
+    outputPath: string;
+    running: boolean;
+    idle: boolean;
+    resolverFactory: ResolverFactory;
+    infrastructureLogger: any;
+    watching?: Watching;
+    inputFileSystem: InputFileSystem | null;
+    intermediateFileSystem: IntermediateFileSystem | null;
+    outputFileSystem: OutputFileSystem | null;
+    watchFileSystem: WatchFileSystem | null;
+    records: Record<string, any[]>;
+    modifiedFiles?: ReadonlySet<string>;
+    removedFiles?: ReadonlySet<string>;
+    fileTimestamps?: ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null>;
+    contextTimestamps?: ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null>;
+    fsStartTime?: number;
+    watchMode: boolean;
+    context: string;
+    cache: Cache;
+    compilerPath: string;
+    options: RspackOptionsNormalized;
+    /**
+     * Whether to skip dropping Rust compiler instance to improve performance.
+     * This is an internal option api and could be removed or changed at any time.
+     * @internal
+     * true: Skip dropping Rust compiler instance.
+     * false: Drop Rust compiler instance when Compiler is garbage collected.
+     */
+    unsafeFastDrop: boolean;
+    /**
+     * Note: This is not a webpack public API, maybe removed in future.
+     * @internal
+     */
+    __internal_browser_require: (id: string) => unknown;
+    constructor(context: string, options: RspackOptionsNormalized);
+    get recordsInputPath(): never;
+    get recordsOutputPath(): never;
+    get managedPaths(): never;
+    get immutablePaths(): never;
+    get _lastCompilation(): Compilation | undefined;
+    /**
+     * Note: This is not a webpack public API, maybe removed in future.
+     * @internal
+     */
+    get __internal__builtinPlugins(): binding.BuiltinPlugin[];
+    /**
+     * Note: This is not a webpack public API, maybe removed in future.
+     * @internal
+     */
+    get __internal__ruleSet(): RuleSetCompiler;
+    /**
+     * @param name - cache name
+     * @returns the cache facade instance
+     */
+    getCache(name: string): CacheFacade;
+    /**
+     * @param name - name of the logger, or function called once to get the logger name
+     * @returns a logger with that name
+     */
+    getInfrastructureLogger(name: string | (() => string)): Logger;
+    /**
+     * @param watchOptions - the watcher's options
+     * @param handler - signals when the call finishes
+     * @returns a compiler watcher
+     */
+    watch(watchOptions: Watchpack.WatchOptions, handler: liteTapable.Callback<Error, Stats>): Watching;
+    /**
+     * @param callback - signals when the call finishes
+     * @param options - additional data like modifiedFiles, removedFiles
+     */
+    run(callback: liteTapable.Callback<Error, Stats>, options?: {
+        modifiedFiles?: ReadonlySet<string>;
+        removedFiles?: ReadonlySet<string>;
+    }): void;
+    runAsChild(callback: (err?: null | Error, entries?: Chunk[], compilation?: Compilation) => any): void;
+    purgeInputFileSystem(): void;
+    /**
+     * @param compilation - the compilation
+     * @param compilerName - the compiler's name
+     * @param compilerIndex - the compiler's index
+     * @param outputOptions - the output options
+     * @param plugins - the plugins to apply
+     * @returns a child compiler
+     */
+    createChildCompiler(compilation: Compilation, compilerName: string, compilerIndex: number, outputOptions: OutputNormalized, plugins: RspackPluginInstance[]): Compiler;
+    isChild(): boolean;
+    /**
+     * Create a compilation and run it, which is the basic method that `compiler.run` and `compiler.watch` depend on.
+     * TODO: make this method private in the next major release
+     * @private this method is only used in Rspack core
+     */
+    compile(callback: liteTapable.Callback<Error, Compilation>): void;
+    close(callback: (error?: Error | null) => void): void;
+    /**
+     * Note: This is not a webpack public API, maybe removed in future.
+     * @internal
+     */
+    __internal__rebuild(modifiedFiles?: ReadonlySet<string>, removedFiles?: ReadonlySet<string>, callback?: (error: Error | null) => void): void;
+    /**
+     * Note: This is not a webpack public API, maybe removed in future.
+     * @internal
+     */
+    __internal__create_compilation(native: binding.JsCompilation): Compilation;
+    /**
+     * Note: This is not a webpack public API, maybe removed in future.
+     * @internal
+     */
+    __internal__get_virtual_file_store(): binding.VirtualFileStore | null | undefined;
+    /**
+     * Note: This is not a webpack public API, maybe removed in future.
+     * @internal
+     */
+    __internal__registerBuiltinPlugin(plugin: binding.BuiltinPlugin): void;
+    /**
+     * Note: This is not a webpack public API, maybe removed in future.
+     * @internal
+     */
+    __internal__takeModuleExecutionResult(id: number): any;
+    /**
+     * Note: This is not a webpack public API, maybe removed in future.
+     * @internal
+     */
+    __internal__get_compilation(): Compilation | undefined;
+    /**
+     * Note: This is not a webpack public API, maybe removed in future.
+     * @internal
+     */
+    __internal__get_compilation_params(): CompilationParams | undefined;
+    /**
+     * Note: This is not a webpack public API, maybe removed in future.
+     * @internal
+     */
+    __internal__get_module_execution_results_map(): Map<number, any>;
+}
+export { Compiler };

package/dist/ConcatenatedModule.d.ts

@@ -0,0 +1 @@
+export { ConcatenatedModule } from "./binding";

package/dist/ContextModule.d.ts

@@ -0,0 +1 @@
+export { ContextModule } from "./binding";

package/dist/ContextModuleFactory.d.ts

@@ -0,0 +1,13 @@
+import * as liteTapable from "@rspack/lite-tapable";
+import type { ContextModuleFactoryAfterResolveResult, ContextModuleFactoryBeforeResolveResult } from "./Module";
+export declare class ContextModuleFactory {
+    hooks: {
+        beforeResolve: liteTapable.AsyncSeriesWaterfallHook<[
+            ContextModuleFactoryBeforeResolveResult
+        ], ContextModuleFactoryBeforeResolveResult | void>;
+        afterResolve: liteTapable.AsyncSeriesWaterfallHook<[
+            ContextModuleFactoryAfterResolveResult
+        ], ContextModuleFactoryAfterResolveResult | void>;
+    };
+    constructor();
+}

package/dist/Diagnostics.d.ts

@@ -0,0 +1,7 @@
+import type { Diagnostics } from "./binding";
+import type { RspackError } from "./RspackError";
+declare const $proxy: unique symbol;
+export declare function createDiagnosticArray(adm: Diagnostics & {
+    [$proxy]?: RspackError[];
+}): RspackError[];
+export {};

package/dist/Entrypoint.d.ts

@@ -0,0 +1,2 @@
+import type { ChunkGroup } from "./binding";
+export type Entrypoint = ChunkGroup;

package/dist/ErrorHelpers.d.ts

@@ -0,0 +1,3 @@
+export declare const cutOffLoaderExecution: (stack: string) => string;
+export declare const cleanUp: (stack: string, name: string, message: string) => string;
+export declare const cutOffMessage: (stack: string, name: string, message: string) => string;

package/dist/ExecuteModulePlugin.d.ts

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

package/dist/ExportsInfo.d.ts

@@ -0,0 +1,20 @@
+import type { JsExportsInfo } from "./binding";
+import type { RuntimeSpec } from "./util/runtime";
+/**
+ * Unused: 0
+ * OnlyPropertiesUsed: 1
+ * NoInfo: 2
+ * Unknown: 3
+ * Used: 4
+ */
+type UsageStateType = 0 | 1 | 2 | 3 | 4;
+export declare class ExportsInfo {
+    #private;
+    static __from_binding(binding: JsExportsInfo): ExportsInfo;
+    private constructor();
+    isUsed(runtime: RuntimeSpec): boolean;
+    isModuleUsed(runtime: RuntimeSpec): boolean;
+    setUsedInUnknownWay(runtime: RuntimeSpec): boolean;
+    getUsed(name: string | string[], runtime: RuntimeSpec): UsageStateType;
+}
+export {};

package/dist/ExternalModule.d.ts

@@ -0,0 +1 @@
+export { ExternalModule } from "./binding";

package/dist/FileSystem.d.ts

@@ -0,0 +1,54 @@
+import type { NodeFsStats, ThreadsafeNodeFS } from "./binding";
+import { type InputFileSystem, type IntermediateFileSystem, type OutputFileSystem } from "./util/fs";
+declare class ThreadsafeInputNodeFS implements ThreadsafeNodeFS {
+    writeFile: (name: string, content: Buffer) => Promise<void>;
+    removeFile: (name: string) => Promise<void>;
+    mkdir: (name: string) => Promise<void>;
+    mkdirp: (name: string) => Promise<string | void>;
+    removeDirAll: (name: string) => Promise<string | void>;
+    readDir: (name: string) => Promise<string[] | void>;
+    readFile: (name: string) => Promise<Buffer | string | void>;
+    stat: (name: string) => Promise<NodeFsStats | void>;
+    lstat: (name: string) => Promise<NodeFsStats | void>;
+    chmod?: (name: string, mode: number) => Promise<void>;
+    realpath: (name: string) => Promise<string | void>;
+    open: (name: string, flags: string) => Promise<number | void>;
+    rename: (from: string, to: string) => Promise<void>;
+    close: (fd: number) => Promise<void>;
+    write: (fd: number, content: Buffer, position: number) => Promise<number | void>;
+    writeAll: (fd: number, content: Buffer) => Promise<number | void>;
+    read: (fd: number, length: number, position: number) => Promise<Buffer | void>;
+    readUntil: (fd: number, code: number, position: number) => Promise<Buffer | void>;
+    readToEnd: (fd: number, position: number) => Promise<Buffer | void>;
+    constructor(fs?: InputFileSystem);
+    static __to_binding(fs?: InputFileSystem): ThreadsafeInputNodeFS;
+    static needsBinding(ifs?: false | RegExp[]): boolean;
+}
+declare class ThreadsafeOutputNodeFS implements ThreadsafeNodeFS {
+    writeFile: (name: string, content: Buffer) => Promise<void>;
+    removeFile: (name: string) => Promise<void>;
+    mkdir: (name: string) => Promise<void>;
+    mkdirp: (name: string) => Promise<string | void>;
+    removeDirAll: (name: string) => Promise<string | void>;
+    readDir: (name: string) => Promise<string[] | void>;
+    readFile: (name: string) => Promise<Buffer | string | void>;
+    stat: (name: string) => Promise<NodeFsStats | void>;
+    lstat: (name: string) => Promise<NodeFsStats | void>;
+    chmod?: (name: string, mode: number) => Promise<void>;
+    realpath: (name: string) => Promise<string | void>;
+    open: (name: string, flags: string) => Promise<number | void>;
+    rename: (from: string, to: string) => Promise<void>;
+    close: (fd: number) => Promise<void>;
+    write: (fd: number, content: Buffer, position: number) => Promise<number | void>;
+    writeAll: (fd: number, content: Buffer) => Promise<number | void>;
+    read: (fd: number, length: number, position: number) => Promise<Buffer | void>;
+    readUntil: (fd: number, code: number, position: number) => Promise<Buffer | void>;
+    readToEnd: (fd: number, position: number) => Promise<Buffer | void>;
+    constructor(fs?: OutputFileSystem);
+    static __to_binding(fs?: OutputFileSystem): ThreadsafeOutputNodeFS;
+}
+declare class ThreadsafeIntermediateNodeFS extends ThreadsafeOutputNodeFS {
+    constructor(fs?: IntermediateFileSystem);
+    static __to_binding(fs?: IntermediateFileSystem): ThreadsafeIntermediateNodeFS;
+}
+export { ThreadsafeInputNodeFS, ThreadsafeOutputNodeFS, ThreadsafeIntermediateNodeFS };

package/dist/FileSystemInfo.d.ts

@@ -0,0 +1,5 @@
+interface FileSystemInfoEntry {
+    safeTime: number;
+    timestamp?: number;
+}
+export type { FileSystemInfoEntry };

package/dist/Module.d.ts

@@ -0,0 +1,42 @@
+import binding, { type AssetInfo } from "./binding";
+import type { Source } from "webpack-sources";
+import type { ResourceData } from "./Resolver";
+import "./BuildInfo";
+export type ResourceDataWithData = ResourceData & {
+    data?: Record<string, any>;
+};
+export type CreateData = binding.JsCreateData;
+export type ContextInfo = binding.ContextInfo;
+export type ResolveData = binding.JsResolveData;
+export declare class ContextModuleFactoryBeforeResolveData {
+    #private;
+    context: string;
+    request: string;
+    regExp: RegExp | undefined;
+    recursive: boolean;
+    static __from_binding(binding: binding.JsContextModuleFactoryBeforeResolveData): ContextModuleFactoryBeforeResolveData;
+    static __to_binding(data: ContextModuleFactoryBeforeResolveData): binding.JsContextModuleFactoryBeforeResolveData;
+    private constructor();
+}
+export type ContextModuleFactoryBeforeResolveResult = false | ContextModuleFactoryBeforeResolveData;
+export declare class ContextModuleFactoryAfterResolveData {
+    #private;
+    resource: number;
+    context: string;
+    request: string;
+    regExp: RegExp | undefined;
+    recursive: boolean;
+    readonly dependencies: binding.Dependency[];
+    static __from_binding(binding: binding.JsContextModuleFactoryAfterResolveData): ContextModuleFactoryAfterResolveData;
+    static __to_binding(data: ContextModuleFactoryAfterResolveData): binding.JsContextModuleFactoryAfterResolveData;
+    private constructor();
+}
+export type ContextModuleFactoryAfterResolveResult = false | ContextModuleFactoryAfterResolveData;
+declare module "./binding" {
+    interface Module {
+        identifier(): string;
+        originalSource(): Source | null;
+        emitFile(filename: string, source: Source, assetInfo?: AssetInfo): void;
+    }
+}
+export { Module } from "./binding";

package/dist/ModuleGraph.d.ts

@@ -0,0 +1,19 @@
+import type { Dependency, JsModuleGraph, ModuleGraphConnection } from "./binding";
+import { ExportsInfo } from "./ExportsInfo";
+import type { Module } from "./Module";
+export default class ModuleGraph {
+    #private;
+    static __from_binding(binding: JsModuleGraph): ModuleGraph;
+    constructor(binding: JsModuleGraph);
+    getModule(dependency: Dependency): Module | null;
+    getResolvedModule(dependency: Dependency): Module | null;
+    getParentModule(dependency: Dependency): Module | null;
+    getIssuer(module: Module): Module | null;
+    getExportsInfo(module: Module): ExportsInfo;
+    getConnection(dependency: Dependency): ModuleGraphConnection | null;
+    getOutgoingConnections(module: Module): ModuleGraphConnection[];
+    getIncomingConnections(module: Module): ModuleGraphConnection[];
+    getParentBlockIndex(dependency: Dependency): number;
+    isAsync(module: Module): boolean;
+    getOutgoingConnectionsInOrder(module: Module): ModuleGraphConnection[];
+}

package/dist/ModuleTypeConstants.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This is the module type used for JSON files. JSON files are always parsed as ES Module.
+ */
+export declare const JSON_MODULE_TYPE = "json";
+/**
+ * This is the module type used for automatically choosing between `asset/inline`, `asset/resource` based on asset size limit (8096).
+ */
+export declare const ASSET_MODULE_TYPE = "asset";

package/dist/MultiCompiler.d.ts

@@ -0,0 +1,82 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/MultiCompiler.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import * as liteTapable from "@rspack/lite-tapable";
+import type { CompilationParams, Compiler, CompilerHooks, RspackOptions } from ".";
+import type { WatchOptions } from "./config";
+import MultiStats from "./MultiStats";
+import MultiWatching from "./MultiWatching";
+import type { InputFileSystem, IntermediateFileSystem, WatchFileSystem } from "./util/fs";
+export interface MultiCompilerOptions {
+    /**
+     * how many Compilers are allows to run at the same time in parallel
+     */
+    parallelism?: number;
+}
+export type MultiRspackOptions = readonly RspackOptions[] & MultiCompilerOptions;
+export declare class MultiCompiler {
+    #private;
+    compilers: Compiler[];
+    dependencies: WeakMap<Compiler, string[]>;
+    hooks: {
+        done: liteTapable.SyncHook<MultiStats>;
+        invalid: liteTapable.MultiHook<liteTapable.SyncHook<[string | null, number]>>;
+        beforeCompile: liteTapable.MultiHook<liteTapable.AsyncSeriesHook<[CompilationParams]>>;
+        shutdown: liteTapable.MultiHook<liteTapable.AsyncSeriesHook<[]>>;
+        run: liteTapable.MultiHook<liteTapable.AsyncSeriesHook<[Compiler]>>;
+        watchClose: liteTapable.SyncHook<[]>;
+        watchRun: liteTapable.MultiHook<liteTapable.AsyncSeriesHook<[Compiler]>>;
+        /**
+         * @see {@link CompilerHooks['infrastructureLog']}
+         */
+        infrastructureLog: liteTapable.MultiHook<CompilerHooks["infrastructureLog"]>;
+    };
+    _options: MultiCompilerOptions;
+    running: boolean;
+    watching?: MultiWatching;
+    constructor(compilers: Compiler[] | Record<string, Compiler>, options?: MultiCompilerOptions);
+    set unsafeFastDrop(value: boolean);
+    get options(): import(".").RspackOptionsNormalized[] & MultiCompilerOptions;
+    get outputPath(): string;
+    get inputFileSystem(): InputFileSystem;
+    get outputFileSystem(): typeof import("fs");
+    get watchFileSystem(): WatchFileSystem;
+    get intermediateFileSystem(): IntermediateFileSystem;
+    set inputFileSystem(value: InputFileSystem);
+    set outputFileSystem(value: typeof import("fs"));
+    set watchFileSystem(value: WatchFileSystem);
+    set intermediateFileSystem(value: IntermediateFileSystem);
+    getInfrastructureLogger(name: string): import("./logging/Logger").Logger;
+    /**
+     * @param compiler - the child compiler
+     * @param dependencies - its dependencies
+     */
+    setDependencies(compiler: Compiler, dependencies: string[]): void;
+    /**
+     * @param callback - signals when the validation is complete
+     * @returns true if the dependencies are valid
+     */
+    validateDependencies(callback: liteTapable.Callback<Error, MultiStats>): boolean;
+    /**
+     * @param watchOptions - the watcher's options
+     * @param handler - signals when the call finishes
+     * @returns a compiler watcher
+     */
+    watch(watchOptions: WatchOptions | WatchOptions[], handler: liteTapable.Callback<Error, MultiStats>): MultiWatching;
+    /**
+     * @param callback - signals when the call finishes
+     * @param options - additional data like modifiedFiles, removedFiles
+     */
+    run(callback: liteTapable.Callback<Error, MultiStats>, options?: {
+        modifiedFiles?: ReadonlySet<string>;
+        removedFiles?: ReadonlySet<string>;
+    }): void;
+    purgeInputFileSystem(): void;
+    close(callback: liteTapable.Callback<Error, void>): void;
+}

package/dist/MultiStats.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/MultiStats.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type { MultiStatsOptions, StatsPresets } from "./config";
+import type { Stats } from "./Stats";
+import type { StatsCompilation } from "./stats/statsFactoryUtils";
+export default class MultiStats {
+    #private;
+    stats: Stats[];
+    constructor(stats: Stats[]);
+    get hash(): string;
+    hasErrors(): boolean;
+    hasWarnings(): boolean;
+    toJson(options: boolean | StatsPresets | MultiStatsOptions): StatsCompilation;
+    toString(options: boolean | StatsPresets | MultiStatsOptions): string;
+}
+export { MultiStats };

package/dist/MultiWatching.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/MultiWatching.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type { Callback } from "@rspack/lite-tapable";
+import type { MultiCompiler } from "./MultiCompiler";
+import type { Watching } from "./Watching";
+declare class MultiWatching {
+    watchings: Watching[];
+    compiler: MultiCompiler;
+    /**
+     * @param watchings - child compilers' watchers
+     * @param compiler - the compiler
+     */
+    constructor(watchings: Watching[], compiler: MultiCompiler);
+    invalidate(callback?: Callback<Error, void>): void;
+    invalidateWithChangesAndRemovals(changedFiles?: Set<string>, removedFiles?: Set<string>, callback?: Callback<Error, void>): void;
+    close(callback: Callback<Error, void>): void;
+    suspend(): void;
+    resume(): void;
+}
+export default MultiWatching;

package/dist/NativeWatchFileSystem.d.ts

@@ -0,0 +1,23 @@
+import binding from "./binding";
+import type Watchpack from "watchpack";
+import type { FileSystemInfoEntry, InputFileSystem, Watcher, WatchFileSystem } from "./util/fs";
+export default class NativeWatchFileSystem implements WatchFileSystem {
+    #private;
+    constructor(inputFileSystem: InputFileSystem);
+    watch(files: Iterable<string> & {
+        added?: Iterable<string>;
+        removed?: Iterable<string>;
+    }, directories: Iterable<string> & {
+        added?: Iterable<string>;
+        removed?: Iterable<string>;
+    }, missing: Iterable<string> & {
+        added?: Iterable<string>;
+        removed?: Iterable<string>;
+    }, startTime: number, options: Watchpack.WatchOptions, callback: (error: Error | null, fileTimeInfoEntries: Map<string, FileSystemInfoEntry | "ignore">, contextTimeInfoEntries: Map<string, FileSystemInfoEntry | "ignore">, changedFiles: Set<string>, removedFiles: Set<string>) => void, callbackUndelayed: (fileName: string, changeTime: number) => void): Watcher;
+    getNativeWatcher(options: Watchpack.WatchOptions): binding.NativeWatcher;
+    triggerEvent(kind: "change" | "remove" | "create", path: string): void;
+    formatWatchDependencies(dependencies: Iterable<string> & {
+        added?: Iterable<string>;
+        removed?: Iterable<string>;
+    }): [string[], string[]];
+}

package/dist/NormalModule.d.ts

@@ -0,0 +1,15 @@
+import * as liteTapable from "@rspack/lite-tapable";
+import type { Compilation } from "./Compilation";
+import type { LoaderContext } from "./config";
+import type { Module } from "./Module";
+export interface NormalModuleCompilationHooks {
+    loader: liteTapable.SyncHook<[LoaderContext, Module]>;
+    readResourceForScheme: any;
+    readResource: liteTapable.HookMap<liteTapable.AsyncSeriesBailHook<[LoaderContext], string | Buffer>>;
+}
+declare module "./binding" {
+    interface NormalModuleConstructor {
+        getCompilationHooks(compilation: Compilation): NormalModuleCompilationHooks;
+    }
+}
+export { NormalModule } from "./binding";

package/dist/NormalModuleFactory.d.ts

@@ -0,0 +1,23 @@
+import type binding from "./binding";
+import * as liteTapable from "@rspack/lite-tapable";
+import type { ResolveData, ResourceDataWithData } from "./Module";
+import type { ResolveOptionsWithDependencyType, ResolverFactory } from "./ResolverFactory";
+export type NormalModuleCreateData = binding.JsNormalModuleFactoryCreateModuleArgs & {
+    settings: {};
+};
+export declare class NormalModuleFactory {
+    hooks: {
+        resolveForScheme: liteTapable.HookMap<liteTapable.AsyncSeriesBailHook<[ResourceDataWithData], true | void>>;
+        beforeResolve: liteTapable.AsyncSeriesBailHook<[ResolveData], false | void>;
+        factorize: liteTapable.AsyncSeriesBailHook<[ResolveData], void>;
+        resolve: liteTapable.AsyncSeriesBailHook<[ResolveData], void>;
+        afterResolve: liteTapable.AsyncSeriesBailHook<[ResolveData], false | void>;
+        createModule: liteTapable.AsyncSeriesBailHook<[
+            NormalModuleCreateData,
+            {}
+        ], void>;
+    };
+    resolverFactory: ResolverFactory;
+    constructor(resolverFactory: ResolverFactory);
+    getResolver(type: string, resolveOptions: ResolveOptionsWithDependencyType): import("./ResolverFactory").ResolverWithOptions;
+}

package/dist/Resolver.d.ts

@@ -0,0 +1,30 @@
+import type binding from "./binding";
+import type { ResolveCallback } from "./config/adapterRuleUse";
+export type ResolveContext = {
+    contextDependencies?: {
+        add: (context: string) => void;
+    };
+    missingDependencies?: {
+        add: (dependency: string) => void;
+    };
+    fileDependencies?: {
+        add: (dependency: string) => void;
+    };
+};
+export type ResourceData = binding.JsResourceData;
+export interface ResolveRequest {
+    path: string;
+    query: string;
+    fragment: string;
+    descriptionFileData?: string;
+    descriptionFilePath?: string;
+    fileDependencies?: string[];
+    missingDependencies?: string[];
+    contextDependencies?: string[];
+}
+export declare class Resolver {
+    #private;
+    constructor(binding: binding.JsResolver);
+    resolveSync(context: object, path: string, request: string): string | false;
+    resolve(context: object, path: string, request: string, resolveContext: ResolveContext, callback: ResolveCallback): void;
+}