elit 3.3.2 → 3.3.4

package/dist/cli.js

@@ -582,7 +582,7 @@ function isAbsoluteWin(path) {
 function normalizePath(path, isWin) {
   if (path.length === 0) return ".";
   const separator = getSeparator(isWin);
-  const isAbsolute2 = isWin ? isAbsoluteWin(path) : isAbsolutePosix(path);
+  const isAbsolute3 = 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);
@@ -590,7 +590,7 @@ function normalizePath(path, isWin) {
   for (let i = 0; i < parts.length; i++) {
     const part = parts[i];
     if (part === "" || part === ".") {
-      if (i === 0 && isAbsolute2) result.push("");
+      if (i === 0 && isAbsolute3) result.push("");
       continue;
     }
     if (part === "..") {
@@ -598,7 +598,7 @@ function normalizePath(path, isWin) {
         if (!(result.length === 1 && result[0] === "")) {
           result.pop();
         }
-      } else if (!isAbsolute2) {
+      } else if (!isAbsolute3) {
         result.push("..");
       }
     } else {
@@ -607,7 +607,7 @@ function normalizePath(path, isWin) {
   }
   let final = result.join(separator);
   if (final.length === 0) {
-    return isAbsolute2 ? separator : ".";
+    return isAbsolute3 ? separator : ".";
   }
   if (trailingSeparator && final[final.length - 1] !== separator) {
     final += separator;
@@ -634,15 +634,15 @@ function joinPaths(paths, isWin) {
 function resolvePaths(paths, isWin) {
   const separator = getSeparator(isWin);
   let resolved = "";
-  let isAbsolute2 = false;
-  for (let i = paths.length - 1; i >= 0 && !isAbsolute2; i--) {
+  let isAbsolute3 = false;
+  for (let i = paths.length - 1; i >= 0 && !isAbsolute3; i--) {
     const path = paths[i];
     if (path && path.length > 0) {
       resolved = path + (resolved.length > 0 ? separator + resolved : "");
-      isAbsolute2 = isWin ? isAbsoluteWin(resolved) : isAbsolutePosix(resolved);
+      isAbsolute3 = isWin ? isAbsoluteWin(resolved) : isAbsolutePosix(resolved);
     }
   }
-  if (!isAbsolute2) {
+  if (!isAbsolute3) {
     const cwd = getCwd();
     resolved = cwd + (resolved.length > 0 ? separator + resolved : "");
   }
@@ -1013,10 +1013,10 @@ var init_http = __esm({
       }
       async text() {
         if (isNode) {
-          return new Promise((resolve2, reject) => {
+          return new Promise((resolve4, reject) => {
             const chunks = [];
             this._req.on("data", (chunk) => chunks.push(chunk));
-            this._req.on("end", () => resolve2(Buffer.concat(chunks).toString("utf8")));
+            this._req.on("end", () => resolve4(Buffer.concat(chunks).toString("utf8")));
             this._req.on("error", reject);
           });
         }
@@ -1160,8 +1160,8 @@ var init_http = __esm({
         }
         return this;
       }
-      _setResolver(resolve2) {
-        this._resolve = resolve2;
+      _setResolver(resolve4) {
+        this._resolve = resolve4;
       }
       // Express.js-like methods
       json(data, statusCode = 200) {
@@ -1320,12 +1320,12 @@ var init_http = __esm({
                   headers
                 });
               }
-              return new Promise((resolve2) => {
+              return new Promise((resolve4) => {
                 serverResponse.end = (chunk) => {
                   if (chunk !== void 0) {
                     body += chunk;
                   }
-                  resolve2(new Response(body, {
+                  resolve4(new Response(body, {
                     status: statusCode,
                     statusText: statusMessage,
                     headers
@@ -1341,10 +1341,10 @@ var init_http = __esm({
             port,
             hostname,
             handler: (req) => {
-              return new Promise((resolve2) => {
+              return new Promise((resolve4) => {
                 const incomingMessage = new IncomingMessage(req);
                 const serverResponse = new ServerResponse();
-                serverResponse._setResolver(resolve2);
+                serverResponse._setResolver(resolve4);
                 if (self.requestListener) {
                   self.requestListener(incomingMessage, serverResponse);
                 } else {
@@ -1430,12 +1430,4510 @@ var init_http = __esm({
   }
 });
 
+// src/test-runtime.ts
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function createTestFunction(defaultTimeout = 5e3) {
+  const testFn = function(name, fn, timeout) {
+    const test2 = {
+      name,
+      fn,
+      skip: currentSuite.skip,
+      only: false,
+      todo: false,
+      timeout: timeout ?? defaultTimeout,
+      suite: currentSuite
+    };
+    currentSuite.tests.push(test2);
+  };
+  testFn.skip = (name, fn, timeout) => {
+    const test2 = {
+      name,
+      fn,
+      skip: true,
+      only: false,
+      todo: false,
+      timeout: timeout ?? defaultTimeout,
+      suite: currentSuite
+    };
+    currentSuite.tests.push(test2);
+  };
+  testFn.only = (name, fn, timeout) => {
+    hasOnly = true;
+    const test2 = {
+      name,
+      fn,
+      skip: false,
+      only: true,
+      todo: false,
+      timeout: timeout ?? defaultTimeout,
+      suite: currentSuite
+    };
+    currentSuite.tests.push(test2);
+  };
+  testFn.todo = (name, fn, timeout) => {
+    const test2 = {
+      name,
+      fn,
+      skip: false,
+      only: false,
+      todo: true,
+      timeout: timeout ?? defaultTimeout,
+      suite: currentSuite
+    };
+    currentSuite.tests.push(test2);
+  };
+  return testFn;
+}
+function createDescribeFunction() {
+  const describeFn = function(name, fn) {
+    const parent = currentSuite;
+    const suite = {
+      name,
+      tests: [],
+      suites: [],
+      parent,
+      skip: parent.skip,
+      only: parent.only
+    };
+    parent.suites.push(suite);
+    currentSuite = suite;
+    fn();
+    currentSuite = parent;
+  };
+  describeFn.skip = (name, fn) => {
+    const parent = currentSuite;
+    const suite = {
+      name,
+      tests: [],
+      suites: [],
+      parent,
+      skip: true,
+      only: false
+    };
+    parent.suites.push(suite);
+    currentSuite = suite;
+    fn();
+    currentSuite = parent;
+  };
+  describeFn.only = (name, fn) => {
+    hasOnly = true;
+    const parent = currentSuite;
+    const suite = {
+      name,
+      tests: [],
+      suites: [],
+      parent,
+      skip: false,
+      only: true
+    };
+    parent.suites.push(suite);
+    currentSuite = suite;
+    fn();
+    currentSuite = parent;
+  };
+  return describeFn;
+}
+function expect(actual) {
+  return new Expect(actual);
+}
+function createMockFunction() {
+  const mock = function(...args) {
+    mock._calls.push(args);
+    try {
+      const result = mock._implementation ? mock._implementation(...args) : void 0;
+      mock._results.push({ type: "return", value: result });
+      return result;
+    } catch (error) {
+      mock._results.push({ type: "throw", value: error });
+      throw error;
+    }
+  };
+  mock._isMock = true;
+  mock._calls = [];
+  mock._results = [];
+  mock._implementation = null;
+  mock.mockImplementation = function(fn) {
+    mock._implementation = fn;
+    return mock;
+  };
+  mock.mockReturnValue = function(value) {
+    mock._implementation = (() => value);
+    return mock;
+  };
+  mock.mockResolvedValue = function(value) {
+    mock._implementation = (() => Promise.resolve(value));
+    return mock;
+  };
+  mock.mockRejectedValue = function(value) {
+    mock._implementation = (() => Promise.reject(value));
+    return mock;
+  };
+  mock.restore = function() {
+    mock._calls = [];
+    mock._results = [];
+    mock._implementation = null;
+  };
+  mock.clear = function() {
+    mock._calls = [];
+    mock._results = [];
+  };
+  return mock;
+}
+async function runTests(options) {
+  const { files, timeout = 5e3, bail = false, describePattern: descPattern, testPattern: tPattern } = options;
+  describePattern = descPattern;
+  testPattern = tPattern;
+  testResults.length = 0;
+  hasOnly = false;
+  for (const file of files) {
+    currentTestFile = file;
+    try {
+      const source = await readFile(file, "utf-8");
+      const testFileDir = dirname(file);
+      const importRegex = /import\s+{\s*([^}]+)\s*}\s+from\s+['"]([^'"]+)['"]/g;
+      const imports = {};
+      let importIndex = 0;
+      let codeWithoutImports = source.replace(importRegex, (_, named, path) => {
+        const varName = `__import_${importIndex++}`;
+        const trimmedNamed = named.trim();
+        imports[varName] = { path, named: trimmedNamed };
+        return `// ${trimmedNamed} import injected later
+`;
+      });
+      const result = (0, import_esbuild.transformSync)(codeWithoutImports, {
+        loader: file.endsWith(".ts") || file.endsWith(".tsx") ? "ts" : "js",
+        format: "iife",
+        sourcemap: "inline",
+        target: "es2020",
+        tsconfigRaw: {
+          compilerOptions: {
+            jsx: "react",
+            jsxFactory: "h",
+            jsxFragmentFactory: "Fragment"
+          }
+        }
+      });
+      let code = result.code;
+      const sourceMapMatch = code.match(/\/\/# sourceMappingURL=data:application\/json;base64,(.+)/);
+      if (sourceMapMatch) {
+        const base64 = sourceMapMatch[1];
+        const json2 = Buffer.from(base64, "base64").toString("utf-8");
+        const sourceMap = JSON.parse(json2);
+        currentSourceMapConsumer = await new import_source_map.SourceMapConsumer(sourceMap);
+      } else {
+        currentSourceMapConsumer = void 0;
+      }
+      const importedValues = {};
+      const importParamNames = [];
+      const importAssignments = [];
+      if (Object.keys(imports).length > 0) {
+        for (const [, { path, named }] of Object.entries(imports)) {
+          let resolvedPath = path;
+          if (path.startsWith(".")) {
+            const nodePath = require("path");
+            resolvedPath = nodePath.resolve(testFileDir, path);
+          }
+          if (!resolvedPath.endsWith(".ts") && !resolvedPath.endsWith(".js") && !resolvedPath.endsWith(".mjs") && !resolvedPath.endsWith(".cjs")) {
+            resolvedPath += ".ts";
+          }
+          if (resolvedPath.endsWith(".ts")) {
+            try {
+              const importSource = await readFile(resolvedPath, "utf-8");
+              const transpiled = (0, import_esbuild.transformSync)(importSource, {
+                loader: "ts",
+                format: "cjs",
+                target: "es2020",
+                tsconfigRaw: {
+                  compilerOptions: {
+                    jsx: "react",
+                    jsxFactory: "h",
+                    jsxFragmentFactory: "Fragment"
+                  }
+                }
+              });
+              const moduleExports = {};
+              const moduleObj = { exports: moduleExports };
+              const fn2 = new Function("module", "exports", "require", "__filename", "__dirname", transpiled.code);
+              const requireFn = (id) => {
+                if (id.startsWith("elit/") || id === "elit") {
+                  return require(id);
+                }
+                if (id.startsWith(".")) {
+                  const nodePath = require("path");
+                  const absPath = nodePath.resolve(dirname(resolvedPath), id);
+                  return require(absPath);
+                }
+                return require(id);
+              };
+              fn2(moduleObj, moduleExports, requireFn, resolvedPath, dirname(resolvedPath));
+              if (!resolvedPath.includes(".test.") && !resolvedPath.includes(".spec.")) {
+                coveredFiles.add(resolvedPath);
+              }
+              let exportedValue = moduleObj.exports[named];
+              if (exportedValue === void 0 && moduleObj.exports.default) {
+                exportedValue = moduleObj.exports.default[named];
+              }
+              if (exportedValue === void 0 && typeof moduleObj.exports === "object") {
+                exportedValue = moduleObj.exports[named];
+              }
+              const paramKey = `__import_${Math.random().toString(36).substring(2, 11)}`;
+              importedValues[paramKey] = exportedValue;
+              importParamNames.push(paramKey);
+              importAssignments.push(`const ${named} = ${paramKey};`);
+            } catch (err) {
+              const paramKey = `__import_${Math.random().toString(36).substring(2, 11)}`;
+              importedValues[paramKey] = null;
+              importParamNames.push(paramKey);
+              importAssignments.push(`const ${named} = ${paramKey}; /* Error importing ${resolvedPath}: ${err} */`);
+            }
+          } else {
+            const requiredModule = require(resolvedPath);
+            const exportedValue = requiredModule[named];
+            const paramKey = `__import_${Math.random().toString(36).substring(2, 11)}`;
+            importedValues[paramKey] = exportedValue;
+            importParamNames.push(paramKey);
+            importAssignments.push(`const ${named} = ${paramKey};`);
+          }
+        }
+      }
+      let preamble = "";
+      if (Object.keys(imports).length > 0) {
+        const iifeStartMatch = code.match(/^(\s*(?:var\s+\w+\s*=\s*)?\(\(\)\s*=>\s*\{\n)/);
+        if (iifeStartMatch) {
+          const iifePrefix = iifeStartMatch[1];
+          const assignments = `${importAssignments.join("\n")}
+`;
+          preamble = iifePrefix;
+          code = iifePrefix + assignments + code.slice(iifeStartMatch[1].length);
+        } else {
+          preamble = importAssignments.join("\n") + "\n";
+          code = preamble + code;
+        }
+      }
+      wrapperLineOffset = preamble.split("\n").length;
+      setupGlobals();
+      const allParams = ["describe", "it", "test", "expect", "beforeAll", "afterAll", "beforeEach", "afterEach", "vi", "require", "module", "__filename", "__dirname", ...importParamNames];
+      const allArgs = [describe, it, test, expect, beforeAll, afterAll, beforeEach, afterEach, vi, require, module, file, testFileDir, ...importParamNames.map((p) => importedValues[p])];
+      const fn = new Function(...allParams, code);
+      await fn(...allArgs);
+      await executeSuite(currentSuite, timeout, bail);
+      if (currentSourceMapConsumer) {
+        currentSourceMapConsumer.destroy();
+        currentSourceMapConsumer = void 0;
+      }
+      currentSuite = {
+        name: "root",
+        tests: [],
+        suites: [],
+        skip: false,
+        only: false
+      };
+      hasOnly = false;
+      beforeAllHooks = [];
+      afterAllHooks = [];
+      beforeEachHooks = [];
+      afterEachHooks = [];
+    } catch (error) {
+      if (currentSourceMapConsumer) {
+        currentSourceMapConsumer.destroy();
+        currentSourceMapConsumer = void 0;
+      }
+      console.error(`Error loading test file ${file}:`, error);
+    }
+  }
+  const passed = testResults.filter((r) => r.status === "pass").length;
+  const failed = testResults.filter((r) => r.status === "fail").length;
+  const skipped = testResults.filter((r) => r.status === "skip").length;
+  const todo = testResults.filter((r) => r.status === "todo").length;
+  return { passed, failed, skipped, todo, results: testResults };
+}
+async function executeSuite(suite, timeout, bail, parentMatched = false) {
+  let directMatch = false;
+  if (describePattern) {
+    const escapedPattern = escapeRegex(describePattern);
+    const regex = new RegExp(escapedPattern, "i");
+    directMatch = regex.test(suite.name);
+  }
+  function suiteOrDescendantMatches(s) {
+    if (!describePattern) return true;
+    const escapedPattern = escapeRegex(describePattern);
+    const regex = new RegExp(escapedPattern, "i");
+    if (regex.test(s.name)) return true;
+    for (const child of s.suites) {
+      if (suiteOrDescendantMatches(child)) return true;
+    }
+    return false;
+  }
+  const shouldRunSuite = !describePattern || directMatch || parentMatched || suiteOrDescendantMatches(suite);
+  if (!shouldRunSuite) {
+    return;
+  }
+  if (suite.suites.length > 0) {
+    for (const childSuite of suite.suites) {
+      await executeSuite(childSuite, timeout, bail, parentMatched || directMatch);
+    }
+  }
+  const shouldRunTests = !describePattern || directMatch || parentMatched || suite.name === "";
+  if (!shouldRunTests) {
+    return;
+  }
+  for (const hook of beforeAllHooks) {
+    await hook();
+  }
+  for (const test2 of suite.tests) {
+    if (hasOnly && !test2.only && !suite.only) {
+      continue;
+    }
+    let testMatches = true;
+    if (testPattern) {
+      const escapedPattern = escapeRegex(testPattern);
+      const regex = new RegExp(escapedPattern, "i");
+      testMatches = regex.test(test2.name);
+    }
+    if (!testMatches) {
+      continue;
+    }
+    if (test2.skip || suite.skip) {
+      testResults.push({
+        name: test2.name,
+        status: "skip",
+        duration: 0,
+        suite: suite.name,
+        file: currentTestFile
+      });
+      continue;
+    }
+    if (test2.todo) {
+      testResults.push({
+        name: test2.name,
+        status: "todo",
+        duration: 0,
+        suite: suite.name,
+        file: currentTestFile
+      });
+      continue;
+    }
+    for (const hook of beforeEachHooks) {
+      await hook();
+    }
+    const startTime = Date.now();
+    try {
+      await Promise.race([
+        test2.fn(),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error(`Test timed out after ${test2.timeout}ms`)), test2.timeout)
+        )
+      ]);
+      testResults.push({
+        name: test2.name,
+        status: "pass",
+        duration: Date.now() - startTime,
+        suite: suite.name,
+        file: currentTestFile
+      });
+    } catch (error) {
+      let lineNumber = void 0;
+      let codeSnippet = void 0;
+      if (error instanceof AssertionError) {
+        lineNumber = error.lineNumber;
+        codeSnippet = error.codeSnippet;
+      }
+      testResults.push({
+        name: test2.name,
+        status: "fail",
+        duration: Date.now() - startTime,
+        error,
+        suite: suite.name,
+        file: currentTestFile,
+        lineNumber,
+        codeSnippet
+      });
+      if (bail) {
+        throw error;
+      }
+    }
+    for (const hook of afterEachHooks) {
+      await hook();
+    }
+  }
+  for (const hook of afterAllHooks) {
+    await hook();
+  }
+}
+function setupGlobals() {
+  global.describe = globals.describe;
+  global.it = globals.it;
+  global.test = globals.test;
+  global.expect = globals.expect;
+  global.beforeAll = globals.beforeAll;
+  global.afterAll = globals.afterAll;
+  global.beforeEach = globals.beforeEach;
+  global.afterEach = globals.afterEach;
+  global.vi = globals.vi;
+}
+function clearGlobals() {
+  delete global.describe;
+  delete global.it;
+  delete global.test;
+  delete global.expect;
+  delete global.beforeAll;
+  delete global.afterAll;
+  delete global.beforeEach;
+  delete global.afterEach;
+  delete global.vi;
+}
+function getCoveredFiles() {
+  return coveredFiles;
+}
+function resetCoveredFiles() {
+  coveredFiles.clear();
+}
+var import_esbuild, import_source_map, AssertionError, currentSuite, testResults, hasOnly, coveredFiles, describePattern, testPattern, currentTestFile, currentSourceMapConsumer, wrapperLineOffset, Expect, vi, beforeAllHooks, afterAllHooks, beforeEachHooks, afterEachHooks, beforeAll, afterAll, beforeEach, afterEach, globals;
+var init_test_runtime = __esm({
+  "src/test-runtime.ts"() {
+    "use strict";
+    import_esbuild = require("esbuild");
+    init_fs();
+    init_path();
+    import_source_map = require("source-map");
+    AssertionError = class extends Error {
+      constructor(message, filePath, lineNumber, columnNumber, codeSnippet) {
+        super(message);
+        this.filePath = filePath;
+        this.lineNumber = lineNumber;
+        this.columnNumber = columnNumber;
+        this.codeSnippet = codeSnippet;
+        this.name = "AssertionError";
+      }
+    };
+    currentSuite = {
+      name: "root",
+      tests: [],
+      suites: [],
+      skip: false,
+      only: false
+    };
+    testResults = [];
+    hasOnly = false;
+    coveredFiles = /* @__PURE__ */ new Set();
+    describePattern = void 0;
+    testPattern = void 0;
+    currentTestFile = void 0;
+    currentSourceMapConsumer = void 0;
+    wrapperLineOffset = 0;
+    Expect = class _Expect {
+      constructor(actual, isNot = false, isAsync = false) {
+        this.actual = actual;
+        this.isNot = isNot;
+        this.isAsync = isAsync;
+        this._not = null;
+        this._resolves = null;
+        this._rejects = null;
+      }
+      get not() {
+        if (!this._not) {
+          this._not = new _Expect(this.actual, !this.isNot, false);
+        }
+        return this._not;
+      }
+      get resolves() {
+        if (!this._resolves) {
+          this._resolves = new _Expect(this.actual, this.isNot, true);
+        }
+        return this._resolves;
+      }
+      get rejects() {
+        if (!this._rejects) {
+          this._rejects = new _Expect(this.actual, this.isNot, true);
+        }
+        return this._rejects;
+      }
+      assertCondition(condition, message, showExpectedReceived = true, expectedDisplay, callerStack) {
+        if (this.isNot) {
+          condition = !condition;
+        }
+        if (!condition) {
+          let errorMsg = message;
+          if (showExpectedReceived) {
+            const expectedValue = expectedDisplay ?? this.stringify(this.expected ?? "truthy");
+            errorMsg += `
+  Expected: ${expectedValue}
+  Received: ${this.stringify(this.actual)}`;
+          }
+          const stack = callerStack || new Error().stack;
+          let lineNumber = void 0;
+          let codeSnippet = void 0;
+          let assertionMethod = void 0;
+          if (stack) {
+            const assertionMatch = stack.match(/at _Expect\.(\w+)/);
+            if (assertionMatch) {
+              assertionMethod = assertionMatch[1];
+            }
+          }
+          if (stack) {
+            const lines = stack.split("\n");
+            const stackFrames = [];
+            for (const line of lines) {
+              const match = line.match(/<anonymous>:([0-9]+):([0-9]+)/);
+              if (match) {
+                stackFrames.push({
+                  line: parseInt(match[1], 10),
+                  column: parseInt(match[2], 10)
+                });
+              }
+            }
+            const targetFrame = stackFrames.length > 1 ? stackFrames[1] : stackFrames[0];
+            if (targetFrame && currentSourceMapConsumer) {
+              try {
+                const transpiledLine = targetFrame.line - wrapperLineOffset;
+                const originalPosition = currentSourceMapConsumer.originalPositionFor({
+                  line: transpiledLine,
+                  column: targetFrame.column
+                });
+                if (originalPosition.line !== null) {
+                  lineNumber = originalPosition.line;
+                  if (currentTestFile) {
+                    try {
+                      let sourceCode = readFileSync(currentTestFile, "utf-8");
+                      if (Buffer.isBuffer(sourceCode)) {
+                        sourceCode = sourceCode.toString("utf-8");
+                      }
+                      const sourceLines = sourceCode.split("\n");
+                      let targetPattern = ".toBe(";
+                      if (assertionMethod === "toEqual") targetPattern = ".toEqual(";
+                      else if (assertionMethod === "toStrictEqual") targetPattern = ".toStrictEqual(";
+                      else if (assertionMethod === "toMatch") targetPattern = ".toMatch(";
+                      else if (assertionMethod === "toContain") targetPattern = ".toContain(";
+                      else if (assertionMethod === "toHaveLength") targetPattern = ".toHaveLength(";
+                      else if (assertionMethod === "toBeDefined") targetPattern = ".toBeDefined(";
+                      else if (assertionMethod === "toBeNull") targetPattern = ".toBeNull(";
+                      else if (assertionMethod === "toBeUndefined") targetPattern = ".toBeUndefined(";
+                      else if (assertionMethod === "toBeTruthy") targetPattern = ".toBeTruthy(";
+                      else if (assertionMethod === "toBeFalsy") targetPattern = ".toBeFalsy(";
+                      else if (assertionMethod === "toThrow") targetPattern = ".toThrow(";
+                      else if (assertionMethod === "toBeGreaterThan") targetPattern = ".toBeGreaterThan(";
+                      else if (assertionMethod === "toBeGreaterThanOrEqual") targetPattern = ".toBeGreaterThanOrEqual(";
+                      else if (assertionMethod === "toBeLessThan") targetPattern = ".toBeLessThan(";
+                      else if (assertionMethod === "toBeLessThanOrEqual") targetPattern = ".toBeLessThanOrEqual(";
+                      if (lineNumber > 0 && lineNumber <= sourceLines.length) {
+                        const mappedLine = sourceLines[lineNumber - 1];
+                        const hasMatchingAssertion = mappedLine.includes(targetPattern);
+                        if (!hasMatchingAssertion) {
+                          for (let i = 1; i <= 3; i++) {
+                            const searchLine = lineNumber - i;
+                            if (searchLine > 0 && searchLine <= sourceLines.length) {
+                              const testLine = sourceLines[searchLine - 1];
+                              if (testLine.includes(targetPattern)) {
+                                lineNumber = searchLine;
+                                break;
+                              }
+                            }
+                          }
+                        }
+                      }
+                    } catch (e) {
+                    }
+                  }
+                } else {
+                  const posWithoutColumn = currentSourceMapConsumer.originalPositionFor({
+                    line: transpiledLine,
+                    column: 0
+                  });
+                  if (posWithoutColumn.line !== null) {
+                    lineNumber = posWithoutColumn.line;
+                  } else {
+                    const lineMappings = [];
+                    currentSourceMapConsumer.eachMapping((mapping) => {
+                      if (mapping.originalLine !== null) {
+                        const distance = Math.abs(mapping.generatedLine - transpiledLine);
+                        lineMappings.push({
+                          line: mapping.originalLine,
+                          distance
+                        });
+                      }
+                    });
+                    if (lineMappings.length > 0) {
+                      lineMappings.sort((a, b) => a.distance - b.distance);
+                      lineNumber = lineMappings[0].line;
+                    }
+                  }
+                }
+              } catch (e) {
+              }
+            }
+            if (currentTestFile && lineNumber) {
+              try {
+                let sourceCode = readFileSync(currentTestFile, "utf-8");
+                if (Buffer.isBuffer(sourceCode)) {
+                  sourceCode = sourceCode.toString("utf-8");
+                }
+                const sourceLines = sourceCode.split("\n");
+                if (lineNumber > 0 && lineNumber <= sourceLines.length) {
+                  const codeLine = sourceLines[lineNumber - 1];
+                  if (codeLine) {
+                    codeSnippet = codeLine.trim();
+                  }
+                }
+              } catch (e) {
+              }
+            }
+          }
+          throw new AssertionError(errorMsg, currentTestFile, lineNumber, void 0, codeSnippet);
+        }
+      }
+      stringify(value) {
+        if (value === void 0) return "undefined";
+        if (value === null) return "null";
+        if (typeof value === "string") return `"${value}"`;
+        if (typeof value === "number" || typeof value === "boolean") return String(value);
+        if (typeof value === "function") return "Function";
+        if (Array.isArray(value)) return `[${value.map((v) => this.stringify(v)).join(", ")}]`;
+        if (typeof value === "object") {
+          const keys = Object.keys(value);
+          if (keys.length === 0) return "{}";
+          return `{ ${keys.slice(0, 3).map((k) => `${k}: ${this.stringify(value[k])}`).join(", ")}${keys.length > 3 ? "..." : ""} }`;
+        }
+        return String(value);
+      }
+      async handleAsyncAssertion(value, assertion) {
+        try {
+          const resolvedValue = await this.actual;
+          if (this.isNot) {
+            throw new Error(`Promise resolved when it should have rejected`);
+          }
+          assertion(resolvedValue);
+          return Promise.resolve(resolvedValue);
+        } catch (error) {
+          if (this.isNot) {
+            return Promise.resolve(void 0);
+          }
+          if (typeof value === "string") {
+            this.assertCondition(
+              error.message?.includes(value),
+              `Expected error message to include "${value}"`
+            );
+          } else if (value instanceof RegExp) {
+            this.assertCondition(
+              value.test(error.message),
+              `Expected error message to match ${value}`
+            );
+          }
+          return Promise.resolve(void 0);
+        }
+      }
+      toBe(value) {
+        const stack = new Error().stack;
+        if (this.isAsync) {
+          return this.handleAsyncAssertion(value, (actual) => {
+            this.expected = value;
+            this.assertCondition(actual === value, `Expected values to be strictly equal (using ===)`, false, void 0, stack);
+            if (typeof actual !== typeof value) {
+              throw new Error(`Types don't match: expected ${typeof value} but got ${typeof actual}`);
+            }
+          });
+        }
+        this.expected = value;
+        this.assertCondition(this.actual === value, `Expected values to be strictly equal (using ===)`, true, void 0, stack);
+        if (typeof this.actual !== typeof value) {
+          throw new Error(`Types don't match: expected ${typeof value} but got ${typeof this.actual}`);
+        }
+      }
+      toEqual(value) {
+        const stack = new Error().stack;
+        this.expected = value;
+        const isEqual = (a, b) => {
+          if (a === b) return true;
+          if (a == null || b == null) return a === b;
+          if (typeof a !== typeof b) return false;
+          if (typeof a !== "object") return a === b;
+          if (Array.isArray(a) !== Array.isArray(b)) return false;
+          if (Array.isArray(a)) {
+            if (a.length !== b.length) return false;
+            return a.every((item, i) => isEqual(item, b[i]));
+          }
+          const keysA = Object.keys(a);
+          const keysB = Object.keys(b);
+          if (keysA.length !== keysB.length) return false;
+          return keysA.every((key) => isEqual(a[key], b[key]));
+        };
+        this.assertCondition(isEqual(this.actual, value), "Expected values to be deeply equal", false, void 0, stack);
+      }
+      toBeTruthy() {
+        const stack = new Error().stack;
+        this.assertCondition(!!this.actual, `Expected value to be truthy`, false, void 0, stack);
+      }
+      toBeFalsy() {
+        const stack = new Error().stack;
+        this.assertCondition(!this.actual, `Expected value to be falsy`, false, void 0, stack);
+      }
+      toBeNull() {
+        const stack = new Error().stack;
+        this.assertCondition(this.actual === null, `Expected value to be null`, false, void 0, stack);
+      }
+      toBeUndefined() {
+        const stack = new Error().stack;
+        this.assertCondition(this.actual === void 0, `Expected value to be undefined`, false, void 0, stack);
+      }
+      toBeDefined() {
+        const stack = new Error().stack;
+        this.assertCondition(this.actual !== void 0, `Expected value to be defined`, false, void 0, stack);
+      }
+      toBeGreaterThan(value) {
+        const stack = new Error().stack;
+        this.expected = value;
+        this.assertCondition(
+          typeof this.actual === "number" && this.actual > value,
+          `Expected ${this.stringify(this.actual)} to be greater than ${value}`,
+          true,
+          String(value),
+          stack
+        );
+      }
+      toBeGreaterThanOrEqual(value) {
+        const stack = new Error().stack;
+        this.expected = value;
+        this.assertCondition(
+          typeof this.actual === "number" && this.actual >= value,
+          `Expected ${this.stringify(this.actual)} to be greater than or equal to ${value}`,
+          true,
+          `${value}`,
+          stack
+        );
+      }
+      toBeLessThan(value) {
+        const stack = new Error().stack;
+        this.expected = value;
+        this.assertCondition(
+          typeof this.actual === "number" && this.actual < value,
+          `Expected ${this.stringify(this.actual)} to be less than ${value}`,
+          true,
+          String(value),
+          stack
+        );
+      }
+      toBeLessThanOrEqual(value) {
+        const stack = new Error().stack;
+        this.expected = value;
+        this.assertCondition(
+          typeof this.actual === "number" && this.actual <= value,
+          `Expected ${this.stringify(this.actual)} to be less than or equal to ${value}`,
+          true,
+          `${value}`,
+          stack
+        );
+      }
+      toContain(value) {
+        const stack = new Error().stack;
+        this.expected = value;
+        if (typeof this.actual === "string") {
+          this.assertCondition(
+            this.actual.includes(value),
+            `Expected "${this.actual}" to contain "${value}"`,
+            false,
+            void 0,
+            stack
+          );
+        } else if (Array.isArray(this.actual)) {
+          this.assertCondition(
+            this.actual.some((item) => this.deepEqual(item, value)),
+            `Expected array to contain ${this.stringify(value)}`,
+            false,
+            void 0,
+            stack
+          );
+        } else {
+          throw new Error(`toContain expects string or array, got ${typeof this.actual}`);
+        }
+      }
+      toHaveLength(length) {
+        const stack = new Error().stack;
+        this.expected = length;
+        const actualLength = this.actual?.length;
+        this.assertCondition(
+          actualLength === length,
+          `Expected length to be ${length}, but got ${actualLength}`,
+          false,
+          void 0,
+          stack
+        );
+      }
+      toThrow(error) {
+        if (this.isAsync) {
+          return this.handleAsyncAssertion(error, () => {
+          });
+        }
+        let threw = false;
+        let thrownError = null;
+        try {
+          if (typeof this.actual === "function") {
+            this.actual();
+          }
+        } catch (e) {
+          threw = true;
+          thrownError = e;
+        }
+        this.assertCondition(threw, `Expected function to throw an error`);
+        if (error) {
+          if (typeof error === "string") {
+            this.assertCondition(
+              thrownError.message.includes(error),
+              `Expected error message to include "${error}"`
+            );
+          } else if (error instanceof RegExp) {
+            this.assertCondition(
+              error.test(thrownError.message),
+              `Expected error message to match ${error}`
+            );
+          }
+        }
+      }
+      toMatch(pattern) {
+        this.expected = pattern;
+        const str = String(this.actual);
+        if (pattern instanceof RegExp) {
+          this.assertCondition(
+            pattern.test(str),
+            `Expected "${str}" to match ${pattern}`
+          );
+        } else {
+          this.assertCondition(
+            str.includes(pattern),
+            `Expected "${str}" to contain "${pattern}"`
+          );
+        }
+      }
+      toBeInstanceOf(classType) {
+        this.expected = classType;
+        this.assertCondition(
+          this.actual instanceof classType,
+          `Expected value to be instance of ${classType.name}`
+        );
+      }
+      toHaveProperty(path, value) {
+        const keys = Array.isArray(path) ? path : path.split(".");
+        let obj = this.actual;
+        for (const key of keys) {
+          if (obj == null || !Object.hasOwnProperty.call(obj, key)) {
+            throw new Error(`Expected object to have property "${path}"`);
+          }
+          obj = obj[key];
+        }
+        if (value !== void 0) {
+          this.assertCondition(
+            this.deepEqual(obj, value),
+            `Expected property "${path}" to equal ${this.stringify(value)}`
+          );
+        }
+      }
+      // Mock function matchers
+      toBeCalled() {
+        this.assertCondition(
+          this.actual._isMock && this.actual._calls.length > 0,
+          `Expected mock function to have been called`
+        );
+      }
+      toBeCalledTimes(times) {
+        this.assertCondition(
+          this.actual._isMock && this.actual._calls.length === times,
+          `Expected mock to be called ${times} times, but was called ${this.actual._calls?.length || 0} times`
+        );
+      }
+      toBeCalledWith(...args) {
+        this.assertCondition(this.actual._isMock && this.actual._calls.some((call) => this.deepEqual(call, args)), `Expected mock to be called with ${this.stringify(args)}`);
+      }
+      lastReturnedWith(value) {
+        const lastResult = this.actual._results?.[this.actual._results.length - 1];
+        this.assertCondition(
+          lastResult && this.deepEqual(lastResult.value, value),
+          `Expected last call to return ${this.stringify(value)}`
+        );
+      }
+      deepEqual(a, b) {
+        return JSON.stringify(a) === JSON.stringify(b);
+      }
+    };
+    vi = {
+      fn: () => createMockFunction(),
+      spyOn: (obj, method) => {
+        const original = obj[method];
+        const mock = createMockFunction();
+        mock.mockImplementation(original);
+        obj[method] = mock;
+        mock.restore = () => {
+          obj[method] = original;
+        };
+        return mock;
+      },
+      clearAllMocks: () => {
+      },
+      restoreAllMocks: () => {
+      }
+    };
+    beforeAllHooks = [];
+    afterAllHooks = [];
+    beforeEachHooks = [];
+    afterEachHooks = [];
+    beforeAll = (fn) => beforeAllHooks.push(fn);
+    afterAll = (fn) => afterAllHooks.push(fn);
+    beforeEach = (fn) => beforeEachHooks.push(fn);
+    afterEach = (fn) => afterEachHooks.push(fn);
+    globals = {
+      describe: createDescribeFunction(),
+      it: createTestFunction(5e3),
+      test: createTestFunction(5e3),
+      expect,
+      beforeAll,
+      afterAll,
+      beforeEach,
+      afterEach,
+      vi
+    };
+  }
+});
+
+// src/test-reporter.ts
+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 colors, TestReporter, DotReporter, JsonReporter, VerboseReporter;
+var init_test_reporter = __esm({
+  "src/test-reporter.ts"() {
+    "use strict";
+    init_path();
+    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"
+    };
+    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("");
+      }
+    };
+    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;
+      }
+    };
+    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));
+      }
+    };
+    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("");
+        }
+      }
+    };
+  }
+});
+
+// src/coverage.ts
+var coverage_exports = {};
+__export(coverage_exports, {
+  calculateUncoveredLines: () => calculateUncoveredLines,
+  generateCloverXml: () => generateCloverXml,
+  generateCoverageFinalJson: () => generateCoverageFinalJson,
+  generateHtmlReport: () => generateHtmlReport,
+  generateTextReport: () => generateTextReport,
+  getExecutedLines: () => getExecutedLines,
+  initializeCoverageTracking: () => initializeCoverageTracking,
+  markFileAsCovered: () => markFileAsCovered,
+  markLineExecuted: () => markLineExecuted,
+  processCoverage: () => processCoverage,
+  resetCoverageTracking: () => resetCoverageTracking
+});
+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: coveredFiles2
+  } = options;
+  const coverageMap = /* @__PURE__ */ new Map();
+  const allTsFiles = findAllTypeScriptFiles(process.cwd(), include, exclude);
+  for (const tsFile of allTsFiles) {
+    const isCovered = coveredFiles2?.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 (coveredFiles2) {
+    for (const coveredFile of coveredFiles2) {
+      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;
+}
+function getColorForPercentage(pct) {
+  if (pct >= 80) return colors2.green;
+  if (pct >= 50) return colors2.yellow;
+  return colors2.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 + "%" + colors2.reset;
+  const coveredPadded = covered.toString().padStart(4);
+  const totalPadded = total.toString().padStart(4);
+  const count = `${colors2.dim}${coveredPadded}${colors2.reset}/${totalPadded}`;
+  const metric = `${pct} (${count})`;
+  const visibleWidth = getVisibleWidth(metric);
+  const padding = " ".repeat(Math.max(0, 19 - visibleWidth));
+  const separator = includeSeparator ? `${colors2.dim}\u2502${colors2.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, testResults2) {
+  let output = "\n";
+  void testResults2;
+  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 += `${colors2.bold}% Coverage report from v8\x1B[0m
+`;
+  output += `
+`;
+  output += `${colors2.dim}${colors2.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 += `${colors2.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 += `${colors2.reset}
+`;
+  output += `${colors2.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 += `${colors2.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 += `
+${colors2.cyan}${relDir}/${colors2.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 += `${colors2.red}${uncoveredStr}${colors2.reset}`;
+      output += "\n";
+    }
+  }
+  output += `
+`;
+  output += `${colors2.dim}${colors2.bold}Test Files\x1B[0m  ${coverageMap.size} passed (100%)
+`;
+  output += `${colors2.dim}${colors2.bold}Tests\x1B[0m       ${coverageMap.size} passed (100%)
+`;
+  output += `
+`;
+  output += `${colors2.dim}${colors2.bold}Statements\x1B[0m   ${colors2.green}${coveredStatements}${colors2.reset} ${colors2.dim}/${colors2.reset} ${totalStatements}
+`;
+  output += `${colors2.dim}${colors2.bold}Branches\x1B[0m    ${colors2.green}${coveredBranches}${colors2.reset} ${colors2.dim}/${colors2.reset} ${totalBranches}
+`;
+  output += `${colors2.dim}${colors2.bold}Functions\x1B[0m    ${colors2.green}${coveredFunctions}${colors2.reset} ${colors2.dim}/${colors2.reset} ${totalFunctions}
+`;
+  output += `${colors2.dim}${colors2.bold}Lines\x1B[0m       ${colors2.green}${coveredLines}${colors2.reset} ${colors2.dim}/${colors2.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 coveredFiles2 = 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>${coveredFiles2}</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");
+}
+var executedLinesMap, totalLinesMap, colors2;
+var init_coverage = __esm({
+  "src/coverage.ts"() {
+    "use strict";
+    init_fs();
+    init_path();
+    executedLinesMap = /* @__PURE__ */ new Map();
+    totalLinesMap = /* @__PURE__ */ new Map();
+    colors2 = {
+      reset: "\x1B[0m",
+      bold: "\x1B[1m",
+      dim: "\x1B[2m",
+      red: "\x1B[31m",
+      green: "\x1B[32m",
+      yellow: "\x1B[33m",
+      cyan: "\x1B[36m"
+    };
+  }
+});
+
+// node_modules/readdirp/esm/index.js
+function readdirp(root, options = {}) {
+  let type = options.entryType || options.type;
+  if (type === "both")
+    type = EntryTypes.FILE_DIR_TYPE;
+  if (type)
+    options.type = type;
+  if (!root) {
+    throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+  } else if (typeof root !== "string") {
+    throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+  } else if (type && !ALL_TYPES.includes(type)) {
+    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+  }
+  options.root = root;
+  return new ReaddirpStream(options);
+}
+var import_promises, import_node_stream, import_node_path, EntryTypes, defaultOptions3, RECURSIVE_ERROR_CODE, NORMAL_FLOW_ERRORS, ALL_TYPES, DIR_TYPES, FILE_TYPES, isNormalFlowError, wantBigintFsStats, emptyFn, normalizeFilter, ReaddirpStream;
+var init_esm = __esm({
+  "node_modules/readdirp/esm/index.js"() {
+    "use strict";
+    import_promises = require("fs/promises");
+    import_node_stream = require("stream");
+    import_node_path = require("path");
+    EntryTypes = {
+      FILE_TYPE: "files",
+      DIR_TYPE: "directories",
+      FILE_DIR_TYPE: "files_directories",
+      EVERYTHING_TYPE: "all"
+    };
+    defaultOptions3 = {
+      root: ".",
+      fileFilter: (_entryInfo) => true,
+      directoryFilter: (_entryInfo) => true,
+      type: EntryTypes.FILE_TYPE,
+      lstat: false,
+      depth: 2147483648,
+      alwaysStat: false,
+      highWaterMark: 4096
+    };
+    Object.freeze(defaultOptions3);
+    RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
+    NORMAL_FLOW_ERRORS = /* @__PURE__ */ new Set(["ENOENT", "EPERM", "EACCES", "ELOOP", RECURSIVE_ERROR_CODE]);
+    ALL_TYPES = [
+      EntryTypes.DIR_TYPE,
+      EntryTypes.EVERYTHING_TYPE,
+      EntryTypes.FILE_DIR_TYPE,
+      EntryTypes.FILE_TYPE
+    ];
+    DIR_TYPES = /* @__PURE__ */ new Set([
+      EntryTypes.DIR_TYPE,
+      EntryTypes.EVERYTHING_TYPE,
+      EntryTypes.FILE_DIR_TYPE
+    ]);
+    FILE_TYPES = /* @__PURE__ */ new Set([
+      EntryTypes.EVERYTHING_TYPE,
+      EntryTypes.FILE_DIR_TYPE,
+      EntryTypes.FILE_TYPE
+    ]);
+    isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+    wantBigintFsStats = process.platform === "win32";
+    emptyFn = (_entryInfo) => true;
+    normalizeFilter = (filter) => {
+      if (filter === void 0)
+        return emptyFn;
+      if (typeof filter === "function")
+        return filter;
+      if (typeof filter === "string") {
+        const fl = filter.trim();
+        return (entry) => entry.basename === fl;
+      }
+      if (Array.isArray(filter)) {
+        const trItems = filter.map((item) => item.trim());
+        return (entry) => trItems.some((f) => entry.basename === f);
+      }
+      return emptyFn;
+    };
+    ReaddirpStream = class extends import_node_stream.Readable {
+      constructor(options = {}) {
+        super({
+          objectMode: true,
+          autoDestroy: true,
+          highWaterMark: options.highWaterMark
+        });
+        const opts = { ...defaultOptions3, ...options };
+        const { root, type } = opts;
+        this._fileFilter = normalizeFilter(opts.fileFilter);
+        this._directoryFilter = normalizeFilter(opts.directoryFilter);
+        const statMethod = opts.lstat ? import_promises.lstat : import_promises.stat;
+        if (wantBigintFsStats) {
+          this._stat = (path) => statMethod(path, { bigint: true });
+        } else {
+          this._stat = statMethod;
+        }
+        this._maxDepth = opts.depth ?? defaultOptions3.depth;
+        this._wantsDir = type ? DIR_TYPES.has(type) : false;
+        this._wantsFile = type ? FILE_TYPES.has(type) : false;
+        this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+        this._root = (0, import_node_path.resolve)(root);
+        this._isDirent = !opts.alwaysStat;
+        this._statsProp = this._isDirent ? "dirent" : "stats";
+        this._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
+        this.parents = [this._exploreDir(root, 1)];
+        this.reading = false;
+        this.parent = void 0;
+      }
+      async _read(batch) {
+        if (this.reading)
+          return;
+        this.reading = true;
+        try {
+          while (!this.destroyed && batch > 0) {
+            const par = this.parent;
+            const fil = par && par.files;
+            if (fil && fil.length > 0) {
+              const { path, depth } = par;
+              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path));
+              const awaited = await Promise.all(slice);
+              for (const entry of awaited) {
+                if (!entry)
+                  continue;
+                if (this.destroyed)
+                  return;
+                const entryType = await this._getEntryType(entry);
+                if (entryType === "directory" && this._directoryFilter(entry)) {
+                  if (depth <= this._maxDepth) {
+                    this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+                  }
+                  if (this._wantsDir) {
+                    this.push(entry);
+                    batch--;
+                  }
+                } else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+                  if (this._wantsFile) {
+                    this.push(entry);
+                    batch--;
+                  }
+                }
+              }
+            } else {
+              const parent = this.parents.pop();
+              if (!parent) {
+                this.push(null);
+                break;
+              }
+              this.parent = await parent;
+              if (this.destroyed)
+                return;
+            }
+          }
+        } catch (error) {
+          this.destroy(error);
+        } finally {
+          this.reading = false;
+        }
+      }
+      async _exploreDir(path, depth) {
+        let files;
+        try {
+          files = await (0, import_promises.readdir)(path, this._rdOptions);
+        } catch (error) {
+          this._onError(error);
+        }
+        return { files, depth, path };
+      }
+      async _formatEntry(dirent, path) {
+        let entry;
+        const basename4 = this._isDirent ? dirent.name : dirent;
+        try {
+          const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path, basename4));
+          entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename4 };
+          entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+        } catch (err) {
+          this._onError(err);
+          return;
+        }
+        return entry;
+      }
+      _onError(err) {
+        if (isNormalFlowError(err) && !this.destroyed) {
+          this.emit("warn", err);
+        } else {
+          this.destroy(err);
+        }
+      }
+      async _getEntryType(entry) {
+        if (!entry && this._statsProp in entry) {
+          return "";
+        }
+        const stats = entry[this._statsProp];
+        if (stats.isFile())
+          return "file";
+        if (stats.isDirectory())
+          return "directory";
+        if (stats && stats.isSymbolicLink()) {
+          const full = entry.fullPath;
+          try {
+            const entryRealPath = await (0, import_promises.realpath)(full);
+            const entryRealPathStats = await (0, import_promises.lstat)(entryRealPath);
+            if (entryRealPathStats.isFile()) {
+              return "file";
+            }
+            if (entryRealPathStats.isDirectory()) {
+              const len = entryRealPath.length;
+              if (full.startsWith(entryRealPath) && full.substr(len, 1) === import_node_path.sep) {
+                const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+                recursiveError.code = RECURSIVE_ERROR_CODE;
+                return this._onError(recursiveError);
+              }
+              return "directory";
+            }
+          } catch (error) {
+            this._onError(error);
+            return "";
+          }
+        }
+      }
+      _includeAsFile(entry) {
+        const stats = entry && entry[this._statsProp];
+        return stats && this._wantsEverything && !stats.isDirectory();
+      }
+    };
+  }
+});
+
+// node_modules/chokidar/esm/handler.js
+function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
+  const handleEvent = (rawEvent, evPath) => {
+    listener(path);
+    emitRaw(rawEvent, evPath, { watchedPath: path });
+    if (evPath && path !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path, evPath), KEY_LISTENERS, sysPath.join(path, evPath));
+    }
+  };
+  try {
+    return (0, import_fs6.watch)(path, {
+      persistent: options.persistent
+    }, handleEvent);
+  } catch (error) {
+    errHandler(error);
+    return void 0;
+  }
+}
+var import_fs6, import_promises2, sysPath, import_os, STR_DATA, STR_END, STR_CLOSE, EMPTY_FN, pl, isWindows2, isMacos, isLinux, isFreeBSD, isIBMi, EVENTS, EV, THROTTLE_MODE_WATCH, statMethods, KEY_LISTENERS, KEY_ERR, KEY_RAW, HANDLER_KEYS, binaryExtensions, isBinaryPath, foreach, addAndConvert, clearItem, delFromSet, isEmptySet, FsWatchInstances, fsWatchBroadcast, setFsWatchListener, FsWatchFileInstances, setFsWatchFileListener, NodeFsHandler;
+var init_handler = __esm({
+  "node_modules/chokidar/esm/handler.js"() {
+    "use strict";
+    import_fs6 = require("fs");
+    import_promises2 = require("fs/promises");
+    sysPath = __toESM(require("path"), 1);
+    import_os = require("os");
+    STR_DATA = "data";
+    STR_END = "end";
+    STR_CLOSE = "close";
+    EMPTY_FN = () => {
+    };
+    pl = process.platform;
+    isWindows2 = pl === "win32";
+    isMacos = pl === "darwin";
+    isLinux = pl === "linux";
+    isFreeBSD = pl === "freebsd";
+    isIBMi = (0, import_os.type)() === "OS400";
+    EVENTS = {
+      ALL: "all",
+      READY: "ready",
+      ADD: "add",
+      CHANGE: "change",
+      ADD_DIR: "addDir",
+      UNLINK: "unlink",
+      UNLINK_DIR: "unlinkDir",
+      RAW: "raw",
+      ERROR: "error"
+    };
+    EV = EVENTS;
+    THROTTLE_MODE_WATCH = "watch";
+    statMethods = { lstat: import_promises2.lstat, stat: import_promises2.stat };
+    KEY_LISTENERS = "listeners";
+    KEY_ERR = "errHandlers";
+    KEY_RAW = "rawEmitters";
+    HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
+    binaryExtensions = /* @__PURE__ */ new Set([
+      "3dm",
+      "3ds",
+      "3g2",
+      "3gp",
+      "7z",
+      "a",
+      "aac",
+      "adp",
+      "afdesign",
+      "afphoto",
+      "afpub",
+      "ai",
+      "aif",
+      "aiff",
+      "alz",
+      "ape",
+      "apk",
+      "appimage",
+      "ar",
+      "arj",
+      "asf",
+      "au",
+      "avi",
+      "bak",
+      "baml",
+      "bh",
+      "bin",
+      "bk",
+      "bmp",
+      "btif",
+      "bz2",
+      "bzip2",
+      "cab",
+      "caf",
+      "cgm",
+      "class",
+      "cmx",
+      "cpio",
+      "cr2",
+      "cur",
+      "dat",
+      "dcm",
+      "deb",
+      "dex",
+      "djvu",
+      "dll",
+      "dmg",
+      "dng",
+      "doc",
+      "docm",
+      "docx",
+      "dot",
+      "dotm",
+      "dra",
+      "DS_Store",
+      "dsk",
+      "dts",
+      "dtshd",
+      "dvb",
+      "dwg",
+      "dxf",
+      "ecelp4800",
+      "ecelp7470",
+      "ecelp9600",
+      "egg",
+      "eol",
+      "eot",
+      "epub",
+      "exe",
+      "f4v",
+      "fbs",
+      "fh",
+      "fla",
+      "flac",
+      "flatpak",
+      "fli",
+      "flv",
+      "fpx",
+      "fst",
+      "fvt",
+      "g3",
+      "gh",
+      "gif",
+      "graffle",
+      "gz",
+      "gzip",
+      "h261",
+      "h263",
+      "h264",
+      "icns",
+      "ico",
+      "ief",
+      "img",
+      "ipa",
+      "iso",
+      "jar",
+      "jpeg",
+      "jpg",
+      "jpgv",
+      "jpm",
+      "jxr",
+      "key",
+      "ktx",
+      "lha",
+      "lib",
+      "lvp",
+      "lz",
+      "lzh",
+      "lzma",
+      "lzo",
+      "m3u",
+      "m4a",
+      "m4v",
+      "mar",
+      "mdi",
+      "mht",
+      "mid",
+      "midi",
+      "mj2",
+      "mka",
+      "mkv",
+      "mmr",
+      "mng",
+      "mobi",
+      "mov",
+      "movie",
+      "mp3",
+      "mp4",
+      "mp4a",
+      "mpeg",
+      "mpg",
+      "mpga",
+      "mxu",
+      "nef",
+      "npx",
+      "numbers",
+      "nupkg",
+      "o",
+      "odp",
+      "ods",
+      "odt",
+      "oga",
+      "ogg",
+      "ogv",
+      "otf",
+      "ott",
+      "pages",
+      "pbm",
+      "pcx",
+      "pdb",
+      "pdf",
+      "pea",
+      "pgm",
+      "pic",
+      "png",
+      "pnm",
+      "pot",
+      "potm",
+      "potx",
+      "ppa",
+      "ppam",
+      "ppm",
+      "pps",
+      "ppsm",
+      "ppsx",
+      "ppt",
+      "pptm",
+      "pptx",
+      "psd",
+      "pya",
+      "pyc",
+      "pyo",
+      "pyv",
+      "qt",
+      "rar",
+      "ras",
+      "raw",
+      "resources",
+      "rgb",
+      "rip",
+      "rlc",
+      "rmf",
+      "rmvb",
+      "rpm",
+      "rtf",
+      "rz",
+      "s3m",
+      "s7z",
+      "scpt",
+      "sgi",
+      "shar",
+      "snap",
+      "sil",
+      "sketch",
+      "slk",
+      "smv",
+      "snk",
+      "so",
+      "stl",
+      "suo",
+      "sub",
+      "swf",
+      "tar",
+      "tbz",
+      "tbz2",
+      "tga",
+      "tgz",
+      "thmx",
+      "tif",
+      "tiff",
+      "tlz",
+      "ttc",
+      "ttf",
+      "txz",
+      "udf",
+      "uvh",
+      "uvi",
+      "uvm",
+      "uvp",
+      "uvs",
+      "uvu",
+      "viv",
+      "vob",
+      "war",
+      "wav",
+      "wax",
+      "wbmp",
+      "wdp",
+      "weba",
+      "webm",
+      "webp",
+      "whl",
+      "wim",
+      "wm",
+      "wma",
+      "wmv",
+      "wmx",
+      "woff",
+      "woff2",
+      "wrm",
+      "wvx",
+      "xbm",
+      "xif",
+      "xla",
+      "xlam",
+      "xls",
+      "xlsb",
+      "xlsm",
+      "xlsx",
+      "xlt",
+      "xltm",
+      "xltx",
+      "xm",
+      "xmind",
+      "xpi",
+      "xpm",
+      "xwd",
+      "xz",
+      "z",
+      "zip",
+      "zipx"
+    ]);
+    isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
+    foreach = (val, fn) => {
+      if (val instanceof Set) {
+        val.forEach(fn);
+      } else {
+        fn(val);
+      }
+    };
+    addAndConvert = (main2, prop, item) => {
+      let container = main2[prop];
+      if (!(container instanceof Set)) {
+        main2[prop] = container = /* @__PURE__ */ new Set([container]);
+      }
+      container.add(item);
+    };
+    clearItem = (cont) => (key) => {
+      const set = cont[key];
+      if (set instanceof Set) {
+        set.clear();
+      } else {
+        delete cont[key];
+      }
+    };
+    delFromSet = (main2, prop, item) => {
+      const container = main2[prop];
+      if (container instanceof Set) {
+        container.delete(item);
+      } else if (container === item) {
+        delete main2[prop];
+      }
+    };
+    isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
+    FsWatchInstances = /* @__PURE__ */ new Map();
+    fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
+      const cont = FsWatchInstances.get(fullPath);
+      if (!cont)
+        return;
+      foreach(cont[listenerType], (listener) => {
+        listener(val1, val2, val3);
+      });
+    };
+    setFsWatchListener = (path, fullPath, options, handlers) => {
+      const { listener, errHandler, rawEmitter } = handlers;
+      let cont = FsWatchInstances.get(fullPath);
+      let watcher;
+      if (!options.persistent) {
+        watcher = createFsWatchInstance(path, options, listener, errHandler, rawEmitter);
+        if (!watcher)
+          return;
+        return watcher.close.bind(watcher);
+      }
+      if (cont) {
+        addAndConvert(cont, KEY_LISTENERS, listener);
+        addAndConvert(cont, KEY_ERR, errHandler);
+        addAndConvert(cont, KEY_RAW, rawEmitter);
+      } else {
+        watcher = createFsWatchInstance(
+          path,
+          options,
+          fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
+          errHandler,
+          // no need to use broadcast here
+          fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
+        );
+        if (!watcher)
+          return;
+        watcher.on(EV.ERROR, async (error) => {
+          const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+          if (cont)
+            cont.watcherUnusable = true;
+          if (isWindows2 && error.code === "EPERM") {
+            try {
+              const fd = await (0, import_promises2.open)(path, "r");
+              await fd.close();
+              broadcastErr(error);
+            } catch (err) {
+            }
+          } else {
+            broadcastErr(error);
+          }
+        });
+        cont = {
+          listeners: listener,
+          errHandlers: errHandler,
+          rawEmitters: rawEmitter,
+          watcher
+        };
+        FsWatchInstances.set(fullPath, cont);
+      }
+      return () => {
+        delFromSet(cont, KEY_LISTENERS, listener);
+        delFromSet(cont, KEY_ERR, errHandler);
+        delFromSet(cont, KEY_RAW, rawEmitter);
+        if (isEmptySet(cont.listeners)) {
+          cont.watcher.close();
+          FsWatchInstances.delete(fullPath);
+          HANDLER_KEYS.forEach(clearItem(cont));
+          cont.watcher = void 0;
+          Object.freeze(cont);
+        }
+      };
+    };
+    FsWatchFileInstances = /* @__PURE__ */ new Map();
+    setFsWatchFileListener = (path, fullPath, options, handlers) => {
+      const { listener, rawEmitter } = handlers;
+      let cont = FsWatchFileInstances.get(fullPath);
+      const copts = cont && cont.options;
+      if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+        (0, import_fs6.unwatchFile)(fullPath);
+        cont = void 0;
+      }
+      if (cont) {
+        addAndConvert(cont, KEY_LISTENERS, listener);
+        addAndConvert(cont, KEY_RAW, rawEmitter);
+      } else {
+        cont = {
+          listeners: listener,
+          rawEmitters: rawEmitter,
+          options,
+          watcher: (0, import_fs6.watchFile)(fullPath, options, (curr, prev) => {
+            foreach(cont.rawEmitters, (rawEmitter2) => {
+              rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
+            });
+            const currmtime = curr.mtimeMs;
+            if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
+              foreach(cont.listeners, (listener2) => listener2(path, curr));
+            }
+          })
+        };
+        FsWatchFileInstances.set(fullPath, cont);
+      }
+      return () => {
+        delFromSet(cont, KEY_LISTENERS, listener);
+        delFromSet(cont, KEY_RAW, rawEmitter);
+        if (isEmptySet(cont.listeners)) {
+          FsWatchFileInstances.delete(fullPath);
+          (0, import_fs6.unwatchFile)(fullPath);
+          cont.options = cont.watcher = void 0;
+          Object.freeze(cont);
+        }
+      };
+    };
+    NodeFsHandler = class {
+      constructor(fsW) {
+        this.fsw = fsW;
+        this._boundHandleError = (error) => fsW._handleError(error);
+      }
+      /**
+       * Watch file for changes with fs_watchFile or fs_watch.
+       * @param path to file or dir
+       * @param listener on fs change
+       * @returns closer for the watcher instance
+       */
+      _watchWithNodeFs(path, listener) {
+        const opts = this.fsw.options;
+        const directory = sysPath.dirname(path);
+        const basename4 = sysPath.basename(path);
+        const parent = this.fsw._getWatchedDir(directory);
+        parent.add(basename4);
+        const absolutePath = sysPath.resolve(path);
+        const options = {
+          persistent: opts.persistent
+        };
+        if (!listener)
+          listener = EMPTY_FN;
+        let closer;
+        if (opts.usePolling) {
+          const enableBin = opts.interval !== opts.binaryInterval;
+          options.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
+          closer = setFsWatchFileListener(path, absolutePath, options, {
+            listener,
+            rawEmitter: this.fsw._emitRaw
+          });
+        } else {
+          closer = setFsWatchListener(path, absolutePath, options, {
+            listener,
+            errHandler: this._boundHandleError,
+            rawEmitter: this.fsw._emitRaw
+          });
+        }
+        return closer;
+      }
+      /**
+       * Watch a file and emit add event if warranted.
+       * @returns closer for the watcher instance
+       */
+      _handleFile(file, stats, initialAdd) {
+        if (this.fsw.closed) {
+          return;
+        }
+        const dirname4 = sysPath.dirname(file);
+        const basename4 = sysPath.basename(file);
+        const parent = this.fsw._getWatchedDir(dirname4);
+        let prevStats = stats;
+        if (parent.has(basename4))
+          return;
+        const listener = async (path, newStats) => {
+          if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
+            return;
+          if (!newStats || newStats.mtimeMs === 0) {
+            try {
+              const newStats2 = await (0, import_promises2.stat)(file);
+              if (this.fsw.closed)
+                return;
+              const at = newStats2.atimeMs;
+              const mt = newStats2.mtimeMs;
+              if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+                this.fsw._emit(EV.CHANGE, file, newStats2);
+              }
+              if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
+                this.fsw._closeFile(path);
+                prevStats = newStats2;
+                const closer2 = this._watchWithNodeFs(file, listener);
+                if (closer2)
+                  this.fsw._addPathCloser(path, closer2);
+              } else {
+                prevStats = newStats2;
+              }
+            } catch (error) {
+              this.fsw._remove(dirname4, basename4);
+            }
+          } else if (parent.has(basename4)) {
+            const at = newStats.atimeMs;
+            const mt = newStats.mtimeMs;
+            if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+              this.fsw._emit(EV.CHANGE, file, newStats);
+            }
+            prevStats = newStats;
+          }
+        };
+        const closer = this._watchWithNodeFs(file, listener);
+        if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+          if (!this.fsw._throttle(EV.ADD, file, 0))
+            return;
+          this.fsw._emit(EV.ADD, file, stats);
+        }
+        return closer;
+      }
+      /**
+       * Handle symlinks encountered while reading a dir.
+       * @param entry returned by readdirp
+       * @param directory path of dir being read
+       * @param path of this item
+       * @param item basename of this item
+       * @returns true if no more processing is needed for this entry.
+       */
+      async _handleSymlink(entry, directory, path, item) {
+        if (this.fsw.closed) {
+          return;
+        }
+        const full = entry.fullPath;
+        const dir = this.fsw._getWatchedDir(directory);
+        if (!this.fsw.options.followSymlinks) {
+          this.fsw._incrReadyCount();
+          let linkPath;
+          try {
+            linkPath = await (0, import_promises2.realpath)(path);
+          } catch (e) {
+            this.fsw._emitReady();
+            return true;
+          }
+          if (this.fsw.closed)
+            return;
+          if (dir.has(item)) {
+            if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+              this.fsw._symlinkPaths.set(full, linkPath);
+              this.fsw._emit(EV.CHANGE, path, entry.stats);
+            }
+          } else {
+            dir.add(item);
+            this.fsw._symlinkPaths.set(full, linkPath);
+            this.fsw._emit(EV.ADD, path, entry.stats);
+          }
+          this.fsw._emitReady();
+          return true;
+        }
+        if (this.fsw._symlinkPaths.has(full)) {
+          return true;
+        }
+        this.fsw._symlinkPaths.set(full, true);
+      }
+      _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+        directory = sysPath.join(directory, "");
+        throttler = this.fsw._throttle("readdir", directory, 1e3);
+        if (!throttler)
+          return;
+        const previous = this.fsw._getWatchedDir(wh.path);
+        const current = /* @__PURE__ */ new Set();
+        let stream = this.fsw._readdirp(directory, {
+          fileFilter: (entry) => wh.filterPath(entry),
+          directoryFilter: (entry) => wh.filterDir(entry)
+        });
+        if (!stream)
+          return;
+        stream.on(STR_DATA, async (entry) => {
+          if (this.fsw.closed) {
+            stream = void 0;
+            return;
+          }
+          const item = entry.path;
+          let path = sysPath.join(directory, item);
+          current.add(item);
+          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) {
+            return;
+          }
+          if (this.fsw.closed) {
+            stream = void 0;
+            return;
+          }
+          if (item === target || !target && !previous.has(item)) {
+            this.fsw._incrReadyCount();
+            path = sysPath.join(dir, sysPath.relative(dir, path));
+            this._addToNodeFs(path, initialAdd, wh, depth + 1);
+          }
+        }).on(EV.ERROR, this._boundHandleError);
+        return new Promise((resolve4, reject) => {
+          if (!stream)
+            return reject();
+          stream.once(STR_END, () => {
+            if (this.fsw.closed) {
+              stream = void 0;
+              return;
+            }
+            const wasThrottled = throttler ? throttler.clear() : false;
+            resolve4(void 0);
+            previous.getChildren().filter((item) => {
+              return item !== directory && !current.has(item);
+            }).forEach((item) => {
+              this.fsw._remove(directory, item);
+            });
+            stream = void 0;
+            if (wasThrottled)
+              this._handleRead(directory, false, wh, target, dir, depth, throttler);
+          });
+        });
+      }
+      /**
+       * Read directory to add / remove files from `@watched` list and re-read it on change.
+       * @param dir fs path
+       * @param stats
+       * @param initialAdd
+       * @param depth relative to user-supplied path
+       * @param target child path targeted for watch
+       * @param wh Common watch helpers for this path
+       * @param realpath
+       * @returns closer for the watcher instance.
+       */
+      async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath3) {
+        const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
+        const tracked = parentDir.has(sysPath.basename(dir));
+        if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+          this.fsw._emit(EV.ADD_DIR, dir, stats);
+        }
+        parentDir.add(sysPath.basename(dir));
+        this.fsw._getWatchedDir(dir);
+        let throttler;
+        let closer;
+        const oDepth = this.fsw.options.depth;
+        if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath3)) {
+          if (!target) {
+            await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+            if (this.fsw.closed)
+              return;
+          }
+          closer = this._watchWithNodeFs(dir, (dirPath, stats2) => {
+            if (stats2 && stats2.mtimeMs === 0)
+              return;
+            this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+          });
+        }
+        return closer;
+      }
+      /**
+       * Handle added file, directory, or glob pattern.
+       * Delegates call to _handleFile / _handleDir after checks.
+       * @param path to file or ir
+       * @param initialAdd was the file added at watch instantiation?
+       * @param priorWh depth relative to user-supplied path
+       * @param depth Child path actually targeted for watch
+       * @param target Child path actually targeted for watch
+       */
+      async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
+        const ready = this.fsw._emitReady;
+        if (this.fsw._isIgnored(path) || this.fsw.closed) {
+          ready();
+          return false;
+        }
+        const wh = this.fsw._getWatchHelpers(path);
+        if (priorWh) {
+          wh.filterPath = (entry) => priorWh.filterPath(entry);
+          wh.filterDir = (entry) => priorWh.filterDir(entry);
+        }
+        try {
+          const stats = await statMethods[wh.statMethod](wh.watchPath);
+          if (this.fsw.closed)
+            return;
+          if (this.fsw._isIgnored(wh.watchPath, stats)) {
+            ready();
+            return false;
+          }
+          const follow = this.fsw.options.followSymlinks;
+          let closer;
+          if (stats.isDirectory()) {
+            const absPath = sysPath.resolve(path);
+            const targetPath = follow ? await (0, import_promises2.realpath)(path) : path;
+            if (this.fsw.closed)
+              return;
+            closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+            if (this.fsw.closed)
+              return;
+            if (absPath !== targetPath && targetPath !== void 0) {
+              this.fsw._symlinkPaths.set(absPath, targetPath);
+            }
+          } else if (stats.isSymbolicLink()) {
+            const targetPath = follow ? await (0, import_promises2.realpath)(path) : path;
+            if (this.fsw.closed)
+              return;
+            const parent = sysPath.dirname(wh.watchPath);
+            this.fsw._getWatchedDir(parent).add(wh.watchPath);
+            this.fsw._emit(EV.ADD, wh.watchPath, stats);
+            closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
+            if (this.fsw.closed)
+              return;
+            if (targetPath !== void 0) {
+              this.fsw._symlinkPaths.set(sysPath.resolve(path), targetPath);
+            }
+          } else {
+            closer = this._handleFile(wh.watchPath, stats, initialAdd);
+          }
+          ready();
+          if (closer)
+            this.fsw._addPathCloser(path, closer);
+          return false;
+        } catch (error) {
+          if (this.fsw._handleError(error)) {
+            ready();
+            return path;
+          }
+        }
+      }
+    };
+  }
+});
+
+// node_modules/chokidar/esm/index.js
+var esm_exports = {};
+__export(esm_exports, {
+  FSWatcher: () => FSWatcher2,
+  WatchHelper: () => WatchHelper,
+  default: () => esm_default,
+  watch: () => watch2
+});
+function arrify(item) {
+  return Array.isArray(item) ? item : [item];
+}
+function createPattern(matcher) {
+  if (typeof matcher === "function")
+    return matcher;
+  if (typeof matcher === "string")
+    return (string) => matcher === string;
+  if (matcher instanceof RegExp)
+    return (string) => matcher.test(string);
+  if (typeof matcher === "object" && matcher !== null) {
+    return (string) => {
+      if (matcher.path === string)
+        return true;
+      if (matcher.recursive) {
+        const relative4 = sysPath2.relative(matcher.path, string);
+        if (!relative4) {
+          return false;
+        }
+        return !relative4.startsWith("..") && !sysPath2.isAbsolute(relative4);
+      }
+      return false;
+    };
+  }
+  return () => false;
+}
+function normalizePath3(path) {
+  if (typeof path !== "string")
+    throw new Error("string expected");
+  path = sysPath2.normalize(path);
+  path = path.replace(/\\/g, "/");
+  let prepend = false;
+  if (path.startsWith("//"))
+    prepend = true;
+  const DOUBLE_SLASH_RE2 = /\/\//;
+  while (path.match(DOUBLE_SLASH_RE2))
+    path = path.replace(DOUBLE_SLASH_RE2, "/");
+  if (prepend)
+    path = "/" + path;
+  return path;
+}
+function matchPatterns(patterns, testString, stats) {
+  const path = normalizePath3(testString);
+  for (let index = 0; index < patterns.length; index++) {
+    const pattern = patterns[index];
+    if (pattern(path, stats)) {
+      return true;
+    }
+  }
+  return false;
+}
+function anymatch(matchers, testString) {
+  if (matchers == null) {
+    throw new TypeError("anymatch: specify first argument");
+  }
+  const matchersArray = arrify(matchers);
+  const patterns = matchersArray.map((matcher) => createPattern(matcher));
+  if (testString == null) {
+    return (testString2, stats) => {
+      return matchPatterns(patterns, testString2, stats);
+    };
+  }
+  return matchPatterns(patterns, testString);
+}
+function watch2(paths, options = {}) {
+  const watcher = new FSWatcher2(options);
+  watcher.add(paths);
+  return watcher;
+}
+var import_fs7, import_promises3, import_events4, sysPath2, SLASH, SLASH_SLASH, ONE_DOT, TWO_DOTS, STRING_TYPE, BACK_SLASH_RE, DOUBLE_SLASH_RE, DOT_RE, REPLACER_RE, isMatcherObject, unifyPaths, toUnix, normalizePathToUnix, normalizeIgnored, getAbsolutePath, EMPTY_SET, DirEntry, STAT_METHOD_F, STAT_METHOD_L, WatchHelper, FSWatcher2, esm_default;
+var init_esm2 = __esm({
+  "node_modules/chokidar/esm/index.js"() {
+    "use strict";
+    import_fs7 = require("fs");
+    import_promises3 = require("fs/promises");
+    import_events4 = require("events");
+    sysPath2 = __toESM(require("path"), 1);
+    init_esm();
+    init_handler();
+    SLASH = "/";
+    SLASH_SLASH = "//";
+    ONE_DOT = ".";
+    TWO_DOTS = "..";
+    STRING_TYPE = "string";
+    BACK_SLASH_RE = /\\/g;
+    DOUBLE_SLASH_RE = /\/\//;
+    DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+    REPLACER_RE = /^\.[/\\]/;
+    isMatcherObject = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp);
+    unifyPaths = (paths_) => {
+      const paths = arrify(paths_).flat();
+      if (!paths.every((p) => typeof p === STRING_TYPE)) {
+        throw new TypeError(`Non-string provided as watch path: ${paths}`);
+      }
+      return paths.map(normalizePathToUnix);
+    };
+    toUnix = (string) => {
+      let str = string.replace(BACK_SLASH_RE, SLASH);
+      let prepend = false;
+      if (str.startsWith(SLASH_SLASH)) {
+        prepend = true;
+      }
+      while (str.match(DOUBLE_SLASH_RE)) {
+        str = str.replace(DOUBLE_SLASH_RE, SLASH);
+      }
+      if (prepend) {
+        str = SLASH + str;
+      }
+      return str;
+    };
+    normalizePathToUnix = (path) => toUnix(sysPath2.normalize(toUnix(path)));
+    normalizeIgnored = (cwd = "") => (path) => {
+      if (typeof path === "string") {
+        return normalizePathToUnix(sysPath2.isAbsolute(path) ? path : sysPath2.join(cwd, path));
+      } else {
+        return path;
+      }
+    };
+    getAbsolutePath = (path, cwd) => {
+      if (sysPath2.isAbsolute(path)) {
+        return path;
+      }
+      return sysPath2.join(cwd, path);
+    };
+    EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
+    DirEntry = class {
+      constructor(dir, removeWatcher) {
+        this.path = dir;
+        this._removeWatcher = removeWatcher;
+        this.items = /* @__PURE__ */ new Set();
+      }
+      add(item) {
+        const { items } = this;
+        if (!items)
+          return;
+        if (item !== ONE_DOT && item !== TWO_DOTS)
+          items.add(item);
+      }
+      async remove(item) {
+        const { items } = this;
+        if (!items)
+          return;
+        items.delete(item);
+        if (items.size > 0)
+          return;
+        const dir = this.path;
+        try {
+          await (0, import_promises3.readdir)(dir);
+        } catch (err) {
+          if (this._removeWatcher) {
+            this._removeWatcher(sysPath2.dirname(dir), sysPath2.basename(dir));
+          }
+        }
+      }
+      has(item) {
+        const { items } = this;
+        if (!items)
+          return;
+        return items.has(item);
+      }
+      getChildren() {
+        const { items } = this;
+        if (!items)
+          return [];
+        return [...items.values()];
+      }
+      dispose() {
+        this.items.clear();
+        this.path = "";
+        this._removeWatcher = EMPTY_FN;
+        this.items = EMPTY_SET;
+        Object.freeze(this);
+      }
+    };
+    STAT_METHOD_F = "stat";
+    STAT_METHOD_L = "lstat";
+    WatchHelper = class {
+      constructor(path, follow, fsw) {
+        this.fsw = fsw;
+        const watchPath = path;
+        this.path = path = path.replace(REPLACER_RE, "");
+        this.watchPath = watchPath;
+        this.fullWatchPath = sysPath2.resolve(watchPath);
+        this.dirParts = [];
+        this.dirParts.forEach((parts) => {
+          if (parts.length > 1)
+            parts.pop();
+        });
+        this.followSymlinks = follow;
+        this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+      }
+      entryPath(entry) {
+        return sysPath2.join(this.watchPath, sysPath2.relative(this.watchPath, entry.fullPath));
+      }
+      filterPath(entry) {
+        const { stats } = entry;
+        if (stats && stats.isSymbolicLink())
+          return this.filterDir(entry);
+        const resolvedPath = this.entryPath(entry);
+        return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+      }
+      filterDir(entry) {
+        return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+      }
+    };
+    FSWatcher2 = class extends import_events4.EventEmitter {
+      // Not indenting methods for history sake; for now.
+      constructor(_opts = {}) {
+        super();
+        this.closed = false;
+        this._closers = /* @__PURE__ */ new Map();
+        this._ignoredPaths = /* @__PURE__ */ new Set();
+        this._throttled = /* @__PURE__ */ new Map();
+        this._streams = /* @__PURE__ */ new Set();
+        this._symlinkPaths = /* @__PURE__ */ new Map();
+        this._watched = /* @__PURE__ */ new Map();
+        this._pendingWrites = /* @__PURE__ */ new Map();
+        this._pendingUnlinks = /* @__PURE__ */ new Map();
+        this._readyCount = 0;
+        this._readyEmitted = false;
+        const awf = _opts.awaitWriteFinish;
+        const DEF_AWF = { stabilityThreshold: 2e3, pollInterval: 100 };
+        const opts = {
+          // Defaults
+          persistent: true,
+          ignoreInitial: false,
+          ignorePermissionErrors: false,
+          interval: 100,
+          binaryInterval: 300,
+          followSymlinks: true,
+          usePolling: false,
+          // useAsync: false,
+          atomic: true,
+          // NOTE: overwritten later (depends on usePolling)
+          ..._opts,
+          // Change format
+          ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+          awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? { ...DEF_AWF, ...awf } : false
+        };
+        if (isIBMi)
+          opts.usePolling = true;
+        if (opts.atomic === void 0)
+          opts.atomic = !opts.usePolling;
+        const envPoll = process.env.CHOKIDAR_USEPOLLING;
+        if (envPoll !== void 0) {
+          const envLower = envPoll.toLowerCase();
+          if (envLower === "false" || envLower === "0")
+            opts.usePolling = false;
+          else if (envLower === "true" || envLower === "1")
+            opts.usePolling = true;
+          else
+            opts.usePolling = !!envLower;
+        }
+        const envInterval = process.env.CHOKIDAR_INTERVAL;
+        if (envInterval)
+          opts.interval = Number.parseInt(envInterval, 10);
+        let readyCalls = 0;
+        this._emitReady = () => {
+          readyCalls++;
+          if (readyCalls >= this._readyCount) {
+            this._emitReady = EMPTY_FN;
+            this._readyEmitted = true;
+            process.nextTick(() => this.emit(EVENTS.READY));
+          }
+        };
+        this._emitRaw = (...args) => this.emit(EVENTS.RAW, ...args);
+        this._boundRemove = this._remove.bind(this);
+        this.options = opts;
+        this._nodeFsHandler = new NodeFsHandler(this);
+        Object.freeze(opts);
+      }
+      _addIgnoredPath(matcher) {
+        if (isMatcherObject(matcher)) {
+          for (const ignored of this._ignoredPaths) {
+            if (isMatcherObject(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) {
+              return;
+            }
+          }
+        }
+        this._ignoredPaths.add(matcher);
+      }
+      _removeIgnoredPath(matcher) {
+        this._ignoredPaths.delete(matcher);
+        if (typeof matcher === "string") {
+          for (const ignored of this._ignoredPaths) {
+            if (isMatcherObject(ignored) && ignored.path === matcher) {
+              this._ignoredPaths.delete(ignored);
+            }
+          }
+        }
+      }
+      // Public methods
+      /**
+       * Adds paths to be watched on an existing FSWatcher instance.
+       * @param paths_ file or file list. Other arguments are unused
+       */
+      add(paths_, _origAdd, _internal) {
+        const { cwd } = this.options;
+        this.closed = false;
+        this._closePromise = void 0;
+        let paths = unifyPaths(paths_);
+        if (cwd) {
+          paths = paths.map((path) => {
+            const absPath = getAbsolutePath(path, cwd);
+            return absPath;
+          });
+        }
+        paths.forEach((path) => {
+          this._removeIgnoredPath(path);
+        });
+        this._userIgnored = void 0;
+        if (!this._readyCount)
+          this._readyCount = 0;
+        this._readyCount += paths.length;
+        Promise.all(paths.map(async (path) => {
+          const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, void 0, 0, _origAdd);
+          if (res)
+            this._emitReady();
+          return res;
+        })).then((results) => {
+          if (this.closed)
+            return;
+          results.forEach((item) => {
+            if (item)
+              this.add(sysPath2.dirname(item), sysPath2.basename(_origAdd || item));
+          });
+        });
+        return this;
+      }
+      /**
+       * Close watchers or start ignoring events from specified paths.
+       */
+      unwatch(paths_) {
+        if (this.closed)
+          return this;
+        const paths = unifyPaths(paths_);
+        const { cwd } = this.options;
+        paths.forEach((path) => {
+          if (!sysPath2.isAbsolute(path) && !this._closers.has(path)) {
+            if (cwd)
+              path = sysPath2.join(cwd, path);
+            path = sysPath2.resolve(path);
+          }
+          this._closePath(path);
+          this._addIgnoredPath(path);
+          if (this._watched.has(path)) {
+            this._addIgnoredPath({
+              path,
+              recursive: true
+            });
+          }
+          this._userIgnored = void 0;
+        });
+        return this;
+      }
+      /**
+       * Close watchers and remove all listeners from watched paths.
+       */
+      close() {
+        if (this._closePromise) {
+          return this._closePromise;
+        }
+        this.closed = true;
+        this.removeAllListeners();
+        const closers = [];
+        this._closers.forEach((closerList) => closerList.forEach((closer) => {
+          const promise = closer();
+          if (promise instanceof Promise)
+            closers.push(promise);
+        }));
+        this._streams.forEach((stream) => stream.destroy());
+        this._userIgnored = void 0;
+        this._readyCount = 0;
+        this._readyEmitted = false;
+        this._watched.forEach((dirent) => dirent.dispose());
+        this._closers.clear();
+        this._watched.clear();
+        this._streams.clear();
+        this._symlinkPaths.clear();
+        this._throttled.clear();
+        this._closePromise = closers.length ? Promise.all(closers).then(() => void 0) : Promise.resolve();
+        return this._closePromise;
+      }
+      /**
+       * Expose list of watched paths
+       * @returns for chaining
+       */
+      getWatched() {
+        const watchList = {};
+        this._watched.forEach((entry, dir) => {
+          const key = this.options.cwd ? sysPath2.relative(this.options.cwd, dir) : dir;
+          const index = key || ONE_DOT;
+          watchList[index] = entry.getChildren().sort();
+        });
+        return watchList;
+      }
+      emitWithAll(event, args) {
+        this.emit(event, ...args);
+        if (event !== EVENTS.ERROR)
+          this.emit(EVENTS.ALL, event, ...args);
+      }
+      // Common helpers
+      // --------------
+      /**
+       * Normalize and emit events.
+       * Calling _emit DOES NOT MEAN emit() would be called!
+       * @param event Type of event
+       * @param path File or directory path
+       * @param stats arguments to be passed with event
+       * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+       */
+      async _emit(event, path, stats) {
+        if (this.closed)
+          return;
+        const opts = this.options;
+        if (isWindows2)
+          path = sysPath2.normalize(path);
+        if (opts.cwd)
+          path = sysPath2.relative(opts.cwd, path);
+        const args = [path];
+        if (stats != null)
+          args.push(stats);
+        const awf = opts.awaitWriteFinish;
+        let pw;
+        if (awf && (pw = this._pendingWrites.get(path))) {
+          pw.lastChange = /* @__PURE__ */ new Date();
+          return this;
+        }
+        if (opts.atomic) {
+          if (event === EVENTS.UNLINK) {
+            this._pendingUnlinks.set(path, [event, ...args]);
+            setTimeout(() => {
+              this._pendingUnlinks.forEach((entry, path2) => {
+                this.emit(...entry);
+                this.emit(EVENTS.ALL, ...entry);
+                this._pendingUnlinks.delete(path2);
+              });
+            }, typeof opts.atomic === "number" ? opts.atomic : 100);
+            return this;
+          }
+          if (event === EVENTS.ADD && this._pendingUnlinks.has(path)) {
+            event = EVENTS.CHANGE;
+            this._pendingUnlinks.delete(path);
+          }
+        }
+        if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
+          const awfEmit = (err, stats2) => {
+            if (err) {
+              event = EVENTS.ERROR;
+              args[0] = err;
+              this.emitWithAll(event, args);
+            } else if (stats2) {
+              if (args.length > 1) {
+                args[1] = stats2;
+              } else {
+                args.push(stats2);
+              }
+              this.emitWithAll(event, args);
+            }
+          };
+          this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
+          return this;
+        }
+        if (event === EVENTS.CHANGE) {
+          const isThrottled = !this._throttle(EVENTS.CHANGE, path, 50);
+          if (isThrottled)
+            return this;
+        }
+        if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
+          const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path) : path;
+          let stats2;
+          try {
+            stats2 = await (0, import_promises3.stat)(fullPath);
+          } catch (err) {
+          }
+          if (!stats2 || this.closed)
+            return;
+          args.push(stats2);
+        }
+        this.emitWithAll(event, args);
+        return this;
+      }
+      /**
+       * Common handler for errors
+       * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+       */
+      _handleError(error) {
+        const code = error && error.code;
+        if (error && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) {
+          this.emit(EVENTS.ERROR, error);
+        }
+        return error || this.closed;
+      }
+      /**
+       * Helper utility for throttling
+       * @param actionType type being throttled
+       * @param path being acted upon
+       * @param timeout duration of time to suppress duplicate actions
+       * @returns tracking object or false if action should be suppressed
+       */
+      _throttle(actionType, path, timeout) {
+        if (!this._throttled.has(actionType)) {
+          this._throttled.set(actionType, /* @__PURE__ */ new Map());
+        }
+        const action = this._throttled.get(actionType);
+        if (!action)
+          throw new Error("invalid throttle");
+        const actionPath = action.get(path);
+        if (actionPath) {
+          actionPath.count++;
+          return false;
+        }
+        let timeoutObject;
+        const clear = () => {
+          const item = action.get(path);
+          const count = item ? item.count : 0;
+          action.delete(path);
+          clearTimeout(timeoutObject);
+          if (item)
+            clearTimeout(item.timeoutObject);
+          return count;
+        };
+        timeoutObject = setTimeout(clear, timeout);
+        const thr = { timeoutObject, clear, count: 0 };
+        action.set(path, thr);
+        return thr;
+      }
+      _incrReadyCount() {
+        return this._readyCount++;
+      }
+      /**
+       * Awaits write operation to finish.
+       * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+       * @param path being acted upon
+       * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+       * @param event
+       * @param awfEmit Callback to be called when ready for event to be emitted.
+       */
+      _awaitWriteFinish(path, threshold, event, awfEmit) {
+        const awf = this.options.awaitWriteFinish;
+        if (typeof awf !== "object")
+          return;
+        const pollInterval = awf.pollInterval;
+        let timeoutHandler;
+        let fullPath = path;
+        if (this.options.cwd && !sysPath2.isAbsolute(path)) {
+          fullPath = sysPath2.join(this.options.cwd, path);
+        }
+        const now = /* @__PURE__ */ new Date();
+        const writes = this._pendingWrites;
+        function awaitWriteFinishFn(prevStat) {
+          (0, import_fs7.stat)(fullPath, (err, curStat) => {
+            if (err || !writes.has(path)) {
+              if (err && err.code !== "ENOENT")
+                awfEmit(err);
+              return;
+            }
+            const now2 = Number(/* @__PURE__ */ new Date());
+            if (prevStat && curStat.size !== prevStat.size) {
+              writes.get(path).lastChange = now2;
+            }
+            const pw = writes.get(path);
+            const df = now2 - pw.lastChange;
+            if (df >= threshold) {
+              writes.delete(path);
+              awfEmit(void 0, curStat);
+            } else {
+              timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
+            }
+          });
+        }
+        if (!writes.has(path)) {
+          writes.set(path, {
+            lastChange: now,
+            cancelWait: () => {
+              writes.delete(path);
+              clearTimeout(timeoutHandler);
+              return event;
+            }
+          });
+          timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
+        }
+      }
+      /**
+       * Determines whether user has asked to ignore this path.
+       */
+      _isIgnored(path, stats) {
+        if (this.options.atomic && DOT_RE.test(path))
+          return true;
+        if (!this._userIgnored) {
+          const { cwd } = this.options;
+          const ign = this.options.ignored;
+          const ignored = (ign || []).map(normalizeIgnored(cwd));
+          const ignoredPaths = [...this._ignoredPaths];
+          const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
+          this._userIgnored = anymatch(list, void 0);
+        }
+        return this._userIgnored(path, stats);
+      }
+      _isntIgnored(path, stat5) {
+        return !this._isIgnored(path, stat5);
+      }
+      /**
+       * Provides a set of common helpers and properties relating to symlink handling.
+       * @param path file or directory pattern being watched
+       */
+      _getWatchHelpers(path) {
+        return new WatchHelper(path, this.options.followSymlinks, this);
+      }
+      // Directory helpers
+      // -----------------
+      /**
+       * Provides directory tracking objects
+       * @param directory path of the directory
+       */
+      _getWatchedDir(directory) {
+        const dir = sysPath2.resolve(directory);
+        if (!this._watched.has(dir))
+          this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+        return this._watched.get(dir);
+      }
+      // File helpers
+      // ------------
+      /**
+       * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
+       */
+      _hasReadPermissions(stats) {
+        if (this.options.ignorePermissionErrors)
+          return true;
+        return Boolean(Number(stats.mode) & 256);
+      }
+      /**
+       * Handles emitting unlink events for
+       * files and directories, and via recursion, for
+       * files and directories within directories that are unlinked
+       * @param directory within which the following item is located
+       * @param item      base path of item/directory
+       */
+      _remove(directory, item, isDirectory) {
+        const path = sysPath2.join(directory, item);
+        const fullPath = sysPath2.resolve(path);
+        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path) || this._watched.has(fullPath);
+        if (!this._throttle("remove", path, 100))
+          return;
+        if (!isDirectory && this._watched.size === 1) {
+          this.add(directory, item, true);
+        }
+        const wp = this._getWatchedDir(path);
+        const nestedDirectoryChildren = wp.getChildren();
+        nestedDirectoryChildren.forEach((nested) => this._remove(path, nested));
+        const parent = this._getWatchedDir(directory);
+        const wasTracked = parent.has(item);
+        parent.remove(item);
+        if (this._symlinkPaths.has(fullPath)) {
+          this._symlinkPaths.delete(fullPath);
+        }
+        let relPath = path;
+        if (this.options.cwd)
+          relPath = sysPath2.relative(this.options.cwd, path);
+        if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+          const event = this._pendingWrites.get(relPath).cancelWait();
+          if (event === EVENTS.ADD)
+            return;
+        }
+        this._watched.delete(path);
+        this._watched.delete(fullPath);
+        const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
+        if (wasTracked && !this._isIgnored(path))
+          this._emit(eventName, path);
+        this._closePath(path);
+      }
+      /**
+       * Closes all watchers for a path
+       */
+      _closePath(path) {
+        this._closeFile(path);
+        const dir = sysPath2.dirname(path);
+        this._getWatchedDir(dir).remove(sysPath2.basename(path));
+      }
+      /**
+       * Closes only file-specific watchers
+       */
+      _closeFile(path) {
+        const closers = this._closers.get(path);
+        if (!closers)
+          return;
+        closers.forEach((closer) => closer());
+        this._closers.delete(path);
+      }
+      _addPathCloser(path, closer) {
+        if (!closer)
+          return;
+        let list = this._closers.get(path);
+        if (!list) {
+          list = [];
+          this._closers.set(path, list);
+        }
+        list.push(closer);
+      }
+      _readdirp(root, opts) {
+        if (this.closed)
+          return;
+        const options = { type: EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
+        let stream = readdirp(root, options);
+        this._streams.add(stream);
+        stream.once(STR_CLOSE, () => {
+          stream = void 0;
+        });
+        stream.once(STR_END, () => {
+          if (stream) {
+            this._streams.delete(stream);
+            stream = void 0;
+          }
+        });
+        return stream;
+      }
+    };
+    esm_default = { watch: watch2, FSWatcher: FSWatcher2 };
+  }
+});
+
+// src/test.ts
+var test_exports = {};
+__export(test_exports, {
+  runJestTests: () => runJestTests,
+  runWatchMode: () => runWatchMode
+});
+function globToRegex2(pattern) {
+  let expanded = pattern;
+  const openBraceIndex = pattern.indexOf("{");
+  if (openBraceIndex !== -1) {
+    const closeBraceIndex = pattern.indexOf("}", openBraceIndex);
+    if (closeBraceIndex !== -1) {
+      const options = pattern.slice(openBraceIndex + 1, closeBraceIndex).split(",");
+      const before = pattern.slice(0, openBraceIndex);
+      const after = pattern.slice(closeBraceIndex + 1);
+      expanded = before + "(" + options.join("|") + ")" + after;
+    }
+  }
+  let regexStr = "^";
+  for (let i = 0; i < expanded.length; i++) {
+    const char = expanded[i];
+    switch (char) {
+      case ".":
+        regexStr += "\\.";
+        break;
+      case "*":
+        regexStr += ".*";
+        break;
+      case "?":
+        regexStr += ".";
+        break;
+      case "+":
+      case "^":
+      case "$":
+      case "|":
+      case "(":
+      case ")":
+      case "[":
+      case "]":
+      case "{":
+      case "}":
+      case "\\":
+        regexStr += "\\" + char;
+        break;
+      default:
+        regexStr += char;
+    }
+  }
+  regexStr += "$";
+  return new RegExp(regexStr);
+}
+function matchesPattern2(relativePath2, pattern) {
+  const openBraceIndex = pattern.indexOf("{");
+  if (openBraceIndex !== -1) {
+    const closeBraceIndex = pattern.indexOf("}", openBraceIndex);
+    if (closeBraceIndex !== -1) {
+      const options = pattern.slice(openBraceIndex + 1, closeBraceIndex).split(",");
+      const before = pattern.slice(0, openBraceIndex);
+      const after = pattern.slice(closeBraceIndex + 1);
+      for (const option of options) {
+        const testPattern2 = before + option + after;
+        if (matchesPattern2(relativePath2, testPattern2)) {
+          return true;
+        }
+      }
+      return false;
+    }
+  }
+  const regex = globToRegex2(pattern);
+  return regex.test(relativePath2);
+}
+function findTestFiles(root, include, exclude) {
+  const files = [];
+  function normalizePathForPattern(path) {
+    return path.replace(/\\/g, "/");
+  }
+  function scanDir(dir) {
+    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()) {
+          const relativePath2 = normalizePathForPattern(relative(root, fullPath));
+          if (exclude.some((pattern) => matchesPattern2(relativePath2, pattern))) {
+            continue;
+          }
+          scanDir(fullPath);
+        } else if (entry.isFile()) {
+          const relativePath2 = normalizePathForPattern(relative(root, fullPath));
+          if (exclude.some((pattern) => matchesPattern2(relativePath2, pattern))) {
+            continue;
+          }
+          for (const pattern of include) {
+            if (matchesPattern2(relativePath2, pattern)) {
+              files.push(fullPath);
+              break;
+            }
+          }
+        }
+      }
+    } catch (error) {
+    }
+  }
+  scanDir(root);
+  return files;
+}
+async function runJestTests(options = {}) {
+  const {
+    include = ["**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"],
+    exclude = ["**/node_modules/**", "**/dist/**", "**/coverage/**", "**/.elit-tests-temp/**"],
+    reporter = "default",
+    timeout = 5e3,
+    bail = false,
+    globals: globals2 = true
+  } = options;
+  const root = process.cwd();
+  const files = options.files || findTestFiles(root, include, exclude);
+  if (files.length === 0) {
+    console.log("\n No test files found\n");
+    return {
+      success: true,
+      passed: 0,
+      failed: 0,
+      total: 0
+    };
+  }
+  if (globals2) {
+    setupGlobals();
+  }
+  let testReporter;
+  switch (reporter) {
+    case "dot":
+      testReporter = new DotReporter();
+      break;
+    case "json":
+      testReporter = new JsonReporter();
+      break;
+    case "verbose":
+      testReporter = new VerboseReporter();
+      break;
+    default:
+      testReporter = new TestReporter({ colors: true });
+  }
+  if ("onRunStart" in testReporter) {
+    testReporter.onRunStart(files);
+  }
+  resetCoveredFiles();
+  const results = await runTests({
+    files,
+    timeout,
+    bail,
+    describePattern: options.describePattern,
+    testPattern: options.testPattern
+  });
+  if ("onTestResult" in testReporter) {
+    for (const result of results.results) {
+      testReporter.onTestResult(result);
+    }
+  }
+  if ("onRunEnd" in testReporter) {
+    testReporter.onRunEnd(results.results);
+  }
+  if (globals2) {
+    clearGlobals();
+  }
+  if (options.coverage?.enabled) {
+    await generateCoverage(options.coverage, results.results);
+  }
+  return {
+    success: results.failed === 0,
+    passed: results.passed,
+    failed: results.failed,
+    total: results.passed + results.failed + results.skipped + results.todo
+  };
+}
+async function generateCoverage(options, testResults2) {
+  const { processCoverage: processCoverage2, generateTextReport: generateTextReport2, generateHtmlReport: generateHtmlReport2, generateCoverageFinalJson: generateCoverageFinalJson2, generateCloverXml: generateCloverXml2 } = await Promise.resolve().then(() => (init_coverage(), coverage_exports));
+  const coveredFilesForCoverage = getCoveredFiles();
+  const coverageMap = await processCoverage2({
+    reportsDirectory: "./coverage",
+    include: options.include || ["**/*.ts", "**/*.js"],
+    exclude: options.exclude || ["**/*.test.ts", "**/*.spec.ts", "**/node_modules/**"],
+    reporter: options.reporter || ["text", "html"],
+    coveredFiles: coveredFilesForCoverage
+  });
+  const reporters = options.reporter || ["text", "html"];
+  if (reporters.includes("text")) {
+    console.log("\n" + generateTextReport2(coverageMap, testResults2));
+  }
+  if (reporters.includes("html")) {
+    generateHtmlReport2(coverageMap, "./coverage");
+    console.log(`
+ Coverage report: coverage/index.html
+`);
+  }
+  if (reporters.includes("coverage-final.json")) {
+    generateCoverageFinalJson2(coverageMap, "./coverage");
+    console.log(`
+ Coverage report: coverage/coverage-final.json
+`);
+  }
+  if (reporters.includes("clover")) {
+    generateCloverXml2(coverageMap, "./coverage");
+    console.log(`
+ Coverage report: coverage/clover.xml
+`);
+  }
+}
+async function runWatchMode(options = {}) {
+  const chokidar = await Promise.resolve().then(() => (init_esm2(), esm_exports));
+  console.log("\n \uFFFD watch mode - files will be re-run on change\n");
+  let isRunning = false;
+  let needsRerun = false;
+  const runTests2 = async () => {
+    if (isRunning) {
+      needsRerun = true;
+      return;
+    }
+    isRunning = true;
+    needsRerun = false;
+    console.clear();
+    await runJestTests(options);
+    isRunning = false;
+    if (needsRerun) {
+      await runTests2();
+    }
+  };
+  await runTests2();
+  const { include, exclude } = options;
+  const watchPatterns = include || ["**/*.test.ts", "**/*.test.js", "**/*.spec.ts", "**/*.spec.js"];
+  const ignoredPatterns = exclude || ["**/node_modules/**", "**/dist/**", "**/coverage/**"];
+  const watcher = chokidar.default.watch(watchPatterns, {
+    ignored: ignoredPatterns,
+    persistent: true
+  });
+  watcher.on("change", async (path) => {
+    console.log(`
+ \u{1F4C4} ${path} changed
+`);
+    await runTests2();
+  });
+  watcher.on("add", async (path) => {
+    console.log(`
+ \u{1F4C4} ${path} added
+`);
+    await runTests2();
+  });
+}
+var init_test = __esm({
+  "src/test.ts"() {
+    "use strict";
+    init_fs();
+    init_path();
+    init_test_runtime();
+    init_test_reporter();
+  }
+});
+
 // package.json
 var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "elit",
-      version: "3.3.2",
+      version: "3.3.4",
       description: "Optimized lightweight library for creating DOM elements with reactive state",
       main: "dist/index.js",
       module: "dist/index.mjs",
@@ -1540,12 +6038,39 @@ var require_package = __commonJS({
           types: "./dist/database.d.ts",
           import: "./dist/database.mjs",
           require: "./dist/database.js"
+        },
+        "./test": {
+          types: "./dist/test.d.ts",
+          import: "./dist/test.mjs",
+          require: "./dist/test.js"
+        },
+        "./test-runtime": {
+          types: "./dist/test-runtime.d.ts",
+          import: "./dist/test-runtime.mjs",
+          require: "./dist/test-runtime.js"
+        },
+        "./test-reporter": {
+          types: "./dist/test-reporter.d.ts",
+          import: "./dist/test-reporter.mjs",
+          require: "./dist/test-reporter.js"
+        },
+        "./test-globals": {
+          types: "./dist/test-globals.d.ts"
+        },
+        "./types": {
+          types: "./dist/types.d.ts",
+          import: "./dist/types.mjs",
+          require: "./dist/types.js"
         }
       },
       scripts: {
-        build: "tsup && tsc --emitDeclarationOnly",
+        build: `rm -rf dist && tsup && node -e "require('fs').copyFileSync('src/test-globals.d.ts', 'dist/test-globals.d.ts')" && tsc --emitDeclarationOnly --outDir dist --declaration --declarationMap`,
         dev: "tsup --watch",
         typecheck: "tsc --noEmit",
+        test: "elit test",
+        "test:run": "elit test --run",
+        "test:coverage": "elit test --coverage",
+        "test:e2e": "elit test --e2e",
         benchmark: "node benchmark/server-benchmark.js",
         "benchmark:router": "node benchmark/router-benchmark.js",
         "docs:dev": "npm run --prefix docs dev",
@@ -1575,7 +6100,9 @@ var require_package = __commonJS({
         "real-time",
         "build",
         "bundler",
-        "esbuild"
+        "esbuild",
+        "testing",
+        "test-utilities"
       ],
       author: "",
       license: "MIT",
@@ -1589,17 +6116,20 @@ var require_package = __commonJS({
       homepage: "https://d-osc.github.io/elit/",
       dependencies: {
         esbuild: "^0.24.2",
-        open: "^11.0.0"
+        open: "^11.0.0",
+        "source-map": "^0.7.6"
       },
       devDependencies: {
         "@types/bun": "^1.3.6",
         "@types/express": "^5.0.6",
         "@types/mime-types": "^2.1.4",
-        "@types/node": "^22.0.0",
+        "@types/node": "^25.0.10",
         "@types/ws": "^8.5.13",
+        copyfiles: "^2.4.1",
         elysia: "^1.4.19",
         express: "^5.2.1",
         terser: "^5.44.1",
+        "ts-node": "^10.9.2",
         tsup: "^8.0.0",
         typescript: "^5.3.0"
       },
@@ -1698,9 +6228,9 @@ async function loadConfigFile(configPath) {
   } else if (ext === "ts") {
     try {
       const { build: build2 } = await import("esbuild");
-      const { join: join2, dirname: dirname2 } = await Promise.resolve().then(() => (init_path(), path_exports));
-      const configDir = dirname2(configPath);
-      const tempFile = join2(configDir, `.elit-config-${Date.now()}.mjs`);
+      const { join: join4, dirname: dirname4 } = await Promise.resolve().then(() => (init_path(), path_exports));
+      const configDir = dirname4(configPath);
+      const tempFile = join4(configDir, `.elit-config-${Date.now()}.mjs`);
       const externalAllPlugin = {
         name: "external-all",
         setup(build3) {
@@ -3171,14 +7701,14 @@ async function generateExternalImportMaps(rootDir, basePath = "") {
     return importMap;
   }
   try {
-    const { readdir: readdir2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-    const packages = await readdir2(nodeModulesPath);
+    const { readdir: readdir4 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
+    const packages = await readdir4(nodeModulesPath);
     for (const pkgEntry of packages) {
       const pkg = typeof pkgEntry === "string" ? pkgEntry : pkgEntry.name;
       if (pkg.startsWith(".")) continue;
       if (pkg.startsWith("@")) {
         try {
-          const scopedPackages = await readdir2(join(nodeModulesPath, pkg));
+          const scopedPackages = await readdir4(join(nodeModulesPath, pkg));
           for (const scopedEntry of scopedPackages) {
             const scopedPkg = typeof scopedEntry === "string" ? scopedEntry : scopedEntry.name;
             const fullPkgName = `${pkg}/${scopedPkg}`;
@@ -3850,9 +8380,9 @@ export default css;
             });
             transpiled = transpiler.transformSync(content.toString());
           } else {
-            const { transformSync } = await import("esbuild");
+            const { transformSync: transformSync2 } = await import("esbuild");
             const loader = ext === ".tsx" ? "tsx" : "ts";
-            const result = transformSync(content.toString(), {
+            const result = transformSync2(content.toString(), {
               loader,
               format: "esm",
               target: "es2020",
@@ -4073,11 +8603,11 @@ ${elitImportMap}` : elitImportMap;
     if (config.open && normalizedClients.length > 0) {
       const firstClient = normalizedClients[0];
       const url = `http://${config.host}:${config.port}${firstClient.basePath}`;
-      const open = async () => {
+      const open2 = async () => {
         const { default: openBrowser } = await import("open");
         await openBrowser(url);
       };
-      open().catch(() => {
+      open2().catch(() => {
       });
     }
   });
@@ -4090,10 +8620,10 @@ ${elitImportMap}` : elitImportMap;
     wss.close();
     wsClients.forEach((client) => client.close());
     wsClients.clear();
-    return new Promise((resolve2) => {
+    return new Promise((resolve4) => {
       server.close(() => {
         if (config.logging) console.log("[Server] Closed");
-        resolve2();
+        resolve4();
       });
     });
   };
@@ -4356,7 +8886,7 @@ function formatBytes(bytes) {
 }
 
 // src/cli.ts
-var COMMANDS = ["dev", "build", "preview", "help", "version"];
+var COMMANDS = ["dev", "build", "preview", "test", "help", "version"];
 function setupShutdownHandlers(closeFunc) {
   const shutdown = async () => {
     console.log("\n[Server] Shutting down...");
@@ -4417,6 +8947,9 @@ async function main() {
     case "preview":
       await runPreview(args.slice(1));
       break;
+    case "test":
+      await runTest(args.slice(1));
+      break;
     case "version":
       printVersion();
       break;
@@ -4452,6 +8985,7 @@ async function runBuild(args) {
       ensureEnv(options, env);
       validateEntry(options.entry);
       await executeBuild(options);
+      process.exit(0);
     } else {
       console.log(`Building ${builds.length} ${builds.length === 1 ? "entry" : "entries"}...
 `);
@@ -4472,12 +9006,15 @@ async function runBuild(args) {
       }
       console.log(`
 \u2713 All ${builds.length} builds completed successfully`);
+      process.exit(0);
     }
   } else {
     const options = cliOptions;
     ensureEnv(options, env);
     validateEntry(options.entry);
     await executeBuild(options);
+    console.log("\n\u2713 Build completed successfully");
+    process.exit(0);
   }
 }
 async function runPreview(args) {
@@ -4535,6 +9072,102 @@ async function runPreview(args) {
   const devServer = createDevServer(options);
   setupShutdownHandlers(() => devServer.close());
 }
+async function runTest(args) {
+  const cliOptions = parseTestArgs(args);
+  const config = await loadConfig();
+  let options = config?.test ? { ...config.test, ...cliOptions } : cliOptions;
+  const { runJestTests: runJestTests2, runWatchMode: runWatchMode2 } = await Promise.resolve().then(() => (init_test(), test_exports));
+  const isWatch = options.watch;
+  if (isWatch) {
+    await runWatchMode2({
+      files: options.files,
+      include: options.include,
+      exclude: options.exclude,
+      reporter: options.reporter,
+      timeout: options.timeout,
+      bail: options.bail,
+      coverage: options.coverage,
+      describePattern: options.describe,
+      testPattern: options.testName
+    });
+  } else {
+    await runJestTests2({
+      files: options.files,
+      include: options.include,
+      exclude: options.exclude,
+      reporter: options.reporter,
+      timeout: options.timeout,
+      bail: options.bail,
+      coverage: options.coverage,
+      describePattern: options.describe,
+      testPattern: options.testName
+    });
+    process.exit(0);
+  }
+}
+function parseTestArgs(args) {
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--run":
+      case "-r":
+        options.run = true;
+        break;
+      case "--watch":
+      case "-w":
+        options.watch = true;
+        break;
+      case "--coverage":
+      case "-c":
+        options.coverage = {
+          enabled: true,
+          provider: "v8",
+          reporter: ["text", "html"]
+        };
+        break;
+      case "--coverage-reporter":
+      case "-cr":
+        const reporterValue = args[++i];
+        if (reporterValue) {
+          const reporters = reporterValue.split(",").map((r) => r.trim());
+          if (!options.coverage) {
+            options.coverage = {
+              enabled: true,
+              provider: "v8",
+              reporter: reporters
+            };
+          } else {
+            options.coverage.enabled = true;
+            options.coverage.reporter = reporters;
+          }
+        }
+        break;
+      case "--file":
+      case "-f":
+        const filesValue = args[++i];
+        if (filesValue) {
+          options.files = filesValue.split(",").map((f) => f.trim());
+        }
+        break;
+      case "--describe":
+      case "-d":
+        const describeValue = args[++i];
+        if (describeValue) {
+          options.describe = describeValue;
+        }
+        break;
+      case "--it":
+      case "-t":
+        const testValue = args[++i];
+        if (testValue) {
+          options.testName = testValue;
+        }
+        break;
+    }
+  }
+  return options;
+}
 function parseDevArgs(args) {
   const options = {};
   const handlers = {
@@ -4665,6 +9298,7 @@ Commands:
   dev       Start development server
   build     Build for production
   preview   Preview production build
+  test      Run tests
   version   Show version number
   help      Show this help message
 
@@ -4702,6 +9336,24 @@ Note: Preview mode has full feature parity with dev mode:
       - Proxy forwarding and Web Workers
       - HTTPS support, custom middleware, and SSR
 
+Test Options:
+  -r, --run               Run all tests once (default, same as no flags)
+  -w, --watch             Run in watch mode
+  -f, --file <files>      Run specific files (comma-separated), e.g.: --file ./test1.test.ts,./test2.spec.ts
+  -d, --describe <name>   Run only tests matching describe name, e.g.: --describe "Footer Component"
+  -t, --it <name>         Run only tests matching test name, e.g.: --it "should create"
+  -c, --coverage          Generate coverage report
+  -cr, --coverage-reporter <reporters>  Coverage reporter formats (comma-separated): text, html, lcov, json, coverage-final.json, clover
+
+Note: Test command behaviors:
+      - elit test                     Run all tests once (default)
+      - elit test --run               Run all tests once (same as default)
+      - elit test -f ./test.ts        Run specific file(s) once
+      - elit test -d "Footer"         Run only tests in describe blocks matching "Footer"
+      - elit test -t "should create"  Run only tests matching "should create"
+      - elit test --watch             Run in watch mode
+      - elit test --coverage          Run with coverage report
+
 Config File:
   Create elit.config.ts, elit.config.js, or elit.config.json in project root
 
@@ -4963,3 +9615,8 @@ main().catch((error) => {
   console.error("Fatal error:", error);
   process.exit(1);
 });
+/*! Bundled license information:
+
+chokidar/esm/index.js:
+  (*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) *)
+*/