@rspack-debug/test-tools 1.3.14

package/dist/compare/format-code.js

@@ -0,0 +1,239 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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 = formatCode;
+const generator_1 = __importDefault(require("@babel/generator"));
+const parser_1 = require("@babel/parser");
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const T = __importStar(require("@babel/types"));
+const replace_module_argument_1 = require("./replace-module-argument");
+const SWC_HELPER_PATH_REG = /^_swc_helpers_[a-zA-Z\d_-]+__WEBPACK_IMPORTED_MODULE_xxx__$/;
+const CSS_FILE_EXT_REG = /(le|sa|c|sc)ss$/;
+const INVALID_PATH_REG = /[<>:"/\\|?*.]/g;
+const MODULE_ID_REG = /__WEBPACK_IMPORTED_MODULE_\d+__/;
+function formatCode(name, raw, options) {
+    const ast = (0, parser_1.parse)(raw, {
+        sourceType: "unambiguous"
+    });
+    (0, traverse_1.default)(ast, {
+        BlockStatement(path) {
+            if (options.ignoreBlockOnlyStatement) {
+                if (path.parentPath.isBlockStatement()) {
+                    path.replaceWithMultiple(path.node.body);
+                }
+            }
+        },
+        ObjectProperty(path) {
+            if (options.ignorePropertyQuotationMark) {
+                const keyPath = path.get("key");
+                if (keyPath.isIdentifier()) {
+                    keyPath.replaceWith(T.stringLiteral(keyPath.node.name));
+                }
+            }
+            if (options.ignoreCssFilePath && CSS_FILE_EXT_REG.test(name)) {
+                const valuePath = path.get("value");
+                if (valuePath.isStringLiteral()) {
+                    valuePath.node.value = valuePath.node.value.replace(INVALID_PATH_REG, "-");
+                }
+            }
+        },
+        Identifier(path) {
+            if (options.ignoreModuleId) {
+                if (MODULE_ID_REG.test(path.node.name)) {
+                    path.node.name = "__WEBPACK_IMPORTED_MODULE_xxx__";
+                }
+            }
+            if (options.ignoreSwcHelpersPath) {
+                if (SWC_HELPER_PATH_REG.test(path.node.name)) {
+                    path.node.name = "$$SWC_HELPERS$$";
+                }
+            }
+        },
+        StringLiteral(path) {
+            if (path.node.extra?.raw) {
+                path.node.extra.raw = JSON.stringify(path.node.extra.rawValue);
+            }
+        },
+        IfStatement(path) {
+            let consequentNode;
+            let alternateNode;
+            if (options.ignoreBlockOnlyStatement) {
+                const consequent = path.get("consequent");
+                if (consequent.isBlockStatement() &&
+                    consequent.node.body.length === 1) {
+                    consequent.node.body[0].leadingComments =
+                        consequent.node.leadingComments;
+                    consequentNode = consequent.node.body[0];
+                    consequent.replaceWith(consequentNode);
+                }
+                const alternate = path.get("alternate");
+                if (alternate.isBlockStatement() && alternate.node.body.length === 1) {
+                    alternate.node.body[0].leadingComments =
+                        alternate.node.leadingComments;
+                    alternateNode = alternate.node.body[0];
+                    alternate.replaceWith(alternateNode);
+                }
+            }
+            if (options.ignoreIfCertainCondition) {
+                const testExpr = path.get("test");
+                const testResult = testExpr.isBooleanLiteral()
+                    ? testExpr.node.value
+                    : undefined;
+                if (typeof testResult === "boolean") {
+                    if (testResult) {
+                        const consequent = path.get("consequent");
+                        if (consequent.isBlockStatement()) {
+                            if (consequentNode) {
+                                path.replaceWith(consequentNode);
+                            }
+                            else {
+                                path.replaceWithMultiple(consequent.node.body);
+                            }
+                        }
+                        else {
+                            path.replaceWith(consequent);
+                        }
+                    }
+                    else {
+                        const alternate = path.get("alternate");
+                        if (alternate.isBlockStatement()) {
+                            if (alternateNode) {
+                                path.replaceWith(alternateNode);
+                            }
+                            else {
+                                path.replaceWithMultiple(alternate.node.body);
+                            }
+                        }
+                        else if (alternate.isStatement()) {
+                            path.replaceWith(alternate);
+                        }
+                        else {
+                            path.remove();
+                        }
+                    }
+                }
+            }
+        },
+        For(path) {
+            if (options.ignoreBlockOnlyStatement) {
+                const body = path.get("body");
+                if (body.isBlockStatement() && body.node.body.length === 1) {
+                    body.node.body[0].leadingComments = body.node.leadingComments;
+                    body.replaceWith(T.cloneNode(body.node.body[0], true, false));
+                }
+            }
+        },
+        While(path) {
+            if (options.ignoreBlockOnlyStatement) {
+                const body = path.get("body");
+                if (body.isBlockStatement() && body.node.body.length === 1) {
+                    body.node.body[0].leadingComments = body.node.leadingComments;
+                    body.replaceWith(T.cloneNode(body.node.body[0], true, false));
+                }
+            }
+        },
+        SwitchCase(path) {
+            if (path.node.consequent.length === 1 &&
+                path.node.consequent[0].type === "BlockStatement") {
+                path.node.consequent = path.node.consequent[0].body;
+            }
+        },
+        ObjectExpression(path) {
+            if (options.ignoreObjectPropertySequence) {
+                const result = [];
+                let safe = [];
+                while (path.node.properties.length || safe.length) {
+                    const cur = path.node.properties.shift();
+                    if (cur && T.isObjectProperty(cur)) {
+                        if (T.isIdentifier(cur.key)) {
+                            safe.push({
+                                name: cur.key.name,
+                                node: cur
+                            });
+                            continue;
+                        }
+                        if (T.isStringLiteral(cur.key)) {
+                            safe.push({
+                                name: cur.key.value,
+                                node: cur
+                            });
+                            continue;
+                        }
+                    }
+                    if (safe.length) {
+                        safe.sort((a, b) => (a.name > b.name ? 1 : -1));
+                        result.push(...safe.map(n => n.node));
+                        safe = [];
+                    }
+                    if (cur) {
+                        result.push(cur);
+                    }
+                }
+                path.node.properties = result;
+            }
+        }
+    });
+    let result = (0, generator_1.default)(ast, {
+        comments: false,
+        compact: false,
+        concise: false,
+        jsescOption: {
+            quotes: "double"
+        }
+    }).code;
+    if (options.ignoreModuleArguments) {
+        result = (0, replace_module_argument_1.replaceModuleArgument)(result);
+    }
+    if (options.replacements) {
+        for (const { from, to } of options.replacements) {
+            result = result.replaceAll(from, to);
+        }
+    }
+    // result of generate() is not stable with comments sometimes
+    // so do it again
+    return (0, generator_1.default)((0, parser_1.parse)(result, {
+        sourceType: "unambiguous"
+    }), {
+        comments: false,
+        compact: false,
+        concise: false,
+        jsescOption: {
+            quotes: "double"
+        }
+    }).code.trim();
+}

package/dist/compare/index.d.ts

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

package/dist/compare/index.js

@@ -0,0 +1,21 @@
+"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("./comparator"), exports);
+__exportStar(require("./compare"), exports);
+__exportStar(require("./format-code"), exports);
+__exportStar(require("./replace-module-argument"), exports);
+__exportStar(require("./replace-runtime-module-name"), 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,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceModuleArgument = replaceModuleArgument;
+function replaceModuleArgument(raw) {
+    return raw
+        .trim()
+        .replace(/^\(function\s?\([\w_,\s]+\)\s?{/, "(function () {");
+}

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

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

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceRuntimeModuleName = replaceRuntimeModuleName;
+const RUNTIME_MODULE_REGEX = /(webpack\/runtime\/)([a-z_]+)/g;
+const RUNTIME_MODULE_NAME_REPLACER = {
+    auto_public_path: "publicPath",
+    public_path: "publicPath",
+    async_module: "async module",
+    base_uri: "base uri",
+    chunk_name: "chunkName",
+    compat_get_default_export: "compat get default export",
+    compat: "compat",
+    create_fake_namespace_object: "create fake namespace object",
+    create_script_url: "trusted types script url",
+    create_script: "trusted types script",
+    define_property_getters: "define property getters",
+    ensure_chunk: "ensure chunk",
+    get_full_hash: "getFullHash",
+    get_trusted_types_policy: "trusted types policy",
+    global: "global",
+    has_own_property: "hasOwnProperty shorthand",
+    load_script: "load script",
+    make_namespace_object: "make namespace object",
+    nonce: "nonce",
+    on_chunk_loaded: "chunk loaded",
+    relative_url: "relative url",
+    runtime_id: "runtimeId",
+    startup_chunk_dependencies: "startup chunk dependencies",
+    startup_entrypoint: "startup entrypoint",
+    system_context: "__system_context__",
+    chunk_prefetch_startup: "startup prefetch",
+    chunk_prefetch_trigger: "chunk prefetch trigger",
+    chunk_preload_trigger: "chunk preload trigger",
+    css_loading: "css loading",
+    async_wasm_loading: "wasm loading",
+    hot_module_replacement: "hot module replacement",
+    readfile_chunk_loading: "readFile chunk loading",
+    require_chunk_loading: "require chunk loading",
+    import_scripts_chunk_loading: "importScripts chunk loading",
+    module_chunk_loading: "import chunk loading",
+    export_webpack_runtime: "export webpack runtime",
+    jsonp_chunk_loading: "jsonp chunk loading",
+    remote: "remotes loading",
+    share: "sharing",
+    consume_shared: "consumes",
+    esm_module_decorator: "harmony module decorator",
+    node_module_decorator: "node module decorator"
+};
+const RUNTIME_MODULE_NAME_MAPPING = {
+    // 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(content) {
+    let res = content.replace(RUNTIME_MODULE_REGEX, (_, $1, $2) => `${$1}${RUNTIME_MODULE_NAME_REPLACER[$2] || $2}`);
+    res = Object.entries(RUNTIME_MODULE_NAME_MAPPING).reduce((res, [rspackName, webpackName]) => {
+        if (RUNTIME_MODULE_PARAM_REGEX[rspackName]) {
+            return res.replace(RUNTIME_MODULE_PARAM_REGEX[rspackName], (_, $1, $2) => {
+                return webpackName.replace("$1", $1.trim()) + ($2 ? " */" : "");
+            });
+        }
+        return res.replaceAll(rspackName, webpackName);
+    }, res);
+    return res;
+}

package/dist/compiler.d.ts

@@ -0,0 +1,28 @@
+import EventEmitter from "node:events";
+import { ECompilerType, type ITestCompilerManager, type TCompiler, type TCompilerFactories, type TCompilerOptions, type TCompilerStats } from "./type";
+export declare enum ECompilerEvent {
+    Build = "build",
+    Option = "option",
+    Create = "create",
+    Close = "close"
+}
+export declare const COMPILER_FACTORIES: TCompilerFactories;
+export declare class TestCompilerManager<T extends ECompilerType> implements ITestCompilerManager<T> {
+    protected type: T;
+    protected factories: TCompilerFactories;
+    protected compilerOptions: TCompilerOptions<T>;
+    protected compilerInstance: TCompiler<T> | null;
+    protected compilerStats: TCompilerStats<T> | null;
+    protected emitter: EventEmitter;
+    constructor(type: T, factories?: TCompilerFactories);
+    getOptions(): TCompilerOptions<T>;
+    setOptions(newOptions: TCompilerOptions<T>): TCompilerOptions<T>;
+    mergeOptions(newOptions: TCompilerOptions<T>): TCompilerOptions<T>;
+    getCompiler(): TCompiler<T> | null;
+    createCompiler(): TCompiler<T>;
+    build(): Promise<TCompilerStats<T>>;
+    watch(timeout?: number): void;
+    getStats(): TCompilerStats<T> | null;
+    getEmitter(): EventEmitter<[never]>;
+    close(): Promise<void>;
+}

package/dist/compiler.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestCompilerManager = exports.COMPILER_FACTORIES = exports.ECompilerEvent = void 0;
+const node_events_1 = __importDefault(require("node:events"));
+const webpack_merge_1 = __importDefault(require("webpack-merge"));
+const type_1 = require("./type");
+var ECompilerEvent;
+(function (ECompilerEvent) {
+    ECompilerEvent["Build"] = "build";
+    ECompilerEvent["Option"] = "option";
+    ECompilerEvent["Create"] = "create";
+    ECompilerEvent["Close"] = "close";
+})(ECompilerEvent || (exports.ECompilerEvent = ECompilerEvent = {}));
+exports.COMPILER_FACTORIES = {
+    [type_1.ECompilerType.Rspack]: ((options) => require("@rspack/core")(options)),
+    [type_1.ECompilerType.Webpack]: ((options) => require("webpack")(options))
+};
+class TestCompilerManager {
+    constructor(type, factories = exports.COMPILER_FACTORIES) {
+        this.type = type;
+        this.factories = factories;
+        this.compilerOptions = {};
+        this.compilerInstance = null;
+        this.compilerStats = null;
+        this.emitter = new node_events_1.default();
+    }
+    getOptions() {
+        return this.compilerOptions;
+    }
+    setOptions(newOptions) {
+        this.compilerOptions = newOptions;
+        this.emitter.emit(ECompilerEvent.Option, this.compilerOptions);
+        return this.compilerOptions;
+    }
+    mergeOptions(newOptions) {
+        this.compilerOptions = (0, webpack_merge_1.default)(this.compilerOptions, newOptions);
+        this.emitter.emit(ECompilerEvent.Option, this.compilerOptions);
+        return this.compilerOptions;
+    }
+    getCompiler() {
+        return this.compilerInstance;
+    }
+    createCompiler() {
+        this.compilerInstance = this.factories[this.type](this.compilerOptions);
+        this.emitter.emit(ECompilerEvent.Create, this.compilerInstance);
+        return this.compilerInstance;
+    }
+    build() {
+        if (!this.compilerInstance)
+            throw new Error("Compiler should be created before build");
+        return new Promise((resolve, reject) => {
+            try {
+                this.compilerInstance.run((error, newStats) => {
+                    this.emitter.emit(ECompilerEvent.Build, error, newStats);
+                    if (error)
+                        return reject(error);
+                    this.compilerStats = newStats;
+                    resolve(newStats);
+                });
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    }
+    watch(timeout = 1000) {
+        if (!this.compilerInstance)
+            throw new Error("Compiler should be created before watch");
+        this.compilerInstance.watch({
+            // IMPORTANT:
+            // This is a workaround for the issue that watchpack cannot detect the file change in time
+            // so we set the poll to 300ms to make it more sensitive to the file change
+            poll: 300,
+            // Rspack ignored node_modules and .git by default for better performance, but for tests we
+            // want to watch all files, which aligns with webpack's default behavior
+            ignored: [],
+            aggregateTimeout: timeout
+        }, (error, newStats) => {
+            this.emitter.emit(ECompilerEvent.Build, error, newStats);
+            if (error)
+                return error;
+            if (newStats) {
+                this.compilerStats = newStats;
+            }
+            return newStats;
+        });
+    }
+    getStats() {
+        return this.compilerStats;
+    }
+    getEmitter() {
+        return this.emitter;
+    }
+    close() {
+        return new Promise((resolve, reject) => {
+            if (this.compilerInstance) {
+                this.compilerInstance.close(e => {
+                    this.emitter.emit(ECompilerEvent.Close, e);
+                    e ? reject(e) : resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+}
+exports.TestCompilerManager = TestCompilerManager;

package/dist/helper/directory.d.ts

@@ -0,0 +1,12 @@
+export declare const isDirectory: (p: string) => boolean;
+export declare const isFile: (p: string) => boolean;
+export declare const isValidCaseDirectory: (name: string) => boolean;
+export declare function describeByWalk(testFile: string, createCase: (name: string, src: string, dist: string) => void, options?: {
+    type?: "file" | "directory";
+    level?: number;
+    source?: string;
+    dist?: string;
+    absoluteDist?: boolean;
+    describe?: jest.Describe;
+    exclude?: RegExp[];
+}): void;

package/dist/helper/directory.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidCaseDirectory = exports.isFile = exports.isDirectory = void 0;
+exports.describeByWalk = describeByWalk;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const _1 = require(".");
+const isDirectory = (p) => node_fs_1.default.lstatSync(p).isDirectory();
+exports.isDirectory = isDirectory;
+const isFile = (p) => node_fs_1.default.lstatSync(p).isFile();
+exports.isFile = isFile;
+const isValidCaseDirectory = (name) => !name.startsWith("_") && !name.startsWith(".") && name !== "node_modules";
+exports.isValidCaseDirectory = isValidCaseDirectory;
+function describeByWalk(testFile, createCase, options = {}) {
+    const describeFn = options.describe || describe;
+    const testBasename = node_path_1.default
+        .basename(testFile)
+        .replace(/\.(diff|hot)?test\.(j|t)s/, "");
+    const testId = testBasename.charAt(0).toLowerCase() + testBasename.slice(1);
+    const sourceBase = options.source || node_path_1.default.join(node_path_1.default.dirname(testFile), `${testId}Cases`);
+    const distBase = options.dist || node_path_1.default.join(node_path_1.default.dirname(testFile), "js", testId);
+    const level = options.level || 2;
+    const type = options.type || "directory";
+    const absoluteDist = options.absoluteDist ?? true;
+    function describeDirectory(dirname, currentLevel) {
+        node_fs_1.default.readdirSync(node_path_1.default.join(sourceBase, dirname))
+            .filter(exports.isValidCaseDirectory)
+            .filter(folder => {
+            if (options.exclude) {
+                if (options.exclude.some(exclude => {
+                    return exclude.test(folder);
+                })) {
+                    return false;
+                }
+            }
+            return true;
+        })
+            .filter(folder => {
+            const p = node_path_1.default.join(sourceBase, dirname, folder);
+            if (type === "file" && currentLevel === 1) {
+                return (0, exports.isFile)(p);
+            }
+            if (type === "directory" || currentLevel > 1) {
+                return (0, exports.isDirectory)(p);
+            }
+            return false;
+        })
+            .map(folder => {
+            const caseName = node_path_1.default.join(dirname, folder);
+            if (currentLevel > 1) {
+                describeDirectory(caseName, currentLevel - 1);
+            }
+            else {
+                const name = (0, _1.escapeSep)(node_path_1.default.join(testId, caseName).split(".").shift());
+                describeFn(name, () => {
+                    const source = node_path_1.default.join(sourceBase, caseName);
+                    let dist = "";
+                    if (absoluteDist) {
+                        dist = node_path_1.default.join(distBase, caseName);
+                    }
+                    else {
+                        const relativeDist = options.dist || "dist";
+                        if (node_path_1.default.isAbsolute(relativeDist)) {
+                            dist = node_path_1.default.join(relativeDist, caseName);
+                        }
+                        else {
+                            dist = node_path_1.default.join(sourceBase, caseName, relativeDist);
+                        }
+                    }
+                    createCase(name, source, dist);
+                });
+            }
+        });
+    }
+    describeFn(testId, () => {
+        describeDirectory("", level);
+    });
+}

package/dist/helper/expect/diff.d.ts

@@ -0,0 +1,3 @@
+export declare const normalizeDiff: (diff: {
+    value: string;
+}) => string;

package/dist/helper/expect/diff.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeDiff = void 0;
+const CURRENT_CWD = process.cwd();
+const quoteMeta = (str) => str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
+const cwdRegExp = new RegExp(`${quoteMeta(CURRENT_CWD)}((?:\\\\)?(?:[a-zA-Z.\\-_]+\\\\)*)`, "g");
+const escapedCwd = JSON.stringify(CURRENT_CWD).slice(1, -1);
+const escapedCwdRegExp = new RegExp(`${quoteMeta(escapedCwd)}((?:\\\\\\\\)?(?:[a-zA-Z.\\-_]+\\\\\\\\)*)`, "g");
+const normalizeDiff = (diff) => {
+    let normalizedStr = diff.value;
+    if (CURRENT_CWD.startsWith("/")) {
+        normalizedStr = normalizedStr.replace(new RegExp(quoteMeta(CURRENT_CWD), "g"), "<cwd>");
+    }
+    else {
+        normalizedStr = normalizedStr.replace(cwdRegExp, (_, g) => `<cwd>${g.replace(/\\/g, "/")}`);
+        normalizedStr = normalizedStr.replace(escapedCwdRegExp, (_, g) => `<cwd>${g.replace(/\\\\/g, "/")}`);
+    }
+    normalizedStr = normalizedStr.replace(/@@ -\d+,\d+ \+\d+,\d+ @@/g, "@@ ... @@");
+    return normalizedStr;
+};
+exports.normalizeDiff = normalizeDiff;

package/dist/helper/expect/error.d.ts

@@ -0,0 +1,5 @@
+export declare function normalizeDignostics(received: {
+    errors: Error[];
+    warnings: Error[];
+}): string;
+export declare function normalizeError(received: Error): string;

package/dist/helper/expect/error.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeDignostics = normalizeDignostics;
+exports.normalizeError = normalizeError;
+const pretty_format_1 = __importDefault(require("pretty-format"));
+const ERROR_STACK_PATTERN = /(│.* at ).*/g;
+const prettyFormatOptions = {
+    escapeRegex: false,
+    printFunctionName: false,
+    plugins: [
+        {
+            test(val) {
+                return typeof val === "string";
+            },
+            print(val) {
+                return `"${val
+                    .replace(/\\/gm, "/")
+                    .replace(/"/gm, '\\"')
+                    .replace(/\r?\n/gm, "\\n")}"`;
+            }
+        }
+    ]
+};
+function cleanErrorStack(message) {
+    return message.replace(ERROR_STACK_PATTERN, "$1xxx");
+}
+function cleanError(err) {
+    const result = {};
+    for (const key of Object.getOwnPropertyNames(err)) {
+        result[key] = err[key];
+    }
+    if (result.message) {
+        result.message = cleanErrorStack(err.message);
+    }
+    if (result.stack) {
+        result.stack = cleanErrorStack(result.stack);
+    }
+    return result;
+}
+function normalizeDignostics(received) {
+    return (0, pretty_format_1.default)({
+        errors: received.errors.map(e => cleanError(e)),
+        warnings: received.warnings.map(e => cleanError(e))
+    }, prettyFormatOptions).trim();
+}
+function normalizeError(received) {
+    return (0, pretty_format_1.default)(cleanError(received), prettyFormatOptions).trim();
+}