@rspack-debug/core 1.3.14

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 * as binding from "@rspack/binding";
+import * as liteTapable from "@rspack/lite-tapable";
+import Cache from "./lib/Cache";
+import CacheFacade from "./lib/CacheFacade";
+import type { Chunk } from "./Chunk";
+import { Compilation } from "./Compilation";
+import { ContextModuleFactory } from "./ContextModuleFactory";
+import { NormalModuleFactory } from "./NormalModuleFactory";
+import { ResolverFactory } from "./ResolverFactory";
+import { RuleSetCompiler } from "./RuleSetCompiler";
+import { Stats } from "./Stats";
+import { Watching } from "./Watching";
+import { rspack } from "./index";
+import { Logger } from "./logging/Logger";
+import type Watchpack from "../compiled/watchpack";
+import type { Source } from "../compiled/webpack-sources";
+import type { CompilationParams } from "./Compilation";
+import type { FileSystemInfoEntry } from "./FileSystemInfo";
+import type { EntryNormalized, OutputNormalized, RspackOptionsNormalized, RspackPluginInstance } from "./config";
+import type { InputFileSystem, IntermediateFileSystem, OutputFileSystem, WatchFileSystem } from "./util/fs";
+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";

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 "@rspack/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,10 @@
+import type { JsChunkGroup } from "@rspack/binding";
+import { Chunk } from "./Chunk";
+import { ChunkGroup } from "./ChunkGroup";
+export declare class Entrypoint extends ChunkGroup {
+    #private;
+    static __from_binding(binding: JsChunkGroup): Entrypoint;
+    protected constructor(binding: JsChunkGroup);
+    getRuntimeChunk(): Readonly<Chunk | null>;
+    getEntrypointChunk(): Readonly<Chunk | null>;
+}

package/dist/ErrorHelpers.d.ts

@@ -0,0 +1 @@
+export declare const cutOffLoaderExecution: (stack: 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 "@rspack/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 "@rspack/binding";

package/dist/FileSystem.d.ts

@@ -0,0 +1,29 @@
+import type { NodeFsStats, ThreadsafeNodeFS } from "@rspack/binding";
+import { type IStats, type IntermediateFileSystem, type OutputFileSystem } from "./util/fs";
+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>;
+    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;
+    static __to_binding_stat(stat: IStats): NodeFsStats;
+}
+declare class ThreadsafeIntermediateNodeFS extends ThreadsafeOutputNodeFS {
+    constructor(fs?: IntermediateFileSystem);
+    static __to_binding(fs?: IntermediateFileSystem): ThreadsafeIntermediateNodeFS;
+}
+export { 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,66 @@
+import * as binding from "@rspack/binding";
+import type { Source } from "../compiled/webpack-sources";
+import type { ResourceData } from "./Resolver";
+export type ResourceDataWithData = ResourceData & {
+    data?: Record<string, any>;
+};
+export type CreateData = Partial<binding.JsCreateData>;
+export type ContextInfo = {
+    issuer: string;
+    issuerLayer?: string | null;
+};
+export type ResolveData = {
+    contextInfo: ContextInfo;
+    context: string;
+    request: string;
+    fileDependencies: string[];
+    missingDependencies: string[];
+    contextDependencies: string[];
+    createData?: CreateData;
+};
+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 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>;
+    }
+}
+declare module "@rspack/binding" {
+    interface Module {
+        identifier(): string;
+        readableIdentifier(): string;
+        originalSource(): Source | null;
+        emitFile(filename: string, source: Source, assetInfo?: AssetInfo): void;
+    }
+}
+export { Module } from "@rspack/binding";

package/dist/ModuleGraph.d.ts

@@ -0,0 +1,19 @@
+import type { Dependency, JsModuleGraph, ModuleGraphConnection } from "@rspack/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,75 @@
+/**
+ * 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 { Compiler, RspackOptions } from ".";
+import MultiStats from "./MultiStats";
+import MultiWatching from "./MultiWatching";
+import type { WatchOptions } from "./config";
+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 = ReadonlyArray<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]>>;
+        run: liteTapable.MultiHook<liteTapable.AsyncSeriesHook<[Compiler]>>;
+        watchClose: liteTapable.SyncHook<[]>;
+        watchRun: liteTapable.MultiHook<liteTapable.AsyncSeriesHook<[Compiler]>>;
+        infrastructureLog: liteTapable.MultiHook<liteTapable.SyncBailHook<[string, string, any[]], true>>;
+    };
+    _options: MultiCompilerOptions;
+    running: boolean;
+    constructor(compilers: Compiler[] | Record<string, Compiler>, options?: MultiCompilerOptions);
+    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, 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,22 @@
+/**
+ * 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 { 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: any): StatsCompilation;
+    toString(options: any): string;
+}
+export { MultiStats };

package/dist/MultiWatching.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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;
+    close(callback: Callback<Error, void>): void;
+    suspend(): void;
+    resume(): void;
+}
+export default MultiWatching;

package/dist/NormalModule.d.ts

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

package/dist/NormalModuleFactory.d.ts

@@ -0,0 +1,23 @@
+import type * as binding from "@rspack/binding";
+import * as liteTapable from "@rspack/lite-tapable";
+import type { ResolveData, ResourceDataWithData } from "./Module";
+import type { 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: Parameters<ResolverFactory["get"]>[1]): import("./Resolver").Resolver;
+}

package/dist/Resolver.d.ts

@@ -0,0 +1,18 @@
+import type * as binding from "@rspack/binding";
+import { type Resolve } from "./config";
+import type { ResolveCallback } from "./config/adapterRuleUse";
+type ResolveContext = {};
+type ResolveOptionsWithDependencyType = Resolve & {
+    dependencyCategory?: string;
+    resolveToContext?: boolean;
+};
+export type ResourceData = binding.JsResourceData;
+export type ResolveRequest = ResourceData;
+export declare class Resolver {
+    binding: binding.JsResolver;
+    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;
+    withOptions({ dependencyCategory, resolveToContext, ...resolve }: ResolveOptionsWithDependencyType): Resolver;
+}
+export {};

package/dist/ResolverFactory.d.ts

@@ -0,0 +1,14 @@
+import * as binding from "@rspack/binding";
+import { Resolver } from "./Resolver";
+import { type Resolve } from "./config";
+type ResolveOptionsWithDependencyType = Resolve & {
+    dependencyCategory?: string;
+    resolveToContext?: boolean;
+};
+export declare class ResolverFactory {
+    #private;
+    static __to_binding(resolver_factory: ResolverFactory): binding.JsResolverFactory;
+    constructor(pnp: boolean);
+    get(type: string, resolveOptions?: ResolveOptionsWithDependencyType): Resolver;
+}
+export {};

package/dist/RspackError.d.ts

@@ -0,0 +1,9 @@
+import type * as binding from "@rspack/binding";
+export type RspackError = binding.JsRspackError;
+export type RspackSeverity = binding.JsRspackSeverity;
+export declare class NonErrorEmittedError extends Error {
+    constructor(error: Error);
+}
+export declare class DeadlockRiskError extends Error {
+    constructor(message: string);
+}

package/dist/RuleSetCompiler.d.ts

@@ -0,0 +1,9 @@
+declare class RuleSetCompiler {
+    references: Map<string, any>;
+    /**
+     * builtin references that should be serializable and passed to Rust.
+     */
+    builtinReferences: Map<string, any>;
+    constructor();
+}
+export { RuleSetCompiler };