@rspack/core 1.0.0-alpha.2 → 1.0.0-alpha.4

package/dist/sharing/SharePlugin.d.ts

@@ -1,4 +1,4 @@
-import { Compiler } from "../Compiler";
+import type { Compiler } from "../Compiler";
 export type SharePluginOptions = {
     shareScope?: string;
     shared: Shared;

package/dist/sharing/ShareRuntimePlugin.d.ts

@@ -1,5 +1,5 @@
-import { BuiltinPlugin, BuiltinPluginName } from "@rspack/binding";
-import { Compiler } from "../Compiler";
+import { type BuiltinPlugin, BuiltinPluginName } from "@rspack/binding";
+import type { Compiler } from "../Compiler";
 import { RspackBuiltinPlugin } from "../builtin-plugin/base";
 export declare class ShareRuntimePlugin extends RspackBuiltinPlugin {
     private enhanced;

package/dist/stats/DefaultStatsFactoryPlugin.js

@@ -57,22 +57,14 @@ const ITEM_NAMES = {
     "module.issuerPath[]": "moduleIssuer",
     "module.reasons[]": "moduleReason",
     "module.modules[]": "module",
-    "module.children[]": "module"
-    // "moduleTrace[]": "moduleTraceItem",
+    "module.children[]": "module",
+    "moduleTrace[]": "moduleTraceItem"
     // "moduleTraceItem.dependencies[]": "moduleTraceDependency"
 };
-// const MERGER: Record<
-// 	string,
-// 	(
-// 		items: {
-// 			[key: string]: any;
-// 			name: string;
-// 		}[]
-// 	) => any
-// > = {
-// 	"compilation.entrypoints": mergeToObject,
-// 	"compilation.namedChunkGroups": mergeToObject
-// };
+const MERGER = {
+    "compilation.entrypoints": statsFactoryUtils_1.mergeToObject,
+    "compilation.namedChunkGroups": statsFactoryUtils_1.mergeToObject
+};
 const ASSETS_GROUPERS = {
     _: (groupConfigs, context, options) => {
         const groupByFlag = (name, exclude) => {
@@ -149,10 +141,74 @@ const ASSETS_GROUPERS = {
                 }
             });
         }
+    },
+    groupAssetsByInfo: groupConfigs => {
+        const groupByAssetInfoFlag = (name) => {
+            groupConfigs.push({
+                getKeys: asset => {
+                    return asset.info && asset.info[name] ? ["1"] : undefined;
+                },
+                // @ts-expect-error
+                createGroup: (key, children) => {
+                    return {
+                        type: "assets by info",
+                        info: {
+                            [name]: !!key
+                        },
+                        children,
+                        ...(0, statsFactoryUtils_1.assetGroup)(children)
+                    };
+                }
+            });
+        };
+        groupByAssetInfoFlag("immutable");
+        groupByAssetInfoFlag("development");
+        groupByAssetInfoFlag("hotModuleReplacement");
+    },
+    groupAssetsByChunk: groupConfigs => {
+        const groupByNames = (name) => {
+            groupConfigs.push({
+                getKeys: asset => {
+                    return asset[name];
+                },
+                // @ts-expect-error
+                createGroup: (key, children) => {
+                    return {
+                        type: "assets by chunk",
+                        [name]: [key],
+                        children,
+                        ...(0, statsFactoryUtils_1.assetGroup)(children)
+                    };
+                }
+            });
+        };
+        groupByNames("chunkNames");
+        // groupByNames("auxiliaryChunkNames");
+        // groupByNames("chunkIdHints");
+        // groupByNames("auxiliaryChunkIdHints");
+    },
+    excludeAssets: (groupConfigs, context, { excludeAssets }) => {
+        groupConfigs.push({
+            getKeys: asset => {
+                const ident = asset.name;
+                const excluded = excludeAssets.some(fn => fn(ident, asset));
+                if (excluded)
+                    return ["excluded"];
+            },
+            getOptions: () => ({
+                groupChildren: false,
+                force: true
+            }),
+            // @ts-expect-error
+            createGroup: (key, children, assets) => ({
+                type: "hidden assets",
+                filteredChildren: assets.length,
+                ...(0, statsFactoryUtils_1.assetGroup)(children)
+            })
+        });
     }
-    // not support groupAssetsByInfo / groupAssetsByChunk / excludeAssets
 };
-const MODULES_GROUPERS = (_type) => ({
+const MODULES_GROUPERS = (type) => ({
     _: (groupConfigs, context, options) => {
         const groupByFlag = (name, type, exclude) => {
             groupConfigs.push({
@@ -176,7 +232,7 @@ const MODULES_GROUPERS = (_type) => ({
                 }
             });
         };
-        const { groupModulesByCacheStatus, groupModulesByAttributes, groupModulesByType } = options;
+        const { groupModulesByCacheStatus, groupModulesByAttributes, groupModulesByType, groupModulesByPath, groupModulesByExtension } = options;
         if (groupModulesByAttributes) {
             groupByFlag("errors", "modules with errors");
             groupByFlag("warnings", "modules with warnings");
@@ -228,9 +284,76 @@ const MODULES_GROUPERS = (_type) => ({
                 }
             });
         }
-        // not support groupModulesByLayer / groupModulesByPath / groupModulesByExtension
+        // not support groupModulesByLayer
+        if (groupModulesByPath || groupModulesByExtension) {
+            groupConfigs.push({
+                getKeys: module => {
+                    if (!module.name)
+                        return;
+                    const resource = (0, identifier_1.parseResource)(module.name.split("!").pop()).path;
+                    const dataUrl = /^data:[^,;]+/.exec(resource);
+                    if (dataUrl)
+                        return [dataUrl[0]];
+                    const extensionMatch = groupModulesByExtension && GROUP_EXTENSION_REGEXP.exec(resource);
+                    const extension = extensionMatch ? extensionMatch[1] : "";
+                    const pathMatch = groupModulesByPath && GROUP_PATH_REGEXP.exec(resource);
+                    const path = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
+                    const keys = [];
+                    if (groupModulesByPath) {
+                        if (extension)
+                            keys.push(path.length
+                                ? `${path.join("/")}/*${extension}`
+                                : `*${extension}`);
+                        while (path.length > 0) {
+                            keys.push(path.join("/") + "/");
+                            path.pop();
+                        }
+                    }
+                    else {
+                        if (extension)
+                            keys.push(`*${extension}`);
+                    }
+                    return keys;
+                },
+                // @ts-expect-error
+                createGroup: (key, children, modules) => {
+                    const isDataUrl = key.startsWith("data:");
+                    return {
+                        type: isDataUrl
+                            ? "modules by mime type"
+                            : groupModulesByPath
+                                ? "modules by path"
+                                : "modules by extension",
+                        name: isDataUrl ? key.slice(/* 'data:'.length */ 5) : key,
+                        children,
+                        ...(0, statsFactoryUtils_1.moduleGroup)(children)
+                    };
+                }
+            });
+        }
+    },
+    excludeModules: (groupConfigs, context, { excludeModules }) => {
+        groupConfigs.push({
+            getKeys: module => {
+                const name = module.name;
+                if (name) {
+                    const excluded = excludeModules.some(fn => fn(name, module, type));
+                    if (excluded)
+                        return ["1"];
+                }
+            },
+            getOptions: () => ({
+                groupChildren: false,
+                force: true
+            }),
+            // @ts-expect-error
+            createGroup: (key, children, modules) => ({
+                type: "hidden modules",
+                filteredChildren: children.length,
+                ...(0, statsFactoryUtils_1.moduleGroup)(children)
+            })
+        });
     }
-    // not support excludeModules
 });
 const RESULT_GROUPERS = {
     "compilation.assets": ASSETS_GROUPERS,
@@ -295,6 +418,31 @@ const SORTERS = {
         }
     }
 };
+const EXTRACT_ERROR = {
+    _: (object, error) => {
+        object.message = error.message;
+        object.chunkName = error.chunkName;
+        object.chunkEntry = error.chunkEntry;
+        object.chunkInitial = error.chunkInitial;
+        object.file = error.file;
+        object.moduleIdentifier = error.moduleIdentifier;
+        object.moduleName = error.moduleName;
+    },
+    ids: (object, error) => {
+        object.chunkId = error.chunkId;
+        object.moduleId = error.moduleId;
+    },
+    moduleTrace: (object, error, context, _, factory) => {
+        const { type } = context;
+        object.moduleTrace = factory.create(`${type}.moduleTrace`, error.moduleTrace, context);
+    },
+    errorDetails: (object, error) => {
+        object.details = error.details;
+    },
+    errorStack: (object, error) => {
+        object.stack = error.stack;
+    }
+};
 const SIMPLE_EXTRACTORS = {
     compilation: {
         _: (object, compilation, context, options) => {
@@ -487,7 +635,7 @@ const SIMPLE_EXTRACTORS = {
                 // compilationFileToChunks
                 // compilationAuxiliaryFileToChunks
             });
-            const limited = (0, statsFactoryUtils_1.spaceLimited)(groupedAssets, options.assetsSpace || Infinity);
+            const limited = (0, statsFactoryUtils_1.spaceLimited)(groupedAssets, options.assetsSpace || Number.POSITIVE_INFINITY);
             // object.filteredAssets = limited.filteredChildren;
             // const limited = spaceLimited(groupedAssets, options.assetsSpace);
             object.assets = limited.children;
@@ -509,35 +657,46 @@ const SIMPLE_EXTRACTORS = {
             object.modules = limited.children;
             object.filteredModules = limited.filteredChildren;
         },
-        entrypoints: (object, compilation, context, { chunkGroupAuxiliary, chunkGroupChildren }, _factory) => {
-            // const { type } = context;
+        entrypoints: (object, compilation, context, { entrypoints, chunkGroups, chunkGroupAuxiliary, chunkGroupChildren }, factory) => {
+            const { type } = context;
             const array = context
                 .getInner(compilation)
-                .getEntrypoints(chunkGroupAuxiliary, chunkGroupChildren);
-            // object.entrypoints = factory.create(
-            // 	`${type}.entrypoints`,
-            // 	array,
-            // 	context
-            // );
-            object.entrypoints = array.reduce((acc, cur) => {
-                acc[cur.name] = cur;
-                return acc;
+                .getEntrypoints(chunkGroupAuxiliary, chunkGroupChildren)
+                .map(entrypoint => ({
+                name: entrypoint.name,
+                chunkGroup: entrypoint
+            }));
+            const chunks = Array.from(compilation.chunks).reduce((res, chunk) => {
+                res[chunk.id] = chunk;
+                return res;
             }, {});
+            if (entrypoints === "auto" && !chunkGroups) {
+                if (array.length > 5)
+                    return;
+                if (!chunkGroupChildren &&
+                    array.every(({ chunkGroup }) => {
+                        if (chunkGroup.chunks.length !== 1)
+                            return false;
+                        const chunk = chunks[chunkGroup.chunks[0]];
+                        return (chunk &&
+                            chunk.files.size === 1 &&
+                            (!chunkGroupAuxiliary || chunk.auxiliaryFiles.size === 0));
+                    })) {
+                    return;
+                }
+            }
+            object.entrypoints = factory.create(`${type}.entrypoints`, array, context);
         },
         chunkGroups: (object, compilation, context, { chunkGroupAuxiliary, chunkGroupChildren }, factory) => {
-            // const { type } = context;
+            const { type } = context;
             const namedChunkGroups = context
                 .getInner(compilation)
-                .getNamedChunkGroups(chunkGroupAuxiliary, chunkGroupChildren);
-            // object.namedChunkGroups = factory.create(
-            // 	`${type}.namedChunkGroups`,
-            // 	namedChunkGroups,
-            // 	context
-            // );
-            object.namedChunkGroups = namedChunkGroups.reduce((acc, cur) => {
-                acc[cur.name] = cur;
-                return acc;
-            }, {});
+                .getNamedChunkGroups(chunkGroupAuxiliary, chunkGroupChildren)
+                .map(cg => ({
+                name: cg.name,
+                chunkGroup: cg
+            }));
+            object.namedChunkGroups = factory.create(`${type}.namedChunkGroups`, namedChunkGroups, context);
         },
         errors: (object, compilation, context, _options, _factory) => {
             const { cachedGetErrors } = context;
@@ -571,15 +730,39 @@ const SIMPLE_EXTRACTORS = {
                 ...asset.info,
                 related: Object.fromEntries(asset.info.related.map(i => [i.name, i.value]))
             };
+            // - comparedForEmit
+            // - cached
             Object.assign(object, factory.create(`${context.type}$visible`, asset, context));
         }
     },
     asset$visible: {
         _: (object, asset) => {
             object.chunkNames = asset.chunkNames;
+            // - chunkIdHints
+            // - auxiliaryChunkNames
+            // - auxiliaryChunkIdHints
+            // - filteredRelated
         },
+        // relatedAssets
         ids: (object, asset) => {
             object.chunks = asset.chunks;
+            // - auxiliaryChunks
+        }
+    },
+    chunkGroup: {
+        _: (object, { name, chunkGroup }, _context, { chunkGroupMaxAssets }) => {
+            object.name = name;
+            object.chunks = chunkGroup.chunks;
+            object.assets = chunkGroup.assets;
+            object.filteredAssets =
+                chunkGroup.assets.length <= chunkGroupMaxAssets
+                    ? 0
+                    : chunkGroup.assets.length;
+            object.assetsSize = chunkGroup.assetsSize;
+            object.auxiliaryAssets = chunkGroup.auxiliaryAssets;
+            object.auxiliaryAssetsSize = chunkGroup.auxiliaryAssetsSize;
+            object.children = chunkGroup.children;
+            // - childAssets
         }
     },
     module: {
@@ -635,6 +818,7 @@ const SIMPLE_EXTRACTORS = {
         reasons: (object, module, context, options, factory) => {
             const { type } = context;
             object.reasons = factory.create(`${type.slice(0, -8)}.reasons`, module.reasons, context);
+            // object.filteredReasons
         },
         source: (object, module) => {
             object.source = module.source;
@@ -745,7 +929,23 @@ const SIMPLE_EXTRACTORS = {
         chunkOrigins: (object, chunk, context, options, factory) => {
             object.origins = chunk.origins;
         }
+    },
+    // chunkOrigin
+    error: EXTRACT_ERROR,
+    warning: EXTRACT_ERROR,
+    moduleTraceItem: {
+        _: (object, { origin, module }, context, { requestShortener }, factory) => {
+            object.originIdentifier = origin.identifier;
+            object.originName = origin.name;
+            object.moduleIdentifier = module.identifier;
+            object.moduleName = module.name;
+        },
+        ids: (object, { origin, module }) => {
+            object.originId = origin.id;
+            object.moduleId = module.id;
+        }
     }
+    // moduleTraceDependency
 };
 /**
  * only support below factories:
@@ -797,10 +997,10 @@ class DefaultStatsFactoryPlugin {
                         .for(key)
                         .tap("DefaultStatsFactoryPlugin", () => itemName);
                 }
-                // for (const key of Object.keys(MERGER)) {
-                // 	const merger = MERGER[key];
-                // 	stats.hooks.merge.for(key).tap("DefaultStatsFactoryPlugin", merger);
-                // }
+                for (const key of Object.keys(MERGER)) {
+                    const merger = MERGER[key];
+                    stats.hooks.merge.for(key).tap("DefaultStatsFactoryPlugin", merger);
+                }
             });
         });
     }

package/dist/stats/DefaultStatsPresetPlugin.js

@@ -16,7 +16,7 @@ const NAMED_PRESETS = {
     verbose: {
         hash: true,
         builtAt: true,
-        // relatedAssets: true,
+        relatedAssets: true,
         entrypoints: true,
         chunkGroups: true,
         ids: true,
@@ -24,16 +24,16 @@ const NAMED_PRESETS = {
         chunks: true,
         chunkRelations: true,
         chunkModules: true,
-        // dependentModules: true,
-        // chunkOrigins: true,
+        dependentModules: true,
+        chunkOrigins: true,
         depth: true,
-        // env: true,
+        env: true,
         reasons: true,
         usedExports: true,
         providedExports: true,
         optimizationBailout: true,
-        // errorDetails: true,
-        // errorStack: true,
+        errorDetails: true,
+        errorStack: true,
         publicPath: true,
         logging: "verbose",
         orphanModules: true,
@@ -41,7 +41,7 @@ const NAMED_PRESETS = {
         // exclude: false,
         // errorsSpace: Infinity,
         // warningsSpace: Infinity,
-        modulesSpace: Infinity,
+        modulesSpace: Number.POSITIVE_INFINITY,
         // chunkModulesSpace: Infinity,
         // assetsSpace: Infinity,
         // reasonsSpace: Infinity,
@@ -50,19 +50,19 @@ const NAMED_PRESETS = {
     detailed: {
         hash: true,
         builtAt: true,
-        // relatedAssets: true,
+        relatedAssets: true,
         entrypoints: true,
         chunkGroups: true,
         ids: true,
         chunks: true,
         chunkRelations: true,
         chunkModules: false,
-        // chunkOrigins: true,
+        chunkOrigins: true,
         depth: true,
         usedExports: true,
         providedExports: true,
         optimizationBailout: true,
-        // errorDetails: true,
+        errorDetails: true,
         publicPath: true,
         logging: true,
         runtimeModules: true,
@@ -94,7 +94,7 @@ const NAMED_PRESETS = {
         errors: true,
         errorsCount: true,
         // errorsSpace: Infinity,
-        // moduleTrace: true,
+        moduleTrace: true,
         logging: "error"
     },
     "errors-warnings": {
@@ -147,7 +147,7 @@ const DEFAULTS = {
     chunkGroups: OFF_FOR_TO_STRING,
     chunkGroupAuxiliary: OFF_FOR_TO_STRING,
     chunkGroupChildren: OFF_FOR_TO_STRING,
-    chunkGroupMaxAssets: (o, { forToString }) => (forToString ? 5 : Infinity),
+    chunkGroupMaxAssets: (o, { forToString }) => forToString ? 5 : Number.POSITIVE_INFINITY,
     chunks: OFF_FOR_TO_STRING,
     chunkRelations: OFF_FOR_TO_STRING,
     chunkModules: ({ all, modules }) => {
@@ -178,16 +178,16 @@ const DEFAULTS = {
     groupModulesByAttributes: ON_FOR_TO_STRING,
     groupModulesByPath: ON_FOR_TO_STRING,
     groupModulesByExtension: ON_FOR_TO_STRING,
-    modulesSpace: (o, { forToString }) => (forToString ? 15 : Infinity),
-    chunkModulesSpace: (o, { forToString }) => (forToString ? 10 : Infinity),
-    nestedModulesSpace: (o, { forToString }) => (forToString ? 10 : Infinity),
+    modulesSpace: (o, { forToString }) => forToString ? 15 : Number.POSITIVE_INFINITY,
+    chunkModulesSpace: (o, { forToString }) => forToString ? 10 : Number.POSITIVE_INFINITY,
+    nestedModulesSpace: (o, { forToString }) => forToString ? 10 : Number.POSITIVE_INFINITY,
     relatedAssets: OFF_FOR_TO_STRING,
     groupAssetsByEmitStatus: ON_FOR_TO_STRING,
     groupAssetsByInfo: ON_FOR_TO_STRING,
     groupAssetsByPath: ON_FOR_TO_STRING,
     groupAssetsByExtension: ON_FOR_TO_STRING,
     groupAssetsByChunk: ON_FOR_TO_STRING,
-    assetsSpace: (o, { forToString }) => (forToString ? 15 : Infinity),
+    assetsSpace: (o, { forToString }) => forToString ? 15 : Number.POSITIVE_INFINITY,
     orphanModules: OFF_FOR_TO_STRING,
     runtimeModules: ({ all, runtime }, { forToString }) => runtime !== undefined
         ? runtime
@@ -200,7 +200,7 @@ const DEFAULTS = {
     depth: OFF_FOR_TO_STRING,
     // cachedAssets: OFF_FOR_TO_STRING,
     reasons: OFF_FOR_TO_STRING,
-    reasonsSpace: (o, { forToString }) => (forToString ? 15 : Infinity),
+    reasonsSpace: (o, { forToString }) => forToString ? 15 : Number.POSITIVE_INFINITY,
     groupReasonsByOrigin: ON_FOR_TO_STRING,
     usedExports: OFF_FOR_TO_STRING,
     providedExports: OFF_FOR_TO_STRING,

package/dist/stats/DefaultStatsPrinterPlugin.js

@@ -367,7 +367,7 @@ const SIMPLE_PRINTERS = {
     "error.message": (message, { bold, formatError }) => message.includes("\u001b[") ? message : bold(formatError(message)),
     // "error.details": (details, { formatError }) => formatError(details),
     // "error.stack": stack => stack,
-    // "error.moduleTrace": moduleTrace => undefined,
+    "error.moduleTrace": moduleTrace => undefined,
     "error.separator!": () => "\n",
     "loggingEntry(error).loggingEntry.message": (message, { red }) => mapLines(message, x => `<e> ${red(x)}`),
     "loggingEntry(warn).loggingEntry.message": (message, { yellow }) => mapLines(message, x => `<w> ${yellow(x)}`),

package/dist/stats/StatsFactory.d.ts

@@ -7,10 +7,10 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-import { JsStats, JsStatsError, JsStatsWarning } from "@rspack/binding";
+import type { JsStats, JsStatsError, JsStatsWarning } from "@rspack/binding";
 import { HookMap, SyncBailHook, SyncWaterfallHook } from "@rspack/lite-tapable";
 import type { Compilation } from "../Compilation";
-import { GroupConfig } from "../util/smartGrouping";
+import { type GroupConfig } from "../util/smartGrouping";
 export type KnownStatsFactoryContext = {
     type: string;
     makePathsRelative?: ((arg0: string) => string) | undefined;

package/dist/stats/statsFactoryUtils.d.ts

@@ -1,4 +1,4 @@
-import * as binding from "@rspack/binding";
+import type * as binding from "@rspack/binding";
 import type { Compilation, NormalizedStatsOptions } from "../Compilation";
 import { type Comparator } from "../util/comparators";
 import type { StatsFactory, StatsFactoryContext } from "./StatsFactory";
@@ -34,6 +34,14 @@ export type StatsModule = KnownStatsModule & Record<string, any>;
 export type StatsModuleIssuer = binding.JsStatsModuleIssuer & Record<string, any>;
 export type StatsError = binding.JsStatsError & Record<string, any>;
 export type StatsWarnings = binding.JsStatsWarning & Record<string, any>;
+export type StatsModuleTraceItem = {
+    originIdentifier?: string;
+    originName?: string;
+    moduleIdentifier?: string;
+    moduleName?: string;
+    originId?: string;
+    moduleId?: string;
+};
 export type StatsModuleReason = binding.JsStatsModuleReason & Record<string, any>;
 export type KnownStatsCompilation = {
     /**
@@ -99,12 +107,19 @@ export type SimpleExtractors = {
     compilation: ExtractorsByOption<Compilation, StatsCompilation>;
     asset$visible: ExtractorsByOption<PreprocessedAsset, StatsAsset>;
     asset: ExtractorsByOption<PreprocessedAsset, StatsAsset>;
+    chunkGroup: ExtractorsByOption<{
+        name: string;
+        chunkGroup: binding.JsStatsChunkGroup;
+    }, StatsChunkGroup>;
     module: ExtractorsByOption<binding.JsStatsModule, StatsModule>;
     module$visible: ExtractorsByOption<binding.JsStatsModule, StatsModule>;
     moduleIssuer: ExtractorsByOption<binding.JsStatsModuleIssuer, StatsModuleIssuer>;
     profile: ExtractorsByOption<binding.JsStatsModuleProfile, StatsProfile>;
     moduleReason: ExtractorsByOption<binding.JsStatsModuleReason, StatsModuleReason>;
     chunk: ExtractorsByOption<binding.JsStatsChunk, KnownStatsChunk>;
+    error: ExtractorsByOption<binding.JsStatsError, StatsError>;
+    warning: ExtractorsByOption<binding.JsStatsWarning, StatsError>;
+    moduleTraceItem: ExtractorsByOption<binding.JsStatsModuleTrace, StatsModuleTraceItem>;
 };
 export declare const uniqueArray: <T, I>(items: Iterable<T>, selector: (arg: T) => Iterable<I>) => I[];
 export declare const uniqueOrderedArray: <T, I>(items: Iterable<T>, selector: (arg: T) => Iterable<I>, comparator: Comparator) => I[];

package/dist/util/SplitChunkSize.d.ts

@@ -1,4 +1,4 @@
-import { RawSplitChunkSizes } from "@rspack/binding";
+import type { RawSplitChunkSizes } from "@rspack/binding";
 declare class JsSplitChunkSizes {
     static __to_binding(sizes?: number | Record<string, number>): number | RawSplitChunkSizes | undefined;
 }

package/dist/util/bindingVersionCheck.js

@@ -57,7 +57,7 @@ function isMusl() {
 }
 const BINDING_VERSION = require("@rspack/binding/package.json").version;
 const CORE_VERSION = require("../../package.json").version;
-const getAddonPlatformArchAbi = function () {
+const getAddonPlatformArchAbi = () => {
     const { platform, arch } = process;
     let binding = "";
     binding += platform;

package/dist/util/comparators.d.ts

@@ -8,7 +8,7 @@
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
 import type { JsStatsChunk as Chunk } from "@rspack/binding";
-import { ChunkGroup } from "../ChunkGroup";
+import type { ChunkGroup } from "../ChunkGroup";
 export type Comparator = <T>(arg0: T, arg1: T) => -1 | 0 | 1;
 type Selector<A, B> = (input: A) => B;
 export declare const concatComparators: (c1: Comparator, c2: Comparator, ...cRest: Comparator[]) => Comparator;

package/dist/util/fs.d.ts

@@ -9,7 +9,7 @@
  */
 /// <reference types="node" />
 /// <reference types="node" />
-import { WatchOptions } from "../config";
+import type { WatchOptions } from "../config";
 export interface Watcher {
     close(): void;
     pause(): void;