@rpcbase/test 0.308.0 → 0.310.0

package/{src → dist}/coverage/report.js

@@ -1,234 +1,212 @@
-import fs from "node:fs/promises"
-import path from "node:path"
-import { fileURLToPath } from "node:url"
-
-import * as libCoverage from "istanbul-lib-coverage"
-import * as libInstrument from "istanbul-lib-instrument"
-import { createContext } from "istanbul-lib-report"
-import reports from "istanbul-reports"
-import fg from "fast-glob"
-import picomatch from "picomatch"
-import v8ToIstanbul from "v8-to-istanbul"
-
-import { createCollectCoverageMatcher, toPosix } from "./collect.js"
-import { findCoverageFiles } from "./files.js"
-
-
-const TEXT_REPORT_FILENAME = "coverage.txt"
-
-export class CoverageThresholdError extends Error {
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import * as libCoverage from "istanbul-lib-coverage";
+import * as libInstrument from "istanbul-lib-instrument";
+import fg from "fast-glob";
+import picomatch from "picomatch";
+import v8ToIstanbul from "v8-to-istanbul";
+import { createCollectCoverageMatcher, toPosix } from "./collect.js";
+import { findCoverageFiles } from "./files.js";
+const TEXT_REPORT_FILENAME = "coverage.txt";
+class CoverageThresholdError extends Error {
   constructor(message) {
-    super(message)
-    this.name = "CoverageThresholdError"
+    super(message);
+    this.name = "CoverageThresholdError";
   }
 }
-
-export async function generateCoverageReport(config) {
-  const coverageFiles = await findCoverageFiles(config)
-
+async function generateCoverageReport(config) {
+  const coverageFiles = await findCoverageFiles(config);
   if (coverageFiles.length === 0) {
-    console.warn("[coverage] no V8 coverage artifacts were generated")
-    return
-  }
-
-  const coverageLib = resolveCoverageLib()
-  const coverageMap = coverageLib.createCoverageMap({})
-  const matchesCollectCoverageFrom = createCollectCoverageMatcher(config.collectCoverageFrom, config.rootDir)
-
+    console.warn("[coverage] no V8 coverage artifacts were generated");
+    return;
+  }
+  const coverageLib = resolveCoverageLib();
+  const coverageMap = coverageLib.createCoverageMap({});
+  const matchesCollectCoverageFrom = createCollectCoverageMatcher(config.collectCoverageFrom, config.rootDir);
   for (const file of coverageFiles) {
-    const payload = await readCoverageFile(file)
+    const payload = await readCoverageFile(file);
     if (!payload) {
-      continue
+      continue;
     }
-
     for (const script of payload.scripts) {
-      await mergeScriptCoverage(coverageMap, script, config, matchesCollectCoverageFrom)
+      await mergeScriptCoverage(coverageMap, script, config, matchesCollectCoverageFrom);
     }
   }
-
   if (config.includeAllFiles) {
-    await includeUntestedFiles(coverageMap, config, matchesCollectCoverageFrom)
+    await includeUntestedFiles(coverageMap, config, matchesCollectCoverageFrom);
   }
-
   if (coverageMap.files().length === 0) {
-    console.warn("[coverage] no library files matched the coverage filters")
-    return
+    console.warn("[coverage] no library files matched the coverage filters");
+    return;
   }
-
-  await fs.rm(config.coverageReportDir, { recursive: true, force: true })
-  await fs.mkdir(config.coverageReportDir, { recursive: true })
-
+  await fs.rm(config.coverageReportDir, { recursive: true, force: true });
+  await fs.mkdir(config.coverageReportDir, { recursive: true });
+  const { createContext, reports } = await loadIstanbulModules();
   const context = createContext({
     dir: config.coverageReportDir,
     coverageMap,
-    defaultSummarizer: "pkg",
-  })
-
-  reports.create("text", { maxCols: process.stdout.columns ?? 120 }).execute(context)
-  reports.create("text", { file: TEXT_REPORT_FILENAME }).execute(context)
-
-  console.log(`[coverage] Full text report saved to ${path.join(config.coverageReportDir, TEXT_REPORT_FILENAME)}`)
-
-  const summary = coverageMap.getCoverageSummary()
-  enforceThresholds(summary, config.thresholds, "global")
-
-  const targets = Array.isArray(config.thresholdTargets) ? config.thresholdTargets : []
+    defaultSummarizer: "pkg"
+  });
+  reports.create("text", { maxCols: process.stdout.columns ?? 120 }).execute(context);
+  reports.create("text", { file: TEXT_REPORT_FILENAME }).execute(context);
+  console.log(`[coverage] Full text report saved to ${path.join(config.coverageReportDir, TEXT_REPORT_FILENAME)}`);
+  const summary = coverageMap.getCoverageSummary();
+  enforceThresholds(summary, config.thresholds, "global");
+  const targets = Array.isArray(config.thresholdTargets) ? config.thresholdTargets : [];
   if (targets.length > 0) {
-    const fileSummaries = buildFileSummaries(coverageMap, config.rootDir)
+    const fileSummaries = buildFileSummaries(coverageMap, config.rootDir);
     for (const target of targets) {
-      const matcher = createGlobMatcher(target.pattern)
-      const matchResult = collectTargetSummary(fileSummaries, matcher, coverageLib)
-
+      const matcher = createGlobMatcher(target.pattern);
+      const matchResult = collectTargetSummary(fileSummaries, matcher, coverageLib);
       if (matchResult.matched === 0) {
         console.warn(
-          `[coverage] threshold pattern "${target.pattern}" did not match any files — skipping`,
-        )
-        continue
+          `[coverage] threshold pattern "${target.pattern}" did not match any files — skipping`
+        );
+        continue;
       }
-
-      enforceThresholds(matchResult.summary, target.thresholds, target.pattern)
+      enforceThresholds(matchResult.summary, target.thresholds, target.pattern);
     }
   }
 }
-
-export async function collectCoveredFiles(config) {
-  const coverageFiles = await findCoverageFiles(config)
+async function collectCoveredFiles(config) {
+  const coverageFiles = await findCoverageFiles(config);
   if (coverageFiles.length === 0) {
-    return []
+    return [];
   }
-
-  const coverageLib = resolveCoverageLib()
-  const coverageMap = coverageLib.createCoverageMap({})
-  const matchesCollectCoverageFrom = createCollectCoverageMatcher(config.collectCoverageFrom, config.rootDir)
-
+  const coverageLib = resolveCoverageLib();
+  const coverageMap = coverageLib.createCoverageMap({});
+  const matchesCollectCoverageFrom = createCollectCoverageMatcher(config.collectCoverageFrom, config.rootDir);
   for (const file of coverageFiles) {
-    const payload = await readCoverageFile(file)
+    const payload = await readCoverageFile(file);
     if (!payload) {
-      continue
+      continue;
     }
-
     for (const script of payload.scripts) {
-      await mergeScriptCoverage(coverageMap, script, config, matchesCollectCoverageFrom)
+      await mergeScriptCoverage(coverageMap, script, config, matchesCollectCoverageFrom);
     }
   }
-
-  return coverageMap.files().sort()
+  return coverageMap.files().sort();
+}
+async function loadIstanbulModules() {
+  maybeForceColor();
+  const [libReportMod, reportsMod] = await Promise.all([
+    import("istanbul-lib-report"),
+    import("istanbul-reports")
+  ]);
+  const createContext = typeof libReportMod.createContext === "function" ? libReportMod.createContext : libReportMod.default?.createContext;
+  if (typeof createContext !== "function") {
+    throw new Error("istanbul-lib-report exports are unavailable");
+  }
+  return {
+    createContext,
+    reports: reportsMod.default ?? reportsMod
+  };
+}
+function maybeForceColor() {
+  if (process.stdout.isTTY) {
+    return;
+  }
+  if (process.env.FORCE_COLOR !== void 0) {
+    return;
+  }
+  if (process.env.NO_COLOR !== void 0 || process.env.NODE_DISABLE_COLORS !== void 0) {
+    return;
+  }
+  if (process.env.CI !== void 0) {
+    return;
+  }
+  process.env.FORCE_COLOR = "1";
 }
-
 async function mergeScriptCoverage(coverageMap, script, config, matchesCollectCoverageFrom) {
-  const scriptPath = script.absolutePath
+  const scriptPath = script.absolutePath;
   if (!scriptPath) {
-    return
+    return;
   }
-
   if (isNodeModulesPath(scriptPath)) {
-    return
+    return;
   }
-
   if (isViteVirtualModulePath(scriptPath)) {
-    return
+    return;
   }
-
-  let source = script.source && script.source.length > 0
-    ? script.source
-    : ""
-
+  let source = script.source && script.source.length > 0 ? script.source : "";
   if (!source) {
     try {
-      source = await fs.readFile(scriptPath, "utf8")
+      source = await fs.readFile(scriptPath, "utf8");
     } catch (error) {
-      const base = path.basename(scriptPath)
+      const base = path.basename(scriptPath);
       if (error?.code === "ENOENT" && base && !base.includes(".")) {
-        return
+        return;
       }
-      throw error
+      throw error;
     }
   }
-
-  const sourceMap = await loadSourceMapForScript(scriptPath, source)
+  const sourceMap = await loadSourceMapForScript(scriptPath, source);
   const converter = v8ToIstanbul(
     scriptPath,
     0,
-    sourceMap ? { source, sourceMap: { sourcemap: sourceMap } } : { source },
-  )
-  await converter.load()
-  converter.applyCoverage(script.functions)
-
-  const filtered = filterCoverageMap(converter.toIstanbul(), config, matchesCollectCoverageFrom)
+    sourceMap ? { source, sourceMap: { sourcemap: sourceMap } } : { source }
+  );
+  await converter.load();
+  converter.applyCoverage(script.functions);
+  const filtered = filterCoverageMap(converter.toIstanbul(), config, matchesCollectCoverageFrom);
   if (Object.keys(filtered).length > 0) {
-    coverageMap.merge(filtered)
+    coverageMap.merge(filtered);
   }
 }
-
 async function readCoverageFile(file) {
   try {
-    const raw = await fs.readFile(file, "utf8")
-    return JSON.parse(raw)
+    const raw = await fs.readFile(file, "utf8");
+    return JSON.parse(raw);
   } catch (error) {
-    console.warn(`[coverage] failed to parse ${file}:`, error)
-    return null
+    console.warn(`[coverage] failed to parse ${file}:`, error);
+    return null;
   }
 }
-
 function enforceThresholds(summary, thresholds, label = "global") {
-  const failures = []
-
+  const failures = [];
   for (const metric of Object.keys(thresholds)) {
-    const minimum = thresholds[metric]
-    const actual = summary[metric]?.pct ?? 0
+    const minimum = thresholds[metric];
+    const actual = summary[metric]?.pct ?? 0;
     if (actual < minimum) {
-      failures.push({ metric, actual, minimum })
+      failures.push({ metric, actual, minimum });
     }
   }
-
   if (failures.length === 0) {
-    return
-  }
-
-  const details = failures
-    .map(({ metric, actual, minimum }) => `${metric}: ${actual.toFixed(2)}% < ${minimum}%`)
-    .join("; ")
-
-  throw new CoverageThresholdError(`[coverage] thresholds not met (target: ${label}) — ${details}`)
+    return;
+  }
+  const details = failures.map(({ metric, actual, minimum }) => `${metric}: ${actual.toFixed(2)}% < ${minimum}%`).join("; ");
+  throw new CoverageThresholdError(`[coverage] thresholds not met (target: ${label}) — ${details}`);
 }
-
 function resolveCoverageLib() {
-  const candidate = libCoverage
+  const candidate = libCoverage;
   if (typeof candidate.createCoverageMap === "function") {
-    return candidate
+    return candidate;
   }
-
   if (candidate.default && typeof candidate.default.createCoverageMap === "function") {
-    return candidate.default
+    return candidate.default;
   }
-
-  throw new Error("istanbul-lib-coverage exports are unavailable")
+  throw new Error("istanbul-lib-coverage exports are unavailable");
 }
-
 function resolveInstrumentLib() {
-  const candidate = libInstrument
+  const candidate = libInstrument;
   if (typeof candidate.createInstrumenter === "function") {
-    return candidate
+    return candidate;
   }
-
   if (candidate.default && typeof candidate.default.createInstrumenter === "function") {
-    return candidate.default
+    return candidate.default;
   }
-
-  throw new Error("istanbul-lib-instrument exports are unavailable")
+  throw new Error("istanbul-lib-instrument exports are unavailable");
 }
-
 async function includeUntestedFiles(coverageMap, config, matchesCollectCoverageFrom) {
   const existing = new Set(
-    coverageMap.files().map((filePath) => path.resolve(String(filePath ?? ""))),
-  )
-
-  const candidates = await findCollectCoverageFiles(config, matchesCollectCoverageFrom)
+    coverageMap.files().map((filePath) => path.resolve(String(filePath ?? "")))
+  );
+  const candidates = await findCollectCoverageFiles(config, matchesCollectCoverageFrom);
   if (candidates.length === 0) {
-    return
+    return;
   }
-
-  const instrumentLib = resolveInstrumentLib()
+  const instrumentLib = resolveInstrumentLib();
   const instrumenter = instrumentLib.createInstrumenter({
     esModules: true,
     parserPlugins: [
@@ -239,39 +217,35 @@ async function includeUntestedFiles(coverageMap, config, matchesCollectCoverageF
       "classPrivateMethods",
       "decorators-legacy",
       "importMeta",
-      "topLevelAwait",
-    ],
-  })
-
+      "topLevelAwait"
+    ]
+  });
   for (const filePath of candidates) {
-    const normalized = path.resolve(filePath)
+    const normalized = path.resolve(filePath);
     if (existing.has(normalized)) {
-      continue
+      continue;
     }
-
-    const source = await fs.readFile(normalized, "utf8").catch(() => null)
+    const source = await fs.readFile(normalized, "utf8").catch(() => null);
     if (source === null) {
-      continue
+      continue;
     }
-
     try {
-      instrumenter.instrumentSync(source, normalized)
-      const fileCoverage = instrumenter.lastFileCoverage()
+      instrumenter.instrumentSync(source, normalized);
+      const fileCoverage = instrumenter.lastFileCoverage();
       if (!fileCoverage) {
-        continue
+        continue;
       }
-      coverageMap.addFileCoverage(fileCoverage)
-      existing.add(normalized)
+      coverageMap.addFileCoverage(fileCoverage);
+      existing.add(normalized);
     } catch (error) {
-      const relative = path.relative(config.rootDir, normalized)
+      const relative = path.relative(config.rootDir, normalized);
       console.warn(
         `[coverage] failed to instrument ${relative && !relative.startsWith("..") ? relative : normalized}:`,
-        error,
-      )
+        error
+      );
     }
   }
 }
-
 const DEFAULT_COLLECT_COVERAGE_IGNORES = [
   "**/.git/**",
   "**/.next/**",
@@ -289,18 +263,13 @@ const DEFAULT_COLLECT_COVERAGE_IGNORES = [
   "**/tests/**",
   "**/__tests__/**",
   "**/*.d.ts",
-  "**/*.map",
-]
-
+  "**/*.map"
+];
 async function findCollectCoverageFiles(config, matchesCollectCoverageFrom) {
-  const patterns = Array.isArray(config.collectCoverageFrom)
-    ? config.collectCoverageFrom
-    : []
-
+  const patterns = Array.isArray(config.collectCoverageFrom) ? config.collectCoverageFrom : [];
   if (patterns.length === 0) {
-    return []
+    return [];
   }
-
   const rawFiles = await fg(patterns, {
     cwd: config.rootDir,
     absolute: true,
@@ -308,317 +277,248 @@ async function findCollectCoverageFiles(config, matchesCollectCoverageFrom) {
     onlyFiles: true,
     unique: true,
     followSymbolicLinks: false,
-    ignore: DEFAULT_COLLECT_COVERAGE_IGNORES,
-  }).catch(() => [])
-
-  const collected = new Set()
-
+    ignore: DEFAULT_COLLECT_COVERAGE_IGNORES
+  }).catch(() => []);
+  const collected = /* @__PURE__ */ new Set();
   for (const file of rawFiles) {
-    const normalized = path.resolve(String(file ?? ""))
+    const normalized = path.resolve(String(file ?? ""));
     if (!normalized) {
-      continue
+      continue;
     }
-
     if (normalized.endsWith(".d.ts") || normalized.endsWith(".map")) {
-      continue
+      continue;
     }
-
     if (isNodeModulesPath(normalized)) {
-      continue
+      continue;
     }
-
     if (isViteVirtualModulePath(normalized)) {
-      continue
+      continue;
     }
-
     if (!matchesCollectCoverageFrom(normalized)) {
-      continue
+      continue;
     }
-
-    collected.add(normalized)
+    collected.add(normalized);
   }
-
-  return Array.from(collected).sort()
+  return Array.from(collected).sort();
 }
-
 function buildFileSummaries(coverageMap, rootDir) {
-  const normalizedRoot = path.resolve(rootDir)
+  const normalizedRoot = path.resolve(rootDir);
   return coverageMap.files().map((filePath) => {
-    const normalizedAbsolute = path.resolve(filePath)
-    const summary = coverageMap.fileCoverageFor(filePath).toSummary()
-    const relativePath = path.relative(normalizedRoot, normalizedAbsolute)
-    const candidates = new Set()
-
+    const normalizedAbsolute = path.resolve(filePath);
+    const summary = coverageMap.fileCoverageFor(filePath).toSummary();
+    const relativePath = path.relative(normalizedRoot, normalizedAbsolute);
+    const candidates = /* @__PURE__ */ new Set();
     if (relativePath) {
-      const relativePosix = toPosix(relativePath)
-      candidates.add(relativePosix)
-      candidates.add(`./${relativePosix}`)
+      const relativePosix = toPosix(relativePath);
+      candidates.add(relativePosix);
+      candidates.add(`./${relativePosix}`);
     } else {
-      candidates.add(toPosix(path.basename(normalizedAbsolute)))
+      candidates.add(toPosix(path.basename(normalizedAbsolute)));
     }
-
     return {
       summary,
-      candidates: Array.from(candidates),
-    }
-  })
+      candidates: Array.from(candidates)
+    };
+  });
 }
-
 function collectTargetSummary(fileSummaries, matcher, coverageLib) {
-  const summary = coverageLib.createCoverageSummary()
-  let matched = 0
-
+  const summary = coverageLib.createCoverageSummary();
+  let matched = 0;
   for (const file of fileSummaries) {
     if (file.candidates.some((candidate) => matcher(candidate))) {
-      summary.merge(file.summary)
-      matched += 1
+      summary.merge(file.summary);
+      matched += 1;
     }
   }
-
-  return { summary, matched }
+  return { summary, matched };
 }
-
 function createGlobMatcher(pattern) {
-  const normalized = toPosix(String(pattern ?? "")).trim()
+  const normalized = toPosix(String(pattern ?? "")).trim();
   if (!normalized) {
-    return () => false
+    return () => false;
   }
   if (isAbsoluteGlobPattern(normalized)) {
-    throw new Error(`[coverage] threshold patterns must be relative (absolute paths are not supported): "${pattern}"`)
+    throw new Error(`[coverage] threshold patterns must be relative (absolute paths are not supported): "${pattern}"`);
   }
-  return picomatch(normalized, { dot: true })
+  return picomatch(normalized, { dot: true });
 }
-
 function isAbsoluteGlobPattern(pattern) {
-  const normalized = String(pattern ?? "").trim()
+  const normalized = String(pattern ?? "").trim();
   if (!normalized) {
-    return false
+    return false;
   }
-
   if (normalized.startsWith("/")) {
-    return true
+    return true;
   }
-
   if (normalized.startsWith("file://")) {
-    return true
+    return true;
   }
-
-  return /^[A-Za-z]:\//.test(normalized)
+  return /^[A-Za-z]:\//.test(normalized);
 }
-
 function stripQuery(url) {
-  const queryIndex = url.indexOf("?")
-  const hashIndex = url.indexOf("#")
-
+  const queryIndex = url.indexOf("?");
+  const hashIndex = url.indexOf("#");
   const endIndex = Math.min(
     queryIndex === -1 ? Number.POSITIVE_INFINITY : queryIndex,
-    hashIndex === -1 ? Number.POSITIVE_INFINITY : hashIndex,
-  )
-
+    hashIndex === -1 ? Number.POSITIVE_INFINITY : hashIndex
+  );
   if (!Number.isFinite(endIndex)) {
-    return url
+    return url;
   }
-
-  return url.slice(0, endIndex)
+  return url.slice(0, endIndex);
 }
-
 function extractSourceMappingUrl(source) {
-  const regex = /\/\/[#@]\s*sourceMappingURL=([^\s]+)/g
-
-  let last = null
-  let match = null
-
+  const regex = /\/\/[#@]\s*sourceMappingURL=([^\s]+)/g;
+  let last = null;
+  let match = null;
   while ((match = regex.exec(source)) !== null) {
-    last = match[1]
+    last = match[1];
   }
-
-  return typeof last === "string" && last.length > 0 ? last : null
+  return typeof last === "string" && last.length > 0 ? last : null;
 }
-
 function resolveSourceMapPath(scriptPath, mappingUrl) {
-  const cleaned = stripQuery(mappingUrl)
-
+  const cleaned = stripQuery(mappingUrl);
   if (cleaned.startsWith("file://")) {
-    return fileURLToPath(cleaned)
+    return fileURLToPath(cleaned);
   }
-
   if (path.isAbsolute(cleaned)) {
-    return cleaned
+    return cleaned;
   }
-
-  return path.resolve(path.dirname(scriptPath), cleaned)
+  return path.resolve(path.dirname(scriptPath), cleaned);
 }
-
 function filterCoverageMap(map, config, matchesCollectCoverageFrom) {
   if (!map || typeof map !== "object") {
-    return {}
+    return {};
   }
-
-  const filtered = {}
-
+  const filtered = {};
   for (const [filePath, fileCoverage] of Object.entries(map)) {
-    const absolutePath = resolveCoveragePath(filePath, config.rootDir)
+    const absolutePath = resolveCoveragePath(filePath, config.rootDir);
     if (!absolutePath) {
-      continue
+      continue;
     }
-
     if (absolutePath.endsWith(".d.ts") || absolutePath.endsWith(".map")) {
-      continue
+      continue;
     }
-
     if (isNodeModulesPath(absolutePath)) {
-      continue
+      continue;
     }
-
     if (isViteVirtualModulePath(absolutePath)) {
-      continue
+      continue;
     }
-
     if (!matchesCollectCoverageFrom(absolutePath)) {
-      continue
+      continue;
     }
-
     if (fileCoverage && typeof fileCoverage === "object") {
-      filtered[absolutePath] = { ...fileCoverage, path: absolutePath }
+      filtered[absolutePath] = { ...fileCoverage, path: absolutePath };
     } else {
-      filtered[absolutePath] = fileCoverage
+      filtered[absolutePath] = fileCoverage;
     }
   }
-
-  return filtered
+  return filtered;
 }
-
 function resolveCoveragePath(filePath, rootDir) {
-  const raw = String(filePath ?? "").trim()
+  const raw = String(filePath ?? "").trim();
   if (!raw) {
-    return null
+    return null;
   }
-
-  const cleaned = stripQuery(raw)
-
+  const cleaned = stripQuery(raw);
   if (cleaned.startsWith("file://")) {
     try {
-      return path.normalize(fileURLToPath(cleaned))
+      return path.normalize(fileURLToPath(cleaned));
     } catch {
-      return null
+      return null;
     }
   }
-
   if (path.isAbsolute(cleaned)) {
-    return path.normalize(cleaned)
+    return path.normalize(cleaned);
   }
-
   if (cleaned.includes("://")) {
-    return null
+    return null;
   }
-
-  return path.normalize(path.resolve(rootDir, cleaned))
+  return path.normalize(path.resolve(rootDir, cleaned));
 }
-
 function isNodeModulesPath(filePath) {
-  return path
-    .normalize(String(filePath ?? ""))
-    .split(path.sep)
-    .includes("node_modules")
+  return path.normalize(String(filePath ?? "")).split(path.sep).includes("node_modules");
 }
-
 function isViteVirtualModulePath(filePath) {
-  const normalized = path.normalize(String(filePath ?? ""))
-  const baseName = path.basename(normalized)
-  return baseName === "__vite-browser-external"
-    || baseName.startsWith("__vite-browser-external:")
-    || baseName.startsWith("__vite-")
+  const normalized = path.normalize(String(filePath ?? ""));
+  const baseName = path.basename(normalized);
+  return baseName === "__vite-browser-external" || baseName.startsWith("__vite-browser-external:") || baseName.startsWith("__vite-");
 }
-
 function parseSourceMapPayload(raw) {
   if (!raw || typeof raw !== "object") {
-    return null
+    return null;
   }
-
-  const sources = raw.sources
+  const sources = raw.sources;
   if (!Array.isArray(sources) || sources.length === 0) {
-    return null
+    return null;
   }
-
-  return raw
+  return raw;
 }
-
 function normalizeSourceMap(sourceMap, scriptPath) {
-  const root = typeof sourceMap.sourceRoot === "string"
-    ? sourceMap.sourceRoot.replace("file://", "")
-    : ""
-
-  const dir = path.dirname(scriptPath)
+  const root = typeof sourceMap.sourceRoot === "string" ? sourceMap.sourceRoot.replace("file://", "") : "";
+  const dir = path.dirname(scriptPath);
   const fixedSources = sourceMap.sources.map((source) => {
-    const raw = String(source ?? "")
-    const cleaned = stripQuery(raw)
-
+    const raw = String(source ?? "");
+    const cleaned = stripQuery(raw);
     if (cleaned.startsWith("file://")) {
       try {
-        return path.normalize(fileURLToPath(cleaned))
+        return path.normalize(fileURLToPath(cleaned));
       } catch {
-        return cleaned
+        return cleaned;
       }
     }
-
-    const withoutWebpack = cleaned.replace(/^webpack:\/\//, "")
-    const candidate = path.join(root, withoutWebpack)
-
+    const withoutWebpack = cleaned.replace(/^webpack:\/\//, "");
+    const candidate = path.join(root, withoutWebpack);
     if (path.isAbsolute(candidate)) {
-      return path.normalize(candidate)
+      return path.normalize(candidate);
     }
-
-    const normalizedCandidate = candidate.split("/").join(path.sep)
-
+    const normalizedCandidate = candidate.split("/").join(path.sep);
     if (dir.endsWith(`${path.sep}dist`) && !normalizedCandidate.startsWith(`..${path.sep}`)) {
       if (normalizedCandidate.startsWith(`src${path.sep}`) || normalizedCandidate.startsWith(`lib${path.sep}`)) {
-        return path.normalize(path.resolve(dir, "..", normalizedCandidate))
+        return path.normalize(path.resolve(dir, "..", normalizedCandidate));
       }
     }
-
-    return path.normalize(path.resolve(dir, normalizedCandidate))
-  })
-
+    return path.normalize(path.resolve(dir, normalizedCandidate));
+  });
   return {
     ...sourceMap,
-    sources: fixedSources,
-  }
+    sources: fixedSources
+  };
 }
-
 async function loadSourceMapForScript(scriptPath, source) {
-  const mappingUrl = extractSourceMappingUrl(source)
+  const mappingUrl = extractSourceMappingUrl(source);
   if (!mappingUrl) {
-    return null
+    return null;
   }
-
-  const cleaned = stripQuery(mappingUrl)
-
+  const cleaned = stripQuery(mappingUrl);
   if (cleaned.startsWith("data:")) {
-    const commaIndex = cleaned.indexOf(",")
+    const commaIndex = cleaned.indexOf(",");
     if (commaIndex === -1) {
-      return null
+      return null;
     }
-
-    const meta = cleaned.slice(0, commaIndex)
-    const payload = cleaned.slice(commaIndex + 1)
-    const raw = meta.includes(";base64")
-      ? Buffer.from(payload, "base64").toString("utf8")
-      : decodeURIComponent(payload)
-
+    const meta = cleaned.slice(0, commaIndex);
+    const payload = cleaned.slice(commaIndex + 1);
+    const raw = meta.includes(";base64") ? Buffer.from(payload, "base64").toString("utf8") : decodeURIComponent(payload);
     try {
-      const parsed = parseSourceMapPayload(JSON.parse(raw))
-      return parsed ? normalizeSourceMap(parsed, scriptPath) : null
+      const parsed = parseSourceMapPayload(JSON.parse(raw));
+      return parsed ? normalizeSourceMap(parsed, scriptPath) : null;
     } catch {
-      return null
+      return null;
     }
   }
-
   try {
-    const mapPath = resolveSourceMapPath(scriptPath, cleaned)
-    const raw = await fs.readFile(mapPath, "utf8")
-    const parsed = parseSourceMapPayload(JSON.parse(raw))
-    return parsed ? normalizeSourceMap(parsed, scriptPath) : null
+    const mapPath = resolveSourceMapPath(scriptPath, cleaned);
+    const raw = await fs.readFile(mapPath, "utf8");
+    const parsed = parseSourceMapPayload(JSON.parse(raw));
+    return parsed ? normalizeSourceMap(parsed, scriptPath) : null;
   } catch {
-    return null
+    return null;
   }
 }
+export {
+  CoverageThresholdError,
+  collectCoveredFiles,
+  generateCoverageReport
+};
+//# sourceMappingURL=report.js.map