@rspack/test-tools 1.7.0-beta.1 → 1.7.0

package/dist/compiler.js

@@ -40,13 +40,13 @@ class TestCompilerManager {
         return this.compilerInstance;
     }
     createCompiler() {
-        this.compilerInstance = require("@rspack/core")(this.compilerOptions);
+        this.compilerInstance = require('@rspack/core')(this.compilerOptions);
         if (__DEBUG__) {
             const context = this.context;
             this.compilerInstance = new Proxy(this.compilerInstance, {
                 get(target, p, receiver) {
                     const value = Reflect.get(target, p, receiver);
-                    if (typeof value === "function" &&
+                    if (typeof value === 'function' &&
                         core_1.Compiler.prototype.hasOwnProperty(p)) {
                         return value.bind(target);
                     }
@@ -54,27 +54,27 @@ class TestCompilerManager {
                 },
                 set(target, p, value, receiver) {
                     const debugSetProperties = context.getValue(debug_1.DEBUG_SCOPES.CreateCompilerSetProperties) || [];
-                    debugSetProperties.push(`${p} ${new Error().stack?.split("\n")[2]?.trim()}`);
+                    debugSetProperties.push(`${p} ${new Error().stack?.split('\n')[2]?.trim()}`);
                     context.setValue(debug_1.DEBUG_SCOPES.CreateCompilerSetProperties, debugSetProperties);
                     return Reflect.set(target, p, value, receiver);
-                }
+                },
             });
             this.context.setValue(debug_1.DEBUG_SCOPES.CreateCompilerInstance, {
-                path: require.resolve("@rspack/core"),
-                mode: "no-callback"
+                path: require.resolve('@rspack/core'),
+                mode: 'no-callback',
             });
         }
         this.emitter.emit(ECompilerEvent.Create, this.compilerInstance);
         return this.compilerInstance;
     }
     createCompilerWithCallback(callback) {
-        this.compilerInstance = require("@rspack/core")(this.compilerOptions, callback);
+        this.compilerInstance = require('@rspack/core')(this.compilerOptions, callback);
         if (__DEBUG__) {
             const context = this.context;
             this.compilerInstance = new Proxy(this.compilerInstance, {
                 get(target, p, receiver) {
                     const value = Reflect.get(target, p, receiver);
-                    if (typeof value === "function" &&
+                    if (typeof value === 'function' &&
                         core_1.Compiler.prototype.hasOwnProperty(p)) {
                         return value.bind(target);
                     }
@@ -82,14 +82,14 @@ class TestCompilerManager {
                 },
                 set(target, p, value, receiver) {
                     const debugSetProperties = context.getValue(debug_1.DEBUG_SCOPES.CreateCompilerSetProperties) || [];
-                    debugSetProperties.push(`${p} ${new Error().stack?.split("\n")[2]?.trim()}`);
+                    debugSetProperties.push(`${p} ${new Error().stack?.split('\n')[2]?.trim()}`);
                     context.setValue(debug_1.DEBUG_SCOPES.CreateCompilerSetProperties, debugSetProperties);
                     return Reflect.set(target, p, value, receiver);
-                }
+                },
             });
             this.context.setValue(debug_1.DEBUG_SCOPES.CreateCompilerInstance, {
-                path: require.resolve("@rspack/core"),
-                mode: "callback"
+                path: require.resolve('@rspack/core'),
+                mode: 'callback',
             });
         }
         this.emitter.emit(ECompilerEvent.Create, this.compilerInstance);
@@ -97,13 +97,13 @@ class TestCompilerManager {
     }
     build() {
         if (!this.compilerInstance)
-            throw new Error("Compiler should be created before build");
+            throw new Error('Compiler should be created before build');
         return new Promise((resolve, reject) => {
             try {
                 const context = this.context;
                 if (__DEBUG__) {
                     context.setValue(debug_1.DEBUG_SCOPES.BuildMethod, {
-                        method: "run"
+                        method: 'run',
                     });
                 }
                 this.compilerInstance.run((error, newStats) => {
@@ -111,8 +111,8 @@ class TestCompilerManager {
                     if (error) {
                         if (__DEBUG__) {
                             context.setValue(debug_1.DEBUG_SCOPES.BuildError, {
-                                type: "fatal",
-                                errors: [error]
+                                type: 'fatal',
+                                errors: [error],
                             });
                         }
                         return reject(error);
@@ -121,15 +121,15 @@ class TestCompilerManager {
                     if (__DEBUG__) {
                         if (newStats?.hasErrors()) {
                             context.setValue(debug_1.DEBUG_SCOPES.BuildError, {
-                                type: "stats",
+                                type: 'stats',
                                 errors: newStats.toJson({
-                                    errors: true
-                                }).errors || []
+                                    errors: true,
+                                }).errors || [],
                             });
                         }
                         if (newStats?.hasWarnings()) {
                             context.setValue(debug_1.DEBUG_SCOPES.BuildWarning, newStats.toJson({
-                                warnings: true
+                                warnings: true,
                             }).warnings || []);
                         }
                     }
@@ -143,7 +143,7 @@ class TestCompilerManager {
     }
     watch(timeout = 1000) {
         if (!this.compilerInstance)
-            throw new Error("Compiler should be created before watch");
+            throw new Error('Compiler should be created before watch');
         const context = this.context;
         const watchOptions = {
             // IMPORTANT:
@@ -153,12 +153,12 @@ class TestCompilerManager {
             // 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
+            aggregateTimeout: timeout,
         };
         if (__DEBUG__) {
             context.setValue(debug_1.DEBUG_SCOPES.BuildMethod, {
-                method: "watch",
-                options: watchOptions
+                method: 'watch',
+                options: watchOptions,
             });
         }
         this.compilerInstance.watch(watchOptions, (error, newStats) => {
@@ -166,8 +166,8 @@ class TestCompilerManager {
             if (__DEBUG__) {
                 if (error) {
                     context.setValue(debug_1.DEBUG_SCOPES.BuildError, {
-                        type: "fatal",
-                        errors: [error]
+                        type: 'fatal',
+                        errors: [error],
                     });
                     return error;
                 }
@@ -176,15 +176,15 @@ class TestCompilerManager {
                 if (__DEBUG__) {
                     if (newStats.hasErrors()) {
                         context.setValue(debug_1.DEBUG_SCOPES.BuildError, {
-                            type: "stats",
+                            type: 'stats',
                             errors: newStats.toJson({
-                                errors: true
-                            }).errors || []
+                                errors: true,
+                            }).errors || [],
                         });
                     }
                     if (newStats.hasWarnings()) {
                         context.setValue(debug_1.DEBUG_SCOPES.BuildWarning, newStats.toJson({
-                            warnings: true
+                            warnings: true,
                         }).warnings || []);
                     }
                 }
@@ -202,7 +202,7 @@ class TestCompilerManager {
     close() {
         return new Promise((resolve, reject) => {
             if (this.compilerInstance) {
-                this.compilerInstance.close(e => {
+                this.compilerInstance.close((e) => {
                     this.emitter.emit(ECompilerEvent.Close, e);
                     e ? reject(e) : resolve();
                 });

package/dist/helper/directory.d.ts

@@ -2,7 +2,7 @@ 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";
+    type?: 'file' | 'directory';
     level?: number;
     source?: string;
     dist?: string;

package/dist/helper/directory.js

@@ -12,44 +12,44 @@ 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";
+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(/(\.part\d+)?\.(diff|hot)?test\.(j|t)s/, "");
+        .replace(/(\.part\d+)?\.(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 testSourceId = node_path_1.default.basename(sourceBase);
-    const distBase = options.dist || node_path_1.default.join(node_path_1.default.dirname(testFile), "js", testId);
+    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 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 => {
+            .filter((folder) => {
             if (options.exclude) {
-                if (options.exclude.some(exclude => {
-                    return exclude.test(node_path_1.default.join(dirname, folder).replace(/\\/g, "/"));
+                if (options.exclude.some((exclude) => {
+                    return exclude.test(node_path_1.default.join(dirname, folder).replace(/\\/g, '/'));
                 })) {
                     return false;
                 }
             }
             return true;
         })
-            .filter(folder => {
+            .filter((folder) => {
             const p = node_path_1.default.join(sourceBase, dirname, folder);
-            if (type === "file" && currentLevel === 1) {
+            if (type === 'file' && currentLevel === 1) {
                 return (0, exports.isFile)(p);
             }
-            if (type === "directory" || currentLevel > 1) {
+            if (type === 'directory' || currentLevel > 1) {
                 return (0, exports.isDirectory)(p);
             }
             return false;
         })
-            .map(folder => {
+            .map((folder) => {
             const caseName = node_path_1.default.join(dirname, folder);
             if (currentLevel > 1) {
                 describeDirectory(caseName, currentLevel - 1);
@@ -57,16 +57,16 @@ function describeByWalk(testFile, createCase, options = {}) {
             else {
                 const name = (0, _1.escapeSep)(node_path_1.default
                     .join(`${testId}Cases-${testSourceId}`, caseName)
-                    .split(".")
+                    .split('.')
                     .shift());
                 describeFn(name, () => {
                     const source = node_path_1.default.join(sourceBase, caseName);
-                    let dist = "";
+                    let dist = '';
                     if (absoluteDist) {
                         dist = node_path_1.default.join(distBase, caseName);
                     }
                     else {
-                        const relativeDist = options.dist || "dist";
+                        const relativeDist = options.dist || 'dist';
                         if (node_path_1.default.isAbsolute(relativeDist)) {
                             dist = node_path_1.default.join(relativeDist, caseName);
                         }
@@ -80,6 +80,6 @@ function describeByWalk(testFile, createCase, options = {}) {
         });
     }
     describeFn(testId, () => {
-        describeDirectory("", level);
+        describeDirectory('', level);
     });
 }

package/dist/helper/disable-iconv-lite-warning.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.disableIconvLiteWarning = disableIconvLiteWarning;
 function disableIconvLiteWarning() {
     for (const [path, mod] of Object.entries(require.cache)) {
-        if (path.includes("iconv-lite") &&
-            typeof mod?.exports === "object" &&
-            typeof mod.exports.decode === "function") {
+        if (path.includes('iconv-lite') &&
+            typeof mod?.exports === 'object' &&
+            typeof mod.exports.decode === 'function') {
             mod.exports.skipDecodeWarning = true;
         }
     }

package/dist/helper/expect/diff.js

@@ -2,20 +2,20 @@
 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 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 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>");
+    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(cwdRegExp, (_, g) => `<cwd>${g.replace(/\\/g, '/')}`);
+        normalizedStr = normalizedStr.replace(escapedCwdRegExp, (_, g) => `<cwd>${g.replace(/\\\\/g, '/')}`);
     }
-    normalizedStr = normalizedStr.replace(/@@ -\d+,\d+ \+\d+,\d+ @@/g, "@@ ... @@");
+    normalizedStr = normalizedStr.replace(/@@ -\d+,\d+ \+\d+,\d+ @@/g, '@@ ... @@');
     return normalizedStr;
 };
 exports.normalizeDiff = normalizeDiff;

package/dist/helper/expect/error.js

@@ -13,19 +13,19 @@ const prettyFormatOptions = {
     plugins: [
         {
             test(val) {
-                return typeof val === "string";
+                return typeof val === 'string';
             },
             print(val) {
                 return `"${val
-                    .replace(/\\/gm, "/")
+                    .replace(/\\/gm, '/')
                     .replace(/"/gm, '\\"')
-                    .replace(/\r?\n/gm, "")}"`;
-            }
-        }
-    ]
+                    .replace(/\r?\n/gm, '')}"`;
+            },
+        },
+    ],
 };
 function cleanErrorStack(message) {
-    return message.replace(ERROR_STACK_PATTERN, "$1xxx");
+    return message.replace(ERROR_STACK_PATTERN, '$1xxx');
 }
 function cleanError(err) {
     const result = {};
@@ -42,8 +42,8 @@ function cleanError(err) {
 }
 function normalizeDignostics(received) {
     return (0, pretty_format_1.default)({
-        errors: received.errors.map(e => cleanError(e)),
-        warnings: received.warnings.map(e => cleanError(e))
+        errors: received.errors.map((e) => cleanError(e)),
+        warnings: received.warnings.map((e) => cleanError(e)),
     }, prettyFormatOptions).trim();
 }
 function normalizeError(received) {

package/dist/helper/expect/placeholder.js

@@ -6,36 +6,36 @@ const path_serializer_1 = require("path-serializer");
 // 2. replace <RSPACK_ROOT> etc
 // 3. transform win32 sep
 const placeholderSerializer = (0, path_serializer_1.createSnapshotSerializer)({
-    root: __dirname.includes("node_modules")
+    root: __dirname.includes('node_modules')
         ? // Use `process.cwd()` when using outside Rspack
             process.cwd()
         : __ROOT_PATH__,
     replace: [
         {
             match: __RSPACK_TEST_TOOLS_PATH__,
-            mark: "test_tools_root"
+            mark: 'test_tools_root',
         },
         {
             match: __TEST_PATH__,
-            mark: "test_root"
+            mark: 'test_root',
         },
         {
             match: __RSPACK_PATH__,
-            mark: "rspack_root"
+            mark: 'rspack_root',
         },
         {
             match: /:\d+:\d+-\d+:\d+/g,
-            mark: "line_col_range"
+            mark: 'line_col_range',
         },
         {
             match: /:\d+:\d+/g,
-            mark: "line_col"
-        }
+            mark: 'line_col',
+        },
     ],
     features: {
         replaceWorkspace: false,
         addDoubleQuotes: false,
-        escapeDoubleQuotes: false
-    }
+        escapeDoubleQuotes: false,
+    },
 });
 exports.normalizePlaceholder = placeholderSerializer.serialize;

package/dist/helper/expect/rspack.js

@@ -4,11 +4,11 @@ exports.normalizeStats = void 0;
 const normalizeStats = (stats) => {
     return (stats.value
         // CHANGE: Remove potential line break and "|" caused by long text
-        .replace(/((ERROR|WARNING)([\s\S](?!╭|├))*?)(\n {2}│ )/g, "$1")
+        .replace(/((ERROR|WARNING)([\s\S](?!╭|├))*?)(\n {2}│ )/g, '$1')
         // CHANGE: Update the regular expression to replace the 'Rspack' version string
-        .replace(/Rspack [^ )]+(\)?) compiled/g, "Rspack x.x.x$1 compiled")
-        .replace(/(\w)\\(\w)/g, "$1/$2")
-        .replace(/, additional resolving: X ms/g, "")
-        .replace(/Unexpected identifier '.+?'/g, "Unexpected identifier"));
+        .replace(/Rspack [^ )]+(\)?) compiled/g, 'Rspack x.x.x$1 compiled')
+        .replace(/(\w)\\(\w)/g, '$1/$2')
+        .replace(/, additional resolving: X ms/g, '')
+        .replace(/Unexpected identifier '.+?'/g, 'Unexpected identifier'));
 };
 exports.normalizeStats = normalizeStats;

package/dist/helper/expect/to-be-typeof.js

@@ -6,7 +6,7 @@ function toBeTypeOf(received, expected) {
     const objType = typeof received;
     const pass = objType === expected;
     const message = pass
-        ? () => `${this.utils.matcherHint(".not.toBeTypeOf")}\n\nExpected value to not be (using typeof):\n  ${this.utils.printExpected(expected)}\nReceived:\n  ${this.utils.printReceived(objType)}`
-        : () => `${this.utils.matcherHint(".toBeTypeOf")}\n\nExpected value to be (using typeof):\n  ${this.utils.printExpected(expected)}\nReceived:\n  ${this.utils.printReceived(objType)}`;
+        ? () => `${this.utils.matcherHint('.not.toBeTypeOf')}\n\nExpected value to not be (using typeof):\n  ${this.utils.printExpected(expected)}\nReceived:\n  ${this.utils.printReceived(objType)}`
+        : () => `${this.utils.matcherHint('.toBeTypeOf')}\n\nExpected value to be (using typeof):\n  ${this.utils.printExpected(expected)}\nReceived:\n  ${this.utils.printReceived(objType)}`;
     return { message, pass };
 }

package/dist/helper/expect/to-end-with.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.toEndWith = toEndWith;
 // @ts-nocheck
 function toEndWith(received, expected) {
-    const pass = typeof received === "string" && received.endsWith(expected);
+    const pass = typeof received === 'string' && received.endsWith(expected);
     const message = pass
-        ? () => `${this.utils.matcherHint(".not.toEndWith")}\n\nExpected value to not end with:\n  ${this.utils.printExpected(expected)}\nReceived:\n  ${this.utils.printReceived(received)}`
-        : () => `${this.utils.matcherHint(".toEndWith")}\n\nExpected value to end with:\n  ${this.utils.printExpected(expected)}\nReceived:\n  ${this.utils.printReceived(received)}`;
+        ? () => `${this.utils.matcherHint('.not.toEndWith')}\n\nExpected value to not end with:\n  ${this.utils.printExpected(expected)}\nReceived:\n  ${this.utils.printReceived(received)}`
+        : () => `${this.utils.matcherHint('.toEndWith')}\n\nExpected value to end with:\n  ${this.utils.printExpected(expected)}\nReceived:\n  ${this.utils.printReceived(received)}`;
     return { message, pass };
 }

package/dist/helper/expect/to-match-file-snapshot.d.ts

@@ -14,7 +14,7 @@ export declare function toMatchFileSnapshotSync(this: {
         added: number;
         updated: number;
         unmatched: number;
-        _updateSnapshot: "none" | "new" | "all";
+        _updateSnapshot: 'none' | 'new' | 'all';
     };
 }, rawContent: string | Buffer, filepath: string, options?: FileMatcherOptions): {
     pass: boolean;

package/dist/helper/expect/to-match-file-snapshot.js

@@ -12,9 +12,9 @@ const chalk_1 = __importDefault(require("chalk"));
 const filenamify_1 = __importDefault(require("filenamify"));
 const jest_diff_1 = require("jest-diff");
 const serializers_1 = require("../serializers");
-const { serialize } = require(node_path_1.default.join(node_path_1.default.dirname(require.resolve("jest-snapshot")), "./utils.js"));
+const { serialize } = require(node_path_1.default.join(node_path_1.default.dirname(require.resolve('jest-snapshot')), './utils.js'));
 // get jest builtin serializers
-const { getSerializers } = require(node_path_1.default.join(node_path_1.default.dirname(require.resolve("jest-snapshot")), "./plugins.js"));
+const { getSerializers } = require(node_path_1.default.join(node_path_1.default.dirname(require.resolve('jest-snapshot')), './plugins.js'));
 /**
  * Check if 2 strings or buffer are equal
  */
@@ -36,73 +36,73 @@ function toMatchFileSnapshotSync(rawContent, filepath, options = {}) {
             plugins: [
                 ...getSerializers(),
                 // Rspack serializers
-                ...serializers_1.serializers
-            ]
+                ...serializers_1.serializers,
+            ],
         });
     const { isNot, snapshotState } = this;
     const filename = filepath === undefined
         ? // If file name is not specified, generate one from the test title
-            node_path_1.default.join(node_path_1.default.dirname(this.testPath), "__file_snapshots__", `${(0, filenamify_1.default)(this.currentTestName, {
-                replacement: "-"
-            }).replace(/\s/g, "-")}-${this.assertionCalls}`)
+            node_path_1.default.join(node_path_1.default.dirname(this.testPath), '__file_snapshots__', `${(0, filenamify_1.default)(this.currentTestName, {
+                replacement: '-',
+            }).replace(/\s/g, '-')}-${this.assertionCalls}`)
         : filepath;
-    if (snapshotState._updateSnapshot === "none" && !node_fs_1.default.existsSync(filename)) {
+    if (snapshotState._updateSnapshot === 'none' && !node_fs_1.default.existsSync(filename)) {
         // We're probably running in CI environment
         snapshotState.unmatched++;
         return {
             pass: isNot,
-            message: () => `New output file ${chalk_1.default.blue(node_path_1.default.basename(filename))} was ${chalk_1.default.bold.red("not written")}.\n\nThe update flag must be explicitly passed to write a new snapshot.\n\nThis is likely because this test is run in a ${chalk_1.default.blue("continuous integration (CI) environment")} in which snapshots are not written by default.\n\n`
+            message: () => `New output file ${chalk_1.default.blue(node_path_1.default.basename(filename))} was ${chalk_1.default.bold.red('not written')}.\n\nThe update flag must be explicitly passed to write a new snapshot.\n\nThis is likely because this test is run in a ${chalk_1.default.blue('continuous integration (CI) environment')} in which snapshots are not written by default.\n\n`,
         };
     }
     if (node_fs_1.default.existsSync(filename)) {
         const output = node_fs_1.default
-            .readFileSync(filename, Buffer.isBuffer(content) ? null : "utf8")
-            .replace(/\r\n/g, "\n");
+            .readFileSync(filename, Buffer.isBuffer(content) ? null : 'utf8')
+            .replace(/\r\n/g, '\n');
         if (isNot) {
             // The matcher is being used with `.not`
             if (!isEqual(content, output)) {
                 // The value of `pass` is reversed when used with `.not`
-                return { pass: false, message: () => "" };
+                return { pass: false, message: () => '' };
             }
             snapshotState.unmatched++;
             return {
                 pass: true,
-                message: () => `Expected received content ${chalk_1.default.red("to not match")} the file ${chalk_1.default.blue(node_path_1.default.basename(filename))}.`
+                message: () => `Expected received content ${chalk_1.default.red('to not match')} the file ${chalk_1.default.blue(node_path_1.default.basename(filename))}.`,
             };
         }
         if (isEqual(content, output)) {
-            return { pass: true, message: () => "" };
+            return { pass: true, message: () => '' };
         }
-        if (snapshotState._updateSnapshot === "all") {
+        if (snapshotState._updateSnapshot === 'all') {
             node_fs_1.default.mkdirSync(node_path_1.default.dirname(filename), { recursive: true });
             node_fs_1.default.writeFileSync(filename, content);
             snapshotState.updated++;
-            return { pass: true, message: () => "" };
+            return { pass: true, message: () => '' };
         }
         snapshotState.unmatched++;
         const difference = Buffer.isBuffer(content) || Buffer.isBuffer(output)
-            ? ""
+            ? ''
             : `\n\n${(0, jest_diff_1.diff)(output, content, Object.assign({
                 expand: false,
                 contextLines: 5,
-                aAnnotation: "Snapshot"
+                aAnnotation: 'Snapshot',
             }, options.diff || {}))}`;
         return {
             pass: false,
-            message: () => `Received content ${chalk_1.default.red("doesn't match")} the file ${chalk_1.default.blue(node_path_1.default.basename(filename))}.${difference}`
+            message: () => `Received content ${chalk_1.default.red("doesn't match")} the file ${chalk_1.default.blue(node_path_1.default.basename(filename))}.${difference}`,
         };
     }
     if (!isNot &&
-        (snapshotState._updateSnapshot === "new" ||
-            snapshotState._updateSnapshot === "all")) {
+        (snapshotState._updateSnapshot === 'new' ||
+            snapshotState._updateSnapshot === 'all')) {
         node_fs_1.default.mkdirSync(node_path_1.default.dirname(filename), { recursive: true });
         node_fs_1.default.writeFileSync(filename, content);
         snapshotState.added++;
-        return { pass: true, message: () => "" };
+        return { pass: true, message: () => '' };
     }
     snapshotState.unmatched++;
     return {
         pass: true,
-        message: () => `The output file ${chalk_1.default.blue(node_path_1.default.basename(filename))} ${chalk_1.default.bold.red("doesn't exist")}.`
+        message: () => `The output file ${chalk_1.default.blue(node_path_1.default.basename(filename))} ${chalk_1.default.bold.red("doesn't exist")}.`,
     };
 }

package/dist/helper/hot-update/index.d.ts

@@ -1 +1 @@
-export { HotUpdatePlugin } from "./plugin";
+export { HotUpdatePlugin } from './plugin';

package/dist/helper/hot-update/loader.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const loader = function (c) {
-    return c.replace(/NEXT_HMR/g, "NEXT_HMR.bind(null, module)");
+    return c.replace(/NEXT_HMR/g, 'NEXT_HMR.bind(null, module)');
 };
 module.exports = loader;
 exports.default = loader;

package/dist/helper/hot-update/plugin.d.ts

@@ -1,4 +1,4 @@
-import type { Compiler } from "@rspack/core";
+import type { Compiler } from '@rspack/core';
 export declare class HotUpdatePlugin {
     private projectDir;
     private tempDir;