elit 3.3.2 → 3.3.4

package/dist/test-reporter.mjs

@@ -0,0 +1,696 @@
+import {createRequire as __createRequire} from 'module';const require = __createRequire(import.meta.url);
+
+// src/runtime.ts
+var runtime = (() => {
+  if (typeof Deno !== "undefined") return "deno";
+  if (typeof Bun !== "undefined") return "bun";
+  return "node";
+})();
+var isNode = runtime === "node";
+var isBun = runtime === "bun";
+var isDeno = runtime === "deno";
+
+// src/path.ts
+function getSeparator(isWin) {
+  return isWin ? "\\" : "/";
+}
+function getCwd() {
+  if (isNode || isBun) {
+    return process.cwd();
+  } else if (isDeno) {
+    return Deno.cwd();
+  }
+  return "/";
+}
+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] === "/";
+}
+function isAbsoluteWin(path) {
+  const len = path.length;
+  if (len === 0) return false;
+  const code = path.charCodeAt(0);
+  if (code === 47 || code === 92) {
+    return true;
+  }
+  if (code >= 65 && code <= 90 || code >= 97 && code <= 122) {
+    if (len > 2 && path.charCodeAt(1) === 58) {
+      const code2 = path.charCodeAt(2);
+      if (code2 === 47 || code2 === 92) {
+        return true;
+      }
+    }
+  }
+  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 parts = normalized.split(separator);
+  const result = [];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (part === "" || part === ".") {
+      if (i === 0 && isAbsolute) result.push("");
+      continue;
+    }
+    if (part === "..") {
+      if (result.length > 0 && result[result.length - 1] !== "..") {
+        if (!(result.length === 1 && result[0] === "")) {
+          result.pop();
+        }
+      } else if (!isAbsolute) {
+        result.push("..");
+      }
+    } else {
+      result.push(part);
+    }
+  }
+  let final = result.join(separator);
+  if (final.length === 0) {
+    return isAbsolute ? separator : ".";
+  }
+  if (trailingSeparator && final[final.length - 1] !== separator) {
+    final += separator;
+  }
+  return final;
+}
+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];
+    if (path && path.length > 0) {
+      if (joined.length === 0) {
+        joined = path;
+      } else {
+        joined += separator + path;
+      }
+    }
+  }
+  if (joined.length === 0) return ".";
+  return normalizePath(joined, 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];
+    if (path && path.length > 0) {
+      resolved = path + (resolved.length > 0 ? separator + resolved : "");
+      isAbsolute = isWin ? isAbsoluteWin(resolved) : isAbsolutePosix(resolved);
+    }
+  }
+  if (!isAbsolute) {
+    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 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 minLength = Math.min(fromParts.length, toParts.length);
+  for (let i = 0; i < minLength; i++) {
+    if (fromParts[i] === toParts[i]) {
+      commonLength++;
+    } else {
+      break;
+    }
+  }
+  const upCount = fromParts.length - commonLength;
+  const result = [];
+  for (let i = 0; i < upCount; i++) {
+    result.push("..");
+  }
+  for (let i = commonLength; i < toParts.length; i++) {
+    result.push(toParts[i]);
+  }
+  return result.join(separator) || ".";
+}
+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);
+}
+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);
+  if (ext && base.endsWith(ext)) {
+    base = base.slice(0, base.length - ext.length);
+  }
+  return base;
+}
+function getExtname(path) {
+  const lastDotIndex = path.lastIndexOf(".");
+  const lastSepIndex = findLastSeparator(path);
+  if (lastDotIndex === -1 || lastDotIndex < lastSepIndex || lastDotIndex === path.length - 1) {
+    return "";
+  }
+  return path.slice(lastDotIndex);
+}
+function parsePath(path, isWin) {
+  let root = "";
+  if (isWin) {
+    if (path.length >= 2 && path[1] === ":") {
+      root = path.slice(0, 2);
+      if (path.length > 2 && (path[2] === "\\" || path[2] === "/")) {
+        root += "\\";
+      }
+    } else if (path[0] === "\\" || path[0] === "/") {
+      root = "\\";
+    }
+  } else {
+    if (path[0] === "/") {
+      root = "/";
+    }
+  }
+  const dir = getDirname(path, isWin);
+  const base = getBasename(path, void 0, isWin);
+  const ext = getExtname(path);
+  const name = ext ? base.slice(0, base.length - ext.length) : base;
+  return { root, dir, base, ext, name };
+}
+function formatPath(pathObject, isWin) {
+  const separator = getSeparator(isWin);
+  const dir = pathObject.dir || pathObject.root || "";
+  const base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir) return base;
+  if (dir === pathObject.root) return dir + base;
+  return dir + separator + base;
+}
+function relative(from, to) {
+  return relativePath(from, to, isWindows);
+}
+
+// src/test-reporter.ts
+var colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m"
+};
+function extractArg(code, functionName) {
+  const searchStr = `.${functionName}(`;
+  const startIndex = code.indexOf(searchStr);
+  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];
+    if (!inString) {
+      if (char === "(") parenCount++;
+      else if (char === ")") {
+        parenCount--;
+        if (parenCount < 0) {
+          return code.slice(argStart, i);
+        }
+      } else if (char === '"' || char === "'" || char === "`") {
+        inString = true;
+        stringChar = char;
+      }
+    } else {
+      if (char === "\\" && i + 1 < code.length) {
+        i++;
+      } else if (char === stringChar) {
+        inString = false;
+      }
+    }
+  }
+  return null;
+}
+function extractReceivedValue(errorMsg) {
+  const receivedIndex = errorMsg.indexOf("Received:");
+  if (receivedIndex === -1) return null;
+  const afterReceived = errorMsg.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];
+  if ((firstChar === '"' || firstChar === "'" || firstChar === "`") && firstChar === lastChar) {
+    return {
+      quote: firstChar,
+      content: str.slice(1, -1)
+    };
+  }
+  return null;
+}
+function stripQuotes(str) {
+  if (str.length < 2) return str;
+  const firstChar = str[0];
+  const lastChar = str[str.length - 1];
+  if ((firstChar === '"' || firstChar === "'" || firstChar === "`") && firstChar === lastChar) {
+    return str.slice(1, -1);
+  }
+  return str;
+}
+var TestReporter = class {
+  constructor(options = {}) {
+    this.startTime = 0;
+    this.currentFile = void 0;
+    this.fileTestCount = 0;
+    this.totalFiles = 0;
+    this.options = {
+      verbose: false,
+      colors: true,
+      ...options
+    };
+  }
+  c(color, text) {
+    return this.options.colors !== false ? colors[color] + text + colors.reset : text;
+  }
+  onRunStart(files) {
+    this.startTime = Date.now();
+    this.totalFiles = files.length;
+    console.log(`
+${this.c("bold", "Test Files")}:  ${files.length}`);
+    console.log(`${this.c("dim", "\u2500".repeat(50))}
+`);
+  }
+  onTestResult(result) {
+    const filePath = result.file ? relative(process.cwd(), result.file).split("\\").join("/") : void 0;
+    if (filePath !== this.currentFile) {
+      if (this.currentFile && this.fileTestCount > 0) {
+        console.log("");
+      }
+      this.currentFile = filePath;
+      this.fileTestCount = 0;
+      if (filePath) {
+        console.log(`${this.c("cyan", "\u25CF")} ${this.c("bold", filePath)}`);
+        console.log(`${this.c("dim", "\u2504".repeat(50))}`);
+      }
+    }
+    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") {
+      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 (this.options.verbose && result.error.stack) {
+          const stack = result.error.stack.split("\n").slice(1, 3).join("\n");
+          console.log(`    ${this.c("dim", stack)}`);
+        }
+      }
+    } else 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)")}`);
+    }
+  }
+  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 total = results.length;
+    if (this.currentFile && this.fileTestCount > 0) {
+      console.log("");
+    }
+    console.log(`${this.c("dim", "\u2500".repeat(50))}`);
+    console.log("");
+    console.log(`${this.c("bold", "Test Suites:")} ${this.c("green", `${this.totalFiles} passed`)}${this.c("dim", `, ${this.totalFiles} total`)}`);
+    console.log(`${this.c("bold", "Tests:")}       ${this.c("green", `${passed} passed`)}${failed > 0 ? `, ${this.c("red", `${failed} failed`)}` : ""}${skipped > 0 ? `, ${this.c("yellow", `${skipped} skipped`)}` : ""}${this.c("dim", `, ${total} total`)}`);
+    console.log(`${this.c("bold", "Snapshots:")}   ${this.c("dim", "0 total")}`);
+    console.log(`${this.c("bold", "Time:")}        ${this.c("dim", `${(duration / 1e3).toFixed(2)}s`)}`);
+    console.log("");
+  }
+};
+var DotReporter = class {
+  constructor() {
+    this.passed = 0;
+    this.failed = 0;
+    this.skipped = 0;
+    this.todo = 0;
+    this.lineLength = 0;
+  }
+  onRunStart(files) {
+    console.log(`
+  ${files.length} test files
+`);
+  }
+  onTestResult(result) {
+    const symbol = result.status === "pass" ? "." : result.status === "fail" ? this.c("red", "F") : result.status === "skip" ? this.c("yellow", "o") : this.c("cyan", "o");
+    process.stdout.write(symbol);
+    this.lineLength++;
+    if (result.status === "pass") this.passed++;
+    else if (result.status === "fail") this.failed++;
+    else if (result.status === "skip") this.skipped++;
+    else if (result.status === "todo") this.todo++;
+    if (this.lineLength >= 50) {
+      process.stdout.write("\n    ");
+      this.lineLength = 0;
+    }
+  }
+  onRunEnd(_results) {
+    console.log(`
+
+  ${this.c("green", this.passed + " passed")} ${this.c("dim", "\xB7")} ${this.c("red", this.failed + " failed")} ${this.c("dim", "\xB7")} ${this.c("yellow", this.skipped + " skipped")}
+`);
+  }
+  c(color, text) {
+    return colors[color] + text + colors.reset;
+  }
+};
+var JsonReporter = class {
+  constructor() {
+    this.startTime = 0;
+    this.results = [];
+  }
+  onRunStart(_files) {
+    this.startTime = Date.now();
+    this.results = [];
+  }
+  onTestResult(result) {
+    this.results.push(result);
+  }
+  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,
+        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
+        } : void 0
+      }))
+    };
+    console.log(JSON.stringify(report, null, 2));
+  }
+};
+var VerboseReporter = class {
+  constructor() {
+    this.currentSuite = "";
+  }
+  onRunStart(_files) {
+    console.log(`
+${colors.cyan}Running tests${colors.reset}
+`);
+  }
+  onTestResult(result) {
+    if (result.suite !== this.currentSuite) {
+      this.currentSuite = result.suite;
+      console.log(`
+${colors.dim}${result.suite}${colors.reset}`);
+    }
+    const icon = result.status === "pass" ? colors.green + "  \u2713" : result.status === "fail" ? colors.red + "  \u2715" : result.status === "skip" ? colors.yellow + "  \u2298" : colors.cyan + "  \u25CB";
+    console.log(`${icon}${colors.reset} ${result.name}${colors.dim} (${result.duration}ms)${colors.reset}`);
+    if (result.status === "fail" && result.error) {
+      console.log(`
+${colors.red}    ${result.error.message}${colors.reset}`);
+      if (result.error.stack) {
+        const lines = result.error.stack.split("\n").slice(1, 4);
+        lines.forEach((line) => console.log(`${colors.dim}    ${line}${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;
+    console.log(`
+${colors.dim}${"\u2500".repeat(50)}${colors.reset}
+`);
+    if (failed === 0) {
+      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("");
+    }
+  }
+};
+function formatErrorStack(error) {
+  if (!error.stack) return error.message;
+  const lines = error.stack.split("\n");
+  let formatted = `${error.message}
+`;
+  for (const line of lines.slice(1, 6)) {
+    formatted += `  ${line.trim()}
+`;
+  }
+  return formatted;
+}
+function formatProgress(current, total) {
+  const percentage = Math.floor(current / total * 100);
+  const filled = Math.floor(percentage / 2);
+  const empty = 50 - filled;
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(empty);
+  return `[${bar}] ${percentage}% (${current}/${total})`;
+}
+export {
+  DotReporter,
+  JsonReporter,
+  TestReporter,
+  VerboseReporter,
+  formatErrorStack,
+  formatProgress
+};
+//# sourceMappingURL=test-reporter.mjs.map