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

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

@@ -0,0 +1,49 @@
+import { type JsRsdoctorAsset, type JsRsdoctorAssetPatch, type JsRsdoctorChunk, type JsRsdoctorChunkAssets, type JsRsdoctorChunkGraph, type JsRsdoctorChunkModules, type JsRsdoctorDependency, type JsRsdoctorEntrypoint, type JsRsdoctorEntrypointAssets, type JsRsdoctorExportInfo, type JsRsdoctorModule, type JsRsdoctorModuleGraph, type JsRsdoctorModuleGraphModule, type JsRsdoctorModuleIdsPatch, type JsRsdoctorModuleOriginalSource, type JsRsdoctorModuleSourcesPatch, type JsRsdoctorSideEffect, type JsRsdoctorSourcePosition, type JsRsdoctorSourceRange, type JsRsdoctorStatement, type JsRsdoctorVariable } from "../binding";
+import * as liteTapable from "@rspack/lite-tapable";
+import { type Compilation } from "../Compilation";
+import type { Compiler } from "../Compiler";
+import type { CreatePartialRegisters } from "../taps/types";
+export declare namespace RsdoctorPluginData {
+    export type { JsRsdoctorAsset as RsdoctorAsset, JsRsdoctorChunkGraph as RsdoctorChunkGraph, JsRsdoctorModuleGraph as RsdoctorModuleGraph, JsRsdoctorChunk as RsdoctorChunk, JsRsdoctorModule as RsdoctorModule, JsRsdoctorSideEffect as RsdoctorSideEffect, JsRsdoctorExportInfo as RsdoctorExportInfo, JsRsdoctorVariable as RsdoctorVariable, JsRsdoctorDependency as RsdoctorDependency, JsRsdoctorEntrypoint as RsdoctorEntrypoint, JsRsdoctorStatement as RsdoctorStatement, JsRsdoctorSourceRange as RsdoctorSourceRange, JsRsdoctorSourcePosition as RsdoctorSourcePosition, JsRsdoctorModuleGraphModule as RsdoctorModuleGraphModule, JsRsdoctorModuleIdsPatch as RsdoctorModuleIdsPatch, JsRsdoctorModuleOriginalSource as RsdoctorModuleOriginalSource, JsRsdoctorAssetPatch as RsdoctorAssetPatch, JsRsdoctorChunkAssets as RsdoctorChunkAssets, JsRsdoctorEntrypointAssets as RsdoctorEntrypointAssets, JsRsdoctorChunkModules as RsdoctorChunkModules, JsRsdoctorModuleSourcesPatch as RsdoctorModuleSourcesPatch };
+}
+export type RsdoctorPluginOptions = {
+    moduleGraphFeatures?: boolean | ("graph" | "ids" | "sources")[];
+    chunkGraphFeatures?: boolean | ("graph" | "assets")[];
+    sourceMapFeatures?: {
+        module?: boolean;
+        cheap?: boolean;
+    };
+};
+declare const RsdoctorPluginImpl: {
+    new (c?: RsdoctorPluginOptions | undefined): {
+        name: string;
+        _args: [c?: RsdoctorPluginOptions | undefined];
+        affectedHooks: keyof import("../Compiler").CompilerHooks | undefined;
+        raw(compiler: Compiler): import("../binding").BuiltinPlugin;
+        apply(compiler: Compiler): void;
+    };
+};
+export type RsdoctorPluginHooks = {
+    moduleGraph: liteTapable.AsyncSeriesBailHook<[
+        JsRsdoctorModuleGraph
+    ], false | void>;
+    chunkGraph: liteTapable.AsyncSeriesBailHook<[
+        JsRsdoctorChunkGraph
+    ], false | void>;
+    moduleIds: liteTapable.AsyncSeriesBailHook<[
+        JsRsdoctorModuleIdsPatch
+    ], false | void>;
+    moduleSources: liteTapable.AsyncSeriesBailHook<[
+        JsRsdoctorModuleSourcesPatch
+    ], false | void>;
+    assets: liteTapable.AsyncSeriesBailHook<[JsRsdoctorAssetPatch], false | void>;
+};
+declare const RsdoctorPlugin: typeof RsdoctorPluginImpl & {
+    /**
+     * @deprecated Use `getCompilationHooks` instead.
+     */
+    getHooks: (compilation: Compilation) => RsdoctorPluginHooks;
+    getCompilationHooks: (compilation: Compilation) => RsdoctorPluginHooks;
+};
+export declare const createRsdoctorPluginHooksRegisters: CreatePartialRegisters<`RsdoctorPlugin`>;
+export { RsdoctorPlugin };

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

@@ -0,0 +1,11 @@
+import { type RawRslibPluginOptions } from "../binding";
+export type RslibPluginArgument = Partial<Omit<RawRslibPluginOptions, "handler">> | ((percentage: number, msg: string, ...args: string[]) => void) | undefined;
+export declare const RslibPlugin: {
+    new (rslib: RawRslibPluginOptions): {
+        name: string;
+        _args: [rslib: RawRslibPluginOptions];
+        affectedHooks: keyof import("..").CompilerHooks | undefined;
+        raw(compiler: import("..").Compiler): import("../binding").BuiltinPlugin;
+        apply(compiler: import("..").Compiler): void;
+    };
+};

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

@@ -0,0 +1,11 @@
+import { type RawRstestPluginOptions } from "../binding";
+export type RstestPluginArgument = Partial<Omit<RawRstestPluginOptions, "handler">> | ((percentage: number, msg: string, ...args: string[]) => void) | undefined;
+export declare const RstestPlugin: {
+    new (rstest: RawRstestPluginOptions): {
+        name: string;
+        _args: [rstest: RawRstestPluginOptions];
+        affectedHooks: keyof import("..").CompilerHooks | undefined;
+        raw(compiler: import("..").Compiler): import("../binding").BuiltinPlugin;
+        apply(compiler: import("..").Compiler): void;
+    };
+};

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

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

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

@@ -0,0 +1,28 @@
+import binding from "../binding";
+import * as liteTapable from "@rspack/lite-tapable";
+import type { Chunk } from "../Chunk";
+import { type Compilation } from "../Compilation";
+import type { CreatePartialRegisters } from "../taps/types";
+export declare const RuntimePluginImpl: {
+    new (): {
+        name: string;
+        _args: [];
+        affectedHooks: keyof import("..").CompilerHooks | undefined;
+        raw(compiler: import("..").Compiler): binding.BuiltinPlugin;
+        apply(compiler: import("..").Compiler): void;
+    };
+};
+export type RuntimePluginHooks = {
+    createScript: liteTapable.SyncWaterfallHook<[string, Chunk]>;
+    linkPreload: liteTapable.SyncWaterfallHook<[string, Chunk]>;
+    linkPrefetch: liteTapable.SyncWaterfallHook<[string, Chunk]>;
+};
+declare const RuntimePlugin: typeof RuntimePluginImpl & {
+    /**
+     * @deprecated Use `getCompilationHooks` instead.
+     */
+    getHooks: (compilation: Compilation) => RuntimePluginHooks;
+    getCompilationHooks: (compilation: Compilation) => RuntimePluginHooks;
+};
+export declare const createRuntimePluginHooksRegisters: CreatePartialRegisters<`RuntimePlugin`>;
+export { RuntimePlugin };

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

@@ -0,0 +1,9 @@
+export declare const SideEffectsFlagPlugin: {
+    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/SizeLimitsPlugin.d.ts

@@ -0,0 +1,19 @@
+export declare const SizeLimitsPlugin: {
+    new (options: {
+        assetFilter?: (assetFilename: string) => boolean;
+        hints?: false | "warning" | "error";
+        maxAssetSize?: number;
+        maxEntrypointSize?: number;
+    }): {
+        name: string;
+        _args: [options: {
+            assetFilter?: (assetFilename: string) => boolean;
+            hints?: false | "warning" | "error";
+            maxAssetSize?: number;
+            maxEntrypointSize?: number;
+        }];
+        affectedHooks: keyof import("..").CompilerHooks | undefined;
+        raw(compiler: import("..").Compiler): import("../binding").BuiltinPlugin;
+        apply(compiler: import("..").Compiler): void;
+    };
+};

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

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

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

@@ -0,0 +1,11 @@
+import { type BuiltinPlugin, BuiltinPluginName } from "../binding";
+import type { Compiler } from "../Compiler";
+import type { OptimizationSplitChunksOptions } from "../config";
+import { RspackBuiltinPlugin } from "./base";
+export declare class SplitChunksPlugin extends RspackBuiltinPlugin {
+    private options;
+    name: BuiltinPluginName;
+    affectedHooks: "thisCompilation";
+    constructor(options: OptimizationSplitChunksOptions);
+    raw(compiler: Compiler): BuiltinPlugin;
+}

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

@@ -0,0 +1,39 @@
+import { type RawSubresourceIntegrityPluginOptions } from "../binding";
+import type { Compiler } from "../Compiler";
+export type SubresourceIntegrityHashFunction = "sha256" | "sha384" | "sha512";
+export type SubresourceIntegrityPluginOptions = {
+    hashFuncNames?: [
+        SubresourceIntegrityHashFunction,
+        ...SubresourceIntegrityHashFunction[]
+    ];
+    htmlPlugin?: string | false;
+    enabled?: "auto" | boolean;
+};
+export type NativeSubresourceIntegrityPluginOptions = Omit<RawSubresourceIntegrityPluginOptions, "htmlPlugin"> & {
+    htmlPlugin: string | false;
+};
+/**
+ * Note: This is not a webpack public API, maybe removed in future.
+ * @internal
+ */
+declare const NativeSubresourceIntegrityPlugin: {
+    new (options: NativeSubresourceIntegrityPluginOptions): {
+        name: string;
+        _args: [options: NativeSubresourceIntegrityPluginOptions];
+        affectedHooks: keyof import("../Compiler").CompilerHooks | undefined;
+        raw(compiler: Compiler): import("../binding").BuiltinPlugin;
+        apply(compiler: Compiler): void;
+    };
+};
+export declare class SubresourceIntegrityPlugin extends NativeSubresourceIntegrityPlugin {
+    private integrities;
+    private options;
+    constructor(options?: SubresourceIntegrityPluginOptions);
+    private isEnabled;
+    private getIntegrityChecksumForAsset;
+    private handleHwpPluginArgs;
+    private handleHwpBodyTags;
+    private processTag;
+    apply(compiler: Compiler): void;
+}
+export {};

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

@@ -0,0 +1,215 @@
+import type { LiteralUnion } from "../config";
+import type { AssetConditions } from "../util/assetCondition";
+type ExtractCommentsCondition = boolean | RegExp;
+type ExtractCommentsBanner = string | boolean;
+type ExtractCommentsObject = {
+    condition?: ExtractCommentsCondition | undefined;
+    banner?: ExtractCommentsBanner | undefined;
+};
+type ExtractCommentsOptions = ExtractCommentsCondition | ExtractCommentsObject;
+export type SwcJsMinimizerRspackPluginOptions = {
+    test?: AssetConditions;
+    exclude?: AssetConditions;
+    include?: AssetConditions;
+    extractComments?: ExtractCommentsOptions | undefined;
+    minimizerOptions?: {
+        minify?: boolean;
+        ecma?: TerserEcmaVersion;
+        compress?: TerserCompressOptions | boolean;
+        mangle?: TerserMangleOptions | boolean;
+        format?: JsFormatOptions & ToSnakeCaseProperties<JsFormatOptions>;
+        module?: boolean;
+    };
+};
+/**
+ * @example ToSnakeCase<'indentLevel'> == 'indent_level'
+ */
+type ToSnakeCase<T extends string> = T extends `${infer A}${infer B}` ? `${A extends Lowercase<A> ? A : `_${Lowercase<A>}`}${ToSnakeCase<B>}` : T;
+/**
+ * @example ToSnakeCaseProperties\<{indentLevel: 3\}\> == {indent_level: 3\}
+ */
+type ToSnakeCaseProperties<T> = {
+    [K in keyof T as K extends string ? ToSnakeCase<K> : K]: T[K];
+};
+export interface JsFormatOptions {
+    /**
+     * Currently noop.
+     * @default false
+     * @alias ascii_only
+     */
+    asciiOnly?: boolean;
+    /**
+     * Currently noop.
+     * @default false
+     */
+    beautify?: boolean;
+    /**
+     * Currently noop.
+     * @default false
+     */
+    braces?: boolean;
+    /**
+     * - `false`: removes all comments
+     * - `'some'`: preserves some comments
+     * - `'all'`: preserves all comments
+     * @default false
+     */
+    comments?: false | "some" | "all";
+    /**
+     * Currently noop.
+     * @default 5
+     */
+    ecma?: TerserEcmaVersion;
+    /**
+     * Currently noop.
+     * @alias indent_level
+     */
+    indentLevel?: number;
+    /**
+     * Currently noop.
+     * @alias indent_start
+     */
+    indentStart?: number;
+    inlineScript?: number;
+    /**
+     * Currently noop.
+     * @alias keep_numbers
+     */
+    keepNumbers?: number;
+    /**
+     * Currently noop.
+     * @alias keep_quoted_props
+     */
+    keepQuotedProps?: boolean;
+    /**
+     * Currently noop.
+     * @alias max_line_len
+     */
+    maxLineLen?: number | false;
+    /**
+     * When passed it must be a string and it will be prepended to the output literally.
+     * The source map will adjust for this text. Can be used to insert a comment containing licensing information.
+     */
+    preamble?: string;
+    /**
+     * Currently noop.
+     * @alias quote_keys
+     */
+    quoteKeys?: boolean;
+    /**
+     * Currently noop.
+     * @alias quote_style
+     */
+    quoteStyle?: boolean;
+    /**
+     * Currently noop.
+     * @alias preserve_annotations
+     */
+    preserveAnnotations?: boolean;
+    /**
+     * Currently noop.
+     */
+    safari10?: boolean;
+    /**
+     * Currently noop.
+     */
+    semicolons?: boolean;
+    /**
+     * Currently noop.
+     */
+    shebang?: boolean;
+    /**
+     * Currently noop.
+     */
+    webkit?: boolean;
+    /**
+     * Currently noop.
+     * @alias wrap_iife
+     */
+    wrapIife?: boolean;
+    /**
+     * Currently noop.
+     * @alias wrap_func_args
+     */
+    wrapFuncArgs?: boolean;
+}
+export type TerserEcmaVersion = LiteralUnion<5 | 2015 | 2016, number> | string;
+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;
+}
+export interface TerserMangleOptions {
+    props?: TerserManglePropertiesOptions;
+    toplevel?: boolean;
+    keep_classnames?: boolean;
+    keep_fnames?: boolean;
+    keep_private_props?: boolean;
+    ie8?: boolean;
+    safari10?: boolean;
+    reserved?: string[];
+}
+export type TerserManglePropertiesOptions = {};
+export declare const SwcJsMinimizerRspackPlugin: {
+    new (options?: SwcJsMinimizerRspackPluginOptions | undefined): {
+        name: string;
+        _args: [options?: SwcJsMinimizerRspackPluginOptions | undefined];
+        affectedHooks: keyof import("..").CompilerHooks | undefined;
+        raw(compiler: import("..").Compiler): import("../binding").BuiltinPlugin;
+        apply(compiler: import("..").Compiler): void;
+    };
+};
+export {};

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

@@ -0,0 +1,9 @@
+export declare const URLPlugin: {
+    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/WarnCaseSensitiveModulesPlugin.d.ts

@@ -0,0 +1,9 @@
+export declare const WarnCaseSensitiveModulesPlugin: {
+    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/WebWorkerTemplatePlugin.d.ts

@@ -0,0 +1,7 @@
+import { type BuiltinPlugin, BuiltinPluginName } from "../binding";
+import type { Compiler } from "../Compiler";
+import { RspackBuiltinPlugin } from "./base";
+export declare class WebWorkerTemplatePlugin extends RspackBuiltinPlugin {
+    name: BuiltinPluginName;
+    raw(compiler: Compiler): BuiltinPlugin | undefined;
+}

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

@@ -0,0 +1,13 @@
+import { type BuiltinPlugin, BuiltinPluginName } from "../binding";
+import type { Compiler } from "../Compiler";
+import type { ChunkLoading, OutputModule, WasmLoading, WorkerPublicPath } from "../config";
+import { RspackBuiltinPlugin } from "./base";
+export declare class WorkerPlugin extends RspackBuiltinPlugin {
+    private chunkLoading;
+    private wasmLoading;
+    private module;
+    private workerPublicPath;
+    name: BuiltinPluginName;
+    constructor(chunkLoading: ChunkLoading, wasmLoading: WasmLoading, module: OutputModule, workerPublicPath: WorkerPublicPath);
+    raw(compiler: Compiler): BuiltinPlugin;
+}

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

@@ -0,0 +1,45 @@
+import binding from "../binding";
+import type { Compiler, RspackPluginInstance } from "..";
+type AffectedHooks = keyof Compiler["hooks"];
+export declare function canInherentFromParent(affectedHooks?: AffectedHooks): boolean;
+export declare abstract class RspackBuiltinPlugin implements RspackPluginInstance {
+    abstract raw(compiler: Compiler): binding.BuiltinPlugin | undefined;
+    abstract name: binding.BuiltinPluginName | CustomPluginName;
+    affectedHooks?: AffectedHooks;
+    apply(compiler: Compiler): void;
+}
+export declare function createBuiltinPlugin<R>(name: binding.BuiltinPluginName | CustomPluginName, options: R): binding.BuiltinPlugin;
+type CustomPluginName = string;
+export declare function create<T extends any[], R>(name: binding.BuiltinPluginName | CustomPluginName, resolve: (this: Compiler, ...args: T) => R, affectedHooks?: AffectedHooks): {
+    new (...args: T): {
+        name: string;
+        _args: T;
+        affectedHooks: keyof import("..").CompilerHooks | undefined;
+        raw(compiler: Compiler): binding.BuiltinPlugin;
+        apply(compiler: Compiler): void;
+    };
+};
+/**
+ * Create a wrapper class for builtin plugin.
+ *
+ * @example
+ * ```js
+ * const MyPlugin = createNativePlugin("MyPlugin", (options) => {
+ * 	return options;
+ * });
+ *
+ * new MyPlugin({
+ * 	foo: "bar"
+ * }).apply(compiler);
+ * ```
+ */
+export declare function createNativePlugin<T extends any[], R>(name: CustomPluginName, resolve: (this: Compiler, ...args: T) => R, affectedHooks?: AffectedHooks): {
+    new (...args: T): {
+        name: string;
+        _args: T;
+        affectedHooks: keyof import("..").CompilerHooks | undefined;
+        raw(compiler: Compiler): binding.BuiltinPlugin;
+        apply(compiler: Compiler): void;
+    };
+};
+export {};

package/dist/builtin-plugin/css-extract/index.d.ts

@@ -0,0 +1,24 @@
+import { type RawCssExtractPluginOption } from "../../binding";
+import type { Compiler, LiteralUnion } from "../..";
+export * from "./loader";
+export type { CssExtractRspackLoaderOptions } from "./loader";
+export interface CssExtractRspackPluginOptions {
+    filename?: RawCssExtractPluginOption["filename"];
+    chunkFilename?: RawCssExtractPluginOption["chunkFilename"];
+    ignoreOrder?: boolean;
+    insert?: string | ((linkTag: HTMLLinkElement) => void);
+    attributes?: Record<string, string>;
+    linkType?: LiteralUnion<"text/css", string> | false;
+    runtime?: boolean;
+    pathinfo?: boolean;
+    enforceRelative?: boolean;
+}
+export declare class CssExtractRspackPlugin {
+    static pluginName: string;
+    static loader: string;
+    options: CssExtractRspackPluginOptions;
+    constructor(options?: CssExtractRspackPluginOptions);
+    apply(compiler: Compiler): void;
+    normalizeOptions(options: CssExtractRspackPluginOptions): RawCssExtractPluginOption;
+}
+export default CssExtractRspackPlugin;

package/dist/builtin-plugin/css-extract/loader.d.ts

@@ -0,0 +1,21 @@
+import type { LoaderContext, LoaderDefinition } from "../..";
+export declare const BASE_URI = "webpack://";
+export declare const MODULE_TYPE = "css/mini-extract";
+export declare const AUTO_PUBLIC_PATH = "__mini_css_extract_plugin_public_path_auto__";
+export declare const ABSOLUTE_PUBLIC_PATH = "webpack:///mini-css-extract-plugin/";
+export declare const SINGLE_DOT_PATH_SEGMENT = "__mini_css_extract_plugin_single_dot_path_segment__";
+export interface CssExtractRspackLoaderOptions {
+    publicPath?: string | ((resourcePath: string, context: string) => string);
+    emit?: boolean;
+    esModule?: boolean;
+    layer?: string;
+    defaultExport?: boolean;
+}
+export declare function hotLoader(content: string, context: {
+    loaderContext: LoaderContext;
+    options?: CssExtractRspackLoaderOptions;
+    locals?: Record<string, string>;
+}): string;
+declare const loader: LoaderDefinition;
+export declare const pitch: LoaderDefinition["pitch"];
+export default loader;

package/dist/builtin-plugin/css-extract/utils.d.ts

@@ -0,0 +1,6 @@
+import type { LoaderContext } from "../..";
+export declare function isAbsolutePath(str: string): boolean;
+export declare const PLUGIN_NAME = "css-extract-rspack-plugin";
+export declare function isRelativePath(str: string): boolean;
+export declare function stringifyRequest(loaderContext: LoaderContext, request: string): string;
+export declare function stringifyLocal(value: any): any;

package/dist/builtin-plugin/html-plugin/hooks.d.ts

@@ -0,0 +1,32 @@
+import type { JsAfterEmitData, JsAfterTemplateExecutionData, JsAlterAssetTagGroupsData, JsAlterAssetTagsData, JsBeforeAssetTagGenerationData, JsBeforeEmitData } from "../../binding";
+import * as liteTapable from "@rspack/lite-tapable";
+import { type Compilation } from "../../Compilation";
+import type { HtmlRspackPluginOptions } from "./options";
+type ExtraPluginHookData = {
+    plugin: {
+        options: HtmlRspackPluginOptions;
+    };
+};
+export type HtmlRspackPluginHooks = {
+    beforeAssetTagGeneration: liteTapable.AsyncSeriesWaterfallHook<[
+        JsBeforeAssetTagGenerationData & ExtraPluginHookData
+    ]>;
+    alterAssetTags: liteTapable.AsyncSeriesWaterfallHook<[
+        JsAlterAssetTagsData & ExtraPluginHookData
+    ]>;
+    alterAssetTagGroups: liteTapable.AsyncSeriesWaterfallHook<[
+        JsAlterAssetTagGroupsData & ExtraPluginHookData
+    ]>;
+    afterTemplateExecution: liteTapable.AsyncSeriesWaterfallHook<[
+        JsAfterTemplateExecutionData & ExtraPluginHookData
+    ]>;
+    beforeEmit: liteTapable.AsyncSeriesWaterfallHook<[
+        JsBeforeEmitData & ExtraPluginHookData
+    ]>;
+    afterEmit: liteTapable.AsyncSeriesWaterfallHook<[
+        JsAfterEmitData & ExtraPluginHookData
+    ]>;
+};
+export declare const getPluginHooks: (compilation: Compilation) => HtmlRspackPluginHooks;
+export declare const cleanPluginHooks: (compilation: Compilation) => void;
+export {};

package/dist/builtin-plugin/html-plugin/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./options";
+export * from "./plugin";