@rspack/core 0.6.2 → 0.6.3-canary-e0ce3b5-20240423104040

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

@@ -6,3 +6,4 @@ export { resolveRelay } from "./relay";
 export type { RelayOptions } from "./relay";
 export { resolvePluginImport } from "./pluginImport";
 export type { PluginImportOptions } from "./pluginImport";
+export type { SwcLoaderOptions, SwcLoaderEnvConfig, SwcLoaderJscConfig, SwcLoaderModuleConfig, SwcLoaderParserConfig, SwcLoaderEsParserConfig, SwcLoaderTsParserConfig, SwcLoaderTransformConfig } from "./types";

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

@@ -1,4 +1,4 @@
-import { RawPluginImportConfig } from "@rspack/binding";
+import type { RawPluginImportConfig } from "@rspack/binding";
 type PluginImportConfig = {
     libraryName: string;
     libraryDirectory?: string;
@@ -8,8 +8,8 @@ type PluginImportConfig = {
     styleLibraryDirectory?: string;
     camelToDashComponentName?: boolean;
     transformToDefaultImport?: boolean;
-    ignoreEsComponent?: Array<string>;
-    ignoreStyleComponent?: Array<string>;
+    ignoreEsComponent?: string[];
+    ignoreStyleComponent?: string[];
 };
 type PluginImportOptions = PluginImportConfig[] | undefined;
 declare function resolvePluginImport(pluginImport: PluginImportOptions): RawPluginImportConfig[] | undefined;

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

@@ -1,4 +1,4 @@
-import { RawReactOptions } from "@rspack/binding";
+import type { RawReactOptions } from "@rspack/binding";
 declare function resolveReact(react: ReactOptions): RawReactOptions;
 type ReactOptions = RawReactOptions | undefined;
 export { resolveReact };

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

@@ -1,4 +1,4 @@
-import { RawRelayConfig } from "@rspack/binding";
+import type { RawRelayConfig } from "@rspack/binding";
 type RelayOptions = boolean | RawRelayConfig | undefined;
 declare function resolveRelay(relay: RelayOptions, rootDir: string): RawRelayConfig | undefined;
 export { resolveRelay };

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

@@ -0,0 +1,462 @@
+/**
+ * Some types are modified from https://github.com/swc-project/swc/blob/16a38851/packages/types/index.ts#L647
+ * license at https://github.com/swc-project/swc/blob/main/LICENSE
+ */
+import type { ReactOptions } from "./react";
+import type { RelayOptions } from "./relay";
+import type { EmotionOptions } from "./emotion";
+import type { PluginImportOptions } from "./pluginImport";
+export type StyledComponentsOptions = {
+    displayName?: boolean;
+    ssr?: boolean;
+    fileName?: boolean;
+    meaninglessFileNames?: string[];
+    namespace?: string;
+    topLevelImportPaths?: string[];
+    transpileTemplateLiterals?: boolean;
+    minify?: boolean;
+    pure?: boolean;
+    cssProps?: boolean;
+};
+export type JscTarget = "es3" | "es5" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "esnext";
+export type SwcLoaderParserConfig = SwcLoaderTsParserConfig | SwcLoaderEsParserConfig;
+export interface SwcLoaderTsParserConfig {
+    syntax: "typescript";
+    /**
+     * Defaults to `false`.
+     */
+    tsx?: boolean;
+    /**
+     * Defaults to `false`.
+     */
+    decorators?: boolean;
+    /**
+     * Defaults to `false`
+     */
+    dynamicImport?: boolean;
+}
+export interface SwcLoaderEsParserConfig {
+    syntax: "ecmascript";
+    /**
+     * Defaults to false.
+     */
+    jsx?: boolean;
+    /**
+     * Defaults to `false`
+     */
+    functionBind?: boolean;
+    /**
+     * Defaults to `false`
+     */
+    decorators?: boolean;
+    /**
+     * Defaults to `false`
+     */
+    decoratorsBeforeExport?: boolean;
+    /**
+     * Defaults to `false`
+     */
+    exportDefaultFrom?: boolean;
+    /**
+     * Defaults to `false`
+     */
+    importAssertions?: boolean;
+}
+/**
+ *  - `import { DEBUG } from '@ember/env-flags';`
+ *  - `import { FEATURE_A, FEATURE_B } from '@ember/features';`
+ *
+ * See: https://github.com/swc-project/swc/issues/18#issuecomment-466272558
+ */
+export type ConstModulesConfig = {
+    globals?: {
+        [module: string]: {
+            [name: string]: string;
+        };
+    };
+};
+/**
+ * Options for inline-global pass.
+ */
+export interface GlobalPassOption {
+    /**
+     * Global variables that should be inlined with passed value.
+     *
+     * e.g. `{ __DEBUG__: true }`
+     */
+    vars?: Record<string, string>;
+    /**
+     * Names of environment variables that should be inlined with the value of corresponding env during build.
+     *
+     * Defaults to `["NODE_ENV", "SWC_ENV"]`
+     */
+    envs?: string[] | Record<string, string>;
+    /**
+     * Replaces typeof calls for passed variables with corresponding value
+     *
+     * e.g. `{ window: 'object' }`
+     */
+    typeofs?: Record<string, string>;
+}
+/**
+ * https://swc.rs/docs/configuring-swc.html#jsctransformoptimizerjsonify
+ */
+export type OptimizerConfig = {
+    /**
+     * https://swc.rs/docs/configuration/compilation#jsctransformoptimizersimplify
+     */
+    simplify?: boolean;
+    /**
+     * https://swc.rs/docs/configuring-swc.html#jsctransformoptimizerglobals
+     */
+    globals?: GlobalPassOption;
+    /**
+     * https://swc.rs/docs/configuring-swc.html#jsctransformoptimizerjsonify
+     */
+    jsonify?: {
+        minCost: number;
+    };
+};
+export interface SwcLoaderTransformConfig {
+    /**
+     * Effective only if `syntax` supports ƒ.
+     */
+    react?: ReactOptions;
+    constModules?: ConstModulesConfig;
+    /**
+     * Defaults to null, which skips optimizer pass.
+     */
+    optimizer?: OptimizerConfig;
+    /**
+     * https://swc.rs/docs/configuring-swc.html#jsctransformlegacydecorator
+     */
+    legacyDecorator?: boolean;
+    /**
+     * https://swc.rs/docs/configuring-swc.html#jsctransformdecoratormetadata
+     */
+    decoratorMetadata?: boolean;
+    /**
+     * https://swc.rs/docs/configuration/compilation#jsctransformdecoratorversion
+     */
+    decoratorVersion?: "2021-12" | "2022-03";
+    treatConstEnumAsEnum?: boolean;
+    useDefineForClassFields?: boolean;
+}
+export interface SwcLoaderEnvConfig {
+    mode?: "usage" | "entry";
+    debug?: boolean;
+    dynamicImport?: boolean;
+    loose?: boolean;
+    /**
+     * Transpiles the broken syntax to the closest non-broken modern syntax
+     * Defaults to false.
+     */
+    bugfixes?: boolean;
+    /**
+     * Skipped es features.
+     * e.g.)
+     *   - `core-js/modules/foo`
+     */
+    skip?: string[];
+    include?: string[];
+    exclude?: string[];
+    /**
+     * The version of the used core js.
+     */
+    coreJs?: string;
+    targets?: any;
+    path?: string;
+    shippedProposals?: boolean;
+    /**
+     * Enable all transforms
+     */
+    forceAllTransforms?: boolean;
+}
+export interface SwcLoaderJscConfig {
+    loose?: boolean;
+    /**
+     * Defaults to EsParserConfig
+     */
+    parser?: SwcLoaderParserConfig;
+    transform?: SwcLoaderTransformConfig;
+    /**
+     * Use `@swc/helpers` instead of inline helpers.
+     */
+    externalHelpers?: boolean;
+    /**
+     * Defaults to `es3` (which enabled **all** pass).
+     */
+    target?: JscTarget;
+    /**
+     * Keep class names.
+     */
+    keepClassNames?: boolean;
+    /**
+     * This is experimental, and can be removed without a major version bump.
+     */
+    experimental?: {
+        optimizeHygiene?: boolean;
+        /**
+         * Preserve `with` in imports and exports.
+         */
+        keepImportAttributes?: boolean;
+        /**
+         * Use `assert` instead of `with` for imports and exports.
+         * This option only works when `keepImportAttributes` is `true`.
+         */
+        emitAssertForImportAttributes?: boolean;
+        /**
+         * Specify the location where SWC stores its intermediate cache files.
+         * Currently only transform plugin uses this. If not specified, SWC will
+         * create `.swc` directories.
+         */
+        cacheRoot?: string;
+        /**
+         * List of custom transform plugins written in WebAssembly.
+         * First parameter of tuple indicates the name of the plugin - it can be either
+         * a name of the npm package can be resolved, or absolute path to .wasm binary.
+         *
+         * Second parameter of tuple is JSON based configuration for the plugin.
+         */
+        plugins?: Array<[string, Record<string, any>]>;
+        /**
+         * Disable builtin transforms. If enabled, only Wasm plugins are used.
+         */
+        disableBuiltinTransformsForInternalTesting?: boolean;
+    };
+    baseUrl?: string;
+    paths?: {
+        [from: string]: [string];
+    };
+    preserveAllComments?: boolean;
+}
+export type SwcLoaderModuleConfig = Es6Config | CommonJsConfig | UmdConfig | AmdConfig | NodeNextConfig | SystemjsConfig;
+export interface BaseModuleConfig {
+    /**
+     * By default, when using exports with babel a non-enumerable `__esModule`
+     * property is exported. In some cases this property is used to determine
+     * if the import is the default export or if it contains the default export.
+     *
+     * In order to prevent the __esModule property from being exported, you
+     *  can set the strict option to true.
+     *
+     * Defaults to `false`.
+     */
+    strict?: boolean;
+    /**
+     * Emits 'use strict' directive.
+     *
+     * Defaults to `true`.
+     */
+    strictMode?: boolean;
+    /**
+     * Changes Babel's compiled import statements to be lazily evaluated when their imported bindings are used for the first time.
+     *
+     * This can improve initial load time of your module because evaluating dependencies up
+     *  front is sometimes entirely un-necessary. This is especially the case when implementing
+     *  a library module.
+     *
+     *
+     * The value of `lazy` has a few possible effects:
+     *
+     *  - `false` - No lazy initialization of any imported module.
+     *  - `true` - Do not lazy-initialize local `./foo` imports, but lazy-init `foo` dependencies.
+     *
+     * Local paths are much more likely to have circular dependencies, which may break if loaded lazily,
+     * so they are not lazy by default, whereas dependencies between independent modules are rarely cyclical.
+     *
+     *  - `Array<string>` - Lazy-initialize all imports with source matching one of the given strings.
+     *
+     * -----
+     *
+     * The two cases where imports can never be lazy are:
+     *
+     *  - `import "foo";`
+     *
+     * Side-effect imports are automatically non-lazy since their very existence means
+     *  that there is no binding to later kick off initialization.
+     *
+     *  - `export * from "foo"`
+     *
+     * Re-exporting all names requires up-front execution because otherwise there is no
+     * way to know what names need to be exported.
+     *
+     * Defaults to `false`.
+     */
+    lazy?: boolean | string[];
+    /**
+     * @deprecated  Use the `importInterop` option instead.
+     *
+     * By default, when using exports with swc a non-enumerable __esModule property is exported.
+     * This property is then used to determine if the import is the default export or if
+     *  it contains the default export.
+     *
+     * In cases where the auto-unwrapping of default is not needed, you can set the noInterop option
+     *  to true to avoid the usage of the interopRequireDefault helper (shown in inline form above).
+     *
+     * Defaults to `false`.
+     */
+    noInterop?: boolean;
+    /**
+     * Defaults to `swc`.
+     *
+     * CommonJS modules and ECMAScript modules are not fully compatible.
+     * However, compilers, bundlers and JavaScript runtimes developed different strategies
+     * to make them work together as well as possible.
+     *
+     * - `swc` (alias: `babel`)
+     *
+     * When using exports with `swc` a non-enumerable `__esModule` property is exported
+     * This property is then used to determine if the import is the default export
+     * or if it contains the default export.
+     *
+     * ```javascript
+     * import foo from "foo";
+     * import { bar } from "bar";
+     * foo;
+     * bar;
+     *
+     * // Is compiled to ...
+     *
+     * "use strict";
+     *
+     * function _interop_require_default(obj) {
+     *   return obj && obj.__esModule ? obj : { default: obj };
+     * }
+     *
+     * var _foo = _interop_require_default(require("foo"));
+     * var _bar = require("bar");
+     *
+     * _foo.default;
+     * _bar.bar;
+     * ```
+     *
+     * When this import interop is used, if both the imported and the importer module are compiled
+     * with swc they behave as if none of them was compiled.
+     *
+     * This is the default behavior.
+     *
+     * - `node`
+     *
+     * When importing CommonJS files (either directly written in CommonJS, or generated with a compiler)
+     * Node.js always binds the `default` export to the value of `module.exports`.
+     *
+     * ```javascript
+     * import foo from "foo";
+     * import { bar } from "bar";
+     * foo;
+     * bar;
+     *
+     * // Is compiled to ...
+     *
+     * "use strict";
+     *
+     * var _foo = require("foo");
+     * var _bar = require("bar");
+     *
+     * _foo;
+     * _bar.bar;
+     * ```
+     * This is not exactly the same as what Node.js does since swc allows accessing any property of `module.exports`
+     * as a named export, while Node.js only allows importing statically analyzable properties of `module.exports`.
+     * However, any import working in Node.js will also work when compiled with swc using `importInterop: "node"`.
+     *
+     * - `none`
+     *
+     * If you know that the imported file has been transformed with a compiler that stores the `default` export on
+     * `exports.default` (such as swc or Babel), you can safely omit the `_interop_require_default` helper.
+     *
+     * ```javascript
+     * import foo from "foo";
+     * import { bar } from "bar";
+     * foo;
+     * bar;
+     *
+     * // Is compiled to ...
+     *
+     * "use strict";
+     *
+     * var _foo = require("foo");
+     * var _bar = require("bar");
+     *
+     * _foo.default;
+     * _bar.bar;
+     * ```
+     */
+    importInterop?: "swc" | "babel" | "node" | "none";
+    /**
+     * Emits `cjs-module-lexer` annotation
+     * `cjs-module-lexer` is used in Node.js core for detecting the named exports available when importing a CJS module into ESM.
+     * swc will emit `cjs-module-lexer` detectable annotation with this option enabled.
+     *
+     * Defaults to `true` if import_interop is Node, else `false`
+     */
+    exportInteropAnnotation?: boolean;
+    /**
+     * If set to true, dynamic imports will be preserved.
+     */
+    ignoreDynamic?: boolean;
+    allowTopLevelThis?: boolean;
+    preserveImportMeta?: boolean;
+}
+export interface Es6Config extends BaseModuleConfig {
+    type: "es6";
+}
+export interface NodeNextConfig extends BaseModuleConfig {
+    type: "nodenext";
+}
+export interface CommonJsConfig extends BaseModuleConfig {
+    type: "commonjs";
+}
+export interface UmdConfig extends BaseModuleConfig {
+    type: "umd";
+    globals?: {
+        [key: string]: string;
+    };
+}
+export interface AmdConfig extends BaseModuleConfig {
+    type: "amd";
+    moduleId?: string;
+}
+export interface SystemjsConfig {
+    type: "systemjs";
+    allowTopLevelThis?: boolean;
+}
+export type SwcLoaderOptions = {
+    /**
+     * Note: The type is string because it follows rust's regex syntax.
+     */
+    test?: string | string[];
+    /**
+     * Note: The type is string because it follows rust's regex syntax.
+     */
+    exclude?: string | string[];
+    env?: SwcLoaderEnvConfig;
+    jsc?: SwcLoaderJscConfig;
+    module?: SwcLoaderModuleConfig;
+    minify?: boolean;
+    /**
+     * - true to generate a sourcemap for the code and include it in the result object.
+     * - "inline" to generate a sourcemap and append it as a data URL to the end of the code, but not include it in the result object.
+     *
+     * `swc-cli` overloads some of these to also affect how maps are written to disk:
+     *
+     * - true will write the map to a .map file on disk
+     * - "inline" will write the file directly, so it will have a data: containing the map
+     * - Note: These options are bit weird, so it may make the most sense to just use true
+     *  and handle the rest in your own code, depending on your use case.
+     */
+    sourceMaps?: boolean;
+    inlineSourcesContent?: boolean;
+    isModule?: boolean | "unknown";
+    /**
+     * Experimental features provided by Rspack.
+     * @experimental
+     */
+    rspackExperiments?: {
+        relay?: RelayOptions;
+        emotion?: EmotionOptions;
+        import?: PluginImportOptions;
+        styledComponents?: StyledComponentsOptions;
+    };
+};

package/dist/builtin-loader/swc/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/container/ModuleFederationPlugin.js

@@ -4,6 +4,7 @@ exports.ModuleFederationPlugin = void 0;
 const config_1 = require("../config");
 const options_1 = require("./options");
 const validate_1 = require("../util/validate");
+const ModuleFederationRuntimePlugin_1 = require("./ModuleFederationRuntimePlugin");
 class ModuleFederationPlugin {
     constructor(_options) {
         this._options = _options;
@@ -19,6 +20,7 @@ class ModuleFederationPlugin {
         compiler.hooks.afterPlugins.tap(ModuleFederationPlugin.name, () => {
             new webpack.EntryPlugin(compiler.context, getDefaultEntryRuntime(paths, this._options, compiler), { name: undefined }).apply(compiler);
         });
+        new ModuleFederationRuntimePlugin_1.ModuleFederationRuntimePlugin().apply(compiler);
         new webpack.container.ModuleFederationPluginV1({
             ...this._options,
             enhanced: true

package/dist/container/ModuleFederationRuntimePlugin.d.ts

@@ -0,0 +1,10 @@
+import { BuiltinPluginName } from "@rspack/binding";
+export declare const ModuleFederationRuntimePlugin: {
+    new (): {
+        name: BuiltinPluginName;
+        _options: void;
+        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" | undefined;
+        raw(): import("@rspack/binding").BuiltinPlugin;
+        apply(compiler: import("../Compiler").Compiler): void;
+    };
+};

package/dist/container/ModuleFederationRuntimePlugin.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleFederationRuntimePlugin = void 0;
+const binding_1 = require("@rspack/binding");
+const base_1 = require("../builtin-plugin/base");
+exports.ModuleFederationRuntimePlugin = (0, base_1.create)(binding_1.BuiltinPluginName.ModuleFederationRuntimePlugin, () => { });

package/dist/container/default.runtime.js

@@ -3,8 +3,9 @@
 var __module_federation_bundler_runtime__, __module_federation_runtime_plugins__, __module_federation_remote_infos__, __module_federation_container_name__;
 module.exports = function () {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
-    if (__webpack_require__.initializeSharingData ||
-        __webpack_require__.initializeExposesData) {
+    if ((__webpack_require__.initializeSharingData ||
+        __webpack_require__.initializeExposesData) &&
+        __webpack_require__.federation) {
         const override = (obj, key, value) => {
             if (!obj)
                 return;
@@ -36,7 +37,10 @@ module.exports = function () {
         const initializeSharingInitPromises = [];
         const initializeSharingInitTokens = [];
         const containerShareScope = (_l = __webpack_require__.initializeExposesData) === null || _l === void 0 ? void 0 : _l.shareScope;
-        early(__webpack_require__, "federation", () => __module_federation_bundler_runtime__);
+        for (const key in __module_federation_bundler_runtime__) {
+            __webpack_require__.federation[key] =
+                __module_federation_bundler_runtime__[key];
+        }
         early(__webpack_require__.federation, "consumesLoadingModuleToHandlerMapping", () => {
             const consumesLoadingModuleToHandlerMapping = {};
             for (let [moduleId, data] of Object.entries(consumesLoadingModuleToConsumeDataMapping)) {
@@ -106,11 +110,11 @@ module.exports = function () {
             }
             return idToRemoteMap;
         });
-        override(__webpack_require__, "S", __module_federation_bundler_runtime__.bundlerRuntime.S);
-        if (__module_federation_bundler_runtime__.attachShareScopeMap) {
-            __module_federation_bundler_runtime__.attachShareScopeMap(__webpack_require__);
+        override(__webpack_require__, "S", __webpack_require__.federation.bundlerRuntime.S);
+        if (__webpack_require__.federation.attachShareScopeMap) {
+            __webpack_require__.federation.attachShareScopeMap(__webpack_require__);
         }
-        override(__webpack_require__.f, "remotes", (chunkId, promises) => __module_federation_bundler_runtime__.bundlerRuntime.remotes({
+        override(__webpack_require__.f, "remotes", (chunkId, promises) => __webpack_require__.federation.bundlerRuntime.remotes({
             chunkId,
             promises,
             chunkMapping: remotesLoadingChunkMapping,
@@ -120,7 +124,7 @@ module.exports = function () {
                 .idToRemoteMap,
             webpackRequire: __webpack_require__
         }));
-        override(__webpack_require__.f, "consumes", (chunkId, promises) => __module_federation_bundler_runtime__.bundlerRuntime.consumes({
+        override(__webpack_require__.f, "consumes", (chunkId, promises) => __webpack_require__.federation.bundlerRuntime.consumes({
             chunkId,
             promises,
             chunkMapping: consumesLoadingChunkMapping,
@@ -128,14 +132,14 @@ module.exports = function () {
             installedModules: consumesLoadinginstalledModules,
             webpackRequire: __webpack_require__
         }));
-        override(__webpack_require__, "I", (name, initScope) => __module_federation_bundler_runtime__.bundlerRuntime.I({
+        override(__webpack_require__, "I", (name, initScope) => __webpack_require__.federation.bundlerRuntime.I({
             shareScopeName: name,
             initScope,
             initPromises: initializeSharingInitPromises,
             initTokens: initializeSharingInitTokens,
             webpackRequire: __webpack_require__
         }));
-        override(__webpack_require__, "initContainer", (shareScope, initScope, remoteEntryInitOptions) => __module_federation_bundler_runtime__.bundlerRuntime.initContainerEntry({
+        override(__webpack_require__, "initContainer", (shareScope, initScope, remoteEntryInitOptions) => __webpack_require__.federation.bundlerRuntime.initContainerEntry({
             shareScope,
             initScope,
             remoteEntryInitOptions,
@@ -153,14 +157,14 @@ module.exports = function () {
             __webpack_require__.R = undefined;
             return getScope;
         });
-        __module_federation_bundler_runtime__.instance =
-            __module_federation_bundler_runtime__.runtime.init(__module_federation_bundler_runtime__.initOptions);
+        __webpack_require__.federation.instance =
+            __webpack_require__.federation.runtime.init(__webpack_require__.federation.initOptions);
         if ((_m = __webpack_require__.consumesLoadingData) === null || _m === void 0 ? void 0 : _m.initialConsumes) {
-            __module_federation_bundler_runtime__.bundlerRuntime.installInitialConsumes({
+            __webpack_require__.federation.bundlerRuntime.installInitialConsumes({
                 webpackRequire: __webpack_require__,
                 installedModules: consumesLoadinginstalledModules,
                 initialConsumes: __webpack_require__.consumesLoadingData.initialConsumes,
-                moduleToHandlerMapping: __module_federation_bundler_runtime__.consumesLoadingModuleToHandlerMapping
+                moduleToHandlerMapping: __webpack_require__.federation.consumesLoadingModuleToHandlerMapping
             });
         }
     }

package/dist/exports.d.ts

@@ -14,9 +14,9 @@ export { MultiStats } from "./MultiStats";
 export type { ChunkGroup } from "./ChunkGroup";
 export type { NormalModuleFactory } from "./NormalModuleFactory";
 export { NormalModule } from "./NormalModule";
-declare const ModuleFilenameHelpers: any;
+import * as ModuleFilenameHelpers from "./lib/ModuleFilenameHelpers";
 export { ModuleFilenameHelpers };
-declare const Template: any;
+import Template = require("./Template");
 export { Template };
 export declare const WebpackError: ErrorConstructor;
 export type { Watching } from "./Watching";
@@ -129,3 +129,4 @@ export type { SourceMapDevToolPluginOptions } from "./builtin-plugin";
 export { EvalDevToolModulePlugin } from "./builtin-plugin";
 export type { EvalDevToolModulePluginOptions } from "./builtin-plugin";
 export { CssExtractRspackPlugin } from "./builtin-plugin";
+export type { SwcLoaderOptions, SwcLoaderEnvConfig, SwcLoaderJscConfig, SwcLoaderModuleConfig, SwcLoaderParserConfig, SwcLoaderEsParserConfig, SwcLoaderTsParserConfig, SwcLoaderTransformConfig } from "./builtin-loader/swc/index";

package/dist/exports.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -25,7 +48,7 @@ Object.defineProperty(exports, "MultiStats", { enumerable: true, get: function (
 var NormalModule_1 = require("./NormalModule");
 Object.defineProperty(exports, "NormalModule", { enumerable: true, get: function () { return NormalModule_1.NormalModule; } });
 // API extractor not working with some re-exports, see: https://github.com/microsoft/fluentui/issues/20694
-const ModuleFilenameHelpers = require("./lib/ModuleFilenameHelpers");
+const ModuleFilenameHelpers = __importStar(require("./lib/ModuleFilenameHelpers"));
 exports.ModuleFilenameHelpers = ModuleFilenameHelpers;
 // API extractor not working with some re-exports, see: https://github.com/microsoft/fluentui/issues/20694
 const Template = require("./Template");

package/dist/loader-runner/index.js

@@ -520,7 +520,7 @@ async function runLoaders(compiler, rawContext) {
                 resolve({
                     content: (0, util_1.isNil)(content) ? undefined : (0, util_1.toBuffer)(content),
                     sourceMap: (0, util_1.serializeObject)(sourceMap),
-                    additionalData: (0, util_1.serializeObject)(additionalData),
+                    additionalData,
                     buildDependencies,
                     cacheable,
                     fileDependencies,
@@ -542,7 +542,7 @@ async function runLoaders(compiler, rawContext) {
                     : (0, util_1.toObject)(rawContext.sourceMap),
                 (0, util_1.isNil)(rawContext.additionalData)
                     ? undefined
-                    : (0, util_1.toObject)(rawContext.additionalData)
+                    : rawContext.additionalData
             ], (err, result) => {
                 if (err) {
                     return reject(err);
@@ -551,7 +551,7 @@ async function runLoaders(compiler, rawContext) {
                 resolve({
                     content: (0, util_1.isNil)(content) ? undefined : (0, util_1.toBuffer)(content),
                     sourceMap: (0, util_1.serializeObject)(sourceMap),
-                    additionalData: (0, util_1.serializeObject)(additionalData),
+                    additionalData,
                     buildDependencies,
                     cacheable,
                     fileDependencies,

package/dist/loader-runner/loadLoader.js

@@ -54,7 +54,7 @@ module.exports = function loadLoader(loader, callback) {
                         Object.assign({}, this.__internal__context, {
                             content: isNil(content) ? undefined : toBuffer(content),
                             sourceMap: serializeObject(sourceMap),
-                            additionalData: serializeObject(additionalData)
+                            additionalData
                         }));
                         // @ts-expect-error
                         this.__internal__context.additionalDataExternal =
@@ -69,9 +69,7 @@ module.exports = function loadLoader(loader, callback) {
                         context.buildDependencies.forEach(this.addBuildDependency);
                         callback(null, context.content, isNil(context.sourceMap)
                             ? undefined
-                            : toObject(context.sourceMap), isNil(context.additionalData)
-                            ? undefined
-                            : toObject(context.additionalData));
+                            : toObject(context.sourceMap), isNil(context.additionalData) ? undefined : context.additionalData);
                         // @ts-expect-error
                         this._compilation.__internal__pushNativeDiagnostics(context.diagnosticsExternal);
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/core",
-  "version": "0.6.2",
+  "version": "0.6.3-canary-e0ce3b5-20240423104040",
   "webpackVersion": "5.75.0",
   "license": "MIT",
   "description": "A Fast Rust-based Web Bundler",
@@ -60,8 +60,8 @@
     "styled-components": "^6.0.8",
     "terser": "5.27.2",
     "wast-loader": "^1.11.4",
-    "@rspack/core": "0.6.2",
-    "@rspack/plugin-minify": "^0.6.2"
+    "@rspack/plugin-minify": "^0.6.3-canary-e0ce3b5-20240423104040",
+    "@rspack/core": "0.6.3-canary-e0ce3b5-20240423104040"
   },
   "dependencies": {
     "@module-federation/runtime-tools": "0.1.6",
@@ -76,7 +76,7 @@
     "webpack-sources": "3.2.3",
     "zod": "^3.21.4",
     "zod-validation-error": "1.3.1",
-    "@rspack/binding": "0.6.2"
+    "@rspack/binding": "0.6.3-canary-e0ce3b5-20240423104040"
   },
   "peerDependencies": {
     "@swc/helpers": ">=0.5.1"