@rspack/test-tools 2.0.1 → 2.0.3

package/dist/case/serial.js

@@ -1,30 +1,61 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSerialCase = createSerialCase;
-const creator_1 = require("../test/creator");
-const config_1 = require("./config");
-const runner_1 = require("./runner");
-const creator = new creator_1.BasicCaseCreator({
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createSerialCase: ()=>createSerialCase
+});
+const creator_js_namespaceObject = require("../test/creator.js");
+const external_config_js_namespaceObject = require("./config.js");
+const external_runner_js_namespaceObject = require("./runner.js");
+const creator = new creator_js_namespaceObject.BasicCaseCreator({
     clean: true,
     describe: false,
-    testConfig: (testConfig) => {
+    testConfig: (testConfig)=>{
         const oldModuleScope = testConfig.moduleScope;
-        testConfig.moduleScope = (ms, stats, compilerOptions) => {
+        testConfig.moduleScope = (ms, stats, compilerOptions)=>{
             let res = ms;
-            // TODO: modify runner module scope based on stats here
-            if (typeof oldModuleScope === 'function') {
-                res = oldModuleScope(ms, stats, compilerOptions);
-            }
+            if ('function' == typeof oldModuleScope) res = oldModuleScope(ms, stats, compilerOptions);
             return res;
         };
     },
-    steps: ({ name }) => [(0, config_1.createConfigProcessor)(name)],
+    steps: ({ name })=>[
+            (0, external_config_js_namespaceObject.createConfigProcessor)(name)
+        ],
     runner: {
-        key: runner_1.getMultiCompilerRunnerKey,
-        runner: runner_1.createMultiCompilerRunner,
+        key: external_runner_js_namespaceObject.getMultiCompilerRunnerKey,
+        runner: external_runner_js_namespaceObject.createMultiCompilerRunner
     },
-    concurrent: 1,
+    concurrent: 1
 });
 function createSerialCase(name, src, dist) {
     creator.create(name, src, dist);
 }
+exports.createSerialCase = __webpack_exports__.createSerialCase;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createSerialCase"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/case/stats-api.d.ts

@@ -1,11 +1,11 @@
 import type { Compiler, RspackOptions, Stats } from '@rspack/core';
-import type { ITestContext } from '../type';
+import type { ITestContext, MaybePromise } from '../type';
 export type TStatsAPICaseConfig = {
     description: string;
     options?: (context: ITestContext) => RspackOptions;
     snapshotName?: string;
-    compiler?: (context: ITestContext, compiler: Compiler) => Promise<void>;
-    build?: (context: ITestContext, compiler: Compiler) => Promise<void>;
-    check?: (stats: Stats, compiler: Compiler) => Promise<void>;
+    compiler?: (context: ITestContext, compiler: Compiler) => MaybePromise<void>;
+    build?: (context: ITestContext, compiler: Compiler) => MaybePromise<void>;
+    check?: (stats: Stats, compiler: Compiler) => MaybePromise<void>;
 };
 export declare function createStatsAPICase(name: string, src: string, dist: string, testConfig: string): void;

package/dist/case/stats-api.js

@@ -1,80 +1,93 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createStatsAPICase = createStatsAPICase;
-const memfs_1 = require("memfs");
-const creator_1 = require("../test/creator");
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createStatsAPICase: ()=>createStatsAPICase
+});
+const external_memfs_namespaceObject = require("memfs");
+const creator_js_namespaceObject = require("../test/creator.js");
 let addedSerializer = false;
-const creator = new creator_1.BasicCaseCreator({
+const creator = new creator_js_namespaceObject.BasicCaseCreator({
     clean: true,
     describe: true,
-    steps: ({ name, caseConfig }) => {
+    steps: ({ name, caseConfig })=>{
         const config = caseConfig;
         return [
             {
-                config: async (context) => {
+                config: (context)=>{
                     const compiler = context.getCompiler();
                     compiler.setOptions(options(context, config.options));
                 },
-                compiler: async (context) => {
+                compiler: async (context)=>{
                     const compilerManager = context.getCompiler();
                     compilerManager.createCompiler();
-                    compiler(context, compilerManager.getCompiler(), config.compiler);
+                    await stats_api_compiler(context, compilerManager.getCompiler(), config.compiler);
                 },
-                build: async (context) => {
+                build: async (context)=>{
                     const compiler = context.getCompiler();
-                    if (typeof config.build === 'function') {
-                        await config.build(context, compiler.getCompiler());
-                    }
-                    else {
-                        await compiler.build();
-                    }
-                },
-                run: async (env, context) => {
-                    // no need to run, just check the snapshot of diagnostics
+                    if ('function' == typeof config.build) await config.build(context, compiler.getCompiler());
+                    else await compiler.build();
                 },
-                check: async (env, context) => {
+                run: async (env, context)=>{},
+                check: async (env, context)=>{
                     await check(env, context, name, config.check);
-                },
-            },
+                }
+            }
         ];
     },
-    concurrent: true,
+    concurrent: true
 });
 function createStatsAPICase(name, src, dist, testConfig) {
-    if (!addedSerializer) {
-        addedSerializer = true;
-    }
+    if (!addedSerializer) addedSerializer = true;
     const caseConfig = require(testConfig);
-    creator.create(name, src, dist, undefined, {
+    creator.create(name, src, dist, void 0, {
         caseConfig,
-        description: () => caseConfig.description,
+        description: ()=>caseConfig.description
     });
 }
 function options(context, custom) {
-    const res = (custom?.(context) || {});
+    const res = custom?.(context) || {};
     res.output ??= {};
     res.module ??= {};
-    res.module.defaultRules ??= ['...'];
+    res.module.defaultRules ??= [
+        '...'
+    ];
     res.module.defaultRules.push({
         test: /\.css$/,
-        type: 'css/auto',
+        type: 'css/auto'
     });
     res.output.bundlerInfo ??= {};
     res.output.bundlerInfo.force ??= false;
-    if (!global.printLogger) {
-        res.infrastructureLogging = {
-            level: 'error',
-        };
-    }
+    if (!global.printLogger) res.infrastructureLogging = {
+        level: 'error'
+    };
     return res;
 }
-async function compiler(context, compiler, custom) {
-    if (custom) {
-        await custom(context, compiler);
-    }
-    if (compiler) {
-        compiler.outputFileSystem = (0, memfs_1.createFsFromVolume)(new memfs_1.Volume());
-    }
+async function stats_api_compiler(context, compiler, custom) {
+    if (custom) await custom(context, compiler);
+    if (compiler) compiler.outputFileSystem = (0, external_memfs_namespaceObject.createFsFromVolume)(new external_memfs_namespaceObject.Volume());
 }
 async function check(env, context, name, custom) {
     const manager = context.getCompiler();
@@ -82,3 +95,10 @@ async function check(env, context, name, custom) {
     env.expect(typeof stats).toBe('object');
     await custom?.(stats, manager.getCompiler());
 }
+exports.createStatsAPICase = __webpack_exports__.createStatsAPICase;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createStatsAPICase"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/case/stats-output.d.ts

@@ -1,12 +1,12 @@
 import type { RspackOptions } from '@rspack/core';
 import type { ITestContext, ITestEnv } from '../type';
 export declare function createStatsProcessor(name: string, defaultOptions: (index: number, context: ITestContext) => RspackOptions, overrideOptions: (index: number, context: ITestContext, options: RspackOptions) => void): {
-    before: (context: ITestContext) => Promise<void>;
-    config: (context: ITestContext) => Promise<void>;
+    before: (context: ITestContext) => void;
+    config: (context: ITestContext) => void;
     compiler: (context: ITestContext) => Promise<void>;
     build: (context: ITestContext) => Promise<void>;
     run: (env: ITestEnv, context: ITestContext) => Promise<void>;
     check: (env: ITestEnv, context: ITestContext) => Promise<void>;
-    after: (context: ITestContext) => Promise<void>;
+    after: (context: ITestContext) => void;
 };
 export declare function createStatsOutputCase(name: string, src: string, dist: string): void;

package/dist/case/stats-output.js

@@ -1,77 +1,108 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createStatsProcessor = createStatsProcessor;
-exports.createStatsOutputCase = createStatsOutputCase;
-const node_path_1 = __importDefault(require("node:path"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const placeholder_1 = require("../helper/expect/placeholder");
-const captureStdio_1 = __importDefault(require("../helper/legacy/captureStdio"));
-const creator_1 = require("../test/creator");
-const common_1 = require("./common");
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createStatsOutputCase: ()=>createStatsOutputCase,
+    createStatsProcessor: ()=>createStatsProcessor
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_fs_extra_namespaceObject = require("fs-extra");
+var external_fs_extra_default = /*#__PURE__*/ __webpack_require__.n(external_fs_extra_namespaceObject);
+const placeholder_js_namespaceObject = require("../helper/expect/placeholder.js");
+const captureStdio_js_namespaceObject = require("../helper/legacy/captureStdio.js");
+const creator_js_namespaceObject = require("../test/creator.js");
+const external_common_js_namespaceObject = require("./common.js");
 const REG_ERROR_CASE = /error$/;
 function createStatsProcessor(name, defaultOptions, overrideOptions) {
     const writeStatsOuptut = false;
     const snapshotName = 'stats.txt';
     let stderr = null;
     return {
-        before: async (context) => {
-            stderr = (0, captureStdio_1.default)(process.stderr, true);
+        before: (context)=>{
+            stderr = (0, captureStdio_js_namespaceObject.captureStdio)(process.stderr, true);
         },
-        config: async (context) => {
-            (0, common_1.configMultiCompiler)(context, name, ['rspack.config.js', 'webpack.config.js'], defaultOptions, overrideOptions);
+        config: (context)=>{
+            (0, external_common_js_namespaceObject.configMultiCompiler)(context, name, [
+                'rspack.config.js',
+                'webpack.config.js'
+            ], defaultOptions, overrideOptions);
         },
-        compiler: async (context) => {
-            const c = await (0, common_1.compiler)(context, name);
+        compiler: async (context)=>{
+            const c = await (0, external_common_js_namespaceObject.compiler)(context, name);
             await statsCompiler(context, c);
         },
-        build: async (context) => {
-            await (0, common_1.build)(context, name);
-        },
-        run: async (env, context) => {
-            // no need to run, just check snapshot
+        build: async (context)=>{
+            await (0, external_common_js_namespaceObject.build)(context, name);
         },
-        check: async (env, context) => {
+        run: async (env, context)=>{},
+        check: async (env, context)=>{
             await check(env, context, name, writeStatsOuptut, snapshotName, stderr);
         },
-        after: async (context) => {
+        after: (context)=>{
             stderr.restore();
-        },
+        }
     };
 }
-const creator = new creator_1.BasicCaseCreator({
+const creator = new creator_js_namespaceObject.BasicCaseCreator({
     clean: true,
     describe: false,
-    steps: ({ name }) => [
-        createStatsProcessor(name, defaultOptions, overrideOptions),
-    ],
-    description: () => 'should print correct stats for',
+    steps: ({ name })=>[
+            createStatsProcessor(name, stats_output_defaultOptions, stats_output_overrideOptions)
+        ],
+    description: ()=>'should print correct stats for'
 });
 function createStatsOutputCase(name, src, dist) {
     creator.create(name, src, dist);
 }
-function defaultOptions(index, context) {
-    if (fs_extra_1.default.existsSync(node_path_1.default.join(context.getSource(), 'rspack.config.js')) ||
-        fs_extra_1.default.existsSync(node_path_1.default.join(context.getSource(), 'webpack.config.js'))) {
-        return {
-            output: {
-                bundlerInfo: {
-                    force: false,
-                },
-            },
-            module: {
-                defaultRules: [
-                    '...',
-                    {
-                        test: /\.css$/i,
-                        type: 'css/auto',
-                    },
-                ],
-            },
-        };
-    }
+function stats_output_defaultOptions(index, context) {
+    if (external_fs_extra_default().existsSync(external_node_path_default().join(context.getSource(), 'rspack.config.js')) || external_fs_extra_default().existsSync(external_node_path_default().join(context.getSource(), 'webpack.config.js'))) return {
+        output: {
+            bundlerInfo: {
+                force: false
+            }
+        },
+        module: {
+            defaultRules: [
+                '...',
+                {
+                    test: /\.css$/i,
+                    type: 'css/auto'
+                }
+            ]
+        }
+    };
     return {
         context: context.getSource(),
         mode: 'development',
@@ -80,94 +111,69 @@ function defaultOptions(index, context) {
             filename: 'bundle.js',
             path: context.getDist(),
             bundlerInfo: {
-                force: false,
-            },
+                force: false
+            }
         },
         module: {
             defaultRules: [
                 {
                     test: /\.css$/i,
-                    type: 'css/auto',
-                },
-            ],
+                    type: 'css/auto'
+                }
+            ]
         },
         optimization: {
-            minimize: false,
-        },
+            minimize: false
+        }
     };
 }
-function overrideOptions(index, context, options) {
-    if (!options.context)
-        options.context = context.getSource();
-    if (!options.output)
-        options.output = options.output || {};
-    if (!options.output.path)
-        options.output.path = context.getDist();
-    if (!options.plugins)
-        options.plugins = [];
-    if (!options.optimization)
-        options.optimization = {};
-    if (options.optimization.minimize === undefined) {
-        options.optimization.minimize = false;
-    }
-    if (!global.printLogger) {
-        options.infrastructureLogging = {
-            level: 'error',
-        };
-    }
+function stats_output_overrideOptions(index, context, options) {
+    if (!options.context) options.context = context.getSource();
+    if (!options.output) options.output = options.output || {};
+    if (!options.output.path) options.output.path = context.getDist();
+    if (!options.plugins) options.plugins = [];
+    if (!options.optimization) options.optimization = {};
+    if (void 0 === options.optimization.minimize) options.optimization.minimize = false;
+    if (!global.printLogger) options.infrastructureLogging = {
+        level: 'error'
+    };
 }
 class RspackStats {
-    constructor(value) {
+    value;
+    constructor(value){
         this.value = value;
     }
 }
-async function check(env, context, name, writeStatsOuptut, snapshot, stderr) {
+function check(env, context, name, writeStatsOuptut, snapshot, stderr) {
     const compiler = context.getCompiler();
     const options = compiler.getOptions();
     const stats = compiler.getStats();
-    if (!stats || !compiler)
-        return;
-    for (const compilation of []
-        .concat(stats.stats || stats)
-        .map((s) => s.compilation)) {
-        compilation.logging.delete('webpack.Compilation.ModuleProfile');
-    }
-    if (REG_ERROR_CASE.test(name)) {
-        env.expect(stats.hasErrors()).toBe(true);
-    }
-    else if (stats.hasErrors()) {
-        throw new Error(stats.toString({
-            all: false,
-            errors: true,
-            // errorStack: true,
-            // errorDetails: true
-        }));
-    }
-    else if (writeStatsOuptut) {
-        fs_extra_1.default.writeFileSync(node_path_1.default.join(context.getDist(), 'stats.txt'), stats.toString({
-            preset: 'verbose',
-            // context: context.getSource(),
-            colors: false,
-        }), 'utf-8');
-    }
+    if (!stats || !compiler) return;
+    for (const compilation of [].concat(stats.stats || stats).map((s)=>s.compilation))compilation.logging.delete('webpack.Compilation.ModuleProfile');
+    if (REG_ERROR_CASE.test(name)) env.expect(stats.hasErrors()).toBe(true);
+    else if (stats.hasErrors()) throw new Error(stats.toString({
+        all: false,
+        errors: true
+    }));
+    else if (writeStatsOuptut) external_fs_extra_default().writeFileSync(external_node_path_default().join(context.getDist(), 'stats.txt'), stats.toString({
+        preset: 'verbose',
+        colors: false
+    }), 'utf-8');
     let toStringOptions = {
         context: context.getSource(),
-        colors: false,
+        colors: false
     };
     let hasColorSetting = false;
-    if (typeof options.stats !== 'undefined') {
+    if (void 0 !== options.stats) {
         toStringOptions = options.stats;
-        if (toStringOptions === null || typeof toStringOptions !== 'object')
-            toStringOptions = { preset: toStringOptions };
-        if (!toStringOptions.context)
-            toStringOptions.context = context.getSource();
-        hasColorSetting = typeof toStringOptions.colors !== 'undefined';
-    }
-    if (Array.isArray(options) && !toStringOptions.children) {
-        toStringOptions.children = options.map((o) => o.stats);
+        if (null === toStringOptions || 'object' != typeof toStringOptions) toStringOptions = {
+            preset: toStringOptions
+        };
+        if (!toStringOptions.context) toStringOptions.context = context.getSource();
+        hasColorSetting = void 0 !== toStringOptions.colors;
     }
-    // mock timestamps
-    for (const { compilation: s } of [].concat(stats.stats || stats)) {
+    if (Array.isArray(options) && !toStringOptions.children) toStringOptions.children = options.map((o)=>o.stats);
+    for (const { compilation: s } of [].concat(stats.stats || stats)){
         env.expect(s.startTime).toBeGreaterThan(0);
         env.expect(s.endTime).toBeGreaterThan(0);
         s.endTime = new Date('04/20/1970, 12:42:42 PM').getTime();
@@ -176,51 +182,40 @@ async function check(env, context, name, writeStatsOuptut, snapshot, stderr) {
     let actual = stats.toString(toStringOptions);
     env.expect(typeof actual).toBe('string');
     actual = stderr.toString() + actual;
-    if (!hasColorSetting) {
-        actual = actual
-            .replace(/\u001b\[[0-9;]*m/g, '')
-            // CHANGE: The time unit display in Rspack is second
-            .replace(/[.0-9]+(\s?s)/g, 'X$1')
-            // CHANGE: Replace bundle size, since bundle sizes may differ between platforms
-            .replace(/[0-9]+(\.[0-9]+)? KiB/g, 'xx KiB')
-            .replace(/[0-9]+(\.[0-9]+)? bytes/g, 'xx bytes')
-            .replace(/[0-9]+(\.[0-9]+)? ms/g, 'xx ms');
-    }
-    actual = actual
-        .split('\n')
-        .filter((line) => !line.includes('@rstest/core/dist'))
-        .join('\n');
-    const snapshotPath = node_path_1.default.isAbsolute(snapshot)
-        ? snapshot
-        : node_path_1.default.resolve(context.getSource(), `./__snapshots__/${snapshot}`);
+    if (!hasColorSetting) actual = actual.replace(/\u001b\[[0-9;]*m/g, '').replace(/[.0-9]+(\s?s)/g, 'X$1').replace(/[0-9]+(\.[0-9]+)? KiB/g, 'xx KiB').replace(/[0-9]+(\.[0-9]+)? bytes/g, 'xx bytes').replace(/[0-9]+(\.[0-9]+)? ms/g, 'xx ms');
+    actual = actual.split('\n').filter((line)=>!line.includes('@rstest/core/dist')).join('\n');
+    const snapshotPath = external_node_path_default().isAbsolute(snapshot) ? snapshot : external_node_path_default().resolve(context.getSource(), `./__snapshots__/${snapshot}`);
     env.expect(new RspackStats(actual)).toMatchFileSnapshotSync(snapshotPath);
     const testConfig = context.getTestConfig();
-    if (typeof testConfig?.validate === 'function') {
-        testConfig.validate(stats, stderr.toString());
-    }
+    if ('function' == typeof testConfig?.validate) testConfig.validate(stats, stderr.toString());
 }
-async function statsCompiler(context, compiler) {
-    const compilers = compiler.compilers
-        ? compiler.compilers
-        : [compiler];
-    for (const compiler of compilers) {
-        if (!compiler.inputFileSystem) {
-            continue;
-        }
+function statsCompiler(context, compiler) {
+    const compilers = compiler.compilers ? compiler.compilers : [
+        compiler
+    ];
+    for (const compiler of compilers){
+        if (!compiler.inputFileSystem) continue;
         const ifs = compiler.inputFileSystem;
         const inputFileSystem = Object.create(ifs);
         compiler.inputFileSystem = inputFileSystem;
-        inputFileSystem.readFile = (...args) => {
+        inputFileSystem.readFile = (...args)=>{
             const callback = args.pop();
             ifs.readFile.apply(ifs, args.concat([
-                (err, result) => {
-                    if (err)
-                        return callback(err);
-                    if (!/\.(js|json|txt)$/.test(args[0]))
-                        return callback(null, result);
-                    callback(null, (0, placeholder_1.normalizePlaceholder)(result.toString('utf-8')));
-                },
+                (err, result)=>{
+                    if (err) return callback(err);
+                    if (!/\.(js|json|txt)$/.test(args[0])) return callback(null, result);
+                    callback(null, (0, placeholder_js_namespaceObject.normalizePlaceholder)(result.toString('utf-8')));
+                }
             ]));
         };
     }
 }
+exports.createStatsOutputCase = __webpack_exports__.createStatsOutputCase;
+exports.createStatsProcessor = __webpack_exports__.createStatsProcessor;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createStatsOutputCase",
+    "createStatsProcessor"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});