@rspack-debug/core 1.3.14

package/dist/container/ContainerPlugin.d.ts

@@ -0,0 +1,40 @@
+import { type BuiltinPlugin, BuiltinPluginName } from "@rspack/binding";
+import type { Compiler } from "../Compiler";
+import { RspackBuiltinPlugin } from "../builtin-plugin/base";
+import type { EntryRuntime, FilenameTemplate, LibraryOptions } from "../config";
+export type ContainerPluginOptions = {
+    exposes: Exposes;
+    filename?: FilenameTemplate;
+    library?: LibraryOptions;
+    name: string;
+    runtime?: EntryRuntime;
+    shareScope?: string;
+    enhanced?: boolean;
+};
+export type Exposes = (ExposesItem | ExposesObject)[] | ExposesObject;
+export type ExposesItem = string;
+export type ExposesItems = ExposesItem[];
+export type ExposesObject = {
+    [k: string]: ExposesConfig | ExposesItem | ExposesItems;
+};
+export type ExposesConfig = {
+    import: ExposesItem | ExposesItems;
+    name?: string;
+};
+export declare class ContainerPlugin extends RspackBuiltinPlugin {
+    name: BuiltinPluginName;
+    _options: {
+        name: string;
+        shareScope: string;
+        library: LibraryOptions;
+        runtime: EntryRuntime | undefined;
+        filename: string | undefined;
+        exposes: [string, {
+            import: string[];
+            name: string | undefined;
+        }][];
+        enhanced: boolean;
+    };
+    constructor(options: ContainerPluginOptions);
+    raw(compiler: Compiler): BuiltinPlugin;
+}

package/dist/container/ContainerReferencePlugin.d.ts

@@ -0,0 +1,33 @@
+import { type BuiltinPlugin, BuiltinPluginName } from "@rspack/binding";
+import type { Compiler } from "../Compiler";
+import { RspackBuiltinPlugin } from "../builtin-plugin/base";
+import type { ExternalsType } from "../config";
+export type ContainerReferencePluginOptions = {
+    remoteType: ExternalsType;
+    remotes: Remotes;
+    shareScope?: string;
+    enhanced?: boolean;
+};
+export type Remotes = (RemotesItem | RemotesObject)[] | RemotesObject;
+export type RemotesItem = string;
+export type RemotesItems = RemotesItem[];
+export type RemotesObject = {
+    [k: string]: RemotesConfig | RemotesItem | RemotesItems;
+};
+export type RemotesConfig = {
+    external: RemotesItem | RemotesItems;
+    shareScope?: string;
+};
+export declare class ContainerReferencePlugin extends RspackBuiltinPlugin {
+    name: BuiltinPluginName;
+    _options: {
+        remoteType: ExternalsType;
+        remotes: [string, {
+            external: string[];
+            shareScope: string;
+        }][];
+        enhanced: boolean;
+    };
+    constructor(options: ContainerReferencePluginOptions);
+    raw(compiler: Compiler): BuiltinPlugin;
+}

package/dist/container/ModuleFederationPlugin.d.ts

@@ -0,0 +1,13 @@
+import type { Compiler } from "../Compiler";
+import type { ModuleFederationPluginV1Options } from "./ModuleFederationPluginV1";
+export interface ModuleFederationPluginOptions extends Omit<ModuleFederationPluginV1Options, "enhanced"> {
+    runtimePlugins?: RuntimePlugins;
+    implementation?: string;
+    shareStrategy?: "version-first" | "loaded-first";
+}
+export type RuntimePlugins = string[];
+export declare class ModuleFederationPlugin {
+    private _options;
+    constructor(_options: ModuleFederationPluginOptions);
+    apply(compiler: Compiler): void;
+}

package/dist/container/ModuleFederationPluginV1.d.ts

@@ -0,0 +1,22 @@
+import type { Compiler } from "../Compiler";
+import type { EntryRuntime, ExternalsType, LibraryOptions } from "../config";
+import { type Shared } from "../sharing/SharePlugin";
+import { type Exposes } from "./ContainerPlugin";
+import { type Remotes } from "./ContainerReferencePlugin";
+export interface ModuleFederationPluginV1Options {
+    exposes?: Exposes;
+    filename?: string;
+    library?: LibraryOptions;
+    name: string;
+    remoteType?: ExternalsType;
+    remotes?: Remotes;
+    runtime?: EntryRuntime;
+    shareScope?: string;
+    shared?: Shared;
+    enhanced?: boolean;
+}
+export declare class ModuleFederationPluginV1 {
+    private _options;
+    constructor(_options: ModuleFederationPluginV1Options);
+    apply(compiler: Compiler): void;
+}

package/dist/container/ModuleFederationRuntimePlugin.d.ts

@@ -0,0 +1,10 @@
+import { BuiltinPluginName } from "@rspack/binding";
+export declare const ModuleFederationRuntimePlugin: {
+    new (): {
+        name: BuiltinPluginName;
+        _args: [];
+        affectedHooks: "done" | "compilation" | "make" | "compile" | "emit" | "afterEmit" | "invalid" | "thisCompilation" | "afterDone" | "normalModuleFactory" | "contextModuleFactory" | "initialize" | "shouldEmit" | "infrastructureLog" | "beforeRun" | "run" | "assetEmitted" | "failed" | "shutdown" | "watchRun" | "watchClose" | "environment" | "afterEnvironment" | "afterPlugins" | "afterResolvers" | "beforeCompile" | "afterCompile" | "finishMake" | "entryOption" | "additionalPass" | undefined;
+        raw(compiler: import("..").Compiler): import("@rspack/binding").BuiltinPlugin;
+        apply(compiler: import("..").Compiler): void;
+    };
+};

package/dist/container/options.d.ts

@@ -0,0 +1,3 @@
+type ContainerOptionsFormat<T> = (string | Record<string, string | string[] | T>)[] | Record<string, string | string[] | T>;
+export declare const parseOptions: <T, R>(options: ContainerOptionsFormat<T>, normalizeSimple: (a: string | string[], b: string) => R, normalizeOptions: (a: T, b: string) => R) => [string, R][];
+export {};

package/dist/cssExtractHmr.js

@@ -0,0 +1,125 @@
+"use strict";
+var __webpack_require__ = {};
+__webpack_require__.d = (exports1, definition)=>{
+    for(var key in definition)__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key) && Object.defineProperty(exports1, key, {
+        enumerable: !0,
+        get: definition[key]
+    });
+}, __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop), __webpack_require__.r = (exports1)=>{
+    'undefined' != typeof Symbol && Symbol.toStringTag && Object.defineProperty(exports1, Symbol.toStringTag, {
+        value: 'Module'
+    }), Object.defineProperty(exports1, '__esModule', {
+        value: !0
+    });
+};
+var __webpack_exports__ = {};
+function normalizeUrl(url) {
+    let urlString = url.trim();
+    if (/^data:/i.test(urlString)) return urlString;
+    let protocol = -1 !== urlString.indexOf("//") ? `${urlString.split("//")[0]}//` : "", components = urlString.replace(RegExp(protocol, "i"), "").split("/"), host = components[0].toLowerCase().replace(/\.$/, "");
+    return components[0] = "", protocol + host + components.reduce((accumulator, item)=>{
+        switch(item){
+            case "..":
+                accumulator.pop();
+                break;
+            case ".":
+                break;
+            default:
+                accumulator.push(item);
+        }
+        return accumulator;
+    }, []).join("/");
+}
+__webpack_require__.r(__webpack_exports__), __webpack_require__.d(__webpack_exports__, {
+    cssReload: ()=>cssReload,
+    normalizeUrl: ()=>normalizeUrl
+});
+let srcByModuleId = Object.create(null), noDocument = "undefined" == typeof document, { forEach } = Array.prototype;
+function noop() {}
+function updateCss(el, url) {
+    let normalizedUrl;
+    if (url) normalizedUrl = url;
+    else {
+        if (!el.href) return;
+        normalizedUrl = el.href.split("?")[0];
+    }
+    if (!isUrlRequest(normalizedUrl) || !1 === el.isLoaded || !normalizedUrl || !(normalizedUrl.indexOf(".css") > -1)) return;
+    el.visited = !0;
+    let newEl = el.cloneNode();
+    newEl.isLoaded = !1, newEl.addEventListener("load", ()=>{
+        !newEl.isLoaded && (newEl.isLoaded = !0, el.parentNode && el.parentNode.removeChild(el));
+    }), newEl.addEventListener("error", ()=>{
+        !newEl.isLoaded && (newEl.isLoaded = !0, el.parentNode && el.parentNode.removeChild(el));
+    }), newEl.href = `${normalizedUrl}?${Date.now()}`;
+    let parent = el.parentNode;
+    parent && (el.nextSibling ? parent.insertBefore(newEl, el.nextSibling) : parent.appendChild(newEl));
+}
+function reloadAll() {
+    let elements = document.querySelectorAll("link");
+    forEach.call(elements, (el)=>{
+        !0 !== el.visited && updateCss(el);
+    });
+}
+function isUrlRequest(url) {
+    return !!/^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(url);
+}
+function cssReload(moduleId, options) {
+    var fn;
+    let timeout;
+    if (noDocument) return console.log("[HMR] No `window.document` found, CSS HMR disabled"), noop;
+    let getScriptSrc = function(moduleId) {
+        let src = srcByModuleId[moduleId];
+        if (!src) {
+            if (document.currentScript) ({ src } = document.currentScript);
+            else {
+                let scripts = document.getElementsByTagName("script"), lastScriptTag = scripts[scripts.length - 1];
+                lastScriptTag && ({ src } = lastScriptTag);
+            }
+            srcByModuleId[moduleId] = src;
+        }
+        return (fileMap)=>{
+            if (!src) return null;
+            let splitResult = src.match(/([^\\/]+)\.js$/), filename = splitResult && splitResult[1];
+            return filename && fileMap ? fileMap.split(",").map((mapRule)=>{
+                let reg = RegExp(`${filename}\\.js$`, "g");
+                return normalizeUrl(src.replace(reg, `${mapRule.replace(/{fileName}/g, filename)}.css`));
+            }) : [
+                src.replace(".js", ".css")
+            ];
+        };
+    }(moduleId);
+    return fn = function() {
+        let src = getScriptSrc(options.filename), reloaded = function(src) {
+            if (!src) return !1;
+            let elements = document.querySelectorAll("link"), loaded = !1;
+            return forEach.call(elements, (el)=>{
+                if (!el.href) return;
+                let url = function(href, src) {
+                    let ret = "", normalizedHref = normalizeUrl(href);
+                    return src.some((url)=>{
+                        normalizedHref.indexOf(src) > -1 && (ret = url);
+                    }), ret;
+                }(el.href, src);
+                isUrlRequest(url) && !0 !== el.visited && url && (updateCss(el, url), loaded = !0);
+            }), loaded;
+        }(src);
+        if (options.locals) {
+            console.log("[HMR] Detected local CSS Modules. Reload all CSS"), reloadAll();
+            return;
+        }
+        reloaded ? console.log("[HMR] CSS reload %s", src && src.join(" ")) : (console.log("[HMR] Reload all CSS"), reloadAll());
+    }, timeout = 0, function() {
+        for(var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++)args[_key] = arguments[_key];
+        let self = this;
+        clearTimeout(timeout), timeout = setTimeout(function() {
+            return fn.apply(self, args);
+        }, 50);
+    };
+}
+for(var __webpack_i__ in exports.cssReload = __webpack_exports__.cssReload, exports.normalizeUrl = __webpack_exports__.normalizeUrl, __webpack_exports__)-1 === [
+    "cssReload",
+    "normalizeUrl"
+].indexOf(__webpack_i__) && (exports[__webpack_i__] = __webpack_exports__[__webpack_i__]);
+Object.defineProperty(exports, '__esModule', {
+    value: !0
+});

package/dist/cssExtractLoader.js

@@ -0,0 +1,161 @@
+"use strict";
+var __webpack_require__ = {};
+__webpack_require__.n = (module)=>{
+    var getter = module && module.__esModule ? ()=>module.default : ()=>module;
+    return __webpack_require__.d(getter, {
+        a: getter
+    }), getter;
+}, __webpack_require__.d = (exports1, definition)=>{
+    for(var key in definition)__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key) && Object.defineProperty(exports1, key, {
+        enumerable: !0,
+        get: definition[key]
+    });
+}, __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop), __webpack_require__.r = (exports1)=>{
+    'undefined' != typeof Symbol && Symbol.toStringTag && Object.defineProperty(exports1, Symbol.toStringTag, {
+        value: 'Module'
+    }), Object.defineProperty(exports1, '__esModule', {
+        value: !0
+    });
+};
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__), __webpack_require__.d(__webpack_exports__, {
+    hotLoader: ()=>hotLoader,
+    MODULE_TYPE: ()=>MODULE_TYPE,
+    SINGLE_DOT_PATH_SEGMENT: ()=>SINGLE_DOT_PATH_SEGMENT,
+    BASE_URI: ()=>BASE_URI,
+    default: ()=>css_extract_loader,
+    pitch: ()=>pitch,
+    AUTO_PUBLIC_PATH: ()=>AUTO_PUBLIC_PATH,
+    ABSOLUTE_PUBLIC_PATH: ()=>ABSOLUTE_PUBLIC_PATH
+});
+let external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = __webpack_require__.n(external_node_path_namespaceObject);
+function isAbsolutePath(str) {
+    return external_node_path_default().posix.isAbsolute(str) || external_node_path_default().win32.isAbsolute(str);
+}
+let PLUGIN_NAME = "css-extract-rspack-plugin", RELATIVE_PATH_REGEXP = /^\.\.?[/\\]/, BASE_URI = "webpack://", MODULE_TYPE = "css/mini-extract", AUTO_PUBLIC_PATH = "__mini_css_extract_plugin_public_path_auto__", ABSOLUTE_PUBLIC_PATH = `${BASE_URI}/mini-css-extract-plugin/`, SINGLE_DOT_PATH_SEGMENT = "__mini_css_extract_plugin_single_dot_path_segment__";
+function hotLoader(content, context) {
+    let localsJsonString = JSON.stringify(JSON.stringify(context.locals));
+    return `${content}
+    if(module.hot) {
+      (function() {
+        var localsJsonString = ${localsJsonString};
+        // ${Date.now()}
+        var cssReload = require(${function(loaderContext, request) {
+        if (void 0 !== loaderContext.utils && "function" == typeof loaderContext.utils.contextify) return JSON.stringify(loaderContext.utils.contextify(loaderContext.context || loaderContext.rootContext, request));
+        let splitted = request.split("!"), { context } = loaderContext;
+        return JSON.stringify(splitted.map((part)=>{
+            let splittedPart = part.match(/^(.*?)(\?.*)/), query = splittedPart ? splittedPart[2] : "", singlePath = splittedPart ? splittedPart[1] : part;
+            if (isAbsolutePath(singlePath) && context) {
+                var str;
+                if (isAbsolutePath(singlePath = external_node_path_default().relative(context, singlePath))) return singlePath + query;
+                str = singlePath, RELATIVE_PATH_REGEXP.test(str) || (singlePath = `./${singlePath}`);
+            }
+            return singlePath.replace(/\\/g, "/") + query;
+        }).join("!"));
+    }(context.loaderContext, external_node_path_default().join(__dirname, "cssExtractHmr.js"))}).cssReload(module.id, ${JSON.stringify(context.options ?? {})});
+        // only invalidate when locals change
+        if (
+          module.hot.data &&
+          module.hot.data.value &&
+          module.hot.data.value !== localsJsonString
+        ) {
+          module.hot.invalidate();
+        } else {
+          module.hot.accept();
+        }
+        module.hot.dispose(function(data) {
+          data.value = localsJsonString;
+          cssReload();
+        });
+      })();
+    }
+  `;
+}
+let pitch = function(request, _, data) {
+    let publicPathForExtract;
+    if (this._compiler?.options?.experiments?.css && this._module && ("css" === this._module.type || "css/auto" === this._module.type || "css/global" === this._module.type || "css/module" === this._module.type)) {
+        let e = Error("use type 'css' and `CssExtractRspackPlugin` together, please set `experiments.css` to `false` or set `{ type: \"javascript/auto\" }` for rules with `CssExtractRspackPlugin` in your rspack config (now `CssExtractRspackPlugin` does nothing).");
+        e.stack = void 0, this.emitWarning(e);
+        return;
+    }
+    let options = this.getOptions(), emit = void 0 === options.emit || options.emit, callback = this.async(), filepath = this.resourcePath, parseMeta = this.__internal__parseMeta;
+    this.addDependency(filepath);
+    let { publicPath } = this._compilation.outputOptions;
+    "string" == typeof options.publicPath ? publicPath = options.publicPath : "function" == typeof options.publicPath && (publicPath = options.publicPath(this.resourcePath, this.rootContext)), "auto" === publicPath && (publicPath = AUTO_PUBLIC_PATH), publicPathForExtract = "string" == typeof publicPath ? /^[a-zA-Z][a-zA-Z\d+\-.]*?:/.test(publicPath) ? publicPath : `${ABSOLUTE_PUBLIC_PATH}${publicPath.replace(/\./g, SINGLE_DOT_PATH_SEGMENT)}` : publicPath;
+    let handleExports = (originalExports)=>{
+        let locals, namedExport, esModule = void 0 === options.esModule || options.esModule, dependencies = [];
+        try {
+            let exports1 = originalExports.__esModule ? originalExports.default : originalExports;
+            if (namedExport = originalExports.__esModule && (!originalExports.default || !("locals" in originalExports.default))) for (let key of Object.keys(originalExports))"default" !== key && (locals || (locals = {}), locals[key] = originalExports[key]);
+            else locals = exports1?.locals;
+            if (Array.isArray(exports1) && emit) {
+                let identifierCountMap = new Map();
+                dependencies = exports1.map(([id, content, media, sourceMap, supports, layer])=>{
+                    let context = this.rootContext, count = identifierCountMap.get(id) || 0;
+                    return identifierCountMap.set(id, count + 1), {
+                        identifier: id,
+                        context,
+                        content,
+                        media,
+                        supports,
+                        layer,
+                        identifierIndex: count,
+                        sourceMap: sourceMap ? JSON.stringify(sourceMap) : void 0,
+                        filepath
+                    };
+                }).filter((item)=>null !== item);
+            }
+        } catch (e) {
+            callback(e);
+            return;
+        }
+        let result = function() {
+            if (locals) {
+                if (namedExport) {
+                    let identifiers = Array.from(function*() {
+                        let identifierId = 0;
+                        for (let key of Object.keys(locals))identifierId += 1, yield [
+                            `_${identifierId.toString(16)}`,
+                            key
+                        ];
+                    }()), localsString = identifiers.map(([id, key])=>{
+                        var value;
+                        return `\nvar ${id} = ${"function" == typeof (value = locals[key]) ? value.toString() : JSON.stringify(value)};`;
+                    }).join(""), exportsString = `export { ${identifiers.map(([id, key])=>`${id} as ${JSON.stringify(key)}`).join(", ")} }`;
+                    return void 0 !== options.defaultExport && options.defaultExport ? `${localsString}\n${exportsString}\nexport default { ${identifiers.map(([id, key])=>`${JSON.stringify(key)}: ${id}`).join(", ")} }\n` : `${localsString}\n${exportsString}\n`;
+                }
+                return `\n${esModule ? "export default" : "module.exports = "} ${JSON.stringify(locals)};`;
+            }
+            return esModule ? "\nexport {};" : "";
+        }(), resultSource = `// extracted by ${PLUGIN_NAME}`;
+        resultSource += this.hot && emit ? hotLoader(result, {
+            loaderContext: this,
+            options,
+            locals: locals
+        }) : result, dependencies.length > 0 && (parseMeta[PLUGIN_NAME] = JSON.stringify(dependencies)), callback(null, resultSource, void 0, data);
+    };
+    this.importModule(`${this.resourcePath}.webpack[javascript/auto]!=!!!${request}`, {
+        layer: options.layer,
+        publicPath: publicPathForExtract,
+        baseUri: `${BASE_URI}/`
+    }, (error, exports1)=>{
+        if (error) return void callback(error);
+        handleExports(exports1);
+    });
+}, css_extract_loader = function(content) {
+    if (this._compiler?.options?.experiments?.css && this._module && ("css" === this._module.type || "css/auto" === this._module.type || "css/global" === this._module.type || "css/module" === this._module.type)) return content;
+};
+for(var __webpack_i__ in exports.ABSOLUTE_PUBLIC_PATH = __webpack_exports__.ABSOLUTE_PUBLIC_PATH, exports.AUTO_PUBLIC_PATH = __webpack_exports__.AUTO_PUBLIC_PATH, exports.BASE_URI = __webpack_exports__.BASE_URI, exports.MODULE_TYPE = __webpack_exports__.MODULE_TYPE, exports.SINGLE_DOT_PATH_SEGMENT = __webpack_exports__.SINGLE_DOT_PATH_SEGMENT, exports.default = __webpack_exports__.default, exports.hotLoader = __webpack_exports__.hotLoader, exports.pitch = __webpack_exports__.pitch, __webpack_exports__)-1 === [
+    "ABSOLUTE_PUBLIC_PATH",
+    "AUTO_PUBLIC_PATH",
+    "BASE_URI",
+    "MODULE_TYPE",
+    "SINGLE_DOT_PATH_SEGMENT",
+    "default",
+    "hotLoader",
+    "pitch"
+].indexOf(__webpack_i__) && (exports[__webpack_i__] = __webpack_exports__[__webpack_i__]);
+Object.defineProperty(exports, '__esModule', {
+    value: !0
+});

package/dist/error/ConcurrentCompilationError.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/ConcurrentCompilationError.js
+ *
+ * MIT Licensed
+ * Author Maksim Nazarjev @acupofspirt
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+export default class ConcurrentCompilationError extends Error {
+    name: string;
+    message: string;
+    constructor();
+}

package/dist/exports.d.ts

@@ -0,0 +1,191 @@
+declare const rspackVersion: string;
+declare const version: string;
+export { rspackVersion, version };
+export type { Asset, AssetInfo, Assets, CompilationParams, LogEntry } from "./Compilation";
+export { Compilation } from "./Compilation";
+export { Compiler } from "./Compiler";
+export type { MultiCompilerOptions, MultiRspackOptions } from "./MultiCompiler";
+export { MultiCompiler } from "./MultiCompiler";
+import { RspackOptionsApply } from "./rspackOptionsApply";
+export { RspackOptionsApply, RspackOptionsApply as WebpackOptionsApply };
+export type { Chunk } from "./Chunk";
+export type { ChunkGroup } from "./ChunkGroup";
+export type { ResolveData, ResourceDataWithData } from "./Module";
+export { MultiStats } from "./MultiStats";
+export { Module } from "./Module";
+export { NormalModule } from "./NormalModule";
+export { ContextModule } from "./ContextModule";
+export { ConcatenatedModule } from "./ConcatenatedModule";
+export { ExternalModule } from "./ExternalModule";
+export type { NormalModuleFactory } from "./NormalModuleFactory";
+export type { default as ModuleGraph } from "./ModuleGraph";
+export { RuntimeGlobals } from "./RuntimeGlobals";
+export type { StatsAsset, StatsChunk, StatsCompilation, StatsError, StatsModule } from "./Stats";
+export { Stats } from "./Stats";
+export { RuntimeModule } from "./RuntimeModule";
+export { EntryDependency, Dependency, AsyncDependenciesBlock } from "@rspack/binding";
+export type { RspackError, RspackSeverity } from "./RspackError";
+import * as ModuleFilenameHelpers from "./lib/ModuleFilenameHelpers";
+export { ModuleFilenameHelpers };
+export { Template } from "./Template";
+export declare const WebpackError: ErrorConstructor;
+export type { Watching } from "./Watching";
+import sources = require("../compiled/webpack-sources");
+export { sources };
+import { applyRspackOptionsDefaults, getNormalizedRspackOptions } from "./config";
+type Config = {
+    getNormalizedRspackOptions: typeof getNormalizedRspackOptions;
+    applyRspackOptionsDefaults: typeof applyRspackOptionsDefaults;
+    getNormalizedWebpackOptions: typeof getNormalizedRspackOptions;
+    applyWebpackOptionsDefaults: typeof applyRspackOptionsDefaults;
+};
+export declare const config: Config;
+export type * from "./config";
+import { ValidationError } from "./util/validate";
+export { ValidationError };
+export declare const util: {
+    createHash: (algorithm: "debug" | "xxhash64" | "md4" | "native-md4" | (string & {}) | (new () => import("./util/hash").default)) => import("./util/hash").default;
+    cleverMerge: <First, Second>(first: First, second: Second) => First | Second | (First & Second);
+};
+export { default as EntryOptionPlugin } from "./lib/EntryOptionPlugin";
+export type { OutputFileSystem } from "./util/fs";
+export type { BannerPluginArgument } from "./builtin-plugin";
+export type { ProvidePluginOptions } from "./builtin-plugin";
+export type { DefinePluginOptions } from "./builtin-plugin";
+export type { ProgressPluginArgument } from "./builtin-plugin";
+export type { EntryOptions } from "./builtin-plugin";
+export { BannerPlugin } from "./builtin-plugin";
+export { IgnorePlugin, type IgnorePluginOptions } from "./builtin-plugin";
+export { ProvidePlugin } from "./builtin-plugin";
+export { DefinePlugin } from "./builtin-plugin";
+export { ProgressPlugin } from "./builtin-plugin";
+export { RstestPlugin } from "./builtin-plugin";
+export { EntryPlugin } from "./builtin-plugin";
+export { DynamicEntryPlugin } from "./builtin-plugin";
+export { ExternalsPlugin } from "./builtin-plugin";
+export { HotModuleReplacementPlugin } from "./builtin-plugin";
+export { NoEmitOnErrorsPlugin } from "./builtin-plugin";
+export { WarnCaseSensitiveModulesPlugin } from "./builtin-plugin";
+export { RuntimePlugin } from "./builtin-plugin";
+export { DllPlugin, type DllPluginOptions } from "./lib/DllPlugin";
+export { DllReferencePlugin, type DllReferencePluginOptions, type DllReferencePluginOptionsSourceType, type DllReferencePluginOptionsContent, type DllReferencePluginOptionsManifest } from "./lib/DllReferencePlugin";
+export { EnvironmentPlugin } from "./lib/EnvironmentPlugin";
+export { LoaderOptionsPlugin } from "./lib/LoaderOptionsPlugin";
+export { LoaderTargetPlugin } from "./lib/LoaderTargetPlugin";
+export { NormalModuleReplacementPlugin } from "./lib/NormalModuleReplacementPlugin";
+import { FetchCompileAsyncWasmPlugin, SubresourceIntegrityPlugin, lazyCompilationMiddleware } from "./builtin-plugin";
+interface Web {
+    FetchCompileAsyncWasmPlugin: typeof FetchCompileAsyncWasmPlugin;
+}
+export declare const web: Web;
+import { NodeTargetPlugin } from "./builtin-plugin";
+import NodeEnvironmentPlugin from "./node/NodeEnvironmentPlugin";
+import NodeTemplatePlugin from "./node/NodeTemplatePlugin";
+interface Node {
+    NodeTargetPlugin: typeof NodeTargetPlugin;
+    NodeTemplatePlugin: typeof NodeTemplatePlugin;
+    NodeEnvironmentPlugin: typeof NodeEnvironmentPlugin;
+}
+export declare const node: Node;
+import { ElectronTargetPlugin } from "./builtin-plugin";
+interface Electron {
+    ElectronTargetPlugin: typeof ElectronTargetPlugin;
+}
+export declare const electron: Electron;
+import { EnableLibraryPlugin } from "./builtin-plugin";
+interface Library {
+    EnableLibraryPlugin: typeof EnableLibraryPlugin;
+}
+export declare const library: Library;
+import { EnableWasmLoadingPlugin } from "./builtin-plugin";
+interface Wasm {
+    EnableWasmLoadingPlugin: typeof EnableWasmLoadingPlugin;
+}
+export declare const wasm: Wasm;
+import { EnableChunkLoadingPlugin, JavascriptModulesPlugin } from "./builtin-plugin";
+interface JavaScript {
+    EnableChunkLoadingPlugin: typeof EnableChunkLoadingPlugin;
+    JavascriptModulesPlugin: typeof JavascriptModulesPlugin;
+}
+export declare const javascript: JavaScript;
+import { WebWorkerTemplatePlugin } from "./builtin-plugin";
+interface Webworker {
+    WebWorkerTemplatePlugin: typeof WebWorkerTemplatePlugin;
+}
+export declare const webworker: Webworker;
+import { LimitChunkCountPlugin } from "./builtin-plugin";
+import { RuntimeChunkPlugin } from "./builtin-plugin";
+import { SplitChunksPlugin } from "./builtin-plugin";
+import { RemoveDuplicateModulesPlugin } from "./builtin-plugin";
+import { RsdoctorPlugin } from "./builtin-plugin";
+import { CssChunkingPlugin } from "./builtin-plugin";
+interface Optimize {
+    LimitChunkCountPlugin: typeof LimitChunkCountPlugin;
+    RuntimeChunkPlugin: typeof RuntimeChunkPlugin;
+    SplitChunksPlugin: typeof SplitChunksPlugin;
+}
+export declare const optimize: Optimize;
+import { ModuleFederationPlugin } from "./container/ModuleFederationPlugin";
+export type { ModuleFederationPluginOptions } from "./container/ModuleFederationPlugin";
+import { ModuleFederationPluginV1 } from "./container/ModuleFederationPluginV1";
+export type { ModuleFederationPluginV1Options } from "./container/ModuleFederationPluginV1";
+import { ContainerPlugin } from "./container/ContainerPlugin";
+import { ContainerReferencePlugin } from "./container/ContainerReferencePlugin";
+export type { ContainerPluginOptions, Exposes, ExposesConfig, ExposesItem, ExposesItems, ExposesObject } from "./container/ContainerPlugin";
+export type { ContainerReferencePluginOptions, Remotes, RemotesConfig, RemotesItem, RemotesItems, RemotesObject } from "./container/ContainerReferencePlugin";
+export declare const container: {
+    ContainerPlugin: typeof ContainerPlugin;
+    ContainerReferencePlugin: typeof ContainerReferencePlugin;
+    ModuleFederationPlugin: typeof ModuleFederationPlugin;
+    ModuleFederationPluginV1: typeof ModuleFederationPluginV1;
+};
+import { ConsumeSharedPlugin } from "./sharing/ConsumeSharedPlugin";
+import { ProvideSharedPlugin } from "./sharing/ProvideSharedPlugin";
+import { SharePlugin } from "./sharing/SharePlugin";
+export type { Consumes, ConsumesConfig, ConsumeSharedPluginOptions, ConsumesItem, ConsumesObject } from "./sharing/ConsumeSharedPlugin";
+export type { Provides, ProvidesConfig, ProvideSharedPluginOptions, ProvidesItem, ProvidesObject } from "./sharing/ProvideSharedPlugin";
+export type { Shared, SharedConfig, SharedItem, SharedObject, SharePluginOptions } from "./sharing/SharePlugin";
+export declare const sharing: {
+    ProvideSharedPlugin: typeof ProvideSharedPlugin;
+    ConsumeSharedPlugin: typeof ConsumeSharedPlugin;
+    SharePlugin: typeof SharePlugin;
+};
+export type { RsdoctorPluginData, RsdoctorPluginHooks } from "./builtin-plugin";
+export type { HtmlRspackPluginOptions } from "./builtin-plugin";
+export type { SwcJsMinimizerRspackPluginOptions } from "./builtin-plugin";
+export type { LightningCssMinimizerRspackPluginOptions } from "./builtin-plugin";
+export type { CircularDependencyRspackPluginOptions } from "./builtin-plugin";
+export type { CopyRspackPluginOptions } from "./builtin-plugin";
+export type { SourceMapDevToolPluginOptions } from "./builtin-plugin";
+export type { EvalDevToolModulePluginOptions } from "./builtin-plugin";
+export type { CssExtractRspackLoaderOptions, CssExtractRspackPluginOptions } from "./builtin-plugin";
+export { HtmlRspackPlugin } from "./builtin-plugin";
+export { SwcJsMinimizerRspackPlugin } from "./builtin-plugin";
+export { LightningCssMinimizerRspackPlugin } from "./builtin-plugin";
+export { CircularDependencyRspackPlugin } from "./builtin-plugin";
+export { CopyRspackPlugin } from "./builtin-plugin";
+export { SourceMapDevToolPlugin } from "./builtin-plugin";
+export { EvalSourceMapDevToolPlugin } from "./builtin-plugin";
+export { EvalDevToolModulePlugin } from "./builtin-plugin";
+export { CssExtractRspackPlugin } from "./builtin-plugin";
+export { ContextReplacementPlugin } from "./builtin-plugin";
+export type { SwcLoaderEnvConfig, SwcLoaderEsParserConfig, SwcLoaderJscConfig, SwcLoaderModuleConfig, SwcLoaderOptions, SwcLoaderParserConfig, SwcLoaderTransformConfig, SwcLoaderTsParserConfig } from "./builtin-loader/swc/index";
+export type { LoaderOptions as LightningcssLoaderOptions, FeatureOptions as LightningcssFeatureOptions } from "./builtin-loader/lightningcss/index";
+export type { SubresourceIntegrityPluginOptions } from "./builtin-plugin";
+import { minify, transform } from "./swc";
+interface Experiments {
+    globalTrace: {
+        register: (filter: string, layer: "chrome" | "logger", output: string) => Promise<void>;
+        cleanup: () => Promise<void>;
+    };
+    RemoveDuplicateModulesPlugin: typeof RemoveDuplicateModulesPlugin;
+    RsdoctorPlugin: typeof RsdoctorPlugin;
+    SubresourceIntegrityPlugin: typeof SubresourceIntegrityPlugin;
+    lazyCompilationMiddleware: typeof lazyCompilationMiddleware;
+    swc: {
+        transform: typeof transform;
+        minify: typeof minify;
+    };
+    CssChunkingPlugin: typeof CssChunkingPlugin;
+}
+export declare const experiments: Experiments;

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import * as rspackExports from "./exports";
+import { rspack as rspackFn } from "./rspack";
+type Rspack = typeof rspackFn & typeof rspackExports & {
+    rspack: Rspack;
+    webpack: Rspack;
+};
+declare const rspack: Rspack;
+export * from "./exports";
+export default rspack;
+export { rspack };