elit 3.3.3 → 3.3.5

package/dist/coverage.mjs

@@ -0,0 +1,1520 @@
+import {createRequire as __createRequire} from 'module';const require = __createRequire(import.meta.url);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// 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/fs.ts
+var isBunOrDeno = isBun || isDeno;
+function parseOptions(options, defaultValue) {
+  return typeof options === "string" ? { encoding: options } : options || defaultValue;
+}
+function decodeContent(content, encoding) {
+  if (encoding) {
+    return new TextDecoder(encoding).decode(content);
+  }
+  return Buffer.from(content instanceof ArrayBuffer ? new Uint8Array(content) : content);
+}
+function dataToUint8Array(data) {
+  if (typeof data === "string") {
+    return new TextEncoder().encode(data);
+  }
+  if (data instanceof Buffer) {
+    return new Uint8Array(data);
+  }
+  return data;
+}
+function processDenoEntries(iterator, withFileTypes) {
+  const entries = [];
+  for (const entry of iterator) {
+    if (withFileTypes) {
+      entries.push(createDirentFromDenoEntry(entry));
+    } else {
+      entries.push(entry.name);
+    }
+  }
+  return entries;
+}
+var fs;
+var fsPromises;
+if (isNode) {
+  fs = __require("fs");
+  fsPromises = __require("fs/promises");
+}
+function readFileSync(path, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    return fs.readFileSync(path, opts);
+  } else if (isBun) {
+    const file = Bun.file(path);
+    const content = file.arrayBuffer();
+    return decodeContent(content, opts.encoding);
+  } else if (isDeno) {
+    const content = Deno.readFileSync(path);
+    return decodeContent(content, opts.encoding);
+  }
+  throw new Error("Unsupported runtime");
+}
+function writeFileSync(path, data, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    fs.writeFileSync(path, data, opts);
+  } else if (isBun) {
+    Bun.write(path, data);
+  } else if (isDeno) {
+    Deno.writeFileSync(path, dataToUint8Array(data));
+  }
+}
+function existsSync(path) {
+  try {
+    statSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function statSync(path) {
+  if (isNode) {
+    return fs.statSync(path);
+  } else if (isBun) {
+    const file = Bun.file(path);
+    const size = file.size;
+    try {
+      file.arrayBuffer();
+    } catch {
+      throw new Error(`ENOENT: no such file or directory, stat '${path}'`);
+    }
+    return createStatsObject(path, size, false);
+  } else if (isDeno) {
+    const info = Deno.statSync(path);
+    return createStatsFromDenoFileInfo(info);
+  }
+  throw new Error("Unsupported runtime");
+}
+function mkdirSync(path, options) {
+  const opts = typeof options === "number" ? { mode: options } : options || {};
+  if (isNode) {
+    fs.mkdirSync(path, opts);
+  } else if (isBun) {
+    Deno.mkdirSync(path, { recursive: opts.recursive });
+  } else if (isDeno) {
+    Deno.mkdirSync(path, { recursive: opts.recursive });
+  }
+}
+function readdirSync(path, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    return fs.readdirSync(path, opts);
+  } else if (isBunOrDeno) {
+    return processDenoEntries(Deno.readDirSync(path), opts.withFileTypes);
+  }
+  throw new Error("Unsupported runtime");
+}
+function createStatsObject(_path, size, isDir) {
+  const now = Date.now();
+  return {
+    isFile: () => !isDir,
+    isDirectory: () => isDir,
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isSymbolicLink: () => false,
+    isFIFO: () => false,
+    isSocket: () => false,
+    dev: 0,
+    ino: 0,
+    mode: isDir ? 16877 : 33188,
+    nlink: 1,
+    uid: 0,
+    gid: 0,
+    rdev: 0,
+    size,
+    blksize: 4096,
+    blocks: Math.ceil(size / 512),
+    atimeMs: now,
+    mtimeMs: now,
+    ctimeMs: now,
+    birthtimeMs: now,
+    atime: new Date(now),
+    mtime: new Date(now),
+    ctime: new Date(now),
+    birthtime: new Date(now)
+  };
+}
+function createStatsFromDenoFileInfo(info) {
+  return {
+    isFile: () => info.isFile,
+    isDirectory: () => info.isDirectory,
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isSymbolicLink: () => info.isSymlink || false,
+    isFIFO: () => false,
+    isSocket: () => false,
+    dev: info.dev || 0,
+    ino: info.ino || 0,
+    mode: info.mode || 0,
+    nlink: info.nlink || 1,
+    uid: info.uid || 0,
+    gid: info.gid || 0,
+    rdev: 0,
+    size: info.size,
+    blksize: info.blksize || 4096,
+    blocks: info.blocks || Math.ceil(info.size / 512),
+    atimeMs: info.atime?.getTime() || Date.now(),
+    mtimeMs: info.mtime?.getTime() || Date.now(),
+    ctimeMs: info.birthtime?.getTime() || Date.now(),
+    birthtimeMs: info.birthtime?.getTime() || Date.now(),
+    atime: info.atime || /* @__PURE__ */ new Date(),
+    mtime: info.mtime || /* @__PURE__ */ new Date(),
+    ctime: info.birthtime || /* @__PURE__ */ new Date(),
+    birthtime: info.birthtime || /* @__PURE__ */ new Date()
+  };
+}
+function createDirentFromDenoEntry(entry) {
+  return {
+    name: entry.name,
+    isFile: () => entry.isFile,
+    isDirectory: () => entry.isDirectory,
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isSymbolicLink: () => entry.isSymlink || false,
+    isFIFO: () => false,
+    isSocket: () => false
+  };
+}
+
+// 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 join(...paths) {
+  return joinPaths(paths, isWindows);
+}
+function relative(from, to) {
+  return relativePath(from, to, isWindows);
+}
+function dirname(path) {
+  return getDirname(path, isWindows);
+}
+
+// src/coverage.ts
+var executedLinesMap = /* @__PURE__ */ new Map();
+var totalLinesMap = /* @__PURE__ */ new Map();
+function getExecutableLines(filePath) {
+  const executableLines = /* @__PURE__ */ new Set();
+  try {
+    const sourceCode = readFileSync(filePath, "utf-8").toString();
+    const lines = sourceCode.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("*") || trimmed.startsWith("/*") || trimmed.startsWith("*/") || trimmed.startsWith("import ") || trimmed.startsWith("export ") && !trimmed.includes("function") && !trimmed.includes("class") && !trimmed.includes("const") && !trimmed.includes("let") && !trimmed.includes("var") || trimmed.startsWith("interface ") || trimmed.startsWith("type ") || trimmed.startsWith("enum ") || trimmed.match(/^class\s+\w+.*{?\s*$/) || trimmed === "{" || trimmed === "}" || trimmed === "();") {
+        continue;
+      }
+      executableLines.add(i + 1);
+    }
+  } catch (e) {
+  }
+  return executableLines;
+}
+function markFileAsCovered(_filePath) {
+}
+function markLineExecuted(filePath, lineNumber) {
+  if (!executedLinesMap.has(filePath)) {
+    executedLinesMap.set(filePath, /* @__PURE__ */ new Set());
+  }
+  executedLinesMap.get(filePath).add(lineNumber);
+}
+function getExecutedLines(filePath) {
+  return executedLinesMap.get(filePath) || /* @__PURE__ */ new Set();
+}
+function calculateUncoveredLines(filePath) {
+  const executableLines = getExecutableLines(filePath);
+  const executedLines = getExecutedLines(filePath);
+  const uncovered = [];
+  for (const line of executableLines) {
+    if (!executedLines.has(line)) {
+      uncovered.push(line);
+    }
+  }
+  return uncovered.sort((a, b) => a - b);
+}
+function resetCoverageTracking() {
+  executedLinesMap.clear();
+  totalLinesMap.clear();
+}
+function initializeCoverageTracking() {
+  resetCoverageTracking();
+}
+function globToRegex(pattern) {
+  let regexStr = "^";
+  for (let i = 0; i < pattern.length; i++) {
+    const char = pattern[i];
+    switch (char) {
+      case ".":
+        regexStr += "\\.";
+        break;
+      case "*":
+        if (i + 1 < pattern.length && pattern[i + 1] === "*") {
+          regexStr += "(?:[^/]*(?:/|$))*";
+          i++;
+        } else {
+          regexStr += "[^/]*";
+        }
+        break;
+      case "?":
+        regexStr += "[^/]";
+        break;
+      case "/":
+        regexStr += "/";
+        break;
+      // Escape special regex characters
+      case "^":
+      case "$":
+      case "+":
+      case "(":
+      case ")":
+      case "[":
+      case "]":
+      case "{":
+      case "}":
+      case "|":
+      case "\\":
+        regexStr += "\\" + char;
+        break;
+      default:
+        regexStr += char;
+        break;
+    }
+  }
+  regexStr += "$";
+  return new RegExp(regexStr);
+}
+function matchesInclude(filePath, include) {
+  if (include.length === 0) return true;
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  for (const pattern of include) {
+    const regex = globToRegex(pattern);
+    if (regex.test(normalizedPath)) {
+      return true;
+    }
+  }
+  return false;
+}
+function matchesExclude(filePath, exclude) {
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  for (const pattern of exclude) {
+    const regex = globToRegex(pattern);
+    if (regex.test(normalizedPath)) {
+      return true;
+    }
+  }
+  return false;
+}
+function findAllTypeScriptFiles(dir, include, exclude) {
+  const files = [];
+  if (!existsSync(dir)) {
+    return files;
+  }
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (typeof entry === "string") continue;
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (matchesExclude(fullPath, exclude)) continue;
+        files.push(...findAllTypeScriptFiles(fullPath, include, exclude));
+      } else if (entry.isFile() && fullPath.endsWith(".ts")) {
+        if (matchesInclude(fullPath, include) && !matchesExclude(fullPath, exclude)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  } catch (e) {
+  }
+  return files;
+}
+function analyzeSourceFile(filePath) {
+  try {
+    const sourceCode = readFileSync(filePath, "utf-8").toString();
+    const lines = sourceCode.split("\n");
+    let statements = 0;
+    let branches = 0;
+    let functions = 0;
+    let executableLines = 0;
+    const branchKeywords = ["if", "else if", "for", "while", "switch", "case", "catch", "?", "&&", "||"];
+    const functionPatterns = [/function\s+\w+/, /(\w+)\s*\([^)]*\)\s*{/, /\(\s*\w+\s*(?:,\s*\w+\s*)*\)\s*=>/];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("*") || trimmed.startsWith("/*") || trimmed.startsWith("import ") || trimmed.startsWith("export ") || trimmed.startsWith("interface ") || trimmed.startsWith("type ") || trimmed.startsWith("enum ") || trimmed.match(/^class\s+\w+/)) {
+        continue;
+      }
+      for (const keyword of branchKeywords) {
+        if (trimmed.includes(keyword)) {
+          branches++;
+          break;
+        }
+      }
+      for (const pattern of functionPatterns) {
+        if (pattern.test(trimmed)) {
+          functions++;
+          break;
+        }
+      }
+      const codeOnly = trimmed.replace(/\{|\}|\(|\)|;$/g, "").replace(/^import\s+.*$/, "").replace(/^export\s+.*$/, "").replace(/^interface\s+.*$/, "").replace(/^type\s+.*$/, "").replace(/^enum\s+.*$/, "").replace(/^class\s+\w+.*$/, "").trim();
+      if (codeOnly && codeOnly.length > 0) {
+        statements++;
+        executableLines++;
+      }
+    }
+    return { statements, branches, functions, lines: executableLines };
+  } catch (e) {
+    return { statements: 0, branches: 0, functions: 0, lines: 0 };
+  }
+}
+async function processCoverage(options) {
+  const {
+    include = ["**/*.ts"],
+    exclude = ["**/*.test.ts", "**/*.spec.ts", "**/node_modules/**", "**/dist/**", "**/coverage/**"],
+    coveredFiles
+  } = options;
+  const coverageMap = /* @__PURE__ */ new Map();
+  const allTsFiles = findAllTypeScriptFiles(process.cwd(), include, exclude);
+  for (const tsFile of allTsFiles) {
+    const isCovered = coveredFiles?.has(tsFile) || false;
+    const analysis = analyzeSourceFile(tsFile);
+    const executableLines = getExecutableLines(tsFile);
+    const executedLines = isCovered ? executableLines : /* @__PURE__ */ new Set();
+    const uncoveredLinesArray = [];
+    for (const line of executableLines) {
+      if (!executedLines.has(line)) {
+        uncoveredLinesArray.push(line);
+      }
+    }
+    const uncoveredLines = uncoveredLinesArray.length > 0 ? uncoveredLinesArray.sort((a, b) => a - b) : void 0;
+    const coveredLinesCount = executedLines.size;
+    coverageMap.set(tsFile, {
+      path: tsFile,
+      statements: analysis.statements,
+      coveredStatements: isCovered ? analysis.statements : 0,
+      branches: analysis.branches,
+      coveredBranches: isCovered ? analysis.branches : 0,
+      functions: analysis.functions,
+      coveredFunctions: isCovered ? analysis.functions : 0,
+      lines: executableLines.size,
+      coveredLines: coveredLinesCount,
+      uncoveredLines
+    });
+  }
+  if (coveredFiles) {
+    for (const coveredFile of coveredFiles) {
+      if (coverageMap.has(coveredFile)) continue;
+      const relativePath2 = relative(process.cwd(), coveredFile);
+      const isOutsideProject = relativePath2.startsWith("..");
+      if (!coveredFile.includes("node_modules") && !coveredFile.includes("dist") && !isOutsideProject) {
+        const analysis = analyzeSourceFile(coveredFile);
+        const executableLines = getExecutableLines(coveredFile);
+        const executedLines = executableLines;
+        const uncoveredLinesArray = [];
+        for (const line of executableLines) {
+          if (!executedLines.has(line)) {
+            uncoveredLinesArray.push(line);
+          }
+        }
+        const uncoveredLines = uncoveredLinesArray.length > 0 ? uncoveredLinesArray.sort((a, b) => a - b) : void 0;
+        const coveredLinesCount = executedLines.size;
+        coverageMap.set(coveredFile, {
+          path: coveredFile,
+          statements: analysis.statements,
+          coveredStatements: analysis.statements,
+          branches: analysis.branches,
+          coveredBranches: analysis.branches,
+          functions: analysis.functions,
+          coveredFunctions: analysis.functions,
+          lines: executableLines.size,
+          coveredLines: coveredLinesCount,
+          uncoveredLines
+        });
+      }
+    }
+  }
+  return coverageMap;
+}
+var colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m"
+};
+function getColorForPercentage(pct) {
+  if (pct >= 80) return colors.green;
+  if (pct >= 50) return colors.yellow;
+  return colors.red;
+}
+function calculateFileCoverage(file) {
+  const stmtPct = file.statements > 0 ? file.coveredStatements / file.statements * 100 : 0;
+  const branchPct = file.branches > 0 ? file.coveredBranches / file.branches * 100 : 0;
+  const funcPct = file.functions > 0 ? file.coveredFunctions / file.functions * 100 : 0;
+  const linePct = file.lines > 0 ? file.coveredLines / file.lines * 100 : 0;
+  return {
+    statements: { total: file.statements, covered: file.coveredStatements, percentage: stmtPct },
+    branches: { total: file.branches, covered: file.coveredBranches, percentage: branchPct },
+    functions: { total: file.functions, covered: file.coveredFunctions, percentage: funcPct },
+    lines: { total: file.lines, covered: file.coveredLines, percentage: linePct }
+  };
+}
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function getVisibleWidth(str) {
+  return stripAnsi(str).length;
+}
+function formatMetricFixedWidth(covered, total, percentage, includeSeparator = false) {
+  const color = getColorForPercentage(percentage);
+  const pctStr = percentage.toFixed(2);
+  const pct = color + pctStr + "%" + colors.reset;
+  const coveredPadded = covered.toString().padStart(4);
+  const totalPadded = total.toString().padStart(4);
+  const count = `${colors.dim}${coveredPadded}${colors.reset}/${totalPadded}`;
+  const metric = `${pct} (${count})`;
+  const visibleWidth = getVisibleWidth(metric);
+  const padding = " ".repeat(Math.max(0, 19 - visibleWidth));
+  const separator = includeSeparator ? `${colors.dim}\u2502${colors.reset}` : " ";
+  return metric + padding + separator;
+}
+function formatUncoveredLines(uncoveredLines) {
+  if (!uncoveredLines || uncoveredLines.length === 0) {
+    return "";
+  }
+  const ranges = [];
+  let start = uncoveredLines[0];
+  let end = uncoveredLines[0];
+  for (let i = 1; i < uncoveredLines.length; i++) {
+    if (uncoveredLines[i] === end + 1) {
+      end = uncoveredLines[i];
+    } else {
+      if (start === end) {
+        ranges.push(start.toString());
+      } else {
+        ranges.push(`${start}-${end}`);
+      }
+      start = uncoveredLines[i];
+      end = uncoveredLines[i];
+    }
+  }
+  if (start === end) {
+    ranges.push(start.toString());
+  } else {
+    ranges.push(`${start}-${end}`);
+  }
+  return ranges.join(",");
+}
+function generateTextReport(coverageMap, testResults) {
+  let output = "\n";
+  void testResults;
+  let totalStatements = 0, coveredStatements = 0;
+  let totalBranches = 0, coveredBranches = 0;
+  let totalFunctions = 0, coveredFunctions = 0;
+  let totalLines = 0, coveredLines = 0;
+  for (const coverage of coverageMap.values()) {
+    totalStatements += coverage.statements;
+    coveredStatements += coverage.coveredStatements;
+    totalBranches += coverage.branches;
+    coveredBranches += coverage.coveredBranches;
+    totalFunctions += coverage.functions;
+    coveredFunctions += coverage.coveredFunctions;
+    totalLines += coverage.lines;
+    coveredLines += coverage.coveredLines;
+  }
+  const pctStmts = totalStatements > 0 ? coveredStatements / totalStatements * 100 : 0;
+  const pctBranch = totalBranches > 0 ? coveredBranches / totalBranches * 100 : 0;
+  const pctFunc = totalFunctions > 0 ? coveredFunctions / totalFunctions * 100 : 0;
+  const pctLines = totalLines > 0 ? coveredLines / totalLines * 100 : 0;
+  output += `${colors.bold}% Coverage report from v8\x1B[0m
+`;
+  output += `
+`;
+  output += `${colors.dim}${colors.bold}All files\x1B[0m`;
+  const maxFileNameLength = Math.max(...Array.from(coverageMap.keys()).map((f) => relative(process.cwd(), f).length));
+  const namePadding = Math.max(45, maxFileNameLength + 2);
+  output += " ".repeat(namePadding - 9);
+  const stmtsMetric = formatMetricFixedWidth(coveredStatements, totalStatements, pctStmts, true);
+  const branchMetric = formatMetricFixedWidth(coveredBranches, totalBranches, pctBranch, true);
+  const funcsMetric = formatMetricFixedWidth(coveredFunctions, totalFunctions, pctFunc, true);
+  const linesMetric = formatMetricFixedWidth(coveredLines, totalLines, pctLines, true);
+  output += `${stmtsMetric}${branchMetric}${funcsMetric}${linesMetric}
+`;
+  output += `${colors.dim}`;
+  output += " ".repeat(namePadding);
+  output += " ".repeat(5) + "Statements";
+  output += " ".repeat(12) + "Branch";
+  output += " ".repeat(12) + "Functions";
+  output += " ".repeat(13) + "Lines";
+  output += " ".repeat(12) + "Uncovered";
+  output += `${colors.reset}
+`;
+  output += `${colors.dim}`;
+  output += "\u2500".repeat(namePadding);
+  output += "\u2500".repeat(19);
+  output += "\u253C";
+  output += "\u2500".repeat(19);
+  output += "\u253C";
+  output += "\u2500".repeat(19);
+  output += "\u253C";
+  output += "\u2500".repeat(19);
+  output += "\u253C";
+  output += "\u2500".repeat(19);
+  output += `${colors.reset}
+`;
+  const groupedFiles = /* @__PURE__ */ new Map();
+  for (const [filePath, coverage] of coverageMap.entries()) {
+    const dir = dirname(filePath);
+    if (!groupedFiles.has(dir)) {
+      groupedFiles.set(dir, []);
+    }
+    groupedFiles.get(dir).push({ path: filePath, coverage });
+  }
+  const cwd = process.cwd();
+  const toRelative = (path) => relative(cwd, path).replace(/\\/g, "/");
+  for (const [dir, files] of groupedFiles.entries()) {
+    const relDir = toRelative(dir);
+    if (relDir !== ".") {
+      output += `
+${colors.cyan}${relDir}/${colors.reset}
+`;
+    }
+    for (const { path, coverage } of files) {
+      const stats = calculateFileCoverage(coverage);
+      const relPath = toRelative(path);
+      let displayName = relPath;
+      if (displayName.length > namePadding - 2) {
+        displayName = "..." + displayName.slice(-(namePadding - 5));
+      }
+      output += displayName.padEnd(namePadding);
+      output += formatMetricFixedWidth(
+        stats.statements.covered,
+        stats.statements.total,
+        stats.statements.percentage,
+        true
+        // Include separator
+      );
+      output += formatMetricFixedWidth(
+        stats.branches.covered,
+        stats.branches.total,
+        stats.branches.percentage,
+        true
+        // Include separator
+      );
+      output += formatMetricFixedWidth(
+        stats.functions.covered,
+        stats.functions.total,
+        stats.functions.percentage,
+        true
+        // Include separator
+      );
+      output += formatMetricFixedWidth(
+        stats.lines.covered,
+        stats.lines.total,
+        stats.lines.percentage,
+        true
+        // Include separator
+      );
+      const uncoveredStr = formatUncoveredLines(coverage.uncoveredLines);
+      output += `${colors.red}${uncoveredStr}${colors.reset}`;
+      output += "\n";
+    }
+  }
+  output += `
+`;
+  output += `${colors.dim}${colors.bold}Test Files\x1B[0m  ${coverageMap.size} passed (100%)
+`;
+  output += `${colors.dim}${colors.bold}Tests\x1B[0m       ${coverageMap.size} passed (100%)
+`;
+  output += `
+`;
+  output += `${colors.dim}${colors.bold}Statements\x1B[0m   ${colors.green}${coveredStatements}${colors.reset} ${colors.dim}/${colors.reset} ${totalStatements}
+`;
+  output += `${colors.dim}${colors.bold}Branches\x1B[0m    ${colors.green}${coveredBranches}${colors.reset} ${colors.dim}/${colors.reset} ${totalBranches}
+`;
+  output += `${colors.dim}${colors.bold}Functions\x1B[0m    ${colors.green}${coveredFunctions}${colors.reset} ${colors.dim}/${colors.reset} ${totalFunctions}
+`;
+  output += `${colors.dim}${colors.bold}Lines\x1B[0m       ${colors.green}${coveredLines}${colors.reset} ${colors.dim}/${colors.reset} ${totalLines}
+`;
+  return output;
+}
+function generateHtmlReport(coverageMap, reportsDir) {
+  if (!existsSync(reportsDir)) {
+    mkdirSync(reportsDir, { recursive: true });
+  }
+  let totalStatements = 0, coveredStatements = 0;
+  let totalBranches = 0, coveredBranches = 0;
+  let totalFunctions = 0, coveredFunctions = 0;
+  let totalLines = 0, coveredLines = 0;
+  for (const coverage of coverageMap.values()) {
+    totalStatements += coverage.statements;
+    coveredStatements += coverage.coveredStatements;
+    totalBranches += coverage.branches;
+    coveredBranches += coverage.coveredBranches;
+    totalFunctions += coverage.functions;
+    coveredFunctions += coverage.coveredFunctions;
+    totalLines += coverage.lines;
+    coveredLines += coverage.coveredLines;
+  }
+  const pctStmts = totalStatements > 0 ? coveredStatements / totalStatements * 100 : 0;
+  const pctBranch = totalBranches > 0 ? coveredBranches / totalBranches * 100 : 0;
+  const pctFunc = totalFunctions > 0 ? coveredFunctions / totalFunctions * 100 : 0;
+  const pctLines = totalLines > 0 ? coveredLines / totalLines * 100 : 0;
+  const overallPct = (pctStmts + pctBranch + pctFunc + pctLines) / 4;
+  const totalFiles = coverageMap.size;
+  const coveredFiles = Array.from(coverageMap.values()).filter((c) => c.coveredStatements > 0).length;
+  const cwd = process.cwd();
+  const toRelative = (path) => relative(cwd, path).replace(/\\/g, "/");
+  const indexHtml = `<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8">
+    <title>Coverage Report</title>
+    <link rel="icon" type="image/svg+xml" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'%3E%3Cdefs%3E%3ClinearGradient id='grad' x1='0%25' y1='0%25' x2='100%25' y2='100%25'%3E%3Cstop offset='0%25' stop-color='%236366f1'/%3E%3Cstop offset='100%25' stop-color='%238b5cf6'/%3E%3C/linearGradient%3E%3C/defs%3E%3Crect width='100' height='100' rx='20' fill='url(%23grad)'/%3E%3Crect x='28' y='25' width='44' height='8' rx='4' fill='white'/%3E%3Crect x='28' y='46' width='32' height='8' rx='4' fill='white'/%3E%3Crect x='28' y='67' width='44' height='8' rx='4' fill='white'/%3E%3Crect x='28' y='25' width='8' height='50' rx='4' fill='white'/%3E%3Ccircle cx='72' cy='50' r='6' fill='white' opacity='0.5'/%3E%3C/svg%3E">
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+            background: #0d1117;
+            color: #c9d1d9;
+            padding: 20px;
+        }
+        .container { max-width: 1400px; margin: 0 auto; }
+        h1 {
+            font-size: 24px;
+            font-weight: 600;
+            margin-bottom: 20px;
+            color: #58a6ff;
+        }
+        .overall-bar {
+            background: #161b22;
+            border: 1px solid #30363d;
+            border-radius: 6px;
+            padding: 15px 20px;
+            margin-bottom: 20px;
+        }
+        .overall-bar-inner {
+            display: flex;
+            align-items: center;
+            gap: 15px;
+        }
+        .overall-bar-label {
+            font-size: 14px;
+            font-weight: 600;
+            color: #8b949e;
+            min-width: 140px;
+        }
+        .overall-bar-visual {
+            flex: 1;
+            height: 24px;
+            background: #21262d;
+            border-radius: 4px;
+            overflow: hidden;
+            position: relative;
+        }
+        .overall-bar-fill {
+            height: 100%;
+            background: ${overallPct >= 80 ? "#3fb950" : overallPct >= 50 ? "#d29922" : "#f85149"};
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            transition: width 0.3s ease;
+        }
+        .overall-bar-text {
+            position: absolute;
+            right: 10px;
+            top: 50%;
+            transform: translateY(-50%);
+            font-size: 12px;
+            font-weight: 600;
+            color: #ffffff;
+            text-shadow: 0 1px 2px rgba(0,0,0,0.3);
+        }
+        .files-info {
+            font-size: 13px;
+            color: #8b949e;
+            margin-top: 8px;
+        }
+        .files-info span { color: #58a6ff; font-weight: 600; }
+        .summary {
+            background: #161b22;
+            border: 1px solid #30363d;
+            border-radius: 6px;
+            padding: 20px;
+            margin-bottom: 20px;
+        }
+        .summary-title {
+            font-size: 16px;
+            font-weight: 600;
+            margin-bottom: 15px;
+            color: #c9d1d9;
+        }
+        .metrics { display: grid; grid-template-columns: repeat(4, 1fr); gap: 15px; }
+        .metric {
+            background: #21262d;
+            border: 1px solid #30363d;
+            border-radius: 6px;
+            padding: 15px;
+            text-align: center;
+        }
+        .metric-label { font-size: 12px; color: #8b949e; margin-bottom: 5px; text-transform: uppercase; letter-spacing: 0.5px; }
+        .metric-value { font-size: 24px; font-weight: 700; }
+        .metric-value.high { color: #3fb950; }
+        .metric-value.medium { color: #d29922; }
+        .metric-value.low { color: #f85149; }
+        .progress-bar {
+            height: 8px;
+            background: #21262d;
+            border-radius: 4px;
+            overflow: hidden;
+            margin-top: 8px;
+        }
+        .progress-fill { height: 100%; transition: width 0.3s ease; }
+        .progress-fill.high { background: #3fb950; }
+        .progress-fill.medium { background: #d29922; }
+        .progress-fill.low { background: #f85149; }
+        .metric-count { font-size: 11px; color: #8b949e; margin-top: 5px; }
+        .file-list {
+            background: #161b22;
+            border: 1px solid #30363d;
+            border-radius: 6px;
+            overflow: hidden;
+        }
+        .file-header {
+            display: grid;
+            grid-template-columns: 1fr 80px 80px 80px 80px;
+            padding: 12px 15px;
+            background: #21262d;
+            font-size: 12px;
+            font-weight: 600;
+            color: #8b949e;
+            border-bottom: 1px solid #30363d;
+        }
+        .file-row {
+            display: grid;
+            grid-template-columns: 1fr 80px 80px 80px 80px;
+            padding: 10px 15px;
+            border-bottom: 1px solid #21262d;
+            font-size: 13px;
+        }
+        .file-row:hover { background: #21262d; }
+        .file-row:last-child { border-bottom: none; }
+        .file-name { color: #58a6ff; text-decoration: none; cursor: pointer; }
+        .file-name:hover { text-decoration: underline; }
+        .percentage { font-weight: 600; }
+        .percentage.high { color: #3fb950; }
+        .percentage.medium { color: #d29922; }
+        .percentage.low { color: #f85149; }
+        .metric-detail { font-size: 11px; color: #8b949e; margin-top: 2px; }
+        .badge { display: inline-block; padding: 2px 8px; border-radius: 12px; font-size: 11px; font-weight: 600; margin-left: 8px; }
+        .badge.covered { background: #238636; color: #fff; }
+        .badge.uncovered { background: #da3633; color: #fff; }
+        .coverage-cell { text-align: center; }
+        .coverage-percent { font-weight: 600; }
+        .coverage-percent.high { color: #3fb950; }
+        .coverage-percent.medium { color: #d29922; }
+        .coverage-percent.low { color: #f85149; }
+        .coverage-count { font-size: 11px; color: #8b949e; margin-top: 2px; }
+        .search-container {
+            background: #161b22;
+            border: 1px solid #30363d;
+            border-radius: 6px;
+            padding: 15px;
+            margin-bottom: 20px;
+        }
+        .search-input {
+            width: 100%;
+            padding: 10px 15px;
+            background: #21262d;
+            border: 1px solid #30363d;
+            border-radius: 6px;
+            color: #c9d1d9;
+            font-size: 14px;
+            font-family: inherit;
+            outline: none;
+            transition: border-color 0.2s ease;
+        }
+        .search-input:focus {
+            border-color: #58a6ff;
+        }
+        .search-input::placeholder {
+            color: #8b949e;
+        }
+        .hidden { display: none !important; }
+        .no-results {
+            padding: 20px;
+            text-align: center;
+            color: #8b949e;
+            font-size: 14px;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>Coverage Report</h1>
+
+        <div class="overall-bar">
+            <div class="overall-bar-inner">
+                <div class="overall-bar-label">Overall Coverage</div>
+                <div class="overall-bar-visual">
+                    <div class="overall-bar-fill" style="width: ${overallPct}%"></div>
+                    <div class="overall-bar-text">${overallPct.toFixed(2)}%</div>
+                </div>
+            </div>
+            <div class="files-info"><span>${coveredFiles}</span> of ${totalFiles} files covered</div>
+        </div>
+
+        <div class="summary">
+            <div class="summary-title">Coverage Metrics</div>
+            <div class="metrics">
+                <div class="metric">
+                    <div class="metric-label">Statements</div>
+                    <div class="metric-value ${pctStmts >= 80 ? "high" : pctStmts >= 50 ? "medium" : "low"}">${pctStmts.toFixed(2)}%</div>
+                    <div class="progress-bar">
+                        <div class="progress-fill ${pctStmts >= 80 ? "high" : pctStmts >= 50 ? "medium" : "low"}" style="width: ${pctStmts}%"></div>
+                    </div>
+                    <div class="metric-count">${coveredStatements}/${totalStatements}</div>
+                </div>
+                <div class="metric">
+                    <div class="metric-label">Branches</div>
+                    <div class="metric-value ${pctBranch >= 80 ? "high" : pctBranch >= 50 ? "medium" : "low"}">${pctBranch.toFixed(2)}%</div>
+                    <div class="progress-bar">
+                        <div class="progress-fill ${pctBranch >= 80 ? "high" : pctBranch >= 50 ? "medium" : "low"}" style="width: ${pctBranch}%"></div>
+                    </div>
+                    <div class="metric-count">${coveredBranches}/${totalBranches}</div>
+                </div>
+                <div class="metric">
+                    <div class="metric-label">Functions</div>
+                    <div class="metric-value ${pctFunc >= 80 ? "high" : pctFunc >= 50 ? "medium" : "low"}">${pctFunc.toFixed(2)}%</div>
+                    <div class="progress-bar">
+                        <div class="progress-fill ${pctFunc >= 80 ? "high" : pctFunc >= 50 ? "medium" : "low"}" style="width: ${pctFunc}%"></div>
+                    </div>
+                    <div class="metric-count">${coveredFunctions}/${totalFunctions}</div>
+                </div>
+                <div class="metric">
+                    <div class="metric-label">Lines</div>
+                    <div class="metric-value ${pctLines >= 80 ? "high" : pctLines >= 50 ? "medium" : "low"}">${pctLines.toFixed(2)}%</div>
+                    <div class="progress-bar">
+                        <div class="progress-fill ${pctLines >= 80 ? "high" : pctLines >= 50 ? "medium" : "low"}" style="width: ${pctLines}%"></div>
+                    </div>
+                    <div class="metric-count">${coveredLines}/${totalLines}</div>
+                </div>
+            </div>
+        </div>
+
+        <div class="search-container">
+            <input type="text" id="search-input" class="search-input" placeholder="\u{1F50D} Search files..." autocomplete="off">
+        </div>
+
+        <div class="file-list">
+            <div class="file-header">
+                <div>File</div>
+                <div style="text-align: center">Stmts</div>
+                <div style="text-align: center">Branch</div>
+                <div style="text-align: center">Funcs</div>
+                <div style="text-align: center">Lines</div>
+            </div>
+            <div id="file-rows">
+            ${Array.from(coverageMap.entries()).map(([filePath, coverage]) => {
+    const stats = calculateFileCoverage(coverage);
+    const fileName = toRelative(filePath);
+    const safeFileName = fileName.replace(/[\/\\]/g, "_") + ".html";
+    const isCovered = coverage.coveredStatements > 0;
+    return `
+                    <div class="file-row" onclick="window.location.href='${safeFileName}'">
+                        <div>
+                            <span class="file-name">${fileName}</span>
+                            ${isCovered ? '<span class="badge covered">Covered</span>' : '<span class="badge uncovered">Not Covered</span>'}
+                        </div>
+                        <div class="coverage-cell">
+                            <div class="coverage-percent ${stats.statements.percentage >= 80 ? "high" : stats.statements.percentage >= 50 ? "medium" : "low"}">${stats.statements.percentage.toFixed(2)}%</div>
+                            <div class="coverage-count">${coverage.coveredStatements}/${coverage.statements}</div>
+                        </div>
+                        <div class="coverage-cell">
+                            <div class="coverage-percent ${stats.branches.percentage >= 80 ? "high" : stats.branches.percentage >= 50 ? "medium" : "low"}">${stats.branches.percentage.toFixed(2)}%</div>
+                            <div class="coverage-count">${coverage.coveredBranches}/${coverage.branches}</div>
+                        </div>
+                        <div class="coverage-cell">
+                            <div class="coverage-percent ${stats.functions.percentage >= 80 ? "high" : stats.functions.percentage >= 50 ? "medium" : "low"}">${stats.functions.percentage.toFixed(2)}%</div>
+                            <div class="coverage-count">${coverage.coveredFunctions}/${coverage.functions}</div>
+                        </div>
+                        <div class="coverage-cell">
+                            <div class="coverage-percent ${stats.lines.percentage >= 80 ? "high" : stats.lines.percentage >= 50 ? "medium" : "low"}">${stats.lines.percentage.toFixed(2)}%</div>
+                            <div class="coverage-count">${coverage.coveredLines}/${coverage.lines}</div>
+                        </div>
+                    </div>
+                `;
+  }).join("")}
+            </div>
+            <div id="no-results" class="no-results hidden">No files found matching your search</div>
+        </div>
+    </div>
+
+    <script>
+        const searchInput = document.getElementById('search-input');
+        const fileRows = document.getElementById('file-rows');
+        const noResults = document.getElementById('no-results');
+        const fileRowElements = fileRows.querySelectorAll('.file-row');
+
+        searchInput.addEventListener('input', function() {
+            const searchTerm = this.value.toLowerCase().trim();
+            let visibleCount = 0;
+
+            fileRowElements.forEach(function(row) {
+                const fileName = row.querySelector('.file-name').textContent.toLowerCase();
+                if (fileName.includes(searchTerm)) {
+                    row.classList.remove('hidden');
+                    visibleCount++;
+                } else {
+                    row.classList.add('hidden');
+                }
+            });
+
+            if (visibleCount === 0) {
+                noResults.classList.remove('hidden');
+            } else {
+                noResults.classList.add('hidden');
+            }
+        });
+    </script>
+</body>
+</html>`;
+  writeFileSync(join(reportsDir, "index.html"), indexHtml, "utf-8");
+  for (const [filePath, coverage] of coverageMap.entries()) {
+    generateFileDetailPage(filePath, coverage, reportsDir, toRelative);
+  }
+}
+function generateFileDetailPage(filePath, coverage, reportsDir, toRelative) {
+  const fileName = toRelative(filePath);
+  const safeFileName = fileName.replace(/[\/\\]/g, "_") + ".html";
+  const stats = calculateFileCoverage(coverage);
+  let sourceLines = [];
+  try {
+    const sourceCode = readFileSync(filePath, "utf-8").toString();
+    sourceLines = sourceCode.split("\n");
+  } catch (e) {
+    sourceLines = ["// Unable to read source file"];
+  }
+  const uncoveredSet = new Set(coverage.uncoveredLines || []);
+  const fileHtml = `<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8">
+    <title>Coverage: ${fileName}</title>
+    <link rel="icon" type="image/svg+xml" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'%3E%3Cdefs%3E%3ClinearGradient id='grad' x1='0%25' y1='0%25' x2='100%25' y2='100%25'%3E%3Cstop offset='0%25' stop-color='%236366f1'/%3E%3Cstop offset='100%25' stop-color='%238b5cf6'/%3E%3C/linearGradient%3E%3C/defs%3E%3Crect width='100' height='100' rx='20' fill='url(%23grad)'/%3E%3Crect x='28' y='25' width='44' height='8' rx='4' fill='white'/%3E%3Crect x='28' y='46' width='32' height='8' rx='4' fill='white'/%3E%3Crect x='28' y='67' width='44' height='8' rx='4' fill='white'/%3E%3Crect x='28' y='25' width='8' height='50' rx='4' fill='white'/%3E%3Ccircle cx='72' cy='50' r='6' fill='white' opacity='0.5'/%3E%3C/svg%3E">
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+            background: #0d1117;
+            color: #c9d1d9;
+            padding: 20px;
+        }
+        .container { max-width: 1400px; margin: 0 auto; }
+        a { color: #58a6ff; text-decoration: none; }
+        a:hover { text-decoration: underline; }
+        h1 {
+            font-size: 24px;
+            font-weight: 600;
+            margin-bottom: 10px;
+            color: #58a6ff;
+        }
+        .breadcrumb {
+            font-size: 14px;
+            color: #8b949e;
+            margin-bottom: 20px;
+        }
+        .breadcrumb a { color: #58a6ff; }
+        .summary {
+            background: #161b22;
+            border: 1px solid #30363d;
+            border-radius: 6px;
+            padding: 20px;
+            margin-bottom: 20px;
+        }
+        .summary-title {
+            font-size: 16px;
+            font-weight: 600;
+            margin-bottom: 15px;
+            color: #c9d1d9;
+        }
+        .metrics { display: grid; grid-template-columns: repeat(4, 1fr); gap: 15px; }
+        .metric {
+            background: #21262d;
+            border: 1px solid #30363d;
+            border-radius: 6px;
+            padding: 15px;
+            text-align: center;
+        }
+        .metric-label { font-size: 12px; color: #8b949e; margin-bottom: 5px; text-transform: uppercase; letter-spacing: 0.5px; }
+        .metric-value { font-size: 24px; font-weight: 700; }
+        .metric-value.high { color: #3fb950; }
+        .metric-value.medium { color: #d29922; }
+        .metric-value.low { color: #f85149; }
+        .progress-bar {
+            height: 8px;
+            background: #21262d;
+            border-radius: 4px;
+            overflow: hidden;
+            margin-top: 8px;
+        }
+        .progress-fill { height: 100%; transition: width 0.3s ease; }
+        .progress-fill.high { background: #3fb950; }
+        .progress-fill.medium { background: #d29922; }
+        .progress-fill.low { background: #f85149; }
+        .metric-count { font-size: 11px; color: #8b949e; margin-top: 5px; }
+        .code-container {
+            background: #161b22;
+            border: 1px solid #30363d;
+            border-radius: 6px;
+            overflow: hidden;
+        }
+        .code-header {
+            padding: 10px 15px;
+            background: #21262d;
+            border-bottom: 1px solid #30363d;
+            font-size: 13px;
+            color: #8b949e;
+            display: flex;
+            justify-content: space-between;
+        }
+        .legend { display: flex; gap: 15px; font-size: 12px; }
+        .legend-item { display: flex; align-items: center; gap: 5px; }
+        .legend-box { width: 12px; height: 12px; border-radius: 2px; }
+        .legend-box.covered { background: rgba(63, 185, 80, 0.2); border: 1px solid #3fb950; }
+        .legend-box.uncovered { background: rgba(248, 81, 73, 0.2); border: 1px solid #f85149; }
+        .code-table { width: 100%; border-collapse: collapse; }
+        .code-table td { padding: 0; }
+        .line-number {
+            width: 50px;
+            text-align: right;
+            padding: 0 15px;
+            color: #8b949e;
+            font-size: 12px;
+            user-select: none;
+            border-right: 1px solid #30363d;
+        }
+        .line-content {
+            padding: 0 15px;
+            font-family: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, monospace;
+            font-size: 13px;
+            line-height: 20px;
+            white-space: pre;
+        }
+        tr.covered .line-content { background: rgba(63, 185, 80, 0.1); }
+        tr.uncovered .line-content { background: rgba(248, 81, 73, 0.15); }
+        tr.uncovered .line-number { color: #f85149; }
+        tr:hover td { background: rgba(88, 166, 255, 0.1); }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="breadcrumb">
+            <a href="index.html">\u2190 Back to Coverage Report</a>
+        </div>
+
+        <h1>${fileName}</h1>
+
+        <div class="summary">
+            <div class="summary-title">Coverage Metrics</div>
+            <div class="metrics">
+                <div class="metric">
+                    <div class="metric-label">Statements</div>
+                    <div class="metric-value ${stats.statements.percentage >= 80 ? "high" : stats.statements.percentage >= 50 ? "medium" : "low"}">${stats.statements.percentage.toFixed(2)}%</div>
+                    <div class="progress-bar">
+                        <div class="progress-fill ${stats.statements.percentage >= 80 ? "high" : stats.statements.percentage >= 50 ? "medium" : "low"}" style="width: ${stats.statements.percentage}%"></div>
+                    </div>
+                    <div class="metric-count">${coverage.coveredStatements}/${coverage.statements}</div>
+                </div>
+                <div class="metric">
+                    <div class="metric-label">Branches</div>
+                    <div class="metric-value ${stats.branches.percentage >= 80 ? "high" : stats.branches.percentage >= 50 ? "medium" : "low"}">${stats.branches.percentage.toFixed(2)}%</div>
+                    <div class="progress-bar">
+                        <div class="progress-fill ${stats.branches.percentage >= 80 ? "high" : stats.branches.percentage >= 50 ? "medium" : "low"}" style="width: ${stats.branches.percentage}%"></div>
+                    </div>
+                    <div class="metric-count">${coverage.coveredBranches}/${coverage.branches}</div>
+                </div>
+                <div class="metric">
+                    <div class="metric-label">Functions</div>
+                    <div class="metric-value ${stats.functions.percentage >= 80 ? "high" : stats.functions.percentage >= 50 ? "medium" : "low"}">${stats.functions.percentage.toFixed(2)}%</div>
+                    <div class="progress-bar">
+                        <div class="progress-fill ${stats.functions.percentage >= 80 ? "high" : stats.functions.percentage >= 50 ? "medium" : "low"}" style="width: ${stats.functions.percentage}%"></div>
+                    </div>
+                    <div class="metric-count">${coverage.coveredFunctions}/${coverage.functions}</div>
+                </div>
+                <div class="metric">
+                    <div class="metric-label">Lines</div>
+                    <div class="metric-value ${stats.lines.percentage >= 80 ? "high" : stats.lines.percentage >= 50 ? "medium" : "low"}">${stats.lines.percentage.toFixed(2)}%</div>
+                    <div class="progress-bar">
+                        <div class="progress-fill ${stats.lines.percentage >= 80 ? "high" : stats.lines.percentage >= 50 ? "medium" : "low"}" style="width: ${stats.lines.percentage}%"></div>
+                    </div>
+                    <div class="metric-count">${coverage.coveredLines}/${coverage.lines}</div>
+                </div>
+            </div>
+        </div>
+
+        ${coverage.uncoveredLines && coverage.uncoveredLines.length > 0 ? `
+        <div class="summary">
+            <div class="summary-title">Uncovered Lines</div>
+            <div style="font-size: 13px; color: #f85149;">${formatUncoveredLines(coverage.uncoveredLines)}</div>
+        </div>
+        ` : ""}
+
+        <div class="code-container">
+            <div class="code-header">
+                <span>Source Code</span>
+                <div class="legend">
+                    <div class="legend-item"><div class="legend-box covered"></div><span>Covered</span></div>
+                    <div class="legend-item"><div class="legend-box uncovered"></div><span>Uncovered</span></div>
+                </div>
+            </div>
+            <table class="code-table">
+                ${sourceLines.map((line, index) => {
+    const lineNum = index + 1;
+    const isUncovered = uncoveredSet.has(lineNum);
+    const isExecutable = coverage.lines > 0;
+    const rowClass = isExecutable ? isUncovered ? "uncovered" : "covered" : "";
+    return `
+                        <tr class="${rowClass}">
+                            <td class="line-number">${lineNum}</td>
+                            <td class="line-content">${escapeHtml(line) || " "}</td>
+                        </tr>
+                    `;
+  }).join("")}
+            </table>
+        </div>
+    </div>
+</body>
+</html>`;
+  writeFileSync(join(reportsDir, safeFileName), fileHtml, "utf-8");
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function generateCoverageFinalJson(coverageMap, reportsDir) {
+  const coverageData = {};
+  for (const [filePath, coverage] of coverageMap.entries()) {
+    const relativePath2 = relative(process.cwd(), filePath).replace(/\\/g, "/");
+    const lineMap = {};
+    const executableLines = getExecutableLines(filePath);
+    for (const line of executableLines) {
+      const isCovered = coverage.coveredStatements > 0;
+      lineMap[line] = isCovered ? 1 : 0;
+    }
+    coverageData[relativePath2] = {
+      lines: lineMap
+    };
+  }
+  const jsonData = JSON.stringify(coverageData, null, 2);
+  writeFileSync(join(reportsDir, "coverage-final.json"), jsonData, "utf-8");
+}
+function generateCloverXml(coverageMap, reportsDir) {
+  const timestamp = Date.now();
+  let totalFiles = 0;
+  let totalClasses = 0;
+  let totalElements = 0;
+  let coveredElements = 0;
+  let totalStatements = 0;
+  let coveredStatements = 0;
+  let totalBranches = 0;
+  let coveredBranches = 0;
+  let totalFunctions = 0;
+  let coveredFunctions = 0;
+  let totalLines = 0;
+  let coveredLines = 0;
+  const fileEntries = [];
+  for (const [filePath, coverage] of coverageMap.entries()) {
+    const relativePath2 = relative(process.cwd(), filePath).replace(/\\/g, "/");
+    totalFiles++;
+    totalClasses++;
+    totalStatements += coverage.statements;
+    coveredStatements += coverage.coveredStatements;
+    totalBranches += coverage.branches;
+    coveredBranches += coverage.coveredBranches;
+    totalFunctions += coverage.functions;
+    coveredFunctions += coverage.coveredFunctions;
+    totalLines += coverage.lines;
+    coveredLines += coverage.coveredLines;
+    const fileElements = coverage.statements + coverage.branches + coverage.functions;
+    const fileCoveredElements = coverage.coveredStatements + coverage.coveredBranches + coverage.coveredFunctions;
+    totalElements += fileElements;
+    coveredElements += fileCoveredElements;
+    const escapedPath = escapeXml(relativePath2);
+    fileEntries.push(`
+    <file name="${escapedPath}">
+      <class name="${escapedPath}">
+        <metrics complexity="0" elements="${fileElements}" coveredelements="${fileCoveredElements}"
+                 methods="${coverage.functions}" coveredmethods="${coverage.coveredFunctions}"
+                 statements="${coverage.statements}" coveredstatements="${coverage.coveredStatements}" />
+      </class>
+      <line num="1" type="stmt" count="${coverage.coveredStatements > 0 ? 1 : 0}" />
+    </file>`);
+  }
+  const complexity = 0;
+  const elements = totalElements;
+  const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<coverage generated="${timestamp}" clover="3.2.0">
+  <project timestamp="${timestamp}" name="Coverage">
+    <metrics complexity="${complexity}" elements="${elements}" coveredelements="${coveredElements}"
+             conditionals="${totalBranches}" coveredconditionals="${coveredBranches}"
+             statements="${totalStatements}" coveredstatements="${coveredStatements}"
+             methods="${totalFunctions}" coveredmethods="${coveredFunctions}"
+             classes="${totalClasses}" coveredclasses="${coverageMap.size > 0 ? Array.from(coverageMap.values()).filter((c) => c.coveredStatements > 0).length : 0}"
+             files="${totalFiles}" loc="${totalLines}" ncloc="${totalLines - coveredLines}"
+             packages="${totalFiles}" classes="${totalClasses}" />
+    <package name="root">
+      <metrics complexity="${complexity}" elements="${elements}" coveredelements="${coveredElements}"
+               conditionals="${totalBranches}" coveredconditionals="${coveredBranches}"
+               statements="${totalStatements}" coveredstatements="${coveredStatements}"
+               methods="${totalFunctions}" coveredmethods="${coveredFunctions}"
+               classes="${totalClasses}" coveredclasses="${coverageMap.size > 0 ? Array.from(coverageMap.values()).filter((c) => c.coveredStatements > 0).length : 0}"
+               files="${totalFiles}" loc="${totalLines}" ncloc="${totalLines - coveredLines}" />
+${fileEntries.join("")}
+    </package>
+  </project>
+</coverage>`;
+  writeFileSync(join(reportsDir, "clover.xml"), xml, "utf-8");
+}
+export {
+  calculateUncoveredLines,
+  generateCloverXml,
+  generateCoverageFinalJson,
+  generateHtmlReport,
+  generateTextReport,
+  getExecutedLines,
+  initializeCoverageTracking,
+  markFileAsCovered,
+  markLineExecuted,
+  processCoverage,
+  resetCoverageTracking
+};
+//# sourceMappingURL=coverage.mjs.map