@rspack-canary/browser 1.4.12-canary-f056cdd6-20250801072217 → 1.4.12-canary-d2f8a578-20250801090118

package/dist/BuildInfo.d.ts

@@ -0,0 +1,17 @@
+import binding from "@rspack/binding";
+import type { Source } from "webpack-sources";
+declare const $assets: unique symbol;
+declare module "@rspack/binding" {
+    interface Assets {
+        [$assets]: Record<string, Source>;
+    }
+    interface KnownBuildInfo {
+        assets: Record<string, Source>;
+        fileDependencies: Set<string>;
+        contextDependencies: Set<string>;
+        missingDependencies: Set<string>;
+        buildDependencies: Set<string>;
+    }
+}
+export type { BuildInfo } from "@rspack/binding";
+export declare const commitCustomFieldsToRust: (buildInfo: binding.BuildInfo) => void;

package/dist/Chunk.d.ts

@@ -0,0 +1,16 @@
+import { type ChunkGroup } from "@rspack/binding";
+interface ChunkMaps {
+    hash: Record<string | number, string>;
+    contentHash: Record<string | number, Record<string, string>>;
+    name: Record<string | number, string>;
+}
+declare module "@rspack/binding" {
+    interface Chunk {
+        readonly files: ReadonlySet<string>;
+        readonly runtime: ReadonlySet<string>;
+        readonly auxiliaryFiles: ReadonlySet<string>;
+        readonly groupsIterable: ReadonlySet<ChunkGroup>;
+        getChunkMaps(realHash: boolean): ChunkMaps;
+    }
+}
+export { Chunk } from "@rspack/binding";

package/dist/ChunkGraph.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimeSpec } from "./util/runtime";
+declare module "@rspack/binding" {
+    interface ChunkGraph {
+        getModuleChunksIterable(module: Module): Iterable<Chunk>;
+        getOrderedChunkModulesIterable(chunk: Chunk, compareFn: (a: Module, b: Module) => number): Iterable<Module>;
+        getModuleHash(module: Module, runtime: RuntimeSpec): string | null;
+    }
+}
+export { ChunkGraph } from "@rspack/binding";

package/dist/Chunks.d.ts

@@ -0,0 +1,12 @@
+import { Chunks } from "@rspack/binding";
+declare module "@rspack/binding" {
+    interface Chunks {
+        [Symbol.iterator](): SetIterator<Chunk>;
+        entries(): SetIterator<[Chunk, Chunk]>;
+        values(): SetIterator<Chunk>;
+        keys(): SetIterator<Chunk>;
+        forEach(callbackfn: (value: Chunk, value2: Chunk, set: ReadonlySet<Chunk>) => void, thisArg?: any): void;
+        has(value: Chunk): boolean;
+    }
+}
+export default Chunks;

package/dist/CodeGenerationResults.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/Compilation.d.ts

@@ -0,0 +1,420 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3bb53f36a5b8fc6bc1bd976ed7af161bd80/lib/Compilation.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type { AssetInfo, ChunkGroup, Dependency, ExternalObject, JsCompilation, JsRuntimeModule } from "@rspack/binding";
+import binding from "@rspack/binding";
+export type { AssetInfo } from "@rspack/binding";
+import * as liteTapable from "@rspack/lite-tapable";
+import type { Source } from "webpack-sources";
+import type { EntryOptions, EntryPlugin } from "./builtin-plugin";
+import type { Chunk } from "./Chunk";
+import type { ChunkGraph } from "./ChunkGraph";
+import type { Compiler } from "./Compiler";
+import type { ContextModuleFactory } from "./ContextModuleFactory";
+import type { OutputNormalized, RspackOptionsNormalized, RspackPluginInstance, StatsOptions, StatsValue } from "./config";
+import type { Entrypoint } from "./Entrypoint";
+import WebpackError from "./lib/WebpackError";
+import { Logger } from "./logging/Logger";
+import type { Module } from "./Module";
+import ModuleGraph from "./ModuleGraph";
+import type { NormalModuleCompilationHooks } from "./NormalModule";
+import type { NormalModuleFactory } from "./NormalModuleFactory";
+import type { ResolverFactory } from "./ResolverFactory";
+import type { RspackError } from "./RspackError";
+import { RuntimeModule } from "./RuntimeModule";
+import { Stats, type StatsAsset, type StatsError, type StatsModule } from "./Stats";
+import { StatsFactory } from "./stats/StatsFactory";
+import { StatsPrinter } from "./stats/StatsPrinter";
+import type { InputFileSystem } from "./util/fs";
+import type Hash from "./util/hash";
+import "./Chunk";
+import "./Chunks";
+import "./ChunkGraph";
+import "./CodeGenerationResults";
+import type { CodeGenerationResult } from "./taps/compilation";
+export type Assets = Record<string, Source>;
+export interface Asset {
+    name: string;
+    source: Source;
+    info: AssetInfo;
+}
+export type PathDataChunkLike = {
+    id?: string;
+    name?: string;
+    hash?: string;
+    contentHash?: Record<string, string>;
+};
+export type PathData = {
+    filename?: string;
+    hash?: string;
+    contentHash?: string;
+    runtime?: string;
+    url?: string;
+    id?: string;
+    chunk?: Chunk | PathDataChunkLike;
+    contentHashType?: string;
+};
+export interface LogEntry {
+    type: string;
+    args: any[];
+    time?: number;
+    trace?: string[];
+}
+export interface CompilationParams {
+    normalModuleFactory: NormalModuleFactory;
+    contextModuleFactory: ContextModuleFactory;
+}
+export interface KnownCreateStatsOptionsContext {
+    forToString?: boolean;
+}
+export interface ExecuteModuleArgument {
+    codeGenerationResult: CodeGenerationResult;
+    moduleObject: {
+        id: string;
+        exports: any;
+        loaded: boolean;
+        error?: Error;
+    };
+}
+export interface ExecuteModuleContext {
+    __webpack_require__: (id: string) => any;
+}
+export interface KnownNormalizedStatsOptions {
+    context: string;
+    chunksSort: string;
+    modulesSort: string;
+    chunkModulesSort: string;
+    nestedModulesSort: string;
+    assetsSort: string;
+    ids: boolean;
+    cachedAssets: boolean;
+    groupAssetsByEmitStatus: boolean;
+    groupAssetsByPath: boolean;
+    groupAssetsByExtension: boolean;
+    assetsSpace: number;
+    excludeAssets: ((value: string, asset: StatsAsset) => boolean)[];
+    excludeModules: ((name: string, module: StatsModule, type: "module" | "chunk" | "root-of-chunk" | "nested") => boolean)[];
+    warningsFilter: ((warning: StatsError, textValue: string) => boolean)[];
+    cachedModules: boolean;
+    orphanModules: boolean;
+    dependentModules: boolean;
+    runtimeModules: boolean;
+    groupModulesByCacheStatus: boolean;
+    groupModulesByLayer: boolean;
+    groupModulesByAttributes: boolean;
+    groupModulesByPath: boolean;
+    groupModulesByExtension: boolean;
+    groupModulesByType: boolean;
+    entrypoints: boolean | "auto";
+    chunkGroups: boolean;
+    chunkGroupAuxiliary: boolean;
+    chunkGroupChildren: boolean;
+    chunkGroupMaxAssets: number;
+    modulesSpace: number;
+    chunkModulesSpace: number;
+    nestedModulesSpace: number;
+    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>;
+export declare const checkCompilation: (compilation: Compilation) => void;
+export declare class Compilation {
+    #private;
+    hooks: Readonly<{
+        processAssets: liteTapable.AsyncSeriesHook<Assets>;
+        afterProcessAssets: liteTapable.SyncHook<Assets>;
+        childCompiler: liteTapable.SyncHook<[Compiler, string, number]>;
+        log: liteTapable.SyncBailHook<[string, LogEntry], true>;
+        additionalAssets: any;
+        optimizeModules: liteTapable.SyncBailHook<Iterable<Module>, void>;
+        afterOptimizeModules: liteTapable.SyncHook<Iterable<Module>, void>;
+        optimizeTree: liteTapable.AsyncSeriesHook<[
+            Iterable<Chunk>,
+            Iterable<Module>
+        ]>;
+        optimizeChunkModules: liteTapable.AsyncSeriesBailHook<[
+            Iterable<Chunk>,
+            Iterable<Module>
+        ], void>;
+        finishModules: liteTapable.AsyncSeriesHook<[Iterable<Module>], void>;
+        chunkHash: liteTapable.SyncHook<[Chunk, Hash], void>;
+        chunkAsset: liteTapable.SyncHook<[Chunk, string], void>;
+        processWarnings: liteTapable.SyncWaterfallHook<[WebpackError[]]>;
+        succeedModule: liteTapable.SyncHook<[Module], void>;
+        stillValidModule: liteTapable.SyncHook<[Module], void>;
+        statsPreset: liteTapable.HookMap<liteTapable.SyncHook<[
+            Partial<StatsOptions>,
+            CreateStatsOptionsContext
+        ], void>>;
+        statsNormalize: liteTapable.SyncHook<[
+            Partial<StatsOptions>,
+            CreateStatsOptionsContext
+        ], void>;
+        statsFactory: liteTapable.SyncHook<[StatsFactory, StatsOptions], void>;
+        statsPrinter: liteTapable.SyncHook<[StatsPrinter, StatsOptions], void>;
+        buildModule: liteTapable.SyncHook<[Module]>;
+        executeModule: liteTapable.SyncHook<[
+            ExecuteModuleArgument,
+            ExecuteModuleContext
+        ]>;
+        additionalTreeRuntimeRequirements: liteTapable.SyncHook<[
+            Chunk,
+            Set<string>
+        ], void>;
+        runtimeRequirementInTree: liteTapable.HookMap<liteTapable.SyncBailHook<[Chunk, Set<string>], void>>;
+        runtimeModule: liteTapable.SyncHook<[JsRuntimeModule, Chunk], void>;
+        seal: liteTapable.SyncHook<[], void>;
+        afterSeal: liteTapable.AsyncSeriesHook<[], void>;
+        needAdditionalPass: liteTapable.SyncBailHook<[], boolean>;
+    }>;
+    name?: string;
+    startTime?: number;
+    endTime?: number;
+    compiler: Compiler;
+    resolverFactory: ResolverFactory;
+    inputFileSystem: InputFileSystem | null;
+    options: RspackOptionsNormalized;
+    outputOptions: OutputNormalized;
+    logging: Map<string, LogEntry[]>;
+    childrenCounters: Record<string, number>;
+    children: Compilation[];
+    chunkGraph: ChunkGraph;
+    moduleGraph: ModuleGraph;
+    fileSystemInfo: {
+        createSnapshot(): null;
+    };
+    needAdditionalPass: boolean;
+    [binding.COMPILATION_HOOKS_MAP_SYMBOL]: WeakMap<Compilation, NormalModuleCompilationHooks>;
+    constructor(compiler: Compiler, inner: JsCompilation);
+    get hash(): Readonly<string | null>;
+    get fullHash(): Readonly<string | null>;
+    /**
+     * Get a map of all assets.
+     */
+    get assets(): Record<string, Source>;
+    /**
+     * Get a map of all entrypoints.
+     */
+    get entrypoints(): ReadonlyMap<string, Entrypoint>;
+    get chunkGroups(): ReadonlyArray<ChunkGroup>;
+    /**
+     * Get the named chunk groups.
+     *
+     * Note: This is a proxy for webpack internal API, only method `get`, `keys`, `values` and `entries` are supported now.
+     */
+    get namedChunkGroups(): ReadonlyMap<string, Readonly<ChunkGroup>>;
+    get modules(): ReadonlySet<Module>;
+    get builtModules(): ReadonlySet<Module>;
+    get chunks(): ReadonlySet<Chunk>;
+    /**
+     * Get the named chunks.
+     *
+     * Note: This is a proxy for webpack internal API, only method `get`, `keys`, `values` and `entries` are supported now.
+     */
+    get namedChunks(): ReadonlyMap<string, Readonly<binding.Chunk>>;
+    get entries(): Map<string, EntryData>;
+    get codeGenerationResults(): binding.CodeGenerationResults;
+    getCache(name: string): import("./lib/CacheFacade").CacheFacade;
+    createStatsOptions(statsValue: StatsValue | undefined, context?: CreateStatsOptionsContext): NormalizedStatsOptions;
+    createStatsFactory(options: StatsOptions): StatsFactory;
+    createStatsPrinter(options: StatsOptions): StatsPrinter;
+    /**
+     * Update an existing asset. Trying to update an asset that doesn't exist will throw an error.
+     */
+    updateAsset(filename: string, newSourceOrFunction: Source | ((source: Source) => Source), assetInfoUpdateOrFunction?: AssetInfo | ((assetInfo: AssetInfo) => AssetInfo | undefined)): void;
+    /**
+     * Emit an not existing asset. Trying to emit an asset that already exists will throw an error.
+     *
+     * @param file - file name
+     * @param source - asset source
+     * @param assetInfo - extra asset information
+     */
+    emitAsset(filename: string, source: Source, assetInfo?: AssetInfo): void;
+    deleteAsset(filename: string): void;
+    renameAsset(filename: string, newFilename: string): void;
+    /**
+     * Get an array of Asset
+     */
+    getAssets(): ReadonlyArray<Asset>;
+    getAsset(name: string): Readonly<Asset> | void;
+    /**
+     * Note: This is not a webpack public API, maybe removed in future.
+     *
+     * @internal
+     */
+    __internal__pushRspackDiagnostic(diagnostic: binding.JsRspackDiagnostic): void;
+    /**
+     * Note: This is not a webpack public API, maybe removed in future.
+     *
+     * @internal
+     */
+    __internal__pushDiagnostic(diagnostic: ExternalObject<"Diagnostic">): void;
+    /**
+     * Note: This is not a webpack public API, maybe removed in future.
+     *
+     * @internal
+     */
+    __internal__pushDiagnostics(diagnostics: ExternalObject<"Diagnostic[]">): void;
+    get errors(): RspackError[];
+    set errors(errors: RspackError[]);
+    get warnings(): RspackError[];
+    set warnings(warnings: RspackError[]);
+    getPath(filename: string, data?: PathData): string;
+    getPathWithInfo(filename: string, data?: PathData): binding.PathWithInfo;
+    getAssetPath(filename: string, data?: PathData): string;
+    getAssetPathWithInfo(filename: string, data?: PathData): binding.PathWithInfo;
+    getLogger(name: string | (() => string)): Logger;
+    fileDependencies: {
+        [Symbol.iterator](): Generator<string, void, unknown>;
+        has(dep: string): boolean;
+        add: (dep: string) => void;
+        addAll: (deps: Iterable<string>) => void;
+    };
+    get __internal__addedFileDependencies(): string[];
+    get __internal__removedFileDependencies(): string[];
+    get __internal__addedContextDependencies(): string[];
+    get __internal__removedContextDependencies(): string[];
+    get __internal__addedMissingDependencies(): string[];
+    get __internal__removedMissingDependencies(): string[];
+    contextDependencies: {
+        [Symbol.iterator](): Generator<string, void, unknown>;
+        has(dep: string): boolean;
+        add: (dep: string) => void;
+        addAll: (deps: Iterable<string>) => void;
+    };
+    missingDependencies: {
+        [Symbol.iterator](): Generator<string, void, unknown>;
+        has(dep: string): boolean;
+        add: (dep: string) => void;
+        addAll: (deps: Iterable<string>) => void;
+    };
+    buildDependencies: {
+        [Symbol.iterator](): Generator<string, void, unknown>;
+        has(dep: string): boolean;
+        add: (dep: string) => void;
+        addAll: (deps: Iterable<string>) => void;
+    };
+    getStats(): Stats;
+    createChildCompiler(name: string, outputOptions: OutputNormalized, plugins: RspackPluginInstance[]): Compiler;
+    rebuildModule(module: Module, f: (err: Error | null, module: Module | null) => void): void;
+    addRuntimeModule(chunk: Chunk, runtimeModule: RuntimeModule): void;
+    addInclude(context: string, dependency: ReturnType<typeof EntryPlugin.createDependency>, options: EntryOptions, callback: (err?: null | WebpackError, module?: Module) => void): void;
+    addEntry(context: string, dependency: ReturnType<typeof EntryPlugin.createDependency>, optionsOrName: EntryOptions | string, callback: (err?: null | WebpackError, module?: Module) => void): void;
+    getWarnings(): WebpackError[];
+    getErrors(): WebpackError[];
+    /**
+     * Get the `Source` of a given asset filename.
+     *
+     * Note: This is not a webpack public API, maybe removed in the future.
+     *
+     * @internal
+     */
+    __internal__getAssetSource(filename: string): Source | void;
+    /**
+     * Set the `Source` of an given asset filename.
+     *
+     * Note: This is not a webpack public API, maybe removed in future.
+     *
+     * @internal
+     */
+    __internal__setAssetSource(filename: string, source: Source): void;
+    /**
+     * Delete the `Source` of an given asset filename.
+     *
+     * Note: This is not a webpack public API, maybe removed in future.
+     *
+     * @internal
+     */
+    __internal__deleteAssetSource(filename: string): void;
+    /**
+     * Get a list of asset filenames.
+     *
+     * Note: This is not a webpack public API, maybe removed in future.
+     *
+     * @internal
+     */
+    __internal__getAssetFilenames(): string[];
+    /**
+     * Test if an asset exists.
+     *
+     * Note: This is not a webpack public API, maybe removed in future.
+     *
+     * @internal
+     */
+    __internal__hasAsset(name: string): boolean;
+    /**
+     * Note: This is not a webpack public API, maybe removed in future.
+     *
+     * @internal
+     */
+    __internal_getInner(): JsCompilation;
+    get __internal__shutdown(): boolean;
+    set __internal__shutdown(shutdown: boolean);
+    seal(): void;
+    unseal(): void;
+    static PROCESS_ASSETS_STAGE_ADDITIONAL: number;
+    static PROCESS_ASSETS_STAGE_PRE_PROCESS: number;
+    static PROCESS_ASSETS_STAGE_DERIVED: number;
+    static PROCESS_ASSETS_STAGE_ADDITIONS: number;
+    static PROCESS_ASSETS_STAGE_NONE: number;
+    static PROCESS_ASSETS_STAGE_OPTIMIZE: number;
+    static PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT: number;
+    static PROCESS_ASSETS_STAGE_OPTIMIZE_COMPATIBILITY: number;
+    static PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE: number;
+    static PROCESS_ASSETS_STAGE_DEV_TOOLING: number;
+    static PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE: number;
+    static PROCESS_ASSETS_STAGE_SUMMARIZE: number;
+    static PROCESS_ASSETS_STAGE_OPTIMIZE_HASH: number;
+    static PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER: number;
+    static PROCESS_ASSETS_STAGE_ANALYSE: number;
+    static PROCESS_ASSETS_STAGE_REPORT: number;
+}
+export declare class EntryData {
+    dependencies: Dependency[];
+    includeDependencies: Dependency[];
+    options: binding.JsEntryOptions;
+    static __from_binding(binding: binding.JsEntryData): EntryData;
+    private constructor();
+}
+export declare class Entries implements Map<string, EntryData> {
+    #private;
+    constructor(data: binding.JsEntries);
+    clear(): void;
+    forEach(callback: (value: EntryData, key: string, map: Map<string, EntryData>) => void, thisArg?: any): void;
+    get size(): number;
+    entries(): ReturnType<Map<string, EntryData>["entries"]>;
+    values(): ReturnType<Map<string, EntryData>["values"]>;
+    [Symbol.iterator](): ReturnType<Map<string, EntryData>["entries"]>;
+    get [Symbol.toStringTag](): string;
+    has(key: string): boolean;
+    set(key: string, value: EntryData): this;
+    delete(key: string): boolean;
+    get(key: string): EntryData | undefined;
+    keys(): ReturnType<Map<string, EntryData>["keys"]>;
+}

package/dist/Compiler.d.ts

@@ -0,0 +1,192 @@
+/**
+ * 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 "@rspack/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;
+}
+declare class Compiler {
+    #private;
+    hooks: {
+        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>;
+        infrastructureLog: liteTapable.SyncBailHook<[string, string, any[]], true>;
+        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<[]>;
+    };
+    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;
+    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__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 "@rspack/binding";

package/dist/ContextModule.d.ts

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