@rspack/test-tools 0.3.14-canary-020060b-20231122074120

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2022-present Bytedance, Inc. and its affiliates.
+
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,16 @@
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://lf3-static.bytednsdoc.com/obj/eden-cn/rjhwzy/ljhwZthlaukjlkulzlp/rspack-banner-1610-dark.png">
+  <img alt="Rspack Banner" src="https://lf3-static.bytednsdoc.com/obj/eden-cn/rjhwzy/ljhwZthlaukjlkulzlp/rspack-banner-1610.png">
+</picture>
+
+# @rspack/test-tools
+
+Test tools for rspack.
+
+## Documentation
+
+See [https://rspack.dev](https://rspack.dev) for details.
+
+## License
+
+Rspack is [MIT licensed](https://github.com/web-infra-dev/rspack/blob/main/LICENSE).

package/dist/compare/compare.d.ts

@@ -0,0 +1,11 @@
+import { IFormatCodeOptions } from "./format-code";
+import { TCompareModules, TCompareResult, TFileCompareResult, TModuleCompareResult } from "../type";
+export interface ICompareOptions {
+    modules?: TCompareModules;
+    runtimeModules?: TCompareModules;
+    format: IFormatCodeOptions;
+    renameModule?: (name: string) => string;
+}
+export declare function compareFile(sourceFile: string, distFile: string, compareOptions: ICompareOptions): TFileCompareResult;
+export declare function compareModules(modules: string[], sourceModules: Map<string, string>, distModules: Map<string, string>, formatOptions: IFormatCodeOptions): TModuleCompareResult[];
+export declare function compareContent(sourceContent: string | false, distContent: string | false): TCompareResult;

package/dist/compare/compare.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareContent = exports.compareModules = exports.compareFile = void 0;
+const jest_diff_1 = require("jest-diff");
+const format_code_1 = require("./format-code");
+const replace_runtime_module_name_1 = require("./replace-runtime-module-name");
+const helper_1 = require("../helper");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const type_1 = require("../type");
+function compareFile(sourceFile, distFile, compareOptions) {
+    const result = {
+        type: type_1.ECompareResultType.Same,
+        file: {
+            source: sourceFile,
+            dist: distFile
+        },
+        modules: {}
+    };
+    const sourceExists = fs_extra_1.default.existsSync(sourceFile);
+    const distExists = fs_extra_1.default.existsSync(distFile);
+    if (!sourceExists && !distExists) {
+        result.type = type_1.ECompareResultType.Missing;
+        return result;
+    }
+    else if (!sourceExists && distExists) {
+        result.type = type_1.ECompareResultType.OnlyDist;
+        return result;
+    }
+    else if (sourceExists && !distExists) {
+        result.type = type_1.ECompareResultType.OnlySource;
+        return result;
+    }
+    const sourceContent = (0, replace_runtime_module_name_1.replaceRuntimeModuleName)(fs_extra_1.default.readFileSync(sourceFile, "utf-8"));
+    const distContent = (0, replace_runtime_module_name_1.replaceRuntimeModuleName)(fs_extra_1.default.readFileSync(distFile, "utf-8"));
+    // const compareContentResult = compareContent(sourceContent, distContent);
+    // result.detail = compareContentResult.detail;
+    // result.lines = compareContentResult.lines;
+    result.type = type_1.ECompareResultType.Different;
+    const sourceModules = (0, helper_1.parseModules)(sourceContent);
+    const distModules = (0, helper_1.parseModules)(distContent);
+    for (let type of ["modules", "runtimeModules"]) {
+        const t = type;
+        let moduleList = [];
+        if (compareOptions[t] === true) {
+            moduleList = [
+                ...sourceModules[t].keys(),
+                ...distModules[t].keys()
+            ].filter((i, idx, arr) => arr.indexOf(i) === idx);
+        }
+        else if (Array.isArray(compareOptions[t])) {
+            moduleList = compareOptions[t];
+        }
+        else {
+            continue;
+        }
+        if (typeof compareOptions.renameModule === "function") {
+            moduleList = moduleList.map(compareOptions.renameModule);
+        }
+        result.modules[t] = compareModules(moduleList, sourceModules[t], distModules[t], compareOptions.format);
+    }
+    return result;
+}
+exports.compareFile = compareFile;
+function compareModules(modules, sourceModules, distModules, formatOptions) {
+    const compareResults = [];
+    for (let name of modules) {
+        const renamed = (0, replace_runtime_module_name_1.replaceRuntimeModuleName)(name);
+        const sourceContent = sourceModules.has(renamed) &&
+            (0, format_code_1.formatCode)(sourceModules.get(renamed), formatOptions);
+        const distContent = distModules.has(renamed) &&
+            (0, format_code_1.formatCode)(distModules.get(renamed), formatOptions);
+        compareResults.push({
+            ...compareContent(sourceContent, distContent),
+            name
+        });
+    }
+    return compareResults;
+}
+exports.compareModules = compareModules;
+function compareContent(sourceContent, distContent) {
+    if (sourceContent) {
+        if (distContent) {
+            if (sourceContent === distContent) {
+                const lines = sourceContent.trim().split("\n").length;
+                return {
+                    type: type_1.ECompareResultType.Same,
+                    lines: {
+                        source: lines,
+                        common: lines,
+                        dist: lines
+                    }
+                };
+            }
+            else {
+                const difference = (0, jest_diff_1.diffStringsUnified)(sourceContent.trim(), distContent.trim());
+                const diffLines = (0, jest_diff_1.diffLinesRaw)(sourceContent.trim().split("\n"), distContent.trim().split("\n"));
+                return {
+                    type: type_1.ECompareResultType.Different,
+                    detail: difference,
+                    lines: {
+                        source: diffLines.filter(l => l[0] < 0).length,
+                        common: diffLines.filter(l => l[0] === 0).length,
+                        dist: diffLines.filter(l => l[0] > 0).length
+                    }
+                };
+            }
+        }
+        else {
+            return {
+                type: type_1.ECompareResultType.OnlySource,
+                lines: {
+                    source: sourceContent.trim().split("\n").length,
+                    common: 0,
+                    dist: 0
+                }
+            };
+        }
+    }
+    else {
+        if (distContent) {
+            return {
+                type: type_1.ECompareResultType.OnlyDist,
+                lines: {
+                    source: 0,
+                    common: 0,
+                    dist: distContent.trim().split("\n").length
+                }
+            };
+        }
+        else {
+            return {
+                type: type_1.ECompareResultType.Missing,
+                lines: {
+                    source: 0,
+                    common: 0,
+                    dist: 0
+                }
+            };
+        }
+    }
+}
+exports.compareContent = compareContent;

package/dist/compare/format-code.d.ts

@@ -0,0 +1,7 @@
+export interface IFormatCodeOptions {
+    replacements?: Record<string, string>;
+    ignorePropertyQuotationMark: boolean;
+    ignoreModuleId: boolean;
+    ignoreModuleArugments: boolean;
+}
+export declare function formatCode(raw: string, options: IFormatCodeOptions): string;

package/dist/compare/format-code.js

@@ -0,0 +1,69 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCode = void 0;
+const parser_1 = require("@babel/parser");
+const generator_1 = __importDefault(require("@babel/generator"));
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const T = __importStar(require("@babel/types"));
+const replace_module_argument_1 = require("./replace-module-argument");
+function formatCode(raw, options) {
+    const ast = (0, parser_1.parse)(raw, {
+        sourceType: "unambiguous"
+    });
+    (0, traverse_1.default)(ast, {
+        ObjectProperty(path) {
+            if (options.ignorePropertyQuotationMark) {
+                const keyPath = path.get("key");
+                if (keyPath.isIdentifier()) {
+                    keyPath.replaceWith(T.stringLiteral(keyPath.node.name));
+                }
+            }
+        },
+        Identifier(path) {
+            if (options.ignoreModuleId) {
+                path.node.name = path.node.name.replace(/__WEBPACK_IMPORTED_MODULE_\d+__/g, "__WEBPACK_IMPORTED_MODULE_xxx__");
+            }
+        }
+    });
+    let result = (0, generator_1.default)(ast, {
+        comments: false,
+        compact: false,
+        concise: false
+    }).code;
+    if (options.ignoreModuleArugments) {
+        result = (0, replace_module_argument_1.replaceModuleArgument)(result);
+    }
+    if (options.replacements) {
+        for (let [key, value] of Object.entries(options.replacements)) {
+            result = result.split(key).join(value);
+        }
+    }
+    return result.trim();
+}
+exports.formatCode = formatCode;

package/dist/compare/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./replace-module-argument";
+export * from "./replace-runtime-module-name";
+export * from "./format-code";
+export * from "./compare";

package/dist/compare/index.js

@@ -0,0 +1,20 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./replace-module-argument"), exports);
+__exportStar(require("./replace-runtime-module-name"), exports);
+__exportStar(require("./format-code"), exports);
+__exportStar(require("./compare"), exports);

package/dist/compare/replace-module-argument.d.ts

@@ -0,0 +1 @@
+export declare function replaceModuleArgument(raw: string): string;

package/dist/compare/replace-module-argument.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceModuleArgument = void 0;
+function replaceModuleArgument(raw) {
+    return raw.trim().replace(/^\(function \([\w_,\s]+\) {/, "(function () {");
+}
+exports.replaceModuleArgument = replaceModuleArgument;

package/dist/compare/replace-runtime-module-name.d.ts

@@ -0,0 +1 @@
+export declare function replaceRuntimeModuleName(raw: string): string;

package/dist/compare/replace-runtime-module-name.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceRuntimeModuleName = void 0;
+const RUNTIME_MODULE_NAME_MAPPING = {
+    "webpack/runtime/auto_public_path": "webpack/runtime/publicPath",
+    "webpack/runtime/public_path": "webpack/runtime/publicPath",
+    "webpack/runtime/async_module": "webpack/runtime/async module",
+    "webpack/runtime/base_uri": "webpack/runtime/base uri",
+    "webpack/runtime/chunk_name": "webpack/runtime/chunkName",
+    "webpack/runtime/compat_get_default_export": "webpack/runtime/compat get default export",
+    "webpack/runtime/compat": "webpack/runtime/compat",
+    "webpack/runtime/create_fake_namespace_object": "webpack/runtime/create fake namespace object",
+    "webpack/runtime/create_script": "webpack/runtime/trusted types script",
+    "webpack/runtime/define_property_getters": "webpack/runtime/define property getters",
+    "webpack/runtime/ensure_chunk": "webpack/runtime/ensure chunk",
+    "webpack/runtime/get_full_hash": "webpack/runtime/getFullHash",
+    "webpack/runtime/get_trusted_types_policy": "webpack/runtime/trusted types policy",
+    "webpack/runtime/global": "webpack/runtime/global",
+    "webpack/runtime/has_own_property": "webpack/runtime/hasOwnProperty shorthand",
+    "webpack/runtime/load_script": "webpack/runtime/load script",
+    "webpack/runtime/make_namespace_object": "webpack/runtime/make namespace object",
+    "webpack/runtime/nonce": "webpack/runtime/nonce",
+    "webpack/runtime/on_chunk_loaded": "webpack/runtime/chunk loaded",
+    "webpack/runtime/relative_url": "webpack/runtime/relative url",
+    "webpack/runtime/runtime_id": "webpack/runtime/runtimeId",
+    "webpack/runtime/startup_chunk_dependencies": "webpack/runtime/startup chunk dependencies",
+    "webpack/runtime/startup_entrypoint": "webpack/runtime/startup entrypoint",
+    "webpack/runtime/system_context": "webpack/runtime/__system_context__",
+    "webpack/runtime/chunk_prefetch_startup": "webpack/runtime/startup prefetch",
+    "webpack/runtime/chunk_prefetch_trigger": "webpack/runtime/chunk prefetch trigger",
+    "webpack/runtime/chunk_preload_trigger": "webpack/runtime/chunk preload trigger",
+    "webpack/runtime/css_loading": "webpack/runtime/css loading",
+    "webpack/runtime/async_wasm_loading": "webpack/runtime/wasm loading",
+    "webpack/runtime/hot_module_replacement": "webpack/runtime/hot module replacement",
+    "webpack/runtime/readfile_chunk_loading": "webpack/runtime/readFile chunk loading",
+    "webpack/runtime/require_chunk_loading": "webpack/runtime/require chunk loading",
+    "webpack/runtime/import_scripts_chunk_loading": "webpack/runtime/importScripts chunk loading",
+    "webpack/runtime/module_chunk_loading": "webpack/runtime/import chunk loading",
+    "webpack/runtime/export_webpack_runtime": "webpack/runtime/export webpack runtime",
+    "webpack/runtime/jsonp_chunk_loading": "webpack/runtime/jsonp chunk loading",
+    "webpack/runtime/remote": "webpack/runtime/remotes loading",
+    "webpack/runtime/share": "webpack/runtime/sharing",
+    "webpack/runtime/consume_shared": "webpack/runtime/consumes",
+    "webpack/runtime/harmony_module_decorator": "webpack/runtime/harmony module decorator",
+    "webpack/runtime/node_module_decorator": "webpack/runtime/node module decorator",
+    // module name with parameters
+    "webpack/runtime/get_chunk_filename": "webpack/runtime/get $1 chunk filename",
+    "webpack/runtime/get_main_filename": "webpack/runtime/get $1 filename",
+    "webpack/runtime/chunk_prefetch_function": "webpack/runtime/chunk $1 function"
+};
+const RUNTIME_MODULE_PARAM_REGEX = {
+    "webpack/runtime/get_chunk_filename": /webpack\/runtime\/get_chunk_filename\/([\w.\-_\s]+)(\*\/)?/g,
+    "webpack/runtime/get_main_filename": /webpack\/runtime\/get_main_filename\/([\w.\-_\s]+)(\*\/)?/g,
+    "webpack/runtime/chunk_prefetch_function": /webpack\/runtime\/chunk_prefetch_function\/([\w.\-_\s]+)(\*\/)?/g
+};
+function replaceRuntimeModuleName(raw) {
+    for (let [rspackName, webpackName] of Object.entries(RUNTIME_MODULE_NAME_MAPPING)) {
+        if (RUNTIME_MODULE_PARAM_REGEX[rspackName]) {
+            raw = raw.replace(RUNTIME_MODULE_PARAM_REGEX[rspackName], (full, $1, $2) => {
+                return webpackName.replace("$1", $1.trim()) + ($2 ? " */" : "");
+            });
+        }
+        else {
+            raw = raw.split(rspackName).join(webpackName);
+        }
+    }
+    return raw;
+}
+exports.replaceRuntimeModuleName = replaceRuntimeModuleName;

package/dist/compiler.d.ts

@@ -0,0 +1,12 @@
+import { ECompilerType, ITestCompilerManager, ITestContext, TCompiler, TCompilerOptions, TCompilerStats } from "./type";
+export declare class TestCompilerManager<T extends ECompilerType> implements ITestCompilerManager<T> {
+    private compilerOptions;
+    private compilerInstance;
+    private compilerStats;
+    private runResult;
+    options(context: ITestContext, fn: (options: TCompilerOptions<T>) => TCompilerOptions<T>): void;
+    compiler(context: ITestContext, fn: (options: TCompilerOptions<T>, compiler: TCompiler<T> | null) => TCompiler<T> | null): void;
+    stats(context: ITestContext, fn: (compiler: TCompiler<T> | null, stats: TCompilerStats<T> | null) => TCompilerStats<T> | null): void;
+    result(context: ITestContext, fn: <R>(compiler: TCompiler<T> | null, result: R) => R): void;
+    build(context: ITestContext, fn: (compiler: TCompiler<T>) => Promise<void>): Promise<void>;
+}

package/dist/compiler.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestCompilerManager = void 0;
+class TestCompilerManager {
+    constructor() {
+        this.compilerOptions = {};
+        this.compilerInstance = null;
+        this.compilerStats = null;
+    }
+    options(context, fn) {
+        try {
+            const newOptions = fn(this.compilerOptions);
+            if (newOptions) {
+                this.compilerOptions = newOptions;
+            }
+        }
+        catch (e) {
+            context.emitError(e);
+        }
+    }
+    compiler(context, fn) {
+        try {
+            const newCompiler = fn(this.compilerOptions, this.compilerInstance);
+            if (newCompiler) {
+                this.compilerInstance = newCompiler;
+            }
+        }
+        catch (e) {
+            context.emitError(e);
+        }
+    }
+    stats(context, fn) {
+        try {
+            const newStats = fn(this.compilerInstance, this.compilerStats);
+            if (newStats) {
+                this.compilerStats = newStats;
+            }
+        }
+        catch (e) {
+            context.emitError(e);
+        }
+    }
+    result(context, fn) {
+        try {
+            const newResult = fn(this.compilerInstance, this.runResult);
+            if (newResult) {
+                this.runResult = newResult;
+            }
+        }
+        catch (e) {
+            context.emitError(e);
+        }
+    }
+    async build(context, fn) {
+        if (!this.compilerInstance) {
+            context.emitError(new Error("Build failed: compiler not exists"));
+        }
+        try {
+            await fn(this.compilerInstance);
+        }
+        catch (e) {
+            context.emitError(e);
+        }
+    }
+}
+exports.TestCompilerManager = TestCompilerManager;

package/dist/helper/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./read-config-file";
+export * from "./run-build";
+export * from "./parse-modules";

package/dist/helper/index.js

@@ -0,0 +1,19 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./read-config-file"), exports);
+__exportStar(require("./run-build"), exports);
+__exportStar(require("./parse-modules"), exports);

package/dist/helper/parse-modules.d.ts

@@ -0,0 +1,4 @@
+export declare function parseModules(content: string): {
+    modules: Map<string, string>;
+    runtimeModules: Map<string, string>;
+};

package/dist/helper/parse-modules.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseModules = void 0;
+const BOOTSTRAP_SPLIT_LINE = "/************************************************************************/";
+const MODULE_START_FLAG = "/* start::";
+const MODULE_END_FLAG = "/* end::";
+const MODULE_FLAG_END = " */";
+function getStringBetween(raw, position, start, end) {
+    const startFlagIndex = raw.indexOf(start, position);
+    if (startFlagIndex === -1) {
+        return {
+            result: null,
+            remain: position
+        };
+    }
+    const endFlagIndex = raw.indexOf(end, startFlagIndex + start.length);
+    if (endFlagIndex === -1) {
+        return {
+            result: null,
+            remain: position
+        };
+    }
+    return {
+        result: raw.slice(startFlagIndex + start.length, endFlagIndex),
+        remain: endFlagIndex + end.length
+    };
+}
+function parseModules(content) {
+    const modules = new Map();
+    const runtimeModules = new Map();
+    let currentPosition = 0;
+    // parse bootstrap code
+    const bootstrap = getStringBetween(content, 0, BOOTSTRAP_SPLIT_LINE, BOOTSTRAP_SPLIT_LINE);
+    if (bootstrap.result) {
+        runtimeModules.set("webpack/bootstrap", bootstrap.result);
+    }
+    // parse module & runtime module code
+    let moduleName = getStringBetween(content, currentPosition, MODULE_START_FLAG, MODULE_FLAG_END).result;
+    let totalLength = 0;
+    while (moduleName) {
+        const moduleContent = getStringBetween(content, currentPosition, `${MODULE_START_FLAG}${moduleName}${MODULE_FLAG_END}`, `${MODULE_END_FLAG}${moduleName}${MODULE_FLAG_END}`);
+        if (!moduleContent.result) {
+            throw new Error(`Module code parsed error: ${moduleName}`);
+        }
+        if (moduleName.startsWith("webpack/runtime")) {
+            totalLength += moduleContent.result.length;
+            runtimeModules.set(moduleName, moduleContent.result);
+        }
+        else {
+            totalLength += moduleContent.result.length;
+            modules.set(moduleName, moduleContent.result);
+        }
+        currentPosition = moduleContent.remain;
+        moduleName = getStringBetween(content, currentPosition, MODULE_START_FLAG, MODULE_FLAG_END).result;
+    }
+    return {
+        modules,
+        runtimeModules
+    };
+}
+exports.parseModules = parseModules;

package/dist/helper/read-config-file.d.ts

@@ -0,0 +1,2 @@
+import { ECompilerType, TCompilerOptions } from "../type";
+export declare function readConfigFile<T extends ECompilerType>(root: string, files: string[], options: TCompilerOptions<T>): TCompilerOptions<T>;

package/dist/helper/read-config-file.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readConfigFile = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const deepmerge_1 = __importDefault(require("deepmerge"));
+function readConfigFile(root, files, options) {
+    const existsFile = files
+        .map(i => path_1.default.resolve(root, i))
+        .find(i => fs_extra_1.default.existsSync(i));
+    const fileConfig = existsFile ? require(existsFile) : {};
+    return (0, deepmerge_1.default)(options, fileConfig, {
+        arrayMerge: (a, b) => [...a, ...b]
+    });
+}
+exports.readConfigFile = readConfigFile;

package/dist/helper/run-build.d.ts

@@ -0,0 +1,2 @@
+import { ECompilerType, ITestContext, TCompilerStats } from "../type";
+export declare function runBuild<T extends ECompilerType>(context: ITestContext, name?: string): Promise<TCompilerStats<T> | null>;

package/dist/helper/run-build.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBuild = void 0;
+async function runBuild(context, name) {
+    let stats = null;
+    await context.build(compiler => new Promise((resolve, reject) => {
+        compiler.run((error, newStats) => {
+            if (error)
+                return reject(error);
+            context.stats(() => newStats);
+            stats = newStats;
+            resolve();
+        });
+    }), name);
+    return stats;
+}
+exports.runBuild = runBuild;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./type";
+export * from "./test/tester";
+export * from "./processor/diff";

package/dist/index.js

@@ -0,0 +1,19 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./type"), exports);
+__exportStar(require("./test/tester"), exports);
+__exportStar(require("./processor/diff"), exports);

package/dist/processor/diff.d.ts

@@ -0,0 +1,24 @@
+import { ITestContext, ITestProcessor, TCompareModules, TFileCompareResult, TModuleCompareResult } from "../type";
+import { IFormatCodeOptions } from "../compare";
+export interface IDiffProcessorOptions extends IFormatCodeOptions {
+    webpackPath: string;
+    rspackPath: string;
+    files?: string[];
+    modules?: TCompareModules;
+    runtimeModules?: TCompareModules;
+    onCompareFile?: (file: string, result: TFileCompareResult) => void;
+    onCompareModules?: (file: string, results: TModuleCompareResult[]) => void;
+    onCompareRuntimeModules?: (file: string, results: TModuleCompareResult[]) => void;
+}
+export declare class DiffProcessor implements ITestProcessor {
+    private options;
+    private hashes;
+    constructor(options: IDiffProcessorOptions);
+    config(context: ITestContext): Promise<void>;
+    compiler(context: ITestContext): Promise<void>;
+    build(context: ITestContext): Promise<void>;
+    check(context: ITestContext): Promise<void>;
+    private setCompilerOptions;
+    private setDefaultOptions;
+    private createFormatOptions;
+}

package/dist/processor/diff.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffProcessor = void 0;
+const type_1 = require("../type");
+const path_1 = __importDefault(require("path"));
+const module_placeholder_plugin_1 = require("../webpack/module-placeholder-plugin");
+const compare_1 = require("../compare");
+const helper_1 = require("../helper");
+const deepmerge_1 = __importDefault(require("deepmerge"));
+class DiffProcessor {
+    constructor(options) {
+        this.options = options;
+        this.hashes = [];
+    }
+    async config(context) {
+        this.setCompilerOptions(type_1.ECompilerType.Rspack, ["rspack.config.js", "webpack.config.js"], context);
+        this.setCompilerOptions(type_1.ECompilerType.Webpack, ["webpack.config.js", "rspack.config.js"], context);
+    }
+    async compiler(context) {
+        const rspack = require(this.options.rspackPath).rspack;
+        context.compiler(options => rspack({ ...options }), type_1.ECompilerType.Rspack);
+        const webpack = require(this.options.webpackPath).webpack;
+        context.compiler(options => webpack({ ...options }), type_1.ECompilerType.Webpack);
+    }
+    async build(context) {
+        const rspackStats = await (0, helper_1.runBuild)(context, type_1.ECompilerType.Rspack);
+        const webpackStats = await (0, helper_1.runBuild)(context, type_1.ECompilerType.Webpack);
+        //TODO: handle chunk hash and content hash
+        (rspackStats === null || rspackStats === void 0 ? void 0 : rspackStats.hash) && this.hashes.push(rspackStats === null || rspackStats === void 0 ? void 0 : rspackStats.hash);
+        (webpackStats === null || webpackStats === void 0 ? void 0 : webpackStats.hash) && this.hashes.push(webpackStats === null || webpackStats === void 0 ? void 0 : webpackStats.hash);
+    }
+    async check(context) {
+        const dist = context.getDist();
+        for (let file of this.options.files) {
+            const rspackDist = path_1.default.join(dist, type_1.ECompilerType.Rspack, file);
+            const webpackDist = path_1.default.join(dist, type_1.ECompilerType.Webpack, file);
+            const result = (0, compare_1.compareFile)(rspackDist, webpackDist, {
+                modules: this.options.modules,
+                runtimeModules: this.options.runtimeModules,
+                format: this.createFormatOptions(),
+                renameModule: compare_1.replaceRuntimeModuleName
+            });
+            if (typeof this.options.onCompareFile === "function") {
+                this.options.onCompareFile(file, result);
+            }
+            if (typeof this.options.onCompareModules === "function" &&
+                result.modules["modules"]) {
+                this.options.onCompareModules(file, result.modules["modules"]);
+            }
+            if (typeof this.options.onCompareRuntimeModules === "function" &&
+                result.modules["runtimeModules"]) {
+                this.options.onCompareRuntimeModules(file, result.modules["runtimeModules"]);
+            }
+        }
+    }
+    setCompilerOptions(type, configFiles, context) {
+        const source = context.getSource();
+        const dist = context.getDist();
+        context.options(options => this.setDefaultOptions(options, type, source, path_1.default.join(dist, type)), type);
+        context.options(options => (0, helper_1.readConfigFile)(source, configFiles, options), type);
+    }
+    setDefaultOptions(options, type, src, dist) {
+        let result = (0, deepmerge_1.default)(options, {
+            entry: path_1.default.join(src, "./src/index.js"),
+            context: src,
+            output: {
+                filename: "bundle.js",
+                chunkFilename: "[name].chunk.js"
+            },
+            mode: "development",
+            devtool: false,
+            optimization: {
+                chunkIds: "named",
+                moduleIds: "named"
+            }
+        });
+        if (type === type_1.ECompilerType.Webpack) {
+            result = (0, deepmerge_1.default)(result, {
+                output: {
+                    pathinfo: false,
+                    environment: {
+                        arrowFunction: false,
+                        bigIntLiteral: false,
+                        const: false,
+                        destructuring: false,
+                        dynamicImport: false,
+                        dynamicImportInWorker: false,
+                        forOf: false,
+                        globalThis: false,
+                        module: false,
+                        optionalChaining: false,
+                        templateLiteral: false
+                    },
+                    path: dist
+                },
+                plugins: [(0, module_placeholder_plugin_1.createModulePlaceholderPlugin)(this.options.webpackPath)]
+            }, {
+                arrayMerge: (a, b) => [...a, ...b]
+            });
+        }
+        if (type === type_1.ECompilerType.Rspack) {
+            result = (0, deepmerge_1.default)(result, {
+                output: {
+                    path: dist
+                },
+                experiments: {
+                    rspackFuture: {
+                        disableTransformByDefault: true
+                    }
+                }
+            });
+        }
+        return result;
+    }
+    createFormatOptions() {
+        const formatOptions = {
+            ignoreModuleArugments: this.options.ignoreModuleArugments,
+            ignoreModuleId: this.options.ignoreModuleId,
+            ignorePropertyQuotationMark: this.options.ignorePropertyQuotationMark,
+            replacements: this.options.replacements || {}
+        };
+        for (let hash of this.hashes) {
+            formatOptions.replacements[hash] = "fullhash";
+        }
+        return formatOptions;
+    }
+}
+exports.DiffProcessor = DiffProcessor;

package/dist/test/context.d.ts

@@ -0,0 +1,17 @@
+import { ECompilerType, ITestContext, ITesterConfig, TCompiler, TCompilerOptions, TCompilerStats } from "../type";
+export declare class TestContext implements ITestContext {
+    private config;
+    errors: Error[];
+    private compilers;
+    constructor(config: ITesterConfig);
+    getSource(sub?: string): string;
+    getDist(sub?: string): string;
+    build<T extends ECompilerType>(fn: (compiler: TCompiler<T>) => Promise<void>, name?: string): Promise<void>;
+    options<T extends ECompilerType>(fn: (options: TCompilerOptions<T>) => TCompilerOptions<T>, name?: string): void;
+    compiler<T extends ECompilerType>(fn: (options: TCompilerOptions<T>, compiler: TCompiler<T> | null) => TCompiler<T> | null, name?: string): void;
+    stats<T extends ECompilerType>(fn: (compiler: TCompiler<T> | null, stats: TCompilerStats<T> | null) => TCompilerStats<T> | null, name?: string): void;
+    result<T extends ECompilerType>(fn: <R>(compiler: TCompiler<T> | null, result: R) => R, name?: string): void;
+    emitError(err: Error | string): void;
+    hasError(): boolean;
+    private getCompilerManage;
+}

package/dist/test/context.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestContext = void 0;
+const compiler_1 = require("../compiler");
+const path_1 = __importDefault(require("path"));
+const DEFAULT_COMPILER_NAME = "__default__";
+class TestContext {
+    constructor(config) {
+        this.config = config;
+        this.errors = [];
+        this.compilers = new Map();
+    }
+    getSource(sub) {
+        if (sub) {
+            return path_1.default.resolve(this.config.src, sub);
+        }
+        return this.config.src;
+    }
+    getDist(sub) {
+        if (sub) {
+            return path_1.default.resolve(this.config.dist, sub);
+        }
+        return this.config.dist;
+    }
+    async build(fn, name = DEFAULT_COMPILER_NAME) {
+        const compiler = this.getCompilerManage(name);
+        await compiler.build(this, fn);
+    }
+    options(fn, name = DEFAULT_COMPILER_NAME) {
+        const compiler = this.getCompilerManage(name);
+        compiler.options(this, fn);
+    }
+    compiler(fn, name = DEFAULT_COMPILER_NAME) {
+        const compiler = this.getCompilerManage(name);
+        compiler.compiler(this, fn);
+    }
+    stats(fn, name = DEFAULT_COMPILER_NAME) {
+        const compiler = this.getCompilerManage(name);
+        compiler.stats(this, fn);
+    }
+    result(fn, name = DEFAULT_COMPILER_NAME) {
+        const compiler = this.getCompilerManage(name);
+        compiler.result(this, fn);
+    }
+    emitError(err) {
+        this.errors.push(typeof err === "string" ? new Error(err) : err);
+    }
+    hasError() {
+        return !!this.errors.length;
+    }
+    getCompilerManage(name) {
+        if (!this.compilers.has(name)) {
+            this.compilers.set(name, new compiler_1.TestCompilerManager());
+        }
+        return this.compilers.get(name);
+    }
+}
+exports.TestContext = TestContext;

package/dist/test/tester.d.ts

@@ -0,0 +1,14 @@
+import { ITester, ITesterConfig } from "../type";
+export declare class Tester implements ITester {
+    private context;
+    private steps;
+    step: number;
+    constructor(config: ITesterConfig);
+    prepare(): Promise<void>;
+    compile(): Promise<void>;
+    check(): Promise<void>;
+    next(): boolean;
+    resume(): Promise<void>;
+    private runStepMethods;
+    private outputErrors;
+}

package/dist/test/tester.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tester = void 0;
+const context_1 = require("./context");
+class Tester {
+    constructor(config) {
+        this.steps = [];
+        this.step = 0;
+        this.context = new context_1.TestContext(config);
+        this.steps = config.steps || [];
+        this.step = 0;
+    }
+    async prepare() {
+        for (let i of this.steps) {
+            if (typeof i.beforeAll === "function") {
+                await i.beforeAll(this.context);
+            }
+        }
+    }
+    async compile() {
+        const currentStep = this.steps[this.step];
+        if (!currentStep)
+            return;
+        await this.runStepMethods(currentStep, [
+            "before",
+            "config",
+            "compiler",
+            "build"
+        ]);
+        if (this.context.hasError()) {
+            this.outputErrors();
+            throw new Error("build failed");
+        }
+    }
+    async check() {
+        const currentStep = this.steps[this.step];
+        if (!currentStep)
+            return;
+        await this.runStepMethods(currentStep, ["run", "check", "after"]);
+        if (this.context.hasError()) {
+            this.outputErrors();
+            throw new Error("check failed");
+        }
+    }
+    next() {
+        if (this.context.hasError()) {
+            this.outputErrors();
+            return false;
+        }
+        if (this.steps[this.step + 1]) {
+            this.step++;
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    async resume() {
+        for (let i of this.steps) {
+            if (typeof i.afterAll === "function") {
+                await i.afterAll(this.context);
+            }
+        }
+    }
+    async runStepMethods(step, methods) {
+        for (let i of methods) {
+            if (this.context.hasError())
+                return;
+            if (typeof step[i] === "function") {
+                await step[i](this.context);
+            }
+        }
+    }
+    outputErrors() {
+        console.error(`Errors occur in step ${this.step + 1}:`);
+        for (let error of this.context.errors) {
+            console.error(error);
+        }
+    }
+}
+exports.Tester = Tester;

package/dist/type.d.ts

@@ -0,0 +1,83 @@
+import { RspackOptions, Compiler as RspackCompiler, Stats as RspackStats } from "@rspack/core";
+import type { Configuration as WebpackOptions, Compiler as WebpackCompiler, Stats as WebpackStats } from "webpack";
+export interface ITestContext {
+    errors: Error[];
+    getSource(sub?: string): string;
+    getDist(sub?: string): string;
+    options<T extends ECompilerType>(fn: (options: TCompilerOptions<T>) => TCompilerOptions<T>, name?: string): void;
+    compiler<T extends ECompilerType>(fn: (options: TCompilerOptions<T>, compiler: TCompiler<T> | null) => TCompiler<T> | null, name?: string): void;
+    stats<T extends ECompilerType>(fn: (compiler: TCompiler<T> | null, stats: TCompilerStats<T> | null) => TCompilerStats<T> | null, name?: string): void;
+    result<T extends ECompilerType>(fn: <R>(compiler: TCompiler<T> | null, result: R) => R, name?: string): void;
+    build<T extends ECompilerType>(fn: (compiler: TCompiler<T>) => Promise<void>, name?: string): Promise<void>;
+    emitError(err: Error | string): void;
+    hasError(): boolean;
+}
+export declare enum ECompilerType {
+    Rspack = "rspack",
+    Webpack = "webpack"
+}
+export type TCompilerOptions<T> = T extends ECompilerType.Rspack ? RspackOptions : WebpackOptions;
+export type TCompiler<T> = T extends ECompilerType.Rspack ? RspackCompiler : WebpackCompiler;
+export type TCompilerStats<T> = T extends ECompilerType.Rspack ? RspackStats : WebpackStats;
+export interface ITestCompilerManager<T extends ECompilerType> {
+    options(context: ITestContext, fn: (options: TCompilerOptions<T>) => TCompilerOptions<T>): void;
+    compiler(context: ITestContext, fn: (options: TCompilerOptions<T>, compiler: TCompiler<T> | null) => TCompiler<T> | null): void;
+    stats(context: ITestContext, fn: (compiler: TCompiler<T> | null, stats: TCompilerStats<T> | null) => TCompilerStats<T> | null): void;
+    result(context: ITestContext, fn: <R>(compiler: TCompiler<T> | null, result: R) => R): void;
+    build(context: ITestContext, fn: (compiler: TCompiler<T>) => Promise<void>): Promise<void>;
+}
+export interface ITestLoader {
+    walk(): Promise<void>;
+}
+export interface ITesterConfig {
+    name: string;
+    src: string;
+    dist: string;
+    steps?: ITestProcessor[];
+}
+export interface ITester {
+    step: number;
+    prepare(): Promise<void>;
+    compile(): Promise<void>;
+    check(): Promise<void>;
+    next(): boolean;
+    resume(): Promise<void>;
+}
+export interface ITestProcessor {
+    beforeAll?(context: ITestContext): Promise<void>;
+    afterAll?(context: ITestContext): Promise<void>;
+    before?(context: ITestContext): Promise<void>;
+    after?(context: ITestContext): Promise<void>;
+    config?(context: ITestContext): Promise<void>;
+    compiler?(context: ITestContext): Promise<void>;
+    build?(context: ITestContext): Promise<void>;
+    run?(context: ITestContext): Promise<void>;
+    check?(context: ITestContext): Promise<unknown>;
+}
+export declare enum ECompareResultType {
+    Same = "same",
+    Missing = "missing",
+    OnlyDist = "only-dist",
+    OnlySource = "only-source",
+    Different = "different"
+}
+export type TCompareModules = string[] | true;
+export type TCompareResult = {
+    type: ECompareResultType;
+    detail?: unknown;
+    lines?: {
+        common: number;
+        source: number;
+        dist: number;
+    };
+};
+export type TModuleCompareResult = TCompareResult & {
+    name: string;
+};
+export type TFileCompareResult = TCompareResult & {
+    file: {
+        source: string;
+        dist: string;
+    };
+    modules: Partial<Record<"modules" | "runtimeModules", TModuleCompareResult[]>>;
+};

package/dist/type.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ECompareResultType = exports.ECompilerType = void 0;
+var ECompilerType;
+(function (ECompilerType) {
+    ECompilerType["Rspack"] = "rspack";
+    ECompilerType["Webpack"] = "webpack";
+})(ECompilerType = exports.ECompilerType || (exports.ECompilerType = {}));
+var ECompareResultType;
+(function (ECompareResultType) {
+    ECompareResultType["Same"] = "same";
+    ECompareResultType["Missing"] = "missing";
+    ECompareResultType["OnlyDist"] = "only-dist";
+    ECompareResultType["OnlySource"] = "only-source";
+    ECompareResultType["Different"] = "different";
+})(ECompareResultType = exports.ECompareResultType || (exports.ECompareResultType = {}));

package/dist/webpack/module-placeholder-plugin.d.ts

@@ -0,0 +1,3 @@
+export declare function createModulePlaceholderPlugin(webpackPath: any): {
+    apply(compiler: any): void;
+};

package/dist/webpack/module-placeholder-plugin.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModulePlaceholderPlugin = void 0;
+// @ts-nocheck
+const { ConcatSource, RawSource, CachedSource, PrefixSource } = require("webpack-sources");
+const path = require("path");
+function createRenderRuntimeModulesFn(Template) {
+    return function renderRuntimeModules(runtimeModules, renderContext) {
+        const source = new ConcatSource();
+        for (const module of runtimeModules) {
+            const codeGenerationResults = renderContext.codeGenerationResults;
+            let runtimeSource;
+            if (codeGenerationResults) {
+                runtimeSource = codeGenerationResults.getSource(module, renderContext.chunk.runtime, "runtime");
+            }
+            else {
+                const codeGenResult = module.codeGeneration({
+                    chunkGraph: renderContext.chunkGraph,
+                    dependencyTemplates: renderContext.dependencyTemplates,
+                    moduleGraph: renderContext.moduleGraph,
+                    runtimeTemplate: renderContext.runtimeTemplate,
+                    runtime: renderContext.chunk.runtime,
+                    codeGenerationResults
+                });
+                if (!codeGenResult)
+                    continue;
+                runtimeSource = codeGenResult.sources.get("runtime");
+            }
+            if (runtimeSource) {
+                source.add(Template.toNormalComment(`start::${module.identifier()}`) + "\n");
+                if (!module.shouldIsolate()) {
+                    source.add(runtimeSource);
+                    source.add("\n\n");
+                }
+                else if (renderContext.runtimeTemplate.supportsArrowFunction()) {
+                    source.add("(() => {\n");
+                    source.add(new PrefixSource("\t", runtimeSource));
+                    source.add("\n})();\n\n");
+                }
+                else {
+                    source.add("!function() {\n");
+                    source.add(new PrefixSource("\t", runtimeSource));
+                    source.add("\n}();\n\n");
+                }
+                source.add(Template.toNormalComment(`end::${module.identifier()}`) + "\n");
+            }
+        }
+        return source;
+    };
+}
+const caches = new WeakMap();
+function createModulePlaceholderPlugin(webpackPath) {
+    const JavascriptModulesPlugin = require(path.join(path.dirname(webpackPath), "javascript/JavascriptModulesPlugin.js"));
+    const Template = require(path.join(path.dirname(webpackPath), "Template.js"));
+    Template.renderRuntimeModules = createRenderRuntimeModulesFn(Template);
+    return {
+        apply(compiler) {
+            compiler.hooks.compilation.tap("RuntimeDiffPlugin", compilation => {
+                const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
+                hooks.inlineInRuntimeBailout.tap("RuntimeDiffPlugin", () => "not allow inline startup");
+                hooks.renderModulePackage.tap("RuntimeDiffPlugin", (moduleSource, module, { chunk, chunkGraph, moduleGraph, runtimeTemplate }) => {
+                    const { requestShortener } = runtimeTemplate;
+                    let cacheEntry;
+                    let cache = caches.get(requestShortener);
+                    if (cache === undefined) {
+                        caches.set(requestShortener, (cache = new WeakMap()));
+                        cache.set(module, (cacheEntry = {
+                            header: undefined,
+                            footer: undefined,
+                            full: new WeakMap()
+                        }));
+                    }
+                    else {
+                        cacheEntry = cache.get(module);
+                        if (cacheEntry === undefined) {
+                            cache.set(module, (cacheEntry = {
+                                header: undefined,
+                                footer: undefined,
+                                full: new WeakMap()
+                            }));
+                        }
+                        else {
+                            const cachedSource = cacheEntry.full.get(moduleSource);
+                            if (cachedSource !== undefined)
+                                return cachedSource;
+                        }
+                    }
+                    const source = new ConcatSource();
+                    let header = cacheEntry.header;
+                    let footer = cacheEntry.footer;
+                    if (header === undefined) {
+                        const req = module.readableIdentifier(requestShortener);
+                        const reqStr = req.replace(/\*\//g, "*_/");
+                        header = new RawSource(`\n/* start::${reqStr} */\n`);
+                        footer = new RawSource(`\n/* end::${reqStr} */\n`);
+                        cacheEntry.header = header;
+                        cacheEntry.footer = footer;
+                    }
+                    source.add(header);
+                    source.add(moduleSource);
+                    source.add(footer);
+                    const cachedSource = new CachedSource(source);
+                    cacheEntry.full.set(moduleSource, cachedSource);
+                    return cachedSource;
+                });
+            });
+        }
+    };
+}
+exports.createModulePlaceholderPlugin = createModulePlaceholderPlugin;

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@rspack/test-tools",
+  "version": "0.3.14-canary-020060b-20231122074120",
+  "license": "MIT",
+  "description": "Test tools for rspack",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "client",
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://rspack.dev",
+  "bugs": "https://github.com/web-infra-dev/rspack/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/web-infra-dev/rspack",
+    "directory": "packages/rspack-test-tools"
+  },
+  "dependencies": {
+    "@babel/generator": "7.23.0",
+    "@babel/helpers": "7.23.2",
+    "@babel/parser": "7.23.0",
+    "@babel/template": "7.22.15",
+    "@babel/traverse": "7.23.2",
+    "@babel/types": "7.23.0",
+    "deepmerge": "^4.3.1",
+    "fs-extra": "^11.1.1",
+    "jest-diff": "^29.7.0",
+    "webpack-sources": "3.2.3",
+    "@rspack/core": "0.3.14-canary-020060b-20231122074120"
+  },
+  "devDependencies": {
+    "@types/webpack": "5.28.3",
+    "@types/webpack-sources": "3.2.0",
+    "webpack": "5.89.0"
+  },
+  "peerDependenciesMeta": {},
+  "jest": {
+    "watchPathIgnorePatterns": [
+      "<rootDir>/dist",
+      "<rootDir>/tests/dist"
+    ],
+    "testEnvironment": "../../scripts/test/patch-node-env.cjs"
+  },
+  "scripts": {
+    "build": "rimraf dist/ && tsc -b ./tsconfig.build.json --force",
+    "dev": "tsc -b -w"
+  }
+}