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

package/dist/browser/fs.d.ts

@@ -0,0 +1,13 @@
+import type { IFs, memfs as Memfs, Volume } from "memfs";
+export declare const fs: IFs;
+export declare const volume: Volume;
+export declare const memfs: typeof Memfs;
+declare const readFileSync: (file: import("memfs/lib/core").TFileId, options?: import("memfs/lib/node/types/options").IReadFileOptions | string) => import("memfs/lib/encoding").TDataOut, readdirSync: (path: import("memfs/lib/node/types/misc").PathLike, options?: import("memfs/lib/node/types/options").IReaddirOptions | string) => import("memfs/lib/encoding").TDataOut[] | import("memfs/lib/node/Dirent").Dirent[], lstat: {
+    (path: import("memfs/lib/node/types/misc").PathLike, callback: import("memfs/lib/node/types/misc").TCallback<import("memfs/lib/node/Stats").Stats>): void;
+    (path: import("memfs/lib/node/types/misc").PathLike, options: import("memfs/lib/node/types/options").IStatOptions, callback: import("memfs/lib/node/types/misc").TCallback<import("memfs/lib/node/Stats").Stats>): void;
+}, existsSync: (path: import("memfs/lib/node/types/misc").PathLike) => boolean, readdir: {
+    (path: import("memfs/lib/node/types/misc").PathLike, callback: import("memfs/lib/node/types/misc").TCallback<import("memfs/lib/encoding").TDataOut[] | import("memfs/lib/node/Dirent").Dirent[]>): any;
+    (path: import("memfs/lib/node/types/misc").PathLike, options: import("memfs/lib/node/types/options").IReaddirOptions | string, callback: import("memfs/lib/node/types/misc").TCallback<import("memfs/lib/encoding").TDataOut[] | import("memfs/lib/node/Dirent").Dirent[]>): any;
+}, watch: (path: import("memfs/lib/node/types/misc").PathLike, options?: import("memfs/lib/node/volume").IWatchOptions | string, listener?: (eventType: string, filename: string) => void) => import("memfs/lib/node/volume").FSWatcher;
+export default fs;
+export { readFileSync, readdirSync, lstat, existsSync, readdir, watch };

package/dist/browser/index.d.ts

@@ -0,0 +1,11 @@
+export * from "../index";
+export { BrowserHttpImportEsmPlugin } from "./BrowserHttpImportEsmPlugin";
+export { BrowserRequirePlugin } from "./BrowserRequirePlugin";
+export declare const builtinMemFs: {
+    fs: import("memfs").IFs;
+    volume: import("memfs").Volume;
+    memfs: (json?: import("memfs").NestedDirectoryJSON, cwd?: string) => {
+        fs: import("memfs").IFs;
+        vol: import("memfs").Volume;
+    };
+};

package/dist/browser/service.d.ts

@@ -0,0 +1,25 @@
+export declare enum RequestType {
+    AddDependency = "AddDependency",
+    AddContextDependency = "AddContextDependency",
+    AddMissingDependency = "AddMissingDependency",
+    AddBuildDependency = "AddBuildDependency",
+    GetDependencies = "GetDependencies",
+    GetContextDependencies = "GetContextDependencies",
+    GetMissingDependencies = "GetMissingDependencies",
+    ClearDependencies = "ClearDependencies",
+    Resolve = "Resolve",
+    GetResolve = "GetResolve",
+    GetLogger = "GetLogger",
+    EmitError = "EmitError",
+    EmitWarning = "EmitWarning",
+    EmitFile = "EmitFile",
+    EmitDiagnostic = "EmitDiagnostic",
+    SetCacheable = "SetCacheable",
+    ImportModule = "ImportModule",
+    UpdateLoaderObjects = "UpdateLoaderObjects",
+    CompilationGetPath = "CompilationGetPath",
+    CompilationGetPathWithInfo = "CompilationGetPathWithInfo",
+    CompilationGetAssetPath = "CompilationGetAssetPath",
+    CompilationGetAssetPathWithInfo = "CompilationGetAssetPathWithInfo"
+}
+export declare function run(): Promise<void>;

package/dist/builtin-loader/index.d.ts

@@ -0,0 +1 @@
+export * from "./swc";

package/dist/builtin-loader/lightningcss/index.d.ts

@@ -0,0 +1,117 @@
+/**
+MIT License
+
+Copyright (c) 2021-present Devon Govett
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+export declare function toFeatures(featureOptions: FeatureOptions): Features;
+export declare enum Features {
+    Empty = 0,
+    Nesting = 1,
+    NotSelectorList = 2,
+    DirSelector = 4,
+    LangSelectorList = 8,
+    IsSelector = 16,
+    TextDecorationThicknessPercent = 32,
+    MediaIntervalSyntax = 64,
+    MediaRangeSyntax = 128,
+    CustomMediaQueries = 256,
+    ClampFunction = 512,
+    ColorFunction = 1024,
+    OklabColors = 2048,
+    LabColors = 4096,
+    P3Colors = 8192,
+    HexAlphaColors = 16384,
+    SpaceSeparatedColorNotation = 32768,
+    FontFamilySystemUi = 65536,
+    DoublePositionGradients = 131072,
+    VendorPrefixes = 262144,
+    LogicalProperties = 524288,
+    Selectors = 31,
+    MediaQueries = 448,
+    Color = 64512
+}
+export interface Targets {
+    android?: number;
+    chrome?: number;
+    edge?: number;
+    firefox?: number;
+    ie?: number;
+    ios_saf?: number;
+    opera?: number;
+    safari?: number;
+    samsung?: number;
+}
+export interface Drafts {
+    /** Whether to enable @custom-media rules. */
+    customMedia?: boolean;
+}
+export interface NonStandard {
+    /** Whether to enable the non-standard >>> and /deep/ selector combinators used by Angular and Vue. */
+    deepSelectorCombinator?: boolean;
+}
+export interface PseudoClasses {
+    hover?: string;
+    active?: string;
+    focus?: string;
+    focusVisible?: string;
+    focusWithin?: string;
+}
+export type FeatureOptions = {
+    nesting?: boolean;
+    notSelectorList?: boolean;
+    dirSelector?: boolean;
+    langSelectorList?: boolean;
+    isSelector?: boolean;
+    textDecorationThicknessPercent?: boolean;
+    mediaIntervalSyntax?: boolean;
+    mediaRangeSyntax?: boolean;
+    customMediaQueries?: boolean;
+    clampFunction?: boolean;
+    colorFunction?: boolean;
+    oklabColors?: boolean;
+    labColors?: boolean;
+    p3Colors?: boolean;
+    hexAlphaColors?: boolean;
+    spaceSeparatedColorNotation?: boolean;
+    fontFamilySystemUi?: boolean;
+    doublePositionGradients?: boolean;
+    vendorPrefixes?: boolean;
+    logicalProperties?: boolean;
+    selectors?: boolean;
+    mediaQueries?: boolean;
+    color?: boolean;
+};
+export type LoaderOptions = {
+    minify?: boolean;
+    errorRecovery?: boolean;
+    targets?: Targets | string[] | string;
+    include?: FeatureOptions;
+    exclude?: FeatureOptions;
+    /**
+     * @deprecated Use `drafts` instead.
+     * This will be removed in the next major version.
+     */
+    draft?: Drafts;
+    drafts?: Drafts;
+    nonStandard?: NonStandard;
+    pseudoClasses?: PseudoClasses;
+    unusedSymbols?: string[];
+};

package/dist/builtin-loader/swc/collectTypeScriptInfo.d.ts

@@ -0,0 +1,21 @@
+export type CollectTypeScriptInfoOptions = {
+    /**
+     * Whether to collect type exports information for `typeReexportsPresence`.
+     * This is used to check type exports of submodules when running in `'tolerant'` mode.
+     * @default false
+     */
+    typeExports?: boolean;
+    /**
+     * Whether to collect information about exported `enum`s.
+     * - `true` will collect all `enum` information, including `const enum`s and regular `enum`s.
+     * - `false` will not collect any `enum` information.
+     * - `'const-only'` will gather only `const enum`s, enabling Rspack to perform cross-module
+     * inlining optimizations for them.
+     * @default false
+     */
+    exportedEnum?: boolean | "const-only";
+};
+export declare function resolveCollectTypeScriptInfo(options: CollectTypeScriptInfoOptions): {
+    typeExports: boolean | undefined;
+    exportedEnum: string;
+};

package/dist/builtin-loader/swc/index.d.ts

@@ -0,0 +1,5 @@
+export type { CollectTypeScriptInfoOptions } from "./collectTypeScriptInfo";
+export { resolveCollectTypeScriptInfo } from "./collectTypeScriptInfo";
+export type { PluginImportOptions } from "./pluginImport";
+export { resolvePluginImport } from "./pluginImport";
+export type { SwcLoaderEnvConfig, SwcLoaderEsParserConfig, SwcLoaderJscConfig, SwcLoaderModuleConfig, SwcLoaderOptions, SwcLoaderParserConfig, SwcLoaderTransformConfig, SwcLoaderTsParserConfig } from "./types";

package/dist/builtin-loader/swc/pluginImport.d.ts

@@ -0,0 +1,33 @@
+type RawStyleConfig = {
+    styleLibraryDirectory?: string;
+    custom?: string;
+    css?: string;
+    bool?: boolean;
+};
+type RawPluginImportConfig = {
+    libraryName: string;
+    libraryDirectory?: string;
+    customName?: string;
+    customStyleName?: string;
+    style?: RawStyleConfig;
+    camelToDashComponentName?: boolean;
+    transformToDefaultImport?: boolean;
+    ignoreEsComponent?: string[];
+    ignoreStyleComponent?: string[];
+};
+type PluginImportConfig = {
+    libraryName: string;
+    libraryDirectory?: string;
+    customName?: string;
+    customStyleName?: string;
+    style?: string | boolean;
+    styleLibraryDirectory?: string;
+    camelToDashComponentName?: boolean;
+    transformToDefaultImport?: boolean;
+    ignoreEsComponent?: string[];
+    ignoreStyleComponent?: string[];
+};
+type PluginImportOptions = PluginImportConfig[];
+declare function resolvePluginImport(pluginImport: PluginImportOptions): RawPluginImportConfig[] | undefined;
+export { resolvePluginImport };
+export type { PluginImportOptions };

package/dist/builtin-loader/swc/types.d.ts

@@ -0,0 +1,83 @@
+import type { Config, EnvConfig, EsParserConfig, JscConfig, ModuleConfig, ParserConfig, TerserEcmaVersion, TransformConfig, TsParserConfig } from "@swc/types";
+import type { CollectTypeScriptInfoOptions } from "./collectTypeScriptInfo";
+import type { PluginImportOptions } from "./pluginImport";
+export type SwcLoaderEnvConfig = EnvConfig;
+export type SwcLoaderJscConfig = JscConfig;
+export type SwcLoaderModuleConfig = ModuleConfig;
+export type SwcLoaderParserConfig = ParserConfig;
+export type SwcLoaderEsParserConfig = EsParserConfig;
+export type SwcLoaderTsParserConfig = TsParserConfig;
+export type SwcLoaderTransformConfig = TransformConfig;
+export type SwcLoaderOptions = Config & {
+    isModule?: boolean | "unknown";
+    /**
+     * Experimental features provided by Rspack.
+     * @experimental
+     */
+    rspackExperiments?: {
+        import?: PluginImportOptions;
+        /**
+         * Collects information from TypeScript's AST for consumption by subsequent Rspack processes,
+         * providing better TypeScript development experience and smaller output bundle size.
+         */
+        collectTypeScriptInfo?: CollectTypeScriptInfoOptions;
+    };
+};
+export interface TerserCompressOptions {
+    arguments?: boolean;
+    arrows?: boolean;
+    booleans?: boolean;
+    booleans_as_integers?: boolean;
+    collapse_vars?: boolean;
+    comparisons?: boolean;
+    computed_props?: boolean;
+    conditionals?: boolean;
+    dead_code?: boolean;
+    defaults?: boolean;
+    directives?: boolean;
+    drop_console?: boolean;
+    drop_debugger?: boolean;
+    ecma?: TerserEcmaVersion;
+    evaluate?: boolean;
+    expression?: boolean;
+    global_defs?: any;
+    hoist_funs?: boolean;
+    hoist_props?: boolean;
+    hoist_vars?: boolean;
+    ie8?: boolean;
+    if_return?: boolean;
+    inline?: 0 | 1 | 2 | 3;
+    join_vars?: boolean;
+    keep_classnames?: boolean;
+    keep_fargs?: boolean;
+    keep_fnames?: boolean;
+    keep_infinity?: boolean;
+    loops?: boolean;
+    negate_iife?: boolean;
+    passes?: number;
+    properties?: boolean;
+    pure_getters?: any;
+    pure_funcs?: string[];
+    reduce_funcs?: boolean;
+    reduce_vars?: boolean;
+    sequences?: any;
+    side_effects?: boolean;
+    switches?: boolean;
+    top_retain?: any;
+    toplevel?: any;
+    typeofs?: boolean;
+    unsafe?: boolean;
+    unsafe_passes?: boolean;
+    unsafe_arrows?: boolean;
+    unsafe_comps?: boolean;
+    unsafe_function?: boolean;
+    unsafe_math?: boolean;
+    unsafe_symbols?: boolean;
+    unsafe_methods?: boolean;
+    unsafe_proto?: boolean;
+    unsafe_regexp?: boolean;
+    unsafe_undefined?: boolean;
+    unused?: boolean;
+    const_to_let?: boolean;
+    module?: boolean;
+}

package/dist/builtin-plugin/APIPlugin.d.ts

@@ -0,0 +1,9 @@
+export declare const APIPlugin: {
+    new (): {
+        name: string;
+        _args: [];
+        affectedHooks: keyof import("..").CompilerHooks | undefined;
+        raw(compiler: import("..").Compiler): import("../binding").BuiltinPlugin;
+        apply(compiler: import("..").Compiler): void;
+    };
+};

package/dist/builtin-plugin/ArrayPushCallbackChunkFormatPlugin.d.ts

@@ -0,0 +1,9 @@
+export declare const ArrayPushCallbackChunkFormatPlugin: {
+    new (): {
+        name: string;
+        _args: [];
+        affectedHooks: keyof import("..").CompilerHooks | undefined;
+        raw(compiler: import("..").Compiler): import("../binding").BuiltinPlugin;
+        apply(compiler: import("..").Compiler): void;
+    };
+};

package/dist/builtin-plugin/AssetModulesPlugin.d.ts

@@ -0,0 +1,9 @@
+export declare const AssetModulesPlugin: {
+    new (): {
+        name: string;
+        _args: [];
+        affectedHooks: keyof import("..").CompilerHooks | undefined;
+        raw(compiler: import("..").Compiler): import("../binding").BuiltinPlugin;
+        apply(compiler: import("..").Compiler): void;
+    };
+};

package/dist/builtin-plugin/AsyncWebAssemblyModulesPlugin.d.ts

@@ -0,0 +1,9 @@
+export declare const AsyncWebAssemblyModulesPlugin: {
+    new (): {
+        name: string;
+        _args: [];
+        affectedHooks: keyof import("..").CompilerHooks | undefined;
+        raw(compiler: import("..").Compiler): import("../binding").BuiltinPlugin;
+        apply(compiler: import("..").Compiler): void;
+    };
+};

package/dist/builtin-plugin/BannerPlugin.d.ts

@@ -0,0 +1,40 @@
+import { type Chunk } from "../binding";
+export type Rule = string | RegExp;
+export type Rules = Rule[] | Rule;
+export type BannerFunction = (args: {
+    hash: string;
+    chunk: Chunk;
+    filename: string;
+}) => string;
+export type BannerContent = string | BannerFunction;
+export type BannerPluginOptions = {
+    /** Specifies the banner, it will be wrapped in a comment. */
+    banner: BannerContent;
+    /** If true, the banner will only be added to the entry chunks. */
+    entryOnly?: boolean;
+    /** Exclude all modules matching any of these conditions. */
+    exclude?: Rules;
+    /** Include all modules matching any of these conditions. */
+    include?: Rules;
+    /** If true, banner will not be wrapped in a comment. */
+    raw?: boolean;
+    /** If true, banner will be placed at the end of the output. */
+    footer?: boolean;
+    /**
+     * The stage of the compilation in which the banner should be injected.
+     * @default PROCESS_ASSETS_STAGE_ADDITIONS (-100)
+     */
+    stage?: number;
+    /** Include all modules that pass test assertion. */
+    test?: Rules;
+};
+export type BannerPluginArgument = BannerContent | BannerPluginOptions;
+export declare const BannerPlugin: {
+    new (args: BannerPluginArgument): {
+        name: string;
+        _args: [args: BannerPluginArgument];
+        affectedHooks: keyof import("..").CompilerHooks | undefined;
+        raw(compiler: import("..").Compiler): import("../binding").BuiltinPlugin;
+        apply(compiler: import("..").Compiler): void;
+    };
+};

package/dist/builtin-plugin/BundlerInfoRspackPlugin.d.ts

@@ -0,0 +1,14 @@
+export type BundleInfoOptions = {
+    version?: string;
+    bundler?: string;
+    force?: boolean | string[];
+};
+export declare const BundlerInfoRspackPlugin: {
+    new (options: BundleInfoOptions): {
+        name: string;
+        _args: [options: BundleInfoOptions];
+        affectedHooks: keyof import("..").CompilerHooks | undefined;
+        raw(compiler: import("..").Compiler): import("../binding").BuiltinPlugin;
+        apply(compiler: import("..").Compiler): void;
+    };
+};

package/dist/builtin-plugin/ChunkPrefetchPreloadPlugin.d.ts

@@ -0,0 +1,9 @@
+export declare const ChunkPrefetchPreloadPlugin: {
+    new (): {
+        name: string;
+        _args: [];
+        affectedHooks: keyof import("..").CompilerHooks | undefined;
+        raw(compiler: import("..").Compiler): import("../binding").BuiltinPlugin;
+        apply(compiler: import("..").Compiler): void;
+    };
+};

package/dist/builtin-plugin/CircularDependencyRspackPlugin.d.ts

@@ -0,0 +1,59 @@
+import { type BuiltinPlugin, BuiltinPluginName } from "../binding";
+import type { Compilation } from "../Compilation";
+import type { Compiler } from "../Compiler";
+import type { Module } from "../Module";
+import { RspackBuiltinPlugin } from "./base";
+export type CircularDependencyRspackPluginOptions = {
+    /**
+     * When `true`, the plugin will emit `ERROR` diagnostics rather than the
+     * default `WARN` level.
+     */
+    failOnError?: boolean;
+    /**
+     * When `true`, asynchronous imports like `import("some-module")` will not
+     * be considered connections that can create cycles.
+     */
+    allowAsyncCycles?: boolean;
+    /**
+     * Cycles containing any module name that matches this regex will _not_ be
+     * counted as a cycle.
+     */
+    exclude?: RegExp;
+    /**
+     * List of dependency connections that should not count for creating cycles.
+     * Connections are represented as `[from, to]`, where each entry is matched
+     * against the _identifier_ for that module in the connection. The
+     * identifier contains the full, unique path for the module, including all
+     * of the loaders that were applied to it and any request parameters.
+     *
+     * When an entry is a String, it is tested as a _substring_ of the
+     * identifier. For example, the entry "components/Button" would match the
+     * module "app/design/components/Button.tsx". When the entry is a RegExp,
+     * it is tested against the entire identifier.
+     */
+    ignoredConnections?: [string | RegExp, string | RegExp][];
+    /**
+     * Called once for every detected cycle. Providing this handler overrides the
+     * default behavior of adding diagnostics to the compilation.
+     */
+    onDetected?(entrypoint: Module, modules: string[], compilation: Compilation): void;
+    /**
+     * Called once for every detected cycle that was ignored because of a rule,
+     * either from `exclude` or `ignoredConnections`.
+     */
+    onIgnored?(entrypoint: Module, modules: string[], compilation: Compilation): void;
+    /**
+     * Called before cycle detection begins.
+     */
+    onStart?(compilation: Compilation): void;
+    /**
+     * Called after cycle detection finishes.
+     */
+    onEnd?(compilation: Compilation): void;
+};
+export declare class CircularDependencyRspackPlugin extends RspackBuiltinPlugin {
+    name: BuiltinPluginName;
+    _options: CircularDependencyRspackPluginOptions;
+    constructor(options: CircularDependencyRspackPluginOptions);
+    raw(compiler: Compiler): BuiltinPlugin;
+}

package/dist/builtin-plugin/CommonJsChunkFormatPlugin.d.ts

@@ -0,0 +1,9 @@
+export declare const CommonJsChunkFormatPlugin: {
+    new (): {
+        name: string;
+        _args: [];
+        affectedHooks: keyof import("..").CompilerHooks | undefined;
+        raw(compiler: import("..").Compiler): import("../binding").BuiltinPlugin;
+        apply(compiler: import("..").Compiler): void;
+    };
+};

package/dist/builtin-plugin/ContextReplacementPlugin.d.ts

@@ -0,0 +1,9 @@
+export declare const ContextReplacementPlugin: {
+    new (resourceRegExp: RegExp, newContentResource?: any, newContentRecursive?: any, newContentRegExp?: any): {
+        name: string;
+        _args: [resourceRegExp: RegExp, newContentResource?: any, newContentRecursive?: any, newContentRegExp?: any];
+        affectedHooks: keyof import("..").CompilerHooks | undefined;
+        raw(compiler: import("..").Compiler): import("../binding").BuiltinPlugin;
+        apply(compiler: import("..").Compiler): void;
+    };
+};

package/dist/builtin-plugin/CopyRspackPlugin.d.ts

@@ -0,0 +1,14 @@
+import { type RawCopyPattern } from "../binding";
+export type CopyRspackPluginOptions = {
+    /** An array of objects that describe the copy operations to be performed. */
+    patterns: (string | (Pick<RawCopyPattern, "from"> & Partial<Omit<RawCopyPattern, "from">>))[];
+};
+export declare const CopyRspackPlugin: {
+    new (copy: CopyRspackPluginOptions): {
+        name: string;
+        _args: [copy: CopyRspackPluginOptions];
+        affectedHooks: keyof import("..").CompilerHooks | undefined;
+        raw(compiler: import("..").Compiler): import("../binding").BuiltinPlugin;
+        apply(compiler: import("..").Compiler): void;
+    };
+};

package/dist/builtin-plugin/CssChunkingPlugin.d.ts

@@ -0,0 +1,21 @@
+import binding from "../binding";
+export interface CssChunkingPluginOptions {
+    strict?: boolean;
+    minSize?: number;
+    maxSize?: number;
+    /**
+     * This plugin is intended to be generic, but currently requires some special handling for Next.js.
+     * A `next` option has been added to accommodate this.
+     * In the future, once the design of CssChunkingPlugin becomes more stable, this option may be removed.
+     */
+    nextjs?: boolean;
+}
+export declare const CssChunkingPlugin: {
+    new (options?: CssChunkingPluginOptions | undefined): {
+        name: string;
+        _args: [options?: CssChunkingPluginOptions | undefined];
+        affectedHooks: keyof import("..").CompilerHooks | undefined;
+        raw(compiler: import("..").Compiler): binding.BuiltinPlugin;
+        apply(compiler: import("..").Compiler): void;
+    };
+};

package/dist/builtin-plugin/CssModulesPlugin.d.ts

@@ -0,0 +1,9 @@
+export declare const CssModulesPlugin: {
+    new (): {
+        name: string;
+        _args: [];
+        affectedHooks: keyof import("..").CompilerHooks | undefined;
+        raw(compiler: import("..").Compiler): import("../binding").BuiltinPlugin;
+        apply(compiler: import("..").Compiler): void;
+    };
+};

package/dist/builtin-plugin/DataUriPlugin.d.ts

@@ -0,0 +1,9 @@
+export declare const DataUriPlugin: {
+    new (): {
+        name: string;
+        _args: [];
+        affectedHooks: keyof import("..").CompilerHooks | undefined;
+        raw(compiler: import("..").Compiler): import("../binding").BuiltinPlugin;
+        apply(compiler: import("..").Compiler): void;
+    };
+};

package/dist/builtin-plugin/DefinePlugin.d.ts

@@ -0,0 +1,16 @@
+export type DefinePluginOptions = Record<string, CodeValue>;
+export declare const DefinePlugin: {
+    new (define: DefinePluginOptions): {
+        name: string;
+        _args: [define: DefinePluginOptions];
+        affectedHooks: keyof import("..").CompilerHooks | undefined;
+        raw(compiler: import("..").Compiler): import("../binding").BuiltinPlugin;
+        apply(compiler: import("..").Compiler): void;
+    };
+};
+type CodeValue = RecursiveArrayOrRecord<CodeValuePrimitive>;
+type CodeValuePrimitive = null | undefined | RegExp | Function | string | number | boolean | bigint;
+type RecursiveArrayOrRecord<T> = {
+    [index: string]: RecursiveArrayOrRecord<T>;
+} | RecursiveArrayOrRecord<T>[] | T;
+export {};

package/dist/builtin-plugin/DeterministicChunkIdsPlugin.d.ts

@@ -0,0 +1,7 @@
+import { type BuiltinPlugin, BuiltinPluginName } from "../binding";
+import { RspackBuiltinPlugin } from "./base";
+export declare class DeterministicChunkIdsPlugin extends RspackBuiltinPlugin {
+    name: BuiltinPluginName;
+    affectedHooks: "compilation";
+    raw(): BuiltinPlugin;
+}

package/dist/builtin-plugin/DeterministicModuleIdsPlugin.d.ts

@@ -0,0 +1,7 @@
+import { type BuiltinPlugin, BuiltinPluginName } from "../binding";
+import { RspackBuiltinPlugin } from "./base";
+export declare class DeterministicModuleIdsPlugin extends RspackBuiltinPlugin {
+    name: BuiltinPluginName;
+    affectedHooks: "compilation";
+    raw(): BuiltinPlugin;
+}

package/dist/builtin-plugin/DllEntryPlugin.d.ts

@@ -0,0 +1,12 @@
+export type DllEntryPluginOptions = {
+    name: string;
+};
+export declare const DllEntryPlugin: {
+    new (context: string, entries: string[], options: DllEntryPluginOptions): {
+        name: string;
+        _args: [context: string, entries: string[], options: DllEntryPluginOptions];
+        affectedHooks: keyof import("..").CompilerHooks | undefined;
+        raw(compiler: import("..").Compiler): import("../binding").BuiltinPlugin;
+        apply(compiler: import("..").Compiler): void;
+    };
+};

package/dist/builtin-plugin/DllReferenceAgencyPlugin.d.ts

@@ -0,0 +1,11 @@
+import { type RawDllReferenceAgencyPluginOptions } from "../binding";
+export type DllReferenceAgencyPluginOptions = RawDllReferenceAgencyPluginOptions;
+export declare const DllReferenceAgencyPlugin: {
+    new (options: RawDllReferenceAgencyPluginOptions): {
+        name: string;
+        _args: [options: RawDllReferenceAgencyPluginOptions];
+        affectedHooks: keyof import("..").CompilerHooks | undefined;
+        raw(compiler: import("..").Compiler): import("../binding").BuiltinPlugin;
+        apply(compiler: import("..").Compiler): void;
+    };
+};

package/dist/builtin-plugin/DynamicEntryPlugin.d.ts

@@ -0,0 +1,12 @@
+import { type BuiltinPlugin, BuiltinPluginName } from "../binding";
+import type { Compiler } from "../Compiler";
+import type { EntryDynamicNormalized } from "../config";
+import { RspackBuiltinPlugin } from "./base";
+export declare class DynamicEntryPlugin extends RspackBuiltinPlugin {
+    private context;
+    private entry;
+    name: BuiltinPluginName;
+    affectedHooks: "make";
+    constructor(context: string, entry: EntryDynamicNormalized);
+    raw(compiler: Compiler): BuiltinPlugin | undefined;
+}

package/dist/builtin-plugin/ElectronTargetPlugin.d.ts

@@ -0,0 +1,9 @@
+export declare const ElectronTargetPlugin: {
+    new (context?: string | undefined): {
+        name: string;
+        _args: [context?: string | undefined];
+        affectedHooks: keyof import("..").CompilerHooks | undefined;
+        raw(compiler: import("..").Compiler): import("../binding").BuiltinPlugin;
+        apply(compiler: import("..").Compiler): void;
+    };
+};