elit 3.6.6 → 3.6.7

package/dist/test-reporter.cjs

@@ -17,9 +17,9 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/test-reporter.ts
-var test_reporter_exports = {};
-__export(test_reporter_exports, {
+// src/test/reporter/index.ts
+var reporter_exports = {};
+__export(reporter_exports, {
   DotReporter: () => DotReporter,
   JsonReporter: () => JsonReporter,
   TestReporter: () => TestReporter,
@@ -27,9 +27,9 @@ __export(test_reporter_exports, {
   formatErrorStack: () => formatErrorStack,
   formatProgress: () => formatProgress
 });
-module.exports = __toCommonJS(test_reporter_exports);
+module.exports = __toCommonJS(reporter_exports);
 
-// src/runtime.ts
+// src/shares/runtime.ts
 var runtime = (() => {
   if (typeof Deno !== "undefined") return "deno";
   if (typeof Bun !== "undefined") return "bun";
@@ -39,37 +39,33 @@ var isNode = runtime === "node";
 var isBun = runtime === "bun";
 var isDeno = runtime === "deno";
 
-// src/path.ts
+// src/server/path/platform.ts
 function getSeparator(isWin) {
   return isWin ? "\\" : "/";
 }
 function getCwd() {
   if (isNode || isBun) {
     return process.cwd();
-  } else if (isDeno) {
+  }
+  if (isDeno) {
     return Deno.cwd();
   }
   return "/";
 }
+var isWindows = (() => {
+  if (isNode) {
+    return process.platform === "win32";
+  }
+  if (isDeno) {
+    return Deno.build.os === "windows";
+  }
+  return typeof process !== "undefined" && process.platform === "win32";
+})();
+
+// src/server/path/operations.ts
 function findLastSeparator(path) {
   return Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
 }
-function createPathOps(isWin) {
-  return {
-    sep: getSeparator(isWin),
-    delimiter: isWin ? ";" : ":",
-    normalize: (path) => normalizePath(path, isWin),
-    join: (...paths) => joinPaths(paths, isWin),
-    resolve: (...paths) => resolvePaths(paths, isWin),
-    isAbsolute: (path) => isWin ? isAbsoluteWin(path) : isAbsolutePosix(path),
-    relative: (from, to) => relativePath(from, to, isWin),
-    dirname: (path) => getDirname(path, isWin),
-    basename: (path, ext) => getBasename(path, ext, isWin),
-    extname: (path) => getExtname(path),
-    parse: (path) => parsePath(path, isWin),
-    format: (pathObject) => formatPath(pathObject, isWin)
-  };
-}
 function isAbsolutePosix(path) {
   return path.length > 0 && path[0] === "/";
 }
@@ -90,28 +86,18 @@ function isAbsoluteWin(path) {
   }
   return false;
 }
-var isWindows = (() => {
-  if (isNode) {
-    return process.platform === "win32";
-  } else if (isDeno) {
-    return Deno.build.os === "windows";
-  }
-  return typeof process !== "undefined" && process.platform === "win32";
-})();
-var posix = createPathOps(false);
-var win32 = createPathOps(true);
 function normalizePath(path, isWin) {
   if (path.length === 0) return ".";
   const separator = getSeparator(isWin);
   const isAbsolute = isWin ? isAbsoluteWin(path) : isAbsolutePosix(path);
   const trailingSeparator = path[path.length - 1] === separator || isWin && path[path.length - 1] === "/";
-  let normalized = path.replace(isWin ? /[\/\\]+/g : /\/+/g, separator);
+  const normalized = path.replace(isWin ? /[\/\\]+/g : /\/+/g, separator);
   const parts = normalized.split(separator);
   const result = [];
-  for (let i = 0; i < parts.length; i++) {
-    const part = parts[i];
+  for (let index = 0; index < parts.length; index++) {
+    const part = parts[index];
     if (part === "" || part === ".") {
-      if (i === 0 && isAbsolute) result.push("");
+      if (index === 0 && isAbsolute) result.push("");
       continue;
     }
     if (part === "..") {
@@ -126,21 +112,21 @@ function normalizePath(path, isWin) {
       result.push(part);
     }
   }
-  let final = result.join(separator);
-  if (final.length === 0) {
+  let finalPath = result.join(separator);
+  if (finalPath.length === 0) {
     return isAbsolute ? separator : ".";
   }
-  if (trailingSeparator && final[final.length - 1] !== separator) {
-    final += separator;
+  if (trailingSeparator && finalPath[finalPath.length - 1] !== separator) {
+    finalPath += separator;
   }
-  return final;
+  return finalPath;
 }
 function joinPaths(paths, isWin) {
   if (paths.length === 0) return ".";
   const separator = getSeparator(isWin);
   let joined = "";
-  for (let i = 0; i < paths.length; i++) {
-    const path = paths[i];
+  for (let index = 0; index < paths.length; index++) {
+    const path = paths[index];
     if (path && path.length > 0) {
       if (joined.length === 0) {
         joined = path;
@@ -155,43 +141,43 @@ function joinPaths(paths, isWin) {
 function resolvePaths(paths, isWin) {
   const separator = getSeparator(isWin);
   let resolved = "";
-  let isAbsolute = false;
-  for (let i = paths.length - 1; i >= 0 && !isAbsolute; i--) {
-    const path = paths[i];
+  let absolute = false;
+  for (let index = paths.length - 1; index >= 0 && !absolute; index--) {
+    const path = paths[index];
     if (path && path.length > 0) {
       resolved = path + (resolved.length > 0 ? separator + resolved : "");
-      isAbsolute = isWin ? isAbsoluteWin(resolved) : isAbsolutePosix(resolved);
+      absolute = isWin ? isAbsoluteWin(resolved) : isAbsolutePosix(resolved);
     }
   }
-  if (!isAbsolute) {
+  if (!absolute) {
     const cwd = getCwd();
     resolved = cwd + (resolved.length > 0 ? separator + resolved : "");
   }
   return normalizePath(resolved, isWin);
 }
 function relativePath(from, to, isWin) {
-  from = resolvePaths([from], isWin);
-  to = resolvePaths([to], isWin);
-  if (from === to) return "";
+  const resolvedFrom = resolvePaths([from], isWin);
+  const resolvedTo = resolvePaths([to], isWin);
+  if (resolvedFrom === resolvedTo) return "";
   const separator = getSeparator(isWin);
-  const fromParts = from.split(separator).filter((p) => p.length > 0);
-  const toParts = to.split(separator).filter((p) => p.length > 0);
-  let commonLength = 0;
+  const fromParts = resolvedFrom.split(separator).filter((part) => part.length > 0);
+  const toParts = resolvedTo.split(separator).filter((part) => part.length > 0);
   const minLength = Math.min(fromParts.length, toParts.length);
-  for (let i = 0; i < minLength; i++) {
-    if (fromParts[i] === toParts[i]) {
+  let commonLength = 0;
+  for (let index = 0; index < minLength; index++) {
+    if (fromParts[index] === toParts[index]) {
       commonLength++;
     } else {
       break;
     }
   }
-  const upCount = fromParts.length - commonLength;
   const result = [];
-  for (let i = 0; i < upCount; i++) {
+  const upCount = fromParts.length - commonLength;
+  for (let index = 0; index < upCount; index++) {
     result.push("..");
   }
-  for (let i = commonLength; i < toParts.length; i++) {
-    result.push(toParts[i]);
+  for (let index = commonLength; index < toParts.length; index++) {
+    result.push(toParts[index]);
   }
   return result.join(separator) || ".";
 }
@@ -199,15 +185,15 @@ function getDirname(path, isWin) {
   if (path.length === 0) return ".";
   const separator = getSeparator(isWin);
   const normalized = normalizePath(path, isWin);
-  const lastSepIndex = normalized.lastIndexOf(separator);
-  if (lastSepIndex === -1) return ".";
-  if (lastSepIndex === 0) return separator;
-  return normalized.slice(0, lastSepIndex);
+  const lastSeparatorIndex = normalized.lastIndexOf(separator);
+  if (lastSeparatorIndex === -1) return ".";
+  if (lastSeparatorIndex === 0) return separator;
+  return normalized.slice(0, lastSeparatorIndex);
 }
 function getBasename(path, ext, isWin) {
   if (path.length === 0) return "";
-  const lastSepIndex = isWin ? findLastSeparator(path) : path.lastIndexOf("/");
-  let base = lastSepIndex === -1 ? path : path.slice(lastSepIndex + 1);
+  const lastSeparatorIndex = isWin ? findLastSeparator(path) : path.lastIndexOf("/");
+  let base = lastSeparatorIndex === -1 ? path : path.slice(lastSeparatorIndex + 1);
   if (ext && base.endsWith(ext)) {
     base = base.slice(0, base.length - ext.length);
   }
@@ -215,8 +201,8 @@ function getBasename(path, ext, isWin) {
 }
 function getExtname(path) {
   const lastDotIndex = path.lastIndexOf(".");
-  const lastSepIndex = findLastSeparator(path);
-  if (lastDotIndex === -1 || lastDotIndex < lastSepIndex || lastDotIndex === path.length - 1) {
+  const lastSeparatorIndex = findLastSeparator(path);
+  if (lastDotIndex === -1 || lastDotIndex < lastSeparatorIndex || lastDotIndex === path.length - 1) {
     return "";
   }
   return path.slice(lastDotIndex);
@@ -232,10 +218,8 @@ function parsePath(path, isWin) {
     } else if (path[0] === "\\" || path[0] === "/") {
       root = "\\";
     }
-  } else {
-    if (path[0] === "/") {
-      root = "/";
-    }
+  } else if (path[0] === "/") {
+    root = "/";
   }
   const dir = getDirname(path, isWin);
   const base = getBasename(path, void 0, isWin);
@@ -251,11 +235,31 @@ function formatPath(pathObject, isWin) {
   if (dir === pathObject.root) return dir + base;
   return dir + separator + base;
 }
+function createPathOps(isWin) {
+  return {
+    sep: getSeparator(isWin),
+    delimiter: isWin ? ";" : ":",
+    normalize: (path) => normalizePath(path, isWin),
+    join: (...paths) => joinPaths(paths, isWin),
+    resolve: (...paths) => resolvePaths(paths, isWin),
+    isAbsolute: (path) => isWin ? isAbsoluteWin(path) : isAbsolutePosix(path),
+    relative: (from, to) => relativePath(from, to, isWin),
+    dirname: (path) => getDirname(path, isWin),
+    basename: (path, ext) => getBasename(path, ext, isWin),
+    extname: (path) => getExtname(path),
+    parse: (path) => parsePath(path, isWin),
+    format: (pathObject) => formatPath(pathObject, isWin)
+  };
+}
+
+// src/server/path/index.ts
+var posix = createPathOps(false);
+var win32 = createPathOps(true);
 function relative(from, to) {
   return relativePath(from, to, isWindows);
 }
 
-// src/test-reporter.ts
+// src/test/reporter/colors.ts
 var colors = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -267,68 +271,220 @@ var colors = {
   cyan: "\x1B[36m",
   white: "\x1B[37m"
 };
+function colorize(color, text, enabled = true) {
+  return enabled ? colors[color] + text + colors.reset : text;
+}
+
+// src/test/reporter/suggestions.ts
 function extractArg(code, functionName) {
-  const searchStr = `.${functionName}(`;
-  const startIndex = code.indexOf(searchStr);
+  const searchString = `.${functionName}(`;
+  const startIndex = code.indexOf(searchString);
   if (startIndex === -1) return null;
   let parenCount = 0;
   let inString = false;
   let stringChar = "";
-  let argStart = startIndex + searchStr.length;
-  for (let i = argStart; i < code.length; i++) {
-    const char = code[i];
+  const argumentStart = startIndex + searchString.length;
+  for (let index = argumentStart; index < code.length; index++) {
+    const char = code[index];
     if (!inString) {
-      if (char === "(") parenCount++;
-      else if (char === ")") {
+      if (char === "(") {
+        parenCount++;
+      } else if (char === ")") {
         parenCount--;
         if (parenCount < 0) {
-          return code.slice(argStart, i);
+          return code.slice(argumentStart, index);
         }
       } else if (char === '"' || char === "'" || char === "`") {
         inString = true;
         stringChar = char;
       }
-    } else {
-      if (char === "\\" && i + 1 < code.length) {
-        i++;
-      } else if (char === stringChar) {
-        inString = false;
-      }
+    } else if (char === "\\" && index + 1 < code.length) {
+      index++;
+    } else if (char === stringChar) {
+      inString = false;
     }
   }
   return null;
 }
-function extractReceivedValue(errorMsg) {
-  const receivedIndex = errorMsg.indexOf("Received:");
+function extractReceivedValue(errorMessage) {
+  const receivedIndex = errorMessage.indexOf("Received:");
   if (receivedIndex === -1) return null;
-  const afterReceived = errorMsg.slice(receivedIndex + 9).trimStart();
+  const afterReceived = errorMessage.slice(receivedIndex + 9).trimStart();
   const newlineIndex = afterReceived.indexOf("\n");
   if (newlineIndex !== -1) {
     return afterReceived.slice(0, newlineIndex).trimEnd();
   }
   return afterReceived.trimEnd();
 }
-function parseQuotedString(str) {
-  if (str.length < 2) return null;
-  const firstChar = str[0];
-  const lastChar = str[str.length - 1];
+function parseQuotedString(value) {
+  if (value.length < 2) return null;
+  const firstChar = value[0];
+  const lastChar = value[value.length - 1];
   if ((firstChar === '"' || firstChar === "'" || firstChar === "`") && firstChar === lastChar) {
     return {
       quote: firstChar,
-      content: str.slice(1, -1)
+      content: value.slice(1, -1)
     };
   }
   return null;
 }
-function stripQuotes(str) {
-  if (str.length < 2) return str;
-  const firstChar = str[0];
-  const lastChar = str[str.length - 1];
+function stripQuotes(value) {
+  if (value.length < 2) return value;
+  const firstChar = value[0];
+  const lastChar = value[value.length - 1];
   if ((firstChar === '"' || firstChar === "'" || firstChar === "`") && firstChar === lastChar) {
-    return str.slice(1, -1);
+    return value.slice(1, -1);
   }
-  return str;
+  return value;
 }
+function buildSuggestion(code, errorMessage) {
+  const receivedValue = extractReceivedValue(errorMessage);
+  if (code.includes(".toBeGreaterThanOrEqual(")) {
+    const currentValue = extractArg(code, "toBeGreaterThanOrEqual");
+    if (currentValue && receivedValue) {
+      const actualValue = Number(receivedValue);
+      if (!Number.isNaN(actualValue)) {
+        return code.replace(
+          `.toBeGreaterThanOrEqual(${currentValue})`,
+          `.toBeGreaterThanOrEqual(${actualValue})`
+        );
+      }
+    }
+  } else if (code.includes(".toBeGreaterThan(")) {
+    const currentValue = extractArg(code, "toBeGreaterThan");
+    if (currentValue && receivedValue) {
+      const actualValue = Number(receivedValue);
+      if (!Number.isNaN(actualValue)) {
+        return code.replace(
+          `.toBeGreaterThan(${currentValue})`,
+          `.toBeGreaterThan(${actualValue - 1})`
+        );
+      }
+    }
+  } else if (code.includes(".toBeLessThanOrEqual(")) {
+    const currentValue = extractArg(code, "toBeLessThanOrEqual");
+    if (currentValue && receivedValue) {
+      const actualValue = Number(receivedValue);
+      if (!Number.isNaN(actualValue)) {
+        return code.replace(
+          `.toBeLessThanOrEqual(${currentValue})`,
+          `.toBeLessThanOrEqual(${actualValue})`
+        );
+      }
+    }
+  } else if (code.includes(".toBeLessThan(")) {
+    const currentValue = extractArg(code, "toBeLessThan");
+    if (currentValue && receivedValue) {
+      const actualValue = Number(receivedValue);
+      if (!Number.isNaN(actualValue)) {
+        return code.replace(
+          `.toBeLessThan(${currentValue})`,
+          `.toBeLessThan(${actualValue + 1})`
+        );
+      }
+    }
+  } else if (code.includes(".toStrictEqual(")) {
+    const expectedValue = extractArg(code, "toStrictEqual");
+    if (expectedValue && receivedValue) {
+      const quoted = parseQuotedString(expectedValue);
+      if (quoted) {
+        return code.replace(
+          `.toStrictEqual(${expectedValue})`,
+          `.toStrictEqual(${quoted.quote}${stripQuotes(receivedValue)}${quoted.quote})`
+        );
+      }
+      return code.replace(
+        `.toStrictEqual(${expectedValue})`,
+        `.toStrictEqual(${receivedValue})`
+      );
+    }
+  } else if (code.includes(".toEqual(")) {
+    const expectedValue = extractArg(code, "toEqual");
+    if (expectedValue && receivedValue) {
+      const quoted = parseQuotedString(expectedValue);
+      if (quoted) {
+        return code.replace(
+          `.toEqual(${expectedValue})`,
+          `.toEqual(${quoted.quote}${stripQuotes(receivedValue)}${quoted.quote})`
+        );
+      }
+      return code.replace(
+        `.toEqual(${expectedValue})`,
+        `.toEqual(${receivedValue})`
+      );
+    }
+  } else if (code.includes(".toMatch(")) {
+    const expectedPattern = extractArg(code, "toMatch");
+    if (expectedPattern && receivedValue) {
+      const quoted = parseQuotedString(expectedPattern);
+      if (quoted) {
+        return code.replace(
+          `.toMatch(${expectedPattern})`,
+          `.toMatch(${quoted.quote}${stripQuotes(receivedValue)}${quoted.quote})`
+        );
+      }
+    }
+  } else if (code.includes(".toContain(")) {
+    const expectedValue = extractArg(code, "toContain");
+    if (expectedValue && receivedValue) {
+      const quoted = parseQuotedString(expectedValue);
+      if (quoted) {
+        return code.replace(
+          `.toContain(${expectedValue})`,
+          `.toContain(${quoted.quote}${stripQuotes(receivedValue)}${quoted.quote})`
+        );
+      }
+      return code.replace(
+        `.toContain(${expectedValue})`,
+        `.toContain(${receivedValue})`
+      );
+    }
+  } else if (code.includes(".toHaveLength(")) {
+    const expectedLength = extractArg(code, "toHaveLength");
+    if (expectedLength && receivedValue) {
+      const actualLength = Number(receivedValue);
+      if (!Number.isNaN(actualLength)) {
+        return code.replace(
+          `.toHaveLength(${expectedLength})`,
+          `.toHaveLength(${actualLength})`
+        );
+      }
+    }
+  } else if (code.includes(".toBe(")) {
+    const expectedValue = extractArg(code, "toBe");
+    if (expectedValue) {
+      if (receivedValue) {
+        const quoted = parseQuotedString(expectedValue);
+        if (quoted) {
+          return code.replace(
+            `.toBe(${expectedValue})`,
+            `.toBe(${quoted.quote}${stripQuotes(receivedValue)}${quoted.quote})`
+          );
+        }
+        return code.replace(
+          `.toBe(${expectedValue})`,
+          `.toBe(${receivedValue})`
+        );
+      }
+      if (expectedValue.includes("'") || expectedValue.includes('"')) {
+        return code.replace(".toBe(", ".toEqual(");
+      }
+    }
+  } else if (code.includes(".toBeDefined()")) {
+    return code.replace(".toBeDefined()", ".toBeTruthy()");
+  } else if (code.includes(".toBeNull()")) {
+    return code.replace(".toBeNull()", ".toBeUndefined()");
+  } else if (code.includes(".toBeUndefined()")) {
+    return code.replace(".toBeUndefined()", ".toBeNull()");
+  } else if (code.includes(".toBeTruthy()")) {
+    return code.replace(".toBeTruthy()", ".toBeDefined()");
+  } else if (code.includes(".toBeFalsy()")) {
+    return code.replace(".toBeFalsy()", ".toBeUndefined()");
+  }
+  return "";
+}
+
+// src/test/reporter/default-reporter.ts
 var TestReporter = class {
   constructor(options = {}) {
     this.startTime = 0;
@@ -342,7 +498,7 @@ var TestReporter = class {
     };
   }
   c(color, text) {
-    return this.options.colors !== false ? colors[color] + text + colors.reset : text;
+    return colorize(color, text, this.options.colors !== false);
   }
   onRunStart(files) {
     this.startTime = Date.now();
@@ -368,202 +524,52 @@ ${this.c("bold", "Test Files")}:  ${files.length}`);
     this.fileTestCount++;
     if (result.status === "pass") {
       console.log(`  ${this.c("green", "\u2713")} ${this.c("dim", result.suite + " > ")}${result.name} ${this.c("dim", `(${result.duration}ms)`)}`);
-    } else if (result.status === "fail") {
+      return;
+    }
+    if (result.status === "fail") {
       console.log(`  ${this.c("red", "\u2715")} ${this.c("dim", result.suite + " > ")}${result.name}`);
-      if (result.error) {
-        const filePath2 = result.file;
-        if (filePath2) {
-          const relativePath2 = relative(process.cwd(), filePath2).split("\\").join("/");
-          const lineSuffix = result.lineNumber ? `:${result.lineNumber}` : "";
-          console.log(`    ${this.c("cyan", `\u{1F4C4} ${relativePath2}${lineSuffix}`)}`);
-        }
-        const lines = result.error.message.split("\n");
-        for (const line of lines) {
-          if (line.includes("Expected:")) {
-            console.log(`    ${this.c("green", "Expected:")} ${line.trim().replace("Expected:", "").trim()}`);
-          } else if (line.includes("Received:")) {
-            console.log(`    ${this.c("red", "Received:")} ${line.trim().replace("Received:", "").trim()}`);
-          } else {
-            console.log(`    ${this.c("red", line.trim())}`);
-          }
-        }
-        if (result.codeSnippet) {
-          let suggestion = "";
-          const code = result.codeSnippet;
-          const errorMsg = result.error?.message || "";
-          const receivedValue = extractReceivedValue(errorMsg);
-          if (code.includes(".toBeGreaterThanOrEqual(")) {
-            const currentValue = extractArg(code, "toBeGreaterThanOrEqual");
-            if (currentValue && receivedValue) {
-              const actualValue = Number(receivedValue);
-              if (!isNaN(actualValue)) {
-                suggestion = code.replace(
-                  `.toBeGreaterThanOrEqual(${currentValue})`,
-                  `.toBeGreaterThanOrEqual(${actualValue})`
-                );
-              }
-            }
-          } else if (code.includes(".toBeGreaterThan(")) {
-            const currentValue = extractArg(code, "toBeGreaterThan");
-            if (currentValue && receivedValue) {
-              const actualValue = Number(receivedValue);
-              if (!isNaN(actualValue)) {
-                suggestion = code.replace(
-                  `.toBeGreaterThan(${currentValue})`,
-                  `.toBeGreaterThan(${actualValue - 1})`
-                );
-              }
-            }
-          } else if (code.includes(".toBeLessThanOrEqual(")) {
-            const currentValue = extractArg(code, "toBeLessThanOrEqual");
-            if (currentValue && receivedValue) {
-              const actualValue = Number(receivedValue);
-              if (!isNaN(actualValue)) {
-                suggestion = code.replace(
-                  `.toBeLessThanOrEqual(${currentValue})`,
-                  `.toBeLessThanOrEqual(${actualValue})`
-                );
-              }
-            }
-          } else if (code.includes(".toBeLessThan(")) {
-            const currentValue = extractArg(code, "toBeLessThan");
-            if (currentValue && receivedValue) {
-              const actualValue = Number(receivedValue);
-              if (!isNaN(actualValue)) {
-                suggestion = code.replace(
-                  `.toBeLessThan(${currentValue})`,
-                  `.toBeLessThan(${actualValue + 1})`
-                );
-              }
-            }
-          } else if (code.includes(".toStrictEqual(")) {
-            const expectedValue = extractArg(code, "toStrictEqual");
-            if (expectedValue && receivedValue) {
-              const quoted = parseQuotedString(expectedValue);
-              if (quoted) {
-                const strippedReceived = stripQuotes(receivedValue);
-                suggestion = code.replace(
-                  `.toStrictEqual(${expectedValue})`,
-                  `.toStrictEqual(${quoted.quote}${strippedReceived}${quoted.quote})`
-                );
-              } else {
-                suggestion = code.replace(
-                  `.toStrictEqual(${expectedValue})`,
-                  `.toStrictEqual(${receivedValue})`
-                );
-              }
-            }
-          } else if (code.includes(".toEqual(")) {
-            const expectedValue = extractArg(code, "toEqual");
-            if (expectedValue && receivedValue) {
-              const quoted = parseQuotedString(expectedValue);
-              if (quoted) {
-                const strippedReceived = stripQuotes(receivedValue);
-                suggestion = code.replace(
-                  `.toEqual(${expectedValue})`,
-                  `.toEqual(${quoted.quote}${strippedReceived}${quoted.quote})`
-                );
-              } else {
-                suggestion = code.replace(
-                  `.toEqual(${expectedValue})`,
-                  `.toEqual(${receivedValue})`
-                );
-              }
-            }
-          } else if (code.includes(".toMatch(")) {
-            const expectedPattern = extractArg(code, "toMatch");
-            if (expectedPattern && receivedValue) {
-              const quoted = parseQuotedString(expectedPattern);
-              if (quoted) {
-                const strippedReceived = stripQuotes(receivedValue);
-                suggestion = code.replace(
-                  `.toMatch(${expectedPattern})`,
-                  `.toMatch(${quoted.quote}${strippedReceived}${quoted.quote})`
-                );
-              }
-            }
-          } else if (code.includes(".toContain(")) {
-            const expectedValue = extractArg(code, "toContain");
-            if (expectedValue && receivedValue) {
-              const quoted = parseQuotedString(expectedValue);
-              if (quoted) {
-                const strippedReceived = stripQuotes(receivedValue);
-                suggestion = code.replace(
-                  `.toContain(${expectedValue})`,
-                  `.toContain(${quoted.quote}${strippedReceived}${quoted.quote})`
-                );
-              } else {
-                suggestion = code.replace(
-                  `.toContain(${expectedValue})`,
-                  `.toContain(${receivedValue})`
-                );
-              }
-            }
-          } else if (code.includes(".toHaveLength(")) {
-            const expectedLength = extractArg(code, "toHaveLength");
-            if (expectedLength && receivedValue) {
-              const actualLength = Number(receivedValue);
-              if (!isNaN(actualLength)) {
-                suggestion = code.replace(
-                  `.toHaveLength(${expectedLength})`,
-                  `.toHaveLength(${actualLength})`
-                );
-              }
-            }
-          } else if (code.includes(".toBe(")) {
-            const expectedValue = extractArg(code, "toBe");
-            if (expectedValue) {
-              if (receivedValue) {
-                const quoted = parseQuotedString(expectedValue);
-                if (quoted) {
-                  const strippedReceived = stripQuotes(receivedValue);
-                  suggestion = code.replace(
-                    `.toBe(${expectedValue})`,
-                    `.toBe(${quoted.quote}${strippedReceived}${quoted.quote})`
-                  );
-                } else {
-                  suggestion = code.replace(
-                    `.toBe(${expectedValue})`,
-                    `.toBe(${receivedValue})`
-                  );
-                }
-              } else if (expectedValue.includes("'") || expectedValue.includes('"')) {
-                suggestion = code.replace(".toBe(", ".toEqual(");
-              }
-            }
-          } else if (code.includes(".toBeDefined()")) {
-            suggestion = code.replace(".toBeDefined()", ".toBeTruthy()");
-          } else if (code.includes(".toBeNull()")) {
-            suggestion = code.replace(".toBeNull()", ".toBeUndefined()");
-          } else if (code.includes(".toBeUndefined()")) {
-            suggestion = code.replace(".toBeUndefined()", ".toBeNull()");
-          } else if (code.includes(".toBeTruthy()")) {
-            suggestion = code.replace(".toBeTruthy()", ".toBeDefined()");
-          } else if (code.includes(".toBeFalsy()")) {
-            suggestion = code.replace(".toBeFalsy()", ".toBeUndefined()");
-          }
-          console.log(`    ${this.c("dim", "Code:")}`);
-          console.log(`    ${this.c("dim", code)}`);
-          if (suggestion && suggestion !== code) {
-            console.log(`    ${this.c("yellow", "example \u2192")} ${this.c("green", suggestion)}`);
-          }
+      if (!result.error) {
+        return;
+      }
+      if (result.file) {
+        const relativePath2 = relative(process.cwd(), result.file).split("\\").join("/");
+        const lineSuffix = result.lineNumber ? `:${result.lineNumber}` : "";
+        console.log(`    ${this.c("cyan", `\u{1F4C4} ${relativePath2}${lineSuffix}`)}`);
+      }
+      for (const line of result.error.message.split("\n")) {
+        if (line.includes("Expected:")) {
+          console.log(`    ${this.c("green", "Expected:")} ${line.trim().replace("Expected:", "").trim()}`);
+        } else if (line.includes("Received:")) {
+          console.log(`    ${this.c("red", "Received:")} ${line.trim().replace("Received:", "").trim()}`);
+        } else {
+          console.log(`    ${this.c("red", line.trim())}`);
         }
-        if (this.options.verbose && result.error.stack) {
-          const stack = result.error.stack.split("\n").slice(1, 3).join("\n");
-          console.log(`    ${this.c("dim", stack)}`);
+      }
+      if (result.codeSnippet) {
+        const suggestion = buildSuggestion(result.codeSnippet, result.error.message || "");
+        console.log(`    ${this.c("dim", "Code:")}`);
+        console.log(`    ${this.c("dim", result.codeSnippet)}`);
+        if (suggestion && suggestion !== result.codeSnippet) {
+          console.log(`    ${this.c("yellow", "example \u2192")} ${this.c("green", suggestion)}`);
         }
       }
-    } else if (result.status === "skip") {
+      if (this.options.verbose && result.error.stack) {
+        const stack = result.error.stack.split("\n").slice(1, 3).join("\n");
+        console.log(`    ${this.c("dim", stack)}`);
+      }
+      return;
+    }
+    if (result.status === "skip") {
       console.log(`  ${this.c("yellow", "\u25CB")} ${this.c("dim", result.suite + " > ")}${result.name} ${this.c("yellow", "(skipped)")}`);
-    } else if (result.status === "todo") {
-      console.log(`  ${this.c("cyan", "\u25CB")} ${this.c("dim", result.suite + " > ")}${result.name} ${this.c("cyan", "(todo)")}`);
+      return;
     }
+    console.log(`  ${this.c("cyan", "\u25CB")} ${this.c("dim", result.suite + " > ")}${result.name} ${this.c("cyan", "(todo)")}`);
   }
   onRunEnd(results) {
     const duration = Date.now() - this.startTime;
-    const passed = results.filter((r) => r.status === "pass").length;
-    const failed = results.filter((r) => r.status === "fail").length;
-    const skipped = results.filter((r) => r.status === "skip").length;
+    const passed = results.filter((result) => result.status === "pass").length;
+    const failed = results.filter((result) => result.status === "fail").length;
+    const skipped = results.filter((result) => result.status === "skip").length;
     const total = results.length;
     if (this.currentFile && this.fileTestCount > 0) {
       console.log("");
@@ -577,6 +583,8 @@ ${this.c("bold", "Test Files")}:  ${files.length}`);
     console.log("");
   }
 };
+
+// src/test/reporter/dot-reporter.ts
 var DotReporter = class {
   constructor() {
     this.passed = 0;
@@ -610,9 +618,11 @@ var DotReporter = class {
 `);
   }
   c(color, text) {
-    return colors[color] + text + colors.reset;
+    return colorize(color, text);
   }
 };
+
+// src/test/reporter/json-reporter.ts
 var JsonReporter = class {
   constructor() {
     this.startTime = 0;
@@ -625,30 +635,32 @@ var JsonReporter = class {
   onTestResult(result) {
     this.results.push(result);
   }
-  onRunEnd(results) {
+  onRunEnd(_results) {
     const report = {
       summary: {
-        total: results.length,
-        passed: results.filter((r) => r.status === "pass").length,
-        failed: results.filter((r) => r.status === "fail").length,
-        skipped: results.filter((r) => r.status === "skip").length,
-        todo: results.filter((r) => r.status === "todo").length,
+        total: this.results.length,
+        passed: this.results.filter((result) => result.status === "pass").length,
+        failed: this.results.filter((result) => result.status === "fail").length,
+        skipped: this.results.filter((result) => result.status === "skip").length,
+        todo: this.results.filter((result) => result.status === "todo").length,
         duration: Date.now() - this.startTime
       },
-      tests: results.map((r) => ({
-        status: r.status === "pass" ? "passed" : r.status === "fail" ? "failed" : r.status === "skip" ? "skipped" : "todo",
-        name: r.name,
-        suite: r.suite,
-        duration: r.duration,
-        error: r.error ? {
-          message: r.error.message,
-          stack: r.error.stack
+      tests: this.results.map((result) => ({
+        status: result.status === "pass" ? "passed" : result.status === "fail" ? "failed" : result.status === "skip" ? "skipped" : "todo",
+        name: result.name,
+        suite: result.suite,
+        duration: result.duration,
+        error: result.error ? {
+          message: result.error.message,
+          stack: result.error.stack
         } : void 0
       }))
     };
     console.log(JSON.stringify(report, null, 2));
   }
 };
+
+// src/test/reporter/verbose-reporter.ts
 var VerboseReporter = class {
   constructor() {
     this.currentSuite = "";
@@ -676,9 +688,9 @@ ${colors.red}    ${result.error.message}${colors.reset}`);
     }
   }
   onRunEnd(results) {
-    const passed = results.filter((r) => r.status === "pass").length;
-    const failed = results.filter((r) => r.status === "fail").length;
-    const skipped = results.filter((r) => r.status === "skip").length;
+    const passed = results.filter((result) => result.status === "pass").length;
+    const failed = results.filter((result) => result.status === "fail").length;
+    const skipped = results.filter((result) => result.status === "skip").length;
     console.log(`
 ${colors.dim}${"\u2500".repeat(50)}${colors.reset}
 `);
@@ -686,18 +698,22 @@ ${colors.dim}${"\u2500".repeat(50)}${colors.reset}
       console.log(`${colors.green}All tests passed!${colors.reset}`);
       console.log(`${colors.dim}${passed} tests${colors.reset}
 `);
-    } else {
-      console.log(`${colors.red}${failed} tests failed${colors.reset}`);
-      console.log(`${colors.green}${passed} tests passed${colors.reset}`);
-      if (skipped > 0) {
-        console.log(`${colors.yellow}${skipped} tests skipped${colors.reset}`);
-      }
-      console.log("");
+      return;
+    }
+    console.log(`${colors.red}${failed} tests failed${colors.reset}`);
+    console.log(`${colors.green}${passed} tests passed${colors.reset}`);
+    if (skipped > 0) {
+      console.log(`${colors.yellow}${skipped} tests skipped${colors.reset}`);
     }
+    console.log("");
   }
 };
+
+// src/test/reporter/utilities.ts
 function formatErrorStack(error) {
-  if (!error.stack) return error.message;
+  if (!error.stack) {
+    return error.message;
+  }
   const lines = error.stack.split("\n");
   let formatted = `${error.message}
 `;